From 6180462057af966742c17051c9fd53a4edcf09bd Mon Sep 17 00:00:00 2001 From: =?utf8?q?Krzysztof=20Kosi=C5=84ski?= Date: Thu, 14 Jan 2010 10:38:33 +0100 Subject: [PATCH] Remove nodepath.cpp and nodepath.h --- src/nodepath.cpp | 5146 ---------------------------------------------- src/nodepath.h | 345 ---- 2 files changed, 5491 deletions(-) delete mode 100644 src/nodepath.cpp delete mode 100644 src/nodepath.h diff --git a/src/nodepath.cpp b/src/nodepath.cpp deleted file mode 100644 index 488642cb2..000000000 --- a/src/nodepath.cpp +++ /dev/null @@ -1,5146 +0,0 @@ -#define __SP_NODEPATH_C__ - -/** \file - * Path handler in node edit mode - * - * Authors: - * Lauris Kaplinski - * bulia byak - * - * Portions of this code are in public domain; node sculpting functions written by bulia byak are under GNU GPL - */ - -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#include -#include "display/canvas-bpath.h" -#include "display/curve.h" -#include "display/sp-ctrlline.h" -#include "display/sodipodi-ctrl.h" -#include "display/sp-canvas-util.h" -#include -#include "2geom/pathvector.h" -#include "2geom/sbasis-to-bezier.h" -#include "2geom/bezier-curve.h" -#include "2geom/hvlinesegment.h" -#include "helper/units.h" -#include "helper/geom.h" -#include "knot.h" -#include "inkscape.h" -#include "document.h" -#include "sp-namedview.h" -#include "desktop.h" -#include "desktop-handles.h" -#include "snap.h" -#include "message-stack.h" -#include "message-context.h" -#include "node-context.h" -#include "lpe-tool-context.h" -#include "shape-editor.h" -#include "selection-chemistry.h" -#include "selection.h" -#include "xml/repr.h" -#include "preferences.h" -#include "sp-metrics.h" -#include "sp-path.h" -#include "sp-text.h" -#include "sp-shape.h" -#include "libnr/nr-matrix-ops.h" -#include "svg/svg.h" -#include "verbs.h" -#include <2geom/bezier-utils.h> -#include -#include -#include -#include -#include "live_effects/lpeobject.h" -#include "live_effects/lpeobject-reference.h" -#include "live_effects/effect.h" -#include "live_effects/parameter/parameter.h" -#include "live_effects/parameter/path.h" -#include "util/mathfns.h" -#include "display/snap-indicator.h" -#include "snapped-point.h" - -namespace Geom { class Matrix; } - -/// \todo -/// evil evil evil. FIXME: conflict of two different Path classes! -/// There is a conflict in the namespace between two classes named Path. -/// #include "sp-flowtext.h" -/// #include "sp-flowregion.h" - -#define SP_TYPE_FLOWREGION (sp_flowregion_get_type ()) -#define SP_IS_FLOWREGION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SP_TYPE_FLOWREGION)) -GType sp_flowregion_get_type (void); -#define SP_TYPE_FLOWTEXT (sp_flowtext_get_type ()) -#define SP_IS_FLOWTEXT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SP_TYPE_FLOWTEXT)) -GType sp_flowtext_get_type (void); -// end evil workaround - -#include "helper/stlport.h" - - -/// \todo fixme: Implement these via preferences */ - -#define NODE_FILL 0xbfbfbf00 -#define NODE_STROKE 0x000000ff -#define NODE_FILL_HI 0xff000000 -#define NODE_STROKE_HI 0x000000ff -#define NODE_FILL_SEL 0x0000ffff -#define NODE_STROKE_SEL 0x000000ff -#define NODE_FILL_SEL_HI 0xff000000 -#define NODE_STROKE_SEL_HI 0x000000ff -#define KNOT_FILL 0xffffffff -#define KNOT_STROKE 0x000000ff -#define KNOT_FILL_HI 0xff000000 -#define KNOT_STROKE_HI 0x000000ff - -static GMemChunk *nodechunk = NULL; - -/* Creation from object */ - -static void subpaths_from_pathvector(Inkscape::NodePath::Path *np, Geom::PathVector const & pathv, Inkscape::NodePath::NodeType const *t); -static Inkscape::NodePath::NodeType * parse_nodetypes(gchar const *types, guint length); - -/* Object updating */ - -static void stamp_repr(Inkscape::NodePath::Path *np); -static SPCurve *create_curve(Inkscape::NodePath::Path *np); -static gchar *create_typestr(Inkscape::NodePath::Path *np); - -static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_move_signals = true); - -static void sp_nodepath_node_select(Inkscape::NodePath::Node *node, gboolean incremental, gboolean override); - -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); -static void sp_node_adjust_handles_auto(Inkscape::NodePath::Node *node); - -/* Node event callbacks */ -static void node_clicked(SPKnot *knot, guint state, gpointer data); -static void node_grabbed(SPKnot *knot, guint state, gpointer data); -static void node_ungrabbed(SPKnot *knot, guint state, gpointer data); -static gboolean node_request(SPKnot *knot, Geom::Point const &p, guint state, gpointer data); - -/* Handle event callbacks */ -static void node_handle_clicked(SPKnot *knot, guint state, gpointer data); -static void node_handle_grabbed(SPKnot *knot, guint state, gpointer data); -static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data); -static gboolean node_handle_request(SPKnot *knot, Geom::Point &p, guint state, gpointer data); -static void node_handle_moved(SPKnot *knot, Geom::Point const &p, guint state, gpointer data); -static gboolean node_handle_event(SPKnot *knot, GdkEvent *event, Inkscape::NodePath::Node *n); - -/* Constructors and destructors */ - -static Inkscape::NodePath::SubPath *sp_nodepath_subpath_new(Inkscape::NodePath::Path *nodepath); -static void sp_nodepath_subpath_destroy(Inkscape::NodePath::SubPath *subpath); -static void sp_nodepath_subpath_close(Inkscape::NodePath::SubPath *sp); -static void sp_nodepath_subpath_open(Inkscape::NodePath::SubPath *sp,Inkscape::NodePath::Node *n); -static Inkscape::NodePath::Node * sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp,Inkscape::NodePath::Node *next,Inkscape::NodePath::NodeType type, NRPathcode code, - Geom::Point *ppos, Geom::Point *pos, Geom::Point *npos); -static void sp_nodepath_node_destroy(Inkscape::NodePath::Node *node); - -/* Helpers */ - -static Inkscape::NodePath::NodeSide *sp_node_get_side(Inkscape::NodePath::Node *node, gint which); -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; - -static SPCanvasItem * -sp_nodepath_make_helper_item(Inkscape::NodePath::Path *np, /*SPDesktop *desktop, */const SPCurve *curve, bool show = false, guint32 color = 0xff0000ff) { - SPCurve *helper_curve = curve->copy(); - helper_curve->transform(np->i2d); - SPCanvasItem *helper_path = sp_canvas_bpath_new(sp_desktop_controls(np->desktop), helper_curve); - sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(helper_path), color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); - sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(helper_path), 0, SP_WIND_RULE_NONZERO); - sp_canvas_item_move_to_z(helper_path, 0); - if (show) { - sp_canvas_item_show(helper_path); - } - helper_curve->unref(); - return helper_path; -} - -static void -sp_nodepath_create_helperpaths(Inkscape::NodePath::Path *np) { - //std::map > helper_path_vec; - if (!SP_IS_LPE_ITEM(np->item)) { - g_print ("Only LPEItems can have helperpaths!\n"); - return; - } - - SPLPEItem *lpeitem = SP_LPE_ITEM(np->item); - PathEffectList lpelist = sp_lpe_item_get_effect_list(lpeitem); - for (PathEffectList::iterator i = lpelist.begin(); i != lpelist.end(); ++i) { - Inkscape::LivePathEffect::LPEObjectReference *lperef = (*i); - Inkscape::LivePathEffect::Effect *lpe = lperef->lpeobject->get_lpe(); - if (lpe) { - // create new canvas items from the effect's helper paths - std::vector hpaths = lpe->getHelperPaths(lpeitem); - for (std::vector::iterator j = hpaths.begin(); j != hpaths.end(); ++j) { - SPCurve *helper_curve = new SPCurve(*j); - SPCanvasItem * canvasitem = sp_nodepath_make_helper_item(np, helper_curve, true, 0x509050dd); - np->helper_path_vec[lpe].push_back(canvasitem); - helper_curve->unref(); - } - } - } -} - -static void -sp_nodepath_destroy_helperpaths(Inkscape::NodePath::Path *np) { - for (HelperPathList::iterator i = np->helper_path_vec.begin(); i != np->helper_path_vec.end(); ++i) { - for (std::vector::iterator j = (*i).second.begin(); j != (*i).second.end(); ++j) { - GtkObject *temp = *j; - *j = NULL; - gtk_object_destroy(temp); - } - } - np->helper_path_vec.clear(); -} - -/** updates canvas items from the effect's helper paths */ -void -sp_nodepath_update_helperpaths(Inkscape::NodePath::Path *np) { - //std::map > helper_path_vec; - if (!SP_IS_LPE_ITEM(np->item)) { - g_print ("Only LPEItems can have helperpaths!\n"); - return; - } - - SPLPEItem *lpeitem = SP_LPE_ITEM(np->item); - PathEffectList lpelist = sp_lpe_item_get_effect_list(lpeitem); - - /* The number or type or LPEs may have changed, so we need to clear and recreate our - * helper_path_vec to make sure it is in sync */ - sp_nodepath_destroy_helperpaths(np); - sp_nodepath_create_helperpaths(np); - - for (PathEffectList::iterator i = lpelist.begin(); i != lpelist.end(); ++i) { - Inkscape::LivePathEffect::Effect *lpe = (*i)->lpeobject->get_lpe(); - if (lpe) { - std::vector hpaths = lpe->getHelperPaths(lpeitem); - for (unsigned int j = 0; j < hpaths.size(); ++j) { - SPCurve *curve = new SPCurve(hpaths[j]); - curve->transform(np->i2d); - sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH((np->helper_path_vec[lpe])[j]), curve); - curve = curve->unref(); - } - } - } -} - -/** - * \brief Creates new nodepath from item - * - * If repr_key_in is not NULL, object *has* to be a LivePathEffectObject ! - * - * \todo create proper constructor for nodepath::path, this method returns null a constructor cannot so this cannot be simply converted to constructor. - */ -Inkscape::NodePath::Path *sp_nodepath_new(SPDesktop *desktop, SPObject *object, bool show_handles, const char * repr_key_in, SPItem *item) -{ - if (repr_key_in) { - g_assert(IS_LIVEPATHEFFECT(object)); - } - - 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(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)) { - object = SP_ITEM(grandchild); - break; - } - } - } - } - - SPCurve *curve = sp_nodepath_object_get_curve(object, repr_key_in); - - if (curve == NULL) { - return NULL; - } - - if (curve->get_segment_count() < 1) { - curve->unref(); - return NULL; // prevent crash for one-node paths - } - - //Create new nodepath - Inkscape::NodePath::Path *np = new Inkscape::NodePath::Path(); - if (!np) { - curve->unref(); - return NULL; - } - - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - - // Set defaults - np->desktop = desktop; - np->object = object; - np->subpaths = NULL; - np->selected = NULL; - np->shape_editor = NULL; //Let the shapeeditor that makes this set it - np->local_change = 0; - np->show_handles = show_handles; - np->helper_path = NULL; - np->helperpath_rgba = prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff); - np->helperpath_width = 1.0; - np->curve = curve->copy(); - np->show_helperpath = prefs->getBool("/tools/nodes/show_helperpath"); - if (SP_IS_LPE_ITEM(object)) { - Inkscape::LivePathEffect::Effect *lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(object)); - if (lpe && lpe->isVisible() && lpe->showOrigPath()) { - np->show_helperpath = true; - } - } - np->straight_path = false; - if (IS_LIVEPATHEFFECT(object) && item) { - np->item = item; - } else { - np->item = SP_ITEM(object); - } - - np->drag_origin_mouse = Geom::Point(NR_HUGE, NR_HUGE); - - // we need to update item's transform from the repr here, - // because they may be out of sync when we respond - // to a change in repr by regenerating nodepath --bb - sp_object_read_attr(SP_OBJECT(np->item), "transform"); - - np->i2d = sp_item_i2d_affine(np->item); - np->d2i = np->i2d.inverse(); - - np->repr = repr; - if (repr_key_in) { // apparently 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::Effect * lpe = LIVEPATHEFFECT(object)->get_lpe(); - if (!lpe) { - g_error("sp_nodepath_new: lpeobject without real lpe passed as argument!"); - delete np; - } - Inkscape::LivePathEffect::Parameter *lpeparam = lpe->getParameter(repr_key_in); - if (lpeparam) { - lpeparam->param_setup_nodepath(np); - } - } else { - np->repr_nodetypes_key = g_strdup("sodipodi:nodetypes"); - if ( sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(np->object)) ) { - np->repr_key = g_strdup("inkscape:original-d"); - - Inkscape::LivePathEffect::Effect* lpe = sp_lpe_item_get_current_lpe(SP_LPE_ITEM(np->object)); - if (lpe) { - //lpe->setup_nodepath(np); - } - } else { - np->repr_key = g_strdup("d"); - } - } - - /* Calculate length of the nodetype string. The closing/starting point for closed paths is counted twice. - * So for example a closed rectangle has a nodetypestring of length 5. - * To get the correct count, one can count all segments in the paths, and then add the total number of (non-empty) paths. */ - Geom::PathVector pathv_sanitized = pathv_to_linear_and_cubic_beziers(np->curve->get_pathvector()); - np->curve->set_pathvector(pathv_sanitized); - guint length = np->curve->get_segment_count(); - for (Geom::PathVector::const_iterator pit = pathv_sanitized.begin(); pit != pathv_sanitized.end(); ++pit) { - length += pit->empty() ? 0 : 1; - } - - gchar const *nodetypes = np->repr->attribute(np->repr_nodetypes_key); - Inkscape::NodePath::NodeType *typestr = parse_nodetypes(nodetypes, length); - - // create the subpath(s) from the bpath - subpaths_from_pathvector(np, pathv_sanitized, typestr); - - // reverse the list, because sp_nodepath_subpath_new() used g_list_prepend instead of append (for speed) - np->subpaths = g_list_reverse(np->subpaths); - - delete[] typestr; - curve->unref(); - - // Draw helper curve - if (np->show_helperpath) { - np->helper_path = sp_nodepath_make_helper_item(np, /*desktop, */np->curve, true, np->helperpath_rgba); - } - - sp_nodepath_create_helperpaths(np); - - return np; -} - -/** - * Destroys nodepath's subpaths, then itself, also tell parent ShapeEditor about it. - */ -Inkscape::NodePath::Path::~Path() { - while (this->subpaths) { - sp_nodepath_subpath_destroy((Inkscape::NodePath::SubPath *) this->subpaths->data); - } - - //Inform the ShapeEditor that made me, if any, that I am gone. - if (this->shape_editor) - this->shape_editor->nodepath_destroyed(); - - g_assert(!this->selected); - - if (this->helper_path) { - GtkObject *temp = this->helper_path; - this->helper_path = NULL; - gtk_object_destroy(temp); - } - if (this->curve) { - this->curve->unref(); - this->curve = NULL; - } - - if (this->repr_key) { - g_free(this->repr_key); - this->repr_key = NULL; - } - if (this->repr_nodetypes_key) { - g_free(this->repr_nodetypes_key); - this->repr_nodetypes_key = NULL; - } - - sp_nodepath_destroy_helperpaths(this); - - this->desktop = NULL; -} - -/** - * Return the node count of a given NodeSubPath. - */ -static gint sp_nodepath_subpath_get_node_count(Inkscape::NodePath::SubPath *subpath) -{ - int nodeCount = 0; - - if (subpath) { - nodeCount = g_list_length(subpath->nodes); - } - - return nodeCount; -} - -/** - * Return the node count of a given NodePath. - */ -static gint sp_nodepath_get_node_count(Inkscape::NodePath::Path *np) -{ - gint nodeCount = 0; - if (np) { - for (GList *item = np->subpaths ; item ; item=item->next) { - Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *)item->data; - nodeCount += g_list_length(subpath->nodes); - } - } - return nodeCount; -} - -/** - * Return the subpath count of a given NodePath. - */ -static gint sp_nodepath_get_subpath_count(Inkscape::NodePath::Path *np) -{ - gint nodeCount = 0; - if (np) { - nodeCount = g_list_length(np->subpaths); - } - return nodeCount; -} - -/** - * Return the selected node count of a given NodePath. - */ -static gint sp_nodepath_selection_get_node_count(Inkscape::NodePath::Path *np) -{ - gint nodeCount = 0; - if (np) { - nodeCount = g_list_length(np->selected); - } - return nodeCount; -} - -/** - * 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) -{ - gint nodeCount = 0; - if (np && np->selected) { - if (!np->selected->next) { - nodeCount = 1; - } else { - for (GList *spl = np->subpaths; spl != NULL; spl = spl->next) { - Inkscape::NodePath::SubPath *subpath = static_cast(spl->data); - for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) { - Inkscape::NodePath::Node *node = static_cast(nl->data); - if (node->selected) { - nodeCount++; - break; - } - } - } - } - } - return nodeCount; -} - -/** - * Clean up a nodepath after editing. - * - * Currently we are deleting trivial subpaths. - */ -static void sp_nodepath_cleanup(Inkscape::NodePath::Path *nodepath) -{ - GList *badSubPaths = NULL; - - //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 && !sp->closed) || (sp_nodepath_subpath_get_node_count(sp)<1 && sp->closed)) - badSubPaths = g_list_append(badSubPaths, sp); - } - - //Delete them. This second step is because sp_nodepath_subpath_destroy() - //also removes the subpath from nodepath->subpaths - for (GList *l = badSubPaths; l ; l=l->next) { - Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *)l->data; - sp_nodepath_subpath_destroy(sp); - } - - g_list_free(badSubPaths); -} - -/** - * Create new nodepaths from pathvector, make it subpaths of np. - * \param t The node type array. - */ -static void subpaths_from_pathvector(Inkscape::NodePath::Path *np, Geom::PathVector const & pathv, Inkscape::NodePath::NodeType const *t) -{ - guint i = 0; // index into node type array - for (Geom::PathVector::const_iterator pit = pathv.begin(); pit != pathv.end(); ++pit) { - if (pit->empty()) - continue; // don't add single knot paths - - Inkscape::NodePath::SubPath *sp = sp_nodepath_subpath_new(np); - - Geom::Point ppos = pit->initialPoint() * np->i2d; - NRPathcode pcode = NR_MOVETO; - - /* Johan: Note that this is pretty arcane code. I am pretty sure it is working correctly, be very certain to change it! (better to just rewrite this whole method)*/ - for (Geom::Path::const_iterator cit = pit->begin(); cit != pit->end_closed(); ++cit) { - if( dynamic_cast(&*cit) || - dynamic_cast(&*cit) || - dynamic_cast(&*cit) ) - { - Geom::Point pos = cit->initialPoint() * (Geom::Matrix)np->i2d; - sp_nodepath_node_new(sp, NULL, t[i++], pcode, &ppos, &pos, &pos); - - ppos = cit->finalPoint() * (Geom::Matrix)np->i2d; - pcode = NR_LINETO; - } - else if(Geom::CubicBezier const *cubic_bezier = dynamic_cast(&*cit)) { - std::vector points = cubic_bezier->points(); - Geom::Point pos = points[0] * (Geom::Matrix)np->i2d; - Geom::Point npos = points[1] * (Geom::Matrix)np->i2d; - sp_nodepath_node_new(sp, NULL, t[i++], pcode, &ppos, &pos, &npos); - - ppos = points[2] * (Geom::Matrix)np->i2d; - pcode = NR_CURVETO; - } - } - - if (pit->closed()) { - // Add last knot (because sp_nodepath_subpath_close kills the last knot) - /* Remember that last closing segment is always a lineto, but its length can be zero if the path is visually closed already - * If the length is zero, don't add it to the nodepath. */ - Geom::Curve const &closing_seg = pit->back_closed(); - // Don't use !closing_seg.isDegenerate() as it is too precise, and does not account for floating point rounding probs (LP bug #257289) - if ( ! are_near(closing_seg.initialPoint(), closing_seg.finalPoint()) ) { - Geom::Point pos = closing_seg.finalPoint() * (Geom::Matrix)np->i2d; - sp_nodepath_node_new(sp, NULL, t[i++], NR_LINETO, &pos, &pos, &pos); - } - - sp_nodepath_subpath_close(sp); - } - } -} - -/** - * Convert from sodipodi:nodetypes to new style type array. - */ -static -Inkscape::NodePath::NodeType * parse_nodetypes(gchar const *types, guint length) -{ - Inkscape::NodePath::NodeType *typestr = new Inkscape::NodePath::NodeType[length + 1]; - - guint pos = 0; - - if (types) { - for (guint i = 0; types[i] && ( i < length ); i++) { - while ((types[i] > '\0') && (types[i] <= ' ')) i++; - if (types[i] != '\0') { - switch (types[i]) { - case 's': - typestr[pos++] =Inkscape::NodePath::NODE_SMOOTH; - break; - case 'a': - typestr[pos++] =Inkscape::NodePath::NODE_AUTO; - break; - case 'z': - typestr[pos++] =Inkscape::NodePath::NODE_SYMM; - break; - case 'c': - typestr[pos++] =Inkscape::NodePath::NODE_CUSP; - break; - default: - typestr[pos++] =Inkscape::NodePath::NODE_NONE; - break; - } - } - } - } - - while (pos < length) { - typestr[pos++] = Inkscape::NodePath::NODE_NONE; - } - - return typestr; -} - -/** - * Make curve out of nodepath, write it into that nodepath's SPShape item so that display is - * updated but repr is not (for speed). Used during curve and node drag. - */ -static void update_object(Inkscape::NodePath::Path *np) -{ - g_assert(np); - - np->curve->unref(); - np->curve = create_curve(np); - - sp_nodepath_set_curve(np, np->curve); - - if (np->show_helperpath) { - SPCurve * helper_curve = np->curve->copy(); - helper_curve->transform(np->i2d); - sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve); - helper_curve->unref(); - } - - // updating helperpaths of LPEItems is now done in sp_lpe_item_update(); - //sp_nodepath_update_helperpaths(np); - - // now that nodepath and knotholder can be enabled simultaneously, we must update the knotholder, too - // TODO: this should be done from ShapeEditor!! nodepath should be oblivious of knotholder! - np->shape_editor->update_knotholder(); -} - -/** - * Update XML path node with data from path object. - */ -static void update_repr_internal(Inkscape::NodePath::Path *np) -{ - g_assert(np); - - Inkscape::XML::Node *repr = np->object->repr; - - np->curve->unref(); - np->curve = create_curve(np); - - gchar *typestr = create_typestr(np); - gchar *svgpath = sp_svg_write_path(np->curve->get_pathvector()); - - // 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(np->repr_key, svgpath); - } - - if (repr->attribute(np->repr_nodetypes_key) == NULL || strcmp(typestr, repr->attribute(np->repr_nodetypes_key))) { // nodetypes changed - np->local_change++; - repr->setAttribute(np->repr_nodetypes_key, typestr); - } - - g_free(svgpath); - g_free(typestr); - - if (np->show_helperpath) { - SPCurve * helper_curve = np->curve->copy(); - helper_curve->transform(np->i2d); - sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve); - helper_curve->unref(); - } - - // TODO: do we need this call here? after all, update_object() should have been called just before - //sp_nodepath_update_helperpaths(np); -} - -/** - * Update XML path node with data from path object, commit changes forever. - */ -void sp_nodepath_update_repr(Inkscape::NodePath::Path *np, const gchar *annotation) -{ - //fixme: np can be NULL, so check before proceeding - g_return_if_fail(np != NULL); - - 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, const gchar *annotation) -{ - update_repr_internal(np); - sp_document_maybe_done(sp_desktop_document(np->desktop), key, SP_VERB_CONTEXT_NODE, - annotation); -} - -/** - * Make duplicate of path, replace corresponding XML node in tree, commit. - */ -static void stamp_repr(Inkscape::NodePath::Path *np) -{ - g_assert(np); - - 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(); - // remember parent - Inkscape::XML::Node *parent = sp_repr_parent(old_repr); - - SPCurve *curve = create_curve(np); - gchar *typestr = create_typestr(np); - - gchar *svgpath = sp_svg_write_path(curve->get_pathvector()); - - 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_desktop_document(np->desktop), SP_VERB_CONTEXT_NODE, - _("Stamp")); - - Inkscape::GC::release(new_repr); - g_free(svgpath); - g_free(typestr); - curve->unref(); -} - -/** - * Create curve from path. - */ -static SPCurve *create_curve(Inkscape::NodePath::Path *np) -{ - SPCurve *curve = new SPCurve(); - - for (GList *spl = np->subpaths; spl != NULL; spl = spl->next) { - Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *) spl->data; - curve->moveto(sp->first->pos * np->d2i); - Inkscape::NodePath::Node *n = sp->first->n.other; - while (n) { - Geom::Point const end_pt = n->pos * np->d2i; - if (!IS_FINITE(n->pos[0]) || !IS_FINITE(n->pos[1])){ - g_message("niet finite"); - } - switch (n->code) { - case NR_LINETO: - curve->lineto(end_pt); - break; - case NR_CURVETO: - curve->curveto(n->p.other->n.pos * np->d2i, - n->p.pos * np->d2i, - end_pt); - break; - default: - g_assert_not_reached(); - break; - } - if (n != sp->last) { - n = n->n.other; - } else { - n = NULL; - } - } - if (sp->closed) { - curve->closepath(); - } - } - - return curve; -} - -/** - * Convert path type string to sodipodi:nodetypes style. - */ -static gchar *create_typestr(Inkscape::NodePath::Path *np) -{ - gchar *typestr = g_new(gchar, 32); - gint len = 32; - gint pos = 0; - - for (GList *spl = np->subpaths; spl != NULL; spl = spl->next) { - Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *) spl->data; - - if (pos >= len) { - typestr = g_renew(gchar, typestr, len + 32); - len += 32; - } - - typestr[pos++] = 'c'; - - Inkscape::NodePath::Node *n; - n = sp->first->n.other; - while (n) { - gchar code; - - switch (n->type) { - case Inkscape::NodePath::NODE_CUSP: - code = 'c'; - break; - case Inkscape::NodePath::NODE_SMOOTH: - code = 's'; - break; - case Inkscape::NodePath::NODE_AUTO: - code = 'a'; - break; - case Inkscape::NodePath::NODE_SYMM: - code = 'z'; - break; - default: - g_assert_not_reached(); - code = '\0'; - break; - } - - if (pos >= len) { - typestr = g_renew(gchar, typestr, len + 32); - len += 32; - } - - typestr[pos++] = code; - - if (n != sp->last) { - n = n->n.other; - } else { - n = NULL; - } - } - } - - if (pos >= len) { - typestr = g_renew(gchar, typestr, len + 1); - len += 1; - } - - typestr[pos++] = '\0'; - - return typestr; -} - -// Returns different message contexts depending on the current context. This function should only -// be called when ec is either a SPNodeContext or SPLPEToolContext, thus we return NULL in all -// other cases. -static Inkscape::MessageContext * -get_message_context(SPEventContext *ec) -{ - Inkscape::MessageContext *mc = 0; - - if (SP_IS_NODE_CONTEXT(ec)) { - mc = SP_NODE_CONTEXT(ec)->_node_message_context; - } else if (SP_IS_LPETOOL_CONTEXT(ec)) { - mc = SP_LPETOOL_CONTEXT(ec)->_lpetool_message_context; - } else { - g_warning ("Nodepath should only be present in Node tool or Geometric tool."); - } - - return mc; -} - -/** - \brief Fills node and handle positions for three nodes, splitting line - marked by end at distance t. - */ -static void sp_nodepath_line_midpoint(Inkscape::NodePath::Node *new_path,Inkscape::NodePath::Node *end, gdouble t) -{ - g_assert(new_path != NULL); - g_assert(end != NULL); - - g_assert(end->p.other == new_path); - Inkscape::NodePath::Node *start = new_path->p.other; - g_assert(start); - - if (end->code == NR_LINETO) { - new_path->type =Inkscape::NodePath::NODE_CUSP; - new_path->code = NR_LINETO; - 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; - gdouble s = 1 - t; - for (int dim = 0; dim < 2; dim++) { - Geom::Coord const f000 = start->pos[dim]; - Geom::Coord const f001 = start->n.pos[dim]; - Geom::Coord const f011 = end->p.pos[dim]; - Geom::Coord const f111 = end->pos[dim]; - Geom::Coord const f00t = s * f000 + t * f001; - Geom::Coord const f01t = s * f001 + t * f011; - Geom::Coord const f11t = s * f011 + t * f111; - Geom::Coord const f0tt = s * f00t + t * f01t; - Geom::Coord const f1tt = s * f01t + t * f11t; - Geom::Coord const fttt = s * f0tt + t * f1tt; - start->n.pos[dim] = f00t; - new_path->p.pos[dim] = f0tt; - new_path->pos[dim] = fttt; - new_path->n.pos[dim] = f1tt; - end->p.pos[dim] = f11t; - } - } -} - -/** - * Adds new node on direct line between two nodes, activates handles of all - * three nodes. - */ -static Inkscape::NodePath::Node *sp_nodepath_line_add_node(Inkscape::NodePath::Node *end, gdouble t) -{ - g_assert(end); - g_assert(end->subpath); - g_assert(g_list_find(end->subpath->nodes, end)); - - Inkscape::NodePath::Node *start = end->p.other; - g_assert( start->n.other == end ); - Inkscape::NodePath::Node *newnode = sp_nodepath_node_new(end->subpath, - end, - (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; -} - -/** -\brief Break the path at the node: duplicate the argument node, start a new subpath with the duplicate, and copy all nodes after the argument node to it -*/ -static Inkscape::NodePath::Node *sp_nodepath_node_break(Inkscape::NodePath::Node *node) -{ - g_assert(node); - g_assert(node->subpath); - g_assert(g_list_find(node->subpath->nodes, node)); - - Inkscape::NodePath::Node* result = 0; - Inkscape::NodePath::SubPath *sp = node->subpath; - Inkscape::NodePath::Path *np = sp->nodepath; - - if (sp->closed) { - sp_nodepath_subpath_open(sp, node); - result = sp->first; - } else if ( (node == sp->first) || (node == sp->last ) ){ - // no break for end nodes - result = 0; - } else { - // create a new subpath - Inkscape::NodePath::SubPath *newsubpath = sp_nodepath_subpath_new(np); - - // duplicate the break node as start of the new subpath - Inkscape::NodePath::Node *newnode = sp_nodepath_node_new(newsubpath, NULL, - static_cast(node->type), - NR_MOVETO, &node->pos, &node->pos, &node->n.pos); - - // attach rest of curve to new node - g_assert(node->n.other); - newnode->n.other = node->n.other; node->n.other = NULL; - newnode->n.other->p.other = newnode; - newsubpath->last = sp->last; - sp->last = node; - node = newnode; - while (node->n.other) { - node = node->n.other; - node->subpath = newsubpath; - sp->nodes = g_list_remove(sp->nodes, node); - newsubpath->nodes = g_list_prepend(newsubpath->nodes, node); - } - - - result = newnode; - } - return result; -} - -/** - * Duplicate node and connect to neighbours. - */ -static Inkscape::NodePath::Node *sp_nodepath_node_duplicate(Inkscape::NodePath::Node *node) -{ - g_assert(node); - g_assert(node->subpath); - g_assert(g_list_find(node->subpath->nodes, node)); - - Inkscape::NodePath::SubPath *sp = node->subpath; - - NRPathcode code = (NRPathcode) node->code; - if (code == NR_MOVETO) { // if node is the endnode, - node->code = NR_LINETO; // new one is inserted before it, so change that to line - } - - Inkscape::NodePath::Node *newnode = sp_nodepath_node_new(sp, node, (Inkscape::NodePath::NodeType)node->type, code, &node->p.pos, &node->pos, &node->n.pos); - - if (!node->n.other || !node->p.other) { // if node is an endnode, select it - return node; - } else { - return newnode; // otherwise select the newly created node - } -} - -static void sp_node_handle_mirror_n_to_p(Inkscape::NodePath::Node *node) -{ - node->p.pos = (node->pos + (node->pos - node->n.pos)); -} - -static void sp_node_handle_mirror_p_to_n(Inkscape::NodePath::Node *node) -{ - node->n.pos = (node->pos + (node->pos - node->p.pos)); -} - -/** - * Change line type at node, with side effects on neighbours. - */ -static void sp_nodepath_set_line_type(Inkscape::NodePath::Node *end, NRPathcode code) -{ - g_assert(end); - g_assert(end->subpath); - g_assert(end->p.other); - - if (end->code != static_cast(code) ) { - Inkscape::NodePath::Node *start = end->p.other; - - end->code = code; - - if (code == NR_LINETO) { - 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) { - sp_nodepath_set_node_type(end, Inkscape::NodePath::NODE_CUSP); - } - } - - if (start->type == Inkscape::NodePath::NODE_AUTO) - start->type = Inkscape::NodePath::NODE_SMOOTH; - if (end->type == Inkscape::NodePath::NODE_AUTO) - end->type = Inkscape::NodePath::NODE_SMOOTH; - - start->n.pos = start->pos; - end->p.pos = end->pos; - - sp_node_adjust_handle(start, -1); - sp_node_adjust_handle(end, 1); - - } else { - Geom::Point delta = end->pos - start->pos; - start->n.pos = start->pos + delta / 3; - end->p.pos = end->pos - delta / 3; - sp_node_adjust_handle(start, 1); - sp_node_adjust_handle(end, -1); - } - - sp_node_update_handles(start); - sp_node_update_handles(end); - } -} - -static void -sp_nodepath_update_node_knot(Inkscape::NodePath::Node *node) -{ - if (node->type == Inkscape::NodePath::NODE_CUSP) { - node->knot->setShape (SP_KNOT_SHAPE_DIAMOND); - node->knot->setSize (node->selected? 11 : 9); - sp_knot_update_ctrl(node->knot); - } else if (node->type == Inkscape::NodePath::NODE_AUTO) { - node->knot->setShape (SP_KNOT_SHAPE_CIRCLE); - node->knot->setSize (node->selected? 11 : 9); - sp_knot_update_ctrl(node->knot); - } else { - node->knot->setShape (SP_KNOT_SHAPE_SQUARE); - node->knot->setSize (node->selected? 9 : 7); - sp_knot_update_ctrl(node->knot); - } -} - - -/** - * Change node type, and its handles accordingly. - */ -static Inkscape::NodePath::Node *sp_nodepath_set_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type) -{ - g_assert(node); - g_assert(node->subpath); - - if ((node->p.other != NULL) && (node->n.other != NULL)) { - if ((node->code == NR_LINETO) && (node->n.other->code == NR_LINETO)) { - type =Inkscape::NodePath::NODE_CUSP; - } - } - - node->type = type; - - sp_nodepath_update_node_knot(node); - - // if one of handles is mouseovered, preserve its position - if (node->p.knot && SP_KNOT_IS_MOUSEOVER(node->p.knot)) { - sp_node_adjust_handle(node, 1); - } else if (node->n.knot && SP_KNOT_IS_MOUSEOVER(node->n.knot)) { - sp_node_adjust_handle(node, -1); - } else { - sp_node_adjust_handles(node); - } - - sp_node_update_handles(node); - - sp_nodepath_update_statusbar(node->subpath->nodepath); - - return node; -} - -bool -sp_node_side_is_line (Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *side) -{ -// TODO clean up multiple returns - Inkscape::NodePath::Node *othernode = side->other; - if (!othernode) - return false; - NRPathcode const code = sp_node_path_code_from_side(node, side); - if (code == NR_LINETO) - return true; - Inkscape::NodePath::NodeSide *other_to_me = NULL; - if (&node->p == side) { - other_to_me = &othernode->n; - } else if (&node->n == side) { - other_to_me = &othernode->p; - } - if (!other_to_me) - return false; - bool is_line = - (Geom::L2(othernode->pos - other_to_me->pos) < 1e-6 && - Geom::L2(node->pos - side->pos) < 1e-6); - return is_line; -} - -/** - * Same as sp_nodepath_set_node_type(), but also converts, if necessary, adjacent segments from - * lines to curves. If adjacent to one line segment, pulls out or rotates opposite handle to align - * with that segment, procucing half-smooth node. If already half-smooth, pull out the second handle too. - * If already cusp and set to cusp, retracts handles. -*/ -void sp_nodepath_convert_node_type(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeType type) -{ - if (type == Inkscape::NodePath::NODE_AUTO) { - if (node->p.other != NULL) - node->code = NR_CURVETO; - if (node->n.other != NULL) - node->n.other->code = NR_CURVETO; - } - - if (type == Inkscape::NodePath::NODE_SYMM || type == Inkscape::NodePath::NODE_SMOOTH) { - -/* - Here's the algorithm of converting node to smooth (Shift+S or toolbar button), in pseudocode: - - if (two_handles) { - // do nothing, adjust_handles called via set_node_type will line them up - } else if (one_handle) { - if (opposite_to_handle_is_line) { - if (lined_up) { - // already half-smooth; pull opposite handle too making it fully smooth - } else { - // do nothing, adjust_handles will line the handle up, producing a half-smooth node - } - } else { - // pull opposite handle in line with the existing one - } - } else if (no_handles) { - if (both_segments_are_lines - OR both_segments_are_curves - OR one_is_line_but_the_curveside_node_is_selected_and_has_two_handles) { - //pull both handles - } else { - // pull the handle opposite to line segment, making node half-smooth - } - } -*/ - bool p_has_handle = (Geom::L2(node->pos - node->p.pos) > 1e-6); - bool n_has_handle = (Geom::L2(node->pos - node->n.pos) > 1e-6); - bool p_is_line = sp_node_side_is_line(node, &node->p); - bool n_is_line = sp_node_side_is_line(node, &node->n); - -#define NODE_HAS_BOTH_HANDLES(node) ((Geom::L2(node->pos - node->n.pos) > 1e-6) && (Geom::L2(node->pos - node->p.pos) > 1e-6)) - - if (p_has_handle && n_has_handle) { - // do nothing, adjust_handles will line them up - } else if (p_has_handle || n_has_handle) { - if (p_has_handle && n_is_line) { - Radial line (node->n.other->pos - node->pos); - Radial handle (node->pos - node->p.pos); - if (fabs(line.a - handle.a) < 1e-3) { // lined up - // already half-smooth; pull opposite handle too making it fully smooth - node->n.other->code = NR_CURVETO; - node->n.pos = node->pos + (node->n.other->pos - node->pos) / 3; - } else { - // do nothing, adjust_handles will line the handle up, producing a half-smooth node - } - } else if (n_has_handle && p_is_line) { - Radial line (node->p.other->pos - node->pos); - Radial handle (node->pos - node->n.pos); - if (fabs(line.a - handle.a) < 1e-3) { // lined up - // already half-smooth; pull opposite handle too making it fully smooth - node->code = NR_CURVETO; - node->p.pos = node->pos + (node->p.other->pos - node->pos) / 3; - } else { - // do nothing, adjust_handles will line the handle up, producing a half-smooth node - } - } else if (p_has_handle && node->n.other) { - // pull n handle - node->n.other->code = NR_CURVETO; - double len = (type == Inkscape::NodePath::NODE_SYMM)? - Geom::L2(node->p.pos - node->pos) : - Geom::L2(node->n.other->pos - node->pos) / 3; - node->n.pos = node->pos - (len / Geom::L2(node->p.pos - node->pos)) * (node->p.pos - node->pos); - } else if (n_has_handle && node->p.other) { - // pull p handle - node->code = NR_CURVETO; - double len = (type == Inkscape::NodePath::NODE_SYMM)? - Geom::L2(node->n.pos - node->pos) : - Geom::L2(node->p.other->pos - node->pos) / 3; - node->p.pos = node->pos - (len / Geom::L2(node->n.pos - node->pos)) * (node->n.pos - node->pos); - } - } else if (!p_has_handle && !n_has_handle) { - if ((p_is_line && n_is_line) || (!p_is_line && node->p.other && !n_is_line && node->n.other) || - (n_is_line && node->p.other && node->p.other->selected && NODE_HAS_BOTH_HANDLES(node->p.other)) || - (p_is_line && node->n.other && node->n.other->selected && NODE_HAS_BOTH_HANDLES(node->n.other)) - ) { - // no handles, but: both segments are either lines or curves; or: one is line and the - // node at the other side is selected (so it was just smoothed too!) and now has both - // handles: then pull both handles here - - // convert both to curves: - node->code = NR_CURVETO; - node->n.other->code = NR_CURVETO; - - sp_node_adjust_handles_auto(node); - } else { - // pull the handle opposite to line segment, making it half-smooth - if (p_is_line && node->n.other) { - if (type != Inkscape::NodePath::NODE_SYMM) { - // pull n handle - node->n.other->code = NR_CURVETO; - double len = Geom::L2(node->n.other->pos - node->pos) / 3; - node->n.pos = node->pos + (len / Geom::L2(node->p.other->pos - node->pos)) * (node->p.other->pos - node->pos); - } - } else if (n_is_line && node->p.other) { - if (type != Inkscape::NodePath::NODE_SYMM) { - // pull p handle - node->code = NR_CURVETO; - double len = Geom::L2(node->p.other->pos - node->pos) / 3; - node->p.pos = node->pos + (len / Geom::L2(node->n.other->pos - node->pos)) * (node->n.other->pos - node->pos); - } - } - } - } - } else if (type == Inkscape::NodePath::NODE_CUSP && node->type == Inkscape::NodePath::NODE_CUSP) { - // cusping a cusp: retract nodes - node->p.pos = node->pos; - node->n.pos = node->pos; - } - - sp_nodepath_set_node_type (node, type); -} - -/** - * Move node to point, and adjust its and neighbouring handles. - */ -void sp_node_moveto(Inkscape::NodePath::Node *node, Geom::Point p) -{ - if (node->type == Inkscape::NodePath::NODE_AUTO) { - node->pos = p; - sp_node_adjust_handles_auto(node); - } else { - Geom::Point delta = p - node->pos; - node->pos = p; - - node->p.pos += delta; - node->n.pos += delta; - } - - Inkscape::NodePath::Node *node_p = NULL; - Inkscape::NodePath::Node *node_n = NULL; - - if (node->p.other) { - if (sp_node_side_is_line(node, &node->p)) { - sp_node_adjust_handle(node, 1); - sp_node_adjust_handle(node->p.other, -1); - node_p = node->p.other; - } - if (!node->p.other->selected && node->p.other->type == Inkscape::NodePath::NODE_AUTO) { - sp_node_adjust_handles_auto(node->p.other); - node_p = node->p.other; - } - } - if (node->n.other) { - if (sp_node_side_is_line(node, &node->n)) { - sp_node_adjust_handle(node, -1); - sp_node_adjust_handle(node->n.other, 1); - node_n = node->n.other; - } - if (!node->n.other->selected && node->n.other->type == Inkscape::NodePath::NODE_AUTO) { - sp_node_adjust_handles_auto(node->n.other); - node_n = node->n.other; - } - } - - // this function is only called from batch movers that will update display at the end - // 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); - } -} - -/** - * Call sp_node_moveto() for node selection and handle possible snapping. - */ -static void sp_nodepath_selected_nodes_move(Inkscape::NodePath::Path *nodepath, Geom::Coord dx, Geom::Coord dy, - bool const snap, bool constrained = false, - Inkscape::Snapper::ConstraintLine const &constraint = Geom::Point()) -{ - Geom::Point delta(dx, dy); - Geom::Point best_pt = delta; - Inkscape::SnappedPoint best; - - if (snap) { - /* When dragging a (selected) node, it should only snap to other nodes (i.e. unselected nodes), and - * not to itself. The snapper however can not tell which nodes are selected and which are not, so we - * must provide that information. */ - - // Build a list of the unselected nodes to which the snapper should snap - std::vector unselected_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) { - unselected_nodes.push_back(Inkscape::SnapCandidatePoint(node->pos, Inkscape::SNAPSOURCE_UNDEFINED, node->type == Inkscape::NodePath::NODE_SMOOTH ? Inkscape::SNAPTARGET_NODE_SMOOTH : Inkscape::SNAPTARGET_NODE_CUSP)); - } - } - } - - SnapManager &m = nodepath->desktop->namedview->snap_manager; - - // When only the node closest to the mouse pointer is to be snapped - // then we will not even try to snap to other points and discard those immediately - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - bool closest_only = prefs->getBool("/options/snapclosestonly/value", false); - - Inkscape::NodePath::Node *closest_node = NULL; - Geom::Coord closest_dist = NR_HUGE; - - if (closest_only) { - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - Geom::Coord dist = Geom::L2(nodepath->drag_origin_mouse - n->origin); - if (dist < closest_dist) { - closest_node = n; - closest_dist = dist; - } - } - } - - // Iterate through all selected nodes - m.setup(nodepath->desktop, false, nodepath->item, &unselected_nodes); - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - if (!closest_only || n == closest_node) { //try to snap either all selected nodes or only the closest one - Inkscape::SnappedPoint s; - Inkscape::SnapSourceType source_type = (n->type == Inkscape::NodePath::NODE_SMOOTH ? Inkscape::SNAPSOURCE_NODE_SMOOTH : Inkscape::SNAPSOURCE_NODE_CUSP); - if (constrained) { - Inkscape::Snapper::ConstraintLine dedicated_constraint = constraint; - dedicated_constraint.setPoint(n->pos); - s = m.constrainedSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, Inkscape::SnapCandidatePoint(n->pos + delta, source_type), dedicated_constraint); - } else { - s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, Inkscape::SnapCandidatePoint(n->pos + delta, source_type)); - } - - if (s.getSnapped()) { - s.setPointerDistance(Geom::L2(nodepath->drag_origin_mouse - n->origin)); - if (!s.isOtherSnapBetter(best, true)) { - best = s; - best_pt = from_2geom(s.getPoint()) - n->pos; - } - } - } - } - - if (best.getSnapped()) { - nodepath->desktop->snapindicator->set_new_snaptarget(best); - } else { - nodepath->desktop->snapindicator->remove_snaptarget(); - } - } - - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - sp_node_moveto(n, n->pos + best_pt); - } - - // do not update repr here so that node dragging is acceptably fast - 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) -{ - double result = 1; - - if (x >= 1) { - result = 0; - } else if (x <= 0) { - result = 1; - } else { - switch (profile) { - case SCULPT_PROFILE_LINEAR: - result = 1 - x; - break; - case SCULPT_PROFILE_BELL: - result = (0.5 * cos (M_PI * (pow(x, alpha))) + 0.5); - break; - case SCULPT_PROFILE_ELLIPTIC: - result = sqrt(1 - x*x); - break; - default: - g_assert_not_reached(); - } - } - - return result; -} - -double -bezier_length (Geom::Point a, Geom::Point ah, Geom::Point bh, Geom::Point b) -{ - // extremely primitive for now, don't have time to look for the real one - double lower = Geom::L2(b - a); - double upper = Geom::L2(ah - a) + Geom::L2(bh - ah) + Geom::L2(bh - b); - return (lower + upper)/2; -} - -void -sp_nodepath_move_node_and_handles (Inkscape::NodePath::Node *n, Geom::Point delta, Geom::Point delta_n, Geom::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, Geom::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; - - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - guint profile = prefs->getInt("/tools/nodes/sculpting_profile", SCULPT_PROFILE_BELL); - - if (sp_nodepath_selection_get_subpath_count(nodepath) <= 1) { - // Only one subpath has selected nodes: - // 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 + Geom::L2(n_node->n.origin - n_node->origin)) / n_sel_range, alpha, profile) * delta, - sculpt_profile ((n_range - Geom::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 - Geom::L2(p_node->n.origin - p_node->origin)) / p_sel_range, alpha, profile) * delta, - sculpt_profile ((p_range + Geom::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 Geom::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, Geom::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 (Geom::L2(node->origin - n->origin) / direct_range, alpha, profile) * delta, - sculpt_profile (Geom::L2(node->n.origin - n->origin) / direct_range, alpha, profile) * delta, - sculpt_profile (Geom::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(Inkscape::NodePath::Path *nodepath, gdouble dx, gdouble dy) -{ - if (!nodepath) return; - - sp_nodepath_selected_nodes_move(nodepath, dx, dy, false); - - if (dx == 0) { - 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", _("Move nodes horizontally")); - } else { - sp_nodepath_update_repr(nodepath, _("Move nodes")); - } -} - -/** - * Move node selection off screen and commit the change. - */ -void -sp_node_selected_move_screen(SPDesktop *desktop, 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 zoom = desktop->current_zoom(); - gdouble zdx = dx / zoom; - gdouble zdy = dy / zoom; - - if (!nodepath) return; - - sp_nodepath_selected_nodes_move(nodepath, zdx, zdy, false); - - if (dx == 0) { - 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", _("Move nodes horizontally")); - } else { - 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, Geom::Coord val, Geom::Dim2 axis) -{ - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - Geom::Point npos(axis == Geom::X ? val : n->pos[Geom::X], axis == Geom::Y ? val : n->pos[Geom::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 Geom::Nothing - */ -boost::optional sp_node_selected_common_coord (Inkscape::NodePath::Path *nodepath, Geom::Dim2 axis) -{ - boost::optional no_coord; - 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; - Geom::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 { - Geom::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) -{ - if (!side->knot) { - side->knot = sp_knot_new(desktop, _("Node handle: drag to shape the curve; with Ctrl to snap angle; with Alt to lock length; with Shift to rotate both handles")); - - side->knot->setShape (SP_KNOT_SHAPE_CIRCLE); - side->knot->setSize (7); - side->knot->setAnchor (GTK_ANCHOR_CENTER); - side->knot->setFill(KNOT_FILL, KNOT_FILL_HI, KNOT_FILL_HI); - side->knot->setStroke(KNOT_STROKE, KNOT_STROKE_HI, KNOT_STROKE_HI); - sp_knot_update_ctrl(side->knot); - - g_signal_connect(G_OBJECT(side->knot), "clicked", G_CALLBACK(node_handle_clicked), node); - g_signal_connect(G_OBJECT(side->knot), "grabbed", G_CALLBACK(node_handle_grabbed), node); - g_signal_connect(G_OBJECT(side->knot), "ungrabbed", G_CALLBACK(node_handle_ungrabbed), node); - g_signal_connect(G_OBJECT(side->knot), "request", G_CALLBACK(node_handle_request), node); - g_signal_connect(G_OBJECT(side->knot), "moved", G_CALLBACK(node_handle_moved), node); - g_signal_connect(G_OBJECT(side->knot), "event", G_CALLBACK(node_handle_event), node); - } - - if (!side->line) { - side->line = sp_canvas_item_new(sp_desktop_controls(desktop), - SP_TYPE_CTRLLINE, NULL); - } -} - -/** - * Ensure the given handle of the node is visible/invisible, update its screen position - */ -static void sp_node_update_handle(Inkscape::NodePath::Node *node, gint which, gboolean show_handle, bool fire_move_signals) -{ - g_assert(node != NULL); - - Inkscape::NodePath::NodeSide *side = sp_node_get_side(node, which); - NRPathcode code = sp_node_path_code_from_side(node, side); - - show_handle = show_handle && (code == NR_CURVETO) && (Geom::L2(side->pos - node->pos) > 1e-6); - - if (show_handle) { - if (!side->knot) { // No handle knot at all - 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) - 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); - } else { - if (side->knot->pos != to_2geom(side->pos)) { // only if it's really moved - if (fire_move_signals) { - sp_knot_set_position(side->knot, side->pos, 0); // this will set coords of the line as well - } else { - sp_knot_moveto(side->knot, side->pos); - sp_ctrlline_set_coords(SP_CTRLLINE(side->line), node->pos, side->pos); - } - } - if (!SP_KNOT_IS_VISIBLE(side->knot)) { - sp_knot_show(side->knot); - } - } - sp_canvas_item_show(side->line); - } else { - if (side->knot) { - if (SP_KNOT_IS_VISIBLE(side->knot)) { - sp_knot_hide(side->knot); - } - } - if (side->line) { - sp_canvas_item_hide(side->line); - } - } -} - -/** - * Ensure the node itself is visible, its handles and those of the neighbours of the node are - * visible if selected, update their screen positions. If fire_move_signals, move the node and its - * handles so that the corresponding signals are fired, callbacks are activated, and curve is - * updated; otherwise, just move the knots silently (used in batch moves). - */ -static void sp_node_update_handles(Inkscape::NodePath::Node *node, bool fire_move_signals) -{ - g_assert(node != NULL); - - if (!SP_KNOT_IS_VISIBLE(node->knot)) { - sp_knot_show(node->knot); - } - - if (node->knot->pos != to_2geom(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 - sp_knot_moveto(node->knot, node->pos); - } - - gboolean show_handles = node->selected; - if (node->p.other != NULL) { - if (node->p.other->selected) show_handles = TRUE; - } - if (node->n.other != NULL) { - 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); -} - -/** - * Call sp_node_update_handles() for all nodes on subpath. - */ -static void sp_nodepath_subpath_update_handles(Inkscape::NodePath::SubPath *subpath) -{ - g_assert(subpath != NULL); - - for (GList *l = subpath->nodes; l != NULL; l = l->next) { - sp_node_update_handles((Inkscape::NodePath::Node *) l->data); - } -} - -/** - * Call sp_nodepath_subpath_update_handles() for all subpaths of nodepath. - */ -static void sp_nodepath_update_handles(Inkscape::NodePath::Path *nodepath) -{ - g_assert(nodepath != NULL); - - for (GList *l = nodepath->subpaths; l != NULL; l = l->next) { - sp_nodepath_subpath_update_handles((Inkscape::NodePath::SubPath *) l->data); - } -} - -void -sp_nodepath_show_handles(Inkscape::NodePath::Path *nodepath, bool show) -{ - if (nodepath) { - nodepath->show_handles = show; - sp_nodepath_update_handles(nodepath); - } -} - -/** - * Adds all selected nodes in nodepath to list. - */ -void Inkscape::NodePath::Path::selection(std::list &l) -{ - StlConv::list(l, selected); -/// \todo this adds a copying, rework when the selection becomes a stl list -} - -/** - * Align selected nodes on the specified axis. - */ -void sp_nodepath_selected_align(Inkscape::NodePath::Path *nodepath, Geom::Dim2 axis) -{ - if ( !nodepath || !nodepath->selected ) { // no nodepath, or no nodes selected - return; - } - - if ( !nodepath->selected->next ) { // only one node selected - return; - } - Inkscape::NodePath::Node *pNode = reinterpret_cast(nodepath->selected->data); - Geom::Point dest(pNode->pos); - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - pNode = reinterpret_cast(l->data); - if (pNode) { - dest[axis] = pNode->pos[axis]; - sp_node_moveto(pNode, dest); - } - } - - sp_nodepath_update_repr(nodepath, _("Align nodes")); -} - -/// Helper struct. -struct NodeSort -{ - Inkscape::NodePath::Node *_node; - Geom::Coord _coord; - /// \todo use vectorof pointers instead of calling copy ctor - NodeSort(Inkscape::NodePath::Node *node, Geom::Dim2 axis) : - _node(node), _coord(node->pos[axis]) - {} - -}; - -static bool operator<(NodeSort const &a, NodeSort const &b) -{ - return (a._coord < b._coord); -} - -/** - * Distribute selected nodes on the specified axis. - */ -void sp_nodepath_selected_distribute(Inkscape::NodePath::Path *nodepath, Geom::Dim2 axis) -{ - if ( !nodepath || !nodepath->selected ) { // no nodepath, or no nodes selected - return; - } - - if ( ! (nodepath->selected->next && nodepath->selected->next->next) ) { // less than 3 nodes selected - return; - } - - Inkscape::NodePath::Node *pNode = reinterpret_cast(nodepath->selected->data); - std::vector sorted; - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - pNode = reinterpret_cast(l->data); - if (pNode) { - NodeSort n(pNode, axis); - sorted.push_back(n); - //dest[axis] = pNode->pos[axis]; - //sp_node_moveto(pNode, dest); - } - } - std::sort(sorted.begin(), sorted.end()); - unsigned int len = sorted.size(); - //overall bboxes span - float dist = (sorted.back()._coord - - sorted.front()._coord); - //new distance between each bbox - float step = (dist) / (len - 1); - float pos = sorted.front()._coord; - for ( std::vector ::iterator it(sorted.begin()); - it < sorted.end(); - it ++ ) - { - Geom::Point dest((*it)._node->pos); - dest[axis] = pos; - sp_node_moveto((*it)._node, dest); - pos += step; - } - - sp_nodepath_update_repr(nodepath, _("Distribute nodes")); -} - - -/** - * Call sp_nodepath_line_add_node() for all selected segments. - */ -void -sp_node_selected_add_node(Inkscape::NodePath::Path *nodepath) -{ - 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); - if (t->p.other && t->p.other->selected) { - nl = g_list_prepend(nl, t); - } - } - - 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); - n_added ++; - nl = g_list_remove(nl, t); - } - - /** \todo fixme: adjust ? */ - sp_nodepath_update_handles(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); -} - -/** - * Select segment nearest to point - */ -void -sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, Geom::Point p, bool toggle) -{ - if (!nodepath) { - return; - } - - SPCurve *curve = create_curve(nodepath); // perhaps we can use nodepath->curve here instead? - Geom::PathVector const &pathv = curve->get_pathvector(); - boost::optional pvpos = Geom::nearestPoint(pathv, p); - if (!pvpos) { - g_print ("Possible error?\n"); - return; - } - - // calculate index for nodepath's representation. - unsigned int segment_index = floor(pvpos->t) + 1; - for (unsigned int i = 0; i < pvpos->path_nr; ++i) { - segment_index += pathv[i].size() + 1; - if (pathv[i].closed()) { - segment_index += 1; - } - } - - curve->unref(); - - //find segment to segment - Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(nodepath, segment_index); - - //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; - } - sp_nodepath_node_select(e, (gboolean) toggle, force); - if (e->p.other) - sp_nodepath_node_select(e->p.other, TRUE, force); - - sp_nodepath_update_handles(nodepath); - - sp_nodepath_update_statusbar(nodepath); -} - -/** - * Add a node nearest to point - */ -void -sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, Geom::Point p) -{ - if (!nodepath) { - return; - } - - SPCurve *curve = create_curve(nodepath); // perhaps we can use nodepath->curve here instead? - Geom::PathVector const &pathv = curve->get_pathvector(); - boost::optional pvpos = Geom::nearestPoint(pathv, p); - if (!pvpos) { - g_print ("Possible error?\n"); - return; - } - - // calculate index for nodepath's representation. - double int_part; - double t = std::modf(pvpos->t, &int_part); - unsigned int segment_index = (unsigned int)int_part + 1; - for (unsigned int i = 0; i < pvpos->path_nr; ++i) { - segment_index += pathv[i].size() + 1; - if (pathv[i].closed()) { - segment_index += 1; - } - } - - curve->unref(); - - //find segment to split - Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(nodepath, segment_index); - if (!e) { - return; - } - - //don't know why but t seems to flip for lines - if (sp_node_path_code_from_side(e, sp_node_get_side(e, -1)) == NR_LINETO) { - t = 1.0 - t; - } - - Inkscape::NodePath::Node *n = sp_nodepath_line_add_node(e, t); - sp_nodepath_node_select(n, FALSE, TRUE); - - /* fixme: adjust ? */ - sp_nodepath_update_handles(nodepath); - - sp_nodepath_update_repr(nodepath, _("Add node")); - - sp_nodepath_update_statusbar(nodepath); -} - -/* - * Adjusts a segment so that t moves by a certain delta for dragging - * converts lines to curves - * - * method and idea borrowed from Simon Budig and the GIMP - * cf. app/vectors/gimpbezierstroke.c, gimp_bezier_stroke_point_move_relative() - */ -void -sp_nodepath_curve_drag(Inkscape::NodePath::Path *nodepath, int node, double t, Geom::Point delta) -{ - Inkscape::NodePath::Node *e = sp_nodepath_get_node_by_index(nodepath, 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); - - if (e->type == Inkscape::NodePath::NODE_AUTO) { - e->type = Inkscape::NodePath::NODE_SMOOTH; - sp_nodepath_update_node_knot (e); - } - if (e->p.other->type == Inkscape::NodePath::NODE_AUTO) { - e->p.other->type = Inkscape::NodePath::NODE_SMOOTH; - sp_nodepath_update_node_knot (e->p.other); - } - - /* feel good is an arbitrary parameter that distributes the delta between handles - * if t of the drag point is less than 1/6 distance form the endpoint only - * the corresponding hadle is adjusted. This matches the behavior in GIMP - */ - double feel_good; - if (t <= 1.0 / 6.0) - feel_good = 0; - else if (t <= 0.5) - feel_good = (pow((6 * t - 1) / 2.0, 3)) / 2; - else if (t <= 5.0 / 6.0) - feel_good = (1 - pow((6 * (1-t) - 1) / 2.0, 3)) / 2 + 0.5; - else - feel_good = 1; - - //if we're dragging a line convert it to a curve - if (sp_node_path_code_from_side(e, sp_node_get_side(e, -1))==NR_LINETO) { - sp_nodepath_set_line_type(e, NR_CURVETO); - } - - Geom::Point offsetcoord0 = ((1-feel_good)/(3*t*(1-t)*(1-t))) * delta; - Geom::Point offsetcoord1 = (feel_good/(3*t*t*(1-t))) * delta; - e->p.other->n.pos += offsetcoord0; - e->p.pos += offsetcoord1; - - // adjust handles of adjacent nodes where necessary - sp_node_adjust_handle(e,1); - sp_node_adjust_handle(e->p.other,-1); - - sp_nodepath_update_handles(e->subpath->nodepath); - - update_object(e->subpath->nodepath); - - sp_nodepath_update_statusbar(e->subpath->nodepath); -} - - -/** - * Call sp_nodepath_break() for all selected segments. - */ -void sp_node_selected_break(Inkscape::NodePath::Path *nodepath) -{ - if (!nodepath) return; - - GList *tempin = g_list_copy(nodepath->selected); - GList *temp = NULL; - for (GList *l = tempin; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - Inkscape::NodePath::Node *nn = sp_nodepath_node_break(n); - if (nn == NULL) continue; // no break, no new node - temp = g_list_prepend(temp, nn); - } - g_list_free(tempin); - - if (temp) { - sp_nodepath_deselect(nodepath); - } - for (GList *l = temp; l != NULL; l = l->next) { - sp_nodepath_node_select((Inkscape::NodePath::Node *) l->data, TRUE, TRUE); - } - - sp_nodepath_update_handles(nodepath); - - sp_nodepath_update_repr(nodepath, _("Break path")); -} - -/** - * Duplicate the selected node(s). - */ -void sp_node_selected_duplicate(Inkscape::NodePath::Path *nodepath) -{ - if (!nodepath) { - return; - } - - GList *temp = NULL; - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - Inkscape::NodePath::Node *nn = sp_nodepath_node_duplicate(n); - if (nn == NULL) continue; // could not duplicate - temp = g_list_prepend(temp, nn); - } - - if (temp) { - sp_nodepath_deselect(nodepath); - } - for (GList *l = temp; l != NULL; l = l->next) { - sp_nodepath_node_select((Inkscape::NodePath::Node *) l->data, TRUE, TRUE); - } - - sp_nodepath_update_handles(nodepath); - - sp_nodepath_update_repr(nodepath, _("Duplicate node")); -} - -/** - * Internal function to join two nodes by merging them into one. - */ -static void do_node_selected_join(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *a, Inkscape::NodePath::Node *b) -{ - /* a and b are endpoints */ - - // if one of the two nodes is mouseovered, fix its position - Geom::Point c; - if (a->knot && SP_KNOT_IS_MOUSEOVER(a->knot)) { - c = a->pos; - } else if (b->knot && SP_KNOT_IS_MOUSEOVER(b->knot)) { - c = b->pos; - } else { - // otherwise, move joined node to the midpoint - c = (a->pos + b->pos) / 2; - } - - if (a->subpath == b->subpath) { - Inkscape::NodePath::SubPath *sp = a->subpath; - sp_nodepath_subpath_close(sp); - sp_node_moveto (sp->first, c); - - sp_nodepath_update_handles(sp->nodepath); - sp_nodepath_update_repr(nodepath, _("Close subpath")); - return; - } - - /* a and b are separate subpaths */ - Inkscape::NodePath::SubPath *sa = a->subpath; - Inkscape::NodePath::SubPath *sb = b->subpath; - Geom::Point p; - Inkscape::NodePath::Node *n; - NRPathcode code; - if (a == sa->first) { - // we will now reverse sa, so that a is its last node, not first, and drop that node - p = sa->first->n.pos; - code = (NRPathcode)sa->first->n.other->code; - // create new subpath - Inkscape::NodePath::SubPath *t = sp_nodepath_subpath_new(sa->nodepath); - // create a first moveto node on it - n = sa->last; - sp_nodepath_node_new(t, NULL,Inkscape::NodePath::NODE_CUSP, NR_MOVETO, &n->n.pos, &n->pos, &n->p.pos); - n = n->p.other; - if (n == sa->first) n = NULL; - while (n) { - // copy the rest of the nodes from sa to t, going backwards - sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos); - n = n->p.other; - if (n == sa->first) n = NULL; - } - // replace sa with t - sp_nodepath_subpath_destroy(sa); - sa = t; - } else if (a == sa->last) { - // a is already last, just drop it - p = sa->last->p.pos; - code = (NRPathcode)sa->last->code; - sp_nodepath_node_destroy(sa->last); - } else { - code = NR_END; - g_assert_not_reached(); - } - - if (b == sb->first) { - // copy all nodes from b to a, forward - sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->first->n.pos); - for (n = sb->first->n.other; n != NULL; n = n->n.other) { - sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->code, &n->p.pos, &n->pos, &n->n.pos); - } - } else if (b == sb->last) { - // copy all nodes from b to a, backward - sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &c, &sb->last->p.pos); - for (n = sb->last->p.other; n != NULL; n = n->p.other) { - sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos); - } - } else { - g_assert_not_reached(); - } - /* and now destroy sb */ - - sp_nodepath_subpath_destroy(sb); - - sp_nodepath_update_handles(sa->nodepath); - - sp_nodepath_update_repr(nodepath, _("Join nodes")); - - sp_nodepath_update_statusbar(nodepath); -} - -/** - * Internal function to join two nodes by adding a segment between them. - */ -static void do_node_selected_join_segment(Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::Node *a, Inkscape::NodePath::Node *b) -{ - if (a->subpath == b->subpath) { - Inkscape::NodePath::SubPath *sp = a->subpath; - - /*similar to sp_nodepath_subpath_close(sp), without the node destruction*/ - sp->closed = TRUE; - - sp->first->p.other = sp->last; - sp->last->n.other = sp->first; - - sp_node_handle_mirror_p_to_n(sp->last); - sp_node_handle_mirror_n_to_p(sp->first); - - sp->first->code = sp->last->code; - sp->first = sp->last; - - sp_nodepath_update_handles(sp->nodepath); - - sp_nodepath_update_repr(nodepath, _("Close subpath by segment")); - - return; - } - - /* a and b are separate subpaths */ - Inkscape::NodePath::SubPath *sa = a->subpath; - Inkscape::NodePath::SubPath *sb = b->subpath; - - Inkscape::NodePath::Node *n; - Geom::Point p; - NRPathcode code; - if (a == sa->first) { - code = (NRPathcode) sa->first->n.other->code; - Inkscape::NodePath::SubPath *t = sp_nodepath_subpath_new(sa->nodepath); - n = sa->last; - sp_nodepath_node_new(t, NULL,Inkscape::NodePath::NODE_CUSP, NR_MOVETO, &n->n.pos, &n->pos, &n->p.pos); - for (n = n->p.other; n != NULL; n = n->p.other) { - sp_nodepath_node_new(t, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos); - } - sp_nodepath_subpath_destroy(sa); - sa = t; - } else if (a == sa->last) { - code = (NRPathcode)sa->last->code; - } else { - code = NR_END; - g_assert_not_reached(); - } - - if (b == sb->first) { - n = sb->first; - sp_node_handle_mirror_p_to_n(sa->last); - sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &n->p.pos, &n->pos, &n->n.pos); - sp_node_handle_mirror_n_to_p(sa->last); - for (n = n->n.other; n != NULL; n = n->n.other) { - sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->code, &n->p.pos, &n->pos, &n->n.pos); - } - } else if (b == sb->last) { - n = sb->last; - sp_node_handle_mirror_p_to_n(sa->last); - sp_nodepath_node_new(sa, NULL,Inkscape::NodePath::NODE_CUSP, code, &p, &n->pos, &n->p.pos); - sp_node_handle_mirror_n_to_p(sa->last); - for (n = n->p.other; n != NULL; n = n->p.other) { - sp_nodepath_node_new(sa, NULL, (Inkscape::NodePath::NodeType)n->type, (NRPathcode)n->n.other->code, &n->n.pos, &n->pos, &n->p.pos); - } - } else { - g_assert_not_reached(); - } - /* and now destroy sb */ - - sp_nodepath_subpath_destroy(sb); - - sp_nodepath_update_handles(sa->nodepath); - - sp_nodepath_update_repr(nodepath, _("Join nodes by segment")); -} - -enum NodeJoinType { NODE_JOIN_ENDPOINTS, NODE_JOIN_SEGMENT }; - -/** - * Internal function to handle joining two nodes. - */ -static void node_do_selected_join(Inkscape::NodePath::Path *nodepath, NodeJoinType mode) -{ - if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses - - if (g_list_length(nodepath->selected) != 2) { - nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, _("To join, you must have two endnodes selected.")); - return; - } - - Inkscape::NodePath::Node *a = (Inkscape::NodePath::Node *) nodepath->selected->data; - 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)) { - // 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 two endnodes selected.")); - return; - } - - switch(mode) { - case NODE_JOIN_ENDPOINTS: - do_node_selected_join(nodepath, a, b); - break; - case NODE_JOIN_SEGMENT: - do_node_selected_join_segment(nodepath, a, b); - break; - } -} - -/** - * Join two nodes by merging them into one. - */ -void sp_node_selected_join(Inkscape::NodePath::Path *nodepath) -{ - node_do_selected_join(nodepath, NODE_JOIN_ENDPOINTS); -} - -/** - * Join two nodes by adding a segment between them. - */ -void sp_node_selected_join_segment(Inkscape::NodePath::Path *nodepath) -{ - node_do_selected_join(nodepath, NODE_JOIN_SEGMENT); -} - -/** - * Delete one or more selected nodes and preserve the shape of the path as much as possible. - */ -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::Path *nodepath = sp->nodepath; - Inkscape::NodePath::Node *sample_cursor = NULL; - 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 - for (Inkscape::NodePath::Node *curr=node->p.other; curr && curr!=node && g_list_find(nodes_to_delete, curr); curr=curr->p.other) { - delete_cursor = curr; - } - - //just delete at the beginning of an open path - if (!delete_cursor->p.other) { - sample_cursor = delete_cursor; - just_delete = true; - } else { - sample_cursor = delete_cursor->p.other; - } - - //calculate points for each segment - int rate = 5; - float period = 1.0 / rate; - std::vector data; - if (!just_delete) { - 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 == sp->last) { - just_delete = true; - break; - } - - //sample points on the contiguous selected segment - Geom::Point *bez; - bez = new Geom::Point [4]; - bez[0] = curr->pos; - bez[1] = curr->n.pos; - bez[2] = curr->n.other->p.pos; - bez[3] = curr->n.other->pos; - for (int i=1; in.other->pos); - - sample_end = curr->n.other; - //break if we've come full circle or hit the end of the selection - if (!g_list_find(nodes_to_delete, curr->n.other) || curr->n.other==sample_cursor) { - break; - } - } - } - - if (!just_delete) { - //calculate the best fitting single segment and adjust the endpoints - Geom::Point *adata; - adata = new Geom::Point [data.size()]; - copy(data.begin(), data.end(), adata); - - Geom::Point *bez; - bez = new Geom::Point [4]; - //would decreasing error create a better fitting approximation? - gdouble error = 1.0; - gint ret; - ret = Geom::bezier_fit_cubic (bez, adata, data.size(), error); - - //if these nodes are smooth or symmetrical, the endpoints will be thrown out of sync. - //make sure these nodes are changed to cusp nodes so that, once the endpoints are moved, - //the resulting nodes behave as expected. - if (sample_cursor->type != Inkscape::NodePath::NODE_CUSP) - sp_nodepath_convert_node_type(sample_cursor, Inkscape::NodePath::NODE_CUSP); - if (sample_end->type != 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; - } else { - delete_cursor = delete_cursor->n.other; - } - nodes_to_delete = g_list_remove(nodes_to_delete, temp); - sp_nodepath_node_destroy(temp); - } - - 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_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(nodepath->desktop); - 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); - } - } - - g_slist_free (nodepaths); -} - -/** - * Delete one or more selected nodes. - */ -void sp_node_selected_delete(Inkscape::NodePath::Path *nodepath) -{ - if (!nodepath) return; - if (!nodepath->selected) return; - - /** \todo fixme: do it the right way */ - while (nodepath->selected) { - Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nodepath->selected->data; - sp_nodepath_node_destroy(node); - } - - - //clean up the nodepath (such as for trivial subpaths) - sp_nodepath_cleanup(nodepath); - - sp_nodepath_update_handles(nodepath); - - // if the entire nodepath is removed, delete the selected object. - if (nodepath->subpaths == NULL || - sp_nodepath_get_node_count(nodepath) < 2) { - SPDocument *document = sp_desktop_document (nodepath->desktop); - sp_selection_delete(nodepath->desktop); - sp_document_done (document, SP_VERB_CONTEXT_NODE, - _("Delete nodes")); - return; - } - - sp_nodepath_update_repr(nodepath, _("Delete nodes")); - - sp_nodepath_update_statusbar(nodepath); -} - -/** - * Delete one or more segments between two selected nodes. - * This is the code for 'split'. - */ -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 - - if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses - - if (g_list_length(nodepath->selected) != 2) { - nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, - _("Select two non-endpoint nodes on a path between which to delete segments.")); - return; - } - - //Selected nodes, not inclusive - Inkscape::NodePath::Node *a = (Inkscape::NodePath::Node *) nodepath->selected->data; - Inkscape::NodePath::Node *b = (Inkscape::NodePath::Node *) nodepath->selected->next->data; - - if ( ( a==b) || //same node - (a->subpath != b->subpath ) || //not the same path - (!a->p.other || !a->n.other) || //one of a's sides does not have a segment - (!b->p.other || !b->n.other) ) //one of b's sides does not have a segment - { - nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, - _("Select two non-endpoint nodes on a path between which to delete segments.")); - return; - } - - //########################################### - //# BEGIN EDITS - //########################################### - //################################## - //# CLOSED PATH - //################################## - if (a->subpath->closed) { - - - gboolean reversed = FALSE; - - //Since we can go in a circle, we need to find the shorter distance. - // a->b or b->a - start = end = NULL; - int distance = 0; - int minDistance = 0; - for (curr = a->n.other ; curr && curr!=a ; curr=curr->n.other) { - if (curr==b) { - //printf("a to b:%d\n", distance); - start = a;//go from a to b - end = b; - minDistance = distance; - //printf("A to B :\n"); - break; - } - distance++; - } - - //try again, the other direction - distance = 0; - for (curr = b->n.other ; curr && curr!=b ; curr=curr->n.other) { - if (curr==a) { - //printf("b to a:%d\n", distance); - if (distance < minDistance) { - start = b; //we go from b to a - end = a; - reversed = TRUE; - //printf("B to A\n"); - } - break; - } - distance++; - } - - - //Copy everything from 'end' to 'start' to a new subpath - Inkscape::NodePath::SubPath *t = sp_nodepath_subpath_new(nodepath); - for (curr=end ; curr ; curr=curr->n.other) { - 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); - if (curr == start) - break; - } - sp_nodepath_subpath_destroy(a->subpath); - - - } - - - - //################################## - //# OPEN PATH - //################################## - else { - - //We need to get the direction of the list between A and B - //Can we walk from a to b? - start = end = NULL; - for (curr = a->n.other ; curr && curr!=a ; curr=curr->n.other) { - if (curr==b) { - start = a; //did it! we go from a to b - end = b; - //printf("A to B\n"); - break; - } - } - if (!start) {//didn't work? let's try the other direction - for (curr = b->n.other ; curr && curr!=b ; curr=curr->n.other) { - if (curr==a) { - start = b; //did it! we go from b to a - end = a; - //printf("B to A\n"); - break; - } - } - } - if (!start) { - nodepath->desktop->messageStack()->flash(Inkscape::ERROR_MESSAGE, - _("Cannot find path between nodes.")); - return; - } - - - - //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) { - 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); - } - - //Now let us do our deletion. Since the tail has been saved, go all the way to the end of the list - for (curr = start->n.other ; curr ; curr=next) { - next = curr->n.other; - sp_nodepath_node_destroy(curr); - } - - } - //########################################### - //# END EDITS - //########################################### - - //clean up the nodepath (such as for trivial subpaths) - sp_nodepath_cleanup(nodepath); - - sp_nodepath_update_handles(nodepath); - - 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(Inkscape::NodePath::Path *nodepath, NRPathcode code) -{ - if (nodepath == NULL) return; - - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - g_assert(n->selected); - if (n->p.other && n->p.other->selected) { - sp_nodepath_set_line_type(n, code); - } - } - - 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::Path *nodepath, Inkscape::NodePath::NodeType type) -{ - 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, _("Change node type")); -} - -/** - * Change select status of node, update its own and neighbour handles. - */ -static void sp_node_set_selected(Inkscape::NodePath::Node *node, gboolean selected) -{ - node->selected = selected; - - if (selected) { - node->knot->setSize ((node->type == Inkscape::NodePath::NODE_CUSP || node->type == Inkscape::NodePath::NODE_AUTO) ? 11 : 9); - node->knot->setFill(NODE_FILL_SEL, NODE_FILL_SEL_HI, NODE_FILL_SEL_HI); - node->knot->setStroke(NODE_STROKE_SEL, NODE_STROKE_SEL_HI, NODE_STROKE_SEL_HI); - sp_knot_update_ctrl(node->knot); - } else { - node->knot->setSize ((node->type == Inkscape::NodePath::NODE_CUSP || node->type == Inkscape::NodePath::NODE_AUTO) ? 9 : 7); - node->knot->setFill(NODE_FILL, NODE_FILL_HI, NODE_FILL_HI); - node->knot->setStroke(NODE_STROKE, NODE_STROKE_HI, NODE_STROKE_HI); - sp_knot_update_ctrl(node->knot); - } - - sp_node_update_handles(node); - if (node->n.other) sp_node_update_handles(node->n.other); - if (node->p.other) sp_node_update_handles(node->p.other); -} - -/** -\brief Select a node -\param node The node to select -\param incremental If true, add to selection, otherwise deselect others -\param override If true, always select this node, otherwise toggle selected status -*/ -static void sp_nodepath_node_select(Inkscape::NodePath::Node *node, gboolean incremental, gboolean override) -{ - Inkscape::NodePath::Path *nodepath = node->subpath->nodepath; - - if (incremental) { - if (override) { - if (!g_list_find(nodepath->selected, node)) { - nodepath->selected = g_list_prepend(nodepath->selected, node); - } - sp_node_set_selected(node, TRUE); - } else { // toggle - if (node->selected) { - g_assert(g_list_find(nodepath->selected, node)); - nodepath->selected = g_list_remove(nodepath->selected, node); - } else { - g_assert(!g_list_find(nodepath->selected, node)); - nodepath->selected = g_list_prepend(nodepath->selected, node); - } - sp_node_set_selected(node, !node->selected); - } - } else { - sp_nodepath_deselect(nodepath); - nodepath->selected = g_list_prepend(nodepath->selected, node); - sp_node_set_selected(node, TRUE); - } - - sp_nodepath_update_statusbar(nodepath); -} - - -/** -\brief Deselect all nodes in the nodepath -*/ -void -sp_nodepath_deselect(Inkscape::NodePath::Path *nodepath) -{ - if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses - - while (nodepath->selected) { - sp_node_set_selected((Inkscape::NodePath::Node *) nodepath->selected->data, FALSE); - nodepath->selected = g_list_remove(nodepath->selected, nodepath->selected->data); - } - sp_nodepath_update_statusbar(nodepath); -} - -/** -\brief Select or invert selection of all nodes in the nodepath -*/ -void -sp_nodepath_select_all(Inkscape::NodePath::Path *nodepath, bool invert) -{ - if (!nodepath) return; - - 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; - sp_nodepath_node_select(node, TRUE, invert? !node->selected : TRUE); - } - } -} - -/** - * If nothing selected, does the same as sp_nodepath_select_all(); - * otherwise selects/inverts all nodes in all subpaths that have selected nodes - * (i.e., similar to "select all in layer", with the "selected" subpaths - * being treated as "layers" in the path). - */ -void -sp_nodepath_select_all_from_subpath(Inkscape::NodePath::Path *nodepath, bool invert) -{ - if (!nodepath) return; - - if (g_list_length (nodepath->selected) == 0) { - sp_nodepath_select_all (nodepath, invert); - return; - } - - GList *copy = g_list_copy (nodepath->selected); // copy initial selection so that selecting in the loop does not affect us - GSList *subpaths = NULL; - - for (GList *l = copy; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - Inkscape::NodePath::SubPath *subpath = n->subpath; - if (!g_slist_find (subpaths, subpath)) - subpaths = g_slist_prepend (subpaths, subpath); - } - - for (GSList *sp = subpaths; sp != NULL; sp = sp->next) { - Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) sp->data; - for (GList *nl = subpath->nodes; nl != NULL; nl = nl->next) { - Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data; - sp_nodepath_node_select(node, TRUE, invert? !g_list_find(copy, node) : TRUE); - } - } - - g_slist_free (subpaths); - g_list_free (copy); -} - -/** - * \brief Select the node after the last selected; if none is selected, - * select the first within path. - */ -void sp_nodepath_select_next(Inkscape::NodePath::Path *nodepath) -{ - if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses - - Inkscape::NodePath::Node *last = NULL; - if (nodepath->selected) { - for (GList *spl = nodepath->subpaths; spl != NULL; spl = spl->next) { - Inkscape::NodePath::SubPath *subpath, *subpath_next; - 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 (node->n.other == (Inkscape::NodePath::Node *) subpath->last) { - if (node->n.other == (Inkscape::NodePath::Node *) subpath->first) { // closed subpath - if (spl->next) { // there's a next subpath - subpath_next = (Inkscape::NodePath::SubPath *) spl->next->data; - last = subpath_next->first; - } else if (spl->prev) { // there's a previous subpath - last = NULL; // to be set later to the first node of first subpath - } else { - last = node->n.other; - } - } else { - last = node->n.other; - } - } else { - if (node->n.other) { - last = node->n.other; - } else { - if (spl->next) { // there's a next subpath - subpath_next = (Inkscape::NodePath::SubPath *) spl->next->data; - last = subpath_next->first; - } else if (spl->prev) { // there's a previous subpath - last = NULL; // to be set later to the first node of first subpath - } else { - last = (Inkscape::NodePath::Node *) subpath->first; - } - } - } - } - } - } - sp_nodepath_deselect(nodepath); - } - - if (last) { // there's at least one more node after selected - sp_nodepath_node_select((Inkscape::NodePath::Node *) last, TRUE, TRUE); - } else { // no more nodes, select the first one in first subpath - Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) nodepath->subpaths->data; - sp_nodepath_node_select((Inkscape::NodePath::Node *) subpath->first, TRUE, TRUE); - } -} - -/** - * \brief Select the node before the first selected; if none is selected, - * select the last within path - */ -void sp_nodepath_select_prev(Inkscape::NodePath::Path *nodepath) -{ - if (!nodepath) return; // there's no nodepath when editing rects, stars, spirals or ellipses - - Inkscape::NodePath::Node *last = NULL; - if (nodepath->selected) { - for (GList *spl = g_list_last(nodepath->subpaths); spl != NULL; spl = spl->prev) { - Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data; - for (GList *nl = g_list_last(subpath->nodes); nl != NULL; nl = nl->prev) { - Inkscape::NodePath::Node *node = (Inkscape::NodePath::Node *) nl->data; - if (node->selected) { - if (node->p.other == (Inkscape::NodePath::Node *) subpath->first) { - if (node->p.other == (Inkscape::NodePath::Node *) subpath->last) { // closed subpath - if (spl->prev) { // there's a prev subpath - Inkscape::NodePath::SubPath *subpath_prev = (Inkscape::NodePath::SubPath *) spl->prev->data; - last = subpath_prev->last; - } else if (spl->next) { // there's a next subpath - last = NULL; // to be set later to the last node of last subpath - } else { - last = node->p.other; - } - } else { - last = node->p.other; - } - } else { - if (node->p.other) { - last = node->p.other; - } else { - if (spl->prev) { // there's a prev subpath - Inkscape::NodePath::SubPath *subpath_prev = (Inkscape::NodePath::SubPath *) spl->prev->data; - last = subpath_prev->last; - } else if (spl->next) { // there's a next subpath - last = NULL; // to be set later to the last node of last subpath - } else { - last = (Inkscape::NodePath::Node *) subpath->last; - } - } - } - } - } - } - sp_nodepath_deselect(nodepath); - } - - if (last) { // there's at least one more node before selected - sp_nodepath_node_select((Inkscape::NodePath::Node *) last, TRUE, TRUE); - } else { // no more nodes, select the last one in last subpath - GList *spl = g_list_last(nodepath->subpaths); - Inkscape::NodePath::SubPath *subpath = (Inkscape::NodePath::SubPath *) spl->data; - sp_nodepath_node_select((Inkscape::NodePath::Node *) subpath->last, TRUE, TRUE); - } -} - -/** - * \brief Select all nodes that are within the rectangle. - */ -void sp_nodepath_select_rect(Inkscape::NodePath::Path *nodepath, Geom::Rect const &b, gboolean incremental) -{ - if (!incremental) { - sp_nodepath_deselect(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 *node = (Inkscape::NodePath::Node *) nl->data; - - if (b.contains(node->pos)) { - sp_nodepath_node_select(node, TRUE, TRUE); - } - } - } -} - - -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 (Geom::L2(node->pos - n->pos) > farthest_dist) { - farthest_dist = Geom::L2(node->pos - n->pos); - farthest_selected = node; - } - } else { - if (Geom::L2(node->pos - n->pos) < closest_dist) { - closest_dist = Geom::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 -*/ -GList *save_nodepath_selection(Inkscape::NodePath::Path *nodepath) -{ - GList *r = NULL; - if (nodepath->selected) { - guint i = 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; - i++; - if (node->selected) { - r = g_list_append(r, GINT_TO_POINTER(i)); - } - } - } - } - return r; -} - -/** -\brief Restores selection by selecting nodes whose positions are in the list -*/ -void restore_nodepath_selection(Inkscape::NodePath::Path *nodepath, GList *r) -{ - sp_nodepath_deselect(nodepath); - - guint i = 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; - i++; - if (g_list_find(r, GINT_TO_POINTER(i))) { - sp_nodepath_node_select(node, TRUE, TRUE); - } - } - } -} - - -/** -\brief Adjusts handle according to node type and line code. -*/ -static void sp_node_adjust_handle(Inkscape::NodePath::Node *node, gint which_adjust) -{ - g_assert(node); - - // nothing to do for auto nodes (sp_node_adjust_handles() does the job) - if (node->type == Inkscape::NodePath::NODE_AUTO) - return; - - Inkscape::NodePath::NodeSide *me = sp_node_get_side(node, which_adjust); - Inkscape::NodePath::NodeSide *other = sp_node_opposite_side(node, me); - - // nothing to do if we are an end node - if (me->other == NULL) return; - if (other->other == NULL) return; - - // nothing to do if we are a cusp node - if (node->type == Inkscape::NodePath::NODE_CUSP) return; - - // nothing to do if it's a line from the specified side of the node (i.e. no handle to adjust) - NRPathcode mecode; - if (which_adjust == 1) { - mecode = (NRPathcode)me->other->code; - } else { - mecode = (NRPathcode)node->code; - } - if (mecode == NR_LINETO) return; - - if (sp_node_side_is_line(node, other)) { - // other is a line, and we are either smooth or symm - Inkscape::NodePath::Node *othernode = other->other; - double len = Geom::L2(me->pos - node->pos); - Geom::Point delta = node->pos - othernode->pos; - double linelen = Geom::L2(delta); - if (linelen < 1e-18) - return; - me->pos = node->pos + (len / linelen)*delta; - return; - } - - if (node->type == Inkscape::NodePath::NODE_SYMM) { - // symmetrize - me->pos = 2 * node->pos - other->pos; - return; - } else { - // smoothify - double len = Geom::L2(me->pos - node->pos); - Geom::Point delta = other->pos - node->pos; - double otherlen = Geom::L2(delta); - if (otherlen < 1e-18) return; - me->pos = node->pos - (len / otherlen) * delta; - } -} - -/** - \brief Adjusts both handles according to node type and line code - */ -static void sp_node_adjust_handles(Inkscape::NodePath::Node *node) -{ - g_assert(node); - - if (node->type == Inkscape::NodePath::NODE_CUSP) return; - - /* we are either smooth or symm */ - - if (node->p.other == NULL) return; - if (node->n.other == NULL) return; - - if (node->type == Inkscape::NodePath::NODE_AUTO) { - sp_node_adjust_handles_auto(node); - return; - } - - if (sp_node_side_is_line(node, &node->p)) { - sp_node_adjust_handle(node, 1); - return; - } - - if (sp_node_side_is_line(node, &node->n)) { - sp_node_adjust_handle(node, -1); - return; - } - - /* both are curves */ - Geom::Point const delta( node->n.pos - node->p.pos ); - - if (node->type == Inkscape::NodePath::NODE_SYMM) { - node->p.pos = node->pos - delta / 2; - node->n.pos = node->pos + delta / 2; - return; - } - - /* We are smooth */ - double plen = Geom::L2(node->p.pos - node->pos); - if (plen < 1e-18) return; - double nlen = Geom::L2(node->n.pos - node->pos); - if (nlen < 1e-18) return; - node->p.pos = node->pos - (plen / (plen + nlen)) * delta; - node->n.pos = node->pos + (nlen / (plen + nlen)) * delta; -} - -static void sp_node_adjust_handles_auto(Inkscape::NodePath::Node *node) -{ - if (node->p.other == NULL || node->n.other == NULL) { - node->p.pos = node->pos; - node->n.pos = node->pos; - return; - } - - Geom::Point leg_prev = to_2geom(node->p.other->pos - node->pos); - Geom::Point leg_next = to_2geom(node->n.other->pos - node->pos); - - double norm_leg_prev = Geom::L2(leg_prev); - double norm_leg_next = Geom::L2(leg_next); - - Geom::Point delta; - if (norm_leg_next > 0.0) { - delta = (norm_leg_prev / norm_leg_next) * leg_next - leg_prev; - delta.normalize(); - } - - node->p.pos = node->pos - norm_leg_prev / 3 * delta; - node->n.pos = node->pos + norm_leg_next / 3 * delta; -} - -/** - * Node event callback. - */ -static gboolean node_event(SPKnot */*knot*/, GdkEvent *event, Inkscape::NodePath::Node *n) -{ - gboolean ret = FALSE; - switch (event->type) { - case GDK_ENTER_NOTIFY: - Inkscape::NodePath::Path::active_node = n; - break; - case GDK_LEAVE_NOTIFY: - 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)) { - case GDK_space: - if (event->key.state & GDK_BUTTON1_MASK) { - Inkscape::NodePath::Path *nodepath = n->subpath->nodepath; - stamp_repr(nodepath); - 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; - } - break; - default: - break; - } - - return ret; -} - -/** - * Handle keypress on node; directly called. - */ -gboolean node_key(GdkEvent *event) -{ - Inkscape::NodePath::Path *np; - - // there is no way to verify nodes so set active_node to nil when deleting!! - 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 = 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(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_CUSP); - ret = TRUE; - break; - case GDK_s: - sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SMOOTH); - ret = TRUE; - break; - case GDK_a: - sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_AUTO); - ret = TRUE; - break; - case GDK_y: - sp_nodepath_set_node_type(Inkscape::NodePath::Path::active_node,Inkscape::NodePath::NODE_SYMM); - ret = TRUE; - break; - case GDK_b: - sp_nodepath_node_break(Inkscape::NodePath::Path::active_node); - ret = TRUE; - break; - } - return ret; - } - return FALSE; -} - -/** - * Mouseclick on node callback. - */ -static void node_clicked(SPKnot */*knot*/, guint state, gpointer data) -{ - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; - - if (state & GDK_CONTROL_MASK) { - Inkscape::NodePath::Path *nodepath = n->subpath->nodepath; - - if (!(state & GDK_MOD1_MASK)) { // ctrl+click: toggle node type - if (n->type == Inkscape::NodePath::NODE_CUSP) { - sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_SMOOTH); - } else if (n->type == Inkscape::NodePath::NODE_SMOOTH) { - sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_SYMM); - } else if (n->type == Inkscape::NodePath::NODE_SYMM) { - sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_AUTO); - } else { - sp_nodepath_convert_node_type (n,Inkscape::NodePath::NODE_CUSP); - } - sp_nodepath_update_repr(nodepath, _("Change node type")); - sp_nodepath_update_statusbar(nodepath); - - } else { //ctrl+alt+click: delete node - GList *node_to_delete = NULL; - node_to_delete = g_list_append(node_to_delete, n); - sp_node_delete_preserve(node_to_delete); - } - - } else { - sp_nodepath_node_select(n, (state & GDK_SHIFT_MASK), FALSE); - } -} - -/** - * Mouse grabbed node callback. - */ -static void node_grabbed(SPKnot *knot, guint state, gpointer data) -{ - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; - - if (!n->selected) { - sp_nodepath_node_select(n, (state & GDK_SHIFT_MASK), FALSE); - } - - n->is_dragging = true; - // Reconstruct and store the location of the mouse pointer at the time when we started dragging (needed for snapping) - n->subpath->nodepath->drag_origin_mouse = knot->grabbed_rel_pos + knot->drag_origin; - - sp_canvas_force_full_redraw_after_interruptions(n->subpath->nodepath->desktop->canvas, 5); - - sp_nodepath_remember_origins (n->subpath->nodepath); -} - -/** - * Mouse ungrabbed node callback. - */ -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; - n->subpath->nodepath->drag_origin_mouse = Geom::Point(NR_HUGE, NR_HUGE); - sp_canvas_end_forced_full_redraws(n->subpath->nodepath->desktop->canvas); - - sp_nodepath_update_repr(n->subpath->nodepath, _("Move nodes")); -} - -/** - * The point on a line, given by its angle, closest to the given point. - * \param p A point. - * \param a Angle of the line; it is assumed to go through coordinate origin. - * \param closest Pointer to the point struct where the result is stored. - * \todo FIXME: use dot product perhaps? - */ -static void point_line_closest(Geom::Point *p, double a, Geom::Point *closest) -{ - if (a == HUGE_VAL) { // vertical - *closest = Geom::Point(0, (*p)[Geom::Y]); - } else { - (*closest)[Geom::X] = ( a * (*p)[Geom::Y] + (*p)[Geom::X]) / (a*a + 1); - (*closest)[Geom::Y] = a * (*closest)[Geom::X]; - } -} - -/** - * Distance from the point to a line given by its angle. - * \param p A point. - * \param a Angle of the line; it is assumed to go through coordinate origin. - */ -static double point_line_distance(Geom::Point *p, double a) -{ - Geom::Point c; - point_line_closest(p, a, &c); - return sqrt(((*p)[Geom::X] - c[Geom::X])*((*p)[Geom::X] - c[Geom::X]) + ((*p)[Geom::Y] - c[Geom::Y])*((*p)[Geom::Y] - c[Geom::Y])); -} - -/** - * Callback for node "request" signal. - * \todo fixme: This goes to "moved" event? (lauris) - */ -static gboolean -node_request(SPKnot */*knot*/, Geom::Point const &p, guint state, gpointer data) -{ - double yn, xn, yp, xp; - double an, ap, na, pa; - double d_an, d_ap, d_na, d_pa; - gboolean collinear = FALSE; - Geom::Point c; - Geom::Point pr; - - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; - - n->subpath->nodepath->desktop->snapindicator->remove_snaptarget(); - - // If either (Shift and some handle retracted), or (we're already dragging out a handle) - if ( (!n->subpath->nodepath->straight_path) && - ( ((state & GDK_SHIFT_MASK) && ((n->n.other && n->n.pos == n->pos) || (n->p.other && n->p.pos == n->pos))) - || n->dragging_out ) ) - { - Geom::Point mouse = p; - - if (!n->dragging_out) { - // This is the first drag-out event; find out which handle to drag out - double appr_n = (n->n.other ? Geom::L2(n->n.other->pos - n->pos) - Geom::L2(n->n.other->pos - p) : -HUGE_VAL); - double appr_p = (n->p.other ? Geom::L2(n->p.other->pos - n->pos) - Geom::L2(n->p.other->pos - p) : -HUGE_VAL); - - if (appr_p == -HUGE_VAL && appr_n == -HUGE_VAL) // orphan node? - return FALSE; - - Inkscape::NodePath::NodeSide *opposite; - if (appr_p > appr_n) { // closer to p - n->dragging_out = &n->p; - opposite = &n->n; - n->code = NR_CURVETO; - } else if (appr_p < appr_n) { // closer to n - n->dragging_out = &n->n; - opposite = &n->p; - n->n.other->code = NR_CURVETO; - } else { // p and n nodes are the same - if (n->n.pos != n->pos) { // n handle already dragged, drag p - n->dragging_out = &n->p; - opposite = &n->n; - n->code = NR_CURVETO; - } else if (n->p.pos != n->pos) { // p handle already dragged, drag n - n->dragging_out = &n->n; - opposite = &n->p; - n->n.other->code = NR_CURVETO; - } else { // find out to which handle of the adjacent node we're closer; note that n->n.other == n->p.other - double appr_other_n = (n->n.other ? Geom::L2(n->n.other->n.pos - n->pos) - Geom::L2(n->n.other->n.pos - p) : -HUGE_VAL); - double appr_other_p = (n->n.other ? Geom::L2(n->n.other->p.pos - n->pos) - Geom::L2(n->n.other->p.pos - p) : -HUGE_VAL); - if (appr_other_p > appr_other_n) { // closer to other's p handle - n->dragging_out = &n->n; - opposite = &n->p; - n->n.other->code = NR_CURVETO; - } else { // closer to other's n handle - n->dragging_out = &n->p; - opposite = &n->n; - n->code = NR_CURVETO; - } - } - } - - // if there's another handle, make sure the one we drag out starts parallel to it - if (opposite->pos != n->pos) { - mouse = n->pos - Geom::L2(mouse - n->pos) * Geom::unit_vector(opposite->pos - n->pos); - } - - // knots might not be created yet! - sp_node_ensure_knot_exists (n->subpath->nodepath->desktop, n, n->dragging_out); - sp_node_ensure_knot_exists (n->subpath->nodepath->desktop, n, opposite); - } - - // pass this on to the handle-moved callback - node_handle_moved(n->dragging_out->knot, mouse, state, (gpointer) n); - sp_node_update_handles(n); - return TRUE; - } - - if (state & GDK_CONTROL_MASK) { // constrained motion - - // calculate relative distances of handles - // n handle: - yn = n->n.pos[Geom::Y] - n->pos[Geom::Y]; - xn = n->n.pos[Geom::X] - n->pos[Geom::X]; - // if there's no n handle (straight line), see if we can use the direction to the next point on path - 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->origin[Geom::Y] - n->origin[Geom::Y]; // use origin because otherwise the direction will change as you drag - xn = n->n.other->origin[Geom::X] - n->origin[Geom::X]; - } - } - if (xn < 0) { xn = -xn; yn = -yn; } // limit the angle to between 0 and pi - if (yn < 0) { xn = -xn; yn = -yn; } - - // p handle: - yp = n->p.pos[Geom::Y] - n->pos[Geom::Y]; - xp = n->p.pos[Geom::X] - n->pos[Geom::X]; - // if there's no p handle (straight line), see if we can use the direction to the prev point on path - 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->origin[Geom::Y] - n->origin[Geom::Y]; - xp = n->p.other->origin[Geom::X] - n->origin[Geom::X]; - } - } - if (xp < 0) { xp = -xp; yp = -yp; } // limit the angle to between 0 and pi - if (yp < 0) { xp = -xp; yp = -yp; } - - if (state & GDK_MOD1_MASK && !(xn == 0 && xp == 0)) { - // sliding on handles, only if at least one of the handles is non-vertical - // (otherwise it's the same as ctrl+drag anyway) - - // calculate angles of the handles - if (xn == 0) { - if (yn == 0) { // no handle, consider it the continuation of the other one - an = 0; - collinear = TRUE; - } - else an = 0; // vertical; set the angle to horizontal - } else an = yn/xn; - - if (xp == 0) { - if (yp == 0) { // no handle, consider it the continuation of the other one - ap = an; - } - else ap = 0; // vertical; set the angle to horizontal - } else ap = yp/xp; - - if (collinear) an = ap; - - // angles of the perpendiculars; HUGE_VAL means vertical - if (an == 0) na = HUGE_VAL; else na = -1/an; - if (ap == 0) pa = HUGE_VAL; else pa = -1/ap; - - // mouse point relative to the node's original pos - pr = p - n->origin; - - // distances to the four lines (two handles and two perpendiculars) - d_an = point_line_distance(&pr, an); - d_na = point_line_distance(&pr, na); - d_ap = point_line_distance(&pr, ap); - d_pa = point_line_distance(&pr, pa); - - // find out which line is the closest, save its closest point in c - if (d_an <= d_na && d_an <= d_ap && d_an <= d_pa) { - point_line_closest(&pr, an, &c); - } else if (d_ap <= d_an && d_ap <= d_na && d_ap <= d_pa) { - point_line_closest(&pr, ap, &c); - } else if (d_na <= d_an && d_na <= d_ap && d_na <= d_pa) { - point_line_closest(&pr, na, &c); - } else if (d_pa <= d_an && d_pa <= d_ap && d_pa <= d_na) { - point_line_closest(&pr, pa, &c); - } - - // move the node to the closest point - sp_nodepath_selected_nodes_move(n->subpath->nodepath, - n->origin[Geom::X] + c[Geom::X] - n->pos[Geom::X], - n->origin[Geom::Y] + c[Geom::Y] - n->pos[Geom::Y], - true); - - } else { // constraining to hor/vert - - if (fabs(p[Geom::X] - n->origin[Geom::X]) > fabs(p[Geom::Y] - n->origin[Geom::Y])) { // snap to hor - sp_nodepath_selected_nodes_move(n->subpath->nodepath, - p[Geom::X] - n->pos[Geom::X], - n->origin[Geom::Y] - n->pos[Geom::Y], - true, - true, Inkscape::Snapper::ConstraintLine(component_vectors[Geom::X])); - } else { // snap to vert - sp_nodepath_selected_nodes_move(n->subpath->nodepath, - n->origin[Geom::X] - n->pos[Geom::X], - p[Geom::Y] - n->pos[Geom::Y], - true, - true, Inkscape::Snapper::ConstraintLine(component_vectors[Geom::Y])); - } - } - } else { // move freely - if (n->is_dragging) { - if (state & GDK_MOD1_MASK) { // sculpt - sp_nodepath_selected_nodes_sculpt(n->subpath->nodepath, n, p - n->origin); - } else { - sp_nodepath_selected_nodes_move(n->subpath->nodepath, - p[Geom::X] - n->pos[Geom::X], - p[Geom::Y] - n->pos[Geom::Y], - (state & GDK_SHIFT_MASK) == 0); - } - } - } - - n->subpath->nodepath->desktop->scroll_to_point(p); - - return TRUE; -} - -/** - * Node handle clicked callback. - */ -static void node_handle_clicked(SPKnot *knot, guint state, gpointer data) -{ - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; - - if (state & GDK_CONTROL_MASK) { // "delete" handle - if (n->p.knot == knot) { - n->p.pos = n->pos; - } else if (n->n.knot == knot) { - n->n.pos = n->pos; - } - sp_node_update_handles(n); - Inkscape::NodePath::Path *nodepath = n->subpath->nodepath; - sp_nodepath_update_repr(nodepath, _("Retract handle")); - sp_nodepath_update_statusbar(nodepath); - - } else { // just select or add to selection, depending in Shift - sp_nodepath_node_select(n, (state & GDK_SHIFT_MASK), FALSE); - } -} - -/** - * Node handle grabbed callback. - */ -static void node_handle_grabbed(SPKnot *knot, guint state, gpointer data) -{ - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; - - // convert auto -> smooth when dragging handle - if (n->type == Inkscape::NodePath::NODE_AUTO) { - n->type = Inkscape::NodePath::NODE_SMOOTH; - sp_nodepath_update_node_knot (n); - } - - if (!n->selected) { - sp_nodepath_node_select(n, (state & GDK_SHIFT_MASK), FALSE); - } - - // remember the origin point of the handle - if (n->p.knot == knot) { - n->p.origin_radial = n->p.pos - n->pos; - } else if (n->n.knot == knot) { - 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); -} - -/** - * Node handle ungrabbed callback. - */ -static void node_handle_ungrabbed(SPKnot *knot, guint state, gpointer data) -{ - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; - - // 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_radial.a = 0; - sp_knot_set_position(knot, n->p.pos, state); - } else if (n->n.knot == knot) { - 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, _("Move node handle")); -} - -/** - * Node handle "request" signal callback. - */ -static gboolean node_handle_request(SPKnot *knot, Geom::Point &p, guint state, gpointer data) -{ - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; - - Inkscape::NodePath::NodeSide *me, *opposite; - gint which; - if (n->p.knot == knot) { - me = &n->p; - opposite = &n->n; - which = -1; - } else if (n->n.knot == knot) { - me = &n->n; - opposite = &n->p; - which = 1; - } else { - me = opposite = NULL; - which = 0; - g_assert_not_reached(); - } - - SPDesktop *desktop = n->subpath->nodepath->desktop; - SnapManager &m = desktop->namedview->snap_manager; - m.setup(desktop, true, n->subpath->nodepath->item); - Inkscape::SnappedPoint s; - - if ((state & GDK_SHIFT_MASK) != 0) { - // We will not try to snap when the shift-key is pressed - // so remove the old snap indicator and don't wait for it to time-out - desktop->snapindicator->remove_snaptarget(); - } - - Inkscape::NodePath::Node *othernode = opposite->other; - Inkscape::SnapSourceType source_type = (n->type == Inkscape::NodePath::NODE_SMOOTH ? Inkscape::SNAPSOURCE_NODE_SMOOTH : Inkscape::SNAPSOURCE_NODE_CUSP); - if (othernode) { - if ((n->type != Inkscape::NodePath::NODE_CUSP) && sp_node_side_is_line(n, opposite)) { - /* We are smooth node adjacent with line */ - Geom::Point const delta = p - n->pos; - Geom::Coord const len = Geom::L2(delta); - Inkscape::NodePath::Node *othernode = opposite->other; - Geom::Point const ndelta = n->pos - othernode->pos; - Geom::Coord const linelen = Geom::L2(ndelta); - if (len > NR_EPSILON && linelen > NR_EPSILON) { - Geom::Coord const scal = dot(delta, ndelta) / linelen; - p = n->pos + (scal / linelen) * ndelta; - } - if ((state & GDK_SHIFT_MASK) == 0) { - s = m.constrainedSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, Inkscape::SnapCandidatePoint(p, source_type), Inkscape::Snapper::ConstraintLine(p, ndelta)); - } - } else { - if ((state & GDK_SHIFT_MASK) == 0) { - s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, Inkscape::SnapCandidatePoint(p, source_type)); - } - } - } else { - if ((state & GDK_SHIFT_MASK) == 0) { - s = m.freeSnap(Inkscape::SnapPreferences::SNAPPOINT_NODE, Inkscape::SnapCandidatePoint(p, source_type)); - } - } - - s.getPoint(p); - - sp_node_adjust_handle(n, -which); - - return FALSE; -} - -/** - * Node handle moved callback. - */ -static void node_handle_moved(SPKnot *knot, Geom::Point const &p, guint state, gpointer data) -{ - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) data; - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - - Inkscape::NodePath::NodeSide *me; - Inkscape::NodePath::NodeSide *other; - if (n->p.knot == knot) { - me = &n->p; - other = &n->n; - } else if (n->n.knot == knot) { - me = &n->n; - other = &n->p; - } else { - me = NULL; - other = NULL; - g_assert_not_reached(); - } - - // calculate radial coordinates of the grabbed handle, its other handle, and the mouse point - Radial rme(me->pos - n->pos); - Radial rother(other->pos - n->pos); - Radial rnew(p - n->pos); - - if (state & GDK_CONTROL_MASK && rnew.a != HUGE_VAL) { - int const snaps = prefs->getInt("/options/rotationsnapsperpi/value", 12); - /* 0 interpreted as "no snapping". */ - - // 1. Snap to the closest PI/snaps angle, starting from zero. - double a_snapped = floor(rnew.a/(M_PI/snaps) + 0.5) * (M_PI/snaps); - - // 2. Snap to the original angle, its opposite and perpendiculars - if (me->origin_radial.a != HUGE_VAL) { // otherwise ortho doesn't exist: original handle was zero length - /* The closest PI/2 angle, starting from original angle */ - 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. - a_snapped = ( fabs(a_snapped - rnew.a) < fabs(a_ortho - rnew.a) - ? a_snapped - : a_ortho ); - } - - // 3. Snap to the angle of the opposite line, if any - Inkscape::NodePath::Node *othernode = other->other; - if (othernode) { - Geom::Point other_to_snap(0,0); - if (sp_node_side_is_line(n, other)) { - other_to_snap = othernode->pos - n->pos; - } else { - other_to_snap = other->pos - n->pos; - } - if (Geom::L2(other_to_snap) > 1e-3) { - Radial rother_to_snap(other_to_snap); - /* The closest PI/2 angle, starting from the angle of the opposite line segment */ - double const a_oppo = rother_to_snap.a + floor((rnew.a - rother_to_snap.a)/(M_PI/2) + 0.5) * (M_PI/2); - - // Snap to the closest. - a_snapped = ( fabs(a_snapped - rnew.a) < fabs(a_oppo - rnew.a) - ? a_snapped - : a_oppo ); - } - } - - rnew.a = a_snapped; - } - - if (state & GDK_MOD1_MASK) { - // lock handle length - rnew.r = me->origin_radial.r; - } - - if (( n->type !=Inkscape::NodePath::NODE_CUSP || (!n->dragging_out && (state & GDK_SHIFT_MASK))) - && (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 = Geom::Point(rother) + n->pos; - if (other->knot) { - sp_ctrlline_set_coords(SP_CTRLLINE(other->line), n->pos, other->pos); - sp_knot_moveto(other->knot, other->pos); - } - } - - me->pos = Geom::Point(rnew) + n->pos; - sp_ctrlline_set_coords(SP_CTRLLINE(me->line), n->pos, me->pos); - - // move knot, but without emitting the signal: - // we cannot emit a "moved" signal because we're now processing it - sp_knot_moveto(me->knot, me->pos); - - update_object(n->subpath->nodepath); - - /* status text */ - SPDesktop *desktop = n->subpath->nodepath->desktop; - if (!desktop) return; - SPEventContext *ec = desktop->event_context; - if (!ec) return; - - Inkscape::MessageContext *mc = get_message_context(ec); - - if (!mc) return; - - double degrees = 180 / M_PI * rnew.a; - if (degrees > 180) degrees -= 360; - if (degrees < -180) degrees += 360; - if (prefs->getBool("/options/compassangledisplay/value")) - degrees = angle_to_compass (degrees); - - GString *length = SP_PX_TO_METRIC_STRING(rnew.r, desktop->namedview->getDefaultMetric()); - - mc->setF(Inkscape::IMMEDIATE_MESSAGE, - _("Node handle: angle %0.2f°, length %s; with Ctrl to snap angle; with Alt to lock length; with Shift to rotate both handles"), degrees, length->str); - - g_string_free(length, TRUE); -} - -/** - * Node handle event callback. - */ -static gboolean node_handle_event(SPKnot *knot, GdkEvent *event,Inkscape::NodePath::Node *n) -{ - gboolean ret = FALSE; - switch (event->type) { - case GDK_KEY_PRESS: - switch (get_group0_keyval (&event->key)) { - case GDK_space: - if (event->key.state & GDK_BUTTON1_MASK) { - Inkscape::NodePath::Path *nodepath = n->subpath->nodepath; - stamp_repr(nodepath); - ret = TRUE; - } - break; - default: - break; - } - break; - case GDK_ENTER_NOTIFY: - // we use an experimentally determined threshold that seems to work fine - if (Geom::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 (Geom::L2(n->pos - knot->pos) < 0.75) - Inkscape::NodePath::Path::active_node = NULL; - break; - default: - break; - } - - return ret; -} - -static void node_rotate_one_internal(Inkscape::NodePath::Node const &n, gdouble const angle, - Radial &rme, Radial &rother, gboolean const both) -{ - rme.a += angle; - if ( both - || ( n.type == Inkscape::NodePath::NODE_SMOOTH ) - || ( n.type == Inkscape::NodePath::NODE_SYMM ) ) - { - rother.a += angle; - } -} - -static void node_rotate_one_internal_screen(Inkscape::NodePath::Node const &n, gdouble const angle, - Radial &rme, Radial &rother, gboolean const both) -{ - gdouble const norm_angle = angle / n.subpath->nodepath->desktop->current_zoom(); - - gdouble r; - if ( both - || ( n.type == Inkscape::NodePath::NODE_SMOOTH ) - || ( n.type == Inkscape::NodePath::NODE_SYMM ) ) - { - r = MAX(rme.r, rother.r); - } else { - r = rme.r; - } - - gdouble const weird_angle = atan2(norm_angle, r); -/* Bulia says norm_angle is just the visible distance that the - * object's end must travel on the screen. Left as 'angle' for want of - * a better name.*/ - - rme.a += weird_angle; - if ( both - || ( n.type == Inkscape::NodePath::NODE_SMOOTH ) - || ( n.type == Inkscape::NodePath::NODE_SYMM ) ) - { - rother.a += weird_angle; - } -} - -/** - * Rotate one node. - */ -static void node_rotate_one (Inkscape::NodePath::Node *n, gdouble angle, int which, gboolean screen) -{ - Inkscape::NodePath::NodeSide *me, *other; - bool both = false; - - double xn = n->n.other? n->n.other->pos[Geom::X] : n->pos[Geom::X]; - double xp = n->p.other? n->p.other->pos[Geom::X] : n->pos[Geom::X]; - - if (!n->n.other) { // if this is an endnode, select its single handle regardless of "which" - me = &(n->p); - other = &(n->n); - } else if (!n->p.other) { - me = &(n->n); - other = &(n->p); - } else { - if (which > 0) { // right handle - if (xn > xp) { - me = &(n->n); - other = &(n->p); - } else { - me = &(n->p); - other = &(n->n); - } - } else if (which < 0){ // left handle - if (xn <= xp) { - me = &(n->n); - other = &(n->p); - } else { - me = &(n->p); - other = &(n->n); - } - } else { // both handles - me = &(n->n); - other = &(n->p); - both = true; - } - } - - Radial rme(me->pos - n->pos); - Radial rother(other->pos - n->pos); - - if (screen) { - node_rotate_one_internal_screen (*n, angle, rme, rother, both); - } else { - node_rotate_one_internal (*n, angle, rme, rother, both); - } - - me->pos = n->pos + Geom::Point(rme); - - if (both || n->type == Inkscape::NodePath::NODE_SMOOTH || n->type == Inkscape::NodePath::NODE_SYMM) { - other->pos = n->pos + Geom::Point(rother); - } - - // this function is only called from sp_nodepath_selected_nodes_rotate that will update display at the end, - // so here we just move all the knots without emitting move signals, for speed - sp_node_update_handles(n, false); -} - -/** - * Rotate selected nodes. - */ -void sp_nodepath_selected_nodes_rotate(Inkscape::NodePath::Path *nodepath, gdouble angle, int which, bool screen) -{ - if (!nodepath || !nodepath->selected) return; - - if (g_list_length(nodepath->selected) == 1) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) nodepath->selected->data; - node_rotate_one (n, angle, which, screen); - } else { - // rotate as an object: - - Inkscape::NodePath::Node *n0 = (Inkscape::NodePath::Node *) nodepath->selected->data; - Geom::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 - } - - gdouble rot; - if (screen) { - gdouble const zoom = nodepath->desktop->current_zoom(); - gdouble const zmove = angle / zoom; - gdouble const r = Geom::L2(box.max() - box.midpoint()); - rot = atan2(zmove, r); - } else { - rot = angle; - } - - Geom::Point rot_center; - if (Inkscape::NodePath::Path::active_node == NULL) - rot_center = box.midpoint(); - else - rot_center = Inkscape::NodePath::Path::active_node->pos; - - Geom::Matrix t = - Geom::Matrix (Geom::Translate(-rot_center)) * - Geom::Matrix (Geom::Rotate(rot)) * - Geom::Matrix (Geom::Translate(rot_center)); - - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - n->pos *= t; - n->n.pos *= t; - n->p.pos *= t; - sp_node_update_handles(n, false); - } - } - - sp_nodepath_update_repr_keyed(nodepath, angle > 0 ? "nodes:rot:p" : "nodes:rot:n", _("Rotate nodes")); -} - -/** - * Scale one node. - */ -static void node_scale_one (Inkscape::NodePath::Node *n, gdouble grow, int which) -{ - bool both = false; - Inkscape::NodePath::NodeSide *me, *other; - - double xn = n->n.other? n->n.other->pos[Geom::X] : n->pos[Geom::X]; - double xp = n->p.other? n->p.other->pos[Geom::X] : n->pos[Geom::X]; - - if (!n->n.other) { // if this is an endnode, select its single handle regardless of "which" - me = &(n->p); - other = &(n->n); - n->code = NR_CURVETO; - } else if (!n->p.other) { - me = &(n->n); - other = &(n->p); - if (n->n.other) - n->n.other->code = NR_CURVETO; - } else { - if (which > 0) { // right handle - if (xn > xp) { - me = &(n->n); - other = &(n->p); - if (n->n.other) - n->n.other->code = NR_CURVETO; - } else { - me = &(n->p); - other = &(n->n); - n->code = NR_CURVETO; - } - } else if (which < 0){ // left handle - if (xn <= xp) { - me = &(n->n); - other = &(n->p); - if (n->n.other) - n->n.other->code = NR_CURVETO; - } else { - me = &(n->p); - other = &(n->n); - n->code = NR_CURVETO; - } - } else { // both handles - me = &(n->n); - other = &(n->p); - both = true; - n->code = NR_CURVETO; - if (n->n.other) - n->n.other->code = NR_CURVETO; - } - } - - Radial rme(me->pos - n->pos); - Radial rother(other->pos - n->pos); - - rme.r += grow; - if (rme.r < 0) rme.r = 0; - if (rme.a == HUGE_VAL) { - if (me->other) { // if direction is unknown, initialize it towards the next node - Radial rme_next(me->other->pos - n->pos); - rme.a = rme_next.a; - } else { // if there's no next, initialize to 0 - rme.a = 0; - } - } - if (both || n->type == Inkscape::NodePath::NODE_SYMM) { - rother.r += grow; - if (rother.r < 0) rother.r = 0; - if (rother.a == HUGE_VAL) { - rother.a = rme.a + M_PI; - } - } - - me->pos = n->pos + Geom::Point(rme); - - if (both || n->type == Inkscape::NodePath::NODE_SYMM) { - other->pos = n->pos + Geom::Point(rother); - } - - // this function is only called from sp_nodepath_selected_nodes_scale that will update display at the end, - // so here we just move all the knots without emitting move signals, for speed - sp_node_update_handles(n, false); -} - -/** - * Scale selected nodes. - */ -void sp_nodepath_selected_nodes_scale(Inkscape::NodePath::Path *nodepath, gdouble const grow, int const which) -{ - if (!nodepath || !nodepath->selected) return; - - if (g_list_length(nodepath->selected) == 1) { - // scale handles of the single selected node - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) nodepath->selected->data; - node_scale_one (n, grow, which); - } else { - // scale nodes as an "object": - - Inkscape::NodePath::Node *n0 = (Inkscape::NodePath::Node *) nodepath->selected->data; - Geom::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 - } - - if ( Geom::are_near(box.maxExtent(), 0) ) { - SPEventContext *ec = nodepath->desktop->event_context; - if (!ec) return; - Inkscape::MessageContext *mc = get_message_context(ec); - if (!mc) return; - mc->setF(Inkscape::WARNING_MESSAGE, - _("Cannot scale nodes when all are at the same location.")); - return; - } - double scale = (box.maxExtent() + grow)/box.maxExtent(); - - - Geom::Point scale_center; - if (Inkscape::NodePath::Path::active_node == NULL) - scale_center = box.midpoint(); - else - scale_center = Inkscape::NodePath::Path::active_node->pos; - - Geom::Matrix t = - Geom::Translate(-scale_center) * - Geom::Scale(scale, scale) * - Geom::Translate(scale_center); - - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - n->pos *= t; - n->n.pos *= t; - n->p.pos *= t; - sp_node_update_handles(n, false); - } - } - - 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) -{ - if (!nodepath) return; - sp_nodepath_selected_nodes_scale(nodepath, grow / nodepath->desktop->current_zoom(), which); -} - -/** - * Flip selected nodes horizontally/vertically. - */ -void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, Geom::Dim2 axis, boost::optional center) -{ - if (!nodepath || !nodepath->selected) return; - - 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]; - n->p.pos[axis] = n->n.pos[axis]; - n->n.pos[axis] = temp; - sp_node_update_handles(n, false); - } else { - // scale nodes as an "object": - - Geom::Rect box = sp_node_selected_bbox (nodepath); - if (!center) { - center = box.midpoint(); - } - Geom::Matrix t = - Geom::Matrix (Geom::Translate(- *center)) * - Geom::Matrix ((axis == Geom::X)? Geom::Scale(-1, 1) : Geom::Scale(1, -1)) * - Geom::Matrix (Geom::Translate(*center)); - - for (GList *l = nodepath->selected; l != NULL; l = l->next) { - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node *) l->data; - n->pos *= t; - n->n.pos *= t; - n->p.pos *= t; - sp_node_update_handles(n, false); - } - } - - sp_nodepath_update_repr(nodepath, _("Flip nodes")); -} - -Geom::Rect sp_node_selected_bbox (Inkscape::NodePath::Path *nodepath) -{ - g_assert (nodepath->selected); - - Inkscape::NodePath::Node *n0 = (Inkscape::NodePath::Node *) nodepath->selected->data; - Geom::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. - */ -static Inkscape::NodePath::SubPath *sp_nodepath_subpath_new(Inkscape::NodePath::Path *nodepath) -{ - g_assert(nodepath); - g_assert(nodepath->desktop); - - Inkscape::NodePath::SubPath *s = g_new(Inkscape::NodePath::SubPath, 1); - - s->nodepath = nodepath; - s->closed = FALSE; - s->nodes = NULL; - s->first = NULL; - s->last = NULL; - - // using prepend here saves up to 10% of time on paths with many subpaths, but requires that - // the caller reverses the list after it's ready (this is done in sp_nodepath_new) - nodepath->subpaths = g_list_prepend (nodepath->subpaths, s); - - return s; -} - -/** - * Destroy nodes in subpath, then subpath itself. - */ -static void sp_nodepath_subpath_destroy(Inkscape::NodePath::SubPath *subpath) -{ - g_assert(subpath); - g_assert(subpath->nodepath); - g_assert(g_list_find(subpath->nodepath->subpaths, subpath)); - - while (subpath->nodes) { - sp_nodepath_node_destroy((Inkscape::NodePath::Node *) subpath->nodes->data); - } - - subpath->nodepath->subpaths = g_list_remove(subpath->nodepath->subpaths, subpath); - - g_free(subpath); -} - -/** - * Link head to tail in subpath. - */ -static void sp_nodepath_subpath_close(Inkscape::NodePath::SubPath *sp) -{ - g_assert(!sp->closed); - g_assert(sp->last != sp->first); - g_assert(sp->first->code == NR_MOVETO); - - sp->closed = TRUE; - - //Link the head to the tail - sp->first->p.other = sp->last; - sp->last->n.other = sp->first; - sp->last->n.pos = sp->last->pos + (sp->first->n.pos - sp->first->pos); - sp->first = sp->last; - - //Remove the extra end node - sp_nodepath_node_destroy(sp->last->n.other); -} - -/** - * Open closed (loopy) subpath at node. - */ -static void sp_nodepath_subpath_open(Inkscape::NodePath::SubPath *sp,Inkscape::NodePath::Node *n) -{ - g_assert(sp->closed); - g_assert(n->subpath == sp); - g_assert(sp->first == sp->last); - - /* We create new startpoint, current node will become last one */ - - Inkscape::NodePath::Node *new_path = sp_nodepath_node_new(sp, n->n.other,Inkscape::NodePath::NODE_CUSP, NR_MOVETO, - &n->pos, &n->pos, &n->n.pos); - - - sp->closed = FALSE; - - //Unlink to make a head and tail - sp->first = new_path; - sp->last = n; - n->n.other = NULL; - new_path->p.other = NULL; -} - -/** - * Return new node in subpath with given properties. - * \param pos Position of node. - * \param ppos Handle position in previous direction - * \param npos Handle position in previous direction - */ -Inkscape::NodePath::Node * -sp_nodepath_node_new(Inkscape::NodePath::SubPath *sp, Inkscape::NodePath::Node *next, Inkscape::NodePath::NodeType type, NRPathcode code, Geom::Point *ppos, Geom::Point *pos, Geom::Point *npos) -{ - g_assert(sp); - g_assert(sp->nodepath); - g_assert(sp->nodepath->desktop); - - if (nodechunk == NULL) - nodechunk = g_mem_chunk_create(Inkscape::NodePath::Node, 32, G_ALLOC_AND_FREE); - - Inkscape::NodePath::Node *n = (Inkscape::NodePath::Node*)g_mem_chunk_alloc(nodechunk); - - n->subpath = sp; - - if (type != Inkscape::NodePath::NODE_NONE) { - // use the type from sodipodi:nodetypes - n->type = type; - } else { - if (fabs (Inkscape::Util::triangle_area (*pos, *ppos, *npos)) < 1e-2) { - // points are (almost) collinear - if (Geom::L2(*pos - *ppos) < 1e-6 || Geom::L2(*pos - *npos) < 1e-6) { - // endnode, or a node with a retracted handle - n->type = Inkscape::NodePath::NODE_CUSP; - } else { - n->type = Inkscape::NodePath::NODE_SMOOTH; - } - } else { - n->type = Inkscape::NodePath::NODE_CUSP; - } - } - - n->code = code; - n->selected = FALSE; - n->pos = *pos; - n->p.pos = *ppos; - n->n.pos = *npos; - - n->dragging_out = NULL; - - Inkscape::NodePath::Node *prev; - if (next) { - //g_assert(g_list_find(sp->nodes, next)); - prev = next->p.other; - } else { - prev = sp->last; - } - - if (prev) - prev->n.other = n; - else - sp->first = n; - - if (next) - next->p.other = n; - else - sp->last = n; - - n->p.other = prev; - n->n.other = next; - - n->knot = sp_knot_new(sp->nodepath->desktop, _("Node: drag to edit the path; with Ctrl to snap to horizontal/vertical; with Ctrl+Alt to snap to handles' directions")); - sp_knot_set_position(n->knot, *pos, 0); - - n->knot->setAnchor (GTK_ANCHOR_CENTER); - n->knot->setFill(NODE_FILL, NODE_FILL_HI, NODE_FILL_HI); - n->knot->setStroke(NODE_STROKE, NODE_STROKE_HI, NODE_STROKE_HI); - - sp_nodepath_update_node_knot(n); - - g_signal_connect(G_OBJECT(n->knot), "event", G_CALLBACK(node_event), n); - g_signal_connect(G_OBJECT(n->knot), "clicked", G_CALLBACK(node_clicked), n); - g_signal_connect(G_OBJECT(n->knot), "grabbed", G_CALLBACK(node_grabbed), n); - g_signal_connect(G_OBJECT(n->knot), "ungrabbed", G_CALLBACK(node_ungrabbed), n); - g_signal_connect(G_OBJECT(n->knot), "request", G_CALLBACK(node_request), n); - sp_knot_show(n->knot); - - // We only create handle knots and lines on demand - n->p.knot = NULL; - n->p.line = NULL; - n->n.knot = NULL; - n->n.line = NULL; - - sp->nodes = g_list_prepend(sp->nodes, n); - - return n; -} - -/** - * Destroy node and its knots, link neighbors in subpath. - */ -static void sp_nodepath_node_destroy(Inkscape::NodePath::Node *node) -{ - g_assert(node); - g_assert(node->subpath); - g_assert(SP_IS_KNOT(node->knot)); - - Inkscape::NodePath::SubPath *sp = node->subpath; - - if (node->selected) { // first, deselect - g_assert(g_list_find(node->subpath->nodepath->selected, node)); - node->subpath->nodepath->selected = g_list_remove(node->subpath->nodepath->selected, node); - } - - 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) { - 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)); - 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)); - if (node->n.line) - gtk_object_destroy(GTK_OBJECT(node->n.line)); - - if (sp->nodes) { // there are others nodes on the subpath - if (sp->closed) { - if (sp->first == node) { - g_assert(sp->last == node); - sp->first = node->n.other; - sp->last = sp->first; - } - node->p.other->n.other = node->n.other; - node->n.other->p.other = node->p.other; - } else { - if (sp->first == node) { - sp->first = node->n.other; - sp->first->code = NR_MOVETO; - } - if (sp->last == node) sp->last = node->p.other; - if (node->p.other) node->p.other->n.other = node->n.other; - if (node->n.other) node->n.other->p.other = node->p.other; - } - } else { // this was the last node on subpath - sp->nodepath->subpaths = g_list_remove(sp->nodepath->subpaths, sp); - } - - g_mem_chunk_free(nodechunk, node); -} - -/** - * Returns one of the node's two sides. - * \param which Indicates which side. - * \return Pointer to previous node side if which==-1, next if which==1. - */ -static Inkscape::NodePath::NodeSide *sp_node_get_side(Inkscape::NodePath::Node *node, gint which) -{ - g_assert(node); - Inkscape::NodePath::NodeSide * result = 0; - switch (which) { - case -1: - result = &node->p; - break; - case 1: - result = &node->n; - break; - default: - g_assert_not_reached(); - } - - return result; -} - -/** - * Return the other side of the node, given one of its sides. - */ -static Inkscape::NodePath::NodeSide *sp_node_opposite_side(Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *me) -{ - g_assert(node); - Inkscape::NodePath::NodeSide *result = 0; - - if (me == &node->p) { - result = &node->n; - } else if (me == &node->n) { - result = &node->p; - } else { - g_assert_not_reached(); - } - - return result; -} - -/** - * Return NRPathcode on the given side of the node. - */ -static NRPathcode sp_node_path_code_from_side(Inkscape::NodePath::Node *node,Inkscape::NodePath::NodeSide *me) -{ - g_assert(node); - - NRPathcode result = NR_END; - if (me == &node->p) { - if (node->p.other) { - result = (NRPathcode)node->code; - } else { - result = NR_MOVETO; - } - } else if (me == &node->n) { - if (node->n.other) { - result = (NRPathcode)node->n.other->code; - } else { - result = NR_MOVETO; - } - } else { - g_assert_not_reached(); - } - - return result; -} - -/** - * Return node with the given index - */ -Inkscape::NodePath::Node * -sp_nodepath_get_node_by_index(Inkscape::NodePath::Path *nodepath, int index) -{ - Inkscape::NodePath::Node *e = NULL; - - if (!nodepath) { - return e; - } - - //find segment - for (GList *l = nodepath->subpaths; l ; l=l->next) { - - Inkscape::NodePath::SubPath *sp = (Inkscape::NodePath::SubPath *)l->data; - int n = g_list_length(sp->nodes); - if (sp->closed) { - n++; - } - - //if the piece belongs to this subpath grab it - //otherwise move onto the next subpath - if (index < n) { - e = sp->first; - for (int i = 0; i < index; ++i) { - e = e->n.other; - } - break; - } else { - if (sp->closed) { - index -= (n+1); - } else { - index -= n; - } - } - } - - return e; -} - -/** - * Returns plain text meaning of node type. - */ -static gchar const *sp_node_type_description(Inkscape::NodePath::Node *node) -{ - unsigned retracted = 0; - bool endnode = false; - - for (int which = -1; which <= 1; which += 2) { - Inkscape::NodePath::NodeSide *side = sp_node_get_side(node, which); - if (side->other && Geom::L2(side->pos - node->pos) < 1e-6) - retracted ++; - if (!side->other) - endnode = true; - } - - if (retracted == 0) { - if (endnode) { - // TRANSLATORS: "end" is an adjective here (NOT a verb) - return _("end node"); - } else { - switch (node->type) { - case Inkscape::NodePath::NODE_CUSP: - // TRANSLATORS: "cusp" means "sharp" (cusp node); see also the Advanced Tutorial - return _("cusp"); - case Inkscape::NodePath::NODE_SMOOTH: - // TRANSLATORS: "smooth" is an adjective here - return _("smooth"); - case Inkscape::NodePath::NODE_AUTO: - return _("auto"); - case Inkscape::NodePath::NODE_SYMM: - return _("symmetric"); - } - } - } else if (retracted == 1) { - if (endnode) { - // TRANSLATORS: "end" is an adjective here (NOT a verb) - return _("end node, handle retracted (drag with Shift to extend)"); - } else { - return _("one handle retracted (drag with Shift to extend)"); - } - } else { - return _("both handles retracted (drag with Shift to extend)"); - } - - return NULL; -} - -/** - * Handles content of statusbar as long as node tool is active. - */ -void -sp_nodepath_update_statusbar(Inkscape::NodePath::Path *nodepath)//!!!move to ShapeEditorsCollection -{ - gchar const *when_selected = _("Drag nodes or node handles; Alt+drag nodes to sculpt; arrow keys to move nodes, < > to scale, [ ] to rotate"); - gchar const *when_selected_one = _("Drag the node or its handles; arrow keys to move the node"); - - 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) { - desktop = nodepath->desktop; - } else { - desktop = SP_ACTIVE_DESKTOP; // when this is eliminated also remove #include "inkscape.h" above - } - - SPEventContext *ec = desktop->event_context; - if (!ec) return; - - Inkscape::MessageContext *mc = get_message_context(ec); - if (!mc) return; - - inkscape_active_desktop()->emitToolSubselectionChanged(NULL); - - if (selected_nodes == 0) { - Inkscape::Selection *sel = desktop->selection; - if (!sel || sel->isEmpty()) { - mc->setF(Inkscape::NORMAL_MESSAGE, - _("Select a single object to edit its nodes or handles.")); - } else { - if (nodepath) { - mc->setF(Inkscape::NORMAL_MESSAGE, - ngettext("0 out of %i node selected. Click, Shift+click, or drag around nodes to select.", - "0 out of %i nodes selected. Click, Shift+click, or drag around nodes to select.", - 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 { - mc->setF(Inkscape::NORMAL_MESSAGE, _("Select a single object to edit its nodes or handles.")); - } - } - } - } else if (nodepath && selected_nodes == 1) { - mc->setF(Inkscape::NORMAL_MESSAGE, - ngettext("%i of %i node selected; %s. %s.", - "%i of %i nodes selected; %s. %s.", - total_nodes), - selected_nodes, total_nodes, sp_node_type_description((Inkscape::NodePath::Node *) nodepath->selected->data), when_selected_one); - } else { - if (selected_subpaths > 1) { - mc->setF(Inkscape::NORMAL_MESSAGE, - ngettext("%i of %i node selected in %i of %i subpaths. %s.", - "%i of %i nodes selected in %i of %i subpaths. %s.", - total_nodes), - selected_nodes, total_nodes, selected_subpaths, total_subpaths, when_selected); - } else { - mc->setF(Inkscape::NORMAL_MESSAGE, - ngettext("%i of %i node selected. %s.", - "%i of %i 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 = curve_new->copy(); - } else if ( IS_LIVEPATHEFFECT(object) && key) { - const gchar *svgd = object->repr->attribute(key); - if (svgd) { - Geom::PathVector pv = sp_svg_read_pathv(svgd); - SPCurve *curve_new = new SPCurve(pv); - if (curve_new) { - curve = curve_new; // don't do curve_copy because curve_new is already only created for us! - } - } - } - - 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_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(np->object))) { - 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) ) { - Inkscape::LivePathEffect::Effect * lpe = LIVEPATHEFFECT(np->object)->get_lpe(); - if (lpe) { - Inkscape::LivePathEffect::PathParam *pathparam = dynamic_cast( lpe->getParameter(np->repr_key) ); - if (pathparam) { - pathparam->set_new_value(np->curve->get_pathvector(), false); // do not write to SVG - np->object->requestModified(SP_OBJECT_MODIFIED_FLAG); - } - } - } -} - -/* -SPCanvasItem * -sp_nodepath_path_to_canvasitem(Inkscape::NodePath::Path *np, SPPath *path) { - return sp_nodepath_make_helper_item(np, sp_path_get_curve_for_edit(path)); -} -*/ - - -/// \todo this code to generate a helper canvasitem from an spcurve should be moved to different file -SPCanvasItem * -sp_nodepath_generate_helperpath(SPDesktop *desktop, SPCurve *curve, const Geom::Matrix & i2d, guint32 color = 0xff0000ff) { - SPCurve *flash_curve = curve->copy(); - flash_curve->transform(i2d); - SPCanvasItem * canvasitem = sp_canvas_bpath_new(sp_desktop_tempgroup(desktop), flash_curve); - // would be nice if its color could be XORed or something, now it is invisible for red stroked objects... - // unless we also flash the nodes... - sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(canvasitem), color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT); - sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(canvasitem), 0, SP_WIND_RULE_NONZERO); - sp_canvas_item_show(canvasitem); - flash_curve->unref(); - return canvasitem; -} - -SPCanvasItem * -sp_nodepath_generate_helperpath(SPDesktop *desktop, SPItem *item) { - if (!item || !desktop) { - return NULL; - } - - Inkscape::Preferences *prefs = Inkscape::Preferences::get(); - guint32 color = prefs->getInt("/tools/nodes/highlight_color", 0xff0000ff); - - Geom::Matrix i2d = sp_item_i2d_affine(item); - - SPCurve *curve = NULL; - if (SP_IS_PATH(item)) { - curve = sp_path_get_curve_for_edit(SP_PATH(item)); - } else if ( SP_IS_SHAPE(item) && SP_SHAPE(item)->curve ) { - curve = sp_shape_get_curve (SP_SHAPE(item)); - } else if ( SP_IS_TEXT(item) ) { - // do not display helperpath for text - we cannot do anything with it in Node tool anyway - // curve = SP_TEXT(item)->getNormalizedBpath(); - return NULL; - } else { - g_warning ("-----> sp_nodepath_generate_helperpath(SPDesktop *desktop, SPItem *item): TODO: generate the helper path for this item type!\n"); - return NULL; - } - - SPCanvasItem * helperpath = sp_nodepath_generate_helperpath(desktop, curve, i2d, color); - - curve->unref(); - - return helperpath; -} - - -// TODO: Merge this with sp_nodepath_make_helper_item()! -void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *np, bool show) { - np->show_helperpath = show; - - if (show) { - SPCurve *helper_curve = np->curve->copy(); - helper_curve->transform(np->i2d); - if (!np->helper_path) { - //np->helper_path = sp_nodepath_make_helper_item(np, desktop, helper_curve, true); // Caution: this applies the transform np->i2d twice!! - - 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_move_to_z(np->helper_path, 0); - sp_canvas_item_show(np->helper_path); - } else { - sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(np->helper_path), helper_curve); - } - helper_curve->unref(); - } else { - if (np->helper_path) { - GtkObject *temp = np->helper_path; - np->helper_path = NULL; - gtk_object_destroy(temp); - } - } -} - -/* sp_nodepath_make_straight_path: - * Prevents user from curving the path by dragging a segment or activating handles etc. - * The resulting path is a linear interpolation between nodal points, with only straight segments. - * !!! this function does not work completely yet: it does not actively straighten the path, only prevents the path from being curved - */ -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? - // coding tip: search for this text : "Make selected segments lines" -} - -/* - Local Variables: - mode:c++ - c-file-style:"stroustrup" - c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +)) - indent-tabs-mode:nil - fill-column:99 - End: -*/ -// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 : diff --git a/src/nodepath.h b/src/nodepath.h deleted file mode 100644 index 1dcb4527c..000000000 --- a/src/nodepath.h +++ /dev/null @@ -1,345 +0,0 @@ -/** @file - * @brief Path handler in node edit mode - */ -/* Authors: - * Lauris Kaplinski - * - * This code is in public domain - */ - -#ifndef SEEN_SP_NODEPATH_H -#define SEEN_SP_NODEPATH_H - -#include "libnr/nr-path-code.h" -#include -#include -#include -#include <2geom/point.h> -#include <2geom/matrix.h> -#include - - -struct SPCanvasItem; -class SPCurve; -struct SPItem; -class SPObject; -class SPDesktop; -class SPPath; -class SPKnot; -class LivePathEffectObject; - -namespace Inkscape { - namespace XML { - class Node; - } - - namespace LivePathEffect { - class Effect; - } -} - -typedef std::map > HelperPathList; - -/** - * Radial objects are represented by an angle and a distance from - * 0,0. 0,0 is represented by a == big_num. - */ -class Radial{ - public: -/** Radius */ - double r; -/** Amplitude */ - double a; - Radial() {} - // Radial(Geom::Point const &p); // Convert a point to radial coordinates - Radial(Radial &p) : r(p.r),a(p.a) {} - // operator Geom::Point() const; - -/** - * Construct Radial from Geom::Point. - */ -Radial(Geom::Point const &p) -{ - r = Geom::L2(p); - if (r > 0) { - a = Geom::atan2 (p); - } else { - a = HUGE_VAL; //undefined - } -} - -/** - * Cast Radial to cartesian Geom::Point. - */ -operator Geom::Point() const -{ - if (a == HUGE_VAL) { - return Geom::Point(0,0); - } else { - return r*Geom::Point(cos(a), sin(a)); - } -} - -}; - -class ShapeEditor; - -namespace Inkscape { -namespace NodePath { - -/** - * The entire nodepath, containing multiple subpaths - */ -class Path; - -/** - * A subpath is a continuous chain of linked nodes - */ -class SubPath; - -/** - * One side of a node, i.e. prev or next - */ -class NodeSide; - -/** - * A node on a subpath - */ -class Node; - - -/** - * This is the lowest list item, a simple list of nodes. - */ -class SubPath { - public: -/** The parent of this subpath */ - Path * nodepath; -/** Is this path closed (no endpoints) or not?*/ - gboolean closed; -/** The nodes in this subpath. */ - GList * nodes; -/** The first node of the subpath (does not imply open/closed)*/ - Node * first; -/** The last node of the subpath */ - Node * last; -}; - - - -/** - * What kind of node is this? This is the value for the node->type - * field. NodeType indicates the degree of continuity required for - * the node. I think that the corresponding integer indicates which - * derivate is connected. (Thus 2 means that the node is continuous - * to the second derivative, i.e. has matching endpoints and tangents) - */ -typedef enum { -/** A normal node */ - NODE_NONE, -/** This node non-continuously joins two segments.*/ - NODE_CUSP, -/** This node continuously joins two segments. */ - NODE_SMOOTH, -/** This node has automatic handles. */ - NODE_AUTO, -/** This node is symmetric. */ - NODE_SYMM -} NodeType; - - - -/** - * A NodeSide is a datarecord which may be on either side (n or p) of a node, - * which describes the segment going to the next node. - */ -class NodeSide{ - public: -/** Pointer to the next node, */ - Node * other; -/** Position */ - Geom::Point pos; -/** Origin (while dragging) in radial notation */ - Radial origin_radial; -/** Origin (while dragging) in x/y notation */ - Geom::Point origin; -/** Knots are Inkscape's way of providing draggable points. This - * Knot is the point on the curve representing the control point in a - * bezier curve.*/ - SPKnot * knot; -/** What kind of rendering? */ - SPCanvasItem * line; -}; - -/** - * A node along a NodePath - */ -class Node { - public: -/** The parent subpath of this node */ - SubPath * subpath; -/** Type is selected from NodeType.*/ - guint type : 4; -/** Code refers to which ArtCode is used to represent the segment - * (which segment?).*/ - guint code : 4; -/** Boolean. Am I currently selected or not? */ - guint selected : 1; -/** */ - Geom::Point pos; -/** */ - Geom::Point origin; -/** Knots are Inkscape's way of providing draggable points. This - * Knot is the point on the curve representing the endpoint.*/ - SPKnot * knot; -/** The NodeSide in the 'next' direction */ - NodeSide n; -/** The NodeSide in the 'previous' direction */ - NodeSide p; - - /** The pointer to the nodeside which we are dragging out with Shift */ - NodeSide *dragging_out; - - /** Boolean. Am I being dragged? */ - guint is_dragging : 1; -}; - -/** - * This is a collection of subpaths which contain nodes - * - * In the following data model. Nodepaths are made up of subpaths which - * are comprised of nodes. - * - * Nodes are linked thus: - * \verbatim - n other - node -----> nodeside ------> node \endverbatim - */ -class Path { - public: - /** Constructor should private, people should create new nodepaths using sp_nodepath_new - * But for some reason I cannot make sp_nodepath_new a friend :-( - */ - Path() {}; - /** Destructor */ - ~Path(); - -/** Pointer to the current desktop, for reporting purposes */ - SPDesktop * desktop; -/** The parent path of this nodepath */ - SPObject * object; -/** The parent livepatheffect of this nodepath, if applicable */ - SPItem * item; -/** The context which created this nodepath. Important if this nodepath is deleted */ - ShapeEditor *shape_editor; -/** The subpaths which comprise this NodePath */ - GList * subpaths; -/** A list of nodes which are currently selected */ - GList * selected; -/** Transforms (userspace <---> virtual space? someone please describe ) - njh: I'd be guessing that these are item <-> desktop transforms.*/ - Geom::Matrix i2d, d2i; -/** The DOM node which describes this NodePath */ - Inkscape::XML::Node *repr; - gchar *repr_key; - gchar *repr_nodetypes_key; - //STL compliant method to get the selected nodes - void selection(std::list &l); - - guint numSelected() {return (selected? g_list_length(selected) : 0);} - Geom::Point& singleSelectedCoords() {return (((Node *) selected->data)->pos);} - - /// draw a "sketch" of the path by using these variables - SPCanvasItem *helper_path; - SPCurve *curve; - bool show_helperpath; - guint32 helperpath_rgba; - gdouble helperpath_width; - - // the helperpaths provided by all LPEs (and their paramaters) of the current item - HelperPathList helper_path_vec; - - /// true if we changed repr, to tell this change from an external one such as from undo, simplify, or another desktop - unsigned int local_change; - - /// true if we're showing selected nodes' handles - bool show_handles; - - /// true if the path cannot contain curves, just straight lines - bool straight_path; - - /// active_node points to the node that is currently mouseovered (= NULL if - /// there isn't any); we also consider the node mouseovered if it is covered - /// by one of its handles and the latter is mouseovered - static Node *active_node; - - /// Location of mouse pointer when we started dragging, needed for snapping - Geom::Point drag_origin_mouse; - -}; - -} // namespace NodePath -} // namespace Inkscape - -enum { - SCULPT_PROFILE_LINEAR, - SCULPT_PROFILE_BELL, - SCULPT_PROFILE_ELLIPTIC -}; - -// Do function documentation in nodepath.cpp -Inkscape::NodePath::Path * sp_nodepath_new (SPDesktop * desktop, SPObject *object, bool show_handles, const char * repr_key = NULL, SPItem *item = NULL); -void sp_nodepath_deselect (Inkscape::NodePath::Path *nodepath); -void sp_nodepath_select_all (Inkscape::NodePath::Path *nodepath, bool invert); -void sp_nodepath_select_all_from_subpath(Inkscape::NodePath::Path *nodepath, bool invert); -void sp_nodepath_select_next (Inkscape::NodePath::Path *nodepath); -void sp_nodepath_select_prev (Inkscape::NodePath::Path *nodepath); -void sp_nodepath_select_rect (Inkscape::NodePath::Path * nodepath, Geom::Rect const &b, gboolean incremental); -GList *save_nodepath_selection (Inkscape::NodePath::Path *nodepath); -void restore_nodepath_selection (Inkscape::NodePath::Path *nodepath, GList *r); -gboolean nodepath_repr_d_changed (Inkscape::NodePath::Path * np, const char *newd); -gboolean nodepath_repr_typestr_changed (Inkscape::NodePath::Path * np, const char *newtypestr); -gboolean node_key (GdkEvent * event); -void sp_nodepath_update_repr(Inkscape::NodePath::Path *np, const gchar *annotation); -void sp_nodepath_update_statusbar (Inkscape::NodePath::Path *nodepath); -void sp_nodepath_selected_align(Inkscape::NodePath::Path *nodepath, Geom::Dim2 axis); -void sp_nodepath_selected_distribute(Inkscape::NodePath::Path *nodepath, Geom::Dim2 axis); -void sp_nodepath_select_segment_near_point(Inkscape::NodePath::Path *nodepath, Geom::Point p, bool toggle); -void sp_nodepath_add_node_near_point(Inkscape::NodePath::Path *nodepath, Geom::Point p); -void sp_nodepath_curve_drag(Inkscape::NodePath::Path *nodepath, int node, double t, Geom::Point delta); -Inkscape::NodePath::Node * sp_nodepath_get_node_by_index(Inkscape::NodePath::Path *np, int index); -bool sp_node_side_is_line (Inkscape::NodePath::Node *node, Inkscape::NodePath::NodeSide *side); - -/* possibly private functions */ - -void sp_node_selected_add_node (Inkscape::NodePath::Path *nodepath); -void sp_node_selected_break (Inkscape::NodePath::Path *nodepath); -void sp_node_selected_duplicate (Inkscape::NodePath::Path *nodepath); -void sp_node_selected_join (Inkscape::NodePath::Path *nodepath); -void sp_node_selected_join_segment (Inkscape::NodePath::Path *nodepath); -void sp_node_delete_preserve (GList *nodes_to_delete); -void sp_node_selected_delete (Inkscape::NodePath::Path *nodepath); -void sp_node_selected_delete_segment (Inkscape::NodePath::Path *nodepath); -void sp_node_selected_set_type (Inkscape::NodePath::Path *nodepath, Inkscape::NodePath::NodeType type); -void sp_node_selected_set_line_type (Inkscape::NodePath::Path *nodepath, NRPathcode code); -void sp_node_selected_move (Inkscape::NodePath::Path *nodepath, gdouble dx, gdouble dy); -void sp_node_selected_move_screen (SPDesktop *desktop, Inkscape::NodePath::Path *nodepath, gdouble dx, gdouble dy); -void sp_node_selected_move_absolute (Inkscape::NodePath::Path *nodepath, Geom::Coord val, Geom::Dim2 axis); -Geom::Rect sp_node_selected_bbox (Inkscape::NodePath::Path *nodepath); -boost::optional sp_node_selected_common_coord (Inkscape::NodePath::Path *nodepath, Geom::Dim2 axis); - -void sp_nodepath_show_handles(Inkscape::NodePath::Path *nodepath, bool show); -SPCanvasItem *sp_nodepath_generate_helperpath(SPDesktop *desktop, SPCurve *curve, const Geom::Matrix & i2d, guint32 color); -SPCanvasItem *sp_nodepath_generate_helperpath(SPDesktop *desktop, SPItem *item); -void sp_nodepath_show_helperpath(Inkscape::NodePath::Path *nodepath, bool show); -void sp_nodepath_update_helperpaths(Inkscape::NodePath::Path *np); -void sp_nodepath_make_straight_path(Inkscape::NodePath::Path *np); - -void sp_nodepath_selected_nodes_rotate (Inkscape::NodePath::Path * nodepath, gdouble angle, int which, bool screen); - -void sp_nodepath_selected_nodes_scale (Inkscape::NodePath::Path * nodepath, gdouble grow, int which); -void sp_nodepath_selected_nodes_scale_screen (Inkscape::NodePath::Path * nodepath, gdouble grow, int which); - -void sp_nodepath_flip (Inkscape::NodePath::Path *nodepath, Geom::Dim2 axis, boost::optional center); - -#endif -- 2.30.2