imagedefinition: Split out from icon helper

The image definition is supposed to hold the description about the image
to be displayed. The icon helper actually does caching and tracks
changes.

1 files changed, 411 insertions, 0 deletions

diff --git a/gtk/gtkimagedefinition.c b/gtk/gtkimagedefinition.c
new file mode 100644
index 0000000000..1486031da8
--- /dev/null
+++ b/gtk/gtkimagedefinition.c
@@ -0,0 +1,411 @@
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 2015 Benjamin Otte <otte@gnome.org>
+ *
+ * This library 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) any later version.
+ *
+ * This 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include "gtkimagedefinitionprivate.h"
+
+#include "deprecated/gtkiconfactory.h"
+
+typedef struct _GtkImageDefinitionEmpty GtkImageDefinitionEmpty;
+typedef struct _GtkImageDefinitionPixbuf GtkImageDefinitionPixbuf;
+typedef struct _GtkImageDefinitionStock GtkImageDefinitionStock;
+typedef struct _GtkImageDefinitionIconSet GtkImageDefinitionIconSet;
+typedef struct _GtkImageDefinitionAnimation GtkImageDefinitionAnimation;
+typedef struct _GtkImageDefinitionIconName GtkImageDefinitionIconName;
+typedef struct _GtkImageDefinitionGIcon GtkImageDefinitionGIcon;
+typedef struct _GtkImageDefinitionSurface GtkImageDefinitionSurface;
+
+struct _GtkImageDefinitionEmpty {
+  GtkImageType type;
+  gint ref_count;
+};
+
+struct _GtkImageDefinitionPixbuf {
+  GtkImageType type;
+  gint ref_count;
+
+  GdkPixbuf *pixbuf;
+  int scale;
+};
+
+struct _GtkImageDefinitionStock {
+  GtkImageType type;
+  gint ref_count;
+
+  char *id;
+  GtkIconSize icon_size;
+};
+
+struct _GtkImageDefinitionIconSet {
+  GtkImageType type;
+  gint ref_count;
+
+  GtkIconSet *icon_set;
+  GtkIconSize icon_size;
+};
+
+struct _GtkImageDefinitionAnimation {
+  GtkImageType type;
+  gint ref_count;
+
+  GdkPixbufAnimation *animation;
+  int scale;
+};
+
+struct _GtkImageDefinitionIconName {
+  GtkImageType type;
+  gint ref_count;
+
+  char *icon_name;
+  GtkIconSize icon_size;
+};
+
+struct _GtkImageDefinitionGIcon {
+  GtkImageType type;
+  gint ref_count;
+
+  GIcon *gicon;
+  GtkIconSize icon_size;
+};
+
+struct _GtkImageDefinitionSurface {
+  GtkImageType type;
+  gint ref_count;
+
+  cairo_surface_t *surface;
+};
+
+union _GtkImageDefinition
+{
+  GtkImageType type;
+  GtkImageDefinitionEmpty empty;
+  GtkImageDefinitionPixbuf pixbuf;
+  GtkImageDefinitionStock stock;
+  GtkImageDefinitionIconSet icon_set;
+  GtkImageDefinitionAnimation animation;
+  GtkImageDefinitionIconName icon_name;
+  GtkImageDefinitionGIcon gicon;
+  GtkImageDefinitionSurface surface;
+};
+
+GtkImageDefinition *
+gtk_image_definition_new_empty (void)
+{
+  static GtkImageDefinitionEmpty empty = { GTK_IMAGE_EMPTY, 1 };
+
+  return gtk_image_definition_ref ((GtkImageDefinition *) &empty);
+}
+
+static inline GtkImageDefinition *
+gtk_image_definition_alloc (GtkImageType type)
+{
+  static gsize sizes[] = {
+    sizeof (GtkImageDefinitionEmpty),
+    sizeof (GtkImageDefinitionPixbuf),
+    sizeof (GtkImageDefinitionStock),
+    sizeof (GtkImageDefinitionIconSet),
+    sizeof (GtkImageDefinitionAnimation),
+    sizeof (GtkImageDefinitionIconName),
+    sizeof (GtkImageDefinitionGIcon),
+    sizeof (GtkImageDefinitionSurface)
+  };
+  GtkImageDefinition *def;
+
+  g_assert (type < G_N_ELEMENTS (sizes));
+
+  def = g_malloc0 (sizes[type]);
+  def->type = type;
+  def->empty.ref_count = 1;
+
+  return def;
+}
+
+GtkImageDefinition *
+gtk_image_definition_new_pixbuf (GdkPixbuf *pixbuf,
+                                 int        scale)
+{
+  GtkImageDefinition *def;
+
+  if (pixbuf == NULL || scale <= 0)
+    return NULL;
+
+  def = gtk_image_definition_alloc (GTK_IMAGE_PIXBUF);
+  def->pixbuf.pixbuf = g_object_ref (pixbuf);
+  def->pixbuf.scale = scale;
+
+  return def;
+}
+
+GtkImageDefinition *
+gtk_image_definition_new_stock (const char  *stock_id,
+                                GtkIconSize  icon_size)
+{
+  GtkImageDefinition *def;
+
+  if (stock_id == NULL || stock_id[0] == '\0')
+    return NULL;
+
+  def = gtk_image_definition_alloc (GTK_IMAGE_STOCK);
+  def->stock.id = g_strdup (stock_id);
+  def->stock.icon_size = icon_size;
+
+  return def;
+}
+
+GtkImageDefinition *
+gtk_image_definition_new_icon_set (GtkIconSet  *icon_set,
+                                   GtkIconSize  icon_size)
+{
+  GtkImageDefinition *def;
+
+  if (icon_set == NULL)
+    return NULL;
+
+  def = gtk_image_definition_alloc (GTK_IMAGE_ICON_SET);
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
+  def->icon_set.icon_set = gtk_icon_set_ref (icon_set);
+G_GNUC_END_IGNORE_DEPRECATIONS;
+  def->icon_set.icon_size = icon_size;
+
+  return def;
+}
+
+GtkImageDefinition *
+gtk_image_definition_new_animation (GdkPixbufAnimation *animation,
+                                    int                 scale)
+{
+  GtkImageDefinition *def;
+
+  if (animation == NULL || scale <= 0)
+    return NULL;
+
+  def = gtk_image_definition_alloc (GTK_IMAGE_ANIMATION);
+  def->animation.animation = g_object_ref (animation);
+  def->animation.scale = scale;
+
+  return def;
+}
+
+GtkImageDefinition *
+gtk_image_definition_new_icon_name (const char  *icon_name,
+                                    GtkIconSize  icon_size)
+{
+  GtkImageDefinition *def;
+
+  if (icon_name == NULL || icon_name[0] == '\0')
+    return NULL;
+
+  def = gtk_image_definition_alloc (GTK_IMAGE_ICON_NAME);
+  def->icon_name.icon_name = g_strdup (icon_name);
+  def->icon_name.icon_size = icon_size;
+
+  return def;
+}
+
+GtkImageDefinition *
+gtk_image_definition_new_gicon (GIcon       *gicon,
+                                GtkIconSize  icon_size)
+{
+  GtkImageDefinition *def;
+
+  if (gicon == NULL)
+    return NULL;
+
+  def = gtk_image_definition_alloc (GTK_IMAGE_GICON);
+  def->gicon.gicon = g_object_ref (gicon);
+  def->gicon.icon_size = icon_size;
+
+  return def;
+}
+
+GtkImageDefinition *
+gtk_image_definition_new_surface (cairo_surface_t *surface)
+{
+  GtkImageDefinition *def;
+
+  if (surface == NULL)
+    return NULL;
+
+  def = gtk_image_definition_alloc (GTK_IMAGE_SURFACE);
+  def->surface.surface = cairo_surface_reference (surface);
+
+  return def;
+}
+
+GtkImageDefinition *
+gtk_image_definition_ref (GtkImageDefinition *def)
+{
+  def->empty.ref_count++;
+
+  return def;
+}
+
+void
+gtk_image_definition_unref (GtkImageDefinition *def)
+{
+  def->empty.ref_count--;
+
+  if (def->empty.ref_count > 0)
+    return;
+
+  switch (def->type)
+    {
+    default:
+      g_assert_not_reached ();
+    case GTK_IMAGE_EMPTY:
+      break;
+    case GTK_IMAGE_PIXBUF:
+      g_object_unref (def->pixbuf.pixbuf);
+      break;
+    case GTK_IMAGE_ANIMATION:
+      g_object_unref (def->animation.animation);
+      break;
+    case GTK_IMAGE_SURFACE:
+      cairo_surface_destroy (def->surface.surface);
+      break;
+    case GTK_IMAGE_STOCK:
+      g_free (def->stock.id);
+      break;
+    case GTK_IMAGE_ICON_SET:
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
+      gtk_icon_set_unref (def->icon_set.icon_set);
+G_GNUC_END_IGNORE_DEPRECATIONS;
+      break;
+    case GTK_IMAGE_ICON_NAME:
+      g_free (def->icon_name.icon_name);
+      break;
+    case GTK_IMAGE_GICON:
+      g_object_unref (def->gicon.gicon);
+      break;
+    }
+
+  g_free (def);
+}
+
+gboolean
+gtk_image_definition_get_storage_type (const GtkImageDefinition *def)
+{
+  return def->type;
+}
+
+GtkIconSize
+gtk_image_definition_get_icon_size (const GtkImageDefinition *def)
+{
+  switch (def->type)
+    {
+    default:
+      g_assert_not_reached ();
+    case GTK_IMAGE_EMPTY:
+    case GTK_IMAGE_PIXBUF:
+    case GTK_IMAGE_ANIMATION:
+    case GTK_IMAGE_SURFACE:
+      return GTK_ICON_SIZE_INVALID;
+    case GTK_IMAGE_STOCK:
+      return def->stock.icon_size;
+    case GTK_IMAGE_ICON_SET:
+      return def->icon_set.icon_size;
+    case GTK_IMAGE_ICON_NAME:
+      return def->icon_name.icon_size;
+    case GTK_IMAGE_GICON:
+      return def->gicon.icon_size;
+    }
+}
+
+gint
+gtk_image_definition_get_scale (const GtkImageDefinition *def)
+{
+  switch (def->type)
+    {
+    default:
+      g_assert_not_reached ();
+    case GTK_IMAGE_EMPTY:
+    case GTK_IMAGE_SURFACE:
+    case GTK_IMAGE_STOCK:
+    case GTK_IMAGE_ICON_SET:
+    case GTK_IMAGE_ICON_NAME:
+    case GTK_IMAGE_GICON:
+      return 1;
+    case GTK_IMAGE_PIXBUF:
+      return def->pixbuf.scale;
+    case GTK_IMAGE_ANIMATION:
+      return def->animation.scale;
+    }
+}
+
+GdkPixbuf *
+gtk_image_definition_get_pixbuf (const GtkImageDefinition *def)
+{
+  if (def->type != GTK_IMAGE_PIXBUF)
+    return NULL;
+
+  return def->pixbuf.pixbuf;
+}
+
+const gchar *
+gtk_image_definition_get_stock (const GtkImageDefinition *def)
+{
+  if (def->type != GTK_IMAGE_STOCK)
+    return NULL;
+
+  return def->stock.id;
+}
+
+GtkIconSet *
+gtk_image_definition_get_icon_set (const GtkImageDefinition *def)
+{
+  if (def->type != GTK_IMAGE_ICON_SET)
+    return NULL;
+
+  return def->icon_set.icon_set;
+}
+
+GdkPixbufAnimation *
+gtk_image_definition_get_animation (const GtkImageDefinition *def)
+{
+  if (def->type != GTK_IMAGE_ANIMATION)
+    return NULL;
+
+  return def->animation.animation;
+}
+
+const gchar *
+gtk_image_definition_get_icon_name (const GtkImageDefinition *def)
+{
+  if (def->type != GTK_IMAGE_ICON_NAME)
+    return NULL;
+
+  return def->icon_name.icon_name;
+}
+
+GIcon *
+gtk_image_definition_get_gicon (const GtkImageDefinition *def)
+{
+  if (def->type != GTK_IMAGE_GICON)
+    return NULL;
+
+  return def->gicon.gicon;
+}
+
+cairo_surface_t *
+gtk_image_definition_get_surface (const GtkImageDefinition *def)
+{
+  if (def->type != GTK_IMAGE_SURFACE)
+    return NULL;
+
+  return def->surface.surface;
+}