[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
	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	}