diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index adcfd8d7679cd20456645dca98e1b6fc1185a843..cc38acbe5183210d5bb599b2a182625523b6ddcc 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
#include "display/sodipodi-ctrl.h"
#include "display/sp-canvas-util.h"
#include <glibmm/i18n.h>
-#include <2geom/pathvector.h>
-#include <2geom/sbasis-to-bezier.h>
-#include <2geom/bezier-curve.h>
-#include <2geom/hvlinesegment.h>
+#include "2geom/pathvector.h"
+#include "2geom/sbasis-to-bezier.h"
+#include "2geom/bezier-curve.h"
+#include "2geom/hvlinesegment.h"
#include "helper/units.h"
#include "helper/geom.h"
#include "knot.h"
#include "selection-chemistry.h"
#include "selection.h"
#include "xml/repr.h"
-#include "prefs-utils.h"
+#include "preferences.h"
#include "sp-metrics.h"
#include "sp-path.h"
#include "libnr/nr-matrix-ops.h"
#include "svg/svg.h"
#include "verbs.h"
-#include "display/bezier-utils.h"
+#include <2geom/bezier-utils.h>
#include <vector>
#include <algorithm>
#include <cstring>
#include <cmath>
-#include <string>
#include "live_effects/lpeobject.h"
#include "live_effects/lpeobject-reference.h"
#include "live_effects/effect.h"
#include "display/snap-indicator.h"
#include "snapped-point.h"
-class Geom::Matrix;
+namespace Geom { class Matrix; }
/// \todo
/// evil evil evil. FIXME: conflict of two different Path classes!
@@ -121,19 +120,20 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
/* Adjust handle placement, if the node or the other handle is moved */
static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adjust);
static void sp_node_adjust_handles(Inkscape::NodePath::Node *node);
+static void sp_node_adjust_handles_auto(Inkscape::NodePath::Node *node);
/* Node event callbacks */
static void node_clicked(SPKnot *knot, guint state, gpointer data);
static void node_grabbed(SPKnot *knot, guint state, gpointer data);
static void node_ungrabbed(SPKnot *knot, guint state, gpointer data);
-static gboolean node_request(SPKnot *knot, Geom::Point *p, guint state, gpointer data);
+static gboolean node_request(SPKnot *knot, Geom::Point const &p, guint state, gpointer data);
/* Handle event callbacks */
static void node_handle_clicked(SPKnot *knot, guint state, gpointer data);
static void node_handle_grabbed(SPKnot *knot, guint state, gpointer data);
static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data);
-static gboolean node_handle_request(SPKnot *knot, Geom::Point *p, guint state, gpointer data);
-static void node_handle_moved(SPKnot *knot, Geom::Point *p, guint state, gpointer data);
+static gboolean node_handle_request(SPKnot *knot, Geom::Point &p, guint state, gpointer data);
+static void node_handle_moved(SPKnot *knot, Geom::Point const &p, guint state, gpointer data);
static gboolean node_handle_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::Node *n);
/* Constructors and destructors */
@@ -181,7 +181,7 @@ canvasitem_from_pathvec(Inkscape::NodePath::Path *np, Geom::PathVector const &pa
static void
sp_nodepath_create_helperpaths(Inkscape::NodePath::Path *np) {
- //std::map<Inkscape::LivePathEffect::Effect *, std::vector<SPCanvasItem *> >* helper_path_vec;
+ //std::map<Inkscape::LivePathEffect::Effect *, std::vector<SPCanvasItem *> > helper_path_vec;
if (!SP_IS_LPE_ITEM(np->item)) {
g_print ("Only LPEItems can have helperpaths!\n");
return;
// create new canvas items from the effect's helper paths
std::vector<Geom::PathVector> hpaths = lpe->getHelperPaths(lpeitem);
for (std::vector<Geom::PathVector>::iterator j = hpaths.begin(); j != hpaths.end(); ++j) {
- (*np->helper_path_vec)[lpe].push_back(canvasitem_from_pathvec(np, *j, true));
+ np->helper_path_vec[lpe].push_back(canvasitem_from_pathvec(np, *j, true));
}
}
}
void
sp_nodepath_update_helperpaths(Inkscape::NodePath::Path *np) {
- //std::map<Inkscape::LivePathEffect::Effect *, std::vector<SPCanvasItem *> >* helper_path_vec;
+ //std::map<Inkscape::LivePathEffect::Effect *, std::vector<SPCanvasItem *> > helper_path_vec;
if (!SP_IS_LPE_ITEM(np->item)) {
g_print ("Only LPEItems can have helperpaths!\n");
return;
for (unsigned int j = 0; j < hpaths.size(); ++j) {
SPCurve *curve = new SPCurve(hpaths[j]);
curve->transform(np->i2d);
- sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(((*np->helper_path_vec)[lpe])[j]), curve);
+ sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH((np->helper_path_vec[lpe])[j]), curve);
curve = curve->unref();
}
}
static void
sp_nodepath_destroy_helperpaths(Inkscape::NodePath::Path *np) {
- for (HelperPathList::iterator i = np->helper_path_vec->begin(); i != np->helper_path_vec->end(); ++i) {
+ for (HelperPathList::iterator i = np->helper_path_vec.begin(); i != np->helper_path_vec.end(); ++i) {
for (std::vector<SPCanvasItem *>::iterator j = (*i).second.begin(); j != (*i).second.end(); ++j) {
GtkObject *temp = *j;
*j = NULL;
gtk_object_destroy(temp);
}
}
+ np->helper_path_vec.clear();
}
/**
* \brief Creates new nodepath from item
+ *
+ * \todo create proper constructor for nodepath::path, this method returns null a constructor cannot so this cannot be simply converted to constructor.
*/
Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, bool show_handles, const char * repr_key_in, SPItem *item)
{
@@ -278,12 +281,14 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
}
//Create new nodepath
- Inkscape::NodePath::Path *np = g_new(Inkscape::NodePath::Path, 1);
+ Inkscape::NodePath::Path *np = new Inkscape::NodePath::Path();
if (!np) {
curve->unref();
return NULL;
}
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+
// Set defaults
np->desktop = desktop;
np->object = object;
@@ -293,16 +298,15 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
np->local_change = 0;
np->show_handles = show_handles;
np->helper_path = NULL;
- np->helper_path_vec = new HelperPathList;
- np->helperpath_rgba = prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff);
+ np->helperpath_rgba = prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff);
np->helperpath_width = 1.0;
np->curve = curve->copy();
- np->show_helperpath = (prefs_get_int_attribute ("tools.nodes", "show_helperpath", 0) == 1);
+ np->show_helperpath = prefs->getBool("/tools/nodes/show_helperpath");
if (SP_IS_LPE_ITEM(object)) {
Inkscape::LivePathEffect::Effect *lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(object));
if (lpe && lpe->isVisible() && lpe->showOrigPath()) {
np->show_helperpath = true;
- }
+ }
}
np->straight_path = false;
if (IS_LIVEPATHEFFECT(object) && item) {
np->item = SP_ITEM(object);
}
+ np->drag_origin_mouse = Geom::Point(NR_HUGE, NR_HUGE);
+
// we need to update item's transform from the repr here,
// because they may be out of sync when we respond
// to a change in repr by regenerating nodepath --bb
Inkscape::LivePathEffect::Effect * lpe = LIVEPATHEFFECT(object)->get_lpe();
if (!lpe) {
g_error("sp_nodepath_new: lpeobject without real lpe passed as argument!");
- sp_nodepath_destroy(np);
+ delete np;
}
Inkscape::LivePathEffect::Parameter *lpeparam = lpe->getParameter(repr_key_in);
if (lpeparam) {
@@ -381,48 +387,39 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object,
/**
* Destroys nodepath's subpaths, then itself, also tell parent ShapeEditor about it.
*/
-void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
-
- if (!np) { //soft fail, like delete
- return;
- }
-
- while (np->subpaths) {
- sp_nodepath_subpath_destroy((Inkscape::NodePath::SubPath *) np->subpaths->data);
+Inkscape::NodePath::Path::~Path() {
+ while (this->subpaths) {
+ sp_nodepath_subpath_destroy((Inkscape::NodePath::SubPath *) this->subpaths->data);
}
//Inform the ShapeEditor that made me, if any, that I am gone.
- if (np->shape_editor)
- np->shape_editor->nodepath_destroyed();
+ if (this->shape_editor)
+ this->shape_editor->nodepath_destroyed();
- g_assert(!np->selected);
+ g_assert(!this->selected);
- if (np->helper_path) {
- GtkObject *temp = np->helper_path;
- np->helper_path = NULL;
+ if (this->helper_path) {
+ GtkObject *temp = this->helper_path;
+ this->helper_path = NULL;
gtk_object_destroy(temp);
}
- if (np->curve) {
- np->curve->unref();
- np->curve = NULL;
+ if (this->curve) {
+ this->curve->unref();
+ this->curve = NULL;
}
- if (np->repr_key) {
- g_free(np->repr_key);
- np->repr_key = NULL;
+ if (this->repr_key) {
+ g_free(this->repr_key);
+ this->repr_key = NULL;
}
- if (np->repr_nodetypes_key) {
- g_free(np->repr_nodetypes_key);
- np->repr_nodetypes_key = NULL;
+ if (this->repr_nodetypes_key) {
+ g_free(this->repr_nodetypes_key);
+ this->repr_nodetypes_key = NULL;
}
- sp_nodepath_destroy_helperpaths(np);
- delete np->helper_path_vec;
- np->helper_path_vec = NULL;
+ sp_nodepath_destroy_helperpaths(this);
- np->desktop = NULL;
-
- g_free(np);
+ this->desktop = NULL;
}
/**
@@ -602,6 +599,9 @@ Inkscape::NodePath::NodeType * parse_nodetypes(gchar const *types, guint length)
case 's':
typestr[pos++] =Inkscape::NodePath::NODE_SMOOTH;
break;
+ case 'a':
+ typestr[pos++] =Inkscape::NodePath::NODE_AUTO;
+ break;
case 'z':
typestr[pos++] =Inkscape::NodePath::NODE_SYMM;
break;
Inkscape::NodePath::Node *n = sp->first->n.other;
while (n) {
Geom::Point const end_pt = n->pos * np->d2i;
+ if (!IS_FINITE(n->pos[0]) || !IS_FINITE(n->pos[1])){
+ g_message("niet finite");
+ }
switch (n->code) {
case NR_LINETO:
curve->lineto(end_pt);
case Inkscape::NodePath::NODE_SMOOTH:
code = 's';
break;
+ case Inkscape::NodePath::NODE_AUTO:
+ code = 'a';
+ break;
case Inkscape::NodePath::NODE_SYMM:
code = 'z';
break;
@@ -1053,6 +1059,18 @@ static void sp_nodepath_set_line_type(Inkscape::NodePath::Node *end, NRPathcode
sp_nodepath_set_node_type(end, Inkscape::NodePath::NODE_CUSP);
}
}
+
+ if (start->type == Inkscape::NodePath::NODE_AUTO)
+ start->type = Inkscape::NodePath::NODE_SMOOTH;
+ if (end->type == Inkscape::NodePath::NODE_AUTO)
+ end->type = Inkscape::NodePath::NODE_SMOOTH;
+
+ start->n.pos = start->pos;
+ end->p.pos = end->pos;
+
+ sp_node_adjust_handle(start, -1);
+ sp_node_adjust_handle(end, 1);
+
} else {
Geom::Point delta = end->pos - start->pos;
start->n.pos = start->pos + delta / 3;
@@ -1066,6 +1084,25 @@ static void sp_nodepath_set_line_type(Inkscape::NodePath::Node *end, NRPathcode
}
}
+static void
+sp_nodepath_update_node_knot(Inkscape::NodePath::Node *node)
+{
+ if (node->type == Inkscape::NodePath::NODE_CUSP) {
+ node->knot->setShape (SP_KNOT_SHAPE_DIAMOND);
+ node->knot->setSize (node->selected? 11 : 9);
+ sp_knot_update_ctrl(node->knot);
+ } else if (node->type == Inkscape::NodePath::NODE_AUTO) {
+ node->knot->setShape (SP_KNOT_SHAPE_CIRCLE);
+ node->knot->setSize (node->selected? 11 : 9);
+ sp_knot_update_ctrl(node->knot);
+ } else {
+ node->knot->setShape (SP_KNOT_SHAPE_SQUARE);
+ node->knot->setSize (node->selected? 9 : 7);
+ sp_knot_update_ctrl(node->knot);
+ }
+}
+
+
/**
* Change node type, and its handles accordingly.
*/
@@ -1082,15 +1119,7 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
node->type = type;
- if (node->type == Inkscape::NodePath::NODE_CUSP) {
- node->knot->setShape (SP_KNOT_SHAPE_DIAMOND);
- node->knot->setSize (node->selected? 11 : 9);
- sp_knot_update_ctrl(node->knot);
- } else {
- node->knot->setShape (SP_KNOT_SHAPE_SQUARE);
- node->knot->setSize (node->selected? 9 : 7);
- sp_knot_update_ctrl(node->knot);
- }
+ sp_nodepath_update_node_knot(node);
// if one of handles is mouseovered, preserve its position
if (node->p.knot && SP_KNOT_IS_MOUSEOVER(node->p.knot)) {
@@ -1123,10 +1152,10 @@ sp_node_side_is_line (Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSi
other_to_me = &othernode->n;
} else if (&node->n == side) {
other_to_me = &othernode->p;
- }
+ }
if (!other_to_me)
return false;
- bool is_line =
+ bool is_line =
(Geom::L2(othernode->pos - other_to_me->pos) < 1e-6 &&
Geom::L2(node->pos - side->pos) < 1e-6);
return is_line;
@@ -1135,16 +1164,23 @@ sp_node_side_is_line (Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSi
/**
* Same as sp_nodepath_set_node_type(), but also converts, if necessary, adjacent segments from
* lines to curves. If adjacent to one line segment, pulls out or rotates opposite handle to align
- * with that segment, procucing half-smooth node. If already half-smooth, pull out the second handle too.
+ * with that segment, procucing half-smooth node. If already half-smooth, pull out the second handle too.
* If already cusp and set to cusp, retracts handles.
*/
void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type)
{
+ if (type == Inkscape::NodePath::NODE_AUTO) {
+ if (node->p.other != NULL)
+ node->code = NR_CURVETO;
+ if (node->n.other != NULL)
+ node->n.other->code = NR_CURVETO;
+ }
+
if (type == Inkscape::NodePath::NODE_SYMM || type == Inkscape::NodePath::NODE_SMOOTH) {
-/*
+/*
Here's the algorithm of converting node to smooth (Shift+S or toolbar button), in pseudocode:
-
+
if (two_handles) {
// do nothing, adjust_handles called via set_node_type will line them up
} else if (one_handle) {
@@ -1215,28 +1251,7 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
node->code = NR_CURVETO;
node->n.other->code = NR_CURVETO;
- Geom::Point leg_prev = node->pos - node->p.other->pos;
- Geom::Point leg_next = node->pos - node->n.other->pos;
-
- double norm_leg_prev = L2(leg_prev);
- double norm_leg_next = L2(leg_next);
-
- Geom::Point delta;
- if (norm_leg_next > 0.0) {
- delta = (norm_leg_prev / norm_leg_next) * leg_next - leg_prev;
- (&delta)->normalize();
- }
-
- if (type == Inkscape::NodePath::NODE_SYMM) {
- double norm_leg_avg = (norm_leg_prev + norm_leg_next) / 2;
- node->p.pos = node->pos + 0.3 * norm_leg_avg * delta;
- node->n.pos = node->pos - 0.3 * norm_leg_avg * delta;
- } else {
- // length of handle is proportional to distance to adjacent node
- node->p.pos = node->pos + 0.3 * norm_leg_prev * delta;
- node->n.pos = node->pos - 0.3 * norm_leg_next * delta;
- }
-
+ sp_node_adjust_handles_auto(node);
} else {
// pull the handle opposite to line segment, making it half-smooth
if (p_is_line && node->n.other) {
@@ -1270,11 +1285,16 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
*/
void sp_node_moveto(Inkscape::NodePath::Node *node, Geom::Point p)
{
- Geom::Point delta = p - node->pos;
- node->pos = p;
+ if (node->type == Inkscape::NodePath::NODE_AUTO) {
+ node->pos = p;
+ sp_node_adjust_handles_auto(node);
+ } else {
+ Geom::Point delta = p - node->pos;
+ node->pos = p;
- node->p.pos += delta;
- node->n.pos += delta;
+ node->p.pos += delta;
+ node->n.pos += delta;
+ }
Inkscape::NodePath::Node *node_p = NULL;
Inkscape::NodePath::Node *node_n = NULL;
sp_node_adjust_handle(node->p.other, -1);
node_p = node->p.other;
}
+ if (!node->p.other->selected && node->p.other->type == Inkscape::NodePath::NODE_AUTO) {
+ sp_node_adjust_handles_auto(node->p.other);
+ node_p = node->p.other;
+ }
}
if (node->n.other) {
if (node->n.other->code == NR_LINETO) {
sp_node_adjust_handle(node->n.other, 1);
node_n = node->n.other;
}
+ if (!node->n.other->selected && node->n.other->type == Inkscape::NodePath::NODE_AUTO) {
+ sp_node_adjust_handles_auto(node->n.other);
+ node_n = node->n.other;
+ }
}
// this function is only called from batch movers that will update display at the end
* Call sp_node_moveto() for node selection and handle possible snapping.
*/
static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath, Geom::Coord dx, Geom::Coord dy,
- bool const snap, bool constrained = false,
+ bool const snap, bool constrained = false,
Inkscape::Snapper::ConstraintLine const &constraint = Geom::Point())
{
- Geom::Coord best = NR_HUGE;
Geom::Point delta(dx, dy);
Geom::Point best_pt = delta;
- Inkscape::SnappedPoint best_abs;
-
- if (snap) {
+ Inkscape::SnappedPoint best;
+
+ if (snap) {
/* When dragging a (selected) node, it should only snap to other nodes (i.e. unselected nodes), and
- * not to itself. The snapper however can not tell which nodes are selected and which are not, so we
+ * not to itself. The snapper however can not tell which nodes are selected and which are not, so we
* must provide that information. */
-
- // Build a list of the unselected nodes to which the snapper should snap
+
+ // Build a list of the unselected nodes to which the snapper should snap
std::vector<Geom::Point> unselected_nodes;
for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
@@ -1330,34 +1357,59 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
if (!node->selected) {
unselected_nodes.push_back(to_2geom(node->pos));
- }
+ }
}
- }
-
+ }
+
SnapManager &m = nodepath->desktop->namedview->snap_manager;
-
- for (GList *l = nodepath->selected; l != NULL; l = l->next) {
+
+ // When only the node closest to the mouse pointer is to be snapped
+ // then we will not even try to snap to other points and discard those immediately
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ bool closest_only = prefs->getBool("/options/snapclosestonly/value", false);
+
+ Inkscape::NodePath::Node *closest_node = NULL;
+ Geom::Coord closest_dist = NR_HUGE;
+
+ if (closest_only) {
+ for (GList *l = nodepath->selected; l != NULL; l = l->next) {
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+ Geom::Coord dist = Geom::L2(nodepath->drag_origin_mouse - n->origin);
+ if (dist < closest_dist) {
+ closest_node = n;
+ closest_dist = dist;
+ }
+ }
+ }
+
+ // Iterate through all selected nodes
+ m.setup(nodepath->desktop, false, SP_PATH(nodepath->item), &unselected_nodes);
+ for (GList *l = nodepath->selected; l != NULL; l = l->next) {
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
- m.setup(nodepath->desktop, false, SP_PATH(n->subpath->nodepath->item), &unselected_nodes);
- Inkscape::SnappedPoint s;
- if (constrained) {
- Inkscape::Snapper::ConstraintLine dedicated_constraint = constraint;
- dedicated_constraint.setPoint(n->pos);
- s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, to_2geom(n->pos + delta), dedicated_constraint);
- } else {
- s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, to_2geom(n->pos + delta));
- }
- if (s.getSnapped() && (s.getDistance() < best)) {
- best = s.getDistance();
- best_abs = s;
- best_pt = from_2geom(s.getPoint()) - n->pos;
+ if (!closest_only || n == closest_node) { //try to snap either all selected nodes or only the closest one
+ Inkscape::SnappedPoint s;
+ if (constrained) {
+ Inkscape::Snapper::ConstraintLine dedicated_constraint = constraint;
+ dedicated_constraint.setPoint(n->pos);
+ s = m.constrainedSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, to_2geom(n->pos + delta), dedicated_constraint);
+ } else {
+ s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, to_2geom(n->pos + delta));
+ }
+
+ if (s.getSnapped()) {
+ s.setPointerDistance(Geom::L2(nodepath->drag_origin_mouse - n->origin));
+ if (!s.isOtherSnapBetter(best, true)) {
+ best = s;
+ best_pt = from_2geom(s.getPoint()) - n->pos;
+ }
+ }
}
}
-
- if (best_abs.getSnapped()) {
- nodepath->desktop->snapindicator->set_new_snappoint(best_abs);
+
+ if (best.getSnapped()) {
+ nodepath->desktop->snapindicator->set_new_snaptarget(best);
} else {
- nodepath->desktop->snapindicator->remove_snappoint();
+ nodepath->desktop->snapindicator->remove_snaptarget();
}
}
@@ -1443,7 +1495,8 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
if (pressure > 0.5)
alpha = 1/alpha;
- guint profile = prefs_get_int_attribute("tools.nodes", "sculpting_profile", SCULPT_PROFILE_BELL);
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ guint profile = prefs->getInt("/tools/nodes/sculpting_profile", SCULPT_PROFILE_BELL);
if (sp_nodepath_selection_get_subpath_count(nodepath) <= 1) {
// Only one subpath has selected nodes:
@@ -2039,6 +2092,9 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, Geom::Point
//find segment to split
Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(nodepath, segment_index);
+ if (!e) {
+ return;
+ }
//don't know why but t seems to flip for lines
if (sp_node_path_code_from_side(e, sp_node_get_side(e, -1)) == NR_LINETO) {
@@ -2072,6 +2128,15 @@ sp_nodepath_curve_drag(Inkscape::NodePath::Path *nodepath, int node, double t, G
g_return_if_fail(e != NULL);
g_return_if_fail(&e->p != NULL);
+ if (e->type == Inkscape::NodePath::NODE_AUTO) {
+ e->type = Inkscape::NodePath::NODE_SMOOTH;
+ sp_nodepath_update_node_knot (e);
+ }
+ if (e->p.other->type == Inkscape::NodePath::NODE_AUTO) {
+ e->p.other->type = Inkscape::NodePath::NODE_SMOOTH;
+ sp_nodepath_update_node_knot (e->p.other);
+ }
+
/* feel good is an arbitrary parameter that distributes the delta between handles
* if t of the drag point is less than 1/6 distance form the endpoint only
* the corresponding hadle is adjusted. This matches the behavior in GIMP
@@ -2231,13 +2296,13 @@ static void do_node_selected_join(Inkscape::NodePath::Path *nodepath, Inkscape::
}
if (b == sb->first) {
- // copy all nodes from b to a, forward
+ // copy all nodes from b to a, forward
sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->first->n.pos);
for (n = sb->first->n.other; n != NULL; n = n->n.other) {
sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->code, &n->p.pos, &n->pos, &n->n.pos);
}
} else if (b == sb->last) {
- // copy all nodes from b to a, backward
+ // copy all nodes from b to a, backward
sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->last->p.pos);
for (n = sb->last->p.other; n != NULL; n = n->p.other) {
sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos);
//would decreasing error create a better fitting approximation?
gdouble error = 1.0;
gint ret;
- ret = sp_bezier_fit_cubic (bez, adata, data.size(), error);
+ ret = Geom::bezier_fit_cubic (bez, adata, data.size(), error);
//if these nodes are smooth or symmetrical, the endpoints will be thrown out of sync.
//make sure these nodes are changed to cusp nodes so that, once the endpoints are moved,
@@ -2767,12 +2832,12 @@ static void sp_node_set_selected(Inkscape::NodePath::Node *node, gboolean select
node->selected = selected;
if (selected) {
- node->knot->setSize ((node->type == Inkscape::NodePath::NODE_CUSP) ? 11 : 9);
+ node->knot->setSize ((node->type == Inkscape::NodePath::NODE_CUSP || node->type == Inkscape::NodePath::NODE_AUTO) ? 11 : 9);
node->knot->setFill(NODE_FILL_SEL, NODE_FILL_SEL_HI, NODE_FILL_SEL_HI);
node->knot->setStroke(NODE_STROKE_SEL, NODE_STROKE_SEL_HI, NODE_STROKE_SEL_HI);
sp_knot_update_ctrl(node->knot);
} else {
- node->knot->setSize ((node->type == Inkscape::NodePath::NODE_CUSP) ? 9 : 7);
+ node->knot->setSize ((node->type == Inkscape::NodePath::NODE_CUSP || node->type == Inkscape::NodePath::NODE_AUTO) ? 9 : 7);
node->knot->setFill(NODE_FILL, NODE_FILL_HI, NODE_FILL_HI);
node->knot->setStroke(NODE_STROKE, NODE_STROKE_HI, NODE_STROKE_HI);
sp_knot_update_ctrl(node->knot);
@@ -3232,6 +3297,10 @@ static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adj
{
g_assert(node);
+ // nothing to do for auto nodes (sp_node_adjust_handles() does the job)
+ if (node->type == Inkscape::NodePath::NODE_AUTO)
+ return;
+
Inkscape::NodePath::NodeSide *me = sp_node_get_side(node, which_adjust);
Inkscape::NodePath::NodeSide *other = sp_node_opposite_side(node, me);
@@ -3264,7 +3333,7 @@ static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adj
}
if (node->type == Inkscape::NodePath::NODE_SYMM) {
- // symmetrize
+ // symmetrize
me->pos = 2 * node->pos - other->pos;
return;
} else {
if (node->p.other == NULL) return;
if (node->n.other == NULL) return;
+ if (node->type == Inkscape::NodePath::NODE_AUTO) {
+ sp_node_adjust_handles_auto(node);
+ return;
+ }
+
if (sp_node_side_is_line(node, &node->p)) {
sp_node_adjust_handle(node, 1);
return;
node->n.pos = node->pos + (nlen / (plen + nlen)) * delta;
}
+static void sp_node_adjust_handles_auto(Inkscape::NodePath::Node *node)
+{
+ if (node->p.other == NULL || node->n.other == NULL) {
+ node->p.pos = node->pos;
+ node->n.pos = node->pos;
+ return;
+ }
+
+ Geom::Point leg_prev = to_2geom(node->p.other->pos - node->pos);
+ Geom::Point leg_next = to_2geom(node->n.other->pos - node->pos);
+
+ double norm_leg_prev = Geom::L2(leg_prev);
+ double norm_leg_next = Geom::L2(leg_next);
+
+ Geom::Point delta;
+ if (norm_leg_next > 0.0) {
+ delta = (norm_leg_prev / norm_leg_next) * leg_next - leg_prev;
+ delta.normalize();
+ }
+
+ node->p.pos = node->pos - norm_leg_prev / 3 * delta;
+ node->n.pos = node->pos + norm_leg_next / 3 * delta;
+}
+
/**
* Node event callback.
*/
sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SMOOTH);
ret = TRUE;
break;
+ case GDK_a:
+ sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_AUTO);
+ ret = TRUE;
+ break;
case GDK_y:
sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SYMM);
ret = TRUE;
sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_SMOOTH);
} else if (n->type == Inkscape::NodePath::NODE_SMOOTH) {
sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_SYMM);
+ } else if (n->type == Inkscape::NodePath::NODE_SYMM) {
+ sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_AUTO);
} else {
sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_CUSP);
}
/**
* Mouse grabbed node callback.
*/
-static void node_grabbed(SPKnot */*knot*/, guint state, gpointer data)
+static void node_grabbed(SPKnot *knot, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
}
n->is_dragging = true;
+ sp_canvas_set_snap_delay_active(n->subpath->nodepath->desktop->canvas, true);
+ // Reconstruct and store the location of the mouse pointer at the time when we started dragging (needed for snapping)
+ n->subpath->nodepath->drag_origin_mouse = knot->grabbed_rel_pos + knot->drag_origin;
+
sp_canvas_force_full_redraw_after_interruptions(n->subpath->nodepath->desktop->canvas, 5);
sp_nodepath_remember_origins (n->subpath->nodepath);
n->dragging_out = NULL;
n->is_dragging = false;
+ sp_canvas_set_snap_delay_active(n->subpath->nodepath->desktop->canvas, false);
+ n->subpath->nodepath->drag_origin_mouse = Geom::Point(NR_HUGE, NR_HUGE);
sp_canvas_end_forced_full_redraws(n->subpath->nodepath->desktop->canvas);
sp_nodepath_update_repr(n->subpath->nodepath, _("Move nodes"));
* \todo fixme: This goes to "moved" event? (lauris)
*/
static gboolean
-node_request(SPKnot */*knot*/, Geom::Point *p, guint state, gpointer data)
+node_request(SPKnot */*knot*/, Geom::Point const &p, guint state, gpointer data)
{
double yn, xn, yp, xp;
double an, ap, na, pa;
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
- n->subpath->nodepath->desktop->snapindicator->remove_snappoint();
+ n->subpath->nodepath->desktop->snapindicator->remove_snaptarget();
// If either (Shift and some handle retracted), or (we're already dragging out a handle)
if ( (!n->subpath->nodepath->straight_path) &&
( ((state & GDK_SHIFT_MASK) && ((n->n.other && n->n.pos == n->pos) || (n->p.other && n->p.pos == n->pos)))
|| n->dragging_out ) )
{
- Geom::Point mouse = (*p);
+ Geom::Point mouse = p;
if (!n->dragging_out) {
// This is the first drag-out event; find out which handle to drag out
- double appr_n = (n->n.other ? Geom::L2(n->n.other->pos - n->pos) - Geom::L2(n->n.other->pos - (*p)) : -HUGE_VAL);
- double appr_p = (n->p.other ? Geom::L2(n->p.other->pos - n->pos) - Geom::L2(n->p.other->pos - (*p)) : -HUGE_VAL);
+ double appr_n = (n->n.other ? Geom::L2(n->n.other->pos - n->pos) - Geom::L2(n->n.other->pos - p) : -HUGE_VAL);
+ double appr_p = (n->p.other ? Geom::L2(n->p.other->pos - n->pos) - Geom::L2(n->p.other->pos - p) : -HUGE_VAL);
if (appr_p == -HUGE_VAL && appr_n == -HUGE_VAL) // orphan node?
return FALSE;
opposite = &n->p;
n->n.other->code = NR_CURVETO;
} else { // find out to which handle of the adjacent node we're closer; note that n->n.other == n->p.other
- double appr_other_n = (n->n.other ? Geom::L2(n->n.other->n.pos - n->pos) - Geom::L2(n->n.other->n.pos - (*p)) : -HUGE_VAL);
- double appr_other_p = (n->n.other ? Geom::L2(n->n.other->p.pos - n->pos) - Geom::L2(n->n.other->p.pos - (*p)) : -HUGE_VAL);
+ double appr_other_n = (n->n.other ? Geom::L2(n->n.other->n.pos - n->pos) - Geom::L2(n->n.other->n.pos - p) : -HUGE_VAL);
+ double appr_other_p = (n->n.other ? Geom::L2(n->n.other->p.pos - n->pos) - Geom::L2(n->n.other->p.pos - p) : -HUGE_VAL);
if (appr_other_p > appr_other_n) { // closer to other's p handle
n->dragging_out = &n->n;
opposite = &n->p;
}
// pass this on to the handle-moved callback
- node_handle_moved(n->dragging_out->knot, &mouse, state, (gpointer) n);
+ node_handle_moved(n->dragging_out->knot, mouse, state, (gpointer) n);
sp_node_update_handles(n);
return TRUE;
}
if (ap == 0) pa = HUGE_VAL; else pa = -1/ap;
// mouse point relative to the node's original pos
- pr = (*p) - n->origin;
+ pr = p - n->origin;
// distances to the four lines (two handles and two perpendiculars)
d_an = point_line_distance(&pr, an);
// move the node to the closest point
sp_nodepath_selected_nodes_move(n->subpath->nodepath,
n->origin[Geom::X] + c[Geom::X] - n->pos[Geom::X],
- n->origin[Geom::Y] + c[Geom::Y] - n->pos[Geom::Y],
+ n->origin[Geom::Y] + c[Geom::Y] - n->pos[Geom::Y],
true);
} else { // constraining to hor/vert
- if (fabs((*p)[Geom::X] - n->origin[Geom::X]) > fabs((*p)[Geom::Y] - n->origin[Geom::Y])) { // snap to hor
+ if (fabs(p[Geom::X] - n->origin[Geom::X]) > fabs(p[Geom::Y] - n->origin[Geom::Y])) { // snap to hor
sp_nodepath_selected_nodes_move(n->subpath->nodepath,
- (*p)[Geom::X] - n->pos[Geom::X],
+ p[Geom::X] - n->pos[Geom::X],
n->origin[Geom::Y] - n->pos[Geom::Y],
- true,
+ true,
true, Inkscape::Snapper::ConstraintLine(component_vectors[Geom::X]));
} else { // snap to vert
sp_nodepath_selected_nodes_move(n->subpath->nodepath,
n->origin[Geom::X] - n->pos[Geom::X],
- (*p)[Geom::Y] - n->pos[Geom::Y],
+ p[Geom::Y] - n->pos[Geom::Y],
true,
true, Inkscape::Snapper::ConstraintLine(component_vectors[Geom::Y]));
}
} else { // move freely
if (n->is_dragging) {
if (state & GDK_MOD1_MASK) { // sculpt
- sp_nodepath_selected_nodes_sculpt(n->subpath->nodepath, n, (*p) - n->origin);
+ sp_nodepath_selected_nodes_sculpt(n->subpath->nodepath, n, p - n->origin);
} else {
sp_nodepath_selected_nodes_move(n->subpath->nodepath,
- (*p)[Geom::X] - n->pos[Geom::X],
- (*p)[Geom::Y] - n->pos[Geom::Y],
+ p[Geom::X] - n->pos[Geom::X],
+ p[Geom::Y] - n->pos[Geom::Y],
(state & GDK_SHIFT_MASK) == 0);
}
}
}
- n->subpath->nodepath->desktop->scroll_to_point(*p);
+ n->subpath->nodepath->desktop->scroll_to_point(p);
return TRUE;
}
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
+ // convert auto -> smooth when dragging handle
+ if (n->type == Inkscape::NodePath::NODE_AUTO) {
+ n->type = Inkscape::NodePath::NODE_SMOOTH;
+ sp_nodepath_update_node_knot (n);
+ }
+
if (!n->selected) {
sp_nodepath_node_select(n, (state & GDK_SHIFT_MASK), FALSE);
}
/**
* Node handle "request" signal callback.
*/
-static gboolean node_handle_request(SPKnot *knot, Geom::Point *p, guint state, gpointer data)
+static gboolean node_handle_request(SPKnot *knot, Geom::Point &p, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
@@ -3821,44 +3937,42 @@ static gboolean node_handle_request(SPKnot *knot, Geom::Point *p, guint state, g
SnapManager &m = desktop->namedview->snap_manager;
m.setup(desktop, true, n->subpath->nodepath->item);
Inkscape::SnappedPoint s;
-
+
if ((state & GDK_SHIFT_MASK) != 0) {
// We will not try to snap when the shift-key is pressed
- // so remove the old snap indicator and don't wait for it to time-out
- desktop->snapindicator->remove_snappoint();
+ // so remove the old snap indicator and don't wait for it to time-out
+ desktop->snapindicator->remove_snaptarget();
}
Inkscape::NodePath::Node *othernode = opposite->other;
if (othernode) {
if ((n->type != Inkscape::NodePath::NODE_CUSP) && sp_node_side_is_line(n, opposite)) {
/* We are smooth node adjacent with line */
- Geom::Point const delta = *p - n->pos;
+ Geom::Point const delta = p - n->pos;
Geom::Coord const len = Geom::L2(delta);
Inkscape::NodePath::Node *othernode = opposite->other;
Geom::Point const ndelta = n->pos - othernode->pos;
Geom::Coord const linelen = Geom::L2(ndelta);
if (len > NR_EPSILON && linelen > NR_EPSILON) {
Geom::Coord const scal = dot(delta, ndelta) / linelen;
- (*p) = n->pos + (scal / linelen) * ndelta;
+ p = n->pos + (scal / linelen) * ndelta;
}
if ((state & GDK_SHIFT_MASK) == 0) {
- s = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, to_2geom(*p), Inkscape::Snapper::ConstraintLine(*p, ndelta));
+ s = m.constrainedSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, p, Inkscape::Snapper::ConstraintLine(p, ndelta));
}
} else {
- if ((state & GDK_SHIFT_MASK) == 0) {
- s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, to_2geom(*p));
- }
+ if ((state & GDK_SHIFT_MASK) == 0) {
+ s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, p);
+ }
}
} else {
- if ((state & GDK_SHIFT_MASK) == 0) {
- s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, to_2geom(*p));
- }
- }
-
- Geom::Point pt2g = *p;
- s.getPoint(pt2g);
- *p = pt2g;
-
+ if ((state & GDK_SHIFT_MASK) == 0) {
+ s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, p);
+ }
+ }
+
+ s.getPoint(p);
+
sp_node_adjust_handle(n, -which);
return FALSE;
@@ -3867,9 +3981,10 @@ static gboolean node_handle_request(SPKnot *knot, Geom::Point *p, guint state, g
/**
* Node handle moved callback.
*/
-static void node_handle_moved(SPKnot *knot, Geom::Point *p, guint state, gpointer data)
+static void node_handle_moved(SPKnot *knot, Geom::Point const &p, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
Inkscape::NodePath::NodeSide *me;
Inkscape::NodePath::NodeSide *other;
@@ -3888,10 +4003,10 @@ static void node_handle_moved(SPKnot *knot, Geom::Point *p, guint state, gpointe
// calculate radial coordinates of the grabbed handle, its other handle, and the mouse point
Radial rme(me->pos - n->pos);
Radial rother(other->pos - n->pos);
- Radial rnew(*p - n->pos);
+ Radial rnew(p - n->pos);
if (state & GDK_CONTROL_MASK && rnew.a != HUGE_VAL) {
- int const snaps = prefs_get_int_attribute("options.rotationsnapsperpi", "value", 12);
+ int const snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12);
/* 0 interpreted as "no snapping". */
// 1. Snap to the closest PI/snaps angle, starting from zero.
@@ -3970,7 +4085,7 @@ static void node_handle_moved(SPKnot *knot, Geom::Point *p, guint state, gpointe
double degrees = 180 / M_PI * rnew.a;
if (degrees > 180) degrees -= 360;
if (degrees < -180) degrees += 360;
- if (prefs_get_int_attribute("options.compassangledisplay", "value", 0) != 0)
+ if (prefs->getBool("/options/compassangledisplay/value"))
degrees = angle_to_compass (degrees);
GString *length = SP_PX_TO_METRIC_STRING(rnew.r, desktop->namedview->getDefaultMetric());
@@ -4279,8 +4394,18 @@ void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdoubl
box.expandTo (n->pos); // contain all selected nodes
}
+ if ( Geom::are_near(box.maxExtent(), 0) ) {
+ SPEventContext *ec = nodepath->desktop->event_context;
+ if (!ec) return;
+ Inkscape::MessageContext *mc = get_message_context(ec);
+ if (!mc) return;
+ mc->setF(Inkscape::WARNING_MESSAGE,
+ _("Cannot scale nodes when all are at the same location."));
+ return;
+ }
double scale = (box.maxExtent() + grow)/box.maxExtent();
+
Geom::Point scale_center;
if (Inkscape::NodePath::Path::active_node == NULL)
scale_center = box.midpoint();
@@ -4288,9 +4413,9 @@ void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdoubl
scale_center = Inkscape::NodePath::Path::active_node->pos;
Geom::Matrix t =
- Geom::Matrix (Geom::Translate(-scale_center)) *
- Geom::Matrix (Geom::Scale(scale, scale)) *
- Geom::Matrix (Geom::Translate(scale_center));
+ Geom::Translate(-scale_center) *
+ Geom::Scale(scale, scale) *
+ Geom::Translate(scale_center);
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
@@ -4517,12 +4642,11 @@ sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp, Inkscape::NodePath::Node *
n->knot = sp_knot_new(sp->nodepath->desktop, _("<b>Node</b>: drag to edit the path; with <b>Ctrl</b> to snap to horizontal/vertical; with <b>Ctrl+Alt</b> to snap to handles' directions"));
sp_knot_set_position(n->knot, *pos, 0);
- n->knot->setShape ((n->type == Inkscape::NodePath::NODE_CUSP)? SP_KNOT_SHAPE_DIAMOND : SP_KNOT_SHAPE_SQUARE);
- n->knot->setSize ((n->type == Inkscape::NodePath::NODE_CUSP)? 9 : 7);
n->knot->setAnchor (GTK_ANCHOR_CENTER);
n->knot->setFill(NODE_FILL, NODE_FILL_HI, NODE_FILL_HI);
n->knot->setStroke(NODE_STROKE, NODE_STROKE_HI, NODE_STROKE_HI);
- sp_knot_update_ctrl(n->knot);
+
+ sp_nodepath_update_node_knot(n);
g_signal_connect(G_OBJECT(n->knot), "event", G_CALLBACK(node_event), n);
g_signal_connect(G_OBJECT(n->knot), "clicked", G_CALLBACK(node_clicked), n);
case Inkscape::NodePath::NODE_SMOOTH:
// TRANSLATORS: "smooth" is an adjective here
return _("smooth");
+ case Inkscape::NodePath::NODE_AUTO:
+ return _("auto");
case Inkscape::NodePath::NODE_SYMM:
return _("symmetric");
}
}
}
-/**
+/*
SPCanvasItem *
sp_nodepath_path_to_canvasitem(Inkscape::NodePath::Path *np, SPPath *path) {
return sp_nodepath_make_helper_item(np, sp_path_get_curve_for_edit(path));
}
-**/
+*/
-/**
+/*
SPCanvasItem *
sp_nodepath_generate_helperpath(SPDesktop *desktop, SPCurve *curve, const SPItem *item, guint32 color = 0xff0000ff) {
SPCurve *flash_curve = curve->copy();
@@ -4919,10 +5045,11 @@ sp_nodepath_generate_helperpath(SPDesktop *desktop, SPCurve *curve, const SPItem
SPCanvasItem *
sp_nodepath_generate_helperpath(SPDesktop *desktop, SPPath *path) {
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
return sp_nodepath_generate_helperpath(desktop, sp_path_get_curve_for_edit(path), SP_ITEM(path),
- prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff));
+ prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff));
}
-**/
+*/
SPCanvasItem *
sp_nodepath_helperpath_from_path(SPDesktop *desktop, SPPath *path) {
SPCanvasItem * canvasitem = sp_canvas_bpath_new(sp_desktop_tempgroup(desktop), flash_curve);
// would be nice if its color could be XORed or something, now it is invisible for red stroked objects...
// unless we also flash the nodes...
- guint32 color = prefs_get_int_attribute("tools.nodes", "highlight_color", 0xff0000ff);
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ guint32 color = prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff);
sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvasitem), color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvasitem), 0, SP_WIND_RULE_NONZERO);
sp_canvas_item_show(canvasitem);