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

     2 --- firefox-46.0.1/widget/gtk/gtk3drawing.c.gtk3-20	2016-05-03 07:31:12.000000000 +0200

     3 +++ firefox-46.0.1/widget/gtk/gtk3drawing.c	2016-05-20 15:05:08.750151522 +0200

     4 @@ -17,34 +17,86 @@

     5  

     6  #include <math.h>

     7  

     8 +#define MOZ_WIDGET_STYLES 4

     9 +

    10 +typedef struct {

    11 +    GtkWidget*            widget;

    12 +

    13 +    union {

    14 +        struct {

    15 +            GtkStyleContext*  style;

    16 +            GtkStyleContext*  styleSelection;

    17 +        } entry;

    18 +

    19 +        struct {

    20 +            GtkStyleContext*  style;

    21 +        } button;

    22 +

    23 +        struct {

    24 +            GtkStyleContext*  style;

    25 +            GtkStyleContext*  styleBackground;

    26 +        } tooltip;

    27 +

    28 +        struct {

    29 +            GtkStyleContext*  style;

    30 +            GtkStyleContext*  styleContents;

    31 +            GtkStyleContext*  styleTrough;

    32 +            GtkStyleContext*  styleSlider;

    33 +        } scroll;

    34 +

    35 +        struct {

    36 +            GtkStyleContext*  style;

    37 +            GtkStyleContext*  styleCheck;

    38 +            GtkStyleContext*  styleLabel;

    39 +        } check;

    40 +

    41 +        struct {

    42 +            GtkStyleContext*  style;

    43 +            GtkStyleContext*  styleTrough;

    44 +            GtkStyleContext*  styleProgress;

    45 +        } progress;

    46 +

    47 +        struct {

    48 +            GtkStyleContext*  style;

    49 +            GtkStyleContext*  styleEntry;

    50 +            GtkStyleContext*  styleButtonUp;

    51 +            GtkStyleContext*  styleButtonDown;

    52 +        } spin;

    53 +

    54 +        struct {

    55 +            GtkStyleContext*  style[MOZ_WIDGET_STYLES];

    56 +        } all;

    57 +    };

    58 +} MozGtkWidget;

    59 +

    60  static GtkWidget* gProtoWindow;

    61  static GtkWidget* gProtoLayout;

    62 -static GtkWidget* gButtonWidget;

    63 +static MozGtkWidget gButton;

    64  static GtkWidget* gToggleButtonWidget;

    65  static GtkWidget* gButtonArrowWidget;

    66 -static GtkWidget* gCheckboxWidget;

    67 -static GtkWidget* gRadiobuttonWidget;

    68 -static GtkWidget* gHorizScrollbarWidget;

    69 -static GtkWidget* gVertScrollbarWidget;

    70 -static GtkWidget* gSpinWidget;

    71 +static MozGtkWidget gCheckbox;

    72 +static MozGtkWidget gRadiobutton;

    73 +static MozGtkWidget gVertScrollbar;

    74 +static MozGtkWidget gHorizScrollbar;

    75 +static MozGtkWidget gSpin;

    76  static GtkWidget* gHScaleWidget;

    77  static GtkWidget* gVScaleWidget;

    78 -static GtkWidget* gEntryWidget;

    79 +static MozGtkWidget gEntry;

    80  static GtkWidget* gComboBoxWidget;

    81  static GtkWidget* gComboBoxButtonWidget;

    82  static GtkWidget* gComboBoxArrowWidget;

    83  static GtkWidget* gComboBoxSeparatorWidget;

    84  static GtkWidget* gComboBoxEntryWidget;

    85 -static GtkWidget* gComboBoxEntryTextareaWidget;

    86 +static MozGtkWidget gComboBoxEntryTextarea;

    87  static GtkWidget* gComboBoxEntryButtonWidget;

    88  static GtkWidget* gComboBoxEntryArrowWidget;

    89  static GtkWidget* gHandleBoxWidget;

    90  static GtkWidget* gToolbarWidget;

    91  static GtkWidget* gFrameWidget;

    92  static GtkWidget* gStatusbarWidget;

    93 -static GtkWidget* gProgressWidget;

    94 +static MozGtkWidget gProgressBar;

    95  static GtkWidget* gTabWidget;

    96 -static GtkWidget* gTooltipWidget;

    97 +static MozGtkWidget gTooltip;

    98  static GtkWidget* gMenuBarWidget;

    99  static GtkWidget* gMenuBarItemWidget;

   100  static GtkWidget* gMenuPopupWidget;

   101 @@ -78,6 +130,37 @@ static gboolean is_initialized;

   102  #define GTK_STATE_FLAG_CHECKED (1 << 11)

   103  #endif

   104  

   105 +void moz_gtk_widget_free(MozGtkWidget *aMozWidget)

   106 +{

   107 +    // This was removed as a child of gProtoWindow

   108 +    if (aMozWidget->widget) {

   109 +        aMozWidget->widget = NULL;

   110 +    }

   111 +

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

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

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

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

   116 +        }

   117 +    }

   118 +}

   119 +

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

   121 +#if GTK_CHECK_VERSION(3, 19, 2)

   122 +#define moz_gtk_path_set_class_name    gtk_widget_path_iter_set_object_name

   123 +#else

   124 +#define moz_gtk_path_set_class_name    gtk_widget_path_iter_add_class

   125 +#endif

   126 +//gtk_widget_path_iter_get_state

   127 +

   128 +static void

   129 +moz_gtk_get_style_border(GtkStyleContext* style, GtkStateFlags state_flags,

   130 +                         GtkBorder *border);

   131 +

   132 +static void

   133 +moz_gtk_get_style_padding(GtkStyleContext* style, GtkStateFlags state_flags,

   134 +                          GtkBorder *padding);

   135 +

   136  static GtkStateFlags

   137  GetStateFlagsFromGtkWidgetState(GtkWidgetState* state)

   138  {

   139 @@ -97,6 +180,41 @@ GetStateFlagsFromGtkWidgetState(GtkWidge

   140      return stateFlags;

   141  }

   142  

   143 +GtkStyleContext *

   144 +moz_gtk_style_create(GtkCssNode *node, GtkStyleContext *parent)

   145 +{

   146 +  GtkWidgetPath *path;

   147 +  GtkStyleContext *context;

   148 +

   149 +  if (parent)

   150 +    path = gtk_widget_path_copy (gtk_style_context_get_path (parent));

   151 +  else

   152 +    path = gtk_widget_path_new ();

   153 +

   154 +  gtk_widget_path_append_type (path, node->type);

   155 +  if (node->name)

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

   157 +  if (node->class1)

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

   159 +  if (node->class2)

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

   161 +

   162 +  context = gtk_style_context_new ();

   163 +  gtk_style_context_set_path (context, path);

   164 +  gtk_style_context_set_parent (context, parent);

   165 +

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

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

   168 +       * for it to take effect

   169 +       */

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

   171 +  }

   172 +

   173 +  gtk_widget_path_unref (path);

   174 +

   175 +  return context;

   176 +}

   177 +

   178  /* Because we have such an unconventional way of drawing widgets, signal to the GTK theme engine

   179     that they are drawing for Mozilla instead of a conventional GTK app so they can do any specific

   180     things they may want to do. */

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

   182  static gint

   183  ensure_button_widget()

   184  {

   185 -    if (!gButtonWidget) {

   186 -        gButtonWidget = gtk_button_new_with_label("M");

   187 -        setup_widget_prototype(gButtonWidget);

   188 +    if (!gButton.widget) {

   189 +        GtkCssNode path[] = { 

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

   191 +        };

   192 +

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

   194 +        setup_widget_prototype(gButton.widget);

   195 +        gtk_widget_show(gButton.widget);

   196 +

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

   198      }

   199      return MOZ_GTK_SUCCESS;

   200  }

   201 @@ -195,9 +320,21 @@ ensure_button_arrow_widget()

   202  static gint

   203  ensure_checkbox_widget()

   204  {

   205 -    if (!gCheckboxWidget) {

   206 -        gCheckboxWidget = gtk_check_button_new_with_label("M");

   207 -        setup_widget_prototype(gCheckboxWidget);

   208 +   if (!gCheckbox.widget) {

   209 +        GtkCssNode path[] = {

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

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

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

   213 +        };

   214 +

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

   216 +        setup_widget_prototype(gCheckbox.widget);

   217 +

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

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

   220 +                                       gCheckbox.check.style);

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

   222 +                                       gCheckbox.check.style);

   223      }

   224      return MOZ_GTK_SUCCESS;

   225  }

   226 @@ -205,9 +342,21 @@ ensure_checkbox_widget()

   227  static gint

   228  ensure_radiobutton_widget()

   229  {

   230 -    if (!gRadiobuttonWidget) {

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

   232 -        setup_widget_prototype(gRadiobuttonWidget);

   233 +    if (!gRadiobutton.widget) {

   234 +        GtkCssNode path[] = {

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

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

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

   238 +        };

   239 +

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

   241 +        setup_widget_prototype(gRadiobutton.widget);

   242 +

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

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

   245 +                                          gRadiobutton.check.style);

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

   247 +                                          gRadiobutton.check.style);

   248      }

   249      return MOZ_GTK_SUCCESS;

   250  }

   251 @@ -215,25 +364,62 @@ ensure_radiobutton_widget()

   252  static gint

   253  ensure_scrollbar_widget()

   254  {

   255 -    if (!gVertScrollbarWidget) {

   256 -        gVertScrollbarWidget = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, NULL);

   257 -        setup_widget_prototype(gVertScrollbarWidget);

   258 -    }

   259 -    if (!gHorizScrollbarWidget) {

   260 -        gHorizScrollbarWidget = gtk_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, NULL);

   261 -        setup_widget_prototype(gHorizScrollbarWidget);

   262 -    }

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

   264 +        GtkCssNode path[] = {

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

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

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

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

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

   270 +        };

   271 +

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

   273 +        setup_widget_prototype(gHorizScrollbar.widget);

   274 +

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

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

   277 +                                               gHorizScrollbar.scroll.style);

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

   279 +                                               gHorizScrollbar.scroll.styleContents);

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

   281 +                                               gHorizScrollbar.scroll.styleTrough);

   282 +

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

   284 +        setup_widget_prototype(gVertScrollbar.widget);

   285 +

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

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

   288 +                                              gVertScrollbar.scroll.style);

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

   290 +                                              gVertScrollbar.scroll.styleContents);

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

   292 +                                              gVertScrollbar.scroll.styleTrough);

   293 +

   294 +     }

   295      return MOZ_GTK_SUCCESS;

   296  }

   297  

   298  static gint

   299  ensure_spin_widget()

   300  {

   301 -  if (!gSpinWidget) {

   302 -    gSpinWidget = gtk_spin_button_new(NULL, 1, 0);

   303 -    setup_widget_prototype(gSpinWidget);

   304 -  }

   305 -  return MOZ_GTK_SUCCESS;

   306 +    if (!gSpin.widget) {

   307 +        GtkCssNode path[] = {

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

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

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

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

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

   313 +        };

   314 +

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

   316 +        setup_widget_prototype(gSpin.widget);

   317 +

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

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

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

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

   322 +    }

   323 +    return MOZ_GTK_SUCCESS;

   324  }

   325  

   326  static gint

   327 @@ -253,9 +439,19 @@ ensure_scale_widget()

   328  static gint

   329  ensure_entry_widget()

   330  {

   331 -    if (!gEntryWidget) {

   332 -        gEntryWidget = gtk_entry_new();

   333 -        setup_widget_prototype(gEntryWidget);

   334 +    if (!gEntry.widget) {

   335 +        GtkCssNode path[] = { 

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

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

   338 +        };

   339 +

   340 +        gEntry.widget = gtk_entry_new();

   341 +        setup_widget_prototype(gEntry.widget);

   342 +        gtk_widget_show(gEntry.widget);

   343 +

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

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

   346 +                                                           gEntry.entry.style);

   347      }

   348      return MOZ_GTK_SUCCESS;

   349  }

   350 @@ -387,9 +583,9 @@ moz_gtk_get_combo_box_entry_inner_widget

   351          g_object_add_weak_pointer(G_OBJECT(widget),

   352                                    (gpointer) &gComboBoxEntryButtonWidget);

   353      } else if (GTK_IS_ENTRY(widget)) {

   354 -        gComboBoxEntryTextareaWidget = widget;

   355 +        gComboBoxEntryTextarea.widget = widget;

   356          g_object_add_weak_pointer(G_OBJECT(widget),

   357 -                                  (gpointer) &gComboBoxEntryTextareaWidget);

   358 +                                  (gpointer) &gComboBoxEntryTextarea.widget);

   359      } else

   360          return;

   361      gtk_widget_realize(widget);

   362 @@ -411,7 +607,7 @@ ensure_combo_box_entry_widgets()

   363  {

   364      GtkWidget* buttonChild;

   365  

   366 -    if (gComboBoxEntryTextareaWidget &&

   367 +    if (gComboBoxEntryTextarea.widget &&

   368              gComboBoxEntryButtonWidget &&

   369              gComboBoxEntryArrowWidget)

   370          return MOZ_GTK_SUCCESS;

   371 @@ -427,9 +623,9 @@ ensure_combo_box_entry_widgets()

   372                           moz_gtk_get_combo_box_entry_inner_widgets,

   373                           NULL);

   374  

   375 -    if (!gComboBoxEntryTextareaWidget) {

   376 +    if (!gComboBoxEntryTextarea.widget) {

   377          ensure_entry_widget();

   378 -        gComboBoxEntryTextareaWidget = gEntryWidget;

   379 +        gComboBoxEntryTextarea.widget = gEntry.widget;

   380      }

   381  

   382      if (gComboBoxEntryButtonWidget) {

   383 @@ -507,12 +703,18 @@ ensure_toolbar_separator_widget()

   384  static gint

   385  ensure_tooltip_widget()

   386  {

   387 -    if (!gTooltipWidget) {

   388 -        gTooltipWidget = gtk_window_new(GTK_WINDOW_POPUP);

   389 -        GtkStyleContext* style = gtk_widget_get_style_context(gTooltipWidget);

   390 -        gtk_style_context_add_class(style, GTK_STYLE_CLASS_TOOLTIP);

   391 -        gtk_widget_realize(gTooltipWidget);

   392 -        moz_gtk_set_widget_name(gTooltipWidget);

   393 +    if (!gTooltip.widget) {

   394 +        GtkCssNode path[] = { 

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

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

   397 +        };

   398 +

   399 +        gTooltip.widget = gtk_window_new(GTK_WINDOW_POPUP);

   400 +        gtk_widget_realize(gTooltip.widget);

   401 +        moz_gtk_set_widget_name(gTooltip.widget);

   402 +

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

   404 +        gTooltip.tooltip.styleBackground = moz_gtk_style_create(&path[1], NULL);

   405      }

   406      return MOZ_GTK_SUCCESS;

   407  }

   408 @@ -530,9 +732,21 @@ ensure_tab_widget()

   409  static gint

   410  ensure_progress_widget()

   411  {

   412 -    if (!gProgressWidget) {

   413 -        gProgressWidget = gtk_progress_bar_new();

   414 -        setup_widget_prototype(gProgressWidget);

   415 +    if (!gProgressBar.widget) {

   416 +        GtkCssNode path[] = {

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

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

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

   420 +        };

   421 +

   422 +        gProgressBar.widget = gtk_progress_bar_new();

   423 +        setup_widget_prototype(gProgressBar.widget);

   424 +

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

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

   427 +                                              gProgressBar.progress.style);

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

   429 +                                                gProgressBar.progress.styleTrough);

   430      }

   431      return MOZ_GTK_SUCCESS;

   432  }

   433 @@ -638,6 +852,11 @@ static gint

   434  ensure_check_menu_item_widget()

   435  {

   436      if (!gCheckMenuItemWidget) {

   437 +        GtkCssNode path[] = {

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

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

   440 +        };

   441 +

   442          ensure_menu_popup_widget();

   443          gCheckMenuItemWidget = gtk_check_menu_item_new_with_label("M");

   444          gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),

   445 @@ -752,7 +971,7 @@ moz_gtk_checkbox_get_metrics(gint* indic

   446  {

   447      ensure_checkbox_widget();

   448  

   449 -    gtk_widget_style_get (gCheckboxWidget,

   450 +    gtk_widget_style_get (gCheckbox.widget,

   451                            "indicator_size", indicator_size,

   452                            "indicator_spacing", indicator_spacing,

   453                            NULL);

   454 @@ -765,7 +984,7 @@ moz_gtk_radio_get_metrics(gint* indicato

   455  {

   456      ensure_radiobutton_widget();

   457  

   458 -    gtk_widget_style_get (gRadiobuttonWidget,

   459 +    gtk_widget_style_get (gRadiobutton.widget,

   460                            "indicator_size", indicator_size,

   461                            "indicator_spacing", indicator_spacing,

   462                            NULL);

   463 @@ -778,13 +997,13 @@ moz_gtk_get_focus_outline_size(gint* foc

   464  {

   465      GtkBorder border;

   466      GtkBorder padding;

   467 -    GtkStyleContext *style;

   468 +    GtkStyleContext* style;

   469  

   470      ensure_entry_widget();

   471 -    style = gtk_widget_get_style_context(gEntryWidget);

   472  

   473 -    gtk_style_context_get_border(style, 0, &border);

   474 -    gtk_style_context_get_padding(style, 0, &padding);

   475 +    style = gEntry.entry.style;

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

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

   478      *focus_h_width = border.left + padding.left;

   479      *focus_v_width = border.top + padding.top;

   480      return MOZ_GTK_SUCCESS;

   481 @@ -821,7 +1040,7 @@ moz_gtk_button_get_default_overflow(gint

   482      GtkBorder* default_outside_border;

   483  

   484      ensure_button_widget();

   485 -    gtk_widget_style_get(gButtonWidget,

   486 +    gtk_widget_style_get(gButton.widget,

   487                           "default-outside-border", &default_outside_border,

   488                           NULL);

   489  

   490 @@ -844,7 +1063,7 @@ moz_gtk_button_get_default_border(gint*

   491      GtkBorder* default_border;

   492  

   493      ensure_button_widget();

   494 -    gtk_widget_style_get(gButtonWidget,

   495 +    gtk_widget_style_get(gButton.widget,

   496                           "default-border", &default_border,

   497                           NULL);

   498  

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

   500  

   501      if (state->focused) {

   502          GtkBorder border;

   503 -        gtk_style_context_get_border(style, state_flags, &border);

   504 +        moz_gtk_get_style_border(style, state_flags, &border);

   505          x += border.left;

   506          y += border.top;

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

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

   509      gint indicator_size, indicator_spacing;

   510      gint x, y, width, height;

   511      gint focus_x, focus_y, focus_width, focus_height;

   512 -    GtkWidget *w;

   513 -    GtkStyleContext *style;

   514 +    MozGtkWidget *w;

   515  

   516      if (isradio) {

   517          moz_gtk_radio_get_metrics(&indicator_size, &indicator_spacing);

   518 -        w = gRadiobuttonWidget;

   519 +        w = &gRadiobutton;

   520      } else {

   521          moz_gtk_checkbox_get_metrics(&indicator_size, &indicator_spacing);

   522 -        w = gCheckboxWidget;

   523 +        w = &gCheckbox;

   524      }

   525  

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

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

   528      focus_width = width + 2 * indicator_spacing;

   529      focus_height = height + 2 * indicator_spacing;

   530    

   531 -    style = gtk_widget_get_style_context(w);

   532 -

   533 -    gtk_widget_set_sensitive(w, !state->disabled);

   534 -    gtk_widget_set_direction(w, direction);

   535 -    gtk_style_context_save(style);

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

   537 +    gtk_widget_set_direction(w->widget, direction);

   538 +    gtk_style_context_save(w->check.styleCheck);

   539  

   540      if (selected)

   541          state_flags |= checkbox_check_state;

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

   543      if (inconsistent)

   544          state_flags |= GTK_STATE_FLAG_INCONSISTENT;

   545  

   546 -    gtk_style_context_set_state(style, state_flags);

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

   548 +

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

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

   551  

   552      if (isradio) {

   553 -        gtk_style_context_add_class(style, GTK_STYLE_CLASS_RADIO);

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

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

   556          if (state->focused) {

   557 -            gtk_render_focus(style, cr, focus_x, focus_y,

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

   559                              focus_width, focus_height);

   560          }

   561      }

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

   563          * 'indeterminate' type on checkboxes. In GTK, the shadow type

   564          * must also be changed for the state to be drawn.

   565          */        

   566 -        gtk_style_context_add_class(style, GTK_STYLE_CLASS_CHECK);

   567 -        gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(gCheckboxWidget), inconsistent);

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

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

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

   571          if (state->focused) {

   572 -            gtk_render_focus(style, cr, 

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

   574                               focus_x, focus_y, focus_width, focus_height);

   575          }

   576      }

   577 -    gtk_style_context_restore(style);

   578 +    gtk_style_context_restore(w->check.styleCheck);

   579  

   580      return MOZ_GTK_SUCCESS;

   581  }

   582 @@ -1035,8 +1252,8 @@ calculate_button_inner_rect(GtkWidget* b

   583      style = gtk_widget_get_style_context(button);

   584  

   585      /* This mirrors gtkbutton's child positioning */

   586 -    gtk_style_context_get_border(style, 0, &border);

   587 -    gtk_style_context_get_padding(style, 0, &padding);

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

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

   590  

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

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

   593 @@ -1099,9 +1316,9 @@ moz_gtk_scrollbar_button_paint(cairo_t *

   594      ensure_scrollbar_widget();

   595  

   596      if (flags & MOZ_GTK_STEPPER_VERTICAL)

   597 -        scrollbar = gVertScrollbarWidget;

   598 +        scrollbar = gVertScrollbar.widget;

   599      else

   600 -        scrollbar = gHorizScrollbarWidget;

   601 +        scrollbar = gHorizScrollbar.widget;

   602  

   603      gtk_widget_set_direction(scrollbar, direction);

   604  

   605 @@ -1181,25 +1398,22 @@ moz_gtk_scrollbar_trough_paint(GtkThemeW

   606                                 GtkTextDirection direction)

   607  {

   608      GtkStyleContext* style;

   609 -    GtkScrollbar *scrollbar;

   610  

   611      ensure_scrollbar_widget();

   612  

   613 -    if (widget ==  MOZ_GTK_SCROLLBAR_HORIZONTAL)

   614 -        scrollbar = GTK_SCROLLBAR(gHorizScrollbarWidget);

   615 -    else

   616 -        scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);

   617 -

   618 -    gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);

   619 -    

   620      if (flags & MOZ_GTK_TRACK_OPAQUE) {

   621          style = gtk_widget_get_style_context(GTK_WIDGET(gProtoWindow));

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

   623      }

   624  

   625 -    style = gtk_widget_get_style_context(GTK_WIDGET(scrollbar));

   626 -    gtk_style_context_save(style);

   627 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_TROUGH);

   628 +     if (widget == MOZ_GTK_SCROLLBAR_HORIZONTAL) {

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

   630 +        style = gHorizScrollbar.scroll.style;

   631 +    }

   632 +    else {

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

   634 +        style = gVertScrollbar.scroll.style;

   635 +    }

   636  

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

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

   639 @@ -1208,7 +1422,6 @@ moz_gtk_scrollbar_trough_paint(GtkThemeW

   640          gtk_render_focus(style, cr,

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

   642      }

   643 -    gtk_style_context_restore(style);

   644      return MOZ_GTK_SUCCESS;

   645  }

   646  

   647 @@ -1220,24 +1433,20 @@ moz_gtk_scrollbar_thumb_paint(GtkThemeWi

   648  {

   649      GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);

   650      GtkStyleContext* style;

   651 -    GtkScrollbar *scrollbar;

   652      GtkBorder margin;

   653  

   654      ensure_scrollbar_widget();

   655  

   656 -    if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL)

   657 -        scrollbar = GTK_SCROLLBAR(gHorizScrollbarWidget);

   658 -    else

   659 -        scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);

   660 -

   661 -    gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);

   662 -

   663 -    style = gtk_widget_get_style_context(GTK_WIDGET(scrollbar));

   664 -    gtk_style_context_save(style);

   665 +    if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) {

   666 +        style = gHorizScrollbar.scroll.styleSlider;

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

   668 +    }

   669 +    else {

   670 +        style = gVertScrollbar.scroll.styleSlider; 

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

   672 +    }

   673  

   674 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_SLIDER);

   675      gtk_style_context_set_state(style, state_flags);

   676 -

   677      gtk_style_context_get_margin (style, state_flags, &margin);

   678  

   679      gtk_render_slider(style, cr,

   680 @@ -1248,8 +1457,6 @@ moz_gtk_scrollbar_thumb_paint(GtkThemeWi

   681                       (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) ?

   682                       GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL);

   683  

   684 -    gtk_style_context_restore(style);

   685 -

   686      return MOZ_GTK_SUCCESS;

   687  }

   688  

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

   690      GtkStyleContext* style;

   691  

   692      ensure_spin_widget();

   693 -    gtk_widget_set_direction(gSpinWidget, direction);

   694 -    style = gtk_widget_get_style_context(gSpinWidget);

   695 +    gtk_widget_set_direction(gSpin.widget, direction);

   696 +    style = gSpin.spin.style;

   697      gtk_style_context_save(style);

   698      gtk_style_context_add_class(style, GTK_STYLE_CLASS_SPINBUTTON);

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

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

   701      GtkStyleContext* style;

   702  

   703      ensure_spin_widget();

   704 -    style = gtk_widget_get_style_context(gSpinWidget);

   705 +    style = gSpin.spin.style;

   706      gtk_style_context_save(style);

   707 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_SPINBUTTON);

   708      gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));

   709 -    gtk_widget_set_direction(gSpinWidget, direction);

   710 +    gtk_widget_set_direction(gSpin.widget, direction);

   711  

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

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

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

   715  static gint

   716  moz_gtk_entry_paint(cairo_t *cr, GdkRectangle* rect,

   717                      GtkWidgetState* state,

   718 -                    GtkWidget* widget, GtkTextDirection direction)

   719 +                    MozGtkWidget* w, GtkTextDirection direction)

   720  {

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

   722 -    GtkStyleContext* style;

   723      int draw_focus_outline_only = state->depressed; // NS_THEME_FOCUS_OUTLINE

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

   725  

   726 -    gtk_widget_set_direction(widget, direction);

   727 -

   728 -    style = gtk_widget_get_style_context(widget);

   729 +    gtk_widget_set_direction(w->widget, direction);

   730  

   731      if (draw_focus_outline_only) {

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

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

   734       * textarea window uses gtk_paint_flat_box when exposed */

   735  

   736      /* This gets us a lovely greyish disabledish look */

   737 -    gtk_widget_set_sensitive(widget, !state->disabled);

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

   739  

   740      gtk_style_context_save(style);

   741 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_ENTRY);

   742    

   743      /* Now paint the shadow and focus border.

   744       * We do like in gtk_entry_draw_frame, we first draw the shadow, a tad

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

   746      style = gtk_widget_get_style_context(gScrolledWindowWidget);

   747      gtk_style_context_save(style);

   748      gtk_style_context_add_class(style, GTK_STYLE_CLASS_FRAME);    

   749 -    gtk_style_context_get_border(style, state_flags, &border);

   750 +    moz_gtk_get_style_border(style, state_flags, &border);

   751      xthickness = border.left;

   752      ythickness = border.top;    

   753  

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

   755          if (direction == GTK_TEXT_DIR_LTR) {

   756              GtkBorder padding;

   757              GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);

   758 -            gtk_style_context_get_padding(style, state_flags, &padding);

   759 +            moz_gtk_get_style_padding(style, state_flags, &padding);

   760              arrow_rect.x -= padding.left;

   761          }

   762          else

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

   764                          gboolean isradio, GtkTextDirection direction)

   765  {

   766      GtkStateFlags state_flags = GetStateFlagsFromGtkWidgetState(state);

   767 -    GtkStyleContext* style;

   768 -    GtkWidget *widget;

   769 +    MozGtkWidget *widget;

   770  

   771      if (isradio) {

   772          ensure_radiobutton_widget();

   773 -        widget = gRadiobuttonWidget;

   774 +        widget = &gRadiobutton;

   775      } else {

   776          ensure_checkbox_widget();

   777 -        widget = gCheckboxWidget;

   778 +        widget = &gCheckbox;

   779      }

   780 -    gtk_widget_set_direction(widget, direction);

   781 +    gtk_widget_set_direction(widget->widget, direction);

   782  

   783 -    style = gtk_widget_get_style_context(widget);

   784 -    gtk_style_context_save(style);

   785 -    gtk_style_context_set_state(style, state_flags);

   786 +    gtk_style_context_save(widget->check.style);

   787 +    gtk_style_context_set_state(widget->check.style, state_flags);

   788    

   789      /* this is for drawing a prelight box */

   790      if (state_flags & GTK_STATE_FLAG_PRELIGHT) {

   791 -        gtk_render_background(style, cr,

   792 +        gtk_render_background(widget->check.style, cr,

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

   794      }

   795    

   796 -    gtk_style_context_restore(style);

   797 +    gtk_style_context_restore(widget->check.style);

   798    

   799      return MOZ_GTK_SUCCESS;

   800  }

   801 @@ -1836,32 +2037,26 @@ moz_gtk_toggle_label_paint(cairo_t *cr,

   802                             GtkWidgetState* state, 

   803                             gboolean isradio, GtkTextDirection direction)

   804  {

   805 -    GtkStyleContext *style;

   806 -    GtkWidget *widget;

   807 +    MozGtkWidget *widget;

   808  

   809      if (!state->focused)

   810          return MOZ_GTK_SUCCESS;

   811  

   812      if (isradio) {

   813          ensure_radiobutton_widget();

   814 -        widget = gRadiobuttonWidget;

   815 +        widget = &gRadiobutton;

   816      } else {

   817          ensure_checkbox_widget();

   818 -        widget = gCheckboxWidget;

   819 -    }

   820 -    style = gtk_widget_get_style_context(widget);

   821 -    gtk_style_context_save(style);

   822 -    if (isradio) {

   823 -      gtk_style_context_add_class(style, GTK_STYLE_CLASS_RADIO);

   824 -    } else {

   825 -      gtk_style_context_add_class(style, GTK_STYLE_CLASS_CHECK);

   826 +        widget = &gCheckbox;

   827      }

   828 -    gtk_widget_set_direction(widget, direction);

   829 +    gtk_style_context_save(widget->check.styleLabel);

   830 +    gtk_widget_set_direction(widget->widget, direction);

   831  

   832 -    gtk_style_context_set_state(style, GetStateFlagsFromGtkWidgetState(state));

   833 -    gtk_render_focus(style, cr,

   834 +    gtk_style_context_set_state(widget->check.styleLabel, 

   835 +                                GetStateFlagsFromGtkWidgetState(state));

   836 +    gtk_render_focus(widget->check.styleLabel, cr,

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

   838 -    gtk_style_context_restore(style);

   839 +    gtk_style_context_restore(widget->check.styleLabel);

   840  

   841      return MOZ_GTK_SUCCESS;

   842  }

   843 @@ -1922,7 +2117,7 @@ moz_gtk_toolbar_separator_paint(cairo_t

   844                            rect->height * (end_fraction - start_fraction));

   845      } else {

   846          GtkBorder padding;

   847 -        gtk_style_context_get_padding(style, 0, &padding);

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

   849      

   850          paint_width = padding.left;

   851          if (paint_width > rect->width)

   852 @@ -1945,9 +2140,9 @@ moz_gtk_tooltip_paint(cairo_t *cr, GdkRe

   853      GtkStyleContext* style;

   854  

   855      ensure_tooltip_widget();

   856 -    gtk_widget_set_direction(gTooltipWidget, direction);

   857 +    gtk_widget_set_direction(gTooltip.widget, direction);

   858  

   859 -    style = gtk_widget_get_style_context(gTooltipWidget);

   860 +    style = gTooltip.tooltip.styleBackground;

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

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

   863      return MOZ_GTK_SUCCESS;

   864 @@ -2006,18 +2201,13 @@ static gint

   865  moz_gtk_progressbar_paint(cairo_t *cr, GdkRectangle* rect,

   866                            GtkTextDirection direction)

   867  {

   868 -    GtkStyleContext* style;

   869 -

   870      ensure_progress_widget();

   871 -    gtk_widget_set_direction(gProgressWidget, direction);

   872 +    gtk_widget_set_direction(gProgressBar.widget, direction);

   873  

   874 -    style = gtk_widget_get_style_context(gProgressWidget);

   875 -    gtk_style_context_save(style);

   876 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_TROUGH);

   877 -    

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

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

   880 -    gtk_style_context_restore(style);

   881 +    gtk_render_background(gProgressBar.progress.styleTrough, cr,

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

   883 +    gtk_render_frame(gProgressBar.progress.styleTrough, cr,

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

   885  

   886      return MOZ_GTK_SUCCESS;

   887  }

   888 @@ -2027,15 +2217,8 @@ moz_gtk_progress_chunk_paint(cairo_t *cr

   889                               GtkTextDirection direction,

   890                               GtkThemeWidgetType widget)

   891  {

   892 -    GtkStyleContext* style;

   893 -

   894      ensure_progress_widget();

   895 -    gtk_widget_set_direction(gProgressWidget, direction);

   896 -

   897 -    style = gtk_widget_get_style_context(gProgressWidget);

   898 -    gtk_style_context_save(style);

   899 -    gtk_style_context_remove_class(style, GTK_STYLE_CLASS_TROUGH);

   900 -    gtk_style_context_add_class(style, GTK_STYLE_CLASS_PROGRESSBAR);

   901 +    gtk_widget_set_direction(gProgressBar.widget, direction);

   902  

   903      if (widget == MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE ||

   904          widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE) {

   905 @@ -2074,12 +2257,14 @@ moz_gtk_progress_chunk_paint(cairo_t *cr

   906      // gtk_render_activity was used to render progress chunks on GTK versions

   907      // before 3.13.7, see bug 1173907.

   908      if (!gtk_check_version(3, 13, 7)) {

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

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

   911 +      gtk_render_background(gProgressBar.progress.styleProgress, cr,

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

   913 +      gtk_render_frame(gProgressBar.progress.styleProgress, cr,

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

   915      } else {

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

   917 +      gtk_render_activity(gProgressBar.progress.styleProgress, cr,

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

   919      }

   920 -    gtk_style_context_restore(style);

   921  

   922      return MOZ_GTK_SUCCESS;

   923  }

   924 @@ -2096,7 +2281,7 @@ moz_gtk_get_tab_thickness(void)

   925  

   926      style = gtk_widget_get_style_context(gTabWidget);

   927      gtk_style_context_add_class(style, GTK_STYLE_CLASS_NOTEBOOK);

   928 -    gtk_style_context_get_border(style, 0, &border);

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

   930  

   931      if (border.top < 2)

   932          return 2; /* some themes don't set ythickness correctly */

   933 @@ -2292,7 +2477,7 @@ moz_gtk_tab_paint(cairo_t *cr, GdkRectan

   934        gtk_style_context_save(style);

   935        moz_gtk_tab_prepare_style_context(style, flags);

   936  

   937 -      gtk_style_context_get_padding(style, GetStateFlagsFromGtkWidgetState(state), &padding);

   938 +      moz_gtk_get_style_padding(style, GetStateFlagsFromGtkWidgetState(state), &padding);

   939  

   940        focusRect.x += padding.left;

   941        focusRect.width -= (padding.left + padding.right);

   942 @@ -2408,7 +2593,7 @@ moz_gtk_tab_scroll_arrow_paint(cairo_t *

   943  }

   944  

   945  static gint

   946 -moz_gtk_menu_bar_paint(cairo_t *cr, GdkRectangle* rect,

   947 +moz_gtk_menu_bar_paint(cairo_t *cr, GdkRectangle* rect, GtkWidgetState* state,

   948                         GtkTextDirection direction)

   949  {

   950      GtkStyleContext* style;

   951 @@ -2468,7 +2653,7 @@ moz_gtk_menu_separator_paint(cairo_t *cr

   952      border_width = gtk_container_get_border_width(GTK_CONTAINER(gMenuSeparatorWidget));

   953  

   954      style = gtk_widget_get_style_context(gMenuSeparatorWidget);

   955 -    gtk_style_context_get_padding(style, 0, &padding);

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

   957  

   958      x = rect->x + border_width;

   959      y = rect->y + border_width;

   960 @@ -2521,7 +2706,8 @@ moz_gtk_menu_item_paint(cairo_t *cr, Gdk

   961              item_widget = gMenuItemWidget;

   962          }

   963          style = gtk_widget_get_style_context(item_widget);

   964 -        gtk_style_context_save(style);

   965 +// TODO - FIX!

   966 +//        gtk_style_context_save(style);

   967  

   968          if (flags & MOZ_TOPLEVEL_MENU_ITEM) {

   969              gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUBAR);

   970 @@ -2540,7 +2726,7 @@ moz_gtk_menu_item_paint(cairo_t *cr, Gdk

   971  

   972          gtk_render_background(style, cr, x, y, w, h);

   973          gtk_render_frame(style, cr, x, y, w, h);

   974 -        gtk_style_context_restore(style);

   975 +//        gtk_style_context_restore(style);

   976      }

   977  

   978      return MOZ_GTK_SUCCESS;

   979 @@ -2556,7 +2742,10 @@ moz_gtk_menu_arrow_paint(cairo_t *cr, Gd

   980  

   981      ensure_menu_item_widget();

   982      gtk_widget_set_direction(gMenuItemWidget, direction);

   983 -

   984 +/*

   985 +    state_flags |= (direction == GTK_TEXT_DIR_LTR) ? GTK_STATE_FLAG_DIR_LTR :

   986 +                                                     GTK_STATE_FLAG_DIR_RTL;

   987 +*/

   988      style = gtk_widget_get_style_context(gMenuItemWidget);

   989      gtk_style_context_save(style);

   990      gtk_style_context_add_class(style, GTK_STYLE_CLASS_MENUITEM);

   991 @@ -2606,7 +2795,7 @@ moz_gtk_check_menu_item_paint(cairo_t *c

   992      }

   993      

   994      gtk_style_context_set_state(style, state_flags);

   995 -    gtk_style_context_get_padding(style, state_flags, &padding);

   996 +    moz_gtk_get_style_padding(style, state_flags, &padding);

   997  

   998      offset = gtk_container_get_border_width(GTK_CONTAINER(gCheckMenuItemWidget)) +

   999                                              padding.left + 2;

  1000 @@ -2658,7 +2847,7 @@ moz_gtk_add_style_border(GtkStyleContext

  1001  {

  1002      GtkBorder border;

  1003  

  1004 -    gtk_style_context_get_border(style, 0, &border);

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

  1006  

  1007      *left += border.left;

  1008      *right += border.right;

  1009 @@ -2667,12 +2856,22 @@ moz_gtk_add_style_border(GtkStyleContext

  1010  }

  1011  

  1012  static void

  1013 +moz_gtk_get_style_border(GtkStyleContext* style, GtkStateFlags state_flags,

  1014 +                         GtkBorder *border)

  1015 +{

  1016 +    gtk_style_context_save(style);

  1017 +    gtk_style_context_set_state(style, state_flags);

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

  1019 +    gtk_style_context_restore(style);

  1020 +}

  1021 +

  1022 +static void

  1023  moz_gtk_add_style_padding(GtkStyleContext* style,

  1024                            gint* left, gint* top, gint* right, gint* bottom)

  1025  {

  1026      GtkBorder padding;

  1027  

  1028 -    gtk_style_context_get_padding(style, 0, &padding);

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

  1030  

  1031      *left += padding.left;

  1032      *right += padding.right;

  1033 @@ -2680,6 +2879,16 @@ moz_gtk_add_style_padding(GtkStyleContex

  1034      *bottom += padding.bottom;

  1035  }

  1036  

  1037 +static void

  1038 +moz_gtk_get_style_padding(GtkStyleContext* style, GtkStateFlags state_flags,

  1039 +                          GtkBorder *padding)

  1040 +{

  1041 +    gtk_style_context_save(style);

  1042 +    gtk_style_context_set_state(style, state_flags);

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

  1044 +    gtk_style_context_restore(style);

  1045 +}

  1046 +

  1047  gint

  1048  moz_gtk_get_widget_border(GtkThemeWidgetType widget, gint* left, gint* top,

  1049                            gint* right, gint* bottom, GtkTextDirection direction,

  1050 @@ -2694,37 +2903,35 @@ moz_gtk_get_widget_border(GtkThemeWidget

  1051      case MOZ_GTK_TOOLBAR_BUTTON:

  1052          {

  1053              ensure_button_widget();

  1054 -            style = gtk_widget_get_style_context(gButtonWidget);

  1055 -

  1056 -            *left = *top = *right = *bottom = gtk_container_get_border_width(GTK_CONTAINER(gButtonWidget));

  1057  

  1058 -            if (widget == MOZ_GTK_TOOLBAR_BUTTON) {

  1059 -                gtk_style_context_save(style);

  1060 -                gtk_style_context_add_class(style, "image-button");

  1061 -            }

  1062 -              

  1063 -            moz_gtk_add_style_padding(style, left, top, right, bottom);

  1064 -                

  1065 -            if (widget == MOZ_GTK_TOOLBAR_BUTTON)

  1066 -                gtk_style_context_restore(style);

  1067 +            *left = *top = *right = *bottom = gtk_container_get_border_width(GTK_CONTAINER(gButton.widget));

  1068 +            moz_gtk_add_style_padding(gButton.button.style, left, top, right, bottom);

  1069  

  1070              // XXX: Subtract 1 pixel from the border to account for the added

  1071              // -moz-focus-inner border (Bug 1228281).

  1072              *left -= 1; *top -= 1; *right -= 1; *bottom -= 1;

  1073 -            moz_gtk_add_style_border(style, left, top, right, bottom);

  1074 +            moz_gtk_add_style_border(gButton.button.style, left, top, right, bottom);

  1075 +

  1076              return MOZ_GTK_SUCCESS;

  1077          }

  1078      case MOZ_GTK_ENTRY:

  1079          {

  1080              ensure_entry_widget();

  1081 -            style = gtk_widget_get_style_context(gEntryWidget);

  1082  

  1083              // XXX: Subtract 1 pixel from the padding to account for the default

  1084              // padding in forms.css. See bug 1187385.

  1085              *left = *top = *right = *bottom = -1;

  1086 -            moz_gtk_add_style_padding(style, left, top, right, bottom);

  1087 -            moz_gtk_add_style_border(style, left, top, right, bottom);

  1088  

  1089 +            moz_gtk_add_style_padding(gEntry.entry.style, left, top, right, bottom);

  1090 +            moz_gtk_add_style_border(gEntry.entry.style, left, top, right, bottom);

  1091 +

  1092 +            return MOZ_GTK_SUCCESS;

  1093 +        }

  1094 +    case MOZ_GTK_TOOLTIP:

  1095 +        {

  1096 +            ensure_tooltip_widget();

  1097 +            moz_gtk_add_style_padding(gTooltip.tooltip.styleBackground, left, top, right, bottom);

  1098 +            moz_gtk_add_style_border(gTooltip.tooltip.styleBackground, left, top, right, bottom);

  1099              return MOZ_GTK_SUCCESS;

  1100          }

  1101      case MOZ_GTK_TREEVIEW:

  1102 @@ -2759,7 +2966,7 @@ moz_gtk_get_widget_border(GtkThemeWidget

  1103          break;

  1104      case MOZ_GTK_DROPDOWN_ENTRY:

  1105          ensure_combo_box_entry_widgets();

  1106 -        w = gComboBoxEntryTextareaWidget;

  1107 +        w = gComboBoxEntryTextarea.widget;

  1108          break;

  1109      case MOZ_GTK_DROPDOWN_ARROW:

  1110          ensure_combo_box_entry_widgets();

  1111 @@ -2795,7 +3002,7 @@ moz_gtk_get_widget_border(GtkThemeWidget

  1112  

  1113                  if (!wide_separators) {

  1114                      style = gtk_widget_get_style_context(gComboBoxSeparatorWidget);

  1115 -                    gtk_style_context_get_border(style, 0, &border);

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

  1117                      separator_width = border.left;

  1118                  }

  1119              }

  1120 @@ -2814,14 +3021,17 @@ moz_gtk_get_widget_border(GtkThemeWidget

  1121          w = gTabWidget;

  1122          break;

  1123      case MOZ_GTK_PROGRESSBAR:

  1124 -        ensure_progress_widget();

  1125 -        w = gProgressWidget;

  1126 -        break;

  1127 +        {

  1128 +            ensure_progress_widget();

  1129 +            moz_gtk_add_style_border(gProgressBar.progress.styleTrough,

  1130 +                                     left, top, right, bottom);

  1131 +            return MOZ_GTK_SUCCESS;

  1132 +        }

  1133      case MOZ_GTK_SPINBUTTON_ENTRY:

  1134      case MOZ_GTK_SPINBUTTON_UP: