1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
22 * file for a list of people on the GTK+ Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
37 #include "gtkprogressbar.h"
38 #include "gtksignal.h"
42 #define MIN_HORIZONTAL_BAR_WIDTH 150
43 #define MIN_HORIZONTAL_BAR_HEIGHT 20
44 #define MIN_VERTICAL_BAR_WIDTH 22
45 #define MIN_VERTICAL_BAR_HEIGHT 80
46 #define MAX_TEXT_LENGTH 80
47 #define TEXT_SPACING 2
66 static void gtk_progress_bar_class_init (GtkProgressBarClass *klass);
67 static void gtk_progress_bar_init (GtkProgressBar *pbar);
68 static void gtk_progress_bar_set_property (GObject *object,
72 static void gtk_progress_bar_get_property (GObject *object,
76 static void gtk_progress_bar_size_request (GtkWidget *widget,
77 GtkRequisition *requisition);
78 static void gtk_progress_bar_real_update (GtkProgress *progress);
79 static void gtk_progress_bar_paint (GtkProgress *progress);
80 static void gtk_progress_bar_act_mode_enter (GtkProgress *progress);
84 gtk_progress_bar_get_type (void)
86 static GtkType progress_bar_type = 0;
88 if (!progress_bar_type)
90 static const GtkTypeInfo progress_bar_info =
93 sizeof (GtkProgressBar),
94 sizeof (GtkProgressBarClass),
95 (GtkClassInitFunc) gtk_progress_bar_class_init,
96 (GtkObjectInitFunc) gtk_progress_bar_init,
97 /* reserved_1 */ NULL,
98 /* reserved_2 */ NULL,
99 (GtkClassInitFunc) NULL
102 progress_bar_type = gtk_type_unique (GTK_TYPE_PROGRESS, &progress_bar_info);
105 return progress_bar_type;
109 gtk_progress_bar_class_init (GtkProgressBarClass *class)
111 GObjectClass *gobject_class;
112 GtkWidgetClass *widget_class;
113 GtkProgressClass *progress_class;
115 gobject_class = G_OBJECT_CLASS (class);
116 widget_class = (GtkWidgetClass *) class;
117 progress_class = (GtkProgressClass *) class;
119 gobject_class->set_property = gtk_progress_bar_set_property;
120 gobject_class->get_property = gtk_progress_bar_get_property;
122 widget_class->size_request = gtk_progress_bar_size_request;
124 progress_class->paint = gtk_progress_bar_paint;
125 progress_class->update = gtk_progress_bar_real_update;
126 progress_class->act_mode_enter = gtk_progress_bar_act_mode_enter;
128 g_object_class_install_property (gobject_class,
130 g_param_spec_object ("adjustment",
132 _("The GtkAdjustment connected to the progress bar (Deprecated)"),
136 g_object_class_install_property (gobject_class,
138 g_param_spec_enum ("orientation",
140 _("Orientation and growth of the progress bar"),
141 GTK_TYPE_PROGRESS_BAR_ORIENTATION,
142 GTK_PROGRESS_LEFT_TO_RIGHT,
145 g_object_class_install_property (gobject_class,
147 g_param_spec_enum ("bar_style",
149 _("Specifies the visual style of the bar in percentage mode (Deprecated)"),
150 GTK_TYPE_PROGRESS_BAR_STYLE,
151 GTK_PROGRESS_CONTINUOUS,
154 g_object_class_install_property (gobject_class,
156 g_param_spec_uint ("activity_step",
158 _("The increment used for each iteration in activity mode (Deprecated)"),
164 g_object_class_install_property (gobject_class,
165 PROP_ACTIVITY_BLOCKS,
166 g_param_spec_uint ("activity_blocks",
167 _("Activity Blocks"),
168 _("The number of blocks which can fit in the progress bar area in activity mode (Deprecated)"),
174 g_object_class_install_property (gobject_class,
175 PROP_DISCRETE_BLOCKS,
176 g_param_spec_uint ("discrete_blocks",
177 _("Discrete Blocks"),
178 _("The number of discrete blocks in a progress bar (when shown in the discrete style"),
184 g_object_class_install_property (gobject_class,
186 g_param_spec_double ("fraction",
188 _("The fraction of total work that has been completed"),
194 g_object_class_install_property (gobject_class,
196 g_param_spec_double ("pulse_step",
198 _("The fraction of total progress to move the bouncing block when pulsed"),
204 g_object_class_install_property (gobject_class,
206 g_param_spec_string ("text",
208 _("Text to be displayed in the progress bar"),
215 gtk_progress_bar_init (GtkProgressBar *pbar)
217 pbar->bar_style = GTK_PROGRESS_CONTINUOUS;
220 pbar->orientation = GTK_PROGRESS_LEFT_TO_RIGHT;
221 pbar->pulse_fraction = 0.1;
222 pbar->activity_pos = 0;
223 pbar->activity_dir = 1;
224 pbar->activity_step = 3;
225 pbar->activity_blocks = 5;
229 gtk_progress_bar_set_property (GObject *object,
234 GtkProgressBar *pbar;
236 pbar = GTK_PROGRESS_BAR (object);
240 case PROP_ADJUSTMENT:
241 gtk_progress_set_adjustment (GTK_PROGRESS (pbar),
242 GTK_ADJUSTMENT (g_value_get_object (value)));
244 case PROP_ORIENTATION:
245 gtk_progress_bar_set_orientation (pbar, g_value_get_enum (value));
248 gtk_progress_bar_set_bar_style (pbar, g_value_get_enum (value));
250 case PROP_ACTIVITY_STEP:
251 gtk_progress_bar_set_activity_step (pbar, g_value_get_uint (value));
253 case PROP_ACTIVITY_BLOCKS:
254 gtk_progress_bar_set_activity_blocks (pbar, g_value_get_uint (value));
256 case PROP_DISCRETE_BLOCKS:
257 gtk_progress_bar_set_discrete_blocks (pbar, g_value_get_uint (value));
260 gtk_progress_bar_set_fraction (pbar, g_value_get_double (value));
262 case PROP_PULSE_STEP:
263 gtk_progress_bar_set_pulse_step (pbar, g_value_get_double (value));
266 gtk_progress_bar_set_text (pbar, g_value_get_string (value));
269 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
275 gtk_progress_bar_get_property (GObject *object,
280 GtkProgressBar *pbar;
282 pbar = GTK_PROGRESS_BAR (object);
286 case PROP_ADJUSTMENT:
287 g_value_set_object (value, G_OBJECT (GTK_PROGRESS (pbar)->adjustment));
289 case PROP_ORIENTATION:
290 g_value_set_enum (value, pbar->orientation);
293 g_value_set_enum (value, pbar->bar_style);
295 case PROP_ACTIVITY_STEP:
296 g_value_set_uint (value, pbar->activity_step);
298 case PROP_ACTIVITY_BLOCKS:
299 g_value_set_uint (value, pbar->activity_blocks);
301 case PROP_DISCRETE_BLOCKS:
302 g_value_set_uint (value, pbar->blocks);
305 g_value_set_double (value, gtk_progress_get_current_percentage (GTK_PROGRESS (pbar)));
307 case PROP_PULSE_STEP:
308 g_value_set_double (value, pbar->pulse_fraction);
311 g_value_set_string (value, gtk_progress_bar_get_text (pbar));
314 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
320 gtk_progress_bar_new (void)
324 pbar = gtk_widget_new (GTK_TYPE_PROGRESS_BAR, NULL);
330 gtk_progress_bar_new_with_adjustment (GtkAdjustment *adjustment)
334 g_return_val_if_fail (GTK_IS_ADJUSTMENT (adjustment), NULL);
336 pbar = gtk_widget_new (GTK_TYPE_PROGRESS_BAR,
337 "adjustment", adjustment,
344 gtk_progress_bar_real_update (GtkProgress *progress)
346 GtkProgressBar *pbar;
349 g_return_if_fail (GTK_IS_PROGRESS (progress));
351 pbar = GTK_PROGRESS_BAR (progress);
352 widget = GTK_WIDGET (progress);
354 if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS ||
355 GTK_PROGRESS (pbar)->activity_mode)
357 if (GTK_PROGRESS (pbar)->activity_mode)
361 /* advance the block */
363 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
364 pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
366 /* Update our activity step. */
368 pbar->activity_step = widget->allocation.width * pbar->pulse_fraction;
370 size = MAX (2, widget->allocation.width / pbar->activity_blocks);
372 if (pbar->activity_dir == 0)
374 pbar->activity_pos += pbar->activity_step;
375 if (pbar->activity_pos + size >=
376 widget->allocation.width -
377 widget->style->xthickness)
379 pbar->activity_pos = widget->allocation.width -
380 widget->style->xthickness - size;
381 pbar->activity_dir = 1;
386 pbar->activity_pos -= pbar->activity_step;
387 if (pbar->activity_pos <= widget->style->xthickness)
389 pbar->activity_pos = widget->style->xthickness;
390 pbar->activity_dir = 0;
396 /* Update our activity step. */
398 pbar->activity_step = widget->allocation.height * pbar->pulse_fraction;
400 size = MAX (2, widget->allocation.height / pbar->activity_blocks);
402 if (pbar->activity_dir == 0)
404 pbar->activity_pos += pbar->activity_step;
405 if (pbar->activity_pos + size >=
406 widget->allocation.height -
407 widget->style->ythickness)
409 pbar->activity_pos = widget->allocation.height -
410 widget->style->ythickness - size;
411 pbar->activity_dir = 1;
416 pbar->activity_pos -= pbar->activity_step;
417 if (pbar->activity_pos <= widget->style->ythickness)
419 pbar->activity_pos = widget->style->ythickness;
420 pbar->activity_dir = 0;
425 gtk_progress_bar_paint (progress);
426 gtk_widget_queue_draw (GTK_WIDGET (progress));
432 in_block = -1 + (gint)(gtk_progress_get_current_percentage (progress) *
433 (gdouble)pbar->blocks);
435 if (pbar->in_block != in_block)
437 pbar->in_block = in_block;
438 gtk_progress_bar_paint (progress);
439 gtk_widget_queue_draw (GTK_WIDGET (progress));
445 gtk_progress_bar_size_request (GtkWidget *widget,
446 GtkRequisition *requisition)
448 GtkProgress *progress;
449 GtkProgressBar *pbar;
451 PangoRectangle logical_rect;
454 g_return_if_fail (GTK_IS_PROGRESS_BAR (widget));
455 g_return_if_fail (requisition != NULL);
457 progress = GTK_PROGRESS (widget);
458 pbar = GTK_PROGRESS_BAR (widget);
460 if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
462 buf = gtk_progress_get_text_from_value (progress, progress->adjustment->upper);
464 layout = gtk_widget_create_pango_layout (widget, buf);
465 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
467 g_object_unref (G_OBJECT (layout));
471 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
472 pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
474 if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
476 requisition->width = MAX (MIN_HORIZONTAL_BAR_WIDTH,
477 2 * widget->style->xthickness + 3 +
478 logical_rect.width + 2 * TEXT_SPACING);
480 requisition->height = MAX (MIN_HORIZONTAL_BAR_HEIGHT,
481 2 * widget->style->ythickness + 3 +
482 logical_rect.height + 2 * TEXT_SPACING);
486 requisition->width = MIN_HORIZONTAL_BAR_WIDTH;
487 requisition->height = MIN_HORIZONTAL_BAR_HEIGHT;
492 if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
494 requisition->width = MAX (MIN_VERTICAL_BAR_WIDTH,
495 2 * widget->style->xthickness + 3 +
496 logical_rect.width + 2 * TEXT_SPACING);
498 requisition->height = MAX (MIN_VERTICAL_BAR_HEIGHT,
499 2 * widget->style->ythickness + 3 +
500 logical_rect.height + 2 * TEXT_SPACING);
504 requisition->width = MIN_VERTICAL_BAR_WIDTH;
505 requisition->height = MIN_VERTICAL_BAR_HEIGHT;
511 gtk_progress_bar_act_mode_enter (GtkProgress *progress)
513 GtkProgressBar *pbar;
517 pbar = GTK_PROGRESS_BAR (progress);
518 widget = GTK_WIDGET (progress);
520 /* calculate start pos */
522 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
523 pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
525 size = MAX (2, widget->allocation.width / pbar->activity_blocks);
527 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT)
529 pbar->activity_pos = widget->style->xthickness;
530 pbar->activity_dir = 0;
534 pbar->activity_pos = widget->allocation.width -
535 widget->style->xthickness - (widget->allocation.height -
536 widget->style->ythickness * 2);
537 pbar->activity_dir = 1;
542 size = MAX (2, widget->allocation.height / pbar->activity_blocks);
544 if (pbar->orientation == GTK_PROGRESS_TOP_TO_BOTTOM)
546 pbar->activity_pos = widget->style->ythickness;
547 pbar->activity_dir = 0;
551 pbar->activity_pos = widget->allocation.height -
552 widget->style->ythickness - (widget->allocation.width -
553 widget->style->xthickness * 2);
554 pbar->activity_dir = 1;
560 gtk_progress_bar_paint (GtkProgress *progress)
562 GtkProgressBar *pbar;
565 gint block_delta = 0;
573 g_return_if_fail (GTK_IS_PROGRESS_BAR (progress));
575 pbar = GTK_PROGRESS_BAR (progress);
576 widget = GTK_WIDGET (progress);
578 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
579 pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
580 space = widget->allocation.width -
581 2 * widget->style->xthickness;
583 space = widget->allocation.height -
584 2 * widget->style->ythickness;
586 percentage = gtk_progress_get_current_percentage (progress);
588 if (progress->offscreen_pixmap)
590 gtk_paint_box (widget->style,
591 progress->offscreen_pixmap,
592 GTK_STATE_NORMAL, GTK_SHADOW_IN,
593 NULL, widget, "trough",
595 widget->allocation.width,
596 widget->allocation.height);
598 if (progress->activity_mode)
600 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
601 pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
603 size = MAX (2, widget->allocation.width / pbar->activity_blocks);
605 gtk_paint_box (widget->style,
606 progress->offscreen_pixmap,
607 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
610 widget->style->ythickness,
612 widget->allocation.height - widget->style->ythickness * 2);
617 size = MAX (2, widget->allocation.height / pbar->activity_blocks);
619 gtk_paint_box (widget->style,
620 progress->offscreen_pixmap,
621 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
623 widget->style->xthickness,
625 widget->allocation.width - widget->style->xthickness * 2,
631 amount = percentage * space;
635 switch (pbar->orientation)
638 case GTK_PROGRESS_LEFT_TO_RIGHT:
640 if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
642 gtk_paint_box (widget->style,
643 progress->offscreen_pixmap,
644 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
646 widget->style->xthickness,
647 widget->style->ythickness,
649 widget->allocation.height - widget->style->ythickness * 2);
653 x = widget->style->xthickness;
655 for (i = 0; i <= pbar->in_block; i++)
657 block_delta = (((i + 1) * space) / pbar->blocks)
658 - ((i * space) / pbar->blocks);
660 gtk_paint_box (widget->style,
661 progress->offscreen_pixmap,
662 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
665 widget->style->ythickness,
667 widget->allocation.height - widget->style->ythickness * 2);
674 case GTK_PROGRESS_RIGHT_TO_LEFT:
676 if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
678 gtk_paint_box (widget->style,
679 progress->offscreen_pixmap,
680 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
682 widget->allocation.width -
683 widget->style->xthickness - amount,
684 widget->style->ythickness,
686 widget->allocation.height -
687 widget->style->ythickness * 2);
691 x = widget->allocation.width -
692 widget->style->xthickness;
694 for (i = 0; i <= pbar->in_block; i++)
696 block_delta = (((i + 1) * space) / pbar->blocks) -
697 ((i * space) / pbar->blocks);
701 gtk_paint_box (widget->style,
702 progress->offscreen_pixmap,
703 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
706 widget->style->ythickness,
708 widget->allocation.height -
709 widget->style->ythickness * 2);
714 case GTK_PROGRESS_BOTTOM_TO_TOP:
716 if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
718 gtk_paint_box (widget->style,
719 progress->offscreen_pixmap,
720 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
722 widget->style->xthickness,
723 widget->allocation.height -
724 widget->style->ythickness - amount,
725 widget->allocation.width -
726 widget->style->xthickness * 2,
731 y = widget->allocation.height -
732 widget->style->ythickness;
734 for (i = 0; i <= pbar->in_block; i++)
736 block_delta = (((i + 1) * space) / pbar->blocks) -
737 ((i * space) / pbar->blocks);
741 gtk_paint_box (widget->style,
742 progress->offscreen_pixmap,
743 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
745 widget->style->xthickness,
747 widget->allocation.width -
748 widget->style->xthickness * 2,
754 case GTK_PROGRESS_TOP_TO_BOTTOM:
756 if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
758 gtk_paint_box (widget->style,
759 progress->offscreen_pixmap,
760 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
762 widget->style->xthickness,
763 widget->style->ythickness,
764 widget->allocation.width -
765 widget->style->xthickness * 2,
770 y = widget->style->ythickness;
772 for (i = 0; i <= pbar->in_block; i++)
775 block_delta = (((i + 1) * space) / pbar->blocks)
776 - ((i * space) / pbar->blocks);
778 gtk_paint_box (widget->style,
779 progress->offscreen_pixmap,
780 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
782 widget->style->xthickness,
784 widget->allocation.width -
785 widget->style->xthickness * 2,
798 if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
805 PangoRectangle logical_rect;
807 buf = gtk_progress_get_current_text (progress);
809 layout = gtk_widget_create_pango_layout (widget, buf);
810 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
812 x = widget->style->xthickness + 1 +
813 (widget->allocation.width - 2 * widget->style->xthickness -
814 3 - logical_rect.width)
817 y = widget->style->ythickness + 1 +
818 (widget->allocation.height - 2 * widget->style->ythickness -
819 3 - logical_rect.height)
822 rect.x = widget->style->xthickness + 1;
823 rect.y = widget->style->ythickness + 1;
824 rect.width = widget->allocation.width -
825 2 * widget->style->xthickness - 3;
826 rect.height = widget->allocation.height -
827 2 * widget->style->ythickness - 3;
829 gtk_paint_layout (widget->style,
830 progress->offscreen_pixmap,
831 GTK_WIDGET_STATE (widget),
839 g_object_unref (G_OBJECT (layout));
845 /*******************************************************************/
848 * gtk_progress_bar_set_fraction:
849 * @pbar: a #GtkProgressBar
850 * @fraction: fraction of the task that's been completed
852 * Causes the progress bar to "fill in" the given fraction
853 * of the bar. The fraction should be between 0.0 and 1.0,
858 gtk_progress_bar_set_fraction (GtkProgressBar *pbar,
861 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
863 /* If we know the percentage, we don't want activity mode. */
864 gtk_progress_set_activity_mode (GTK_PROGRESS (pbar), FALSE);
866 /* We use the deprecated GtkProgress interface internally.
867 * Once everything's been deprecated for a good long time,
868 * we can clean up all this code.
870 gtk_progress_set_percentage (GTK_PROGRESS (pbar), fraction);
872 g_object_notify (G_OBJECT (pbar), "fraction");
876 * gtk_progress_bar_pulse:
877 * @pbar: a #GtkProgressBar
879 * Indicates that some progress is made, but you don't know how much.
880 * Causes the progress bar to enter "activity mode," where a block
881 * bounces back and forth. Each call to gtk_progress_bar_pulse()
882 * causes the block to move by a little bit (the amount of movement
883 * per pulse is determined by gtk_progress_bar_set_pulse_step()).
886 gtk_progress_bar_pulse (GtkProgressBar *pbar)
888 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
890 /* If we don't know the percentage, we must want activity mode. */
891 gtk_progress_set_activity_mode (GTK_PROGRESS (pbar), TRUE);
894 gtk_progress_bar_real_update (GTK_PROGRESS (pbar));
898 * gtk_progress_bar_set_text:
899 * @pbar: a #GtkProgressBar
900 * @text: a UTF-8 string
902 * Causes the given @text to appear superimposed on the progress bar.
905 gtk_progress_bar_set_text (GtkProgressBar *pbar,
908 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
912 gtk_progress_set_show_text (GTK_PROGRESS (pbar), TRUE);
913 gtk_progress_set_format_string (GTK_PROGRESS (pbar), text);
917 gtk_progress_set_show_text (GTK_PROGRESS (pbar), FALSE);
918 gtk_progress_set_format_string (GTK_PROGRESS (pbar), "");
921 /* We don't support formats in this interface */
922 GTK_PROGRESS (pbar)->use_text_format = FALSE;
924 g_object_notify (G_OBJECT (pbar), "text");
928 * gtk_progress_bar_set_pulse_step:
929 * @pbar: a #GtkProgressBar
930 * @fraction: fraction between 0.0 and 1.0
932 * Sets the fraction of total progress bar length to move the
933 * bouncing block for each call to gtk_progress_bar_pulse().
936 gtk_progress_bar_set_pulse_step (GtkProgressBar *pbar,
939 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
941 pbar->pulse_fraction = fraction;
943 g_object_notify (G_OBJECT (pbar), "pulse_step");
947 gtk_progress_bar_update (GtkProgressBar *pbar,
950 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
952 /* Use of gtk_progress_bar_update() is deprecated !
953 * Use gtk_progress_bar_set_percentage ()
956 gtk_progress_set_percentage (GTK_PROGRESS (pbar), percentage);
960 * gtk_progress_bar_set_orientation:
961 * @pbar: a #GtkProgressBar
962 * @orientation: orientation of the progress bar
964 * Causes the progress bar to switch to a different orientation
965 * (left-to-right, right-to-left, top-to-bottom, or bottom-to-top).
968 gtk_progress_bar_set_orientation (GtkProgressBar *pbar,
969 GtkProgressBarOrientation orientation)
971 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
973 if (pbar->orientation != orientation)
975 pbar->orientation = orientation;
977 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
978 gtk_widget_queue_resize (GTK_WIDGET (pbar));
980 g_object_notify (G_OBJECT (pbar), "orientation");
985 * gtk_progress_bar_get_text:
986 * @pbar: a #GtkProgressBar
988 * Retrieves the text displayed superimposed on the progress bar,
989 * if any, otherwise %NULL. The return value is a reference
990 * to the text, not a copy of it, so will become invalid
991 * if you change the text in the progress bar.
993 * Return value: text, or %NULL; don't free the string
995 G_CONST_RETURN gchar*
996 gtk_progress_bar_get_text (GtkProgressBar *pbar)
998 g_return_val_if_fail (GTK_IS_PROGRESS_BAR (pbar), NULL);
1000 if (GTK_PROGRESS (pbar)->use_text_format)
1003 return GTK_PROGRESS (pbar)->format;
1007 * gtk_progress_bar_get_fraction:
1008 * @pbar: a #GtkProgressBar
1010 * Returns the current fraction of the task that's been completed.
1012 * Return value: a fraction from 0.0 to 1.0
1015 gtk_progress_bar_get_fraction (GtkProgressBar *pbar)
1017 g_return_val_if_fail (GTK_IS_PROGRESS_BAR (pbar), 0);
1019 return gtk_progress_get_current_percentage (GTK_PROGRESS (pbar));
1023 * gtk_progress_bar_get_pulse_step:
1024 * @pbar: a #GtkProgressBar
1026 * Retrieves the pulse step set with gtk_progress_bar_set_pulse_step()
1028 * Return value: a fraction from 0.0 to 1.0
1031 gtk_progress_bar_get_pulse_step (GtkProgressBar *pbar)
1033 g_return_val_if_fail (GTK_IS_PROGRESS_BAR (pbar), 0);
1035 return pbar->pulse_fraction;
1039 * gtk_progress_bar_get_orientation:
1040 * @pbar: a #GtkProgressBar
1042 * Retrieves the current progress bar orientation.
1044 * Return value: orientation of the progress bar
1046 GtkProgressBarOrientation
1047 gtk_progress_bar_get_orientation (GtkProgressBar *pbar)
1049 g_return_val_if_fail (GTK_IS_PROGRESS_BAR (pbar), 0);
1051 return pbar->orientation;
1055 gtk_progress_bar_set_bar_style (GtkProgressBar *pbar,
1056 GtkProgressBarStyle bar_style)
1058 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
1060 if (pbar->bar_style != bar_style)
1062 pbar->bar_style = bar_style;
1064 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
1065 gtk_widget_queue_resize (GTK_WIDGET (pbar));
1067 g_object_notify (G_OBJECT (pbar), "bar_style");
1072 gtk_progress_bar_set_discrete_blocks (GtkProgressBar *pbar,
1075 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
1076 g_return_if_fail (blocks > 1);
1078 if (pbar->blocks != blocks)
1080 pbar->blocks = blocks;
1082 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
1083 gtk_widget_queue_resize (GTK_WIDGET (pbar));
1085 g_object_notify (G_OBJECT (pbar), "discrete_blocks");
1090 gtk_progress_bar_set_activity_step (GtkProgressBar *pbar,
1093 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
1095 if (pbar->activity_step != step)
1097 pbar->activity_step = step;
1098 g_object_notify (G_OBJECT (pbar), "activity_step");
1103 gtk_progress_bar_set_activity_blocks (GtkProgressBar *pbar,
1106 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
1107 g_return_if_fail (blocks > 1);
1109 if (pbar->activity_blocks != blocks)
1111 pbar->activity_blocks = blocks;
1112 g_object_notify (G_OBJECT (pbar), "activity_blocks");