update to trunk

(bzr r13645.1.94)

5 files changed, 158 insertions, 114 deletions

diff --git a/src/ui/tools/node-tool.cpp b/src/ui/tools/node-tool.cpp
index ef00eaa40..6a6ca0b26 100644
--- a/src/ui/tools/node-tool.cpp
+++ b/src/ui/tools/node-tool.cpp
@@ -26,6 +26,8 @@
 #include "ui/shape-editor.h" // temporary!
 #include "live_effects/effect.h"
 #include "display/curve.h"
+#include "snap.h"
+#include "sp-namedview.h"
 #include "sp-clippath.h"
 #include "sp-item-group.h"
 #include "sp-mask.h"
@@ -112,7 +114,7 @@ namespace UI {
 namespace Tools {
 
 const std::string& NodeTool::getPrefsPath() {
-	return NodeTool::prefsPath;
+    return NodeTool::prefsPath;
 }
 
 const std::string NodeTool::prefsPath = "/tools/nodes";
@@ -216,7 +218,7 @@ void NodeTool::setup() {
         Inkscape::UI::ControlPoint::signal_mouseover_change.connect(sigc::mem_fun(this, &NodeTool::mouseover_changed));
 
     this->_sizeUpdatedConn = ControlManager::getManager().connectCtrlSizeChanged(
-    		sigc::mem_fun(this, &NodeTool::handleControlUiStyleChange)
+            sigc::mem_fun(this, &NodeTool::handleControlUiStyleChange)
     );
     
     this->_selected_nodes = new Inkscape::UI::ControlPointSelection(this->desktop, this->_transform_handle_group);
@@ -236,14 +238,14 @@ void NodeTool::setup() {
     );
 
     this->_selected_nodes->signal_selection_changed.connect(
-		// Hide both signal parameters and bind the function parameter to 0
-		// sigc::signal<void, SelectableControlPoint *, bool>
-		// <=>
-		// void update_tip(GdkEvent *event)
-		sigc::hide(sigc::hide(sigc::bind(
-				sigc::mem_fun(this, &NodeTool::update_tip),
-				(GdkEvent*)NULL
-		)))
+        // Hide both signal parameters and bind the function parameter to 0
+        // sigc::signal<void, SelectableControlPoint *, bool>
+        // <=>
+        // void update_tip(GdkEvent *event)
+        sigc::hide(sigc::hide(sigc::bind(
+                sigc::mem_fun(this, &NodeTool::update_tip),
+                (GdkEvent*)NULL
+        )))
     );
 
     this->helperpath_tmpitem = NULL;
@@ -359,7 +361,7 @@ void NodeTool::set(const Inkscape::Preferences::Entry& value) {
         this->edit_masks = value.getBool();
         this->selection_changed(this->desktop->selection);
     } else {
-    	ToolBase::set(value);
+        ToolBase::set(value);
     }
 }
 
@@ -370,7 +372,7 @@ void gather_items(NodeTool *nt, SPItem *base, SPObject *obj, Inkscape::UI::Shape
     using namespace Inkscape::UI;
 
     if (!obj) {
-    	return;
+        return;
     }
 
     //XML Tree being used directly here while it shouldn't be.
@@ -446,6 +448,9 @@ void NodeTool::selection_changed(Inkscape::Selection *sel) {
         }
     }
 
+    _previous_selection = _current_selection;
+    _current_selection = sel->itemList();
+
     this->_multipath->setItems(shapes);
     this->update_tip(NULL);
     this->desktop->updateNow();
@@ -458,31 +463,47 @@ bool NodeTool::root_handler(GdkEvent* event) {
      * 3. some keybindings
      */
     using namespace Inkscape::UI; // pull in event helpers
-    
+
     Inkscape::Selection *selection = desktop->selection;
     static Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     if (this->_multipath->event(this, event)) {
-    	return true;
+        return true;
     }
 
     if (this->_selector->event(this, event)) {
-    	return true;
+        return true;
     }
 
     if (this->_selected_nodes->event(this, event)) {
-    	return true;
+        return true;
     }
 
     switch (event->type)
     {
     case GDK_MOTION_NOTIFY: {
-	this->update_helperpath();
+        this->update_helperpath();
         combine_motion_events(desktop->canvas, event->motion, 0);
         this->update_helperpath();
         SPItem *over_item = sp_event_context_find_item (desktop, event_point(event->button),
                 FALSE, TRUE);
 
+        Geom::Point const motion_w(event->motion.x, event->motion.y);
+        Geom::Point const motion_dt(this->desktop->w2d(motion_w));
+
+        SnapManager &m = this->desktop->namedview->snap_manager;
+
+        // We will show a pre-snap indication for when the user adds a node through double-clicking
+        // Adding a node will only work when a path has been selected; if that's not the case then snapping is useless
+        if (not this->desktop->selection->isEmpty()) {
+            if (!(event->motion.state & GDK_SHIFT_MASK)) {
+                m.setup(this->desktop);
+                Inkscape::SnapCandidatePoint scp(motion_dt, Inkscape::SNAPSOURCE_OTHER_HANDLE);
+                m.preSnap(scp, true);
+                m.unSetup();
+            }
+        }
+
         if (over_item != this->_last_over) {
             this->_last_over = over_item;
             //ink_node_tool_update_tip(nt, event);
@@ -491,11 +512,11 @@ bool NodeTool::root_handler(GdkEvent* event) {
         // create pathflash outline
         if (prefs->getBool("/tools/nodes/pathflash_enabled")) {
             if (over_item == this->flashed_item) {
-            	break;
+                break;
             }
 
             if (!prefs->getBool("/tools/nodes/pathflash_selected") && selection->includes(over_item)) {
-            	break;
+                break;
             }
 
             if (this->flash_tempitem) {
@@ -505,14 +526,14 @@ bool NodeTool::root_handler(GdkEvent* event) {
             }
 
             if (!SP_IS_SHAPE(over_item)) {
-            	break; // for now, handle only shapes
+                break; // for now, handle only shapes
             }
 
             this->flashed_item = over_item;
             SPCurve *c = SP_SHAPE(over_item)->getCurveBeforeLPE();
 
             if (!c) {
-            	break; // break out when curve doesn't exist
+                break; // break out when curve doesn't exist
             }
 
             c->transform(over_item->i2dt_affine());
@@ -575,11 +596,42 @@ bool NodeTool::root_handler(GdkEvent* event) {
 
     case GDK_KEY_RELEASE:
         //ink_node_tool_update_tip(nt, event);
-    	this->update_tip(event);
+        this->update_tip(event);
+        break;
+
+    case GDK_BUTTON_RELEASE:
+        if (this->_selector->doubleClicked()) {
+            // If the selector received the doubleclick event, then we're at some distance from
+            // the path; otherwise, the doubleclick event would have been received by
+            // CurveDragPoint; we will insert nodes into the path anyway but only if we can snap
+            // to the path. Otherwise the position would not be very well defined.
+            if (!(event->motion.state & GDK_SHIFT_MASK)) {
+                Geom::Point const motion_w(event->motion.x, event->motion.y);
+                Geom::Point const motion_dt(this->desktop->w2d(motion_w));
+
+                SnapManager &m = this->desktop->namedview->snap_manager;
+                m.setup(this->desktop);
+                Inkscape::SnapCandidatePoint scp(motion_dt, Inkscape::SNAPSOURCE_OTHER_HANDLE);
+                Inkscape::SnappedPoint sp = m.freeSnap(scp, Geom::OptRect(), true);
+                m.unSetup();
+
+                if (sp.getSnapped()) {
+                    // The first click of the double click will have cleared the path selection, because
+                    // we clicked aside of the path. We need to undo this on double click
+                    Inkscape::Selection *selection = desktop->getSelection();
+                    selection->addList(_previous_selection);
+
+                    // The selection has been restored, and the signal selection_changed has been emitted,
+                    // which has again forced a restore of the _mmap variable of the MultiPathManipulator (this->_multipath)
+                    // Now we can insert the new nodes as if nothing has happened!
+                    this->_multipath->insertNode(this->desktop->d2w(sp.getPoint()));
+                }
+            }
+        }
         break;
 
     default:
-    	break;
+        break;
     }
     
     return ToolBase::root_handler(event);
@@ -592,7 +644,7 @@ void NodeTool::update_tip(GdkEvent *event) {
         unsigned new_state = state_after_event(event);
 
         if (new_state == event->key.state) {
-        	return;
+            return;
         }
 
         if (state_held_shift(new_state)) {
@@ -613,9 +665,27 @@ void NodeTool::update_tip(GdkEvent *event) {
     unsigned total = this->_selected_nodes->allPoints().size();
 
     if (sz != 0) {
-        char *nodestring = g_strdup_printf(
-            ngettext("<b>%u of %u</b> node selected.", "<b>%u of %u</b> nodes selected.", total),
-            sz, total);
+        char *nodestring; 
+        if (sz == 2) {
+            // if there are only two nodes selected, display the angle
+            // of a line going through them relative to the X axis.
+            Inkscape::UI::ControlPointSelection::Set &selection_nodes = this->_selected_nodes->allPoints();
+            std::vector<Geom::Point> positions;
+            for (Inkscape::UI::ControlPointSelection::Set::iterator i = selection_nodes.begin(); i != selection_nodes.end(); ++i) {
+                if ((*i)->selected()) {
+                    Inkscape::UI::Node *n = dynamic_cast<Inkscape::UI::Node *>(*i);
+                    positions.push_back(n->position());
+                }
+            }
+            g_assert(positions.size() == 2);
+            const double angle = Geom::rad_to_deg(Geom::Line(positions[0], positions[1]).angle());
+            nodestring = g_strdup_printf("<b>%u of %u</b> nodes selected, angle: %.2f°.", sz, total, angle);
+        }
+        else {
+            nodestring = g_strdup_printf(
+                ngettext("<b>%u of %u</b> node selected.", "<b>%u of %u</b> nodes selected.", total),
+                sz, total);
+        }
 
         if (this->_last_over) {
             // TRANSLATORS: The %s below is where the "%u of %u nodes selected" sentence gets put
@@ -661,7 +731,7 @@ void NodeTool::select_area(Geom::Rect const &sel, GdkEventButton *event) {
         selection->setList(items);
     } else {
         if (!held_shift(*event)) {
-        	this->_selected_nodes->clear();
+            this->_selected_nodes->clear();
         }
 
         this->_selected_nodes->selectArea(sel);
@@ -672,11 +742,11 @@ void NodeTool::select_point(Geom::Point const &/*sel*/, GdkEventButton *event) {
     using namespace Inkscape::UI; // pull in event helpers
 
     if (!event) {
-    	return;
+        return;
     }
 
     if (event->button != 1) {
-    	return;
+        return;
     }
 
     Inkscape::Selection *selection = this->desktop->selection;
diff --git a/src/ui/tools/node-tool.h b/src/ui/tools/node-tool.h
index 20375e869..8342d66a6 100644
--- a/src/ui/tools/node-tool.h
+++ b/src/ui/tools/node-tool.h
@@ -19,18 +19,18 @@
 #include "selection.h"
 
 namespace Inkscape {
-	namespace Display {
-		class TemporaryItem;
-	}
-
-	namespace UI {
-		class MultiPathManipulator;
-		class ControlPointSelection;
-		class Selector;
-		class ControlPoint;
-
-		struct PathSharedData;
-	}
+    namespace Display {
+        class TemporaryItem;
+    }
+
+    namespace UI {
+        class MultiPathManipulator;
+        class ControlPointSelection;
+        class Selector;
+        class ControlPoint;
+
+        struct PathSharedData;
+    }
 }
 
 struct SPCanvasGroup;
@@ -44,26 +44,26 @@ namespace Tools {
 
 class NodeTool : public ToolBase {
 public:
-	NodeTool();
-	virtual ~NodeTool();
+    NodeTool();
+    virtual ~NodeTool();
 
-	Inkscape::UI::ControlPointSelection* _selected_nodes;
+    Inkscape::UI::ControlPointSelection* _selected_nodes;
     Inkscape::UI::MultiPathManipulator* _multipath;
 
     bool edit_clipping_paths;
     bool edit_masks;
 
-	static const std::string prefsPath;
+    static const std::string prefsPath;
 
-	virtual void setup();
-	virtual void update_helperpath();
-	virtual void set(const Inkscape::Preferences::Entry& val);
-	virtual bool root_handler(GdkEvent* event);
+    virtual void setup();
+    virtual void update_helperpath();
+    virtual void set(const Inkscape::Preferences::Entry& val);
+    virtual bool root_handler(GdkEvent* event);
 
-	virtual const std::string& getPrefsPath();
+    virtual const std::string& getPrefsPath();
 
 private:
-	sigc::connection _selection_changed_connection;
+    sigc::connection _selection_changed_connection;
     sigc::connection _mouseover_changed_connection;
     sigc::connection _sizeUpdatedConn;
 
@@ -85,13 +85,16 @@ private:
     bool show_transform_handles;
     bool single_node_transform_handles;
 
-	void selection_changed(Inkscape::Selection *sel);
+    std::vector<SPItem*> _current_selection;
+    std::vector<SPItem*> _previous_selection;
 
-	void select_area(Geom::Rect const &sel, GdkEventButton *event);
-	void select_point(Geom::Point const &sel, GdkEventButton *event);
-	void mouseover_changed(Inkscape::UI::ControlPoint *p);
-	void update_tip(GdkEvent *event);
-	void handleControlUiStyleChange();
+    void selection_changed(Inkscape::Selection *sel);
+
+    void select_area(Geom::Rect const &sel, GdkEventButton *event);
+    void select_point(Geom::Point const &sel, GdkEventButton *event);
+    void mouseover_changed(Inkscape::UI::ControlPoint *p);
+    void update_tip(GdkEvent *event);
+    void handleControlUiStyleChange();
 };
 
 }
diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp
index ba103fa8e..16c26546f 100644
--- a/src/ui/tools/pencil-tool.cpp
+++ b/src/ui/tools/pencil-tool.cpp
@@ -53,6 +53,7 @@ static Geom::Point pencil_drag_origin_w(0, 0);
 static bool pencil_within_tolerance = false;
 
 static bool in_svg_plane(Geom::Point const &p) { return Geom::LInfty(p) < 1e18; }
+const double HANDLE_CUBIC_GAP = 0.01;
 
 const std::string& PencilTool::getPrefsPath() {
 	return PencilTool::prefsPath;
@@ -660,10 +661,10 @@ void PencilTool::_interpolate() {
         for (int c = 0; c < n_segs; c++) {
             // if we are in BSpline we modify the trace to create adhoc nodes 
             if(mode == 2){
-                Geom::Point point_at1 = b[4*c+0] + (1./3)*(b[4*c+3] - b[4*c+0]);
-                point_at1 = Geom::Point(point_at1[X] + 0.0001,point_at1[Y] + 0.0001);
-                Geom::Point point_at2 = b[4*c+3] + (1./3)*(b[4*c+0] - b[4*c+3]);
-                point_at2 = Geom::Point(point_at2[X] + 0.0001,point_at2[Y] + 0.0001);
+                Geom::Point point_at1 = b[4 * c + 0] + (1./3) * (b[4 * c + 3] - b[4 * c + 0]);
+                point_at1 = Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP);
+                Geom::Point point_at2 = b[4 * c + 3] + (1./3) * (b[4 * c + 0] - b[4 * c + 3]);
+                point_at2 = Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP);
                 this->green_curve->curveto(point_at1,point_at2,b[4*c+3]);
             }else{
                 this->green_curve->curveto(b[4 * c + 1], b[4 * c + 2], b[4 * c + 3]);
@@ -808,9 +809,9 @@ void PencilTool::_fitAndSplit() {
         guint mode = prefs->getInt("/tools/freehand/pencil/freehand-mode", 0);
         if(mode == 2){
             Geom::Point point_at1 = b[0] + (1./3)*(b[3] - b[0]);
-            point_at1 = Geom::Point(point_at1[X] + 0.0001,point_at1[Y] + 0.0001);
+            point_at1 = Geom::Point(point_at1[X] + HANDLE_CUBIC_GAP, point_at1[Y] + HANDLE_CUBIC_GAP);
             Geom::Point point_at2 = b[3] + (1./3)*(b[0] - b[3]);
-            point_at2 = Geom::Point(point_at2[X] + 0.0001,point_at2[Y] + 0.0001);
+            point_at2 = Geom::Point(point_at2[X] + HANDLE_CUBIC_GAP, point_at2[Y] + HANDLE_CUBIC_GAP);
             this->red_curve->curveto(point_at1,point_at2,b[3]);
         }else{
             this->red_curve->curveto(b[1], b[2], b[3]);
diff --git a/src/ui/tools/spray-tool.cpp b/src/ui/tools/spray-tool.cpp
index 26d74733a..14595740d 100644
--- a/src/ui/tools/spray-tool.cpp
+++ b/src/ui/tools/spray-tool.cpp
@@ -133,14 +133,13 @@ SprayTool::SprayTool()
     : ToolBase(cursor_spray_xpm, 4, 4, false)
     , pressure(TC_DEFAULT_PRESSURE)
     , dragging(false)
-    , usepressure(0)
-    , usetilt(0)
+    , usepressure(false)
+    , usetilt(false)
     , usetext(false)
     , width(0.2)
     , ratio(0)
     , tilt(0)
     , rotation_variation(0)
-    , force(0.2)
     , population(0)
     , scale_variation(1)
     , scale(1)
@@ -165,14 +164,6 @@ SprayTool::~SprayTool() {
     }
 }
 
-static bool is_transform_modes(gint mode)
-{
-    return (mode == SPRAY_MODE_COPY ||
-            mode == SPRAY_MODE_CLONE ||
-            mode == SPRAY_MODE_SINGLE_PATH ||
-            mode == SPRAY_OPTION);
-}
-
 void SprayTool::update_cursor(bool /*with_shift*/) {
     guint num = 0;
     gchar *sel_message = NULL;
@@ -229,7 +220,6 @@ void SprayTool::setup() {
     sp_event_context_read(this, "scale_variation");
     sp_event_context_read(this, "mode");
     sp_event_context_read(this, "population");
-    sp_event_context_read(this, "force");
     sp_event_context_read(this, "mean");
     sp_event_context_read(this, "standard_deviation");
     sp_event_context_read(this, "usepressure");
@@ -271,9 +261,7 @@ void SprayTool::set(const Inkscape::Preferences::Entry& val) {
         this->tilt = CLAMP(val.getDouble(0.1), 0, 1000.0);
     } else if (path == "ratio") {
         this->ratio = CLAMP(val.getDouble(), 0.0, 0.9);
-    } else if (path == "force") {
-        this->force = CLAMP(val.getDouble(1.0), 0, 1.0);
-    } 
+    }
 }
 
 static void sp_spray_extinput(SprayTool *tc, GdkEvent *event)
@@ -290,16 +278,6 @@ static double get_dilate_radius(SprayTool *tc)
     return 250 * tc->width/SP_EVENT_CONTEXT(tc)->desktop->current_zoom();
 }
 
-static double get_path_force(SprayTool *tc)
-{
-    double force = 8 * (tc->usepressure? tc->pressure : TC_DEFAULT_PRESSURE)
-        /sqrt(SP_EVENT_CONTEXT(tc)->desktop->current_zoom());
-    if (force > 3) {
-        force += 4 * (force - 3);
-    }
-    return force * tc->force;
-}
-
 static double get_path_mean(SprayTool *tc)
 {
     return tc->mean;
@@ -310,10 +288,11 @@ static double get_path_standard_deviation(SprayTool *tc)
     return tc->standard_deviation;
 }
 
-static double get_move_force(SprayTool *tc)
+static double get_population(SprayTool *tc)
 {
-    double force = (tc->usepressure? tc->pressure : TC_DEFAULT_PRESSURE);
-    return force * tc->force;
+    double pressure = (tc->usepressure? tc->pressure / TC_DEFAULT_PRESSURE : 1);
+    //g_warning("Pressure, population: %f, %f", pressure, pressure * tc->population);
+    return pressure * tc->population;
 }
 
 static double get_move_mean(SprayTool *tc)
@@ -361,7 +340,6 @@ static bool sp_spray_recursive(SPDesktop *desktop,
                                Geom::Point /*vector*/,
                                gint mode,
                                double radius,
-                               double /*force*/,
                                double population,
                                double &scale,
                                double scale_variation,
@@ -525,8 +503,8 @@ static bool sp_spray_dilate(SprayTool *tc, Geom::Point /*event_p*/, Geom::Point
 
     bool did = false;
     double radius = get_dilate_radius(tc);
-    double path_force = get_path_force(tc);
-    if (radius == 0 || path_force == 0) {
+    double population = get_population(tc);
+    if (radius == 0 || population == 0) {
         return false;
     }
     double path_mean = get_path_mean(tc);
@@ -537,12 +515,11 @@ static bool sp_spray_dilate(SprayTool *tc, Geom::Point /*event_p*/, Geom::Point
     if (radius == 0 || path_standard_deviation == 0) {
         return false;
     }
-    double move_force = get_move_force(tc);
     double move_mean = get_move_mean(tc);
     double move_standard_deviation = get_move_standard_deviation(tc);
 
     {
-    	std::vector<SPItem*> const items(selection->itemList());
+        std::vector<SPItem*> const items(selection->itemList());
 
         for(std::vector<SPItem*>::const_iterator i=items.begin();i!=items.end();i++){
             SPItem *item = *i;
@@ -554,14 +531,8 @@ static bool sp_spray_dilate(SprayTool *tc, Geom::Point /*event_p*/, Geom::Point
             SPItem *item = *i;
             g_assert(item != NULL);
 
-            if (is_transform_modes(tc->mode)) {
-                if (sp_spray_recursive(desktop, selection, item, p, vector, tc->mode, radius, move_force, tc->population, tc->scale, tc->scale_variation, reverse, move_mean, move_standard_deviation, tc->ratio, tc->tilt, tc->rotation_variation, tc->distrib)) {
-                    did = true;
-                }
-            } else {
-                if (sp_spray_recursive(desktop, selection, item, p, vector, tc->mode, radius, path_force, tc->population, tc->scale, tc->scale_variation, reverse, path_mean, path_standard_deviation, tc->ratio, tc->tilt, tc->rotation_variation, tc->distrib)) {
-                    did = true;
-                }
+            if (sp_spray_recursive(desktop, selection, item, p, vector, tc->mode, radius, population, tc->scale, tc->scale_variation, reverse, move_mean, move_standard_deviation, tc->ratio, tc->tilt, tc->rotation_variation, tc->distrib)) {
+                did = true;
             }
         }
 
diff --git a/src/ui/tools/spray-tool.h b/src/ui/tools/spray-tool.h
index 1a8f98006..8df730201 100644
--- a/src/ui/tools/spray-tool.h
+++ b/src/ui/tools/spray-tool.h
@@ -52,8 +52,8 @@ enum {
 
 class SprayTool : public ToolBase {
 public:
-	SprayTool();
-	virtual ~SprayTool();
+    SprayTool();
+    virtual ~SprayTool();
 
     //ToolBase event_context;
     //Inkscape::UI::Dialog::Dialog *dialog_option;//Attribut de type SprayOptionClass, localisé dans scr/ui/dialog    
@@ -70,7 +70,6 @@ public:
     double ratio;
     double tilt;
     double rotation_variation;
-    double force;
     double population;
     double scale_variation;
     double scale;
@@ -90,16 +89,16 @@ public:
 
     sigc::connection style_set_connection;
 
-	static const std::string prefsPath;
+    static const std::string prefsPath;
 
-	virtual void setup();
-	virtual void set(const Inkscape::Preferences::Entry& val);
-	virtual bool root_handler(GdkEvent* event);
+    virtual void setup();
+    virtual void set(const Inkscape::Preferences::Entry& val);
+    virtual bool root_handler(GdkEvent* event);
 
-	virtual const std::string& getPrefsPath();
+    virtual const std::string& getPrefsPath();
 
 
-	void update_cursor(bool /*with_shift*/);
+    void update_cursor(bool /*with_shift*/);
 };
 
 }