![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
diff --git a/src/nodepath.cpp b/src/nodepath.cpp
index ec3066cfc2ff9c22e40a55b8dc49293f24db7b42..09c030aecc119c16b26430cb16118b2971491f32 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 "live_effects/lpeobject.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);
@@ -133,71 +138,96 @@ 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_object_set_curve (SPObject *object, 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
+* repr_key_in should be NULL, unless you are called Johan or really know what you are doing! (See "if (repr_key_in)" below)
*/
-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)
{
- 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->curve = sp_curve_copy(curve);
+ np->show_helperpath = false;
+ np->straight_path = false;
+
// 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(object, "transform");
- np->i2d = sp_item_i2d_affine(SP_ITEM(path));
+ np->i2d = sp_item_i2d_affine(SP_ITEM(object));
np->d2i = np->i2d.inverse();
+
np->repr = repr;
+ if (repr_key_in) {
+ np->repr_key = g_strdup(repr_key_in);
+ np->repr_nodetypes_key = g_strconcat(np->repr_key, "-nodetypes", NULL);
+ np->show_helperpath = true;
+ } 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");
+ np->show_helperpath = true;
+ } 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;
@@ -214,6 +244,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), 0xff0000ff, 1.0, 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;
}
delete np->livarot_path;
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;
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 && np->object && SP_IS_ITEM(np->object)) {
+ 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);
}
}
{
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_object_set_curve(np->object, 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;
- SPCurve *curve = create_curve(np);
+ sp_curve_unref(np->curve);
+ np->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.
{
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);
@@ -698,7 +778,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;
@@ -737,13 +817,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;
@@ -839,12 +922,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;
@@ -919,26 +1004,18 @@ void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::Nod
// BEFORE:
{
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;
+ NR::Point delta = node->n.other->pos - node->p.other->pos;
node->p.pos = node->pos - delta / 4;
- sp_node_update_handles(node);
}
// AFTER:
{
node->n.other->code = NR_CURVETO;
- 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;
+ NR::Point delta = node->p.other->pos - node->n.other->pos;
node->n.pos = node->pos - delta / 4;
- sp_node_update_handles(node);
}
+
+ sp_node_update_handles(node);
}
}
@@ -1000,7 +1077,7 @@ static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath,
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, NULL);
+ Inkscape::SnappedPoint const s = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, n->pos + delta, SP_PATH(n->subpath->nodepath->object));
if (s.getDistance() < best) {
best = s.getDistance();
best_pt = s.getPoint() - n->pos;
@@ -1229,9 +1306,8 @@ sp_nodepath_selected_nodes_sculpt(Inkscape::NodePath::Path *nodepath, Inkscape::
* 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);
* 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);
}
void
-sp_nodepath_show_handles(bool show)
+sp_nodepath_show_handles(Inkscape::NodePath::Path *nodepath, bool show)
{
- Inkscape::NodePath::Path *nodepath = sp_nodepath_current();
if (nodepath == NULL) return;
nodepath->show_handles = show;
@@ -1518,9 +1592,8 @@ 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;
}
/**
* 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;
/**
* 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;
}
/**
* 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) {
/**
* 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) {
/**
* 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;
* 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) {
* 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) {
* 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;
for (GList *l = nodepath->selected; l != NULL; l = l->next) {
@@ -2898,10 +2963,10 @@ static gboolean node_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::No
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
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);
+ np = Inkscape::NodePath::Path::active_node->subpath->nodepath;
+ sp_nodepath_node_destroy(Inkscape::NodePath::Path::active_node);
sp_nodepath_update_repr(np, _("Delete node"));
- active_node = NULL;
+ 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;
}
@@ -3390,9 +3455,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), SP_ITEM(n->subpath->nodepath->object)).getPoint();
} else {
- *p = m.freeSnap(Inkscape::Snapper::SNAP_POINT, *p, NULL).getPoint();
+ *p = m.freeSnap(Inkscape::Snapper::SNAPPOINT_NODE, *p, SP_ITEM(n->subpath->nodepath->object)).getPoint();
}
sp_node_adjust_handle(n, -which);
@@ -3453,12 +3518,14 @@ static void node_handle_moved(SPKnot *knot, NR::Point *p, guint state, gpointer
}
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;
@@ -3512,6 +3579,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;
}
@@ -3651,10 +3728,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;
@@ -3776,10 +3859,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;
@@ -3802,11 +3891,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];
box.expandTo (n->pos); // contain all selected nodes
}
+ 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;
@@ -4168,7 +4260,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)
@@ -4324,6 +4416,60 @@ 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_object_set_curve (SPObject *object, SPCurve *curve) {
+ if (!object || !curve)
+ return;
+
+ if (SP_IS_PATH(object)) {
+ if (SP_SHAPE(object)->path_effect_href) {
+ sp_path_set_original_curve(SP_PATH(object), curve, true, false);
+ } else {
+ sp_shape_set_curve(SP_SHAPE(object), curve, true);
+ }
+ } else if ( IS_LIVEPATHEFFECT(object) ) {
+ g_warning("sp_nodepath_set_curve not implemented yet for lpeobjects");
+ }
+}
+
+void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) {
+ np->show_helperpath = show;
+}
+
+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: