# HG changeset patch
# User Tomasz Mon <desowin@gmail.com>
# Date 1183720756 -7200
# Node ID a2eb970ca66952123c966f69eb894d19fd31c5e5
# Parent  934c1a79904fa7cb10a586732dd4b6e4107ce2eb
bring back UiSkinnedTextboxPrivate

diff -r 934c1a79904f -r a2eb970ca669 src/audacious/ui_skinned_button.c
--- a/src/audacious/ui_skinned_button.c	Fri Jul 06 12:52:13 2007 +0200
+++ b/src/audacious/ui_skinned_button.c	Fri Jul 06 13:19:16 2007 +0200
@@ -101,11 +101,11 @@
 }
 
 static void ui_skinned_button_class_init (UiSkinnedButtonClass *klass) {
-GObjectClass *gobject_class;
-gobject_class = G_OBJECT_CLASS(klass);
+    GObjectClass *gobject_class;
     GtkObjectClass *object_class;
     GtkWidgetClass *widget_class;
 
+    gobject_class = G_OBJECT_CLASS(klass);
     object_class = (GtkObjectClass*) klass;
     widget_class = (GtkWidgetClass*) klass;
     parent_class = gtk_type_class (gtk_widget_get_type ());
diff -r 934c1a79904f -r a2eb970ca669 src/audacious/ui_skinned_textbox.c
--- a/src/audacious/ui_skinned_textbox.c	Fri Jul 06 12:52:13 2007 +0200
+++ b/src/audacious/ui_skinned_textbox.c	Fri Jul 06 13:19:16 2007 +0200
@@ -33,6 +33,10 @@
 #include <gtk/gtkmarshal.h>
 #include <gtk/gtkimage.h>
 
+#define UI_TYPE_SKINNED_TEXTBOX           (ui_skinned_textbox_get_type())
+#define UI_SKINNED_TEXTBOX_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), UI_TYPE_SKINNED_TEXTBOX, UiSkinnedTextboxPrivate))
+typedef struct _UiSkinnedTextboxPrivate UiSkinnedTextboxPrivate;
+
 static GMutex *mutex = NULL;
 
 #define TEXTBOX_SCROLL_SMOOTH_TIMEOUT  30
@@ -47,6 +51,31 @@
     LAST_SIGNAL
 };
 
+struct _UiSkinnedTextboxPrivate {
+    gboolean         redraw;
+    GdkPixmap        *img;
+    GdkGC            *gc;
+    SkinPixmapId     skin_index;
+    GtkWidget        *fixed;
+    gboolean         double_size;
+    gboolean         scroll_back;
+    gint             nominal_y, nominal_height;
+    gint             scroll_timeout;
+    gint             font_ascent, font_descent;
+    PangoFontDescription *font;
+    gchar            *fontname;
+    gchar            *pixmap_text;
+    gint             skin_id;
+    gint             drag_x, drag_off, offset;
+    gboolean         is_scrollable, is_dragging;
+    gint             pixmap_width;
+    GdkPixmap        *pixmap;
+    gboolean         scroll_allowed, scroll_enabled;
+    gint             scroll_dummy;
+    gint             resize_width, resize_height;
+    gint             move_x, move_y;
+};
+
 static void ui_skinned_textbox_class_init         (UiSkinnedTextboxClass *klass);
 static void ui_skinned_textbox_init               (UiSkinnedTextbox *textbox);
 static void ui_skinned_textbox_destroy            (GtkObject *object);
@@ -89,9 +118,11 @@
 }
 
 static void ui_skinned_textbox_class_init(UiSkinnedTextboxClass *klass) {
+    GObjectClass *gobject_class;
     GtkObjectClass *object_class;
     GtkWidgetClass *widget_class;
 
+    gobject_class = G_OBJECT_CLASS(klass);
     object_class = (GtkObjectClass*) klass;
     widget_class = (GtkWidgetClass*) klass;
     parent_class = gtk_type_class (gtk_widget_get_type ());
@@ -136,38 +167,42 @@
         g_signal_new ("redraw", G_OBJECT_CLASS_TYPE (object_class), G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
                       G_STRUCT_OFFSET (UiSkinnedTextboxClass, redraw), NULL, NULL,
                       gtk_marshal_VOID__VOID, G_TYPE_NONE, 0);
+
+    g_type_class_add_private (gobject_class, sizeof (UiSkinnedTextboxPrivate));
 }
 
 static void ui_skinned_textbox_init(UiSkinnedTextbox *textbox) {
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
     mutex = g_mutex_new();
-    textbox->resize_width = 0;
-    textbox->resize_height = 0;
-    textbox->move_x = 0;
-    textbox->move_y = 0;
-    textbox->img = NULL;
+    priv->resize_width = 0;
+    priv->resize_height = 0;
+    priv->move_x = 0;
+    priv->move_y = 0;
+    priv->img = NULL;
 }
 
 GtkWidget* ui_skinned_textbox_new(GtkWidget *fixed, GdkPixmap * parent, GdkGC * gc, gint x, gint y, gint w, gboolean allow_scroll, SkinPixmapId si) {
     UiSkinnedTextbox *textbox = g_object_new (ui_skinned_textbox_get_type (), NULL);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
 
     textbox->height = bmp_active_skin->properties.textbox_bitmap_font_height;
     textbox->x = x;
     textbox->y = y;
     textbox->text = g_strdup("");
-    textbox->gc = gc;
+    priv->gc = gc;
     textbox->width = w;
-    textbox->scroll_allowed = allow_scroll;
-    textbox->scroll_enabled = TRUE;
-    textbox->skin_index = si;
-    textbox->nominal_y = y;
-    textbox->nominal_height = textbox->height;
-    textbox->scroll_timeout = 0;
-    textbox->scroll_dummy = 0;
+    priv->scroll_allowed = allow_scroll;
+    priv->scroll_enabled = TRUE;
+    priv->skin_index = si;
+    priv->nominal_y = y;
+    priv->nominal_height = textbox->height;
+    priv->scroll_timeout = 0;
+    priv->scroll_dummy = 0;
 
-    textbox->fixed = fixed;
-    textbox->double_size = FALSE;
+    priv->fixed = fixed;
+    priv->double_size = FALSE;
 
-    gtk_fixed_put(GTK_FIXED(textbox->fixed), GTK_WIDGET(textbox), textbox->x, textbox->y);
+    gtk_fixed_put(GTK_FIXED(priv->fixed), GTK_WIDGET(textbox), textbox->x, textbox->y);
 
     return GTK_WIDGET(textbox);
 }
