aboutsummaryrefslogtreecommitdiffstats
path: root/e-util/e-image-chooser.c
diff options
context:
space:
mode:
Diffstat (limited to 'e-util/e-image-chooser.c')
-rw-r--r--e-util/e-image-chooser.c562
1 files changed, 562 insertions, 0 deletions
diff --git a/e-util/e-image-chooser.c b/e-util/e-image-chooser.c
new file mode 100644
index 0000000000..20c2f0e473
--- /dev/null
+++ b/e-util/e-image-chooser.c
@@ -0,0 +1,562 @@
+/*
+ * e-image-chooser.c
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) version 3.
+ *
+ * This program 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the program; if not, see <http://www.gnu.org/licenses/>
+ *
+ *
+ * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#include <glib/gi18n.h>
+
+#include "e-image-chooser.h"
+
+#include "e-icon-factory.h"
+
+#define E_IMAGE_CHOOSER_GET_PRIVATE(obj) \
+ (G_TYPE_INSTANCE_GET_PRIVATE \
+ ((obj), E_TYPE_IMAGE_CHOOSER, EImageChooserPrivate))
+
+struct _EImageChooserPrivate {
+ GtkWidget *frame;
+ GtkWidget *image;
+
+ gchar *image_buf;
+ gint image_buf_size;
+ gint image_width;
+ gint image_height;
+
+ /* Default Image */
+ gchar *icon_name;
+};
+
+enum {
+ PROP_0,
+ PROP_ICON_NAME
+};
+
+enum {
+ CHANGED,
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+#define URI_LIST_TYPE "text/uri-list"
+
+G_DEFINE_TYPE (
+ EImageChooser,
+ e_image_chooser,
+ GTK_TYPE_VBOX)
+
+static gboolean
+set_image_from_data (EImageChooser *chooser,
+ gchar *data,
+ gint length)
+{
+ GdkPixbufLoader *loader;
+ GdkPixbuf *pixbuf;
+ gfloat scale;
+ gint new_height;
+ gint new_width;
+
+ loader = gdk_pixbuf_loader_new ();
+ gdk_pixbuf_loader_write (loader, (guchar *) data, length, NULL);
+ gdk_pixbuf_loader_close (loader, NULL);
+
+ pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
+ if (pixbuf)
+ g_object_ref (pixbuf);
+
+ g_object_unref (loader);
+
+ if (pixbuf == NULL)
+ return FALSE;
+
+ new_height = gdk_pixbuf_get_height (pixbuf);
+ new_width = gdk_pixbuf_get_width (pixbuf);
+
+ if (chooser->priv->image_height == 0
+ && chooser->priv->image_width == 0) {
+ scale = 1.0;
+ } else if (chooser->priv->image_height < new_height
+ || chooser->priv->image_width < new_width) {
+ /* we need to scale down */
+ if (new_height > new_width)
+ scale = (gfloat) chooser->priv->image_height / new_height;
+ else
+ scale = (gfloat) chooser->priv->image_width / new_width;
+ } else {
+ /* we need to scale up */
+ if (new_height > new_width)
+ scale = (gfloat) new_height / chooser->priv->image_height;
+ else
+ scale = (gfloat) new_width / chooser->priv->image_width;
+ }
+
+ if (scale == 1.0) {
+ gtk_image_set_from_pixbuf (
+ GTK_IMAGE (chooser->priv->image), pixbuf);
+ chooser->priv->image_width = new_width;
+ chooser->priv->image_height = new_height;
+ } else {
+ GdkPixbuf *scaled;
+ GdkPixbuf *composite;
+
+ new_width *= scale;
+ new_height *= scale;
+ new_width = MIN (new_width, chooser->priv->image_width);
+ new_height = MIN (new_height, chooser->priv->image_height);
+
+ scaled = gdk_pixbuf_scale_simple (
+ pixbuf, new_width, new_height,
+ GDK_INTERP_BILINEAR);
+
+ composite = gdk_pixbuf_new (
+ GDK_COLORSPACE_RGB, TRUE,
+ gdk_pixbuf_get_bits_per_sample (pixbuf),
+ chooser->priv->image_width,
+ chooser->priv->image_height);
+
+ gdk_pixbuf_fill (composite, 0x00000000);
+
+ gdk_pixbuf_copy_area (
+ scaled, 0, 0, new_width, new_height,
+ composite,
+ chooser->priv->image_width / 2 - new_width / 2,
+ chooser->priv->image_height / 2 - new_height / 2);
+
+ gtk_image_set_from_pixbuf (
+ GTK_IMAGE (chooser->priv->image), composite);
+
+ g_object_unref (scaled);
+ g_object_unref (composite);
+ }
+
+ g_object_unref (pixbuf);
+
+ g_free (chooser->priv->image_buf);
+ chooser->priv->image_buf = data;
+ chooser->priv->image_buf_size = length;
+
+ g_signal_emit (chooser, signals[CHANGED], 0);
+
+ return TRUE;
+}
+
+static gboolean
+image_drag_motion_cb (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ guint time,
+ EImageChooser *chooser)
+{
+ GtkFrame *frame;
+ GList *targets, *p;
+
+ frame = GTK_FRAME (chooser->priv->frame);
+ targets = gdk_drag_context_list_targets (context);
+
+ for (p = targets; p != NULL; p = p->next) {
+ gchar *possible_type;
+
+ possible_type = gdk_atom_name (GDK_POINTER_TO_ATOM (p->data));
+ if (!strcmp (possible_type, URI_LIST_TYPE)) {
+ g_free (possible_type);
+ gdk_drag_status (context, GDK_ACTION_COPY, time);
+ gtk_frame_set_shadow_type (frame, GTK_SHADOW_IN);
+ return TRUE;
+ }
+
+ g_free (possible_type);
+ }
+
+ gtk_frame_set_shadow_type (frame, GTK_SHADOW_NONE);
+
+ return FALSE;
+}
+
+static void
+image_drag_leave_cb (GtkWidget *widget,
+ GdkDragContext *context,
+ guint time,
+ EImageChooser *chooser)
+{
+ GtkFrame *frame;
+
+ frame = GTK_FRAME (chooser->priv->frame);
+ gtk_frame_set_shadow_type (frame, GTK_SHADOW_NONE);
+}
+
+static gboolean
+image_drag_drop_cb (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ guint time,
+ EImageChooser *chooser)
+{
+ GtkFrame *frame;
+ GList *targets, *p;
+
+ frame = GTK_FRAME (chooser->priv->frame);
+ targets = gdk_drag_context_list_targets (context);
+
+ if (targets == NULL) {
+ gtk_frame_set_shadow_type (frame, GTK_SHADOW_NONE);
+ return FALSE;
+ }
+
+ for (p = targets; p != NULL; p = p->next) {
+ gchar *possible_type;
+
+ possible_type = gdk_atom_name (GDK_POINTER_TO_ATOM (p->data));
+ if (!strcmp (possible_type, URI_LIST_TYPE)) {
+ g_free (possible_type);
+ gtk_drag_get_data (
+ widget, context,
+ GDK_POINTER_TO_ATOM (p->data), time);
+ gtk_frame_set_shadow_type (frame, GTK_SHADOW_NONE);
+ return TRUE;
+ }
+
+ g_free (possible_type);
+ }
+
+ gtk_frame_set_shadow_type (frame, GTK_SHADOW_NONE);
+
+ return FALSE;
+}
+
+static void
+image_chooser_file_loaded_cb (GFile *file,
+ GAsyncResult *result,
+ EImageChooser *chooser)
+{
+ gchar *contents;
+ gsize length;
+ GError *error = NULL;
+
+ g_file_load_contents_finish (
+ file, result, &contents, &length, NULL, &error);
+
+ if (error != NULL) {
+ g_warning ("%s", error->message);
+ g_error_free (error);
+ goto exit;
+ }
+
+ set_image_from_data (chooser, contents, length);
+
+ g_free (contents);
+
+exit:
+ g_object_unref (chooser);
+}
+
+static void
+image_drag_data_received_cb (GtkWidget *widget,
+ GdkDragContext *context,
+ gint x,
+ gint y,
+ GtkSelectionData *selection_data,
+ guint info,
+ guint time,
+ EImageChooser *chooser)
+{
+ GFile *file;
+ gboolean handled = FALSE;
+ gchar **uris;
+
+ uris = gtk_selection_data_get_uris (selection_data);
+
+ if (uris == NULL)
+ goto exit;
+
+ file = g_file_new_for_uri (uris[0]);
+
+ /* XXX Not cancellable. */
+ g_file_load_contents_async (
+ file, NULL, (GAsyncReadyCallback)
+ image_chooser_file_loaded_cb,
+ g_object_ref (chooser));
+
+ g_object_unref (file);
+ g_strfreev (uris);
+
+ /* Assume success. We won't know til later. */
+ handled = TRUE;
+
+exit:
+ gtk_drag_finish (context, handled, FALSE, time);
+}
+
+static void
+image_chooser_set_icon_name (EImageChooser *chooser,
+ const gchar *icon_name)
+{
+ GtkIconTheme *icon_theme;
+ GtkIconInfo *icon_info;
+ const gchar *filename;
+ gint width, height;
+
+ g_return_if_fail (chooser->priv->icon_name == NULL);
+
+ chooser->priv->icon_name = g_strdup (icon_name);
+
+ icon_theme = gtk_icon_theme_get_default ();
+ gtk_icon_size_lookup (GTK_ICON_SIZE_DIALOG, &width, &height);
+
+ icon_info = gtk_icon_theme_lookup_icon (
+ icon_theme, icon_name, height, 0);
+ g_return_if_fail (icon_info != NULL);
+
+ filename = gtk_icon_info_get_filename (icon_info);
+ e_image_chooser_set_from_file (chooser, filename);
+ gtk_icon_info_free (icon_info);
+}
+
+static void
+image_chooser_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ switch (property_id) {
+ case PROP_ICON_NAME:
+ image_chooser_set_icon_name (
+ E_IMAGE_CHOOSER (object),
+ g_value_get_string (value));
+ return;
+ }
+
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+image_chooser_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ switch (property_id) {
+ case PROP_ICON_NAME:
+ g_value_set_string (
+ value,
+ e_image_chooser_get_icon_name (
+ E_IMAGE_CHOOSER (object)));
+ return;
+ }
+
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+}
+
+static void
+image_chooser_dispose (GObject *object)
+{
+ EImageChooserPrivate *priv;
+
+ priv = E_IMAGE_CHOOSER_GET_PRIVATE (object);
+
+ if (priv->frame != NULL) {
+ g_object_unref (priv->frame);
+ priv->frame = NULL;
+ }
+
+ if (priv->image != NULL) {
+ g_object_unref (priv->image);
+ priv->image = NULL;
+ }
+
+ /* Chain up to parent's dispose() method. */
+ G_OBJECT_CLASS (e_image_chooser_parent_class)->dispose (object);
+}
+
+static void
+image_chooser_finalize (GObject *object)
+{
+ EImageChooserPrivate *priv;
+
+ priv = E_IMAGE_CHOOSER_GET_PRIVATE (object);
+
+ g_free (priv->image_buf);
+ g_free (priv->icon_name);
+
+ /* Chain up to parent's finalize() method. */
+ G_OBJECT_CLASS (e_image_chooser_parent_class)->finalize (object);
+}
+
+static void
+e_image_chooser_class_init (EImageChooserClass *class)
+{
+ GObjectClass *object_class;
+
+ g_type_class_add_private (class, sizeof (EImageChooserPrivate));
+
+ object_class = G_OBJECT_CLASS (class);
+ object_class->set_property = image_chooser_set_property;
+ object_class->get_property = image_chooser_get_property;
+ object_class->dispose = image_chooser_dispose;
+ object_class->finalize = image_chooser_finalize;
+
+ g_object_class_install_property (
+ object_class,
+ PROP_ICON_NAME,
+ g_param_spec_string (
+ "icon-name",
+ "Icon Name",
+ NULL,
+ "avatar-default",
+ G_PARAM_READWRITE |
+ G_PARAM_CONSTRUCT_ONLY));
+
+ signals[CHANGED] = g_signal_new (
+ "changed",
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_FIRST,
+ G_STRUCT_OFFSET (EImageChooserClass, changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+}
+
+static void
+e_image_chooser_init (EImageChooser *chooser)
+{
+ GtkWidget *container;
+ GtkWidget *widget;
+
+ chooser->priv = E_IMAGE_CHOOSER_GET_PRIVATE (chooser);
+
+ container = GTK_WIDGET (chooser);
+
+ widget = gtk_frame_new ("");
+ gtk_frame_set_shadow_type (GTK_FRAME (widget), GTK_SHADOW_NONE);
+ gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
+ chooser->priv->frame = g_object_ref (widget);
+ gtk_widget_show (widget);
+
+ container = widget;
+
+ widget = gtk_alignment_new (0, 0, 0, 0);
+ gtk_container_add (GTK_CONTAINER (container), widget);
+ gtk_widget_show (widget);
+
+ container = widget;
+
+ widget = gtk_image_new ();
+ gtk_container_add (GTK_CONTAINER (container), widget);
+ chooser->priv->image = g_object_ref (widget);
+ gtk_widget_show (widget);
+
+ gtk_drag_dest_set (widget, 0, NULL, 0, GDK_ACTION_COPY);
+ gtk_drag_dest_add_uri_targets (widget);
+
+ g_signal_connect (
+ widget, "drag-motion",
+ G_CALLBACK (image_drag_motion_cb), chooser);
+ g_signal_connect (
+ widget, "drag-leave",
+ G_CALLBACK (image_drag_leave_cb), chooser);
+ g_signal_connect (
+ widget, "drag-drop",
+ G_CALLBACK (image_drag_drop_cb), chooser);
+ g_signal_connect (
+ widget, "drag-data-received",
+ G_CALLBACK (image_drag_data_received_cb), chooser);
+}
+
+const gchar *
+e_image_chooser_get_icon_name (EImageChooser *chooser)
+{
+ g_return_val_if_fail (E_IS_IMAGE_CHOOSER (chooser), NULL);
+
+ return chooser->priv->icon_name;
+}
+
+GtkWidget *
+e_image_chooser_new (const gchar *icon_name)
+{
+ g_return_val_if_fail (icon_name != NULL, NULL);
+
+ return g_object_new (
+ E_TYPE_IMAGE_CHOOSER,
+ "icon-name", icon_name, NULL);
+}
+
+gboolean
+e_image_chooser_set_from_file (EImageChooser *chooser,
+ const gchar *filename)
+{
+ gchar *data;
+ gsize data_length;
+
+ g_return_val_if_fail (E_IS_IMAGE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (filename != NULL, FALSE);
+
+ if (!g_file_get_contents (filename, &data, &data_length, NULL))
+ return FALSE;
+
+ if (!set_image_from_data (chooser, data, data_length))
+ g_free (data);
+
+ return TRUE;
+}
+
+gboolean
+e_image_chooser_get_image_data (EImageChooser *chooser,
+ gchar **data,
+ gsize *data_length)
+{
+ g_return_val_if_fail (E_IS_IMAGE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (data != NULL, FALSE);
+ g_return_val_if_fail (data_length != NULL, FALSE);
+
+ *data_length = chooser->priv->image_buf_size;
+ *data = g_malloc (*data_length);
+ memcpy (*data, chooser->priv->image_buf, *data_length);
+
+ return TRUE;
+}
+
+gboolean
+e_image_chooser_set_image_data (EImageChooser *chooser,
+ gchar *data,
+ gsize data_length)
+{
+ gchar *buf;
+
+ g_return_val_if_fail (E_IS_IMAGE_CHOOSER (chooser), FALSE);
+ g_return_val_if_fail (data != NULL, FALSE);
+
+ /* yuck, a copy... */
+ buf = g_malloc (data_length);
+ memcpy (buf, data, data_length);
+
+ if (!set_image_from_data (chooser, buf, data_length)) {
+ g_free (buf);
+ return FALSE;
+ }
+
+ return TRUE;
+}