summaryrefslogtreecommitdiff
path: root/eel/eel-labeled-image.c
diff options
context:
space:
mode:
authorPerberos <[email protected]>2011-12-01 22:24:23 -0300
committerPerberos <[email protected]>2011-12-01 22:24:23 -0300
commit0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree43261e815529cb9518ed7be37af13b846af8b26b /eel/eel-labeled-image.c
downloadcaja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2
caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz
moving from https://github.com/perberos/mate-desktop-environment
Diffstat (limited to 'eel/eel-labeled-image.c')
-rw-r--r--eel/eel-labeled-image.c2493
1 files changed, 2493 insertions, 0 deletions
diff --git a/eel/eel-labeled-image.c b/eel/eel-labeled-image.c
new file mode 100644
index 00000000..76a23876
--- /dev/null
+++ b/eel/eel-labeled-image.c
@@ -0,0 +1,2493 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+
+/* eel-labeled-image.c - A labeled image.
+
+ Copyright (C) 2000 Eazel, Inc.
+
+ The Mate Library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ The Mate Library 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
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public
+ License along with the Mate Library; see the file COPYING.LIB. If not,
+ write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA.
+
+ Authors: Ramiro Estrugo <[email protected]>
+*/
+
+#include <config.h>
+#include "eel-labeled-image.h"
+
+#include "eel-art-extensions.h"
+#include "eel-art-gtk-extensions.h"
+#include "eel-debug-drawing.h"
+#include "eel-gtk-container.h"
+#include "eel-gtk-extensions.h"
+#include "eel-gtk-macros.h"
+#include "eel-accessibility.h"
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+#include <atk/atkimage.h>
+
+#define DEFAULT_SPACING 0
+#define DEFAULT_X_PADDING 0
+#define DEFAULT_Y_PADDING 0
+#define DEFAULT_X_ALIGNMENT 0.5
+#define DEFAULT_Y_ALIGNMENT 0.5
+
+/* Signals */
+enum
+{
+ ACTIVATE,
+ LAST_SIGNAL
+};
+
+/* Arguments */
+enum
+{
+ PROP_0,
+ PROP_FILL,
+ PROP_LABEL,
+ PROP_LABEL_POSITION,
+ PROP_PIXBUF,
+ PROP_SHOW_IMAGE,
+ PROP_SHOW_LABEL,
+ PROP_SPACING,
+ PROP_X_ALIGNMENT,
+ PROP_X_PADDING,
+ PROP_Y_ALIGNMENT,
+ PROP_Y_PADDING
+};
+
+/* Detail member struct */
+struct EelLabeledImageDetails
+{
+ GtkWidget *image;
+ GtkWidget *label;
+ GtkPositionType label_position;
+ gboolean show_label;
+ gboolean show_image;
+ guint spacing;
+ float x_alignment;
+ float y_alignment;
+ int x_padding;
+ int y_padding;
+ int fixed_image_height;
+ gboolean fill;
+};
+
+/* derived types so we can add our accessibility interfaces */
+static GType eel_labeled_image_button_get_type (void);
+static GType eel_labeled_image_check_button_get_type (void);
+static GType eel_labeled_image_radio_button_get_type (void);
+static GType eel_labeled_image_toggle_button_get_type (void);
+
+
+static void eel_labeled_image_class_init (EelLabeledImageClass *labeled_image_class);
+static void eel_labeled_image_init (EelLabeledImage *image);
+static void eel_labeled_image_finalize (GObject *object);
+
+
+
+/* GObjectClass methods */
+static void eel_labeled_image_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
+static void eel_labeled_image_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+/* GtkObjectClass methods */
+static void eel_labeled_image_destroy (GtkObject *object);
+
+/* GtkWidgetClass methods */
+static void eel_labeled_image_size_request (GtkWidget *widget,
+ GtkRequisition *requisition);
+static int eel_labeled_image_expose_event (GtkWidget *widget,
+ GdkEventExpose *event);
+static void eel_labeled_image_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation);
+static void eel_labeled_image_map (GtkWidget *widget);
+static void eel_labeled_image_unmap (GtkWidget *widget);
+static AtkObject *eel_labeled_image_get_accessible (GtkWidget *widget);
+
+/* GtkContainerClass methods */
+static void eel_labeled_image_add (GtkContainer *container,
+ GtkWidget *widget);
+static void eel_labeled_image_remove (GtkContainer *container,
+ GtkWidget *widget);
+static void eel_labeled_image_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data);
+
+/* Private EelLabeledImage methods */
+static EelDimensions labeled_image_get_image_dimensions (const EelLabeledImage *labeled_image);
+static EelDimensions labeled_image_get_label_dimensions (const EelLabeledImage *labeled_image);
+static void labeled_image_ensure_label (EelLabeledImage *labeled_image);
+static void labeled_image_ensure_image (EelLabeledImage *labeled_image);
+static EelIRect labeled_image_get_content_bounds (const EelLabeledImage *labeled_image);
+static EelDimensions labeled_image_get_content_dimensions (const EelLabeledImage *labeled_image);
+static void labeled_image_update_alignments (EelLabeledImage *labeled_image);
+static gboolean labeled_image_show_label (const EelLabeledImage *labeled_image);
+static gboolean labeled_image_show_image (const EelLabeledImage *labeled_image);
+
+static guint labeled_image_signals[LAST_SIGNAL] = { 0 };
+
+EEL_CLASS_BOILERPLATE (EelLabeledImage, eel_labeled_image, GTK_TYPE_CONTAINER)
+
+/* Class init methods */
+static void
+eel_labeled_image_class_init (EelLabeledImageClass *labeled_image_class)
+{
+ GObjectClass *gobject_class = G_OBJECT_CLASS (labeled_image_class);
+ GtkObjectClass *object_class = GTK_OBJECT_CLASS (labeled_image_class);
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (labeled_image_class);
+ GtkContainerClass *container_class = GTK_CONTAINER_CLASS (labeled_image_class);
+ GtkBindingSet *binding_set;
+
+ gobject_class->finalize = eel_labeled_image_finalize;
+
+ /* GObjectClass */
+ gobject_class->set_property = eel_labeled_image_set_property;
+ gobject_class->get_property = eel_labeled_image_get_property;
+
+ /* GtkObjectClass */
+ object_class->destroy = eel_labeled_image_destroy;
+
+ /* GtkWidgetClass */
+ widget_class->size_request = eel_labeled_image_size_request;
+ widget_class->size_allocate = eel_labeled_image_size_allocate;
+ widget_class->expose_event = eel_labeled_image_expose_event;
+ widget_class->map = eel_labeled_image_map;
+ widget_class->unmap = eel_labeled_image_unmap;
+ widget_class->get_accessible = eel_labeled_image_get_accessible;
+
+ /* GtkContainerClass */
+ container_class->add = eel_labeled_image_add;
+ container_class->remove = eel_labeled_image_remove;
+ container_class->forall = eel_labeled_image_forall;
+
+ labeled_image_signals[ACTIVATE] =
+ g_signal_new ("activate",
+ G_TYPE_FROM_CLASS (labeled_image_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_STRUCT_OFFSET (EelLabeledImageClass,
+ activate),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ widget_class->activate_signal = labeled_image_signals[ACTIVATE];
+
+ binding_set = gtk_binding_set_by_class (gobject_class);
+
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_Return, 0,
+ "activate", 0);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_KP_Enter, 0,
+ "activate", 0);
+ gtk_binding_entry_add_signal (binding_set,
+ GDK_space, 0,
+ "activate", 0);
+
+
+ /* Properties */
+ g_object_class_install_property (
+ gobject_class,
+ PROP_PIXBUF,
+ g_param_spec_object ("pixbuf", NULL, NULL,
+ GDK_TYPE_PIXBUF, G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_LABEL,
+ g_param_spec_string ("label", NULL, NULL,
+ "", G_PARAM_READWRITE));
+
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_LABEL_POSITION,
+ g_param_spec_enum ("label_position", NULL, NULL,
+ GTK_TYPE_POSITION_TYPE,
+ GTK_POS_BOTTOM,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_SHOW_LABEL,
+ g_param_spec_boolean ("show_label", NULL, NULL,
+ TRUE, G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_SHOW_IMAGE,
+ g_param_spec_boolean ("show_image", NULL, NULL,
+ TRUE, G_PARAM_READWRITE));
+
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_SPACING,
+ g_param_spec_uint ("spacing", NULL, NULL,
+ 0,
+ G_MAXINT,
+ DEFAULT_SPACING,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_X_PADDING,
+ g_param_spec_int ("x_padding", NULL, NULL,
+ 0,
+ G_MAXINT,
+ DEFAULT_X_PADDING,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_Y_PADDING,
+ g_param_spec_int ("y_padding", NULL, NULL,
+ 0,
+ G_MAXINT,
+ DEFAULT_Y_PADDING,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_X_ALIGNMENT,
+ g_param_spec_float ("x_alignment", NULL, NULL,
+ 0.0,
+ 1.0,
+ DEFAULT_X_ALIGNMENT,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_Y_ALIGNMENT,
+ g_param_spec_float ("y_alignment", NULL, NULL,
+ 0.0,
+ 1.0,
+ DEFAULT_Y_ALIGNMENT,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ gobject_class,
+ PROP_FILL,
+ g_param_spec_boolean ("fill", NULL, NULL,
+ FALSE,
+ G_PARAM_READWRITE));
+}
+
+static void
+eel_labeled_image_init (EelLabeledImage *labeled_image)
+{
+ gtk_widget_set_has_window (GTK_WIDGET (labeled_image), FALSE);
+
+ labeled_image->details = g_new0 (EelLabeledImageDetails, 1);
+ labeled_image->details->show_label = TRUE;
+ labeled_image->details->show_image = TRUE;
+ labeled_image->details->label_position = GTK_POS_BOTTOM;
+ labeled_image->details->spacing = DEFAULT_SPACING;
+ labeled_image->details->x_padding = DEFAULT_X_PADDING;
+ labeled_image->details->y_padding = DEFAULT_Y_PADDING;
+ labeled_image->details->x_alignment = DEFAULT_X_ALIGNMENT;
+ labeled_image->details->y_alignment = DEFAULT_Y_ALIGNMENT;
+ labeled_image->details->fixed_image_height = 0;
+
+ eel_labeled_image_set_fill (labeled_image, FALSE);
+}
+
+static void
+eel_labeled_image_finalize (GObject *object)
+{
+ EelLabeledImage *labeled_image;
+
+ labeled_image = EEL_LABELED_IMAGE (object);
+
+ g_free (labeled_image->details);
+
+ EEL_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+
+static void
+eel_labeled_image_destroy (GtkObject *object)
+{
+ EelLabeledImage *labeled_image;
+
+ labeled_image = EEL_LABELED_IMAGE (object);
+
+ if (labeled_image->details->image != NULL)
+ {
+ gtk_widget_destroy (labeled_image->details->image);
+ }
+
+ if (labeled_image->details->label != NULL)
+ {
+ gtk_widget_destroy (labeled_image->details->label);
+ }
+
+ EEL_CALL_PARENT (GTK_OBJECT_CLASS, destroy, (object));
+}
+
+/* GObjectClass methods */
+static void
+eel_labeled_image_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ EelLabeledImage *labeled_image;
+
+ g_assert (EEL_IS_LABELED_IMAGE (object));
+
+ labeled_image = EEL_LABELED_IMAGE (object);
+
+ switch (property_id)
+ {
+ case PROP_PIXBUF:
+ eel_labeled_image_set_pixbuf (labeled_image,
+ g_value_get_object (value));
+ break;
+
+ case PROP_LABEL:
+ eel_labeled_image_set_text (labeled_image, g_value_get_string (value));
+ break;
+
+ case PROP_LABEL_POSITION:
+ eel_labeled_image_set_label_position (labeled_image,
+ g_value_get_enum (value));
+ break;
+
+ case PROP_SHOW_LABEL:
+ eel_labeled_image_set_show_label (labeled_image,
+ g_value_get_boolean (value));
+ break;
+
+ case PROP_SHOW_IMAGE:
+ eel_labeled_image_set_show_image (labeled_image,
+ g_value_get_boolean (value));
+ break;
+
+ case PROP_SPACING:
+ eel_labeled_image_set_spacing (labeled_image,
+ g_value_get_uint (value));
+ break;
+
+ case PROP_X_PADDING:
+ eel_labeled_image_set_x_padding (labeled_image,
+ g_value_get_int (value));
+ break;
+
+ case PROP_Y_PADDING:
+ eel_labeled_image_set_y_padding (labeled_image,
+ g_value_get_int (value));
+ break;
+
+ case PROP_X_ALIGNMENT:
+ eel_labeled_image_set_x_alignment (labeled_image,
+ g_value_get_float (value));
+ break;
+
+ case PROP_Y_ALIGNMENT:
+ eel_labeled_image_set_y_alignment (labeled_image,
+ g_value_get_float (value));
+ break;
+
+ case PROP_FILL:
+ eel_labeled_image_set_fill (labeled_image,
+ g_value_get_boolean (value));
+ break;
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+static void
+eel_labeled_image_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ EelLabeledImage *labeled_image;
+
+ g_assert (EEL_IS_LABELED_IMAGE (object));
+
+ labeled_image = EEL_LABELED_IMAGE (object);
+
+ switch (property_id)
+ {
+ case PROP_LABEL:
+ if (labeled_image->details->label == NULL)
+ {
+ g_value_set_string (value, NULL);
+ }
+ else
+ {
+ g_value_set_string (value,
+ gtk_label_get_text (GTK_LABEL (
+ labeled_image->details->label)));
+ }
+ break;
+
+ case PROP_LABEL_POSITION:
+ g_value_set_enum (value, eel_labeled_image_get_label_position (labeled_image));
+ break;
+
+ case PROP_SHOW_LABEL:
+ g_value_set_boolean (value, eel_labeled_image_get_show_label (labeled_image));
+ break;
+
+ case PROP_SHOW_IMAGE:
+ g_value_set_boolean (value, eel_labeled_image_get_show_image (labeled_image));
+ break;
+
+ case PROP_SPACING:
+ g_value_set_uint (value, eel_labeled_image_get_spacing (labeled_image));
+ break;
+
+ case PROP_X_PADDING:
+ g_value_set_int (value, eel_labeled_image_get_x_padding (labeled_image));
+ break;
+
+ case PROP_Y_PADDING:
+ g_value_set_int (value, eel_labeled_image_get_y_padding (labeled_image));
+ break;
+
+ case PROP_X_ALIGNMENT:
+ g_value_set_float (value, eel_labeled_image_get_x_alignment (labeled_image));
+ break;
+
+ case PROP_Y_ALIGNMENT:
+ g_value_set_float (value, eel_labeled_image_get_y_alignment (labeled_image));
+ break;
+
+ case PROP_FILL:
+ g_value_set_boolean (value, eel_labeled_image_get_fill (labeled_image));
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+/* GtkWidgetClass methods */
+static void
+eel_labeled_image_size_request (GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ EelLabeledImage *labeled_image;
+ EelDimensions content_dimensions;
+
+ g_assert (EEL_IS_LABELED_IMAGE (widget));
+ g_assert (requisition != NULL);
+
+ labeled_image = EEL_LABELED_IMAGE (widget);
+
+ content_dimensions = labeled_image_get_content_dimensions (labeled_image);
+
+ requisition->width =
+ MAX (1, content_dimensions.width) +
+ 2 * labeled_image->details->x_padding;
+
+ requisition->height =
+ MAX (1, content_dimensions.height) +
+ 2 * labeled_image->details->y_padding;
+}
+
+static void
+eel_labeled_image_size_allocate (GtkWidget *widget,
+ GtkAllocation *allocation)
+{
+ EelLabeledImage *labeled_image;
+ EelIRect image_bounds;
+ EelIRect label_bounds;
+
+ g_assert (EEL_IS_LABELED_IMAGE (widget));
+ g_assert (allocation != NULL);
+
+ labeled_image = EEL_LABELED_IMAGE (widget);
+
+ gtk_widget_set_allocation (widget, allocation);
+
+ label_bounds = eel_labeled_image_get_label_bounds (labeled_image);
+ eel_gtk_container_child_size_allocate (GTK_CONTAINER (widget),
+ labeled_image->details->label,
+ label_bounds);
+
+ image_bounds = eel_labeled_image_get_image_bounds (labeled_image);
+ eel_gtk_container_child_size_allocate (GTK_CONTAINER (widget),
+ labeled_image->details->image,
+ image_bounds);
+}
+
+static int
+eel_labeled_image_expose_event (GtkWidget *widget,
+ GdkEventExpose *event)
+{
+ EelLabeledImage *labeled_image;
+ EelIRect label_bounds;
+ GtkStyle *style;
+ GdkWindow *window;
+
+ g_assert (EEL_IS_LABELED_IMAGE (widget));
+ g_assert (gtk_widget_get_realized (widget));
+ g_assert (event != NULL);
+
+ labeled_image = EEL_LABELED_IMAGE (widget);
+
+ style = gtk_widget_get_style (widget);
+ window = gtk_widget_get_window (widget);
+ if (gtk_widget_get_state (widget) == GTK_STATE_SELECTED ||
+ gtk_widget_get_state (widget) == GTK_STATE_ACTIVE)
+ {
+ label_bounds = eel_labeled_image_get_label_bounds (EEL_LABELED_IMAGE (widget));
+
+ gtk_paint_flat_box (style,
+ window,
+ gtk_widget_get_state (widget),
+ GTK_SHADOW_NONE,
+ &event->area,
+ widget,
+ "eel-labeled-image",
+ label_bounds.x0, label_bounds.y0,
+ label_bounds.x1 - label_bounds.x0,
+ label_bounds.y1 - label_bounds.y0);
+ }
+
+ if (labeled_image_show_label (labeled_image))
+ {
+ eel_gtk_container_child_expose_event (GTK_CONTAINER (widget),
+ labeled_image->details->label,
+ event);
+ }
+
+ if (labeled_image_show_image (labeled_image))
+ {
+ eel_gtk_container_child_expose_event (GTK_CONTAINER (widget),
+ labeled_image->details->image,
+ event);
+ }
+
+ if (gtk_widget_has_focus (widget))
+ {
+ label_bounds = eel_labeled_image_get_image_bounds (EEL_LABELED_IMAGE (widget));
+ gtk_paint_focus (style, window,
+ GTK_STATE_NORMAL,
+ &event->area, widget,
+ "eel-focusable-labeled-image",
+ label_bounds.x0, label_bounds.y0,
+ label_bounds.x1 - label_bounds.x0,
+ label_bounds.y1 - label_bounds.y0);
+ }
+
+ return FALSE;
+}
+
+static void
+eel_labeled_image_map (GtkWidget *widget)
+{
+ EelLabeledImage *labeled_image;
+
+ g_assert (EEL_IS_LABELED_IMAGE (widget));
+
+ labeled_image = EEL_LABELED_IMAGE (widget);
+
+ gtk_widget_set_mapped (widget, TRUE);
+
+ if (labeled_image_show_label (labeled_image))
+ {
+ eel_gtk_container_child_map (GTK_CONTAINER (widget), labeled_image->details->label);
+ }
+
+ if (labeled_image_show_image (labeled_image))
+ {
+ eel_gtk_container_child_map (GTK_CONTAINER (widget), labeled_image->details->image);
+ }
+}
+
+static void
+eel_labeled_image_unmap (GtkWidget *widget)
+{
+ EelLabeledImage *labeled_image;
+
+ g_assert (EEL_IS_LABELED_IMAGE (widget));
+
+ labeled_image = EEL_LABELED_IMAGE (widget);
+
+ gtk_widget_set_mapped (widget, FALSE);
+
+ eel_gtk_container_child_unmap (GTK_CONTAINER (widget), labeled_image->details->label);
+ eel_gtk_container_child_unmap (GTK_CONTAINER (widget), labeled_image->details->image);
+}
+
+/* GtkContainerClass methods */
+static void
+eel_labeled_image_add (GtkContainer *container,
+ GtkWidget *child)
+{
+ g_assert (GTK_IS_LABEL (child) || GTK_IS_IMAGE (child));
+
+ eel_gtk_container_child_add (container, child);
+}
+
+static void
+eel_labeled_image_remove (GtkContainer *container,
+ GtkWidget *child)
+{
+ EelLabeledImage *labeled_image;
+
+ g_assert (GTK_IS_LABEL (child) || GTK_IS_IMAGE (child));
+
+ labeled_image = EEL_LABELED_IMAGE (container);;
+
+ g_assert (child == labeled_image->details->image || child == labeled_image->details->label);
+
+ eel_gtk_container_child_remove (container, child);
+
+ if (labeled_image->details->image == child)
+ {
+ labeled_image->details->image = NULL;
+ }
+
+ if (labeled_image->details->label == child)
+ {
+ labeled_image->details->label = NULL;
+ }
+}
+
+static void
+eel_labeled_image_forall (GtkContainer *container,
+ gboolean include_internals,
+ GtkCallback callback,
+ gpointer callback_data)
+{
+ EelLabeledImage *labeled_image;
+
+ g_assert (EEL_IS_LABELED_IMAGE (container));
+ g_assert (callback != NULL);
+
+ labeled_image = EEL_LABELED_IMAGE (container);
+
+ if (include_internals)
+ {
+ if (labeled_image->details->image != NULL)
+ {
+ (* callback) (labeled_image->details->image, callback_data);
+ }
+
+ if (labeled_image->details->label != NULL)
+ {
+ (* callback) (labeled_image->details->label, callback_data);
+ }
+ }
+}
+
+/* Private EelLabeledImage methods */
+static gboolean
+is_fixed_height (const EelLabeledImage *labeled_image)
+{
+ return labeled_image->details->fixed_image_height > 0;
+}
+
+static EelDimensions
+labeled_image_get_image_dimensions (const EelLabeledImage *labeled_image)
+{
+ EelDimensions image_dimensions;
+ GtkRequisition image_requisition;
+
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (!labeled_image_show_image (labeled_image))
+ {
+ return eel_dimensions_empty;
+ }
+
+ gtk_widget_size_request (labeled_image->details->image, &image_requisition);
+
+ image_dimensions.width = (int) image_requisition.width;
+ image_dimensions.height = (int) image_requisition.height;
+
+ if (is_fixed_height (labeled_image))
+ {
+ image_dimensions.height = labeled_image->details->fixed_image_height;
+ }
+
+ return image_dimensions;
+}
+
+static EelDimensions
+labeled_image_get_label_dimensions (const EelLabeledImage *labeled_image)
+{
+ EelDimensions label_dimensions;
+ GtkRequisition label_requisition;
+
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (!labeled_image_show_label (labeled_image))
+ {
+ return eel_dimensions_empty;
+ }
+
+ gtk_widget_size_request (labeled_image->details->label, &label_requisition);
+
+ label_dimensions.width = (int) label_requisition.width;
+ label_dimensions.height = (int) label_requisition.height;
+
+ return label_dimensions;
+}
+
+static EelIRect
+labeled_image_get_image_bounds_fill (const EelLabeledImage *labeled_image)
+{
+ EelIRect image_bounds;
+ EelDimensions image_dimensions;
+ EelIRect content_bounds;
+ EelIRect bounds;
+
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ image_dimensions = labeled_image_get_image_dimensions (labeled_image);
+
+ if (eel_dimensions_are_empty (image_dimensions))
+ {
+ return eel_irect_empty;
+ }
+
+ content_bounds = labeled_image_get_content_bounds (labeled_image);
+ bounds = eel_gtk_widget_get_bounds (GTK_WIDGET (labeled_image));
+
+ if (!labeled_image_show_label (labeled_image))
+ {
+ image_bounds = bounds;
+ }
+ else
+ {
+ switch (labeled_image->details->label_position)
+ {
+ case GTK_POS_LEFT:
+ image_bounds.y0 = bounds.y0;
+ image_bounds.x0 = content_bounds.x1 - image_dimensions.width;
+ image_bounds.y1 = bounds.y1;
+ image_bounds.x1 = bounds.x1;
+ break;
+
+ case GTK_POS_RIGHT:
+ image_bounds.y0 = bounds.y0;
+ image_bounds.x0 = bounds.x0;
+ image_bounds.y1 = bounds.y1;
+ image_bounds.x1 = content_bounds.x0 + image_dimensions.width;
+ break;
+
+ case GTK_POS_TOP:
+ image_bounds.x0 = bounds.x0;
+ image_bounds.y0 = content_bounds.y1 - image_dimensions.height;
+ image_bounds.x1 = bounds.x1;
+ image_bounds.y1 = bounds.y1;
+ break;
+
+ case GTK_POS_BOTTOM:
+ image_bounds.x0 = bounds.x0;
+ image_bounds.y0 = bounds.y0;
+ image_bounds.x1 = bounds.x1;
+ image_bounds.y1 = content_bounds.y0 + image_dimensions.height;
+ break;
+
+ default:
+ image_bounds.x0 = 0;
+ image_bounds.y0 = 0;
+ image_bounds.x1 = 0;
+ image_bounds.y1 = 0;
+ g_assert_not_reached ();
+ }
+ }
+
+ return image_bounds;
+}
+
+EelIRect
+eel_labeled_image_get_image_bounds (const EelLabeledImage *labeled_image)
+{
+ EelDimensions image_dimensions;
+ EelDimensions label_dimensions;
+ GtkRequisition image_requisition;
+ EelIRect image_bounds;
+ EelIRect content_bounds;
+
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), eel_irect_empty);
+
+ if (labeled_image->details->fill)
+ {
+ return labeled_image_get_image_bounds_fill (labeled_image);
+ }
+
+ /* get true real dimensions if we're in fixed height mode */
+ if (is_fixed_height (labeled_image) && labeled_image_show_image (labeled_image))
+ {
+ gtk_widget_size_request (labeled_image->details->image, &image_requisition);
+ image_dimensions.width = (int) image_requisition.width;
+ image_dimensions.height = (int) image_requisition.height;
+ }
+ else
+ {
+ image_dimensions = labeled_image_get_image_dimensions (labeled_image);
+ }
+
+ label_dimensions = labeled_image_get_label_dimensions (labeled_image);
+
+ if (eel_dimensions_are_empty (image_dimensions))
+ {
+ return eel_irect_empty;
+ }
+
+ content_bounds = labeled_image_get_content_bounds (labeled_image);
+
+ if (!labeled_image_show_label (labeled_image))
+ {
+ image_bounds.x0 =
+ content_bounds.x0 +
+ (eel_irect_get_width (content_bounds) - image_dimensions.width) / 2;
+ image_bounds.y0 =
+ content_bounds.y0 +
+ (eel_irect_get_height (content_bounds) - image_dimensions.height) / 2;
+ }
+ else
+ {
+ switch (labeled_image->details->label_position)
+ {
+ case GTK_POS_LEFT:
+ image_bounds.x0 = content_bounds.x1 - image_dimensions.width;
+ image_bounds.y0 =
+ content_bounds.y0 +
+ (eel_irect_get_height (content_bounds) - image_dimensions.height) / 2;
+ break;
+
+ case GTK_POS_RIGHT:
+ image_bounds.x0 = content_bounds.x0;
+ image_bounds.y0 =
+ content_bounds.y0 +
+ (eel_irect_get_height (content_bounds) - image_dimensions.height) / 2;
+ break;
+
+ case GTK_POS_TOP:
+ image_bounds.x0 =
+ content_bounds.x0 +
+ (eel_irect_get_width (content_bounds) - image_dimensions.width) / 2;
+ image_bounds.y0 = content_bounds.y1 - image_dimensions.height;
+ break;
+
+ case GTK_POS_BOTTOM:
+ image_bounds.x0 =
+ content_bounds.x0 +
+ (eel_irect_get_width (content_bounds) - image_dimensions.width) / 2;
+
+ if (is_fixed_height (labeled_image))
+ {
+ image_bounds.y0 = content_bounds.y0 + eel_irect_get_height (content_bounds)
+ - image_dimensions.height
+ - label_dimensions.height
+ - labeled_image->details->spacing;
+ }
+ else
+ {
+ image_bounds.y0 = content_bounds.y0;
+ }
+
+ break;
+
+ default:
+ image_bounds.x0 = 0;
+ image_bounds.y0 = 0;
+ g_assert_not_reached ();
+ }
+ }
+
+ image_bounds.x1 = image_bounds.x0 + image_dimensions.width;
+ image_bounds.y1 = image_bounds.y0 + image_dimensions.height;
+
+ return image_bounds;
+}
+
+static EelIRect
+labeled_image_get_label_bounds_fill (const EelLabeledImage *labeled_image)
+{
+ EelIRect label_bounds;
+ EelDimensions label_dimensions;
+ EelIRect content_bounds;
+ EelIRect bounds;
+
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ label_dimensions = labeled_image_get_label_dimensions (labeled_image);
+
+ if (eel_dimensions_are_empty (label_dimensions))
+ {
+ return eel_irect_empty;
+ }
+
+ content_bounds = labeled_image_get_content_bounds (labeled_image);
+ bounds = eel_gtk_widget_get_bounds (GTK_WIDGET (labeled_image));
+
+ /* Only the label is shown */
+ if (!labeled_image_show_image (labeled_image))
+ {
+ label_bounds = bounds;
+ /* Both label and image are shown */
+ }
+ else
+ {
+ switch (labeled_image->details->label_position)
+ {
+ case GTK_POS_LEFT:
+ label_bounds.y0 = bounds.y0;
+ label_bounds.x0 = bounds.x0;
+ label_bounds.y1 = bounds.y1;
+ label_bounds.x1 = content_bounds.x0 + label_dimensions.width;
+ break;
+
+ case GTK_POS_RIGHT:
+ label_bounds.y0 = bounds.y0;
+ label_bounds.x0 = content_bounds.x1 - label_dimensions.width;
+ label_bounds.y1 = bounds.y1;
+ label_bounds.x1 = bounds.x1;
+ break;
+
+ case GTK_POS_TOP:
+ label_bounds.x0 = bounds.x0;
+ label_bounds.y0 = bounds.y0;
+ label_bounds.x1 = bounds.x1;
+ label_bounds.y1 = content_bounds.y0 + label_dimensions.height;
+ break;
+
+ case GTK_POS_BOTTOM:
+ label_bounds.x0 = bounds.x0;
+ label_bounds.y0 = content_bounds.y1 - label_dimensions.height;
+ label_bounds.x1 = bounds.x1;
+ label_bounds.y1 = bounds.y1;
+ break;
+
+ default:
+ label_bounds.x0 = 0;
+ label_bounds.y0 = 0;
+ label_bounds.x1 = 0;
+ label_bounds.y1 = 0;
+ g_assert_not_reached ();
+ }
+ }
+
+ return label_bounds;
+}
+
+EelIRect
+eel_labeled_image_get_label_bounds (const EelLabeledImage *labeled_image)
+{
+ EelIRect label_bounds;
+ EelDimensions label_dimensions;
+ EelIRect content_bounds;
+
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), eel_irect_empty);
+
+ if (labeled_image->details->fill)
+ {
+ return labeled_image_get_label_bounds_fill (labeled_image);
+ }
+
+ label_dimensions = labeled_image_get_label_dimensions (labeled_image);
+
+ if (eel_dimensions_are_empty (label_dimensions))
+ {
+ return eel_irect_empty;
+ }
+
+ content_bounds = labeled_image_get_content_bounds (labeled_image);
+
+ /* Only the label is shown */
+ if (!labeled_image_show_image (labeled_image))
+ {
+ label_bounds.x0 =
+ content_bounds.x0 +
+ (eel_irect_get_width (content_bounds) - label_dimensions.width) / 2;
+ label_bounds.y0 =
+ content_bounds.y0 +
+ (eel_irect_get_height (content_bounds) - label_dimensions.height) / 2;
+ /* Both label and image are shown */
+ }
+ else
+ {
+ switch (labeled_image->details->label_position)
+ {
+ case GTK_POS_LEFT:
+ label_bounds.x0 = content_bounds.x0;
+ label_bounds.y0 =
+ content_bounds.y0 +
+ (eel_irect_get_height (content_bounds) - label_dimensions.height) / 2;
+ break;
+
+ case GTK_POS_RIGHT:
+ label_bounds.x0 = content_bounds.x1 - label_dimensions.width;
+ label_bounds.y0 =
+ content_bounds.y0 +
+ (eel_irect_get_height (content_bounds) - label_dimensions.height) / 2;
+ break;
+
+ case GTK_POS_TOP:
+ label_bounds.x0 =
+ content_bounds.x0 +
+ (eel_irect_get_width (content_bounds) - label_dimensions.width) / 2;
+ label_bounds.y0 = content_bounds.y0;
+ break;
+
+ case GTK_POS_BOTTOM:
+ label_bounds.x0 =
+ content_bounds.x0 +
+ (eel_irect_get_width (content_bounds) - label_dimensions.width) / 2;
+ label_bounds.y0 = content_bounds.y1 - label_dimensions.height;
+ break;
+
+ default:
+ label_bounds.x0 = 0;
+ label_bounds.y0 = 0;
+ g_assert_not_reached ();
+ }
+ }
+
+ label_bounds.x1 = label_bounds.x0 + label_dimensions.width;
+ label_bounds.y1 = label_bounds.y0 + label_dimensions.height;
+
+ return label_bounds;
+}
+
+static void
+labeled_image_update_alignments (EelLabeledImage *labeled_image)
+{
+
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (labeled_image->details->label != NULL)
+ {
+ float x_alignment;
+ float y_alignment;
+
+ if (labeled_image->details->fill)
+ {
+ gtk_misc_get_alignment (GTK_MISC (labeled_image->details->label),
+ &x_alignment, &y_alignment);
+
+ /* Only the label is shown */
+ if (!labeled_image_show_image (labeled_image))
+ {
+ x_alignment = 0.5;
+ y_alignment = 0.5;
+ /* Both label and image are shown */
+ }
+ else
+ {
+ switch (labeled_image->details->label_position)
+ {
+ case GTK_POS_LEFT:
+ x_alignment = 1.0;
+ y_alignment = 0.5;
+ break;
+
+ case GTK_POS_RIGHT:
+ x_alignment = 0.0;
+ y_alignment = 0.5;
+ break;
+
+ case GTK_POS_TOP:
+ x_alignment = 0.5;
+ y_alignment = 1.0;
+ break;
+
+ case GTK_POS_BOTTOM:
+ x_alignment = 0.5;
+ y_alignment = 0.0;
+ break;
+ }
+
+ }
+
+ gtk_misc_set_alignment (GTK_MISC (labeled_image->details->label),
+ x_alignment,
+ y_alignment);
+ }
+ }
+
+ if (labeled_image->details->image != NULL)
+ {
+ float x_alignment;
+ float y_alignment;
+
+ if (labeled_image->details->fill)
+ {
+ gtk_misc_get_alignment (GTK_MISC (labeled_image->details->image),
+ &x_alignment, &y_alignment);
+
+ /* Only the image is shown */
+ if (!labeled_image_show_label (labeled_image))
+ {
+ x_alignment = 0.5;
+ y_alignment = 0.5;
+ /* Both label and image are shown */
+ }
+ else
+ {
+ switch (labeled_image->details->label_position)
+ {
+ case GTK_POS_LEFT:
+ x_alignment = 0.0;
+ y_alignment = 0.5;
+ break;
+
+ case GTK_POS_RIGHT:
+ x_alignment = 1.0;
+ y_alignment = 0.5;
+ break;
+
+ case GTK_POS_TOP:
+ x_alignment = 0.5;
+ y_alignment = 0.0;
+ break;
+
+ case GTK_POS_BOTTOM:
+ x_alignment = 0.5;
+ y_alignment = 1.0;
+ break;
+ }
+ }
+
+ gtk_misc_set_alignment (GTK_MISC (labeled_image->details->image),
+ x_alignment,
+ y_alignment);
+ }
+ }
+}
+
+static EelDimensions
+labeled_image_get_content_dimensions (const EelLabeledImage *labeled_image)
+{
+ EelDimensions image_dimensions;
+ EelDimensions label_dimensions;
+ EelDimensions content_dimensions;
+
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ image_dimensions = labeled_image_get_image_dimensions (labeled_image);
+ label_dimensions = labeled_image_get_label_dimensions (labeled_image);
+
+ content_dimensions = eel_dimensions_empty;
+
+ /* Both shown */
+ if (!eel_dimensions_are_empty (image_dimensions) && !eel_dimensions_are_empty (label_dimensions))
+ {
+ content_dimensions.width =
+ image_dimensions.width + labeled_image->details->spacing + label_dimensions.width;
+ switch (labeled_image->details->label_position)
+ {
+ case GTK_POS_LEFT:
+ case GTK_POS_RIGHT:
+ content_dimensions.width =
+ image_dimensions.width + labeled_image->details->spacing + label_dimensions.width;
+ content_dimensions.height = MAX (image_dimensions.height, label_dimensions.height);
+ break;
+
+ case GTK_POS_TOP:
+ case GTK_POS_BOTTOM:
+ content_dimensions.width = MAX (image_dimensions.width, label_dimensions.width);
+ content_dimensions.height =
+ image_dimensions.height + labeled_image->details->spacing + label_dimensions.height;
+ break;
+ }
+ /* Only image shown */
+ }
+ else if (!eel_dimensions_are_empty (image_dimensions))
+ {
+ content_dimensions.width = image_dimensions.width;
+ content_dimensions.height = image_dimensions.height;
+ /* Only label shown */
+ }
+ else
+ {
+ content_dimensions.width = label_dimensions.width;
+ content_dimensions.height = label_dimensions.height;
+ }
+
+ return content_dimensions;
+}
+
+static EelIRect
+labeled_image_get_content_bounds (const EelLabeledImage *labeled_image)
+{
+ EelDimensions content_dimensions;
+ EelIRect content_bounds;
+ EelIRect bounds;
+
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ bounds = eel_gtk_widget_get_bounds (GTK_WIDGET (labeled_image));
+
+ content_dimensions = labeled_image_get_content_dimensions (labeled_image);
+ content_bounds = eel_irect_align (bounds,
+ content_dimensions.width,
+ content_dimensions.height,
+ labeled_image->details->x_alignment,
+ labeled_image->details->y_alignment);
+
+ return content_bounds;
+}
+
+static void
+labeled_image_ensure_label (EelLabeledImage *labeled_image)
+{
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (labeled_image->details->label != NULL)
+ {
+ return;
+ }
+
+ labeled_image->details->label = gtk_label_new (NULL);
+ gtk_container_add (GTK_CONTAINER (labeled_image), labeled_image->details->label);
+ gtk_widget_show (labeled_image->details->label);
+}
+
+static void
+labeled_image_ensure_image (EelLabeledImage *labeled_image)
+{
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (labeled_image->details->image != NULL)
+ {
+ return;
+ }
+
+ labeled_image->details->image = gtk_image_new ();
+ gtk_container_add (GTK_CONTAINER (labeled_image), labeled_image->details->image);
+ gtk_widget_show (labeled_image->details->image);
+}
+
+static gboolean
+labeled_image_show_image (const EelLabeledImage *labeled_image)
+{
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ return labeled_image->details->image != NULL && labeled_image->details->show_image;
+}
+
+static gboolean
+labeled_image_show_label (const EelLabeledImage *labeled_image)
+{
+ g_assert (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ return labeled_image->details->label != NULL && labeled_image->details->show_label;
+}
+
+/**
+ * eel_labeled_image_new:
+ * @text: Text to use for label or NULL.
+ * @pixbuf: Pixbuf to use for image or NULL.
+ *
+ * Returns A newly allocated EelLabeledImage. If the &text parameter is not
+ * NULL then the LabeledImage will show a label. If the &pixbuf parameter is not
+ * NULL then the LabeledImage will show a pixbuf. Either of these can be NULL at
+ * creation time.
+ *
+ * Later in the lifetime of the widget you can invoke methods that affect the
+ * label and/or the image. If at creation time these were NULL, then they will
+ * be created as neeeded.
+ *
+ * Thus, using this widget in place of EelImage or EelLabel is "free" with
+ * only the GtkObject and function call overhead.
+ *
+ */
+GtkWidget*
+eel_labeled_image_new (const char *text,
+ GdkPixbuf *pixbuf)
+{
+ EelLabeledImage *labeled_image;
+
+ labeled_image = EEL_LABELED_IMAGE (gtk_widget_new (eel_labeled_image_get_type (), NULL));
+
+ if (text != NULL)
+ {
+ eel_labeled_image_set_text (labeled_image, text);
+ }
+
+ if (pixbuf != NULL)
+ {
+ eel_labeled_image_set_pixbuf (labeled_image, pixbuf);
+ }
+
+ labeled_image_update_alignments (labeled_image);
+
+ return GTK_WIDGET (labeled_image);
+}
+
+/**
+ * eel_labeled_image_new_from_file_name:
+ * @text: Text to use for label or NULL.
+ * @file_name: File name of picture to use for pixbuf. Cannot be NULL.
+ *
+ * Returns A newly allocated EelLabeledImage. If the &text parameter is not
+ * NULL then the LabeledImage will show a label.
+ *
+ */
+GtkWidget*
+eel_labeled_image_new_from_file_name (const char *text,
+ const char *pixbuf_file_name)
+{
+ EelLabeledImage *labeled_image;
+
+ g_return_val_if_fail (pixbuf_file_name != NULL, NULL);
+
+ labeled_image = EEL_LABELED_IMAGE (eel_labeled_image_new (text, NULL));
+ eel_labeled_image_set_pixbuf_from_file_name (labeled_image, pixbuf_file_name);
+ return GTK_WIDGET (labeled_image);
+}
+
+/**
+ * eel_labeled_image_set_label_position:
+ * @labeled_image: A EelLabeledImage.
+ * @label_position: The position of the label with respect to the image.
+ *
+ * Set the position of the label with respect to the image as follows:
+ *
+ * GTK_POS_LEFT:
+ * [ <label> <image> ]
+ *
+ * GTK_POS_RIGHT:
+ * [ <image> <label> ]
+ *
+ * GTK_POS_TOP:
+ * [ <label> ]
+ * [ <image> ]
+ *
+ * GTK_POS_BOTTOM:
+ * [ <image> ]
+ * [ <label> ]
+ *
+ */
+void
+eel_labeled_image_set_label_position (EelLabeledImage *labeled_image,
+ GtkPositionType label_position)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+ g_return_if_fail (label_position >= GTK_POS_LEFT);
+ g_return_if_fail (label_position <= GTK_POS_BOTTOM);
+
+ if (labeled_image->details->label_position == label_position)
+ {
+ return;
+ }
+
+ labeled_image->details->label_position = label_position;
+
+ labeled_image_update_alignments (labeled_image);
+
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_get_label_postiion:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Returns an enumeration indicating the position of the label with respect to the image.
+ */
+GtkPositionType
+eel_labeled_image_get_label_position (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), 0);
+
+ return labeled_image->details->label_position;
+}
+
+/**
+ * eel_labeled_image_set_show_label:
+ * @labeled_image: A EelLabeledImage.
+ * @show_image: A boolean value indicating whether the label should be shown.
+ *
+ * Update the labeled image to either show or hide the internal label widget.
+ * This function doesnt have any effect if the LabeledImage doesnt already
+ * contain an label.
+ */
+void
+eel_labeled_image_set_show_label (EelLabeledImage *labeled_image,
+ gboolean show_label)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (labeled_image->details->show_label == show_label)
+ {
+ return;
+ }
+
+ labeled_image->details->show_label = show_label;
+
+ if (labeled_image->details->label != NULL)
+ {
+ if (labeled_image->details->show_label)
+ {
+ gtk_widget_show (labeled_image->details->label);
+ }
+ else
+ {
+ gtk_widget_hide (labeled_image->details->label);
+ }
+ }
+
+ labeled_image_update_alignments (labeled_image);
+
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_get_show_label:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Returns a boolean value indicating whether the internal label is shown.
+ */
+gboolean
+eel_labeled_image_get_show_label (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), 0);
+
+ return labeled_image->details->show_label;
+}
+
+/**
+ * eel_labeled_image_set_show_image:
+ * @labeled_image: A EelLabeledImage.
+ * @show_image: A boolean value indicating whether the image should be shown.
+ *
+ * Update the labeled image to either show or hide the internal image widget.
+ * This function doesnt have any effect if the LabeledImage doesnt already
+ * contain an image.
+ */
+void
+eel_labeled_image_set_show_image (EelLabeledImage *labeled_image,
+ gboolean show_image)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (labeled_image->details->show_image == show_image)
+ {
+ return;
+ }
+
+ labeled_image->details->show_image = show_image;
+
+ if (labeled_image->details->image != NULL)
+ {
+ if (labeled_image->details->show_image)
+ {
+ gtk_widget_show (labeled_image->details->image);
+ }
+ else
+ {
+ gtk_widget_hide (labeled_image->details->image);
+ }
+ }
+
+ labeled_image_update_alignments (labeled_image);
+
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_get_show_image:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Returns a boolean value indicating whether the internal image is shown.
+ */
+gboolean
+eel_labeled_image_get_show_image (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), 0);
+
+ return labeled_image->details->show_image;
+}
+
+
+/**
+ * eel_labeled_image_set_fixed_image_height:
+ * @labeled_image: A EelLabeledImage.
+ * @fixed_image_height: The new fixed image height.
+ *
+ * Normally, we measure the height of images, but it's sometimes useful
+ * to use a fixed height for all the images. This routine sets the
+ * image height to the passed in value
+ *
+ */
+void
+eel_labeled_image_set_fixed_image_height (EelLabeledImage *labeled_image,
+ int new_height)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (labeled_image->details->fixed_image_height == new_height)
+ {
+ return;
+ }
+
+ labeled_image->details->fixed_image_height = new_height;
+
+ labeled_image_update_alignments (labeled_image);
+
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_set_selected:
+ * @labeled_image: A EelLabeledImage.
+ * @selected: A boolean value indicating whether the labeled image
+ * should be selected.
+ *
+ * Selects or deselects the labeled image.
+ *
+ */
+void
+eel_labeled_image_set_selected (EelLabeledImage *labeled_image,
+ gboolean selected)
+{
+ GtkStateType state;
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ state = selected ? GTK_STATE_SELECTED : GTK_STATE_NORMAL;
+
+ gtk_widget_set_state (GTK_WIDGET (labeled_image), state);
+ gtk_widget_set_state (labeled_image->details->image, state);
+ gtk_widget_set_state (labeled_image->details->label, state);
+}
+
+/**
+ * eel_labeled_image_get_selected:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Returns the selected state of the labeled image.
+ *
+ */
+gboolean
+eel_labeled_image_get_selected (EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), FALSE);
+
+ return gtk_widget_get_state (GTK_WIDGET (labeled_image)) == GTK_STATE_SELECTED;
+}
+
+/**
+ * eel_labeled_image_set_spacing:
+ * @labeled_image: A EelLabeledImage.
+ * @spacing: The new spacing between label and image.
+ *
+ * Set the spacing between label and image. This will only affect
+ * the geometry of the widget if both a label and image are currently
+ * visible.
+ *
+ */
+void
+eel_labeled_image_set_spacing (EelLabeledImage *labeled_image,
+ guint spacing)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (labeled_image->details->spacing == spacing)
+ {
+ return;
+ }
+
+ labeled_image->details->spacing = spacing;
+
+ labeled_image_update_alignments (labeled_image);
+
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_get_spacing:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Returns: The spacing between the label and image.
+ */
+guint
+eel_labeled_image_get_spacing (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), 0);
+
+ return labeled_image->details->spacing;
+}
+
+/**
+ * eel_labeled_image_set_x_padding:
+ * @labeled_image: A EelLabeledImage.
+ * @x_padding: The new horizontal padding.
+ *
+ * Set horizontal padding for the EelLabeledImage. The padding
+ * attribute work just like that in GtkMisc.
+ */
+void
+eel_labeled_image_set_x_padding (EelLabeledImage *labeled_image,
+ int x_padding)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ x_padding = MAX (0, x_padding);
+
+ if (labeled_image->details->x_padding == x_padding)
+ {
+ return;
+ }
+
+ labeled_image->details->x_padding = x_padding;
+ labeled_image_update_alignments (labeled_image);
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_get_x_padding:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Returns: The horizontal padding for the LabeledImage's content.
+ */
+int
+eel_labeled_image_get_x_padding (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), 0);
+
+ return labeled_image->details->x_padding;
+}
+
+/**
+ * eel_labeled_image_set_y_padding:
+ * @labeled_image: A EelLabeledImage.
+ * @x_padding: The new vertical padding.
+ *
+ * Set vertical padding for the EelLabeledImage. The padding
+ * attribute work just like that in GtkMisc.
+ */
+void
+eel_labeled_image_set_y_padding (EelLabeledImage *labeled_image,
+ int y_padding)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ y_padding = MAX (0, y_padding);
+
+ if (labeled_image->details->y_padding == y_padding)
+ {
+ return;
+ }
+
+ labeled_image->details->y_padding = y_padding;
+ labeled_image_update_alignments (labeled_image);
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_get_x_padding:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Returns: The vertical padding for the LabeledImage's content.
+ */
+int
+eel_labeled_image_get_y_padding (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), 0);
+
+ return labeled_image->details->y_padding;
+}
+
+/**
+ * eel_labeled_image_set_x_alignment:
+ * @labeled_image: A EelLabeledImage.
+ * @x_alignment: The new horizontal alignment.
+ *
+ * Set horizontal alignment for the EelLabeledImage's content.
+ * The 'content' is the union of the image and label. The alignment
+ * attribute work just like that in GtkMisc.
+ */
+void
+eel_labeled_image_set_x_alignment (EelLabeledImage *labeled_image,
+ float x_alignment)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ x_alignment = MAX (0, x_alignment);
+ x_alignment = MIN (1.0, x_alignment);
+
+ if (labeled_image->details->x_alignment == x_alignment)
+ {
+ return;
+ }
+
+ labeled_image->details->x_alignment = x_alignment;
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_get_x_alignment:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Returns: The horizontal alignment for the LabeledImage's content.
+ */
+float
+eel_labeled_image_get_x_alignment (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), 0);
+
+ return labeled_image->details->x_alignment;
+}
+
+/**
+ * eel_labeled_image_set_y_alignment:
+ * @labeled_image: A EelLabeledImage.
+ * @y_alignment: The new vertical alignment.
+ *
+ * Set vertical alignment for the EelLabeledImage's content.
+ * The 'content' is the union of the image and label. The alignment
+ * attribute work just like that in GtkMisc.
+ */
+void
+eel_labeled_image_set_y_alignment (EelLabeledImage *labeled_image,
+ float y_alignment)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ y_alignment = MAX (0, y_alignment);
+ y_alignment = MIN (1.0, y_alignment);
+
+ if (labeled_image->details->y_alignment == y_alignment)
+ {
+ return;
+ }
+
+ labeled_image->details->y_alignment = y_alignment;
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_get_y_alignment:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Returns: The vertical alignment for the LabeledImage's content.
+ */
+float
+eel_labeled_image_get_y_alignment (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), 0);
+
+ return labeled_image->details->y_alignment;
+}
+
+/**
+ * eel_labeled_image_set_fill:
+ * @labeled_image: A EelLabeledImage.
+ * @fill: A boolean value indicating whether the internal image and label
+ * widgets should fill all the available allocation.
+ *
+ * By default the internal image and label wigets are sized to their natural
+ * preferred geometry. You can use the 'fill' attribute of LabeledImage
+ * to have the internal widgets fill as much of the LabeledImage allocation
+ * as is available.
+ */
+void
+eel_labeled_image_set_fill (EelLabeledImage *labeled_image,
+ gboolean fill)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (labeled_image->details->fill == fill)
+ {
+ return;
+ }
+
+ labeled_image->details->fill = fill;
+
+ labeled_image_update_alignments (labeled_image);
+
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+}
+
+/**
+ * eel_labeled_image_get_fill:
+ * @labeled_image: A EelLabeledImage.
+ *
+ * Retruns a boolean value indicating whether the internal widgets fill
+ * all the available allocation.
+ */
+gboolean
+eel_labeled_image_get_fill (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), 0);
+
+ return labeled_image->details->fill;
+}
+
+static void
+eel_labled_set_mnemonic_widget (GtkWidget *image_widget,
+ GtkWidget *mnemonic_widget)
+{
+ EelLabeledImage *image;
+
+ g_assert (EEL_IS_LABELED_IMAGE (image_widget));
+
+ image = EEL_LABELED_IMAGE (image_widget);
+
+ if (image->details->label)
+ gtk_label_set_mnemonic_widget
+ (GTK_LABEL (image->details->label), mnemonic_widget);
+}
+
+/**
+ * eel_labeled_image_button_new:
+ * @text: Text to use for label or NULL.
+ * @pixbuf: Pixbuf to use for image or NULL.
+ *
+ * Create a stock GtkButton with a EelLabeledImage child.
+ *
+ */
+GtkWidget *
+eel_labeled_image_button_new (const char *text,
+ GdkPixbuf *pixbuf)
+{
+ GtkWidget *button;
+ GtkWidget *labeled_image;
+
+ button = g_object_new (eel_labeled_image_button_get_type (), NULL);
+ labeled_image = eel_labeled_image_new (text, pixbuf);
+ gtk_container_add (GTK_CONTAINER (button), labeled_image);
+ eel_labled_set_mnemonic_widget (labeled_image, button);
+ gtk_widget_show (labeled_image);
+
+ return button;
+}
+
+/**
+ * eel_labeled_image_button_new_from_file_name:
+ * @text: Text to use for label or NULL.
+ * @pixbuf_file_name: Name of pixbuf to use for image. Cannot be NULL.
+ *
+ * Create a stock GtkToggleButton with a EelLabeledImage child.
+ *
+ */
+GtkWidget *
+eel_labeled_image_button_new_from_file_name (const char *text,
+ const char *pixbuf_file_name)
+{
+ GtkWidget *button;
+ GtkWidget *labeled_image;
+
+ g_return_val_if_fail (pixbuf_file_name != NULL, NULL);
+
+ button = g_object_new (eel_labeled_image_button_get_type (), NULL);
+ labeled_image = eel_labeled_image_new_from_file_name (text, pixbuf_file_name);
+ gtk_container_add (GTK_CONTAINER (button), labeled_image);
+ eel_labled_set_mnemonic_widget (labeled_image, button);
+ gtk_widget_show (labeled_image);
+
+ return button;
+}
+
+/**
+ * eel_labeled_image_toggle_button_new:
+ * @text: Text to use for label or NULL.
+ * @pixbuf: Pixbuf to use for image or NULL.
+ *
+ * Create a stock GtkToggleButton with a EelLabeledImage child.
+ *
+ */
+GtkWidget *
+eel_labeled_image_toggle_button_new (const char *text,
+ GdkPixbuf *pixbuf)
+{
+ GtkWidget *toggle_button;
+ GtkWidget *labeled_image;
+
+ toggle_button = g_object_new (eel_labeled_image_toggle_button_get_type (), NULL);
+ labeled_image = eel_labeled_image_new (text, pixbuf);
+ gtk_container_add (GTK_CONTAINER (toggle_button), labeled_image);
+ eel_labled_set_mnemonic_widget (labeled_image, toggle_button);
+ gtk_widget_show (labeled_image);
+
+ return toggle_button;
+}
+
+/**
+ * eel_labeled_image_toggle_button_new_from_file_name:
+ * @text: Text to use for label or NULL.
+ * @pixbuf_file_name: Name of pixbuf to use for image. Cannot be NULL.
+ *
+ * Create a stock GtkToggleButton with a EelLabeledImage child.
+ *
+ */
+GtkWidget *
+eel_labeled_image_toggle_button_new_from_file_name (const char *text,
+ const char *pixbuf_file_name)
+{
+ GtkWidget *toggle_button;
+ GtkWidget *labeled_image;
+
+ g_return_val_if_fail (pixbuf_file_name != NULL, NULL);
+
+ toggle_button = g_object_new (eel_labeled_image_toggle_button_get_type (), NULL);
+ labeled_image = eel_labeled_image_new_from_file_name (text, pixbuf_file_name);
+ gtk_container_add (GTK_CONTAINER (toggle_button), labeled_image);
+ eel_labled_set_mnemonic_widget (labeled_image, toggle_button);
+ gtk_widget_show (labeled_image);
+
+ return toggle_button;
+}
+
+/**
+ * eel_labeled_image_toggle_button_new:
+ * @text: Text to use for label or NULL.
+ * @pixbuf: Pixbuf to use for image or NULL.
+ *
+ * Create a stock GtkToggleButton with a EelLabeledImage child.
+ *
+ * Returns: the new radio button.
+ */
+GtkWidget *
+eel_labeled_image_radio_button_new (const char *text,
+ GdkPixbuf *pixbuf)
+{
+ GtkWidget *radio_button;
+ GtkWidget *labeled_image;
+
+ radio_button = g_object_new (eel_labeled_image_radio_button_get_type (), NULL);
+ labeled_image = eel_labeled_image_new (text, pixbuf);
+ gtk_container_add (GTK_CONTAINER (radio_button), labeled_image);
+ eel_labled_set_mnemonic_widget (labeled_image, radio_button);
+ gtk_widget_show (labeled_image);
+
+ return radio_button;
+}
+
+/**
+ * eel_labeled_image_radio_button_new_from_file_name:
+ * @text: Text to use for label or NULL.
+ * @pixbuf_file_name: Name of pixbuf to use for image. Cannot be NULL.
+ *
+ * Create a stock GtkRadioButton with a EelLabeledImage child.
+ *
+ * Returns: the new radio button.
+ */
+GtkWidget *
+eel_labeled_image_radio_button_new_from_file_name (const char *text,
+ const char *pixbuf_file_name)
+{
+ GtkWidget *radio_button;
+ GtkWidget *labeled_image;
+
+ g_return_val_if_fail (pixbuf_file_name != NULL, NULL);
+
+ radio_button = g_object_new (eel_labeled_image_radio_button_get_type (), NULL);
+ labeled_image = eel_labeled_image_new_from_file_name (text, pixbuf_file_name);
+ gtk_container_add (GTK_CONTAINER (radio_button), labeled_image);
+ eel_labled_set_mnemonic_widget (labeled_image, radio_button);
+ gtk_widget_show (labeled_image);
+
+ return radio_button;
+}
+
+/*
+ * Workaround some bugs in GtkCheckButton where the widget
+ * does not redraw properly after leave or focus out events
+ *
+ * The workaround is to draw a little bit more than the
+ * widget itself - 4 pixels worth. For some reason the
+ * widget does not properly redraw its edges.
+ */
+static void
+button_leave_callback (GtkWidget *widget,
+ gpointer callback_data)
+{
+ g_assert (GTK_IS_WIDGET (widget));
+
+ if (gtk_widget_is_drawable (widget))
+ {
+ const int fudge = 4;
+ EelIRect bounds;
+
+ bounds = eel_gtk_widget_get_bounds (widget);
+
+ bounds.x0 -= fudge;
+ bounds.y0 -= fudge;
+ bounds.x1 += fudge;
+ bounds.y1 += fudge;
+
+ gtk_widget_queue_draw_area (gtk_widget_get_parent (widget),
+ bounds.x0,
+ bounds.y0,
+ eel_irect_get_width (bounds),
+ eel_irect_get_height (bounds));
+ }
+}
+
+static gint
+button_focus_out_event_callback (GtkWidget *widget,
+ GdkEventFocus *event,
+ gpointer callback_data)
+{
+ g_assert (GTK_IS_WIDGET (widget));
+
+ button_leave_callback (widget, callback_data);
+
+ return FALSE;
+}
+
+/**
+ * eel_labeled_image_check_button_new:
+ * @text: Text to use for label or NULL.
+ * @pixbuf: Pixbuf to use for image or NULL.
+ *
+ * Create a stock GtkCheckButton with a EelLabeledImage child.
+ *
+ */
+GtkWidget *
+eel_labeled_image_check_button_new (const char *text,
+ GdkPixbuf *pixbuf)
+{
+ GtkWidget *check_button;
+ GtkWidget *labeled_image;
+
+ check_button = g_object_new (eel_labeled_image_check_button_get_type (), NULL);
+ labeled_image = eel_labeled_image_new (text, pixbuf);
+ gtk_container_add (GTK_CONTAINER (check_button), labeled_image);
+ eel_labled_set_mnemonic_widget (labeled_image, check_button);
+ gtk_widget_show (labeled_image);
+
+ /*
+ * Workaround some bugs in GtkCheckButton where the widget
+ * does not redraw properly after leave or focus out events
+ */
+ g_signal_connect (check_button, "leave",
+ G_CALLBACK (button_leave_callback), NULL);
+ g_signal_connect (check_button, "focus_out_event",
+ G_CALLBACK (button_focus_out_event_callback), NULL);
+
+ return check_button;
+}
+
+/**
+ * eel_labeled_image_check_button_new_from_file_name:
+ * @text: Text to use for label or NULL.
+ * @pixbuf_file_name: Name of pixbuf to use for image. Cannot be NULL.
+ *
+ * Create a stock GtkCheckButton with a EelLabeledImage child.
+ *
+ */
+GtkWidget *
+eel_labeled_image_check_button_new_from_file_name (const char *text,
+ const char *pixbuf_file_name)
+{
+ GtkWidget *check_button;
+ GtkWidget *labeled_image;
+
+ g_return_val_if_fail (pixbuf_file_name != NULL, NULL);
+
+ check_button = g_object_new (eel_labeled_image_check_button_get_type (), NULL);
+ labeled_image = eel_labeled_image_new_from_file_name (text, pixbuf_file_name);
+ gtk_container_add (GTK_CONTAINER (check_button), labeled_image);
+ eel_labled_set_mnemonic_widget (labeled_image, check_button);
+ gtk_widget_show (labeled_image);
+
+ return check_button;
+}
+
+/*
+ * The rest of the methods are proxies for those in EelImage and
+ * EelLabel. We have all these so that we dont have to expose
+ * our internal widgets at all. Probably more of these will be added
+ * as they are needed.
+ */
+
+/**
+ * eel_labeled_image_set_pixbuf:
+ * @labaled_image: A EelLabeledImage.
+ * @pixbuf: New pixbuf to use or NULL.
+ *
+ * Change the pixbuf displayed by the LabeledImage. Note that the widget display
+ * is only updated if the show_image attribute is TRUE.
+ *
+ * If no internal image widget exists as of yet, a new one will be created.
+ *
+ * A NULL &pixbuf will cause the internal image widget (if alive) to be destroyed.
+ */
+void
+eel_labeled_image_set_pixbuf (EelLabeledImage *labeled_image,
+ GdkPixbuf *pixbuf)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (pixbuf == NULL)
+ {
+ if (labeled_image->details->image != NULL)
+ {
+ gtk_widget_destroy (labeled_image->details->image);
+ labeled_image->details->image = NULL;
+ }
+
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+ }
+ else
+ {
+ labeled_image_ensure_image (labeled_image);
+ gtk_image_set_from_pixbuf (GTK_IMAGE (labeled_image->details->image), pixbuf);
+ }
+}
+
+void
+eel_labeled_image_set_pixbuf_from_file_name (EelLabeledImage *labeled_image,
+ const char *pixbuf_file_name)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ labeled_image_ensure_image (labeled_image);
+ gtk_image_set_from_file (GTK_IMAGE (labeled_image->details->image), pixbuf_file_name);
+}
+
+/**
+ * eel_labeled_image_set_text:
+ * @labaled_image: A EelLabeledImage.
+ * @text: New text (with mnemnonic) to use or NULL.
+ *
+ * Change the text displayed by the LabeledImage. Note that the widget display
+ * is only updated if the show_label attribute is TRUE.
+ *
+ * If no internal label widget exists as of yet, a new one will be created.
+ *
+ * A NULL &text will cause the internal label widget (if alive) to be destroyed.
+ */
+void
+eel_labeled_image_set_text (EelLabeledImage *labeled_image,
+ const char *text)
+{
+ g_return_if_fail (EEL_IS_LABELED_IMAGE (labeled_image));
+
+ if (text == NULL)
+ {
+ if (labeled_image->details->label)
+ {
+ gtk_widget_destroy (labeled_image->details->label);
+ labeled_image->details->label = NULL;
+ }
+
+ gtk_widget_queue_resize (GTK_WIDGET (labeled_image));
+ }
+ else
+ {
+ labeled_image_ensure_label (labeled_image);
+ gtk_label_set_text_with_mnemonic
+ (GTK_LABEL (labeled_image->details->label), text);
+ }
+}
+
+char *
+eel_labeled_image_get_text (const EelLabeledImage *labeled_image)
+{
+ g_return_val_if_fail (EEL_IS_LABELED_IMAGE (labeled_image), NULL);
+
+ if (labeled_image->details->label == NULL)
+ {
+ return NULL;
+ }
+
+ return g_strdup (gtk_label_get_text (GTK_LABEL (labeled_image->details->label)));
+}
+
+void
+eel_labeled_image_set_can_focus (EelLabeledImage *labeled_image,
+ gboolean can_focus)
+{
+ gtk_widget_set_can_focus (GTK_WIDGET (labeled_image), can_focus);
+}
+
+static AtkObjectClass *a11y_parent_class = NULL;
+
+static void
+eel_labeled_image_accessible_initialize (AtkObject *accessible,
+ gpointer widget)
+{
+ a11y_parent_class->initialize (accessible, widget);
+}
+
+static EelLabeledImage *
+get_image (gpointer object)
+{
+ GtkWidget *widget;
+
+ if (!(widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (object))))
+ {
+ return NULL;
+ }
+
+ if (GTK_IS_BUTTON (widget))
+ widget = gtk_bin_get_child (GTK_BIN (widget));
+
+ return EEL_LABELED_IMAGE (widget);
+}
+
+static const gchar* eel_labeled_image_accessible_get_name(AtkObject* accessible)
+{
+ EelLabeledImage* labeled_image;
+
+ labeled_image = get_image(accessible);
+
+ if (labeled_image && labeled_image->details && labeled_image->details->label)
+ {
+ return gtk_label_get_text(GTK_LABEL(labeled_image->details->label));
+ }
+
+ g_warning("no label on '%p'", labeled_image);
+
+ return NULL;
+}
+
+static void
+eel_labeled_image_accessible_image_get_size (AtkImage *image,
+ gint *width,
+ gint *height)
+{
+ EelLabeledImage *labeled_image;
+ GtkAllocation allocation;
+
+ labeled_image = get_image (image);
+
+ if (!labeled_image || !labeled_image->details->image)
+ {
+ *width = *height = 0;
+ return;
+ }
+
+ gtk_widget_get_allocation (labeled_image->details->image, &allocation);
+ *width = allocation.width;
+ *height = allocation.height;
+}
+
+static void
+eel_labeled_image_accessible_image_interface_init (AtkImageIface *iface)
+{
+ iface->get_image_size = eel_labeled_image_accessible_image_get_size;
+}
+
+static void
+eel_labeled_image_accessible_class_init (AtkObjectClass *klass)
+{
+ a11y_parent_class = g_type_class_peek_parent (klass);
+
+ klass->get_name = eel_labeled_image_accessible_get_name;
+ klass->initialize = eel_labeled_image_accessible_initialize;
+}
+
+enum
+{
+ BUTTON,
+ CHECK,
+ TOGGLE,
+ RADIO,
+ PLAIN,
+ LAST_ONE
+};
+
+static AtkObject *
+eel_labeled_image_get_accessible (GtkWidget *widget)
+{
+ int i;
+ static GType types[LAST_ONE] = { 0 };
+ const char *tname;
+ AtkRole role;
+ AtkObject *accessible;
+
+ if ((accessible = eel_accessibility_get_atk_object (widget)))
+ return accessible;
+
+ if (GTK_IS_CHECK_BUTTON (widget))
+ {
+ i = BUTTON;
+ role = ATK_ROLE_CHECK_BOX;
+ tname = "EelLabeledImageCheckButtonAccessible";
+
+ }
+ else if (GTK_IS_TOGGLE_BUTTON (widget))
+ {
+ i = CHECK;
+ role = ATK_ROLE_TOGGLE_BUTTON;
+ tname = "EelLabeledImageToggleButtonAccessible";
+
+ }
+ else if (GTK_IS_RADIO_BUTTON (widget))
+ {
+ i = RADIO;
+ role = ATK_ROLE_RADIO_BUTTON;
+ tname = "EelLabeledImageRadioButtonAccessible";
+
+ }
+ else if (GTK_IS_BUTTON (widget))
+ {
+ i = TOGGLE;
+ role = ATK_ROLE_PUSH_BUTTON;
+ tname = "EelLabeledImagePushButtonAccessible";
+
+ }
+ else /* plain */
+ {
+ i = PLAIN;
+ role = ATK_ROLE_IMAGE;
+ tname = "EelLabeledImagePlainAccessible";
+ }
+
+ if (!types [i])
+ {
+ const GInterfaceInfo atk_image_info =
+ {
+ (GInterfaceInitFunc) eel_labeled_image_accessible_image_interface_init,
+ (GInterfaceFinalizeFunc) NULL,
+ NULL
+ };
+
+ types [i] = eel_accessibility_create_derived_type
+ (tname, G_TYPE_FROM_INSTANCE (widget),
+ eel_labeled_image_accessible_class_init);
+
+ if (!types [i])
+ return NULL;
+
+ g_type_add_interface_static (
+ types [i], ATK_TYPE_IMAGE, &atk_image_info);
+ }
+
+ accessible = g_object_new (types [i], NULL);
+ atk_object_set_role (accessible, role);
+
+ return eel_accessibility_set_atk_object_return (widget, accessible);
+}
+
+static void
+eel_labeled_image_button_class_init (GtkWidgetClass *klass)
+{
+ klass->get_accessible = eel_labeled_image_get_accessible;
+}
+
+static GType
+eel_labeled_image_button_get_type (void)
+{
+ static GType type = 0;
+
+ if (!type)
+ {
+ GTypeInfo info =
+ {
+ sizeof (GtkButtonClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) eel_labeled_image_button_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkButton),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) NULL
+ };
+
+ type = g_type_register_static
+ (GTK_TYPE_BUTTON,
+ "EelLabeledImageButton", &info, 0);
+ }
+
+ return type;
+}
+
+static GType
+eel_labeled_image_check_button_get_type (void)
+{
+ static GType type = 0;
+
+ if (!type)
+ {
+ GTypeInfo info =
+ {
+ sizeof (GtkCheckButtonClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) eel_labeled_image_button_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkCheckButton),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) NULL
+ };
+
+ type = g_type_register_static
+ (GTK_TYPE_CHECK_BUTTON,
+ "EelLabeledImageCheckButton", &info, 0);
+ }
+
+ return type;
+}
+
+static GType
+eel_labeled_image_toggle_button_get_type (void)
+{
+ static GType type = 0;
+
+ if (!type)
+ {
+ GTypeInfo info =
+ {
+ sizeof (GtkToggleButtonClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) eel_labeled_image_button_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkToggleButton),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) NULL
+ };
+
+ type = g_type_register_static
+ (GTK_TYPE_TOGGLE_BUTTON,
+ "EelLabeledImageToggleButton", &info, 0);
+ }
+
+ return type;
+}
+
+
+static GType
+eel_labeled_image_radio_button_get_type (void)
+{
+ static GType type = 0;
+
+ if (!type)
+ {
+ GTypeInfo info =
+ {
+ sizeof (GtkRadioButtonClass),
+ (GBaseInitFunc) NULL,
+ (GBaseFinalizeFunc) NULL,
+ (GClassInitFunc) eel_labeled_image_button_class_init,
+ NULL, /* class_finalize */
+ NULL, /* class_data */
+ sizeof (GtkRadioButton),
+ 0, /* n_preallocs */
+ (GInstanceInitFunc) NULL
+ };
+
+ type = g_type_register_static
+ (GTK_TYPE_RADIO_BUTTON,
+ "EelLabeledImageRadioButton", &info, 0);
+ }
+
+ return type;
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-07-06 18:27:34 +0000