[doldaconnect.git] / clients / gtk2 / progressbar.c

/* Taken from the GTK TreeView tutorial on gtk.org.
 * Slightly modified.
 */

#include "progressbar.h"

/* This is based mainly on GtkCellRendererProgress
 *  in GAIM, written and (c) 2002 by Sean Egan
 *  (Licensed under the GPL), which in turn is
 *  based on Gtk's GtkCellRenderer[Text|Toggle|Pixbuf]
 *  implementation by Jonathan Blandford */

/* Some boring function declarations: GObject type system stuff */

static void     custom_cell_renderer_progress_init       (CustomCellRendererProgress      *cellprogress);

static void     custom_cell_renderer_progress_class_init (CustomCellRendererProgressClass *klass);

static void     custom_cell_renderer_progress_get_property  (GObject                    *object,
                                                             guint                       param_id,
                                                             GValue                     *value,
                                                             GParamSpec                 *pspec);

static void     custom_cell_renderer_progress_set_property  (GObject                    *object,
                                                             guint                       param_id,
                                                             const GValue               *value,
                                                             GParamSpec                 *pspec);

static void     custom_cell_renderer_progress_finalize (GObject *gobject);


/* These functions are the heart of our custom cell renderer: */

static void     custom_cell_renderer_progress_get_size   (GtkCellRenderer            *cell,
                                                          GtkWidget                  *widget,
                                                          GdkRectangle               *cell_area,
                                                          gint                       *x_offset,
                                                          gint                       *y_offset,
                                                          gint                       *width,
                                                          gint                       *height);

static void     custom_cell_renderer_progress_render     (GtkCellRenderer            *cell,
                                                          GdkWindow                  *window,
                                                          GtkWidget                  *widget,
                                                          GdkRectangle               *background_area,
                                                          GdkRectangle               *cell_area,
                                                          GdkRectangle               *expose_area,
                                                          guint                       flags);


enum
{
  PROP_PERCENTAGE = 1,
};

static   gpointer parent_class;


/***************************************************************************
 *
 *  custom_cell_renderer_progress_get_type: here we register our type with
 *                                          the GObject type system if we
 *                                          haven't done so yet. Everything
 *                                          else is done in the callbacks.
 *
 ***************************************************************************/

GType
custom_cell_renderer_progress_get_type (void)
{
    static GType cell_progress_type = 0;

    if (cell_progress_type)
	return cell_progress_type;

    if (1)
    {
	static const GTypeInfo cell_progress_info =
	    {
		sizeof (CustomCellRendererProgressClass),
		NULL,                                                     /* base_init */
		NULL,                                                     /* base_finalize */
		(GClassInitFunc) custom_cell_renderer_progress_class_init,
		NULL,                                                     /* class_finalize */
		NULL,                                                     /* class_data */
		sizeof (CustomCellRendererProgress),
		0,                                                        /* n_preallocs */
		(GInstanceInitFunc) custom_cell_renderer_progress_init,
	    };

	/* Derive from GtkCellRenderer */
	cell_progress_type = g_type_register_static (GTK_TYPE_CELL_RENDERER,
						     "CustomCellRendererProgress",
						     &cell_progress_info,
						     0);
    }

    return cell_progress_type;
}


/***************************************************************************
 *
 *  custom_cell_renderer_progress_init: set some default properties of the
 *                                      parent (GtkCellRenderer).
 *
 ***************************************************************************/

static void
custom_cell_renderer_progress_init (CustomCellRendererProgress *cellrendererprogress)
{
    GTK_CELL_RENDERER(cellrendererprogress)->mode = GTK_CELL_RENDERER_MODE_INERT;
    GTK_CELL_RENDERER(cellrendererprogress)->xpad = 2;
    GTK_CELL_RENDERER(cellrendererprogress)->ypad = 2;
}


/***************************************************************************
 *
 *  custom_cell_renderer_progress_class_init:
 *
 *  set up our own get_property and set_property functions, and
 *  override the parent's functions that we need to implement.
 *  And make our new "percentage" property known to the type system.
 *  If you want cells that can be activated on their own (ie. not
 *  just the whole row selected) or cells that are editable, you
 *  will need to override 'activate' and 'start_editing' as well.
 *
 ***************************************************************************/

