GNOME.org
 

[gtk/wip/otte/nodeeditor: 6/12] magnifier: Add renderings with alternative renderers

commit 16c4216b98be2aae763a41a0fa62467859a11a07
Author: Benjamin Otte <otte redhat com>
Date:   Sat Mar 9 14:55:17 2019 +0100

    magnifier: Add renderings with alternative renderers
    
    That's pretty rough around the edges, but it mostly works.
    Apart from sizing, screw listbox sizing.

 gtk/gtkrendererpaintable.c        | 315 ++++++++++++++++++++++++++++++++++++++
 gtk/gtkrendererpaintableprivate.h |  43 ++++++
 gtk/inspector/magnifier.c         | 164 ++++++++++++++++++--
 gtk/inspector/magnifier.ui        |  16 +-
 gtk/meson.build                   |   1 +
 5 files changed, 523 insertions(+), 16 deletions(-)
---
diff --git a/gtk/gtkrendererpaintable.c b/gtk/gtkrendererpaintable.c
new file mode 100644
index 0000000000..4bdfc934fb
--- /dev/null
+++ b/gtk/gtkrendererpaintable.c
@@ -0,0 +1,315 @@
+/*
+ * 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 "gtkrendererpaintableprivate.h"
+
+#include "gtkintl.h"
+#include "gtksnapshot.h"
+
+struct _GtkRendererPaintable
+{
+  GObject parent_instance;
+
+  GskRenderer *renderer;
+  GdkPaintable *paintable;
+};
+
+struct _GtkRendererPaintableClass
+{
+  GObjectClass parent_class;
+};
+
+enum {
+  PROP_0,
+  PROP_PAINTABLE,
+  PROP_RENDERER,
+  N_PROPS
+};
+
+static GParamSpec *properties[N_PROPS] = { NULL, };
+
+static void
+gtk_renderer_paintable_paintable_snapshot (GdkPaintable *paintable,
+                                           GdkSnapshot  *snapshot,
+                                           double        width,
+                                           double        height)
+{
+  GtkRendererPaintable *self = GTK_RENDERER_PAINTABLE (paintable);
+  GtkSnapshot *node_snapshot;
+  GskRenderNode *node;
+  GdkTexture *texture;
+
+  if (self->paintable == NULL)
+    return;
+
+  if (self->renderer == NULL ||
+      !gsk_renderer_is_realized (self->renderer))
+    {
+      gdk_paintable_snapshot (self->paintable, snapshot, width, height);
+      return;
+    }
+
+  node_snapshot = gtk_snapshot_new ();
+  gdk_paintable_snapshot (self->paintable, node_snapshot, width, height);
+  node = gtk_snapshot_free_to_node (node_snapshot);
+
+  texture = gsk_renderer_render_texture (self->renderer,
+                                         node,
+                                         &GRAPHENE_RECT_INIT (0, 0, width, height));
+
+  gdk_paintable_snapshot (GDK_PAINTABLE (texture), snapshot, width, height);
+}
+
+static int
+gtk_renderer_paintable_paintable_get_intrinsic_width (GdkPaintable *paintable)
+{
+  GtkRendererPaintable *self = GTK_RENDERER_PAINTABLE (paintable);
+
+  if (self->paintable == NULL)
+    return 0;
+
+  return gdk_paintable_get_intrinsic_width (self->paintable);
+}
+
+static int
+gtk_renderer_paintable_paintable_get_intrinsic_height (GdkPaintable *paintable)
+{
+  GtkRendererPaintable *self = GTK_RENDERER_PAINTABLE (paintable);
+
+  if (self->paintable == NULL)
+    return 0;
+
+  return gdk_paintable_get_intrinsic_height (self->paintable);
+}
+
+static double
+gtk_renderer_paintable_paintable_get_intrinsic_aspect_ratio (GdkPaintable *paintable)
+{
+  GtkRendererPaintable *self = GTK_RENDERER_PAINTABLE (paintable);
+
+  if (self->paintable == NULL)
+    return 0.0;
+
+  return gdk_paintable_get_intrinsic_aspect_ratio (self->paintable);
+}
+
+static void
+gtk_renderer_paintable_paintable_init (GdkPaintableInterface *iface)
+{
+  iface->snapshot = gtk_renderer_paintable_paintable_snapshot;
+  iface->get_intrinsic_width = gtk_renderer_paintable_paintable_get_intrinsic_width;
+  iface->get_intrinsic_height = gtk_renderer_paintable_paintable_get_intrinsic_height;
+  iface->get_intrinsic_aspect_ratio = gtk_renderer_paintable_paintable_get_intrinsic_aspect_ratio;
+}
+
+G_DEFINE_TYPE_EXTENDED (GtkRendererPaintable, gtk_renderer_paintable, G_TYPE_OBJECT, 0,
+                        G_IMPLEMENT_INTERFACE (GDK_TYPE_PAINTABLE,
+                                               gtk_renderer_paintable_paintable_init))
+
+static void
+gtk_renderer_paintable_set_property (GObject      *object,
+                                     guint         prop_id,
+                                     const GValue *value,
+                                     GParamSpec   *pspec)
+
+{
+  GtkRendererPaintable *self = GTK_RENDERER_PAINTABLE (object);
+
+  switch (prop_id)
+    {
+    case PROP_PAINTABLE:
+      gtk_renderer_paintable_set_paintable (self, g_value_get_object (value));
+      break;
+
+    case PROP_RENDERER:
+      gtk_renderer_paintable_set_renderer (self, g_value_get_object (value));
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_renderer_paintable_get_property (GObject    *object,
+                                     guint       prop_id,
+                                     GValue     *value,
+                                     GParamSpec *pspec)
+{
+  GtkRendererPaintable *self = GTK_RENDERER_PAINTABLE (object);
+
+  switch (prop_id)
+    {
+    case PROP_PAINTABLE:
+      g_value_set_object (value, self->paintable);
+      break;
+
+    case PROP_RENDERER:
+      g_value_set_object (value, self->renderer);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+      break;
+    }
+}
+
+static void
+gtk_renderer_paintable_unset_paintable (GtkRendererPaintable *self)
+{
+  guint flags;
+  
+  if (self->paintable == NULL)
+    return;
+
+  flags = gdk_paintable_get_flags (self->paintable);
+
+  if ((flags & GDK_PAINTABLE_STATIC_CONTENTS) == 0)
+    g_signal_handlers_disconnect_by_func (self->paintable,
+                                          gdk_paintable_invalidate_contents,
+                                          self);
+
+  if ((flags & GDK_PAINTABLE_STATIC_SIZE) == 0)
+    g_signal_handlers_disconnect_by_func (self->paintable,
+                                          gdk_paintable_invalidate_size,
+                                          self);
+}
+
+static void
+gtk_renderer_paintable_dispose (GObject *object)
+{
+  GtkRendererPaintable *self = GTK_RENDERER_PAINTABLE (object);
+
+  g_clear_object (&self->renderer);
+  gtk_renderer_paintable_unset_paintable (self);
+
+  G_OBJECT_CLASS (gtk_renderer_paintable_parent_class)->dispose (object);
+}
+
+static void
+gtk_renderer_paintable_class_init (GtkRendererPaintableClass *klass)
+{
+  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
+
+  gobject_class->get_property = gtk_renderer_paintable_get_property;
+  gobject_class->set_property = gtk_renderer_paintable_set_property;
+  gobject_class->dispose = gtk_renderer_paintable_dispose;
+
+  properties[PROP_PAINTABLE] =
+    g_param_spec_object ("paintable",
+                         P_("Paintable"),
+                         P_("The paintable to be shown"),
+                         GDK_TYPE_PAINTABLE,
+                         G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+  properties[PROP_RENDERER] =
+    g_param_spec_object ("renderer",
+                         P_("Renderer"),
+                         P_("Renderer used to render the paintable"),
+                         GSK_TYPE_RENDERER,
+                         G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS | G_PARAM_EXPLICIT_NOTIFY);
+
+  g_object_class_install_properties (gobject_class, N_PROPS, properties);
+}
+
+static void
+gtk_renderer_paintable_init (GtkRendererPaintable *self)
+{
+}
+
+GdkPaintable *
+gtk_renderer_paintable_new (GskRenderer  *renderer,
+                            GdkPaintable *paintable)
+{
+  g_return_val_if_fail (renderer == NULL || GSK_IS_RENDERER (renderer), NULL);
+  g_return_val_if_fail (paintable == NULL || GDK_IS_PAINTABLE (paintable), NULL);
+
+  return g_object_new (GTK_TYPE_RENDERER_PAINTABLE,
+                       "renderer", renderer,
+                       "paintable", paintable,
+                       NULL);
+}
+
+void
+gtk_renderer_paintable_set_renderer (GtkRendererPaintable *self,
+                                     GskRenderer          *renderer)
+{
+  g_return_if_fail (GTK_IS_RENDERER_PAINTABLE (self));
+  g_return_if_fail (renderer == NULL || GSK_IS_RENDERER (renderer));
+
+  if (!g_set_object (&self->renderer, renderer))
+    return;
+
+  if (self->paintable)
+    gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+}
+
+GskRenderer *
+gtk_renderer_paintable_get_renderer (GtkRendererPaintable *self)
+{
+  g_return_val_if_fail (GTK_IS_RENDERER_PAINTABLE (self), NULL);
+
+  return self->renderer;
+}
+
+void
+gtk_renderer_paintable_set_paintable (GtkRendererPaintable *self,
+                                      GdkPaintable         *paintable)
+{
+  g_return_if_fail (GTK_IS_RENDERER_PAINTABLE (self));
+  g_return_if_fail (paintable == NULL || GDK_IS_PAINTABLE (paintable));
+
+  if (self->paintable == paintable)
+    return;
+
+  gtk_renderer_paintable_unset_paintable (self);
+
+  if (paintable)
+    {
+      const guint flags = gdk_paintable_get_flags (paintable);
+
+      self->paintable = g_object_ref (paintable);
+
+      if ((flags & GDK_PAINTABLE_STATIC_CONTENTS) == 0)
+        g_signal_connect_swapped (paintable,
+                                  "invalidate-contents",
+                                  G_CALLBACK (gdk_paintable_invalidate_contents),
+                                  self);
+      if ((flags & GDK_PAINTABLE_STATIC_SIZE) == 0)
+        g_signal_connect_swapped (paintable,
+                                  "invalidate-size",
+                                  G_CALLBACK (gdk_paintable_invalidate_size),
+                                  self);
+    }
+
+  gdk_paintable_invalidate_size (GDK_PAINTABLE (self));
+  gdk_paintable_invalidate_contents (GDK_PAINTABLE (self));
+}
+
+GdkPaintable *
+gtk_renderer_paintable_get_paintable (GtkRendererPaintable *self)
+{
+  g_return_val_if_fail (GTK_IS_RENDERER_PAINTABLE (self), NULL);
+
+  return self->paintable;
+}
+
diff --git a/gtk/gtkrendererpaintableprivate.h b/gtk/gtkrendererpaintableprivate.h
new file mode 100644
index 0000000000..39b9f8e93b
--- /dev/null
+++ b/gtk/gtkrendererpaintableprivate.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_RENDERER_PAINTABLE_H__
+#define __GTK_RENDERER_PAINTABLE_H__
+
+#include <gsk/gsk.h>
+
+G_BEGIN_DECLS
+
+#define GTK_TYPE_RENDERER_PAINTABLE (gtk_renderer_paintable_get_type ())
+
+G_DECLARE_FINAL_TYPE (GtkRendererPaintable, gtk_renderer_paintable, GTK, RENDERER_PAINTABLE, GObject)
+
+GdkPaintable *  gtk_renderer_paintable_new                (GskRenderer          *renderer,
+                                                           GdkPaintable         *paintable);
+
+void            gtk_renderer_paintable_set_renderer       (GtkRendererPaintable *self,
+                                                           GskRenderer          *renderer);
+GskRenderer *   gtk_renderer_paintable_get_renderer       (GtkRendererPaintable *self) G_GNUC_PURE;
+void            gtk_renderer_paintable_set_paintable      (GtkRendererPaintable *self,
+                                                           GdkPaintable         *paintable);
+GdkPaintable *  gtk_renderer_paintable_get_paintable      (GtkRendererPaintable *self) G_GNUC_PURE;
+
+G_END_DECLS
+
+#endif /* __GTK_RENDERER_PAINTABLE_H__ */
diff --git a/gtk/inspector/magnifier.c b/gtk/inspector/magnifier.c
index f4a0f7e2e3..fa0ac51d4d 100644
--- a/gtk/inspector/magnifier.c
+++ b/gtk/inspector/magnifier.c
@@ -22,8 +22,21 @@
 
 #include "gtkmagnifierprivate.h"
 
