added args ::show_text, ::text_xalign, ::text_yalign, ::activity_mode.

Sun Nov 22 16:21:28 1998  Tim Janik  <timj@gtk.org>

	* gtk/gtkprogress.c: added args ::show_text, ::text_xalign,
 	::text_yalign, ::activity_mode.

	* gtk/gtkprogressbar.c: added construct arg ::adjustment. added args
 	::bar_style, ::orientation, ::discrete_blocks, ::activity_step,
 	::activity_blocks.
	(gtk_progress_bar_new):
	(gtk_progress_bar_new_with_adjustment): use gtk_widget_new().
	(gtk_progress_bar_construct): deprecated.

	* gtk/gtkvscrollbar.c:
	(gtk_vscrollbar_draw_step_back):
	(gtk_vscrollbar_draw_step_forw): use "vscrollbar" as detail for
 	gtk_paint_arrow, to be consistent with hscrollbar.

	* gtk/gtktext.c
	added construct args ::hadjustment, ::vadjustment.
	added args ::line_wrap, ::word_wrap.
	(gtk_text_class_init): added scroll_adjustments signal.
	(gtk_text_new): use gtk_widget_new.
	(gtk_text_disconnect): remove adjustement with gtk_text_set_adjustments,
	so we don't screw the reference counts and don't leave signals connected.
 	(gtk_text_destroy): disconnect adjustments signals.
 	(gtk_text_finalize): unref adjustments.

	* gtk/gtkctree.c: added construct args ::n_columns and ::tree_column.
	added args ::indent, ::spacing, ::show_stub, ::reorderable,
 	::use_drag_icons, ::line_style and ::expander_style.
	(gtk_ctree_set_show_stub): renamed from gtk_ctree_show_stub, which is
	deprecated now.

	* gtk/gtkclist.h: remove GTK_CLIST_CONSTRUCT flag.
	* gtk/gtkclist.c:
 	removed ::vadjustment and ::hadjustment args, introduced
 	::scroll_adjustments signal.
	added ::shadow_type, ::selection_mode and ::row_height args.
	added n_columns construct arg.
	(gtk_clist_construct): call gtk_object_constructed().
 	(gtk_clist_set_row_height): if height is passed as 0,
	revert to automatic height calculation.
	(gtk_clist_destroy): before unrefing the adjustments, disconnect our
	signal handlers.

Fri Nov 21 22:34:58 1998  Tim Janik  <timj@gtk.org>

	* gtk/gtkwidget.c (gtk_widget_new): call gtk_object_default_construct
	like gtk_object_new.
	(gtk_widget_destroy): assert that we only destroy constructed widgets.

	* gtk/gtkobject.h (enum GtkArgFlags): new flag GTK_ARG_CONSTRUCT_ONLY
	to identify args that may only be used for construction.
	GTK_ARG_CONSTRUCT maybe used as normal arguments besides construction
	time.
	* gtk/gtkobject.c (gtk_object_new): invoke gtk_object_default_construct
	at the end if the object is not fully constructed.
	(gtk_object_newv): likewise.
	(gtk_object_destroy): assert that we only destroy constructed objects.
 	(gtk_object_init): setup GTK_CONSTRUCTED from the
	objects real klass.
	(gtk_object_default_construct): new function to complete default
	construction of an object by applying missing construtor args with
	default values of 0, 0.0 or NULL.
	(gtk_object_constructed): new function to mark an object as being
	constructed (used from within constructors).

	* gtk/gtkarg.c (gtk_arg_type_new_static): return the args info pointer
	so it is immediatedly available for the caller.

	* gtk/gtktypeutils.c (gtk_type_new): pass an object's real class to
	the object initilizer (GtkObjectInitFunc takes a second arg now, the
 	real klass), and asure that object initializers may temporarily alter
	the class pointer.

