diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 35f64c1b38326c17d41d74e75d34ca2a63caa0f5..e03484d7a383033b8af80f7499e5b8040ad11f62 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
* Lauris Kaplinski <lauris@kaplinski.com>
* bulia byak <buliabyak@users.sf.net>
*
- * This code is in public domain
+ * Portions of this code are in public domain; node sculpting functions written by bulia byak are under GNU GPL
*/
#ifdef HAVE_CONFIG_H
#endif
#include <gdk/gdkkeysyms.h>
+#include "display/canvas-bpath.h"
#include "display/curve.h"
#include "display/sp-ctrlline.h"
#include "display/sodipodi-ctrl.h"
#include <glibmm/i18n.h>
#include "libnr/n-art-bpath.h"
+#include "libnr/nr-path.h"
#include "helper/units.h"
#include "knot.h"
#include "inkscape.h"
#include "message-stack.h"
#include "message-context.h"
#include "node-context.h"
+#include "shape-editor.h"
#include "selection-chemistry.h"
#include "selection.h"
#include "xml/repr.h"
#include "libnr/nr-matrix-ops.h"
#include "splivarot.h"
#include "svg/svg.h"
+#include "verbs.h"
#include "display/bezier-utils.h"
#include <vector>
#include <algorithm>
+#include <cstring>
+#include <string>
+#include "live_effects/lpeobject.h"
+#include "live_effects/parameter/parameter.h"
+#include "util/mathfns.h"
class NR::Matrix;
static void sp_node_set_selected(Inkscape::NodePath::Node *node, gboolean selected);
+static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type);
+
/* 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);
@@ -131,70 +142,108 @@ static Inkscape::NodePath::NodeSide *sp_node_get_side(Inkscape::NodePath::Node *
static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me);
static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me);
+static SPCurve* sp_nodepath_object_get_curve(SPObject *object, const gchar *key);
+static void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve);
+
// active_node indicates mouseover node
-static Inkscape::NodePath::Node *active_node = NULL;
+Inkscape::NodePath::Node * Inkscape::NodePath::Path::active_node = NULL;
/**
* \brief Creates new nodepath from item
*/
-Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item)
+Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, bool show_handles, const char * repr_key_in, SPItem *item)
{
- Inkscape::XML::Node *repr = SP_OBJECT(item)->repr;
+ Inkscape::XML::Node *repr = object->repr;
/** \todo
* FIXME: remove this. We don't want to edit paths inside flowtext.
* Instead we will build our flowtext with cloned paths, so that the
* real paths are outside the flowtext and thus editable as usual.
*/
- if (SP_IS_FLOWTEXT(item)) {
- for (SPObject *child = sp_object_first_child(SP_OBJECT(item)) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
+ if (SP_IS_FLOWTEXT(object)) {
+ for (SPObject *child = sp_object_first_child(object) ; child != NULL; child = SP_OBJECT_NEXT(child) ) {
if SP_IS_FLOWREGION(child) {
SPObject *grandchild = sp_object_first_child(SP_OBJECT(child));
if (grandchild && SP_IS_PATH(grandchild)) {
- item = SP_ITEM(grandchild);
+ object = SP_ITEM(grandchild);
break;
}
}
}
}
- if (!SP_IS_PATH(item))
- return NULL;
- SPPath *path = SP_PATH(item);
- SPCurve *curve = sp_shape_get_curve(SP_SHAPE(path));
+ SPCurve *curve = sp_nodepath_object_get_curve(object, repr_key_in);
+
if (curve == NULL)
return NULL;
NArtBpath *bpath = sp_curve_first_bpath(curve);
gint length = curve->end;
- if (length == 0)
+ if (length == 0) {
+ sp_curve_unref(curve);
return NULL; // prevent crash for one-node paths
-
- gchar const *nodetypes = repr->attribute("sodipodi:nodetypes");
- gchar *typestr = parse_nodetypes(nodetypes, length);
+ }
//Create new nodepath
Inkscape::NodePath::Path *np = g_new(Inkscape::NodePath::Path, 1);
- if (!np)
+ if (!np) {
+ sp_curve_unref(curve);
return NULL;
+ }
// Set defaults
np->desktop = desktop;
- np->path = path;
+ np->object = object;
np->subpaths = NULL;
np->selected = NULL;
- np->nodeContext = NULL; //Let the context that makes this set it
+ np->shape_editor = NULL; //Let the shapeeditor that makes this set it
np->livarot_path = NULL;
np->local_change = 0;
+ np->show_handles = show_handles;
+ np->helper_path = NULL;
+ np->helperpath_rgba = 0xff0000ff;
+ np->helperpath_width = 1.0;
+ np->curve = sp_curve_copy(curve);
+ np->show_helperpath = false;
+ np->straight_path = false;
+ if (IS_LIVEPATHEFFECT(object) && item) {
+ np->item = item;
+ } else {
+ np->item = SP_ITEM(object);
+ }
// 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
- sp_object_read_attr(SP_OBJECT(item), "transform");
+ sp_object_read_attr(SP_OBJECT(np->item), "transform");
- np->i2d = sp_item_i2d_affine(SP_ITEM(path));
+ np->i2d = sp_item_i2d_affine(np->item);
np->d2i = np->i2d.inverse();
+
np->repr = repr;
+ if (repr_key_in) { // apparantly the object is an LPEObject
+ np->repr_key = g_strdup(repr_key_in);
+ np->repr_nodetypes_key = g_strconcat(np->repr_key, "-nodetypes", NULL);
+ Inkscape::LivePathEffect::Parameter *lpeparam = LIVEPATHEFFECT(object)->lpe->getParameter(repr_key_in);
+ if (lpeparam) {
+ lpeparam->param_setup_nodepath(np);
+ }
+ } else {
+ np->repr_nodetypes_key = g_strdup("sodipodi:nodetypes");
+ if ( SP_SHAPE(np->object)->path_effect_href ) {
+ np->repr_key = g_strdup("inkscape:original-d");
+
+ LivePathEffectObject *lpeobj = sp_shape_get_livepatheffectobject(SP_SHAPE(np->object));
+ if (lpeobj && lpeobj->lpe) {
+ lpeobj->lpe->setup_nodepath(np);
+ }
+ } else {
+ np->repr_key = g_strdup("d");
+ }
+ }
+
+ gchar const *nodetypes = np->repr->attribute(np->repr_nodetypes_key);
+ gchar *typestr = parse_nodetypes(nodetypes, length);
// create the subpath(s) from the bpath
NArtBpath *b = bpath;
sp_curve_unref(curve);
// create the livarot representation from the same item
- np->livarot_path = Path_for_item(item, true, true);
- if (np->livarot_path)
- np->livarot_path->ConvertWithBackData(0.01);
+ sp_nodepath_ensure_livarot_path(np);
+
+ // Draw helper curve
+ if (np->show_helperpath) {
+ SPCurve *helper_curve = sp_curve_copy(np->curve);
+ sp_curve_transform(helper_curve, np->i2d );
+ np->helper_path = sp_canvas_bpath_new(sp_desktop_controls(desktop), helper_curve);
+ sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(np->helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+ sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(np->helper_path), 0, SP_WIND_RULE_NONZERO);
+ sp_canvas_item_show(np->helper_path);
+ sp_curve_unref(helper_curve);
+ }
return np;
}
/**
- * Destroys nodepath's subpaths, then itself, also tell context about it.
+ * Destroys nodepath's subpaths, then itself, also tell parent ShapeEditor about it.
*/
void sp_nodepath_destroy(Inkscape::NodePath::Path *np) {
sp_nodepath_subpath_destroy((Inkscape::NodePath::SubPath *) np->subpaths->data);
}
- //Inform the context that made me, if any, that I am gone.
- if (np->nodeContext)
- np->nodeContext->nodepath = NULL;
+ //Inform the ShapeEditor that made me, if any, that I am gone.
+ if (np->shape_editor)
+ np->shape_editor->nodepath_destroyed();
g_assert(!np->selected);
np->livarot_path = NULL;
}
+ if (np->helper_path) {
+ GtkObject *temp = np->helper_path;
+ np->helper_path = NULL;
+ gtk_object_destroy(temp);
+ }
+ if (np->curve) {
+ sp_curve_unref(np->curve);
+ np->curve = NULL;
+ }
+
+ if (np->repr_key) {
+ g_free(np->repr_key);
+ np->repr_key = NULL;
+ }
+ if (np->repr_nodetypes_key) {
+ g_free(np->repr_nodetypes_key);
+ np->repr_nodetypes_key = NULL;
+ }
+
np->desktop = NULL;
g_free(np);
}
+void sp_nodepath_ensure_livarot_path(Inkscape::NodePath::Path *np)
+{
+ if (np && np->livarot_path == NULL) {
+ SPCurve *curve = create_curve(np);
+ NArtBpath *bpath = SP_CURVE_BPATH(curve);
+ np->livarot_path = bpath_to_Path(bpath);
+
+ if (np->livarot_path)
+ np->livarot_path->ConvertWithBackData(0.01);
+
+ sp_curve_unref(curve);
+ }
+}
+
+
/**
* Return the node count of a given NodeSubPath.
*/
return nodeCount;
}
+/**
+ * Return the subpath count of a given NodePath.
+ */
+static gint sp_nodepath_get_subpath_count(Inkscape::NodePath::Path *np)
+{
+ if (!np)
+ return 0;
+ return g_list_length (np->subpaths);
+}
+
+/**
+ * Return the selected node count of a given NodePath.
+ */
+static gint sp_nodepath_selection_get_node_count(Inkscape::NodePath::Path *np)
+{
+ if (!np)
+ return 0;
+ return g_list_length (np->selected);
+}
+
+/**
+ * Return the number of subpaths where nodes are selected in a given NodePath.
+ */
+static gint sp_nodepath_selection_get_subpath_count(Inkscape::NodePath::Path *np)
+{
+ if (!np)
+ return 0;
+ if (!np->selected)
+ return 0;
+ if (!np->selected->next)
+ return 1;
+ gint count = 0;
+ for (GList *spl = np->subpaths; spl != NULL; spl = spl->next) {
+ Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
+ for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
+ Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
+ if (node->selected) {
+ count ++;
+ break;
+ }
+ }
+ }
+ return count;
+}
/**
* Clean up a nodepath after editing.
{
GList *badSubPaths = NULL;
- //Check all subpaths to be >=2 nodes
+ //Check all closed subpaths to be >=1 nodes, all open subpaths to be >= 2 nodes
for (GList *l = nodepath->subpaths; l ; l=l->next) {
Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *)l->data;
- if (sp_nodepath_subpath_get_node_count(sp)<2)
+ if ((sp_nodepath_subpath_get_node_count(sp)<2 && !sp->closed) || (sp_nodepath_subpath_get_node_count(sp)<1 && sp->closed))
badSubPaths = g_list_append(badSubPaths, sp);
}
{
g_assert(np);
- SPCurve *curve = create_curve(np);
+ sp_curve_unref(np->curve);
+ np->curve = create_curve(np);
- sp_shape_set_curve(SP_SHAPE(np->path), curve, TRUE);
+ sp_nodepath_set_curve(np, np->curve);
- sp_curve_unref(curve);
+ if (np->show_helperpath) {
+ SPCurve * helper_curve = sp_curve_copy(np->curve);
+ sp_curve_transform(helper_curve, np->i2d );
+ sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
+ sp_curve_unref(helper_curve);
+ }
}
/**
{
g_assert(np);
- Inkscape::XML::Node *repr = SP_OBJECT(np->path)->repr;
+ Inkscape::XML::Node *repr = np->object->repr;
+
+ sp_curve_unref(np->curve);
+ np->curve = create_curve(np);
- SPCurve *curve = create_curve(np);
gchar *typestr = create_typestr(np);
- gchar *svgpath = sp_svg_write_path(curve->bpath);
+ gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(np->curve));
- if (repr->attribute("d") == NULL || strcmp(svgpath, repr->attribute("d"))) { // d changed
+ // determine if path has an effect applied and write to correct "d" attribute.
+ if (repr->attribute(np->repr_key) == NULL || strcmp(svgpath, repr->attribute(np->repr_key))) { // d changed
np->local_change++;
- repr->setAttribute("d", svgpath);
+ repr->setAttribute(np->repr_key, svgpath);
}
- if (repr->attribute("sodipodi:nodetypes") == NULL || strcmp(typestr, repr->attribute("sodipodi:nodetypes"))) { // nodetypes changed
+ if (repr->attribute(np->repr_nodetypes_key) == NULL || strcmp(typestr, repr->attribute(np->repr_nodetypes_key))) { // nodetypes changed
np->local_change++;
- repr->setAttribute("sodipodi:nodetypes", typestr);
+ repr->setAttribute(np->repr_nodetypes_key, typestr);
}
g_free(svgpath);
g_free(typestr);
- sp_curve_unref(curve);
-}
+
+ if (np->show_helperpath) {
+ SPCurve * helper_curve = sp_curve_copy(np->curve);
+ sp_curve_transform(helper_curve, np->i2d );
+ sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
+ sp_curve_unref(helper_curve);
+ }
+ }
/**
* Update XML path node with data from path object, commit changes forever.
*/
-void sp_nodepath_update_repr(Inkscape::NodePath::Path *np)
+void sp_nodepath_update_repr(Inkscape::NodePath::Path *np, const gchar *annotation)
{
- update_repr_internal(np);
- sp_document_done(SP_DT_DOCUMENT(np->desktop));
+ //fixme: np can be NULL, so check before proceeding
+ g_return_if_fail(np != NULL);
if (np->livarot_path) {
delete np->livarot_path;
np->livarot_path = NULL;
}
- if (np->path && SP_IS_ITEM(np->path)) {
- np->livarot_path = Path_for_item (np->path, true, true);
- if (np->livarot_path)
- np->livarot_path->ConvertWithBackData(0.01);
- }
+ update_repr_internal(np);
+ sp_canvas_end_forced_full_redraws(np->desktop->canvas);
+
+ sp_document_done(sp_desktop_document(np->desktop), SP_VERB_CONTEXT_NODE,
+ annotation);
}
/**
* Update XML path node with data from path object, commit changes with undo.
*/
-static void sp_nodepath_update_repr_keyed(Inkscape::NodePath::Path *np, gchar const *key)
+static void sp_nodepath_update_repr_keyed(Inkscape::NodePath::Path *np, gchar const *key, const gchar *annotation)
{
- update_repr_internal(np);
- sp_document_maybe_done(SP_DT_DOCUMENT(np->desktop), key);
-
if (np->livarot_path) {
delete np->livarot_path;
np->livarot_path = NULL;
}
- if (np->path && SP_IS_ITEM(np->path)) {
- np->livarot_path = Path_for_item (np->path, true, true);
- if (np->livarot_path)
- np->livarot_path->ConvertWithBackData(0.01);
- }
+ update_repr_internal(np);
+ sp_document_maybe_done(sp_desktop_document(np->desktop), key, SP_VERB_CONTEXT_NODE,
+ annotation);
}
/**
{
g_assert(np);
- Inkscape::XML::Node *old_repr = SP_OBJECT(np->path)->repr;
- Inkscape::XML::Node *new_repr = old_repr->duplicate();
+ Inkscape::XML::Node *old_repr = np->object->repr;
+ Inkscape::XML::Node *new_repr = old_repr->duplicate(old_repr->document());
// remember the position of the item
gint pos = old_repr->position();
SPCurve *curve = create_curve(np);
gchar *typestr = create_typestr(np);
- gchar *svgpath = sp_svg_write_path(curve->bpath);
+ gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(curve));
- new_repr->setAttribute("d", svgpath);
- new_repr->setAttribute("sodipodi:nodetypes", typestr);
+ new_repr->setAttribute(np->repr_key, svgpath);
+ new_repr->setAttribute(np->repr_nodetypes_key, typestr);
// add the new repr to the parent
parent->appendChild(new_repr);
// move to the saved position
new_repr->setPosition(pos > 0 ? pos : 0);
- sp_document_done(SP_DT_DOCUMENT(np->desktop));
+ sp_document_done(sp_desktop_document(np->desktop), SP_VERB_CONTEXT_NODE,
+ _("Stamp"));
Inkscape::GC::release(new_repr);
g_free(svgpath);
}
/**
- * Returns current path in context.
+ * Returns current path in context. // later eliminate this function at all!
*/
static Inkscape::NodePath::Path *sp_nodepath_current()
{
return NULL;
}
- return SP_NODE_CONTEXT(event_context)->nodepath;
+ return SP_NODE_CONTEXT(event_context)->shape_editor->get_nodepath();
}
@@ -647,7 +794,7 @@ static void sp_nodepath_line_midpoint(Inkscape::NodePath::Node *new_path,Inkscap
if (end->code == NR_LINETO) {
new_path->type =Inkscape::NodePath::NODE_CUSP;
new_path->code = NR_LINETO;
- new_path->pos = (t * start->pos + (1 - t) * end->pos);
+ new_path->pos = new_path->n.pos = new_path->p.pos = (t * start->pos + (1 - t) * end->pos);
} else {
new_path->type =Inkscape::NodePath::NODE_SMOOTH;
new_path->code = NR_CURVETO;
@@ -686,13 +833,16 @@ static Inkscape::NodePath::Node *sp_nodepath_line_add_node(Inkscape::NodePath::N
g_assert( start->n.other == end );
Inkscape::NodePath::Node *newnode = sp_nodepath_node_new(end->subpath,
end,
- Inkscape::NodePath::NODE_SMOOTH,
+ (NRPathcode)end->code == NR_LINETO?
+ Inkscape::NodePath::NODE_CUSP : Inkscape::NodePath::NODE_SMOOTH,
(NRPathcode)end->code,
&start->pos, &start->pos, &start->n.pos);
sp_nodepath_line_midpoint(newnode, end, t);
+ sp_node_adjust_handles(start);
sp_node_update_handles(start);
sp_node_update_handles(newnode);
+ sp_node_adjust_handles(end);
sp_node_update_handles(end);
return newnode;
@@ -788,12 +938,14 @@ static void sp_nodepath_set_line_type(Inkscape::NodePath::Node *end, NRPathcode
end->code = code;
if (code == NR_LINETO) {
- if (start->code == NR_LINETO) start->type =Inkscape::NodePath::NODE_CUSP;
+ if (start->code == NR_LINETO) {
+ sp_nodepath_set_node_type (start, Inkscape::NodePath::NODE_CUSP);
+ }
if (end->n.other) {
- if (end->n.other->code == NR_LINETO) end->type =Inkscape::NodePath::NODE_CUSP;
+ if (end->n.other->code == NR_LINETO) {
+ sp_nodepath_set_node_type (end, Inkscape::NodePath::NODE_CUSP);
+ }
}
- sp_node_adjust_handle(start, -1);
- sp_node_adjust_handle(end, 1);
} else {
NR::Point delta = end->pos - start->pos;
start->n.pos = start->pos + delta / 3;
@@ -857,28 +1009,40 @@ static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::N
*/
void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type)
{
+ bool p_line = (node->p.other != NULL) && (node->code == NR_LINETO || node->pos == node->p.pos);
+ bool n_line = (node->n.other != NULL) && (node->n.other->code == NR_LINETO || node->pos == node->n.pos);
+
if (type == Inkscape::NodePath::NODE_SYMM || type == Inkscape::NodePath::NODE_SMOOTH) {
- if ((node->p.other != NULL) && (node->code == NR_LINETO || node->pos == node->p.pos)) {
- // convert adjacent segment BEFORE to curve
- node->code = NR_CURVETO;
- NR::Point delta;
- if (node->n.other != NULL)
- delta = node->n.other->pos - node->p.other->pos;
- else
- delta = node->pos - node->p.other->pos;
- node->p.pos = node->pos - delta / 4;
- sp_node_update_handles(node);
- }
+ if (p_line && n_line) {
+ // only if both adjacent segments are lines,
+ // convert both to curves:
- if ((node->n.other != NULL) && (node->n.other->code == NR_LINETO || node->pos == node->n.pos)) {
- // convert adjacent segment AFTER to curve
+ node->code = NR_CURVETO;
node->n.other->code = NR_CURVETO;
+
+ NR::Point leg_prev = node->pos - node->p.other->pos;
+ NR::Point leg_next = node->pos - node->n.other->pos;
+
+ double norm_leg_prev = L2(leg_prev);
+ double norm_leg_next = L2(leg_next);
+
+ // delta has length 1 and is orthogonal to bisecting line
NR::Point delta;
- if (node->p.other != NULL)
- delta = node->p.other->pos - node->n.other->pos;
- else
- delta = node->pos - node->n.other->pos;
- node->n.pos = node->pos - delta / 4;
+ 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_update_handles(node);
}
}
node->p.pos += delta;
node->n.pos += delta;
+ Inkscape::NodePath::Node *node_p = NULL;
+ Inkscape::NodePath::Node *node_n = NULL;
+
if (node->p.other) {
if (node->code == NR_LINETO) {
sp_node_adjust_handle(node, 1);
sp_node_adjust_handle(node->p.other, -1);
+ node_p = node->p.other;
}
}
if (node->n.other) {
if (node->n.other->code == NR_LINETO) {
sp_node_adjust_handle(node, -1);
sp_node_adjust_handle(node->n.other, 1);
+ node_n = node->n.other;
}
}
// this function is only called from batch movers that will update display at the end
// themselves, so here we just move all the knots without emitting move signals, for speed
sp_node_update_handles(node, false);
+ if (node_n) {
+ sp_node_update_handles(node_n, false);
+ }
+ if (node_p) {
+ sp_node_update_handles(node_p, false);
+ }
}
/**
static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath, NR::Coord dx, NR::Coord dy,
bool const snap = true)
{
- NR::Coord best[2] = { NR_HUGE, NR_HUGE };
+ NR::Coord best = NR_HUGE;
NR::Point delta(dx, dy);
NR::Point best_pt = delta;
if (snap) {
+ SnapManager const &m = nodepath->desktop->namedview->snap_manager;
+
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
- Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
- NR::Point p = n->pos + delta;
- for (int dim = 0; dim < 2; dim++) {
- NR::Coord dist = namedview_dim_snap(nodepath->desktop->namedview,
- Inkscape::Snapper::SNAP_POINT, p,
- NR::Dim2(dim), nodepath->path);
- if (dist < best[dim]) {
- best[dim] = dist;
- best_pt[dim] = p[dim] - n->pos[dim];
- }
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+ Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta, SP_PATH(n->subpath->nodepath->item));
+ if (s.getDistance() < best) {
+ best = s.getDistance();
+ best_pt = s.getPoint() - n->pos;
}
}
}
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
- Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
sp_node_moveto(n, n->pos + best_pt);
}
@@ -950,24 +1122,230 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
update_object(nodepath);
}
+/**
+Function mapping x (in the range 0..1) to y (in the range 1..0) using a smooth half-bell-like
+curve; the parameter alpha determines how blunt (alpha > 1) or sharp (alpha < 1) will be the curve
+near x = 0.
+ */
+double
+sculpt_profile (double x, double alpha, guint profile)
+{
+ if (x >= 1)
+ return 0;
+ if (x <= 0)
+ return 1;
+
+ switch (profile) {
+ case SCULPT_PROFILE_LINEAR:
+ return 1 - x;
+ case SCULPT_PROFILE_BELL:
+ return (0.5 * cos (M_PI * (pow(x, alpha))) + 0.5);
+ case SCULPT_PROFILE_ELLIPTIC:
+ return sqrt(1 - x*x);
+ }
+
+ return 1;
+}
+
+double
+bezier_length (NR::Point a, NR::Point ah, NR::Point bh, NR::Point b)
+{
+ // extremely primitive for now, don't have time to look for the real one
+ double lower = NR::L2(b - a);
+ double upper = NR::L2(ah - a) + NR::L2(bh - ah) + NR::L2(bh - b);
+ return (lower + upper)/2;
+}
+
+void
+sp_nodepath_move_node_and_handles (Inkscape::NodePath::Node *n, NR::Point delta, NR::Point delta_n, NR::Point delta_p)
+{
+ n->pos = n->origin + delta;
+ n->n.pos = n->n.origin + delta_n;
+ n->p.pos = n->p.origin + delta_p;
+ sp_node_adjust_handles(n);
+ sp_node_update_handles(n, false);
+}
+
+/**
+ * Displace selected nodes and their handles by fractions of delta (from their origins), depending
+ * on how far they are from the dragged node n.
+ */
+static void
+sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, NR::Point delta)
+{
+ g_assert (n);
+ g_assert (nodepath);
+ g_assert (n->subpath->nodepath == nodepath);
+
+ double pressure = n->knot->pressure;
+ if (pressure == 0)
+ pressure = 0.5; // default
+ pressure = CLAMP (pressure, 0.2, 0.8);
+
+ // map pressure to alpha = 1/5 ... 5
+ double alpha = 1 - 2 * fabs(pressure - 0.5);
+ if (pressure > 0.5)
+ alpha = 1/alpha;
+
+ guint profile = prefs_get_int_attribute("tools.nodes", "sculpting_profile", SCULPT_PROFILE_BELL);
+
+ if (sp_nodepath_selection_get_subpath_count(nodepath) <= 1) {
+ // Only one subpath has selected nodes:
+ // use linear mode, where the distance from n to node being dragged is calculated along the path
+
+ double n_sel_range = 0, p_sel_range = 0;
+ guint n_nodes = 0, p_nodes = 0;
+ guint n_sel_nodes = 0, p_sel_nodes = 0;
+
+ // First pass: calculate ranges (TODO: we could cache them, as they don't change while dragging)
+ {
+ double n_range = 0, p_range = 0;
+ bool n_going = true, p_going = true;
+ Inkscape::NodePath::Node *n_node = n;
+ Inkscape::NodePath::Node *p_node = n;
+ do {
+ // Do one step in both directions from n, until reaching the end of subpath or bumping into each other
+ if (n_node && n_going)
+ n_node = n_node->n.other;
+ if (n_node == NULL) {
+ n_going = false;
+ } else {
+ n_nodes ++;
+ n_range += bezier_length (n_node->p.other->origin, n_node->p.other->n.origin, n_node->p.origin, n_node->origin);
+ if (n_node->selected) {
+ n_sel_nodes ++;
+ n_sel_range = n_range;
+ }
+ if (n_node == p_node) {
+ n_going = false;
+ p_going = false;
+ }
+ }
+ if (p_node && p_going)
+ p_node = p_node->p.other;
+ if (p_node == NULL) {
+ p_going = false;
+ } else {
+ p_nodes ++;
+ p_range += bezier_length (p_node->n.other->origin, p_node->n.other->p.origin, p_node->n.origin, p_node->origin);
+ if (p_node->selected) {
+ p_sel_nodes ++;
+ p_sel_range = p_range;
+ }
+ if (p_node == n_node) {
+ n_going = false;
+ p_going = false;
+ }
+ }
+ } while (n_going || p_going);
+ }
+
+ // Second pass: actually move nodes in this subpath
+ sp_nodepath_move_node_and_handles (n, delta, delta, delta);
+ {
+ double n_range = 0, p_range = 0;
+ bool n_going = true, p_going = true;
+ Inkscape::NodePath::Node *n_node = n;
+ Inkscape::NodePath::Node *p_node = n;
+ do {
+ // Do one step in both directions from n, until reaching the end of subpath or bumping into each other
+ if (n_node && n_going)
+ n_node = n_node->n.other;
+ if (n_node == NULL) {
+ n_going = false;
+ } else {
+ n_range += bezier_length (n_node->p.other->origin, n_node->p.other->n.origin, n_node->p.origin, n_node->origin);
+ if (n_node->selected) {
+ sp_nodepath_move_node_and_handles (n_node,
+ sculpt_profile (n_range / n_sel_range, alpha, profile) * delta,
+ sculpt_profile ((n_range + NR::L2(n_node->n.origin - n_node->origin)) / n_sel_range, alpha, profile) * delta,
+ sculpt_profile ((n_range - NR::L2(n_node->p.origin - n_node->origin)) / n_sel_range, alpha, profile) * delta);
+ }
+ if (n_node == p_node) {
+ n_going = false;
+ p_going = false;
+ }
+ }
+ if (p_node && p_going)
+ p_node = p_node->p.other;
+ if (p_node == NULL) {
+ p_going = false;
+ } else {
+ p_range += bezier_length (p_node->n.other->origin, p_node->n.other->p.origin, p_node->n.origin, p_node->origin);
+ if (p_node->selected) {
+ sp_nodepath_move_node_and_handles (p_node,
+ sculpt_profile (p_range / p_sel_range, alpha, profile) * delta,
+ sculpt_profile ((p_range - NR::L2(p_node->n.origin - p_node->origin)) / p_sel_range, alpha, profile) * delta,
+ sculpt_profile ((p_range + NR::L2(p_node->p.origin - p_node->origin)) / p_sel_range, alpha, profile) * delta);
+ }
+ if (p_node == n_node) {
+ n_going = false;
+ p_going = false;
+ }
+ }
+ } while (n_going || p_going);
+ }
+
+ } else {
+ // Multiple subpaths have selected nodes:
+ // use spatial mode, where the distance from n to node being dragged is measured directly as NR::L2.
+ // TODO: correct these distances taking into account their angle relative to the bisector, so as to
+ // fix the pear-like shape when sculpting e.g. a ring
+
+ // First pass: calculate range
+ gdouble direct_range = 0;
+ for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
+ Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
+ for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
+ Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
+ if (node->selected) {
+ direct_range = MAX(direct_range, NR::L2(node->origin - n->origin));
+ }
+ }
+ }
+
+ // Second pass: actually move nodes
+ for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
+ Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
+ for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
+ Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
+ if (node->selected) {
+ if (direct_range > 1e-6) {
+ sp_nodepath_move_node_and_handles (node,
+ sculpt_profile (NR::L2(node->origin - n->origin) / direct_range, alpha, profile) * delta,
+ sculpt_profile (NR::L2(node->n.origin - n->origin) / direct_range, alpha, profile) * delta,
+ sculpt_profile (NR::L2(node->p.origin - n->origin) / direct_range, alpha, profile) * delta);
+ } else {
+ sp_nodepath_move_node_and_handles (node, delta, delta, delta);
+ }
+
+ }
+ }
+ }
+ }
+
+ // do not update repr here so that node dragging is acceptably fast
+ update_object(nodepath);
+}
+
+
/**
* Move node selection to point, adjust its and neighbouring handles,
* handle possible snapping, and commit the change with possible undo.
*/
void
-sp_node_selected_move(gdouble dx, gdouble dy)
+sp_node_selected_move(Inkscape::NodePath::Path *nodepath, gdouble dx, gdouble dy)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) return;
sp_nodepath_selected_nodes_move(nodepath, dx, dy, false);
if (dx == 0) {
- sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical", _("Move nodes vertically"));
} else if (dy == 0) {
- sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal", _("Move nodes horizontally"));
} else {
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Move nodes"));
}
}
* Move node selection off screen and commit the change.
*/
void
-sp_node_selected_move_screen(gdouble dx, gdouble dy)
+sp_node_selected_move_screen(Inkscape::NodePath::Path *nodepath, gdouble dx, gdouble dy)
{
// borrowed from sp_selection_move_screen in selection-chemistry.c
// we find out the current zoom factor and divide deltas by it
gdouble zdx = dx / zoom;
gdouble zdy = dy / zoom;
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) return;
sp_nodepath_selected_nodes_move(nodepath, zdx, zdy, false);
if (dx == 0) {
- sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:vertical", _("Move nodes vertically"));
} else if (dy == 0) {
- sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal");
+ sp_nodepath_update_repr_keyed(nodepath, "node:move:horizontal", _("Move nodes horizontally"));
} else {
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Move nodes"));
+ }
+}
+
+/**
+ * Move selected nodes to the absolute position given
+ */
+void sp_node_selected_move_absolute(Inkscape::NodePath::Path *nodepath, NR::Coord val, NR::Dim2 axis)
+{
+ for (GList *l = nodepath->selected; l != NULL; l = l->next) {
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+ NR::Point npos(axis == NR::X ? val : n->pos[NR::X], axis == NR::Y ? val : n->pos[NR::Y]);
+ sp_node_moveto(n, npos);
+ }
+
+ sp_nodepath_update_repr(nodepath, _("Move nodes"));
+}
+
+/**
+ * If the coordinates of all selected nodes coincide, return the common coordinate; otherwise return NR::Nothing
+ */
+NR::Maybe<NR::Coord> sp_node_selected_common_coord (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis)
+{
+ NR::Maybe<NR::Coord> no_coord = NR::Nothing();
+ g_return_val_if_fail(nodepath->selected, no_coord);
+
+ // determine coordinate of first selected node
+ GList *nsel = nodepath->selected;
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) nsel->data;
+ NR::Coord coord = n->pos[axis];
+ bool coincide = true;
+
+ // compare it to the coordinates of all the other selected nodes
+ for (GList *l = nsel->next; l != NULL; l = l->next) {
+ n = (Inkscape::NodePath::Node *) l->data;
+ if (n->pos[axis] != coord) {
+ coincide = false;
+ }
+ }
+ if (coincide) {
+ return coord;
+ } else {
+ NR::Rect bbox = sp_node_selected_bbox(nodepath);
+ // currently we return the coordinate of the bounding box midpoint because I don't know how
+ // to erase the spin button entry field :), but maybe this can be useful behaviour anyway
+ return bbox.midpoint()[axis];
}
}
@@ -1021,7 +1443,7 @@ static void sp_node_ensure_knot_exists (SPDesktop *desktop, Inkscape::NodePath::
}
if (!side->line) {
- side->line = sp_canvas_item_new(SP_DT_CONTROLS(desktop),
+ side->line = sp_canvas_item_new(sp_desktop_controls(desktop),
SP_TYPE_CTRLLINE, NULL);
}
}
@@ -1043,7 +1465,7 @@ static void sp_node_update_handle(Inkscape::NodePath::Node *node, gint which, gb
sp_node_ensure_knot_exists(node->subpath->nodepath->desktop, node, side);
// Just created, so we shouldn't fire the node_moved callback - instead set the knot position directly
side->knot->pos = side->pos;
- if (side->knot->item)
+ if (side->knot->item)
SP_CTRL(side->knot->item)->moveto(side->pos);
sp_ctrlline_set_coords(SP_CTRLLINE(side->line), node->pos, side->pos);
sp_knot_show(side->knot);
@@ -1090,7 +1512,7 @@ static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_mov
if (node->knot->pos != node->pos) { // visible knot is in a different position, need to update
if (fire_move_signals)
sp_knot_set_position(node->knot, &node->pos, 0);
- else
+ else
sp_knot_moveto(node->knot, &node->pos);
}
@@ -1102,6 +1524,9 @@ static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_mov
if (node->n.other->selected) show_handles = TRUE;
}
+ if (node->subpath->nodepath->show_handles == false)
+ show_handles = FALSE;
+
sp_node_update_handle(node, -1, show_handles, fire_move_signals);
sp_node_update_handle(node, 1, show_handles, fire_move_signals);
}
}
}
+void
+sp_nodepath_show_handles(Inkscape::NodePath::Path *nodepath, bool show)
+{
+ if (nodepath == NULL) return;
+
+ nodepath->show_handles = show;
+ sp_nodepath_update_handles(nodepath);
+}
+
/**
* Adds all selected nodes in nodepath to list.
*/
@@ -1161,7 +1595,7 @@ void sp_nodepath_selected_align(Inkscape::NodePath::Path *nodepath, NR::Dim2 axi
}
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Align nodes"));
}
/// Helper struct.
@@ -1223,7 +1657,7 @@ void sp_nodepath_selected_distribute(Inkscape::NodePath::Path *nodepath, NR::Dim
pos += step;
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Distribute nodes"));
}
@@ -1231,15 +1665,16 @@ void sp_nodepath_selected_distribute(Inkscape::NodePath::Path *nodepath, NR::Dim
* Call sp_nodepath_line_add_node() for all selected segments.
*/
void
-sp_node_selected_add_node(void)
+sp_node_selected_add_node(Inkscape::NodePath::Path *nodepath)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) {
return;
}
GList *nl = NULL;
+ int n_added = 0;
+
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
Inkscape::NodePath::Node *t = (Inkscape::NodePath::Node *) l->data;
g_assert(t->selected);
while (nl) {
Inkscape::NodePath::Node *t = (Inkscape::NodePath::Node *) nl->data;
Inkscape::NodePath::Node *n = sp_nodepath_line_add_node(t, 0.5);
- sp_nodepath_node_select(n, TRUE, FALSE);
- nl = g_list_remove(nl, t);
+ sp_nodepath_node_select(n, TRUE, FALSE);
+ n_added ++;
+ nl = g_list_remove(nl, t);
}
/** \todo fixme: adjust ? */
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
+ if (n_added > 1) {
+ sp_nodepath_update_repr(nodepath, _("Add nodes"));
+ } else if (n_added > 0) {
+ sp_nodepath_update_repr(nodepath, _("Add node"));
+ }
sp_nodepath_update_statusbar(nodepath);
}
@@ -1273,11 +1713,19 @@ sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Po
return;
}
- Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
+ sp_nodepath_ensure_livarot_path(nodepath);
+ NR::Maybe<Path::cut_position> maybe_position = get_nearest_position_on_Path(nodepath->livarot_path, p);
+ if (!maybe_position) {
+ return;
+ }
+ Path::cut_position position = *maybe_position;
//find segment to segment
Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece);
+ //fixme: this can return NULL, so check before proceeding.
+ g_return_if_fail(e != NULL);
+
gboolean force = FALSE;
if (!(e->selected && (!e->p.other || e->p.other->selected))) {
force = TRUE;
@@ -1301,7 +1749,12 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
return;
}
- Path::cut_position position = get_nearest_position_on_Path(nodepath->livarot_path, p);
+ sp_nodepath_ensure_livarot_path(nodepath);
+ NR::Maybe<Path::cut_position> maybe_position = get_nearest_position_on_Path(nodepath->livarot_path, p);
+ if (!maybe_position) {
+ return;
+ }
+ Path::cut_position position = *maybe_position;
//find segment to split
Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(position.piece);
@@ -1316,7 +1769,7 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
/* fixme: adjust ? */
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Add node"));
sp_nodepath_update_statusbar(nodepath);
}
@@ -1329,8 +1782,14 @@ sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, NR::Point p)
* cf. app/vectors/gimpbezierstroke.c, gimp_bezier_stroke_point_move_relative()
*/
void
-sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta)
+sp_nodepath_curve_drag(int node, double t, NR::Point delta)
{
+ Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(node);
+
+ //fixme: e and e->p can be NULL, so check for those before proceeding
+ g_return_if_fail(e != NULL);
+ g_return_if_fail(&e->p != NULL);
+
/* 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
@@ -1370,9 +1829,8 @@ sp_nodepath_curve_drag(Inkscape::NodePath::Node * e, double t, NR::Point delta)
/**
* Call sp_nodepath_break() for all selected segments.
*/
-void sp_node_selected_break()
+void sp_node_selected_break(Inkscape::NodePath::Path *nodepath)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) return;
GList *temp = NULL;
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Break path"));
}
/**
* Duplicate the selected node(s).
*/
-void sp_node_selected_duplicate()
+void sp_node_selected_duplicate(Inkscape::NodePath::Path *nodepath)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) {
return;
}
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Duplicate node"));
}
/**
* Join two nodes by merging them into one.
*/
-void sp_node_selected_join()
+void sp_node_selected_join(Inkscape::NodePath::Path *nodepath)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses
if (g_list_length(nodepath->selected) != 2) {
Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
g_assert(a != b);
- g_assert(a->p.other || a->n.other);
- g_assert(b->p.other || b->n.other);
+ if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) {
+ // someone tried to join an orphan node (i.e. a single-node subpath).
+ // this is not worth an error message, just fail silently.
+ return;
+ }
if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) {
nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
sp_node_moveto (sp->first, c);
sp_nodepath_update_handles(sp->nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Close subpath"));
return;
}
sp_nodepath_update_handles(sa->nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Join nodes"));
sp_nodepath_update_statusbar(nodepath);
}
/**
* Join two nodes by adding a segment between them.
*/
-void sp_node_selected_join_segment()
+void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses
if (g_list_length(nodepath->selected) != 2) {
Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
g_assert(a != b);
- g_assert(a->p.other || a->n.other);
- g_assert(b->p.other || b->n.other);
+ if (!(a->p.other || a->n.other) || !(b->p.other || b->n.other)) {
+ // someone tried to join an orphan node (i.e. a single-node subpath).
+ // this is not worth an error message, just fail silently.
+ return;
+ }
if (((a->subpath->closed) || (b->subpath->closed)) || (a->p.other && a->n.other) || (b->p.other && b->n.other)) {
nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have <b>two endnodes</b> selected."));
sp_nodepath_update_handles(sp->nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Close subpath by segment"));
return;
}
sp_nodepath_update_handles(sa->nodepath);
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Join nodes by segment"));
}
/**
*/
void sp_node_delete_preserve(GList *nodes_to_delete)
{
-
+ GSList *nodepaths = NULL;
+
while (nodes_to_delete) {
Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node*) g_list_first(nodes_to_delete)->data;
Inkscape::NodePath::SubPath *sp = node->subpath;
Inkscape::NodePath::Node *sample_end = NULL;
Inkscape::NodePath::Node *delete_cursor = node;
bool just_delete = false;
-
+
//find the start of this contiguous selection
//move left to the first node that is not selected
//or the start of the non-closed path
} else {
sample_cursor = delete_cursor->p.other;
}
-
+
//calculate points for each segment
int rate = 5;
float period = 1.0 / rate;
data.push_back(sample_cursor->pos);
for (Inkscape::NodePath::Node *curr=sample_cursor; curr; curr=curr->n.other) {
//just delete at the end of an open path
- if (!sp->closed && curr->n.other == sp->last) {
+ if (!sp->closed && curr == sp->last) {
just_delete = true;
break;
}
-
+
//sample points on the contiguous selected segment
NR::Point *bez;
bez = new NR::Point [4];
NR::Point *adata;
adata = new NR::Point [data.size()];
copy(data.begin(), data.end(), adata);
-
+
NR::Point *bez;
bez = new NR::Point [4];
//would decreasing error create a better fitting approximation?
gint ret;
ret = sp_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,
+ //the resulting nodes behave as expected.
+ sp_nodepath_convert_node_type(sample_cursor, Inkscape::NodePath::NODE_CUSP);
+ sp_nodepath_convert_node_type(sample_end, Inkscape::NodePath::NODE_CUSP);
+
//adjust endpoints
sample_cursor->n.pos = bez[1];
sample_end->p.pos = bez[2];
}
-
+
//destroy this contiguous selection
while (delete_cursor && g_list_find(nodes_to_delete, delete_cursor)) {
Inkscape::NodePath::Node *temp = delete_cursor;
if (delete_cursor->n.other == delete_cursor) {
// delete_cursor->n points to itself, which means this is the last node on a closed subpath
- delete_cursor = NULL;
+ delete_cursor = NULL;
} else {
delete_cursor = delete_cursor->n.other;
}
sp_nodepath_node_destroy(temp);
}
- //clean up the nodepath (such as for trivial subpaths)
- sp_nodepath_cleanup(nodepath);
-
sp_nodepath_update_handles(nodepath);
+ if (!g_slist_find(nodepaths, nodepath))
+ nodepaths = g_slist_prepend (nodepaths, nodepath);
+ }
+
+ for (GSList *i = nodepaths; i; i = i->next) {
+ // FIXME: when/if we teach node tool to have more than one nodepath, deleting nodes from
+ // different nodepaths will give us one undo event per nodepath
+ Inkscape::NodePath::Path *nodepath = (Inkscape::NodePath::Path *) i->data;
+
// if the entire nodepath is removed, delete the selected object.
if (nodepath->subpaths == NULL ||
+ //FIXME: a closed path CAN legally have one node, it's only an open one which must be
+ //at least 2
sp_nodepath_get_node_count(nodepath) < 2) {
- SPDocument *document = SP_DT_DOCUMENT (nodepath->desktop);
- sp_nodepath_destroy(nodepath);
- g_list_free(nodes_to_delete);
- nodes_to_delete = NULL;
- //is the next line necessary?
+ SPDocument *document = sp_desktop_document (nodepath->desktop);
+ //FIXME: The following line will be wrong when we have mltiple nodepaths: we only want to
+ //delete this nodepath's object, not the entire selection! (though at this time, this
+ //does not matter)
sp_selection_delete();
- sp_document_done (document);
- return;
+ sp_document_done (document, SP_VERB_CONTEXT_NODE,
+ _("Delete nodes"));
+ } else {
+ sp_nodepath_update_repr(nodepath, _("Delete nodes preserving shape"));
+ sp_nodepath_update_statusbar(nodepath);
}
-
- sp_nodepath_update_repr(nodepath);
-
- sp_nodepath_update_statusbar(nodepath);
}
+
+ g_slist_free (nodepaths);
}
/**
* Delete one or more selected nodes.
*/
-void sp_node_selected_delete()
+void sp_node_selected_delete(Inkscape::NodePath::Path *nodepath)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) return;
if (!nodepath->selected) return;
// if the entire nodepath is removed, delete the selected object.
if (nodepath->subpaths == NULL ||
sp_nodepath_get_node_count(nodepath) < 2) {
- SPDocument *document = SP_DT_DOCUMENT (nodepath->desktop);
- sp_nodepath_destroy(nodepath);
+ SPDocument *document = sp_desktop_document (nodepath->desktop);
sp_selection_delete();
- sp_document_done (document);
+ sp_document_done (document, SP_VERB_CONTEXT_NODE,
+ _("Delete nodes"));
return;
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Delete nodes"));
sp_nodepath_update_statusbar(nodepath);
}
* This is the code for 'split'.
*/
void
-sp_node_selected_delete_segment(void)
+sp_node_selected_delete_segment(Inkscape::NodePath::Path *nodepath)
{
Inkscape::NodePath::Node *start, *end; //Start , end nodes. not inclusive
Inkscape::NodePath::Node *curr, *next; //Iterators
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses
if (g_list_length(nodepath->selected) != 2) {
//Copy everything after 'end' to a new subpath
Inkscape::NodePath::SubPath *t = sp_nodepath_subpath_new(nodepath);
for (curr=end ; curr ; curr=curr->n.other) {
- sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)curr->type, (NRPathcode)curr->code,
+ NRPathcode code = (NRPathcode) curr->code;
+ if (curr == end)
+ code = NR_MOVETO;
+ sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)curr->type, code,
&curr->p.pos, &curr->pos, &curr->n.pos);
}
sp_nodepath_update_handles(nodepath);
- sp_nodepath_update_repr(nodepath);
-
- // if the entire nodepath is removed, delete the selected object.
- if (nodepath->subpaths == NULL ||
- sp_nodepath_get_node_count(nodepath) < 2) {
- sp_nodepath_destroy(nodepath);
- sp_selection_delete();
- return;
- }
+ sp_nodepath_update_repr(nodepath, _("Delete segment"));
sp_nodepath_update_statusbar(nodepath);
}
* Call sp_nodepath_set_line() for all selected segments.
*/
void
-sp_node_selected_set_line_type(NRPathcode code)
+sp_node_selected_set_line_type(Inkscape::NodePath::Path *nodepath, NRPathcode code)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (nodepath == NULL) return;
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
}
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Change segment type"));
}
/**
* Call sp_nodepath_convert_node_type() for all selected nodes.
*/
void
-sp_node_selected_set_type(Inkscape::NodePath::NodeType type)
+sp_node_selected_set_type(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::NodeType type)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (nodepath == NULL) return;
+ if (nodepath->straight_path) return; // don't change type when it is a straight path!
+
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
sp_nodepath_convert_node_type((Inkscape::NodePath::Node *) l->data, type);
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Change node type"));
}
/**
@@ -2247,6 +2716,164 @@ void sp_nodepath_select_rect(Inkscape::NodePath::Path *nodepath, NR::Rect const
}
}
+
+void
+nodepath_grow_selection_linearly (Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, int grow)
+{
+ g_assert (n);
+ g_assert (nodepath);
+ g_assert (n->subpath->nodepath == nodepath);
+
+ if (g_list_length (nodepath->selected) == 0) {
+ if (grow > 0) {
+ sp_nodepath_node_select(n, TRUE, TRUE);
+ }
+ return;
+ }
+
+ if (g_list_length (nodepath->selected) == 1) {
+ if (grow < 0) {
+ sp_nodepath_deselect (nodepath);
+ return;
+ }
+ }
+
+ double n_sel_range = 0, p_sel_range = 0;
+ Inkscape::NodePath::Node *farthest_n_node = n;
+ Inkscape::NodePath::Node *farthest_p_node = n;
+
+ // Calculate ranges
+ {
+ double n_range = 0, p_range = 0;
+ bool n_going = true, p_going = true;
+ Inkscape::NodePath::Node *n_node = n;
+ Inkscape::NodePath::Node *p_node = n;
+ do {
+ // Do one step in both directions from n, until reaching the end of subpath or bumping into each other
+ if (n_node && n_going)
+ n_node = n_node->n.other;
+ if (n_node == NULL) {
+ n_going = false;
+ } else {
+ n_range += bezier_length (n_node->p.other->pos, n_node->p.other->n.pos, n_node->p.pos, n_node->pos);
+ if (n_node->selected) {
+ n_sel_range = n_range;
+ farthest_n_node = n_node;
+ }
+ if (n_node == p_node) {
+ n_going = false;
+ p_going = false;
+ }
+ }
+ if (p_node && p_going)
+ p_node = p_node->p.other;
+ if (p_node == NULL) {
+ p_going = false;
+ } else {
+ p_range += bezier_length (p_node->n.other->pos, p_node->n.other->p.pos, p_node->n.pos, p_node->pos);
+ if (p_node->selected) {
+ p_sel_range = p_range;
+ farthest_p_node = p_node;
+ }
+ if (p_node == n_node) {
+ n_going = false;
+ p_going = false;
+ }
+ }
+ } while (n_going || p_going);
+ }
+
+ if (grow > 0) {
+ if (n_sel_range < p_sel_range && farthest_n_node && farthest_n_node->n.other && !(farthest_n_node->n.other->selected)) {
+ sp_nodepath_node_select(farthest_n_node->n.other, TRUE, TRUE);
+ } else if (farthest_p_node && farthest_p_node->p.other && !(farthest_p_node->p.other->selected)) {
+ sp_nodepath_node_select(farthest_p_node->p.other, TRUE, TRUE);
+ }
+ } else {
+ if (n_sel_range > p_sel_range && farthest_n_node && farthest_n_node->selected) {
+ sp_nodepath_node_select(farthest_n_node, TRUE, FALSE);
+ } else if (farthest_p_node && farthest_p_node->selected) {
+ sp_nodepath_node_select(farthest_p_node, TRUE, FALSE);
+ }
+ }
+}
+
+void
+nodepath_grow_selection_spatially (Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, int grow)
+{
+ g_assert (n);
+ g_assert (nodepath);
+ g_assert (n->subpath->nodepath == nodepath);
+
+ if (g_list_length (nodepath->selected) == 0) {
+ if (grow > 0) {
+ sp_nodepath_node_select(n, TRUE, TRUE);
+ }
+ return;
+ }
+
+ if (g_list_length (nodepath->selected) == 1) {
+ if (grow < 0) {
+ sp_nodepath_deselect (nodepath);
+ return;
+ }
+ }
+
+ Inkscape::NodePath::Node *farthest_selected = NULL;
+ double farthest_dist = 0;
+
+ Inkscape::NodePath::Node *closest_unselected = NULL;
+ double closest_dist = NR_HUGE;
+
+ for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
+ Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
+ for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
+ Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data;
+ if (node == n)
+ continue;
+ if (node->selected) {
+ if (NR::L2(node->pos - n->pos) > farthest_dist) {
+ farthest_dist = NR::L2(node->pos - n->pos);
+ farthest_selected = node;
+ }
+ } else {
+ if (NR::L2(node->pos - n->pos) < closest_dist) {
+ closest_dist = NR::L2(node->pos - n->pos);
+ closest_unselected = node;
+ }
+ }
+ }
+ }
+
+ if (grow > 0) {
+ if (closest_unselected) {
+ sp_nodepath_node_select(closest_unselected, TRUE, TRUE);
+ }
+ } else {
+ if (farthest_selected) {
+ sp_nodepath_node_select(farthest_selected, TRUE, FALSE);
+ }
+ }
+}
+
+
+/**
+\brief Saves all nodes' and handles' current positions in their origin members
+*/
+void
+sp_nodepath_remember_origins(Inkscape::NodePath::Path *nodepath)
+{
+ for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
+ Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
+ for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) {
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) nl->data;
+ n->origin = n->pos;
+ n->p.origin = n->p.pos;
+ n->n.origin = n->n.pos;
+ }
+ }
+}
+
/**
\brief Saves selected nodes in a nodepath into a list containing integer positions of all selected nodes
*/
@@ -2336,7 +2963,7 @@ static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adj
len = NR::L2(me->pos - node->pos);
delta = node->pos - othernode->pos;
linelen = NR::L2(delta);
- if (linelen < 1e-18)
+ if (linelen < 1e-18)
return;
me->pos = node->pos + (len / linelen)*delta;
return;
/**
* Node event callback.
*/
-static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n)
+static gboolean node_event(SPKnot */*knot*/, GdkEvent *event, Inkscape::NodePath::Node *n)
{
gboolean ret = FALSE;
switch (event->type) {
case GDK_ENTER_NOTIFY:
- active_node = n;
+ Inkscape::NodePath::Path::active_node = n;
break;
case GDK_LEAVE_NOTIFY:
- active_node = NULL;
+ Inkscape::NodePath::Path::active_node = NULL;
+ break;
+ case GDK_SCROLL:
+ if ((event->scroll.state & GDK_CONTROL_MASK) && !(event->scroll.state & GDK_SHIFT_MASK)) { // linearly
+ switch (event->scroll.direction) {
+ case GDK_SCROLL_UP:
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1);
+ break;
+ case GDK_SCROLL_DOWN:
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1);
+ break;
+ default:
+ break;
+ }
+ ret = TRUE;
+ } else if (!(event->scroll.state & GDK_SHIFT_MASK)) { // spatially
+ switch (event->scroll.direction) {
+ case GDK_SCROLL_UP:
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
+ break;
+ case GDK_SCROLL_DOWN:
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
+ break;
+ default:
+ break;
+ }
+ ret = TRUE;
+ }
break;
case GDK_KEY_PRESS:
switch (get_group0_keyval (&event->key)) {
@@ -2425,6 +3079,20 @@ static gboolean node_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Nod
ret = TRUE;
}
break;
+ case GDK_Page_Up:
+ if (event->key.state & GDK_CONTROL_MASK) {
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, +1);
+ } else {
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, +1);
+ }
+ break;
+ case GDK_Page_Down:
+ if (event->key.state & GDK_CONTROL_MASK) {
+ nodepath_grow_selection_linearly (n->subpath->nodepath, n, -1);
+ } else {
+ nodepath_grow_selection_spatially (n->subpath->nodepath, n, -1);
+ }
+ break;
default:
break;
}
Inkscape::NodePath::Path *np;
// there is no way to verify nodes so set active_node to nil when deleting!!
- if (active_node == NULL) return FALSE;
+ if (Inkscape::NodePath::Path::active_node == NULL) return FALSE;
if ((event->type == GDK_KEY_PRESS) && !(event->key.state & (GDK_SHIFT_MASK | GDK_CONTROL_MASK))) {
gint ret = FALSE;
switch (get_group0_keyval (&event->key)) {
/// \todo FIXME: this does not seem to work, the keys are stolen by tool contexts!
case GDK_BackSpace:
- np = active_node->subpath->nodepath;
- sp_nodepath_node_destroy(active_node);
- sp_nodepath_update_repr(np);
- active_node = NULL;
+ np = Inkscape::NodePath::Path::active_node->subpath->nodepath;
+ sp_nodepath_node_destroy(Inkscape::NodePath::Path::active_node);
+ sp_nodepath_update_repr(np, _("Delete node"));
+ Inkscape::NodePath::Path::active_node = NULL;
ret = TRUE;
break;
case GDK_c:
- sp_nodepath_set_node_type(active_node,Inkscape::NodePath::NODE_CUSP);
+ sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_CUSP);
ret = TRUE;
break;
case GDK_s:
- sp_nodepath_set_node_type(active_node,Inkscape::NodePath::NODE_SMOOTH);
+ sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SMOOTH);
ret = TRUE;
break;
case GDK_y:
- sp_nodepath_set_node_type(active_node,Inkscape::NodePath::NODE_SYMM);
+ sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SYMM);
ret = TRUE;
break;
case GDK_b:
- sp_nodepath_node_break(active_node);
+ sp_nodepath_node_break(Inkscape::NodePath::Path::active_node);
ret = TRUE;
break;
}
/**
* Mouseclick on node callback.
*/
-static void node_clicked(SPKnot *knot, guint state, gpointer data)
+static void node_clicked(SPKnot */*knot*/, guint state, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
} else {
sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_CUSP);
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Change node type"));
sp_nodepath_update_statusbar(nodepath);
} else { //ctrl+alt+click: delete node
/**
* 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->origin = knot->pos;
-
if (!n->selected) {
sp_nodepath_node_select(n, (state & GDK_SHIFT_MASK), FALSE);
}
+
+ n->is_dragging = true;
+ sp_canvas_force_full_redraw_after_interruptions(n->subpath->nodepath->desktop->canvas, 5);
+
+ sp_nodepath_remember_origins (n->subpath->nodepath);
}
/**
* Mouse ungrabbed node callback.
*/
-static void node_ungrabbed(SPKnot *knot, guint state, gpointer data)
+static void node_ungrabbed(SPKnot */*knot*/, guint /*state*/, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
n->dragging_out = NULL;
+ n->is_dragging = false;
+ sp_canvas_end_forced_full_redraws(n->subpath->nodepath->desktop->canvas);
- sp_nodepath_update_repr(n->subpath->nodepath);
+ sp_nodepath_update_repr(n->subpath->nodepath, _("Move nodes"));
}
/**
* \todo fixme: This goes to "moved" event? (lauris)
*/
static gboolean
-node_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
+node_request(SPKnot */*knot*/, NR::Point *p, guint state, gpointer data)
{
double yn, xn, yp, xp;
double an, ap, na, pa;
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
// If either (Shift and some handle retracted), or (we're already dragging out a handle)
- if (((state & GDK_SHIFT_MASK) && ((n->n.other && n->n.pos == n->pos) || (n->p.other && n->p.pos == n->pos))) || n->dragging_out) {
-
+ 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 ) )
+ {
NR::Point mouse = (*p);
if (!n->dragging_out) {
if ((n->n.other && n->n.other->code == NR_LINETO) || fabs(yn) + fabs(xn) < 1e-6) {
if (n->n.other) { // if there is the next point
if (L2(n->n.other->p.pos - n->n.other->pos) < 1e-6) // and the next point has no handle either
- yn = n->n.other->pos[NR::Y] - n->origin[NR::Y]; // use origin because otherwise the direction will change as you drag
- xn = n->n.other->pos[NR::X] - n->origin[NR::X];
+ yn = n->n.other->origin[NR::Y] - n->origin[NR::Y]; // use origin because otherwise the direction will change as you drag
+ xn = n->n.other->origin[NR::X] - n->origin[NR::X];
}
}
if (xn < 0) { xn = -xn; yn = -yn; } // limit the angle to between 0 and pi
if (n->code == NR_LINETO || fabs(yp) + fabs(xp) < 1e-6) {
if (n->p.other) {
if (L2(n->p.other->n.pos - n->p.other->pos) < 1e-6)
- yp = n->p.other->pos[NR::Y] - n->origin[NR::Y];
- xp = n->p.other->pos[NR::X] - n->origin[NR::X];
+ yp = n->p.other->origin[NR::Y] - n->origin[NR::Y];
+ xp = n->p.other->origin[NR::X] - n->origin[NR::X];
}
}
if (xp < 0) { xp = -xp; yp = -yp; } // limit the angle to between 0 and pi
if (an == 0) na = HUGE_VAL; else na = -1/an;
if (ap == 0) pa = HUGE_VAL; else pa = -1/ap;
- //g_print("an %g ap %g\n", an, ap);
-
// mouse point relative to the node's original pos
pr = (*p) - n->origin;
}
}
} else { // move freely
- sp_nodepath_selected_nodes_move(n->subpath->nodepath,
- (*p)[NR::X] - n->pos[NR::X],
- (*p)[NR::Y] - n->pos[NR::Y],
- (state & GDK_SHIFT_MASK) == 0);
+ if (n->is_dragging) {
+ if (state & GDK_MOD1_MASK) { // sculpt
+ sp_nodepath_selected_nodes_sculpt(n->subpath->nodepath, n, (*p) - n->origin);
+ } else {
+ sp_nodepath_selected_nodes_move(n->subpath->nodepath,
+ (*p)[NR::X] - n->pos[NR::X],
+ (*p)[NR::Y] - n->pos[NR::Y],
+ (state & GDK_SHIFT_MASK) == 0);
+ }
+ }
}
n->subpath->nodepath->desktop->scroll_to_point(p);
}
sp_node_update_handles(n);
Inkscape::NodePath::Path *nodepath = n->subpath->nodepath;
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Retract handle"));
sp_nodepath_update_statusbar(nodepath);
} else { // just select or add to selection, depending in Shift
// remember the origin point of the handle
if (n->p.knot == knot) {
- n->p.origin = n->p.pos - n->pos;
+ n->p.origin_radial = n->p.pos - n->pos;
} else if (n->n.knot == knot) {
- n->n.origin = n->n.pos - n->pos;
+ n->n.origin_radial = n->n.pos - n->pos;
} else {
g_assert_not_reached();
}
+ sp_canvas_force_full_redraw_after_interruptions(n->subpath->nodepath->desktop->canvas, 5);
}
/**
// forget origin and set knot position once more (because it can be wrong now due to restrictions)
if (n->p.knot == knot) {
- n->p.origin.a = 0;
+ n->p.origin_radial.a = 0;
sp_knot_set_position(knot, &n->p.pos, state);
} else if (n->n.knot == knot) {
- n->n.origin.a = 0;
+ n->n.origin_radial.a = 0;
sp_knot_set_position(knot, &n->n.pos, state);
} else {
g_assert_not_reached();
}
- sp_nodepath_update_repr(n->subpath->nodepath);
+ sp_nodepath_update_repr(n->subpath->nodepath, _("Move node handle"));
}
/**
* Node handle "request" signal callback.
*/
-static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpointer data)
+static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint /*state*/, gpointer data)
{
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data;
@@ -2839,7 +3519,7 @@ static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpo
NRPathcode const othercode = sp_node_path_code_from_side(n, opposite);
- SnapManager const m(n->subpath->nodepath->desktop->namedview);
+ SnapManager const &m = n->subpath->nodepath->desktop->namedview->snap_manager;
if (opposite->other && (n->type != Inkscape::NodePath::NODE_CUSP) && (othercode == NR_LINETO)) {
/* We are smooth node adjacent with line */
@@ -2852,9 +3532,9 @@ static gboolean node_handle_request(SPKnot *knot, NR::Point *p, guint state, gpo
NR::Coord const scal = dot(delta, ndelta) / linelen;
(*p) = n->pos + (scal / linelen) * ndelta;
}
- *p = m.constrainedSnap(Inkscape::Snapper::SNAP_POINT, *p, ndelta, NULL).getPoint();
+ *p = m.constrainedSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, Inkscape::Snapper::ConstraintLine(*p, ndelta), n->subpath->nodepath->item).getPoint();
} else {
- *p = m.freeSnap(Inkscape::Snapper::SNAP_POINT, *p, NULL).getPoint();
+ *p = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, n->subpath->nodepath->item).getPoint();
}
sp_node_adjust_handle(n, -which);
@@ -2894,13 +3574,13 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer
// The closest PI/snaps angle, starting from zero.
double const a_snapped = floor(rnew.a/(M_PI/snaps) + 0.5) * (M_PI/snaps);
- if (me->origin.a == HUGE_VAL) {
+ if (me->origin_radial.a == HUGE_VAL) {
// ortho doesn't exist: original handle was zero length.
rnew.a = a_snapped;
} else {
/* The closest PI/2 angle, starting from original angle (i.e. snapping to original,
* its opposite and perpendiculars). */
- double const a_ortho = me->origin.a + floor((rnew.a - me->origin.a)/(M_PI/2) + 0.5) * (M_PI/2);
+ double const a_ortho = me->origin_radial.a + floor((rnew.a - me->origin_radial.a)/(M_PI/2) + 0.5) * (M_PI/2);
// Snap to the closest.
rnew.a = ( fabs(a_snapped - rnew.a) < fabs(a_ortho - rnew.a)
@@ -2911,26 +3591,26 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer
if (state & GDK_MOD1_MASK) {
// lock handle length
- rnew.r = me->origin.r;
+ rnew.r = me->origin_radial.r;
}
if (( n->type !=Inkscape::NodePath::NODE_CUSP || (state & GDK_SHIFT_MASK))
- && rme.a != HUGE_VAL && rnew.a != HUGE_VAL && fabs(rme.a - rnew.a) > 0.001) {
+ && rme.a != HUGE_VAL && rnew.a != HUGE_VAL && (fabs(rme.a - rnew.a) > 0.001 || n->type ==Inkscape::NodePath::NODE_SYMM)) {
// rotate the other handle correspondingly, if both old and new angles exist and are not the same
rother.a += rnew.a - rme.a;
other->pos = NR::Point(rother) + n->pos;
- sp_ctrlline_set_coords(SP_CTRLLINE(other->line), n->pos, other->pos);
- sp_knot_set_position(other->knot, &other->pos, 0);
+ if (other->knot) {
+ sp_ctrlline_set_coords(SP_CTRLLINE(other->line), n->pos, other->pos);
+ sp_knot_moveto(other->knot, &other->pos);
+ }
}
me->pos = NR::Point(rnew) + n->pos;
sp_ctrlline_set_coords(SP_CTRLLINE(me->line), n->pos, me->pos);
- // this is what sp_knot_set_position does, but without emitting the signal:
+ // move knot, but without emitting the signal:
// we cannot emit a "moved" signal because we're now processing it
- if (me->knot->item) SP_CTRL(me->knot->item)->moveto(me->pos);
-
- knot->desktop->set_coordinate_status(me->pos);
+ sp_knot_moveto(me->knot, &(me->pos));
update_object(n->subpath->nodepath);
@@ -2976,6 +3656,16 @@ static gboolean node_handle_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePa
break;
}
break;
+ case GDK_ENTER_NOTIFY:
+ // we use an experimentally determined threshold that seems to work fine
+ if (NR::L2(n->pos - knot->pos) < 0.75)
+ Inkscape::NodePath::Path::active_node = n;
+ break;
+ case GDK_LEAVE_NOTIFY:
+ // we use an experimentally determined threshold that seems to work fine
+ if (NR::L2(n->pos - knot->pos) < 0.75)
+ Inkscape::NodePath::Path::active_node = NULL;
+ break;
default:
break;
}
@@ -3115,10 +3805,16 @@ void sp_nodepath_selected_nodes_rotate(Inkscape::NodePath::Path *nodepath, gdoub
rot = angle;
}
+ NR::Point rot_center;
+ if (Inkscape::NodePath::Path::active_node == NULL)
+ rot_center = box.midpoint();
+ else
+ rot_center = Inkscape::NodePath::Path::active_node->pos;
+
NR::Matrix t =
- NR::Matrix (NR::translate(-box.midpoint())) *
+ NR::Matrix (NR::translate(-rot_center)) *
NR::Matrix (NR::rotate(rot)) *
- NR::Matrix (NR::translate(box.midpoint()));
+ NR::Matrix (NR::translate(rot_center));
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
@@ -3129,7 +3825,7 @@ void sp_nodepath_selected_nodes_rotate(Inkscape::NodePath::Path *nodepath, gdoub
}
}
- sp_nodepath_update_repr_keyed(nodepath, angle > 0 ? "nodes:rot:p" : "nodes:rot:n");
+ sp_nodepath_update_repr_keyed(nodepath, angle > 0 ? "nodes:rot:p" : "nodes:rot:n", _("Rotate nodes"));
}
/**
@@ -3240,10 +3936,16 @@ void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdoubl
double scale = (box.maxExtent() + grow)/box.maxExtent();
+ NR::Point scale_center;
+ if (Inkscape::NodePath::Path::active_node == NULL)
+ scale_center = box.midpoint();
+ else
+ scale_center = Inkscape::NodePath::Path::active_node->pos;
+
NR::Matrix t =
- NR::Matrix (NR::translate(-box.midpoint())) *
+ NR::Matrix (NR::translate(-scale_center)) *
NR::Matrix (NR::scale(scale, scale)) *
- NR::Matrix (NR::translate(box.midpoint()));
+ NR::Matrix (NR::translate(scale_center));
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
@@ -3254,7 +3956,7 @@ void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdoubl
}
}
- sp_nodepath_update_repr_keyed(nodepath, grow > 0 ? "nodes:scale:p" : "nodes:scale:n");
+ sp_nodepath_update_repr_keyed(nodepath, grow > 0 ? "nodes:scale:p" : "nodes:scale:n", _("Scale nodes"));
}
void sp_nodepath_selected_nodes_scale_screen(Inkscape::NodePath::Path *nodepath, gdouble const grow, int const which)
@@ -3266,11 +3968,11 @@ void sp_nodepath_selected_nodes_scale_screen(Inkscape::NodePath::Path *nodepath,
/**
* Flip selected nodes horizontally/vertically.
*/
-void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis)
+void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Maybe<NR::Point> center)
{
if (!nodepath || !nodepath->selected) return;
- if (g_list_length(nodepath->selected) == 1) {
+ if (g_list_length(nodepath->selected) == 1 && !center) {
// flip handles of the single selected node
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) nodepath->selected->data;
double temp = n->p.pos[axis];
} else {
// scale nodes as an "object":
- Inkscape::NodePath::Node *n0 = (Inkscape::NodePath::Node *) nodepath->selected->data;
- NR::Rect box (n0->pos, n0->pos); // originally includes the first selected node
- for (GList *l = nodepath->selected; l != NULL; l = l->next) {
- Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
- box.expandTo (n->pos); // contain all selected nodes
+ NR::Rect box = sp_node_selected_bbox (nodepath);
+ if (!center) {
+ center = box.midpoint();
}
-
NR::Matrix t =
- NR::Matrix (NR::translate(-box.midpoint())) *
+ NR::Matrix (NR::translate(- *center)) *
NR::Matrix ((axis == NR::X)? NR::scale(-1, 1) : NR::scale(1, -1)) *
- NR::Matrix (NR::translate(box.midpoint()));
+ NR::Matrix (NR::translate(*center));
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
}
}
- sp_nodepath_update_repr(nodepath);
+ sp_nodepath_update_repr(nodepath, _("Flip nodes"));
+}
+
+NR::Rect sp_node_selected_bbox (Inkscape::NodePath::Path *nodepath)
+{
+ g_assert (nodepath->selected);
+
+ Inkscape::NodePath::Node *n0 = (Inkscape::NodePath::Node *) nodepath->selected->data;
+ NR::Rect box (n0->pos, n0->pos); // originally includes the first selected node
+ for (GList *l = nodepath->selected; l != NULL; l = l->next) {
+ Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data;
+ box.expandTo (n->pos); // contain all selected nodes
+ }
+ return box;
}
//-----------------------------------------------
@@ -3391,15 +4103,6 @@ static void sp_nodepath_subpath_open(Inkscape::NodePath::SubPath *sp,Inkscape::N
new_path->p.other = NULL;
}
-/**
- * Returns area in triangle given by points; may be negative.
- */
-inline double
-triangle_area (NR::Point p1, NR::Point p2, NR::Point p3)
-{
- return (p1[NR::X]*p2[NR::Y] + p1[NR::Y]*p3[NR::X] + p2[NR::X]*p3[NR::Y] - p2[NR::Y]*p3[NR::X] - p1[NR::Y]*p2[NR::X] - p1[NR::X]*p3[NR::Y]);
-}
-
/**
* Return new node in subpath with given properties.
* \param pos Position of node.
@@ -3424,7 +4127,7 @@ sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp, Inkscape::NodePath::Node *
// use the type from sodipodi:nodetypes
n->type = type;
} else {
- if (fabs (triangle_area (*pos, *ppos, *npos)) < 1e-2) {
+ if (fabs (Inkscape::Util::triangle_area (*pos, *ppos, *npos)) < 1e-2) {
// points are (almost) collinear
if (NR::L2(*pos - *ppos) < 1e-6 || NR::L2(*pos - *npos) < 1e-6) {
// endnode, or a node with a retracted handle
node->subpath->nodes = g_list_remove(node->subpath->nodes, node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_event), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_clicked), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_grabbed), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_ungrabbed), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->knot), (gpointer) G_CALLBACK(node_request), node);
g_object_unref(G_OBJECT(node->knot));
- if (node->p.knot)
+
+ if (node->p.knot) {
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_clicked), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_grabbed), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_ungrabbed), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_request), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_moved), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->p.knot), (gpointer) G_CALLBACK(node_handle_event), node);
g_object_unref(G_OBJECT(node->p.knot));
- if (node->n.knot)
+ node->p.knot = NULL;
+ }
+
+ if (node->n.knot) {
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_clicked), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_grabbed), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_ungrabbed), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_request), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_moved), node);
+ g_signal_handlers_disconnect_by_func(G_OBJECT(node->n.knot), (gpointer) G_CALLBACK(node_handle_event), node);
g_object_unref(G_OBJECT(node->n.knot));
+ node->n.knot = NULL;
+ }
if (node->p.line)
gtk_object_destroy(GTK_OBJECT(node->p.line));
@@ -3609,7 +4335,7 @@ static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Ink
}
/**
- * Call sp_nodepath_line_add_node() at t on the segment denoted by piece
+ * Return node with the given index
*/
Inkscape::NodePath::Node *
sp_nodepath_get_node_by_index(int index)
@@ -3700,21 +4426,18 @@ static gchar const *sp_node_type_description(Inkscape::NodePath::Node *node)
* Handles content of statusbar as long as node tool is active.
*/
void
-sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)
+sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)//!!!move to ShapeEditorsCollection
{
- gchar const *when_selected = _("<b>Drag</b> nodes or node handles; <b>arrow</b> keys to move nodes");
+ gchar const *when_selected = _("<b>Drag</b> nodes or node handles; <b>Alt+drag</b> nodes to sculpt; <b>arrow</b> keys to move nodes, <b>< ></b> to scale, <b>[ ]</b> to rotate");
gchar const *when_selected_one = _("<b>Drag</b> the node or its handles; <b>arrow</b> keys to move the node");
- gint total = 0;
- gint selected = 0;
- SPDesktop *desktop = NULL;
+ gint total_nodes = sp_nodepath_get_node_count(nodepath);
+ gint selected_nodes = sp_nodepath_selection_get_node_count(nodepath);
+ gint total_subpaths = sp_nodepath_get_subpath_count(nodepath);
+ gint selected_subpaths = sp_nodepath_selection_get_subpath_count(nodepath);
+ SPDesktop *desktop = NULL;
if (nodepath) {
- for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) {
- Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data;
- total += g_list_length(subpath->nodes);
- }
- selected = g_list_length(nodepath->selected);
desktop = nodepath->desktop;
} else {
desktop = SP_ACTIVE_DESKTOP;
Inkscape::MessageContext *mc = SP_NODE_CONTEXT (ec)->_node_message_context;
if (!mc) return;
- if (selected == 0) {
+ inkscape_active_desktop()->emitToolSubselectionChanged(NULL);
+
+ if (selected_nodes == 0) {
Inkscape::Selection *sel = desktop->selection;
if (!sel || sel->isEmpty()) {
mc->setF(Inkscape::NORMAL_MESSAGE,
mc->setF(Inkscape::NORMAL_MESSAGE,
ngettext("<b>0</b> out of <b>%i</b> node selected. <b>Click</b>, <b>Shift+click</b>, or <b>drag around</b> nodes to select.",
"<b>0</b> out of <b>%i</b> nodes selected. <b>Click</b>, <b>Shift+click</b>, or <b>drag around</b> nodes to select.",
- total),
- total);
+ total_nodes),
+ total_nodes);
} else {
if (g_slist_length((GSList *)sel->itemList()) == 1) {
mc->setF(Inkscape::NORMAL_MESSAGE, _("Drag the handles of the object to modify it."));
}
}
}
- } else if (nodepath && selected == 1) {
+ } else if (nodepath && selected_nodes == 1) {
mc->setF(Inkscape::NORMAL_MESSAGE,
ngettext("<b>%i</b> of <b>%i</b> node selected; %s. %s.",
"<b>%i</b> of <b>%i</b> nodes selected; %s. %s.",
- total),
- selected, total, sp_node_type_description((Inkscape::NodePath::Node *) nodepath->selected->data), when_selected_one);
+ total_nodes),
+ selected_nodes, total_nodes, sp_node_type_description((Inkscape::NodePath::Node *) nodepath->selected->data), when_selected_one);
} else {
- mc->setF(Inkscape::NORMAL_MESSAGE,
- ngettext("<b>%i</b> of <b>%i</b> node selected. %s.",
- "<b>%i</b> of <b>%i</b> nodes selected. %s.",
- total),
- selected, total, when_selected);
+ if (selected_subpaths > 1) {
+ mc->setF(Inkscape::NORMAL_MESSAGE,
+ ngettext("<b>%i</b> of <b>%i</b> node selected in <b>%i</b> of <b>%i</b> subpaths. %s.",
+ "<b>%i</b> of <b>%i</b> nodes selected in <b>%i</b> of <b>%i</b> subpaths. %s.",
+ total_nodes),
+ selected_nodes, total_nodes, selected_subpaths, total_subpaths, when_selected);
+ } else {
+ mc->setF(Inkscape::NORMAL_MESSAGE,
+ ngettext("<b>%i</b> of <b>%i</b> node selected. %s.",
+ "<b>%i</b> of <b>%i</b> nodes selected. %s.",
+ total_nodes),
+ selected_nodes, total_nodes, when_selected);
+ }
}
}
+/*
+ * returns a *copy* of the curve of that object.
+ */
+SPCurve* sp_nodepath_object_get_curve(SPObject *object, const gchar *key) {
+ if (!object)
+ return NULL;
+
+ SPCurve *curve = NULL;
+ if (SP_IS_PATH(object)) {
+ SPCurve *curve_new = sp_path_get_curve_for_edit(SP_PATH(object));
+ curve = sp_curve_copy(curve_new);
+ } else if ( IS_LIVEPATHEFFECT(object) && key) {
+ const gchar *svgd = object->repr->attribute(key);
+ if (svgd) {
+ NArtBpath *bpath = sp_svg_read_path(svgd);
+ SPCurve *curve_new = sp_curve_new_from_bpath(bpath);
+ if (curve_new) {
+ curve = curve_new; // don't do curve_copy because curve_new is already only created for us!
+ } else {
+ g_free(bpath);
+ }
+ }
+ }
+
+ return curve;
+}
+
+void sp_nodepath_set_curve (Inkscape::NodePath::Path *np, SPCurve *curve) {
+ if (!np || !np->object || !curve)
+ return;
+
+ if (SP_IS_PATH(np->object)) {
+ if (SP_SHAPE(np->object)->path_effect_href) {
+ sp_path_set_original_curve(SP_PATH(np->object), curve, true, false);
+ } else {
+ sp_shape_set_curve(SP_SHAPE(np->object), curve, true);
+ }
+ } else if ( IS_LIVEPATHEFFECT(np->object) ) {
+ // FIXME: this writing to string and then reading from string is bound to be slow.
+ // create a method to convert from curve directly to 2geom...
+ gchar *svgpath = sp_svg_write_path(SP_CURVE_BPATH(np->curve));
+ LIVEPATHEFFECT(np->object)->lpe->setParameter(np->repr_key, svgpath);
+ g_free(svgpath);
+
+ np->object->requestModified(SP_OBJECT_MODIFIED_FLAG);
+ }
+}
+
+void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) {
+ np->show_helperpath = show;
+
+ if (show) {
+ SPCurve *helper_curve = sp_curve_copy(np->curve);
+ sp_curve_transform(helper_curve, np->i2d );
+ if (!np->helper_path) {
+ np->helper_path = sp_canvas_bpath_new(sp_desktop_controls(np->desktop), helper_curve);
+ sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(np->helper_path), np->helperpath_rgba, np->helperpath_width, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+ sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(np->helper_path), 0, SP_WIND_RULE_NONZERO);
+ sp_canvas_item_show(np->helper_path);
+ } else {
+ sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve);
+ }
+ sp_curve_unref(helper_curve);
+ } else {
+ if (np->helper_path) {
+ GtkObject *temp = np->helper_path;
+ np->helper_path = NULL;
+ gtk_object_destroy(temp);
+ }
+ }
+}
+
+/* this function does not work yet */
+void sp_nodepath_make_straight_path(Inkscape::NodePath::Path *np) {
+ np->straight_path = true;
+ np->show_handles = false;
+ g_message("add code to make the path straight.");
+ // do sp_nodepath_convert_node_type on all nodes?
+ // search for this text !!! "Make selected segments lines"
+}
+
/*
Local Variables: