diff options
Diffstat (limited to 'app/display/gimpcanvaspolygon.c')
| -rw-r--r-- | app/display/gimpcanvaspolygon.c | 505 |
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); +} |