Fri Nov 20 08:00:30 1998  Tim Janik  <timj@gtk.org>

	* gtk/testgtk.c: change all occourances of gtk_container_add (
	scrolled_window, widget) to gtk_scrolled_window_add_with_viewport (...)
	for widget!=(clist, ctree, text, viewport).

	* gtk/gtkcombo.c:
 	(gtk_combo_init): use gtk_scrolled_window_add_with_viewport()
	to add children to the scrolled window.

	* gtk/gtkscrolledwindow.h:
	* gtk/gtkscrolledwindow.c:
	changed scrolled_window->viewport to scrolled_window->child, and use
	gtk_widget_scroll_adjustements() to set the scroll adjustments for the
	widget, we do not create an additional viewport anymore.
	added ::hadjustment and ::vadjustment constructor args.
 	(gtk_scrolled_window_new): use gtk_widget_new() to create the widget.
	(gtk_scrolled_window_set_hadjustment):
	(gtk_scrolled_window_set_vadjustment): new functions that superceed
	gtk_scrolled_window_construct.
	(gtk_scrolled_window_construct): deprecated this function.

	* gtk/gtkhscrollbar.c:
	* gtk/gtkvscrollbar.c:
	* gtk/gtkhscale.c:
	* gtk/gtkvscale.c:
	support a constructor arg "::adjustment", and use gtk_widget_new() for
	the widget creation.

	* gtk/gtkrange.c: added ::update_policy arg.
 	(gtk_range_set_adjustment): if adjustment is passed in as NULL, create
 	a default adjustment so this function can be used for derived widgets
 	that depend on the adjustment's existance.
	(gtk_range_destroy): disconnect the adjustment signal, so we don't
	get called after we got destroyed, we don't destroy the adjustment
	in here, because it might have been provided from another widget.

	* gtk/gtkviewport.c: introduced ::scroll_adjustments signal.
	(gtk_viewport_destroy): same as gtk_range_destroy.

	* gtk/gtkprogress.c (gtk_progress_destroy): same as gtk_range_destroy.

	* gtk/gtkwidget.h:
	* gtk/gtkwidget.c: changed gtk_widget_activate() to return a
	gboolean, indicating whether this widget supports activation.
	added gtk_widget_scroll_adjustements() to set the scrolling
	adjustments of a widget.

Wed Nov 19 01:22:42 1998  Tim Janik  <timj@gtk.org>

	* gtk/gtkoptionmenu.c:
 	(gtk_option_menu_remove_contents):
	(gtk_option_menu_update_contents): removed
 	gtk_container_[un]block_resize() pairs.

	* gtk/gtknotebook.h:
	* gtk/gtknotebook.c: removed the tab_border field, since it shouldn't
	be used outside of gtknotebook.c anyways. made ARG_TAB_BORDER a
	wrtie-only argument.

	* *.c: made deprecated functions issue a message:
	gtk_clist_set_border, gtk_container_block_resize,
 	gtk_container_unblock_resize, gtk_container_need_resize,
 	gtk_object_class_add_user_signal, gtk_spin_button_construct,
	gtk_scrolled_window_construct.
	removed non-functional functions:
	gtk_container_disable_resize, gtk_container_enable_resize,
	gtk_clist_set_policy.

Wed Nov 18 22:54:36 1998  Tim Janik  <timj@gtk.org>

	* gtk/gtkbox.c (gtk_box_init):
	* gtk/gtkdrawingarea.c (gtk_drawing_area_init):
	* gtk/gtkeventbox.c (gtk_event_box_init):
	* gtk/gtkfixed.c (gtk_fixed_init):
	* gtk/gtkframe.c (gtk_frame_init):
	* gtk/gtkhandlebox.c (gtk_handle_box_init):
	* gtk/gtkpacker.c (gtk_packer_init):
	* gtk/gtkmisc.c (gtk_misc_init):
	* gtk/gtkpreview.c (gtk_preview_init):
	* gtk/gtkprogress.c (gtk_progress_init):
	* gtk/gtkprogressbar.c (gtk_progress_bar_init):
	* gtk/gtkseparator.c (gtk_separator_init):
	* gtk/gtktable.c (gtk_table_init):
	* gtk/gtkviewport.c (gtk_viewport_init):
	* gtk/gtkalignment.c (gtk_alignment_init):
	removed setting of the GTK_BASIC flag.

	* gtk/gtkwidget.h:
	* gtk/gtkwidget.c:
	removed GTK_BASIC, GTK_WIDGET_BASIC and	gtk_widget_basic.

	* miscellaneous GtkType and macro fixups.

1 files changed, 262 insertions, 205 deletions

