summaryrefslogtreecommitdiffstats
path: root/plug-ins/gfig/gfig-bezier.c
diff options
context:
space:
mode:
Diffstat (limited to 'plug-ins/gfig/gfig-bezier.c')
-rw-r--r--plug-ins/gfig/gfig-bezier.c422
1 files changed, 422 insertions, 0 deletions
diff --git a/plug-ins/gfig/gfig-bezier.c b/plug-ins/gfig/gfig-bezier.c
new file mode 100644
index 0000000..9156d7c
--- /dev/null
+++ b/plug-ins/gfig/gfig-bezier.c
@@ -0,0 +1,422 @@
+/*
+ * Copyright (C) 1995 Spencer Kimball and Peter Mattis
+ *
+ * This is a plug-in for GIMP.
+ *
+ * Generates images containing vector type drawings.
+ *
+ * Copyright (C) 1997 Andy Thomas alt@picnic.demon.co.uk
+ *
+ * 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 <libgimp/gimp.h>
+#include <libgimp/gimpui.h>
+
+#include "gfig.h"
+#include "gfig-line.h"
+#include "gfig-dobject.h"
+#include "gfig-dialog.h"
+#include "gfig-bezier.h"
+
+#include "libgimp/stdplugins-intl.h"
+
+#define FP_PNT_MAX 10
+
+typedef gdouble (*fp_pnt)[2];
+
+static gboolean bezier_closed = FALSE;
+static gboolean bezier_line_frame = FALSE;
+static int fp_pnt_cnt = 0;
+static int fp_pnt_chunk = 0;
+static gdouble *fp_pnt_pnts = NULL;
+
+GfigObject *tmp_bezier; /* Needed when drawing bezier curves */
+
+static void fp_pnt_start (void);
+static void fp_pnt_add (gdouble p1,
+ gdouble p2,
+ gdouble p3,
+ gdouble p4);
+static gdouble *d_bz_get_array (gint *sz);
+static void d_bz_line (cairo_t *cr);
+static void DrawBezier (fp_pnt points,
+ gint np,
+ gdouble mid,
+ gint depth);
+static void d_paint_bezier (GfigObject *obj);
+static GfigObject *d_copy_bezier (GfigObject *obj);
+static void d_update_bezier (GdkPoint *pnt);
+
+static void
+fp_pnt_start (void)
+{
+ fp_pnt_cnt = 0;
+}
+
+/* Add a line segment to collection array */
+static void
+fp_pnt_add (gdouble p1,
+ gdouble p2,
+ gdouble p3,
+ gdouble p4)
+{
+ if (!fp_pnt_pnts)
+ {
+ fp_pnt_pnts = g_new0 (gdouble, FP_PNT_MAX);
+ fp_pnt_chunk = 1;
+ }
+
+ if (((fp_pnt_cnt + 4) / FP_PNT_MAX) >= fp_pnt_chunk)
+ {
+ /* more space pls */
+ fp_pnt_chunk++;
+ fp_pnt_pnts = g_renew (gdouble, fp_pnt_pnts, fp_pnt_chunk * FP_PNT_MAX);
+ }
+
+ fp_pnt_pnts[fp_pnt_cnt++] = p1;
+ fp_pnt_pnts[fp_pnt_cnt++] = p2;
+ fp_pnt_pnts[fp_pnt_cnt++] = p3;
+ fp_pnt_pnts[fp_pnt_cnt++] = p4;
+}
+
+static gdouble *
+d_bz_get_array (gint *sz)
+{
+ *sz = fp_pnt_cnt;
+ return fp_pnt_pnts;
+}
+
+static void
+d_bz_line (cairo_t *cr)
+{
+ gint i, x0, y0, x1, y1;
+
+ g_assert ((fp_pnt_cnt % 4) == 0);
+
+ for (i = 0 ; i < fp_pnt_cnt; i += 4)
+ {
+ x0 = fp_pnt_pnts[i];
+ y0 = fp_pnt_pnts[i + 1];
+ x1 = fp_pnt_pnts[i + 2];
+ y1 = fp_pnt_pnts[i + 3];
+
+ gfig_draw_line (x0, y0, x1, y1, cr);
+ }
+}
+
+/* Return points to plot */
+/* Terminate by point with DBL_MAX, DBL_MAX */
+static void
+DrawBezier (fp_pnt points,
+ gint np,
+ gdouble mid,
+ gint depth)
+{
+ gint i, j, x0 = 0, y0 = 0, x1, y1;
+ fp_pnt left;
+ fp_pnt right;
+
+ if (depth == 0) /* draw polyline */
+ {
+ for (i = 0; i < np; i++)
+ {
+ x1 = (int) points[i][0];
+ y1 = (int) points[i][1];
+ if (i > 0 && (x1 != x0 || y1 != y0))
+ {
+ /* Add pnts up */
+ fp_pnt_add ((gdouble) x0, (gdouble) y0,
+ (gdouble) x1, (gdouble) y1);
+ }
+ x0 = x1;
+ y0 = y1;
+ }
+ }
+ else /* subdivide control points at mid */
+ {
+ left = (fp_pnt)g_new (gdouble, np * 2);
+ right = (fp_pnt)g_new (gdouble, np * 2);
+ for (i = 0; i < np; i++)
+ {
+ right[i][0] = points[i][0];
+ right[i][1] = points[i][1];
+ }
+ left[0][0] = right[0][0];
+ left[0][1] = right[0][1];
+ for (j = np - 1; j >= 1; j--)
+ {
+ for (i = 0; i < j; i++)
+ {
+ right[i][0] = (1 - mid) * right[i][0] + mid * right[i + 1][0];
+ right[i][1] = (1 - mid) * right[i][1] + mid * right[i + 1][1];
+ }
+ left[np - j][0] = right[0][0];
+ left[np - j][1] = right[0][1];
+ }
+ if (depth > 0)
+ {
+ DrawBezier (left, np, mid, depth - 1);
+ DrawBezier (right, np, mid, depth - 1);
+ g_free (left);
+ g_free (right);
+ }
+ }
+}
+
+void
+d_draw_bezier (GfigObject *obj,
+ cairo_t *cr)
+{
+ DobjPoints *spnt;
+ gint seg_count = 0;
+ gint i = 0;
+ gdouble (*line_pnts)[2];
+
+ spnt = obj->points;
+
+ /* First count the number of points */
+ for (spnt = obj->points; spnt; spnt = spnt->next)
+ seg_count++;
+
+ if (!seg_count)
+ return; /* no-line */
+
+ line_pnts = (fp_pnt) g_new0 (gdouble, 2 * seg_count + 1);
+
+ /* Go around all the points drawing a line from one to the next */
+ for (spnt = obj->points; spnt; spnt = spnt->next)
+ {
+ if (! spnt->next && obj == obj_creating)
+ draw_circle (&spnt->pnt, TRUE, cr);
+ else
+ draw_sqr (&spnt->pnt, obj == gfig_context->selected_obj, cr);
+ line_pnts[i][0] = spnt->pnt.x;
+ line_pnts[i][1] = spnt->pnt.y;
+ i++;
+ }
+
+ /* Generate an array of doubles which are the control points */
+
+ if (bezier_line_frame && tmp_bezier)
+ {
+ fp_pnt_start ();
+ DrawBezier (line_pnts, seg_count, 0.5, 0);
+ d_bz_line (cr);
+ }
+
+ fp_pnt_start ();
+ DrawBezier (line_pnts, seg_count, 0.5, 3);
+ d_bz_line (cr);
+
+ g_free (line_pnts);
+}
+
+static void
+d_paint_bezier (GfigObject *obj)
+{
+ gdouble *line_pnts;
+ gdouble (*bz_line_pnts)[2];
+ DobjPoints *spnt;
+ gint seg_count = 0;
+ gint i = 0;
+
+ /* First count the number of points */
+ for (spnt = obj->points; spnt; spnt = spnt->next)
+ seg_count++;
+
+ if (!seg_count)
+ return; /* no-line */
+
+ bz_line_pnts = (fp_pnt) g_new0 (gdouble, 2 * seg_count + 1);
+
+ /* Go around all the points drawing a line from one to the next */
+ for (spnt = obj->points; spnt; spnt = spnt->next)
+ {
+ bz_line_pnts[i][0] = spnt->pnt.x;
+ bz_line_pnts[i][1] = spnt->pnt.y;
+ i++;
+ }
+
+ fp_pnt_start ();
+ DrawBezier (bz_line_pnts, seg_count, 0.5, 5);
+ line_pnts = d_bz_get_array (&i);
+
+ /* Scale before drawing */
+ if (selvals.scaletoimage)
+ scale_to_original_xy (&line_pnts[0], i / 2);
+ else
+ scale_to_xy (&line_pnts[0], i / 2);
+
+ /* One go */
+ if (obj->style.paint_type == PAINT_BRUSH_TYPE)
+ {
+ gfig_paint (selvals.brshtype,
+ gfig_context->drawable_id,
+ i, line_pnts);
+ }
+
+ g_free (bz_line_pnts);
+ /* Don't free line_pnts - may need again */
+}
+
+static GfigObject *
+d_copy_bezier (GfigObject *obj)
+{
+ GfigObject *np;
+
+ g_assert (obj->type == BEZIER);
+
+ np = d_new_object (BEZIER, obj->points->pnt.x, obj->points->pnt.y);
+ np->points->next = d_copy_dobjpoints (obj->points->next);
+ np->type_data = obj->type_data;
+
+ return np;
+}
+
+void
+d_bezier_object_class_init (void)
+{
+ GfigObjectClass *class = &dobj_class[BEZIER];
+
+ class->type = BEZIER;
+ class->name = "BEZIER";
+ class->drawfunc = d_draw_bezier;
+ class->paintfunc = d_paint_bezier;
+ class->copyfunc = d_copy_bezier;
+ class->update = d_update_bezier;
+}
+
+static void
+d_update_bezier (GdkPoint *pnt)
+{
+ DobjPoints *s_pnt, *l_pnt;
+
+ g_assert (tmp_bezier != NULL);
+
+ s_pnt = tmp_bezier->points;
+
+ if (!s_pnt)
+ return; /* No points */
+
+ if ((l_pnt = s_pnt->next))
+ {
+ while (l_pnt->next)
+ {
+ l_pnt = l_pnt->next;
+ }
+
+ l_pnt->pnt = *pnt;
+ }
+ else
+ {
+ /* Radius is a few pixels away */
+ /* First edge point */
+ d_pnt_add_line (tmp_bezier, pnt->x, pnt->y,-1);
+ }
+}
+
+void
+d_bezier_start (GdkPoint *pnt,
+ gboolean shift_down)
+{
+ if (!tmp_bezier)
+ {
+ /* New curve */
+ tmp_bezier = obj_creating = d_new_object (BEZIER, pnt->x, pnt->y);
+ }
+}
+
+void
+d_bezier_end (GdkPoint *pnt,
+ gboolean shift_down)
+{
+ DobjPoints *l_pnt;
+
+ if (!tmp_bezier)
+ {
+ tmp_bezier = obj_creating;
+ }
+
+ l_pnt = tmp_bezier->points->next;
+
+ if (!l_pnt)
+ return;
+
+ if (shift_down)
+ {
+ while (l_pnt->next)
+ {
+ l_pnt = l_pnt->next;
+ }
+
+ if (l_pnt)
+ {
+ if (bezier_closed)
+ {
+ /* if closed then add first point */
+ d_pnt_add_line (tmp_bezier,
+ tmp_bezier->points->pnt.x,
+ tmp_bezier->points->pnt.y, -1);
+ }
+
+ add_to_all_obj (gfig_context->current_obj, obj_creating);
+ }
+
+ /* small mem leak if !l_pnt ? */
+ tmp_bezier = NULL;
+ obj_creating = NULL;
+ }
+ else
+ {
+ d_pnt_add_line (tmp_bezier, pnt->x, pnt->y,-1);
+ }
+}
+
+void
+tool_options_bezier (GtkWidget *notebook)
+{
+ GtkWidget *vbox;
+ GtkWidget *toggle;
+
+ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+ gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
+ gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox, NULL);
+ gtk_widget_show (vbox);
+
+ toggle = gtk_check_button_new_with_label (_("Closed"));
+ g_signal_connect (toggle, "toggled",
+ G_CALLBACK (gimp_toggle_button_update),
+ &bezier_closed);
+ gimp_help_set_help_data (toggle,
+ _("Close curve on completion"), NULL);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bezier_closed);
+ gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+ gtk_widget_show (toggle);
+
+ toggle = gtk_check_button_new_with_label (_("Show Line Frame"));
+ g_signal_connect (toggle, "toggled",
+ G_CALLBACK (gimp_toggle_button_update),
+ &bezier_line_frame);
+ gimp_help_set_help_data (toggle,
+ _("Draws lines between the control points. "
+ "Only during curve creation"), NULL);
+ gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (toggle), bezier_line_frame);
+ gtk_box_pack_start (GTK_BOX (vbox), toggle, FALSE, FALSE, 0);
+ gtk_widget_show (toggle);
+}
+
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-21 08:07:05 +0000