Mercurial > geeqie.yaz

comparison src/cellrenderericon.c @ 9:d907d608745f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Sync to GQview 1.5.9 release. ######## DO NOT BASE ENHANCEMENTS OR TRANSLATION UPDATES ON CODE IN THIS CVS! This CVS is never up to date with current development and is provided solely for reference purposes, please use the latest official release package when making any changes or translation updates. ########
author gqview
date Sat, 26 Feb 2005 00:13:35 +0000
parents
children 4b2d7f9af171
comparison
equal deleted inserted replaced
8:e0d0593d519e 9:d907d608745f
1 /* cellrenderericon.c, based on:
2 *
3 * gtkcellrendererpixbuf.c
4 * Copyright (C) 2000 Red Hat, Inc., Jonathan Blandford <jrb@redhat.com>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Library General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library 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 GNU
14 * Library General Public License for more details.
15 *
16 * You should have received a copy of the GNU Library General Public
17 * License along with this library; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 02111-1307, USA.
20 */
21
22 #include <stdlib.h>
23 #include "cellrenderericon.h"
24 #include "intl.h"
25
26
27 #define FIXED_ICON_SIZE_MAX 512
28
29 static void gqv_cell_renderer_icon_get_property(GObject *object,
30 guint param_id,
31 GValue *value,
32 GParamSpec *pspec);
33 static void gqv_cell_renderer_icon_set_property(GObject *object,
34 guint param_id,
35 const GValue *value,
36 GParamSpec *pspec);
37 static void gqv_cell_renderer_icon_init(GQvCellRendererIcon *celltext);
38 static void gqv_cell_renderer_icon_class_init(GQvCellRendererIconClass *class);
39 static void gqv_cell_renderer_icon_finalize(GObject *object);
40 static void gqv_cell_renderer_icon_get_size(GtkCellRenderer *cell,
41 GtkWidget *widget,
42 GdkRectangle *rectangle,
43 gint *x_offset,
44 gint *y_offset,
45 gint *width,
46 gint *height);
47 static void gqv_cell_renderer_icon_render(GtkCellRenderer *cell,
48 GdkWindow *window,
49 GtkWidget *widget,
50 GdkRectangle *background_area,
51 GdkRectangle *cell_area,
52 GdkRectangle *expose_area,
53 GtkCellRendererState flags);
54
55
56 enum {
57 PROP_ZERO,
58 PROP_PIXBUF,
59 PROP_TEXT,
60 PROP_BACKGROUND_GDK,
61 PROP_FOREGROUND_GDK,
62 PROP_FOCUSED,
63 PROP_FIXED_WIDTH,
64 PROP_FIXED_HEIGHT,
65
66 PROP_BACKGROUND_SET,
67 PROP_FOREGROUND_SET,
68 PROP_SHOW_TEXT
69 };
70
71 static gpointer parent_class;
72
73 GType
74 gqv_cell_renderer_icon_get_type (void)
75 {
76 static GType cell_icon_type = 0;
77
78 if (!cell_icon_type)
79 {
80 static const GTypeInfo cell_icon_info =
81 {
82 sizeof (GQvCellRendererIconClass),
83 NULL, /* base_init */
84 NULL, /* base_finalize */
85 (GClassInitFunc) gqv_cell_renderer_icon_class_init,
86 NULL, /* class_finalize */
87 NULL, /* class_data */
88 sizeof (GQvCellRendererIcon),
89 0, /* n_preallocs */
90 (GInstanceInitFunc) gqv_cell_renderer_icon_init,
91 };
92
93 cell_icon_type = g_type_register_static(GTK_TYPE_CELL_RENDERER,
94 "GQvCellRendererIcon",
95 &cell_icon_info, 0);
96 }
97
98 return cell_icon_type;
99 }
100
101 static void
102 gqv_cell_renderer_icon_init (GQvCellRendererIcon *cellicon)
103 {
104 GTK_CELL_RENDERER(cellicon)->xpad = 2;
105 GTK_CELL_RENDERER(cellicon)->ypad = 2;
106 }
107
108 static void
109 gqv_cell_renderer_icon_class_init (GQvCellRendererIconClass *class)
110 {
111 GObjectClass *object_class = G_OBJECT_CLASS (class);
112 GtkCellRendererClass *cell_class = GTK_CELL_RENDERER_CLASS (class);
113
114 parent_class = g_type_class_peek_parent (class);
115
116 object_class->finalize = gqv_cell_renderer_icon_finalize;
117
118 object_class->get_property = gqv_cell_renderer_icon_get_property;
119 object_class->set_property = gqv_cell_renderer_icon_set_property;
120
121 cell_class->get_size = gqv_cell_renderer_icon_get_size;
122 cell_class->render = gqv_cell_renderer_icon_render;
123
124 g_object_class_install_property(object_class,
125 PROP_PIXBUF,
126 g_param_spec_object("pixbuf",
127 _("Pixbuf Object"),
128 _("The pixbuf to render"),
129 GDK_TYPE_PIXBUF,
130 G_PARAM_READWRITE));
131
132 g_object_class_install_property(object_class,
133 PROP_TEXT,
134 g_param_spec_string("text",
135 _("Text"),
136 _("Text to render"),
137 NULL,
138 G_PARAM_READWRITE));
139
140 g_object_class_install_property(object_class,
141 PROP_BACKGROUND_GDK,
142 g_param_spec_boxed("background_gdk",
143 _("Background color"),
144 _("Background color as a GdkColor"),
145 GDK_TYPE_COLOR,
146 G_PARAM_READWRITE));
147
148 g_object_class_install_property(object_class,
149 PROP_FOREGROUND_GDK,
150 g_param_spec_boxed("foreground_gdk",
151 _("Foreground color"),
152 _("Foreground color as a GdkColor"),
153 GDK_TYPE_COLOR,
154 G_PARAM_READWRITE));
155
156 g_object_class_install_property(object_class,
157 PROP_FOCUSED,
158 g_param_spec_boolean ("has_focus",
159 _("Focus"),
160 _("Draw focus indicator"),
161 FALSE,
162 G_PARAM_READWRITE));
163
164 g_object_class_install_property(object_class,
165 PROP_FIXED_WIDTH,
166 g_param_spec_int("fixed_width",
167 _("Fixed width"),
168 _("Width of cell"),
169 -1, FIXED_ICON_SIZE_MAX,
170 -1,
171 G_PARAM_READWRITE));
172
173 g_object_class_install_property(object_class,
174 PROP_FIXED_HEIGHT,
175 g_param_spec_int("fixed_height",
176 _("Fixed height"),
177 _("Height of icon excluding text"),
178 -1, FIXED_ICON_SIZE_MAX,
179 -1,
180 G_PARAM_READWRITE));
181
182 g_object_class_install_property(object_class,
183 PROP_BACKGROUND_SET,
184 g_param_spec_boolean("background_set",
185 _("Background set"),
186 _("Whether this tag affects the background color"),
187 FALSE,
188 G_PARAM_READWRITE));
189
190 g_object_class_install_property(object_class,
191 PROP_FOREGROUND_SET,
192 g_param_spec_boolean ("foreground_set",
193 _("Foreground set"),
194 _("Whether this tag affects the foreground color"),
195 FALSE,
196 G_PARAM_READWRITE));
197
198 g_object_class_install_property(object_class,
199 PROP_SHOW_TEXT,
200 g_param_spec_boolean("show_text",
201 _("Show text"),
202 _("Whether the text is displayed"),
203 TRUE,
204 G_PARAM_READWRITE));
205 }
206
207 static void
208 gqv_cell_renderer_icon_finalize (GObject *object)
209 {
210 GQvCellRendererIcon *cellicon = GQV_CELL_RENDERER_ICON (object);
211
212 if (cellicon->pixbuf) g_object_unref (cellicon->pixbuf);
213
214 g_free(cellicon->text);
215
216 (* G_OBJECT_CLASS (parent_class)->finalize) (object);
217 }
218
219 static void
220 gqv_cell_renderer_icon_get_property(GObject *object,
221 guint param_id,
222 GValue *value,
223 GParamSpec *pspec)
224 {
225 GQvCellRendererIcon *cellicon = GQV_CELL_RENDERER_ICON (object);
226
227 switch (param_id)
228 {
229 case PROP_PIXBUF:
230 g_value_set_object(value,
231 cellicon->pixbuf ? G_OBJECT (cellicon->pixbuf) : NULL);
232 break;
233 case PROP_TEXT:
234 g_value_set_string (value, cellicon->text);
235 break;
236 case PROP_BACKGROUND_GDK:
237 {
238 GdkColor color;
239
240 color.red = cellicon->background.red;
241 color.green = cellicon->background.green;
242 color.blue = cellicon->background.blue;
243
244 g_value_set_boxed (value, &color);
245 }
246 break;
247 case PROP_FOREGROUND_GDK:
248 {
249 GdkColor color;
250
251 color.red = cellicon->foreground.red;
252 color.green = cellicon->foreground.green;
253 color.blue = cellicon->foreground.blue;
254
255 g_value_set_boxed (value, &color);
256 }
257 break;
258 case PROP_FOCUSED:
259 g_value_set_boolean (value, cellicon->focused);
260 break;
261 case PROP_FIXED_WIDTH:
262 g_value_set_int(value, cellicon->fixed_width);
263 break;
264 case PROP_FIXED_HEIGHT:
265 g_value_set_int(value, cellicon->fixed_height);
266 break;
267 case PROP_BACKGROUND_SET:
268 g_value_set_boolean(value, cellicon->background_set);
269 break;
270 case PROP_FOREGROUND_SET:
271 g_value_set_boolean(value, cellicon->foreground_set);
272 break;
273 case PROP_SHOW_TEXT:
274 g_value_set_boolean(value, cellicon->show_text);
275 break;
276 default:
277 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
278 break;
279 }
280 }
281
282 static void
283 set_bg_color (GQvCellRendererIcon *cellicon,
284 GdkColor *color)
285 {
286 if (color)
287 {
288 if (!cellicon->background_set)
289 {
290 cellicon->background_set = TRUE;
291 g_object_notify(G_OBJECT(cellicon), "background_set");
292 }
293
294 cellicon->background.red = color->red;
295 cellicon->background.green = color->green;
296 cellicon->background.blue = color->blue;
297 }
298 else
299 {
300 if (cellicon->background_set)
301 {
302 cellicon->background_set = FALSE;
303 g_object_notify(G_OBJECT(cellicon), "background_set");
304 }
305 }
306 }
307
308 static void set_fg_color (GQvCellRendererIcon *cellicon,
309 GdkColor *color)
310 {
311 if (color)
312 {
313 if (!cellicon->foreground_set)
314 {
315 cellicon->foreground_set = TRUE;
316 g_object_notify(G_OBJECT(cellicon), "foreground_set");
317 }
318
319 cellicon->foreground.red = color->red;
320 cellicon->foreground.green = color->green;
321 cellicon->foreground.blue = color->blue;
322 }
323 else
324 {
325 if (cellicon->foreground_set)
326 {
327 cellicon->foreground_set = FALSE;
328 g_object_notify(G_OBJECT(cellicon), "foreground_set");
329 }
330 }
331 }
332
333 static void
334 gqv_cell_renderer_icon_set_property(GObject *object,
335 guint param_id,
336 const GValue *value,
337 GParamSpec *pspec)
338 {
339 GQvCellRendererIcon *cellicon = GQV_CELL_RENDERER_ICON (object);
340
341 switch (param_id)
342 {
343 case PROP_PIXBUF:
344 {
345 GdkPixbuf *pixbuf;
346
347 pixbuf = (GdkPixbuf*) g_value_get_object (value);
348 if (pixbuf) g_object_ref (pixbuf);
349 if (cellicon->pixbuf) g_object_unref (cellicon->pixbuf);
350 cellicon->pixbuf = pixbuf;
351 }
352 break;
353 case PROP_TEXT:
354 {
355 gchar *text;
356
357 text = cellicon->text;
358 cellicon->text = g_strdup(g_value_get_string(value));
359 g_free(text);
360
361 g_object_notify(object, "text");
362 }
363 break;
364 case PROP_BACKGROUND_GDK:
365 set_bg_color(cellicon, g_value_get_boxed(value));
366 break;
367 case PROP_FOREGROUND_GDK:
368 set_fg_color(cellicon, g_value_get_boxed(value));
369 break;
370 case PROP_FOCUSED:
371 cellicon->focused = g_value_get_boolean(value);
372 break;
373 case PROP_FIXED_WIDTH:
374 cellicon->fixed_width = g_value_get_int(value);
375 break;
376 case PROP_FIXED_HEIGHT:
377 cellicon->fixed_height = g_value_get_int(value);
378 break;
379 case PROP_BACKGROUND_SET:
380 cellicon->background_set = g_value_get_boolean(value);
381 break;
382 case PROP_FOREGROUND_SET:
383 cellicon->foreground_set = g_value_get_boolean(value);
384 break;
385 case PROP_SHOW_TEXT:
386 cellicon->show_text = g_value_get_boolean(value);
387 break;
388 default:
389 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
390 break;
391 }
392 }
393
394 static PangoLayout *
395 gqv_cell_renderer_icon_get_layout(GQvCellRendererIcon *cellicon, GtkWidget *widget, gboolean will_render)
396 {
397 PangoLayout *layout;
398 gint width;
399
400 width = (cellicon->fixed_width > 0) ? cellicon->fixed_width * PANGO_SCALE : -1;
401
402 layout = gtk_widget_create_pango_layout(widget, cellicon->text);
403 pango_layout_set_width(layout, width);
404 pango_layout_set_alignment(layout, PANGO_ALIGN_CENTER);
405 pango_layout_set_wrap(layout, PANGO_WRAP_WORD_CHAR);
406
407 if (will_render)
408 {
409 PangoAttrList *attr_list;
410
411 attr_list = pango_attr_list_new();
412
413 if (cellicon->foreground_set)
414 {
415 PangoColor color;
416 PangoAttribute *attr;
417
418 color = cellicon->foreground;
419
420 attr = pango_attr_foreground_new(color.red, color.green, color.blue);
421
422 attr->start_index = 0;
423 attr->end_index = G_MAXINT;
424 pango_attr_list_insert(attr_list, attr);
425 }
426
427 pango_layout_set_attributes(layout, attr_list);
428 pango_attr_list_unref(attr_list);
429 }
430
431 return layout;
432 }
433
434 /**
435 * gqv_cell_renderer_icon_new:
436 *
437 * Creates a new #GQvCellRendererIcon. Adjust rendering
438 * parameters using object properties. Object properties can be set
439 * globally (with g_object_set()). Also, with #GtkTreeViewColumn, you
440 * can bind a property to a value in a #GtkTreeModel. For example, you
441 * can bind the "pixbuf" property on the cell renderer to a pixbuf value
442 * in the model, thus rendering a different image in each row of the
443 * #GtkTreeView.
444 *
445 * Return value: the new cell renderer
446 **/
447 GtkCellRenderer *
448 gqv_cell_renderer_icon_new(void)
449 {
450 return g_object_new (GQV_TYPE_CELL_RENDERER_ICON, NULL);
451 }
452
453 static void
454 gqv_cell_renderer_icon_get_size(GtkCellRenderer *cell,
455 GtkWidget *widget,
456 GdkRectangle *cell_area,
457 gint *x_offset,
458 gint *y_offset,
459 gint *width,
460 gint *height)
461 {
462 GQvCellRendererIcon *cellicon = (GQvCellRendererIcon *) cell;
463 gint calc_width;
464 gint calc_height;
465
466 if (cellicon->fixed_width > 0)
467 {
468 calc_width = cellicon->fixed_width;
469 }
470 else
471 {
472 calc_width = (cellicon->pixbuf) ? gdk_pixbuf_get_width(cellicon->pixbuf) : 0;
473 }
474
475 if (cellicon->fixed_height > 0)
476 {
477 calc_height = cellicon->fixed_height;
478 }
479 else
480 {
481 calc_height = (cellicon->pixbuf) ? gdk_pixbuf_get_height(cellicon->pixbuf) : 0;
482 }
483
484 if (cellicon->show_text && cellicon->text)
485 {
486 PangoLayout *layout;
487 PangoRectangle rect;
488
489 layout = gqv_cell_renderer_icon_get_layout(cellicon, widget, FALSE);
490 pango_layout_get_pixel_extents(layout, NULL, &rect);
491 g_object_unref(layout);
492
493 calc_width = MAX(calc_width, rect.width);
494 calc_height += rect.height;
495 }
496
497 calc_width += (gint)cell->xpad * 2;
498 calc_height += (gint)cell->ypad * 2;
499
500 if (x_offset) *x_offset = 0;
501 if (y_offset) *y_offset = 0;
502
503 if (cell_area && calc_width > 0 && calc_height > 0)
504 {
505 if (x_offset)
506 {
507 *x_offset = (cell->xalign * (cell_area->width - calc_width - 2 * cell->xpad));
508 *x_offset = MAX (*x_offset, 0) + cell->xpad;
509 }
510 if (y_offset)
511 {
512 *y_offset = (cell->yalign * (cell_area->height - calc_height - 2 * cell->ypad));
513 *y_offset = MAX (*y_offset, 0) + cell->ypad;
514 }
515 }
516
517 if (width) *width = calc_width;
518 if (height) *height = calc_height;
519 }
520
521 static void
522 gqv_cell_renderer_icon_render(GtkCellRenderer *cell,
523 GdkWindow *window,
524 GtkWidget *widget,
525 GdkRectangle *background_area,
526 GdkRectangle *cell_area,
527 GdkRectangle *expose_area,
528 GtkCellRendererState flags)
529
530 {
531 GQvCellRendererIcon *cellicon = (GQvCellRendererIcon *) cell;
532 GdkPixbuf *pixbuf;
533 const gchar *text;
534 GdkRectangle cell_rect;
535 GtkStateType state;
536
537 pixbuf = cellicon->pixbuf;
538 text = cellicon->text;
539
540 if (!pixbuf && !text) return;
541
542 gqv_cell_renderer_icon_get_size(cell, widget, cell_area,
543 &cell_rect.x, &cell_rect.y,
544 &cell_rect.width, &cell_rect.height);
545
546 cell_rect.x += cell->xpad;
547 cell_rect.y += cell->ypad;
548 cell_rect.width -= cell->xpad * 2;
549 cell_rect.height -= cell->ypad * 2;
550
551 if ((flags & GTK_CELL_RENDERER_SELECTED) == GTK_CELL_RENDERER_SELECTED)
552 {
553 if (GTK_WIDGET_HAS_FOCUS(widget))
554 state = GTK_STATE_SELECTED;
555 else
556 state = GTK_STATE_ACTIVE;
557 }
558 else
559 {
560 if (GTK_WIDGET_STATE(widget) == GTK_STATE_INSENSITIVE)
561 state = GTK_STATE_INSENSITIVE;
562 else
563 state = GTK_STATE_NORMAL;
564 }
565
566 if (pixbuf)
567 {
568 GdkRectangle pix_rect;
569 GdkRectangle draw_rect;
570
571 pix_rect.width = gdk_pixbuf_get_width(pixbuf);
572 pix_rect.height = gdk_pixbuf_get_height(pixbuf);
573
574 pix_rect.x = cell_area->x + (cell_area->width - pix_rect.width) / 2;
575
576 if (cellicon->fixed_height > 0)
577 {
578 pix_rect.y = cell_area->y + cell->ypad + (cellicon->fixed_height - pix_rect.height) / 2;
579 }
580 else
581 {
582 pix_rect.y = cell_area->y + cell_rect.y;
583 }
584
585 if (gdk_rectangle_intersect(cell_area, &pix_rect, &draw_rect) &&
586 gdk_rectangle_intersect(expose_area, &draw_rect, &draw_rect))
587 {
588 gdk_draw_pixbuf(window,
589 widget->style->black_gc,
590 pixbuf,
591 /* pixbuf 0, 0 is at pix_rect.x, pix_rect.y */
592 draw_rect.x - pix_rect.x,
593 draw_rect.y - pix_rect.y,
594 draw_rect.x,
595 draw_rect.y,
596 draw_rect.width,
597 draw_rect.height,
598 GDK_RGB_DITHER_NORMAL,
599 0, 0);
600 }
601 }
602
603 if (cellicon->show_text && text)
604 {
605 PangoLayout *layout;
606 PangoRectangle text_rect;
607 GdkRectangle pix_rect;
608 GdkRectangle draw_rect;
609
610 layout = gqv_cell_renderer_icon_get_layout(cellicon, widget, TRUE);
611 pango_layout_get_pixel_extents(layout, NULL, &text_rect);
612
613 pix_rect.width = text_rect.width;
614 pix_rect.height = text_rect.height;
615 pix_rect.x = cell_area->x + cell->xpad + (cell_rect.width - text_rect.width + 1) / 2;
616 pix_rect.y = cell_area->y + cell->ypad + (cell_rect.height - text_rect.height);
617
618 if (gdk_rectangle_intersect(cell_area, &pix_rect, &draw_rect) &&
619 gdk_rectangle_intersect(expose_area, &draw_rect, &draw_rect))
620 {
621 gtk_paint_layout(widget->style, window,
622 state, TRUE,
623 cell_area, widget,
624 "cellrenderertext",
625 pix_rect.x - text_rect.x, pix_rect.y,
626 layout);
627 }
628
629 g_object_unref(layout);
630 }
631
632 if (cellicon->focused &&
633 GTK_WIDGET_HAS_FOCUS(widget))
634 {
635 gtk_paint_focus(widget->style, window,
636 state,
637 cell_area, widget,
638 "cellrendererfocus",
639 cell_area->x, cell_area->y,
640 cell_area->width, cell_area->height);
641 }
642 }
643