Introduced generic GtkProgress widget. Derived GtkProgressBar from

Sun Jul 19 12:19:16 1998  Stefan Jeske  <stefan@gtk.org>

	* gtk/gtkprogress.c gtk/gtkprogress.h gtk/gtkprogressbar.c
	  gtk/gtkprogressbar.h gtk/Makefile.am gtk/gtk.h gtk/testgtk.c:
	Introduced generic GtkProgress widget. Derived GtkProgressBar from
	GtkProgress. Made GtkProgressBar much more flexible (see testgtk).

1 files changed, 664 insertions, 134 deletions

diff --git a/gtk/gtkprogressbar.c b/gtk/gtkprogressbar.c
index c82ed8f096..f00e51e58c 100644
--- a/gtk/gtkprogressbar.c
+++ b/gtk/gtkprogressbar.c
@@ -16,22 +16,27 @@
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
+
+#include <stdio.h>
 #include "gtkprogressbar.h"
+#include "gtksignal.h"
 
 
-#define MIN_WIDTH   200
-#define MIN_HEIGHT  20
+#define MIN_HORIZONTAL_BAR_WIDTH   150
+#define MIN_HORIZONTAL_BAR_HEIGHT  20
+#define MIN_VERTICAL_BAR_WIDTH     22
+#define MIN_VERTICAL_BAR_HEIGHT    80
+#define MAX_TEXT_LENGTH            80
+#define TEXT_SPACING               2
 
 
 static void gtk_progress_bar_class_init    (GtkProgressBarClass *klass);
 static void gtk_progress_bar_init          (GtkProgressBar      *pbar);
-static void gtk_progress_bar_realize       (GtkWidget           *widget);
-static void gtk_progress_bar_size_allocate (GtkWidget           *widget,
-					    GtkAllocation       *allocation);
-static gint gtk_progress_bar_expose        (GtkWidget           *widget,
-					    GdkEventExpose      *event);
-static void gtk_progress_bar_make_pixmap   (GtkProgressBar      *pbar);
-static void gtk_progress_bar_paint         (GtkProgressBar      *pbar);
+static void gtk_progress_bar_size_request  (GtkWidget           *widget,
+					    GtkRequisition      *requisition);
+static void gtk_progress_bar_real_update   (GtkProgress         *progress);
+static void gtk_progress_bar_paint         (GtkProgress         *progress);
+static void gtk_progress_bar_act_mode_enter (GtkProgress        *progress);
 
 
 guint
@@ -48,12 +53,13 @@ gtk_progress_bar_get_type (void)
 	sizeof (GtkProgressBarClass),
 	(GtkClassInitFunc) gtk_progress_bar_class_init,
 	(GtkObjectInitFunc) gtk_progress_bar_init,
-	/* reserved_1 */ NULL,
+        /* reserved_1 */ NULL,
         /* reserved_2 */ NULL,
-        (GtkClassInitFunc) NULL,
+        (GtkClassInitFunc) NULL
       };
 
-      progress_bar_type = gtk_type_unique (gtk_widget_get_type (), &progress_bar_info);
+      progress_bar_type = gtk_type_unique (gtk_progress_get_type (),
+					   &progress_bar_info);
     }
 
   return progress_bar_type;
@@ -63,12 +69,16 @@ static void
 gtk_progress_bar_class_init (GtkProgressBarClass *class)
 {
   GtkWidgetClass *widget_class;
+  GtkProgressClass *progress_class;
+
+  widget_class = (GtkWidgetClass *) class;
+  progress_class = (GtkProgressClass *) class;
 
-  widget_class = (GtkWidgetClass*) class;
+  widget_class->size_request = gtk_progress_bar_size_request;
 
-  widget_class->realize = gtk_progress_bar_realize;
-  widget_class->size_allocate = gtk_progress_bar_size_allocate;
-  widget_class->expose_event = gtk_progress_bar_expose;
+  progress_class->paint = gtk_progress_bar_paint;
+  progress_class->update = gtk_progress_bar_real_update;
+  progress_class->act_mode_enter = gtk_progress_bar_act_mode_enter;
 }
 
 static void
@@ -76,187 +86,707 @@ gtk_progress_bar_init (GtkProgressBar *pbar)
 {
   GTK_WIDGET_SET_FLAGS (pbar, GTK_BASIC);
 
-  GTK_WIDGET (pbar)->requisition.width = MIN_WIDTH;
-  GTK_WIDGET (pbar)->requisition.height = MIN_HEIGHT;
-  pbar->offscreen_pixmap = NULL;
-  pbar->percentage = 0;
+  pbar->bar_style = GTK_PROGRESS_CONTINUOUS;
+  pbar->blocks = 10;
+  pbar->in_block = -1;
+  pbar->orientation = GTK_PROGRESS_LEFT_TO_RIGHT;
+  pbar->activity_pos = 0;
+  pbar->activity_dir = 1;
+  pbar->activity_step = 3;
 }
 
 
-GtkWidget*
+GtkWidget *
 gtk_progress_bar_new (void)
 {
-  return GTK_WIDGET (gtk_type_new (gtk_progress_bar_get_type ()));
+  GtkProgressBar *pbar;
+
+  pbar = gtk_type_new (gtk_progress_bar_get_type ());
+
+  gtk_progress_bar_construct (pbar, NULL);
+
+  return GTK_WIDGET (pbar);
+}
+
+GtkWidget *
+gtk_progress_bar_new_with_adjustment (GtkAdjustment *adjustment)
+{
+  GtkProgressBar *pbar;
+
+  pbar = gtk_type_new (gtk_progress_bar_get_type ());
+
+  gtk_progress_bar_construct (pbar, adjustment);
+
+  return GTK_WIDGET (pbar);
 }
 
 void
-gtk_progress_bar_update (GtkProgressBar *pbar,
-			 gfloat          percentage)
+gtk_progress_bar_construct (GtkProgressBar *pbar,
+			    GtkAdjustment  *adjustment)
 {
   g_return_if_fail (pbar != NULL);
   g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
 
-  if (percentage < 0.0)
-    percentage = 0.0;
-  else if (percentage > 1.0)
-    percentage = 1.0;
+  if (!adjustment)
+    adjustment = (GtkAdjustment *) gtk_adjustment_new (0, 0, 100, 0, 0, 0);
 
-  if (pbar->percentage != percentage)
+  gtk_progress_set_adjustment (GTK_PROGRESS (pbar), adjustment);
+}
+
+static void
+gtk_progress_bar_real_update (GtkProgress *progress)
+{
+  GtkProgressBar *pbar;
+  GtkWidget *widget;
+
+  g_return_if_fail (progress != NULL);
+  g_return_if_fail (GTK_IS_PROGRESS (progress));
+
+  pbar = GTK_PROGRESS_BAR (progress);
+  widget = GTK_WIDGET (progress);
+ 
+  if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS ||
+      GTK_PROGRESS (pbar)->activity_mode)
     {
-      pbar->percentage = percentage;
-      gtk_progress_bar_paint (pbar);
-      gtk_widget_queue_draw (GTK_WIDGET (pbar));
+      if (GTK_PROGRESS (pbar)->activity_mode)
+	{
+	  guint size;
+
+	  /* advance the block */
+
+	  if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
+	      pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
+	    {
+	      size = widget->allocation.height - 
+		widget->style->klass->ythickness * 2;
+
+	      if (pbar->activity_dir == 0)
+		{
+		  pbar->activity_pos += pbar->activity_step;
+		  if (pbar->activity_pos + size >=
+		      widget->allocation.width -
+		      widget->style->klass->xthickness)
+		    {
+		      pbar->activity_pos = widget->allocation.width -
+			widget->style->klass->xthickness - size;
+		      pbar->activity_dir = 1;
+		    }
+		}
+	      else
+		{
+		  pbar->activity_pos -= pbar->activity_step;
+		  if (pbar->activity_pos <= widget->style->klass->xthickness)
+		    {
+		      pbar->activity_pos = widget->style->klass->xthickness;
+		      pbar->activity_dir = 0;
+		    }
+		}
+	    }
+	  else
+	    {
+	      size = widget->allocation.width - 
+		widget->style->klass->xthickness * 2;
+
+	      if (pbar->activity_dir == 0)
+		{
+		  pbar->activity_pos += pbar->activity_step;
+		  if (pbar->activity_pos + size >=
+		      widget->allocation.height -
+		      widget->style->klass->ythickness)
+		    {
+		      pbar->activity_pos = widget->allocation.height -
+			widget->style->klass->ythickness - size;
+		      pbar->activity_dir = 1;
+		    }
+		}
+	      else
+		{
+		  pbar->activity_pos -= pbar->activity_step;
+		  if (pbar->activity_pos <= widget->style->klass->ythickness)
+		    {
+		      pbar->activity_pos = widget->style->klass->ythickness;
+		      pbar->activity_dir = 0;
+		    }
+		}
+	    }
+	}
+      gtk_progress_bar_paint (progress);
+      gtk_widget_queue_draw (GTK_WIDGET (progress));
+    }
+  else
+    {
+      gint in_block;
+      
+      in_block = -1 + (gint)(gtk_progress_get_current_percentage (progress) *
+			     (gfloat)pbar->blocks);
+      
+      if (pbar->in_block != in_block)
+	{
+	  pbar->in_block = in_block;
+	  gtk_progress_bar_paint (progress);
+	  gtk_widget_queue_draw (GTK_WIDGET (progress));
+	}
     }
 }
 
 static void