static void
custom_cell_renderer_progress_class_init (CustomCellRendererProgressClass *klass)
{
    GtkCellRendererClass *cell_class   = GTK_CELL_RENDERER_CLASS(klass);
    GObjectClass         *object_class = G_OBJECT_CLASS(klass);

    parent_class           = g_type_class_peek_parent (klass);
    object_class->finalize = custom_cell_renderer_progress_finalize;

    /* Hook up functions to set and get our
     *   custom cell renderer properties */
    object_class->get_property = custom_cell_renderer_progress_get_property;
    object_class->set_property = custom_cell_renderer_progress_set_property;

    /* Override the two crucial functions that are the heart
     *   of a cell renderer in the parent class */
    cell_class->get_size = custom_cell_renderer_progress_get_size;
    cell_class->render   = custom_cell_renderer_progress_render;

    /* Install our very own properties */
    g_object_class_install_property (object_class,
				     PROP_PERCENTAGE,
				     g_param_spec_double ("percentage",
							  "Percentage",
							  "The fractional progress to display",
							  0, 1, 0,
							  G_PARAM_READWRITE));
}


/***************************************************************************
 *
 *  custom_cell_renderer_progress_finalize: free any resources here
 *
 ***************************************************************************/

static void
custom_cell_renderer_progress_finalize (GObject *object)
{
/*
  CustomCellRendererProgress *cellrendererprogress = CUSTOM_CELL_RENDERER_PROGRESS(object);
*/

    /* Free any dynamically allocated resources here */

    (* G_OBJECT_CLASS (parent_class)->finalize) (object);
}


/***************************************************************************
 *
 *  custom_cell_renderer_progress_get_property: as it says
 *
 ***************************************************************************/

static void
custom_cell_renderer_progress_get_property (GObject    *object,
                                            guint       param_id,
                                            GValue     *value,
                                            GParamSpec *psec)
{
  CustomCellRendererProgress  *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS(object);

  switch (param_id)
  {
    case PROP_PERCENTAGE:
      g_value_set_double(value, cellprogress->progress);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, psec);
      break;
  }
}


/***************************************************************************
 *
 *  custom_cell_renderer_progress_set_property: as it says
 *
 ***************************************************************************/

static void
custom_cell_renderer_progress_set_property (GObject      *object,
                                            guint         param_id,
                                            const GValue *value,
                                            GParamSpec   *pspec)
{
    CustomCellRendererProgress *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS (object);

    switch (param_id)
    {
    case PROP_PERCENTAGE:
	cellprogress->progress = g_value_get_double(value);
	break;

    default:
	G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
	break;
    }
}

/***************************************************************************
 *
 *  custom_cell_renderer_progress_new: return a new cell renderer instance
 *
 ***************************************************************************/

GtkCellRenderer *
custom_cell_renderer_progress_new (void)
{
    return g_object_new(CUSTOM_TYPE_CELL_RENDERER_PROGRESS, NULL);
}


/***************************************************************************
 *
 *  custom_cell_renderer_progress_get_size: crucial - calculate the size
 *                                          of our cell, taking into account
 *                                          padding and alignment properties
 *                                          of parent.
 *
 ***************************************************************************/

#define FIXED_WIDTH   100
#define FIXED_HEIGHT  12

static void
custom_cell_renderer_progress_get_size (GtkCellRenderer *cell,
                                        GtkWidget       *widget,
                                        GdkRectangle    *cell_area,
                                        gint            *x_offset,
                                        gint            *y_offset,
                                        gint            *width,
                                        gint            *height)
{
    gint calc_width;
    gint calc_height;

    calc_width  = (gint) cell->xpad * 2 + FIXED_WIDTH;
    calc_height = (gint) cell->ypad * 2 + FIXED_HEIGHT;

    if (width)
	*width = calc_width;

    if (height)
	*height = calc_height;

    if (cell_area)
    {
	if (x_offset)
	{
	    *x_offset = cell->xalign * (cell_area->width - calc_width);
	    *x_offset = MAX (*x_offset, 0);
	}

	if (y_offset)
	{
	    *y_offset = cell->yalign * (cell_area->height - calc_height);
	    *y_offset = MAX (*y_offset, 0);
	}
    }
}


