src/svg/gnome-canvas-bpath-util.cpp

   1 /* GnomeCanvas Bezier polyline paths & segments
   2  *
   3  * GnomeCanvas is basically a port of the Tk toolkit's most excellent canvas widget.  Tk is
   4  * copyrighted by the Regents of the University of California, Sun Microsystems, and other parties.
   5  *
   6  * Copyright (C) 1998,1999 The Free Software Foundation
   7  *
   8  * Authors: Federico Mena <federico@nuclecu.unam.mx>
   9  *          Lauris Kaplinski <lauris@ariman.ee>
  10  *          Raph Levien <raph@acm.org>
  11  */
  12
  13 #include <cstring>
  14 #include <string>
  15 #include <cstdlib>
  16 #include <cstdio>
  17 #include <glib/gmem.h>
  18 #include <glib/gmessages.h>
  19
  20 #include "libnr/n-art-bpath.h"
  21 #include "gnome-canvas-bpath-util.h"
  22
  23 GnomeCanvasBpathDef *
  24 gnome_canvas_bpath_def_new (void)
  25 {
  26         GnomeCanvasBpathDef *bpd;
  27
  28         bpd = g_new (GnomeCanvasBpathDef, 1);
  29         bpd->n_bpath = 0;
  30         bpd->n_bpath_max = 16;
  31         bpd->moveto_idx = -1;
  32         bpd->bpath = g_new (NArtBpath, bpd->n_bpath_max);
  33         bpd->ref_count = 1;
  34
  35         return bpd;
  36 }
  37
  38 GnomeCanvasBpathDef *
  39 gnome_canvas_bpath_def_new_from (NArtBpath *path)
  40 {
  41         GnomeCanvasBpathDef *bpd;
  42         int i;
  43
  44         g_return_val_if_fail (path != NULL, NULL);
  45
  46         bpd = g_new (GnomeCanvasBpathDef, 1);
  47
  48         for (i = 0; path [i].code != NR_END; i++)
  49                 ;
  50         bpd->n_bpath = i;
  51         bpd->n_bpath_max = i;
  52         bpd->moveto_idx = -1;
  53         bpd->ref_count = 1;
  54         bpd->bpath = g_new (NArtBpath, i);
  55
  56         memcpy (bpd->bpath, path, i * sizeof (NArtBpath));
  57         return bpd;
  58 }
  59
  60 GnomeCanvasBpathDef *
  61 gnome_canvas_bpath_def_ref (GnomeCanvasBpathDef *bpd)
  62 {
  63         g_return_val_if_fail (bpd != NULL, NULL);
  64
  65         bpd->ref_count += 1;
  66         return bpd;
  67 }
  68
  69 void
  70 gnome_canvas_bpath_def_free (GnomeCanvasBpathDef *bpd)
  71 {
  72         g_return_if_fail (bpd != NULL);
  73
  74         bpd->ref_count -= 1;
  75         if (bpd->ref_count == 0) {
  76                 g_free (bpd->bpath);
  77                 g_free (bpd);
  78         }
  79 }
  80
  81 void
  82 gnome_canvas_bpath_def_moveto (GnomeCanvasBpathDef *bpd, double x, double y)
  83 {
  84         NArtBpath *bpath;
  85         int n_bpath;
  86
  87         g_return_if_fail (bpd != NULL);
  88
  89         n_bpath = bpd->n_bpath++;
  90
  91         if (n_bpath == bpd->n_bpath_max)
  92                 bpd->bpath = (NArtBpath*)g_realloc (bpd->bpath,
  93                                         (bpd->n_bpath_max <<= 1) * sizeof (NArtBpath));
  94         bpath = bpd->bpath;
  95         bpath[n_bpath].code = NR_MOVETO_OPEN;
  96         bpath[n_bpath].x3 = x;
  97         bpath[n_bpath].y3 = y;
  98         bpd->moveto_idx = n_bpath;
  99 }
 100
 101 void
 102 gnome_canvas_bpath_def_lineto (GnomeCanvasBpathDef *bpd, double x, double y)
 103 {
 104         NArtBpath *bpath;
 105         int n_bpath;
 106
 107         g_return_if_fail (bpd != NULL);
 108         g_return_if_fail (bpd->moveto_idx >= 0);
 109
 110         n_bpath = bpd->n_bpath++;
 111
 112         if (n_bpath == bpd->n_bpath_max)
 113                 bpd->bpath = (NArtBpath*)g_realloc (bpd->bpath,
 114                                         (bpd->n_bpath_max <<= 1) * sizeof (NArtBpath));
 115         bpath = bpd->bpath;
 116         bpath[n_bpath].code = NR_LINETO;
 117         bpath[n_bpath].x3 = x;
 118         bpath[n_bpath].y3 = y;
 119 }
 120
 121 void
 122 gnome_canvas_bpath_def_curveto (GnomeCanvasBpathDef *bpd, double x1, double y1, double x2, double y2, double x3, double y3)
 123 {
 124         NArtBpath *bpath;
 125         int n_bpath;
 126
 127         g_return_if_fail (bpd != NULL);
 128         g_return_if_fail (bpd->moveto_idx >= 0);
 129
 130         n_bpath = bpd->n_bpath++;
 131
 132         if (n_bpath == bpd->n_bpath_max)
 133                 bpd->bpath = (NArtBpath*)g_realloc (bpd->bpath,
 134                                         (bpd->n_bpath_max <<= 1) * sizeof (NArtBpath));
 135         bpath = bpd->bpath;
 136         bpath[n_bpath].code = NR_CURVETO;
 137         bpath[n_bpath].x1 = x1;
 138         bpath[n_bpath].y1 = y1;
 139         bpath[n_bpath].x2 = x2;
 140         bpath[n_bpath].y2 = y2;
 141         bpath[n_bpath].x3 = x3;
 142         bpath[n_bpath].y3 = y3;
 143 }
 144
 145 void
 146 gnome_canvas_bpath_def_closepath (GnomeCanvasBpathDef *bpd)
 147 {
 148         NArtBpath *bpath;
 149         int n_bpath;
 150
 151         g_return_if_fail (bpd != NULL);
 152         g_return_if_fail (bpd->moveto_idx >= 0);
 153         g_return_if_fail (bpd->n_bpath > 0);
 154
 155         bpath = bpd->bpath;
 156         n_bpath = bpd->n_bpath;
 157
 158         /* Add closing vector if we need it. */
 159         if (bpath[n_bpath - 1].x3 != bpath[bpd->moveto_idx].x3 ||
 160             bpath[n_bpath - 1].y3 != bpath[bpd->moveto_idx].y3) {
 161                 gnome_canvas_bpath_def_lineto (bpd, bpath[bpd->moveto_idx].x3,
 162                                                bpath[bpd->moveto_idx].y3);
 163                 bpath = bpd->bpath;
 164         }
 165         bpath[bpd->moveto_idx].code = NR_MOVETO;
 166         bpd->moveto_idx = -1;
 167 }
 168
 169 void
 170 gnome_canvas_bpath_def_art_finish (GnomeCanvasBpathDef *bpd)
 171 {
 172         int n_bpath;
 173
 174         g_return_if_fail (bpd != NULL);
 175
 176         n_bpath = bpd->n_bpath++;
 177
 178         if (n_bpath == bpd->n_bpath_max)
 179                 bpd->bpath = (NArtBpath*)g_realloc (bpd->bpath,
 180                                         (bpd->n_bpath_max <<= 1) * sizeof (NArtBpath));
 181         bpd->bpath [n_bpath].code = NR_END;
 182 }
 183