-gtk_progress_bar_realize (GtkWidget *widget)
+gtk_progress_bar_size_request (GtkWidget      *widget,
+			       GtkRequisition *requisition)
 {
+  GtkProgress *progress;
   GtkProgressBar *pbar;
-  GdkWindowAttr attributes;
-  gint attributes_mask;
+  gchar *buf;
 
   g_return_if_fail (widget != NULL);
   g_return_if_fail (GTK_IS_PROGRESS_BAR (widget));
+  g_return_if_fail (requisition != NULL);
 
+  progress = GTK_PROGRESS (widget);
   pbar = GTK_PROGRESS_BAR (widget);
-  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 
-  attributes.window_type = GDK_WINDOW_CHILD;
-  attributes.x = widget->allocation.x;
-  attributes.y = widget->allocation.y;
-  attributes.width = widget->allocation.width;
-  attributes.height = widget->allocation.height;
-  attributes.wclass = GDK_INPUT_OUTPUT;
-  attributes.visual = gtk_widget_get_visual (widget);
-  attributes.colormap = gtk_widget_get_colormap (widget);
-  attributes.event_mask = gtk_widget_get_events (widget);
-  attributes.event_mask |= GDK_EXPOSURE_MASK;
+  if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
+      pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
+    {
+      if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
+	{
+	  buf = gtk_progress_get_text_from_value (progress,
+						  progress->adjustment->upper);
+
+	  requisition->width = MAX (MIN_HORIZONTAL_BAR_WIDTH,
+				    2 * widget->style->klass->xthickness + 3 +
+				    gdk_text_width (widget->style->font, 
+						    buf, strlen (buf)) +
+				    2 * TEXT_SPACING);
+
+	  requisition->height = MAX (MIN_HORIZONTAL_BAR_HEIGHT,
+				     2 * widget->style->klass->ythickness + 3 +
+				     gdk_text_height (widget->style->font, 
+						      buf, strlen (buf)) +
+				     2 * TEXT_SPACING);
+	  g_free (buf);
+	}
+      else
+	{
+	  requisition->width = MIN_HORIZONTAL_BAR_WIDTH;
+	  requisition->height = MIN_HORIZONTAL_BAR_HEIGHT;
+	}
+    }
+  else
+    {
+      if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
+	{	  
+	  buf = gtk_progress_get_text_from_value (progress,
+						  progress->adjustment->upper);
+
+	  requisition->width = MAX (MIN_VERTICAL_BAR_WIDTH,
+				    2 * widget->style->klass->xthickness + 3 +
+				    gdk_text_width (widget->style->font, 
+						    buf, strlen (buf)) +
+				    2 * TEXT_SPACING);
+
+	  requisition->height = MAX (MIN_VERTICAL_BAR_HEIGHT,
+				     2 * widget->style->klass->ythickness + 3 +
+				     gdk_text_height (widget->style->font, 
+						      buf, strlen (buf)) +
+				     2 * TEXT_SPACING);
+	  g_free (buf);
+	}
+      else
+	{
+	  requisition->width = MIN_VERTICAL_BAR_WIDTH;
+	  requisition->height = MIN_VERTICAL_BAR_HEIGHT;
+	}
+    }
+}
 
