/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ /* * This file contains painting functions for each of the gtk2 widgets. * Adapted from the gtkdrawing.c, and gtk+2.0 source. */ #include #include #include #include "gtkdrawing.h" #include "mozilla/Assertions.h" #include "mozilla/ScopeExit.h" #include "prinrval.h" #include "WidgetStyleCache.h" #include "nsString.h" #include "nsDebug.h" #include #include static gboolean checkbox_check_state; static gboolean notebook_has_tab_gap; static ScrollbarGTKMetrics sScrollbarMetrics[2]; static ScrollbarGTKMetrics sActiveScrollbarMetrics[2]; static ToggleGTKMetrics sCheckboxMetrics; static ToggleGTKMetrics sRadioMetrics; static ToggleGTKMetrics sMenuRadioMetrics; static ToggleGTKMetrics sMenuCheckboxMetrics; static ToolbarGTKMetrics sToolbarMetrics; static CSDWindowDecorationSize sToplevelWindowDecorationSize; static CSDWindowDecorationSize sPopupWindowDecorationSize; using mozilla::Span; #define ARROW_UP 0 #define ARROW_DOWN G_PI #define ARROW_RIGHT G_PI_2 #define ARROW_LEFT (G_PI + G_PI_2) #if !GTK_CHECK_VERSION(3, 14, 0) # define GTK_STATE_FLAG_CHECKED (1 << 11) #endif #if 0 // It's used for debugging only to compare Gecko widget style with // the ones used by Gtk+ applications. static void style_path_print(GtkStyleContext *context) { const GtkWidgetPath* path = gtk_style_context_get_path(context); static auto sGtkWidgetPathToStringPtr = (char * (*)(const GtkWidgetPath *)) dlsym(RTLD_DEFAULT, "gtk_widget_path_to_string"); fprintf(stderr, "Style path:\n%s\n\n", sGtkWidgetPathToStringPtr(path)); } #endif static GtkBorder operator-(const GtkBorder& first, const GtkBorder& second) { GtkBorder result; result.left = first.left - second.left; result.right = first.right - second.right; result.top = first.top - second.top; result.bottom = first.bottom - second.bottom; return result; } static GtkBorder operator+(const GtkBorder& first, const GtkBorder& second) { GtkBorder result; result.left = first.left + second.left; result.right = first.right + second.right; result.top = first.top + second.top; result.bottom = first.bottom + second.bottom; return result; } static GtkBorder operator+=(GtkBorder& first, const GtkBorder& second) { first.left += second.left; first.right += second.right; first.top += second.top; first.bottom += second.bottom; return first; } static gint moz_gtk_get_tab_thickness(GtkStyleContext* style); static gint moz_gtk_menu_item_paint(WidgetNodeType widget, cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction); static GtkBorder GetMarginBorderPadding(GtkStyleContext* aStyle); static void Inset(GdkRectangle*, const GtkBorder&); static void InsetByMargin(GdkRectangle*, GtkStyleContext* style); static void moz_gtk_add_style_margin(GtkStyleContext* style, gint* left, gint* top, gint* right, gint* bottom) { GtkBorder margin; gtk_style_context_get_margin(style, gtk_style_context_get_state(style), &margin); *left += margin.left; *right += margin.right; *top += margin.top; *bottom += margin.bottom; } static void moz_gtk_add_style_border(GtkStyleContext* style, gint* left, gint* top, gint* right, gint* bottom) { GtkBorder border; gtk_style_context_get_border(style, gtk_style_context_get_state(style), &border); *left += border.left; *right += border.right; *top += border.top; *bottom += border.bottom; } static void moz_gtk_add_style_padding(GtkStyleContext* style, gint* left, gint* top, gint* right, gint* bottom) { GtkBorder padding; gtk_style_context_get_padding(style, gtk_style_context_get_state(style), &padding); *left += padding.left; *right += padding.right; *top += padding.top; *bottom += padding.bottom; } static void moz_gtk_add_margin_border_padding(GtkStyleContext* style, gint* left, gint* top, gint* right, gint* bottom) { moz_gtk_add_style_margin(style, left, top, right, bottom); moz_gtk_add_style_border(style, left, top, right, bottom); moz_gtk_add_style_padding(style, left, top, right, bottom); } static void moz_gtk_add_border_padding(GtkStyleContext* style, gint* left, gint* top, gint* right, gint* bottom) { moz_gtk_add_style_border(style, left, top, right, bottom); moz_gtk_add_style_padding(style, left, top, right, bottom); } // In case there's an error in Gtk theme and preferred size is zero, // return some sane values to pass mozilla automation tests. // It should not happen in real-life. #define MIN_WIDGET_SIZE 10 static void moz_gtk_sanity_preferred_size(GtkRequisition* requisition) { if (requisition->width <= 0) { requisition->width = MIN_WIDGET_SIZE; } if (requisition->height <= 0) { requisition->height = MIN_WIDGET_SIZE; } } // GetStateFlagsFromGtkWidgetState() can be safely used for the specific // GtkWidgets that set both prelight and active flags. For other widgets, // either the GtkStateFlags or Gecko's GtkWidgetState need to be carefully // adjusted to match GTK behavior. Although GTK sets insensitive and focus // flags in the generic GtkWidget base class, GTK adds prelight and active // flags only to widgets that are expected to demonstrate prelight or active // states. This contrasts with HTML where any element may have :active and // :hover states, and so Gecko's GtkStateFlags do not necessarily map to GTK // flags. Failure to restrict the flags in the same way as GTK can cause // generic CSS selectors from some themes to unintentionally match elements // that are not expected to change appearance on hover or mouse-down. static GtkStateFlags GetStateFlagsFromGtkWidgetState(GtkWidgetState* state) { GtkStateFlags stateFlags = GTK_STATE_FLAG_NORMAL; if (state->disabled) stateFlags = GTK_STATE_FLAG_INSENSITIVE; else { if (state->depressed || state->active) stateFlags = static_cast(stateFlags | GTK_STATE_FLAG_ACTIVE); if (state->inHover) stateFlags = static_cast(stateFlags | GTK_STATE_FLAG_PRELIGHT); if (state->focused) stateFlags = static_cast(stateFlags | GTK_STATE_FLAG_FOCUSED); if (state->backdrop) stateFlags = static_cast(stateFlags | GTK_STATE_FLAG_BACKDROP); } return stateFlags; } static GtkStateFlags GetStateFlagsFromGtkTabFlags(GtkTabFlags flags) { return ((flags & MOZ_GTK_TAB_SELECTED) == 0) ? GTK_STATE_FLAG_NORMAL : GTK_STATE_FLAG_ACTIVE; } gint moz_gtk_init() { if (gtk_major_version > 3 || (gtk_major_version == 3 && gtk_minor_version >= 14)) checkbox_check_state = GTK_STATE_FLAG_CHECKED; else checkbox_check_state = GTK_STATE_FLAG_ACTIVE; moz_gtk_refresh(); return MOZ_GTK_SUCCESS; } void moz_gtk_refresh() { if (gtk_check_version(3, 12, 0) == nullptr && gtk_check_version(3, 20, 0) != nullptr) { // Deprecated for Gtk >= 3.20+ GtkStyleContext* style = GetStyleContext(MOZ_GTK_TAB_TOP); gtk_style_context_get_style(style, "has-tab-gap", ¬ebook_has_tab_gap, NULL); } else { notebook_has_tab_gap = true; } sScrollbarMetrics[GTK_ORIENTATION_HORIZONTAL].initialized = false; sScrollbarMetrics[GTK_ORIENTATION_VERTICAL].initialized = false; sActiveScrollbarMetrics[GTK_ORIENTATION_HORIZONTAL].initialized = false; sActiveScrollbarMetrics[GTK_ORIENTATION_VERTICAL].initialized = false; sCheckboxMetrics.initialized = false; sRadioMetrics.initialized = false; sMenuCheckboxMetrics.initialized = false; sMenuRadioMetrics.initialized = false; sToolbarMetrics.initialized = false; sToplevelWindowDecorationSize.initialized = false; sPopupWindowDecorationSize.initialized = false; /* This will destroy all of our widgets */ ResetWidgetCache(); } static gint moz_gtk_get_focus_outline_size(GtkStyleContext* style, gint* focus_h_width, gint* focus_v_width) { GtkBorder border; gtk_style_context_get_border(style, gtk_style_context_get_state(style), &border); *focus_h_width = border.left; *focus_v_width = border.top; return MOZ_GTK_SUCCESS; } gint moz_gtk_get_focus_outline_size(gint* focus_h_width, gint* focus_v_width) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_ENTRY); moz_gtk_get_focus_outline_size(style, focus_h_width, focus_v_width); return MOZ_GTK_SUCCESS; } gint moz_gtk_menuitem_get_horizontal_padding(gint* horizontal_padding) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_MENUITEM); gtk_style_context_get_style(style, "horizontal-padding", horizontal_padding, nullptr); return MOZ_GTK_SUCCESS; } gint moz_gtk_checkmenuitem_get_horizontal_padding(gint* horizontal_padding) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_CHECKMENUITEM); gtk_style_context_get_style(style, "horizontal-padding", horizontal_padding, nullptr); return MOZ_GTK_SUCCESS; } gint moz_gtk_button_get_default_overflow(gint* border_top, gint* border_left, gint* border_bottom, gint* border_right) { GtkBorder* default_outside_border; GtkStyleContext* style = GetStyleContext(MOZ_GTK_BUTTON); gtk_style_context_get_style(style, "default-outside-border", &default_outside_border, NULL); if (default_outside_border) { *border_top = default_outside_border->top; *border_left = default_outside_border->left; *border_bottom = default_outside_border->bottom; *border_right = default_outside_border->right; gtk_border_free(default_outside_border); } else { *border_top = *border_left = *border_bottom = *border_right = 0; } return MOZ_GTK_SUCCESS; } static gint moz_gtk_button_get_default_border(gint* border_top, gint* border_left, gint* border_bottom, gint* border_right) { GtkBorder* default_border; GtkStyleContext* style = GetStyleContext(MOZ_GTK_BUTTON); gtk_style_context_get_style(style, "default-border", &default_border, NULL); if (default_border) { *border_top = default_border->top; *border_left = default_border->left; *border_bottom = default_border->bottom; *border_right = default_border->right; gtk_border_free(default_border); } else { /* see gtkbutton.c */ *border_top = *border_left = *border_bottom = *border_right = 1; } return MOZ_GTK_SUCCESS; } gint moz_gtk_splitter_get_metrics(gint orientation, gint* size) { GtkStyleContext* style; if (orientation == GTK_ORIENTATION_HORIZONTAL) { style = GetStyleContext(MOZ_GTK_SPLITTER_HORIZONTAL); } else { style = GetStyleContext(MOZ_GTK_SPLITTER_VERTICAL); } gtk_style_context_get_style(style, "handle_size", size, NULL); return MOZ_GTK_SUCCESS; } static void CalculateToolbarButtonMetrics(WidgetNodeType aAppearance, ToolbarButtonGTKMetrics* aMetrics) { gint iconWidth, iconHeight; if (!gtk_icon_size_lookup(GTK_ICON_SIZE_MENU, &iconWidth, &iconHeight)) { NS_WARNING("Failed to get Gtk+ icon size for titlebar button!"); // Use some reasonable fallback size iconWidth = 16; iconHeight = 16; } GtkStyleContext* style = GetStyleContext(aAppearance); gint width = 0, height = 0; if (gtk_check_version(3, 20, 0) == nullptr) { gtk_style_context_get(style, gtk_style_context_get_state(style), "min-width", &width, "min-height", &height, NULL); } // Cover cases when min-width/min-height is not set, it's invalid // or we're running on Gtk+ < 3.20. if (width < iconWidth) width = iconWidth; if (height < iconHeight) height = iconHeight; gint left = 0, top = 0, right = 0, bottom = 0; moz_gtk_add_border_padding(style, &left, &top, &right, &bottom); // Button size is calculated as min-width/height + border/padding. width += left + right; height += top + bottom; // Place icon at button center. aMetrics->iconXPosition = (width - iconWidth) / 2; aMetrics->iconYPosition = (height - iconHeight) / 2; aMetrics->minSizeWithBorderMargin.width = width; aMetrics->minSizeWithBorderMargin.height = height; } // We support LTR layout only here for now. static void CalculateToolbarButtonSpacing(WidgetNodeType aAppearance, ToolbarButtonGTKMetrics* aMetrics) { GtkStyleContext* style = GetStyleContext(aAppearance); gtk_style_context_get_margin(style, gtk_style_context_get_state(style), &aMetrics->buttonMargin); // Get titlebar spacing, a default one is 6 pixels (gtk/gtkheaderbar.c) gint buttonSpacing = 6; g_object_get(GetWidget(MOZ_GTK_HEADER_BAR), "spacing", &buttonSpacing, nullptr); // We apply spacing as a margin equaly to both adjacent buttons. buttonSpacing /= 2; if (!aMetrics->firstButton) { aMetrics->buttonMargin.left += buttonSpacing; } if (!aMetrics->lastButton) { aMetrics->buttonMargin.right += buttonSpacing; } aMetrics->minSizeWithBorderMargin.width += aMetrics->buttonMargin.right + aMetrics->buttonMargin.left; aMetrics->minSizeWithBorderMargin.height += aMetrics->buttonMargin.top + aMetrics->buttonMargin.bottom; } size_t GetGtkHeaderBarButtonLayout(Span aButtonLayout, bool* aReversedButtonsPlacement) { gchar* decorationLayoutSetting = nullptr; GtkSettings* settings = gtk_settings_get_for_screen(gdk_screen_get_default()); g_object_get(settings, "gtk-decoration-layout", &decorationLayoutSetting, nullptr); auto free = mozilla::MakeScopeExit([&] { g_free(decorationLayoutSetting); }); // Use a default layout const gchar* decorationLayout = "menu:minimize,maximize,close"; if (decorationLayoutSetting) { decorationLayout = decorationLayoutSetting; } // "minimize,maximize,close:" layout means buttons are on the opposite // titlebar side. close button is always there. if (aReversedButtonsPlacement) { const char* closeButton = strstr(decorationLayout, "close"); const char* separator = strchr(decorationLayout, ':'); *aReversedButtonsPlacement = closeButton && separator && closeButton < separator; } // We check what position a button string is stored in decorationLayout. // // decorationLayout gets its value from the GNOME preference: // org.gnome.desktop.vm.preferences.button-layout via the // gtk-decoration-layout property. // // Documentation of the gtk-decoration-layout property can be found here: // https://developer.gnome.org/gtk3/stable/GtkSettings.html#GtkSettings--gtk-decoration-layout if (aButtonLayout.IsEmpty()) { return 0; } nsDependentCSubstring layout(decorationLayout, strlen(decorationLayout)); bool right = false; size_t activeButtons = 0; for (const auto& part : layout.Split(':')) { for (const auto& button : part.Split(',')) { if (button.EqualsLiteral("close")) { aButtonLayout[activeButtons++] = {MOZ_GTK_HEADER_BAR_BUTTON_CLOSE, right}; } else if (button.EqualsLiteral("minimize")) { aButtonLayout[activeButtons++] = {MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE, right}; } else if (button.EqualsLiteral("maximize")) { aButtonLayout[activeButtons++] = {MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE, right}; } if (activeButtons == aButtonLayout.Length()) { return activeButtons; } } right = true; } return activeButtons; } static void EnsureToolbarMetrics(void) { if (!sToolbarMetrics.initialized) { // Make sure we have clean cache after theme reset, etc. memset(&sToolbarMetrics, 0, sizeof(sToolbarMetrics)); // We're running on old Gtk+ version. Leave the cache empty // which means all buttons are disabled. if (gtk_check_version(3, 10, 0) != nullptr) { sToolbarMetrics.initialized = true; return; } // Calculate titlebar button visibility and positions. ButtonLayout aButtonLayout[TOOLBAR_BUTTONS]; size_t activeButtonNums = GetGtkHeaderBarButtonLayout(mozilla::MakeSpan(aButtonLayout), nullptr); for (size_t i = 0; i < activeButtonNums; i++) { int buttonIndex = (aButtonLayout[i].mType - MOZ_GTK_HEADER_BAR_BUTTON_CLOSE); ToolbarButtonGTKMetrics* metrics = sToolbarMetrics.button + buttonIndex; metrics->visible = true; // Mark first button if (!i) { metrics->firstButton = true; } // Mark last button. if (i == (activeButtonNums - 1)) { metrics->lastButton = true; } CalculateToolbarButtonMetrics(aButtonLayout[i].mType, metrics); CalculateToolbarButtonSpacing(aButtonLayout[i].mType, metrics); } sToolbarMetrics.initialized = true; } } const ToolbarButtonGTKMetrics* GetToolbarButtonMetrics( WidgetNodeType aAppearance) { EnsureToolbarMetrics(); int buttonIndex = (aAppearance - MOZ_GTK_HEADER_BAR_BUTTON_CLOSE); NS_ASSERTION(buttonIndex >= 0 && buttonIndex <= TOOLBAR_BUTTONS, "GetToolbarButtonMetrics(): Wrong titlebar button!"); return sToolbarMetrics.button + buttonIndex; } static gint moz_gtk_window_paint(cairo_t* cr, GdkRectangle* rect, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_WINDOW, direction); gtk_style_context_save(style); gtk_style_context_add_class(style, GTK_STYLE_CLASS_BACKGROUND); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_style_context_restore(style); return MOZ_GTK_SUCCESS; } static gint moz_gtk_button_paint(cairo_t* cr, const GdkRectangle* rect, GtkWidgetState* state, GtkReliefStyle relief, GtkWidget* widget, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style = gtk_widget_get_style_context(widget); gint x = rect->x, y = rect->y, width = rect->width, height = rect->height; gtk_widget_set_direction(widget, direction); gtk_style_context_save(style); StyleContextSetScale(style, state->scale); gtk_style_context_set_state(style, state_flags); if (state->isDefault && relief == GTK_RELIEF_NORMAL) { /* handle default borders both outside and inside the button */ gint default_top, default_left, default_bottom, default_right; moz_gtk_button_get_default_overflow(&default_top, &default_left, &default_bottom, &default_right); x -= default_left; y -= default_top; width += default_left + default_right; height += default_top + default_bottom; gtk_render_background(style, cr, x, y, width, height); gtk_render_frame(style, cr, x, y, width, height); moz_gtk_button_get_default_border(&default_top, &default_left, &default_bottom, &default_right); x += default_left; y += default_top; width -= (default_left + default_right); height -= (default_top + default_bottom); } else if (relief != GTK_RELIEF_NONE || state->depressed || (state_flags & GTK_STATE_FLAG_PRELIGHT)) { /* the following line can trigger an assertion (Crux theme) file ../../gdk/gdkwindow.c: line 1846 (gdk_window_clear_area): assertion `GDK_IS_WINDOW (window)' failed */ gtk_render_background(style, cr, x, y, width, height); gtk_render_frame(style, cr, x, y, width, height); } if (state->focused) { GtkBorder border; gtk_style_context_get_border(style, state_flags, &border); x += border.left; y += border.top; width -= (border.left + border.right); height -= (border.top + border.bottom); gtk_render_focus(style, cr, x, y, width, height); } gtk_style_context_restore(style); return MOZ_GTK_SUCCESS; } static gint moz_gtk_header_bar_button_paint(cairo_t* cr, const GdkRectangle* aRect, GtkWidgetState* state, GtkReliefStyle relief, WidgetNodeType aIconWidgetType, GtkTextDirection direction) { WidgetNodeType buttonWidgetType = (aIconWidgetType == MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE) ? MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE : aIconWidgetType; GdkRectangle rect = *aRect; // We need to inset our calculated margin because it also // contains titlebar button spacing. const ToolbarButtonGTKMetrics* metrics = GetToolbarButtonMetrics(buttonWidgetType); Inset(&rect, metrics->buttonMargin); GtkWidget* buttonWidget = GetWidget(buttonWidgetType); moz_gtk_button_paint(cr, &rect, state, relief, buttonWidget, direction); GtkWidget* iconWidget = gtk_bin_get_child(GTK_BIN(GetWidget(aIconWidgetType))); cairo_surface_t* surface = GetWidgetIconSurface(iconWidget, state->scale); if (surface) { GtkStyleContext* style = gtk_widget_get_style_context(buttonWidget); GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); gtk_style_context_save(style); StyleContextSetScale(style, state->scale); gtk_style_context_set_state(style, state_flags); const ToolbarButtonGTKMetrics* metrics = GetToolbarButtonMetrics(buttonWidgetType); /* This is available since Gtk+ 3.10 as well as GtkHeaderBar */ static auto sGtkRenderIconSurfacePtr = (void (*)(GtkStyleContext*, cairo_t*, cairo_surface_t*, gdouble, gdouble))dlsym(RTLD_DEFAULT, "gtk_render_icon_surface"); sGtkRenderIconSurfacePtr(style, cr, surface, rect.x + metrics->iconXPosition, rect.y + metrics->iconYPosition); gtk_style_context_restore(style); } return MOZ_GTK_SUCCESS; } static gint moz_gtk_toggle_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, gboolean selected, gboolean inconsistent, gboolean isradio, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); gint x, y, width, height; GtkStyleContext* style; // We need to call this before GetStyleContext, because otherwise we would // reset state flags const ToggleGTKMetrics* metrics = GetToggleMetrics(isradio ? MOZ_GTK_RADIOBUTTON : MOZ_GTK_CHECKBUTTON); // Clamp the rect and paint it center aligned in the rect. x = rect->x; y = rect->y; width = rect->width; height = rect->height; if (rect->width < rect->height) { y = rect->y + (rect->height - rect->width) / 2; height = rect->width; } if (rect->height < rect->width) { x = rect->x + (rect->width - rect->height) / 2; width = rect->height; } if (selected) state_flags = static_cast(state_flags | checkbox_check_state); if (inconsistent) state_flags = static_cast(state_flags | GTK_STATE_FLAG_INCONSISTENT); style = GetStyleContext(isradio ? MOZ_GTK_RADIOBUTTON : MOZ_GTK_CHECKBUTTON, state->scale, direction, state_flags); if (gtk_check_version(3, 20, 0) == nullptr) { gtk_render_background(style, cr, x, y, width, height); gtk_render_frame(style, cr, x, y, width, height); // Indicator is inset by the toggle's padding and border. gint indicator_x = x + metrics->borderAndPadding.left; gint indicator_y = y + metrics->borderAndPadding.top; gint indicator_width = metrics->minSizeWithBorder.width - metrics->borderAndPadding.left - metrics->borderAndPadding.right; gint indicator_height = metrics->minSizeWithBorder.height - metrics->borderAndPadding.top - metrics->borderAndPadding.bottom; if (isradio) { gtk_render_option(style, cr, indicator_x, indicator_y, indicator_width, indicator_height); } else { gtk_render_check(style, cr, indicator_x, indicator_y, indicator_width, indicator_height); } } else { if (isradio) { gtk_render_option(style, cr, x, y, width, height); } else { gtk_render_check(style, cr, x, y, width, height); } } return MOZ_GTK_SUCCESS; } static gint calculate_button_inner_rect(GtkWidget* button, const GdkRectangle* rect, GdkRectangle* inner_rect, GtkTextDirection direction) { GtkStyleContext* style; GtkBorder border; GtkBorder padding = {0, 0, 0, 0}; style = gtk_widget_get_style_context(button); /* This mirrors gtkbutton's child positioning */ gtk_style_context_get_border(style, gtk_style_context_get_state(style), &border); gtk_style_context_get_padding(style, gtk_style_context_get_state(style), &padding); inner_rect->x = rect->x + border.left + padding.left; inner_rect->y = rect->y + padding.top + border.top; inner_rect->width = MAX(1, rect->width - padding.left - padding.right - border.left * 2); inner_rect->height = MAX(1, rect->height - padding.top - padding.bottom - border.top * 2); return MOZ_GTK_SUCCESS; } static gint calculate_arrow_rect(GtkWidget* arrow, GdkRectangle* rect, GdkRectangle* arrow_rect, GtkTextDirection direction) { /* defined in gtkarrow.c */ gfloat arrow_scaling = 0.7; gfloat xalign, xpad; gint extent; gint mxpad, mypad; gfloat mxalign, myalign; GtkMisc* misc = GTK_MISC(arrow); gtk_style_context_get_style(gtk_widget_get_style_context(arrow), "arrow_scaling", &arrow_scaling, NULL); gtk_misc_get_padding(misc, &mxpad, &mypad); extent = MIN((rect->width - mxpad * 2), (rect->height - mypad * 2)) * arrow_scaling; gtk_misc_get_alignment(misc, &mxalign, &myalign); xalign = direction == GTK_TEXT_DIR_LTR ? mxalign : 1.0 - mxalign; xpad = mxpad + (rect->width - extent) * xalign; arrow_rect->x = direction == GTK_TEXT_DIR_LTR ? floor(rect->x + xpad) : ceil(rect->x + xpad); arrow_rect->y = floor(rect->y + mypad + ((rect->height - extent) * myalign)); arrow_rect->width = arrow_rect->height = extent; return MOZ_GTK_SUCCESS; } static MozGtkSize GetMinContentBox(GtkStyleContext* style) { GtkStateFlags state_flags = gtk_style_context_get_state(style); gint width, height; gtk_style_context_get(style, state_flags, "min-width", &width, "min-height", &height, nullptr); return {width, height}; } /** * Get minimum widget size as sum of margin, padding, border and * min-width/min-height. */ static void moz_gtk_get_widget_min_size(GtkStyleContext* style, int* width, int* height) { GtkStateFlags state_flags = gtk_style_context_get_state(style); gtk_style_context_get(style, state_flags, "min-height", height, "min-width", width, nullptr); GtkBorder border, padding, margin; gtk_style_context_get_border(style, state_flags, &border); gtk_style_context_get_padding(style, state_flags, &padding); gtk_style_context_get_margin(style, state_flags, &margin); *width += border.left + border.right + margin.left + margin.right + padding.left + padding.right; *height += border.top + border.bottom + margin.top + margin.bottom + padding.top + padding.bottom; } static MozGtkSize GetMinMarginBox(GtkStyleContext* style) { gint width, height; moz_gtk_get_widget_min_size(style, &width, &height); return {width, height}; } static void Inset(GdkRectangle* rect, const GtkBorder& aBorder) { rect->x += aBorder.left; rect->y += aBorder.top; rect->width -= aBorder.left + aBorder.right; rect->height -= aBorder.top + aBorder.bottom; } // Inset a rectangle by the margins specified in a style context. static void InsetByMargin(GdkRectangle* rect, GtkStyleContext* style) { GtkBorder margin; gtk_style_context_get_margin(style, gtk_style_context_get_state(style), &margin); Inset(rect, margin); } // Inset a rectangle by the border and padding specified in a style context. static void InsetByBorderPadding(GdkRectangle* rect, GtkStyleContext* style) { GtkStateFlags state = gtk_style_context_get_state(style); GtkBorder padding, border; gtk_style_context_get_padding(style, state, &padding); Inset(rect, padding); gtk_style_context_get_border(style, state, &border); Inset(rect, border); } static gint moz_gtk_scrollbar_button_paint(cairo_t* cr, const GdkRectangle* aRect, GtkWidgetState* state, GtkScrollbarButtonFlags flags, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GdkRectangle arrow_rect; gdouble arrow_angle; GtkStyleContext* style; gint arrow_displacement_x, arrow_displacement_y; GtkWidget* scrollbar = GetWidget(flags & MOZ_GTK_STEPPER_VERTICAL ? MOZ_GTK_SCROLLBAR_VERTICAL : MOZ_GTK_SCROLLBAR_HORIZONTAL); gtk_widget_set_direction(scrollbar, direction); if (flags & MOZ_GTK_STEPPER_VERTICAL) { arrow_angle = (flags & MOZ_GTK_STEPPER_DOWN) ? ARROW_DOWN : ARROW_UP; } else { arrow_angle = (flags & MOZ_GTK_STEPPER_DOWN) ? ARROW_RIGHT : ARROW_LEFT; } style = gtk_widget_get_style_context(scrollbar); gtk_style_context_save(style); gtk_style_context_add_class(style, GTK_STYLE_CLASS_BUTTON); StyleContextSetScale(style, state->scale); gtk_style_context_set_state(style, state_flags); if (arrow_angle == ARROW_RIGHT) { gtk_style_context_add_class(style, GTK_STYLE_CLASS_RIGHT); } else if (arrow_angle == ARROW_DOWN) { gtk_style_context_add_class(style, GTK_STYLE_CLASS_BOTTOM); } else if (arrow_angle == ARROW_LEFT) { gtk_style_context_add_class(style, GTK_STYLE_CLASS_LEFT); } else { gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOP); } GdkRectangle rect = *aRect; if (gtk_check_version(3, 20, 0) == nullptr) { // The "trough-border" is not used since GTK 3.20. The stepper margin // box occupies the full width of the "contents" gadget content box. InsetByMargin(&rect, style); } else { // Scrollbar button has to be inset by trough_border because its DOM // element is filling width of vertical scrollbar's track (or height // in case of horizontal scrollbars). GtkOrientation orientation = flags & MOZ_GTK_STEPPER_VERTICAL ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL; const ScrollbarGTKMetrics* metrics = GetScrollbarMetrics(orientation); if (flags & MOZ_GTK_STEPPER_VERTICAL) { rect.x += metrics->border.track.left; rect.width = metrics->size.thumb.width; } else { rect.y += metrics->border.track.top; rect.height = metrics->size.thumb.height; } } gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height); gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height); arrow_rect.width = rect.width / 2; arrow_rect.height = rect.height / 2; gfloat arrow_scaling; gtk_style_context_get_style(style, "arrow-scaling", &arrow_scaling, NULL); gdouble arrow_size = MIN(rect.width, rect.height) * arrow_scaling; arrow_rect.x = rect.x + (rect.width - arrow_size) / 2; arrow_rect.y = rect.y + (rect.height - arrow_size) / 2; if (state_flags & GTK_STATE_FLAG_ACTIVE) { gtk_style_context_get_style(style, "arrow-displacement-x", &arrow_displacement_x, "arrow-displacement-y", &arrow_displacement_y, NULL); arrow_rect.x += arrow_displacement_x; arrow_rect.y += arrow_displacement_y; } gtk_render_arrow(style, cr, arrow_angle, arrow_rect.x, arrow_rect.y, arrow_size); gtk_style_context_restore(style); return MOZ_GTK_SUCCESS; } static void moz_gtk_update_scrollbar_style(GtkStyleContext* style, WidgetNodeType widget, GtkTextDirection direction) { if (widget == MOZ_GTK_SCROLLBAR_HORIZONTAL) { gtk_style_context_add_class(style, GTK_STYLE_CLASS_BOTTOM); } else { if (direction == GTK_TEXT_DIR_LTR) { gtk_style_context_add_class(style, GTK_STYLE_CLASS_RIGHT); gtk_style_context_remove_class(style, GTK_STYLE_CLASS_LEFT); } else { gtk_style_context_add_class(style, GTK_STYLE_CLASS_LEFT); gtk_style_context_remove_class(style, GTK_STYLE_CLASS_RIGHT); } } } static void moz_gtk_draw_styled_frame(GtkStyleContext* style, cairo_t* cr, const GdkRectangle* aRect, bool drawFocus) { GdkRectangle rect = *aRect; if (gtk_check_version(3, 6, 0) == nullptr) { InsetByMargin(&rect, style); } gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height); gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height); if (drawFocus) { gtk_render_focus(style, cr, rect.x, rect.y, rect.width, rect.height); } } static gint moz_gtk_scrollbar_trough_paint(WidgetNodeType widget, cairo_t* cr, const GdkRectangle* aRect, GtkWidgetState* state, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GdkRectangle rect = *aRect; GtkStyleContext* style; if (gtk_get_minor_version() >= 20) { WidgetNodeType thumb = widget == MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL ? MOZ_GTK_SCROLLBAR_THUMB_VERTICAL : MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL; MozGtkSize thumbSize = GetMinMarginBox(GetStyleContext(thumb)); style = GetStyleContext(widget, state->scale, direction, state_flags); MozGtkSize trackSize = GetMinContentBox(style); trackSize.Include(thumbSize); trackSize += GetMarginBorderPadding(style); // Gecko's trough |aRect| fills available breadth, but GTK's trough is // centered in the contents_gadget. The centering here round left // and up, like gtk_box_gadget_allocate_child(). if (widget == MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL) { rect.x += (rect.width - trackSize.width) / 2; rect.width = trackSize.width; } else { rect.y += (rect.height - trackSize.height) / 2; rect.height = trackSize.height; } } else { style = GetStyleContext(widget, state->scale, direction, state_flags); } moz_gtk_draw_styled_frame(style, cr, &rect, state->focused); return MOZ_GTK_SUCCESS; } static gint moz_gtk_scrollbar_paint(WidgetNodeType widget, cairo_t* cr, const GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style = GetStyleContext(widget, state->scale, direction, state_flags); moz_gtk_update_scrollbar_style(style, widget, direction); moz_gtk_draw_styled_frame(style, cr, rect, state->focused); style = GetStyleContext((widget == MOZ_GTK_SCROLLBAR_HORIZONTAL) ? MOZ_GTK_SCROLLBAR_CONTENTS_HORIZONTAL : MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL, state->scale, direction, state_flags); moz_gtk_draw_styled_frame(style, cr, rect, state->focused); return MOZ_GTK_SUCCESS; } static gint moz_gtk_scrollbar_thumb_paint(WidgetNodeType widget, cairo_t* cr, const GdkRectangle* aRect, GtkWidgetState* state, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style = GetStyleContext(widget, state->scale, direction, state_flags); GtkOrientation orientation = (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL; GdkRectangle rect = *aRect; const ScrollbarGTKMetrics* metrics = (state->depressed || state->active || state->inHover) ? GetActiveScrollbarMetrics(orientation) : GetScrollbarMetrics(orientation); Inset(&rect, metrics->margin.thumb); gtk_render_slider(style, cr, rect.x, rect.y, rect.width, rect.height, orientation); return MOZ_GTK_SUCCESS; } static gint moz_gtk_inner_spin_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_SPINBUTTON, state->scale, direction, GetStateFlagsFromGtkWidgetState(state)); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); /* hard code these values */ GdkRectangle arrow_rect; arrow_rect.width = 6; arrow_rect.height = 6; // align spin to the left arrow_rect.x = rect->x; // up button arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2 - 3; gtk_render_arrow(style, cr, ARROW_UP, arrow_rect.x, arrow_rect.y, arrow_rect.width); // down button arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2 + 3; gtk_render_arrow(style, cr, ARROW_DOWN, arrow_rect.x, arrow_rect.y, arrow_rect.width); return MOZ_GTK_SUCCESS; } static gint moz_gtk_spin_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_SPINBUTTON, state->scale, direction); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_spin_updown_paint(cairo_t* cr, GdkRectangle* rect, gboolean isDown, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_SPINBUTTON, state->scale, direction, GetStateFlagsFromGtkWidgetState(state)); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); /* hard code these values */ GdkRectangle arrow_rect; arrow_rect.width = 6; arrow_rect.height = 6; arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2; arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2; arrow_rect.y += isDown ? -1 : 1; gtk_render_arrow(style, cr, isDown ? ARROW_DOWN : ARROW_UP, arrow_rect.x, arrow_rect.y, arrow_rect.width); return MOZ_GTK_SUCCESS; } /* See gtk_range_draw() for reference. */ static gint moz_gtk_scale_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkOrientation flags, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); gint x, y, width, height, min_width, min_height; GtkStyleContext* style; GtkBorder margin; moz_gtk_get_scale_metrics(flags, &min_width, &min_height); WidgetNodeType widget = (flags == GTK_ORIENTATION_HORIZONTAL) ? MOZ_GTK_SCALE_TROUGH_HORIZONTAL : MOZ_GTK_SCALE_TROUGH_VERTICAL; style = GetStyleContext(widget, state->scale, direction, state_flags); gtk_style_context_get_margin(style, state_flags, &margin); // Clamp the dimension perpendicular to the direction that the slider crosses // to the minimum size. if (flags == GTK_ORIENTATION_HORIZONTAL) { width = rect->width - (margin.left + margin.right); height = min_height - (margin.top + margin.bottom); x = rect->x + margin.left; y = rect->y + (rect->height - height) / 2; } else { width = min_width - (margin.left + margin.right); height = rect->height - (margin.top + margin.bottom); x = rect->x + (rect->width - width) / 2; y = rect->y + margin.top; } gtk_render_background(style, cr, x, y, width, height); gtk_render_frame(style, cr, x, y, width, height); if (state->focused) gtk_render_focus(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_scale_thumb_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkOrientation flags, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style; gint thumb_width, thumb_height, x, y; /* determine the thumb size, and position the thumb in the center in the * opposite axis */ if (flags == GTK_ORIENTATION_HORIZONTAL) { moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_HORIZONTAL, &thumb_width, &thumb_height); x = rect->x; y = rect->y + (rect->height - thumb_height) / 2; } else { moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_VERTICAL, &thumb_height, &thumb_width); x = rect->x + (rect->width - thumb_width) / 2; y = rect->y; } WidgetNodeType widget = (flags == GTK_ORIENTATION_HORIZONTAL) ? MOZ_GTK_SCALE_THUMB_HORIZONTAL : MOZ_GTK_SCALE_THUMB_VERTICAL; style = GetStyleContext(widget, state->scale, direction, state_flags); gtk_render_slider(style, cr, x, y, thumb_width, thumb_height, flags); return MOZ_GTK_SUCCESS; } static gint moz_gtk_gripper_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_GRIPPER, state->scale, direction, GetStateFlagsFromGtkWidgetState(state)); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_hpaned_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_SPLITTER_SEPARATOR_HORIZONTAL, state->scale, GTK_TEXT_DIR_LTR, GetStateFlagsFromGtkWidgetState(state)); gtk_render_handle(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_vpaned_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_SPLITTER_SEPARATOR_VERTICAL, state->scale, GTK_TEXT_DIR_LTR, GetStateFlagsFromGtkWidgetState(state)); gtk_render_handle(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } // See gtk_entry_draw() for reference. static gint moz_gtk_entry_paint(cairo_t* cr, const GdkRectangle* aRect, GtkWidgetState* state, GtkStyleContext* style, WidgetNodeType widget) { // StyleAppearance::FocusOutline int draw_focus_outline_only = state->depressed; GdkRectangle rect = *aRect; if (draw_focus_outline_only) { // Inflate the given 'rect' with the focus outline size. gint h, v; moz_gtk_get_focus_outline_size(style, &h, &v); rect.x -= h; rect.width += 2 * h; rect.y -= v; rect.height += 2 * v; } else { gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height); } // Paint the border, except for 'menulist-textfield' that isn't focused: if (widget != MOZ_GTK_DROPDOWN_ENTRY || state->focused) { gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height); } return MOZ_GTK_SUCCESS; } static gint moz_gtk_text_view_paint(cairo_t* cr, GdkRectangle* aRect, GtkWidgetState* state, GtkTextDirection direction) { // GtkTextView and GtkScrolledWindow do not set active and prelight flags. // The use of focus with MOZ_GTK_SCROLLED_WINDOW here is questionable // because a parent widget will not have focus when its child GtkTextView // has focus, but perhaps this may help identify a focused textarea with // some themes as GtkTextView backgrounds do not typically render // differently with focus. GtkStateFlags state_flags = state->disabled ? GTK_STATE_FLAG_INSENSITIVE : state->focused ? GTK_STATE_FLAG_FOCUSED : GTK_STATE_FLAG_NORMAL; GtkStyleContext* style_frame = GetStyleContext( MOZ_GTK_SCROLLED_WINDOW, state->scale, direction, state_flags); gtk_render_frame(style_frame, cr, aRect->x, aRect->y, aRect->width, aRect->height); GdkRectangle rect = *aRect; InsetByBorderPadding(&rect, style_frame); GtkStyleContext* style = GetStyleContext(MOZ_GTK_TEXT_VIEW, state->scale, direction, state_flags); gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height); // There is a separate "text" window, which usually provides the // background behind the text. However, this is transparent in Ambiance // for GTK 3.20, in which case the MOZ_GTK_TEXT_VIEW background is // visible. style = GetStyleContext(MOZ_GTK_TEXT_VIEW_TEXT, state->scale, direction, state_flags); gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_treeview_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { gint xthickness, ythickness; GtkStyleContext* style; GtkStyleContext* style_tree; GtkStateFlags state_flags; GtkBorder border; /* only handle disabled and normal states, otherwise the whole background * area will be painted differently with other states */ state_flags = state->disabled ? GTK_STATE_FLAG_INSENSITIVE : GTK_STATE_FLAG_NORMAL; style = GetStyleContext(MOZ_GTK_SCROLLED_WINDOW, state->scale, direction); gtk_style_context_get_border(style, state_flags, &border); xthickness = border.left; ythickness = border.top; style_tree = GetStyleContext(MOZ_GTK_TREEVIEW_VIEW, state->scale, direction); gtk_render_background(style_tree, cr, rect->x + xthickness, rect->y + ythickness, rect->width - 2 * xthickness, rect->height - 2 * ythickness); style = GetStyleContext(MOZ_GTK_SCROLLED_WINDOW, state->scale, direction); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_tree_header_cell_paint(cairo_t* cr, const GdkRectangle* aRect, GtkWidgetState* state, gboolean isSorted, GtkTextDirection direction) { moz_gtk_button_paint(cr, aRect, state, GTK_RELIEF_NORMAL, GetWidget(MOZ_GTK_TREE_HEADER_CELL), direction); return MOZ_GTK_SUCCESS; } static gint moz_gtk_tree_header_sort_arrow_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkArrowType arrow_type, GtkTextDirection direction) { GdkRectangle arrow_rect; gdouble arrow_angle; GtkStyleContext* style; /* hard code these values */ arrow_rect.width = 11; arrow_rect.height = 11; arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2; arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2; style = GetStyleContext(MOZ_GTK_TREE_HEADER_SORTARROW, state->scale, direction, GetStateFlagsFromGtkWidgetState(state)); switch (arrow_type) { case GTK_ARROW_LEFT: arrow_angle = ARROW_LEFT; break; case GTK_ARROW_RIGHT: arrow_angle = ARROW_RIGHT; break; case GTK_ARROW_DOWN: arrow_angle = ARROW_DOWN; break; default: arrow_angle = ARROW_UP; break; } if (arrow_type != GTK_ARROW_NONE) gtk_render_arrow(style, cr, arrow_angle, arrow_rect.x, arrow_rect.y, arrow_rect.width); return MOZ_GTK_SUCCESS; } /* See gtk_expander_paint() for reference. */ static gint moz_gtk_treeview_expander_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkExpanderStyle expander_state, GtkTextDirection direction) { /* Because the frame we get is of the entire treeview, we can't get the * precise event state of one expander, thus rendering hover and active * feedback useless. */ GtkStateFlags state_flags = state->disabled ? GTK_STATE_FLAG_INSENSITIVE : GTK_STATE_FLAG_NORMAL; if (state->inHover) state_flags = static_cast(state_flags | GTK_STATE_FLAG_PRELIGHT); if (state->selected) state_flags = static_cast(state_flags | GTK_STATE_FLAG_SELECTED); /* GTK_STATE_FLAG_ACTIVE controls expanded/colapsed state rendering * in gtk_render_expander() */ if (expander_state == GTK_EXPANDER_EXPANDED) state_flags = static_cast(state_flags | checkbox_check_state); else state_flags = static_cast(state_flags & ~(checkbox_check_state)); GtkStyleContext* style = GetStyleContext( MOZ_GTK_TREEVIEW_EXPANDER, state->scale, direction, state_flags); gtk_render_expander(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } /* See gtk_separator_draw() for reference. */ static gint moz_gtk_combo_box_paint(cairo_t* cr, const GdkRectangle* aRect, GtkWidgetState* state, GtkTextDirection direction) { GdkRectangle arrow_rect, real_arrow_rect; gint separator_width; gboolean wide_separators; GtkStyleContext* style; GtkRequisition arrow_req; GtkWidget* comboBoxButton = GetWidget(MOZ_GTK_COMBOBOX_BUTTON); GtkWidget* comboBoxArrow = GetWidget(MOZ_GTK_COMBOBOX_ARROW); /* Also sets the direction on gComboBoxButtonWidget, which is then * inherited by the separator and arrow */ moz_gtk_button_paint(cr, aRect, state, GTK_RELIEF_NORMAL, comboBoxButton, direction); calculate_button_inner_rect(comboBoxButton, aRect, &arrow_rect, direction); /* Now arrow_rect contains the inner rect ; we want to correct the width * to what the arrow needs (see gtk_combo_box_size_allocate) */ gtk_widget_get_preferred_size(comboBoxArrow, NULL, &arrow_req); moz_gtk_sanity_preferred_size(&arrow_req); if (direction == GTK_TEXT_DIR_LTR) arrow_rect.x += arrow_rect.width - arrow_req.width; arrow_rect.width = arrow_req.width; calculate_arrow_rect(comboBoxArrow, &arrow_rect, &real_arrow_rect, direction); style = GetStyleContext(MOZ_GTK_COMBOBOX_ARROW, state->scale); gtk_render_arrow(style, cr, ARROW_DOWN, real_arrow_rect.x, real_arrow_rect.y, real_arrow_rect.width); /* If there is no separator in the theme, there's nothing left to do. */ GtkWidget* widget = GetWidget(MOZ_GTK_COMBOBOX_SEPARATOR); if (!widget) return MOZ_GTK_SUCCESS; style = gtk_widget_get_style_context(widget); StyleContextSetScale(style, state->scale); gtk_style_context_get_style(style, "wide-separators", &wide_separators, "separator-width", &separator_width, NULL); if (wide_separators) { if (direction == GTK_TEXT_DIR_LTR) arrow_rect.x -= separator_width; else arrow_rect.x += arrow_rect.width; gtk_render_frame(style, cr, arrow_rect.x, arrow_rect.y, separator_width, arrow_rect.height); } else { if (direction == GTK_TEXT_DIR_LTR) { GtkBorder padding; GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); gtk_style_context_get_padding(style, state_flags, &padding); arrow_rect.x -= padding.left; } else arrow_rect.x += arrow_rect.width; gtk_render_line(style, cr, arrow_rect.x, arrow_rect.y, arrow_rect.x, arrow_rect.y + arrow_rect.height); } return MOZ_GTK_SUCCESS; } static gint moz_gtk_arrow_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkArrowType arrow_type, GtkTextDirection direction) { GdkRectangle arrow_rect; gdouble arrow_angle; if (direction == GTK_TEXT_DIR_RTL) { if (arrow_type == GTK_ARROW_LEFT) { arrow_type = GTK_ARROW_RIGHT; } else if (arrow_type == GTK_ARROW_RIGHT) { arrow_type = GTK_ARROW_LEFT; } } switch (arrow_type) { case GTK_ARROW_LEFT: arrow_angle = ARROW_LEFT; break; case GTK_ARROW_RIGHT: arrow_angle = ARROW_RIGHT; break; case GTK_ARROW_DOWN: arrow_angle = ARROW_DOWN; break; default: arrow_angle = ARROW_UP; break; } if (arrow_type == GTK_ARROW_NONE) return MOZ_GTK_SUCCESS; calculate_arrow_rect(GetWidget(MOZ_GTK_BUTTON_ARROW), rect, &arrow_rect, direction); GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style = GetStyleContext(MOZ_GTK_BUTTON_ARROW, state->scale, direction, state_flags); gtk_render_arrow(style, cr, arrow_angle, arrow_rect.x, arrow_rect.y, arrow_rect.width); return MOZ_GTK_SUCCESS; } static gint moz_gtk_combo_box_entry_button_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, gboolean input_focus, GtkTextDirection direction) { gint x_displacement, y_displacement; GdkRectangle arrow_rect, real_arrow_rect; GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style; GtkWidget* comboBoxEntry = GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON); moz_gtk_button_paint(cr, rect, state, GTK_RELIEF_NORMAL, comboBoxEntry, direction); calculate_button_inner_rect(comboBoxEntry, rect, &arrow_rect, direction); if (state_flags & GTK_STATE_FLAG_ACTIVE) { style = gtk_widget_get_style_context(comboBoxEntry); StyleContextSetScale(style, state->scale); gtk_style_context_get_style(style, "child-displacement-x", &x_displacement, "child-displacement-y", &y_displacement, NULL); arrow_rect.x += x_displacement; arrow_rect.y += y_displacement; } calculate_arrow_rect(GetWidget(MOZ_GTK_COMBOBOX_ENTRY_ARROW), &arrow_rect, &real_arrow_rect, direction); style = GetStyleContext(MOZ_GTK_COMBOBOX_ENTRY_ARROW, state->scale); gtk_render_arrow(style, cr, ARROW_DOWN, real_arrow_rect.x, real_arrow_rect.y, real_arrow_rect.width); return MOZ_GTK_SUCCESS; } static gint moz_gtk_container_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, WidgetNodeType widget_type, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style = GetStyleContext(widget_type, state->scale, direction, state_flags); /* this is for drawing a prelight box */ if (state_flags & GTK_STATE_FLAG_PRELIGHT) { gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); } return MOZ_GTK_SUCCESS; } static gint moz_gtk_toggle_label_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, gboolean isradio, GtkTextDirection direction) { if (!state->focused) return MOZ_GTK_SUCCESS; GtkStyleContext* style = GetStyleContext( isradio ? MOZ_GTK_RADIOBUTTON_CONTAINER : MOZ_GTK_CHECKBUTTON_CONTAINER, state->scale, direction, GetStateFlagsFromGtkWidgetState(state)); gtk_render_focus(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_toolbar_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLBAR, state->scale, direction); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } /* See _gtk_toolbar_paint_space_line() for reference. */ static gint moz_gtk_toolbar_separator_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { gint separator_width; gint paint_width; gboolean wide_separators; /* Defined as constants in GTK+ 2.10.14 */ const double start_fraction = 0.2; const double end_fraction = 0.8; GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLBAR, state->scale); gtk_style_context_get_style(style, "wide-separators", &wide_separators, "separator-width", &separator_width, NULL); style = GetStyleContext(MOZ_GTK_TOOLBAR_SEPARATOR, state->scale, direction); if (wide_separators) { if (separator_width > rect->width) separator_width = rect->width; gtk_render_frame(style, cr, rect->x + (rect->width - separator_width) / 2, rect->y + rect->height * start_fraction, separator_width, rect->height * (end_fraction - start_fraction)); } else { GtkBorder padding; gtk_style_context_get_padding(style, gtk_style_context_get_state(style), &padding); paint_width = padding.left; if (paint_width > rect->width) paint_width = rect->width; gtk_render_line(style, cr, rect->x + (rect->width - paint_width) / 2, rect->y + rect->height * start_fraction, rect->x + (rect->width - paint_width) / 2, rect->y + rect->height * end_fraction); } return MOZ_GTK_SUCCESS; } static gint moz_gtk_tooltip_paint(cairo_t* cr, const GdkRectangle* aRect, GtkWidgetState* state, GtkTextDirection direction) { // Tooltip widget is made in GTK3 as following tree: // Tooltip window // Horizontal Box // Icon (not supported by Firefox) // Label // Each element can be fully styled by CSS of GTK theme. // We have to draw all elements with appropriate offset and right dimensions. // Tooltip drawing GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLTIP, state->scale, direction); GdkRectangle rect = *aRect; gtk_render_background(style, cr, rect.x, rect.y, rect.width, rect.height); gtk_render_frame(style, cr, rect.x, rect.y, rect.width, rect.height); // Horizontal Box drawing // // The box element has hard-coded 6px margin-* GtkWidget properties, which // are added between the window dimensions and the CSS margin box of the // horizontal box. The frame of the tooltip window is drawn in the // 6px margin. // For drawing Horizontal Box we have to inset drawing area by that 6px // plus its CSS margin. GtkStyleContext* boxStyle = GetStyleContext(MOZ_GTK_TOOLTIP_BOX, state->scale, direction); rect.x += 6; rect.y += 6; rect.width -= 12; rect.height -= 12; InsetByMargin(&rect, boxStyle); gtk_render_background(boxStyle, cr, rect.x, rect.y, rect.width, rect.height); gtk_render_frame(boxStyle, cr, rect.x, rect.y, rect.width, rect.height); // Label drawing InsetByBorderPadding(&rect, boxStyle); GtkStyleContext* labelStyle = GetStyleContext(MOZ_GTK_TOOLTIP_BOX_LABEL, state->scale, direction); moz_gtk_draw_styled_frame(labelStyle, cr, &rect, false); return MOZ_GTK_SUCCESS; } static gint moz_gtk_resizer_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_RESIZER, state->scale, GTK_TEXT_DIR_LTR, GetStateFlagsFromGtkWidgetState(state)); // Workaround unico not respecting the text direction for resizers. // See bug 1174248. cairo_save(cr); if (direction == GTK_TEXT_DIR_RTL) { cairo_matrix_t mat; cairo_matrix_init_translate(&mat, 2 * rect->x + rect->width, 0); cairo_matrix_scale(&mat, -1, 1); cairo_transform(cr, &mat); } gtk_render_handle(style, cr, rect->x, rect->y, rect->width, rect->height); cairo_restore(cr); return MOZ_GTK_SUCCESS; } static gint moz_gtk_frame_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_FRAME, state->scale, direction); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_progressbar_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_PROGRESS_TROUGH, state->scale, direction); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_progress_chunk_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction, WidgetNodeType widget) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_PROGRESS_CHUNK, state->scale, direction); if (widget == MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE || widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE) { /** * The bar's size and the bar speed are set depending of the progress' * size. These could also be constant for all progress bars easily. */ gboolean vertical = (widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE); /* The size of the dimension we are going to use for the animation. */ const gint progressSize = vertical ? rect->height : rect->width; /* The bar is using a fifth of the element size, based on GtkProgressBar * activity-blocks property. */ const gint barSize = MAX(1, progressSize / 5); /* Represents the travel that has to be done for a complete cycle. */ const gint travel = 2 * (progressSize - barSize); /* period equals to travel / pixelsPerMillisecond * where pixelsPerMillisecond equals progressSize / 1000.0. * This is equivalent to 1600. */ static const guint period = 1600; const gint t = PR_IntervalToMilliseconds(PR_IntervalNow()) % period; const gint dx = travel * t / period; if (vertical) { rect->y += (dx < travel / 2) ? dx : travel - dx; rect->height = barSize; } else { rect->x += (dx < travel / 2) ? dx : travel - dx; rect->width = barSize; } } // gtk_render_activity was used to render progress chunks on GTK versions // before 3.13.7, see bug 1173907. if (!gtk_check_version(3, 13, 7)) { gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); } else { gtk_render_activity(style, cr, rect->x, rect->y, rect->width, rect->height); } return MOZ_GTK_SUCCESS; } static gint moz_gtk_get_tab_thickness(GtkStyleContext* style) { if (!notebook_has_tab_gap) return 0; /* tabs do not overdraw the tabpanel border with "no gap" style */ GtkBorder border; gtk_style_context_get_border(style, gtk_style_context_get_state(style), &border); if (border.top < 2) return 2; /* some themes don't set ythickness correctly */ return border.top; } gint moz_gtk_get_tab_thickness(WidgetNodeType aNodeType) { GtkStyleContext* style = GetStyleContext(aNodeType); int thickness = moz_gtk_get_tab_thickness(style); return thickness; } /* actual small tabs */ static gint moz_gtk_tab_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTabFlags flags, GtkTextDirection direction, WidgetNodeType widget) { /* When the tab isn't selected, we just draw a notebook extension. * When it is selected, we overwrite the adjacent border of the tabpanel * touching the tab with a pierced border (called "the gap") to make the * tab appear physically attached to the tabpanel; see details below. */ GtkStyleContext* style; GdkRectangle tabRect; GdkRectangle focusRect; GdkRectangle backRect; int initial_gap = 0; bool isBottomTab = (widget == MOZ_GTK_TAB_BOTTOM); style = GetStyleContext(widget, state->scale, direction, GetStateFlagsFromGtkTabFlags(flags)); tabRect = *rect; if (flags & MOZ_GTK_TAB_FIRST) { gtk_style_context_get_style(style, "initial-gap", &initial_gap, NULL); tabRect.width -= initial_gap; if (direction != GTK_TEXT_DIR_RTL) { tabRect.x += initial_gap; } } focusRect = backRect = tabRect; if (notebook_has_tab_gap) { if ((flags & MOZ_GTK_TAB_SELECTED) == 0) { /* Only draw the tab */ gtk_render_extension(style, cr, tabRect.x, tabRect.y, tabRect.width, tabRect.height, isBottomTab ? GTK_POS_TOP : GTK_POS_BOTTOM); } else { /* Draw the tab and the gap * We want the gap to be positioned exactly on the tabpanel top * border; since tabbox.css may set a negative margin so that the tab * frame rect already overlaps the tabpanel frame rect, we need to take * that into account when drawing. To that effect, nsNativeThemeGTK * passes us this negative margin (bmargin in the graphic below) in the * lowest bits of |flags|. We use it to set gap_voffset, the distance * between the top of the gap and the bottom of the tab (resp. the * bottom of the gap and the top of the tab when we draw a bottom tab), * while ensuring that the gap always touches the border of the tab, * i.e. 0 <= gap_voffset <= gap_height, to avoid surprinsing results * with big negative or positive margins. * Here is a graphical explanation in the case of top tabs: * ___________________________ * / \ * | T A B | * ----------|. . . . . . . . . . . . . . .|----- top of tabpanel * : ^ bmargin : ^ * : | (-negative margin, : | * bottom : v passed in flags) : | gap_height * of -> :.............................: | (the size of the * the tab . part of the gap . | tabpanel top border) * . outside of the tab . v * ---------------------------------------------- * * To draw the gap, we use gtk_render_frame_gap(), see comment in * moz_gtk_tabpanels_paint(). This gap is made 3 * gap_height tall, * which should suffice to ensure that the only visible border is the * pierced one. If the tab is in the middle, we make the box_gap begin * a bit to the left of the tab and end a bit to the right, adjusting * the gap position so it still is under the tab, because we want the * rendering of a gap in the middle of a tabpanel. This is the role of * the gints gap_{l,r}_offset. On the contrary, if the tab is the * first, we align the start border of the box_gap with the start * border of the tab (left if LTR, right if RTL), by setting the * appropriate offset to 0.*/ gint gap_loffset, gap_roffset, gap_voffset, gap_height; /* Get height needed by the gap */ gap_height = moz_gtk_get_tab_thickness(style); /* Extract gap_voffset from the first bits of flags */ gap_voffset = flags & MOZ_GTK_TAB_MARGIN_MASK; if (gap_voffset > gap_height) gap_voffset = gap_height; /* Set gap_{l,r}_offset to appropriate values */ gap_loffset = gap_roffset = 20; /* should be enough */ if (flags & MOZ_GTK_TAB_FIRST) { if (direction == GTK_TEXT_DIR_RTL) gap_roffset = initial_gap; else gap_loffset = initial_gap; } GtkStyleContext* panelStyle = GetStyleContext(MOZ_GTK_TABPANELS, state->scale, direction); if (isBottomTab) { /* Draw the tab on bottom */ focusRect.y += gap_voffset; focusRect.height -= gap_voffset; gtk_render_extension(style, cr, tabRect.x, tabRect.y + gap_voffset, tabRect.width, tabRect.height - gap_voffset, GTK_POS_TOP); backRect.y += (gap_voffset - gap_height); backRect.height = gap_height; /* Draw the gap; erase with background color before painting in * case theme does not */ gtk_render_background(panelStyle, cr, backRect.x, backRect.y, backRect.width, backRect.height); cairo_save(cr); cairo_rectangle(cr, backRect.x, backRect.y, backRect.width, backRect.height); cairo_clip(cr); gtk_render_frame_gap(panelStyle, cr, tabRect.x - gap_loffset, tabRect.y + gap_voffset - 3 * gap_height, tabRect.width + gap_loffset + gap_roffset, 3 * gap_height, GTK_POS_BOTTOM, gap_loffset, gap_loffset + tabRect.width); cairo_restore(cr); } else { /* Draw the tab on top */ focusRect.height -= gap_voffset; gtk_render_extension(style, cr, tabRect.x, tabRect.y, tabRect.width, tabRect.height - gap_voffset, GTK_POS_BOTTOM); backRect.y += (tabRect.height - gap_voffset); backRect.height = gap_height; /* Draw the gap; erase with background color before painting in * case theme does not */ gtk_render_background(panelStyle, cr, backRect.x, backRect.y, backRect.width, backRect.height); cairo_save(cr); cairo_rectangle(cr, backRect.x, backRect.y, backRect.width, backRect.height); cairo_clip(cr); gtk_render_frame_gap(panelStyle, cr, tabRect.x - gap_loffset, tabRect.y + tabRect.height - gap_voffset, tabRect.width + gap_loffset + gap_roffset, 3 * gap_height, GTK_POS_TOP, gap_loffset, gap_loffset + tabRect.width); cairo_restore(cr); } } } else { gtk_render_background(style, cr, tabRect.x, tabRect.y, tabRect.width, tabRect.height); gtk_render_frame(style, cr, tabRect.x, tabRect.y, tabRect.width, tabRect.height); } if (state->focused) { /* Paint the focus ring */ GtkBorder padding; gtk_style_context_get_padding(style, GetStateFlagsFromGtkWidgetState(state), &padding); focusRect.x += padding.left; focusRect.width -= (padding.left + padding.right); focusRect.y += padding.top; focusRect.height -= (padding.top + padding.bottom); gtk_render_focus(style, cr, focusRect.x, focusRect.y, focusRect.width, focusRect.height); } return MOZ_GTK_SUCCESS; } /* tab area*/ static gint moz_gtk_tabpanels_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_TABPANELS, state->scale, direction); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); /* * The gap size is not needed in moz_gtk_tabpanels_paint because * the gap will be painted with the foreground tab in moz_gtk_tab_paint. * * However, if moz_gtk_tabpanels_paint just uses gtk_render_frame(), * the theme will think that there are no tabs and may draw something * different.Hence the trick of using two clip regions, and drawing the * gap outside each clip region, to get the correct frame for * a tabpanel with tabs. */ /* left side */ cairo_save(cr); cairo_rectangle(cr, rect->x, rect->y, rect->x + rect->width / 2, rect->y + rect->height); cairo_clip(cr); gtk_render_frame_gap(style, cr, rect->x, rect->y, rect->width, rect->height, GTK_POS_TOP, rect->width - 1, rect->width); cairo_restore(cr); /* right side */ cairo_save(cr); cairo_rectangle(cr, rect->x + rect->width / 2, rect->y, rect->x + rect->width, rect->y + rect->height); cairo_clip(cr); gtk_render_frame_gap(style, cr, rect->x, rect->y, rect->width, rect->height, GTK_POS_TOP, 0, 1); cairo_restore(cr); return MOZ_GTK_SUCCESS; } static gint moz_gtk_tab_scroll_arrow_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkArrowType arrow_type, GtkTextDirection direction) { GtkStyleContext* style; gdouble arrow_angle; gint arrow_size = MIN(rect->width, rect->height); gint x = rect->x + (rect->width - arrow_size) / 2; gint y = rect->y + (rect->height - arrow_size) / 2; if (direction == GTK_TEXT_DIR_RTL) { arrow_type = (arrow_type == GTK_ARROW_LEFT) ? GTK_ARROW_RIGHT : GTK_ARROW_LEFT; } switch (arrow_type) { case GTK_ARROW_LEFT: arrow_angle = ARROW_LEFT; break; case GTK_ARROW_RIGHT: arrow_angle = ARROW_RIGHT; break; case GTK_ARROW_DOWN: arrow_angle = ARROW_DOWN; break; default: arrow_angle = ARROW_UP; break; } if (arrow_type != GTK_ARROW_NONE) { style = GetStyleContext(MOZ_GTK_TAB_SCROLLARROW, state->scale, direction, GetStateFlagsFromGtkWidgetState(state)); gtk_render_arrow(style, cr, arrow_angle, x, y, arrow_size); } return MOZ_GTK_SUCCESS; } static gint moz_gtk_menu_bar_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style; GtkWidget* widget = GetWidget(MOZ_GTK_MENUBAR); gtk_widget_set_direction(widget, direction); style = gtk_widget_get_style_context(widget); gtk_style_context_save(style); gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR); StyleContextSetScale(style, state->scale); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_style_context_restore(style); return MOZ_GTK_SUCCESS; } static gint moz_gtk_menu_popup_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStyleContext* style; GtkWidget* widget = GetWidget(MOZ_GTK_MENUPOPUP); gtk_widget_set_direction(widget, direction); // Draw a backing toplevel. This fixes themes that don't provide a menu // background, and depend on the GtkMenu's implementation window to provide // it. moz_gtk_window_paint(cr, rect, direction); style = gtk_widget_get_style_context(widget); gtk_style_context_save(style); gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENU); StyleContextSetScale(style, state->scale); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_style_context_restore(style); return MOZ_GTK_SUCCESS; } // See gtk_menu_item_draw() for reference. static gint moz_gtk_menu_separator_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkWidgetState defaultState = {0}; moz_gtk_menu_item_paint(MOZ_GTK_MENUSEPARATOR, cr, rect, &defaultState, direction); if (gtk_get_minor_version() >= 20) return MOZ_GTK_SUCCESS; GtkStyleContext* style; gboolean wide_separators; gint separator_height; gint x, y, w; GtkBorder padding; style = GetStyleContext(MOZ_GTK_MENUSEPARATOR, state->scale, direction); gtk_style_context_get_padding(style, gtk_style_context_get_state(style), &padding); x = rect->x; y = rect->y; w = rect->width; gtk_style_context_save(style); gtk_style_context_add_class(style, GTK_STYLE_CLASS_SEPARATOR); gtk_style_context_get_style(style, "wide-separators", &wide_separators, "separator-height", &separator_height, NULL); if (wide_separators) { gtk_render_frame(style, cr, x + padding.left, y + padding.top, w - padding.left - padding.right, separator_height); } else { gtk_render_line(style, cr, x + padding.left, y + padding.top, x + w - padding.right - 1, y + padding.top); } gtk_style_context_restore(style); return MOZ_GTK_SUCCESS; } // See gtk_menu_item_draw() for reference. static gint moz_gtk_menu_item_paint(WidgetNodeType widget, cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { gint x, y, w, h; guint minorVersion = gtk_get_minor_version(); GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); // GTK versions prior to 3.8 render the background and frame only when not // a separator and in hover prelight. if (minorVersion < 8 && (widget == MOZ_GTK_MENUSEPARATOR || !(state_flags & GTK_STATE_FLAG_PRELIGHT))) return MOZ_GTK_SUCCESS; GtkStyleContext* style = GetStyleContext(widget, state->scale, direction, state_flags); if (minorVersion < 6) { // GTK+ 3.4 saves the style context and adds the menubar class to // menubar children, but does each of these only when drawing, not // during layout. gtk_style_context_save(style); if (widget == MOZ_GTK_MENUBARITEM) { gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR); } } x = rect->x; y = rect->y; w = rect->width; h = rect->height; gtk_render_background(style, cr, x, y, w, h); gtk_render_frame(style, cr, x, y, w, h); if (minorVersion < 6) { gtk_style_context_restore(style); } return MOZ_GTK_SUCCESS; } static gint moz_gtk_menu_arrow_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style = GetStyleContext(MOZ_GTK_MENUITEM, state->scale, direction, state_flags); gtk_render_arrow(style, cr, (direction == GTK_TEXT_DIR_LTR) ? ARROW_RIGHT : ARROW_LEFT, rect->x, rect->y, rect->width); return MOZ_GTK_SUCCESS; } // For reference, see gtk_check_menu_item_size_allocate() in GTK versions after // 3.20 and gtk_real_check_menu_item_draw_indicator() in earlier versions. static gint moz_gtk_check_menu_item_paint(WidgetNodeType widgetType, cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, gboolean checked, GtkTextDirection direction) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style; gint indicator_size, horizontal_padding; gint x, y; moz_gtk_menu_item_paint(MOZ_GTK_MENUITEM, cr, rect, state, direction); if (checked) { state_flags = static_cast(state_flags | checkbox_check_state); } bool pre_3_20 = gtk_get_minor_version() < 20; gint offset; style = GetStyleContext(widgetType, state->scale, direction); gtk_style_context_get_style(style, "indicator-size", &indicator_size, "horizontal-padding", &horizontal_padding, NULL); if (pre_3_20) { GtkBorder padding; gtk_style_context_get_padding(style, state_flags, &padding); offset = horizontal_padding + padding.left + 2; } else { GdkRectangle r = {0}; InsetByMargin(&r, style); InsetByBorderPadding(&r, style); offset = r.x; } bool isRadio = (widgetType == MOZ_GTK_RADIOMENUITEM); WidgetNodeType indicatorType = isRadio ? MOZ_GTK_RADIOMENUITEM_INDICATOR : MOZ_GTK_CHECKMENUITEM_INDICATOR; const ToggleGTKMetrics* metrics = GetToggleMetrics(indicatorType); style = GetStyleContext(indicatorType, state->scale, direction, state_flags); if (direction == GTK_TEXT_DIR_RTL) { x = rect->width - indicator_size - offset; } else { x = rect->x + offset; } y = rect->y + (rect->height - indicator_size) / 2; gint indicator_width, indicator_height; indicator_width = indicator_height = indicator_size; if (!pre_3_20) { gtk_render_background(style, cr, x, y, indicator_size, indicator_size); gtk_render_frame(style, cr, x, y, indicator_size, indicator_size); x = x + metrics->borderAndPadding.left; y = y + metrics->borderAndPadding.top; indicator_width = metrics->minSizeWithBorder.width - metrics->borderAndPadding.left - metrics->borderAndPadding.right; indicator_height = metrics->minSizeWithBorder.height - metrics->borderAndPadding.top - metrics->borderAndPadding.bottom; } if (isRadio) { gtk_render_option(style, cr, x, y, indicator_width, indicator_height); } else { gtk_render_check(style, cr, x, y, indicator_width, indicator_height); } return MOZ_GTK_SUCCESS; } static gint moz_gtk_info_bar_paint(cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_INFO_BAR, state->scale, GTK_TEXT_DIR_LTR, GetStateFlagsFromGtkWidgetState(state)); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height); return MOZ_GTK_SUCCESS; } static gint moz_gtk_header_bar_paint(WidgetNodeType widgetType, cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state) { GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state); GtkStyleContext* style = GetStyleContext(widgetType, state->scale, GTK_TEXT_DIR_NONE, state_flags); // Some themes (Adwaita for instance) draws bold dark line at // titlebar bottom. It does not fit well with Firefox tabs so // draw with some extent to make the titlebar bottom part invisible. #define TITLEBAR_EXTENT 4 // We don't need to draw window decoration for MOZ_GTK_HEADER_BAR_MAXIMIZED, // i.e. when main window is maximized. if (widgetType == MOZ_GTK_HEADER_BAR) { GtkStyleContext* windowStyle = GetStyleContext(MOZ_GTK_HEADERBAR_WINDOW, state->scale); bool solidDecorations = gtk_style_context_has_class(windowStyle, "solid-csd"); GtkStyleContext* decorationStyle = GetStyleContext(solidDecorations ? MOZ_GTK_WINDOW_DECORATION_SOLID : MOZ_GTK_WINDOW_DECORATION, state->scale, GTK_TEXT_DIR_LTR, state_flags); gtk_render_background(decorationStyle, cr, rect->x, rect->y, rect->width, rect->height + TITLEBAR_EXTENT); gtk_render_frame(decorationStyle, cr, rect->x, rect->y, rect->width, rect->height + TITLEBAR_EXTENT); } gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height + TITLEBAR_EXTENT); gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height + TITLEBAR_EXTENT); return MOZ_GTK_SUCCESS; } static GtkBorder GetMarginBorderPadding(GtkStyleContext* aStyle) { gint left = 0, top = 0, right = 0, bottom = 0; moz_gtk_add_margin_border_padding(aStyle, &left, &top, &right, &bottom); // narrowing conversions to gint16: GtkBorder result; result.left = left; result.right = right; result.top = top; result.bottom = bottom; return result; } gint moz_gtk_get_widget_border(WidgetNodeType widget, gint* left, gint* top, gint* right, gint* bottom, // NOTE: callers depend on direction being used // only for MOZ_GTK_DROPDOWN widgets. GtkTextDirection direction) { GtkWidget* w; GtkStyleContext* style; *left = *top = *right = *bottom = 0; switch (widget) { case MOZ_GTK_BUTTON: case MOZ_GTK_TOOLBAR_BUTTON: { style = GetStyleContext(MOZ_GTK_BUTTON); *left = *top = *right = *bottom = gtk_container_get_border_width( GTK_CONTAINER(GetWidget(MOZ_GTK_BUTTON))); if (widget == MOZ_GTK_TOOLBAR_BUTTON) { gtk_style_context_save(style); gtk_style_context_add_class(style, "image-button"); } moz_gtk_add_style_padding(style, left, top, right, bottom); if (widget == MOZ_GTK_TOOLBAR_BUTTON) gtk_style_context_restore(style); moz_gtk_add_style_border(style, left, top, right, bottom); return MOZ_GTK_SUCCESS; } case MOZ_GTK_ENTRY: case MOZ_GTK_DROPDOWN_ENTRY: { style = GetStyleContext(widget); // XXX: Subtract 1 pixel from the padding to account for the default // padding in forms.css. See bug 1187385. *left = *top = *right = *bottom = -1; moz_gtk_add_border_padding(style, left, top, right, bottom); return MOZ_GTK_SUCCESS; } case MOZ_GTK_TEXT_VIEW: case MOZ_GTK_TREEVIEW: { style = GetStyleContext(MOZ_GTK_SCROLLED_WINDOW); moz_gtk_add_style_border(style, left, top, right, bottom); return MOZ_GTK_SUCCESS; } case MOZ_GTK_TREE_HEADER_CELL: { /* A Tree Header in GTK is just a different styled button * It must be placed in a TreeView for getting the correct style * assigned. * That is why the following code is the same as for MOZ_GTK_BUTTON. * */ *left = *top = *right = *bottom = gtk_container_get_border_width( GTK_CONTAINER(GetWidget(MOZ_GTK_TREE_HEADER_CELL))); style = GetStyleContext(MOZ_GTK_TREE_HEADER_CELL); moz_gtk_add_border_padding(style, left, top, right, bottom); return MOZ_GTK_SUCCESS; } case MOZ_GTK_TREE_HEADER_SORTARROW: w = GetWidget(MOZ_GTK_TREE_HEADER_SORTARROW); break; case MOZ_GTK_DROPDOWN_ARROW: w = GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON); break; case MOZ_GTK_DROPDOWN: { /* We need to account for the arrow on the dropdown, so text * doesn't come too close to the arrow, or in some cases spill * into the arrow. */ gboolean wide_separators; gint separator_width; GtkRequisition arrow_req; GtkBorder border; *left = *top = *right = *bottom = gtk_container_get_border_width( GTK_CONTAINER(GetWidget(MOZ_GTK_COMBOBOX_BUTTON))); style = GetStyleContext(MOZ_GTK_COMBOBOX_BUTTON); moz_gtk_add_border_padding(style, left, top, right, bottom); /* If there is no separator, don't try to count its width. */ separator_width = 0; GtkWidget* comboBoxSeparator = GetWidget(MOZ_GTK_COMBOBOX_SEPARATOR); if (comboBoxSeparator) { style = gtk_widget_get_style_context(comboBoxSeparator); gtk_style_context_get_style(style, "wide-separators", &wide_separators, "separator-width", &separator_width, NULL); if (!wide_separators) { gtk_style_context_get_border( style, gtk_style_context_get_state(style), &border); separator_width = border.left; } } gtk_widget_get_preferred_size(GetWidget(MOZ_GTK_COMBOBOX_ARROW), NULL, &arrow_req); moz_gtk_sanity_preferred_size(&arrow_req); if (direction == GTK_TEXT_DIR_RTL) *left += separator_width + arrow_req.width; else *right += separator_width + arrow_req.width; return MOZ_GTK_SUCCESS; } case MOZ_GTK_TABPANELS: w = GetWidget(MOZ_GTK_TABPANELS); break; case MOZ_GTK_PROGRESSBAR: w = GetWidget(MOZ_GTK_PROGRESSBAR); break; case MOZ_GTK_SPINBUTTON_ENTRY: case MOZ_GTK_SPINBUTTON_UP: case MOZ_GTK_SPINBUTTON_DOWN: w = GetWidget(MOZ_GTK_SPINBUTTON); break; case MOZ_GTK_SCALE_HORIZONTAL: case MOZ_GTK_SCALE_VERTICAL: w = GetWidget(widget); break; case MOZ_GTK_FRAME: w = GetWidget(MOZ_GTK_FRAME); break; case MOZ_GTK_CHECKBUTTON_CONTAINER: case MOZ_GTK_RADIOBUTTON_CONTAINER: { w = GetWidget(widget); style = gtk_widget_get_style_context(w); *left = *top = *right = *bottom = gtk_container_get_border_width(GTK_CONTAINER(w)); moz_gtk_add_border_padding(style, left, top, right, bottom); return MOZ_GTK_SUCCESS; } case MOZ_GTK_MENUPOPUP: w = GetWidget(MOZ_GTK_MENUPOPUP); break; case MOZ_GTK_MENUBARITEM: case MOZ_GTK_MENUITEM: case MOZ_GTK_CHECKMENUITEM: case MOZ_GTK_RADIOMENUITEM: { // Bug 1274143 for MOZ_GTK_MENUBARITEM WidgetNodeType type = widget == MOZ_GTK_MENUBARITEM ? MOZ_GTK_MENUITEM : widget; style = GetStyleContext(type); if (gtk_get_minor_version() < 20) { moz_gtk_add_style_padding(style, left, top, right, bottom); } else { moz_gtk_add_margin_border_padding(style, left, top, right, bottom); } return MOZ_GTK_SUCCESS; } case MOZ_GTK_INFO_BAR: w = GetWidget(MOZ_GTK_INFO_BAR); break; case MOZ_GTK_TOOLTIP: { // In GTK 3 there are 6 pixels of additional margin around the box. // See details there: // https://github.com/GNOME/gtk/blob/5ea69a136bd7e4970b3a800390e20314665aaed2/gtk/ui/gtktooltipwindow.ui#L11 *left = *right = *top = *bottom = 6; // We also need to add margin/padding/borders from Tooltip content. // Tooltip contains horizontal box, where icon and label is put. // We ignore icon as long as we don't have support for it. GtkStyleContext* boxStyle = GetStyleContext(MOZ_GTK_TOOLTIP_BOX); moz_gtk_add_margin_border_padding(boxStyle, left, top, right, bottom); GtkStyleContext* labelStyle = GetStyleContext(MOZ_GTK_TOOLTIP_BOX_LABEL); moz_gtk_add_margin_border_padding(labelStyle, left, top, right, bottom); return MOZ_GTK_SUCCESS; } case MOZ_GTK_HEADER_BAR_BUTTON_BOX: { style = GetStyleContext(MOZ_GTK_HEADER_BAR); moz_gtk_add_border_padding(style, left, top, right, bottom); *top = *bottom = 0; bool leftButtonsPlacement = false; GetGtkHeaderBarButtonLayout({}, &leftButtonsPlacement); if (direction == GTK_TEXT_DIR_RTL) { leftButtonsPlacement = !leftButtonsPlacement; } if (leftButtonsPlacement) { *right = 0; } else { *left = 0; } return MOZ_GTK_SUCCESS; } /* These widgets have no borders, since they are not containers. */ case MOZ_GTK_CHECKBUTTON_LABEL: case MOZ_GTK_RADIOBUTTON_LABEL: case MOZ_GTK_SPLITTER_HORIZONTAL: case MOZ_GTK_SPLITTER_VERTICAL: case MOZ_GTK_CHECKBUTTON: case MOZ_GTK_RADIOBUTTON: case MOZ_GTK_SCROLLBAR_BUTTON: case MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL: case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL: case MOZ_GTK_SCALE_THUMB_HORIZONTAL: case MOZ_GTK_SCALE_THUMB_VERTICAL: case MOZ_GTK_GRIPPER: case MOZ_GTK_PROGRESS_CHUNK: case MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE: case MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE: case MOZ_GTK_TREEVIEW_EXPANDER: case MOZ_GTK_TOOLBAR_SEPARATOR: case MOZ_GTK_MENUSEPARATOR: case MOZ_GTK_HEADER_BAR: case MOZ_GTK_HEADER_BAR_MAXIMIZED: case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE: case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE: case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE: case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE: /* These widgets have no borders.*/ case MOZ_GTK_INNER_SPIN_BUTTON: case MOZ_GTK_SPINBUTTON: case MOZ_GTK_WINDOW: case MOZ_GTK_RESIZER: case MOZ_GTK_MENUARROW: case MOZ_GTK_TOOLBARBUTTON_ARROW: case MOZ_GTK_TOOLBAR: case MOZ_GTK_MENUBAR: case MOZ_GTK_TAB_SCROLLARROW: return MOZ_GTK_SUCCESS; default: g_warning("Unsupported widget type: %d", widget); return MOZ_GTK_UNKNOWN_WIDGET; } /* TODO - we're still missing some widget implementations */ if (w) { moz_gtk_add_style_border(gtk_widget_get_style_context(w), left, top, right, bottom); } return MOZ_GTK_SUCCESS; } gint moz_gtk_get_tab_border(gint* left, gint* top, gint* right, gint* bottom, GtkTextDirection direction, GtkTabFlags flags, WidgetNodeType widget) { GtkStyleContext* style = GetStyleContext(widget, 1, direction, GetStateFlagsFromGtkTabFlags(flags)); *left = *top = *right = *bottom = 0; moz_gtk_add_style_padding(style, left, top, right, bottom); // Gtk >= 3.20 does not use those styles if (gtk_check_version(3, 20, 0) != nullptr) { int tab_curvature; gtk_style_context_get_style(style, "tab-curvature", &tab_curvature, NULL); *left += tab_curvature; *right += tab_curvature; if (flags & MOZ_GTK_TAB_FIRST) { int initial_gap = 0; gtk_style_context_get_style(style, "initial-gap", &initial_gap, NULL); if (direction == GTK_TEXT_DIR_RTL) *right += initial_gap; else *left += initial_gap; } } else { GtkBorder margin; gtk_style_context_get_margin(style, gtk_style_context_get_state(style), &margin); *left += margin.left; *right += margin.right; if (flags & MOZ_GTK_TAB_FIRST) { style = GetStyleContext(MOZ_GTK_NOTEBOOK_HEADER, direction); gtk_style_context_get_margin(style, gtk_style_context_get_state(style), &margin); *left += margin.left; *right += margin.right; } } return MOZ_GTK_SUCCESS; } gint moz_gtk_get_combo_box_entry_button_size(gint* width, gint* height) { /* * We get the requisition of the drop down button, which includes * all padding, border and focus line widths the button uses, * as well as the minimum arrow size and its padding * */ GtkRequisition requisition; gtk_widget_get_preferred_size(GetWidget(MOZ_GTK_COMBOBOX_ENTRY_BUTTON), NULL, &requisition); moz_gtk_sanity_preferred_size(&requisition); *width = requisition.width; *height = requisition.height; return MOZ_GTK_SUCCESS; } gint moz_gtk_get_tab_scroll_arrow_size(gint* width, gint* height) { gint arrow_size; GtkStyleContext* style = GetStyleContext(MOZ_GTK_TABPANELS); gtk_style_context_get_style(style, "scroll-arrow-hlength", &arrow_size, NULL); *height = *width = arrow_size; return MOZ_GTK_SUCCESS; } void moz_gtk_get_arrow_size(WidgetNodeType widgetType, gint* width, gint* height) { GtkWidget* widget; switch (widgetType) { case MOZ_GTK_DROPDOWN: widget = GetWidget(MOZ_GTK_COMBOBOX_ARROW); break; default: widget = GetWidget(MOZ_GTK_BUTTON_ARROW); break; } GtkRequisition requisition; gtk_widget_get_preferred_size(widget, NULL, &requisition); moz_gtk_sanity_preferred_size(&requisition); *width = requisition.width; *height = requisition.height; } gint moz_gtk_get_toolbar_separator_width(gint* size) { gboolean wide_separators; gint separator_width; GtkBorder border; GtkStyleContext* style = GetStyleContext(MOZ_GTK_TOOLBAR); gtk_style_context_get_style(style, "space-size", size, "wide-separators", &wide_separators, "separator-width", &separator_width, NULL); /* Just in case... */ gtk_style_context_get_border(style, gtk_style_context_get_state(style), &border); *size = MAX(*size, (wide_separators ? separator_width : border.left)); return MOZ_GTK_SUCCESS; } gint moz_gtk_get_expander_size(gint* size) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_EXPANDER); gtk_style_context_get_style(style, "expander-size", size, NULL); return MOZ_GTK_SUCCESS; } gint moz_gtk_get_treeview_expander_size(gint* size) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_TREEVIEW); gtk_style_context_get_style(style, "expander-size", size, NULL); return MOZ_GTK_SUCCESS; } // See gtk_menu_item_draw() for reference. gint moz_gtk_get_menu_separator_height(gint* size) { gboolean wide_separators; gint separator_height; GtkBorder padding; GtkStyleContext* style = GetStyleContext(MOZ_GTK_MENUSEPARATOR); gtk_style_context_get_padding(style, gtk_style_context_get_state(style), &padding); gtk_style_context_save(style); gtk_style_context_add_class(style, GTK_STYLE_CLASS_SEPARATOR); gtk_style_context_get_style(style, "wide-separators", &wide_separators, "separator-height", &separator_height, NULL); gtk_style_context_restore(style); *size = padding.top + padding.bottom; *size += (wide_separators) ? separator_height : 1; return MOZ_GTK_SUCCESS; } void moz_gtk_get_entry_min_height(gint* min_content_height, gint* border_padding_height) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_ENTRY); if (!gtk_check_version(3, 20, 0)) { gtk_style_context_get(style, gtk_style_context_get_state(style), "min-height", min_content_height, nullptr); } else { *min_content_height = 0; } GtkBorder border; GtkBorder padding; gtk_style_context_get_border(style, gtk_style_context_get_state(style), &border); gtk_style_context_get_padding(style, gtk_style_context_get_state(style), &padding); *border_padding_height = (border.top + border.bottom + padding.top + padding.bottom); } void moz_gtk_get_scale_metrics(GtkOrientation orient, gint* scale_width, gint* scale_height) { if (gtk_check_version(3, 20, 0) != nullptr) { WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL) ? MOZ_GTK_SCALE_HORIZONTAL : MOZ_GTK_SCALE_VERTICAL; gint thumb_length, thumb_height, trough_border; moz_gtk_get_scalethumb_metrics(orient, &thumb_length, &thumb_height); GtkStyleContext* style = GetStyleContext(widget); gtk_style_context_get_style(style, "trough-border", &trough_border, NULL); if (orient == GTK_ORIENTATION_HORIZONTAL) { *scale_width = thumb_length + trough_border * 2; *scale_height = thumb_height + trough_border * 2; } else { *scale_width = thumb_height + trough_border * 2; *scale_height = thumb_length + trough_border * 2; } } else { WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL) ? MOZ_GTK_SCALE_TROUGH_HORIZONTAL : MOZ_GTK_SCALE_TROUGH_VERTICAL; moz_gtk_get_widget_min_size(GetStyleContext(widget), scale_width, scale_height); } } gint moz_gtk_get_scalethumb_metrics(GtkOrientation orient, gint* thumb_length, gint* thumb_height) { if (gtk_check_version(3, 20, 0) != nullptr) { WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL) ? MOZ_GTK_SCALE_HORIZONTAL : MOZ_GTK_SCALE_VERTICAL; GtkStyleContext* style = GetStyleContext(widget); gtk_style_context_get_style(style, "slider_length", thumb_length, "slider_width", thumb_height, NULL); } else { WidgetNodeType widget = (orient == GTK_ORIENTATION_HORIZONTAL) ? MOZ_GTK_SCALE_THUMB_HORIZONTAL : MOZ_GTK_SCALE_THUMB_VERTICAL; GtkStyleContext* style = GetStyleContext(widget); gint min_width, min_height; GtkStateFlags state = gtk_style_context_get_state(style); gtk_style_context_get(style, state, "min-width", &min_width, "min-height", &min_height, nullptr); GtkBorder margin; gtk_style_context_get_margin(style, state, &margin); gint margin_width = margin.left + margin.right; gint margin_height = margin.top + margin.bottom; // Negative margin of slider element also determines its minimal size // so use bigger of those two values. if (min_width < -margin_width) min_width = -margin_width; if (min_height < -margin_height) min_height = -margin_height; *thumb_length = min_width; *thumb_height = min_height; } return MOZ_GTK_SUCCESS; } static MozGtkSize SizeFromLengthAndBreadth(GtkOrientation aOrientation, gint aLength, gint aBreadth) { return aOrientation == GTK_ORIENTATION_HORIZONTAL ? MozGtkSize({aLength, aBreadth}) : MozGtkSize({aBreadth, aLength}); } const ToggleGTKMetrics* GetToggleMetrics(WidgetNodeType aWidgetType) { ToggleGTKMetrics* metrics; switch (aWidgetType) { case MOZ_GTK_RADIOBUTTON: metrics = &sRadioMetrics; break; case MOZ_GTK_CHECKBUTTON: metrics = &sCheckboxMetrics; break; case MOZ_GTK_RADIOMENUITEM_INDICATOR: metrics = &sMenuRadioMetrics; break; case MOZ_GTK_CHECKMENUITEM_INDICATOR: metrics = &sMenuCheckboxMetrics; break; default: MOZ_CRASH("Unsupported widget type for getting metrics"); return nullptr; } metrics->initialized = true; if (gtk_check_version(3, 20, 0) == nullptr) { GtkStyleContext* style = GetStyleContext(aWidgetType); GtkStateFlags state_flags = gtk_style_context_get_state(style); gtk_style_context_get(style, state_flags, "min-height", &(metrics->minSizeWithBorder.height), "min-width", &(metrics->minSizeWithBorder.width), nullptr); // Fallback to indicator size if min dimensions are zero if (metrics->minSizeWithBorder.height == 0 || metrics->minSizeWithBorder.width == 0) { gint indicator_size; gtk_widget_style_get(GetWidget(MOZ_GTK_CHECKBUTTON_CONTAINER), "indicator_size", &indicator_size, nullptr); if (metrics->minSizeWithBorder.height == 0) { metrics->minSizeWithBorder.height = indicator_size; } if (metrics->minSizeWithBorder.width == 0) { metrics->minSizeWithBorder.width = indicator_size; } } GtkBorder border, padding; gtk_style_context_get_border(style, state_flags, &border); gtk_style_context_get_padding(style, state_flags, &padding); metrics->borderAndPadding.left = border.left + padding.left; metrics->borderAndPadding.right = border.right + padding.right; metrics->borderAndPadding.top = border.top + padding.top; metrics->borderAndPadding.bottom = border.bottom + padding.bottom; metrics->minSizeWithBorder.width += metrics->borderAndPadding.left + metrics->borderAndPadding.right; metrics->minSizeWithBorder.height += metrics->borderAndPadding.top + metrics->borderAndPadding.bottom; } else { gint indicator_size, indicator_spacing; gtk_widget_style_get(GetWidget(MOZ_GTK_CHECKBUTTON_CONTAINER), "indicator_size", &indicator_size, "indicator_spacing", &indicator_spacing, nullptr); metrics->minSizeWithBorder.width = metrics->minSizeWithBorder.height = indicator_size; } return metrics; } static void InitScrollbarMetrics(ScrollbarGTKMetrics* aMetrics, GtkOrientation aOrientation, GtkStateFlags aStateFlags) { WidgetNodeType scrollbar = aOrientation == GTK_ORIENTATION_HORIZONTAL ? MOZ_GTK_SCROLLBAR_HORIZONTAL : MOZ_GTK_SCROLLBAR_VERTICAL; gboolean backward, forward, secondary_backward, secondary_forward; GtkStyleContext* style = GetStyleContext(scrollbar, 1, GTK_TEXT_DIR_NONE, aStateFlags); gtk_style_context_get_style( style, "has-backward-stepper", &backward, "has-forward-stepper", &forward, "has-secondary-backward-stepper", &secondary_backward, "has-secondary-forward-stepper", &secondary_forward, nullptr); bool hasButtons = backward || forward || secondary_backward || secondary_forward; if (gtk_get_minor_version() < 20) { gint slider_width, trough_border, stepper_size, min_slider_size; gtk_style_context_get_style(style, "slider-width", &slider_width, "trough-border", &trough_border, "stepper-size", &stepper_size, "min-slider-length", &min_slider_size, nullptr); aMetrics->size.thumb = SizeFromLengthAndBreadth(aOrientation, min_slider_size, slider_width); aMetrics->size.button = SizeFromLengthAndBreadth(aOrientation, stepper_size, slider_width); // overall scrollbar gint breadth = slider_width + 2 * trough_border; // Require room for the slider in the track if we don't have buttons. gint length = hasButtons ? 0 : min_slider_size + 2 * trough_border; aMetrics->size.scrollbar = SizeFromLengthAndBreadth(aOrientation, length, breadth); // Borders on the major axis are set on the outermost scrollbar // element to correctly position the buttons when // trough-under-steppers is true. // Borders on the minor axis are set on the track element so that it // receives mouse events, as in GTK. // Other borders have been zero-initialized. if (aOrientation == GTK_ORIENTATION_HORIZONTAL) { aMetrics->border.scrollbar.left = aMetrics->border.scrollbar.right = aMetrics->border.track.top = aMetrics->border.track.bottom = trough_border; } else { aMetrics->border.scrollbar.top = aMetrics->border.scrollbar.bottom = aMetrics->border.track.left = aMetrics->border.track.right = trough_border; } // We're done here for Gtk+ < 3.20... return; } // GTK version > 3.20 // scrollbar aMetrics->border.scrollbar = GetMarginBorderPadding(style); WidgetNodeType contents, track, thumb; if (aOrientation == GTK_ORIENTATION_HORIZONTAL) { contents = MOZ_GTK_SCROLLBAR_CONTENTS_HORIZONTAL; track = MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL; thumb = MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL; } else { contents = MOZ_GTK_SCROLLBAR_CONTENTS_VERTICAL; track = MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL; thumb = MOZ_GTK_SCROLLBAR_THUMB_VERTICAL; } /* GetStyleContext() sets GtkStateFlags to the latest widget name * in css selector string. When we call: * * GetStyleContext(thumb, GTK_STATE_FLAG_PRELIGHT) * * we get: * * "scrollbar contents trough slider:hover" * * Some themes (Ubuntu Ambiance) styles trough/thumb by scrollbar, * the Gtk+ css rule looks like: * * "scrollbar:hover contents trough slider" * * So we need to apply GtkStateFlags to each widgets in style path. */ // thumb style = CreateStyleContextWithStates(thumb, 1, GTK_TEXT_DIR_NONE, aStateFlags); aMetrics->size.thumb = GetMinMarginBox(style); gtk_style_context_get_margin(style, gtk_style_context_get_state(style), &aMetrics->margin.thumb); g_object_unref(style); // track style = CreateStyleContextWithStates(track, 1, GTK_TEXT_DIR_NONE, aStateFlags); aMetrics->border.track = GetMarginBorderPadding(style); MozGtkSize trackMinSize = GetMinContentBox(style) + aMetrics->border.track; MozGtkSize trackSizeForThumb = aMetrics->size.thumb + aMetrics->border.track; g_object_unref(style); // button if (hasButtons) { style = CreateStyleContextWithStates(MOZ_GTK_SCROLLBAR_BUTTON, 1, GTK_TEXT_DIR_NONE, aStateFlags); aMetrics->size.button = GetMinMarginBox(style); g_object_unref(style); } else { aMetrics->size.button = {0, 0}; } if (aOrientation == GTK_ORIENTATION_HORIZONTAL) { aMetrics->size.button.Rotate(); // If the track is wider than necessary for the thumb, including when // the buttons will cause Gecko to expand the track to fill // available breadth, then add to the track border to prevent Gecko // from expanding the thumb to fill available breadth. gint extra = std::max(trackMinSize.height, aMetrics->size.button.height) - trackSizeForThumb.height; if (extra > 0) { // If extra is odd, then the thumb is 0.5 pixels above // center as in gtk_range_compute_slider_position(). aMetrics->border.track.top += extra / 2; aMetrics->border.track.bottom += extra - extra / 2; // Update size for change in border. trackSizeForThumb.height += extra; } } else { gint extra = std::max(trackMinSize.width, aMetrics->size.button.width) - trackSizeForThumb.width; if (extra > 0) { // If extra is odd, then the thumb is 0.5 pixels to the left // of center as in gtk_range_compute_slider_position(). aMetrics->border.track.left += extra / 2; aMetrics->border.track.right += extra - extra / 2; trackSizeForThumb.width += extra; } } style = CreateStyleContextWithStates(contents, 1, GTK_TEXT_DIR_NONE, aStateFlags); GtkBorder contentsBorder = GetMarginBorderPadding(style); g_object_unref(style); aMetrics->size.scrollbar = trackSizeForThumb + contentsBorder + aMetrics->border.scrollbar; } const ScrollbarGTKMetrics* GetScrollbarMetrics(GtkOrientation aOrientation) { auto metrics = &sScrollbarMetrics[aOrientation]; if (!metrics->initialized) { InitScrollbarMetrics(metrics, aOrientation, GTK_STATE_FLAG_NORMAL); // We calculate thumb margin here because it's composited from // thumb class margin + difference margin between active and inactive // scrollbars. It's a workaround which alows us to emulate // overlay scrollbars for some Gtk+ themes (Ubuntu/Ambiance), // when an inactive scrollbar thumb is smaller than the active one. const ScrollbarGTKMetrics* metricsActive = GetActiveScrollbarMetrics(aOrientation); if (metrics->size.thumb < metricsActive->size.thumb) { metrics->margin.thumb += (metrics->border.scrollbar + metrics->border.track) - (metricsActive->border.scrollbar + metricsActive->border.track); } metrics->initialized = true; } return metrics; } const ScrollbarGTKMetrics* GetActiveScrollbarMetrics( GtkOrientation aOrientation) { auto metrics = &sActiveScrollbarMetrics[aOrientation]; if (!metrics->initialized) { InitScrollbarMetrics(metrics, aOrientation, GTK_STATE_FLAG_PRELIGHT); metrics->initialized = true; } return metrics; } /* * get_shadow_width() from gtkwindow.c is not public so we need * to implement it. */ void InitWindowDecorationSize(CSDWindowDecorationSize* sWindowDecorationSize, bool aPopupWindow) { bool solidDecorations = gtk_style_context_has_class( GetStyleContext(MOZ_GTK_HEADERBAR_WINDOW, 1), "solid-csd"); // solid-csd does not use frame extents, quit now. if (solidDecorations) { sWindowDecorationSize->decorationSize = {0, 0, 0, 0}; return; } // Scale factor is applied later when decoration size is used for actual // gtk windows. GtkStyleContext* context = GetStyleContext(MOZ_GTK_WINDOW_DECORATION); /* Always sum border + padding */ GtkBorder padding; GtkStateFlags state = gtk_style_context_get_state(context); gtk_style_context_get_border(context, state, &sWindowDecorationSize->decorationSize); gtk_style_context_get_padding(context, state, &padding); sWindowDecorationSize->decorationSize += padding; // Available on GTK 3.20+. static auto sGtkRenderBackgroundGetClip = (void (*)( GtkStyleContext*, gdouble, gdouble, gdouble, gdouble, GdkRectangle*))dlsym(RTLD_DEFAULT, "gtk_render_background_get_clip"); if (!sGtkRenderBackgroundGetClip) { return; } GdkRectangle clip; sGtkRenderBackgroundGetClip(context, 0, 0, 0, 0, &clip); GtkBorder extents; extents.top = -clip.y; extents.right = clip.width + clip.x; extents.bottom = clip.height + clip.y; extents.left = -clip.x; // Get shadow extents but combine with style margin; use the bigger value. // Margin is used for resize grip size - it's not present on // popup windows. if (!aPopupWindow) { GtkBorder margin; gtk_style_context_get_margin(context, state, &margin); extents.top = MAX(extents.top, margin.top); extents.right = MAX(extents.right, margin.right); extents.bottom = MAX(extents.bottom, margin.bottom); extents.left = MAX(extents.left, margin.left); } sWindowDecorationSize->decorationSize += extents; } GtkBorder GetCSDDecorationSize(bool aIsPopup) { auto metrics = aIsPopup ? &sPopupWindowDecorationSize : &sToplevelWindowDecorationSize; if (!metrics->initialized) { InitWindowDecorationSize(metrics, aIsPopup); metrics->initialized = true; } return metrics->decorationSize; } /* cairo_t *cr argument has to be a system-cairo. */ gint moz_gtk_widget_paint(WidgetNodeType widget, cairo_t* cr, GdkRectangle* rect, GtkWidgetState* state, gint flags, GtkTextDirection direction) { /* A workaround for https://bugzilla.gnome.org/show_bug.cgi?id=694086 */ cairo_new_path(cr); switch (widget) { case MOZ_GTK_BUTTON: case MOZ_GTK_TOOLBAR_BUTTON: if (state->depressed) { return moz_gtk_button_paint(cr, rect, state, (GtkReliefStyle)flags, GetWidget(MOZ_GTK_TOGGLE_BUTTON), direction); } return moz_gtk_button_paint(cr, rect, state, (GtkReliefStyle)flags, GetWidget(MOZ_GTK_BUTTON), direction); break; case MOZ_GTK_HEADER_BAR_BUTTON_CLOSE: case MOZ_GTK_HEADER_BAR_BUTTON_MINIMIZE: case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE: case MOZ_GTK_HEADER_BAR_BUTTON_MAXIMIZE_RESTORE: return moz_gtk_header_bar_button_paint( cr, rect, state, (GtkReliefStyle)flags, widget, direction); break; case MOZ_GTK_CHECKBUTTON: case MOZ_GTK_RADIOBUTTON: return moz_gtk_toggle_paint(cr, rect, state, !!(flags & MOZ_GTK_WIDGET_CHECKED), !!(flags & MOZ_GTK_WIDGET_INCONSISTENT), (widget == MOZ_GTK_RADIOBUTTON), direction); break; case MOZ_GTK_SCROLLBAR_BUTTON: return moz_gtk_scrollbar_button_paint( cr, rect, state, (GtkScrollbarButtonFlags)flags, direction); break; case MOZ_GTK_SCROLLBAR_HORIZONTAL: case MOZ_GTK_SCROLLBAR_VERTICAL: if (flags & MOZ_GTK_TRACK_OPAQUE) { GtkStyleContext* style = GetStyleContext(MOZ_GTK_WINDOW, direction); gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height); } if (gtk_check_version(3, 20, 0) == nullptr) { return moz_gtk_scrollbar_paint(widget, cr, rect, state, direction); } else { WidgetNodeType trough_widget = (widget == MOZ_GTK_SCROLLBAR_HORIZONTAL) ? MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL : MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL; return moz_gtk_scrollbar_trough_paint(trough_widget, cr, rect, state, direction); } break; case MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL: case MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL: if (gtk_check_version(3, 20, 0) == nullptr) { return moz_gtk_scrollbar_trough_paint(widget, cr, rect, state, direction); } break; case MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL: case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL: return moz_gtk_scrollbar_thumb_paint(widget, cr, rect, state, direction); break; case MOZ_GTK_SCALE_HORIZONTAL: case MOZ_GTK_SCALE_VERTICAL: return moz_gtk_scale_paint(cr, rect, state, (GtkOrientation)flags, direction); break; case MOZ_GTK_SCALE_THUMB_HORIZONTAL: case MOZ_GTK_SCALE_THUMB_VERTICAL: return moz_gtk_scale_thumb_paint(cr, rect, state, (GtkOrientation)flags, direction); break; case MOZ_GTK_INNER_SPIN_BUTTON: return moz_gtk_inner_spin_paint(cr, rect, state, direction); break; case MOZ_GTK_SPINBUTTON: return moz_gtk_spin_paint(cr, rect, state, direction); break; case MOZ_GTK_SPINBUTTON_UP: case MOZ_GTK_SPINBUTTON_DOWN: return moz_gtk_spin_updown_paint( cr, rect, (widget == MOZ_GTK_SPINBUTTON_DOWN), state, direction); break; case MOZ_GTK_SPINBUTTON_ENTRY: { GtkStyleContext* style = GetStyleContext(MOZ_GTK_SPINBUTTON_ENTRY, state->scale, direction, GetStateFlagsFromGtkWidgetState(state)); gint ret = moz_gtk_entry_paint(cr, rect, state, style, widget); return ret; } break; case MOZ_GTK_GRIPPER: return moz_gtk_gripper_paint(cr, rect, state, direction); break; case MOZ_GTK_TREEVIEW: return moz_gtk_treeview_paint(cr, rect, state, direction); break; case MOZ_GTK_TREE_HEADER_CELL: return moz_gtk_tree_header_cell_paint(cr, rect, state, flags, direction); break; case MOZ_GTK_TREE_HEADER_SORTARROW: return moz_gtk_tree_header_sort_arrow_paint( cr, rect, state, (GtkArrowType)flags, direction); break; case MOZ_GTK_TREEVIEW_EXPANDER: return moz_gtk_treeview_expander_paint( cr, rect, state, (GtkExpanderStyle)flags, direction); break; case MOZ_GTK_ENTRY: case MOZ_GTK_DROPDOWN_ENTRY: { GtkStyleContext* style = GetStyleContext(widget, state->scale, direction, GetStateFlagsFromGtkWidgetState(state)); gint ret = moz_gtk_entry_paint(cr, rect, state, style, widget); return ret; } case MOZ_GTK_TEXT_VIEW: return moz_gtk_text_view_paint(cr, rect, state, direction); break; case MOZ_GTK_DROPDOWN: return moz_gtk_combo_box_paint(cr, rect, state, direction); break; case MOZ_GTK_DROPDOWN_ARROW: return moz_gtk_combo_box_entry_button_paint(cr, rect, state, flags, direction); break; case MOZ_GTK_CHECKBUTTON_CONTAINER: case MOZ_GTK_RADIOBUTTON_CONTAINER: return moz_gtk_container_paint(cr, rect, state, widget, direction); break; case MOZ_GTK_CHECKBUTTON_LABEL: case MOZ_GTK_RADIOBUTTON_LABEL: return moz_gtk_toggle_label_paint( cr, rect, state, (widget == MOZ_GTK_RADIOBUTTON_LABEL), direction); break; case MOZ_GTK_TOOLBAR: return moz_gtk_toolbar_paint(cr, rect, state, direction); break; case MOZ_GTK_TOOLBAR_SEPARATOR: return moz_gtk_toolbar_separator_paint(cr, rect, state, direction); break; case MOZ_GTK_TOOLTIP: return moz_gtk_tooltip_paint(cr, rect, state, direction); break; case MOZ_GTK_FRAME: return moz_gtk_frame_paint(cr, rect, state, direction); break; case MOZ_GTK_RESIZER: return moz_gtk_resizer_paint(cr, rect, state, direction); break; case MOZ_GTK_PROGRESSBAR: return moz_gtk_progressbar_paint(cr, rect, state, direction); break; case MOZ_GTK_PROGRESS_CHUNK: case MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE: case MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE: return moz_gtk_progress_chunk_paint(cr, rect, state, direction, widget); break; case MOZ_GTK_TAB_TOP: case MOZ_GTK_TAB_BOTTOM: return moz_gtk_tab_paint(cr, rect, state, (GtkTabFlags)flags, direction, widget); break; case MOZ_GTK_TABPANELS: return moz_gtk_tabpanels_paint(cr, rect, state, direction); break; case MOZ_GTK_TAB_SCROLLARROW: return moz_gtk_tab_scroll_arrow_paint(cr, rect, state, (GtkArrowType)flags, direction); break; case MOZ_GTK_MENUBAR: return moz_gtk_menu_bar_paint(cr, rect, state, direction); break; case MOZ_GTK_MENUPOPUP: return moz_gtk_menu_popup_paint(cr, rect, state, direction); break; case MOZ_GTK_MENUSEPARATOR: return moz_gtk_menu_separator_paint(cr, rect, state, direction); break; case MOZ_GTK_MENUBARITEM: case MOZ_GTK_MENUITEM: return moz_gtk_menu_item_paint(widget, cr, rect, state, direction); break; case MOZ_GTK_MENUARROW: return moz_gtk_menu_arrow_paint(cr, rect, state, direction); break; case MOZ_GTK_TOOLBARBUTTON_ARROW: return moz_gtk_arrow_paint(cr, rect, state, (GtkArrowType)flags, direction); break; case MOZ_GTK_CHECKMENUITEM: case MOZ_GTK_RADIOMENUITEM: return moz_gtk_check_menu_item_paint(widget, cr, rect, state, (gboolean)flags, direction); break; case MOZ_GTK_SPLITTER_HORIZONTAL: return moz_gtk_vpaned_paint(cr, rect, state); break; case MOZ_GTK_SPLITTER_VERTICAL: return moz_gtk_hpaned_paint(cr, rect, state); break; case MOZ_GTK_WINDOW: return moz_gtk_window_paint(cr, rect, direction); break; case MOZ_GTK_INFO_BAR: return moz_gtk_info_bar_paint(cr, rect, state); break; case MOZ_GTK_HEADER_BAR: case MOZ_GTK_HEADER_BAR_MAXIMIZED: return moz_gtk_header_bar_paint(widget, cr, rect, state); break; default: g_warning("Unknown widget type: %d", widget); } return MOZ_GTK_UNKNOWN_WIDGET; } gint moz_gtk_shutdown() { /* This will destroy all of our widgets */ ResetWidgetCache(); return MOZ_GTK_SUCCESS; }