@@ -218,29 +253,33 @@
 
 static void ui_skinned_textbox_size_request(GtkWidget *widget, GtkRequisition *requisition) {
     UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX(widget);
-    requisition->width = UI_SKINNED_TEXTBOX(widget)->width*(1+textbox->double_size);
-    requisition->height = UI_SKINNED_TEXTBOX(widget)->height*(1+textbox->double_size);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
+
+    requisition->width = textbox->width*(1+priv->double_size);
+    requisition->height = textbox->height*(1+priv->double_size);
 }
 
 static void ui_skinned_textbox_size_allocate(GtkWidget *widget, GtkAllocation *allocation) {
     g_mutex_lock(mutex);
     UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX (widget);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
+
     widget->allocation = *allocation;
     if (GTK_WIDGET_REALIZED (widget))
         gdk_window_move_resize(widget->window, allocation->x, allocation->y, allocation->width, allocation->height);
 
-    textbox->x = widget->allocation.x/(textbox->double_size ? 2 : 1);
-    textbox->y = widget->allocation.y/(textbox->double_size ? 2 : 1);
-    textbox->move_x = 0;
-    textbox->move_y = 0;
+    textbox->x = widget->allocation.x/(priv->double_size ? 2 : 1);
+    textbox->y = widget->allocation.y/(priv->double_size ? 2 : 1);
+    priv->move_x = 0;
+    priv->move_y = 0;
 
-    if (textbox->width != widget->allocation.width/(textbox->double_size ? 2 : 1)) {
-        textbox->width = widget->allocation.width/(textbox->double_size ? 2 : 1);
-        textbox->resize_width = 0;
-        textbox->resize_height = 0;
-        if (textbox->pixmap_text) g_free(textbox->pixmap_text);
-        textbox->pixmap_text = NULL;
-        textbox->offset = 0;
+    if (textbox->width != widget->allocation.width/(priv->double_size ? 2 : 1)) {
+        textbox->width = widget->allocation.width/(priv->double_size ? 2 : 1);
+        priv->resize_width = 0;
+        priv->resize_height = 0;
+        if (priv->pixmap_text) g_free(priv->pixmap_text);
+        priv->pixmap_text = NULL;
+        priv->offset = 0;
         gtk_widget_queue_draw(GTK_WIDGET(textbox));
     }
     g_mutex_unlock(mutex);
@@ -252,73 +291,75 @@
     g_return_val_if_fail (event != NULL, FALSE);
 
     UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX (widget);
-    if(textbox->redraw) {
-        textbox->redraw = FALSE;
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
+
+    if(priv->redraw) {
+        priv->redraw = FALSE;
         GdkPixmap *obj = NULL;
         gint cw;
 
-        if (textbox->text && (!textbox->pixmap_text || strcmp(textbox->text, textbox->pixmap_text)))
+        if (textbox->text && (!priv->pixmap_text || strcmp(textbox->text, priv->pixmap_text)))
             textbox_generate_pixmap(textbox);
 
-        if (textbox->pixmap) {
-            if (skin_get_id() != textbox->skin_id) {
-                textbox->skin_id = skin_get_id();
+        if (priv->pixmap) {
+            if (skin_get_id() != priv->skin_id) {
+                priv->skin_id = skin_get_id();
                 textbox_generate_pixmap(textbox);
             }
             obj = gdk_pixmap_new(NULL, textbox->width, textbox->height, gdk_rgb_get_visual()->depth);
 
             if(cfg.twoway_scroll) { // twoway scroll
-                cw = textbox->pixmap_width - textbox->offset;
+                cw = priv->pixmap_width - priv->offset;
                 if (cw > textbox->width)
                     cw = textbox->width;
-                gdk_draw_drawable(obj, textbox->gc, textbox->pixmap, textbox->offset, 0, 0, 0, cw, textbox->height);
+                gdk_draw_drawable(obj, priv->gc, priv->pixmap, priv->offset, 0, 0, 0, cw, textbox->height);
                 if (cw < textbox->width)
-                    gdk_draw_drawable(obj, textbox->gc, textbox->pixmap, 0, 0,
+                    gdk_draw_drawable(obj, priv->gc, priv->pixmap, 0, 0,
                                       textbox->x + cw, textbox->y,
                                       textbox->width - cw, textbox->height);
             }
             else { // oneway scroll
                 int cw1, cw2;
 
-                if(textbox->offset >= textbox->pixmap_width)
-                    textbox->offset = 0;
+                if(priv->offset >= priv->pixmap_width)
+                    priv->offset = 0;
 
-                if(textbox->pixmap_width - textbox->offset > textbox->width){ // case1
+                if(priv->pixmap_width - priv->offset > textbox->width){ // case1
                     cw1 = textbox->width;
-                    gdk_draw_drawable(obj, textbox->gc, textbox->pixmap, textbox->offset, 0,
+                    gdk_draw_drawable(obj, priv->gc, priv->pixmap, priv->offset, 0,
                                       0, 0, cw1, textbox->height);
                 }
                 else { // case 2
-                    cw1 = textbox->pixmap_width - textbox->offset;
-                    gdk_draw_drawable(obj, textbox->gc, textbox->pixmap, textbox->offset, 0,
+                    cw1 = priv->pixmap_width - priv->offset;
+                    gdk_draw_drawable(obj, priv->gc, priv->pixmap, priv->offset, 0,
                                       0, 0, cw1, textbox->height);
                     cw2 = textbox->width - cw1;
-                    gdk_draw_drawable(obj, textbox->gc, textbox->pixmap, 0, 0, cw1, 0, cw2, textbox->height);
+                    gdk_draw_drawable(obj, priv->gc, priv->pixmap, 0, 0, cw1, 0, cw2, textbox->height);
                 }
 
             }
-        if (textbox->img)
-                g_object_unref(textbox->img);
-        textbox->img = gdk_pixmap_new(NULL, textbox->width*(1+textbox->double_size),
-                                            textbox->height*(1+textbox->double_size),
+        if (priv->img)
+                g_object_unref(priv->img);
+        priv->img = gdk_pixmap_new(NULL, textbox->width*(1+priv->double_size),
+                                            textbox->height*(1+priv->double_size),
                                             gdk_rgb_get_visual()->depth);
 
-        if (textbox->double_size) {
+        if (priv->double_size) {
             GdkImage *img, *img2x;
             img = gdk_drawable_get_image(obj, 0, 0, textbox->width, textbox->height);
             img2x = create_dblsize_image(img);
-            gdk_draw_image (textbox->img, textbox->gc, img2x, 0, 0, 0, 0, textbox->width*2, textbox->height*2);
+            gdk_draw_image (priv->img, priv->gc, img2x, 0, 0, 0, 0, textbox->width*2, textbox->height*2);
             g_object_unref(img2x);
             g_object_unref(img);
         } else
-            gdk_draw_drawable (textbox->img, textbox->gc, obj, 0, 0, 0, 0, textbox->width, textbox->height);
+            gdk_draw_drawable (priv->img, priv->gc, obj, 0, 0, 0, 0, textbox->width, textbox->height);
             g_object_unref(obj);
             gtk_widget_queue_resize(widget);
         }
     }
 
-    gdk_draw_drawable (widget->window, textbox->gc, textbox->img, 0, 0, 0, 0,
-                       textbox->width*(1+textbox->double_size), textbox->height*(1+textbox->double_size));
+    gdk_draw_drawable (widget->window, priv->gc, priv->img, 0, 0, 0, 0,
+                       textbox->width*(1+priv->double_size), textbox->height*(1+priv->double_size));
   return FALSE;
 }
 
@@ -328,14 +369,16 @@
     g_return_val_if_fail (event != NULL, FALSE);
 
     UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX (widget);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
+
     if (event->type == GDK_BUTTON_PRESS) {
         textbox = UI_SKINNED_TEXTBOX(widget);
         if (event->button == 1) {
-            if (textbox->scroll_allowed) {
-                if ((textbox->pixmap_width > textbox->width) && textbox->is_scrollable) {
-                    textbox->is_dragging = TRUE;
-                    textbox->drag_off = textbox->offset;
-                    textbox->drag_x = event->x;
+            if (priv->scroll_allowed) {
+                if ((priv->pixmap_width > textbox->width) && priv->is_scrollable) {
+                    priv->is_dragging = TRUE;
+                    priv->drag_off = priv->offset;
+                    priv->drag_x = event->x;
                 }
             } else
                 g_signal_emit(widget, textbox_signals[CLICKED], 0);
@@ -353,11 +396,10 @@
 }
 
 static gboolean ui_skinned_textbox_button_release(GtkWidget *widget, GdkEventButton *event) {
-    UiSkinnedTextbox *textbox;
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(widget);
 
-    textbox = UI_SKINNED_TEXTBOX (widget);
     if (event->button == 1) {
-        textbox->is_dragging = FALSE;
+        priv->is_dragging = FALSE;
     }
 
     return FALSE;
@@ -367,20 +409,21 @@
     g_return_val_if_fail (widget != NULL, FALSE);
     g_return_val_if_fail (UI_SKINNED_IS_TEXTBOX (widget), FALSE);
     g_return_val_if_fail (event != NULL, FALSE);
+    UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX(widget);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(widget);
 
-    UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX (widget);
-    if (textbox->is_dragging) {
-        if (textbox->scroll_allowed &&
-            textbox->pixmap_width > textbox->width) {
-            textbox->offset = textbox->drag_off - (event->x - textbox->drag_x);
+    if (priv->is_dragging) {
+        if (priv->scroll_allowed &&
+            priv->pixmap_width > textbox->width) {
+            priv->offset = priv->drag_off - (event->x - priv->drag_x);
 
-            while (textbox->offset < 0)
-                textbox->offset = 0;
+            while (priv->offset < 0)
+                priv->offset = 0;
 
-            while (textbox->offset > (textbox->pixmap_width - textbox->width))
-                textbox->offset = (textbox->pixmap_width - textbox->width);
+            while (priv->offset > (priv->pixmap_width - textbox->width))
+                priv->offset = (priv->pixmap_width - textbox->width);
 
-            textbox->redraw = TRUE;
+            priv->redraw = TRUE;
             gtk_widget_queue_draw(widget);
         }
     }
@@ -390,36 +433,42 @@
 
 static void ui_skinned_textbox_toggle_doublesize(UiSkinnedTextbox *textbox) {
     GtkWidget *widget = GTK_WIDGET (textbox);
-    textbox->double_size = !textbox->double_size;
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
+
+    priv->double_size = !priv->double_size;
 
-    gtk_widget_set_size_request(widget, textbox->width*(1+textbox->double_size), textbox->height*(1+textbox->double_size));
-    gtk_widget_set_uposition(widget, textbox->x*(1+textbox->double_size), textbox->y*(1+textbox->double_size));
+    gtk_widget_set_size_request(widget, textbox->width*(1+priv->double_size), textbox->height*(1+priv->double_size));
+    gtk_widget_set_uposition(widget, textbox->x*(1+priv->double_size), textbox->y*(1+priv->double_size));
 
-    textbox->redraw = TRUE;
+    priv->redraw = TRUE;
     gtk_widget_queue_draw(GTK_WIDGET(textbox));
 }
 
 static void ui_skinned_textbox_redraw(UiSkinnedTextbox *textbox) {
     g_mutex_lock(mutex);
-    if (textbox->resize_width || textbox->resize_height)
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
+
+    if (priv->resize_width || priv->resize_height)
         gtk_widget_set_size_request(GTK_WIDGET(textbox),
-                                   (textbox->width+textbox->resize_width)*(1+textbox->double_size),
-                                   (textbox->height+textbox->resize_height)*(1+textbox->double_size));
-    if (textbox->move_x || textbox->move_y)
-        gtk_fixed_move(GTK_FIXED(textbox->fixed), GTK_WIDGET(textbox), textbox->x+textbox->move_x, textbox->y+textbox->move_y);
+                                   (textbox->width+priv->resize_width)*(1+priv->double_size),
+                                   (textbox->height+priv->resize_height)*(1+priv->double_size));
+    if (priv->move_x || priv->move_y)
+        gtk_fixed_move(GTK_FIXED(priv->fixed), GTK_WIDGET(textbox), textbox->x+priv->move_x, textbox->y+priv->move_y);
 
-    textbox->redraw = TRUE;
+    priv->redraw = TRUE;
     gtk_widget_queue_draw(GTK_WIDGET(textbox));
     g_mutex_unlock(mutex);
 }
 
 static gboolean ui_skinned_textbox_should_scroll(UiSkinnedTextbox *textbox) {
-    if (!textbox->scroll_allowed)
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
+
+    if (!priv->scroll_allowed)
         return FALSE;
 
-    if (textbox->font) {
+    if (priv->font) {
         gint width;
-        text_get_extents(textbox->fontname, textbox->text, &width, NULL, NULL, NULL);
+        text_get_extents(priv->fontname, textbox->text, &width, NULL, NULL, NULL);
 
         if (width <= textbox->width)
             return FALSE;
@@ -435,59 +484,62 @@
 
 void ui_skinned_textbox_set_xfont(GtkWidget *widget, gboolean use_xfont, const gchar * fontname) {
     UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX (widget);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
+
     gint ascent, descent;
 
     g_return_if_fail(textbox != NULL);
 
-    if (textbox->font) {
-        pango_font_description_free(textbox->font);
-        textbox->font = NULL;
+    if (priv->font) {
+        pango_font_description_free(priv->font);
+        priv->font = NULL;
     }
 
-    textbox->y = textbox->nominal_y;
-    textbox->height = textbox->nominal_height;
+    textbox->y = priv->nominal_y;
+    textbox->height = priv->nominal_height;
 
     /* Make sure the pixmap is regenerated */
-    if (textbox->pixmap_text) {
-        g_free(textbox->pixmap_text);
-        textbox->pixmap_text = NULL;
+    if (priv->pixmap_text) {
+        g_free(priv->pixmap_text);
+        priv->pixmap_text = NULL;
     }
 
     if (!use_xfont || strlen(fontname) == 0)
         return;
 
-    textbox->font = pango_font_description_from_string(fontname);
-    textbox->fontname = g_strdup(fontname);
+    priv->font = pango_font_description_from_string(fontname);
+    priv->fontname = g_strdup(fontname);
 
     text_get_extents(fontname,
                      "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz ",
                      NULL, NULL, &ascent, &descent);
-    textbox->font_ascent = ascent;
-    textbox->font_descent = descent;
+    priv->font_ascent = ascent;
+    priv->font_descent = descent;
 
 
-    if (textbox->font == NULL)
+    if (priv->font == NULL)
         return;
 
-    textbox->height = textbox->font_ascent;
-    if (textbox->height > textbox->nominal_height)
-        textbox->y -= (textbox->height - textbox->nominal_height) / 2;
+    textbox->height = priv->font_ascent;
+    if (textbox->height > priv->nominal_height)
+        textbox->y -= (textbox->height - priv->nominal_height) / 2;
     else
-        textbox->height = textbox->nominal_height;
+        textbox->height = priv->nominal_height;
 }
 
 void ui_skinned_textbox_set_text(GtkWidget *widget, const gchar *text) {
     g_return_if_fail(text != NULL);
     UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX (widget);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
 
     if (!strcmp(textbox->text, text))
          return;
     if (textbox->text)
         g_free(textbox->text);
 
-    textbox->redraw = TRUE;
+    priv->redraw = TRUE;
     textbox->text = str_to_utf8(text);
-    textbox->scroll_back = FALSE;
+    priv->scroll_back = FALSE;
     gtk_widget_queue_draw(GTK_WIDGET(textbox));
 }
 
@@ -502,36 +554,38 @@
     g_return_if_fail(textbox != NULL);
     g_return_if_fail(pixmaptext != NULL);
 
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
+
     length = g_utf8_strlen(pixmaptext, -1);
 
-    text_get_extents(textbox->fontname, pixmaptext, &width, NULL, NULL, NULL);
+    text_get_extents(priv->fontname, pixmaptext, &width, NULL, NULL, NULL);
 
-    textbox->pixmap_width = MAX(width, textbox->width);
-    textbox->pixmap = gdk_pixmap_new(mainwin->window, textbox->pixmap_width,
+    priv->pixmap_width = MAX(width, textbox->width);
+    priv->pixmap = gdk_pixmap_new(mainwin->window, priv->pixmap_width,
                                    textbox->height,
                                    gdk_rgb_get_visual()->depth);
-    gc = textbox->gc;
+    gc = priv->gc;
     c = skin_get_color(bmp_active_skin, SKIN_TEXTBG);
     for (i = 0; i < textbox->height; i++) {
         gdk_gc_set_foreground(gc, &c[6 * i / textbox->height]);
-        gdk_draw_line(textbox->pixmap, gc, 0, i, textbox->pixmap_width, i);
+        gdk_draw_line(priv->pixmap, gc, 0, i, priv->pixmap_width, i);
     }
 
-    mask = gdk_pixmap_new(mainwin->window, textbox->pixmap_width, textbox->height, 1);
+    mask = gdk_pixmap_new(mainwin->window, priv->pixmap_width, textbox->height, 1);
     maskgc = gdk_gc_new(mask);
     pattern.pixel = 0;
     gdk_gc_set_foreground(maskgc, &pattern);
 
-    gdk_draw_rectangle(mask, maskgc, TRUE, 0, 0, textbox->pixmap_width, textbox->height);
+    gdk_draw_rectangle(mask, maskgc, TRUE, 0, 0, priv->pixmap_width, textbox->height);
     pattern.pixel = 1;
     gdk_gc_set_foreground(maskgc, &pattern);
 
     gdk_gc_set_foreground(gc, skin_get_color(bmp_active_skin, SKIN_TEXTFG));
 
     layout = gtk_widget_create_pango_layout(mainwin, pixmaptext);
-    pango_layout_set_font_description(layout, textbox->font);
+    pango_layout_set_font_description(layout, priv->font);
 
-    gdk_draw_layout(textbox->pixmap, gc, 0, (textbox->font_descent / 2), layout);
+    gdk_draw_layout(priv->pixmap, gc, 0, (priv->font_descent / 2), layout);
     g_object_unref(layout);
 
     g_object_unref(maskgc);
@@ -540,7 +594,7 @@
     c = skin_get_color(bmp_active_skin, SKIN_TEXTFG);
     for (i = 0; i < textbox->height; i++) {
         gdk_gc_set_foreground(gc, &c[6 * i / textbox->height]);
-        gdk_draw_line(textbox->pixmap, gc, 0, i, textbox->pixmap_width, i);
+        gdk_draw_line(priv->pixmap, gc, 0, i, priv->pixmap_width, i);
     }
     g_object_unref(mask);
     gdk_gc_set_clip_mask(gc, NULL);
@@ -548,31 +602,32 @@
 
 static gboolean textbox_scroll(gpointer data) {
     UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX(data);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
 
-    if (!textbox->is_dragging) {
-        if (textbox->scroll_dummy < TEXTBOX_SCROLL_WAIT)
-            textbox->scroll_dummy++;
+    if (!priv->is_dragging) {
+        if (priv->scroll_dummy < TEXTBOX_SCROLL_WAIT)
+            priv->scroll_dummy++;
         else {
             if(cfg.twoway_scroll) {
-                if (textbox->scroll_back)
-                    textbox->offset -= 1;
+                if (priv->scroll_back)
+                    priv->offset -= 1;
                 else
-                    textbox->offset += 1;
+                    priv->offset += 1;
 
-                if (textbox->offset >= (textbox->pixmap_width - textbox->width)) {
-                    textbox->scroll_back = TRUE;
-                    textbox->scroll_dummy = 0;
+                if (priv->offset >= (priv->pixmap_width - textbox->width)) {
+                    priv->scroll_back = TRUE;
+                    priv->scroll_dummy = 0;
                 }
-                if (textbox->offset <= 0) {
-                    textbox->scroll_back = FALSE;
-                    textbox->scroll_dummy = 0;
+                if (priv->offset <= 0) {
+                    priv->scroll_back = FALSE;
+                    priv->scroll_dummy = 0;
                 }
             }
             else { // oneway scroll
-                textbox->scroll_back = FALSE;
-                textbox->offset += 1;
+                priv->scroll_back = FALSE;
+                priv->offset += 1;
             }
-            textbox->redraw=TRUE;
+            priv->redraw=TRUE;
             gtk_widget_queue_draw(GTK_WIDGET(textbox));
         }
     }
@@ -586,10 +641,11 @@
     GdkGC *gc;
 
     g_return_if_fail(textbox != NULL);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
 
-    if (textbox->pixmap) {
-        g_object_unref(textbox->pixmap);
-        textbox->pixmap = NULL;
+    if (priv->pixmap) {
+        g_object_unref(priv->pixmap);
+        priv->pixmap = NULL;
     }
 
     /*
@@ -597,13 +653,13 @@
      * changed.  This is a hack to avoid visual noice on vbr files
      * where we guess the length.
      */
-    if (!(textbox->pixmap_text && strrchr(textbox->text, '(') &&
-          !strncmp(textbox->pixmap_text, textbox->text,
+    if (!(priv->pixmap_text && strrchr(textbox->text, '(') &&
+          !strncmp(priv->pixmap_text, textbox->text,
                    strrchr(textbox->text, '(') - textbox->text)))
-        textbox->offset = 0;
+        priv->offset = 0;
 
-    g_free(textbox->pixmap_text);
-    textbox->pixmap_text = g_strdup(textbox->text);
+    g_free(priv->pixmap_text);
+    priv->pixmap_text = g_strdup(textbox->text);
 
     /*
      * wl is the number of (partial) letters visible. Only makes
@@ -615,52 +671,52 @@
 
     length = g_utf8_strlen(textbox->text, -1);
 
-    textbox->is_scrollable = FALSE;
+    priv->is_scrollable = FALSE;
 
-    textbox->is_scrollable = ui_skinned_textbox_should_scroll(textbox);
+    priv->is_scrollable = ui_skinned_textbox_should_scroll(textbox);
 
-    if (textbox->is_scrollable) {
+    if (priv->is_scrollable) {
         if(!cfg.twoway_scroll) {
-            pixmaptext = g_strdup_printf("%s *** ", textbox->pixmap_text);
+            pixmaptext = g_strdup_printf("%s *** ", priv->pixmap_text);
             length += 5;
         } else
-            pixmaptext = g_strdup(textbox->pixmap_text);
+            pixmaptext = g_strdup(priv->pixmap_text);
     } else
-    if (!textbox->font && length <= wl) {
+    if (!priv->font && length <= wl) {
         gint pad = wl - length;
         gchar *padchars = g_strnfill(pad, ' ');
 
-        pixmaptext = g_strconcat(textbox->pixmap_text, padchars, NULL);
+        pixmaptext = g_strconcat(priv->pixmap_text, padchars, NULL);
         g_free(padchars);
         length += pad;
     } else
-        pixmaptext = g_strdup(textbox->pixmap_text);
+        pixmaptext = g_strdup(priv->pixmap_text);
 
-    if (textbox->is_scrollable) {
-        if (textbox->scroll_enabled && !textbox->scroll_timeout) {
+    if (priv->is_scrollable) {
+        if (priv->scroll_enabled && !priv->scroll_timeout) {
             gint tag;
             tag = TEXTBOX_SCROLL_SMOOTH_TIMEOUT;
-            textbox->scroll_timeout = g_timeout_add(tag, textbox_scroll, textbox);
+            priv->scroll_timeout = g_timeout_add(tag, textbox_scroll, textbox);
         }
     } else {
-        if (textbox->scroll_timeout) {
-            g_source_remove(textbox->scroll_timeout);
-            textbox->scroll_timeout = 0;
+        if (priv->scroll_timeout) {
+            g_source_remove(priv->scroll_timeout);
+            priv->scroll_timeout = 0;
         }
-        textbox->offset = 0;
+        priv->offset = 0;
     }
 
-    if (textbox->font) {
+    if (priv->font) {
         textbox_generate_xfont_pixmap(textbox, pixmaptext);
         g_free(pixmaptext);
         return;
     }
 
-    textbox->pixmap_width = length * bmp_active_skin->properties.textbox_bitmap_font_width;
-    textbox->pixmap = gdk_pixmap_new(NULL,
-                                     textbox->pixmap_width, bmp_active_skin->properties.textbox_bitmap_font_height,
+    priv->pixmap_width = length * bmp_active_skin->properties.textbox_bitmap_font_width;
+    priv->pixmap = gdk_pixmap_new(NULL,
+                                     priv->pixmap_width, bmp_active_skin->properties.textbox_bitmap_font_height,
                                      gdk_rgb_get_visual()->depth);
-    gc = textbox->gc;
+    gc = priv->gc;
 
     for (tmp = stxt = g_utf8_strup(pixmaptext, -1), i = 0;
          tmp != NULL && i < length; i++, tmp = g_utf8_next_char(tmp)) {
@@ -678,7 +734,7 @@
             textbox_handle_special_char(c, &x, &y);
 
         skin_draw_pixmap(bmp_active_skin,
-                         textbox->pixmap, gc, textbox->skin_index,
+                         priv->pixmap, gc, priv->skin_index,
                          x, y, i * bmp_active_skin->properties.textbox_bitmap_font_width, 0,
                          bmp_active_skin->properties.textbox_bitmap_font_width, 
                          bmp_active_skin->properties.textbox_bitmap_font_height);
@@ -690,25 +746,26 @@
 void ui_skinned_textbox_set_scroll(GtkWidget *widget, gboolean scroll) {
     g_return_if_fail(widget != NULL);
     UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX(widget);
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(textbox);
 
-    textbox->scroll_enabled = scroll;
-    if (textbox->scroll_enabled && textbox->is_scrollable && textbox->scroll_allowed) {
+    priv->scroll_enabled = scroll;
+    if (priv->scroll_enabled && priv->is_scrollable && priv->scroll_allowed) {
         gint tag;
         tag = TEXTBOX_SCROLL_SMOOTH_TIMEOUT;
-        if (textbox->scroll_timeout) {
-            g_source_remove(textbox->scroll_timeout);
-            textbox->scroll_timeout = 0;
+        if (priv->scroll_timeout) {
+            g_source_remove(priv->scroll_timeout);
+            priv->scroll_timeout = 0;
         }
-        textbox->scroll_timeout = g_timeout_add(tag, textbox_scroll, textbox);
+        priv->scroll_timeout = g_timeout_add(tag, textbox_scroll, textbox);
 
     } else {
 
-        if (textbox->scroll_timeout) {
-            g_source_remove(textbox->scroll_timeout);
-            textbox->scroll_timeout = 0;
+        if (priv->scroll_timeout) {
+            g_source_remove(priv->scroll_timeout);
+            priv->scroll_timeout = 0;
         }
 
-        textbox->offset = 0;
+        priv->offset = 0;
         gtk_widget_queue_draw(GTK_WIDGET(textbox));
     }
 }
@@ -824,16 +881,16 @@
 
 void ui_skinned_textbox_move_relative(GtkWidget *widget, gint x, gint y) {
     g_mutex_lock(mutex);
-    UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX(widget);
-    textbox->move_x += x;
-    textbox->move_y += y;
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(widget);
+    priv->move_x += x;
+    priv->move_y += y;
     g_mutex_unlock(mutex);
 }
 
 void ui_skinned_textbox_resize_relative(GtkWidget *widget, gint w, gint h) {
     g_mutex_lock(mutex);
-    UiSkinnedTextbox *textbox = UI_SKINNED_TEXTBOX(widget);
-    textbox->resize_width += w;
-    textbox->resize_height += h;
+    UiSkinnedTextboxPrivate *priv = UI_SKINNED_TEXTBOX_GET_PRIVATE(widget);
+    priv->resize_width += w;
+    priv->resize_height += h;
     g_mutex_unlock(mutex);
 }
diff -r 934c1a79904f -r a2eb970ca669 src/audacious/ui_skinned_textbox.h
--- a/src/audacious/ui_skinned_textbox.h	Fri Jul 06 12:52:13 2007 +0200
+++ b/src/audacious/ui_skinned_textbox.h	Fri Jul 06 13:19:16 2007 +0200
@@ -45,28 +45,6 @@
 
     gint             x, y, width, height;
     gchar            *text;
-    gboolean         redraw;
-    GdkPixmap        *img;
-    GdkGC            *gc;
-    SkinPixmapId     skin_index;
-    GtkWidget        *fixed;
-    gboolean         double_size;
-    gboolean         scroll_back;
-    gint             nominal_y, nominal_height;
-    gint             scroll_timeout;
-    gint             font_ascent, font_descent;
-    PangoFontDescription *font;
-    gchar            *fontname;
-    gchar            *pixmap_text;
-    gint             skin_id;
-    gint             drag_x, drag_off, offset;
-    gboolean         is_scrollable, is_dragging;
-    gint             pixmap_width;
-    GdkPixmap        *pixmap;
-    gboolean         scroll_allowed, scroll_enabled;
-    gint             scroll_dummy;
-    gint             resize_width, resize_height;
-    gint             move_x, move_y;
 };
 
 struct _UiSkinnedTextboxClass {