2 * This file is part of hildon-libs
4 * Copyright (C) 2005 Nokia Corporation.
6 * Contact: Luc Pionchon <luc.pionchon@nokia.com>
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation; either version 2.1 of
11 * the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
26 * SECTION:hildon-grid-item
27 * @short_description: Creating grid items used by #HildonGrid
28 * @see_also: #HildonGrid
30 * HildonGridItem is used to create grid items used by #HildonGrid. The
31 * grid item consists of an icon and a label. Based on the displaying
32 * mode employed by #HildonGrid, the label is justified to the right or
38 * - play with libtool to get _-functions private but accesable from grid
49 #include <gtk/gtklabel.h>
50 #include <gtk/gtkicontheme.h>
51 #include <gtk/gtkimage.h>
52 #include <gtk/gtkmisc.h>
53 #include <gtk/gtkwidget.h>
54 #include <gtk/gtkenums.h>
55 #include <pango/pango.h>
57 #include "hildon-grid-item-private.h"
58 #include <hildon-widgets/hildon-grid-item.h>
61 #define _(String) dgettext(PACKAGE, String)
63 #define HILDON_GRID_ITEM_GET_PRIVATE(obj) \
64 (G_TYPE_INSTANCE_GET_PRIVATE ((obj), HILDON_TYPE_GRID_ITEM, \
65 HildonGridItemPrivate))
67 typedef struct _HildonGridItemPrivate HildonGridItemPrivate;
71 #define DEFAULT_ICON_BASENAME "qgn_list_gene_unknown_file"
72 #define HILDON_GRID_ICON_SIZE 26
73 #define HILDON_GRID_EMBLEM_SIZE 16
75 /* Use some alpha-thing for emblems. */
76 #define USE_DIRTY_ALPHA
78 struct _HildonGridItemPrivate {
83 gchar *emblem_basename;
86 GtkWidget *label; /* TODO use pango! */
87 HildonGridPositionType label_pos;
91 gint label_icon_margin;
97 gint pending_icon_size;
98 gint pending_emblem_size;
99 HildonGridPositionType pending_label_pos;
100 gint pending_focus_margin;
101 gint pending_label_height;
102 gint pending_label_icon_margin;
103 gint pending_icon_width;
104 gint pending_icon_height;
116 static void hildon_grid_item_class_init(HildonGridItemClass * klass);
117 static void hildon_grid_item_init(HildonGridItem * item);
118 static gboolean hildon_grid_item_expose(GtkWidget * widget,
119 GdkEventExpose * event);
120 static void hildon_grid_item_size_request(GtkWidget * widget,
121 GtkRequisition * requisition);
122 static void hildon_grid_item_size_allocate(GtkWidget * widget,
123 GtkAllocation * allocation);
124 static void hildon_grid_item_forall(GtkContainer * container,
125 gboolean include_int,
126 GtkCallback callback,
127 gpointer callback_data);
128 static void hildon_grid_item_remove(GtkContainer * container,
131 static void hildon_grid_item_finalize(GObject * object);
133 static void update_icon(HildonGridItem * item);
134 static void set_label_justify(HildonGridItem * item);
136 static void hildon_grid_item_set_icon_size(HildonGridItem *item,
137 HildonGridItemIconSizeType icon_size);
139 static void hildon_grid_item_set_property(GObject * object,
141 const GValue * value,
144 static void hildon_grid_item_get_property(GObject * object,
145 guint prop_id, GValue * value,
149 static GtkContainerClass *parent_class = NULL;
151 /* Private functions */
153 hildon_grid_item_set_property(GObject * object,
155 const GValue * value, GParamSpec * pspec)
157 HildonGridItem *item = HILDON_GRID_ITEM(object);
158 HildonGridItemPrivate *priv;
160 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
163 case PROP_EMBLEM_TYPE:
164 hildon_grid_item_set_emblem_type(item, g_value_get_string(value));
166 case PROP_ICON_BASENAME:
167 if(priv->icon_basename)
168 g_free(priv->icon_basename);
170 priv->icon_basename = g_strdup(g_value_get_string(value));
175 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
181 hildon_grid_item_get_property(GObject * object,
183 GValue * value, GParamSpec * pspec)
185 HildonGridItem *item = HILDON_GRID_ITEM(object);
186 HildonGridItemPrivate *priv;
189 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
192 case PROP_EMBLEM_TYPE:
193 string = hildon_grid_item_get_emblem_type(item);
194 g_value_set_string(value, string);
196 case PROP_ICON_BASENAME:
197 g_value_set_string(value, priv->icon_basename);
200 G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
207 hildon_grid_item_get_type(void)
209 static GType grid_item_type = 0;
211 if (!grid_item_type) {
212 static const GTypeInfo grid_item_info = {
213 sizeof(HildonGridItemClass),
214 NULL, /* base_init */
215 NULL, /* base_finalize */
216 (GClassInitFunc) hildon_grid_item_class_init,
217 NULL, /* class_finalize */
218 NULL, /* class_data */
219 sizeof(HildonGridItem),
221 (GInstanceInitFunc) hildon_grid_item_init,
223 grid_item_type = g_type_register_static(GTK_TYPE_CONTAINER,
228 return grid_item_type;
232 hildon_grid_item_class_init(HildonGridItemClass *klass)
234 GtkWidgetClass *widget_class;
235 GtkContainerClass *container_class;
236 GObjectClass *gobject_class;
238 widget_class = GTK_WIDGET_CLASS(klass);
239 gobject_class = G_OBJECT_CLASS(klass);
240 container_class = GTK_CONTAINER_CLASS(klass);
242 parent_class = g_type_class_peek_parent(klass);
244 g_type_class_add_private(klass, sizeof(HildonGridItemPrivate));
246 gobject_class->finalize = hildon_grid_item_finalize;
248 widget_class->expose_event = hildon_grid_item_expose;
249 widget_class->size_request = hildon_grid_item_size_request;
250 widget_class->size_allocate = hildon_grid_item_size_allocate;
252 container_class->forall = hildon_grid_item_forall;
253 container_class->remove = hildon_grid_item_remove;
255 gobject_class->set_property = hildon_grid_item_set_property;
256 gobject_class->get_property = hildon_grid_item_get_property;
258 g_object_class_install_property
261 g_param_spec_string ("emblem-type",
263 "The emblem's basename",
267 g_object_class_install_property
270 g_param_spec_string ("icon-basename",
272 "The icon's basename",
279 hildon_grid_item_init(HildonGridItem *item)
281 HildonGridItemPrivate *priv;
283 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
285 priv->icon_basename = NULL;
286 priv->pending_icon_size = priv->icon_size = HILDON_GRID_ICON_SIZE;
289 priv->emblem_basename = NULL;
290 priv->pending_emblem_size = priv->emblem_size = HILDON_GRID_EMBLEM_SIZE;
293 priv->pending_label_pos = priv->label_pos =
294 HILDON_GRID_ITEM_LABEL_POS_BOTTOM;
296 priv->selected = FALSE;
298 priv->pending_focus_margin = priv->focus_margin = 6;
299 priv->pending_label_height = priv->label_height = 30;
300 priv->pending_label_icon_margin = priv->label_icon_margin = 6;
301 priv->pending_icon_width = priv->icon_width = 64;
302 priv->pending_icon_height = priv->icon_height = 54;
303 priv->pending_label_height = priv->label_height = 30;
306 GTK_WIDGET_SET_FLAGS(GTK_WIDGET(item), GTK_CAN_FOCUS);
308 priv->label = gtk_label_new(NULL);
309 gtk_widget_set_name(priv->label, "hildon-grid-item-label");
310 gtk_widget_set_parent(priv->label, GTK_WIDGET(item));
313 set_label_justify(item);
315 gtk_widget_show(priv->label);
319 * hildon_grid_item_new:
320 * @icon_basename: icon base name
322 * Creates a new #HildonGridItem.
324 * Returns: a new #HildonGridItem
327 hildon_grid_item_new(const gchar *icon_basename)
329 HildonGridItem *item;
331 item = g_object_new(HILDON_TYPE_GRID_ITEM, "icon-basename", icon_basename, NULL);
333 return GTK_WIDGET(item);
337 * hildon_grid_item_new_with_label:
338 * @icon_basename: icon base name
339 * @label: text label for icon
341 * Creates a new #HildonGridItem with a specified label for the icon.
343 * Returns: a new #HildonGridItem
346 hildon_grid_item_new_with_label(const gchar *icon_basename,
349 HildonGridItem *item;
351 item = g_object_new(HILDON_TYPE_GRID_ITEM, "icon-basename", icon_basename, NULL);
353 hildon_grid_item_set_label(item, label);
355 return GTK_WIDGET(item);
360 update_icon(HildonGridItem *item)
362 GtkIconTheme *icon_theme;
364 GdkPixbuf *emblem_icon;
365 HildonGridItemPrivate *priv;
368 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
370 if (priv->icon != NULL) {
371 if (GTK_WIDGET_VISIBLE(priv->icon))
372 gtk_widget_hide(priv->icon);
373 gtk_widget_unparent(priv->icon);
376 icon_theme = gtk_icon_theme_get_default();
378 /* Load icon. Fall to default if loading fails. */
380 if (priv->icon_basename)
383 icon = gtk_icon_theme_load_icon(icon_theme,
385 priv->icon_size, 0, &error);
387 g_warning("Couldn't load icon \"%s\": %s", priv->icon_basename,
395 icon = gtk_icon_theme_load_icon(icon_theme,
396 DEFAULT_ICON_BASENAME,
397 priv->icon_size, 0, &error);
399 g_warning("Couldn't load default icon: %s!\n", error->message);
403 priv->icon_width = gdk_pixbuf_get_width(icon);
404 priv->icon_height = gdk_pixbuf_get_height(icon);
407 /* Load and merge emblem if one is specified. */
408 if (priv->emblem_basename != NULL) {
410 emblem_icon = gtk_icon_theme_load_icon(icon_theme,
411 priv->emblem_basename,
414 if (emblem_icon == NULL) {
415 g_warning("Couldn't load emblem \"%s\": %s",
416 priv->emblem_basename, error->message);
420 gint width, height, y;
422 #ifdef USE_DIRTY_ALPHA
426 icon_height = gdk_pixbuf_get_height(icon);
427 width = MIN(gdk_pixbuf_get_width(emblem_icon),
428 gdk_pixbuf_get_width(icon));
429 height = MIN(gdk_pixbuf_get_height(emblem_icon), icon_height);
430 y = icon_height - height;
431 #ifndef USE_DIRTY_ALPHA
432 gdk_pixbuf_copy_area(emblem_icon, 0, 0, width, height,
436 * Using composite to copy emblem to lower left corner creates
437 * some garbage on top of emblem. This way it can be avoided.
439 tmp = gdk_pixbuf_new(GDK_COLORSPACE_RGB, TRUE,
440 8, width, icon_height);
441 gdk_pixbuf_fill(tmp, 0x00000000);
442 gdk_pixbuf_copy_area(emblem_icon, 0, 0, width, height,
444 gdk_pixbuf_composite(tmp, icon,
445 0, 0, width, icon_height,
447 GDK_INTERP_NEAREST, 255);
449 #endif /* ifndef else USE_DIRTY_ALPHA */
450 g_object_unref(emblem_icon);
454 priv->icon = gtk_image_new_from_pixbuf(icon);
455 g_object_unref(icon);
457 gtk_widget_set_parent(priv->icon, GTK_WIDGET(item));
458 gtk_widget_show(priv->icon);
460 gtk_widget_queue_draw(priv->icon);
464 hildon_grid_item_set_label(HildonGridItem *item, const gchar *label)
466 HildonGridItemPrivate *priv;
468 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
473 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
474 if (strcmp (gtk_label_get_label (GTK_LABEL (priv->label)), label) == 0)
476 gtk_label_set_label(GTK_LABEL(priv->label), label);
480 hildon_grid_item_set_icon_size(HildonGridItem *item,
481 HildonGridItemIconSizeType icon_size)
483 HildonGridItemPrivate *priv;
485 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
487 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
488 if (priv->pending_icon_size == icon_size) {
491 priv->pending_icon_size = icon_size;
496 _hildon_grid_item_set_label_pos(HildonGridItem *item,
497 HildonGridPositionType label_pos)
499 HildonGridItemPrivate *priv;
501 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
503 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
504 if (priv->pending_label_pos == label_pos) {
507 priv->pending_label_pos = label_pos;
512 _hildon_grid_item_set_emblem_size(HildonGridItem *item, gint emblem_size)
514 HildonGridItemPrivate *priv;
516 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
518 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
519 if (priv->pending_emblem_size == emblem_size) {
522 priv->pending_emblem_size = emblem_size;
527 _hildon_grid_item_set_focus_margin(HildonGridItem *item,
528 const gint focus_margin)
530 HildonGridItemPrivate *priv;
532 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
534 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
535 if (priv->pending_focus_margin == focus_margin) {
538 priv->pending_focus_margin = focus_margin;
543 _hildon_grid_item_set_label_height(HildonGridItem *item,
544 const gint label_height)
546 HildonGridItemPrivate *priv;
548 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
550 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
551 if (priv->pending_label_height == label_height) {
554 priv->pending_label_height = label_height;
559 _hildon_grid_item_set_label_icon_margin(HildonGridItem *item,
560 const gint label_icon_margin)
562 HildonGridItemPrivate *priv;
564 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
566 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
567 if (priv->pending_label_icon_margin == label_icon_margin) {
570 priv->pending_label_icon_margin = label_icon_margin;
575 _hildon_grid_item_set_icon_height(HildonGridItem *item,
576 const gint icon_height)
578 HildonGridItemPrivate *priv;
580 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
582 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
583 if (priv->pending_icon_height == icon_height) {
586 priv->pending_icon_height = icon_height;
591 _hildon_grid_item_set_icon_width(HildonGridItem *item,
592 const gint icon_width)
594 HildonGridItemPrivate *priv;
596 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
598 hildon_grid_item_set_icon_size(item, icon_width);
600 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
601 if (priv->pending_icon_width == icon_width) {
604 priv->pending_icon_width = icon_width;
609 set_label_justify(HildonGridItem *item)
611 HildonGridItemPrivate *priv;
613 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
615 if (priv->label != NULL) {
616 switch (priv->label_pos) {
617 case HILDON_GRID_ITEM_LABEL_POS_BOTTOM:
618 gtk_misc_set_alignment(GTK_MISC(priv->label), 0.5, 0.5);
621 case HILDON_GRID_ITEM_LABEL_POS_RIGHT:
622 gtk_misc_set_alignment(GTK_MISC(priv->label), 0.0, 0.5);
626 g_warning("Invalid position!");
633 hildon_grid_item_remove(GtkContainer *container, GtkWidget *child)
635 HildonGridItem *item;
636 HildonGridItemPrivate *priv;
638 item = HILDON_GRID_ITEM(container);
639 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
641 g_return_if_fail(GTK_IS_WIDGET(child));
642 g_return_if_fail(child == priv->label || child == priv->icon);
644 if (child == priv->label) {
645 gtk_widget_unparent(child);
647 } else if (child == priv->icon) {
648 gtk_widget_unparent(child);
654 hildon_grid_item_expose(GtkWidget *widget, GdkEventExpose *event)
656 HildonGridItem *item;
657 HildonGridItemPrivate *priv;
659 g_return_val_if_fail(widget, FALSE);
660 g_return_val_if_fail(HILDON_IS_GRID_ITEM(widget), FALSE);
661 g_return_val_if_fail(event, FALSE);
663 item = HILDON_GRID_ITEM(widget);
664 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
666 if (priv->label == NULL && priv->icon == NULL) {
669 if (GTK_WIDGET_HAS_FOCUS(GTK_WIDGET(item))) {
673 if (priv->label != NULL) {
674 focused = priv->label;
676 focused = priv->icon;
679 /* Determine the coordinates and size of clip */
680 switch (priv->label_pos) {
681 case HILDON_GRID_ITEM_LABEL_POS_BOTTOM:
682 clip.x = focused->allocation.x - priv->focus_margin;
683 clip.y = focused->allocation.y;
684 clip.width = focused->allocation.width + priv->focus_margin * 2;
685 clip.height = focused->allocation.height;
686 if (clip.x < widget->allocation.x ||
687 clip.width > widget->allocation.width) {
688 clip.x = widget->allocation.x;
689 clip.width = widget->allocation.width;
691 if (clip.y + clip.height >
692 widget->allocation.y + widget->allocation.height) {
693 clip.height = widget->allocation.y +
694 widget->allocation.height - clip.y;
698 case HILDON_GRID_ITEM_LABEL_POS_RIGHT:
699 clip.x = widget->allocation.x;
700 clip.y = widget->allocation.y;
701 clip.width = widget->allocation.width;
702 clip.height = widget->allocation.height;
706 /* Build painting box for the exposure event */
707 gtk_paint_box(focused->style,
708 gtk_widget_get_toplevel(focused)->window,
711 &clip, focused, "selected",
712 clip.x, clip.y, clip.width, clip.height);
716 * Items are not exposed unless they are visible.
717 * -> No need to "optimize" by checking if they need exposing.
719 gtk_container_propagate_expose(GTK_CONTAINER(widget),
721 gtk_container_propagate_expose(GTK_CONTAINER(widget),
728 hildon_grid_item_size_request(GtkWidget *widget, GtkRequisition *requisition)
730 HildonGridItem *item;
731 HildonGridItemPrivate *priv;
732 GtkRequisition label_req;
735 item = HILDON_GRID_ITEM(widget);
736 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
738 label_margin = priv->focus_margin;
740 gtk_widget_size_request(priv->icon, requisition);
741 gtk_widget_size_request(priv->label, &label_req);
743 switch (priv->label_pos) {
744 case HILDON_GRID_ITEM_LABEL_POS_BOTTOM:
745 requisition->width = MAX(requisition->width, label_req.width);
746 requisition->height += label_req.height + label_margin;
749 case HILDON_GRID_ITEM_LABEL_POS_RIGHT:
750 requisition->width += label_req.width + label_margin;
751 requisition->height = MAX(requisition->height, label_req.height);
754 g_warning("bad position");
761 hildon_grid_item_size_allocate(GtkWidget *widget, GtkAllocation *allocation)
763 HildonGridItem *item;
764 HildonGridItemPrivate *priv;
765 GtkRequisition l_req;
766 GtkAllocation i_alloc, l_alloc;
768 g_return_if_fail(widget);
769 g_return_if_fail(allocation);
771 item = HILDON_GRID_ITEM(widget);
772 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
773 widget->allocation = *allocation;
775 /* If creating label and icon failed, don't show a thing... */
776 if (priv->label == NULL && priv->icon == NULL) {
779 if (priv->label != NULL) {
780 gtk_widget_get_child_requisition(priv->label, &l_req);
782 l_req.width = l_req.height = 0;
785 /* Determine icon and label allocation based on label position */
786 switch (priv->label_pos) {
787 case HILDON_GRID_ITEM_LABEL_POS_BOTTOM:
788 i_alloc.x = (allocation->width - priv->icon_width) / 2 +
790 if (priv->label != NULL) {
791 i_alloc.y = allocation->y + (allocation->height -
793 priv->label_icon_margin -
794 priv->icon_height) / 2;
796 i_alloc.y = (allocation->height - priv->icon_height) / 2 +
800 if (priv->label != NULL) {
801 l_alloc.x = allocation->x + priv->focus_margin;
802 l_alloc.y = i_alloc.y + priv->icon_height +
803 priv->label_icon_margin;
804 l_alloc.width = allocation->width - priv->focus_margin * 2;
805 l_alloc.height = priv->label_height;
809 case HILDON_GRID_ITEM_LABEL_POS_RIGHT:
810 i_alloc.x = allocation->x + priv->focus_margin;
811 i_alloc.y = allocation->y +
812 (priv->label_height - priv->icon_height) / 2;
814 if (priv->label != NULL) {
815 l_alloc.x = allocation->x + priv->focus_margin +
816 priv->icon_width + priv->label_icon_margin;
817 l_alloc.y = allocation->y;
818 l_alloc.width = allocation->width - priv->focus_margin * 2 -
819 priv->label_icon_margin - priv->icon_width;
820 l_alloc.height = priv->label_height;
824 g_warning("bad label position");
829 if (i_alloc.y < allocation->y) {
830 i_alloc.height -= i_alloc.height - allocation->height;
831 i_alloc.y = allocation->y;
833 if (i_alloc.y + i_alloc.height > allocation->y + allocation->height) {
834 i_alloc.height-= i_alloc.y + i_alloc.height -
835 allocation->y - allocation->height;
839 i_alloc.width = priv->icon_width;
840 i_alloc.height = priv->icon_height;
842 if (priv->label != NULL) {
843 gtk_widget_size_allocate(priv->label, &l_alloc);
845 if (priv->icon != NULL) {
846 gtk_widget_size_allocate(priv->icon, &i_alloc);
851 hildon_grid_item_forall(GtkContainer *container,
852 gboolean include_int,
853 GtkCallback callback,
854 gpointer callback_data)
856 HildonGridItem *item;
857 HildonGridItemPrivate *priv;
859 g_return_if_fail(container);
860 g_return_if_fail(callback);
862 item = HILDON_GRID_ITEM(container);
863 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
865 /* Connect callback functions to the item */
866 if (priv->icon != NULL) {
867 (*callback) (priv->icon, callback_data);
869 if (priv->label != NULL) {
870 (*callback) (priv->label, callback_data);
875 hildon_grid_item_finalize(GObject *object)
877 HildonGridItem *item;
878 HildonGridItemPrivate *priv;
880 item = HILDON_GRID_ITEM(object);
881 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
883 g_free(priv->icon_basename);
884 if (priv->emblem_basename != NULL) {
885 g_free(priv->emblem_basename);
888 G_OBJECT_CLASS(parent_class)->finalize(object);
892 static int hildon_time_get_font_width(GtkWidget * widget)
894 PangoContext *context;
895 PangoFontMetrics *metrics;
898 context = gtk_widget_get_pango_context(widget);
899 metrics = pango_context_get_metrics(context,
900 widget->style->font_desc,
901 pango_context_get_language
904 digit_width = pango_font_metrics_get_approximate_digit_width(metrics);
905 digit_width = PANGO_PIXELS(digit_width);
907 pango_font_metrics_unref(metrics);
915 * hildon_grid_item_set_emblem_type:
916 * @item: #HildonGridItem
917 * @emblem_basename: emblem's basename
919 * Sets item emblem type.
922 hildon_grid_item_set_emblem_type(HildonGridItem *item,
923 const gchar *emblem_basename)
925 HildonGridItemPrivate *priv;
927 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
929 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
931 if (priv->emblem_basename != NULL) {
932 g_free(priv->emblem_basename);
935 priv->emblem_basename = g_strdup(emblem_basename);
939 g_object_notify (G_OBJECT (item), "emblem-type");
943 * hildon_grid_item_get_emblem_type:
944 * @item: #HildonGridItem
946 * Returns: emblem's basename. Must not be changed or freed.
949 hildon_grid_item_get_emblem_type(HildonGridItem *item)
951 g_return_val_if_fail(HILDON_IS_GRID_ITEM(item), NULL);
953 return HILDON_GRID_ITEM_GET_PRIVATE(item)->emblem_basename;
959 _hildon_grid_item_done_updating_settings(HildonGridItem *item)
961 gboolean need_update_icon;
962 gboolean need_resize;
964 HildonGridItemPrivate *priv;
965 g_return_if_fail(HILDON_IS_GRID_ITEM(item));
966 priv = HILDON_GRID_ITEM_GET_PRIVATE(item);
968 need_update_icon = need_resize = FALSE;
970 if (priv->pending_icon_size != priv->icon_size) {
971 if (priv->pending_icon_size > 0) {
972 priv->icon_size = priv->pending_icon_size;
976 need_update_icon = TRUE;
978 if (priv->pending_emblem_size != priv->emblem_size) {
979 priv->emblem_size = priv->pending_emblem_size;
980 need_update_icon = TRUE;
982 if (priv->pending_label_pos != priv->label_pos) {
983 priv->label_pos = priv->pending_label_pos;
984 /* No refresh here, grid will do it. */
985 set_label_justify(item);
988 * grid will take care of this
990 if (priv->pending_focus_margin != priv->focus_margin) {
991 priv->focus_margin = priv->pending_focus_margin;
994 if (priv->pending_label_height != priv->label_height) {
995 priv->label_height = priv->pending_label_height;
998 if (priv->pending_label_icon_margin != priv->label_icon_margin) {
999 priv->label_icon_margin = priv->pending_label_icon_margin;
1002 if (priv->pending_icon_height != priv->icon_height) {
1003 priv->icon_height = priv->pending_icon_height;
1006 if (priv->pending_icon_width != priv->icon_width) {
1007 priv->icon_width = priv->pending_icon_width;
1012 if (need_update_icon == TRUE) {
1013 update_icon(HILDON_GRID_ITEM(item));
1016 if (need_resize == TRUE) {
1017 gtk_widget_queue_resize(GTK_WIDGET(item));