-  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+static void
+gtk_progress_bar_act_mode_enter (GtkProgress *progress)
+{
+  GtkProgressBar *pbar;
+  GtkWidget *widget;
 
-  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
-  gdk_window_set_user_data (widget->window, pbar);
+  pbar = GTK_PROGRESS_BAR (progress);
+  widget = GTK_WIDGET (progress);
 
-  widget->style = gtk_style_attach (widget->style, widget->window);
-  gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
+  /* calculate start pos */
 
-  gtk_progress_bar_make_pixmap (pbar);
+  if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
+      pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
+    {
+      if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT)
+	{
+	  pbar->activity_pos = widget->style->klass->xthickness;
+	  pbar->activity_dir = 0;
+	}
+      else
+	{
+	  pbar->activity_pos = widget->allocation.width - 
+	    widget->style->klass->xthickness - (widget->allocation.height - 
+		widget->style->klass->ythickness * 2);
+	  pbar->activity_dir = 1;
+	}
+    }
+  else
+    {
+      if (pbar->orientation == GTK_PROGRESS_TOP_TO_BOTTOM)
+	{
+	  pbar->activity_pos = widget->style->klass->ythickness;
+	  pbar->activity_dir = 0;
+	}
+      else
+	{
+	  pbar->activity_pos = widget->allocation.height -
+	    widget->style->klass->ythickness - (widget->allocation.width - 
+		widget->style->klass->xthickness * 2);
+	  pbar->activity_dir = 1;
+	}
+    }
 }
 
 static void