diff --git a/gtk/gtkhscale.c b/gtk/gtkhscale.c
index e4559fb12c..037d9b00f2 100644
--- a/gtk/gtkhscale.c
+++ b/gtk/gtkhscale.c
@@ -25,86 +25,145 @@
 #define SCALE_CLASS(w)  GTK_SCALE_CLASS (GTK_OBJECT (w)->klass)
 #define RANGE_CLASS(w)  GTK_RANGE_CLASS (GTK_OBJECT (w)->klass)
 
+enum {
+  ARG_0,
+  ARG_ADJUSTMENT,
+};
 
 static void gtk_hscale_class_init    (GtkHScaleClass *klass);
 static void gtk_hscale_init          (GtkHScale      *hscale);
+static void gtk_hscale_set_arg       (GtkObject      *object,
+                                      GtkArg         *arg,
+                                      guint           arg_id);
+static void gtk_hscale_get_arg       (GtkObject      *object,
+                                      GtkArg         *arg,
+                                      guint           arg_id);
 static void gtk_hscale_realize       (GtkWidget      *widget);
 static void gtk_hscale_size_request  (GtkWidget      *widget,
-				      GtkRequisition *requisition);
+                                      GtkRequisition *requisition);
 static void gtk_hscale_size_allocate (GtkWidget      *widget,
-				      GtkAllocation  *allocation);
+                                      GtkAllocation  *allocation);
 static void gtk_hscale_pos_trough    (GtkHScale      *hscale,
-				      gint           *x,
-				      gint           *y,
-				      gint           *w,
-				      gint           *h);
+                                      gint           *x,
+                                      gint           *y,
+                                      gint           *w,
+                                      gint           *h);
 static void gtk_hscale_pos_background (GtkHScale     *hscale,
-				       gint          *x,
-				       gint          *y,
-				       gint          *w,
-				       gint          *h);
+                                       gint          *x,
+                                       gint          *y,
+                                       gint          *w,
+                                       gint          *h);
 static void gtk_hscale_draw_slider   (GtkRange       *range);
 static void gtk_hscale_draw_value    (GtkScale       *scale);
 static void gtk_hscale_draw          (GtkWidget      *widget,
-				      GdkRectangle   *area);
+                                      GdkRectangle   *area);
 static gint gtk_hscale_trough_keys   (GtkRange *range,
-				      GdkEventKey *key,
-				      GtkScrollType *scroll,
-				      GtkTroughType *pos);
+                                      GdkEventKey *key,
+                                      GtkScrollType *scroll,
+                                      GtkTroughType *pos);
 static void gtk_hscale_clear_background (GtkRange    *range);
 
-guint
+GtkType
 gtk_hscale_get_type (void)
 {
-  static guint hscale_type = 0;
-
+  static GtkType hscale_type = 0;
+  
   if (!hscale_type)
     {
       GtkTypeInfo hscale_info =
       {
-	"GtkHScale",
-	sizeof (GtkHScale),
-	sizeof (GtkHScaleClass),
-	(GtkClassInitFunc) gtk_hscale_class_init,
-	(GtkObjectInitFunc) gtk_hscale_init,
-	/* reserved_1 */ NULL,
+        "GtkHScale",
+        sizeof (GtkHScale),
+        sizeof (GtkHScaleClass),
+        (GtkClassInitFunc) gtk_hscale_class_init,
+        (GtkObjectInitFunc) gtk_hscale_init,
+        /* reserved_1 */ NULL,
         /* reserved_2 */ NULL,
         (GtkClassInitFunc) NULL,
       };
-
-      hscale_type = gtk_type_unique (gtk_scale_get_type (), &hscale_info);
+      
+      hscale_type = gtk_type_unique (GTK_TYPE_SCALE, &hscale_info);
     }
-
+  
   return hscale_type;
 }
 
 static void
 gtk_hscale_class_init (GtkHScaleClass *class)
 {
+  GtkObjectClass *object_class;
   GtkWidgetClass *widget_class;
   GtkRangeClass *range_class;
   GtkScaleClass *scale_class;
-
+  
+  object_class = (GtkObjectClass*) class;
   widget_class = (GtkWidgetClass*) class;
   range_class = (GtkRangeClass*) class;
   scale_class = (GtkScaleClass*) class;
-
+  
+  gtk_object_add_arg_type ("GtkHScale::adjustment",
+                           GTK_TYPE_ADJUSTMENT,
+                           GTK_ARG_READWRITE | GTK_ARG_CONSTRUCT,
+                           ARG_ADJUSTMENT);
+  
+  object_class->set_arg = gtk_hscale_set_arg;
+  object_class->get_arg = gtk_hscale_get_arg;
+  
   widget_class->realize = gtk_hscale_realize;
   widget_class->size_request = gtk_hscale_size_request;
   widget_class->size_allocate = gtk_hscale_size_allocate;
   widget_class->draw = gtk_hscale_draw;
-
+  
   range_class->slider_update = gtk_range_default_hslider_update;
   range_class->trough_click = gtk_range_default_htrough_click;
   range_class->motion = gtk_range_default_hmotion;
   range_class->draw_slider = gtk_hscale_draw_slider;
   range_class->trough_keys = gtk_hscale_trough_keys;
   range_class->clear_background = gtk_hscale_clear_background;
-
+  
   scale_class->draw_value = gtk_hscale_draw_value;
 }
 
 static void
