![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index 4131c8ccaaeca8e439804d672c92a12c2b738f8a..e03484d7a383033b8af80f7499e5b8040ad11f62 100644 (file)
--- a/src/nodepath.cpp
+++ b/src/nodepath.cpp
#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 "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;
@@ -135,71 +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
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, bool show_handles)
+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->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;
@@ -216,6 +260,17 @@ Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPItem *item, bool
// create the livarot representation from the same item
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;
}
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 && np->path && SP_IS_ITEM(np->path)) {
- np->livarot_path = Path_for_item (np->path, true, true);
+ 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);
}
}
@@ -328,7 +407,7 @@ static gint sp_nodepath_selection_get_subpath_count(Inkscape::NodePath::Path *np
}
return count;
}
-
+
/**
* Clean up a nodepath after editing.
*
{
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(SP_CURVE_BPATH(curve));
+ 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.
@@ -500,8 +594,8 @@ void sp_nodepath_update_repr(Inkscape::NodePath::Path *np, const gchar *annotati
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,
+
+ sp_document_done(sp_desktop_document(np->desktop), SP_VERB_CONTEXT_NODE,
annotation);
}
@@ -516,7 +610,7 @@ static void sp_nodepath_update_repr_keyed(Inkscape::NodePath::Path *np, gchar co
}
update_repr_internal(np);
- sp_document_maybe_done(sp_desktop_document(np->desktop), key, SP_VERB_CONTEXT_NODE,
+ 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 *old_repr = np->object->repr;
Inkscape::XML::Node *new_repr = old_repr->duplicate(old_repr->document());
// remember the position of the item
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);
@@ -739,7 +833,7 @@ 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,
- (NRPathcode)end->code == NR_LINETO?
+ (NRPathcode)end->code == NR_LINETO?
Inkscape::NodePath::NODE_CUSP : Inkscape::NodePath::NODE_SMOOTH,
(NRPathcode)end->code,
&start->pos, &start->pos, &start->n.pos);
@@ -920,21 +1014,33 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
if (type == Inkscape::NodePath::NODE_SYMM || type == Inkscape::NodePath::NODE_SMOOTH) {
if (p_line && n_line) {
- // only if both adjacent segments are lines,
+ // only if both adjacent segments are lines,
// convert both to curves:
- // BEFORE:
- {
node->code = NR_CURVETO;
- NR::Point delta = node->n.other->pos - node->p.other->pos;
- node->p.pos = node->pos - delta / 4;
+ 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 (norm_leg_next > 0.0) {
+ delta = (norm_leg_prev / norm_leg_next) * leg_next - leg_prev;
+ (&delta)->normalize();
}
- // AFTER:
- {
- node->n.other->code = NR_CURVETO;
- NR::Point delta = node->p.other->pos - node->n.other->pos;
- node->n.pos = node->pos - delta / 4;
+ 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);
@@ -996,10 +1102,10 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
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;
- Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAP_POINT, n->pos + delta, n->subpath->nodepath->path);
+ 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;
@@ -1064,7 +1170,7 @@ sp_nodepath_move_node_and_handles (Inkscape::NodePath::Node *n, NR::Point delta,
* 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
+static void
sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *n, NR::Point delta)
{
g_assert (n);
@@ -1150,7 +1256,7 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
} 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,
+ 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);
@@ -1167,7 +1273,7 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
} 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,
+ 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);
@@ -1183,7 +1289,7 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
} 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
+ // 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
@@ -1270,6 +1376,51 @@ sp_node_selected_move_screen(Inkscape::NodePath::Path *nodepath, gdouble dx, gdo
}
}
+/**
+ * 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];
+ }
+}
+
/** If they don't yet exist, creates knot and line for the given side of the node */
static void sp_node_ensure_knot_exists (SPDesktop *desktop, Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *side)
{
@@ -1314,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);
@@ -1361,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);
}
@@ -1574,7 +1725,7 @@ sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, NR::Po
//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;
//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
Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
g_assert(a != b);
- if (!(a->p.other || a->n.other) || !(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;
Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data;
g_assert(a != b);
- if (!(a->p.other || a->n.other) || !(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;
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;
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?
//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_get_node_count(nodepath) < 2) {
SPDocument *document = sp_desktop_document (nodepath->desktop);
sp_selection_delete();
- sp_document_done (document, SP_VERB_CONTEXT_NODE,
+ sp_document_done (document, SP_VERB_CONTEXT_NODE,
_("Delete nodes"));
return;
}
@@ -2291,6 +2442,8 @@ sp_node_selected_set_type(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath
{
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);
}
n->n.origin = n->n.pos;
}
}
-}
+}
/**
\brief Saves selected nodes in a nodepath into a list containing integer positions of all selected nodes
@@ -2810,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) {
/**
* 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;
/**
* 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;
/**
* 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;
* \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) {
/**
* 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;
@@ -3377,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, Inkscape::Snapper::ConstraintLine(*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);
@@ -3827,13 +3982,7 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Ma
} 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();
}
@@ -3854,6 +4003,19 @@ void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, NR::Dim2 axis, NR::Ma
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;
+}
+
//-----------------------------------------------
/**
* Return new subpath under given nodepath.
@@ -3941,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.
@@ -3974,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
@@ -4295,6 +4448,8 @@ sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)//!!!move to Sha
Inkscape::MessageContext *mc = SP_NODE_CONTEXT (ec)->_node_message_context;
if (!mc) return;
+ inkscape_active_desktop()->emitToolSubselectionChanged(NULL);
+
if (selected_nodes == 0) {
Inkscape::Selection *sel = desktop->selection;
if (!sel || sel->isEmpty()) {
@@ -4338,6 +4493,87 @@ sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)//!!!move to Sha
}
}
+/*
+ * 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: