AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity

Get rid of GtkProgress

Browse Source 
The entire api was deprecated since 2.0. This patch detangles
GtkProgress from GtkProgressBar and moves all the pieces into
GtkProgressBar that are required for non-deprecated progressbar
functionality.

Bug #620618
This commit is contained in:
Matthias Clasen 2010-06-09 00:29:55 -04:00
parent 882660e13d
commit 5e0dfed135
11 changed files with 570 additions and 1452 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
docs/reference/gtk/gtk3-sections.txt
View File

@ -2344,52 +2344,25 @@ GTK_PLUG_GET_CLASS
gtk_plug_get_type gtk_plug_get_type
</SECTION> </SECTION>
<SECTION>
<FILE>gtkprogress</FILE>
<TITLE>GtkProgress</TITLE>
GtkProgress
gtk_progress_set_show_text
gtk_progress_set_text_alignment
gtk_progress_set_format_string
gtk_progress_set_adjustment
gtk_progress_set_percentage
gtk_progress_set_value
gtk_progress_get_value
gtk_progress_set_activity_mode
gtk_progress_get_current_text
gtk_progress_get_text_from_value
gtk_progress_get_current_percentage
gtk_progress_get_percentage_from_value
gtk_progress_configure
<SUBSECTION Standard>
GTK_PROGRESS
GTK_IS_PROGRESS
GTK_TYPE_PROGRESS
GTK_PROGRESS_CLASS
GTK_IS_PROGRESS_CLASS
GTK_PROGRESS_GET_CLASS
<SUBSECTION Private>
gtk_progress_get_type
</SECTION>
<SECTION> <SECTION>
<FILE>gtkprogressbar</FILE> <FILE>gtkprogressbar</FILE>
<TITLE>GtkProgressBar</TITLE> <TITLE>GtkProgressBar</TITLE>
GtkProgressBar GtkProgressBar
gtk_progress_bar_new gtk_progress_bar_new
gtk_progress_bar_pulse gtk_progress_bar_pulse
gtk_progress_bar_set_text
gtk_progress_bar_set_fraction gtk_progress_bar_set_fraction
gtk_progress_bar_set_pulse_step
gtk_progress_bar_set_orientation
gtk_progress_bar_set_ellipsize
GtkProgressBarOrientation
gtk_progress_bar_get_text
gtk_progress_bar_get_fraction gtk_progress_bar_get_fraction
gtk_progress_bar_get_pulse_step GtkProgressBarOrientation
gtk_progress_bar_set_orientation
gtk_progress_bar_get_orientation gtk_progress_bar_get_orientation
gtk_progress_bar_set_show_text
gtk_progress_bar_get_show_text
gtk_progress_bar_set_text
gtk_progress_bar_get_text
gtk_progress_bar_set_ellipsize
gtk_progress_bar_get_ellipsize gtk_progress_bar_get_ellipsize
GtkProgressBarStyle gtk_progress_bar_set_pulse_step
gtk_progress_bar_get_pulse_step
<SUBSECTION Standard> <SUBSECTION Standard>
GTK_PROGRESS_BAR GTK_PROGRESS_BAR
GTK_IS_PROGRESS_BAR GTK_IS_PROGRESS_BAR

1
docs/reference/gtk/gtk3.types
View File

@ -111,7 +111,6 @@ gtk_print_operation_preview_get_type
gtk_print_settings_get_type gtk_print_settings_get_type
gtk_print_unix_dialog_get_type gtk_print_unix_dialog_get_type
gtk_progress_bar_get_type gtk_progress_bar_get_type
gtk_progress_get_type
gtk_radio_action_get_type gtk_radio_action_get_type
gtk_radio_button_get_type gtk_radio_button_get_type
gtk_radio_menu_item_get_type gtk_radio_menu_item_get_type

6
gtk/Makefile.am
View File

@ -634,12 +634,6 @@ gtk_base_c_sources = \
gtkwindow.c \ gtkwindow.c \
$(gtk_clipboard_dnd_c_sources) $(gtk_clipboard_dnd_c_sources)
# Deprecated
gtk_public_h_sources += \
gtkprogress.h
gtk_base_c_sources += \
gtkprogress.c
gtk_c_sources = $(gtk_base_c_sources) gtk_c_sources = $(gtk_base_c_sources)
gtk_all_c_sources = $(gtk_base_c_sources) gtk_all_c_sources = $(gtk_base_c_sources)

23
gtk/gtk.symbols
View File

@ -365,7 +365,6 @@ gtk_recent_filter_flags_get_type G_GNUC_CONST
gtk_print_operation_action_get_type G_GNUC_CONST gtk_print_operation_action_get_type G_GNUC_CONST
gtk_private_flags_get_type G_GNUC_CONST gtk_private_flags_get_type G_GNUC_CONST
gtk_progress_bar_orientation_get_type G_GNUC_CONST gtk_progress_bar_orientation_get_type G_GNUC_CONST
gtk_progress_bar_style_get_type G_GNUC_CONST
gtk_rc_flags_get_type G_GNUC_CONST gtk_rc_flags_get_type G_GNUC_CONST
gtk_rc_token_type_get_type G_GNUC_CONST gtk_rc_token_type_get_type G_GNUC_CONST
gtk_recent_chooser_error_get_type G_GNUC_CONST gtk_recent_chooser_error_get_type G_GNUC_CONST
@ -2676,26 +2675,6 @@ gtk_print_win32_devnames_from_printer_name
#endif #endif
#endif #endif
#if IN_HEADER(__GTK_PROGRESS_H__)
#if IN_FILE(__GTK_PROGRESS_C__)
#ifndef GTK_DISABLE_DEPRECATED
gtk_progress_configure
gtk_progress_get_current_percentage
gtk_progress_get_current_text
gtk_progress_get_percentage_from_value
gtk_progress_get_text_from_value
gtk_progress_get_type
gtk_progress_get_value
gtk_progress_set_activity_mode
gtk_progress_set_adjustment
gtk_progress_set_format_string
gtk_progress_set_percentage
gtk_progress_set_show_text
gtk_progress_set_text_alignment
gtk_progress_set_value
#endif
#endif
#endif
#if IN_HEADER(__GTK_PROGRESS_BAR_H__) #if IN_HEADER(__GTK_PROGRESS_BAR_H__)
#if IN_FILE(__GTK_PROGRESS_BAR_C__) #if IN_FILE(__GTK_PROGRESS_BAR_C__)
@ -2712,6 +2691,8 @@ gtk_progress_bar_set_orientation
gtk_progress_bar_set_pulse_step gtk_progress_bar_set_pulse_step
gtk_progress_bar_set_text gtk_progress_bar_set_text
gtk_progress_bar_set_ellipsize gtk_progress_bar_set_ellipsize
gtk_progress_bar_set_show_text
gtk_progress_bar_get_show_text
#endif #endif
#endif #endif

713
gtk/gtkprogress.c
View File

@ -1,713 +0,0 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "config.h"
#include <math.h>
#include <string.h>
#undef GTK_DISABLE_DEPRECATED
#define __GTK_PROGRESS_C__
#include "gtkprogress.h"
#include "gtkprivate.h"
#include "gtkintl.h"
#include "gtkalias.h"
#define EPSILON 1e-5
#define DEFAULT_FORMAT "%P %%"
enum {
PROP_0,
PROP_ACTIVITY_MODE,
PROP_SHOW_TEXT,
PROP_TEXT_XALIGN,
PROP_TEXT_YALIGN
};
static void gtk_progress_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gtk_progress_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void gtk_progress_destroy (GtkObject *object);
static void gtk_progress_finalize (GObject *object);
static void gtk_progress_realize (GtkWidget *widget);
static gboolean gtk_progress_expose (GtkWidget *widget,
GdkEventExpose *event);
static void gtk_progress_size_allocate (GtkWidget *widget,
GtkAllocation *allocation);
static void gtk_progress_create_pixmap (GtkProgress *progress);
static void gtk_progress_value_changed (GtkAdjustment *adjustment,
GtkProgress *progress);
static void gtk_progress_changed (GtkAdjustment *adjustment,
GtkProgress *progress);
G_DEFINE_ABSTRACT_TYPE (GtkProgress, gtk_progress, GTK_TYPE_WIDGET)
static void
gtk_progress_class_init (GtkProgressClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS (class);
GtkObjectClass *object_class;
GtkWidgetClass *widget_class;
object_class = (GtkObjectClass *) class;
widget_class = (GtkWidgetClass *) class;
gobject_class->finalize = gtk_progress_finalize;
gobject_class->set_property = gtk_progress_set_property;
gobject_class->get_property = gtk_progress_get_property;
object_class->destroy = gtk_progress_destroy;
widget_class->realize = gtk_progress_realize;
widget_class->expose_event = gtk_progress_expose;
widget_class->size_allocate = gtk_progress_size_allocate;
/* to be overridden */
class->paint = NULL;
class->update = NULL;
class->act_mode_enter = NULL;
g_object_class_install_property (gobject_class,
PROP_ACTIVITY_MODE,
g_param_spec_boolean ("activity-mode",
P_("Activity mode"),
P_("If TRUE, the GtkProgress is in activity mode, meaning that it signals "
"something is happening, but not how much of the activity is finished. "
"This is used when you're doing something but don't know how long it will take."),
FALSE,
GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_SHOW_TEXT,
g_param_spec_boolean ("show-text",
P_("Show text"),
P_("Whether the progress is shown as text."),
FALSE,
GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TEXT_XALIGN,
g_param_spec_float ("text-xalign",
P_("Text x alignment"),
P_("The horizontal text alignment, from 0 (left) to 1 (right). Reversed for RTL layouts."),
0.0, 1.0, 0.5,
GTK_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_TEXT_YALIGN,
g_param_spec_float ("text-yalign",
P_("Text y alignment"),
P_("The vertical text alignment, from 0 (top) to 1 (bottom)."),
0.0, 1.0, 0.5,
GTK_PARAM_READWRITE));
}
static void
gtk_progress_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkProgress *progress;
progress = GTK_PROGRESS (object);
switch (prop_id)
{
case PROP_ACTIVITY_MODE:
gtk_progress_set_activity_mode (progress, g_value_get_boolean (value));
break;
case PROP_SHOW_TEXT:
gtk_progress_set_show_text (progress, g_value_get_boolean (value));
break;
case PROP_TEXT_XALIGN:
gtk_progress_set_text_alignment (progress,
g_value_get_float (value),
progress->y_align);
break;
case PROP_TEXT_YALIGN:
gtk_progress_set_text_alignment (progress,
progress->x_align,
g_value_get_float (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_progress_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkProgress *progress;
progress = GTK_PROGRESS (object);
switch (prop_id)
{
case PROP_ACTIVITY_MODE:
g_value_set_boolean (value, (progress->activity_mode != FALSE));
break;
case PROP_SHOW_TEXT:
g_value_set_boolean (value, (progress->show_text != FALSE));
break;
case PROP_TEXT_XALIGN:
g_value_set_float (value, progress->x_align);
break;
case PROP_TEXT_YALIGN:
g_value_set_float (value, progress->y_align);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gtk_progress_init (GtkProgress *progress)
{
progress->adjustment = NULL;
progress->offscreen_pixmap = NULL;
progress->format = g_strdup (DEFAULT_FORMAT);
progress->x_align = 0.5;
progress->y_align = 0.5;
progress->show_text = FALSE;
progress->activity_mode = FALSE;
progress->use_text_format = TRUE;
}
static void
gtk_progress_realize (GtkWidget *widget)
{
GtkProgress *progress = GTK_PROGRESS (widget);
GdkWindowAttr attributes;
gint attributes_mask;
gtk_widget_set_realized (widget, TRUE);
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;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
&attributes, attributes_mask);
gdk_window_set_user_data (widget->window, progress);
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
gtk_progress_create_pixmap (progress);
}
static void
gtk_progress_destroy (GtkObject *object)
{
GtkProgress *progress = GTK_PROGRESS (object);
if (progress->adjustment)
{
g_signal_handlers_disconnect_by_func (progress->adjustment,
gtk_progress_value_changed,
progress);
g_signal_handlers_disconnect_by_func (progress->adjustment,
gtk_progress_changed,
progress);
g_object_unref (progress->adjustment);
progress->adjustment = NULL;
}
GTK_OBJECT_CLASS (gtk_progress_parent_class)->destroy (object);
}
static void
gtk_progress_finalize (GObject *object)
{
GtkProgress *progress = GTK_PROGRESS (object);
if (progress->offscreen_pixmap)
g_object_unref (progress->offscreen_pixmap);
g_free (progress->format);
G_OBJECT_CLASS (gtk_progress_parent_class)->finalize (object);
}
static gboolean
gtk_progress_expose (GtkWidget *widget,
GdkEventExpose *event)
{
if (gtk_widget_is_drawable (widget))
gdk_draw_drawable (widget->window,
widget->style->black_gc,
GTK_PROGRESS (widget)->offscreen_pixmap,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width,
event->area.height);
return FALSE;
}
static void
gtk_progress_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
widget->allocation = *allocation;
if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);
gtk_progress_create_pixmap (GTK_PROGRESS (widget));
}
}
static void
gtk_progress_create_pixmap (GtkProgress *progress)
{
GtkWidget *widget;
g_return_if_fail (GTK_IS_PROGRESS (progress));
widget = GTK_WIDGET (progress);
if (gtk_widget_get_realized (widget))
{
if (progress->offscreen_pixmap)
g_object_unref (progress->offscreen_pixmap);
progress->offscreen_pixmap = gdk_pixmap_new (widget->window,
widget->allocation.width,
widget->allocation.height,
-1);
/* clear the pixmap for transparent themes */
gtk_paint_flat_box (widget->style,
progress->offscreen_pixmap,
GTK_STATE_NORMAL, GTK_SHADOW_NONE,
NULL, widget, "trough", 0, 0, -1, -1);
GTK_PROGRESS_GET_CLASS (progress)->paint (progress);
}
}
static void
gtk_progress_changed (GtkAdjustment *adjustment,
GtkProgress *progress)
{
/* A change in the value of adjustment->upper can change
* the size request
*/
if (progress->use_text_format && progress->show_text)
gtk_widget_queue_resize (GTK_WIDGET (progress));
else
GTK_PROGRESS_GET_CLASS (progress)->update (progress);
}
static void
gtk_progress_value_changed (GtkAdjustment *adjustment,
GtkProgress *progress)
{
GTK_PROGRESS_GET_CLASS (progress)->update (progress);
}
static gchar *
gtk_progress_build_string (GtkProgress *progress,
gdouble value,
gdouble percentage)
{
gchar buf[256] = { 0 };
gchar tmp[256] = { 0 };
gchar *src;
gchar *dest;
gchar fmt[10];
src = progress->format;
/* This is the new supported version of this function */
if (!progress->use_text_format)
return g_strdup (src);
/* And here's all the deprecated goo. */
dest = buf;
while (src && *src)
{
if (*src != '%')
{
*dest = *src;
dest++;
}
else
{
gchar c;
gint digits;
c = *(src + sizeof(gchar));
digits = 0;
if (c >= '0' && c <= '2')
{
digits = (gint) (c - '0');
src++;
c = *(src + sizeof(gchar));
}
switch (c)
{
case '%':
*dest = '%';
src++;
dest++;
break;
case 'p':
case 'P':
if (digits)
{
g_snprintf (fmt, sizeof (fmt), "%%.%df", digits);
g_snprintf (tmp, sizeof (tmp), fmt, 100 * percentage);
}
else
g_snprintf (tmp, sizeof (tmp), "%.0f", 100 * percentage);
strcat (buf, tmp);
dest = &(buf[strlen (buf)]);
src++;
break;
case 'v':
case 'V':
if (digits)
{
g_snprintf (fmt, sizeof (fmt), "%%.%df", digits);
g_snprintf (tmp, sizeof (tmp), fmt, value);
}
else
g_snprintf (tmp, sizeof (tmp), "%.0f", value);
strcat (buf, tmp);
dest = &(buf[strlen (buf)]);
src++;
break;
case 'l':
case 'L':
if (digits)
{
g_snprintf (fmt, sizeof (fmt), "%%.%df", digits);
g_snprintf (tmp, sizeof (tmp), fmt, progress->adjustment->lower);
}
else
g_snprintf (tmp, sizeof (tmp), "%.0f", progress->adjustment->lower);
strcat (buf, tmp);
dest = &(buf[strlen (buf)]);
src++;
break;
case 'u':
case 'U':
if (digits)
{
g_snprintf (fmt, sizeof (fmt), "%%.%df", digits);
g_snprintf (tmp, sizeof (tmp), fmt, progress->adjustment->upper);
}
else
g_snprintf (tmp, sizeof (tmp), "%.0f", progress->adjustment->upper);
strcat (buf, tmp);
dest = &(buf[strlen (buf)]);
src++;
break;
default:
break;
}
}
src++;
}
return g_strdup (buf);
}
/***************************************************************/
void
gtk_progress_set_adjustment (GtkProgress *progress,
GtkAdjustment *adjustment)
{
g_return_if_fail (GTK_IS_PROGRESS (progress));
if (adjustment)
g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
else
adjustment = (GtkAdjustment*) gtk_adjustment_new (0, 0, 100, 0, 0, 0);
if (progress->adjustment != adjustment)
{
if (progress->adjustment)
{
g_signal_handlers_disconnect_by_func (progress->adjustment,
gtk_progress_changed,
progress);
g_signal_handlers_disconnect_by_func (progress->adjustment,
gtk_progress_value_changed,
progress);
g_object_unref (progress->adjustment);
}
progress->adjustment = adjustment;
if (adjustment)
{
g_object_ref_sink (adjustment);
g_signal_connect (adjustment, "changed",
G_CALLBACK (gtk_progress_changed),
progress);
g_signal_connect (adjustment, "value-changed",
G_CALLBACK (gtk_progress_value_changed),
progress);
}
gtk_progress_changed (adjustment, progress);
}
}
void
gtk_progress_configure (GtkProgress *progress,
gdouble value,
gdouble min,
gdouble max)
{
GtkAdjustment *adj;
gboolean changed = FALSE;
g_return_if_fail (GTK_IS_PROGRESS (progress));
g_return_if_fail (min <= max);
g_return_if_fail (value >= min && value <= max);
if (!progress->adjustment)
gtk_progress_set_adjustment (progress, NULL);
adj = progress->adjustment;
if (fabs (adj->lower - min) > EPSILON || fabs (adj->upper - max) > EPSILON)
changed = TRUE;
adj->value = value;
adj->lower = min;
adj->upper = max;
gtk_adjustment_value_changed (adj);
if (changed)
gtk_adjustment_changed (adj);
}
void
gtk_progress_set_percentage (GtkProgress *progress,
gdouble percentage)
{
g_return_if_fail (GTK_IS_PROGRESS (progress));
g_return_if_fail (percentage >= 0 && percentage <= 1.0);
if (!progress->adjustment)
gtk_progress_set_adjustment (progress, NULL);
gtk_progress_set_value (progress, progress->adjustment->lower + percentage *
(progress->adjustment->upper - progress->adjustment->lower));
}
gdouble
gtk_progress_get_current_percentage (GtkProgress *progress)
{
g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
if (!progress->adjustment)
gtk_progress_set_adjustment (progress, NULL);
return gtk_progress_get_percentage_from_value (progress, progress->adjustment->value);
}
gdouble
gtk_progress_get_percentage_from_value (GtkProgress *progress,
gdouble value)
{
g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
if (!progress->adjustment)
gtk_progress_set_adjustment (progress, NULL);
if (progress->adjustment->lower < progress->adjustment->upper &&
value >= progress->adjustment->lower &&
value <= progress->adjustment->upper)
return (value - progress->adjustment->lower) /
(progress->adjustment->upper - progress->adjustment->lower);
else
return 0.0;
}
void
gtk_progress_set_value (GtkProgress *progress,
gdouble value)
{
g_return_if_fail (GTK_IS_PROGRESS (progress));
if (!progress->adjustment)
gtk_progress_set_adjustment (progress, NULL);
if (fabs (progress->adjustment->value - value) > EPSILON)
gtk_adjustment_set_value (progress->adjustment, value);
}
gdouble
gtk_progress_get_value (GtkProgress *progress)
{
g_return_val_if_fail (GTK_IS_PROGRESS (progress), 0);
return progress->adjustment ? progress->adjustment->value : 0;
}
void
gtk_progress_set_show_text (GtkProgress *progress,
gboolean show_text)
{
g_return_if_fail (GTK_IS_PROGRESS (progress));
if (progress->show_text != show_text)
{
progress->show_text = show_text;
gtk_widget_queue_resize (GTK_WIDGET (progress));
g_object_notify (G_OBJECT (progress), "show-text");
}
}
void
gtk_progress_set_text_alignment (GtkProgress *progress,
gfloat x_align,
gfloat y_align)
{
g_return_if_fail (GTK_IS_PROGRESS (progress));
g_return_if_fail (x_align >= 0.0 && x_align <= 1.0);
g_return_if_fail (y_align >= 0.0 && y_align <= 1.0);
if (progress->x_align != x_align || progress->y_align != y_align)
{
g_object_freeze_notify (G_OBJECT (progress));
if (progress->x_align != x_align)
{
progress->x_align = x_align;
g_object_notify (G_OBJECT (progress), "text-xalign");
}
if (progress->y_align != y_align)
{
progress->y_align = y_align;
g_object_notify (G_OBJECT (progress), "text-yalign");
}
g_object_thaw_notify (G_OBJECT (progress));
if (gtk_widget_is_drawable (GTK_WIDGET (progress)))
gtk_widget_queue_resize (GTK_WIDGET (progress));
}
}
void
gtk_progress_set_format_string (GtkProgress *progress,
const gchar *format)
{
gchar *old_format;
g_return_if_fail (GTK_IS_PROGRESS (progress));
/* Turn on format, in case someone called
* gtk_progress_bar_set_text() and turned it off.
*/
progress->use_text_format = TRUE;
old_format = progress->format;
if (!format)
format = DEFAULT_FORMAT;
progress->format = g_strdup (format);
g_free (old_format);
gtk_widget_queue_resize (GTK_WIDGET (progress));
}
gchar *
gtk_progress_get_current_text (GtkProgress *progress)
{
g_return_val_if_fail (GTK_IS_PROGRESS (progress), NULL);
if (!progress->adjustment)
gtk_progress_set_adjustment (progress, NULL);
return gtk_progress_build_string (progress, progress->adjustment->value,
gtk_progress_get_current_percentage (progress));
}
gchar *
gtk_progress_get_text_from_value (GtkProgress *progress,
gdouble value)
{
g_return_val_if_fail (GTK_IS_PROGRESS (progress), NULL);
if (!progress->adjustment)
gtk_progress_set_adjustment (progress, NULL);
return gtk_progress_build_string (progress, value,
gtk_progress_get_percentage_from_value (progress, value));
}
void
gtk_progress_set_activity_mode (GtkProgress *progress,
gboolean activity_mode)
{
g_return_if_fail (GTK_IS_PROGRESS (progress));
if (progress->activity_mode != (activity_mode != FALSE))
{
progress->activity_mode = (activity_mode != FALSE);
if (progress->activity_mode)
GTK_PROGRESS_GET_CLASS (progress)->act_mode_enter (progress);
if (gtk_widget_is_drawable (GTK_WIDGET (progress)))
gtk_widget_queue_resize (GTK_WIDGET (progress));
g_object_notify (G_OBJECT (progress), "activity-mode");
}
}
#include "gtkaliasdef.c"

120
gtk/gtkprogress.h
View File

@ -1,120 +0,0 @@
/* GTK - The GIMP Toolkit
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#ifndef __GTK_PROGRESS_H__
#define __GTK_PROGRESS_H__
#include <gtk/gtkwidget.h>
#include <gtk/gtkadjustment.h>
G_BEGIN_DECLS
#if !defined (GTK_DISABLE_DEPRECATED) || defined (__GTK_PROGRESS_C__) || defined (__GTK_PROGRESS_BAR_C__)
#define GTK_TYPE_PROGRESS (gtk_progress_get_type ())
#define GTK_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_PROGRESS, GtkProgress))
#define GTK_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_PROGRESS, GtkProgressClass))
#define GTK_IS_PROGRESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_PROGRESS))
#define GTK_IS_PROGRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_PROGRESS))
#define GTK_PROGRESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_PROGRESS, GtkProgressClass))
#endif /* !GTK_DISABLE_DEPRECATED */
typedef struct _GtkProgress GtkProgress;
typedef struct _GtkProgressClass GtkProgressClass;
struct _GtkProgress
{
GtkWidget widget;
GtkAdjustment *adjustment;
GdkPixmap *offscreen_pixmap;
gchar *format;
gfloat x_align;
gfloat y_align;
guint show_text : 1;
guint activity_mode : 1;
guint use_text_format : 1;
};
struct _GtkProgressClass
{
GtkWidgetClass parent_class;
void (* paint) (GtkProgress *progress);
void (* update) (GtkProgress *progress);
void (* act_mode_enter) (GtkProgress *progress);
/* Padding for future expansion */
void (*_gtk_reserved1) (void);
void (*_gtk_reserved2) (void);
void (*_gtk_reserved3) (void);
void (*_gtk_reserved4) (void);
};
/* This entire interface is deprecated. Use GtkProgressBar
* directly.
*/
#if !defined (GTK_DISABLE_DEPRECATED) || defined (__GTK_PROGRESS_C__) || defined (__GTK_PROGRESS_BAR_C__)
GType gtk_progress_get_type (void) G_GNUC_CONST;
void gtk_progress_set_show_text (GtkProgress *progress,
gboolean show_text);
void gtk_progress_set_text_alignment (GtkProgress *progress,
gfloat x_align,
gfloat y_align);
void gtk_progress_set_format_string (GtkProgress *progress,
const gchar *format);
void gtk_progress_set_adjustment (GtkProgress *progress,
GtkAdjustment *adjustment);
void gtk_progress_configure (GtkProgress *progress,
gdouble value,
gdouble min,
gdouble max);
void gtk_progress_set_percentage (GtkProgress *progress,
gdouble percentage);
void gtk_progress_set_value (GtkProgress *progress,
gdouble value);
gdouble gtk_progress_get_value (GtkProgress *progress);
void gtk_progress_set_activity_mode (GtkProgress *progress,
gboolean activity_mode);
gchar* gtk_progress_get_current_text (GtkProgress *progress);
gchar* gtk_progress_get_text_from_value (GtkProgress *progress,
gdouble value);
gdouble gtk_progress_get_current_percentage (GtkProgress *progress);
gdouble gtk_progress_get_percentage_from_value (GtkProgress *progress,
gdouble value);
#endif /* !GTK_DISABLE_DEPRECATED */
G_END_DECLS
#endif /* __GTK_PROGRESS_H__ */

955
gtk/gtkprogressbar.c
View File

File diff suppressed because it is too large Load Diff

34
gtk/gtkprogressbar.h
View File

@ -31,9 +31,7 @@
#ifndef __GTK_PROGRESS_BAR_H__ #ifndef __GTK_PROGRESS_BAR_H__
#define __GTK_PROGRESS_BAR_H__ #define __GTK_PROGRESS_BAR_H__
#include <gtk/gtkwidget.h>
#include <gtk/gtkprogress.h>
G_BEGIN_DECLS G_BEGIN_DECLS
@ -48,12 +46,6 @@ G_BEGIN_DECLS
typedef struct _GtkProgressBar GtkProgressBar; typedef struct _GtkProgressBar GtkProgressBar;
typedef struct _GtkProgressBarClass GtkProgressBarClass; typedef struct _GtkProgressBarClass GtkProgressBarClass;
typedef enum
{
GTK_PROGRESS_CONTINUOUS,
GTK_PROGRESS_DISCRETE
} GtkProgressBarStyle;
typedef enum typedef enum
{ {
GTK_PROGRESS_LEFT_TO_RIGHT, GTK_PROGRESS_LEFT_TO_RIGHT,
@ -64,9 +56,10 @@ typedef enum
struct _GtkProgressBar struct _GtkProgressBar
{ {
GtkProgress progress; GtkWidget parent;
GdkPixmap *GSEAL (offscreen_pixmap);
GtkProgressBarStyle GSEAL (bar_style);
GtkProgressBarOrientation GSEAL (orientation); GtkProgressBarOrientation GSEAL (orientation);
guint GSEAL (blocks); guint GSEAL (blocks);
@ -81,17 +74,27 @@ struct _GtkProgressBar
guint GSEAL (activity_dir) : 1; guint GSEAL (activity_dir) : 1;
guint GSEAL (ellipsize) : 3; guint GSEAL (ellipsize) : 3;
guint GSEAL (dirty) : 1; guint GSEAL (dirty) : 1;
guint GSEAL (activity_mode) : 1;
guint GSEAL (show_text) : 1;
}; };
struct _GtkProgressBarClass struct _GtkProgressBarClass
{ {
GtkProgressClass parent_class; GtkWidgetClass parent_class;
void (* paint) (GtkProgressBar *progress);
void (* update) (GtkProgressBar *progress);
void (* act_mode_enter) (GtkProgressBar *progress);
/* Padding for future expansion */ /* Padding for future expansion */
void (*_gtk_reserved1) (void); void (*_gtk_reserved1) (void);
void (*_gtk_reserved2) (void); void (*_gtk_reserved2) (void);
void (*_gtk_reserved3) (void); void (*_gtk_reserved3) (void);
void (*_gtk_reserved4) (void); void (*_gtk_reserved4) (void);
void (*_gtk_reserved5) (void);
void (*_gtk_reserved6) (void);
void (*_gtk_reserved7) (void);
void (*_gtk_reserved8) (void);
}; };
@ -107,7 +110,7 @@ void gtk_progress_bar_set_fraction (GtkProgressBar *pbar,
void gtk_progress_bar_set_pulse_step (GtkProgressBar *pbar, void gtk_progress_bar_set_pulse_step (GtkProgressBar *pbar,
gdouble fraction); gdouble fraction);
void gtk_progress_bar_set_orientation (GtkProgressBar *pbar, void gtk_progress_bar_set_orientation (GtkProgressBar *pbar,
GtkProgressBarOrientation orientation); GtkProgressBarOrientation orientation);
G_CONST_RETURN gchar* gtk_progress_bar_get_text (GtkProgressBar *pbar); G_CONST_RETURN gchar* gtk_progress_bar_get_text (GtkProgressBar *pbar);
gdouble gtk_progress_bar_get_fraction (GtkProgressBar *pbar); gdouble gtk_progress_bar_get_fraction (GtkProgressBar *pbar);
@ -115,9 +118,12 @@ gdouble gtk_progress_bar_get_pulse_step (GtkProgressBar *pbar);
GtkProgressBarOrientation gtk_progress_bar_get_orientation (GtkProgressBar *pbar); GtkProgressBarOrientation gtk_progress_bar_get_orientation (GtkProgressBar *pbar);
void gtk_progress_bar_set_ellipsize (GtkProgressBar *pbar, void gtk_progress_bar_set_ellipsize (GtkProgressBar *pbar,
PangoEllipsizeMode mode); PangoEllipsizeMode mode);
PangoEllipsizeMode gtk_progress_bar_get_ellipsize (GtkProgressBar *pbar); PangoEllipsizeMode gtk_progress_bar_get_ellipsize (GtkProgressBar *pbar);
void gtk_progress_bar_set_show_text (GtkProgressBar *pbar,
gboolean show_text);
gboolean gtk_progress_bar_get_show_text (GtkProgressBar *pbar);
G_END_DECLS G_END_DECLS

116
modules/other/gail/gailprogressbar.c
View File

@ -32,8 +32,6 @@ static void gail_progress_bar_class_init (GailProgressBarClass *klass);
static void gail_progress_bar_init (GailProgressBar *bar); static void gail_progress_bar_init (GailProgressBar *bar);
static void gail_progress_bar_real_initialize (AtkObject *obj, static void gail_progress_bar_real_initialize (AtkObject *obj,
gpointer data); gpointer data);
static void gail_progress_bar_finalize (GObject *object);
static void atk_value_interface_init (AtkValueIface *iface); static void atk_value_interface_init (AtkValueIface *iface);
@ -47,13 +45,11 @@ static void gail_progress_bar_get_maximum_value (AtkValue *obj,
GValue *value); GValue *value);
static void gail_progress_bar_get_minimum_value (AtkValue *obj, static void gail_progress_bar_get_minimum_value (AtkValue *obj,
GValue *value); GValue *value);
static void gail_progress_bar_value_changed (GtkAdjustment *adjustment,
gpointer data);
G_DEFINE_TYPE_WITH_CODE (GailProgressBar, gail_progress_bar, GAIL_TYPE_WIDGET, G_DEFINE_TYPE_WITH_CODE (GailProgressBar, gail_progress_bar, GAIL_TYPE_WIDGET,
G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init)) G_IMPLEMENT_INTERFACE (ATK_TYPE_VALUE, atk_value_interface_init))
static void static void
gail_progress_bar_class_init (GailProgressBarClass *klass) gail_progress_bar_class_init (GailProgressBarClass *klass)
{ {
GObjectClass *gobject_class = G_OBJECT_CLASS (klass); GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
@ -65,8 +61,6 @@ gail_progress_bar_class_init (GailProgressBarClass *klass)
widget_class->notify_gtk = gail_progress_bar_real_notify_gtk; widget_class->notify_gtk = gail_progress_bar_real_notify_gtk;
class->initialize = gail_progress_bar_real_initialize; class->initialize = gail_progress_bar_real_initialize;
gobject_class->finalize = gail_progress_bar_finalize;
} }
static void static void
@ -79,30 +73,13 @@ gail_progress_bar_real_initialize (AtkObject *obj,
gpointer data) gpointer data)
{ {
GailProgressBar *progress_bar = GAIL_PROGRESS_BAR (obj); GailProgressBar *progress_bar = GAIL_PROGRESS_BAR (obj);
GtkProgress *gtk_progress;
ATK_OBJECT_CLASS (gail_progress_bar_parent_class)->initialize (obj, data); ATK_OBJECT_CLASS (gail_progress_bar_parent_class)->initialize (obj, data);
gtk_progress = GTK_PROGRESS (data);
/*
* If a GtkAdjustment already exists for the spin_button,
* create the GailAdjustment
*/
if (gtk_progress->adjustment)
{
progress_bar->adjustment = gail_adjustment_new (gtk_progress->adjustment);
g_signal_connect (gtk_progress->adjustment,
"value-changed",
G_CALLBACK (gail_progress_bar_value_changed),
obj);
}
else
progress_bar->adjustment = NULL;
obj->role = ATK_ROLE_PROGRESS_BAR; obj->role = ATK_ROLE_PROGRESS_BAR;
} }
static void static void
atk_value_interface_init (AtkValueIface *iface) atk_value_interface_init (AtkValueIface *iface)
{ {
iface->get_current_value = gail_progress_bar_get_current_value; iface->get_current_value = gail_progress_bar_get_current_value;
@ -110,75 +87,37 @@ atk_value_interface_init (AtkValueIface *iface)
iface->get_minimum_value = gail_progress_bar_get_minimum_value; iface->get_minimum_value = gail_progress_bar_get_minimum_value;
} }
static void static void
gail_progress_bar_get_current_value (AtkValue *obj, gail_progress_bar_get_current_value (AtkValue *obj,
GValue *value) GValue *value)
{ {
GailProgressBar *progress_bar; GtkWidget *widget;
g_return_if_fail (GAIL_IS_PROGRESS_BAR (obj)); g_return_if_fail (GAIL_IS_PROGRESS_BAR (obj));
progress_bar = GAIL_PROGRESS_BAR (obj); widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (obj));
if (progress_bar->adjustment == NULL)
/*
* Adjustment has not been specified
*/
return;
atk_value_get_current_value (ATK_VALUE (progress_bar->adjustment), value); g_value_set_double (value, gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (widget)));
} }
static void static void
gail_progress_bar_get_maximum_value (AtkValue *obj, gail_progress_bar_get_maximum_value (AtkValue *obj,
GValue *value) GValue *value)
{ {
GailProgressBar *progress_bar;
g_return_if_fail (GAIL_IS_PROGRESS_BAR (obj)); g_return_if_fail (GAIL_IS_PROGRESS_BAR (obj));
progress_bar = GAIL_PROGRESS_BAR (obj); g_value_set_double (value, 1.0);
if (progress_bar->adjustment == NULL)
/*
* Adjustment has not been specified
*/
return;
atk_value_get_maximum_value (ATK_VALUE (progress_bar->adjustment), value);
} }
static void static void
gail_progress_bar_get_minimum_value (AtkValue *obj, gail_progress_bar_get_minimum_value (AtkValue *obj,
GValue *value) GValue *value)
{ {
GailProgressBar *progress_bar;
g_return_if_fail (GAIL_IS_PROGRESS_BAR (obj)); g_return_if_fail (GAIL_IS_PROGRESS_BAR (obj));
progress_bar = GAIL_PROGRESS_BAR (obj); g_value_set_double (value, 0.0);
if (progress_bar->adjustment == NULL)
/*
* Adjustment has not been specified
*/
return;
atk_value_get_minimum_value (ATK_VALUE (progress_bar->adjustment), value);
} }
static void
gail_progress_bar_finalize (GObject *object)
{
GailProgressBar *progress_bar = GAIL_PROGRESS_BAR (object);
if (progress_bar->adjustment)
{
g_object_unref (progress_bar->adjustment);
progress_bar->adjustment = NULL;
}
G_OBJECT_CLASS (gail_progress_bar_parent_class)->finalize (object);
}
static void static void
gail_progress_bar_real_notify_gtk (GObject *obj, gail_progress_bar_real_notify_gtk (GObject *obj,
GParamSpec *pspec) GParamSpec *pspec)
@ -186,41 +125,8 @@ gail_progress_bar_real_notify_gtk (GObject *obj,
GtkWidget *widget = GTK_WIDGET (obj); GtkWidget *widget = GTK_WIDGET (obj);
GailProgressBar *progress_bar = GAIL_PROGRESS_BAR (gtk_widget_get_accessible (widget)); GailProgressBar *progress_bar = GAIL_PROGRESS_BAR (gtk_widget_get_accessible (widget));
if (strcmp (pspec->name, "adjustment") == 0) if (strcmp (pspec->name, "fraction") == 0)
{ g_object_notify (G_OBJECT (progress_bar), "accessible-value");
/*
* Get rid of the GailAdjustment for the GtkAdjustment
* which was associated with the progress_bar.
*/
if (progress_bar->adjustment)
{
g_object_unref (progress_bar->adjustment);
progress_bar->adjustment = NULL;
}
/*
* Create the GailAdjustment when notify for "adjustment" property
* is received
*/
progress_bar->adjustment = gail_adjustment_new (GTK_PROGRESS (widget)->adjustment);
g_signal_connect (GTK_PROGRESS (widget)->adjustment,
"value-changed",
G_CALLBACK (gail_progress_bar_value_changed),
progress_bar);
}
else else
GAIL_WIDGET_CLASS (gail_progress_bar_parent_class)->notify_gtk (obj, pspec); GAIL_WIDGET_CLASS (gail_progress_bar_parent_class)->notify_gtk (obj, pspec);
} }
static void
gail_progress_bar_value_changed (GtkAdjustment *adjustment,
gpointer data)
{
GailProgressBar *progress_bar;
g_return_if_fail (adjustment != NULL);
g_return_if_fail (data != NULL);
progress_bar = GAIL_PROGRESS_BAR (data);
g_object_notify (G_OBJECT (progress_bar), "accessible-value");
}