-#include "gtklabel.h"
 #include "gtkadjustment.h"
+#include "gtklabel.h"
+#include "gtklistbox.h"
+#include "gtkpicture.h"
+#include "gtkrendererpaintableprivate.h"
+#include "gtkwidgetpaintable.h"
+
+#ifdef GDK_WINDOWING_BROADWAY
+#include "gsk/gskbroadwayrendererprivate.h"
+#endif
+#include "gsk/gskcairorendererprivate.h"
+#include "gsk/gl/gskglrendererprivate.h"
+#ifdef GDK_RENDERING_VULKAN
+#include "gsk/vulkan/gskvulkanrendererprivate.h"
+#endif
 
 enum
 {
@@ -35,37 +48,144 @@ struct _GtkInspectorMagnifierPrivate
 {
   GtkWidget *object;
   GtkWidget *magnifier;
+  GtkWidget *renderer_listbox;
   GtkAdjustment *adjustment;
+  GListStore *renderers;
+  GdkPaintable *paintable;
 };
 
 G_DEFINE_TYPE_WITH_PRIVATE (GtkInspectorMagnifier, gtk_inspector_magnifier, GTK_TYPE_BOX)
 
 static void
-gtk_inspector_magnifier_init (GtkInspectorMagnifier *sl)
+gtk_inspector_magnifier_add_renderer (GtkInspectorMagnifier *self,
+                                      GType                  renderer_type,
+                                      const char            *description)
+{
+  GtkInspectorMagnifierPrivate *priv = gtk_inspector_magnifier_get_instance_private (self);
+  GskRenderer *renderer;
+  GdkSurface *surface;
+  GdkPaintable *paintable;
+
+  surface = gtk_widget_get_surface (GTK_WIDGET (self));
+  g_assert (surface != NULL);
+
+  if (renderer_type == G_TYPE_NONE)
+    renderer = NULL;
+  else
+    {
+      renderer = g_object_new (renderer_type, NULL);
+
+      if (!gsk_renderer_realize (renderer, surface, NULL))
+        {
+          g_object_unref (renderer);
+          return;
+        }
+    }
+
+  paintable = gtk_renderer_paintable_new (renderer, priv->paintable);
+  g_object_set_data_full (G_OBJECT (paintable), "description", g_strdup (description), g_free);
+  g_object_unref (renderer);
+
+  g_list_store_append (priv->renderers, paintable);
+  g_object_unref (paintable);
+}
+
+static void
+gtk_inspector_magnifier_realize (GtkWidget *widget)
 {
-  sl->priv = gtk_inspector_magnifier_get_instance_private (sl);
-  gtk_widget_init_template (GTK_WIDGET (sl));
+  GtkInspectorMagnifier *self = GTK_INSPECTOR_MAGNIFIER (widget);
+
+  GTK_WIDGET_CLASS (gtk_inspector_magnifier_parent_class)->realize (widget);
+
+  gtk_inspector_magnifier_add_renderer (self,
+                                        G_TYPE_NONE,
+                                        "Default");
+  gtk_inspector_magnifier_add_renderer (self,
+                                        GSK_TYPE_GL_RENDERER,
+                                        "OpenGL");
+#ifdef GDK_RENDERING_VULKAN
+  gtk_inspector_magnifier_add_renderer (self,
+                                        GSK_TYPE_VULKAN_RENDERER,
+                                        "Vulkan");
+#endif
+#ifdef GDK_WINDOWING_BROADWAY
+  gtk_inspector_magnifier_add_renderer (self,
+                                        GSK_TYPE_BROADWAY_RENDERER,
+                                        "Broadway");
+#endif
+  gtk_inspector_magnifier_add_renderer (self,
+                                        GSK_TYPE_CAIRO_RENDERER,
+                                        "Cairo");
+}
+
+static void
+gtk_inspector_magnifier_unrealize (GtkWidget *widget)
+{
+  GtkInspectorMagnifier *self = GTK_INSPECTOR_MAGNIFIER (widget);
+  GtkInspectorMagnifierPrivate *priv = gtk_inspector_magnifier_get_instance_private (self);
+
+  g_list_store_remove_all (priv->renderers);
+
+  GTK_WIDGET_CLASS (gtk_inspector_magnifier_parent_class)->unrealize (widget);
+}
+
+static GtkWidget *
+gtk_inspector_magnifier_create_renderer_widget (gpointer item,
+                                                gpointer user_data)
+{
+  GdkPaintable *paintable = item;
+  GtkWidget *box, *label, *picture;
+
+  box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+  gtk_widget_set_size_request (box, 160, 120);
+
+  label = gtk_label_new (g_object_get_data (G_OBJECT (paintable), "description"));
+  gtk_container_add (GTK_CONTAINER (box), label);
+
+  picture = gtk_picture_new_for_paintable (paintable);
+  gtk_container_add (GTK_CONTAINER (box), picture);
+
+  return box;
+}
+
+static void
+gtk_inspector_magnifier_init (GtkInspectorMagnifier *self)
+{
+  self->priv = gtk_inspector_magnifier_get_instance_private (self);
+  gtk_widget_init_template (GTK_WIDGET (self));
+
+  self->priv->renderers = g_list_store_new (GDK_TYPE_PAINTABLE);
+  gtk_list_box_bind_model (GTK_LIST_BOX (self->priv->renderer_listbox),
+                           G_LIST_MODEL (self->priv->renderers),
+                           gtk_inspector_magnifier_create_renderer_widget,
+                           self,
+                           NULL);
+  self->priv->paintable = gtk_widget_paintable_new (NULL);
 }
 
 void
-gtk_inspector_magnifier_set_object (GtkInspectorMagnifier *sl,
-                                    GObject              *object)
+gtk_inspector_magnifier_set_object (GtkInspectorMagnifier *self,
+                                    GObject               *object)
 {
-  sl->priv->object = NULL;
+  GtkInspectorMagnifierPrivate *priv = gtk_inspector_magnifier_get_instance_private (self);
+
+  priv->object = NULL;
 
   if (!GTK_IS_WIDGET (object) || !gtk_widget_is_visible (GTK_WIDGET (object)))
     {
-      gtk_widget_hide (GTK_WIDGET (sl));
-      _gtk_magnifier_set_inspected (GTK_MAGNIFIER (sl->priv->magnifier), NULL);
+      gtk_widget_hide (GTK_WIDGET (self));
+      _gtk_magnifier_set_inspected (GTK_MAGNIFIER (priv->magnifier), NULL);
+      gtk_widget_paintable_set_widget (GTK_WIDGET_PAINTABLE (priv->paintable), NULL);
       return;
     }
 
-  gtk_widget_show (GTK_WIDGET (sl));
+  gtk_widget_show (GTK_WIDGET (self));
 
-  sl->priv->object = GTK_WIDGET (object);
+  priv->object = GTK_WIDGET (object);
 
-  _gtk_magnifier_set_inspected (GTK_MAGNIFIER (sl->priv->magnifier), GTK_WIDGET (object));
-  _gtk_magnifier_set_coords (GTK_MAGNIFIER (sl->priv->magnifier), 0, 0);
+  _gtk_magnifier_set_inspected (GTK_MAGNIFIER (priv->magnifier), GTK_WIDGET (object));
+  gtk_widget_paintable_set_widget (GTK_WIDGET_PAINTABLE (priv->paintable), GTK_WIDGET (object));
+  _gtk_magnifier_set_coords (GTK_MAGNIFIER (priv->magnifier), 0, 0);
 }
 
 static void
@@ -108,6 +228,17 @@ set_property (GObject      *object,
     }
 }
 
+static void
+gtk_inspector_magnifier_dispose (GObject *object)
+{
+  GtkInspectorMagnifier *self = GTK_INSPECTOR_MAGNIFIER (object);
+  GtkInspectorMagnifierPrivate *priv = gtk_inspector_magnifier_get_instance_private (self);
+
+  g_clear_object (&priv->renderers);
+
+  G_OBJECT_CLASS (gtk_inspector_magnifier_parent_class)->dispose (object);
+}
+
 static void
 constructed (GObject *object)
 {
@@ -116,6 +247,8 @@ constructed (GObject *object)
   g_object_bind_property (sl->priv->adjustment, "value",
                           sl->priv->magnifier, "magnification",
                           G_BINDING_SYNC_CREATE);
+
+  G_OBJECT_CLASS (gtk_inspector_magnifier_parent_class)->constructed (object);
 }
 
 static void
@@ -126,14 +259,19 @@ gtk_inspector_magnifier_class_init (GtkInspectorMagnifierClass *klass)
 
   object_class->get_property = get_property;
   object_class->set_property = set_property;
+  object_class->dispose = gtk_inspector_magnifier_dispose;
   object_class->constructed = constructed;
 
   g_object_class_install_property (object_class, PROP_ADJUSTMENT,
       g_param_spec_object ("adjustment", NULL, NULL,
                            GTK_TYPE_ADJUSTMENT, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
 
+  widget_class->realize = gtk_inspector_magnifier_realize;
+  widget_class->unrealize = gtk_inspector_magnifier_unrealize;
+
   gtk_widget_class_set_template_from_resource (widget_class, "/org/gtk/libgtk/inspector/magnifier.ui");
   gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMagnifier, magnifier);
+  gtk_widget_class_bind_template_child_private (widget_class, GtkInspectorMagnifier, renderer_listbox);
 }
 
 // vim: set et sw=2 ts=2:
diff --git a/gtk/inspector/magnifier.ui b/gtk/inspector/magnifier.ui
index 27d72e9ba1..f8bb2ff25f 100644
--- a/gtk/inspector/magnifier.ui
+++ b/gtk/inspector/magnifier.ui
@@ -5,9 +5,19 @@
       <object class="GtkScrolledWindow">
         <property name="expand">1</property>
         <child>
-          <object class="GtkMagnifier" id="magnifier">
-            <property name="visible">True</property>
-            <property name="resize">True</property>
+          <object class="GtkBox">
+            <child>
+              <object class="GtkMagnifier" id="magnifier">
+                <property name="hexpand">True</property>
+                <property name="vexpand">True</property>
+                <property name="resize">True</property>
+              </object>
+            </child>
+            <child>
+              <object class="GtkListBox" id="renderer_listbox">
+                <property name="width-request">240</property>
+              </object>
+            </child>
           </object>
         </child>
       </object>
diff --git a/gtk/meson.build b/gtk/meson.build
index 714c0eab65..ed0668cb69 100644
--- a/gtk/meson.build
+++ b/gtk/meson.build
@@ -312,6 +312,7 @@ gtk_public_sources = files([
   'gtkrenderbackground.c',
   'gtkrenderborder.c',
   'gtkrendericon.c',
+  'gtkrendererpaintable.c',
   'gtkrendernodepaintable.c',
   'gtkrevealer.c',
   'gtkroot.c',
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]