| // Copyright 2016 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/libgtkui/native_theme_gtk3.h" |
| |
| #include <gtk/gtk.h> |
| |
| #include "chrome/browser/ui/libgtkui/chrome_gtk_frame.h" |
| #include "chrome/browser/ui/libgtkui/chrome_gtk_menu_subclasses.h" |
| #include "chrome/browser/ui/libgtkui/gtk_util.h" |
| #include "chrome/browser/ui/libgtkui/skia_utils_gtk.h" |
| #include "ui/gfx/color_palette.h" |
| #include "ui/gfx/color_utils.h" |
| #include "ui/gfx/geometry/rect.h" |
| #include "ui/gfx/skbitmap_operations.h" |
| #include "ui/native_theme/native_theme_dark_aura.h" |
| |
| namespace libgtkui { |
| |
| namespace { |
| |
| enum BackgroundRenderMode { |
| BG_RENDER_NORMAL, |
| BG_RENDER_NONE, |
| BG_RENDER_RECURSIVE, |
| }; |
| |
| SkBitmap GetWidgetBitmap(const gfx::Size& size, |
| GtkStyleContext* context, |
| BackgroundRenderMode bg_mode, |
| bool render_frame) { |
| DCHECK(bg_mode != BG_RENDER_NONE || render_frame); |
| SkBitmap bitmap; |
| bitmap.allocN32Pixels(size.width(), size.height()); |
| bitmap.eraseColor(0); |
| |
| CairoSurface surface(bitmap); |
| cairo_t* cr = surface.cairo(); |
| |
| switch (bg_mode) { |
| case BG_RENDER_NORMAL: |
| gtk_render_background(context, cr, 0, 0, size.width(), size.height()); |
| break; |
| case BG_RENDER_RECURSIVE: |
| RenderBackground(size, cr, context); |
| break; |
| case BG_RENDER_NONE: |
| break; |
| } |
| if (render_frame) |
| gtk_render_frame(context, cr, 0, 0, size.width(), size.height()); |
| return bitmap; |
| } |
| |
| void PaintWidget(cc::PaintCanvas* canvas, |
| const gfx::Rect& rect, |
| GtkStyleContext* context, |
| BackgroundRenderMode bg_mode, |
| bool render_frame) { |
| canvas->drawBitmap( |
| GetWidgetBitmap(rect.size(), context, bg_mode, render_frame), rect.x(), |
| rect.y()); |
| } |
| |
| SkColor SkColorFromColorId(ui::NativeTheme::ColorId color_id) { |
| const SkColor kPositiveTextColor = SkColorSetRGB(0x0b, 0x80, 0x43); |
| const SkColor kNegativeTextColor = SkColorSetRGB(0xc5, 0x39, 0x29); |
| |
| switch (color_id) { |
| // Windows |
| case ui::NativeTheme::kColorId_WindowBackground: |
| // Dialogs |
| case ui::NativeTheme::kColorId_DialogBackground: |
| case ui::NativeTheme::kColorId_BubbleBackground: |
| return GetBgColor(""); |
| |
| // FocusableBorder |
| case ui::NativeTheme::kColorId_FocusedBorderColor: |
| // GetBorderColor("GtkEntry#entry:focus") is correct here. The focus ring |
| // around widgets is usually a lighter version of the "canonical theme |
| // color" - orange on Ambiance, blue on Adwaita, etc. However, Chrome |
| // lightens the color we give it, so it would look wrong if we give it an |
| // already-lightened color. This workaround returns the theme color |
| // directly, taken from a selected table row. This has matched the theme |
| // color on every theme that I've tested. |
| return GetBgColor( |
| "GtkTreeView#treeview.view " |
| "GtkTreeView#treeview.view.cell:selected:focus"); |
| case ui::NativeTheme::kColorId_UnfocusedBorderColor: |
| return GetBorderColor("GtkEntry#entry"); |
| |
| // Menu |
| case ui::NativeTheme::kColorId_MenuBackgroundColor: |
| return GetBgColor("GtkMenu#menu"); |
| case ui::NativeTheme::kColorId_MenuBorderColor: |
| return GetBorderColor("GtkMenu#menu"); |
| case ui::NativeTheme::kColorId_FocusedMenuItemBackgroundColor: |
| return GetBgColor("GtkMenu#menu GtkMenuItem#menuitem:hover"); |
| case ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor: |
| return GetFgColor("GtkMenu#menu GtkMenuItem#menuitem GtkLabel"); |
| case ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor: |
| return GetFgColor("GtkMenu#menu GtkMenuItem#menuitem:hover GtkLabel"); |
| case ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor: |
| return GetFgColor("GtkMenu#menu GtkMenuItem#menuitem:disabled GtkLabel"); |
| case ui::NativeTheme::kColorId_MenuItemSubtitleColor: |
| if (GtkVersionCheck(3, 20)) { |
| return GetFgColor("GtkMenu#menu GtkMenuItem#menuitem #accelerator"); |
| } |
| return GetFgColor( |
| "GtkMenu#menu GtkMenuItem#menuitem GtkLabel.accelerator"); |
| case ui::NativeTheme::kColorId_MenuSeparatorColor: |
| // MenuButton borders are used as vertical menu separators in Chrome. |
| case ui::NativeTheme::kColorId_EnabledMenuButtonBorderColor: |
| case ui::NativeTheme::kColorId_FocusedMenuButtonBorderColor: |
| case ui::NativeTheme::kColorId_HoverMenuButtonBorderColor: |
| if (GtkVersionCheck(3, 20)) { |
| return GetSeparatorColor( |
| "GtkMenu#menu GtkSeparator#separator.horizontal"); |
| } |
| return GetFgColor("GtkMenu#menu GtkMenuItem#menuitem.separator"); |
| |
| // Label |
| case ui::NativeTheme::kColorId_LabelEnabledColor: |
| return GetFgColor("GtkLabel"); |
| case ui::NativeTheme::kColorId_LabelDisabledColor: |
| return GetFgColor("GtkLabel:disabled"); |
| case ui::NativeTheme::kColorId_LabelTextSelectionColor: |
| return GetFgColor(GtkVersionCheck(3, 20) ? "GtkLabel #selection" |
| : "GtkLabel:selected"); |
| case ui::NativeTheme::kColorId_LabelTextSelectionBackgroundFocused: |
| return GetSelectionBgColor(GtkVersionCheck(3, 20) ? "GtkLabel #selection" |
| : "GtkLabel:selected"); |
| |
| // Link |
| case ui::NativeTheme::kColorId_LinkDisabled: |
| return SkColorSetA( |
| SkColorFromColorId(ui::NativeTheme::kColorId_LinkEnabled), 0xBB); |
| case ui::NativeTheme::kColorId_LinkPressed: |
| if (GtkVersionCheck(3, 12)) |
| return GetFgColor("GtkLabel.link:link:hover:active"); |
| // fallthrough |
| case ui::NativeTheme::kColorId_LinkEnabled: { |
| if (GtkVersionCheck(3, 12)) { |
| return GetFgColor("GtkLabel.link:link"); |
| } |
| auto link_context = GetStyleContextFromCss("GtkLabel.view"); |
| GdkColor* color; |
| gtk_style_context_get_style(link_context, "link-color", &color, nullptr); |
| if (color) { |
| SkColor ret_color = GdkColorToSkColor(*color); |
| // gdk_color_free() was deprecated in Gtk3.14. This code path is only |
| // taken on versions earlier than Gtk3.12, but the compiler doesn't know |
| // that, so silence the deprecation warnings. |
| G_GNUC_BEGIN_IGNORE_DEPRECATIONS; |
| gdk_color_free(color); |
| G_GNUC_END_IGNORE_DEPRECATIONS; |
| return ret_color; |
| } |
| |
| // Default color comes from gtklinkbutton.c. |
| return SkColorSetRGB(0x00, 0x00, 0xEE); |
| } |
| |
| // Separator |
| case ui::NativeTheme::kColorId_SeparatorColor: |
| return GetSeparatorColor("GtkSeparator#separator.horizontal"); |
| |
| // Button |
| case ui::NativeTheme::kColorId_ButtonEnabledColor: |
| return GetFgColor("GtkButton#button.text-button GtkLabel"); |
| case ui::NativeTheme::kColorId_ButtonDisabledColor: |
| return GetFgColor("GtkButton#button.text-button:disabled GtkLabel"); |
| case ui::NativeTheme::kColorId_ButtonHoverColor: |
| return GetFgColor("GtkButton#button.text-button:hover GtkLabel"); |
| case ui::NativeTheme::kColorId_ButtonPressedShade: |
| return SK_ColorTRANSPARENT; |
| |
| // BlueButton |
| case ui::NativeTheme::kColorId_BlueButtonEnabledColor: |
| return GetFgColor( |
| "GtkButton#button.text-button.default.suggested-action GtkLabel"); |
| case ui::NativeTheme::kColorId_BlueButtonDisabledColor: |
| return GetFgColor( |
| "GtkButton#button.text-button.default.suggested-action:disabled " |
| "GtkLabel"); |
| case ui::NativeTheme::kColorId_BlueButtonHoverColor: |
| return GetFgColor( |
| "GtkButton#button.text-button.default.suggested-action:hover " |
| "GtkLabel"); |
| case ui::NativeTheme::kColorId_BlueButtonPressedColor: |
| return GetFgColor( |
| "GtkButton#button.text-button.default.suggested-action:hover:active " |
| "GtkLabel"); |
| case ui::NativeTheme::kColorId_BlueButtonShadowColor: |
| return SK_ColorTRANSPARENT; |
| |
| // ProminentButton |
| case ui::NativeTheme::kColorId_ProminentButtonColor: |
| return GetBgColor( |
| "GtkTreeView#treeview.view " |
| "GtkTreeView#treeview.view.cell:selected:focus"); |
| case ui::NativeTheme::kColorId_TextOnProminentButtonColor: |
| return GetFgColor( |
| "GtkTreeView#treeview.view " |
| "GtkTreeview#treeview.view.cell:selected:focus GtkLabel"); |
| |
| // Textfield |
| case ui::NativeTheme::kColorId_TextfieldDefaultColor: |
| return GetFgColor(GtkVersionCheck(3, 20) |
| ? "GtkTextView#textview.view #text" |
| : "GtkTextView.view"); |
| case ui::NativeTheme::kColorId_TextfieldDefaultBackground: |
| return GetBgColor(GtkVersionCheck(3, 20) ? "GtkTextView#textview.view" |
| : "GtkTextView.view"); |
| case ui::NativeTheme::kColorId_TextfieldReadOnlyColor: |
| return GetFgColor(GtkVersionCheck(3, 20) |
| ? "GtkTextView#textview.view:disabled #text" |
| : "GtkTextView.view:disabled"); |
| case ui::NativeTheme::kColorId_TextfieldReadOnlyBackground: |
| return GetBgColor(GtkVersionCheck(3, 20) |
| ? "GtkTextView#textview.view:disabled" |
| : "GtkTextView.view:disabled"); |
| case ui::NativeTheme::kColorId_TextfieldSelectionColor: |
| return GetFgColor(GtkVersionCheck(3, 20) |
| ? "GtkTextView#textview.view #text #selection" |
| : "GtkTextView.view:selected"); |
| case ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused: |
| return GetSelectionBgColor( |
| GtkVersionCheck(3, 20) ? "GtkTextView#textview.view #text #selection" |
| : "GtkTextView.view:selected"); |
| |
| // Tooltips |
| case ui::NativeTheme::kColorId_TooltipBackground: |
| return GetBgColor("GtkTooltip#tooltip"); |
| case ui::NativeTheme::kColorId_TooltipText: |
| return color_utils::GetReadableColor(GetFgColor("GtkTooltip#tooltip"), |
| GetBgColor("GtkTooltip#tooltip")); |
| |
| // Trees and Tables (implemented on GTK using the same class) |
| case ui::NativeTheme::kColorId_TableBackground: |
| case ui::NativeTheme::kColorId_TreeBackground: |
| return GetBgColor( |
| "GtkTreeView#treeview.view GtkTreeView#treeview.view.cell"); |
| case ui::NativeTheme::kColorId_TableText: |
| case ui::NativeTheme::kColorId_TreeText: |
| case ui::NativeTheme::kColorId_TableGroupingIndicatorColor: |
| return GetFgColor( |
| "GtkTreeView#treeview.view GtkTreeView#treeview.view.cell GtkLabel"); |
| case ui::NativeTheme::kColorId_TableSelectedText: |
| case ui::NativeTheme::kColorId_TableSelectedTextUnfocused: |
| case ui::NativeTheme::kColorId_TreeSelectedText: |
| case ui::NativeTheme::kColorId_TreeSelectedTextUnfocused: |
| return GetFgColor( |
| "GtkTreeView#treeview.view " |
| "GtkTreeView#treeview.view.cell:selected:focus GtkLabel"); |
| case ui::NativeTheme::kColorId_TableSelectionBackgroundFocused: |
| case ui::NativeTheme::kColorId_TableSelectionBackgroundUnfocused: |
| case ui::NativeTheme::kColorId_TreeSelectionBackgroundFocused: |
| case ui::NativeTheme::kColorId_TreeSelectionBackgroundUnfocused: |
| return GetBgColor( |
| "GtkTreeView#treeview.view " |
| "GtkTreeView#treeview.view.cell:selected:focus"); |
| |
| // Table Header |
| case ui::NativeTheme::kColorId_TableHeaderText: |
| return GetFgColor("GtkTreeView#treeview.view GtkButton#button GtkLabel"); |
| case ui::NativeTheme::kColorId_TableHeaderBackground: |
| return GetBgColor("GtkTreeView#treeview.view GtkButton#button"); |
| case ui::NativeTheme::kColorId_TableHeaderSeparator: |
| return GetBorderColor("GtkTreeView#treeview.view GtkButton#button"); |
| |
| // Results Table |
| case ui::NativeTheme::kColorId_ResultsTableNormalBackground: |
| return SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldDefaultBackground); |
| case ui::NativeTheme::kColorId_ResultsTableHoveredBackground: |
| return color_utils::AlphaBlend( |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldDefaultBackground), |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused), |
| 0x80); |
| case ui::NativeTheme::kColorId_ResultsTableSelectedBackground: |
| return SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused); |
| case ui::NativeTheme::kColorId_ResultsTableNormalText: |
| case ui::NativeTheme::kColorId_ResultsTableHoveredText: |
| return SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldDefaultColor); |
| case ui::NativeTheme::kColorId_ResultsTableSelectedText: |
| return SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldSelectionColor); |
| case ui::NativeTheme::kColorId_ResultsTableNormalDimmedText: |
| case ui::NativeTheme::kColorId_ResultsTableHoveredDimmedText: |
| return color_utils::AlphaBlend( |
| SkColorFromColorId(ui::NativeTheme::kColorId_TextfieldDefaultColor), |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldDefaultBackground), |
| 0x80); |
| case ui::NativeTheme::kColorId_ResultsTableSelectedDimmedText: |
| return color_utils::AlphaBlend( |
| SkColorFromColorId(ui::NativeTheme::kColorId_TextfieldSelectionColor), |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldDefaultBackground), |
| 0x80); |
| case ui::NativeTheme::kColorId_ResultsTableNormalUrl: |
| case ui::NativeTheme::kColorId_ResultsTableHoveredUrl: |
| return NormalURLColor( |
| SkColorFromColorId(ui::NativeTheme::kColorId_TextfieldDefaultColor)); |
| case ui::NativeTheme::kColorId_ResultsTableSelectedUrl: |
| return SelectedURLColor( |
| SkColorFromColorId(ui::NativeTheme::kColorId_TextfieldSelectionColor), |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused)); |
| case ui::NativeTheme::kColorId_ResultsTablePositiveText: |
| return color_utils::GetReadableColor( |
| kPositiveTextColor, |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldDefaultBackground)); |
| case ui::NativeTheme::kColorId_ResultsTablePositiveHoveredText: |
| return color_utils::GetReadableColor( |
| kPositiveTextColor, |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldDefaultBackground)); |
| case ui::NativeTheme::kColorId_ResultsTablePositiveSelectedText: |
| return color_utils::GetReadableColor( |
| kPositiveTextColor, |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused)); |
| case ui::NativeTheme::kColorId_ResultsTableNegativeText: |
| return color_utils::GetReadableColor( |
| kNegativeTextColor, |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldDefaultBackground)); |
| case ui::NativeTheme::kColorId_ResultsTableNegativeHoveredText: |
| return color_utils::GetReadableColor( |
| kNegativeTextColor, |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldDefaultBackground)); |
| case ui::NativeTheme::kColorId_ResultsTableNegativeSelectedText: |
| return color_utils::GetReadableColor( |
| kNegativeTextColor, |
| SkColorFromColorId( |
| ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused)); |
| |
| // Throbber |
| // TODO(thomasanderson): Render GtkSpinner directly. |
| case ui::NativeTheme::kColorId_ThrobberSpinningColor: |
| case ui::NativeTheme::kColorId_ThrobberWaitingColor: |
| return GetFgColor("GtkMenu#menu GtkSpinner#spinner"); |
| case ui::NativeTheme::kColorId_ThrobberLightColor: |
| return GetFgColor("GtkMenu#menu GtkSpinner#spinner:disabled"); |
| |
| // Alert icons |
| // Fallback to the same colors as Aura. |
| case ui::NativeTheme::kColorId_AlertSeverityLow: |
| case ui::NativeTheme::kColorId_AlertSeverityMedium: |
| case ui::NativeTheme::kColorId_AlertSeverityHigh: { |
| // Alert icons appear on the toolbar, so use the toolbar BG |
| // color to determine if the dark Aura theme should be used. |
| ui::NativeTheme* fallback_theme = |
| color_utils::IsDark(GetBgColor("GtkToolbar#toolbar")) |
| ? ui::NativeTheme::GetInstanceForNativeUi() |
| : ui::NativeThemeDarkAura::instance(); |
| return fallback_theme->GetSystemColor(color_id); |
| } |
| |
| case ui::NativeTheme::kColorId_NumColors: |
| NOTREACHED(); |
| break; |
| } |
| return kInvalidColorIdColor; |
| } |
| |
| void OnThemeChanged(GObject* obj, GParamSpec* param, NativeThemeGtk3* theme) { |
| theme->ResetColorCache(); |
| } |
| |
| } // namespace |
| |
| // static |
| NativeThemeGtk3* NativeThemeGtk3::instance() { |
| CR_DEFINE_STATIC_LOCAL(NativeThemeGtk3, s_native_theme, ()); |
| return &s_native_theme; |
| } |
| |
| // Constructors automatically called |
| NativeThemeGtk3::NativeThemeGtk3() { |
| // These types are needed by g_type_from_name(), but may not be registered at |
| // this point. We need the g_type_class magic to make sure the compiler |
| // doesn't optimize away this code. |
| g_type_class_unref(g_type_class_ref(gtk_button_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_entry_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_info_bar_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_label_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_menu_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_menu_bar_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_menu_item_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_range_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_scrollbar_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_scrolled_window_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_separator_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_spinner_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_text_view_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_toolbar_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_tooltip_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_tree_view_get_type())); |
| g_type_class_unref(g_type_class_ref(gtk_window_get_type())); |
| |
| g_signal_connect_after(gtk_settings_get_default(), "notify::gtk-theme-name", |
| G_CALLBACK(OnThemeChanged), this); |
| } |
| |
| // This doesn't actually get called |
| NativeThemeGtk3::~NativeThemeGtk3() {} |
| |
| void NativeThemeGtk3::ResetColorCache() { |
| for (auto& color : color_cache_) |
| color = base::nullopt; |
| } |
| |
| SkColor NativeThemeGtk3::GetSystemColor(ColorId color_id) const { |
| if (color_cache_[color_id]) |
| return color_cache_[color_id].value(); |
| |
| SkColor color = SkColorFromColorId(color_id); |
| color_cache_[color_id] = color; |
| return color; |
| } |
| |
| void NativeThemeGtk3::PaintArrowButton(cc::PaintCanvas* canvas, |
| const gfx::Rect& rect, |
| Part direction, |
| State state) const { |
| auto context = GetStyleContextFromCss( |
| GtkVersionCheck(3, 20) |
| ? "GtkScrollbar#scrollbar #contents GtkButton#button" |
| : "GtkRange.scrollbar.button"); |
| GtkStateFlags state_flags = StateToStateFlags(state); |
| gtk_style_context_set_state(context, state_flags); |
| |
| switch (direction) { |
| case kScrollbarUpArrow: |
| gtk_style_context_add_class(context, GTK_STYLE_CLASS_TOP); |
| break; |
| case kScrollbarRightArrow: |
| gtk_style_context_add_class(context, GTK_STYLE_CLASS_RIGHT); |
| break; |
| case kScrollbarDownArrow: |
| gtk_style_context_add_class(context, GTK_STYLE_CLASS_BOTTOM); |
| break; |
| case kScrollbarLeftArrow: |
| gtk_style_context_add_class(context, GTK_STYLE_CLASS_LEFT); |
| break; |
| default: |
| NOTREACHED(); |
| } |
| |
| PaintWidget(canvas, rect, context, BG_RENDER_NORMAL, true); |
| PaintArrow(canvas, rect, direction, GetFgColorFromStyleContext(context)); |
| } |
| |
| void NativeThemeGtk3::PaintScrollbarTrack( |
| cc::PaintCanvas* canvas, |
| Part part, |
| State state, |
| const ScrollbarTrackExtraParams& extra_params, |
| const gfx::Rect& rect) const { |
| PaintWidget(canvas, rect, GetStyleContextFromCss( |
| GtkVersionCheck(3, 20) |
| ? "GtkScrollbar#scrollbar #contents #trough" |
| : "GtkScrollbar.scrollbar.trough"), |
| BG_RENDER_NORMAL, true); |
| } |
| |
| void NativeThemeGtk3::PaintScrollbarThumb( |
| cc::PaintCanvas* canvas, |
| Part part, |
| State state, |
| const gfx::Rect& rect, |
| NativeTheme::ScrollbarOverlayColorTheme theme) const { |
| auto context = GetStyleContextFromCss( |
| GtkVersionCheck(3, 20) |
| ? "GtkScrollbar#scrollbar #contents #trough #slider" |
| : "GtkScrollbar.scrollbar.slider"); |
| gtk_style_context_set_state(context, StateToStateFlags(state)); |
| PaintWidget(canvas, rect, context, BG_RENDER_NORMAL, true); |
| } |
| |
| void NativeThemeGtk3::PaintScrollbarCorner(cc::PaintCanvas* canvas, |
| State state, |
| const gfx::Rect& rect) const { |
| auto context = GetStyleContextFromCss( |
| GtkVersionCheck(3, 19, 2) |
| ? "GtkScrolledWindow#scrolledwindow #junction" |
| : "GtkScrolledWindow.scrolledwindow.scrollbars-junction"); |
| PaintWidget(canvas, rect, context, BG_RENDER_NORMAL, true); |
| } |
| |
| void NativeThemeGtk3::PaintMenuPopupBackground( |
| cc::PaintCanvas* canvas, |
| const gfx::Size& size, |
| const MenuBackgroundExtraParams& menu_background) const { |
| PaintWidget(canvas, gfx::Rect(size), GetStyleContextFromCss("GtkMenu#menu"), |
| BG_RENDER_RECURSIVE, false); |
| } |
| |
| void NativeThemeGtk3::PaintMenuItemBackground( |
| cc::PaintCanvas* canvas, |
| State state, |
| const gfx::Rect& rect, |
| const MenuItemExtraParams& menu_item) const { |
| auto context = GetStyleContextFromCss("GtkMenu#menu GtkMenuItem#menuitem"); |
| gtk_style_context_set_state(context, StateToStateFlags(state)); |
| PaintWidget(canvas, rect, context, BG_RENDER_NORMAL, true); |
| } |
| |
| void NativeThemeGtk3::PaintMenuSeparator( |
| cc::PaintCanvas* canvas, |
| State state, |
| const gfx::Rect& rect, |
| const MenuSeparatorExtraParams& menu_separator) const { |
| auto separator_offset = [&](int separator_thickness) { |
| switch (menu_separator.type) { |
| case ui::LOWER_SEPARATOR: |
| return rect.height() - separator_thickness; |
| case ui::UPPER_SEPARATOR: |
| return 0; |
| default: |
| return (rect.height() - separator_thickness) / 2; |
| } |
| }; |
| if (GtkVersionCheck(3, 20)) { |
| auto context = GetStyleContextFromCss( |
| "GtkMenu#menu GtkSeparator#separator.horizontal"); |
| GtkBorder margin, border, padding; |
| GtkStateFlags state = gtk_style_context_get_state(context); |
| gtk_style_context_get_margin(context, state, &margin); |
| gtk_style_context_get_border(context, state, &border); |
| gtk_style_context_get_padding(context, state, &padding); |
| int min_height = 1; |
| gtk_style_context_get(context, state, "min-height", &min_height, nullptr); |
| int w = rect.width() - margin.left - margin.right; |
| int h = std::max( |
| min_height + padding.top + padding.bottom + border.top + border.bottom, |
| 1); |
| int x = margin.left; |
| int y = separator_offset(h); |
| PaintWidget(canvas, gfx::Rect(x, y, w, h), context, BG_RENDER_NORMAL, true); |
| } else { |
| auto context = GetStyleContextFromCss( |
| "GtkMenu#menu GtkMenuItem#menuitem.separator.horizontal"); |
| gboolean wide_separators = false; |
| gint separator_height = 0; |
| gtk_style_context_get_style(context, "wide-separators", &wide_separators, |
| "separator-height", &separator_height, nullptr); |
| // This code was adapted from gtk/gtkmenuitem.c. For some reason, |
| // padding is used as the margin. |
| GtkBorder padding; |
| gtk_style_context_get_padding(context, gtk_style_context_get_state(context), |
| &padding); |
| int w = rect.width() - padding.left - padding.right; |
| int x = rect.x() + padding.left; |
| int h = wide_separators ? separator_height : 1; |
| int y = rect.y() + separator_offset(h); |
| if (wide_separators) { |
| PaintWidget(canvas, gfx::Rect(x, y, w, h), context, BG_RENDER_NONE, true); |
| } else { |
| cc::PaintFlags flags; |
| flags.setColor(GetFgColorFromStyleContext(context)); |
| canvas->drawLine(x, y, x + w, y, flags); |
| } |
| } |
| } |
| |
| void NativeThemeGtk3::PaintFrameTopArea( |
| cc::PaintCanvas* canvas, |
| State state, |
| const gfx::Rect& rect, |
| const FrameTopAreaExtraParams& frame_top_area) const { |
| auto context = GetStyleContextFromCss(frame_top_area.use_custom_frame && |
| GtkVersionCheck(3, 10) |
| ? "#headerbar.header-bar.titlebar" |
| : "GtkMenuBar#menubar"); |
| ApplyCssToContext(context, "* { border-radius: 0px; border-style: none; }"); |
| gtk_style_context_set_state(context, frame_top_area.is_active |
| ? GTK_STATE_FLAG_NORMAL |
| : GTK_STATE_FLAG_BACKDROP); |
| |
| SkBitmap bitmap = |
| GetWidgetBitmap(rect.size(), context, BG_RENDER_RECURSIVE, false); |
| |
| if (frame_top_area.incognito) { |
| bitmap = SkBitmapOperations::CreateHSLShiftedBitmap( |
| bitmap, kDefaultTintFrameIncognito); |
| } |
| |
| canvas->drawBitmap(bitmap, rect.x(), rect.y()); |
| } |
| |
| } // namespace libgtkui |
