diff -up firefox-47.0/widget/gtk/gtk3drawing.c.gtk3-20 firefox-47.0/widget/gtk/gtk3drawing.c

--- firefox-47.0/widget/gtk/gtk3drawing.c.gtk3-20	2016-06-01 06:11:44.000000000 +0200

+++ firefox-47.0/widget/gtk/gtk3drawing.c	2016-06-23 10:21:37.072462099 +0200

@@ -17,34 +17,85 @@

 #include <math.h>

+#define MOZ_WIDGET_STYLES 4

+

+typedef struct {

+    GtkWidget*            widget;

+

+    union {

+        struct {

+            GtkStyleContext*  style;

+            GtkStyleContext*  styleSelection;

+        } entry;

+

+        struct {

+            GtkStyleContext*  style;

+        } button;

+

+        struct {

+            GtkStyleContext*  style;

+        } tooltip;

+

+        struct {

+            GtkStyleContext*  style;

+            GtkStyleContext*  styleContents;

+            GtkStyleContext*  styleTrough;

+            GtkStyleContext*  styleSlider;

+        } scroll;

+

+        struct {

+            GtkStyleContext*  style;

+            GtkStyleContext*  styleCheck;

+            GtkStyleContext*  styleLabel;

+        } check;

+

+        struct {

+            GtkStyleContext*  style;

+            GtkStyleContext*  styleTrough;

+            GtkStyleContext*  styleProgress;

+        } progress;

+

+        struct {

+            GtkStyleContext*  style;

+            GtkStyleContext*  styleEntry;

+            GtkStyleContext*  styleButtonUp;

+            GtkStyleContext*  styleButtonDown;

+        } spin;

+

+        struct {

+            GtkStyleContext*  style[MOZ_WIDGET_STYLES];

+        } all;

+    };

+} MozGtkWidget;

+

 static GtkWidget* gProtoWindow;

 static GtkWidget* gProtoLayout;

-static GtkWidget* gButtonWidget;

+static MozGtkWidget gButton;

 static GtkWidget* gToggleButtonWidget;

 static GtkWidget* gButtonArrowWidget;

-static GtkWidget* gCheckboxWidget;

-static GtkWidget* gRadiobuttonWidget;

-static GtkWidget* gHorizScrollbarWidget;

-static GtkWidget* gVertScrollbarWidget;

-static GtkWidget* gSpinWidget;

+static MozGtkWidget gCheckbox;

+static MozGtkWidget gRadiobutton;

+static MozGtkWidget gVertScrollbar;

+static MozGtkWidget gHorizScrollbar;

+static MozGtkWidget gSpin;

 static GtkWidget* gHScaleWidget;

 static GtkWidget* gVScaleWidget;

-static GtkWidget* gEntryWidget;

+static MozGtkWidget gEntry;

 static GtkWidget* gComboBoxWidget;

 static GtkWidget* gComboBoxButtonWidget;

 static GtkWidget* gComboBoxArrowWidget;

 static GtkWidget* gComboBoxSeparatorWidget;

 static GtkWidget* gComboBoxEntryWidget;

-static GtkWidget* gComboBoxEntryTextareaWidget;

+static MozGtkWidget gComboBoxEntryTextarea;

 static GtkWidget* gComboBoxEntryButtonWidget;

 static GtkWidget* gComboBoxEntryArrowWidget;

 static GtkWidget* gHandleBoxWidget;

 static GtkWidget* gToolbarWidget;

 static GtkWidget* gFrameWidget;

 static GtkWidget* gStatusbarWidget;

-static GtkWidget* gProgressWidget;

+static MozGtkWidget gProgressBar;

 static GtkWidget* gTabWidget;

-static GtkWidget* gTooltipWidget;

+static MozGtkWidget gTooltip;

 static GtkWidget* gMenuBarWidget;

 static GtkWidget* gMenuBarItemWidget;

 static GtkWidget* gMenuPopupWidget;

