trunk/src/custom_size_renderer.c

/*
 * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of GPXView.
 *
 * GPXView is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GPXView 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GPXView.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "gpxview.h"
#include "custom_size_renderer.h"

/* http://scentric.net/tutorial/sec-custom-cell-renderers.html */
/* https://stage.maemo.org/svn/maemo/projects/haf/trunk/gtk+/gtk/gtkcellrendererpixbuf.c */
/* https://stage.maemo.org/svn/maemo/projects/haf/trunk/gtk+/gtk/gtkcellrenderertext.c */

/* 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_size_init       (CustomCellRendererSize      *cellsize);
static void     custom_cell_renderer_size_class_init (CustomCellRendererSizeClass *klass);
static void     custom_cell_renderer_size_get_property  (GObject                    *object,
                                                             guint                       param_id,
                                                             GValue                     *value,
                                                             GParamSpec                 *pspec);
static void     custom_cell_renderer_size_set_property  (GObject                    *object,
                                                             guint                       param_id,
                                                             const GValue               *value,
                                                             GParamSpec                 *pspec);
static void     custom_cell_renderer_size_finalize (GObject *gobject);


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

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

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


enum { PROP_SIZE = 1, };

static const char *size_str[] = { 
  "Regular", "Small", "Micro", "Other", "Not chosen", "Large", "Virtual" 
};

static gpointer parent_class;

GType custom_cell_renderer_size_get_type (void) {
  static GType cell_size_type = 0;

  if (cell_size_type == 0)
  {
    static const GTypeInfo cell_size_info =
    {
      sizeof (CustomCellRendererSizeClass),
      NULL,                                                     /* base_init */
      NULL,                                                     /* base_finalize */
      (GClassInitFunc) custom_cell_renderer_size_class_init,
      NULL,                                                     /* class_finalize */
      NULL,                                                     /* class_data */
      sizeof (CustomCellRendererSize),
      0,                                                        /* n_preallocs */
      (GInstanceInitFunc) custom_cell_renderer_size_init,
    };

    /* Derive from GtkCellRenderer */
    cell_size_type = g_type_register_static (GTK_TYPE_CELL_RENDERER,
                                                 "CustomCellRendererSize",
                                                  &cell_size_info,
                                                  0);
  }
  return cell_size_type;
}


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

static void
custom_cell_renderer_size_init (CustomCellRendererSize *cellrenderersize)
{
  GTK_CELL_RENDERER(cellrenderersize)->mode = GTK_CELL_RENDERER_MODE_INERT;
  GTK_CELL_RENDERER(cellrenderersize)->xpad = 0;
  GTK_CELL_RENDERER(cellrenderersize)->ypad = 0;
}


/***************************************************************************
 *
 *  custom_cell_renderer_size_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 "size" 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_size_class_init (CustomCellRendererSizeClass *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_size_finalize;

  /* Hook up functions to set and get our
   *   custom cell renderer properties */
  object_class->get_property = custom_cell_renderer_size_get_property;
  object_class->set_property = custom_cell_renderer_size_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_size_get_size;
  cell_class->render   = custom_cell_renderer_size_render;

  /* Install our very own properties */
  g_object_class_install_property (object_class, PROP_SIZE,
    g_param_spec_int ("size", "Size", "Container size", -1, CACHE_CONT_MAX, 0,
                      G_PARAM_READWRITE));
}


/***************************************************************************
 *
 *  custom_cell_renderer_size_finalize: free any resources here
 *
 ***************************************************************************/

static void custom_cell_renderer_size_finalize (GObject *object) {
  (* G_OBJECT_CLASS (parent_class)->finalize) (object);
}


/***************************************************************************
 *
 *  custom_cell_renderer_size_get_property: as it says
 *
 ***************************************************************************/

