Changeset 29824 for trunk/WebCore/platform/gtk/gtk2drawing.c

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.

Files:

• trunk/WebCore/platform/gtk/gtk2drawing.c (modified) (80 diffs)

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;
+    gtk_widget_set_direction(gSpinWidget, direction);
 
     TSOffsetStyleGCs(style, rect->x, rect->y);
@@ -847 +1040 @@
 moz_gtk_scale_paint(GdkDrawable* drawable, GdkRectangle* rect,
                     GdkRectangle* cliprect, GtkWidgetState* state,
-                    GtkOrientation flags)
+                    GtkOrientation flags, GtkTextDirection direction)
 {
   gint x = 0, y = 0;
@@ -856 +1049 @@
   ensure_scale_widget();
   widget = ((flags == GTK_ORIENTATION_HORIZONTAL) ? gHScaleWidget : gVScaleWidget);
+  gtk_widget_set_direction(widget, direction);
+
   style = widget->style;
 
@@ -886 +1081 @@
 moz_gtk_scale_thumb_paint(GdkDrawable* drawable, GdkRectangle* rect,
                           GdkRectangle* cliprect, GtkWidgetState* state,
-                          GtkOrientation flags)
+                          GtkOrientation flags, GtkTextDirection direction)
 {
   GtkStateType state_type = ConvertGtkState(state);
@@ -895 +1090 @@
   ensure_scale_widget();
   widget = ((flags == GTK_ORIENTATION_HORIZONTAL) ? gHScaleWidget : gVScaleWidget);
+  gtk_widget_set_direction(widget, direction);
+
   style = widget->style;
 
@@ -919 +1116 @@
 static gint
 moz_gtk_gripper_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                      GdkRectangle* cliprect, GtkWidgetState* state)
+                      GdkRectangle* cliprect, GtkWidgetState* state,
+                      GtkTextDirection direction)
 {
     GtkStateType state_type = ConvertGtkState(state);
@@ -926 +1124 @@
 
     ensure_handlebox_widget();
+    gtk_widget_set_direction(gHandleBoxWidget, direction);
+
     style = gHandleBoxWidget->style;
     shadow_type = GTK_HANDLE_BOX(gHandleBoxWidget)->shadow_type;
@@ -938 +1138 @@
 
 static gint
+moz_gtk_hpaned_paint(GdkDrawable* drawable, GdkRectangle* rect,
+                     GdkRectangle* cliprect, GtkWidgetState* state)
+{
+    GtkStateType hpaned_state = ConvertGtkState(state);
+
+    ensure_hpaned_widget();
+    gtk_paint_handle(gHPanedWidget->style, drawable, hpaned_state,
+                     GTK_SHADOW_NONE, cliprect, gHPanedWidget, "paned",
+                     rect->x, rect->y, rect->width, rect->height,
+                     GTK_ORIENTATION_VERTICAL);
+
+    return MOZ_GTK_SUCCESS;
+}
+
+static gint
+moz_gtk_vpaned_paint(GdkDrawable* drawable, GdkRectangle* rect,
+                     GdkRectangle* cliprect, GtkWidgetState* state)
+{
+    GtkStateType vpaned_state = ConvertGtkState(state);
+
+    ensure_vpaned_widget();
+    gtk_paint_handle(gVPanedWidget->style, drawable, vpaned_state,
+                     GTK_SHADOW_NONE, cliprect, gVPanedWidget, "paned",
+                     rect->x, rect->y, rect->width, rect->height,
+                     GTK_ORIENTATION_HORIZONTAL);
+
+    return MOZ_GTK_SUCCESS;
+}
+
+static gint
 moz_gtk_entry_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                    GdkRectangle* cliprect, GtkWidgetState* state)
+                    GdkRectangle* cliprect, GtkWidgetState* state,
+                    GtkWidget* widget, GtkTextDirection direction)
 {
     gint x, y, width = rect->width, height = rect->height;
@@ -946 +1177 @@
     gint focus_width;
 
-    ensure_entry_widget();
-    style = gEntryWidget->style;
+    gtk_widget_set_direction(widget, direction);
+
+    style = widget->style;
 
     /* paint the background first */
@@ -954 +1186 @@
 
     /* This gets us a lovely greyish disabledish look */
-    gtk_widget_set_sensitive(gEntryWidget, !state->disabled);
+    gtk_widget_set_sensitive(widget, !state->disabled);
 
     TSOffsetStyleGCs(style, rect->x + x, rect->y + y);
     gtk_paint_flat_box(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_NONE,
-                       cliprect, gEntryWidget, "entry_bg",  rect->x + x,
+                       cliprect, widget, "entry_bg",  rect->x + x,
                        rect->y + y, rect->width - 2*x, rect->height - 2*y);
 
-    gtk_widget_style_get(gEntryWidget,
+    gtk_widget_style_get(widget,
                          "interior-focus", &interior_focus,
                          "focus-line-width", &focus_width,
@@ -982 +1214 @@
     if (state->focused && !state->disabled) {
          /* This will get us the lit borders that focused textboxes enjoy on some themes. */
-        GTK_WIDGET_SET_FLAGS(gEntryWidget, GTK_HAS_FOCUS);
+        GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
 
         if (!interior_focus) {