@@ -78,6 +129,37 @@ static gboolean is_initialized;

 #define GTK_STATE_FLAG_CHECKED (1 << 11)

 #endif

+void moz_gtk_widget_free(MozGtkWidget *aMozWidget)

+{

+    // This was removed as a child of gProtoWindow

+    if (aMozWidget->widget) {

+        aMozWidget->widget = NULL;

+    }

+

+    for(int i = 0; i < MOZ_WIDGET_STYLES; i++) {

+        if (aMozWidget->all.style[i]) {

+            g_object_unref(aMozWidget->all.style[i]);

+            aMozWidget->all.style[i] = NULL;

+        }

+    }

+}

+

+// TODO - weak dep!! (dlsym)

+#if GTK_CHECK_VERSION(3, 19, 2)

+#define moz_gtk_path_set_class_name    gtk_widget_path_iter_set_object_name

+#else

+#define moz_gtk_path_set_class_name    gtk_widget_path_iter_add_class

+#endif

+//gtk_widget_path_iter_get_state

+

+static void

+moz_gtk_get_style_border(GtkStyleContext* style, GtkStateFlags state_flags,

+                         GtkBorder *border);

+

+static void

+moz_gtk_get_style_padding(GtkStyleContext* style, GtkStateFlags state_flags,

+                          GtkBorder *padding);