/***************************************************************************
 *
 *  custom_cell_renderer_progress_render: crucial - do the rendering.
 *
 ***************************************************************************/

static void
custom_cell_renderer_progress_render (GtkCellRenderer *cell,
                                      GdkWindow       *window,
                                      GtkWidget       *widget,
                                      GdkRectangle    *background_area,
                                      GdkRectangle    *cell_area,
                                      GdkRectangle    *expose_area,
                                      guint            flags)
{
    CustomCellRendererProgress *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS (cell);
    GtkStateType                state;
    gint                        width, height;
    gint                        x_offset, y_offset;

    custom_cell_renderer_progress_get_size (cell, widget, cell_area,
					    &x_offset, &y_offset,
					    &width, &height);

    if (GTK_WIDGET_HAS_FOCUS (widget))
	state = GTK_STATE_ACTIVE;
    else
	state = GTK_STATE_NORMAL;

    width  -= cell->xpad*2;
    height -= cell->ypad*2;

    gtk_paint_box (widget->style,
		   window,
		   GTK_STATE_NORMAL, GTK_SHADOW_IN,
		   NULL, widget, "trough",
		   cell_area->x + x_offset + cell->xpad,
		   cell_area->y + y_offset + cell->ypad,
		   width - 1, height - 1);

    gtk_paint_box (widget->style,
		   window,
		   state, GTK_SHADOW_OUT,
		   NULL, widget, "bar",
		   cell_area->x + x_offset + cell->xpad,
		   cell_area->y + y_offset + cell->ypad,
		   width * cellprogress->progress,
		   height - 1);
}
Commit	Line	Data
d3372da9	1	/* Taken from the GTK TreeView tutorial on gtk.org.
	2	* Slightly modified.
	3	*/
	4
	5	#include "progressbar.h"
	6
	7	/* This is based mainly on GtkCellRendererProgress
	8	* in GAIM, written and (c) 2002 by Sean Egan
	9	* (Licensed under the GPL), which in turn is
	10	* based on Gtk's GtkCellRenderer[Text\|Toggle\|Pixbuf]
	11	* implementation by Jonathan Blandford */
	12
	13	/* Some boring function declarations: GObject type system stuff */
	14
	15	static void custom_cell_renderer_progress_init (CustomCellRendererProgress *cellprogress);
	16
	17	static void custom_cell_renderer_progress_class_init (CustomCellRendererProgressClass *klass);
	18
	19	static void custom_cell_renderer_progress_get_property (GObject *object,
	20	guint param_id,
	21	GValue *value,
	22	GParamSpec *pspec);
	23
	24	static void custom_cell_renderer_progress_set_property (GObject *object,
	25	guint param_id,
	26	const GValue *value,
	27	GParamSpec *pspec);
	28
	29	static void custom_cell_renderer_progress_finalize (GObject *gobject);
	30
	31
	32	/* These functions are the heart of our custom cell renderer: */
	33
	34	static void custom_cell_renderer_progress_get_size (GtkCellRenderer *cell,
	35	GtkWidget *widget,
	36	GdkRectangle *cell_area,
	37	gint *x_offset,
	38	gint *y_offset,
	39	gint *width,
	40	gint *height);
	41
	42	static void custom_cell_renderer_progress_render (GtkCellRenderer *cell,
	43	GdkWindow *window,
	44	GtkWidget *widget,
	45	GdkRectangle *background_area,
	46	GdkRectangle *cell_area,
	47	GdkRectangle *expose_area,
	48	guint flags);
	49
	50
	51	enum
	52	{
	53	PROP_PERCENTAGE = 1,
	54	};
	55
	56	static gpointer parent_class;
	57
	58
	59	/***************************************************************************
	60	*
	61	* custom_cell_renderer_progress_get_type: here we register our type with
	62	* the GObject type system if we
	63	* haven't done so yet. Everything
	64	* else is done in the callbacks.
65	*
66	***************************************************************************/
67
68	GType
69	custom_cell_renderer_progress_get_type (void)
70	{
71	static GType cell_progress_type = 0;
72
73	if (cell_progress_type)
74	return cell_progress_type;
75
76	if (1)
77	{
78	static const GTypeInfo cell_progress_info =
79	{
80	sizeof (CustomCellRendererProgressClass),
81	NULL, /* base_init */
82	NULL, /* base_finalize */
83	(GClassInitFunc) custom_cell_renderer_progress_class_init,
84	NULL, /* class_finalize */
85	NULL, /* class_data */
86	sizeof (CustomCellRendererProgress),
87	0, /* n_preallocs */
88	(GInstanceInitFunc) custom_cell_renderer_progress_init,
89	};
90
91	/* Derive from GtkCellRenderer */
92	cell_progress_type = g_type_register_static (GTK_TYPE_CELL_RENDERER,
93	"CustomCellRendererProgress",
94	&cell_progress_info,
95	0);
96	}
97
98	return cell_progress_type;
99	}
100
101
102	/***************************************************************************
103	*
104	* custom_cell_renderer_progress_init: set some default properties of the
105	* parent (GtkCellRenderer).
106	*
107	***************************************************************************/
108
109	static void
110	custom_cell_renderer_progress_init (CustomCellRendererProgress *cellrendererprogress)
111	{
112	GTK_CELL_RENDERER(cellrendererprogress)->mode = GTK_CELL_RENDERER_MODE_INERT;
113	GTK_CELL_RENDERER(cellrendererprogress)->xpad = 2;
114	GTK_CELL_RENDERER(cellrendererprogress)->ypad = 2;
115	}
116
117
118	/***************************************************************************
119	*
120	* custom_cell_renderer_progress_class_init:
121	*
122	* set up our own get_property and set_property functions, and
123	* override the parent's functions that we need to implement.
124	* And make our new "percentage" property known to the type system.
125	* If you want cells that can be activated on their own (ie. not
126	* just the whole row selected) or cells that are editable, you
127	* will need to override 'activate' and 'start_editing' as well.
128	*
129	***************************************************************************/
130
131	static void
132	custom_cell_renderer_progress_class_init (CustomCellRendererProgressClass *klass)
133	{
134	GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS(klass);
135	GObjectClass *object_class = G_OBJECT_CLASS(klass);
136
137	parent_class = g_type_class_peek_parent (klass);
138	object_class->finalize = custom_cell_renderer_progress_finalize;
139
140	/* Hook up functions to set and get our
141	* custom cell renderer properties */
142	object_class->get_property = custom_cell_renderer_progress_get_property;
143	object_class->set_property = custom_cell_renderer_progress_set_property;
144
145	/* Override the two crucial functions that are the heart
146	* of a cell renderer in the parent class */
147	cell_class->get_size = custom_cell_renderer_progress_get_size;
148	cell_class->render = custom_cell_renderer_progress_render;
149
150	/* Install our very own properties */
151	g_object_class_install_property (object_class,
152	PROP_PERCENTAGE,
153	g_param_spec_double ("percentage",
154	"Percentage",
155	"The fractional progress to display",
156	0, 1, 0,
157	G_PARAM_READWRITE));
158	}
159
160
161	/***************************************************************************
162	*
163	* custom_cell_renderer_progress_finalize: free any resources here
164	*
165	***************************************************************************/
166
167	static void
168	custom_cell_renderer_progress_finalize (GObject *object)
169	{
170	/*
171	CustomCellRendererProgress *cellrendererprogress = CUSTOM_CELL_RENDERER_PROGRESS(object);
172	*/
173
174	/* Free any dynamically allocated resources here */
175
176	(* G_OBJECT_CLASS (parent_class)->finalize) (object);
177	}
178
179
180	/***************************************************************************
181	*
182	* custom_cell_renderer_progress_get_property: as it says
183	*
184	***************************************************************************/
185
186	static void
187	custom_cell_renderer_progress_get_property (GObject *object,
188	guint param_id,
189	GValue *value,
190	GParamSpec *psec)
191	{
192	CustomCellRendererProgress *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS(object);
193
194	switch (param_id)
195	{
196	case PROP_PERCENTAGE:
197	g_value_set_double(value, cellprogress->progress);
198	break;
199
200	default:
201	G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, psec);
202	break;
203	}
204	}
205
206
207	/***************************************************************************
208	*
209	* custom_cell_renderer_progress_set_property: as it says
210	*
211	***************************************************************************/
212
213	static void
214	custom_cell_renderer_progress_set_property (GObject *object,
215	guint param_id,
216	const GValue *value,
217	GParamSpec *pspec)
218	{
219	CustomCellRendererProgress *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS (object);
220
221	switch (param_id)
222	{
223	case PROP_PERCENTAGE:
224	cellprogress->progress = g_value_get_double(value);
225	break;
226
227	default:
228	G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
229	break;
230	}
231	}
232
233	/***************************************************************************
234	*
235	* custom_cell_renderer_progress_new: return a new cell renderer instance
236	*
237	***************************************************************************/
238
239	GtkCellRenderer *
240	custom_cell_renderer_progress_new (void)
241	{
242	return g_object_new(CUSTOM_TYPE_CELL_RENDERER_PROGRESS, NULL);
243	}
244
245
246	/***************************************************************************
247	*
248	* custom_cell_renderer_progress_get_size: crucial - calculate the size
249	* of our cell, taking into account
250	* padding and alignment properties
251	* of parent.
252	*
253	***************************************************************************/
254
255	#define FIXED_WIDTH 100
256	#define FIXED_HEIGHT 12
257
258	static void
259	custom_cell_renderer_progress_get_size (GtkCellRenderer *cell,
260	GtkWidget *widget,
261	GdkRectangle *cell_area,
262	gint *x_offset,
263	gint *y_offset,
264	gint *width,
265	gint *height)
266	{
267	gint calc_width;
268	gint calc_height;
269
270	calc_width = (gint) cell->xpad * 2 + FIXED_WIDTH;
271	calc_height = (gint) cell->ypad * 2 + FIXED_HEIGHT;
272
273	if (width)
274	*width = calc_width;
275
276	if (height)
277	*height = calc_height;
278
279	if (cell_area)
280	{
281	if (x_offset)
282	{
283	x_offset = cell->xalign (cell_area->width - calc_width);
284	x_offset = MAX (x_offset, 0);
285	}
286
287	if (y_offset)
288	{
289	y_offset = cell->yalign (cell_area->height - calc_height);
290	y_offset = MAX (y_offset, 0);
291	}
292	}
293	}
294
295
296	/***************************************************************************
297	*
298	* custom_cell_renderer_progress_render: crucial - do the rendering.
299	*
300	***************************************************************************/
301
302	static void
303	custom_cell_renderer_progress_render (GtkCellRenderer *cell,
304	GdkWindow *window,
305	GtkWidget *widget,
306	GdkRectangle *background_area,
307	GdkRectangle *cell_area,
308	GdkRectangle *expose_area,
309	guint flags)
310	{
311	CustomCellRendererProgress *cellprogress = CUSTOM_CELL_RENDERER_PROGRESS (cell);
312	GtkStateType state;
313	gint width, height;
314	gint x_offset, y_offset;
315
316	custom_cell_renderer_progress_get_size (cell, widget, cell_area,
317	&x_offset, &y_offset,
318	&width, &height);
319
320	if (GTK_WIDGET_HAS_FOCUS (widget))
321	state = GTK_STATE_ACTIVE;
322	else
323	state = GTK_STATE_NORMAL;
324
325	width -= cell->xpad*2;
326	height -= cell->ypad*2;
327
328	gtk_paint_box (widget->style,
329	window,
330	GTK_STATE_NORMAL, GTK_SHADOW_IN,
331	NULL, widget, "trough",
332	cell_area->x + x_offset + cell->xpad,
333	cell_area->y + y_offset + cell->ypad,
334	width - 1, height - 1);
335
336	gtk_paint_box (widget->style,
337	window,
338	state, GTK_SHADOW_OUT,
339	NULL, widget, "bar",
340	cell_area->x + x_offset + cell->xpad,
341	cell_area->y + y_offset + cell->ypad,
342	width * cellprogress->progress,
343	height - 1);
344	}