[gnome-photos/wip/rishi/imageview: 4/4] Image Canvas

[Debarshi Ray <debarshir src gnome org>]

commit cd5a202ff45a8fc64ac2d1316996f5805e52418c
Author: Debarshi Ray <debarshir gnome org>
Date:   Sun Jan 31 19:06:46 2016 +0100

    Image Canvas

 src/photos-image-canvas.c |  378 +++++++++++++++++++++++++++++++++++++++++++++
 src/photos-image-canvas.h |   72 +++++++++
 2 files changed, 450 insertions(+), 0 deletions(-)
---
diff --git a/src/photos-image-canvas.c b/src/photos-image-canvas.c
new file mode 100644
index 0000000..b70caa7
--- /dev/null
+++ b/src/photos-image-canvas.c
@@ -0,0 +1,378 @@
+/*
+ * Photos - access, organize and share your photos on GNOME
+ * Copyright © 2016 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#include "config.h"
+
+#include <babl/babl.h>
+#include <cairo-gobject.h>
+#include <glib.h>
+
+#include "photos-debug.h"
+#include "photos-image-view.h"
+#include "photos-marshalers.h"
+
+
+struct _PhotosImageCanvas
+{
+  GtkBin parent_instance;
+  GeglNode *node;
+  GtkWidget *stack;
+  cairo_region_t *bbox_region;
+  cairo_region_t *region;
+  gfloat x;
+  gfloat x_scaled;
+  gfloat y;
+  gfloat y_scaled;
+  gfloat zoom;
+  gfloat zoom_scaled;
+};
+
+struct _PhotosImageCanvasClass
+{
+  GtkBinClass parent_class;
+
+  /* signals */
+  void        (*draw_background)    (PhotosImageCanvas *self, cairo_t *cr, GdkRectangle *rect);
+  void        (*draw_overlay)       (PhotosImageCanvas *self, cairo_t *cr, GdkRectangle *rect);
+};
+
+
+enum
+  {
+    PROP_0,
+    PROP_NODE,
+    PROP_X,
+    PROP_Y,
+    PROP_ZOOM
+  };
+
+enum
+  {
+    DRAW_BACKGROUND,
+    DRAW_OVERLAY,
+    LAST_SIGNAL
+  };
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+
+G_DEFINE_TYPE (PhotosImageCanvas, photos_image_canvas, GTK_TYPE_BIN);
+
+
+static void
+photos_image_canvas_computed (PhotosImageCanvas *self, GeglRectangle *rect)
+{
+  cairo_status_t status;
+
+  status = cairo_region_union_rectangle (self->region, (cairo_rectangle_t *) rect);
+  g_assert_cmpint (status, =, CAIRO_STATUS_SUCCESS);
+
+  if (cairo_region_equal (self->bbox_region, self->region))
+    g_message ("compute done");
+}
+
+
+static void
+photos_image_canvas_dispose (GObject *object)
+{
+  PhotosImageCanvas *self = PHOTOS_IMAGE_CANVAS (object);
+
+  g_clear_object (&self->node);
+
+  G_OBJECT_CLASS (photos_image_canvas_parent_class)->dispose (object);
+}
+
+
+static void
+photos_image_canvas_finalize (GObject *object)
+{
+  PhotosImageCanvas *self = PHOTOS_IMAGE_CANVAS (object);
+
+  g_clear_pointer (&self->bbox_region, (GDestroyNotify) cairo_region_destroy);
+  g_clear_pointer (&self->region, (GDestroyNotify) cairo_region_destroy);
+
+  G_OBJECT_CLASS (photos_image_canvas_parent_class)->finalize (object);
+}
+
+
+static void
+photos_image_canvas_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+  PhotosImageCanvas *self = PHOTOS_IMAGE_CANVAS (object);
+
+  switch (prop_id)
+    {
+    case PROP_NODE:
+      g_value_set_object (value, self->node);
+      break;
+
+    case PROP_X:
+      {
+        GtkWidget *view;
+        gfloat x;
+
+        view = gtk_stack_get_visible_child (GTK_STACK (self->stack));
+        x = photos_image_canvas_get_x (PHOTOS_IMAGE_VIEW (view));
+        g_value_set_float (value, x);
+        break;
+      }
+
+    case PROP_Y:
+      {
+        GtkWidget *view;
+        gfloat y;
+
+        view = gtk_stack_get_visible_child (GTK_STACK (self->stack));
+        y = photos_image_canvas_get_y (PHOTOS_IMAGE_VIEW (view));
+        g_value_set_float (value, y);
+        break;
+      }
+
+    case PROP_ZOOM:
+      {
+        GtkWidget *view;
+        gfloat zoom;
+
+        view = gtk_stack_get_visible_child (GTK_STACK (self->stack));
+        zoom = photos_image_canvas_get_zoom (PHOTOS_IMAGE_VIEW (view));
+        g_value_set_float (value, zoom);
+        break;
+      }
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+
+static void
+photos_image_canvas_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
+{
+  PhotosImageCanvas *self = PHOTOS_IMAGE_CANVAS (object);
+
+  switch (prop_id)
+    {
+    case PROP_NODE:
+      {
+        GeglNode *node;
+
+        node = GEGL_NODE (g_value_get_object (value));
+        photos_image_canvas_set_node (self, node);
+        break;
+      }
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+
+static void
+photos_image_canvas_init (PhotosImageCanvas *self)
+{
+  GtkWidget *view;
+
+  self->stack = gtk_stack_new ();
+  gtk_widget_set_hexpand (self->stack, TRUE);
+  gtk_widget_set_vexpand (self->stack, TRUE);
+  gtk_container_add (GTK_CONTAINER (self), self->stack);
+
+  view = photos_image_view_new ();
+  g_signal_connect ()
+  gtk_widget_show (view);
+  gtk_container_add (GTK_CONTAINER (self->stack), view_container);
+  gtk_stack_set_visible_child (GTK_STACK (self->stack), view);
+}
+
+
+static void
+photos_image_canvas_class_init (PhotosImageCanvasClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+
+  object_class->dispose = photos_image_canvas_dispose;
+  object_class->finalize = photos_image_canvas_finalize;
+  object_class->get_property = photos_image_canvas_get_property;
+  object_class->set_property = photos_image_canvas_set_property;
+
+  g_object_class_install_property (object_class,
+                                   PROP_NODE,
+                                   g_param_spec_object ("node",
+                                                        "GeglNode object",
+                                                        "The GeglNode to render",
+                                                        GEGL_TYPE_NODE,
+                                                        G_PARAM_CONSTRUCT | G_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_X,
+                                   g_param_spec_float ("x",
+                                                       "X",
+                                                       "X origin",
+                                                       -G_MAXFLOAT,
+                                                       G_MAXFLOAT,
+                                                       0.0,
+                                                       G_PARAM_READABLE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_Y,
+                                   g_param_spec_float ("y",
+                                                       "Y",
+                                                       "Y origin",
+                                                       -G_MAXFLOAT,
+                                                       G_MAXFLOAT,
+                                                       0.0,
+                                                       G_PARAM_READABLE));
+
+  g_object_class_install_property (object_class,
+                                   PROP_ZOOM,
+                                   g_param_spec_float ("zoom",
+                                                       "Zoom",
+                                                       "Zoom factor",
+                                                       0.0f,
+                                                       100.0f,
+                                                       1.0f,
+                                                       G_PARAM_READABLE));
+
+  signals[DRAW_BACKGROUND] = g_signal_new ("draw-background",
+                                           G_TYPE_FROM_CLASS (class),
+                                           G_SIGNAL_RUN_LAST,
+                                           G_STRUCT_OFFSET (PhotosImageCanvasClass, draw_background),
+                                           NULL, /* accumulator */
+                                           NULL, /* accu_data */
+                                           _photos_marshal_VOID__BOXED_BOXED,
+                                           G_TYPE_NONE,
+                                           2,
+                                           CAIRO_GOBJECT_TYPE_CONTEXT,
+                                           GDK_TYPE_RECTANGLE);
+
+  signals[DRAW_OVERLAY] = g_signal_new ("draw-overlay",
+                                        G_TYPE_FROM_CLASS (class),
+                                        G_SIGNAL_RUN_LAST,
+                                        G_STRUCT_OFFSET (PhotosImageCanvasClass, draw_overlay),
+                                        NULL, /* accumulator */
+                                        NULL, /* accu_data */
+                                        _photos_marshal_VOID__BOXED_BOXED,
+                                        G_TYPE_NONE,
+                                        2,
+                                        CAIRO_GOBJECT_TYPE_CONTEXT,
+                                        GDK_TYPE_RECTANGLE);
+}
+
+
+GtkWidget *
+photos_image_canvas_new (void)
+{
+  return g_object_new (PHOTOS_TYPE_IMAGE_CANVAS, NULL);
+}
+
+
+GtkWidget *
+photos_image_canvas_new_from_node (GeglNode *node)
+{
+  g_return_val_if_fail (node == NULL || GEGL_IS_NODE (node), NULL);
+  return g_object_new (PHOTOS_TYPE_IMAGE_CANVAS, "node", node, NULL);
+}
+
+
+GeglNode *
+photos_image_canvas_get_node (PhotosImageCanvas *self)
+{
+  g_return_val_if_fail (PHOTOS_IS_IMAGE_CANVAS (self), NULL);
+  return self->node;
+}
+
+
+gfloat
+photos_image_canvas_get_x (PhotosImageCanvas *self)
+{
+  GtkWidget *view;
+  gfloat y;
+
+  g_return_val_if_fail (PHOTOS_IS_IMAGE_CANVAS (self), 0.0);
+
+  view = gtk_stack_get_visible_child (GTK_STACK (self->stack));
+  x = photos_image_view_get_x (PHOTOS_IMAGE_VIEW (view));
+  return x;
+}
+
+
+gfloat
+photos_image_canvas_get_y (PhotosImageCanvas *self)
+{
+  GtkWidget *view;
+  gfloat y;
+
+  g_return_val_if_fail (PHOTOS_IS_IMAGE_CANVAS (self), 0.0);
+
+  view = gtk_stack_get_visible_child (GTK_STACK (self->stack));
+  y = photos_image_view_get_y (PHOTOS_IMAGE_VIEW (view));
+  return y;
+}
+
+
+gfloat
+photos_image_canvas_get_zoom (PhotosImageCanvas *self)
+{
+  GtkWidget *view;
+  gfloat zoom;
+
+  g_return_val_if_fail (PHOTOS_IS_IMAGE_CANVAS (self), 0.0);
+
+  view = gtk_stack_get_visible_child (GTK_STACK (self->stack));
+  zoom = photos_image_view_get_zoom (PHOTOS_IMAGE_VIEW (view));
+  return zoom;
+}
+
+
+void
+photos_image_canvas_set_node (PhotosImageCanvas *self, GeglNode *node)
+{
+  GtkWidget *view;
+
+  g_return_if_fail (PHOTOS_IS_IMAGE_CANVAS (self));
+
+  if (self->node == node)
+    return;
+
+  if (self->node != NULL)
+    g_signal_handlers_disconnect_by_func (self->node, photos_image_canvas_computed, self);
+
+  g_clear_object (&self->node);
+  g_clear_pointer (&self->bbox_region, (GDestroyNotify) cairo_region_destroy);
+  g_clear_pointer (&self->region, (GDestroyNotify) cairo_region_destroy);
+
+  if (node != NULL)
+    {
+      GeglRectangle bbox;
+
+      g_object_ref (node);
+      g_signal_connect_object (node, "computed", G_CALLBACK (photos_image_canvas_computed), self, 
G_CONNECT_SWAPPED);
+      bbox = gegl_node_get_bounding_box (node);
+      self->bbox_region = cairo_region_create_rectangle ((cairo_rectangle_t *) &bbox);
+      self->region = cairo_region_create ();
+    }
+
+  self->node = node;
+
+  view = gtk_stack_get_visible_child (GTK_STACK (self->stack));
+  photos_image_view_set_node (PHOTOS_IMAGE_VIEW (view), self->node);
+}
diff --git a/src/photos-image-canvas.h b/src/photos-image-canvas.h
new file mode 100644
index 0000000..c44c836
--- /dev/null
+++ b/src/photos-image-canvas.h
@@ -0,0 +1,72 @@
+/*
+ * Photos - access, organize and share your photos on GNOME
+ * Copyright © 2016 Red Hat, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ */
+
+#ifndef PHOTOS_IMAGE_CANVAS_H
+#define PHOTOS_IMAGE_CANVAS_H
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+#define PHOTOS_TYPE_IMAGE_CANVAS (photos_image_canvas_get_type ())
+
+#define PHOTOS_IMAGE_CANVAS(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST ((obj), \
+   PHOTOS_TYPE_IMAGE_CANVAS, PhotosImageCanvas))
+
+#define PHOTOS_IMAGE_CANVAS_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_CAST ((klass), \
+   PHOTOS_TYPE_IMAGE_CANVAS, PhotosImageCanvasClass))
+
+#define PHOTOS_IS_IMAGE_CANVAS(obj) \
+  (G_TYPE_CHECK_INSTANCE_TYPE ((obj), \
+   PHOTOS_TYPE_IMAGE_CANVAS))
+
+#define PHOTOS_IS_IMAGE_CANVAS_CLASS(klass) \
+  (G_TYPE_CHECK_CLASS_TYPE ((klass), \
+   PHOTOS_TYPE_IMAGE_CANVAS))
+
+#define PHOTOS_IMAGE_CANVAS_GET_CLASS(obj) \
+  (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+   PHOTOS_TYPE_IMAGE_CANVAS, PhotosImageCanvasClass))
+
+typedef struct _PhotosImageCanvas      PhotosImageCanvas;
+typedef struct _PhotosImageCanvasClass PhotosImageCanvasClass;
+
+GType               photos_image_canvas_get_type           (void) G_GNUC_CONST;
+
+GtkWidget          *photos_image_canvas_new                (void);
+
+GtkWidget          *photos_image_canvas_new_from_node      (GeglNode *node);
+
+GeglNode           *photos_image_canvas_get_node           (PhotosImageCanvas *self);
+
+gfloat              photos_image_canvas_get_x              (PhotosImageCanvas *self);
+
+gfloat              photos_image_canvas_get_y              (PhotosImageCanvas *self);
+
+gfloat              photos_image_canvas_get_zoom           (PhotosImageCanvas *self);
+
+void                photos_image_canvas_set_node           (PhotosImageCanvas *self, GeglNode *node);
+
+G_END_DECLS
+
+#endif /* PHOTOS_IMAGE_CANVAS_H */