+gtk_hscale_set_arg (GtkObject          *object,
+                    GtkArg             *arg,
+                    guint               arg_id)
+{
+  GtkHScale *hscale;
+  
+  hscale = GTK_HSCALE (object);
+  
+  switch (arg_id)
+    {
+    case ARG_ADJUSTMENT:
+      gtk_range_set_adjustment (GTK_RANGE (hscale), GTK_VALUE_POINTER (*arg));
+      break;
+    default:
+      break;
+    }
+}
+
+static void
+gtk_hscale_get_arg (GtkObject          *object,
+                    GtkArg             *arg,
+                    guint               arg_id)
+{
+  GtkHScale *hscale;
+  
+  hscale = GTK_HSCALE (object);
+  
+  switch (arg_id)
+    {
+    case ARG_ADJUSTMENT:
+      GTK_VALUE_POINTER (*arg) = GTK_RANGE (hscale);
+      break;
+    default:
+      arg->type = GTK_TYPE_INVALID;
+      break;
+    }
+}
+
+static void
 gtk_hscale_init (GtkHScale *hscale)
 {
   GTK_WIDGET_SET_FLAGS (hscale, GTK_NO_WINDOW);
@@ -113,16 +172,13 @@ gtk_hscale_init (GtkHScale *hscale)
 GtkWidget*
 gtk_hscale_new (GtkAdjustment *adjustment)
 {
-  GtkHScale *hscale;
-
-  hscale = gtk_type_new (gtk_hscale_get_type ());
-
-  if (!adjustment)
-    adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
-
-  gtk_range_set_adjustment (GTK_RANGE (hscale), adjustment);
+  GtkWidget *hscale;
+  
+  hscale = gtk_widget_new (GTK_TYPE_HSCALE,
+			   "adjustment", adjustment,
+			   NULL);
 
-  return GTK_WIDGET (hscale);
+  return hscale;
 }
 
 
@@ -133,17 +189,18 @@ gtk_hscale_realize (GtkWidget *widget)
   GdkWindowAttr attributes;
   gint attributes_mask;
   gint x, y, w, h;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_HSCALE (widget));
-
+  
   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
   range = GTK_RANGE (widget);
-
+  
   widget->window = gtk_widget_get_parent_window (widget);
   gdk_window_ref (widget->window);
-
+  
   gtk_hscale_pos_trough (GTK_HSCALE (widget), &x, &y, &w, &h);
+
   attributes.x = x + widget->allocation.x;
   attributes.y = y + widget->allocation.y;
   attributes.width = w;
@@ -152,79 +209,79 @@ gtk_hscale_realize (GtkWidget *widget)
   attributes.window_type = GDK_WINDOW_CHILD;
   
   attributes.event_mask = gtk_widget_get_events (widget) | 
-                            (GDK_EXPOSURE_MASK |
-                             GDK_BUTTON_PRESS_MASK |
-			     GDK_BUTTON_RELEASE_MASK |
-			     GDK_ENTER_NOTIFY_MASK |
-			     GDK_LEAVE_NOTIFY_MASK);
+    (GDK_EXPOSURE_MASK |
+     GDK_BUTTON_PRESS_MASK |
+     GDK_BUTTON_RELEASE_MASK |
+     GDK_ENTER_NOTIFY_MASK |
+     GDK_LEAVE_NOTIFY_MASK);
   attributes.visual = gtk_widget_get_visual (widget);
   attributes.colormap = gtk_widget_get_colormap (widget);