2
modules/other/gail/gailprogressbar.h
View File

@ -37,8 +37,6 @@ typedef struct _GailProgressBarClass GailProgressBarClass;
struct _GailProgressBar struct _GailProgressBar
{ {
GailWidget parent; GailWidget parent;
AtkObject *adjustment;
}; };
GType gail_progress_bar_get_type (void); GType gail_progress_bar_get_type (void);

7
tests/testgtk.c
View File

@ -8908,10 +8908,7 @@ toggle_show_text (GtkWidget *widget, ProgressData *pdata)
gboolean active; gboolean active;
active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)); active = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget));
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (pdata->pbar), gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (pdata->pbar), active);
active ? gtk_entry_get_text (GTK_ENTRY (pdata->entry)) : NULL);
gtk_widget_set_sensitive (pdata->entry, active);
} }
static void static void
@ -9061,13 +9058,11 @@ create_progress_bar (GtkWidget *widget)
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
pdata->entry = gtk_entry_new (); pdata->entry = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (pdata->entry), "Installing ...");
g_signal_connect (pdata->entry, "changed", g_signal_connect (pdata->entry, "changed",
G_CALLBACK (entry_changed), G_CALLBACK (entry_changed),
pdata); pdata);
gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), pdata->entry, TRUE, TRUE, 0);
gtk_widget_set_size_request (pdata->entry, 100, -1); gtk_widget_set_size_request (pdata->entry, 100, -1);
gtk_widget_set_sensitive (pdata->entry, FALSE);
label = gtk_label_new ("Ellipsize text :"); label = gtk_label_new ("Ellipsize text :");
gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 10, 11, gtk_table_attach (GTK_TABLE (tab), label, 0, 1, 10, 11,