The Tor Browser: comparison widget/gtk/gtk3drawing.c

--1:000000000000
+:d9984a2f0f9f
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 <gtk/gtk.h>
+#include <gdk/gdkprivate.h>
+#include <string.h>
+#include "gtkdrawing.h"
+#include "nsDebug.h"
+#include "prinrval.h"
+#include <math.h>
+static GtkWidget* gProtoWindow;
+static GtkWidget* gProtoLayout;
+static GtkWidget* gButtonWidget;
+static GtkWidget* gToggleMenuButtonWidget;
+static GtkWidget* gButtonArrowWidget;
+static GtkWidget* gCheckboxWidget;
+static GtkWidget* gRadiobuttonWidget;
+static GtkWidget* gHorizScrollbarWidget;
+static GtkWidget* gVertScrollbarWidget;
+static GtkWidget* gSpinWidget;
+static GtkWidget* gHScaleWidget;
+static GtkWidget* gVScaleWidget;
+static GtkWidget* gEntryWidget;
+static GtkWidget* gComboBoxWidget;
+static GtkWidget* gComboBoxButtonWidget;
+static GtkWidget* gComboBoxArrowWidget;
+static GtkWidget* gComboBoxSeparatorWidget;
+static GtkWidget* gComboBoxEntryWidget;
+static GtkWidget* gComboBoxEntryTextareaWidget;
+static GtkWidget* gComboBoxEntryButtonWidget;
+static GtkWidget* gComboBoxEntryArrowWidget;
+static GtkWidget* gHandleBoxWidget;
+static GtkWidget* gToolbarWidget;
+static GtkWidget* gFrameWidget;
+static GtkWidget* gStatusbarWidget;
+static GtkWidget* gProgressWidget;
+static GtkWidget* gTabWidget;
+static GtkWidget* gTooltipWidget;
+static GtkWidget* gMenuBarWidget;
+static GtkWidget* gMenuBarItemWidget;
+static GtkWidget* gMenuPopupWidget;
+static GtkWidget* gMenuItemWidget;
+static GtkWidget* gImageMenuItemWidget;
+static GtkWidget* gCheckMenuItemWidget;
+static GtkWidget* gTreeViewWidget;
+static GtkTreeViewColumn* gMiddleTreeViewColumn;
+static GtkWidget* gTreeHeaderCellWidget;
+static GtkWidget* gTreeHeaderSortArrowWidget;
+static GtkWidget* gExpanderWidget;
+static GtkWidget* gToolbarSeparatorWidget;
+static GtkWidget* gMenuSeparatorWidget;
+static GtkWidget* gHPanedWidget;
+static GtkWidget* gVPanedWidget;
+static GtkWidget* gScrolledWindowWidget;
+static style_prop_t style_prop_func;
+static gboolean have_arrow_scaling;
+static gboolean is_initialized;
+#define ARROW_UP      0
+#define ARROW_DOWN    G_PI
+#define ARROW_RIGHT   G_PI_2
+#define ARROW_LEFT    (G_PI+G_PI_2)
+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 |= GTK_STATE_FLAG_ACTIVE;
+if (state->inHover)
+stateFlags |= GTK_STATE_FLAG_PRELIGHT;
+if (state->focused)
+stateFlags |= GTK_STATE_FLAG_FOCUSED;
+}
+return stateFlags;
+}
+/* Because we have such an unconventional way of drawing widgets, signal to the GTK theme engine
+that they are drawing for Mozilla instead of a conventional GTK app so they can do any specific
+things they may want to do. */
+static void
+moz_gtk_set_widget_name(GtkWidget* widget)
+{
+gtk_widget_set_name(widget, "MozillaGtkWidget");
+}
+gint
+moz_gtk_enable_style_props(style_prop_t styleGetProp)
+{
+style_prop_func = styleGetProp;
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_window_widget()
+{
+if (!gProtoWindow) {
+gProtoWindow = gtk_window_new(GTK_WINDOW_POPUP);
+gtk_widget_realize(gProtoWindow);
+moz_gtk_set_widget_name(gProtoWindow);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+setup_widget_prototype(GtkWidget* widget)
+{
+ensure_window_widget();
+if (!gProtoLayout) {
+gProtoLayout = gtk_fixed_new();
+gtk_container_add(GTK_CONTAINER(gProtoWindow), gProtoLayout);
+}
+gtk_container_add(GTK_CONTAINER(gProtoLayout), widget);
+gtk_widget_realize(widget);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_button_widget()
+{
+if (!gButtonWidget) {
+gButtonWidget = gtk_button_new_with_label("M");
+setup_widget_prototype(gButtonWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_hpaned_widget()
+{
+if (!gHPanedWidget) {
+gHPanedWidget = gtk_hpaned_new();
+setup_widget_prototype(gHPanedWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_vpaned_widget()
+{
+if (!gVPanedWidget) {
+gVPanedWidget = gtk_vpaned_new();
+setup_widget_prototype(gVPanedWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_toggle_menu_button_widget()
+{
+if (!gToggleMenuButtonWidget) {
+gToggleMenuButtonWidget = gtk_menu_button_new();
+setup_widget_prototype(gToggleMenuButtonWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_button_arrow_widget()
+{
+if (!gButtonArrowWidget) {
+ensure_toggle_menu_button_widget();
+gButtonArrowWidget = gtk_bin_get_child(GTK_BIN(gToggleMenuButtonWidget));
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_checkbox_widget()
+{
+if (!gCheckboxWidget) {
+gCheckboxWidget = gtk_check_button_new_with_label("M");
+setup_widget_prototype(gCheckboxWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_radiobutton_widget()
+{
+if (!gRadiobuttonWidget) {
+gRadiobuttonWidget = gtk_radio_button_new_with_label(NULL, "M");
+setup_widget_prototype(gRadiobuttonWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_scrollbar_widget()
+{
+if (!gVertScrollbarWidget) {
+gVertScrollbarWidget = gtk_vscrollbar_new(NULL);
+setup_widget_prototype(gVertScrollbarWidget);
+}
+if (!gHorizScrollbarWidget) {
+gHorizScrollbarWidget = gtk_hscrollbar_new(NULL);
+setup_widget_prototype(gHorizScrollbarWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_spin_widget()
+{
+if (!gSpinWidget) {
+gSpinWidget = gtk_spin_button_new(NULL, 1, 0);
+setup_widget_prototype(gSpinWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_scale_widget()
+{
+if (!gHScaleWidget) {
+gHScaleWidget = gtk_hscale_new(NULL);
+setup_widget_prototype(gHScaleWidget);
+}
+if (!gVScaleWidget) {
+gVScaleWidget = gtk_vscale_new(NULL);
+setup_widget_prototype(gVScaleWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_entry_widget()
+{
+if (!gEntryWidget) {
+gEntryWidget = gtk_entry_new();
+setup_widget_prototype(gEntryWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+/* We need to have pointers to the inner widgets (button, separator, arrow)
+* of the ComboBox to get the correct rendering from theme engines which
+* special cases their look. Since the inner layout can change, we ask GTK
+* to NULL our pointers when they are about to become invalid because the
+* corresponding widgets don't exist anymore. It's the role of
+* g_object_add_weak_pointer().
+* Note that if we don't find the inner widgets (which shouldn't happen), we
+* fallback to use generic "non-inner" widgets, and they don't need that kind
+* of weak pointer since they are explicit children of gProtoWindow and as
+* such GTK holds a strong reference to them. */
+static void
+moz_gtk_get_combo_box_inner_button(GtkWidget *widget, gpointer client_data)
+{
+if (GTK_IS_TOGGLE_BUTTON(widget)) {
+gComboBoxButtonWidget = widget;
+g_object_add_weak_pointer(G_OBJECT(widget),
+(gpointer) &gComboBoxButtonWidget);
+gtk_widget_realize(widget);
+}
+}
+static void
+moz_gtk_get_combo_box_button_inner_widgets(GtkWidget *widget,
+gpointer client_data)
+{
+if (GTK_IS_SEPARATOR(widget)) {
+gComboBoxSeparatorWidget = widget;
+g_object_add_weak_pointer(G_OBJECT(widget),
+(gpointer) &gComboBoxSeparatorWidget);
+} else if (GTK_IS_ARROW(widget)) {
+gComboBoxArrowWidget = widget;
+g_object_add_weak_pointer(G_OBJECT(widget),
+(gpointer) &gComboBoxArrowWidget);
+} else
+return;
+gtk_widget_realize(widget);
+}
+static gint
+ensure_combo_box_widgets()
+{
+GtkWidget* buttonChild;
+if (gComboBoxButtonWidget && gComboBoxArrowWidget)
+return MOZ_GTK_SUCCESS;
+/* Create a ComboBox if needed */
+if (!gComboBoxWidget) {
+gComboBoxWidget = gtk_combo_box_new();
+setup_widget_prototype(gComboBoxWidget);
+}
+/* Get its inner Button */
+gtk_container_forall(GTK_CONTAINER(gComboBoxWidget),
+moz_gtk_get_combo_box_inner_button,
+NULL);
+if (gComboBoxButtonWidget) {
+/* Get the widgets inside the Button */
+buttonChild = gtk_bin_get_child(GTK_BIN(gComboBoxButtonWidget));
+if (GTK_IS_BOX(buttonChild)) {
+/* appears-as-list = FALSE, cell-view = TRUE; the button
+* contains an hbox. This hbox is there because the ComboBox
+* needs to place a cell renderer, a separator, and an arrow in
+* the button when appears-as-list is FALSE. */
+gtk_container_forall(GTK_CONTAINER(buttonChild),
+moz_gtk_get_combo_box_button_inner_widgets,
+NULL);
+} else if(GTK_IS_ARROW(buttonChild)) {
+/* appears-as-list = TRUE, or cell-view = FALSE;
+* the button only contains an arrow */
+gComboBoxArrowWidget = buttonChild;
+g_object_add_weak_pointer(G_OBJECT(buttonChild), (gpointer)
+&gComboBoxArrowWidget);
+gtk_widget_realize(gComboBoxArrowWidget);
+}
+} else {
+/* Shouldn't be reached with current internal gtk implementation; we
+* use a generic toggle button as last resort fallback to avoid
+* crashing. */
+ensure_toggle_menu_button_widget();
+gComboBoxButtonWidget = gToggleMenuButtonWidget;
+}
+if (!gComboBoxArrowWidget) {
+/* Shouldn't be reached with current internal gtk implementation;
+* we gButtonArrowWidget as last resort fallback to avoid
+* crashing. */
+ensure_button_arrow_widget();
+gComboBoxArrowWidget = gButtonArrowWidget;
+}
+/* We don't test the validity of gComboBoxSeparatorWidget since there
+* is none when "appears-as-list" = TRUE or "cell-view" = FALSE; if it
+* is invalid we just won't paint it. */
+return MOZ_GTK_SUCCESS;
+}
+/* We need to have pointers to the inner widgets (entry, button, arrow) of
+* the ComboBoxEntry to get the correct rendering from theme engines which
+* special cases their look. Since the inner layout can change, we ask GTK
+* to NULL our pointers when they are about to become invalid because the
+* corresponding widgets don't exist anymore. It's the role of
+* g_object_add_weak_pointer().
+* Note that if we don't find the inner widgets (which shouldn't happen), we
+* fallback to use generic "non-inner" widgets, and they don't need that kind
+* of weak pointer since they are explicit children of gProtoWindow and as
+* such GTK holds a strong reference to them. */
+static void
+moz_gtk_get_combo_box_entry_inner_widgets(GtkWidget *widget,
+gpointer client_data)
+{
+if (GTK_IS_TOGGLE_BUTTON(widget)) {
+gComboBoxEntryButtonWidget = widget;
+g_object_add_weak_pointer(G_OBJECT(widget),
+(gpointer) &gComboBoxEntryButtonWidget);
+} else if (GTK_IS_ENTRY(widget)) {
+gComboBoxEntryTextareaWidget = widget;
+g_object_add_weak_pointer(G_OBJECT(widget),
+(gpointer) &gComboBoxEntryTextareaWidget);
+} else
+return;
+gtk_widget_realize(widget);
+}
+static void
+moz_gtk_get_combo_box_entry_arrow(GtkWidget *widget, gpointer client_data)
+{
+if (GTK_IS_ARROW(widget)) {
+gComboBoxEntryArrowWidget = widget;
+g_object_add_weak_pointer(G_OBJECT(widget),
+(gpointer) &gComboBoxEntryArrowWidget);
+gtk_widget_realize(widget);
+}
+}
+static gint
+ensure_combo_box_entry_widgets()
+{
+GtkWidget* buttonChild;
+if (gComboBoxEntryTextareaWidget &&
+gComboBoxEntryButtonWidget &&
+gComboBoxEntryArrowWidget)
+return MOZ_GTK_SUCCESS;
+/* Create a ComboBoxEntry if needed */
+if (!gComboBoxEntryWidget) {
+gComboBoxEntryWidget = gtk_combo_box_new_with_entry();
+setup_widget_prototype(gComboBoxEntryWidget);
+}
+/* Get its inner Entry and Button */
+gtk_container_forall(GTK_CONTAINER(gComboBoxEntryWidget),
+moz_gtk_get_combo_box_entry_inner_widgets,
+NULL);
+if (!gComboBoxEntryTextareaWidget) {
+ensure_entry_widget();
+gComboBoxEntryTextareaWidget = gEntryWidget;
+}
+if (gComboBoxEntryButtonWidget) {
+/* Get the Arrow inside the Button */
+buttonChild = gtk_bin_get_child(GTK_BIN(gComboBoxEntryButtonWidget));
+if (GTK_IS_BOX(buttonChild)) {
+/* appears-as-list = FALSE, cell-view = TRUE; the button
+* contains an hbox. This hbox is there because the ComboBox
+* needs to place a cell renderer, a separator, and an arrow in
+* the button when appears-as-list is FALSE. */
+gtk_container_forall(GTK_CONTAINER(buttonChild),
+moz_gtk_get_combo_box_entry_arrow,
+NULL);
+} else if(GTK_IS_ARROW(buttonChild)) {
+/* appears-as-list = TRUE, or cell-view = FALSE;
+* the button only contains an arrow */
+gComboBoxEntryArrowWidget = buttonChild;
+g_object_add_weak_pointer(G_OBJECT(buttonChild), (gpointer)
+&gComboBoxEntryArrowWidget);
+gtk_widget_realize(gComboBoxEntryArrowWidget);
+}
+} else {
+/* Shouldn't be reached with current internal gtk implementation;
+* we use a generic toggle button as last resort fallback to avoid
+* crashing. */
+ensure_toggle_menu_button_widget();
+gComboBoxEntryButtonWidget = gToggleMenuButtonWidget;
+}
+if (!gComboBoxEntryArrowWidget) {
+/* Shouldn't be reached with current internal gtk implementation;
+* we gButtonArrowWidget as last resort fallback to avoid
+* crashing. */
+ensure_button_arrow_widget();
+gComboBoxEntryArrowWidget = gButtonArrowWidget;
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_handlebox_widget()
+{
+if (!gHandleBoxWidget) {
+gHandleBoxWidget = gtk_handle_box_new();
+setup_widget_prototype(gHandleBoxWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_toolbar_widget()
+{
+if (!gToolbarWidget) {
+ensure_handlebox_widget();
+gToolbarWidget = gtk_toolbar_new();
+gtk_container_add(GTK_CONTAINER(gHandleBoxWidget), gToolbarWidget);
+gtk_widget_realize(gToolbarWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_toolbar_separator_widget()
+{
+if (!gToolbarSeparatorWidget) {
+ensure_toolbar_widget();
+gToolbarSeparatorWidget = GTK_WIDGET(gtk_separator_tool_item_new());
+setup_widget_prototype(gToolbarSeparatorWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_tooltip_widget()
+{
+if (!gTooltipWidget) {
+gTooltipWidget = gtk_window_new(GTK_WINDOW_POPUP);
+gtk_widget_realize(gTooltipWidget);
+moz_gtk_set_widget_name(gTooltipWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_tab_widget()
+{
+if (!gTabWidget) {
+gTabWidget = gtk_notebook_new();
+setup_widget_prototype(gTabWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_progress_widget()
+{
+if (!gProgressWidget) {
+gProgressWidget = gtk_progress_bar_new();
+setup_widget_prototype(gProgressWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_statusbar_widget()
+{
+if (!gStatusbarWidget) {
+gStatusbarWidget = gtk_statusbar_new();
+setup_widget_prototype(gStatusbarWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_frame_widget()
+{
+if (!gFrameWidget) {
+ensure_statusbar_widget();
+gFrameWidget = gtk_frame_new(NULL);
+gtk_container_add(GTK_CONTAINER(gStatusbarWidget), gFrameWidget);
+gtk_widget_realize(gFrameWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_menu_bar_widget()
+{
+if (!gMenuBarWidget) {
+gMenuBarWidget = gtk_menu_bar_new();
+setup_widget_prototype(gMenuBarWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_menu_bar_item_widget()
+{
+if (!gMenuBarItemWidget) {
+ensure_menu_bar_widget();
+gMenuBarItemWidget = gtk_menu_item_new();
+gtk_menu_shell_append(GTK_MENU_SHELL(gMenuBarWidget),
+gMenuBarItemWidget);
+gtk_widget_realize(gMenuBarItemWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_menu_popup_widget()
+{
+if (!gMenuPopupWidget) {
+ensure_menu_bar_item_widget();
+gMenuPopupWidget = gtk_menu_new();
+gtk_menu_item_set_submenu(GTK_MENU_ITEM(gMenuBarItemWidget),
+gMenuPopupWidget);
+gtk_widget_realize(gMenuPopupWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_menu_item_widget()
+{
+if (!gMenuItemWidget) {
+ensure_menu_popup_widget();
+gMenuItemWidget = gtk_menu_item_new_with_label("M");
+gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
+gMenuItemWidget);
+gtk_widget_realize(gMenuItemWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_image_menu_item_widget()
+{
+if (!gImageMenuItemWidget) {
+ensure_menu_popup_widget();
+gImageMenuItemWidget = gtk_image_menu_item_new();
+gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
+gImageMenuItemWidget);
+gtk_widget_realize(gImageMenuItemWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_menu_separator_widget()
+{
+if (!gMenuSeparatorWidget) {
+ensure_menu_popup_widget();
+gMenuSeparatorWidget = gtk_separator_menu_item_new();
+gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
+gMenuSeparatorWidget);
+gtk_widget_realize(gMenuSeparatorWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_check_menu_item_widget()
+{
+if (!gCheckMenuItemWidget) {
+ensure_menu_popup_widget();
+gCheckMenuItemWidget = gtk_check_menu_item_new_with_label("M");
+gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
+gCheckMenuItemWidget);
+gtk_widget_realize(gCheckMenuItemWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_tree_view_widget()
+{
+if (!gTreeViewWidget) {
+gTreeViewWidget = gtk_tree_view_new();
+setup_widget_prototype(gTreeViewWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_tree_header_cell_widget()
+{
+if(!gTreeHeaderCellWidget) {
+/*
+* Some GTK engines paint the first and last cell
+* of a TreeView header with a highlight.
+* Since we do not know where our widget will be relative
+* to the other buttons in the TreeView header, we must
+* paint it as a button that is between two others,
+* thus ensuring it is neither the first or last button
+* in the header.
+* GTK doesn't give us a way to do this explicitly,
+* so we must paint with a button that is between two
+* others.
+*/
+GtkTreeViewColumn* firstTreeViewColumn;
+GtkTreeViewColumn* lastTreeViewColumn;
+ensure_tree_view_widget();
+/* Create and append our three columns */
+firstTreeViewColumn = gtk_tree_view_column_new();
+gtk_tree_view_column_set_title(firstTreeViewColumn, "M");
+gtk_tree_view_append_column(GTK_TREE_VIEW(gTreeViewWidget), firstTreeViewColumn);
+gMiddleTreeViewColumn = gtk_tree_view_column_new();
+gtk_tree_view_column_set_title(gMiddleTreeViewColumn, "M");
+gtk_tree_view_append_column(GTK_TREE_VIEW(gTreeViewWidget),
+gMiddleTreeViewColumn);
+lastTreeViewColumn = gtk_tree_view_column_new();
+gtk_tree_view_column_set_title(lastTreeViewColumn, "M");
+gtk_tree_view_append_column(GTK_TREE_VIEW(gTreeViewWidget), lastTreeViewColumn);
+/* Use the middle column's header for our button */
+gTreeHeaderCellWidget = gtk_tree_view_column_get_button(gMiddleTreeViewColumn);
+/* TODO, but it can't be NULL */
+gTreeHeaderSortArrowWidget = gtk_button_new();
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_expander_widget()
+{
+if (!gExpanderWidget) {
+gExpanderWidget = gtk_expander_new("M");
+setup_widget_prototype(gExpanderWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+static gint
+ensure_scrolled_window_widget()
+{
+if (!gScrolledWindowWidget) {
+gScrolledWindowWidget = gtk_scrolled_window_new(NULL, NULL);
+setup_widget_prototype(gScrolledWindowWidget);
+}
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_init()
+{
+GtkWidgetClass *entry_class;
+if (is_initialized)
+return MOZ_GTK_SUCCESS;
+is_initialized = TRUE;
+have_arrow_scaling = (gtk_major_version > 2 ||
+(gtk_major_version == 2 && gtk_minor_version >= 12));
+/* Add style property to GtkEntry.
+* Adding the style property to the normal GtkEntry class means that it
+* will work without issues inside GtkComboBox and for Spinbuttons. */
+entry_class = g_type_class_ref(GTK_TYPE_ENTRY);
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_checkbox_get_metrics(gint* indicator_size, gint* indicator_spacing)
+{
+ensure_checkbox_widget();
+gtk_widget_style_get (gCheckboxWidget,
+"indicator_size", indicator_size,
+"indicator_spacing", indicator_spacing,
+NULL);
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_radio_get_metrics(gint* indicator_size, gint* indicator_spacing)
+{
+ensure_radiobutton_widget();
+gtk_widget_style_get (gRadiobuttonWidget,
+"indicator_size", indicator_size,
+"indicator_spacing", indicator_spacing,
+NULL);
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_widget_get_focus(GtkWidget* widget, gboolean* interior_focus,
+gint* focus_width, gint* focus_pad)
+{
+gtk_widget_style_get (widget,
+"interior-focus", interior_focus,
+"focus-line-width", focus_width,
+"focus-padding", focus_pad,
+NULL);
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_menuitem_get_horizontal_padding(gint* horizontal_padding)
+{
+ensure_menu_item_widget();
+gtk_widget_style_get (gMenuItemWidget,
+"horizontal-padding", horizontal_padding,
+NULL);
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_checkmenuitem_get_horizontal_padding(gint* horizontal_padding)
+{
+ensure_check_menu_item_widget();
+gtk_widget_style_get (gCheckMenuItemWidget,
+"horizontal-padding", horizontal_padding,
+NULL);
+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;
+ensure_button_widget();
+gtk_widget_style_get(gButtonWidget,
+"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;
+ensure_button_widget();
+gtk_widget_style_get(gButtonWidget,
+"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)
+{
+if (orientation == GTK_ORIENTATION_HORIZONTAL) {
+ensure_hpaned_widget();
+gtk_widget_style_get(gHPanedWidget, "handle_size", size, NULL);
+} else {
+ensure_vpaned_widget();
+gtk_widget_style_get(gVPanedWidget, "handle_size", size, NULL);
+}
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_button_get_inner_border(GtkWidget* widget, GtkBorder* inner_border)
+{
+static const GtkBorder default_inner_border = { 1, 1, 1, 1 };
+GtkBorder *tmp_border;
+gtk_widget_style_get (widget, "inner-border", &tmp_border, NULL);
+if (tmp_border) {
+*inner_border = *tmp_border;
+gtk_border_free(tmp_border);
+}
+else
+*inner_border = default_inner_border;
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_button_paint(cairo_t *cr, 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;
+gboolean interior_focus;
+gint focus_width, focus_pad;
+moz_gtk_widget_get_focus(widget, &interior_focus, &focus_width, &focus_pad);
+gtk_widget_set_direction(widget, direction);
+if (!interior_focus && state->focused) {
+x += focus_width + focus_pad;
+y += focus_width + focus_pad;
+width -= 2 * (focus_width + focus_pad);
+height -= 2 * (focus_width + focus_pad);
+}
+gtk_style_context_save(style);
+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);
+}
+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) {
+if (interior_focus) {
+GtkBorder border;
+gtk_style_context_get_border(style, state_flags, &border);
+x += border.left + focus_pad;
+y += border.top + focus_pad;
+width -= 2 * (border.left + focus_pad);
+height -= 2 * (border.top + focus_pad);
+} else {
+x -= focus_width + focus_pad;
+y -= focus_width + focus_pad;
+width += 2 * (focus_width + focus_pad);
+height += 2 * (focus_width + focus_pad);
+}
+gtk_render_focus(style, cr, x, y, width, height);
+}
+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)
+{
+gint indicator_size, indicator_spacing;
+gint x, y, width, height;
+gint focus_x, focus_y, focus_width, focus_height;
+GtkWidget *w;
+GtkStyleContext *style;
+if (isradio) {
+moz_gtk_radio_get_metrics(&indicator_size, &indicator_spacing);
+w = gRadiobuttonWidget;
+} else {
+moz_gtk_checkbox_get_metrics(&indicator_size, &indicator_spacing);
+w = gCheckboxWidget;
+}
+// XXX we should assert rect->height >= indicator_size too
+// after bug 369581 is fixed.
+NS_ASSERTION(rect->width >= indicator_size,
+"GetMinimumWidgetSize was ignored");
+// Paint it center aligned in the rect.
+x = rect->x + (rect->width - indicator_size) / 2;
+y = rect->y + (rect->height - indicator_size) / 2;
+width = indicator_size;
+height = indicator_size;
+focus_x = x - indicator_spacing;
+focus_y = y - indicator_spacing;
+focus_width = width + 2 * indicator_spacing;
+focus_height = height + 2 * indicator_spacing;
+style = gtk_widget_get_style_context(w);
+gtk_widget_set_sensitive(w, !state->disabled);
+gtk_widget_set_direction(w, direction);
+gtk_style_context_save(style);
+if (isradio) {
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_RADIO);
+gtk_style_context_set_state(style, selected ? GTK_STATE_FLAG_ACTIVE :
+GTK_STATE_FLAG_NORMAL);
+gtk_render_option(style, cr, x, y, width, height);
+if (state->focused) {
+gtk_render_focus(style, cr, focus_x, focus_y,
+focus_width, focus_height);
+}
+}
+else {
+/*
+* 'indeterminate' type on checkboxes. In GTK, the shadow type
+* must also be changed for the state to be drawn.
+*/
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_CHECK);
+if (inconsistent) {
+gtk_style_context_set_state(style, GTK_STATE_FLAG_INCONSISTENT);
+gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(gCheckboxWidget), TRUE);
+} else if (selected) {
+gtk_style_context_set_state(style, GTK_STATE_FLAG_ACTIVE);
+} else {
+gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(gCheckboxWidget), FALSE);
+}
+gtk_render_check(style, cr, x, y, width, height);
+if (state->focused) {
+gtk_render_focus(style, cr,
+focus_x, focus_y, focus_width, focus_height);
+}
+}
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+calculate_button_inner_rect(GtkWidget* button, GdkRectangle* rect,
+GdkRectangle* inner_rect,
+GtkTextDirection direction,
+gboolean ignore_focus)
+{
+GtkBorder inner_border;
+gboolean interior_focus;
+gint focus_width, focus_pad;
+GtkStyleContext* style;
+GtkBorder border;
+style = gtk_widget_get_style_context(button);
+/* This mirrors gtkbutton's child positioning */
+moz_gtk_button_get_inner_border(button, &inner_border);
+moz_gtk_widget_get_focus(button, &interior_focus,
+&focus_width, &focus_pad);
+if (ignore_focus)
+focus_width = focus_pad = 0;
+gtk_style_context_get_border(style, 0, &border);
+inner_rect->x = rect->x + border.left + focus_width + focus_pad;
+inner_rect->x += direction == GTK_TEXT_DIR_LTR ?
+inner_border.left : inner_border.right;
+inner_rect->y = rect->y + inner_border.top + border.top +
+focus_width + focus_pad;
+inner_rect->width = MAX(1, rect->width - inner_border.left -
+inner_border.right - (border.left + focus_pad + focus_width) * 2);
+inner_rect->height = MAX(1, rect->height - inner_border.top -
+inner_border.bottom - (border.top + focus_pad + focus_width) * 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);
+if (have_arrow_scaling)
+gtk_widget_style_get(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 gint
+moz_gtk_scrollbar_button_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+GtkScrollbarButtonFlags flags,
+GtkTextDirection direction)
+{
+GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+GtkStateType saved_state;
+GdkRectangle arrow_rect;
+gdouble arrow_angle;
+GtkStyleContext* style;
+GtkWidget *scrollbar;
+gint arrow_displacement_x, arrow_displacement_y;
+const char* detail = (flags & MOZ_GTK_STEPPER_VERTICAL) ?
+"vscrollbar" : "hscrollbar";
+ensure_scrollbar_widget();
+if (flags & MOZ_GTK_STEPPER_VERTICAL)
+scrollbar = gVertScrollbarWidget;
+else
+scrollbar = gHorizScrollbarWidget;
+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_SCROLLBAR);
+gtk_style_context_set_state(style, state_flags);
+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;
+arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
+arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2;
+if (state_flags & GTK_STATE_FLAG_ACTIVE) {
+gtk_widget_style_get(scrollbar,
+"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_rect.width);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_scrollbar_trough_paint(GtkThemeWidgetType widget,
+cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+GtkScrollbar *scrollbar;
+ensure_scrollbar_widget();
+if (widget ==  MOZ_GTK_SCROLLBAR_TRACK_HORIZONTAL)
+scrollbar = GTK_SCROLLBAR(gHorizScrollbarWidget);
+else
+scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);
+gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);
+style = gtk_widget_get_style_context(GTK_WIDGET(scrollbar));
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_TROUGH);
+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 (state->focused) {
+gtk_render_focus(style, cr,
+rect->x, rect->y, rect->width, rect->height);
+}
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_scrollbar_thumb_paint(GtkThemeWidgetType widget,
+cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+GtkTextDirection direction)
+{
+GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+GtkStyleContext* style;
+GtkScrollbar *scrollbar;
+GtkAdjustment *adj;
+ensure_scrollbar_widget();
+if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL)
+scrollbar = GTK_SCROLLBAR(gHorizScrollbarWidget);
+else
+scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);
+gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);
+style = gtk_widget_get_style_context(GTK_WIDGET(scrollbar));
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_SLIDER);
+gtk_style_context_set_state(style, state_flags);
+gtk_render_slider(style, cr, rect->x, rect->y,
+rect->width,  rect->height,
+(widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) ?
+GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_spin_paint(cairo_t *cr, GdkRectangle* rect,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_spin_widget();
+gtk_widget_set_direction(gSpinWidget, direction);
+style = gtk_widget_get_style_context(gSpinWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_SPINBUTTON);
+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_spin_updown_paint(cairo_t *cr, GdkRectangle* rect,
+gboolean isDown, GtkWidgetState* state,
+GtkTextDirection direction)
+{
+GdkRectangle arrow_rect;
+GtkStyleContext* style;
+ensure_spin_widget();
+style = gtk_widget_get_style_context(gSpinWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_SPINBUTTON);
+gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
+gtk_widget_set_direction(gSpinWidget, 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);
+/* hard code these values */
+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);
+gtk_style_context_restore(style);
+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 = 0, y = 0;
+GtkStyleContext* style;
+GtkWidget* widget;
+GtkBorder margin;
+ensure_scale_widget();
+widget = ((flags == GTK_ORIENTATION_HORIZONTAL) ? gHScaleWidget : gVScaleWidget);
+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_SCALE);
+gtk_style_context_get_margin(style, state_flags, &margin);
+if (flags == GTK_ORIENTATION_HORIZONTAL) {
+x = margin.left;
+y++;
+}
+else {
+x++;
+y = margin.top;
+}
+gtk_render_frame(style, cr, rect->x + x, rect->y + y,
+rect->width - 2*x, rect->height - 2*y);
+if (state->focused)
+gtk_render_focus(style, cr,
+rect->x, rect->y, rect->width, rect->height);
+gtk_style_context_restore(style);
+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;
+GtkWidget* widget;
+gint thumb_width, thumb_height, x, y;
+ensure_scale_widget();
+widget = ((flags == GTK_ORIENTATION_HORIZONTAL) ? gHScaleWidget : gVScaleWidget);
+gtk_widget_set_direction(widget, direction);
+style = gtk_widget_get_style_context(widget);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_SLIDER);
+gtk_style_context_save(style);
+gtk_style_context_set_state(style, state_flags);
+/* 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;
+}
+gtk_render_slider(style, cr, x, y, thumb_width, thumb_height, flags);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_gripper_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_handlebox_widget();
+gtk_widget_set_direction(gHandleBoxWidget, direction);
+style = gtk_widget_get_style_context(gHandleBoxWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_GRIP);
+gtk_style_context_set_state(style, 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);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_hpaned_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state)
+{
+GtkStyleContext* style;
+ensure_hpaned_widget();
+style = gtk_widget_get_style_context(gHPanedWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_PANE_SEPARATOR);
+gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
+gtk_render_handle(style, cr,
+rect->x, rect->y, rect->width, rect->height);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_vpaned_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state)
+{
+GtkStyleContext* style;
+ensure_vpaned_widget();
+style = gtk_widget_get_style_context(gVPanedWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_PANE_SEPARATOR);
+gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
+gtk_render_handle(style, cr,
+rect->x, rect->y, rect->width, rect->height);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+// See gtk_entry_draw() for reference.
+static gint
+moz_gtk_entry_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+GtkWidget* widget, GtkTextDirection direction)
+{
+gint x = rect->x, y = rect->y, width = rect->width, height = rect->height;
+GtkStyleContext* style;
+gboolean interior_focus;
+gint focus_width;
+gtk_widget_set_direction(widget, direction);
+style = gtk_widget_get_style_context(widget);
+gtk_widget_style_get(widget,
+"interior-focus", &interior_focus,
+"focus-line-width", &focus_width,
+NULL);
+/* gtkentry.c uses two windows, one for the entire widget and one for the
+* text area inside it. The background of both windows is set to the "base"
+* color of the new state in gtk_entry_state_changed, but only the inner
+* textarea window uses gtk_paint_flat_box when exposed */
+/* This gets us a lovely greyish disabledish look */
+gtk_widget_set_sensitive(widget, !state->disabled);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_ENTRY);
+/* Now paint the shadow and focus border.
+* We do like in gtk_entry_draw_frame, we first draw the shadow, a tad
+* smaller when focused if the focus is not interior, then the focus. */
+if (state->focused && !state->disabled) {
+/* This will get us the lit borders that focused textboxes enjoy on
+* some themes. */
+gtk_style_context_set_state(style, GTK_STATE_FLAG_FOCUSED);
+if (!interior_focus) {
+/* Indent the border a little bit if we have exterior focus
+(this is what GTK does to draw native entries) */
+x += focus_width;
+y += focus_width;
+width -= 2 * focus_width;
+height -= 2 * focus_width;
+}
+}
+if (state->disabled) {
+gtk_style_context_set_state(style, GTK_STATE_FLAG_INSENSITIVE);
+}
+gtk_render_background(style, cr, x, y, width, height);
+gtk_render_frame(style, cr, x, y, width, height);
+if (state->focused && !state->disabled) {
+if (!interior_focus) {
+gtk_render_focus(style, cr, rect->x, rect->y, rect->width, rect->height);
+}
+}
+gtk_style_context_restore(style);
+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;
+ensure_tree_view_widget();
+ensure_scrolled_window_widget();
+gtk_widget_set_direction(gTreeViewWidget, direction);
+gtk_widget_set_direction(gScrolledWindowWidget, direction);
+/* 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 = gtk_widget_get_style_context(gScrolledWindowWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME);
+gtk_style_context_get_border(style, state_flags, &border);
+xthickness = border.left;
+ythickness = border.top;
+style_tree = gtk_widget_get_style_context(gTreeViewWidget);
+gtk_style_context_save(style_tree);
+gtk_style_context_add_class(style_tree, GTK_STYLE_CLASS_VIEW);
+gtk_render_background(style_tree, cr,
+rect->x + xthickness, rect->y + ythickness,
+rect->width - 2 * xthickness,
+rect->height - 2 * ythickness);
+gtk_render_frame(style, cr,
+rect->x, rect->y, rect->width, rect->height);
+gtk_style_context_restore(style);
+gtk_style_context_restore(style_tree);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_tree_header_cell_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+gboolean isSorted, GtkTextDirection direction)
+{
+moz_gtk_button_paint(cr, rect, state, GTK_RELIEF_NORMAL,
+gTreeHeaderCellWidget, 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;
+ensure_tree_header_cell_widget();
+gtk_widget_set_direction(gTreeHeaderSortArrowWidget, direction);
+/* 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 = gtk_widget_get_style_context(gTreeHeaderSortArrowWidget);
+gtk_style_context_save(style);
+gtk_style_context_set_state(style, 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);
+gtk_style_context_restore(style);
+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)
+{
+GtkStyleContext *style;
+GtkStateFlags    state_flags;
+ensure_tree_view_widget();
+gtk_widget_set_direction(gTreeViewWidget, direction);
+style = gtk_widget_get_style_context(gTreeViewWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_EXPANDER);
+/* 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. */
+state_flags = state->disabled ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL;
+/* GTK_STATE_FLAG_ACTIVE controls expanded/colapsed state rendering
+* in gtk_render_expander()
+*/
+if (expander_state == GTK_EXPANDER_EXPANDED)
+state_flags |= GTK_STATE_FLAG_ACTIVE;
+else
+state_flags &= ~(GTK_STATE_FLAG_ACTIVE);
+gtk_style_context_set_state(style, state_flags);
+gtk_render_expander(style, cr,
+rect->x,
+rect->y,
+rect->width,
+rect->height);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+/* See gtk_separator_draw() for reference.
+*/
+static gint
+moz_gtk_combo_box_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+gboolean ishtml, GtkTextDirection direction)
+{
+GdkRectangle arrow_rect, real_arrow_rect;
+gint arrow_size, separator_width;
+gboolean wide_separators;
+GtkStyleContext* style;
+GtkRequisition arrow_req;
+ensure_combo_box_widgets();
+/* Also sets the direction on gComboBoxButtonWidget, which is then
+* inherited by the separator and arrow */
+moz_gtk_button_paint(cr, rect, state, GTK_RELIEF_NORMAL,
+gComboBoxButtonWidget, direction);
+calculate_button_inner_rect(gComboBoxButtonWidget,
+rect, &arrow_rect, direction, ishtml);
+/* 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_size_request(gComboBoxArrowWidget, &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(gComboBoxArrowWidget,
+&arrow_rect, &real_arrow_rect, direction);
+style = gtk_widget_get_style_context(gComboBoxArrowWidget);
+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. */
+if (!gComboBoxSeparatorWidget)
+return MOZ_GTK_SUCCESS;
+style = gtk_widget_get_style_context(gComboBoxSeparatorWidget);
+gtk_widget_style_get(gComboBoxSeparatorWidget,
+"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)
+{
+GtkStyleContext* style;
+GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+GdkRectangle arrow_rect;
+gdouble arrow_angle = ARROW_UP;
+ensure_button_arrow_widget();
+style = gtk_widget_get_style_context(gButtonArrowWidget);
+gtk_style_context_save(style);
+gtk_style_context_set_state(style, state_flags);
+gtk_widget_set_direction(gButtonArrowWidget, direction);
+calculate_arrow_rect(gButtonArrowWidget, rect, &arrow_rect,
+direction);
+if (direction == GTK_TEXT_DIR_RTL) {
+if (arrow_type == GTK_ARROW_LEFT)
+arrow_angle = ARROW_RIGHT;
+else if (arrow_type == GTK_ARROW_RIGHT)
+arrow_angle = ARROW_LEFT;
+} else if (arrow_type == GTK_ARROW_DOWN) {
+arrow_angle = ARROW_DOWN;
+}
+if (arrow_type != GTK_ARROW_NONE)
+gtk_render_arrow(style, cr, arrow_angle,
+arrow_rect.x, arrow_rect.y, arrow_rect.width);
+gtk_style_context_restore(style);
+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;
+ensure_combo_box_entry_widgets();
+moz_gtk_button_paint(cr, rect, state, GTK_RELIEF_NORMAL,
+gComboBoxEntryButtonWidget, direction);
+calculate_button_inner_rect(gComboBoxEntryButtonWidget,
+rect, &arrow_rect, direction, FALSE);
+if (state_flags & GTK_STATE_FLAG_ACTIVE) {
+gtk_widget_style_get(gComboBoxEntryButtonWidget,
+"child-displacement-x", &x_displacement,
+"child-displacement-y", &y_displacement,
+NULL);
+arrow_rect.x += x_displacement;
+arrow_rect.y += y_displacement;
+}
+calculate_arrow_rect(gComboBoxEntryArrowWidget,
+&arrow_rect, &real_arrow_rect, direction);
+style = gtk_widget_get_style_context(gComboBoxEntryArrowWidget);
+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,
+gboolean isradio, GtkTextDirection direction)
+{
+GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+GtkStyleContext* style;
+GtkWidget *widget;
+gboolean interior_focus;
+gint focus_width, focus_pad;
+if (isradio) {
+ensure_radiobutton_widget();
+widget = gRadiobuttonWidget;
+} else {
+ensure_checkbox_widget();
+widget = gCheckboxWidget;
+}
+gtk_widget_set_direction(widget, direction);
+style = gtk_widget_get_style_context(widget);
+gtk_style_context_save(style);
+moz_gtk_widget_get_focus(widget, &interior_focus, &focus_width, &focus_pad);
+gtk_style_context_set_state(style, 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);
+}
+if (state->focused && !interior_focus) {
+gtk_render_focus(style, cr,
+rect->x, rect->y, rect->width, rect->height);
+}
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_toggle_label_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+gboolean isradio, GtkTextDirection direction)
+{
+GtkStyleContext *style;
+GtkWidget *widget;
+gboolean interior_focus;
+if (!state->focused)
+return MOZ_GTK_SUCCESS;
+if (isradio) {
+ensure_radiobutton_widget();
+widget = gRadiobuttonWidget;
+} else {
+ensure_checkbox_widget();
+widget = gCheckboxWidget;
+}
+style = gtk_widget_get_style_context(widget);
+gtk_style_context_save(style);
+if (isradio) {
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_RADIO);
+} else {
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_CHECK);
+}
+gtk_widget_set_direction(widget, direction);
+gtk_widget_style_get(widget, "interior-focus", &interior_focus, NULL);
+if (!interior_focus)
+return MOZ_GTK_SUCCESS;
+gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
+gtk_render_focus(style, cr,
+rect->x, rect->y, rect->width, rect->height);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_toolbar_paint(cairo_t *cr, GdkRectangle* rect,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_toolbar_widget();
+gtk_widget_set_direction(gToolbarWidget, direction);
+style = gtk_widget_get_style_context(gToolbarWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOOLBAR);
+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_toolbar_paint_space_line() for reference.
+*/
+static gint
+moz_gtk_toolbar_separator_paint(cairo_t *cr, GdkRectangle* rect,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+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;
+ensure_toolbar_separator_widget();
+gtk_widget_set_direction(gToolbarSeparatorWidget, direction);
+style = gtk_widget_get_style_context(gToolbarSeparatorWidget);
+gtk_widget_style_get(gToolbarWidget,
+"wide-separators", &wide_separators,
+"separator-width", &separator_width,
+NULL);
+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, 0, &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, GdkRectangle* rect,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_tooltip_widget();
+gtk_widget_set_direction(gTooltipWidget, direction);
+style = gtk_widget_get_style_context(gTooltipWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOOLTIP);
+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_resizer_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_frame_widget();
+gtk_widget_set_direction(gStatusbarWidget, direction);
+style = gtk_widget_get_style_context(gStatusbarWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_GRIP);
+gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
+gtk_render_handle(style, cr, rect->x, rect->y, rect->width, rect->height);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_frame_paint(cairo_t *cr, GdkRectangle* rect,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_frame_widget();
+gtk_widget_set_direction(gFrameWidget, direction);
+style = gtk_widget_get_style_context(gFrameWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME);
+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_progressbar_paint(cairo_t *cr, GdkRectangle* rect,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_progress_widget();
+gtk_widget_set_direction(gProgressWidget, direction);
+style = gtk_widget_get_style_context(gProgressWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_TROUGH);
+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_progress_chunk_paint(cairo_t *cr, GdkRectangle* rect,
+GtkTextDirection direction,
+GtkThemeWidgetType widget)
+{
+GtkStyleContext* style;
+ensure_progress_widget();
+gtk_widget_set_direction(gProgressWidget, direction);
+style = gtk_widget_get_style_context(gProgressWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_PROGRESSBAR);
+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_background(style, cr, rect->x, rect->y, rect->width, rect->height);
+gtk_render_activity(style, cr, rect->x, rect->y, rect->width, rect->height);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_get_tab_thickness(void)
+{
+GtkBorder border;
+ensure_tab_widget();
+GtkStyleContext * style = gtk_widget_get_style_context(gTabWidget);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_NOTEBOOK);
+gtk_style_context_get_border(style, 0, &border);
+if (border.top < 2)
+return 2; /* some themes don't set ythickness correctly */
+return border.top;
+}
+/* actual small tabs */
+static gint
+moz_gtk_tab_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+GtkTabFlags flags, GtkTextDirection direction)
+{
+/* 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 focusRect;
+GdkRectangle backRect;
+ensure_tab_widget();
+gtk_widget_set_direction(gTabWidget, direction);
+style = gtk_widget_get_style_context(gTabWidget);
+backRect = focusRect = *rect;
+gtk_style_context_save(style);
+if ((flags & MOZ_GTK_TAB_SELECTED) == 0) {
+/* Only draw the tab */
+gtk_style_context_set_state(style, GTK_STATE_FLAG_NORMAL);
+gtk_render_extension(style, cr,
+rect->x, rect->y, rect->width, rect->height,
+(flags & MOZ_GTK_TAB_BOTTOM) ?
+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_paint_box_gap(), see comment in
+* moz_gtk_tabpanels_paint(). This box_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();
+/* 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 = 0;
+else
+gap_loffset = 0;
+}
+gtk_style_context_set_state(style, GTK_STATE_FLAG_ACTIVE);
+/* Adwaita theme engine crashes without it (rhbz#713764) */
+gtk_style_context_add_region(style, GTK_STYLE_REGION_TAB, 0);
+if (flags & MOZ_GTK_TAB_BOTTOM) {
+/* Draw the tab on bottom */
+focusRect.y += gap_voffset;
+focusRect.height -= gap_voffset;
+gtk_render_extension(style, cr,
+rect->x, rect->y + gap_voffset, rect->width,
+rect->height - gap_voffset, GTK_POS_TOP);
+gtk_style_context_remove_region(style, GTK_STYLE_REGION_TAB);
+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(style, 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(style, cr,
+rect->x - gap_loffset,
+rect->y + gap_voffset - 3 * gap_height,
+rect->width + gap_loffset + gap_roffset,
+3 * gap_height, GTK_POS_BOTTOM,
+gap_loffset, gap_loffset + rect->width);
+cairo_restore(cr);
+} else {
+/* Draw the tab on top */
+focusRect.height -= gap_voffset;
+gtk_render_extension(style, cr,
+rect->x, rect->y, rect->width,
+rect->height - gap_voffset, GTK_POS_BOTTOM);
+gtk_style_context_remove_region(style, GTK_STYLE_REGION_TAB);
+backRect.y += (rect->height - gap_voffset);
+backRect.height = gap_height;
+/* Draw the gap; erase with background color before painting in
+* case theme does not */
+gtk_render_background(style, 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(style, cr,
+rect->x - gap_loffset,
+rect->y + rect->height - gap_voffset,
+rect->width + gap_loffset + gap_roffset,
+3 * gap_height, GTK_POS_TOP,
+gap_loffset, gap_loffset + rect->width);
+cairo_restore(cr);
+}
+}
+if (state->focused) {
+/* Paint the focus ring */
+GtkBorder border;
+gtk_style_context_get_border(style, GetStateFlagsFromGtkWidgetState(state), &border);
+focusRect.x += border.left;
+focusRect.width -= (border.left + border.right);
+focusRect.y += border.top;
+focusRect.height -= (border.top + border.bottom);
+gtk_render_focus(style, cr,
+focusRect.x, focusRect.y, focusRect.width, focusRect.height);
+}
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+/* tab area*/
+static gint
+moz_gtk_tabpanels_paint(cairo_t *cr, GdkRectangle* rect,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_tab_widget();
+gtk_widget_set_direction(gTabWidget, direction);
+style = gtk_widget_get_style_context(gTabWidget);
+gtk_style_context_save(style);
+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);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_tab_scroll_arrow_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+GtkArrowType arrow_type,
+GtkTextDirection direction)
+{
+GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+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;
+ensure_tab_widget();
+style = gtk_widget_get_style_context(gTabWidget);
+gtk_style_context_save(style);
+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)  {
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_NOTEBOOK); /* TODO TEST */
+gtk_style_context_set_state(style, state_flags);
+gtk_render_arrow(style, cr, arrow_angle,
+x, y, arrow_size);
+}
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_menu_bar_paint(cairo_t *cr, GdkRectangle* rect,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_menu_bar_widget();
+gtk_widget_set_direction(gMenuBarWidget, direction);
+style = gtk_widget_get_style_context(gMenuBarWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);
+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,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_menu_popup_widget();
+gtk_widget_set_direction(gMenuPopupWidget, direction);
+style = gtk_widget_get_style_context(gMenuPopupWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENU);
+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,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+gboolean wide_separators;
+gint separator_height;
+gint paint_height;
+guint border_width;
+gint x, y, w, h;
+GtkBorder padding;
+ensure_menu_separator_widget();
+gtk_widget_set_direction(gMenuSeparatorWidget, direction);
+border_width = gtk_container_get_border_width(gMenuSeparatorWidget);
+gtk_widget_style_get(gMenuSeparatorWidget,
+"wide-separators",    &wide_separators,
+"separator-height",   &separator_height,
+NULL);
+style = gtk_widget_get_style_context(gMenuSeparatorWidget);
+gtk_style_context_get_padding(style, 0, &padding);
+x = rect->x + border_width;
+y = rect->y + border_width;
+w = rect->width - border_width * 2;
+h = rect->height - border_width * 2;
+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);
+}
+return MOZ_GTK_SUCCESS;
+}
+// See gtk_menu_item_draw() for reference.
+static gint
+moz_gtk_menu_item_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+gint flags, GtkTextDirection direction)
+{
+GtkStyleContext* style;
+GtkWidget* item_widget;
+guint border_width;
+gint x, y, w, h;
+if (state->inHover && !state->disabled) {
+if (flags & MOZ_TOPLEVEL_MENU_ITEM) {
+ensure_menu_bar_item_widget();
+item_widget = gMenuBarItemWidget;
+} else {
+ensure_menu_item_widget();
+item_widget = gMenuItemWidget;
+}
+style = gtk_widget_get_style_context(item_widget);
+gtk_style_context_save(style);
+if (flags & MOZ_TOPLEVEL_MENU_ITEM) {
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);
+}
+gtk_widget_set_direction(item_widget, direction);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUITEM);
+gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));
+border_width = gtk_container_get_border_width(GTK_CONTAINER(item_widget));
+x = rect->x + border_width;
+y = rect->y + border_width;
+w = rect->width - border_width * 2;
+h = rect->height - border_width * 2;
+gtk_render_background(style, cr, x, y, w, h);
+gtk_render_frame(style, cr, x, y, w, h);
+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)
+{
+GtkStyleContext* style;
+GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+ensure_menu_item_widget();
+gtk_widget_set_direction(gMenuItemWidget, direction);
+style = gtk_widget_get_style_context(gMenuItemWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUITEM);
+gtk_style_context_set_state(style, state_flags);
+gtk_render_arrow(style, cr,
+(direction == GTK_TEXT_DIR_LTR) ? ARROW_RIGHT : ARROW_LEFT,
+rect->x, rect->y, rect->width);
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+// See gtk_real_check_menu_item_draw_indicator() for reference.
+static gint
+moz_gtk_check_menu_item_paint(cairo_t *cr, GdkRectangle* rect,
+GtkWidgetState* state,
+gboolean checked, gboolean isradio,
+GtkTextDirection direction)
+{
+GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);
+GtkStyleContext* style;
+GtkBorder padding;
+gint offset;
+gint indicator_size, horizontal_padding;
+gint x, y;
+moz_gtk_menu_item_paint(cr, rect, state, FALSE, direction);
+ensure_check_menu_item_widget();
+gtk_widget_set_direction(gCheckMenuItemWidget, direction);
+gtk_widget_style_get (gCheckMenuItemWidget,
+"indicator-size", &indicator_size,
+"horizontal-padding", &horizontal_padding,
+NULL);
+style = gtk_widget_get_style_context(gCheckMenuItemWidget);
+gtk_style_context_save(style);
+if (isradio) {
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_RADIO);
+} else {
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_CHECK);
+}
+if (checked)
+state_flags |= GTK_STATE_FLAG_ACTIVE;
+gtk_style_context_set_state(style, state_flags);
+gtk_style_context_get_padding(style, state_flags, &padding);
+offset = gtk_container_get_border_width(GTK_CONTAINER(gCheckMenuItemWidget)) +
+padding.left + 2;
+if (direction == GTK_TEXT_DIR_RTL) {
+x = rect->width - indicator_size - offset - horizontal_padding;
+}
+else {
+x = rect->x + offset + horizontal_padding;
+}
+y = rect->y + (rect->height - indicator_size) / 2;
+if (isradio) {
+gtk_render_option(style, cr, x, y, indicator_size, indicator_size);
+} else {
+gtk_render_check(style, cr, x, y, indicator_size, indicator_size);
+}
+gtk_style_context_restore(style);
+return MOZ_GTK_SUCCESS;
+}
+static gint
+moz_gtk_window_paint(cairo_t *cr, GdkRectangle* rect,
+GtkTextDirection direction)
+{
+GtkStyleContext* style;
+ensure_window_widget();
+gtk_widget_set_direction(gProtoWindow, direction);
+style = gtk_widget_get_style_context(gProtoWindow);
+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 void
+moz_gtk_add_style_border(GtkStyleContext* style,
+gint* left, gint* top, gint* right, gint* bottom)
+{
+GtkBorder border;
+gtk_style_context_get_border(style, 0, &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, 0, &padding);
+*left += padding.left;
+*right += padding.right;
+*top += padding.top;
+*bottom += padding.bottom;
+}
+gint
+moz_gtk_get_widget_border(GtkThemeWidgetType widget, gint* left, gint* top,
+gint* right, gint* bottom, GtkTextDirection direction,
+gboolean inhtml)
+{
+GtkWidget* w;
+GtkStyleContext* style;
+*left = *top = *right = *bottom = 0;
+switch (widget) {
+case MOZ_GTK_BUTTON:
+{
+GtkBorder inner_border;
+gboolean interior_focus;
+gint focus_width, focus_pad;
+ensure_button_widget();
+*left = *top = *right = *bottom = gtk_container_get_border_width(GTK_CONTAINER(gButtonWidget));
+/* Don't add this padding in HTML, otherwise the buttons will
+become too big and stuff the layout. */
+if (!inhtml) {
+moz_gtk_widget_get_focus(gButtonWidget, &interior_focus, &focus_width, &focus_pad);
+moz_gtk_button_get_inner_border(gButtonWidget, &inner_border);
+*left += focus_width + focus_pad + inner_border.left;
+*right += focus_width + focus_pad + inner_border.right;
+*top += focus_width + focus_pad + inner_border.top;
+*bottom += focus_width + focus_pad + inner_border.bottom;
+}
+moz_gtk_add_style_border(gtk_widget_get_style_context(gButtonWidget),
+left, top, right, bottom);
+return MOZ_GTK_SUCCESS;
+}
+case MOZ_GTK_ENTRY:
+{
+ensure_entry_widget();
+style = gtk_widget_get_style_context(gEntryWidget);
+moz_gtk_add_style_border(style, left, top, right, bottom);
+moz_gtk_add_style_padding(style, left, top, right, bottom);
+return MOZ_GTK_SUCCESS;
+}
+case MOZ_GTK_TREEVIEW:
+{
+ensure_scrolled_window_widget();
+style = gtk_widget_get_style_context(gScrolledWindowWidget);
+gtk_style_context_save(style);
+gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME);
+moz_gtk_add_style_border(style, left, top, right, bottom);
+gtk_style_context_restore(style);
+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.
+* */
+GtkBorder inner_border;
+gboolean interior_focus;
+gint focus_width, focus_pad;
+ensure_tree_header_cell_widget();
+*left = *top = *right = *bottom = gtk_container_get_border_width(GTK_CONTAINER(gTreeHeaderCellWidget));
+moz_gtk_widget_get_focus(gTreeHeaderCellWidget, &interior_focus, &focus_width, &focus_pad);
+moz_gtk_button_get_inner_border(gTreeHeaderCellWidget, &inner_border);
+*left += focus_width + focus_pad + inner_border.left;
+*right += focus_width + focus_pad + inner_border.right;
+*top += focus_width + focus_pad + inner_border.top;
+*bottom += focus_width + focus_pad + inner_border.bottom;
+moz_gtk_add_style_border(gtk_widget_get_style_context(gTreeHeaderCellWidget),
+left, top, right, bottom);
+return MOZ_GTK_SUCCESS;
+}
+case MOZ_GTK_TREE_HEADER_SORTARROW:
+ensure_tree_header_cell_widget();
+w = gTreeHeaderSortArrowWidget;
+break;
+case MOZ_GTK_DROPDOWN_ENTRY:
+ensure_combo_box_entry_widgets();
+w = gComboBoxEntryTextareaWidget;
+break;
+case MOZ_GTK_DROPDOWN_ARROW:
+ensure_combo_box_entry_widgets();
+w = gComboBoxEntryButtonWidget;
+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 ignored_interior_focus, wide_separators;
+gint focus_width, focus_pad, separator_width;
+GtkRequisition arrow_req;
+GtkBorder border;
+ensure_combo_box_widgets();
+*left = gtk_container_get_border_width(GTK_CONTAINER(gComboBoxButtonWidget));
+if (!inhtml) {
+moz_gtk_widget_get_focus(gComboBoxButtonWidget,
+&ignored_interior_focus,
+&focus_width, &focus_pad);
+*left += focus_width + focus_pad;
+}
+style = gtk_widget_get_style_context(gComboBoxButtonWidget);
+gtk_style_context_get_border(style, 0, &border);
+*top = *left + border.top;
+*left += border.left;
+*right = *left; *bottom = *top;
+/* If there is no separator, don't try to count its width. */
+separator_width = 0;
+if (gComboBoxSeparatorWidget) {
+gtk_widget_style_get(gComboBoxSeparatorWidget,
+"wide-separators", &wide_separators,
+"separator-width", &separator_width,
+NULL);
+if (!wide_separators) {
+style = gtk_widget_get_style_context(gComboBoxSeparatorWidget);
+gtk_style_context_get_border(style, 0, &border);
+separator_width = border.left;
+}
+}
+gtk_widget_size_request(gComboBoxArrowWidget, &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:
+ensure_tab_widget();
+w = gTabWidget;
+break;
+case MOZ_GTK_PROGRESSBAR:
+ensure_progress_widget();
+w = gProgressWidget;
+break;
+case MOZ_GTK_SPINBUTTON_ENTRY:
+case MOZ_GTK_SPINBUTTON_UP:
+case MOZ_GTK_SPINBUTTON_DOWN:
+ensure_spin_widget();
+w = gSpinWidget;
+break;
+case MOZ_GTK_SCALE_HORIZONTAL:
+ensure_scale_widget();
+w = gHScaleWidget;
+break;
+case MOZ_GTK_SCALE_VERTICAL:
+ensure_scale_widget();
+w = gVScaleWidget;
+break;
+case MOZ_GTK_FRAME:
+ensure_frame_widget();
+w = gFrameWidget;
+break;
+case MOZ_GTK_CHECKBUTTON_LABEL:
+case MOZ_GTK_RADIOBUTTON_LABEL:
+{
+gboolean interior_focus;
+gint focus_width, focus_pad;
+/* If the focus is interior, then the label has a border of
+(focus_width + focus_pad). */
+if (widget == MOZ_GTK_CHECKBUTTON_LABEL) {
+ensure_checkbox_widget();
+moz_gtk_widget_get_focus(gCheckboxWidget, &interior_focus,
+&focus_width, &focus_pad);
+}
+else {
+ensure_radiobutton_widget();
+moz_gtk_widget_get_focus(gRadiobuttonWidget, &interior_focus,
+&focus_width, &focus_pad);
+}
+if (interior_focus)
+*left = *top = *right = *bottom = (focus_width + focus_pad);
+return MOZ_GTK_SUCCESS;
+}
+case MOZ_GTK_CHECKBUTTON_CONTAINER:
+case MOZ_GTK_RADIOBUTTON_CONTAINER:
+{
+gboolean interior_focus;
+gint focus_width, focus_pad;
+/* If the focus is _not_ interior, then the container has a border
+of (focus_width + focus_pad). */
+if (widget == MOZ_GTK_CHECKBUTTON_CONTAINER) {
+ensure_checkbox_widget();
+moz_gtk_widget_get_focus(gCheckboxWidget, &interior_focus,
+&focus_width, &focus_pad);
+w = gCheckboxWidget;
+} else {
+ensure_radiobutton_widget();
+moz_gtk_widget_get_focus(gRadiobuttonWidget, &interior_focus,
+&focus_width, &focus_pad);
+w = gRadiobuttonWidget;
+}
+*left = *top = *right = *bottom = gtk_container_get_border_width(GTK_CONTAINER(w));
+if (!interior_focus) {
+*left += (focus_width + focus_pad);
+*right += (focus_width + focus_pad);
+*top += (focus_width + focus_pad);
+*bottom += (focus_width + focus_pad);
+}
+return MOZ_GTK_SUCCESS;
+}
+case MOZ_GTK_MENUPOPUP:
+ensure_menu_popup_widget();
+w = gMenuPopupWidget;
+break;
+case MOZ_GTK_MENUITEM:
+case MOZ_GTK_CHECKMENUITEM:
+case MOZ_GTK_RADIOMENUITEM:
+{
+if (widget == MOZ_GTK_MENUITEM) {
+ensure_menu_item_widget();
+ensure_menu_bar_item_widget();
+w = gMenuItemWidget;
+}
+else {
+ensure_check_menu_item_widget();
+w = gCheckMenuItemWidget;
+}
+*left = *top = *right = *bottom = gtk_container_get_border_width(GTK_CONTAINER(w));
+moz_gtk_add_style_padding(gtk_widget_get_style_context(w),
+left, top, right, bottom);
+return MOZ_GTK_SUCCESS;
+}
+case MOZ_GTK_TAB:
+ensure_tab_widget();
+w = gTabWidget;
+break;
+/* These widgets have no borders, since they are not containers. */
+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_TRACK_HORIZONTAL:
+case MOZ_GTK_SCROLLBAR_TRACK_VERTICAL:
+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:
+/* These widgets have no borders.*/
+case MOZ_GTK_SPINBUTTON:
+case MOZ_GTK_TOOLTIP:
+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_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;
+ensure_combo_box_entry_widgets();
+gtk_widget_size_request(gComboBoxEntryButtonWidget, &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;
+ensure_tab_widget();
+gtk_widget_style_get(gTabWidget,
+"scroll-arrow-hlength", &arrow_size,
+NULL);
+*height = *width = arrow_size;
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_get_arrow_size(gint* width, gint* height)
+{
+GtkRequisition requisition;
+ensure_button_arrow_widget();
+gtk_widget_size_request(gButtonArrowWidget, &requisition);
+*width = requisition.width;
+*height = requisition.height;
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_get_toolbar_separator_width(gint* size)
+{
+gboolean wide_separators;
+gint separator_width;
+GtkStyleContext* style;
+GtkBorder border;
+ensure_toolbar_widget();
+style = gtk_widget_get_style_context(gToolbarWidget);
+gtk_widget_style_get(gToolbarWidget,
+"space-size", size,
+"wide-separators",  &wide_separators,
+"separator-width", &separator_width,
+NULL);
+/* Just in case... */
+gtk_style_context_get_border(style, 0, &border);
+*size = MAX(*size, (wide_separators ? separator_width : border.left));
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_get_expander_size(gint* size)
+{
+ensure_expander_widget();
+gtk_widget_style_get(gExpanderWidget,
+"expander-size", size,
+NULL);
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_get_treeview_expander_size(gint* size)
+{
+ensure_tree_view_widget();
+gtk_widget_style_get(gTreeViewWidget,
+"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;
+guint border_width;
+ensure_menu_separator_widget();
+gtk_widget_style_get(gMenuSeparatorWidget,
+"wide-separators",  &wide_separators,
+"separator-height", &separator_height,
+NULL);
+border_width = gtk_container_get_border_width(GTK_CONTAINER(gMenuSeparatorWidget));
+style = gtk_widget_get_style_context(gMenuSeparatorWidget);
+gtk_style_context_get_padding(style, 0, &padding);
+*size = padding.top + padding.bottom + border_width*2;
+*size += (wide_separators) ? separator_height : 1;
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_get_scalethumb_metrics(GtkOrientation orient, gint* thumb_length, gint* thumb_height)
+{
+GtkWidget* widget;
+ensure_scale_widget();
+widget = ((orient == GTK_ORIENTATION_HORIZONTAL) ? gHScaleWidget : gVScaleWidget);
+gtk_widget_style_get (widget,
+"slider_length", thumb_length,
+"slider_width", thumb_height,
+NULL);
+return MOZ_GTK_SUCCESS;
+}
+gint
+moz_gtk_get_scrollbar_metrics(MozGtkScrollbarMetrics *metrics)
+{
+ensure_scrollbar_widget();
+gtk_widget_style_get (gHorizScrollbarWidget,
+"slider_width", &metrics->slider_width,
+"trough_border", &metrics->trough_border,
+"stepper_size", &metrics->stepper_size,
+"stepper_spacing", &metrics->stepper_spacing,
+NULL);
+metrics->min_slider_size =
+gtk_range_get_min_slider_size(GTK_RANGE(gHorizScrollbarWidget));
+return MOZ_GTK_SUCCESS;
+}
+gboolean
+moz_gtk_images_in_menus()
+{
+gboolean result;
+GtkSettings* settings;
+ensure_image_menu_item_widget();
+settings = gtk_widget_get_settings(gImageMenuItemWidget);
+g_object_get(settings, "gtk-menu-images", &result, NULL);
+return result;
+}
+gboolean
+moz_gtk_images_in_buttons()
+{
+gboolean result;
+GtkSettings* settings;
+ensure_button_widget();
+settings = gtk_widget_get_settings(gButtonWidget);
+g_object_get(settings, "gtk-button-images", &result, NULL);
+return result;
+}
+/* cairo_t *cr argument has to be a system-cairo. */
+gint
+moz_gtk_widget_paint(GtkThemeWidgetType 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:
+if (state->depressed) {
+ensure_toggle_menu_button_widget();
+return moz_gtk_button_paint(cr, rect, state,
+(GtkReliefStyle) flags,
+gToggleMenuButtonWidget, direction);
+}
+ensure_button_widget();
+return moz_gtk_button_paint(cr, rect, state,
+(GtkReliefStyle) flags, gButtonWidget,
+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_TRACK_HORIZONTAL:
+case MOZ_GTK_SCROLLBAR_TRACK_VERTICAL:
+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_SPINBUTTON:
+return moz_gtk_spin_paint(cr, rect, 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:
+ensure_spin_widget();
+return moz_gtk_entry_paint(cr, rect, state,
+gSpinWidget, direction);
+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:
+ensure_entry_widget();
+return moz_gtk_entry_paint(cr, rect, state,
+gEntryWidget, direction);
+break;
+case MOZ_GTK_DROPDOWN:
+return moz_gtk_combo_box_paint(cr, rect, state,
+(gboolean) flags, direction);
+break;
+case MOZ_GTK_DROPDOWN_ARROW:
+return moz_gtk_combo_box_entry_button_paint(cr, rect,
+state, flags, direction);
+break;
+case MOZ_GTK_DROPDOWN_ENTRY:
+ensure_combo_box_entry_widgets();
+return moz_gtk_entry_paint(cr, rect, state,
+gComboBoxEntryTextareaWidget, direction);
+break;
+case MOZ_GTK_CHECKBUTTON_CONTAINER:
+case MOZ_GTK_RADIOBUTTON_CONTAINER:
+return moz_gtk_container_paint(cr, rect, state,
+(widget == MOZ_GTK_RADIOBUTTON_CONTAINER),
+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, direction);
+break;
+case MOZ_GTK_TOOLBAR_SEPARATOR:
+return moz_gtk_toolbar_separator_paint(cr, rect,
+direction);
+break;
+case MOZ_GTK_TOOLTIP:
+return moz_gtk_tooltip_paint(cr, rect, direction);
+break;
+case MOZ_GTK_FRAME:
+return moz_gtk_frame_paint(cr, rect, 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, 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,
+direction, widget);
+break;
+case MOZ_GTK_TAB:
+return moz_gtk_tab_paint(cr, rect, state,
+(GtkTabFlags) flags, direction);
+break;
+case MOZ_GTK_TABPANELS:
+return moz_gtk_tabpanels_paint(cr, rect, 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, direction);
+break;
+case MOZ_GTK_MENUPOPUP:
+return moz_gtk_menu_popup_paint(cr, rect, direction);
+break;
+case MOZ_GTK_MENUSEPARATOR:
+return moz_gtk_menu_separator_paint(cr, rect,
+direction);
+break;
+case MOZ_GTK_MENUITEM:
+return moz_gtk_menu_item_paint(cr, rect, state, flags,
+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(cr, rect, state,
+(gboolean) flags,
+(widget == MOZ_GTK_RADIOMENUITEM),
+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;
+default:
+g_warning("Unknown widget type: %d", widget);
+}
+return MOZ_GTK_UNKNOWN_WIDGET;
+}
+GtkWidget* moz_gtk_get_scrollbar_widget(void)
+{
+NS_ASSERTION(is_initialized, "Forgot to call moz_gtk_init()");
+ensure_scrollbar_widget();
+return gHorizScrollbarWidget;
+}
+gint
+moz_gtk_shutdown()
+{
+GtkWidgetClass *entry_class;
+if (gTooltipWidget)
+gtk_widget_destroy(gTooltipWidget);
+/* This will destroy all of our widgets */
+if (gProtoWindow)
+gtk_widget_destroy(gProtoWindow);
+/* TODO - replace it with appropriate widget */
+if (gTreeHeaderSortArrowWidget)
+gtk_widget_destroy(gTreeHeaderSortArrowWidget);
+gProtoWindow = NULL;
+gProtoLayout = NULL;
+gButtonWidget = NULL;
+gToggleMenuButtonWidget = NULL;
+gButtonArrowWidget = NULL;
+gCheckboxWidget = NULL;
+gRadiobuttonWidget = NULL;
+gHorizScrollbarWidget = NULL;
+gVertScrollbarWidget = NULL;
+gSpinWidget = NULL;
+gHScaleWidget = NULL;
+gVScaleWidget = NULL;
+gEntryWidget = NULL;
+gComboBoxWidget = NULL;
+gComboBoxButtonWidget = NULL;
+gComboBoxSeparatorWidget = NULL;
+gComboBoxArrowWidget = NULL;
+gComboBoxEntryWidget = NULL;
+gComboBoxEntryButtonWidget = NULL;
+gComboBoxEntryArrowWidget = NULL;
+gComboBoxEntryTextareaWidget = NULL;
+gHandleBoxWidget = NULL;
+gToolbarWidget = NULL;
+gStatusbarWidget = NULL;
+gFrameWidget = NULL;
+gProgressWidget = NULL;
+gTabWidget = NULL;
+gTooltipWidget = NULL;
+gMenuBarWidget = NULL;
+gMenuBarItemWidget = NULL;
+gMenuPopupWidget = NULL;
+gMenuItemWidget = NULL;
+gImageMenuItemWidget = NULL;
+gCheckMenuItemWidget = NULL;
+gTreeViewWidget = NULL;
+gMiddleTreeViewColumn = NULL;
+gTreeHeaderCellWidget = NULL;
+gTreeHeaderSortArrowWidget = NULL;
+gExpanderWidget = NULL;
+gToolbarSeparatorWidget = NULL;
+gMenuSeparatorWidget = NULL;
+gHPanedWidget = NULL;
+gVPanedWidget = NULL;
+gScrolledWindowWidget = NULL;
+entry_class = g_type_class_peek(GTK_TYPE_ENTRY);
+g_type_class_unref(entry_class);
+is_initialized = FALSE;
+return MOZ_GTK_SUCCESS;
+}

The Tor Browser / file comparison

comparison: widget/gtk/gtk3drawing.c

widget/gtk/gtk3drawing.c