-
+  
   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
-
+  
   range->trough = gdk_window_new (widget->window, &attributes, attributes_mask);
-
+  
   attributes.width = SCALE_CLASS (range)->slider_length;
   attributes.height = RANGE_CLASS (range)->slider_width;
   attributes.event_mask |= (GDK_BUTTON_MOTION_MASK |
-			    GDK_POINTER_MOTION_HINT_MASK);
-
+                            GDK_POINTER_MOTION_HINT_MASK);
+  
   range->slider = gdk_window_new (range->trough, &attributes, attributes_mask);
-
+  
   widget->style = gtk_style_attach (widget->style, widget->window);
-
+  
   gdk_window_set_user_data (range->trough, widget);
   gdk_window_set_user_data (range->slider, widget);
-
+  
   gtk_style_set_background (widget->style, range->trough, GTK_STATE_ACTIVE);
   gtk_style_set_background (widget->style, range->slider, GTK_STATE_NORMAL);
-
+  
   gtk_range_slider_update (GTK_RANGE (widget));
-
+  
   gdk_window_show (range->slider);
 }
 
 static void
 gtk_hscale_draw (GtkWidget    *widget,
-		 GdkRectangle *area)
+                 GdkRectangle *area)
 {
   GtkRange *range;
   GdkRectangle tmp_area;
   GdkRectangle child_area;
   gint x, y, width, height;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_RANGE (widget));
   g_return_if_fail (area != NULL);
-
+  
   if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_MAPPED (widget))
     {
       range = GTK_RANGE (widget);
-
+      
       gtk_hscale_pos_background (GTK_HSCALE (widget), &x, &y, &width, &height);
-
+      
       tmp_area.x = x;
       tmp_area.y = y;
       tmp_area.width = width;
       tmp_area.height = height;
-
+      
       if (gdk_rectangle_intersect (area, &tmp_area, &child_area))
-	gtk_range_draw_background (range);
-
+        gtk_range_draw_background (range);
+      
       gtk_hscale_pos_trough (GTK_HSCALE (widget), &x, &y, &width, &height);
-
+      
       tmp_area.x = x;
       tmp_area.y = y;
       tmp_area.width = width;
       tmp_area.height = height;
-
+      
       if (gdk_rectangle_intersect (area, &tmp_area, &child_area))
-	{
-	  gtk_range_draw_trough (range);
-	  gtk_range_draw_slider (range);
-	  gtk_range_draw_step_forw (range);
-	  gtk_range_draw_step_back (range);
-	}
+        {
+          gtk_range_draw_trough (range);
+          gtk_range_draw_slider (range);
+          gtk_range_draw_step_forw (range);
+          gtk_range_draw_step_back (range);
+        }
     }
 }
 
@@ -233,129 +290,129 @@ gtk_hscale_clear_background (GtkRange    *range)
 {
   GtkWidget *widget;
   gint x, y, width, height;
-
+  
   g_return_if_fail (range != NULL);
-
+  
   widget = GTK_WIDGET (range);
   
   gtk_hscale_pos_background (GTK_HSCALE (range), &x, &y, &width, &height);
-
+  
   gtk_widget_queue_clear_area (GTK_WIDGET (range),
-			       x, y, width, height);
+                               x, y, width, height);
 }
 
 static void
 gtk_hscale_size_request (GtkWidget      *widget,
-			 GtkRequisition *requisition)
+                         GtkRequisition *requisition)
 {
   GtkScale *scale;
   gint value_width;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_HSCALE (widget));
   g_return_if_fail (requisition != NULL);
-
+  
   scale = GTK_SCALE (widget);
