Changeset 29824

Timestamp:

01/27/08 16:04:31 (10 months ago)

Author:

alp@webkit.org

Message:

2008-01-27 Alp Toker <alp@atoker.com>

Reviewed by Mark Rowe.

http://bugs.webkit.org/show_bug.cgi?id=17029
Use of deprecated class function but declares GTK_DISABLE_DEPRECATED

Sync gtkdrawing.h (1.51) and gtk2drawing.c (1.71) from Mozilla
upstream.

Adapt RenderThemeGtk.cpp to track minor changes.

Location:

trunk/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/gtk/RenderThemeGtk.cpp (modified) (3 diffs)
• platform/gtk/gtk2drawing.c (modified) (80 diffs)
• platform/gtk/gtkdrawing.h (modified) (12 diffs)

trunk/WebCore/ChangeLog

@@ +1 @@
+2008-01-27  Alp Toker  <alp@atoker.com>
+
+        Reviewed by Mark Rowe.
+
+        http://bugs.webkit.org/show_bug.cgi?id=17029
+        Use of deprecated class function but declares GTK_DISABLE_DEPRECATED
+
+        Sync gtkdrawing.h (1.51) and gtk2drawing.c (1.71) from Mozilla
+        upstream.
+
+        Adapt RenderThemeGtk.cpp to track minor changes.
+
+        * platform/gtk/RenderThemeGtk.cpp:
+        (WebCore::gtkTextDirection):
+        (WebCore::adjustMozStyle):
+        (WebCore::setMozState):
+        (WebCore::paintMozWidget):
+        * platform/gtk/gtk2drawing.c:
+        (setup_widget_prototype):
+        (ensure_hpaned_widget):
+        (ensure_vpaned_widget):
+        (ensure_toggle_button_widget):
+        (ensure_combo_box_entry_widget):
+        (ensure_dropdown_entry_widget):
+        (moz_gtk_get_dropdown_button):
+        (ensure_arrow_widget):
+        (ensure_toolbar_separator_widget):
+        (ensure_statusbar_widget):
+        (ensure_frame_widget):
+        (ensure_menu_separator_widget):
+        (ensure_tree_view_widget):
+        (ensure_tree_header_cell_widget):
+        (ensure_expander_widget):
+        (ConvertGtkState):
+        (moz_gtk_button_paint):
+        (moz_gtk_widget_get_focus):
+        (moz_gtk_splitter_get_metrics):
+        (moz_gtk_toggle_paint):
+        (moz_gtk_scrollbar_button_paint):
+        (moz_gtk_scrollbar_trough_paint):
+        (moz_gtk_scrollbar_thumb_paint):
+        (moz_gtk_spin_paint):
+        (moz_gtk_spin_updown_paint):
+        (moz_gtk_scale_paint):
+        (moz_gtk_scale_thumb_paint):
+        (moz_gtk_gripper_paint):
+        (moz_gtk_hpaned_paint):
+        (moz_gtk_vpaned_paint):
+        (moz_gtk_entry_paint):
+        (moz_gtk_treeview_paint):
+        (moz_gtk_tree_header_cell_paint):
+        (moz_gtk_tree_header_sort_arrow_paint):
+        (moz_gtk_treeview_expander_paint):
+        (moz_gtk_expander_paint):
+        (moz_gtk_option_menu_paint):
+        (moz_gtk_downarrow_paint):
+        (moz_gtk_dropdown_arrow_paint):
+        (moz_gtk_container_paint):
+        (moz_gtk_toggle_label_paint):
+        (moz_gtk_toolbar_paint):
+        (moz_gtk_toolbar_separator_paint):
+        (moz_gtk_tooltip_paint):
+        (moz_gtk_resizer_paint):
+        (moz_gtk_frame_paint):
+        (moz_gtk_progressbar_paint):
+        (moz_gtk_progress_chunk_paint):
+        (moz_gtk_get_tab_thickness):
+        (moz_gtk_tab_paint):
+        (moz_gtk_tabpanels_paint):
+        (moz_gtk_menu_bar_paint):
+        (moz_gtk_menu_popup_paint):
+        (moz_gtk_menu_separator_paint):
+        (moz_gtk_menu_item_paint):
+        (moz_gtk_menu_arrow_paint):
+        (moz_gtk_check_menu_item_paint):
+        (moz_gtk_window_paint):
+        (moz_gtk_get_widget_border):
+        (moz_gtk_get_dropdown_arrow_size):
+        (moz_gtk_get_toolbar_separator_width):
+        (moz_gtk_get_expander_size):
+        (moz_gtk_get_treeview_expander_size):
+        (moz_gtk_get_menu_separator_height):
+        (moz_gtk_widget_paint):
+        (moz_gtk_shutdown):
+        * platform/gtk/gtkdrawing.h:
+
 2008-01-27  Jan Michael Alonzo  <jmalonzo@unpluggable.com>
 

trunk/WebCore/platform/gtk/RenderThemeGtk.cpp

@@ -80 +80 @@
 }
 
+static GtkTextDirection gtkTextDirection(TextDirection direction)
+{
+    switch (direction) {
+    case RTL:
+        return GTK_TEXT_DIR_RTL;
+    case LTR:
+        return GTK_TEXT_DIR_LTR;
+    default:
+        return GTK_TEXT_DIR_NONE;
+    }
+}
+
 static void adjustMozStyle(RenderStyle* style, GtkThemeWidgetType type)
 {
     gint left, top, right, bottom;
+    GtkTextDirection direction = gtkTextDirection(style->direction());
     gboolean inhtml = true;
 
-    if (moz_gtk_get_widget_border(type, &left, &top, &right, &bottom, inhtml) != MOZ_GTK_SUCCESS)
+    if (moz_gtk_get_widget_border(type, &left, &top, &right, &bottom, direction, inhtml) != MOZ_GTK_SUCCESS)
         return;
 
@@ -107 +120 @@
     state->isDefault = false;
     state->canDefault = false;
+    state->depressed = false;
 }
 
@@ -140 +154 @@
     IntPoint pos = i.context->translatePoint(rect.location());
     GdkRectangle gdkRect = IntRect(pos.x(), pos.y(), rect.width(), rect.height());
+    GtkTextDirection direction = gtkTextDirection(o->style()->direction());
 
     // FIXME: Pass the real clip region.
-    return moz_gtk_widget_paint(type, i.context->gdkDrawable(), &gdkRect, &gdkRect, &mozState, flags) != MOZ_GTK_SUCCESS;
+    return moz_gtk_widget_paint(type, i.context->gdkDrawable(), &gdkRect, &gdkRect, &mozState, flags, direction) != MOZ_GTK_SUCCESS;
 }
 

trunk/WebCore/platform/gtk/gtk2drawing.c

@@ -57 +57 @@
 static GtkWidget* gProtoWindow;
 static GtkWidget* gButtonWidget;
+static GtkWidget* gToggleButtonWidget;
 static GtkWidget* gCheckboxWidget;
 static GtkWidget* gRadiobuttonWidget;
@@ -67 +68 @@
 static GtkWidget* gArrowWidget;
 static GtkWidget* gOptionMenuWidget;
+static GtkWidget* gComboBoxEntryWidget;
+static GtkWidget* gDropdownEntryWidget;
 static GtkWidget* gDropdownButtonWidget;
 static GtkWidget* gHandleBoxWidget;
 static GtkWidget* gToolbarWidget;
 static GtkWidget* gFrameWidget;
+static GtkWidget* gStatusbarWidget;
 static GtkWidget* gProgressWidget;
 static GtkWidget* gTabWidget;
@@ -79 +83 @@
 static GtkWidget* gMenuItemWidget;
 static GtkWidget* gCheckMenuItemWidget;
+static GtkWidget* gTreeViewWidget;
+static GtkWidget* gTreeHeaderCellWidget;
+static GtkWidget* gTreeHeaderSortArrowWidget;
+static GtkWidget* gExpanderWidget;
+static GtkWidget* gToolbarSeparatorWidget;
+static GtkWidget* gMenuSeparatorWidget;
+static GtkWidget* gHPanedWidget;
+static GtkWidget* gVPanedWidget;
 
 static GtkShadowType gMenuBarShadowType;
@@ -110 +122 @@
     ensure_window_widget();
     if (!protoLayout) {
-        protoLayout = gtk_hbox_new(FALSE, 0);
+        protoLayout = gtk_fixed_new();
         gtk_container_add(GTK_CONTAINER(gProtoWindow), protoLayout);
     }
@@ -127 +139 @@
     }
     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_button_widget()
+{
+    if (!gToggleButtonWidget) {
+        gToggleButtonWidget = gtk_toggle_button_new();
+        setup_widget_prototype(gToggleButtonWidget);
+        /* toggle button must be set active to get the right style on hover. */
+        GTK_TOGGLE_BUTTON(gToggleButtonWidget)->active = TRUE;
+  }
+  return MOZ_GTK_SUCCESS;
 }
 
@@ -208 +252 @@
 
 static gint
+ensure_combo_box_entry_widget()
+{
+    if (!gComboBoxEntryWidget) {
+        gComboBoxEntryWidget = gtk_combo_box_entry_new();
+        setup_widget_prototype(gComboBoxEntryWidget);
+    }
+    return MOZ_GTK_SUCCESS;
+}
+
+static gint
+ensure_dropdown_entry_widget()
+{
+    if (!gDropdownEntryWidget) {
+        ensure_combo_box_entry_widget();
+
+        gDropdownEntryWidget = GTK_BIN(gComboBoxEntryWidget)->child;
+        gtk_widget_realize(gDropdownEntryWidget);
+    }
+    return MOZ_GTK_SUCCESS;
+}
+
+static void
+moz_gtk_get_dropdown_button(GtkWidget *widget,
+                            gpointer client_data)
+{
+    if (GTK_IS_TOGGLE_BUTTON(widget))
+        gDropdownButtonWidget = widget;
+}
+
+static gint
 ensure_arrow_widget()
 {
     if (!gArrowWidget) {
-        gDropdownButtonWidget = gtk_button_new();
-        setup_widget_prototype(gDropdownButtonWidget);
+        ensure_combo_box_entry_widget();
+
+        gtk_container_forall(GTK_CONTAINER(gComboBoxEntryWidget),
+                             moz_gtk_get_dropdown_button,
+                             NULL);
+
         gArrowWidget = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
-        gtk_container_add(GTK_CONTAINER(gDropdownButtonWidget), gArrowWidget);
+        gtk_container_add(GTK_CONTAINER(GTK_BIN(gDropdownButtonWidget)->child),
+                          gArrowWidget);
         gtk_widget_realize(gArrowWidget);
     }
@@ -245 +324 @@
 
 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()
 {
@@ -275 +365 @@
 
 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);
-        setup_widget_prototype(gFrameWidget);
+        gtk_container_add(GTK_CONTAINER(gStatusbarWidget), gFrameWidget);
+        gtk_widget_realize(gFrameWidget);
     }
     return MOZ_GTK_SUCCESS;
@@ -336 +438 @@
 
 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()
 {
@@ -348 +463 @@
 }
 
+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) {
+        GtkTreeViewColumn* treeViewColumn;
+        ensure_tree_view_widget();
+
+        treeViewColumn = gtk_tree_view_column_new();
+        gtk_tree_view_column_set_title(treeViewColumn, "M");
+
+        gtk_tree_view_append_column(GTK_TREE_VIEW(gTreeViewWidget), treeViewColumn);
+        gTreeHeaderCellWidget = treeViewColumn->button;
+        gtk_tree_view_column_set_sort_indicator(treeViewColumn, TRUE);
+        gTreeHeaderSortArrowWidget = treeViewColumn->arrow;
+    }
+    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 GtkStateType
 ConvertGtkState(GtkWidgetState* state)
@@ -353 +506 @@
     if (state->disabled)
         return GTK_STATE_INSENSITIVE;
+    else if (state->depressed)
+        return (state->inHover ? GTK_STATE_PRELIGHT : GTK_STATE_ACTIVE);
     else if (state->inHover)
         return (state->active ? GTK_STATE_ACTIVE : GTK_STATE_PRELIGHT);
@@ -387 +542 @@
 moz_gtk_button_paint(GdkDrawable* drawable, GdkRectangle* rect,
                      GdkRectangle* cliprect, GtkWidgetState* state,
-                     GtkReliefStyle relief, GtkWidget* widget)
+                     GtkReliefStyle relief, GtkWidget* widget,
+                     GtkTextDirection direction)
 {
     GtkShadowType shadow_type;
@@ -397 +553 @@
     gint focus_width, focus_pad;
 
-    moz_gtk_button_get_focus(&interior_focus, &focus_width, &focus_pad);
+    moz_gtk_widget_get_focus(widget, &interior_focus, &focus_width, &focus_pad);
 
     if (WINDOW_IS_MAPPED(drawable)) {
@@ -406 +562 @@
 
     gtk_widget_set_state(widget, button_state);
+    gtk_widget_set_direction(widget, direction);
 
     if (state->isDefault)
@@ -417 +574 @@
     }
 
-    shadow_type = button_state == GTK_STATE_ACTIVE ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
-
-    if (relief != GTK_RELIEF_NONE || (button_state != GTK_STATE_NORMAL &&
-                                      button_state != GTK_STATE_INSENSITIVE)) {
+    shadow_type = button_state == GTK_STATE_ACTIVE ||
+                      state->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
+ 
+    if (state->isDefault && GTK_BUTTON(widget)->relief == GTK_RELIEF_NORMAL) {
+        gtk_paint_box(style, drawable, button_state, shadow_type, cliprect,
+                      widget, "buttondefault", x, y, width, height);                   
+    }
+ 
+    if (relief != GTK_RELIEF_NONE || state->depressed ||
+           (button_state != GTK_STATE_NORMAL &&
+            button_state != GTK_STATE_INSENSITIVE)) {
         TSOffsetStyleGCs(style, x, y);
         /* the following line can trigger an assertion (Crux theme)
@@ -489 +653 @@
 
 gint
-moz_gtk_checkbox_get_focus(gboolean* interior_focus,
-                           gint* focus_width, gint* focus_pad)
-{
-    ensure_checkbox_widget();
-
-    gtk_widget_style_get (gCheckboxWidget,
-                          "interior-focus", interior_focus,
-                          "focus-line-width", focus_width,
-                          "focus-padding", focus_pad,
-                          NULL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_radio_get_focus(gboolean* interior_focus,
-                        gint* focus_width, gint* focus_pad)
-{
-    ensure_radiobutton_widget();
-
-    gtk_widget_style_get (gRadiobuttonWidget,
-                          "interior-focus", interior_focus,
-                          "focus-line-width", focus_width,
-                          "focus-padding", focus_pad,
-                          NULL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_button_get_focus(gboolean* interior_focus,
-                         gint* focus_width, gint* focus_pad)
-{
-    ensure_button_widget();
-
-    gtk_widget_style_get (gButtonWidget,
+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,
@@ -572 +704 @@
 }
 
+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;
+}
+
 static gint
 moz_gtk_toggle_paint(GdkDrawable* drawable, GdkRectangle* rect,
                      GdkRectangle* cliprect, GtkWidgetState* state,
-                     gboolean selected, gboolean isradio)
+                     gboolean selected, gboolean isradio,
+                     GtkTextDirection direction)
 {
     GtkStateType state_type = ConvertGtkState(state);
@@ -602 +748 @@
 
     gtk_widget_set_sensitive(w, !state->disabled);
+    gtk_widget_set_direction(w, direction);
     GTK_TOGGLE_BUTTON(w)->active = selected;
       
@@ -651 +798 @@
 moz_gtk_scrollbar_button_paint(GdkDrawable* drawable, GdkRectangle* rect,
                                GdkRectangle* cliprect, GtkWidgetState* state,
-                               GtkArrowType type)
+                               GtkScrollbarButtonFlags flags,
+                               GtkTextDirection direction)
 {
     GtkStateType state_type = ConvertGtkState(state);
@@ -659 +807 @@
     GdkRectangle arrow_rect;
     GtkStyle* style;
-    GtkAdjustment *adj;
-    GtkScrollbar *scrollbar;
+    GtkWidget *scrollbar;
+    GtkArrowType arrow_type;
+    const char* detail = (flags & MOZ_GTK_STEPPER_VERTICAL) ?
+                           "vscrollbar" : "hscrollbar";
 
     ensure_scrollbar_widget();
 
-    if (type < 2)
-        scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);
+    if (flags & MOZ_GTK_STEPPER_VERTICAL)
+        scrollbar = gVertScrollbarWidget;
     else
-        scrollbar = GTK_SCROLLBAR(gHorizScrollbarWidget);
+        scrollbar = gHorizScrollbarWidget;
+
+    gtk_widget_set_direction(scrollbar, direction);
 
     /* Some theme engines (i.e., ClearLooks) check the scrollbar's allocation
@@ -673 +825 @@
        We need to trick them into drawing the buttons the way we want them. */
 
-    GTK_WIDGET(scrollbar)->allocation.x = rect->x;
-    GTK_WIDGET(scrollbar)->allocation.y = rect->y;
-    GTK_WIDGET(scrollbar)->allocation.width = rect->width;
-    GTK_WIDGET(scrollbar)->allocation.height = rect->height;
-
-    if (type < 2) {
-        GTK_WIDGET(scrollbar)->allocation.height *= 3;
-        if (type == GTK_ARROW_DOWN)
-            GTK_WIDGET(scrollbar)->allocation.y -= 2 * rect->height;
+    scrollbar->allocation.x = rect->x;
+    scrollbar->allocation.y = rect->y;
+    scrollbar->allocation.width = rect->width;
+    scrollbar->allocation.height = rect->height;
+
+    if (flags & MOZ_GTK_STEPPER_VERTICAL) {
+        scrollbar->allocation.height *= 5;
+        if (flags & MOZ_GTK_STEPPER_DOWN) {
+            arrow_type = GTK_ARROW_DOWN;
+            if (flags & MOZ_GTK_STEPPER_BOTTOM)
+                scrollbar->allocation.y -= 4 * rect->height;
+            else
+                scrollbar->allocation.y -= rect->height;
+
+        } else {
+            arrow_type = GTK_ARROW_UP;
+            if (flags & MOZ_GTK_STEPPER_BOTTOM)
+                scrollbar->allocation.y -= 3 * rect->height;
+        }
     } else {
-        GTK_WIDGET(scrollbar)->allocation.width *= 3;
-        if (type == GTK_ARROW_RIGHT)
-            GTK_WIDGET(scrollbar)->allocation.x -= 2 * rect->width;
-    }
-
-    style = GTK_WIDGET(scrollbar)->style;
+        scrollbar->allocation.width *= 5;
+        if (flags & MOZ_GTK_STEPPER_DOWN) {
+            arrow_type = GTK_ARROW_RIGHT;
+            if (flags & MOZ_GTK_STEPPER_BOTTOM)
+                scrollbar->allocation.x -= 4 * rect->width;
+            else
+                scrollbar->allocation.x -= rect->width;
+        } else {
+            arrow_type = GTK_ARROW_LEFT;
+            if (flags & MOZ_GTK_STEPPER_BOTTOM)
+                scrollbar->allocation.x -= 3 * rect->width;
+        }
+    }
+
+    style = scrollbar->style;
 
     ensure_arrow_widget();
@@ -696 +867 @@
 
     gtk_paint_box(style, drawable, state_type, shadow_type, cliprect,
-                  GTK_WIDGET(scrollbar),
-                  (type < 2) ? "vscrollbar" : "hscrollbar",
-                  button_rect.x, button_rect.y, button_rect.width,
-                  button_rect.height);
+                  scrollbar, detail, button_rect.x, button_rect.y,
+                  button_rect.width, button_rect.height);
 
     arrow_rect.width = button_rect.width / 2;
@@ -708 +877 @@
 
     gtk_paint_arrow(style, drawable, state_type, shadow_type, cliprect,
-                    GTK_WIDGET(scrollbar), (type < 2) ?
-                    "vscrollbar" : "hscrollbar", 
-                    type, TRUE, arrow_rect.x, arrow_rect.y, arrow_rect.width,
-                    arrow_rect.height);
+                    scrollbar, detail, arrow_type, TRUE, arrow_rect.x,
+                    arrow_rect.y, arrow_rect.width, arrow_rect.height);
 
     return MOZ_GTK_SUCCESS;
@@ -719 +886 @@
 moz_gtk_scrollbar_trough_paint(GtkThemeWidgetType widget,
                                GdkDrawable* drawable, GdkRectangle* rect,
-                               GdkRectangle* cliprect, GtkWidgetState* state)
+                               GdkRectangle* cliprect, GtkWidgetState* state,
+                               GtkTextDirection direction)
 {
     GtkStyle* style;
@@ -731 +899 @@
         scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);
 
