The Tor Browser: widget/gtk/gtk3drawing.c@ac0c01689b40 (annotated)

widget/gtk/gtk3drawing.c@ac0c01689b40 (annotated)

widget/gtk/gtk3drawing.c

Thu, 15 Jan 2015 15:59:08 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:59:08 +0100
branch: TOR_BUG_9701
changeset 10: ac0c01689b40
permissions: -rw-r--r--

Implement a real Private Browsing Mode condition by changing the API/ABI;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- 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,
 * 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,
 * 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 / annotate

widget/gtk/gtk3drawing.c@ac0c01689b40 (annotated)

widget/gtk/gtk3drawing.c