-
+  
   requisition->width = (SCALE_CLASS (scale)->slider_length +
-			widget->style->klass->xthickness) * 2;
+                        widget->style->klass->xthickness) * 2;
   requisition->height = (RANGE_CLASS (scale)->slider_width +
-			 widget->style->klass->ythickness * 2);
-
+                         widget->style->klass->ythickness * 2);
+  
   if (scale->draw_value)
     {
       value_width = gtk_scale_value_width (scale);
-
+      
       if ((scale->value_pos == GTK_POS_LEFT) ||
-	  (scale->value_pos == GTK_POS_RIGHT))
-	{
-	  requisition->width += value_width + SCALE_CLASS (scale)->value_spacing;
-	  if (requisition->height < (widget->style->font->ascent + widget->style->font->descent))
-	    requisition->height = widget->style->font->ascent + widget->style->font->descent;
-	}
+          (scale->value_pos == GTK_POS_RIGHT))
+        {
+          requisition->width += value_width + SCALE_CLASS (scale)->value_spacing;
+          if (requisition->height < (widget->style->font->ascent + widget->style->font->descent))
+            requisition->height = widget->style->font->ascent + widget->style->font->descent;
+        }
       else if ((scale->value_pos == GTK_POS_TOP) ||
-	       (scale->value_pos == GTK_POS_BOTTOM))
-	{
-	  if (requisition->width < value_width)
-	    requisition->width = value_width;
-	  requisition->height += widget->style->font->ascent + widget->style->font->descent;
-	}
+               (scale->value_pos == GTK_POS_BOTTOM))
+        {
+          if (requisition->width < value_width)
+            requisition->width = value_width;
+          requisition->height += widget->style->font->ascent + widget->style->font->descent;
+        }
     }
 }
 
 static void
 gtk_hscale_size_allocate (GtkWidget     *widget,
-			  GtkAllocation *allocation)
+                          GtkAllocation *allocation)
 {
   GtkRange *range;
   GtkScale *scale;
   gint width, height;
   gint x, y;
-
+  
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_HSCALE (widget));
   g_return_if_fail (allocation != NULL);