+    gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);
+
     style = GTK_WIDGET(scrollbar)->style;
 
@@ -754 +924 @@
 moz_gtk_scrollbar_thumb_paint(GtkThemeWidgetType widget,
                               GdkDrawable* drawable, GdkRectangle* rect,
-                              GdkRectangle* cliprect, GtkWidgetState* state)
+                              GdkRectangle* cliprect, GtkWidgetState* state,
+                              GtkTextDirection direction)
 {
     GtkStateType state_type = (state->inHover || state->active) ?
@@ -768 +939 @@
     else
         scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);
+
+    gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);
 
     /* Make sure to set the scrollbar range before painting so that
@@ -812 +985 @@
 
 static gint
-moz_gtk_spin_paint(GdkDrawable* drawable, GdkRectangle* rect, gboolean isDown,
-                   GtkWidgetState* state)
+moz_gtk_spin_paint(GdkDrawable* drawable, GdkRectangle* rect,
+                   GtkTextDirection direction)
+{
+    GtkStyle* style;
+
+    ensure_spin_widget();
+    gtk_widget_set_direction(gSpinWidget, direction);
+    style = gSpinWidget->style;
+
+    TSOffsetStyleGCs(style, rect->x, rect->y);
+    gtk_paint_box(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_IN, NULL,
+                  gSpinWidget, "spinbutton",
+                  rect->x, rect->y, rect->width, rect->height);
+    return MOZ_GTK_SUCCESS;
+}
+
+static gint
+moz_gtk_spin_updown_paint(GdkDrawable* drawable, GdkRectangle* rect,
+                          gboolean isDown, GtkWidgetState* state,
+                          GtkTextDirection direction)
 {
     GdkRectangle arrow_rect;
     GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = state_type == GTK_STATE_ACTIVE ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
+    GtkShadowType shadow_type = state_type == GTK_STATE_ACTIVE ?
+                                  GTK_SHADOW_IN : GTK_SHADOW_OUT;
     GtkStyle* style;
 
     ensure_spin_widget();
     style = gSpinWidget->style;