+

 static GtkStateFlags

 GetStateFlagsFromGtkWidgetState(GtkWidgetState* state)

 {

@@ -97,6 +179,41 @@ GetStateFlagsFromGtkWidgetState(GtkWidge

     return stateFlags;

 }

+GtkStyleContext *

+moz_gtk_style_create(GtkCssNode *node, GtkStyleContext *parent)

+{

+  GtkWidgetPath *path;

+  GtkStyleContext *context;

+

+  if (parent)

+    path = gtk_widget_path_copy (gtk_style_context_get_path (parent));

+  else

+    path = gtk_widget_path_new ();

+

+  gtk_widget_path_append_type (path, node->type);

+  if (node->name)

+    moz_gtk_path_set_class_name(path, -1, node->name);

+  if (node->class1)

+    gtk_widget_path_iter_add_class(path, -1, node->class1);

+  if (node->class2)

+    gtk_widget_path_iter_add_class(path, -1, node->class2);

+

+  context = gtk_style_context_new ();

+  gtk_style_context_set_path (context, path);

+  gtk_style_context_set_parent (context, parent);

+

+  if(!gtk_check_version(3, 14, 0)) {

+      /* Unfortunately, we have to explicitly set the state again here

+       * for it to take effect

+       */

+      gtk_style_context_set_state (context, gtk_widget_path_iter_get_state (path, -1));

+  }

+

+  gtk_widget_path_unref (path);

+

+  return context;

+}

+

 /* 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. */

@@ -141,9 +258,16 @@ setup_widget_prototype(GtkWidget* widget

 static gint

 ensure_button_widget()

 {

-    if (!gButtonWidget) {

-        gButtonWidget = gtk_button_new_with_label("M");

-        setup_widget_prototype(gButtonWidget);

+    if (!gButton.widget) {

+        GtkCssNode path[] = { 

+            { GTK_TYPE_BUTTON, "button", NULL, NULL }

+        };

+

+        gButton.widget = gtk_button_new_with_label("M");

+        setup_widget_prototype(gButton.widget);

+        gtk_widget_show(gButton.widget);

+

+        gButton.button.style = moz_gtk_style_create(&path[0], NULL);

     }

     return MOZ_GTK_SUCCESS;

 }

@@ -195,9 +319,21 @@ ensure_button_arrow_widget()

 static gint

 ensure_checkbox_widget()

 {

-    if (!gCheckboxWidget) {

-        gCheckboxWidget = gtk_check_button_new_with_label("M");

-        setup_widget_prototype(gCheckboxWidget);

+   if (!gCheckbox.widget) {

+        GtkCssNode path[] = {

+           { GTK_TYPE_TOGGLE_BUTTON, "checkbutton", NULL, NULL },

+           { G_TYPE_NONE, "check", NULL, NULL },

+           { G_TYPE_NONE, "label", NULL, NULL }

+        };

+

+        gCheckbox.widget = gtk_check_button_new_with_label("M");

+        setup_widget_prototype(gCheckbox.widget);

+

+        gCheckbox.check.style = moz_gtk_style_create(&path[0], NULL);

+        gCheckbox.check.styleCheck = moz_gtk_style_create(&path[1],

+                                       gCheckbox.check.style);

+        gCheckbox.check.styleLabel = moz_gtk_style_create(&path[2],

+                                       gCheckbox.check.style);

     }

     return MOZ_GTK_SUCCESS;

 }

@@ -205,9 +341,21 @@ ensure_checkbox_widget()

 static gint

 ensure_radiobutton_widget()

 {

-    if (!gRadiobuttonWidget) {

-        gRadiobuttonWidget = gtk_radio_button_new_with_label(NULL, "M");

-        setup_widget_prototype(gRadiobuttonWidget);

+    if (!gRadiobutton.widget) {

+        GtkCssNode path[] = {

+           { GTK_TYPE_TOGGLE_BUTTON, "radiobutton", NULL, NULL },

+           { G_TYPE_NONE, "radio", NULL, NULL },

+           { G_TYPE_NONE, "label", NULL, NULL }

+        };

+

+        gRadiobutton.widget = gtk_radio_button_new_with_label(NULL, "M");

+        setup_widget_prototype(gRadiobutton.widget);

+

+        gRadiobutton.check.style = moz_gtk_style_create(&path[0], NULL);

+        gRadiobutton.check.styleCheck = moz_gtk_style_create(&path[1],

+                                          gRadiobutton.check.style);

+        gRadiobutton.check.styleLabel = moz_gtk_style_create(&path[2],

+                                          gRadiobutton.check.style);

     }

     return MOZ_GTK_SUCCESS;

 }

@@ -215,25 +363,62 @@ ensure_radiobutton_widget()

 static gint

 ensure_scrollbar_widget()

 {

-    if (!gVertScrollbarWidget) {

-        gVertScrollbarWidget = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, NULL);

-        setup_widget_prototype(gVertScrollbarWidget);

-    }

-    if (!gHorizScrollbarWidget) {

-        gHorizScrollbarWidget = gtk_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL);

-        setup_widget_prototype(gHorizScrollbarWidget);

-    }

+    if (!gVertScrollbar.widget && !gHorizScrollbar.widget) {

+        GtkCssNode path[] = {

+            { GTK_TYPE_SCROLLBAR, "scrollbar", "horizontal", "bottom"},

+            { GTK_TYPE_SCROLLBAR, "scrollbar", "vertical", "right" },

+            { G_TYPE_NONE, "contents", NULL, NULL },

+            { G_TYPE_NONE, "trough", NULL, NULL },

+            { G_TYPE_NONE, "slider", NULL, NULL }

+        };

+

+        gHorizScrollbar.widget = gtk_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL);

+        setup_widget_prototype(gHorizScrollbar.widget);

+

+        gHorizScrollbar.scroll.style = moz_gtk_style_create(path, NULL);

+        gHorizScrollbar.scroll.styleContents = moz_gtk_style_create(path+2, 

+                                               gHorizScrollbar.scroll.style);

+        gHorizScrollbar.scroll.styleTrough = moz_gtk_style_create(path+3, 

+                                               gHorizScrollbar.scroll.styleContents);

+        gHorizScrollbar.scroll.styleSlider = moz_gtk_style_create(path+4, 

+                                               gHorizScrollbar.scroll.styleTrough);

+

+        gVertScrollbar.widget = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, NULL);

+        setup_widget_prototype(gVertScrollbar.widget);

+

+        gVertScrollbar.scroll.style = moz_gtk_style_create(path+1, NULL);

+        gVertScrollbar.scroll.styleContents = moz_gtk_style_create(path+2, 

+                                              gVertScrollbar.scroll.style);

+        gVertScrollbar.scroll.styleTrough = moz_gtk_style_create(path+3, 

+                                              gVertScrollbar.scroll.styleContents);

+        gVertScrollbar.scroll.styleSlider = moz_gtk_style_create(path+4, 

+                                              gVertScrollbar.scroll.styleTrough);

+

+     }

     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;

+    if (!gSpin.widget) {

+        GtkCssNode path[] = {

+            { GTK_TYPE_SPIN_BUTTON, "spinbutton", "horizontal", NULL },

+            { GTK_TYPE_SPIN_BUTTON, "spinbutton", "vertical", NULL },

+            { GTK_TYPE_ENTRY, "entry", NULL, NULL },

+            { G_TYPE_NONE, "button", "up", NULL },

+            { G_TYPE_NONE, "button", "down", NULL }

+        };

+

+        gSpin.widget = gtk_spin_button_new(NULL, 1, 0);

+        setup_widget_prototype(gSpin.widget);

+

+        gSpin.spin.style = moz_gtk_style_create(path, NULL);

+        gSpin.spin.styleButtonUp = moz_gtk_style_create(path+3, gSpin.spin.style);

+        gSpin.spin.styleButtonDown = moz_gtk_style_create(path+4, gSpin.spin.style);

+        gSpin.spin.styleEntry = moz_gtk_style_create(path+2, gSpin.spin.style);

+    }

+    return MOZ_GTK_SUCCESS;

 }

 static gint

@@ -253,9 +438,19 @@ ensure_scale_widget()

 static gint

 ensure_entry_widget()

 {

-    if (!gEntryWidget) {

-        gEntryWidget = gtk_entry_new();

-        setup_widget_prototype(gEntryWidget);

+    if (!gEntry.widget) {

+        GtkCssNode path[] = { 

+            { GTK_TYPE_ENTRY, "entry", NULL, NULL },

+            { G_TYPE_NONE, "selection", NULL, NULL }

+        };

+

+        gEntry.widget = gtk_entry_new();

+        setup_widget_prototype(gEntry.widget);

+        gtk_widget_show(gEntry.widget);

+

+        gEntry.entry.style = moz_gtk_style_create(&path[0], NULL);

+        gEntry.entry.styleSelection = moz_gtk_style_create(&path[1], 

+                                                           gEntry.entry.style);

     }

     return MOZ_GTK_SUCCESS;

 }

@@ -387,9 +582,9 @@ moz_gtk_get_combo_box_entry_inner_widget

         g_object_add_weak_pointer(G_OBJECT(widget),

                                   (gpointer) &gComboBoxEntryButtonWidget);

     } else if (GTK_IS_ENTRY(widget)) {

-        gComboBoxEntryTextareaWidget = widget;

+        gComboBoxEntryTextarea.widget = widget;

         g_object_add_weak_pointer(G_OBJECT(widget),

-                                  (gpointer) &gComboBoxEntryTextareaWidget);

+                                  (gpointer) &gComboBoxEntryTextarea.widget);

     } else

         return;

     gtk_widget_realize(widget);