-
+  
   widget->allocation = *allocation;
   if (GTK_WIDGET_REALIZED (widget))
     {
       range = GTK_RANGE (widget);
       scale = GTK_SCALE (widget);
-
+      
       gtk_hscale_pos_trough (GTK_HSCALE (widget), &x, &y, &width, &height);
-
+      
       gdk_window_move_resize (range->trough, 
-			      x + widget->allocation.x, 
-			      y + widget->allocation.y, width, height);
+                              x + widget->allocation.x, 
+                              y + widget->allocation.y, width, height);
       gtk_range_slider_update (GTK_RANGE (widget));
     }
 }
 
 static void
 gtk_hscale_pos_trough (GtkHScale *hscale,
-		       gint      *x,
-		       gint      *y,
-		       gint      *w,
-		       gint      *h)
+                       gint      *x,
+                       gint      *y,
+                       gint      *w,
+                       gint      *h)
 {
   GtkWidget *widget;
   GtkScale *scale;
-
+  
   g_return_if_fail (hscale != NULL);
   g_return_if_fail (GTK_IS_HSCALE (hscale));
   g_return_if_fail ((x != NULL) && (y != NULL) && (w != NULL) && (h != NULL));
-
+  
   widget = GTK_WIDGET (hscale);
   scale = GTK_SCALE (hscale);
-
+  
   *w = widget->allocation.width;
   *h = (RANGE_CLASS (scale)->slider_width +
-	widget->style->klass->ythickness * 2);
-
+        widget->style->klass->ythickness * 2);
+  
   if (scale->draw_value)
     {
       *x = 0;
       *y = 0;
-
+      
       switch (scale->value_pos)
-	{
-	case GTK_POS_LEFT:
-	  *x += gtk_scale_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
-	  *y = (widget->allocation.height - *h) / 2;
-	  *w -= *x;
-	  break;
-	case GTK_POS_RIGHT:
-	  *w -= gtk_scale_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
-	  *y = (widget->allocation.height - *h) / 2;
-	  break;
-	case GTK_POS_TOP:
-	  *y = (widget->style->font->ascent + widget->style->font->descent +
-		(widget->allocation.height - widget->requisition.height) / 2);
-	  break;
-	case GTK_POS_BOTTOM:
-	  *y = (widget->allocation.height - widget->requisition.height) / 2;
-	  break;
-	}
+        {
+        case GTK_POS_LEFT:
+          *x += gtk_scale_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
+          *y = (widget->allocation.height - *h) / 2;
+          *w -= *x;
+          break;
+        case GTK_POS_RIGHT:
+          *w -= gtk_scale_value_width (scale) + SCALE_CLASS (scale)->value_spacing;
+          *y = (widget->allocation.height - *h) / 2;
+          break;
+        case GTK_POS_TOP:
+          *y = (widget->style->font->ascent + widget->style->font->descent +
+                (widget->allocation.height - widget->requisition.height) / 2);
+          break;
+        case GTK_POS_BOTTOM:
+          *y = (widget->allocation.height - widget->requisition.height) / 2;
+          break;
+        }
     }
   else
     {
@@ -368,30 +425,30 @@ gtk_hscale_pos_trough (GtkHScale *hscale,
 
 static void
 gtk_hscale_pos_background (GtkHScale *hscale,
-			   gint      *x,
-			   gint      *y,
-			   gint      *w,
-			   gint      *h)
+                           gint      *x,
+                           gint      *y,
+                           gint      *w,
+                           gint      *h)
 {
   GtkWidget *widget;
   GtkScale *scale;
-
+  
   gint tx, ty, twidth, theight;
-
+  
   g_return_if_fail (hscale != NULL);
   g_return_if_fail (GTK_IS_HSCALE (hscale));
   g_return_if_fail ((x != NULL) && (y != NULL) && (w != NULL) && (h != NULL));
-
+  
   gtk_hscale_pos_trough (hscale, &tx, &ty, &twidth, &theight);
   
   widget = GTK_WIDGET (hscale);
   scale = GTK_SCALE (hscale);
-
+  
   *x = widget->allocation.x;
   *y = widget->allocation.y;
   *w = widget->allocation.width;
   *h = widget->allocation.height;
-
+  
   switch (scale->value_pos)
     {
     case GTK_POS_LEFT:
@@ -415,10 +472,10 @@ static void
 gtk_hscale_draw_slider (GtkRange *range)
 {
   GtkStateType state_type;
-
+  
   g_return_if_fail (range != NULL);
   g_return_if_fail (GTK_IS_HSCALE (range));
-
+  
   if (range->slider)
     {
       if ((range->in_child == RANGE_CLASS (range)->slider) ||
@@ -426,8 +483,8 @@ gtk_hscale_draw_slider (GtkRange *range)
         state_type = GTK_STATE_PRELIGHT;
       else
         state_type = GTK_STATE_NORMAL;
-
-       gtk_paint_slider(GTK_WIDGET (range)->style, range->slider, state_type, 
+      
+      gtk_paint_slider (GTK_WIDGET (range)->style, range->slider, state_type, 
 			GTK_SHADOW_OUT,
 			NULL, GTK_WIDGET (range), "hscale",
 			0, 0, -1, -1, 
@@ -444,76 +501,76 @@ gtk_hscale_draw_value (GtkScale *scale)
   gint text_width;
   gint width, height;
   gint x, y;
-
+  
   g_return_if_fail (scale != NULL);
   g_return_if_fail (GTK_IS_HSCALE (scale));
-
+  
   widget = GTK_WIDGET (scale);
   
   if (scale->draw_value)
     {
       sprintf (buffer, "%0.*f", GTK_RANGE (scale)->digits, GTK_RANGE (scale)->adjustment->value);
       text_width = gdk_string_measure (GTK_WIDGET (scale)->style->font, buffer);
-
+      
       switch (scale->value_pos)
-	{
-	case GTK_POS_LEFT:
-	  gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
-	  gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
-
-	  x -= SCALE_CLASS (scale)->value_spacing + text_width;
-	  y += ((height -
-		 (GTK_WIDGET (scale)->style->font->ascent +
-		  GTK_WIDGET (scale)->style->font->descent)) / 2 +
-		GTK_WIDGET (scale)->style->font->ascent);
-	  break;
-	case GTK_POS_RIGHT:
-	  gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
-	  gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
-
-	  x += width + SCALE_CLASS (scale)->value_spacing;
-	  y += ((height -
-		 (GTK_WIDGET (scale)->style->font->ascent +
-		  GTK_WIDGET (scale)->style->font->descent)) / 2 +
-		GTK_WIDGET (scale)->style->font->ascent);
-	  break;
-	case GTK_POS_TOP:
-	  gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
-	  gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
-	  gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
-	  gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
-
-	  x += widget->allocation.x + (width - text_width) / 2;
-	  y -= GTK_WIDGET (scale)->style->font->descent;
-	  break;
-	case GTK_POS_BOTTOM:
-	  gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
-	  gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
-	  gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
-	  gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
-
-	  x += widget->allocation.x + (width - text_width) / 2;
-	  y += height + GTK_WIDGET (scale)->style->font->ascent;
-	  break;
-	}
-
+        {
+        case GTK_POS_LEFT:
+          gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
+          gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
+          
+          x -= SCALE_CLASS (scale)->value_spacing + text_width;
+          y += ((height -
+                 (GTK_WIDGET (scale)->style->font->ascent +
+                  GTK_WIDGET (scale)->style->font->descent)) / 2 +
+                GTK_WIDGET (scale)->style->font->ascent);
+          break;
+        case GTK_POS_RIGHT:
+          gdk_window_get_position (GTK_RANGE (scale)->trough, &x, &y);
+          gdk_window_get_size (GTK_RANGE (scale)->trough, &width, &height);
+          
+          x += width + SCALE_CLASS (scale)->value_spacing;
+          y += ((height -
+                 (GTK_WIDGET (scale)->style->font->ascent +
+                  GTK_WIDGET (scale)->style->font->descent)) / 2 +
+                GTK_WIDGET (scale)->style->font->ascent);
+          break;
+        case GTK_POS_TOP:
+          gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
+          gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
+          gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
+          gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
+          
+          x += widget->allocation.x + (width - text_width) / 2;
+          y -= GTK_WIDGET (scale)->style->font->descent;
+          break;
+        case GTK_POS_BOTTOM:
+          gdk_window_get_position (GTK_RANGE (scale)->slider, &x, NULL);
+          gdk_window_get_position (GTK_RANGE (scale)->trough, NULL, &y);
+          gdk_window_get_size (GTK_RANGE (scale)->slider, &width, NULL);
+          gdk_window_get_size (GTK_RANGE (scale)->trough, NULL, &height);
+          
+          x += widget->allocation.x + (width - text_width) / 2;
+          y += height + GTK_WIDGET (scale)->style->font->ascent;
+          break;
+        }
+      
       state_type = GTK_STATE_NORMAL;
       if (!GTK_WIDGET_IS_SENSITIVE (scale))
-	state_type = GTK_STATE_INSENSITIVE;
-
-       gtk_paint_string (GTK_WIDGET (scale)->style,
-			 GTK_WIDGET (scale)->window,
-			 state_type, 
-			 NULL, GTK_WIDGET (scale), "hscale", 
-			 x, y, buffer);
+        state_type = GTK_STATE_INSENSITIVE;
+      
+      gtk_paint_string (GTK_WIDGET (scale)->style,
+                        GTK_WIDGET (scale)->window,
+                        state_type, 
+                        NULL, GTK_WIDGET (scale), "hscale", 
+                        x, y, buffer);
     }
 }
 
 static gint
-gtk_hscale_trough_keys(GtkRange *range,
-		       GdkEventKey *key,
-		       GtkScrollType *scroll,
-		       GtkTroughType *pos)
+gtk_hscale_trough_keys (GtkRange *range,
+			GdkEventKey *key,
+			GtkScrollType *scroll,
+			GtkTroughType *pos)
 {
   gint return_val = FALSE;
   switch (key->keyval)
@@ -521,16 +578,16 @@ gtk_hscale_trough_keys(GtkRange *range,
     case GDK_Left:
       return_val = TRUE;
       if (key->state & GDK_CONTROL_MASK)
-	*scroll = GTK_SCROLL_PAGE_BACKWARD;
+        *scroll = GTK_SCROLL_PAGE_BACKWARD;
       else
-	*scroll = GTK_SCROLL_STEP_BACKWARD;
+        *scroll = GTK_SCROLL_STEP_BACKWARD;
       break;
     case GDK_Right:
       return_val = TRUE;
       if (key->state & GDK_CONTROL_MASK)
-	*scroll = GTK_SCROLL_PAGE_FORWARD;
+        *scroll = GTK_SCROLL_PAGE_FORWARD;
       else
-	*scroll = GTK_SCROLL_STEP_FORWARD;
+        *scroll = GTK_SCROLL_STEP_FORWARD;
       break;
     case GDK_Home:
       return_val = TRUE;