static void
custom_cell_renderer_size_get_property (GObject    *object,
                                            guint       param_id,
                                            GValue     *value,
                                            GParamSpec *psec) {
  CustomCellRendererSize  *cellsize = CUSTOM_CELL_RENDERER_SIZE(object);

  switch (param_id) {
    case PROP_SIZE:
      g_value_set_int(value, cellsize->size);
      break;

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


/***************************************************************************
 *
 *  custom_cell_renderer_size_set_property: as it says
 *
 ***************************************************************************/

static void
custom_cell_renderer_size_set_property (GObject      *object,
                                            guint         param_id,
                                            const GValue *value,
                                            GParamSpec   *pspec) {
  CustomCellRendererSize *cellsize = CUSTOM_CELL_RENDERER_SIZE (object);

  switch (param_id) {
    case PROP_SIZE:
      cellsize->size = g_value_get_int(value);
      break;

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

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

GtkCellRenderer *custom_cell_renderer_size_new (void) {
  return g_object_new(CUSTOM_TYPE_CELL_RENDERER_SIZE, NULL);
}

static PangoLayout *new_layout(GtkWidget *widget, const char *str) {
#ifndef USE_MAEMO
  return gtk_widget_create_pango_layout(widget, str);
#else
#ifdef USE_PANNABLE_AREA
  char *tmp = g_strdup_printf("<span size=\"x-small\">%s</span>", str);
#else
  char *tmp = g_strdup_printf("<span size=\"xx-small\">%s</span>", str);
#endif
  PangoLayout *layout = gtk_widget_create_pango_layout(widget, NULL);
  pango_layout_set_markup(layout, tmp, strlen(tmp));
  g_free(tmp);
  return layout;
#endif
}

static void
custom_cell_renderer_size_get_size (GtkCellRenderer *cell,
            GtkWidget *widget, GdkRectangle *cell_area, gint *x_offset, 
            gint *y_offset, gint *width, gint *height) {
  GdkPixbuf *pixbuf = NULL;
  CustomCellRendererSize *cellsize = CUSTOM_CELL_RENDERER_SIZE (cell);

  if(cellsize->size < 0) return;
 
  pixbuf = icon_get(ICON_CACHE_SIZE, cellsize->size);
  if (!pixbuf) return;

  pixbuf = icon_get(ICON_CACHE_SIZE, cellsize->size);
  gint calc_width  = (gint) gdk_pixbuf_get_width(pixbuf);
  gint calc_height  = (gint) gdk_pixbuf_get_height(pixbuf);

  /* do the text */
  PangoLayout *layout = new_layout(widget, _(size_str[cellsize->size]));

  PangoRectangle rect;
  pango_layout_get_pixel_extents(layout, NULL, &rect);
  g_object_unref (layout);

  calc_height += rect.height;
  if(rect.width > calc_width) calc_width = rect.width;

  //  printf("req size = %d*%d\n", calc_width, calc_height);

  if (x_offset) *x_offset = 0;
  if (y_offset) *y_offset = 0;

  if (cell_area) {
    //    printf("cell size = %d*%d\n", cell_area->width, cell_area->height);

    if (x_offset) 
      *x_offset = (cell_area->width - calc_width)/2;

    if (y_offset)
      *y_offset = (cell_area->height - calc_height)/2;
  }

  if (width)  *width = calc_width;
  if (height) *height = calc_height;
}


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

static void
custom_cell_renderer_size_render (GtkCellRenderer *cell,
                                      GdkWindow       *window,
                                      GtkWidget       *widget,
                                      GdkRectangle    *background_area,
                                      GdkRectangle    *cell_area,
                                      GdkRectangle    *expose_area,
                                      guint            flags)
{
  CustomCellRendererSize *cellsize = CUSTOM_CELL_RENDERER_SIZE (cell);
  GdkPixbuf *pixbuf = NULL;
  GdkRectangle all_rect;
  GdkRectangle draw_rect;

  if(cellsize->size < 0) return;
 
  pixbuf = icon_get(ICON_CACHE_SIZE, cellsize->size);
  if (!pixbuf) return;

  gint pix_width  = gdk_pixbuf_get_width(pixbuf);
  gint pix_height  = gdk_pixbuf_get_height(pixbuf);

  
  custom_cell_renderer_size_get_size (cell, widget, cell_area,
                                     &all_rect.x, &all_rect.y,
                                     &all_rect.width, &all_rect.height);

  all_rect.x += cell_area->x;
  all_rect.y += cell_area->y;
  
  if (!gdk_rectangle_intersect (cell_area, &all_rect, &draw_rect) ||
      !gdk_rectangle_intersect (expose_area, &draw_rect, &draw_rect))
    return;

  /* do the text */
  PangoLayout *layout = new_layout(widget, _(size_str[cellsize->size]));
  PangoRectangle rect;
  pango_layout_get_pixel_extents(layout, NULL, &rect);
  //  printf("cell width = %d, text width = %d\n", all_rect.width, rect.width);

  int yoff = (all_rect.height - (rect.height + pix_height))/2;

  gtk_paint_layout(widget->style, window, GTK_STATE_NORMAL,
                    TRUE, expose_area, widget, "cellrenderersize",
                    all_rect.x + (all_rect.width - rect.width)/2,
                    all_rect.y + yoff,
                    layout);

  g_object_unref (layout);

  /* draw the bitmap */
  cairo_t *cr = gdk_cairo_create(window);
  gdk_cairo_set_source_pixbuf(cr, pixbuf, 
                      all_rect.x + (all_rect.width - pix_width)/2, 
                      all_rect.y + rect.height + yoff);
  gdk_cairo_rectangle(cr, &draw_rect);
  cairo_fill(cr);
  cairo_destroy(cr);
}
1	harbaum	1	/*
2			* Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3			*
4			* This file is part of GPXView.
5			*
6			* GPXView is free software: you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* GPXView is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with GPXView. If not, see <http://www.gnu.org/licenses/>.
18			*/
19
20			#include "gpxview.h"
21			#include "custom_size_renderer.h"
22
23			/* http://scentric.net/tutorial/sec-custom-cell-renderers.html */
24			/* https://stage.maemo.org/svn/maemo/projects/haf/trunk/gtk+/gtk/gtkcellrendererpixbuf.c */
25			/* https://stage.maemo.org/svn/maemo/projects/haf/trunk/gtk+/gtk/gtkcellrenderertext.c */
26
27			/* This is based mainly on GtkCellRendererProgress
28			* in GAIM, written and (c) 2002 by Sean Egan
29			* (Licensed under the GPL), which in turn is
30			* based on Gtk's GtkCellRenderer[Text\|Toggle\|Pixbuf]
31			* implementation by Jonathan Blandford */
32
33			/* Some boring function declarations: GObject type system stuff */
34
35			static void custom_cell_renderer_size_init (CustomCellRendererSize *cellsize);
36			static void custom_cell_renderer_size_class_init (CustomCellRendererSizeClass *klass);
37			static void custom_cell_renderer_size_get_property (GObject *object,
38			guint param_id,
39			GValue *value,
40			GParamSpec *pspec);
41			static void custom_cell_renderer_size_set_property (GObject *object,
42			guint param_id,
43			const GValue *value,
44			GParamSpec *pspec);
45			static void custom_cell_renderer_size_finalize (GObject *gobject);
46
47
48			/* These functions are the heart of our custom cell renderer: */
49
50			static void custom_cell_renderer_size_get_size (GtkCellRenderer *cell,
51			GtkWidget *widget,
52			GdkRectangle *cell_area,
53			gint *x_offset,
54			gint *y_offset,
55			gint *width,
56			gint *height);
57
58			static void custom_cell_renderer_size_render (GtkCellRenderer *cell,
59			GdkWindow *window,
60			GtkWidget *widget,
61			GdkRectangle *background_area,
62			GdkRectangle *cell_area,
63			GdkRectangle *expose_area,
64			guint flags);
65
66
67			enum { PROP_SIZE = 1, };
68
69			static const char *size_str[] = {
70			"Regular", "Small", "Micro", "Other", "Not chosen", "Large", "Virtual"
71			};
72
73			static gpointer parent_class;
74
75			GType custom_cell_renderer_size_get_type (void) {
76			static GType cell_size_type = 0;
77
78			if (cell_size_type == 0)
79			{
80			static const GTypeInfo cell_size_info =
81			{
82			sizeof (CustomCellRendererSizeClass),
83			NULL, /* base_init */
84			NULL, /* base_finalize */
85			(GClassInitFunc) custom_cell_renderer_size_class_init,
86			NULL, /* class_finalize */
87			NULL, /* class_data */
88			sizeof (CustomCellRendererSize),
89			0, /* n_preallocs */
90			(GInstanceInitFunc) custom_cell_renderer_size_init,
91			};
92
93			/* Derive from GtkCellRenderer */
94			cell_size_type = g_type_register_static (GTK_TYPE_CELL_RENDERER,
95			"CustomCellRendererSize",
96			&cell_size_info,
97			0);
98			}
99			return cell_size_type;
100			}
101
102
103			/***************************************************************************
104			*
105			* custom_cell_renderer_size_init: set some default properties of the
106			* parent (GtkCellRenderer).
107			*
108			***************************************************************************/
109
110			static void
111			custom_cell_renderer_size_init (CustomCellRendererSize *cellrenderersize)
112			{
113			GTK_CELL_RENDERER(cellrenderersize)->mode = GTK_CELL_RENDERER_MODE_INERT;
114			GTK_CELL_RENDERER(cellrenderersize)->xpad = 0;
115			GTK_CELL_RENDERER(cellrenderersize)->ypad = 0;
116			}
117
118
119			/***************************************************************************
120			*
121			* custom_cell_renderer_size_class_init:
122			*
123			* set up our own get_property and set_property functions, and
124			* override the parent's functions that we need to implement.
125			* And make our new "size" property known to the type system.
126			* If you want cells that can be activated on their own (ie. not
127			* just the whole row selected) or cells that are editable, you
128			* will need to override 'activate' and 'start_editing' as well.
129			*
130			***************************************************************************/
131
132			static void
133			custom_cell_renderer_size_class_init (CustomCellRendererSizeClass *klass) {
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_size_finalize;
139
140			/* Hook up functions to set and get our
141			* custom cell renderer properties */
142			object_class->get_property = custom_cell_renderer_size_get_property;
143			object_class->set_property = custom_cell_renderer_size_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_size_get_size;
148			cell_class->render = custom_cell_renderer_size_render;
149
150			/* Install our very own properties */
151			g_object_class_install_property (object_class, PROP_SIZE,
152			g_param_spec_int ("size", "Size", "Container size", -1, CACHE_CONT_MAX, 0,
153			G_PARAM_READWRITE));
154			}
155
156
157			/***************************************************************************
158			*
159			* custom_cell_renderer_size_finalize: free any resources here
160			*
161			***************************************************************************/
162
163			static void custom_cell_renderer_size_finalize (GObject *object) {
164			(* G_OBJECT_CLASS (parent_class)->finalize) (object);
165			}
166
167
168			/***************************************************************************
169			*
170			* custom_cell_renderer_size_get_property: as it says
171			*
172			***************************************************************************/
173
174			static void
175			custom_cell_renderer_size_get_property (GObject *object,
176			guint param_id,
177			GValue *value,
178			GParamSpec *psec) {
179			CustomCellRendererSize *cellsize = CUSTOM_CELL_RENDERER_SIZE(object);
180
181			switch (param_id) {
182			case PROP_SIZE:
183			g_value_set_int(value, cellsize->size);
184			break;
185
186			default:
187			G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, psec);
188			break;
189			}
190			}
191
192
193			/***************************************************************************
194			*
195			* custom_cell_renderer_size_set_property: as it says
196			*
197			***************************************************************************/
198
199			static void
200			custom_cell_renderer_size_set_property (GObject *object,
201			guint param_id,
202			const GValue *value,
203			GParamSpec *pspec) {
204			CustomCellRendererSize *cellsize = CUSTOM_CELL_RENDERER_SIZE (object);
205
206			switch (param_id) {
207			case PROP_SIZE:
208			cellsize->size = g_value_get_int(value);
209			break;
210
211			default:
212			G_OBJECT_WARN_INVALID_PROPERTY_ID(object, param_id, pspec);
213			break;
214			}
215			}
216
217			/***************************************************************************
218			*
219			* custom_cell_renderer_size_new: return a new cell renderer instance
220			*
221			***************************************************************************/
222
223			GtkCellRenderer *custom_cell_renderer_size_new (void) {
224			return g_object_new(CUSTOM_TYPE_CELL_RENDERER_SIZE, NULL);
225			}
226
227			static PangoLayout new_layout(GtkWidget widget, const char *str) {
228			#ifndef USE_MAEMO
229			return gtk_widget_create_pango_layout(widget, str);
230			#else
231			#ifdef USE_PANNABLE_AREA
232			char *tmp = g_strdup_printf("<span size=\"x-small\">%s</span>", str);
233			#else
234			char *tmp = g_strdup_printf("<span size=\"xx-small\">%s</span>", str);
235			#endif
236			PangoLayout *layout = gtk_widget_create_pango_layout(widget, NULL);
237			pango_layout_set_markup(layout, tmp, strlen(tmp));
238			g_free(tmp);
239			return layout;
240			#endif
241			}
242
243			static void
244			custom_cell_renderer_size_get_size (GtkCellRenderer *cell,
245			GtkWidget widget, GdkRectangle cell_area, gint *x_offset,
246			gint y_offset, gint width, gint *height) {
247			GdkPixbuf *pixbuf = NULL;
248			CustomCellRendererSize *cellsize = CUSTOM_CELL_RENDERER_SIZE (cell);
249
250			if(cellsize->size < 0) return;
251
252			pixbuf = icon_get(ICON_CACHE_SIZE, cellsize->size);
253			if (!pixbuf) return;
254
255			pixbuf = icon_get(ICON_CACHE_SIZE, cellsize->size);
256			gint calc_width = (gint) gdk_pixbuf_get_width(pixbuf);
257			gint calc_height = (gint) gdk_pixbuf_get_height(pixbuf);
258
259			/* do the text */
260	harbaum	185	PangoLayout *layout = new_layout(widget, _(size_str[cellsize->size]));
261	harbaum	1
262			PangoRectangle rect;
263			pango_layout_get_pixel_extents(layout, NULL, &rect);
264			g_object_unref (layout);
265
266			calc_height += rect.height;
267			if(rect.width > calc_width) calc_width = rect.width;
268
269			// printf("req size = %d*%d\n", calc_width, calc_height);
270
271			if (x_offset) *x_offset = 0;
272			if (y_offset) *y_offset = 0;
273
274			if (cell_area) {
275			// printf("cell size = %d*%d\n", cell_area->width, cell_area->height);
276
277			if (x_offset)
278			*x_offset = (cell_area->width - calc_width)/2;
279
280			if (y_offset)
281			*y_offset = (cell_area->height - calc_height)/2;
282			}
283
284			if (width) *width = calc_width;
285			if (height) *height = calc_height;
286			}
287
288
289			/***************************************************************************
290			*
291			* custom_cell_renderer_size_render: crucial - do the rendering.
292			*
293			***************************************************************************/
294
295			static void
296			custom_cell_renderer_size_render (GtkCellRenderer *cell,
297			GdkWindow *window,
298			GtkWidget *widget,
299			GdkRectangle *background_area,
300			GdkRectangle *cell_area,
301			GdkRectangle *expose_area,
302			guint flags)
303			{
304			CustomCellRendererSize *cellsize = CUSTOM_CELL_RENDERER_SIZE (cell);
305			GdkPixbuf *pixbuf = NULL;
306			GdkRectangle all_rect;
307			GdkRectangle draw_rect;
308
309			if(cellsize->size < 0) return;
310
311			pixbuf = icon_get(ICON_CACHE_SIZE, cellsize->size);
312			if (!pixbuf) return;
313
314			gint pix_width = gdk_pixbuf_get_width(pixbuf);
315			gint pix_height = gdk_pixbuf_get_height(pixbuf);
316
317
318			custom_cell_renderer_size_get_size (cell, widget, cell_area,
319			&all_rect.x, &all_rect.y,
320			&all_rect.width, &all_rect.height);
321
322			all_rect.x += cell_area->x;
323			all_rect.y += cell_area->y;
324
325			if (!gdk_rectangle_intersect (cell_area, &all_rect, &draw_rect) \|\|
326			!gdk_rectangle_intersect (expose_area, &draw_rect, &draw_rect))
327			return;
328
329			/* do the text */
330	harbaum	185	PangoLayout *layout = new_layout(widget, _(size_str[cellsize->size]));
331	harbaum	1	PangoRectangle rect;
332			pango_layout_get_pixel_extents(layout, NULL, &rect);
333			// printf("cell width = %d, text width = %d\n", all_rect.width, rect.width);
334
335			int yoff = (all_rect.height - (rect.height + pix_height))/2;
336
337			gtk_paint_layout(widget->style, window, GTK_STATE_NORMAL,
338			TRUE, expose_area, widget, "cellrenderersize",
339			all_rect.x + (all_rect.width - rect.width)/2,
340			all_rect.y + yoff,
341			layout);
342
343			g_object_unref (layout);
344
345			/* draw the bitmap */
346			cairo_t *cr = gdk_cairo_create(window);
347			gdk_cairo_set_source_pixbuf(cr, pixbuf,
348			all_rect.x + (all_rect.width - pix_width)/2,
349			all_rect.y + rect.height + yoff);
350			gdk_cairo_rectangle(cr, &draw_rect);
351			cairo_fill(cr);
352			cairo_destroy(cr);
353			}