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 direction 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, 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 if (!progress->adjustment)
463 gtk_progress_set_adjustment (progress, NULL);
465 buf = gtk_progress_get_text_from_value (progress, progress->adjustment->upper);
467 layout = gtk_widget_create_pango_layout (widget, buf);
468 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
470 g_object_unref (G_OBJECT (layout));
474 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
475 pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
477 if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
479 requisition->width = MAX (MIN_HORIZONTAL_BAR_WIDTH,
480 2 * widget->style->xthickness + 3 +
481 logical_rect.width + 2 * TEXT_SPACING);
483 requisition->height = MAX (MIN_HORIZONTAL_BAR_HEIGHT,
484 2 * widget->style->ythickness + 3 +
485 logical_rect.height + 2 * TEXT_SPACING);
489 requisition->width = MIN_HORIZONTAL_BAR_WIDTH;
490 requisition->height = MIN_HORIZONTAL_BAR_HEIGHT;
495 if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
497 requisition->width = MAX (MIN_VERTICAL_BAR_WIDTH,
498 2 * widget->style->xthickness + 3 +
499 logical_rect.width + 2 * TEXT_SPACING);
501 requisition->height = MAX (MIN_VERTICAL_BAR_HEIGHT,
502 2 * widget->style->ythickness + 3 +
503 logical_rect.height + 2 * TEXT_SPACING);
507 requisition->width = MIN_VERTICAL_BAR_WIDTH;
508 requisition->height = MIN_VERTICAL_BAR_HEIGHT;
514 gtk_progress_bar_act_mode_enter (GtkProgress *progress)
516 GtkProgressBar *pbar;
520 pbar = GTK_PROGRESS_BAR (progress);
521 widget = GTK_WIDGET (progress);
523 /* calculate start pos */
525 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
526 pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
528 size = MAX (2, widget->allocation.width / pbar->activity_blocks);
530 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT)
532 pbar->activity_pos = widget->style->xthickness;
533 pbar->activity_dir = 0;
537 pbar->activity_pos = widget->allocation.width -
538 widget->style->xthickness - (widget->allocation.height -
539 widget->style->ythickness * 2);
540 pbar->activity_dir = 1;
545 size = MAX (2, widget->allocation.height / pbar->activity_blocks);
547 if (pbar->orientation == GTK_PROGRESS_TOP_TO_BOTTOM)
549 pbar->activity_pos = widget->style->ythickness;
550 pbar->activity_dir = 0;
554 pbar->activity_pos = widget->allocation.height -
555 widget->style->ythickness - (widget->allocation.width -
556 widget->style->xthickness * 2);
557 pbar->activity_dir = 1;
563 gtk_progress_bar_paint (GtkProgress *progress)
565 GtkProgressBar *pbar;
568 gint block_delta = 0;
576 g_return_if_fail (GTK_IS_PROGRESS_BAR (progress));
578 pbar = GTK_PROGRESS_BAR (progress);
579 widget = GTK_WIDGET (progress);
581 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
582 pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
583 space = widget->allocation.width -
584 2 * widget->style->xthickness;
586 space = widget->allocation.height -
587 2 * widget->style->ythickness;
589 percentage = gtk_progress_get_current_percentage (progress);
591 if (progress->offscreen_pixmap)
593 gtk_paint_box (widget->style,
594 progress->offscreen_pixmap,
595 GTK_STATE_NORMAL, GTK_SHADOW_IN,
596 NULL, widget, "trough",
598 widget->allocation.width,
599 widget->allocation.height);
601 if (progress->activity_mode)
603 if (pbar->orientation == GTK_PROGRESS_LEFT_TO_RIGHT ||
604 pbar->orientation == GTK_PROGRESS_RIGHT_TO_LEFT)
606 size = MAX (2, widget->allocation.width / pbar->activity_blocks);
608 gtk_paint_box (widget->style,
609 progress->offscreen_pixmap,
610 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
613 widget->style->ythickness,
615 widget->allocation.height - widget->style->ythickness * 2);
620 size = MAX (2, widget->allocation.height / pbar->activity_blocks);
622 gtk_paint_box (widget->style,
623 progress->offscreen_pixmap,
624 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
626 widget->style->xthickness,
628 widget->allocation.width - widget->style->xthickness * 2,
634 amount = percentage * space;
638 switch (pbar->orientation)
641 case GTK_PROGRESS_LEFT_TO_RIGHT:
643 if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
645 gtk_paint_box (widget->style,
646 progress->offscreen_pixmap,
647 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
649 widget->style->xthickness,
650 widget->style->ythickness,
652 widget->allocation.height - widget->style->ythickness * 2);
656 x = widget->style->xthickness;
658 for (i = 0; i <= pbar->in_block; i++)
660 block_delta = (((i + 1) * space) / pbar->blocks)
661 - ((i * space) / pbar->blocks);
663 gtk_paint_box (widget->style,
664 progress->offscreen_pixmap,
665 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
668 widget->style->ythickness,
670 widget->allocation.height - widget->style->ythickness * 2);
677 case GTK_PROGRESS_RIGHT_TO_LEFT:
679 if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
681 gtk_paint_box (widget->style,
682 progress->offscreen_pixmap,
683 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
685 widget->allocation.width -
686 widget->style->xthickness - amount,
687 widget->style->ythickness,
689 widget->allocation.height -
690 widget->style->ythickness * 2);
694 x = widget->allocation.width -
695 widget->style->xthickness;
697 for (i = 0; i <= pbar->in_block; i++)
699 block_delta = (((i + 1) * space) / pbar->blocks) -
700 ((i * space) / pbar->blocks);
704 gtk_paint_box (widget->style,
705 progress->offscreen_pixmap,
706 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
709 widget->style->ythickness,
711 widget->allocation.height -
712 widget->style->ythickness * 2);
717 case GTK_PROGRESS_BOTTOM_TO_TOP:
719 if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
721 gtk_paint_box (widget->style,
722 progress->offscreen_pixmap,
723 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
725 widget->style->xthickness,
726 widget->allocation.height -
727 widget->style->ythickness - amount,
728 widget->allocation.width -
729 widget->style->xthickness * 2,
734 y = widget->allocation.height -
735 widget->style->ythickness;
737 for (i = 0; i <= pbar->in_block; i++)
739 block_delta = (((i + 1) * space) / pbar->blocks) -
740 ((i * space) / pbar->blocks);
744 gtk_paint_box (widget->style,
745 progress->offscreen_pixmap,
746 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
748 widget->style->xthickness,
750 widget->allocation.width -
751 widget->style->xthickness * 2,
757 case GTK_PROGRESS_TOP_TO_BOTTOM:
759 if (pbar->bar_style == GTK_PROGRESS_CONTINUOUS)
761 gtk_paint_box (widget->style,
762 progress->offscreen_pixmap,
763 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
765 widget->style->xthickness,
766 widget->style->ythickness,
767 widget->allocation.width -
768 widget->style->xthickness * 2,
773 y = widget->style->ythickness;
775 for (i = 0; i <= pbar->in_block; i++)
778 block_delta = (((i + 1) * space) / pbar->blocks)
779 - ((i * space) / pbar->blocks);
781 gtk_paint_box (widget->style,
782 progress->offscreen_pixmap,
783 GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
785 widget->style->xthickness,
787 widget->allocation.width -
788 widget->style->xthickness * 2,
801 if (progress->show_text && pbar->bar_style != GTK_PROGRESS_DISCRETE)
808 PangoRectangle logical_rect;
810 buf = gtk_progress_get_current_text (progress);
812 layout = gtk_widget_create_pango_layout (widget, buf);
813 pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
815 x = widget->style->xthickness + 1 +
816 (widget->allocation.width - 2 * widget->style->xthickness -
817 3 - logical_rect.width)
820 y = widget->style->ythickness + 1 +
821 (widget->allocation.height - 2 * widget->style->ythickness -
822 3 - logical_rect.height)
825 rect.x = widget->style->xthickness + 1;
826 rect.y = widget->style->ythickness + 1;
827 rect.width = widget->allocation.width -
828 2 * widget->style->xthickness - 3;
829 rect.height = widget->allocation.height -
830 2 * widget->style->ythickness - 3;
832 gtk_paint_layout (widget->style,
833 progress->offscreen_pixmap,
834 GTK_WIDGET_STATE (widget),
842 g_object_unref (G_OBJECT (layout));
848 /*******************************************************************/
851 * gtk_progress_bar_set_fraction:
852 * @pbar: a #GtkProgressBar
853 * @fraction: fraction of the task that's been completed
855 * Causes the progress bar to "fill in" the given fraction
856 * of the bar. The fraction should be between 0.0 and 1.0,
861 gtk_progress_bar_set_fraction (GtkProgressBar *pbar,
864 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
866 /* If we know the percentage, we don't want activity mode. */
867 gtk_progress_set_activity_mode (GTK_PROGRESS (pbar), FALSE);
869 /* We use the deprecated GtkProgress interface internally.
870 * Once everything's been deprecated for a good long time,
871 * we can clean up all this code.
873 gtk_progress_set_percentage (GTK_PROGRESS (pbar), fraction);
875 g_object_notify (G_OBJECT (pbar), "fraction");
879 * gtk_progress_bar_pulse:
880 * @pbar: a #GtkProgressBar
882 * Indicates that some progress is made, but you don't know how much.
883 * Causes the progress bar to enter "activity mode," where a block
884 * bounces back and forth. Each call to gtk_progress_bar_pulse()
885 * causes the block to move by a little bit (the amount of movement
886 * per pulse is determined by gtk_progress_bar_set_pulse_step()).
889 gtk_progress_bar_pulse (GtkProgressBar *pbar)
891 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
893 /* If we don't know the percentage, we must want activity mode. */
894 gtk_progress_set_activity_mode (GTK_PROGRESS (pbar), TRUE);
897 gtk_progress_bar_real_update (GTK_PROGRESS (pbar));
901 * gtk_progress_bar_set_text:
902 * @pbar: a #GtkProgressBar
903 * @text: a UTF-8 string
905 * Causes the given @text to appear superimposed on the progress bar.
908 gtk_progress_bar_set_text (GtkProgressBar *pbar,
911 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
915 gtk_progress_set_show_text (GTK_PROGRESS (pbar), TRUE);
916 gtk_progress_set_format_string (GTK_PROGRESS (pbar), text);
920 gtk_progress_set_show_text (GTK_PROGRESS (pbar), FALSE);
921 gtk_progress_set_format_string (GTK_PROGRESS (pbar), "");
924 /* We don't support formats in this interface */
925 GTK_PROGRESS (pbar)->use_text_format = FALSE;
927 g_object_notify (G_OBJECT (pbar), "text");
931 * gtk_progress_bar_set_pulse_step:
932 * @pbar: a #GtkProgressBar
933 * @fraction: fraction between 0.0 and 1.0
935 * Sets the fraction of total progress bar length to move the
936 * bouncing block for each call to gtk_progress_bar_pulse().
939 gtk_progress_bar_set_pulse_step (GtkProgressBar *pbar,
942 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
944 pbar->pulse_fraction = fraction;
946 g_object_notify (G_OBJECT (pbar), "pulse_step");
950 gtk_progress_bar_update (GtkProgressBar *pbar,
953 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
955 /* Use of gtk_progress_bar_update() is deprecated !
956 * Use gtk_progress_bar_set_percentage ()
959 gtk_progress_set_percentage (GTK_PROGRESS (pbar), percentage);
963 * gtk_progress_bar_set_orientation:
964 * @pbar: a #GtkProgressBar
965 * @orientation: orientation of the progress bar
967 * Causes the progress bar to switch to a different orientation
968 * (left-to-right, right-to-left, top-to-bottom, or bottom-to-top).
971 gtk_progress_bar_set_orientation (GtkProgressBar *pbar,
972 GtkProgressBarOrientation orientation)
974 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
976 if (pbar->orientation != orientation)
978 pbar->orientation = orientation;
980 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
981 gtk_widget_queue_resize (GTK_WIDGET (pbar));
983 g_object_notify (G_OBJECT (pbar), "orientation");
988 * gtk_progress_bar_get_text:
989 * @pbar: a #GtkProgressBar
991 * Retrieves the text displayed superimposed on the progress bar,
992 * if any, otherwise %NULL. The return value is a reference
993 * to the text, not a copy of it, so will become invalid
994 * if you change the text in the progress bar.
996 * Return value: text, or %NULL; this string is owned by the widget
997 * and should not be modified or freed.
999 G_CONST_RETURN gchar*
1000 gtk_progress_bar_get_text (GtkProgressBar *pbar)
1002 g_return_val_if_fail (GTK_IS_PROGRESS_BAR (pbar), NULL);
1004 if (GTK_PROGRESS (pbar)->use_text_format)
1007 return GTK_PROGRESS (pbar)->format;
1011 * gtk_progress_bar_get_fraction:
1012 * @pbar: a #GtkProgressBar
1014 * Returns the current fraction of the task that's been completed.
1016 * Return value: a fraction from 0.0 to 1.0
1019 gtk_progress_bar_get_fraction (GtkProgressBar *pbar)
1021 g_return_val_if_fail (GTK_IS_PROGRESS_BAR (pbar), 0);
1023 return gtk_progress_get_current_percentage (GTK_PROGRESS (pbar));
1027 * gtk_progress_bar_get_pulse_step:
1028 * @pbar: a #GtkProgressBar
1030 * Retrieves the pulse step set with gtk_progress_bar_set_pulse_step()
1032 * Return value: a fraction from 0.0 to 1.0
1035 gtk_progress_bar_get_pulse_step (GtkProgressBar *pbar)
1037 g_return_val_if_fail (GTK_IS_PROGRESS_BAR (pbar), 0);
1039 return pbar->pulse_fraction;
1043 * gtk_progress_bar_get_orientation:
1044 * @pbar: a #GtkProgressBar
1046 * Retrieves the current progress bar orientation.
1048 * Return value: orientation of the progress bar
1050 GtkProgressBarOrientation
1051 gtk_progress_bar_get_orientation (GtkProgressBar *pbar)
1053 g_return_val_if_fail (GTK_IS_PROGRESS_BAR (pbar), 0);
1055 return pbar->orientation;
1059 gtk_progress_bar_set_bar_style (GtkProgressBar *pbar,
1060 GtkProgressBarStyle bar_style)
1062 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
1064 if (pbar->bar_style != bar_style)
1066 pbar->bar_style = bar_style;
1068 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
1069 gtk_widget_queue_resize (GTK_WIDGET (pbar));
1071 g_object_notify (G_OBJECT (pbar), "bar_style");
1076 gtk_progress_bar_set_discrete_blocks (GtkProgressBar *pbar,
1079 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
1080 g_return_if_fail (blocks > 1);
1082 if (pbar->blocks != blocks)
1084 pbar->blocks = blocks;
1086 if (GTK_WIDGET_DRAWABLE (GTK_WIDGET (pbar)))
1087 gtk_widget_queue_resize (GTK_WIDGET (pbar));
1089 g_object_notify (G_OBJECT (pbar), "discrete_blocks");
1094 gtk_progress_bar_set_activity_step (GtkProgressBar *pbar,
1097 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
1099 if (pbar->activity_step != step)
1101 pbar->activity_step = step;
1102 g_object_notify (G_OBJECT (pbar), "activity_step");
1107 gtk_progress_bar_set_activity_blocks (GtkProgressBar *pbar,
1110 g_return_if_fail (GTK_IS_PROGRESS_BAR (pbar));
1111 g_return_if_fail (blocks > 1);
1113 if (pbar->activity_blocks != blocks)
1115 pbar->activity_blocks = blocks;
1116 g_object_notify (G_OBJECT (pbar), "activity_blocks");