[gtk/path-work-rebased: 11/121] gsk: Add GskPathMeasure
- From: Matthias Clasen <matthiasc src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gtk/path-work-rebased: 11/121] gsk: Add GskPathMeasure
- Date: Sun, 5 Dec 2021 03:58:51 +0000 (UTC)
commit 9c721bff1bb2c960875c0d4912ecd26a7c2da224
Author: Benjamin Otte <otte redhat com>
Date: Thu Nov 12 05:09:47 2020 +0100
gsk: Add GskPathMeasure
An object to do measuring operations on paths - determining their
length, cutting off subpaths, things like that.
gsk/gsk-autocleanup.h | 1 +
gsk/gsk.h | 1 +
gsk/gskpath.c | 117 +++++++++++++++++++++++++++++++++++--
gsk/gskpathmeasure.c | 156 ++++++++++++++++++++++++++++++++++++++++++++++++++
gsk/gskpathmeasure.h | 49 ++++++++++++++++
gsk/gskpathprivate.h | 40 +++++++++++++
gsk/gsktypes.h | 1 +
gsk/meson.build | 2 +
8 files changed, 362 insertions(+), 5 deletions(-)
---
diff --git a/gsk/gsk-autocleanup.h b/gsk/gsk-autocleanup.h
index 6ca7b00d19..515ca713ec 100644
--- a/gsk/gsk-autocleanup.h
+++ b/gsk/gsk-autocleanup.h
@@ -23,6 +23,7 @@
#ifndef __GI_SCANNER__
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPath, gsk_path_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskPathMeasure, gsk_path_measure_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskRenderer, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskRenderNode, gsk_render_node_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GskTransform, gsk_transform_unref)
diff --git a/gsk/gsk.h b/gsk/gsk.h
index a5b530f291..9b9ddaceae 100644
--- a/gsk/gsk.h
+++ b/gsk/gsk.h
@@ -23,6 +23,7 @@
#include <gsk/gskenums.h>
#include <gsk/gskglshader.h>
#include <gsk/gskpath.h>
+#include <gsk/gskpathmeasure.h>
#include <gsk/gskrenderer.h>
#include <gsk/gskrendernode.h>
#include <gsk/gskroundedrect.h>
diff --git a/gsk/gskpath.c b/gsk/gskpath.c
index 4dd68f653e..a1759b3ec5 100644
--- a/gsk/gskpath.c
+++ b/gsk/gskpath.c
@@ -19,7 +19,7 @@
#include "config.h"
-#include "gskpath.h"
+#include "gskpathprivate.h"
typedef struct _GskContour GskContour;
@@ -42,6 +42,10 @@ struct _GskContourClass
cairo_t *cr);
gboolean (* get_bounds) (const GskContour *contour,
graphene_rect_t *bounds);
+ gpointer (* init_measure) (const GskContour *contour,
+ float *out_length);
+ void (* free_measure) (const GskContour *contour,
+ gpointer measure_data);
};
struct _GskPath
@@ -149,6 +153,23 @@ gsk_rect_contour_get_bounds (const GskContour *contour,
return TRUE;
}
+static gpointer
+gsk_rect_contour_init_measure (const GskContour *contour,
+ float *out_length)
+{
+ const GskRectContour *self = (const GskRectContour *) contour;
+
+ *out_length = 2 * ABS (self->width) + 2 * ABS (self->height);
+
+ return NULL;
+}
+
+static void
+gsk_rect_contour_free_measure (const GskContour *contour,
+ gpointer data)
+{
+}
+
static const GskContourClass GSK_RECT_CONTOUR_CLASS =
{
sizeof (GskRectContour),
@@ -156,7 +177,9 @@ static const GskContourClass GSK_RECT_CONTOUR_CLASS =
gsk_contour_get_size_default,
gsk_rect_contour_print,
gsk_rect_contour_to_cairo,
- gsk_rect_contour_get_bounds
+ gsk_rect_contour_get_bounds,
+ gsk_rect_contour_init_measure,
+ gsk_rect_contour_free_measure
};
static void
@@ -229,7 +252,7 @@ gsk_standard_contour_print (const GskContour *contour,
for (i = 0; i < self->n_ops; i ++)
{
- graphene_point_t *pt = &self->points [self->ops[i].point];
+ graphene_point_t *pt = &self->points[self->ops[i].point];
switch (self->ops[i].op)
{
@@ -274,7 +297,7 @@ gsk_standard_contour_to_cairo (const GskContour *contour,
for (i = 0; i < self->n_ops; i ++)
{
- graphene_point_t *pt = &self->points [self->ops[i].point];
+ graphene_point_t *pt = &self->points[self->ops[i].point];
switch (self->ops[i].op)
{
@@ -348,6 +371,52 @@ gsk_standard_contour_get_bounds (const GskContour *contour,
return bounds->size.width > 0 && bounds->size.height > 0;
}
+static gpointer
+gsk_standard_contour_init_measure (const GskContour *contour,
+ float *out_length)
+{
+ const GskStandardContour *self = (const GskStandardContour *) contour;
+ gsize i;
+ float length;
+
+ length = 0;
+
+ for (i = 1; i < self->n_ops; i ++)
+ {
+ graphene_point_t *pt = &self->points[self->ops[i].point];
+
+ switch (self->ops[i].op)
+ {
+ case GSK_PATH_MOVE:
+ break;
+
+ case GSK_PATH_CLOSE:
+ case GSK_PATH_LINE:
+ length += graphene_point_distance (&pt[0], &pt[1], NULL, NULL);
+ break;
+
+ case GSK_PATH_CURVE:
+ g_warning ("i'm not fat!");
+ length += graphene_point_distance (&pt[0], &pt[3], NULL, NULL);
+ break;
+
+ default:
+ g_assert_not_reached();
+ return NULL;
+ }
+ }
+
+ *out_length = length;
+
+ return NULL;
+}
+
+static void
+gsk_standard_contour_free_measure (const GskContour *contour,
+ gpointer data)
+{
+}
+
static const GskContourClass GSK_STANDARD_CONTOUR_CLASS =
{
sizeof (GskStandardContour),
@@ -355,7 +424,9 @@ static const GskContourClass GSK_STANDARD_CONTOUR_CLASS =
gsk_standard_contour_get_size,
gsk_standard_contour_print,
gsk_standard_contour_to_cairo,
- gsk_standard_contour_get_bounds
+ gsk_standard_contour_get_bounds,
+ gsk_standard_contour_init_measure,
+ gsk_standard_contour_free_measure
};
/* You must ensure the contour has enough size allocated,
@@ -379,6 +450,28 @@ gsk_standard_contour_init (GskContour *contour,
memcpy (self->points, points, sizeof (graphene_point_t) * n_points);
}
+/* CONTOUR */
+
+gpointer
+gsk_contour_init_measure (GskPath *path,
+ gsize i,
+ float *out_length)
+{
+ GskContour *self = path->contours[i];
+
+ return self->klass->init_measure (self, out_length);
+}
+
+void
+gsk_contour_free_measure (GskPath *path,
+ gsize i,
+ gpointer data)
+{
+ GskContour *self = path->contours[i];
+
+ self->klass->free_measure (self, data);
+}
+
/* PATH */
static GskPath *
@@ -574,6 +667,20 @@ gsk_path_to_cairo (GskPath *self,
}
}
+/*
+ * gsk_path_get_n_contours:
+ * @path: a #GskPath
+ *
+ * Gets the number of contours @path is composed out of.
+ *
+ * Returns: the number of contours in @path
+ **/
+gsize
+gsk_path_get_n_contours (GskPath *path)
+{
+ return path->n_contours;
+}
+
/**
* gsk_path_is_empty:
* @self: a `GskPath`
diff --git a/gsk/gskpathmeasure.c b/gsk/gskpathmeasure.c
new file mode 100644
index 0000000000..99759a47b0
--- /dev/null
+++ b/gsk/gskpathmeasure.c
@@ -0,0 +1,156 @@
+/*
+ * Copyright © 2020 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 "gskpathmeasure.h"
+
+#include "gskpathprivate.h"
+
+/**
+ * GskPathMeasure:
+ *
+ * `GskPathMeasure` is an object that allows measuring operations
+ * on `GskPath` objects, to determine quantities like the arc
+ * length of the path, its curvature, or closest points.
+ *
+ * These operations are useful when implementing animations.
+ */
+
+typedef struct _GskContourMeasure GskContourMeasure;
+
+struct _GskContourMeasure
+{
+ float length;
+ gpointer contour_data;
+};
+
+struct _GskPathMeasure
+{
+ /*< private >*/
+ guint ref_count;
+
+ GskPath *path;
+
+ float length;
+ gsize n_contours;
+ GskContourMeasure measures[];
+};
+
+G_DEFINE_BOXED_TYPE (GskPathMeasure, gsk_path_measure,
+ gsk_path_measure_ref,
+ gsk_path_measure_unref)
+
+/**
+ * gsk_path_measure_new:
+ * @path: the path to measure
+ *
+ * Creates a measure object for the given @path.
+ *
+ * Returns: a new `GskPathMeasure` representing @path
+ **/
+GskPathMeasure *
+gsk_path_measure_new (GskPath *path)
+{
+ GskPathMeasure *self;
+ gsize i, n_contours;
+
+ g_return_val_if_fail (path != NULL, NULL);
+
+ n_contours = gsk_path_get_n_contours (path);
+
+ self = g_malloc0 (sizeof (GskPathMeasure) + n_contours * sizeof (GskContourMeasure));
+
+ self->ref_count = 1;
+ self->path = gsk_path_ref (path);
+ self->n_contours = n_contours;
+
+ for (i = 0; i < n_contours; i++)
+ {
+ self->measures[i].contour_data = gsk_contour_init_measure (path, i, &self->measures[i].length);
+ self->length += self->measures[i].length;
+ }
+
+ return self;
+}
+
+/**
+ * gsk_path_measure_ref:
+ * @self: a `GskPathMeasure`
+ *
+ * Increases the reference count of a `GskPathMeasure` by one.
+ *
+ * Returns: the passed in `GskPathMeasure`.
+ **/
+GskPathMeasure *
+gsk_path_measure_ref (GskPathMeasure *self)
+{
+ g_return_val_if_fail (self != NULL, NULL);
+
+ self->ref_count++;
+
+ return self;
+}
+
+/**
+ * gsk_path_measure_unref:
+ * @self: a `GskPathMeasure`
+ *
+ * Decreases the reference count of a `GskPathMeasure` by one.
+ *
+ * If the resulting reference count is zero, frees the object.
+ **/
+void
+gsk_path_measure_unref (GskPathMeasure *self)
+{
+ gsize i;
+
+ g_return_if_fail (self != NULL);
+ g_return_if_fail (self->ref_count > 0);
+
+ self->ref_count--;
+ if (self->ref_count > 0)
+ return;
+
+ for (i = 0; i < self->n_contours; i++)
+ {
+ gsk_contour_free_measure (self->path, i, self->measures[i].contour_data);
+ }
+
+ gsk_path_unref (self->path);
+ g_free (self);
+}
+
+/**
+ * gsk_path_measure_get_length:
+ * @self: a `GskPathMeasure`
+ *
+ * Gets the length of the path being measured.
+ *
+ * The length is cached, so this function does not do any work.
+ *
+ * Returns: The length of the path measured by @self
+ **/
+float
+gsk_path_measure_get_length (GskPathMeasure *self)
+{
+ g_return_val_if_fail (self != NULL, 0);
+
+ return self->length;
+}
diff --git a/gsk/gskpathmeasure.h b/gsk/gskpathmeasure.h
new file mode 100644
index 0000000000..2941176e60
--- /dev/null
+++ b/gsk/gskpathmeasure.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2020 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 __GSK_PATH_MEASURE_H__
+#define __GSK_PATH_MEASURE_H__
+
+#if !defined (__GSK_H_INSIDE__) && !defined (GTK_COMPILATION)
+#error "Only <gsk/gsk.h> can be included directly."
+#endif
+
+
+#include <gsk/gsktypes.h>
+
+G_BEGIN_DECLS
+
+#define GSK_TYPE_PATH_MEASURE (gsk_path_measure_get_type ())
+
+GDK_AVAILABLE_IN_ALL
+GType gsk_path_measure_get_type (void) G_GNUC_CONST;
+GDK_AVAILABLE_IN_ALL
+GskPathMeasure * gsk_path_measure_new (GskPath *path);
+
+GDK_AVAILABLE_IN_ALL
+GskPathMeasure * gsk_path_measure_ref (GskPathMeasure *self);
+GDK_AVAILABLE_IN_ALL
+void gsk_path_measure_unref (GskPathMeasure *self);
+
+GDK_AVAILABLE_IN_ALL
+float gsk_path_measure_get_length (GskPathMeasure *self);
+
+G_END_DECLS
+
+#endif /* __GSK_PATH_MEASURE_H__ */
diff --git a/gsk/gskpathprivate.h b/gsk/gskpathprivate.h
new file mode 100644
index 0000000000..5551734411
--- /dev/null
+++ b/gsk/gskpathprivate.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2020 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 __GSK_PATH_PRIVATE_H__
+#define __GSK_PATH_PRIVATE_H__
+
+#include "gskpath.h"
+
+G_BEGIN_DECLS
+
+gsize gsk_path_get_n_contours (GskPath *path);
+
+gpointer gsk_contour_init_measure (GskPath *path,
+ gsize i,
+ float *out_length);
+void gsk_contour_free_measure (GskPath *path,
+ gsize i,
+ gpointer data);
+
+G_END_DECLS
+
+#endif /* __GSK_PATH_PRIVATE_H__ */
+
diff --git a/gsk/gsktypes.h b/gsk/gsktypes.h
index fdf06b5ffc..d31e5d9be4 100644
--- a/gsk/gsktypes.h
+++ b/gsk/gsktypes.h
@@ -27,6 +27,7 @@
#include <gsk/gskenums.h>
typedef struct _GskPath GskPath;
+typedef struct _GskPathMeasure GskPathMeasure;
typedef struct _GskRenderer GskRenderer;
typedef struct _GskStroke GskStroke;
typedef struct _GskTransform GskTransform;
diff --git a/gsk/meson.build b/gsk/meson.build
index 4463dcd26c..0ccb18a087 100644
--- a/gsk/meson.build
+++ b/gsk/meson.build
@@ -26,6 +26,7 @@ gsk_public_sources = files([
'gskcairorenderer.c',
'gskglshader.c',
'gskpath.c',
+ 'gskpathmeasure.c',
'gskrenderer.c',
'gskrendernode.c',
'gskrendernodeimpl.c',
@@ -68,6 +69,7 @@ gsk_public_headers = files([
'gskenums.h',
'gskglshader.h',
'gskpath.h',
+ 'gskpathmeasure.h',
'gskrenderer.h',
'gskrendernode.h',
'gskroundedrect.h',
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
