gtk-demo: Add a few path benchmarks

The Tiger and Graph examples in the fishbowl test
path handling.

demos/gtk-demo/demo.gresource.xml

@@ -127,6 +127,7 @@
     <file>fishbowl.ui</file>
     <file>gtkfishbowl.c</file>
     <file>gtkfishbowl.h</file>
+    <file>tiger.node</file>
   </gresource>
   <gresource prefix="/frames">
     <file>frames.ui</file>

demos/gtk-demo/fishbowl.c

@@ -11,6 +11,9 @@
 #include "gtkgears.h"
 #include "gskshaderpaintable.h"
 
+#include "nodewidget.h"
+#include "graphwidget.h"
+
 const char *const css =
 ".blurred-button {"
 "  box-shadow: 0px 0px 5px 10px rgba(0, 0, 0, 0.5);"
@@ -208,6 +211,18 @@ create_menu_button (void)
   return w;
 }
 
+static GtkWidget *
+create_tiger (void)
+{
+  return node_widget_new ("/fishbowl/tiger.node");
+}
+
+static GtkWidget *
+create_graph (void)
+{
+  return graph_widget_new ();
+}
+
 static const struct {
   const char *name;
   GtkWidget * (*create_func) (void);
@@ -225,6 +240,8 @@ static const struct {
   { "Switch",     create_switch         },
   { "Menubutton", create_menu_button    },
   { "Shader",     create_cogs           },
+  { "Tiger",      create_tiger          },
+  { "Graph",      create_graph          },
 };
 
 static int selected_widget_type = -1;

demos/gtk-demo/graphwidget.c

@@ -0,0 +1,153 @@
+#include "graphwidget.h"
+
+struct _GraphWidget
+{
+  GtkWidget parent_instance;
+
+  GskPath *path;
+  GskStroke *stroke;
+  GdkRGBA color;
+
+  guint tick_cb;
+  guint64 start_time;
+
+  double period;
+  double amplitude;
+};
+
+struct _GraphWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (GraphWidget, graph_widget, GTK_TYPE_WIDGET)
+
+static void
+update_path (GraphWidget *self,
+             float        amplitude)
+{
+  graphene_point_t p[20];
+  GskPathBuilder *builder;
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+
+  for (int i = 0; i < 20; i++)
+    {
+      p[i].x = 10 * i;
+      p[i].y = 50;
+
+      if (i % 4 == 1 || i % 4 == 2)
+        {
+          if (i % 8 < 4)
+            p[i].y += amplitude;
+          else
+            p[i].y -= amplitude;
+        }
+    }
+
+  builder = gsk_path_builder_new ();
+  gsk_path_builder_move_to (builder, p[0].x, p[0].y);
+
+  for (int i = 0; i < 20; i += 4)
+    gsk_path_builder_cubic_to (builder,
+                               p[i+1].x, p[i+1].y,
+                               p[i+2].x, p[i+2].y,
+                               p[i+3].x, p[i+3].y);
+
+  self->path = gsk_path_builder_free_to_path (builder);
+}
+
+static gboolean
+tick_cb (GtkWidget     *widget,
+         GdkFrameClock *frame_clock,
+         gpointer       user_data)
+{
+  GraphWidget *self = GRAPH_WIDGET (widget);
+  guint64 now;
+  double angle;
+
+  now = gdk_frame_clock_get_frame_time (frame_clock);
+
+  if (self->start_time == 0)
+    self->start_time = now;
+
+  angle = 360 * (now - self->start_time) / (double)(self->period * G_TIME_SPAN_MINUTE);
+  update_path (self, sin (angle) * self->amplitude);
+
+  gtk_widget_queue_draw (widget);
+
+  return G_SOURCE_CONTINUE;
+}
+
+static void
+graph_widget_init (GraphWidget *self)
+{
+  self->color.red = g_random_double_range (0, 1);
+  self->color.green = g_random_double_range (0, 1);
+  self->color.blue = g_random_double_range (0, 1);
+  self->color.alpha = 1;
+
+  self->period = g_random_double_range (0.5, 1);
+  self->amplitude = g_random_double_range (10, 25);
+
+  self->stroke = gsk_stroke_new (2);
+
+  update_path (self, 0);
+
+  self->start_time = 0;
+  self->tick_cb = gtk_widget_add_tick_callback (GTK_WIDGET (self), tick_cb, NULL, NULL);
+}
+
+static void
+graph_widget_dispose (GObject *object)
+{
+  GraphWidget *self = GRAPH_WIDGET (object);
+
+  g_clear_pointer (&self->path, gsk_path_unref);
+  gsk_stroke_free (self->stroke);
+
+  G_OBJECT_CLASS (graph_widget_parent_class)->dispose (object);
+}
+
+static void
+graph_widget_snapshot (GtkWidget   *widget,
+                      GtkSnapshot *snapshot)
+{
+  GraphWidget *self = GRAPH_WIDGET (widget);
+
+  gtk_snapshot_append_stroke (snapshot, self->path, self->stroke, &self->color);
+}
+
+static void
+graph_widget_measure (GtkWidget      *widget,
+                      GtkOrientation  orientation,
+                      int             for_size,
+                      int            *minimum,
+                      int            *natural,
+                      int            *minimum_baseline,
+                      int            *natural_baseline)
+{
+  if (orientation == GTK_ORIENTATION_HORIZONTAL)
+    *minimum = *natural = 200;
+  else
+    *minimum = *natural = 100;
+}
+
+
+static void
+graph_widget_class_init (GraphWidgetClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->dispose = graph_widget_dispose;
+
+  widget_class->snapshot = graph_widget_snapshot;
+  widget_class->measure = graph_widget_measure;
+}
+
+GtkWidget *
+graph_widget_new (void)
+{
+  return g_object_new (GRAPH_TYPE_WIDGET, NULL);
+}

demos/gtk-demo/graphwidget.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define GRAPH_TYPE_WIDGET (graph_widget_get_type ())
+G_DECLARE_FINAL_TYPE (GraphWidget, graph_widget, GRAPH, WIDGET, GtkWidget)
+
+GtkWidget * graph_widget_new       (void);

demos/gtk-demo/meson.build

@@ -141,6 +141,8 @@ extra_demo_sources = files([
   'unicode-names.c',
   'suggestionentry.c',
   'language-names.c',
+  'nodewidget.c',
+  'graphwidget.c',
 ])
 
 if os_unix

demos/gtk-demo/nodewidget.c

@@ -0,0 +1,76 @@
+#include "nodewidget.h"
+
+struct _NodeWidget
+{
+  GtkWidget parent_instance;
+
+  GskRenderNode *node;
+};
+
+struct _NodeWidgetClass
+{
+  GtkWidgetClass parent_class;
+};
+
+G_DEFINE_TYPE (NodeWidget, node_widget, GTK_TYPE_WIDGET)
+
+static void
+node_widget_init (NodeWidget *self)
+{
+}
+
+static void
+node_widget_dispose (GObject *object)
+{
+  NodeWidget *self = NODE_WIDGET (object);
+
+  gsk_render_node_unref (self->node);
+
+  G_OBJECT_CLASS (node_widget_parent_class)->dispose (object);
+}
+
+static void
+node_widget_snapshot (GtkWidget   *widget,
+                      GtkSnapshot *snapshot)
+{
+  NodeWidget *self = NODE_WIDGET (widget);
+
+  gtk_snapshot_append_node (snapshot, self->node);
+}
+
+static void
+node_widget_class_init (NodeWidgetClass *class)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (class);
+  GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (class);
+
+  object_class->dispose = node_widget_dispose;
+
+  widget_class->snapshot = node_widget_snapshot;
+}
+
+GtkWidget *
+node_widget_new (const char *resource)
+{
+  NodeWidget *self;
+  GBytes *bytes;
+  GskRenderNode *node;
+  graphene_rect_t bounds;
+  float scale;
+  GskTransform *transform;
+
+  self = g_object_new (NODE_TYPE_WIDGET, NULL);
+
+  bytes = g_resources_lookup_data (resource, 0, NULL);
+  node = gsk_render_node_deserialize (bytes, NULL, NULL);
+  g_bytes_unref (bytes);
+
+  gsk_render_node_get_bounds (node, &bounds);
+  scale = MIN (100.0/bounds.size.width, 100.0/bounds.size.height);
+  transform = gsk_transform_scale (NULL, scale, scale);
+  self->node = gsk_transform_node_new (node, transform);
+  gsk_transform_unref (transform);
+  gsk_render_node_unref (node);
+
+  return GTK_WIDGET (self);
+}

demos/gtk-demo/nodewidget.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <gtk/gtk.h>
+
+#define NODE_TYPE_WIDGET (node_widget_get_type ())
+G_DECLARE_FINAL_TYPE (NodeWidget, node_widget, NODE, WIDGET, GtkWidget)
+
+GtkWidget * node_widget_new       (const char *file);