Adding upstream version 2.10.36.upstream/2.10.36

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

1 files changed, 735 insertions, 0 deletions

diff --git a/plug-ins/gfig/gfig-arc.c b/plug-ins/gfig/gfig-arc.c
new file mode 100644
index 0000000..3625918
--- /dev/null
+++ b/plug-ins/gfig/gfig-arc.c
@@ -0,0 +1,735 @@
+/*
+ * 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 <math.h>
+#include <stdlib.h>
+
+#include <gtk/gtk.h>
+
+#include <libgimp/gimp.h>
+
+#include "gfig.h"
+#include "gfig-dobject.h"
+#include "gfig-arc.h"
+
+#include "libgimp/stdplugins-intl.h"
+
+static gdouble     dist                (gdouble   x1,
+                                        gdouble   y1,
+                                        gdouble   x2,
+                                        gdouble   y2);
+
+static void        mid_point           (gdouble   x1,
+                                        gdouble   y1,
+                                        gdouble   x2,
+                                        gdouble   y2,
+                                        gdouble  *mx,
+                                        gdouble  *my);
+
+static gdouble     line_grad           (gdouble   x1,
+                                        gdouble   y1,
+                                        gdouble   x2,
+                                        gdouble   y2);
+
+static gdouble     line_cons           (gdouble   x,
+                                        gdouble   y,
+                                        gdouble   lgrad);
+
+static void        line_definition     (gdouble   x1,
+                                        gdouble   y1,
+                                        gdouble   x2,
+                                        gdouble   y2,
+                                        gdouble  *lgrad,
+                                        gdouble  *lconst);
+
+static void        arc_details         (GdkPoint *vert_a,
+                                        GdkPoint *vert_b,
+                                        GdkPoint *vert_c,
+                                        GdkPoint *center_pnt,
+                                        gdouble  *radius);
+
+static gdouble     arc_angle           (GdkPoint *pnt,
+                                        GdkPoint *center);
+
+static void        arc_drawing_details (GfigObject *obj,
+                                        gdouble    *minang,
+                                        GdkPoint   *center_pnt,
+                                        gdouble    *arcang,
+                                        gdouble    *radius,
+                                        gboolean    draw_cnts,
+                                        gboolean    do_scale);
+
+static void        d_draw_arc          (GfigObject *obj,
+                                        cairo_t    *cr);
+
+static void        d_paint_arc         (GfigObject *obj);
+
+static GfigObject *d_copy_arc          (GfigObject *obj);
+
+static void        d_update_arc_line   (GdkPoint   *pnt);
+static void        d_update_arc        (GdkPoint   *pnt);
+static void        d_arc_line_start    (GdkPoint   *pnt,
+                                        gboolean    shift_down);
+static void        d_arc_line_end      (GdkPoint *pnt,
+                                        gboolean  shift_down);
+
+/* Distance between two points. */
+static gdouble
+dist (gdouble x1,
+      gdouble y1,
+      gdouble x2,
+      gdouble y2)
+{
+
+  double s1 = x1 - x2;
+  double s2 = y1 - y2;
+
+  return sqrt (s1 * s1 + s2 * s2);
+}
+
+/* Mid point of line returned */
+static void
+mid_point (gdouble  x1,
+           gdouble  y1,
+           gdouble  x2,
+           gdouble  y2,
+           gdouble *mx,
+           gdouble *my)
+{
+  *mx = (x1 + x2) / 2.0;
+  *my = (y1 + y2) / 2.0;
+}
+
+/* Careful about infinite grads */
+static gdouble
+line_grad (gdouble x1,
+           gdouble y1,
+           gdouble x2,
+           gdouble y2)
+{
+  double dx, dy;
+
+  dx = x1 - x2;
+  dy = y1 - y2;
+
+  return (dx == 0.0) ? 0.0 : dy / dx;
+}
+
+/* Constant of line that goes through x, y with grad lgrad */
+static gdouble
+line_cons (gdouble x,
+           gdouble y,
+           gdouble lgrad)
+{
+  return y - lgrad * x;
+}
+
+/* Get grad & const for perpend. line to given points */
+static void
+line_definition (gdouble  x1,
+                 gdouble  y1,
+                 gdouble  x2,
+                 gdouble  y2,
+                 gdouble *lgrad,
+                 gdouble *lconst)
+{
+  double grad1;
+  double midx, midy;
+
+  grad1 = line_grad (x1, y1, x2, y2);
+
+  if (grad1 == 0.0)
+    {
+#ifdef DEBUG
+      printf ("Infinite grad....\n");
+#endif /* DEBUG */
+      return;
+    }
+
+  mid_point (x1, y1, x2, y2, &midx, &midy);
+
+  /* Invert grad for perpen gradient */
+
+  *lgrad = -1.0 / grad1;
+
+  *lconst = line_cons (midx, midy,*lgrad);
+}
+
+/* Arch details
+ * Given three points get arc radius and the co-ords
+ * of center point.
+ */
+
+static void
+arc_details (GdkPoint *vert_a,
+             GdkPoint *vert_b,
+             GdkPoint *vert_c,
+             GdkPoint *center_pnt,
+             gdouble  *radius)
+{
+  /* Only vertices are in whole numbers - everything else is in doubles */
+  double ax, ay;
+  double bx, by;
+  double cx, cy;
+
+  double len_a, len_b, len_c;
+  double sum_sides2;
+  double area;
+  double circumcircle_R;
+  double line1_grad = 0, line1_const = 0;
+  double line2_grad = 0, line2_const = 0;
+  double inter_x = 0.0, inter_y = 0.0;
+  int    got_x = 0, got_y = 0;
+
+  ax = (double) (vert_a->x);
+  ay = (double) (vert_a->y);
+  bx = (double) (vert_b->x);
+  by = (double) (vert_b->y);
+  cx = (double) (vert_c->x);
+  cy = (double) (vert_c->y);
+
+  len_a = dist (ax, ay, bx, by);
+  len_b = dist (bx, by, cx, cy);
+  len_c = dist (cx, cy, ax, ay);
+
+  sum_sides2 = (fabs (len_a) + fabs (len_b) + fabs (len_c))/2;
+
+  /* Area */
+  area = sqrt (sum_sides2 * (sum_sides2 - len_a) *
+                            (sum_sides2 - len_b) *
+                            (sum_sides2 - len_c));
+
+  /* Circumcircle */
+  circumcircle_R = len_a * len_b * len_c / (4 * area);
+  *radius = circumcircle_R;
+
+  /* Deal with exceptions - I hate exceptions */
+
+  if (ax == bx || ax == cx || cx == bx)
+    {
+      /* vert line -> mid point gives inter_x */
+      if (ax == bx && bx == cx)
+        {
+          /* Straight line */
+          double miny = ay;
+          double maxy = ay;
+
+          if (by > maxy)
+            maxy = by;
+
+          if (by < miny)
+            miny = by;
+
+          if (cy > maxy)
+            maxy = cy;
+
+          if (cy < miny)
+            miny = cy;
+
+          inter_y = (maxy - miny) / 2 + miny;
+        }
+      else if (ax == bx)
+        {
+          inter_y = (ay - by) / 2 + by;
+        }
+      else if (bx == cx)
+        {
+          inter_y = (by - cy) / 2 + cy;
+        }
+      else
+        {
+          inter_y = (cy - ay) / 2 + ay;
+        }
+      got_y = 1;
+    }
+
+  if (ay == by || by == cy || ay == cy)
+    {
+      /* Horz line -> midpoint gives inter_y */
+      if (ay == by && by == cy)
+        {
+          /* Straight line */
+          double minx = ax;
+          double maxx = ax;
+
+          if (bx > maxx)
+            maxx = bx;
+
+          if (bx < minx)
+            minx = bx;
+
+          if (cx > maxx)
+            maxx = cx;
+
+          if (cx < minx)
+            minx = cx;
+
+          inter_x = (maxx - minx) / 2 + minx;
+        }
+      else if (ay == by)
+        {
+          inter_x = (ax - bx) / 2 + bx;
+        }
+      else if (by == cy)
+        {
+          inter_x = (bx - cx) / 2 + cx;
+        }
+      else
+        {
+          inter_x = (cx - ax) / 2 + ax;
+        }
+      got_x = 1;
+    }
+
+  if (!got_x || !got_y)
+    {
+      /* At least two of the lines are not parallel to the axis */
+      /*first line */
+      if (ax != bx && ay != by)
+        line_definition (ax, ay, bx, by, &line1_grad, &line1_const);
+      else
+        line_definition (ax, ay, cx, cy, &line1_grad, &line1_const);
+      /* second line */
+      if (bx != cx && by != cy)
+        line_definition (bx, by, cx, cy, &line2_grad, &line2_const);
+      else
+        line_definition (ax, ay, cx, cy, &line2_grad, &line2_const);
+    }
+
+  /* Intersection point */
+
+  if (!got_x)
+    inter_x = (line2_const - line1_const) / (line1_grad - line2_grad);
+  if (!got_y)
+    inter_y = line1_grad * inter_x + line1_const;
+
+  center_pnt->x = (gint) inter_x;
+  center_pnt->y = (gint) inter_y;
+}
+
+static gdouble
+arc_angle (GdkPoint *pnt,
+           GdkPoint *center)
+{
+  /* Get angle (in degrees) of point given origin of center */
+  gint16  shift_x;
+  gint16  shift_y;
+  gdouble offset_angle;
+
+  shift_x =  pnt->x - center->x;
+  shift_y = -pnt->y + center->y;
+  offset_angle = atan2 (shift_y, shift_x);
+
+  if (offset_angle < 0)
+    offset_angle += 2.0 * G_PI;
+
+  return offset_angle * 360 / (2.0 * G_PI);
+}
+
+static void
+arc_drawing_details (GfigObject *obj,
+                     gdouble    *minang,
+                     GdkPoint   *center_pnt,
+                     gdouble    *arcang,
+                     gdouble    *radius,
+                     gboolean    draw_cnts,
+                     gboolean    do_scale)
+{
+  DobjPoints *pnt1 = NULL;
+  DobjPoints *pnt2 = NULL;
+  DobjPoints *pnt3 = NULL;
+  DobjPoints  dpnts[3];
+  gdouble     ang1, ang2, ang3;
+  gdouble     maxang;
+
+  pnt1 = obj->points;
+
+  if (!pnt1)
+    return; /* Not fully drawn */
+
+  pnt2 = pnt1->next;
+
+  if (!pnt2)
+    return; /* Not fully drawn */
+
+  pnt3 = pnt2->next;
+
+  if (!pnt3)
+    return; /* Still not fully drawn */
+
+  if (do_scale)
+    {
+      /* Adjust pnts for scaling */
+      /* Warning struct copies here! and casting to double <-> int */
+      /* Too complex fix me - to much hacking */
+      gdouble xy[2];
+      int     j;
+
+      dpnts[0] = *pnt1;
+      dpnts[1] = *pnt2;
+      dpnts[2] = *pnt3;
+
+      pnt1 = &dpnts[0];
+      pnt2 = &dpnts[1];
+      pnt3 = &dpnts[2];
+
+      for (j = 0 ; j < 3; j++)
+        {
+          xy[0] = dpnts[j].pnt.x;
+          xy[1] = dpnts[j].pnt.y;
+          if (selvals.scaletoimage)
+            scale_to_original_xy (&xy[0], 1);
+          else
+            scale_to_xy (&xy[0], 1);
+          dpnts[j].pnt.x = xy[0];
+          dpnts[j].pnt.y = xy[1];
+        }
+    }
+
+  arc_details (&pnt1->pnt, &pnt2->pnt, &pnt3->pnt, center_pnt, radius);
+
+  ang1 = arc_angle (&pnt1->pnt, center_pnt);
+  ang2 = arc_angle (&pnt2->pnt, center_pnt);
+  ang3 = arc_angle (&pnt3->pnt, center_pnt);
+
+  /* Find min/max angle */
+
+  maxang = ang1;
+
+  if (ang3 > maxang)
+    maxang = ang3;
+
+  *minang = ang1;
+
+  if (ang3 < *minang)
+    *minang = ang3;
+
+  if (ang2 > *minang && ang2 < maxang)
+    *arcang = maxang - *minang;
+  else
+    *arcang = maxang - *minang - 360;
+}
+
+static void
+d_draw_arc (GfigObject *obj,
+            cairo_t    *cr)
+{
+  DobjPoints *pnt1, *pnt2, *pnt3;
+  GdkPoint center_pnt;
+  gdouble  radius, minang, arcang;
+
+  g_assert (obj != NULL);
+
+  if (!obj)
+    return;
+
+  pnt1 = obj->points;
+  pnt2 = pnt1 ? pnt1->next : NULL;
+  pnt3 = pnt2 ? pnt2->next : NULL;
+
+  if (! pnt3)
+    return;
+
+  draw_sqr (&pnt1->pnt, obj == gfig_context->selected_obj, cr);
+  draw_sqr (&pnt2->pnt, obj == gfig_context->selected_obj, cr);
+  draw_sqr (&pnt3->pnt, obj == gfig_context->selected_obj, cr);
+
+  arc_drawing_details (obj, &minang, &center_pnt, &arcang, &radius,
+                       TRUE, FALSE);
+  gfig_draw_arc (center_pnt.x, center_pnt.y, radius, radius, -minang, -(minang + arcang), cr);
+}
+
+static void
+d_paint_arc (GfigObject *obj)
+{
+  /* first point center */
+  /* Next point is radius */
+  gdouble *line_pnts;
+  gint     seg_count = 0;
+  gint     i = 0;
+  gdouble  ang_grid;
+  gdouble  ang_loop;
+  gdouble  radius;
+  gint     loop;
+  GdkPoint last_pnt = { 0, 0 };
+  gboolean first = TRUE;
+  GdkPoint center_pnt;
+  gdouble  minang, arcang;
+
+  g_assert (obj != NULL);
+
+  if (!obj)
+    return;
+
+  /* No cnt pnts & must scale */
+  arc_drawing_details (obj, &minang, &center_pnt, &arcang, &radius,
+                       FALSE, TRUE);
+
+  seg_count = 360; /* Should make a smoth-ish curve */
+
+  /* +3 because we MIGHT do pie selection */
+  line_pnts = g_new0 (gdouble, 2 * seg_count + 3);
+
+  /* Lines */
+  ang_grid = 2.0 * G_PI / 360.0;
+
+  if (arcang < 0.0)
+    {
+      /* Swap - since we always draw anti-clock wise */
+      minang += arcang;
+      arcang  = -arcang;
+    }
+
+  minang = minang * (2.0 * G_PI / 360.0); /* min ang is in degrees - need in rads */
+
+  for (loop = 0 ; loop < abs ((gint)arcang) ; loop++)
+    {
+      gdouble  lx, ly;
+      GdkPoint calc_pnt;
+
+      ang_loop = (gdouble)loop * ang_grid + minang;
+
+      lx =  radius * cos (ang_loop);
+      ly = -radius * sin (ang_loop); /* y grows down screen and angs measured from x clockwise */
+
+      calc_pnt.x = RINT (lx + center_pnt.x);
+      calc_pnt.y = RINT (ly + center_pnt.y);
+
+      /* Miss out duped pnts */
+      if (!first)
+        {
+          if (calc_pnt.x == last_pnt.x && calc_pnt.y == last_pnt.y)
+            {
+              continue;
+            }
+        }
+
+      line_pnts[i++] = calc_pnt.x;
+      line_pnts[i++] = calc_pnt.y;
+      last_pnt = calc_pnt;
+
+      if (first)
+        {
+          first = FALSE;
+        }
+    }
+
+  /* One go */
+  if (obj->style.paint_type == PAINT_BRUSH_TYPE)
+    {
+      gfig_paint (selvals.brshtype,
+                  gfig_context->drawable_id,
+                  i, line_pnts);
+    }
+
+  g_free (line_pnts);
+}
+
+static GfigObject *
+d_copy_arc (GfigObject *obj)
+{
+  GfigObject *nc;
+
+  g_assert (obj->type == ARC);
+
+  nc = d_new_object (ARC, obj->points->pnt.x, obj->points->pnt.y);
+  nc->points->next = d_copy_dobjpoints (obj->points->next);
+
+  return nc;
+}
+
+void
+d_arc_object_class_init (void)
+{
+  GfigObjectClass *class = &dobj_class[ARC];
+
+  class->type      = ARC;
+  class->name      = "ARC";
+  class->drawfunc  = d_draw_arc;
+  class->paintfunc = d_paint_arc;
+  class->copyfunc  = d_copy_arc;
+  class->update    = d_update_arc;
+}
+
+/* Update end point of line */
+static void
+d_update_arc_line (GdkPoint *pnt)
+{
+  DobjPoints *spnt, *epnt;
+  /* Get last but one segment and undraw it -
+   * Then draw new segment in.
+   * always dealing with the static object.
+   */
+
+  /* Get start of segments */
+  spnt = obj_creating->points;
+
+  if (!spnt)
+    return; /* No points */
+
+  if ((epnt = spnt->next))
+    {
+      g_free (epnt);
+    }
+
+  epnt = new_dobjpoint (pnt->x, pnt->y);
+  spnt->next = epnt;
+}
+
+static void
+d_update_arc (GdkPoint *pnt)
+{
+  DobjPoints *pnt1 = NULL;
+  DobjPoints *pnt2 = NULL;
+  DobjPoints *pnt3 = NULL;
+
+  /* First two points as line only become arch when third
+   * point is placed on canvas.
+   */
+
+  pnt1 = obj_creating->points;
+
+  if (!pnt1                ||
+      !(pnt2 = pnt1->next) ||
+      !(pnt3 = pnt2->next))
+    {
+      d_update_arc_line (pnt);
+      return; /* Not fully drawn */
+    }
+
+  /* Update a real curve */
+  /* Nothing to be done ... */
+}
+
+static void
+d_arc_line_start (GdkPoint *pnt,
+                  gboolean  shift_down)
+{
+  if (!obj_creating || !shift_down)
+    {
+      /* Must delete obj_creating if we have one */
+      obj_creating = d_new_object (LINE, pnt->x, pnt->y);
+    }
+  else
+    {
+      /* Contniuation */
+      d_update_arc_line (pnt);
+    }
+}
+
+void
+d_arc_start (GdkPoint *pnt,
+             gboolean  shift_down)
+{
+  /* Draw lines to start with -- then convert to an arc */
+  d_arc_line_start (pnt, TRUE); /* TRUE means multiple pointed line */
+}
+
+static void
+d_arc_line_end (GdkPoint *pnt,
+                gboolean  shift_down)
+{
+  if (shift_down)
+    {
+      if (tmp_line)
+        {
+          GdkPoint tmp_pnt = *pnt;
+
+          if (need_to_scale)
+            {
+              tmp_pnt.x = pnt->x * scale_x_factor;
+              tmp_pnt.y = pnt->y * scale_y_factor;
+            }
+
+          d_pnt_add_line (tmp_line, tmp_pnt.x, tmp_pnt.y, -1);
+          free_one_obj (obj_creating);
+          /* Must free obj_creating */
+        }
+      else
+        {
+          tmp_line = obj_creating;
+          add_to_all_obj (gfig_context->current_obj, obj_creating);
+        }
+
+      obj_creating = d_new_object (LINE, pnt->x, pnt->y);
+    }
+  else
+    {
+      if (tmp_line)
+        {
+          GdkPoint tmp_pnt = *pnt;
+
+          if (need_to_scale)
+            {
+              tmp_pnt.x = pnt->x * scale_x_factor;
+              tmp_pnt.y = pnt->y * scale_y_factor;
+            }
+
+          d_pnt_add_line (tmp_line, tmp_pnt.x, tmp_pnt.y, -1);
+          free_one_obj (obj_creating);
+          /* Must free obj_creating */
+        }
+      else
+        {
+          add_to_all_obj (gfig_context->current_obj, obj_creating);
+        }
+      obj_creating = NULL;
+      tmp_line = NULL;
+    }
+  /*gtk_widget_queue_draw (gfig_context->preview);*/
+}
+
+void
+d_arc_end (GdkPoint *pnt,
+           gboolean  shift_down)
+{
+  /* Under control point */
+  if (!tmp_line               ||
+      !tmp_line->points       ||
+      !tmp_line->points->next)
+    {
+      /* No arc created  - yet. Must have three points */
+      d_arc_line_end (pnt, TRUE);
+    }
+  else
+    {
+      /* Complete arc */
+      /* Convert to an arc ... */
+      tmp_line->type = ARC;
+      tmp_line->class = &dobj_class[ARC];
+      d_arc_line_end (pnt, FALSE);
+      if (need_to_scale)
+        {
+          selvals.scaletoimage = 0;
+        }
+      gtk_widget_queue_draw (gfig_context->preview);
+      if (need_to_scale)
+        {
+          selvals.scaletoimage = 1;
+        }
+    }
+}
+