Adding upstream version 2.10.36.upstream/2.10.36

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 505 insertions, 0 deletions

diff --git a/app/display/gimpcanvaspolygon.c b/app/display/gimpcanvaspolygon.c
new file mode 100644
index 0000000..9c670e7
--- /dev/null
+++ b/app/display/gimpcanvaspolygon.c
@@ -0,0 +1,505 @@
+/* GIMP - The GNU Image Manipulation Program
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * gimpcanvaspolygon.c
+ * Copyright (C) 2010 Michael Natterer <mitch@gimp.org>
+ *
+ * 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 3 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, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "config.h"
+
+#include <gegl.h>
+#include <gtk/gtk.h>
+
+#include "libgimpbase/gimpbase.h"
+#include "libgimpmath/gimpmath.h"
+
+#include "display-types.h"
+
+#include "core/gimp-transform-utils.h"
+#include "core/gimpparamspecs.h"
+
+#include "gimpcanvaspolygon.h"
+#include "gimpdisplayshell.h"
+
+
+enum
+{
+  PROP_0,
+  PROP_POINTS,
+  PROP_TRANSFORM,
+  PROP_FILLED
+};
+
+
+typedef struct _GimpCanvasPolygonPrivate GimpCanvasPolygonPrivate;
+
+struct _GimpCanvasPolygonPrivate
+{
+  GimpVector2  *points;
+  gint          n_points;
+  GimpMatrix3  *transform;
+  gboolean      filled;
+};
+
+#define GET_PRIVATE(polygon) \
+        ((GimpCanvasPolygonPrivate *) gimp_canvas_polygon_get_instance_private ((GimpCanvasPolygon *) (polygon)))
+
+
+/*  local function prototypes  */
+
+static void             gimp_canvas_polygon_finalize     (GObject        *object);
+static void             gimp_canvas_polygon_set_property (GObject        *object,
+                                                          guint           property_id,
+                                                          const GValue   *value,
+                                                          GParamSpec     *pspec);
+static void             gimp_canvas_polygon_get_property (GObject        *object,
+                                                          guint           property_id,
+                                                          GValue         *value,
+                                                          GParamSpec     *pspec);
+static void             gimp_canvas_polygon_draw         (GimpCanvasItem *item,
+                                                          cairo_t        *cr);
+static cairo_region_t * gimp_canvas_polygon_get_extents  (GimpCanvasItem *item);
+static gboolean         gimp_canvas_polygon_hit          (GimpCanvasItem *item,
+                                                          gdouble         x,
+                                                          gdouble         y);
+
+
+G_DEFINE_TYPE_WITH_PRIVATE (GimpCanvasPolygon, gimp_canvas_polygon,
+                            GIMP_TYPE_CANVAS_ITEM)
+
+#define parent_class gimp_canvas_polygon_parent_class
+
+
+static void
+gimp_canvas_polygon_class_init (GimpCanvasPolygonClass *klass)
+{
+  GObjectClass        *object_class = G_OBJECT_CLASS (klass);
+  GimpCanvasItemClass *item_class   = GIMP_CANVAS_ITEM_CLASS (klass);
+
+  object_class->finalize     = gimp_canvas_polygon_finalize;
+  object_class->set_property = gimp_canvas_polygon_set_property;
+  object_class->get_property = gimp_canvas_polygon_get_property;
+
+  item_class->draw           = gimp_canvas_polygon_draw;
+  item_class->get_extents    = gimp_canvas_polygon_get_extents;
+  item_class->hit            = gimp_canvas_polygon_hit;
+
+  g_object_class_install_property (object_class, PROP_POINTS,
+                                   gimp_param_spec_array ("points", NULL, NULL,
+                                                          GIMP_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class, PROP_TRANSFORM,
+                                   g_param_spec_pointer ("transform", NULL, NULL,
+                                                         GIMP_PARAM_READWRITE));
+
+  g_object_class_install_property (object_class, PROP_FILLED,
+                                   g_param_spec_boolean ("filled", NULL, NULL,
+                                                         FALSE,
+                                                         GIMP_PARAM_READWRITE));
+}
+
+static void
+gimp_canvas_polygon_init (GimpCanvasPolygon *polygon)
+{
+}
+
+static void
+gimp_canvas_polygon_finalize (GObject *object)
+{
+  GimpCanvasPolygonPrivate *private = GET_PRIVATE (object);
+
+  g_clear_pointer (&private->points, g_free);
+  private->n_points = 0;
+
+  g_clear_pointer (&private->transform, g_free);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gimp_canvas_polygon_set_property (GObject      *object,
+                                  guint         property_id,
+                                  const GValue *value,
+                                  GParamSpec   *pspec)
+{
+  GimpCanvasPolygonPrivate *private = GET_PRIVATE (object);
+
+  switch (property_id)
+    {
+    case PROP_POINTS:
+      {
+        GimpArray *array = g_value_get_boxed (value);
+
+        g_clear_pointer (&private->points, g_free);
+        private->n_points = 0;
+
+        if (array)
+          {
+            private->points = g_memdup (array->data, array->length);
+            private->n_points = array->length / sizeof (GimpVector2);
+          }
+      }
+      break;
+
+    case PROP_TRANSFORM:
+      {
+        GimpMatrix3 *transform = g_value_get_pointer (value);
+        if (private->transform)
+          g_free (private->transform);
+        if (transform)
+          private->transform = g_memdup (transform, sizeof (GimpMatrix3));
+        else
+          private->transform = NULL;
+      }
+      break;
+
+    case PROP_FILLED:
+      private->filled = g_value_get_boolean (value);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_canvas_polygon_get_property (GObject    *object,
+                                  guint       property_id,
+                                  GValue     *value,
+                                  GParamSpec *pspec)
+{
+  GimpCanvasPolygonPrivate *private = GET_PRIVATE (object);
+
+  switch (property_id)
+    {
+    case PROP_POINTS:
+      if (private->points)
+        {
+          GimpArray *array;
+
+          array = gimp_array_new ((const guint8 *) private->points,
+                                  private->n_points * sizeof (GimpVector2),
+                                  FALSE);
+          g_value_take_boxed (value, array);
+        }
+      else
+        {
+          g_value_set_boxed (value, NULL);
+        }
+      break;
+
+    case PROP_TRANSFORM:
+      g_value_set_pointer (value, private->transform);
+      break;
+
+    case PROP_FILLED:
+      g_value_set_boolean (value, private->filled);
+      break;
+
+    default:
+      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
+      break;
+    }
+}
+
+static void
+gimp_canvas_polygon_transform (GimpCanvasItem *item,
+                               GimpVector2    *points,
+                               gint           *n_points)
+{
+  GimpCanvasPolygonPrivate *private = GET_PRIVATE (item);
+  gint                      i;
+
+  if (private->transform)
+    {
+      gimp_transform_polygon (private->transform,
+                              private->points, private->n_points, FALSE,
+                              points, n_points);
+
+      for (i = 0; i < *n_points; i++)
+        {
+          gimp_canvas_item_transform_xy_f (item,
+                                           points[i].x,
+                                           points[i].y,
+                                           &points[i].x,
+                                           &points[i].y);
+
+          points[i].x = floor (points[i].x) + 0.5;
+          points[i].y = floor (points[i].y) + 0.5;
+        }
+    }
+  else
+    {
+      for (i = 0; i < private->n_points; i++)
+        {
+          gimp_canvas_item_transform_xy_f (item,
+                                           private->points[i].x,
+                                           private->points[i].y,
+                                           &points[i].x,
+                                           &points[i].y);
+
+          points[i].x = floor (points[i].x) + 0.5;
+          points[i].y = floor (points[i].y) + 0.5;
+        }
+
+      *n_points = private->n_points;
+    }
+}
+
+static void
+gimp_canvas_polygon_draw (GimpCanvasItem *item,
+                          cairo_t        *cr)
+{
+  GimpCanvasPolygonPrivate *private = GET_PRIVATE (item);
+  GimpVector2              *points;
+  gint                      n_points;
+  gint                      i;
+
+  if (! private->points)
+    return;
+
+  n_points = private->n_points;
+
+  if (private->transform)
+    n_points = 3 * n_points / 2;
+
+  points = g_new0 (GimpVector2, n_points);
+
+  gimp_canvas_polygon_transform (item, points, &n_points);
+
+  if (n_points < 2)
+    {
+      g_free (points);
+
+      return;
+    }
+
+  cairo_move_to (cr, points[0].x, points[0].y);
+
+  for (i = 1; i < n_points; i++)
+    {
+      cairo_line_to (cr, points[i].x, points[i].y);
+    }
+
+  if (private->filled)
+    _gimp_canvas_item_fill (item, cr);
+  else
+    _gimp_canvas_item_stroke (item, cr);
+
+  g_free (points);
+}
+
+static cairo_region_t *
+gimp_canvas_polygon_get_extents (GimpCanvasItem *item)
+{
+  GimpCanvasPolygonPrivate *private = GET_PRIVATE (item);
+  cairo_rectangle_int_t     rectangle;
+  GimpVector2              *points;
+  gint                      n_points;
+  gint                      x1, y1, x2, y2;
+  gint                      i;
+
+  if (! private->points)
+    return NULL;
+
+  n_points = private->n_points;
+
+  if (private->transform)
+    n_points = 3 * n_points / 2;
+
+  points = g_new0 (GimpVector2, n_points);
+
+  gimp_canvas_polygon_transform (item, points, &n_points);
+
+  if (n_points < 2)
+    {
+      g_free (points);
+
+      return NULL;
+    }
+
+  x1 = floor (points[0].x - 1.5);
+  y1 = floor (points[0].y - 1.5);
+  x2 = x1 + 3;
+  y2 = y1 + 3;
+
+  for (i = 1; i < n_points; i++)
+    {
+      gint x3 = floor (points[i].x - 1.5);
+      gint y3 = floor (points[i].y - 1.5);
+      gint x4 = x3 + 3;
+      gint y4 = y3 + 3;
+
+      x1 = MIN (x1, x3);
+      y1 = MIN (y1, y3);
+      x2 = MAX (x2, x4);
+      y2 = MAX (y2, y4);
+    }
+
+  g_free (points);
+
+  rectangle.x      = x1;
+  rectangle.y      = y1;
+  rectangle.width  = x2 - x1;
+  rectangle.height = y2 - y1;
+
+  return cairo_region_create_rectangle (&rectangle);
+}
+
+static gboolean
+gimp_canvas_polygon_hit (GimpCanvasItem *item,
+                         gdouble         x,
+                         gdouble         y)
+{
+  GimpCanvasPolygonPrivate *private = GET_PRIVATE (item);
+  GimpVector2              *points;
+  gint                      n_points;
+  gdouble                   tx, ty;
+  cairo_surface_t          *surface;
+  cairo_t                  *cr;
+  gboolean                  hit;
+  gint                      i;
+
+  if (! private->points)
+    return FALSE;
+
+  gimp_canvas_item_transform_xy_f (item, x, y, &tx, &ty);
+
+  n_points = private->n_points;
+
+  if (private->transform)
+    n_points = 3 * n_points / 2;
+
+  points = g_new0 (GimpVector2, n_points);
+
+  gimp_canvas_polygon_transform (item, points, &n_points);
+
+  if (n_points < 2)
+    {
+      g_free (points);
+
+      return FALSE;
+    }
+
+  surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, 1, 1);
+  cr = cairo_create (surface);
+  cairo_surface_destroy (surface);
+
+  cairo_move_to (cr, points[0].x, points[0].y);
+
+  for (i = 1; i < private->n_points; i++)
+    {
+      cairo_line_to (cr, points[i].x, points[i].y);
+    }
+
+  g_free (points);
+
+  hit = cairo_in_fill (cr, tx, ty);
+
+  cairo_destroy (cr);
+
+  return hit;
+}
+
+GimpCanvasItem *
+gimp_canvas_polygon_new (GimpDisplayShell  *shell,
+                         const GimpVector2 *points,
+                         gint               n_points,
+                         GimpMatrix3       *transform,
+                         gboolean           filled)
+{
+  GimpCanvasItem *item;
+  GimpArray      *array;
+
+  g_return_val_if_fail (GIMP_IS_DISPLAY_SHELL (shell), NULL);
+  g_return_val_if_fail (points == NULL || n_points > 0, NULL);
+
+  array = gimp_array_new ((const guint8 *) points,
+                          n_points * sizeof (GimpVector2), TRUE);
+
+  item = g_object_new (GIMP_TYPE_CANVAS_POLYGON,
+                       "shell",     shell,
+                       "transform", transform,
+                       "filled",    filled,
+                       "points",    array,
+                       NULL);
+
+  gimp_array_free (array);
+
+  return item;
+}
+
+GimpCanvasItem *
+gimp_canvas_polygon_new_from_coords (GimpDisplayShell *shell,
+                                     const GimpCoords *coords,
+                                     gint              n_coords,
+                                     GimpMatrix3      *transform,
+                                     gboolean          filled)
+{
+  GimpCanvasItem *item;
+  GimpVector2    *points;
+  GimpArray      *array;
+  gint            i;
+
+  g_return_val_if_fail (GIMP_IS_DISPLAY_SHELL (shell), NULL);
+  g_return_val_if_fail (coords == NULL || n_coords > 0, NULL);
+
+  points = g_new (GimpVector2, n_coords);
+
+  for (i = 0; i < n_coords; i++)
+    {
+      points[i].x = coords[i].x;
+      points[i].y = coords[i].y;
+    }
+
+  array = gimp_array_new ((const guint8 *) points,
+                          n_coords * sizeof (GimpVector2), TRUE);
+
+  item = g_object_new (GIMP_TYPE_CANVAS_POLYGON,
+                       "shell",     shell,
+                       "transform", transform,
+                       "filled",    filled,
+                       "points",    array,
+                       NULL);
+
+  gimp_array_free (array);
+  g_free (points);
+
+  return item;
+}
+
+void
+gimp_canvas_polygon_set_points (GimpCanvasItem    *polygon,
+                                const GimpVector2 *points,
+                                gint               n_points)
+{
+  GimpArray *array;
+
+  g_return_if_fail (GIMP_IS_CANVAS_POLYGON (polygon));
+  g_return_if_fail (points == NULL || n_points > 0);
+
+  array = gimp_array_new ((const guint8 *) points,
+                          n_points * sizeof (GimpVector2), TRUE);
+
+  gimp_canvas_item_begin_change (polygon);
+  g_object_set (polygon,
+                "points", array,
+                NULL);
+  gimp_canvas_item_end_change (polygon);
+
+  gimp_array_free (array);
+}