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