-gtk_progress_bar_size_allocate (GtkWidget     *widget,
-				GtkAllocation *allocation)
+gtk_progress_bar_paint (GtkProgress *progress)
 {
-  g_return_if_fail (widget != NULL);
-  g_return_if_fail (GTK_IS_PROGRESS_BAR (widget));
-  g_return_if_fail (allocation != NULL);
+  GtkProgressBar *pbar;
+  GtkWidget *widget;
+  gint amount;
+  gint block_delta = 0;
+  gint space = 0;
+  gint i;
+  gint x;
+  gint y;
+  gfloat percentage;
+
+  g_return_if_fail (progress != NULL);
+  g_return_if_fail (GTK_IS_PROGRESS_BAR (progress));
+
+  pbar = GTK_PROGRESS_BAR (progress);
+  widget = GTK_WIDGET (progress);
+
+  if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
+      pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
+    space = widget->allocation.width -
+      2 * widget->style->klass->xthickness;
+  else
+    space = widget->allocation.height -
+      2 * widget->style->klass->ythickness;
+
+  percentage = gtk_progress_get_current_percentage (progress);
+
+  if (progress->offscreen_pixmap)
+    {
+      gtk_draw_shadow (widget->style,
+		       progress->offscreen_pixmap,
+		       GTK_STATE_NORMAL, GTK_SHADOW_IN, 0, 0,
+		       widget->allocation.width,
+		       widget->allocation.height);
+	  
+      gdk_draw_rectangle (progress->offscreen_pixmap,
+			  widget->style->bg_gc[GTK_STATE_ACTIVE], TRUE,
+			  widget->style->klass->xthickness,
+			  widget->style->klass->ythickness,
+			  widget->allocation.width -
+			  widget->style->klass->xthickness * 2,
+			  widget->allocation.height -
+			  widget->style->klass->ythickness * 2);
 
-  widget->allocation = *allocation;
+      if (progress->activity_mode)
+	{
+	  if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
+	      pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
+	    {
+	      gdk_draw_rectangle (progress->offscreen_pixmap,
+				  widget->style->bg_gc[GTK_STATE_PRELIGHT],
+				  TRUE,
+				  pbar->activity_pos,
+				  widget->style->klass->ythickness,
+				  widget->allocation.height - 
+				  widget->style->klass->ythickness * 2,
+				  widget->allocation.height - 
+				  widget->style->klass->ythickness * 2);
+	      
+	      gtk_draw_shadow (widget->style,
+			       progress->offscreen_pixmap,
+			       GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+			       pbar->activity_pos,
+			       widget->style->klass->ythickness,
+			       widget->allocation.height - 
+			       widget->style->klass->ythickness * 2,
+			       widget->allocation.height -
+			       widget->style->klass->ythickness * 2);
+	      return;
+	    }
+	  else
+	    {
+	      gdk_draw_rectangle (progress->offscreen_pixmap,
+				  widget->style->bg_gc[GTK_STATE_PRELIGHT],
+				  TRUE,
+				  widget->style->klass->xthickness,
+				  pbar->activity_pos,
+				  widget->allocation.width - 
+				  widget->style->klass->xthickness * 2,
+				  widget->allocation.width - 
+				  widget->style->klass->xthickness * 2);
+	      
+	      gtk_draw_shadow (widget->style,
+			       progress->offscreen_pixmap,
+			       GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+			       widget->style->klass->xthickness,
+			       pbar->activity_pos,
+			       widget->allocation.width -
+			       widget->style->klass->xthickness * 2,
+			       widget->allocation.width - 
+			       widget->style->klass->xthickness * 2);
+	      return;
+	    }
+	}
 
-  if (GTK_WIDGET_REALIZED (widget))
-    {
-      gdk_window_move_resize (widget->window,
-			      allocation->x, allocation->y,
-			      allocation->width, allocation->height);
+      amount = percentage * space;
+      
+      if (amount > 0)
+	{
+	  switch (pbar->orientation)
+	    {
+	      
+	    case GTK_PROGRESS_LEFT_TO_RIGHT:
+	      
+	      if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
+		{
+		  gdk_draw_rectangle (progress->offscreen_pixmap,
+				      widget->style->bg_gc[GTK_STATE_PRELIGHT],
+				      TRUE,
+				      widget->style->klass->xthickness,
+				      widget->style->klass->ythickness,
+				      amount,
+				      widget->allocation.height - 
+				      widget->style->klass->ythickness * 2);
+		  gtk_draw_shadow (widget->style,
+				   progress->offscreen_pixmap,
+				   GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+				   widget->style->klass->xthickness,
+				   widget->style->klass->ythickness,
+				   amount,
+				   widget->allocation.height -
+				   widget->style->klass->ythickness * 2);
+		}
+	      else
+		{
+		  x = widget->style->klass->xthickness;
+		  
+		  for (i = 0; i <= pbar->in_block; i++)
+		    {
+		      block_delta = (((i + 1) * space) / pbar->blocks)
+			- ((i * space) / pbar->blocks);
+		      
+		      gdk_draw_rectangle 
+			(progress->offscreen_pixmap,
+			 widget->style->bg_gc[GTK_STATE_PRELIGHT],
+			 TRUE,
+			 x,
+			 widget->style->klass->ythickness,
+			 block_delta,
+			 widget->allocation.height - 
+			 widget->style->klass->ythickness * 2);
+
+		      gtk_draw_shadow (widget->style,
+				       progress->offscreen_pixmap,
+				       GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+				       x,
+				       widget->style->klass->ythickness,
+				       block_delta,
+				       widget->allocation.height -
+				       widget->style->klass->ythickness * 2);
+
+		      x +=  block_delta;
+		    }
+		}
+	      break;
+
+	    case GTK_PROGRESS_RIGHT_TO_LEFT:
+
+	      if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
+		{
+		  gdk_draw_rectangle (progress->offscreen_pixmap,
+				      widget->style->bg_gc[GTK_STATE_PRELIGHT],
+				      TRUE,
+				      widget->allocation.width - 
+				      widget->style->klass->xthickness - amount,
+				      widget->style->klass->ythickness,
+				      amount,
+				      widget->allocation.height - 
+				      widget->style->klass->ythickness * 2);
+		  gtk_draw_shadow (widget->style,
+				   progress->offscreen_pixmap,
+				   GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+				   widget->allocation.width - 
+				   widget->style->klass->xthickness - amount,
+				   widget->style->klass->ythickness,
+				   amount,
+				   widget->allocation.height -
+				   widget->style->klass->ythickness * 2);
+		}
+	      else
+		{
+		  x = widget->allocation.width - 
+		    widget->style->klass->xthickness;
+
+		  for (i = 0; i <= pbar->in_block; i++)
+		    {
+		      block_delta = (((i + 1) * space) / pbar->blocks) -
+			((i * space) / pbar->blocks);
+
+		      x -=  block_delta;
+
+		      gdk_draw_rectangle (progress->offscreen_pixmap,
+				  widget->style->bg_gc[GTK_STATE_PRELIGHT],
+				  TRUE,
+				  x,
+				  widget->style->klass->ythickness,
+				  block_delta,
+				  widget->allocation.height - 
+				  widget->style->klass->ythickness * 2);
+
+		      gtk_draw_shadow (widget->style,
+				       progress->offscreen_pixmap,
+				       GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+				       x,
+				       widget->style->klass->ythickness,
+				       block_delta,
+				       widget->allocation.height -
+				       widget->style->klass->ythickness * 2);
+		    }
+		}
+	      break;
+
+	    case GTK_PROGRESS_BOTTOM_TO_TOP:
+
+	      if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
+		{
+		  gdk_draw_rectangle (progress->offscreen_pixmap,
+				      widget->style->bg_gc[GTK_STATE_PRELIGHT],
+				      TRUE,
+				      widget->style->klass->xthickness,
+				      widget->allocation.height - 
+				      widget->style->klass->ythickness - amount,
+				      widget->allocation.width - 
+				      widget->style->klass->xthickness * 2,
+				      amount);
+		  gtk_draw_shadow (widget->style,
+				   progress->offscreen_pixmap,
+				   GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+				   widget->style->klass->xthickness,
+				   widget->allocation.height - 
+				   widget->style->klass->ythickness - amount,
+				   widget->allocation.width -
+				   widget->style->klass->xthickness * 2,
+				   amount);
+		}
+	      else
+		{
+		  y = widget->allocation.height - 
+		    widget->style->klass->ythickness;
+
+		  for (i = 0; i <= pbar->in_block; i++)
+		    {
+		      block_delta = (((i + 1) * space) / pbar->blocks) -
+			((i * space) / pbar->blocks);
+		      
+		      y -= block_delta;
+
+		      gdk_draw_rectangle 
+			(progress->offscreen_pixmap,
+			 widget->style->bg_gc[GTK_STATE_PRELIGHT],
+			 TRUE,
+			 widget->style->klass->xthickness,
+			 y,
+			 widget->allocation.width - 
+			 widget->style->klass->xthickness * 2,
+			 block_delta);
+
+		      gtk_draw_shadow (widget->style,
+				       progress->offscreen_pixmap,
+				       GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+				       widget->style->klass->xthickness,
+				       y,
+				       widget->allocation.width - 
+				       widget->style->klass->xthickness * 2,
+				       block_delta);
+		    }
+		}
+	      break;
+
+	    case GTK_PROGRESS_TOP_TO_BOTTOM:
+
+	      if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
+		{
+		  gdk_draw_rectangle (progress->offscreen_pixmap,
+				      widget->style->bg_gc[GTK_STATE_PRELIGHT],
+				      TRUE,
+				      widget->style->klass->xthickness,
+				      widget->style->klass->ythickness,
+				      widget->allocation.width -
+				      widget->style->klass->xthickness * 2,
+				      amount);
+		  gtk_draw_shadow (widget->style,
+				   progress->offscreen_pixmap,
+				   GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+				   widget->style->klass->xthickness,
+				   widget->style->klass->ythickness,
+				   widget->allocation.width -
+				   widget->style->klass->xthickness * 2,
+				   amount);
+		}
+	      else
+		{
+		  y = widget->style->klass->ythickness;
+
+		  for (i = 0; i <= pbar->in_block; i++)
+		    {
+
+		      block_delta = (((i + 1) * space) / pbar->blocks)
+			- ((i * space) / pbar->blocks);
+
+		      gdk_draw_rectangle
+			(progress->offscreen_pixmap,
+			 widget->style->bg_gc[GTK_STATE_PRELIGHT],
+			 TRUE,
+			 widget->style->klass->xthickness,
+			 y,
+			 widget->allocation.width -
+			 widget->style->klass->xthickness * 2,
+			 block_delta);
+
+		      gtk_draw_shadow (widget->style,
+				       progress->offscreen_pixmap,
+				       GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
+				       widget->style->klass->xthickness,
+				       y,
+				       widget->allocation.width -
+				       widget->style->klass->xthickness * 2,
+				       block_delta);
+
+		      y += block_delta;
+		    }
+		}
+	      break;
+
+	    default:
+	      break;
+	    }
+	}
 
-      gtk_progress_bar_make_pixmap (GTK_PROGRESS_BAR (widget));
+      if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
+	{
+	  gint x;
+	  gint y;
+	  gchar *buf;
+	  GdkRectangle rect;
+
+	  buf = gtk_progress_get_current_text (progress);
+
+	  x = widget->style->klass->xthickness + 1 + 
+	    (widget->allocation.width - 2 * widget->style->klass->xthickness -
+	     3 - gdk_text_width (widget->style->font, buf, strlen (buf)))
+	    * progress->x_align; 
+
+	  y = widget->style->font->ascent + 1 +
+	    (widget->allocation.height - 2 * widget->style->klass->ythickness -
+	     3 - gdk_text_height (widget->style->font, buf, strlen (buf)))
+	    * progress->y_align;
+
+	  rect.x = widget->style->klass->xthickness + 1;
+	  rect.y = widget->style->klass->ythickness + 1;
+	  rect.width = widget->allocation.width -
+	    2 * widget->style->klass->xthickness - 3;
+	  rect.height = widget->allocation.height -
+	    2 * widget->style->klass->ythickness - 3;
+
+	  gdk_gc_set_clip_rectangle (widget->style->fg_gc[widget->state],
+				     &rect);
+
+	  gdk_draw_text (progress->offscreen_pixmap, widget->style->font,
+			 widget->style->fg_gc[widget->state],
+			 x, y, buf, strlen (buf));
+
+	  gdk_gc_set_clip_rectangle (widget->style->fg_gc[widget->state],
+				     NULL);
+	  g_free (buf);
+ 	}
     }
 }
 
-static gint
-gtk_progress_bar_expose (GtkWidget      *widget,
-			 GdkEventExpose *event)
+/*******************************************************************/
+
+void
+gtk_progress_bar_update (GtkProgressBar *pbar,
+			 gfloat          percentage)
 {
-  GtkProgressBar *pbar;
+  g_return_if_fail (pbar != NULL);
+  g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
 
-  g_return_val_if_fail (widget != NULL, FALSE);
-  g_return_val_if_fail (GTK_IS_PROGRESS_BAR (widget), FALSE);
-  g_return_val_if_fail (event != NULL, FALSE);
+  /***********************************************************************
+   *                 Use of this function is deprecated !	         * 
+   * Use gtk_progress_set_value or gtk_progress_set_percentage instead.  *
+   ***********************************************************************/
 
-  if (GTK_WIDGET_DRAWABLE (widget))
+  gtk_progress_set_percentage (GTK_PROGRESS (pbar), percentage);
+}
+
+void
+gtk_progress_bar_set_orientation (GtkProgressBar           *pbar,
+				  GtkProgressBarOrientation orientation)
+{
+  g_return_if_fail (pbar != NULL);
+  g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
+
+  if (pbar->orientation != orientation)
     {
-      pbar = GTK_PROGRESS_BAR (widget);
+      pbar->orientation = orientation;
 
-      gdk_draw_pixmap (widget->window,
-		       widget->style->black_gc,
-		       pbar->offscreen_pixmap,
-		       0, 0, 0, 0,
-		       widget->allocation.width,
-		       widget->allocation.height);
+      if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
+	gtk_widget_queue_resize (GTK_WIDGET (pbar));
     }
-
-  return FALSE;
 }
 
-static void
-gtk_progress_bar_make_pixmap (GtkProgressBar *pbar)
+void
+gtk_progress_bar_set_bar_style (GtkProgressBar     *pbar,
+				GtkProgressBarStyle bar_style)
 {
-  GtkWidget *widget;
-
   g_return_if_fail (pbar != NULL);
   g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
 
-  if (GTK_WIDGET_REALIZED (pbar))
+  if (pbar->bar_style != bar_style)
     {
-      widget = GTK_WIDGET (pbar);
-
-      if (pbar->offscreen_pixmap)
-	gdk_pixmap_unref (pbar->offscreen_pixmap);
-
-      pbar->offscreen_pixmap = gdk_pixmap_new (widget->window,
-					       widget->allocation.width,
-					       widget->allocation.height,
-					       -1);
+      pbar->bar_style = bar_style;
 
-      gtk_progress_bar_paint (pbar);
+      if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
+	gtk_widget_queue_resize (GTK_WIDGET (pbar));
     }
 }
 
-static void
-gtk_progress_bar_paint (GtkProgressBar *pbar)
+void
+gtk_progress_bar_set_number_of_blocks (GtkProgressBar *pbar,
+				       guint           blocks)
 {
-  GtkWidget *widget;
-  int amount;
-
   g_return_if_fail (pbar != NULL);
   g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
+  g_return_if_fail (blocks > 1);
 
-  if (pbar->offscreen_pixmap)
+  if (pbar->blocks != blocks)
     {
-      widget = GTK_WIDGET (pbar);
-
-      gtk_draw_shadow (widget->style,
-		       pbar->offscreen_pixmap,
-		       GTK_STATE_NORMAL, GTK_SHADOW_IN, 0, 0,
-		       widget->allocation.width,
-		       widget->allocation.height);
+      pbar->blocks = blocks;
 
-      gdk_draw_rectangle (pbar->offscreen_pixmap,
-			  widget->style->bg_gc[GTK_STATE_ACTIVE], TRUE,
-			  widget->style->klass->xthickness,
-			  widget->style->klass->ythickness,
-			  widget->allocation.width - widget->style->klass->xthickness * 2,
-			  widget->allocation.height - widget->style->klass->ythickness * 2);
+      if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
+	gtk_widget_queue_resize (GTK_WIDGET (pbar));
+    }
+}
 
+void
+gtk_progress_bar_set_activity_step (GtkProgressBar *pbar,
+                                    guint           step)
+{
+  g_return_if_fail (pbar != NULL);
+  g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
 
-      amount = pbar->percentage * (widget->allocation.width - widget->style->klass->xthickness * 2);
-      if (amount > 0)
-	{
-	  gdk_draw_rectangle (pbar->offscreen_pixmap,
-			      widget->style->bg_gc[GTK_STATE_PRELIGHT], TRUE,
-			      widget->style->klass->xthickness,
-			      widget->style->klass->ythickness,
-			      amount,
-			      widget->allocation.height - widget->style->klass->ythickness * 2);
-
-	  gtk_draw_shadow (widget->style,
-			   pbar->offscreen_pixmap,
-			   GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
-			   widget->style->klass->xthickness,
-			   widget->style->klass->ythickness,
-			   amount,
-			   widget->allocation.height - widget->style->klass->ythickness * 2);
-	}
-    }
+  if (pbar->activity_step != step)
+    pbar->activity_step = step;
 }