| // Copyright (c) 2013 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/browser/ui/libgtk2ui/native_theme_gtk2.h" |
| |
| #include <gtk/gtk.h> |
| |
| #include "chrome/browser/ui/libgtk2ui/chrome_gtk_menu_subclasses.h" |
| #include "chrome/browser/ui/libgtk2ui/gtk2_util.h" |
| #include "chrome/browser/ui/libgtk2ui/skia_utils_gtk2.h" |
| #include "ui/gfx/color_utils.h" |
| #include "ui/gfx/path.h" |
| #include "ui/gfx/rect.h" |
| #include "ui/gfx/size.h" |
| #include "ui/gfx/skia_util.h" |
| #include "ui/native_theme/common_theme.h" |
| |
| namespace { |
| |
| // Theme colors returned by GetSystemColor(). |
| const SkColor kInvalidColorIdColor = SkColorSetRGB(255, 0, 128); |
| |
| const GdkColor kURLTextColor = GDK_COLOR_RGB(0x00, 0x88, 0x00); |
| |
| GdkColor GdkAlphaBlend(GdkColor foreground, |
| GdkColor background, |
| SkAlpha alpha) { |
| return libgtk2ui::SkColorToGdkColor( |
| color_utils::AlphaBlend(libgtk2ui::GdkColorToSkColor(foreground), |
| libgtk2ui::GdkColorToSkColor(background), alpha)); |
| } |
| |
| // Generates the normal URL color, a green color used in unhighlighted URL |
| // text. It is a mix of |kURLTextColor| and the current text color. Unlike the |
| // selected text color, it is more important to match the qualities of the |
| // foreground typeface color instead of taking the background into account. |
| GdkColor NormalURLColor(GdkColor foreground) { |
| color_utils::HSL fg_hsl; |
| color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(foreground), &fg_hsl); |
| |
| color_utils::HSL hue_hsl; |
| color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(kURLTextColor), |
| &hue_hsl); |
| |
| // Only allow colors that have a fair amount of saturation in them (color vs |
| // white). This means that our output color will always be fairly green. |
| double s = std::max(0.5, fg_hsl.s); |
| |
| // Make sure the luminance is at least as bright as the |kURLTextColor| green |
| // would be if we were to use that. |
| double l; |
| if (fg_hsl.l < hue_hsl.l) |
| l = hue_hsl.l; |
| else |
| l = (fg_hsl.l + hue_hsl.l) / 2; |
| |
| color_utils::HSL output = { hue_hsl.h, s, l }; |
| return libgtk2ui::SkColorToGdkColor(color_utils::HSLToSkColor(output, 255)); |
| } |
| |
| // Generates the selected URL color, a green color used on URL text in the |
| // currently highlighted entry in the autocomplete popup. It's a mix of |
| // |kURLTextColor|, the current text color, and the background color (the |
| // select highlight). It is more important to contrast with the background |
| // saturation than to look exactly like the foreground color. |
| GdkColor SelectedURLColor(GdkColor foreground, GdkColor background) { |
| color_utils::HSL fg_hsl; |
| color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(foreground), |
| &fg_hsl); |
| |
| color_utils::HSL bg_hsl; |
| color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(background), |
| &bg_hsl); |
| |
| color_utils::HSL hue_hsl; |
| color_utils::SkColorToHSL(libgtk2ui::GdkColorToSkColor(kURLTextColor), |
| &hue_hsl); |
| |
| // The saturation of the text should be opposite of the background, clamped |
| // to 0.2-0.8. We make sure it's greater than 0.2 so there's some color, but |
| // less than 0.8 so it's not the oversaturated neon-color. |
| double opposite_s = 1 - bg_hsl.s; |
| double s = std::max(0.2, std::min(0.8, opposite_s)); |
| |
| // The luminance should match the luminance of the foreground text. Again, |
| // we clamp so as to have at some amount of color (green) in the text. |
| double opposite_l = fg_hsl.l; |
| double l = std::max(0.1, std::min(0.9, opposite_l)); |
| |
| color_utils::HSL output = { hue_hsl.h, s, l }; |
| return libgtk2ui::SkColorToGdkColor(color_utils::HSLToSkColor(output, 255)); |
| } |
| |
| } // namespace |
| |
| |
| namespace libgtk2ui { |
| |
| // static |
| NativeThemeGtk2* NativeThemeGtk2::instance() { |
| CR_DEFINE_STATIC_LOCAL(NativeThemeGtk2, s_native_theme, ()); |
| return &s_native_theme; |
| } |
| |
| NativeThemeGtk2::NativeThemeGtk2() |
| : fake_window_(NULL), |
| fake_tooltip_(NULL), |
| fake_menu_item_(NULL) { |
| } |
| |
| NativeThemeGtk2::~NativeThemeGtk2() { |
| if (fake_window_) |
| gtk_widget_destroy(fake_window_); |
| if (fake_tooltip_) |
| gtk_widget_destroy(fake_tooltip_); |
| |
| fake_entry_.Destroy(); |
| fake_label_.Destroy(); |
| fake_button_.Destroy(); |
| fake_tree_.Destroy(); |
| fake_menu_.Destroy(); |
| } |
| |
| gfx::Size NativeThemeGtk2::GetPartSize(Part part, |
| State state, |
| const ExtraParams& extra) const { |
| if (part == kComboboxArrow) |
| return gfx::Size(12, 12); |
| |
| return ui::NativeThemeBase::GetPartSize(part, state, extra); |
| } |
| |
| void NativeThemeGtk2::Paint(SkCanvas* canvas, |
| Part part, |
| State state, |
| const gfx::Rect& rect, |
| const ExtraParams& extra) const { |
| if (rect.IsEmpty()) |
| return; |
| |
| switch (part) { |
| case kComboboxArrow: |
| PaintComboboxArrow(canvas, GetGtkState(state), rect); |
| return; |
| |
| default: |
| NativeThemeBase::Paint(canvas, part, state, rect, extra); |
| } |
| } |
| |
| SkColor NativeThemeGtk2::GetSystemColor(ColorId color_id) const { |
| return GdkColorToSkColor(GetSystemGdkColor(color_id)); |
| } |
| |
| void NativeThemeGtk2::PaintMenuPopupBackground( |
| SkCanvas* canvas, |
| const gfx::Size& size, |
| const MenuBackgroundExtraParams& menu_background) const { |
| if (menu_background.corner_radius > 0) { |
| SkPaint paint; |
| paint.setStyle(SkPaint::kFill_Style); |
| paint.setFlags(SkPaint::kAntiAlias_Flag); |
| paint.setColor(GetSystemColor(kColorId_MenuBackgroundColor)); |
| |
| gfx::Path path; |
| SkRect rect = SkRect::MakeWH(SkIntToScalar(size.width()), |
| SkIntToScalar(size.height())); |
| SkScalar radius = SkIntToScalar(menu_background.corner_radius); |
| SkScalar radii[8] = {radius, radius, radius, radius, |
| radius, radius, radius, radius}; |
| path.addRoundRect(rect, radii); |
| |
| canvas->drawPath(path, paint); |
| } else { |
| canvas->drawColor(GetSystemColor(kColorId_MenuBackgroundColor), |
| SkXfermode::kSrc_Mode); |
| } |
| } |
| |
| void NativeThemeGtk2::PaintMenuItemBackground( |
| SkCanvas* canvas, |
| State state, |
| const gfx::Rect& rect, |
| const MenuListExtraParams& menu_list) const { |
| SkColor color; |
| SkPaint paint; |
| switch (state) { |
| case NativeTheme::kNormal: |
| case NativeTheme::kDisabled: |
| color = GetSystemColor(NativeTheme::kColorId_MenuBackgroundColor); |
| paint.setColor(color); |
| break; |
| case NativeTheme::kHovered: |
| color = GetSystemColor( |
| NativeTheme::kColorId_FocusedMenuItemBackgroundColor); |
| paint.setColor(color); |
| break; |
| default: |
| NOTREACHED() << "Invalid state " << state; |
| break; |
| } |
| canvas->drawRect(gfx::RectToSkRect(rect), paint); |
| } |
| |
| GdkColor NativeThemeGtk2::GetSystemGdkColor(ColorId color_id) const { |
| switch (color_id) { |
| // Windows |
| case kColorId_WindowBackground: |
| return GetWindowStyle()->bg[GTK_STATE_NORMAL]; |
| |
| // Dialogs |
| case kColorId_DialogBackground: |
| return GetWindowStyle()->bg[GTK_STATE_NORMAL]; |
| |
| // FocusableBorder |
| case kColorId_FocusedBorderColor: |
| return GetEntryStyle()->bg[GTK_STATE_SELECTED]; |
| case kColorId_UnfocusedBorderColor: |
| return GetEntryStyle()->text_aa[GTK_STATE_NORMAL]; |
| |
| // MenuItem |
| case kColorId_EnabledMenuItemForegroundColor: |
| case kColorId_DisabledEmphasizedMenuItemForegroundColor: |
| return GetMenuItemStyle()->text[GTK_STATE_NORMAL]; |
| case kColorId_DisabledMenuItemForegroundColor: |
| return GetMenuItemStyle()->text[GTK_STATE_INSENSITIVE]; |
| case kColorId_SelectedMenuItemForegroundColor: |
| return GetMenuItemStyle()->text[GTK_STATE_SELECTED]; |
| case kColorId_FocusedMenuItemBackgroundColor: |
| return GetMenuItemStyle()->bg[GTK_STATE_SELECTED]; |
| case kColorId_HoverMenuItemBackgroundColor: |
| return GetMenuItemStyle()->bg[GTK_STATE_PRELIGHT]; |
| case kColorId_FocusedMenuButtonBorderColor: |
| return GetEntryStyle()->bg[GTK_STATE_NORMAL]; |
| case kColorId_HoverMenuButtonBorderColor: |
| return GetEntryStyle()->text_aa[GTK_STATE_PRELIGHT]; |
| case kColorId_MenuBorderColor: |
| case kColorId_EnabledMenuButtonBorderColor: |
| case kColorId_MenuSeparatorColor: { |
| return GetMenuItemStyle()->text[GTK_STATE_INSENSITIVE]; |
| } |
| case kColorId_MenuBackgroundColor: |
| return GetMenuStyle()->bg[GTK_STATE_NORMAL]; |
| |
| // Label |
| case kColorId_LabelEnabledColor: |
| return GetLabelStyle()->text[GTK_STATE_NORMAL]; |
| case kColorId_LabelDisabledColor: |
| return GetLabelStyle()->text[GTK_STATE_INSENSITIVE]; |
| case kColorId_LabelBackgroundColor: |
| return GetWindowStyle()->bg[GTK_STATE_NORMAL]; |
| |
| // Button |
| case kColorId_ButtonBackgroundColor: |
| return GetButtonStyle()->bg[GTK_STATE_NORMAL]; |
| case kColorId_ButtonEnabledColor: |
| return GetButtonStyle()->text[GTK_STATE_NORMAL]; |
| case kColorId_ButtonDisabledColor: |
| return GetButtonStyle()->text[GTK_STATE_INSENSITIVE]; |
| case kColorId_ButtonHighlightColor: |
| return GetButtonStyle()->base[GTK_STATE_SELECTED]; |
| case kColorId_ButtonHoverColor: |
| return GetButtonStyle()->text[GTK_STATE_PRELIGHT]; |
| case kColorId_ButtonHoverBackgroundColor: |
| return GetButtonStyle()->bg[GTK_STATE_PRELIGHT]; |
| // TODO(estade): determine a more distinct color for the Blue |
| // buttons. |
| case kColorId_BlueButtonEnabledColor: |
| return GetButtonStyle()->text[GTK_STATE_NORMAL]; |
| case kColorId_BlueButtonDisabledColor: |
| return GetButtonStyle()->text[GTK_STATE_INSENSITIVE]; |
| case kColorId_BlueButtonHighlightColor: |
| return GetButtonStyle()->base[GTK_STATE_SELECTED]; |
| case kColorId_BlueButtonHoverColor: |
| return GetButtonStyle()->text[GTK_STATE_PRELIGHT]; |
| |
| // Textfield |
| case kColorId_TextfieldDefaultColor: |
| return GetEntryStyle()->text[GTK_STATE_NORMAL]; |
| case kColorId_TextfieldDefaultBackground: |
| return GetEntryStyle()->base[GTK_STATE_NORMAL]; |
| case kColorId_TextfieldReadOnlyColor: |
| return GetEntryStyle()->text[GTK_STATE_INSENSITIVE]; |
| case kColorId_TextfieldReadOnlyBackground: |
| return GetEntryStyle()->base[GTK_STATE_INSENSITIVE]; |
| case kColorId_TextfieldSelectionColor: |
| return GetEntryStyle()->text[GTK_STATE_SELECTED]; |
| case kColorId_TextfieldSelectionBackgroundFocused: |
| return GetEntryStyle()->base[GTK_STATE_SELECTED]; |
| |
| // Tooltips |
| case kColorId_TooltipBackground: |
| return GetTooltipStyle()->bg[GTK_STATE_NORMAL]; |
| case kColorId_TooltipText: |
| return GetTooltipStyle()->fg[GTK_STATE_NORMAL]; |
| |
| // Trees and Tables (implemented on GTK using the same class) |
| case kColorId_TableBackground: |
| case kColorId_TreeBackground: |
| return GetTreeStyle()->bg[GTK_STATE_NORMAL]; |
| case kColorId_TableText: |
| case kColorId_TreeText: |
| return GetTreeStyle()->text[GTK_STATE_NORMAL]; |
| case kColorId_TableSelectedText: |
| case kColorId_TableSelectedTextUnfocused: |
| case kColorId_TreeSelectedText: |
| case kColorId_TreeSelectedTextUnfocused: |
| return GetTreeStyle()->text[GTK_STATE_SELECTED]; |
| case kColorId_TableSelectionBackgroundFocused: |
| case kColorId_TableSelectionBackgroundUnfocused: |
| case kColorId_TreeSelectionBackgroundFocused: |
| case kColorId_TreeSelectionBackgroundUnfocused: |
| return GetTreeStyle()->bg[GTK_STATE_SELECTED]; |
| case kColorId_TreeArrow: |
| return GetTreeStyle()->fg[GTK_STATE_NORMAL]; |
| case kColorId_TableGroupingIndicatorColor: |
| return GetTreeStyle()->text_aa[GTK_STATE_NORMAL]; |
| |
| // Results Table |
| case kColorId_ResultsTableNormalBackground: |
| return GetEntryStyle()->base[GTK_STATE_NORMAL]; |
| case kColorId_ResultsTableHoveredBackground: { |
| GtkStyle* entry_style = GetEntryStyle(); |
| return GdkAlphaBlend( |
| entry_style->base[GTK_STATE_NORMAL], |
| entry_style->base[GTK_STATE_SELECTED], 0x80); |
| } |
| case kColorId_ResultsTableSelectedBackground: |
| return GetEntryStyle()->base[GTK_STATE_SELECTED]; |
| case kColorId_ResultsTableNormalText: |
| case kColorId_ResultsTableHoveredText: |
| return GetEntryStyle()->text[GTK_STATE_NORMAL]; |
| case kColorId_ResultsTableSelectedText: |
| return GetEntryStyle()->text[GTK_STATE_SELECTED]; |
| case kColorId_ResultsTableNormalDimmedText: |
| case kColorId_ResultsTableHoveredDimmedText: { |
| GtkStyle* entry_style = GetEntryStyle(); |
| return GdkAlphaBlend( |
| entry_style->text[GTK_STATE_NORMAL], |
| entry_style->base[GTK_STATE_NORMAL], 0x80); |
| } |
| case kColorId_ResultsTableSelectedDimmedText: { |
| GtkStyle* entry_style = GetEntryStyle(); |
| return GdkAlphaBlend( |
| entry_style->text[GTK_STATE_SELECTED], |
| entry_style->base[GTK_STATE_NORMAL], 0x80); |
| } |
| case kColorId_ResultsTableNormalUrl: |
| case kColorId_ResultsTableHoveredUrl: { |
| return NormalURLColor(GetEntryStyle()->text[GTK_STATE_NORMAL]); |
| } |
| case kColorId_ResultsTableSelectedUrl: { |
| GtkStyle* entry_style = GetEntryStyle(); |
| return SelectedURLColor(entry_style->text[GTK_STATE_SELECTED], |
| entry_style->base[GTK_STATE_SELECTED]); |
| } |
| case kColorId_ResultsTableNormalDivider: { |
| GtkStyle* win_style = GetWindowStyle(); |
| return GdkAlphaBlend(win_style->text[GTK_STATE_NORMAL], |
| win_style->bg[GTK_STATE_NORMAL], 0x34); |
| } |
| case kColorId_ResultsTableHoveredDivider: { |
| GtkStyle* win_style = GetWindowStyle(); |
| return GdkAlphaBlend(win_style->text[GTK_STATE_PRELIGHT], |
| win_style->bg[GTK_STATE_PRELIGHT], 0x34); |
| } |
| case kColorId_ResultsTableSelectedDivider: { |
| GtkStyle* win_style = GetWindowStyle(); |
| return GdkAlphaBlend(win_style->text[GTK_STATE_SELECTED], |
| win_style->bg[GTK_STATE_SELECTED], 0x34); |
| } |
| } |
| |
| return SkColorToGdkColor(kInvalidColorIdColor); |
| } |
| |
| GtkWidget* NativeThemeGtk2::GetRealizedWindow() const { |
| if (!fake_window_) { |
| fake_window_ = gtk_window_new(GTK_WINDOW_TOPLEVEL); |
| gtk_widget_realize(fake_window_); |
| } |
| |
| return fake_window_; |
| } |
| |
| GtkStyle* NativeThemeGtk2::GetWindowStyle() const { |
| return gtk_rc_get_style(GetRealizedWindow()); |
| } |
| |
| GtkStyle* NativeThemeGtk2::GetEntryStyle() const { |
| if (!fake_entry_.get()) { |
| fake_entry_.Own(gtk_entry_new()); |
| |
| // The fake entry needs to be in the window so it can be realized so we can |
| // use the computed parts of the style. |
| gtk_container_add(GTK_CONTAINER(GetRealizedWindow()), fake_entry_.get()); |
| gtk_widget_realize(fake_entry_.get()); |
| } |
| return gtk_rc_get_style(fake_entry_.get()); |
| } |
| |
| GtkStyle* NativeThemeGtk2::GetLabelStyle() const { |
| if (!fake_label_.get()) |
| fake_label_.Own(gtk_label_new("")); |
| |
| return gtk_rc_get_style(fake_label_.get()); |
| } |
| |
| GtkStyle* NativeThemeGtk2::GetButtonStyle() const { |
| if (!fake_button_.get()) |
| fake_button_.Own(gtk_button_new()); |
| |
| return gtk_rc_get_style(fake_button_.get()); |
| } |
| |
| GtkStyle* NativeThemeGtk2::GetTreeStyle() const { |
| if (!fake_tree_.get()) |
| fake_tree_.Own(gtk_tree_view_new()); |
| |
| return gtk_rc_get_style(fake_tree_.get()); |
| } |
| |
| GtkStyle* NativeThemeGtk2::GetTooltipStyle() const { |
| if (!fake_tooltip_) { |
| fake_tooltip_ = gtk_window_new(GTK_WINDOW_TOPLEVEL); |
| gtk_widget_set_name(fake_tooltip_, "gtk-tooltip"); |
| gtk_widget_realize(fake_tooltip_); |
| } |
| return gtk_rc_get_style(fake_tooltip_); |
| } |
| |
| GtkStyle* NativeThemeGtk2::GetMenuStyle() const { |
| if (!fake_menu_.get()) |
| fake_menu_.Own(gtk_menu_new()); |
| return gtk_rc_get_style(fake_menu_.get()); |
| } |
| |
| GtkStyle* NativeThemeGtk2::GetMenuItemStyle() const { |
| if (!fake_menu_item_) { |
| if (!fake_menu_.get()) |
| fake_menu_.Own(gtk_custom_menu_new()); |
| |
| fake_menu_item_ = gtk_custom_menu_item_new(); |
| gtk_menu_shell_append(GTK_MENU_SHELL(fake_menu_.get()), fake_menu_item_); |
| } |
| |
| return gtk_rc_get_style(fake_menu_item_); |
| } |
| |
| void NativeThemeGtk2::PaintComboboxArrow(SkCanvas* canvas, |
| GtkStateType state, |
| const gfx::Rect& rect) const { |
| GdkPixmap* pm = gdk_pixmap_new(gtk_widget_get_window(GetRealizedWindow()), |
| rect.width(), |
| rect.height(), |
| -1); |
| // Paint the background. |
| gtk_paint_flat_box(GetWindowStyle(), |
| pm, |
| state, |
| GTK_SHADOW_NONE, |
| NULL, |
| GetRealizedWindow(), |
| NULL, 0, 0, rect.width(), rect.height()); |
| gtk_paint_arrow(GetWindowStyle(), |
| pm, |
| state, |
| GTK_SHADOW_NONE, |
| NULL, |
| GetRealizedWindow(), |
| NULL, |
| GTK_ARROW_DOWN, |
| true, |
| 0, 0, rect.width(), rect.height()); |
| GdkPixbuf* pb = gdk_pixbuf_get_from_drawable(NULL, |
| pm, |
| gdk_drawable_get_colormap(pm), |
| 0, 0, |
| 0, 0, |
| rect.width(), rect.height()); |
| SkBitmap arrow = GdkPixbufToImageSkia(pb); |
| canvas->drawBitmap(arrow, rect.x(), rect.y()); |
| |
| g_object_unref(pb); |
| g_object_unref(pm); |
| } |
| |
| } // namespace libgtk2ui |
