ui/native_theme/native_theme_base.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/native_theme/native_theme_base.h"
   6
   7 #include <limits>
   8
   9 #include "base/command_line.h"
  10 #include "base/logging.h"
  11 #include "base/memory/scoped_ptr.h"
  12 #include "grit/ui_resources.h"
  13 #include "third_party/skia/include/effects/SkGradientShader.h"
  14 #include "ui/base/layout.h"
  15 #include "ui/base/resource/resource_bundle.h"
  16 #include "ui/base/ui_base_switches.h"
  17 #include "ui/gfx/canvas.h"
  18 #include "ui/gfx/color_utils.h"
  19 #include "ui/gfx/image/image_skia.h"
  20 #include "ui/gfx/rect.h"
  21 #include "ui/gfx/size.h"
  22 #include "ui/gfx/skia_util.h"
  23 #include "ui/native_theme/common_theme.h"
  24
  25 namespace {
  26
  27 // These are the default dimensions of radio buttons and checkboxes.
  28 const int kCheckboxAndRadioWidth = 13;
  29 const int kCheckboxAndRadioHeight = 13;
  30
  31 // These sizes match the sizes in Chromium Win.
  32 const int kSliderThumbWidth = 11;
  33 const int kSliderThumbHeight = 21;
  34
  35 const SkColor kSliderTrackBackgroundColor =
  36     SkColorSetRGB(0xe3, 0xdd, 0xd8);
  37 const SkColor kSliderThumbLightGrey = SkColorSetRGB(0xf4, 0xf2, 0xef);
  38 const SkColor kSliderThumbDarkGrey = SkColorSetRGB(0xea, 0xe5, 0xe0);
  39 const SkColor kSliderThumbBorderDarkGrey =
  40     SkColorSetRGB(0x9d, 0x96, 0x8e);
  41
  42 const SkColor kTextBorderColor = SkColorSetRGB(0xa9, 0xa9, 0xa9);
  43
  44 const SkColor kMenuPopupBackgroundColor = SkColorSetRGB(210, 225, 246);
  45
  46 const unsigned int kDefaultScrollbarWidth = 15;
  47 const unsigned int kDefaultScrollbarButtonLength = 14;
  48
  49 const SkColor kCheckboxTinyColor = SK_ColorGRAY;
  50 const SkColor kCheckboxShadowColor = SkColorSetARGB(0x15, 0, 0, 0);
  51 const SkColor kCheckboxShadowHoveredColor = SkColorSetARGB(0x1F, 0, 0, 0);
  52 const SkColor kCheckboxShadowDisabledColor = SkColorSetARGB(0, 0, 0, 0);
  53 const SkColor kCheckboxGradientColors[] = {
  54     SkColorSetRGB(0xed, 0xed, 0xed),
  55     SkColorSetRGB(0xde, 0xde, 0xde) };
  56 const SkColor kCheckboxGradientPressedColors[] = {
  57     SkColorSetRGB(0xe7, 0xe7, 0xe7),
  58     SkColorSetRGB(0xd7, 0xd7, 0xd7) };
  59 const SkColor kCheckboxGradientHoveredColors[] = {
  60     SkColorSetRGB(0xf0, 0xf0, 0xf0),
  61     SkColorSetRGB(0xe0, 0xe0, 0xe0) };
  62 const SkColor kCheckboxGradientDisabledColors[] = {
  63     SkColorSetARGB(0x80, 0xed, 0xed, 0xed),
  64     SkColorSetARGB(0x80, 0xde, 0xde, 0xde) };
  65 const SkColor kCheckboxBorderColor = SkColorSetARGB(0x40, 0, 0, 0);
  66 const SkColor kCheckboxBorderHoveredColor = SkColorSetARGB(0x4D, 0, 0, 0);
  67 const SkColor kCheckboxBorderDisabledColor = SkColorSetARGB(0x20, 0, 0, 0);
  68 const SkColor kCheckboxStrokeColor = SkColorSetARGB(0xB3, 0, 0, 0);
  69 const SkColor kCheckboxStrokeDisabledColor = SkColorSetARGB(0x59, 0, 0, 0);
  70 const SkColor kRadioDotColor = SkColorSetRGB(0x66, 0x66, 0x66);
  71 const SkColor kRadioDotDisabledColor = SkColorSetARGB(0x80, 0x66, 0x66, 0x66);
  72
  73 // Get lightness adjusted color.
  74 SkColor BrightenColor(const color_utils::HSL& hsl, SkAlpha alpha,
  75     double lightness_amount) {
  76   color_utils::HSL adjusted = hsl;
  77   adjusted.l += lightness_amount;
  78   if (adjusted.l > 1.0)
  79     adjusted.l = 1.0;
  80   if (adjusted.l < 0.0)
  81     adjusted.l = 0.0;
  82
  83   return color_utils::HSLToSkColor(adjusted, alpha);
  84 }
  85
  86 }  // namespace
  87
  88 namespace ui {
  89
  90 gfx::Size NativeThemeBase::GetPartSize(Part part,
  91                                        State state,
  92                                        const ExtraParams& extra) const {
  93   gfx::Size size = CommonThemeGetPartSize(part, state, extra);
  94   if (!size.IsEmpty())
  95     return size;
  96
  97   switch (part) {
  98     // Please keep these in the order of NativeTheme::Part.
  99     case kCheckbox:
 100       return gfx::Size(kCheckboxAndRadioWidth, kCheckboxAndRadioHeight);
 101     case kInnerSpinButton:
 102       return gfx::Size(scrollbar_width_, 0);
 103     case kMenuList:
 104       return gfx::Size();  // No default size.
 105     case kMenuCheck:
 106     case kMenuCheckBackground:
 107     case kMenuPopupArrow:
 108       NOTIMPLEMENTED();
 109       break;
 110     case kMenuPopupBackground:
 111       return gfx::Size();  // No default size.
 112     case kMenuPopupGutter:
 113     case kMenuPopupSeparator:
 114       NOTIMPLEMENTED();
 115       break;
 116     case kMenuItemBackground:
 117     case kProgressBar:
 118     case kPushButton:
 119       return gfx::Size();  // No default size.
 120     case kRadio:
 121       return gfx::Size(kCheckboxAndRadioWidth, kCheckboxAndRadioHeight);
 122     case kScrollbarDownArrow:
 123     case kScrollbarUpArrow:
 124       return gfx::Size(scrollbar_width_, scrollbar_button_length_);
 125     case kScrollbarLeftArrow:
 126     case kScrollbarRightArrow:
 127       return gfx::Size(scrollbar_button_length_, scrollbar_width_);
 128     case kScrollbarHorizontalThumb:
 129       // This matches Firefox on Linux.
 130       return gfx::Size(2 * scrollbar_width_, scrollbar_width_);
 131     case kScrollbarVerticalThumb:
 132       // This matches Firefox on Linux.
 133       return gfx::Size(scrollbar_width_, 2 * scrollbar_width_);
 134     case kScrollbarHorizontalTrack:
 135       return gfx::Size(0, scrollbar_width_);
 136     case kScrollbarVerticalTrack:
 137       return gfx::Size(scrollbar_width_, 0);
 138     case kScrollbarHorizontalGripper:
 139     case kScrollbarVerticalGripper:
 140       NOTIMPLEMENTED();
 141       break;
 142     case kSliderTrack:
 143       return gfx::Size();  // No default size.
 144     case kSliderThumb:
 145       // These sizes match the sizes in Chromium Win.
 146       return gfx::Size(kSliderThumbWidth, kSliderThumbHeight);
 147     case kTabPanelBackground:
 148       NOTIMPLEMENTED();
 149       break;
 150     case kTextField:
 151       return gfx::Size();  // No default size.
 152     case kTrackbarThumb:
 153     case kTrackbarTrack:
 154     case kWindowResizeGripper:
 155       NOTIMPLEMENTED();
 156       break;
 157     default:
 158       NOTREACHED() << "Unknown theme part: " << part;
 159       break;
 160   }
 161   return gfx::Size();
 162 }
 163
 164 void NativeThemeBase::PaintStateTransition(SkCanvas* canvas,
 165                                            Part part,
 166                                            State startState,
 167                                            State endState,
 168                                            double progress,
 169                                            const gfx::Rect& rect) const {
 170   if (rect.IsEmpty())
 171     return;
 172
 173   // Currently state transition is animation only working for overlay scrollbars
 174   // on Aura platforms.
 175   switch (part) {
 176     case kScrollbarHorizontalThumb:
 177     case kScrollbarVerticalThumb:
 178       PaintScrollbarThumbStateTransition(
 179           canvas, startState, endState, progress, rect);
 180       break;
 181     default:
 182       NOTREACHED() << "Does not support state transition for this part:"
 183                    << part;
 184       break;
 185   }
 186   return;
 187 }
 188
 189 void NativeThemeBase::Paint(SkCanvas* canvas,
 190                             Part part,
 191                             State state,
 192                             const gfx::Rect& rect,
 193                             const ExtraParams& extra) const {
 194   if (rect.IsEmpty())
 195     return;
 196
 197   switch (part) {
 198     // Please keep these in the order of NativeTheme::Part.
 199     case kComboboxArrow:
 200       CommonThemePaintComboboxArrow(canvas, rect);
 201       break;
 202     case kCheckbox:
 203       PaintCheckbox(canvas, state, rect, extra.button);
 204       break;
 205     case kInnerSpinButton:
 206       PaintInnerSpinButton(canvas, state, rect, extra.inner_spin);
 207       break;
 208     case kMenuList:
 209       PaintMenuList(canvas, state, rect, extra.menu_list);
 210       break;
 211     case kMenuCheck:
 212     case kMenuCheckBackground:
 213     case kMenuPopupArrow:
 214       NOTIMPLEMENTED();
 215       break;
 216     case kMenuPopupBackground:
 217       PaintMenuPopupBackground(canvas, rect.size(), extra.menu_background);
 218       break;
 219     case kMenuPopupGutter:
 220     case kMenuPopupSeparator:
 221       NOTIMPLEMENTED();
 222       break;
 223     case kMenuItemBackground:
 224       PaintMenuItemBackground(canvas, state, rect, extra.menu_list);
 225       break;
 226     case kProgressBar:
 227       PaintProgressBar(canvas, state, rect, extra.progress_bar);
 228       break;
 229     case kPushButton:
 230       PaintButton(canvas, state, rect, extra.button);
 231       break;
 232     case kRadio:
 233       PaintRadio(canvas, state, rect, extra.button);
 234       break;
 235     case kScrollbarDownArrow:
 236     case kScrollbarUpArrow:
 237     case kScrollbarLeftArrow:
 238     case kScrollbarRightArrow:
 239       PaintArrowButton(canvas, rect, part, state);
 240       break;
 241     case kScrollbarHorizontalThumb:
 242     case kScrollbarVerticalThumb:
 243       PaintScrollbarThumb(canvas, part, state, rect);
 244       break;
 245     case kScrollbarHorizontalTrack:
 246     case kScrollbarVerticalTrack:
 247       PaintScrollbarTrack(canvas, part, state, extra.scrollbar_track, rect);
 248       break;
 249     case kScrollbarHorizontalGripper:
 250     case kScrollbarVerticalGripper:
 251       // Invoked by views scrollbar code, don't care about for non-win
 252       // implementations, so no NOTIMPLEMENTED.
 253       break;
 254     case kScrollbarCorner:
 255       PaintScrollbarCorner(canvas, state, rect);
 256       break;
 257     case kSliderTrack:
 258       PaintSliderTrack(canvas, state, rect, extra.slider);
 259       break;
 260     case kSliderThumb:
 261       PaintSliderThumb(canvas, state, rect, extra.slider);
 262       break;
 263     case kTabPanelBackground:
 264       NOTIMPLEMENTED();
 265       break;
 266     case kTextField:
 267       PaintTextField(canvas, state, rect, extra.text_field);
 268       break;
 269     case kTrackbarThumb:
 270     case kTrackbarTrack:
 271     case kWindowResizeGripper:
 272       NOTIMPLEMENTED();
 273       break;
 274     default:
 275       NOTREACHED() << "Unknown theme part: " << part;
 276       break;
 277   }
 278 }
 279
 280 NativeThemeBase::NativeThemeBase()
 281     : scrollbar_width_(kDefaultScrollbarWidth),
 282       scrollbar_button_length_(kDefaultScrollbarButtonLength) {
 283 }
 284
 285 NativeThemeBase::~NativeThemeBase() {
 286 }
 287
 288 void NativeThemeBase::PaintArrowButton(
 289     SkCanvas* canvas,
 290     const gfx::Rect& rect, Part direction, State state) const {
 291   SkPaint paint;
 292
 293   // Calculate button color.
 294   SkScalar trackHSV[3];
 295   SkColorToHSV(track_color_, trackHSV);
 296   SkColor buttonColor = SaturateAndBrighten(trackHSV, 0, 0.2f);
 297   SkColor backgroundColor = buttonColor;
 298   if (state == kPressed) {
 299     SkScalar buttonHSV[3];
 300     SkColorToHSV(buttonColor, buttonHSV);
 301     buttonColor = SaturateAndBrighten(buttonHSV, 0, -0.1f);
 302   } else if (state == kHovered) {
 303     SkScalar buttonHSV[3];
 304     SkColorToHSV(buttonColor, buttonHSV);
 305     buttonColor = SaturateAndBrighten(buttonHSV, 0, 0.05f);
 306   }
 307
 308   SkIRect skrect;
 309   skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), rect.y()
 310       + rect.height());
 311   // Paint the background (the area visible behind the rounded corners).
 312   paint.setColor(backgroundColor);
 313   canvas->drawIRect(skrect, paint);
 314
 315   // Paint the button's outline and fill the middle
 316   SkPath outline;
 317   switch (direction) {
 318     case kScrollbarUpArrow:
 319       outline.moveTo(rect.x() + 0.5, rect.y() + rect.height() + 0.5);
 320       outline.rLineTo(0, -(rect.height() - 2));
 321       outline.rLineTo(2, -2);
 322       outline.rLineTo(rect.width() - 5, 0);
 323       outline.rLineTo(2, 2);
 324       outline.rLineTo(0, rect.height() - 2);
 325       break;
 326     case kScrollbarDownArrow:
 327       outline.moveTo(rect.x() + 0.5, rect.y() - 0.5);
 328       outline.rLineTo(0, rect.height() - 2);
 329       outline.rLineTo(2, 2);
 330       outline.rLineTo(rect.width() - 5, 0);
 331       outline.rLineTo(2, -2);
 332       outline.rLineTo(0, -(rect.height() - 2));
 333       break;
 334     case kScrollbarRightArrow:
 335       outline.moveTo(rect.x() - 0.5, rect.y() + 0.5);
 336       outline.rLineTo(rect.width() - 2, 0);
 337       outline.rLineTo(2, 2);
 338       outline.rLineTo(0, rect.height() - 5);
 339       outline.rLineTo(-2, 2);
 340       outline.rLineTo(-(rect.width() - 2), 0);
 341       break;
 342     case kScrollbarLeftArrow:
 343       outline.moveTo(rect.x() + rect.width() + 0.5, rect.y() + 0.5);
 344       outline.rLineTo(-(rect.width() - 2), 0);
 345       outline.rLineTo(-2, 2);
 346       outline.rLineTo(0, rect.height() - 5);
 347       outline.rLineTo(2, 2);
 348       outline.rLineTo(rect.width() - 2, 0);
 349       break;
 350     default:
 351       break;
 352   }
 353   outline.close();
 354
 355   paint.setStyle(SkPaint::kFill_Style);
 356   paint.setColor(buttonColor);
 357   canvas->drawPath(outline, paint);
 358
 359   paint.setAntiAlias(true);
 360   paint.setStyle(SkPaint::kStroke_Style);
 361   SkScalar thumbHSV[3];
 362   SkColorToHSV(thumb_inactive_color_, thumbHSV);
 363   paint.setColor(OutlineColor(trackHSV, thumbHSV));
 364   canvas->drawPath(outline, paint);
 365
 366   PaintArrow(canvas, rect, direction, GetArrowColor(state));
 367 }
 368
 369 void NativeThemeBase::PaintArrow(SkCanvas* gc,
 370                                  const gfx::Rect& rect,
 371                                  Part direction,
 372                                  SkColor color) const {
 373   int width_middle, length_middle;
 374   if (direction == kScrollbarUpArrow || direction == kScrollbarDownArrow) {
 375     width_middle = rect.width() / 2 + 1;
 376     length_middle = rect.height() / 2 + 1;
 377   } else {
 378     length_middle = rect.width() / 2 + 1;
 379     width_middle = rect.height() / 2 + 1;
 380   }
 381
 382   SkPaint paint;
 383   paint.setColor(color);
 384   paint.setAntiAlias(false);
 385   paint.setStyle(SkPaint::kFill_Style);
 386
 387   SkPath path;
 388   // The constants in this block of code are hand-tailored to produce good
 389   // looking arrows without anti-aliasing.
 390   switch (direction) {
 391     case kScrollbarUpArrow:
 392       path.moveTo(rect.x() + width_middle - 4, rect.y() + length_middle + 2);
 393       path.rLineTo(7, 0);
 394       path.rLineTo(-4, -4);
 395       break;
 396     case kScrollbarDownArrow:
 397       path.moveTo(rect.x() + width_middle - 4, rect.y() + length_middle - 3);
 398       path.rLineTo(7, 0);
 399       path.rLineTo(-4, 4);
 400       break;
 401     case kScrollbarRightArrow:
 402       path.moveTo(rect.x() + length_middle - 3, rect.y() + width_middle - 4);
 403       path.rLineTo(0, 7);
 404       path.rLineTo(4, -4);
 405       break;
 406     case kScrollbarLeftArrow:
 407       path.moveTo(rect.x() + length_middle + 1, rect.y() + width_middle - 5);
 408       path.rLineTo(0, 9);
 409       path.rLineTo(-4, -4);
 410       break;
 411     default:
 412       break;
 413   }
 414   path.close();
 415
 416   gc->drawPath(path, paint);
 417 }
 418
 419 void NativeThemeBase::PaintScrollbarTrack(SkCanvas* canvas,
 420     Part part,
 421     State state,
 422     const ScrollbarTrackExtraParams& extra_params,
 423     const gfx::Rect& rect) const {
 424   SkPaint paint;
 425   SkIRect skrect;
 426
 427   skrect.set(rect.x(), rect.y(), rect.right(), rect.bottom());
 428   SkScalar track_hsv[3];
 429   SkColorToHSV(track_color_, track_hsv);
 430   paint.setColor(SaturateAndBrighten(track_hsv, 0, 0));
 431   canvas->drawIRect(skrect, paint);
 432
 433   SkScalar thumb_hsv[3];
 434   SkColorToHSV(thumb_inactive_color_, thumb_hsv);
 435
 436   paint.setColor(OutlineColor(track_hsv, thumb_hsv));
 437   DrawBox(canvas, rect, paint);
 438 }
 439
 440 void NativeThemeBase::PaintScrollbarThumb(SkCanvas* canvas,
 441                                            Part part,
 442                                            State state,
 443                                            const gfx::Rect& rect) const {
 444   const bool hovered = state == kHovered;
 445   const int midx = rect.x() + rect.width() / 2;
 446   const int midy = rect.y() + rect.height() / 2;
 447   const bool vertical = part == kScrollbarVerticalThumb;
 448
 449   SkScalar thumb[3];
 450   SkColorToHSV(hovered ? thumb_active_color_ : thumb_inactive_color_, thumb);
 451
 452   SkPaint paint;
 453   paint.setColor(SaturateAndBrighten(thumb, 0, 0.02f));
 454
 455   SkIRect skrect;
 456   if (vertical)
 457     skrect.set(rect.x(), rect.y(), midx + 1, rect.y() + rect.height());
 458   else
 459     skrect.set(rect.x(), rect.y(), rect.x() + rect.width(), midy + 1);
 460
 461   canvas->drawIRect(skrect, paint);
 462
 463   paint.setColor(SaturateAndBrighten(thumb, 0, -0.02f));
 464
 465   if (vertical) {
 466     skrect.set(
 467         midx + 1, rect.y(), rect.x() + rect.width(), rect.y() + rect.height());
 468   } else {
 469     skrect.set(
 470         rect.x(), midy + 1, rect.x() + rect.width(), rect.y() + rect.height());
 471   }
 472
 473   canvas->drawIRect(skrect, paint);
 474
 475   SkScalar track[3];
 476   SkColorToHSV(track_color_, track);
 477   paint.setColor(OutlineColor(track, thumb));
 478   DrawBox(canvas, rect, paint);
 479
 480   if (rect.height() > 10 && rect.width() > 10) {
 481     const int grippy_half_width = 2;
 482     const int inter_grippy_offset = 3;
 483     if (vertical) {
 484       DrawHorizLine(canvas,
 485                     midx - grippy_half_width,
 486                     midx + grippy_half_width,
 487                     midy - inter_grippy_offset,
 488                     paint);
 489       DrawHorizLine(canvas,
 490                     midx - grippy_half_width,
 491                     midx + grippy_half_width,
 492                     midy,
 493                     paint);
 494       DrawHorizLine(canvas,
 495                     midx - grippy_half_width,
 496                     midx + grippy_half_width,
 497                     midy + inter_grippy_offset,
 498                     paint);
 499     } else {
 500       DrawVertLine(canvas,
 501                    midx - inter_grippy_offset,
 502                    midy - grippy_half_width,
 503                    midy + grippy_half_width,
 504                    paint);
 505       DrawVertLine(canvas,
 506                    midx,
 507                    midy - grippy_half_width,
 508                    midy + grippy_half_width,
 509                    paint);
 510       DrawVertLine(canvas,
 511                    midx + inter_grippy_offset,
 512                    midy - grippy_half_width,
 513                    midy + grippy_half_width,
 514                    paint);
 515     }
 516   }
 517 }
 518
 519 void NativeThemeBase::PaintScrollbarCorner(SkCanvas* canvas,
 520                                            State state,
 521                                            const gfx::Rect& rect) const {
 522   SkPaint paint;
 523   paint.setColor(SK_ColorWHITE);
 524   paint.setStyle(SkPaint::kFill_Style);
 525   paint.setXfermodeMode(SkXfermode::kSrc_Mode);
 526   canvas->drawIRect(RectToSkIRect(rect), paint);
 527 }
 528
 529 void NativeThemeBase::PaintCheckbox(SkCanvas* canvas,
 530                                     State state,
 531                                     const gfx::Rect& rect,
 532                                     const ButtonExtraParams& button) const {
 533   SkRect skrect = PaintCheckboxRadioCommon(canvas, state, rect,
 534                                            SkIntToScalar(2));
 535   if (!skrect.isEmpty()) {
 536     // Draw the checkmark / dash.
 537     SkPaint paint;
 538     paint.setAntiAlias(true);
 539     paint.setStyle(SkPaint::kStroke_Style);
 540     if (state == kDisabled)
 541       paint.setColor(kCheckboxStrokeDisabledColor);
 542     else
 543       paint.setColor(kCheckboxStrokeColor);
 544     if (button.indeterminate) {
 545       SkPath dash;
 546       dash.moveTo(skrect.x() + skrect.width() * 0.16,
 547                   (skrect.y() + skrect.bottom()) / 2);
 548       dash.rLineTo(skrect.width() * 0.68, 0);
 549       paint.setStrokeWidth(SkFloatToScalar(skrect.height() * 0.2));
 550       canvas->drawPath(dash, paint);
 551     } else if (button.checked) {
 552       SkPath check;
 553       check.moveTo(skrect.x() + skrect.width() * 0.2,
 554                    skrect.y() + skrect.height() * 0.5);
 555       check.rLineTo(skrect.width() * 0.2, skrect.height() * 0.2);
 556       paint.setStrokeWidth(SkFloatToScalar(skrect.height() * 0.23));
 557       check.lineTo(skrect.right() - skrect.width() * 0.2,
 558                    skrect.y() + skrect.height() * 0.2);
 559       canvas->drawPath(check, paint);
 560     }
 561   }
 562 }
 563
 564 // Draws the common elements of checkboxes and radio buttons.
 565 // Returns the rectangle within which any additional decorations should be
 566 // drawn, or empty if none.
 567 SkRect NativeThemeBase::PaintCheckboxRadioCommon(
 568     SkCanvas* canvas,
 569     State state,
 570     const gfx::Rect& rect,
 571     const SkScalar borderRadius) const {
 572
 573   SkRect skrect = gfx::RectToSkRect(rect);
 574
 575   // Use the largest square that fits inside the provided rectangle.
 576   // No other browser seems to support non-square widget, so accidentally
 577   // having non-square sizes is common (eg. amazon and webkit dev tools).
 578   if (skrect.width() != skrect.height()) {
 579     SkScalar size = SkMinScalar(skrect.width(), skrect.height());
 580     skrect.inset((skrect.width() - size) / 2, (skrect.height() - size) / 2);
 581   }
 582
 583   // If the rectangle is too small then paint only a rectangle.  We don't want
 584   // to have to worry about '- 1' and '+ 1' calculations below having overflow
 585   // or underflow.
 586   if (skrect.width() <= 2) {
 587     SkPaint paint;
 588     paint.setColor(kCheckboxTinyColor);
 589     paint.setStyle(SkPaint::kFill_Style);
 590     canvas->drawRect(skrect, paint);
 591     // Too small to draw anything more.
 592     return SkRect::MakeEmpty();
 593   }
 594
 595   // Make room for the drop shadow.
 596   skrect.iset(skrect.x(), skrect.y(), skrect.right() - 1, skrect.bottom() - 1);
 597
 598   // Draw the drop shadow below the widget.
 599   if (state != kPressed) {
 600     SkPaint paint;
 601     paint.setAntiAlias(true);
 602     SkRect shadowRect = skrect;
 603     shadowRect.offset(0, 1);
 604     if (state == kDisabled)
 605      paint.setColor(kCheckboxShadowDisabledColor);
 606     else if (state == kHovered)
 607       paint.setColor(kCheckboxShadowHoveredColor);
 608     else
 609       paint.setColor(kCheckboxShadowColor);
 610     paint.setStyle(SkPaint::kFill_Style);
 611     canvas->drawRoundRect(shadowRect, borderRadius, borderRadius, paint);
 612   }
 613
 614   // Draw the gradient-filled rectangle
 615   SkPoint gradient_bounds[3];
 616   gradient_bounds[0].set(skrect.x(), skrect.y());
 617   gradient_bounds[1].set(skrect.x(), skrect.y() + skrect.height() * 0.38);
 618   gradient_bounds[2].set(skrect.x(), skrect.bottom());
 619   const SkColor* startEndColors;
 620   if (state == kPressed)
 621     startEndColors = kCheckboxGradientPressedColors;
 622   else if (state == kHovered)
 623     startEndColors = kCheckboxGradientHoveredColors;
 624   else if (state == kDisabled)
 625     startEndColors = kCheckboxGradientDisabledColors;
 626   else /* kNormal */
 627     startEndColors = kCheckboxGradientColors;
 628   SkColor colors[3] = {startEndColors[0], startEndColors[0], startEndColors[1]};
 629   skia::RefPtr<SkShader> shader = skia::AdoptRef(
 630       SkGradientShader::CreateLinear(
 631           gradient_bounds, colors, NULL, 3, SkShader::kClamp_TileMode));
 632   SkPaint paint;
 633   paint.setAntiAlias(true);
 634   paint.setShader(shader.get());
 635   paint.setStyle(SkPaint::kFill_Style);
 636   canvas->drawRoundRect(skrect, borderRadius, borderRadius, paint);
 637   paint.setShader(NULL);
 638
 639   // Draw the border.
 640   if (state == kHovered)
 641     paint.setColor(kCheckboxBorderHoveredColor);
 642   else if (state == kDisabled)
 643     paint.setColor(kCheckboxBorderDisabledColor);
 644   else
 645     paint.setColor(kCheckboxBorderColor);
 646   paint.setStyle(SkPaint::kStroke_Style);
 647   paint.setStrokeWidth(SkIntToScalar(1));
 648   skrect.inset(SkFloatToScalar(.5f), SkFloatToScalar(.5f));
 649   canvas->drawRoundRect(skrect, borderRadius, borderRadius, paint);
 650
 651   // Return the rectangle excluding the drop shadow for drawing any additional
 652   // decorations.
 653   return skrect;
 654 }
 655
 656 void NativeThemeBase::PaintRadio(SkCanvas* canvas,
 657                                   State state,
 658                                   const gfx::Rect& rect,
 659                                   const ButtonExtraParams& button) const {
 660
 661   // Most of a radio button is the same as a checkbox, except the the rounded
 662   // square is a circle (i.e. border radius >= 100%).
 663   const SkScalar radius = SkFloatToScalar(
 664       static_cast<float>(std::max(rect.width(), rect.height())) / 2);
 665   SkRect skrect = PaintCheckboxRadioCommon(canvas, state, rect, radius);
 666   if (!skrect.isEmpty() && button.checked) {
 667     // Draw the dot.
 668     SkPaint paint;
 669     paint.setAntiAlias(true);
 670     paint.setStyle(SkPaint::kFill_Style);
 671     if (state == kDisabled)
 672       paint.setColor(kRadioDotDisabledColor);
 673     else
 674       paint.setColor(kRadioDotColor);
 675     skrect.inset(skrect.width() * 0.25, skrect.height() * 0.25);
 676     // Use drawRoundedRect instead of drawOval to be completely consistent
 677     // with the border in PaintCheckboxRadioNewCommon.
 678     canvas->drawRoundRect(skrect, radius, radius, paint);
 679   }
 680 }
 681
 682 void NativeThemeBase::PaintButton(SkCanvas* canvas,
 683                                   State state,
 684                                   const gfx::Rect& rect,
 685                                   const ButtonExtraParams& button) const {
 686   SkPaint paint;
 687   const int kRight = rect.right();
 688   const int kBottom = rect.bottom();
 689   SkRect skrect = SkRect::MakeLTRB(rect.x(), rect.y(), kRight, kBottom);
 690   SkColor base_color = button.background_color;
 691
 692   color_utils::HSL base_hsl;
 693   color_utils::SkColorToHSL(base_color, &base_hsl);
 694
 695   // Our standard gradient is from 0xdd to 0xf8. This is the amount of
 696   // increased luminance between those values.
 697   SkColor light_color(BrightenColor(base_hsl, SkColorGetA(base_color), 0.105));
 698
 699   // If the button is too small, fallback to drawing a single, solid color
 700   if (rect.width() < 5 || rect.height() < 5) {
 701     paint.setColor(base_color);
 702     canvas->drawRect(skrect, paint);
 703     return;
 704   }
 705
 706   paint.setColor(SK_ColorBLACK);
 707   const int kLightEnd = state == kPressed ? 1 : 0;
 708   const int kDarkEnd = !kLightEnd;
 709   SkPoint gradient_bounds[2];
 710   gradient_bounds[kLightEnd].iset(rect.x(), rect.y());
 711   gradient_bounds[kDarkEnd].iset(rect.x(), kBottom - 1);
 712   SkColor colors[2];
 713   colors[0] = light_color;
 714   colors[1] = base_color;
 715
 716   skia::RefPtr<SkShader> shader = skia::AdoptRef(
 717       SkGradientShader::CreateLinear(
 718           gradient_bounds, colors, NULL, 2, SkShader::kClamp_TileMode));
 719   paint.setStyle(SkPaint::kFill_Style);
 720   paint.setAntiAlias(true);
 721   paint.setShader(shader.get());
 722
 723   canvas->drawRoundRect(skrect, SkIntToScalar(1), SkIntToScalar(1), paint);
 724   paint.setShader(NULL);
 725
 726   if (button.has_border) {
 727     int border_alpha = state == kHovered ? 0x80 : 0x55;
 728     if (button.is_focused) {
 729       border_alpha = 0xff;
 730       paint.setColor(GetSystemColor(kColorId_FocusedBorderColor));
 731     }
 732     paint.setStyle(SkPaint::kStroke_Style);
 733     paint.setStrokeWidth(SkIntToScalar(1));
 734     paint.setAlpha(border_alpha);
 735     skrect.inset(SkFloatToScalar(.5f), SkFloatToScalar(.5f));
 736     canvas->drawRoundRect(skrect, SkIntToScalar(1), SkIntToScalar(1), paint);
 737   }
 738 }
 739
 740 void NativeThemeBase::PaintTextField(SkCanvas* canvas,
 741                                      State state,
 742                                      const gfx::Rect& rect,
 743                                      const TextFieldExtraParams& text) const {
 744   SkRect bounds;
 745   bounds.set(rect.x(), rect.y(), rect.right() - 1, rect.bottom() - 1);
 746
 747   SkPaint fill_paint;
 748   fill_paint.setStyle(SkPaint::kFill_Style);
 749   fill_paint.setColor(text.background_color);
 750   canvas->drawRect(bounds, fill_paint);
 751
 752   // Text INPUT, listbox SELECT, and TEXTAREA have consistent borders.
 753   // border: 1px solid #a9a9a9
 754   SkPaint stroke_paint;
 755   stroke_paint.setStyle(SkPaint::kStroke_Style);
 756   stroke_paint.setColor(kTextBorderColor);
 757   canvas->drawRect(bounds, stroke_paint);
 758 }
 759
 760 void NativeThemeBase::PaintMenuList(
 761     SkCanvas* canvas,
 762     State state,
 763     const gfx::Rect& rect,
 764     const MenuListExtraParams& menu_list) const {
 765   // If a border radius is specified, we let the WebCore paint the background
 766   // and the border of the control.
 767   if (!menu_list.has_border_radius) {
 768     ButtonExtraParams button = { 0 };
 769     button.background_color = menu_list.background_color;
 770     button.has_border = menu_list.has_border;
 771     PaintButton(canvas, state, rect, button);
 772   }
 773
 774   SkPaint paint;
 775   paint.setColor(SK_ColorBLACK);
 776   paint.setAntiAlias(true);
 777   paint.setStyle(SkPaint::kFill_Style);
 778
 779   SkPath path;
 780   path.moveTo(menu_list.arrow_x, menu_list.arrow_y - 3);
 781   path.rLineTo(6, 0);
 782   path.rLineTo(-3, 6);
 783   path.close();
 784   canvas->drawPath(path, paint);
 785 }
 786
 787 void NativeThemeBase::PaintMenuPopupBackground(
 788     SkCanvas* canvas,
 789     const gfx::Size& size,
 790     const MenuBackgroundExtraParams& menu_background) const {
 791   canvas->drawColor(kMenuPopupBackgroundColor, SkXfermode::kSrc_Mode);
 792 }
 793
 794 void NativeThemeBase::PaintMenuItemBackground(
 795     SkCanvas* canvas,
 796     State state,
 797     const gfx::Rect& rect,
 798     const MenuListExtraParams& menu_list) const {
 799   // By default don't draw anything over the normal background.
 800 }
 801
 802 void NativeThemeBase::PaintSliderTrack(SkCanvas* canvas,
 803                                        State state,
 804                                        const gfx::Rect& rect,
 805                                        const SliderExtraParams& slider) const {
 806   const int kMidX = rect.x() + rect.width() / 2;
 807   const int kMidY = rect.y() + rect.height() / 2;
 808
 809   SkPaint paint;
 810   paint.setColor(kSliderTrackBackgroundColor);
 811
 812   SkRect skrect;
 813   if (slider.vertical) {
 814     skrect.set(std::max(rect.x(), kMidX - 2),
 815                rect.y(),
 816                std::min(rect.right(), kMidX + 2),
 817                rect.bottom());
 818   } else {
 819     skrect.set(rect.x(),
 820                std::max(rect.y(), kMidY - 2),
 821                rect.right(),
 822                std::min(rect.bottom(), kMidY + 2));
 823   }
 824   canvas->drawRect(skrect, paint);
 825 }
 826
 827 void NativeThemeBase::PaintSliderThumb(SkCanvas* canvas,
 828                                        State state,
 829                                        const gfx::Rect& rect,
 830                                        const SliderExtraParams& slider) const {
 831   const bool hovered = (state == kHovered) || slider.in_drag;
 832   const int kMidX = rect.x() + rect.width() / 2;
 833   const int kMidY = rect.y() + rect.height() / 2;
 834
 835   SkPaint paint;
 836   paint.setColor(hovered ? SK_ColorWHITE : kSliderThumbLightGrey);
 837
 838   SkIRect skrect;
 839   if (slider.vertical)
 840     skrect.set(rect.x(), rect.y(), kMidX + 1, rect.bottom());
 841   else
 842     skrect.set(rect.x(), rect.y(), rect.right(), kMidY + 1);
 843
 844   canvas->drawIRect(skrect, paint);
 845
 846   paint.setColor(hovered ? kSliderThumbLightGrey : kSliderThumbDarkGrey);
 847
 848   if (slider.vertical)
 849     skrect.set(kMidX + 1, rect.y(), rect.right(), rect.bottom());
 850   else
 851     skrect.set(rect.x(), kMidY + 1, rect.right(), rect.bottom());
 852
 853   canvas->drawIRect(skrect, paint);
 854
 855   paint.setColor(kSliderThumbBorderDarkGrey);
 856   DrawBox(canvas, rect, paint);
 857
 858   if (rect.height() > 10 && rect.width() > 10) {
 859     DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY, paint);
 860     DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY - 3, paint);
 861     DrawHorizLine(canvas, kMidX - 2, kMidX + 2, kMidY + 3, paint);
 862   }
 863 }
 864
 865 void NativeThemeBase::PaintInnerSpinButton(SkCanvas* canvas,
 866     State state,
 867     const gfx::Rect& rect,
 868     const InnerSpinButtonExtraParams& spin_button) const {
 869   if (spin_button.read_only)
 870     state = kDisabled;
 871
 872   State north_state = state;
 873   State south_state = state;
 874   if (spin_button.spin_up)
 875     south_state = south_state != kDisabled ? kNormal : kDisabled;
 876   else
 877     north_state = north_state != kDisabled ? kNormal : kDisabled;
 878
 879   gfx::Rect half = rect;
 880   half.set_height(rect.height() / 2);
 881   PaintArrowButton(canvas, half, kScrollbarUpArrow, north_state);
 882
 883   half.set_y(rect.y() + rect.height() / 2);
 884   PaintArrowButton(canvas, half, kScrollbarDownArrow, south_state);
 885 }
 886
 887 void NativeThemeBase::PaintProgressBar(SkCanvas* canvas,
 888     State state,
 889     const gfx::Rect& rect,
 890     const ProgressBarExtraParams& progress_bar) const {
 891   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 892   gfx::ImageSkia* bar_image = rb.GetImageSkiaNamed(IDR_PROGRESS_BAR);
 893   gfx::ImageSkia* left_border_image = rb.GetImageSkiaNamed(
 894       IDR_PROGRESS_BORDER_LEFT);
 895   gfx::ImageSkia* right_border_image = rb.GetImageSkiaNamed(
 896       IDR_PROGRESS_BORDER_RIGHT);
 897
 898   DCHECK(bar_image->width() > 0);
 899   DCHECK(rect.width() > 0);
 900
 901   float tile_scale_y = static_cast<float>(rect.height()) / bar_image->height();
 902
 903   int dest_left_border_width = left_border_image->width();
 904   int dest_right_border_width = right_border_image->width();
 905
 906   // Since an implicit float -> int conversion will truncate, we want to make
 907   // sure that if a border is desired, it gets at least one pixel.
 908   if (dest_left_border_width > 0) {
 909     dest_left_border_width = dest_left_border_width * tile_scale_y;
 910     dest_left_border_width = std::max(dest_left_border_width, 1);
 911   }
 912   if (dest_right_border_width > 0) {
 913     dest_right_border_width = dest_right_border_width * tile_scale_y;
 914     dest_right_border_width = std::max(dest_right_border_width, 1);
 915   }
 916
 917   // Since the width of the progress bar may not be evenly divisible by the
 918   // tile size, in order to make it look right we may need to draw some of the
 919   // with a width of 1 pixel smaller than the rest of the tiles.
 920   int new_tile_width = static_cast<int>(bar_image->width() * tile_scale_y);
 921   new_tile_width = std::max(new_tile_width, 1);
 922
 923   float tile_scale_x = static_cast<float>(new_tile_width) / bar_image->width();
 924   if (rect.width() % new_tile_width == 0) {
 925     DrawTiledImage(canvas, *bar_image, 0, 0, tile_scale_x, tile_scale_y,
 926         rect.x(), rect.y(),
 927         rect.width(), rect.height());
 928   } else {
 929     int num_tiles = 1 + rect.width() / new_tile_width;
 930     int overshoot = num_tiles * new_tile_width - rect.width();
 931     // Since |overshoot| represents the number of tiles that were too big, draw
 932     // |overshoot| tiles with their width reduced by 1.
 933     int num_big_tiles = num_tiles - overshoot;
 934     int num_small_tiles = overshoot;
 935     int small_width = new_tile_width - 1;
 936     float small_scale_x = static_cast<float>(small_width) / bar_image->width();
 937     float big_scale_x = tile_scale_x;
 938
 939     gfx::Rect big_rect = rect;
 940     gfx::Rect small_rect = rect;
 941     big_rect.Inset(0, 0, num_small_tiles*small_width, 0);
 942     small_rect.Inset(num_big_tiles*new_tile_width, 0, 0, 0);
 943
 944     DrawTiledImage(canvas, *bar_image, 0, 0, big_scale_x, tile_scale_y,
 945       big_rect.x(), big_rect.y(), big_rect.width(), big_rect.height());
 946     DrawTiledImage(canvas, *bar_image, 0, 0, small_scale_x, tile_scale_y,
 947       small_rect.x(), small_rect.y(), small_rect.width(), small_rect.height());
 948   }
 949   if (progress_bar.value_rect_width) {
 950     gfx::ImageSkia* value_image = rb.GetImageSkiaNamed(IDR_PROGRESS_VALUE);
 951
 952     new_tile_width = static_cast<int>(value_image->width() * tile_scale_y);
 953     tile_scale_x = static_cast<float>(new_tile_width) /
 954         value_image->width();
 955
 956     DrawTiledImage(canvas, *value_image, 0, 0, tile_scale_x, tile_scale_y,
 957         progress_bar.value_rect_x,
 958         progress_bar.value_rect_y,
 959         progress_bar.value_rect_width,
 960         progress_bar.value_rect_height);
 961   }
 962
 963   DrawImageInt(canvas, *left_border_image, 0, 0, left_border_image->width(),
 964       left_border_image->height(), rect.x(), rect.y(), dest_left_border_width,
 965       rect.height());
 966
 967   int dest_x = rect.right() - dest_right_border_width;
 968   DrawImageInt(canvas, *right_border_image, 0, 0, right_border_image->width(),
 969                right_border_image->height(), dest_x, rect.y(),
 970                dest_right_border_width, rect.height());
 971 }
 972
 973 bool NativeThemeBase::IntersectsClipRectInt(SkCanvas* canvas,
 974                                             int x, int y, int w, int h) const {
 975   SkRect clip;
 976   return canvas->getClipBounds(&clip) &&
 977       clip.intersect(SkIntToScalar(x), SkIntToScalar(y), SkIntToScalar(x + w),
 978                      SkIntToScalar(y + h));
 979 }
 980
 981 void NativeThemeBase::DrawImageInt(
 982     SkCanvas* sk_canvas, const gfx::ImageSkia& image,
 983     int src_x, int src_y, int src_w, int src_h,
 984     int dest_x, int dest_y, int dest_w, int dest_h) const {
 985   scoped_ptr<gfx::Canvas> canvas(CommonThemeCreateCanvas(sk_canvas));
 986   canvas->DrawImageInt(image, src_x, src_y, src_w, src_h,
 987       dest_x, dest_y, dest_w, dest_h, true);
 988 }
 989
 990 void NativeThemeBase::DrawTiledImage(SkCanvas* sk_canvas,
 991     const gfx::ImageSkia& image,
 992     int src_x, int src_y, float tile_scale_x, float tile_scale_y,
 993     int dest_x, int dest_y, int w, int h) const {
 994   scoped_ptr<gfx::Canvas> canvas(CommonThemeCreateCanvas(sk_canvas));
 995   canvas->TileImageInt(image, src_x, src_y, tile_scale_x,
 996       tile_scale_y, dest_x, dest_y, w, h);
 997 }
 998
 999 SkColor NativeThemeBase::SaturateAndBrighten(SkScalar* hsv,
1000                                              SkScalar saturate_amount,
1001                                              SkScalar brighten_amount) const {
1002   SkScalar color[3];
1003   color[0] = hsv[0];
1004   color[1] = Clamp(hsv[1] + saturate_amount, 0.0, 1.0);
1005   color[2] = Clamp(hsv[2] + brighten_amount, 0.0, 1.0);
1006   return SkHSVToColor(color);
1007 }
1008
1009 SkColor NativeThemeBase::GetArrowColor(State state) const {
1010   if (state != kDisabled)
1011     return SK_ColorBLACK;
1012
1013   SkScalar track_hsv[3];
1014   SkColorToHSV(track_color_, track_hsv);
1015   SkScalar thumb_hsv[3];
1016   SkColorToHSV(thumb_inactive_color_, thumb_hsv);
1017   return OutlineColor(track_hsv, thumb_hsv);
1018 }
1019
1020 void NativeThemeBase::DrawVertLine(SkCanvas* canvas,
1021                                    int x,
1022                                    int y1,
1023                                    int y2,
1024                                    const SkPaint& paint) const {
1025   SkIRect skrect;
1026   skrect.set(x, y1, x + 1, y2 + 1);
1027   canvas->drawIRect(skrect, paint);
1028 }
1029
1030 void NativeThemeBase::DrawHorizLine(SkCanvas* canvas,
1031                                     int x1,
1032                                     int x2,
1033                                     int y,
1034                                     const SkPaint& paint) const {
1035   SkIRect skrect;
1036   skrect.set(x1, y, x2 + 1, y + 1);
1037   canvas->drawIRect(skrect, paint);
1038 }
1039
1040 void NativeThemeBase::DrawBox(SkCanvas* canvas,
1041                               const gfx::Rect& rect,
1042                               const SkPaint& paint) const {
1043   const int right = rect.x() + rect.width() - 1;
1044   const int bottom = rect.y() + rect.height() - 1;
1045   DrawHorizLine(canvas, rect.x(), right, rect.y(), paint);
1046   DrawVertLine(canvas, right, rect.y(), bottom, paint);
1047   DrawHorizLine(canvas, rect.x(), right, bottom, paint);
1048   DrawVertLine(canvas, rect.x(), rect.y(), bottom, paint);
1049 }
1050
1051 SkScalar NativeThemeBase::Clamp(SkScalar value,
1052                                 SkScalar min,
1053                                 SkScalar max) const {
1054   return std::min(std::max(value, min), max);
1055 }
1056
1057 SkColor NativeThemeBase::OutlineColor(SkScalar* hsv1, SkScalar* hsv2) const {
1058   // GTK Theme engines have way too much control over the layout of
1059   // the scrollbar. We might be able to more closely approximate its
1060   // look-and-feel, if we sent whole images instead of just colors
1061   // from the browser to the renderer. But even then, some themes
1062   // would just break.
1063   //
1064   // So, instead, we don't even try to 100% replicate the look of
1065   // the native scrollbar. We render our own version, but we make
1066   // sure to pick colors that blend in nicely with the system GTK
1067   // theme. In most cases, we can just sample a couple of pixels
1068   // from the system scrollbar and use those colors to draw our
1069   // scrollbar.
1070   //
1071   // This works fine for the track color and the overall thumb
1072   // color. But it fails spectacularly for the outline color used
1073   // around the thumb piece.  Not all themes have a clearly defined
1074   // outline. For some of them it is partially transparent, and for
1075   // others the thickness is very unpredictable.
1076   //
1077   // So, instead of trying to approximate the system theme, we
1078   // instead try to compute a reasonable looking choice based on the
1079   // known color of the track and the thumb piece. This is difficult
1080   // when trying to deal both with high- and low-contrast themes,
1081   // and both with positive and inverted themes.
1082   //
1083   // The following code has been tested to look OK with all of the
1084   // default GTK themes.
1085   SkScalar min_diff = Clamp((hsv1[1] + hsv2[1]) * 1.2f, 0.28f, 0.5f);
1086   SkScalar diff = Clamp(fabs(hsv1[2] - hsv2[2]) / 2, min_diff, 0.5f);
1087
1088   if (hsv1[2] + hsv2[2] > 1.0)
1089     diff = -diff;
1090
1091   return SaturateAndBrighten(hsv2, -0.2f, diff);
1092 }
1093
1094 }  // namespace ui