@@ -411,7 +606,7 @@ ensure_combo_box_entry_widgets()

 {

     GtkWidget* buttonChild;

-    if (gComboBoxEntryTextareaWidget &&

+    if (gComboBoxEntryTextarea.widget &&

             gComboBoxEntryButtonWidget &&

             gComboBoxEntryArrowWidget)

         return MOZ_GTK_SUCCESS;

@@ -427,9 +622,9 @@ ensure_combo_box_entry_widgets()

                          moz_gtk_get_combo_box_entry_inner_widgets,

                          NULL);

-    if (!gComboBoxEntryTextareaWidget) {

+    if (!gComboBoxEntryTextarea.widget) {

         ensure_entry_widget();

-        gComboBoxEntryTextareaWidget = gEntryWidget;

+        gComboBoxEntryTextarea.widget = gEntry.widget;

     }

     if (gComboBoxEntryButtonWidget) {

@@ -507,12 +702,16 @@ ensure_toolbar_separator_widget()

 static gint

 ensure_tooltip_widget()

 {

-    if (!gTooltipWidget) {

-        gTooltipWidget = gtk_window_new(GTK_WINDOW_POPUP);

-        GtkStyleContext* style = gtk_widget_get_style_context(gTooltipWidget);

-        gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOOLTIP);

-        gtk_widget_realize(gTooltipWidget);

-        moz_gtk_set_widget_name(gTooltipWidget);

+    if (!gTooltip.widget) {

+        GtkCssNode path[] = {

+            { GTK_TYPE_TOOLTIP, "tooltip", "background", NULL},

+        };

+

+        gTooltip.widget = gtk_window_new(GTK_WINDOW_POPUP);

+        gtk_widget_realize(gTooltip.widget);

+        moz_gtk_set_widget_name(gTooltip.widget);

+

+        gTooltip.tooltip.style = moz_gtk_style_create(&path[0], NULL);

     }

     return MOZ_GTK_SUCCESS;

 }

@@ -530,9 +729,21 @@ ensure_tab_widget()

 static gint

 ensure_progress_widget()

 {

-    if (!gProgressWidget) {

-        gProgressWidget = gtk_progress_bar_new();

-        setup_widget_prototype(gProgressWidget);

+    if (!gProgressBar.widget) {

+        GtkCssNode path[] = {

+           { GTK_TYPE_LABEL, "progressbar", NULL, NULL },

+           { G_TYPE_NONE, "trough", NULL, NULL },

+           { G_TYPE_NONE, "progress", NULL, NULL },

+        };

+

+        gProgressBar.widget = gtk_progress_bar_new();

+        setup_widget_prototype(gProgressBar.widget);

+

+        gProgressBar.progress.style = moz_gtk_style_create(&path[0], NULL);

+        gProgressBar.progress.styleTrough = moz_gtk_style_create(&path[1],

+                                              gProgressBar.progress.style);

+        gProgressBar.progress.styleProgress = moz_gtk_style_create(&path[2],

+                                                gProgressBar.progress.styleTrough);

     }

     return MOZ_GTK_SUCCESS;

 }

@@ -638,6 +849,11 @@ static gint

 ensure_check_menu_item_widget()

 {

     if (!gCheckMenuItemWidget) {

+        GtkCssNode path[] = {

+           { GTK_TYPE_CHECK_MENU_ITEM, "menuitem", NULL, NULL },

+           { G_TYPE_NONE, "check", NULL, NULL }

+        };

+

         ensure_menu_popup_widget();

         gCheckMenuItemWidget = gtk_check_menu_item_new_with_label("M");

         gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),

@@ -752,7 +968,7 @@ moz_gtk_checkbox_get_metrics(gint* indic

 {

     ensure_checkbox_widget();

-    gtk_widget_style_get (gCheckboxWidget,

+    gtk_widget_style_get (gCheckbox.widget,

                           "indicator_size", indicator_size,

                           "indicator_spacing", indicator_spacing,

                           NULL);

@@ -765,7 +981,7 @@ moz_gtk_radio_get_metrics(gint* indicato

 {

     ensure_radiobutton_widget();

-    gtk_widget_style_get (gRadiobuttonWidget,

+    gtk_widget_style_get (gRadiobutton.widget,

                           "indicator_size", indicator_size,

                           "indicator_spacing", indicator_spacing,

                           NULL);

@@ -778,13 +994,13 @@ moz_gtk_get_focus_outline_size(gint* foc

 {

     GtkBorder border;

     GtkBorder padding;

-    GtkStyleContext *style;

+    GtkStyleContext* style;

     ensure_entry_widget();

-    style = gtk_widget_get_style_context(gEntryWidget);

-    gtk_style_context_get_border(style, 0, &border);

-    gtk_style_context_get_padding(style, 0, &padding);

+    style = gEntry.entry.style;

+    gtk_style_context_get_border(style, gtk_style_context_get_state(style), &border);

+    gtk_style_context_get_padding(style, gtk_style_context_get_state(style), &padding);

     *focus_h_width = border.left + padding.left;

     *focus_v_width = border.top + padding.top;

     return MOZ_GTK_SUCCESS;

@@ -821,7 +1037,7 @@ moz_gtk_button_get_default_overflow(gint

     GtkBorder* default_outside_border;

     ensure_button_widget();

-    gtk_widget_style_get(gButtonWidget,

+    gtk_widget_style_get(gButton.widget,

                          "default-outside-border", &default_outside_border,

                          NULL);

@@ -844,7 +1060,7 @@ moz_gtk_button_get_default_border(gint*

     GtkBorder* default_border;

     ensure_button_widget();

-    gtk_widget_style_get(gButtonWidget,

+    gtk_widget_style_get(gButton.widget,

                          "default-border", &default_border,

                          NULL);

@@ -935,7 +1151,7 @@ moz_gtk_button_paint(cairo_t *cr, GdkRec

     if (state->focused) {

         GtkBorder border;

-        gtk_style_context_get_border(style, state_flags, &border);

+        moz_gtk_get_style_border(style, state_flags, &border);

         x += border.left;

         y += border.top;

         width -= (border.left + border.right);

@@ -956,15 +1172,14 @@ moz_gtk_toggle_paint(cairo_t *cr, GdkRec

     gint indicator_size, indicator_spacing;

     gint x, y, width, height;

     gint focus_x, focus_y, focus_width, focus_height;

-    GtkWidget *w;

-    GtkStyleContext *style;

+    MozGtkWidget *w;

     if (isradio) {

         moz_gtk_radio_get_metrics(&indicator_size, &indicator_spacing);

-        w = gRadiobuttonWidget;

+        w = &gRadiobutton;

     } else {

         moz_gtk_checkbox_get_metrics(&indicator_size, &indicator_spacing);

-        w = gCheckboxWidget;

+        w = &gCheckbox;

     }

     // XXX we should assert rect->height >= indicator_size too

@@ -983,11 +1198,9 @@ moz_gtk_toggle_paint(cairo_t *cr, GdkRec

     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);

+    gtk_widget_set_sensitive(w->widget, !state->disabled);

+    gtk_widget_set_direction(w->widget, direction);

+    gtk_style_context_save(w->check.styleCheck);

     if (selected)

         state_flags |= checkbox_check_state;

@@ -995,13 +1208,15 @@ moz_gtk_toggle_paint(cairo_t *cr, GdkRec

     if (inconsistent)

         state_flags |= GTK_STATE_FLAG_INCONSISTENT;

-    gtk_style_context_set_state(style, state_flags);

+    gtk_style_context_set_state(w->check.styleCheck, state_flags);

+

+    gtk_render_background(w->check.styleCheck, cr, x, y, width, height);

+    gtk_render_frame(w->check.styleCheck, cr, x, y, width, height);

     if (isradio) {

-        gtk_style_context_add_class(style, GTK_STYLE_CLASS_RADIO);

-        gtk_render_option(style, cr, x, y, width, height);

+        gtk_render_option(w->check.styleCheck, cr, x, y, width, height);

         if (state->focused) {

-            gtk_render_focus(style, cr, focus_x, focus_y,

+            gtk_render_focus(w->check.styleCheck, cr, focus_x, focus_y,

                             focus_width, focus_height);

         }

     }

@@ -1010,15 +1225,14 @@ moz_gtk_toggle_paint(cairo_t *cr, GdkRec

         * '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);

-        gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(gCheckboxWidget), inconsistent);

-        gtk_render_check(style, cr, x, y, width, height);        

+        gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(w->widget), inconsistent);

+        gtk_render_check(w->check.styleCheck, cr, x, y, width, height);

         if (state->focused) {

-            gtk_render_focus(style, cr, 

+            gtk_render_focus(w->check.styleCheck, cr,

                              focus_x, focus_y, focus_width, focus_height);

         }

     }

-    gtk_style_context_restore(style);

+    gtk_style_context_restore(w->check.styleCheck);

     return MOZ_GTK_SUCCESS;

 }

@@ -1035,8 +1249,8 @@ calculate_button_inner_rect(GtkWidget* b

     style = gtk_widget_get_style_context(button);

     /* This mirrors gtkbutton's child positioning */

-    gtk_style_context_get_border(style, 0, &border);

-    gtk_style_context_get_padding(style, 0, &padding);

+    gtk_style_context_get_border(style, gtk_style_context_get_state(style), &border);

+    gtk_style_context_get_padding(style, gtk_style_context_get_state(style), &padding);

     inner_rect->x = rect->x + border.left + padding.left;

     inner_rect->y = rect->y + padding.top + border.top;

@@ -1099,9 +1313,9 @@ moz_gtk_scrollbar_button_paint(cairo_t *

     ensure_scrollbar_widget();

     if (flags & MOZ_GTK_STEPPER_VERTICAL)

-        scrollbar = gVertScrollbarWidget;

+        scrollbar = gVertScrollbar.widget;

     else

-        scrollbar = gHorizScrollbarWidget;

+        scrollbar = gHorizScrollbar.widget;

     gtk_widget_set_direction(scrollbar, direction);

@@ -1181,25 +1395,22 @@ moz_gtk_scrollbar_trough_paint(GtkThemeW

                                GtkTextDirection direction)

 {

     GtkStyleContext* style;

-    GtkScrollbar *scrollbar;

     ensure_scrollbar_widget();

-    if (widget ==  MOZ_GTK_SCROLLBAR_HORIZONTAL)

-        scrollbar = GTK_SCROLLBAR(gHorizScrollbarWidget);

-    else

-        scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);

-

-    gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);

-    

     if (flags & MOZ_GTK_TRACK_OPAQUE) {

         style = gtk_widget_get_style_context(GTK_WIDGET(gProtoWindow));

         gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);

     }

-    style = gtk_widget_get_style_context(GTK_WIDGET(scrollbar));

-    gtk_style_context_save(style);

-    gtk_style_context_add_class(style, GTK_STYLE_CLASS_TROUGH);

+     if (widget == MOZ_GTK_SCROLLBAR_HORIZONTAL) {

+        gtk_widget_set_direction(GTK_WIDGET(gHorizScrollbar.widget), direction);

+        style = gHorizScrollbar.scroll.style;

+    }

+    else {

+        gtk_widget_set_direction(GTK_WIDGET(gVertScrollbar.widget), direction);

+        style = gVertScrollbar.scroll.style;

+    }

     gtk_render_background(style, cr, rect->x, rect->y, rect->width, rect->height);

     gtk_render_frame(style, cr, rect->x, rect->y, rect->width, rect->height);

@@ -1208,7 +1419,6 @@ moz_gtk_scrollbar_trough_paint(GtkThemeW

         gtk_render_focus(style, cr,

                          rect->x, rect->y, rect->width, rect->height);

     }

-    gtk_style_context_restore(style);

     return MOZ_GTK_SUCCESS;

 }

@@ -1220,24 +1430,20 @@ moz_gtk_scrollbar_thumb_paint(GtkThemeWi

 {

     GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);

     GtkStyleContext* style;

-    GtkScrollbar *scrollbar;

     GtkBorder margin;

     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);

+    if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) {

+        style = gHorizScrollbar.scroll.styleSlider;

+        gtk_widget_set_direction(GTK_WIDGET(gHorizScrollbar.widget), direction);

+    }

+    else {

+        style = gVertScrollbar.scroll.styleSlider; 

+        gtk_widget_set_direction(GTK_WIDGET(gVertScrollbar.widget), direction);

+    }

-    gtk_style_context_add_class(style, GTK_STYLE_CLASS_SLIDER);

     gtk_style_context_set_state(style, state_flags);

-

     gtk_style_context_get_margin (style, state_flags, &margin);

     gtk_render_slider(style, cr,

@@ -1248,8 +1454,6 @@ moz_gtk_scrollbar_thumb_paint(GtkThemeWi

                      (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) ?

                      GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL);

-    gtk_style_context_restore(style);

-

     return MOZ_GTK_SUCCESS;

 }

@@ -1260,8 +1464,8 @@ moz_gtk_spin_paint(cairo_t *cr, GdkRecta

     GtkStyleContext* style;

     ensure_spin_widget();

-    gtk_widget_set_direction(gSpinWidget, direction);

-    style = gtk_widget_get_style_context(gSpinWidget);

+    gtk_widget_set_direction(gSpin.widget, direction);

+    style = gSpin.spin.style;

     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);

@@ -1280,11 +1484,10 @@ moz_gtk_spin_updown_paint(cairo_t *cr, G

     GtkStyleContext* style;

     ensure_spin_widget();

-    style = gtk_widget_get_style_context(gSpinWidget);

+    style = gSpin.spin.style;

     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_widget_set_direction(gSpin.widget, 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);

@@ -1450,15 +1653,13 @@ moz_gtk_vpaned_paint(cairo_t *cr, GdkRec

 static gint

 moz_gtk_entry_paint(cairo_t *cr, GdkRectangle* rect,

                     GtkWidgetState* state,

-                    GtkWidget* widget, GtkTextDirection direction)

+                    MozGtkWidget* w, GtkTextDirection direction)

 {

     gint x = rect->x, y = rect->y, width = rect->width, height = rect->height;

-    GtkStyleContext* style;

     int draw_focus_outline_only = state->depressed; // NS_THEME_FOCUS_OUTLINE

+    GtkStyleContext* style = w->entry.style;

-    gtk_widget_set_direction(widget, direction);

-

-    style = gtk_widget_get_style_context(widget);

+    gtk_widget_set_direction(w->widget, direction);

     if (draw_focus_outline_only) {

         // Inflate the given 'rect' with the focus outline size.

@@ -1478,10 +1679,9 @@ moz_gtk_entry_paint(cairo_t *cr, GdkRect

      * 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_widget_set_sensitive(w->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

@@ -1531,7 +1731,7 @@ moz_gtk_treeview_paint(cairo_t *cr, GdkR

     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);

+    moz_gtk_get_style_border(style, state_flags, &border);

     xthickness = border.left;

     ythickness = border.top;    

@@ -1702,7 +1902,7 @@ moz_gtk_combo_box_paint(cairo_t *cr, Gdk

         if (direction == GTK_TEXT_DIR_LTR) {

             GtkBorder padding;

             GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);

-            gtk_style_context_get_padding(style, state_flags, &padding);

+            moz_gtk_get_style_padding(style, state_flags, &padding);

             arrow_rect.x -= padding.left;

         }

         else

@@ -1804,29 +2004,27 @@ moz_gtk_container_paint(cairo_t *cr, Gdk

                         gboolean isradio, GtkTextDirection direction)

 {

     GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);

-    GtkStyleContext* style;

-    GtkWidget *widget;

+    MozGtkWidget *widget;

     if (isradio) {

         ensure_radiobutton_widget();

-        widget = gRadiobuttonWidget;

+        widget = &gRadiobutton;

     } else {

         ensure_checkbox_widget();

-        widget = gCheckboxWidget;

+        widget = &gCheckbox;

     }

-    gtk_widget_set_direction(widget, direction);