src/chrome/browser/ui/libgtk2ui/native_theme_gtk2.cc

   1 // Copyright (c) 2013 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 "chrome/browser/ui/libgtk2ui/native_theme_gtk2.h"
   6
   7 #include <gtk/gtk.h>
   8
   9 #include "chrome/browser/ui/libgtk2ui/chrome_gtk_menu_subclasses.h"
  10 #include "chrome/browser/ui/libgtk2ui/gtk2_ui.h"
  11 #include "chrome/browser/ui/libgtk2ui/gtk2_util.h"
  12 #include "chrome/browser/ui/libgtk2ui/skia_utils_gtk2.h"
  13 #include "ui/gfx/color_utils.h"
  14 #include "ui/gfx/path.h"
  15 #include "ui/gfx/rect.h"
  16 #include "ui/gfx/size.h"
  17 #include "ui/gfx/skia_util.h"
  18 #include "ui/native_theme/common_theme.h"
  19
  20 namespace {
  21
  22 // Theme colors returned by GetSystemColor().
  23 const SkColor kInvalidColorIdColor = SkColorSetRGB(255, 0, 128);
  24
  25 const GdkColor kURLTextColor = GDK_COLOR_RGB(0x00, 0x88, 0x00);
  26
  27 GdkColor GdkAlphaBlend(GdkColor foreground,
  28                        GdkColor background,
  29                        SkAlpha alpha) {
  30   return libgtk2ui::SkColorToGdkColor(
  31       color_utils::AlphaBlend(libgtk2ui::GdkColorToSkColor(foreground),
  32                               libgtk2ui::GdkColorToSkColor(background), alpha));
  33 }
  34
  35 // Generates the normal URL color, a green color used in unhighlighted URL
  36 // text. It is a mix of |kURLTextColor| and the current text color.  Unlike the
  37 // selected text color, it is more important to match the qualities of the
  38 // foreground typeface color instead of taking the background into account.
  39 GdkColor NormalURLColor(GdkColor foreground) {
  40   color_utils::HSL fg_hsl;
  41   color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(foreground), &fg_hsl);
  42
  43   color_utils::HSL hue_hsl;
  44   color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(kURLTextColor),
  45                             &hue_hsl);
  46
  47   // Only allow colors that have a fair amount of saturation in them (color vs
  48   // white). This means that our output color will always be fairly green.
  49   double s = std::max(0.5, fg_hsl.s);
  50
  51   // Make sure the luminance is at least as bright as the |kURLTextColor| green
  52   // would be if we were to use that.
  53   double l;
  54   if (fg_hsl.l < hue_hsl.l)
  55     l = hue_hsl.l;
  56   else
  57     l = (fg_hsl.l + hue_hsl.l) / 2;
  58
  59   color_utils::HSL output = { hue_hsl.h, s, l };
  60   return libgtk2ui::SkColorToGdkColor(color_utils::HSLToSkColor(output, 255));
  61 }
  62
  63 // Generates the selected URL color, a green color used on URL text in the
  64 // currently highlighted entry in the autocomplete popup. It's a mix of
  65 // |kURLTextColor|, the current text color, and the background color (the
  66 // select highlight). It is more important to contrast with the background
  67 // saturation than to look exactly like the foreground color.
  68 GdkColor SelectedURLColor(GdkColor foreground, GdkColor background) {
  69   color_utils::HSL fg_hsl;
  70   color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(foreground),
  71                             &fg_hsl);
  72
  73   color_utils::HSL bg_hsl;
  74   color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(background),
  75                             &bg_hsl);
  76
  77   color_utils::HSL hue_hsl;
  78   color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(kURLTextColor),
  79                             &hue_hsl);
  80
  81   // The saturation of the text should be opposite of the background, clamped
  82   // to 0.2-0.8. We make sure it's greater than 0.2 so there's some color, but
  83   // less than 0.8 so it's not the oversaturated neon-color.
  84   double opposite_s = 1 - bg_hsl.s;
  85   double s = std::max(0.2, std::min(0.8, opposite_s));
  86
  87   // The luminance should match the luminance of the foreground text.  Again,
  88   // we clamp so as to have at some amount of color (green) in the text.
  89   double opposite_l = fg_hsl.l;
  90   double l = std::max(0.1, std::min(0.9, opposite_l));
  91
  92   color_utils::HSL output = { hue_hsl.h, s, l };
  93   return libgtk2ui::SkColorToGdkColor(color_utils::HSLToSkColor(output, 255));
  94 }
  95
  96 }  // namespace
  97
  98
  99 namespace libgtk2ui {
 100
 101 // static
 102 NativeThemeGtk2* NativeThemeGtk2::instance() {
 103   CR_DEFINE_STATIC_LOCAL(NativeThemeGtk2, s_native_theme, ());
 104   return &s_native_theme;
 105 }
 106
 107 NativeThemeGtk2::NativeThemeGtk2()
 108     : fake_window_(NULL),
 109       fake_tooltip_(NULL),
 110       fake_menu_item_(NULL) {
 111 }
 112
 113 NativeThemeGtk2::~NativeThemeGtk2() {
 114   if (fake_window_)
 115     gtk_widget_destroy(fake_window_);
 116   if (fake_tooltip_)
 117     gtk_widget_destroy(fake_tooltip_);
 118
 119   fake_entry_.Destroy();
 120   fake_label_.Destroy();
 121   fake_button_.Destroy();
 122   fake_tree_.Destroy();
 123   fake_menu_.Destroy();
 124 }
 125
 126 gfx::Size NativeThemeGtk2::GetPartSize(Part part,
 127                                        State state,
 128                                        const ExtraParams& extra) const {
 129   if (part == kComboboxArrow)
 130     return gfx::Size(12, 12);
 131
 132   return ui::NativeThemeBase::GetPartSize(part, state, extra);
 133 }
 134
 135 void NativeThemeGtk2::Paint(SkCanvas* canvas,
 136                             Part part,
 137                             State state,
 138                             const gfx::Rect& rect,
 139                             const ExtraParams& extra) const {
 140   if (rect.IsEmpty())
 141     return;
 142
 143   switch (part) {
 144     case kComboboxArrow:
 145       PaintComboboxArrow(canvas, GetGtkState(state), rect);
 146       return;
 147
 148     default:
 149       NativeThemeBase::Paint(canvas, part, state, rect, extra);
 150   }
 151 }
 152
 153 SkColor NativeThemeGtk2::GetSystemColor(ColorId color_id) const {
 154   if (color_id == kColorId_BlueButtonShadowColor)
 155     return SK_ColorTRANSPARENT;
 156
 157   return GdkColorToSkColor(GetSystemGdkColor(color_id));
 158 }
 159
 160 void NativeThemeGtk2::PaintMenuPopupBackground(
 161     SkCanvas* canvas,
 162     const gfx::Size& size,
 163     const MenuBackgroundExtraParams& menu_background) const {
 164   if (menu_background.corner_radius > 0) {
 165     SkPaint paint;
 166     paint.setStyle(SkPaint::kFill_Style);
 167     paint.setFlags(SkPaint::kAntiAlias_Flag);
 168     paint.setColor(GetSystemColor(kColorId_MenuBackgroundColor));
 169
 170     gfx::Path path;
 171     SkRect rect = SkRect::MakeWH(SkIntToScalar(size.width()),
 172                                  SkIntToScalar(size.height()));
 173     SkScalar radius = SkIntToScalar(menu_background.corner_radius);
 174     SkScalar radii[8] = {radius, radius, radius, radius,
 175                          radius, radius, radius, radius};
 176     path.addRoundRect(rect, radii);
 177
 178     canvas->drawPath(path, paint);
 179   } else {
 180     canvas->drawColor(GetSystemColor(kColorId_MenuBackgroundColor),
 181                       SkXfermode::kSrc_Mode);
 182   }
 183 }
 184
 185 void NativeThemeGtk2::PaintMenuItemBackground(
 186     SkCanvas* canvas,
 187     State state,
 188     const gfx::Rect& rect,
 189     const MenuListExtraParams& menu_list) const {
 190   SkColor color;
 191   SkPaint paint;
 192   switch (state) {
 193     case NativeTheme::kNormal:
 194     case NativeTheme::kDisabled:
 195       color = GetSystemColor(NativeTheme::kColorId_MenuBackgroundColor);
 196       paint.setColor(color);
 197       break;
 198     case NativeTheme::kHovered:
 199       color = GetSystemColor(
 200           NativeTheme::kColorId_FocusedMenuItemBackgroundColor);
 201       paint.setColor(color);
 202       break;
 203     default:
 204       NOTREACHED() << "Invalid state " << state;
 205       break;
 206   }
 207   canvas->drawRect(gfx::RectToSkRect(rect), paint);
 208 }
 209
 210 GdkColor NativeThemeGtk2::GetSystemGdkColor(ColorId color_id) const {
 211   switch (color_id) {
 212     // Windows
 213     case kColorId_WindowBackground:
 214       return GetWindowStyle()->bg[GTK_STATE_NORMAL];
 215
 216     // Dialogs
 217     case kColorId_DialogBackground:
 218       return GetWindowStyle()->bg[GTK_STATE_NORMAL];
 219
 220     // FocusableBorder
 221     case kColorId_FocusedBorderColor:
 222       return GetEntryStyle()->bg[GTK_STATE_SELECTED];
 223     case kColorId_UnfocusedBorderColor:
 224       return GetEntryStyle()->text_aa[GTK_STATE_NORMAL];
 225
 226     // MenuItem
 227     case kColorId_EnabledMenuItemForegroundColor:
 228     case kColorId_DisabledEmphasizedMenuItemForegroundColor:
 229       return GetMenuItemStyle()->text[GTK_STATE_NORMAL];
 230     case kColorId_DisabledMenuItemForegroundColor:
 231       return GetMenuItemStyle()->text[GTK_STATE_INSENSITIVE];
 232     case kColorId_SelectedMenuItemForegroundColor:
 233       return GetMenuItemStyle()->text[GTK_STATE_SELECTED];
 234     case kColorId_FocusedMenuItemBackgroundColor:
 235       return GetMenuItemStyle()->bg[GTK_STATE_SELECTED];
 236     case kColorId_HoverMenuItemBackgroundColor:
 237       return GetMenuItemStyle()->bg[GTK_STATE_PRELIGHT];
 238     case kColorId_FocusedMenuButtonBorderColor:
 239       return GetEntryStyle()->bg[GTK_STATE_NORMAL];
 240     case kColorId_HoverMenuButtonBorderColor:
 241       return GetEntryStyle()->text_aa[GTK_STATE_PRELIGHT];
 242     case kColorId_MenuBorderColor:
 243     case kColorId_EnabledMenuButtonBorderColor:
 244     case kColorId_MenuSeparatorColor: {
 245       return GetMenuItemStyle()->text[GTK_STATE_INSENSITIVE];
 246     }
 247     case kColorId_MenuBackgroundColor:
 248       return GetMenuStyle()->bg[GTK_STATE_NORMAL];
 249
 250     // Label
 251     case kColorId_LabelEnabledColor:
 252       return GetLabelStyle()->text[GTK_STATE_NORMAL];
 253     case kColorId_LabelDisabledColor:
 254       return GetLabelStyle()->text[GTK_STATE_INSENSITIVE];
 255     case kColorId_LabelBackgroundColor:
 256       return GetWindowStyle()->bg[GTK_STATE_NORMAL];
 257
 258     // Button
 259     case kColorId_ButtonBackgroundColor:
 260       return GetButtonStyle()->bg[GTK_STATE_NORMAL];
 261     case kColorId_ButtonEnabledColor:
 262     case kColorId_BlueButtonEnabledColor:
 263       return GetButtonStyle()->text[GTK_STATE_NORMAL];
 264     case kColorId_ButtonDisabledColor:
 265     case kColorId_BlueButtonDisabledColor:
 266       return GetButtonStyle()->text[GTK_STATE_INSENSITIVE];
 267     case kColorId_ButtonHighlightColor:
 268       return GetButtonStyle()->base[GTK_STATE_SELECTED];
 269     case kColorId_ButtonHoverColor:
 270     case kColorId_BlueButtonHoverColor:
 271       return GetButtonStyle()->text[GTK_STATE_PRELIGHT];
 272     case kColorId_ButtonHoverBackgroundColor:
 273       return GetButtonStyle()->bg[GTK_STATE_PRELIGHT];
 274     case kColorId_BlueButtonPressedColor:
 275       return GetButtonStyle()->text[GTK_STATE_ACTIVE];
 276     case kColorId_BlueButtonShadowColor:
 277       // Should be handled in GetSystemColor().
 278       NOTREACHED();
 279       return GetButtonStyle()->text[GTK_STATE_NORMAL];
 280
 281     // Textfield
 282     case kColorId_TextfieldDefaultColor:
 283       return GetEntryStyle()->text[GTK_STATE_NORMAL];
 284     case kColorId_TextfieldDefaultBackground:
 285       return GetEntryStyle()->base[GTK_STATE_NORMAL];
 286     case kColorId_TextfieldReadOnlyColor:
 287       return GetEntryStyle()->text[GTK_STATE_INSENSITIVE];
 288     case kColorId_TextfieldReadOnlyBackground:
 289       return GetEntryStyle()->base[GTK_STATE_INSENSITIVE];
 290     case kColorId_TextfieldSelectionColor:
 291       return GetEntryStyle()->text[GTK_STATE_SELECTED];
 292     case kColorId_TextfieldSelectionBackgroundFocused:
 293       return GetEntryStyle()->base[GTK_STATE_SELECTED];
 294
 295     // Tooltips
 296     case kColorId_TooltipBackground:
 297       return GetTooltipStyle()->bg[GTK_STATE_NORMAL];
 298     case kColorId_TooltipText:
 299       return GetTooltipStyle()->fg[GTK_STATE_NORMAL];
 300
 301     // Trees and Tables (implemented on GTK using the same class)
 302     case kColorId_TableBackground:
 303     case kColorId_TreeBackground:
 304       return GetTreeStyle()->bg[GTK_STATE_NORMAL];
 305     case kColorId_TableText:
 306     case kColorId_TreeText:
 307       return GetTreeStyle()->text[GTK_STATE_NORMAL];
 308     case kColorId_TableSelectedText:
 309     case kColorId_TableSelectedTextUnfocused:
 310     case kColorId_TreeSelectedText:
 311     case kColorId_TreeSelectedTextUnfocused:
 312       return GetTreeStyle()->text[GTK_STATE_SELECTED];
 313     case kColorId_TableSelectionBackgroundFocused:
 314     case kColorId_TableSelectionBackgroundUnfocused:
 315     case kColorId_TreeSelectionBackgroundFocused:
 316     case kColorId_TreeSelectionBackgroundUnfocused:
 317       return GetTreeStyle()->bg[GTK_STATE_SELECTED];
 318     case kColorId_TreeArrow:
 319       return GetTreeStyle()->fg[GTK_STATE_NORMAL];
 320     case kColorId_TableGroupingIndicatorColor:
 321       return GetTreeStyle()->text_aa[GTK_STATE_NORMAL];
 322
 323       // Results Table
 324     case kColorId_ResultsTableNormalBackground:
 325       return GetEntryStyle()->base[GTK_STATE_NORMAL];
 326     case kColorId_ResultsTableHoveredBackground: {
 327       GtkStyle* entry_style = GetEntryStyle();
 328       return GdkAlphaBlend(
 329           entry_style->base[GTK_STATE_NORMAL],
 330           entry_style->base[GTK_STATE_SELECTED], 0x80);
 331     }
 332     case kColorId_ResultsTableSelectedBackground:
 333       return GetEntryStyle()->base[GTK_STATE_SELECTED];
 334     case kColorId_ResultsTableNormalText:
 335     case kColorId_ResultsTableHoveredText:
 336       return GetEntryStyle()->text[GTK_STATE_NORMAL];
 337     case kColorId_ResultsTableSelectedText:
 338       return GetEntryStyle()->text[GTK_STATE_SELECTED];
 339     case kColorId_ResultsTableNormalDimmedText:
 340     case kColorId_ResultsTableHoveredDimmedText: {
 341       GtkStyle* entry_style = GetEntryStyle();
 342       return GdkAlphaBlend(
 343           entry_style->text[GTK_STATE_NORMAL],
 344           entry_style->base[GTK_STATE_NORMAL], 0x80);
 345     }
 346     case kColorId_ResultsTableSelectedDimmedText: {
 347       GtkStyle* entry_style = GetEntryStyle();
 348       return GdkAlphaBlend(
 349           entry_style->text[GTK_STATE_SELECTED],
 350           entry_style->base[GTK_STATE_NORMAL], 0x80);
 351     }
 352     case kColorId_ResultsTableNormalUrl:
 353     case kColorId_ResultsTableHoveredUrl: {
 354       return NormalURLColor(GetEntryStyle()->text[GTK_STATE_NORMAL]);
 355     }
 356     case kColorId_ResultsTableSelectedUrl: {
 357       GtkStyle* entry_style = GetEntryStyle();
 358       return SelectedURLColor(entry_style->text[GTK_STATE_SELECTED],
 359                               entry_style->base[GTK_STATE_SELECTED]);
 360     }
 361     case kColorId_ResultsTableNormalDivider: {
 362       GtkStyle* win_style = GetWindowStyle();
 363       return GdkAlphaBlend(win_style->text[GTK_STATE_NORMAL],
 364                            win_style->bg[GTK_STATE_NORMAL], 0x34);
 365     }
 366     case kColorId_ResultsTableHoveredDivider: {
 367       GtkStyle* win_style = GetWindowStyle();
 368       return GdkAlphaBlend(win_style->text[GTK_STATE_PRELIGHT],
 369                            win_style->bg[GTK_STATE_PRELIGHT], 0x34);
 370     }
 371     case kColorId_ResultsTableSelectedDivider: {
 372       GtkStyle* win_style = GetWindowStyle();
 373       return GdkAlphaBlend(win_style->text[GTK_STATE_SELECTED],
 374                            win_style->bg[GTK_STATE_SELECTED], 0x34);
 375     }
 376     case kColorId_NumColors:
 377       NOTREACHED();
 378       break;
 379   }
 380
 381   return SkColorToGdkColor(kInvalidColorIdColor);
 382 }
 383
 384 GtkWidget* NativeThemeGtk2::GetRealizedWindow() const {
 385   if (!fake_window_) {
 386     fake_window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 387     gtk_widget_realize(fake_window_);
 388   }
 389
 390   return fake_window_;
 391 }
 392
 393 GtkStyle* NativeThemeGtk2::GetWindowStyle() const {
 394   return gtk_rc_get_style(GetRealizedWindow());
 395 }
 396
 397 GtkStyle* NativeThemeGtk2::GetEntryStyle() const {
 398   if (!fake_entry_.get()) {
 399     fake_entry_.Own(gtk_entry_new());
 400
 401     // The fake entry needs to be in the window so it can be realized so we can
 402     // use the computed parts of the style.
 403     gtk_container_add(GTK_CONTAINER(GetRealizedWindow()), fake_entry_.get());
 404     gtk_widget_realize(fake_entry_.get());
 405   }
 406   return gtk_rc_get_style(fake_entry_.get());
 407 }
 408
 409 GtkStyle* NativeThemeGtk2::GetLabelStyle() const {
 410   if (!fake_label_.get())
 411     fake_label_.Own(gtk_label_new(""));
 412
 413   return gtk_rc_get_style(fake_label_.get());
 414 }
 415
 416 GtkStyle* NativeThemeGtk2::GetButtonStyle() const {
 417   if (!fake_button_.get())
 418     fake_button_.Own(gtk_button_new());
 419
 420   return gtk_rc_get_style(fake_button_.get());
 421 }
 422
 423 GtkStyle* NativeThemeGtk2::GetTreeStyle() const {
 424   if (!fake_tree_.get())
 425     fake_tree_.Own(gtk_tree_view_new());
 426
 427   return gtk_rc_get_style(fake_tree_.get());
 428 }
 429
 430 GtkStyle* NativeThemeGtk2::GetTooltipStyle() const {
 431   if (!fake_tooltip_) {
 432     fake_tooltip_ = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 433     gtk_widget_set_name(fake_tooltip_, "gtk-tooltip");
 434     gtk_widget_realize(fake_tooltip_);
 435   }
 436   return gtk_rc_get_style(fake_tooltip_);
 437 }
 438
 439 GtkStyle* NativeThemeGtk2::GetMenuStyle() const {
 440   if (!fake_menu_.get())
 441     fake_menu_.Own(gtk_custom_menu_new());
 442   return gtk_rc_get_style(fake_menu_.get());
 443 }
 444
 445 GtkStyle* NativeThemeGtk2::GetMenuItemStyle() const {
 446   if (!fake_menu_item_) {
 447     if (!fake_menu_.get())
 448       fake_menu_.Own(gtk_custom_menu_new());
 449
 450     fake_menu_item_ = gtk_custom_menu_item_new();
 451     gtk_menu_shell_append(GTK_MENU_SHELL(fake_menu_.get()), fake_menu_item_);
 452   }
 453
 454   return gtk_rc_get_style(fake_menu_item_);
 455 }
 456
 457 void NativeThemeGtk2::PaintComboboxArrow(SkCanvas* canvas,
 458                                          GtkStateType state,
 459                                          const gfx::Rect& rect) const {
 460   GdkPixmap* pm = gdk_pixmap_new(gtk_widget_get_window(GetRealizedWindow()),
 461                                  rect.width(),
 462                                  rect.height(),
 463                                  -1);
 464   // Paint the background.
 465   gtk_paint_flat_box(GetWindowStyle(),
 466                      pm,
 467                      state,
 468                      GTK_SHADOW_NONE,
 469                      NULL,
 470                      GetRealizedWindow(),
 471                      NULL, 0, 0, rect.width(), rect.height());
 472   gtk_paint_arrow(GetWindowStyle(),
 473                   pm,
 474                   state,
 475                   GTK_SHADOW_NONE,
 476                   NULL,
 477                   GetRealizedWindow(),
 478                   NULL,
 479                   GTK_ARROW_DOWN,
 480                   true,
 481                   0, 0, rect.width(), rect.height());
 482   GdkPixbuf* pb = gdk_pixbuf_get_from_drawable(NULL,
 483                                                pm,
 484                                                gdk_drawable_get_colormap(pm),
 485                                                0, 0,
 486                                                0, 0,
 487                                                rect.width(), rect.height());
 488   SkBitmap arrow = GdkPixbufToImageSkia(pb);
 489   canvas->drawBitmap(arrow, rect.x(), rect.y());
 490
 491   g_object_unref(pb);
 492   g_object_unref(pm);
 493 }
 494
 495 }  // namespace libgtk2ui