[gtk/wip/baedert/nodeeditor: 4/18] Add GtkDiffPaintable and use it in the magnifier

[Timm Bäder <baedert src gnome org>]

commit f381cc68e6dee26037be6c1a47d6a8950cdf5d5d
Author: Benjamin Otte <otte redhat com>
Date:   Sun Mar 10 23:46:19 2019 +0100

    Add GtkDiffPaintable and use it in the magnifier
    
    This is supposed to show diffs, but works only semi-well because we
    fallback on GL for blend nodes, so the diffs are actually with cairo
    renderings. Oops.

 gtk/gtkdiffpaintable.c        | 326 ++++++++++++++++++++++++++++++++++++++++++
 gtk/gtkdiffpaintableprivate.h |  43 ++++++
 gtk/inspector/magnifier.c     |  24 +++-
 gtk/meson.build               |   1 +
 4 files changed, 388 insertions(+), 6 deletions(-)
---
diff --git a/gtk/gtkdiffpaintable.c b/gtk/gtkdiffpaintable.c
new file mode 100644
index 0000000000..5f7add5ce9
--- /dev/null
+++ b/gtk/gtkdiffpaintable.c
@@ -0,0 +1,326 @@
+/*
+ * Copyright © 2019 Benjamin Otte
+ *
+ * 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.1 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/>.
+ *
+ * Authors: Benjamin Otte <otte gnome org>
+ */
+
+#include "config.h"
+
+#include "gtkdiffpaintableprivate.h"
+
+#include "gtkintl.h"
+#include "gtksnapshot.h"
+
+struct _GtkDiffPaintable
+{
+  GObject parent_instance;
+
+  GdkPaintable *first;
+  GdkPaintable *second;
+};
+
+struct _GtkDiffPaintableClass
+{
+  GObjectClass parent_class;
+};
+
+enum {
+  PROP_0,
+  PROP_FIRST,
+  PROP_SECOND,
+  N_PROPS
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gtk_diff_paintable_paintable_snapshot (GdkPaintable *paintable,
+                                       GdkSnapshot  *snapshot,
+                                       double        width,
+                                       double        height)
+{
+  GtkDiffPaintable *self = GTK_DIFF_PAINTABLE (paintable);
+  float amplify[16] = { 4, 0, 0, 0,
+                        0, 4, 0, 0,
+                        0, 0, 4, 0,
+                        0, 0, 0, 1 };
+  graphene_matrix_t matrix;
+
+  graphene_matrix_init_from_float (&matrix, amplify);
+
+  gtk_snapshot_push_color_matrix (snapshot, &matrix, graphene_vec4_zero ());
+
+  gtk_snapshot_push_blend (snapshot, GSK_BLEND_MODE_DIFFERENCE);
+
+  if (self->first)
+    gdk_paintable_snapshot (self->first, snapshot, width, height);
+  gtk_snapshot_pop (snapshot);
+
+  if (self->second)
+    gdk_paintable_snapshot (self->second, snapshot, width, height);
+  gtk_snapshot_pop (snapshot);
+
+  gtk_snapshot_pop (snapshot);
+}
+
+static int
+gtk_diff_paintable_paintable_get_intrinsic_width (GdkPaintable *paintable)
+{
+  GtkDiffPaintable *self = GTK_DIFF_PAINTABLE (paintable);
+  int result;
+  
+  result = 0;
+
+  if (self->first)
+    result = MAX (result, gdk_paintable_get_intrinsic_width (self->first));
+  if (self->second)
+    result = MAX (result, gdk_paintable_get_intrinsic_width (self->second));
+
+  return result;
+}
+
+static int
+gtk_diff_paintable_paintable_get_intrinsic_height (GdkPaintable *paintable)
+{
+  GtkDiffPaintable *self = GTK_DIFF_PAINTABLE (paintable);
+  int result;
+  
+  result = 0;
+
+  if (self->first)
+    result = MAX (result, gdk_paintable_get_intrinsic_height (self->first));
+  if (self->second)
+    result = MAX (result, gdk_paintable_get_intrinsic_height (self->second));
+
+  return result;
+}
+
+static void
+gtk_diff_paintable_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->snapshot = gtk_diff_paintable_paintable_snapshot;
+  iface->get_intrinsic_width = gtk_diff_paintable_paintable_get_intrinsic_width;
+  iface->get_intrinsic_height = gtk_diff_paintable_paintable_get_intrinsic_height;
+}
+
+G_DEFINE_TYPE_EXTENDED (GtkDiffPaintable, gtk_diff_paintable, G_TYPE_OBJECT, 0,
+                        G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                               gtk_diff_paintable_paintable_init))
+
+static void
+gtk_diff_paintable_set_property (GObject      *object,
+                                     guint         prop_id,
+                                     const GValue *value,
+                                     GParamSpec   *pspec)
+
+{
+  GtkDiffPaintable *self = GTK_DIFF_PAINTABLE (object);
+
+  switch (prop_id)
+    {
+    case PROP_FIRST:
+      gtk_diff_paintable_set_first (self, g_value_get_object (value));
+      break;
+
+    case PROP_SECOND:
+      gtk_diff_paintable_set_second (self, g_value_get_object (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_diff_paintable_get_property (GObject    *object,
+                                 guint       prop_id,
+                                 GValue     *value,
+                                 GParamSpec *pspec)
+{
+  GtkDiffPaintable *self = GTK_DIFF_PAINTABLE (object);
+
+  switch (prop_id)
+    {
+    case PROP_FIRST:
+      g_value_set_object (value, self->first);
+      break;
+
+    case PROP_SECOND:
+      g_value_set_object (value, self->second);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_diff_paintable_unset_paintable (GtkDiffPaintable  *self,
+                                    GdkPaintable     **paintable)
+{
+  guint flags;
+  
+  if (*paintable == NULL)
+    return;
+
+  flags = gdk_paintable_get_flags (*paintable);
+
+  if ((flags & GDK_PAINTABLE_STATIC_CONTENTS) == 0)
+    g_signal_handlers_disconnect_by_func (*paintable,
+                                          gdk_paintable_invalidate_contents,
+                                          self);
+
+  if ((flags & GDK_PAINTABLE_STATIC_SIZE) == 0)
+    g_signal_handlers_disconnect_by_func (*paintable,
+                                          gdk_paintable_invalidate_size,
+                                          self);
+
+  g_clear_object (paintable);
+}
+
+static void
+gtk_diff_paintable_dispose (GObject *object)
+{
+  GtkDiffPaintable *self = GTK_DIFF_PAINTABLE (object);
+
+  gtk_diff_paintable_unset_paintable (self, &self->first);
+  gtk_diff_paintable_unset_paintable (self, &self->second);
+
+  G_OBJECT_CLASS (gtk_diff_paintable_parent_class)->dispose (object);
+}
+
+static void
+gtk_diff_paintable_class_init (GtkDiffPaintableClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->get_property = gtk_diff_paintable_get_property;
+  gobject_class->set_property = gtk_diff_paintable_set_property;
+  gobject_class->dispose = gtk_diff_paintable_dispose;
+
+  properties[PROP_FIRST] =
+    g_param_spec_object ("first",
+                         P_("First"),
+                         P_("First paintable to diff"),
+                         GDK_TYPE_PAINTABLE,
+                         G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+  properties[PROP_SECOND] =
+    g_param_spec_object ("second",
+                         P_("Second"),
+                         P_("Second paintable to diff"),
+                         GDK_TYPE_PAINTABLE,
+                         G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gtk_diff_paintable_init (GtkDiffPaintable *self)
+{
+}
+
+GdkPaintable *
+gtk_diff_paintable_new (GdkPaintable *first,
+                        GdkPaintable *second)
+{
+  g_return_val_if_fail (first == NULL || GDK_IS_PAINTABLE (first), NULL);
+  g_return_val_if_fail (second == NULL || GDK_IS_PAINTABLE (second), NULL);
+
+  return g_object_new (GTK_TYPE_DIFF_PAINTABLE,
+                       "first", first,
+                       "second", second,
+                       NULL);
+}
+
+static gboolean
+gtk_diff_paintable_set_paintable (GtkDiffPaintable  *self,
+                                  GdkPaintable     **paintable,
+                                  GdkPaintable      *new_paintable)
+{
+  if (*paintable == new_paintable)
+    return FALSE;
+
+  gtk_diff_paintable_unset_paintable (self, paintable);
+
+  if (new_paintable)
+    {
+      const guint flags = gdk_paintable_get_flags (new_paintable);
+
+      *paintable = g_object_ref (new_paintable);
+
+      if ((flags & GDK_PAINTABLE_STATIC_CONTENTS) == 0)
+        g_signal_connect_swapped (new_paintable,
+                                  "invalidate-contents",
+                                  G_CALLBACK (gdk_paintable_invalidate_contents),
+                                  self);
+      if ((flags & GDK_PAINTABLE_STATIC_SIZE) == 0)
+        g_signal_connect_swapped (new_paintable,
+                                  "invalidate-size",
+                                  G_CALLBACK (gdk_paintable_invalidate_size),
+                                  self);
+    }
+
+  gdk_paintable_invalidate_size (GDK_PAINTABLE (self));
+  gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+
+  return TRUE;
+}
+
+void
+gtk_diff_paintable_set_first (GtkDiffPaintable *self,
+                              GdkPaintable     *paintable)
+{
+  g_return_if_fail (GTK_IS_DIFF_PAINTABLE (self));
+  g_return_if_fail (paintable == NULL || GDK_IS_PAINTABLE (paintable));
+
+  if (!gtk_diff_paintable_set_paintable (self, &self->first, paintable))
+    return;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_FIRST]);
+}
+
+GdkPaintable *
+gtk_diff_paintable_get_first (GtkDiffPaintable *self)
+{
+  g_return_val_if_fail (GTK_IS_DIFF_PAINTABLE (self), NULL);
+
+  return self->first;
+}
+
+void
+gtk_diff_paintable_set_second (GtkDiffPaintable *self,
+                               GdkPaintable     *paintable)
+{
+  g_return_if_fail (GTK_IS_DIFF_PAINTABLE (self));
+  g_return_if_fail (paintable == NULL || GDK_IS_PAINTABLE (paintable));
+
+  if (!gtk_diff_paintable_set_paintable (self, &self->second, paintable))
+    return;
+
+  g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_SECOND]);
+}
+
+GdkPaintable *
+gtk_diff_paintable_get_second (GtkDiffPaintable *self)
+{
+  g_return_val_if_fail (GTK_IS_DIFF_PAINTABLE (self), NULL);
+
+  return self->second;
+}
+
diff --git a/gtk/gtkdiffpaintableprivate.h b/gtk/gtkdiffpaintableprivate.h
new file mode 100644
index 0000000000..9d3789fb20
--- /dev/null
+++ b/gtk/gtkdiffpaintableprivate.h
@@ -0,0 +1,43 @@
+/*
+ * Copyright © 2019 Benjamin Otte
+ *
+ * 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.1 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/>.
+ *
+ * Authors: Benjamin Otte <otte gnome org>
+ */
+
+#ifndef __GTK_DIFF_PAINTABLE_H__
+#define __GTK_DIFF_PAINTABLE_H__
+
+#include <gsk/gsk.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_DIFF_PAINTABLE (gtk_diff_paintable_get_type ())
+
+G_DECLARE_FINAL_TYPE (GtkDiffPaintable, gtk_diff_paintable, GTK, DIFF_PAINTABLE, GObject)
+
+GdkPaintable *  gtk_diff_paintable_new                  (GdkPaintable           *first,
+                                                         GdkPaintable           *second);
+
+void            gtk_diff_paintable_set_first            (GtkDiffPaintable       *self,
+                                                         GdkPaintable           *first);
+GdkPaintable *  gtk_diff_paintable_get_first            (GtkDiffPaintable       *self) G_GNUC_PURE;
+void            gtk_diff_paintable_set_second           (GtkDiffPaintable       *self,
+                                                         GdkPaintable           *second);
+GdkPaintable *  gtk_diff_paintable_get_second           (GtkDiffPaintable       *self) G_GNUC_PURE;
+
+G_END_DECLS
+
+#endif /* __GTK_DIFF_PAINTABLE_H__ */
diff --git a/gtk/inspector/magnifier.c b/gtk/inspector/magnifier.c
index 4e826135a4..36810743b1 100644
--- a/gtk/inspector/magnifier.c
+++ b/gtk/inspector/magnifier.c
@@ -24,6 +24,7 @@
 
 #include "gtkadjustment.h"
 #include "gtkstack.h"
+#include "gtkdiffpaintableprivate.h"
 #include "gtklabel.h"
 #include "gtklistbox.h"
 #include "gtkpicture.h"
@@ -134,19 +135,30 @@ static GtkWidget *
 gtk_inspector_magnifier_create_renderer_widget (gpointer item,
                                                 gpointer user_data)
 {
+  GtkInspectorMagnifier *self = user_data;
+  GtkInspectorMagnifierPrivate *priv = gtk_inspector_magnifier_get_instance_private (self);
   GdkPaintable *paintable = item;
-  GtkWidget *box, *label, *picture;
+  GdkPaintable *diff;
+  GtkWidget *vbox, *hbox, *label, *picture;
 
-  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
-  gtk_widget_set_size_request (box, 160, 120);
+  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+  gtk_widget_set_size_request (vbox, 160, 60);
 
   label = gtk_label_new (g_object_get_data (G_OBJECT (paintable), "description"));
-  gtk_container_add (GTK_CONTAINER (box), label);
+  gtk_container_add (GTK_CONTAINER (vbox), label);
+
+  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
+  gtk_container_add (GTK_CONTAINER (vbox), hbox);
 
   picture = gtk_picture_new_for_paintable (paintable);
-  gtk_container_add (GTK_CONTAINER (box), picture);
+  gtk_container_add (GTK_CONTAINER (hbox), picture);
+
+  diff = gtk_diff_paintable_new (paintable, priv->paintable);
+  picture = gtk_picture_new_for_paintable (diff);
+  gtk_container_add (GTK_CONTAINER (hbox), picture);
+  g_object_unref (diff);
 
-  return box;
+  return vbox;
 }
 
 static void
diff --git a/gtk/meson.build b/gtk/meson.build
index 59f5749551..2033a1a909 100644
--- a/gtk/meson.build
+++ b/gtk/meson.build
@@ -202,6 +202,7 @@ gtk_public_sources = files([
   'gtkcontainer.c',
   'gtkcssprovider.c',
   'gtkdialog.c',
+  'gtkdiffpaintable.c',
   'gtkdnd.c',
   'gtkdragdest.c',
   'gtkdragsource.c',