update to trunk

(bzr r11950.1.315)

19 files changed, 461 insertions, 405 deletions

diff --git a/src/ui/dialog/spellcheck.cpp b/src/ui/dialog/spellcheck.cpp
index 00bd445bf..8a4ddc57e 100644
--- a/src/ui/dialog/spellcheck.cpp
+++ b/src/ui/dialog/spellcheck.cpp
@@ -590,52 +590,54 @@ SpellCheck::nextWord()
         // draw rect
         std::vector<Geom::Point> points =
             _layout->createSelectionShape(_begin_w, _end_w, _text->i2dt_affine());
-        Geom::Point tl, br;
-        tl = br = points.front();
-        for (unsigned i = 0 ; i < points.size() ; i ++) {
-            if (points[i][Geom::X] < tl[Geom::X])
-                tl[Geom::X] = points[i][Geom::X];
-            if (points[i][Geom::Y] < tl[Geom::Y])
-                tl[Geom::Y] = points[i][Geom::Y];
-            if (points[i][Geom::X] > br[Geom::X])
-                br[Geom::X] = points[i][Geom::X];
-            if (points[i][Geom::Y] > br[Geom::Y])
-                br[Geom::Y] = points[i][Geom::Y];
-        }
+        if (points.size() >= 4) { // we may not have a single quad if this is a clipped part of text on path; in that case skip drawing the rect
+            Geom::Point tl, br;
+            tl = br = points.front();
+            for (unsigned i = 0 ; i < points.size() ; i ++) {
+                if (points[i][Geom::X] < tl[Geom::X])
+                    tl[Geom::X] = points[i][Geom::X];
+                if (points[i][Geom::Y] < tl[Geom::Y])
+                    tl[Geom::Y] = points[i][Geom::Y];
+                if (points[i][Geom::X] > br[Geom::X])
+                    br[Geom::X] = points[i][Geom::X];
+                if (points[i][Geom::Y] > br[Geom::Y])
+                    br[Geom::Y] = points[i][Geom::Y];
+            }
 
-        // expand slightly
-        Geom::Rect area = Geom::Rect(tl, br);
-        double mindim = fabs(tl[Geom::Y] - br[Geom::Y]);
-        if (fabs(tl[Geom::X] - br[Geom::X]) < mindim)
-            mindim = fabs(tl[Geom::X] - br[Geom::X]);
-        area.expandBy(MAX(0.05 * mindim, 1));
-
-        // create canvas path rectangle, red stroke
-        SPCanvasItem *rect = sp_canvas_bpath_new(sp_desktop_sketch(desktop), NULL);
-        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(rect), 0xff0000ff, 3.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
-        sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(rect), 0, SP_WIND_RULE_NONZERO);
-        SPCurve *curve = new SPCurve();
-        curve->moveto(area.corner(0));
-        curve->lineto(area.corner(1));
-        curve->lineto(area.corner(2));
-        curve->lineto(area.corner(3));
-        curve->lineto(area.corner(0));
-        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(rect), curve);
-        sp_canvas_item_show(rect);
-        _rects = g_slist_prepend(_rects, rect);
-
-        // scroll to make it all visible
-        Geom::Point const center = desktop->get_display_area().midpoint();
-        area.expandBy(0.5 * mindim);
-        Geom::Point scrollto;
-        double dist = 0;
-        for (unsigned corner = 0; corner < 4; corner ++) {
-            if (Geom::L2(area.corner(corner) - center) > dist) {
-                dist = Geom::L2(area.corner(corner) - center);
-                scrollto = area.corner(corner);
+            // expand slightly
+            Geom::Rect area = Geom::Rect(tl, br);
+            double mindim = fabs(tl[Geom::Y] - br[Geom::Y]);
+            if (fabs(tl[Geom::X] - br[Geom::X]) < mindim)
+                mindim = fabs(tl[Geom::X] - br[Geom::X]);
+            area.expandBy(MAX(0.05 * mindim, 1));
+
+            // create canvas path rectangle, red stroke
+            SPCanvasItem *rect = sp_canvas_bpath_new(sp_desktop_sketch(desktop), NULL);
+            sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(rect), 0xff0000ff, 3.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+            sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(rect), 0, SP_WIND_RULE_NONZERO);
+            SPCurve *curve = new SPCurve();
+            curve->moveto(area.corner(0));
+            curve->lineto(area.corner(1));
+            curve->lineto(area.corner(2));
+            curve->lineto(area.corner(3));
+            curve->lineto(area.corner(0));
+            sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(rect), curve);
+            sp_canvas_item_show(rect);
+            _rects = g_slist_prepend(_rects, rect);
+
+            // scroll to make it all visible
+            Geom::Point const center = desktop->get_display_area().midpoint();
+            area.expandBy(0.5 * mindim);
+            Geom::Point scrollto;
+            double dist = 0;
+            for (unsigned corner = 0; corner < 4; corner ++) {
+                if (Geom::L2(area.corner(corner) - center) > dist) {
+                    dist = Geom::L2(area.corner(corner) - center);
+                    scrollto = area.corner(corner);
+                }
             }
+            desktop->scroll_to_point (scrollto, 1.0);
         }
-        desktop->scroll_to_point (scrollto, 1.0);
 
         // select text; if in Text tool, position cursor to the beginning of word
         // unless it is already in the word
diff --git a/src/ui/tools/arc-tool.h b/src/ui/tools/arc-tool.h
index eaa50f2b9..c4c67660d 100644
--- a/src/ui/tools/arc-tool.h
+++ b/src/ui/tools/arc-tool.h
@@ -16,12 +16,18 @@
  */
 
 #include <stddef.h>
-#include <sigc++/connection.h>
 
 #include <2geom/point.h>
+#include <sigc++/connection.h>
+
 #include "ui/tools/tool-base.h"
 
-#include "sp-ellipse.h"
+class SPItem;
+class SPGenericEllipse;
+
+namespace Inkscape {
+    class Selection;
+}
 
 #define SP_ARC_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::ArcTool*>((Inkscape::UI::Tools::ToolBase*)obj))
 #define SP_IS_ARC_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::ArcTool*>(const Inkscape::UI::Tools::ToolBase*(obj)) != NULL)
diff --git a/src/ui/tools/box3d-tool.h b/src/ui/tools/box3d-tool.h
index 99bf99a7a..1dd6bb5f8 100644
--- a/src/ui/tools/box3d-tool.h
+++ b/src/ui/tools/box3d-tool.h
@@ -16,12 +16,25 @@
  */
 
 #include <stddef.h>
-#include <sigc++/sigc++.h>
-#include "ui/tools/tool-base.h"
+
+#include <2geom/point.h>
+#include <sigc++/connection.h>
+
 #include "proj_pt.h"
 #include "vanishing-point.h"
 
-#include "box3d.h"
+#include "ui/tools/tool-base.h"
+
+class SPItem;
+class SPBox3D;
+
+namespace Box3D {
+    struct VPDrag;
+}
+
+namespace Inkscape {
+    class Selection;
+}
 
 #define SP_BOX3D_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::Box3dTool*>((Inkscape::UI::Tools::ToolBase*)obj))
 #define SP_IS_BOX3D_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::Box3dTool*>((const Inkscape::UI::Tools::ToolBase*)obj) != NULL)
diff --git a/src/ui/tools/calligraphic-tool.h b/src/ui/tools/calligraphic-tool.h
index 926e9d126..83b4d73ff 100644
--- a/src/ui/tools/calligraphic-tool.h
+++ b/src/ui/tools/calligraphic-tool.h
@@ -18,8 +18,16 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <list>
+#include <string>
+
+#include <2geom/point.h>
+
 #include "ui/tools/dynamic-base.h"
-#include "splivarot.h"
+
+class SPItem;
+class Path;
+struct SPCanvasItem;
 
 #define DDC_MIN_PRESSURE      0.0
 #define DDC_MAX_PRESSURE      1.0
diff --git a/src/ui/tools/connector-tool.cpp b/src/ui/tools/connector-tool.cpp
index d2e23837c..e19f35832 100644
--- a/src/ui/tools/connector-tool.cpp
+++ b/src/ui/tools/connector-tool.cpp
@@ -379,7 +379,7 @@ cc_deselect_handle(SPKnot* knot)
 }
 
 bool ConnectorTool::item_handler(SPItem* item, GdkEvent* event) {
-    gint ret = FALSE;
+    bool ret = false;
 
     Geom::Point p(event->button.x, event->button.y);
 
@@ -412,7 +412,7 @@ bool ConnectorTool::item_handler(SPItem* item, GdkEvent* event) {
                     }
                 }
 
-                ret = TRUE;
+                ret = true;
             }
             break;
 
@@ -422,7 +422,7 @@ bool ConnectorTool::item_handler(SPItem* item, GdkEvent* event) {
                     this->_setActiveShape(item);
                 }
 
-                ret = TRUE;
+                ret = true;
             }
             break;
 
@@ -434,7 +434,7 @@ bool ConnectorTool::item_handler(SPItem* item, GdkEvent* event) {
 }
 
 bool ConnectorTool::root_handler(GdkEvent* event) {
-    gint ret = FALSE;
+    bool ret = false;
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
@@ -465,24 +465,19 @@ bool ConnectorTool::root_handler(GdkEvent* event) {
 }
 
 
-gint ConnectorTool::_handleButtonPress(GdkEventButton const &bevent) {
+bool ConnectorTool::_handleButtonPress(GdkEventButton const &bevent) {
     Geom::Point const event_w(bevent.x, bevent.y);
     /* Find desktop coordinates */
     Geom::Point p = this->desktop->w2d(event_w);
-    ToolBase *event_context = SP_EVENT_CONTEXT(this);
 
-    gint ret = FALSE;
-
-        if ( bevent.button == 1 && !event_context->space_panning ) {
-
-            SPDesktop *desktop = this->desktop;
+    bool ret = false;
 
+        if ( bevent.button == 1 && !this->space_panning ) {
             if (Inkscape::have_viable_layer(desktop, this->message_context) == false) {
-                return TRUE;
+                return true;
             }
 
-            Geom::Point const event_w(bevent.x,
-                                    bevent.y);
+            Geom::Point const event_w(bevent.x, bevent.y);
 
             this->xp = bevent.x;
             this->yp = bevent.y;
@@ -520,7 +515,7 @@ gint ConnectorTool::_handleButtonPress(GdkEventButton const &bevent) {
 
                     }
                     this->state = SP_CONNECTOR_CONTEXT_DRAGGING;
-                    ret = TRUE;
+                    ret = true;
                     break;
                 }
                 case SP_CONNECTOR_CONTEXT_DRAGGING:
@@ -539,7 +534,7 @@ gint ConnectorTool::_handleButtonPress(GdkEventButton const &bevent) {
                     }
                     this->cc_set_active_conn(this->newconn);
                     this->state = SP_CONNECTOR_CONTEXT_IDLE;
-                    ret = TRUE;
+                    ret = true;
                     break;
                 }
                 case SP_CONNECTOR_CONTEXT_CLOSE:
@@ -564,20 +559,19 @@ gint ConnectorTool::_handleButtonPress(GdkEventButton const &bevent) {
             else if (this->npoints != 0) {
                 this->_finish();
                 this->state = SP_CONNECTOR_CONTEXT_IDLE;
-                ret = TRUE;
+                ret = true;
             }
         }
     return ret;
 }
 
-gint ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
-    gint ret = FALSE;
-    ToolBase *event_context = SP_EVENT_CONTEXT(this);
+bool ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
+    bool ret = false;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
-    if (event_context->space_panning || mevent.state & GDK_BUTTON2_MASK || mevent.state & GDK_BUTTON3_MASK) {
+    if (this->space_panning || mevent.state & GDK_BUTTON2_MASK || mevent.state & GDK_BUTTON3_MASK) {
         // allow middle-button scrolling
-        return FALSE;
+        return false;
     }
 
     Geom::Point const event_w(mevent.x, mevent.y);
@@ -586,7 +580,7 @@ gint ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
         this->tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
         if ( ( abs( (gint) mevent.x - this->xp ) < this->tolerance ) &&
              ( abs( (gint) mevent.y - this->yp ) < this->tolerance ) ) {
-            return FALSE;   // Do not drag if we're within tolerance from origin.
+            return false;   // Do not drag if we're within tolerance from origin.
         }
     }
     // Once the user has moved farther than tolerance from the original location
@@ -594,12 +588,10 @@ gint ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
     // the motion notify coordinates as given (no snapping back to origin)
     this->within_tolerance = false;
 
-    SPDesktop *const dt = this->desktop;
-
     /* Find desktop coordinates */
-    Geom::Point p = dt->w2d(event_w);
+    Geom::Point p = desktop->w2d(event_w);
 
-        SnapManager &m = dt->namedview->snap_manager;
+        SnapManager &m = desktop->namedview->snap_manager;
 
         switch (this->state) {
             case SP_CONNECTOR_CONTEXT_DRAGGING:
@@ -607,12 +599,12 @@ gint ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                 gobble_motion_events(mevent.state);
                 // This is movement during a connector creation.
                 if ( this->npoints > 0 ) {
-                    m.setup(dt);
+                    m.setup(desktop);
                     m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_OTHER_HANDLE);
                     m.unSetup();
                     this->selection->clear();
                     this->_setSubsequentPoint(p);
-                    ret = TRUE;
+                    ret = true;
                 }
                 break;
             }
@@ -621,7 +613,7 @@ gint ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                 gobble_motion_events(GDK_BUTTON1_MASK);
                 g_assert( SP_IS_PATH(this->clickeditem));
 
-                m.setup(dt);
+                m.setup(desktop);
                 m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_OTHER_HANDLE);
                 m.unSetup();
 
@@ -645,7 +637,7 @@ gint ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                 this->red_curve->transform(i2d);
 
                 sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
-                ret = TRUE;
+                ret = true;
                 break;
             }
             case SP_CONNECTOR_CONTEXT_STOP:
@@ -653,7 +645,7 @@ gint ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                 break;
             default:
                 if (!this->sp_event_context_knot_mouseover()) {
-                    m.setup(dt);
+                    m.setup(desktop);
                     m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_OTHER_HANDLE));
                     m.unSetup();
                 }
@@ -662,14 +654,11 @@ gint ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
     return ret;
 }
 
-gint ConnectorTool::_handleButtonRelease(GdkEventButton const &revent) {
-    gint ret = FALSE;
-    ToolBase *event_context = SP_EVENT_CONTEXT(this);
-    if ( revent.button == 1 && !event_context->space_panning ) {
+bool ConnectorTool::_handleButtonRelease(GdkEventButton const &revent) {
+    bool ret = false;
 
-        SPDesktop *desktop = this->desktop;
+    if ( revent.button == 1 && !this->space_panning ) {
         SPDocument *doc = sp_desktop_document(desktop);
-
         SnapManager &m = desktop->namedview->snap_manager;
 
         Geom::Point const event_w(revent.x, revent.y);
@@ -688,7 +677,7 @@ gint ConnectorTool::_handleButtonRelease(GdkEventButton const &revent) {
                     if (this->within_tolerance)
                     {
                         this->_finishSegment(p);
-                        return TRUE;
+                        return true;
                     }
                     // Connector has been created via a drag, end it now.
                     this->_setSubsequentPoint(p);
@@ -711,7 +700,7 @@ gint ConnectorTool::_handleButtonRelease(GdkEventButton const &revent) {
 
                     doc->ensureUpToDate();
                     this->state = SP_CONNECTOR_CONTEXT_IDLE;
-                    return TRUE;
+                    return true;
                     break;
                 }
                 case SP_CONNECTOR_CONTEXT_STOP:
@@ -720,13 +709,13 @@ gint ConnectorTool::_handleButtonRelease(GdkEventButton const &revent) {
                 default:
                     break;
             }
-            ret = TRUE;
+            ret = true;
         }
     return ret;
 }
 
-gint ConnectorTool::_handleKeyPress(guint const keyval) {
-    gint ret = FALSE;
+bool ConnectorTool::_handleKeyPress(guint const keyval) {
+    bool ret = false;
 
         switch (keyval) {
             case GDK_KEY_Return:
@@ -734,13 +723,11 @@ gint ConnectorTool::_handleKeyPress(guint const keyval) {
                 if (this->npoints != 0) {
                     this->_finish();
                     this->state = SP_CONNECTOR_CONTEXT_IDLE;
-                    ret = TRUE;
+                    ret = true;
                 }
                 break;
             case GDK_KEY_Escape:
                 if (this->state == SP_CONNECTOR_CONTEXT_REROUTING) {
-
-                    SPDesktop *desktop = this->desktop;
                     SPDocument *doc = sp_desktop_document(desktop);
 
                     this->_reroutingFinish(NULL);
@@ -750,13 +737,13 @@ gint ConnectorTool::_handleKeyPress(guint const keyval) {
                     this->state = SP_CONNECTOR_CONTEXT_IDLE;
                     desktop->messageStack()->flash( Inkscape::NORMAL_MESSAGE,
                             _("Connector endpoint drag cancelled."));
-                    ret = TRUE;
+                    ret = true;
                 }
                 else if (this->npoints != 0) {
                     // if drawing, cancel, otherwise pass it up for deselecting
                     this->state = SP_CONNECTOR_CONTEXT_STOP;
                     this->_resetColors();
-                    ret = TRUE;
+                    ret = true;
                 }
                 break;
             default:
@@ -766,7 +753,6 @@ gint ConnectorTool::_handleKeyPress(guint const keyval) {
 }
 
 void ConnectorTool::_reroutingFinish(Geom::Point *const p) {
-    SPDesktop *desktop = this->desktop;
     SPDocument *doc = sp_desktop_document(desktop);
 
     // Clear the temporary path:
@@ -819,14 +805,13 @@ void ConnectorTool::_setInitialPoint(Geom::Point const p) {
 void ConnectorTool::_setSubsequentPoint(Geom::Point const p) {
     g_assert( this->npoints != 0 );
 
-    SPDesktop *dt = this->desktop;
-    Geom::Point o = dt->dt2doc(this->p[0]);
-    Geom::Point d = dt->dt2doc(p);
+    Geom::Point o = desktop->dt2doc(this->p[0]);
+    Geom::Point d = desktop->dt2doc(p);
     Avoid::Point src(o[Geom::X], o[Geom::Y]);
     Avoid::Point dst(d[Geom::X], d[Geom::Y]);
 
     if (!this->newConnRef) {
-        Avoid::Router *router = sp_desktop_document(dt)->router;
+        Avoid::Router *router = sp_desktop_document(desktop)->router;
         this->newConnRef = new Avoid::ConnRef(router);
         this->newConnRef->setEndpoint(Avoid::VertID::src, src);
         if (this->isOrthogonal)
@@ -841,7 +826,7 @@ void ConnectorTool::_setSubsequentPoint(Geom::Point const p) {
     this->newConnRef->router()->processTransaction();
     // Recreate curve from libavoid route.
     recreateCurve( this->red_curve, this->newConnRef, this->curvature );
-    this->red_curve->transform(dt->doc2dt());
+    this->red_curve->transform(desktop->doc2dt());
     sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
 }
 
@@ -890,7 +875,6 @@ void ConnectorTool::_flushWhite(SPCurve *gc) {
     /* Now we have to go back to item coordinates at last */
     c->transform(this->desktop->dt2doc());
 
-    SPDesktop *desktop = this->desktop;
     SPDocument *doc = sp_desktop_document(desktop);
     Inkscape::XML::Document *xml_doc = doc->getReprDoc();
 
@@ -965,7 +949,6 @@ void ConnectorTool::_finishSegment(Geom::Point const /*p*/) {
 }
 
 void ConnectorTool::_finish() {
-    SPDesktop *const desktop = this->desktop;
     desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Finishing connector"));
 
     this->red_curve->reset();
@@ -1083,7 +1066,6 @@ endpt_handler(SPKnot */*knot*/, GdkEvent *event, ConnectorTool *cc)
 }
 
 void ConnectorTool::_activeShapeAddKnot(SPItem* item) {
-        SPDesktop *desktop = this->desktop;
         SPKnot *knot = sp_knot_new(desktop, 0);
 
         knot->owner = item;
@@ -1096,10 +1078,12 @@ void ConnectorTool::_activeShapeAddKnot(SPItem* item) {
         // We don't want to use the standard knot handler.
         g_signal_handler_disconnect(G_OBJECT(knot->item),
                 knot->_event_handler_id);
+
         knot->_event_handler_id = 0;
 
         g_signal_connect(G_OBJECT(knot->item), "event",
                 G_CALLBACK(cc_generic_knot_handler), knot);
+
         sp_knot_set_position(knot, item->avoidRef->getConnectionPointPos() * desktop->doc2dt(), 0);
         sp_knot_show(knot);
         this->knots[knot] = 1;
@@ -1198,7 +1182,6 @@ void ConnectorTool::cc_set_active_conn(SPItem *item) {
     }
 
     for (int i = 0; i < 2; ++i) {
-
         // Create the handle if it doesn't exist
         if ( this->endpt_handle[i] == NULL ) {
             SPKnot *knot = sp_knot_new(this->desktop,
@@ -1215,6 +1198,7 @@ void ConnectorTool::cc_set_active_conn(SPItem *item) {
             // since we don't want this knot to be draggable.
             g_signal_handler_disconnect(G_OBJECT(knot->item),
                     knot->_event_handler_id);
+
             knot->_event_handler_id = 0;
 
             g_signal_connect(G_OBJECT(knot->item), "event",
@@ -1228,6 +1212,7 @@ void ConnectorTool::cc_set_active_conn(SPItem *item) {
             g_signal_handlers_disconnect_by_func(
                     G_OBJECT(this->endpt_handle[i]->item),
                     (void*)G_CALLBACK(endpt_handler), (gpointer) this );
+
             this->endpt_handler_id[i] = 0;
         }
 
@@ -1264,10 +1249,13 @@ void cc_create_connection_point(ConnectorTool* cc)
         {
             cc_deselect_handle( cc->selected_handle );
         }
+
         SPKnot *knot = sp_knot_new(cc->desktop, 0);
+
         // We do not process events on this knot.
         g_signal_handler_disconnect(G_OBJECT(knot->item),
                                     knot->_event_handler_id);
+
         knot->_event_handler_id = 0;
 
         cc_select_handle( knot );
diff --git a/src/ui/tools/connector-tool.h b/src/ui/tools/connector-tool.h
index 59534a173..9a9ae64cf 100644
--- a/src/ui/tools/connector-tool.h
+++ b/src/ui/tools/connector-tool.h
@@ -12,25 +12,34 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <stddef.h>
-#include <sigc++/sigc++.h>
-#include <sigc++/connection.h>
-#include "ui/tools/tool-base.h"
+#include <map>
+#include <string>
+
 #include <2geom/point.h>
-#include "libavoid/connector.h"
-#include <glibmm/i18n.h>
+#include <sigc++/connection.h>
 
-#define SP_CONNECTOR_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::ConnectorTool*>((Inkscape::UI::Tools::ToolBase*)obj))
-//#define SP_IS_CONNECTOR_CONTEXT(obj) (dynamic_cast<const ConnectorTool*>((const ToolBase*)obj) != NULL)
+#include "ui/tools/tool-base.h"
 
-struct SPKnot;
+class SPItem;
 class SPCurve;
+struct SPKnot;
+struct SPCanvasItem;
+
+namespace Avoid {
+    class ConnRef;
+}
+
+namespace Inkscape {
+    class Selection;
 
-namespace Inkscape
-{
-  class Selection;
+    namespace XML {
+        class Node;
+    }
 }
 
+#define SP_CONNECTOR_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::ConnectorTool*>((Inkscape::UI::Tools::ToolBase*)obj))
+//#define SP_IS_CONNECTOR_CONTEXT(obj) (dynamic_cast<const ConnectorTool*>((const ToolBase*)obj) != NULL)
+
 enum {
     SP_CONNECTOR_CONTEXT_IDLE,
     SP_CONNECTOR_CONTEXT_DRAGGING,
@@ -115,10 +124,10 @@ public:
 private:
 	void _selectionChanged(Inkscape::Selection *selection);
 
-	gint _handleButtonPress(GdkEventButton const &bevent);
-	gint _handleMotionNotify(GdkEventMotion const &mevent);
-	gint _handleButtonRelease(GdkEventButton const &revent);
-	gint _handleKeyPress(guint const keyval);
+	bool _handleButtonPress(GdkEventButton const &bevent);
+	bool _handleMotionNotify(GdkEventMotion const &mevent);
+	bool _handleButtonRelease(GdkEventButton const &revent);
+	bool _handleKeyPress(guint const keyval);
 
 	void _setInitialPoint(Geom::Point const p);
 	void _setSubsequentPoint(Geom::Point const p);
diff --git a/src/ui/tools/dropper-tool.h b/src/ui/tools/dropper-tool.h
index dd6f25bb6..cfeb91dab 100644
--- a/src/ui/tools/dropper-tool.h
+++ b/src/ui/tools/dropper-tool.h
@@ -12,8 +12,12 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <2geom/point.h>
+
 #include "ui/tools/tool-base.h"
 
+struct SPCanvasItem;
+
 #define SP_DROPPER_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::DropperTool*>((Inkscape::UI::Tools::ToolBase*)obj))
 #define SP_IS_DROPPER_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::DropperTool*>((const Inkscape::UI::Tools::ToolBase*)obj) != NULL)
 
diff --git a/src/ui/tools/dynamic-base.cpp b/src/ui/tools/dynamic-base.cpp
index 21b4b0532..eb789d850 100644
--- a/src/ui/tools/dynamic-base.cpp
+++ b/src/ui/tools/dynamic-base.cpp
@@ -10,6 +10,7 @@
 #include "preferences.h"
 #include "display/sp-canvas-item.h"
 #include "desktop.h"
+#include "display/curve.h"
 
 #define MIN_PRESSURE      0.0
 #define MAX_PRESSURE      1.0
diff --git a/src/ui/tools/dynamic-base.h b/src/ui/tools/dynamic-base.h
index 76fcd0f02..c948fa286 100644
--- a/src/ui/tools/dynamic-base.h
+++ b/src/ui/tools/dynamic-base.h
@@ -20,8 +20,15 @@
  */
 
 #include "ui/tools/tool-base.h"
-#include "display/curve.h"
-#include <2geom/point.h>
+
+struct SPCanvasItem;
+class SPCurve;
+
+namespace Inkscape {
+    namespace XML {
+        class Node;
+    }
+}
 
 #define SAMPLING_SIZE 8        /* fixme: ?? */
 
diff --git a/src/ui/tools/eraser-tool.cpp b/src/ui/tools/eraser-tool.cpp
index 011d28663..4106785e7 100644
--- a/src/ui/tools/eraser-tool.cpp
+++ b/src/ui/tools/eraser-tool.cpp
@@ -66,6 +66,7 @@
 #include "verbs.h"
 #include <2geom/math-utils.h>
 #include <2geom/pathvector.h>
+#include "display/curve.h"
 
 #include "ui/tools/eraser-tool.h"
 
diff --git a/src/ui/tools/eraser-tool.h b/src/ui/tools/eraser-tool.h
index eb7eb16e8..110f57ba3 100644
--- a/src/ui/tools/eraser-tool.h
+++ b/src/ui/tools/eraser-tool.h
@@ -19,6 +19,8 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
+#include <2geom/point.h>
+
 #include "ui/tools/dynamic-base.h"
 
 #define ERC_MIN_PRESSURE      0.0
diff --git a/src/ui/tools/freehand-base.h b/src/ui/tools/freehand-base.h
index c134c5352..2422c3563 100644
--- a/src/ui/tools/freehand-base.h
+++ b/src/ui/tools/freehand-base.h
@@ -14,22 +14,29 @@
  * Released under GNU GPL
  */
 
-#include <stddef.h>
-#include <sigc++/sigc++.h>
-#include <2geom/point.h>
+#include <sigc++/connection.h>
+
 #include "ui/tools/tool-base.h"
-#include "live_effects/effect.h"
+#include "live_effects/effect-enum.h"
+
+struct SPCanvasItem;
+class SPCurve;
+struct SPDrawAnchor;
+
+namespace Inkscape {
+    class Selection;
+}
+
+namespace boost {
+    template<class T>
+    class optional;
+}
 
 /* Freehand context */
 
 #define SP_DRAW_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::FreehandBase*>((Inkscape::UI::Tools::ToolBase*)obj))
 #define SP_IS_DRAW_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::FreehandBase*>((const Inkscape::UI::Tools::ToolBase*)obj) != NULL)
 
-struct SPDrawAnchor;
-namespace Inkscape
-{
-  class Selection;
-}
 
 namespace Inkscape {
 namespace UI {
diff --git a/src/ui/tools/measure-tool.cpp b/src/ui/tools/measure-tool.cpp
index 380aa79e3..2c85874bc 100644
--- a/src/ui/tools/measure-tool.cpp
+++ b/src/ui/tools/measure-tool.cpp
@@ -43,6 +43,7 @@
 #include "sp-namedview.h"
 #include "enums.h"
 #include "ui/control-manager.h"
+#include "knot-enums.h"
 
 using Inkscape::ControlManager;
 using Inkscape::CTLINE_SECONDARY;
diff --git a/src/ui/tools/pen-tool.cpp b/src/ui/tools/pen-tool.cpp
index cea8e67e6..053f1ac3d 100644
--- a/src/ui/tools/pen-tool.cpp
+++ b/src/ui/tools/pen-tool.cpp
@@ -307,7 +307,7 @@ void PenTool::_endpointSnapHandle(Geom::Point &p, guint const state) const {
 }
 
 bool PenTool::item_handler(SPItem* item, GdkEvent* event) {
-    gint ret = FALSE;
+    bool ret = false;
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
@@ -331,7 +331,7 @@ bool PenTool::item_handler(SPItem* item, GdkEvent* event) {
  * Callback to handle all pen events.
  */
 bool PenTool::root_handler(GdkEvent* event) {
-    gint ret = FALSE;
+    bool ret = false;
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
@@ -368,14 +368,12 @@ bool PenTool::root_handler(GdkEvent* event) {
 /**
  * Handle mouse button press event.
  */
-gint PenTool::_handleButtonPress(GdkEventButton const &bevent) {
+bool PenTool::_handleButtonPress(GdkEventButton const &bevent) {
     if (this->events_disabled) {
         // skip event processing if events are disabled
-        return FALSE;
+        return false;
     }
 
-    FreehandBase * const dc = SP_DRAW_CONTEXT(this);
-    SPDesktop * const desktop = dc->desktop;
     Geom::Point const event_w(bevent.x, bevent.y);
     Geom::Point event_dt(desktop->w2d(event_w));
     //Test whether we hit any anchor.
@@ -387,18 +385,18 @@ gint PenTool::_handleButtonPress(GdkEventButton const &bevent) {
         if( anchor && anchor == this->sa && this->green_curve->is_empty()){
             //remove the following line to avoid having one node on top of another
             _finishSegment(event_dt, bevent.state);
-            _finish( FALSE);
-            return TRUE;
+            _finish( false);
+            return true;
         }
-        return FALSE;
+        return false;
     } 
-    gint ret = FALSE;
-    if (bevent.button == 1 && !event_context->space_panning
+    bool ret = false;
+    if (bevent.button == 1 && !this->space_panning
         // make sure this is not the last click for a waiting LPE (otherwise we want to finish the path)
         && this->expecting_clicks_for_LPE != 1) {
 
-        if (Inkscape::have_viable_layer(desktop, dc->message_context) == false) {
-            return TRUE;
+        if (Inkscape::have_viable_layer(desktop, this->message_context) == false) {
+            return true;
         }
 
         if (!this->grab ) {
@@ -446,8 +444,8 @@ gint PenTool::_handleButtonPress(GdkEventButton const &bevent) {
                                     m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_NODE_HANDLE);
                                     m.unSetup();
                                 }
-                              spdc_create_single_dot(event_context, p, "/tools/freehand/pen", bevent.state);
-                              ret = TRUE;
+                              spdc_create_single_dot(this, p, "/tools/freehand/pen", bevent.state);
+                              ret = true;
                               break;
                             }
 
@@ -482,7 +480,7 @@ gint PenTool::_handleButtonPress(GdkEventButton const &bevent) {
                                 // Create green anchor
                                 p = event_dt;
                                 this->_endpointSnap(p, bevent.state);
-                                this->green_anchor = sp_draw_anchor_new(this, this->green_curve, TRUE, p);
+                                this->green_anchor = sp_draw_anchor_new(this, this->green_curve, true, p);
                             }
                             this->_setInitialPoint(p);
                         } else {
@@ -499,9 +497,9 @@ gint PenTool::_handleButtonPress(GdkEventButton const &bevent) {
                                 if (this->green_anchor && this->green_anchor->active) {
                                     // we clicked on the current curve start, so close it even if
                                     // we drag a handle away from it
-                                    dc->green_closed = TRUE;
+                                    this->green_closed = true;
                                 }
-                                ret = TRUE;
+                                ret = true;
                                 break;
 
                             } else {
@@ -510,11 +508,9 @@ gint PenTool::_handleButtonPress(GdkEventButton const &bevent) {
                                 this->_setSubsequentPoint(p, true);
                             }
                         }
-
                         // avoid the creation of a control point so a node is created in the release event
                         this->state = (this->spiro || this->bspline || this->polylines_only) ? PenTool::POINT : PenTool::CONTROL;
-
-                        ret = TRUE;
+                        ret = true;
                         break;
                     case PenTool::CONTROL:
                         g_warning("Button down in CONTROL state");
@@ -534,17 +530,17 @@ gint PenTool::_handleButtonPress(GdkEventButton const &bevent) {
         this->_finishSegment(event_dt, bevent.state);
         if (this->green_closed) {
             // finishing at the start anchor, close curve
-            this->_finish(TRUE);
+            this->_finish(true);
         } else {
             // finishing at some other anchor, finish curve but not close
-            this->_finish(FALSE);
+            this->_finish(false);
         }
 
-        ret = TRUE;
+        ret = true;
     } else if (bevent.button == 3 && this->npoints != 0) {
         // right click - finish path
-        this->_finish(FALSE);
-        ret = TRUE;
+        this->_finish(false);
+        ret = true;
     }
 
     if (this->expecting_clicks_for_LPE > 0) {
@@ -557,30 +553,28 @@ gint PenTool::_handleButtonPress(GdkEventButton const &bevent) {
 /**
  * Handle motion_notify event.
  */
-gint PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
-    gint ret = FALSE;
-
-    ToolBase *event_context = SP_EVENT_CONTEXT(this);
-    SPDesktop * const dt = event_context->desktop;
+bool PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
+    bool ret = false;
 
-    if (event_context->space_panning || mevent.state & GDK_BUTTON2_MASK || mevent.state & GDK_BUTTON3_MASK) {
+    if (this->space_panning || mevent.state & GDK_BUTTON2_MASK || mevent.state & GDK_BUTTON3_MASK) {
         // allow scrolling
-        return FALSE;
+        return false;
     }
 
     if (this->events_disabled) {
         // skip motion events if pen events are disabled
-        return FALSE;
+        return false;
     }
 
-    Geom::Point const event_w(mevent.x,
-                            mevent.y);
+    Geom::Point const event_w(mevent.x, mevent.y);
+
     //we take out the function the const "tolerance" because we need it later
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     gint const tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
+
     if (pen_within_tolerance) {
         if ( Geom::LInfty( event_w - pen_drag_origin_w ) < tolerance ) {
-            return FALSE;   // Do not drag if we're within tolerance from origin.
+            return false;   // Do not drag if we're within tolerance from origin.
         }
     }
     // Once the user has moved farther than tolerance from the original location
@@ -589,7 +583,7 @@ gint PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
     pen_within_tolerance = false;
 
     // Find desktop coordinates
-    Geom::Point p = dt->w2d(event_w);
+    Geom::Point p = desktop->w2d(event_w);
 
     // Test, whether we hit any anchor
     SPDrawAnchor *anchor = spdc_test_inside(this, event_w);
@@ -602,10 +596,10 @@ gint PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                         // Only set point, if we are already appending
                         this->_endpointSnap(p, mevent.state);
                         this->_setSubsequentPoint(p, true);
-                        ret = TRUE;
+                        ret = true;
                     } else if (!this->sp_event_context_knot_mouseover()) {
-                        SnapManager &m = dt->namedview->snap_manager;
-                        m.setup(dt);
+                        SnapManager &m = desktop->namedview->snap_manager;
+                        m.setup(desktop);
                         m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_NODE_HANDLE));
                         m.unSetup();
                     }
@@ -615,7 +609,7 @@ gint PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                     // Placing controls is last operation in CLOSE state
                     this->_endpointSnap(p, mevent.state);
                     this->_setCtrl(p, mevent.state);
-                    ret = TRUE;
+                    ret = true;
                     break;
                 case PenTool::STOP:
                     // This is perfectly valid
@@ -649,7 +643,7 @@ gint PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                             this->anchor_statusbar = false;
                         }
 
-                        ret = TRUE;
+                        ret = true;
                     } else {
                         if (anchor && !this->anchor_statusbar) {
                             if(!this->spiro && !this->bspline){
@@ -664,8 +658,8 @@ gint PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
 
                         }
                         if (!this->sp_event_context_knot_mouseover()) {
-                            SnapManager &m = dt->namedview->snap_manager;
-                            m.setup(dt);
+                            SnapManager &m = desktop->namedview->snap_manager;
+                            m.setup(desktop);
                             m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_NODE_HANDLE));
                             m.unSetup();
                         }
@@ -686,15 +680,15 @@ gint PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                     }
 
                     gobble_motion_events(GDK_BUTTON1_MASK);
-                    ret = TRUE;
+                    ret = true;
                     break;
                 case PenTool::STOP:
                     // This is perfectly valid
                     break;
                 default:
                     if (!this->sp_event_context_knot_mouseover()) {
-                        SnapManager &m = dt->namedview->snap_manager;
-                        m.setup(dt);
+                        SnapManager &m = desktop->namedview->snap_manager;
+                        m.setup(desktop);
                         m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_NODE_HANDLE));
                         m.unSetup();
                     }
@@ -722,20 +716,17 @@ gint PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
 /**
  * Handle mouse button release event.
  */
-gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
+bool PenTool::_handleButtonRelease(GdkEventButton const &revent) {
     if (this->events_disabled) {
         // skip event processing if events are disabled
-        return FALSE;
+        return false;
     }
 
-    gint ret = FALSE;
-    ToolBase *event_context = SP_EVENT_CONTEXT(this);
-    if ( revent.button == 1  && !event_context->space_panning) {
+    bool ret = false;
 
-        FreehandBase *dc = SP_DRAW_CONTEXT (this);
+    if (revent.button == 1 && !this->space_panning) {
+        Geom::Point const event_w(revent.x, revent.y);
 
-        Geom::Point const event_w(revent.x,
-                                revent.y);
         // Find desktop coordinates
         Geom::Point p = this->desktop->w2d(event_w);
 
@@ -744,7 +735,7 @@ gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
         SPDrawAnchor *anchor = spdc_test_inside(this, event_w);
         // if we try to create a node in the same place as another node, we skip
         if((!anchor || anchor == this->sa) && (this->spiro || this->bspline) && this->npoints > 0 && this->p[0] == this->p[3]){
-            return TRUE;
+            return true;
         }
 
         switch (this->mode) {
@@ -772,14 +763,14 @@ gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
                             }
                         }
                         this->state = PenTool::CONTROL;
-                        ret = TRUE;
+                        ret = true;
                         break;
                     case PenTool::CONTROL:
                         // End current segment
                         this->_endpointSnap(p, revent.state);
                         this->_finishSegment(p, revent.state);
                         this->state = PenTool::POINT;
-                        ret = TRUE;
+                        ret = true;
                         break;
                     case PenTool::CLOSE:
                         // End current segment
@@ -791,14 +782,14 @@ gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
                         if(this->spiro){
                             sp_canvas_item_hide(this->c1);
                         }
-                        this->_finish(TRUE);
+                        this->_finish(true);
                         this->state = PenTool::POINT;
-                        ret = TRUE;
+                        ret = true;
                         break;
                     case PenTool::STOP:
                         // This is allowed, if we just canceled curve
                         this->state = PenTool::POINT;
-                        ret = TRUE;
+                        ret = true;
                         break;
                     default:
                         break;
@@ -820,10 +811,10 @@ gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
                         }
                         if (this->green_closed) {
                             // finishing at the start anchor, close curve
-                            this->_finish(TRUE);
+                            this->_finish(true);
                         } else {
                             // finishing at some other anchor, finish curve but not close
-                            this->_finish(FALSE);
+                            this->_finish(false);
                         }
                         break;
                     case PenTool::STOP:
@@ -833,7 +824,7 @@ gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
                         break;
                 }
                 this->state = PenTool::POINT;
-                ret = TRUE;
+                ret = true;
                 break;
             default:
                 break;
@@ -844,9 +835,9 @@ gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
             this->grab = NULL;
         }
 
-        ret = TRUE;
+        ret = true;
 
-        dc->green_closed = FALSE;
+        this->green_closed = false;
     }
 
     // TODO: can we be sure that the path was created correctly?
@@ -854,13 +845,12 @@ gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
     if (this->expecting_clicks_for_LPE == 0 && this->hasWaitingLPE()) {
         this->setPolylineMode();
 
-        ToolBase *ec = SP_EVENT_CONTEXT(this);
-        Inkscape::Selection *selection = sp_desktop_selection (ec->desktop);
+        Inkscape::Selection *selection = sp_desktop_selection(this->desktop);
 
         if (this->waiting_LPE) {
             // we have an already created LPE waiting for a path
             this->waiting_LPE->acceptParamPath(SP_PATH(selection->singleItem()));
-            selection->add(SP_OBJECT(this->waiting_item));
+            selection->add(this->waiting_item);
             this->waiting_LPE = NULL;
         } else {
             // the case that we need to create a new LPE and apply it to the just-drawn path is
@@ -871,12 +861,12 @@ gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
     return ret;
 }
 
-gint PenTool::_handle2ButtonPress(GdkEventButton const &bevent) {
-    gint ret = FALSE;
+bool PenTool::_handle2ButtonPress(GdkEventButton const &bevent) {
+    bool ret = false;
     // only end on LMB double click. Otherwise horizontal scrolling causes ending of the path
     if (this->npoints != 0 && bevent.button == 1) {
-        this->_finish(FALSE);
-        ret = TRUE;
+        this->_finish(false);
+        ret = true;
     }
     return ret;
 }
@@ -1066,68 +1056,98 @@ void PenTool::_lastpointToLine() {
 }
 
 
-gint PenTool::_handleKeyPress(GdkEvent *event) {
-
-    gint ret = FALSE;
+bool PenTool::_handleKeyPress(GdkEvent *event) {
+    bool ret = false;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     gdouble const nudge = prefs->getDoubleLimited("/options/nudgedistance/value", 2, 0, 1000, "px"); // in px
 
     switch (get_group0_keyval (&event->key)) {
-
         case GDK_KEY_Left: // move last point left
         case GDK_KEY_KP_Left:
             if (!MOD__CTRL(event)) { // not ctrl
                 if (MOD__ALT(event)) { // alt
-                    if (MOD__SHIFT(event)) this->_lastpointMoveScreen(-10, 0); // shift
-                    else this->_lastpointMoveScreen(-1, 0); // no shift
+                    if (MOD__SHIFT(event)) {
+                        this->_lastpointMoveScreen(-10, 0); // shift
+                    }
+                    else {
+                        this->_lastpointMoveScreen(-1, 0); // no shift
+                    }
                 }
                 else { // no alt
-                    if (MOD__SHIFT(event)) this->_lastpointMove(-10*nudge, 0); // shift
-                    else this->_lastpointMove(-nudge, 0); // no shift
+                    if (MOD__SHIFT(event)) {
+                        this->_lastpointMove(-10*nudge, 0); // shift
+                    }
+                    else {
+                        this->_lastpointMove(-nudge, 0); // no shift
+                    }
                 }
-                ret = TRUE;
+                ret = true;
             }
             break;
         case GDK_KEY_Up: // move last point up
         case GDK_KEY_KP_Up:
             if (!MOD__CTRL(event)) { // not ctrl
                 if (MOD__ALT(event)) { // alt
-                    if (MOD__SHIFT(event)) this->_lastpointMoveScreen(0, 10); // shift
-                    else this->_lastpointMoveScreen(0, 1); // no shift
+                    if (MOD__SHIFT(event)) {
+                        this->_lastpointMoveScreen(0, 10); // shift
+                    }
+                    else {
+                        this->_lastpointMoveScreen(0, 1); // no shift
+                    }
                 }
                 else { // no alt
-                    if (MOD__SHIFT(event)) this->_lastpointMove(0, 10*nudge); // shift
-                    else this->_lastpointMove(0, nudge); // no shift
+                    if (MOD__SHIFT(event)) {
+                        this->_lastpointMove(0, 10*nudge); // shift
+                    }
+                    else {
+                        this->_lastpointMove(0, nudge); // no shift
+                    }
                 }
-                ret = TRUE;
+                ret = true;
             }
             break;
         case GDK_KEY_Right: // move last point right
         case GDK_KEY_KP_Right:
             if (!MOD__CTRL(event)) { // not ctrl
                 if (MOD__ALT(event)) { // alt
-                    if (MOD__SHIFT(event)) this->_lastpointMoveScreen(10, 0); // shift
-                    else this->_lastpointMoveScreen(1, 0); // no shift
+                    if (MOD__SHIFT(event)) {
+                        this->_lastpointMoveScreen(10, 0); // shift
+                    }
+                    else {
+                        this->_lastpointMoveScreen(1, 0); // no shift
+                    }
                 }
                 else { // no alt
-                    if (MOD__SHIFT(event)) this->_lastpointMove(10*nudge, 0); // shift
-                    else this->_lastpointMove(nudge, 0); // no shift
+                    if (MOD__SHIFT(event)) {
+                        this->_lastpointMove(10*nudge, 0); // shift
+                    }
+                    else {
+                        this->_lastpointMove(nudge, 0); // no shift
+                    }
                 }
-                ret = TRUE;
+                ret = true;
             }
             break;
         case GDK_KEY_Down: // move last point down
         case GDK_KEY_KP_Down:
             if (!MOD__CTRL(event)) { // not ctrl
                 if (MOD__ALT(event)) { // alt
-                    if (MOD__SHIFT(event)) this->_lastpointMoveScreen(0, -10); // shift
-                    else this->_lastpointMoveScreen(0, -1); // no shift
+                    if (MOD__SHIFT(event)) {
+                        this->_lastpointMoveScreen(0, -10); // shift
+                    }
+                    else {
+                        this->_lastpointMoveScreen(0, -1); // no shift
+                    }
                 }
                 else { // no alt
-                    if (MOD__SHIFT(event)) this->_lastpointMove(0, -10*nudge); // shift
-                    else this->_lastpointMove(0, -nudge); // no shift
+                    if (MOD__SHIFT(event)) {
+                        this->_lastpointMove(0, -10*nudge); // shift
+                    }
+                    else {
+                        this->_lastpointMove(0, -nudge); // no shift
+                    }
                 }
-                ret = TRUE;
+                ret = true;
             }
             break;
 
@@ -1136,7 +1156,7 @@ gint PenTool::_handleKeyPress(GdkEvent *event) {
         case GDK_KEY_p:
             if (MOD__SHIFT_ONLY(event)) {
                 sp_pen_context_wait_for_LPE_mouse_clicks(pc, Inkscape::LivePathEffect::PARALLEL, 2);
-                ret = TRUE;
+                ret = true;
             }
             break;
 
@@ -1144,7 +1164,7 @@ gint PenTool::_handleKeyPress(GdkEvent *event) {
         case GDK_KEY_c:
             if (MOD__SHIFT_ONLY(event)) {
                 sp_pen_context_wait_for_LPE_mouse_clicks(pc, Inkscape::LivePathEffect::CIRCLE_3PTS, 3);
-                ret = TRUE;
+                ret = true;
             }
             break;
 
@@ -1152,7 +1172,7 @@ gint PenTool::_handleKeyPress(GdkEvent *event) {
         case GDK_KEY_b:
             if (MOD__SHIFT_ONLY(event)) {
                 sp_pen_context_wait_for_LPE_mouse_clicks(pc, Inkscape::LivePathEffect::PERP_BISECTOR, 2);
-                ret = TRUE;
+                ret = true;
             }
             break;
 
@@ -1160,7 +1180,7 @@ gint PenTool::_handleKeyPress(GdkEvent *event) {
         case GDK_KEY_a:
             if (MOD__SHIFT_ONLY(event)) {
                 sp_pen_context_wait_for_LPE_mouse_clicks(pc, Inkscape::LivePathEffect::ANGLE_BISECTOR, 3);
-                ret = TRUE;
+                ret = true;
             }
             break;
 */
@@ -1169,29 +1189,29 @@ gint PenTool::_handleKeyPress(GdkEvent *event) {
         case GDK_KEY_u:
             if (MOD__SHIFT_ONLY(event)) {
                 this->_lastpointToCurve();
-                ret = TRUE;
+                ret = true;
             }
             break;
         case GDK_KEY_L:
         case GDK_KEY_l:
             if (MOD__SHIFT_ONLY(event)) {
                 this->_lastpointToLine();
-                ret = TRUE;
+                ret = true;
             }
             break;
 
         case GDK_KEY_Return:
         case GDK_KEY_KP_Enter:
             if (this->npoints != 0) {
-                this->_finish(FALSE);
-                ret = TRUE;
+                this->_finish(false);
+                ret = true;
             }
             break;
         case GDK_KEY_Escape:
             if (this->npoints != 0) {
                 // if drawing, cancel, otherwise pass it up for deselecting
                 this->_cancel ();
-                ret = TRUE;
+                ret = true;
             }
             break;
         case GDK_KEY_z:
@@ -1199,13 +1219,13 @@ gint PenTool::_handleKeyPress(GdkEvent *event) {
             if (MOD__CTRL_ONLY(event) && this->npoints != 0) {
                 // if drawing, cancel, otherwise pass it up for undo
                 this->_cancel ();
-                ret = TRUE;
+                ret = true;
             }
             break;
         case GDK_KEY_g:
         case GDK_KEY_G:
             if (MOD__SHIFT_ONLY(event)) {
-                sp_selection_to_guides(SP_EVENT_CONTEXT(this)->desktop);
+                sp_selection_to_guides(this->desktop);
                 ret = true;
             }
             break;
@@ -1215,7 +1235,7 @@ gint PenTool::_handleKeyPress(GdkEvent *event) {
             if ( this->green_curve->is_empty() || (this->green_curve->last_segment() == NULL) ) {
                 if (!this->red_curve->is_empty()) {
                     this->_cancel ();
-                    ret = TRUE;
+                    ret = true;
                 } else {
                     // do nothing; this event should be handled upstream
                 }
@@ -1284,7 +1304,7 @@ gint PenTool::_handleKeyPress(GdkEvent *event) {
 
                 //redraw
                 this->_bspline_spiro_build();
-                ret = TRUE;
+                ret = true;
             }
             break;
         default:
@@ -1340,7 +1360,6 @@ void PenTool::_setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_t
     g_assert((pc_point_to_compare == 0) || (pc_point_to_compare == 3)); // exclude control handles
     g_assert(message != NULL);
 
-    SPDesktop *desktop = SP_EVENT_CONTEXT(this)->desktop;
     Geom::Point rel = p - this->p[pc_point_to_compare];
     Inkscape::Util::Quantity q = Inkscape::Util::Quantity(Geom::L2(rel), "px");
     GString *dist = g_string_new(q.string(desktop->namedview->doc_units).c_str());
@@ -1354,7 +1373,7 @@ void PenTool::_setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_t
     }
 
     this->message_context->setF(Inkscape::IMMEDIATE_MESSAGE, message, angle, dist->str);
-    g_string_free(dist, FALSE);
+    g_string_free(dist, false);
 }
 
 // this function changes the colors red, green and blue making them transparent or not, depending on if spiro is being used.
@@ -2165,7 +2184,6 @@ void PenTool::_finish(gboolean const closed) {
 
     this->_disableEvents();
 
-    SPDesktop *const desktop = this->desktop;
     this->message_context->clear();
 
     desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Drawing finished"));
@@ -2190,7 +2208,6 @@ void PenTool::_finish(gboolean const closed) {
         this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
     }
 
-
     this->desktop->canvas->endForcedFullRedraws();
 
     this->_enableEvents();
diff --git a/src/ui/tools/pen-tool.h b/src/ui/tools/pen-tool.h
index 95565abc9..98fd0a43e 100644
--- a/src/ui/tools/pen-tool.h
+++ b/src/ui/tools/pen-tool.h
@@ -83,11 +83,11 @@ protected:
 	virtual bool item_handler(SPItem* item, GdkEvent* event);
 
 private:
-	gint _handleButtonPress(GdkEventButton const &bevent);
-	gint _handleMotionNotify(GdkEventMotion const &mevent);
-	gint _handleButtonRelease(GdkEventButton const &revent);
-	gint _handle2ButtonPress(GdkEventButton const &bevent);
-	gint _handleKeyPress(GdkEvent *event);
+	bool _handleButtonPress(GdkEventButton const &bevent);
+	bool _handleMotionNotify(GdkEventMotion const &mevent);
+	bool _handleButtonRelease(GdkEventButton const &revent);
+	bool _handle2ButtonPress(GdkEventButton const &bevent);
+	bool _handleKeyPress(GdkEvent *event);
     //adds spiro & bspline modes
     void _pen_context_set_mode(guint mode);
     //this function changes the colors red, green and blue making them transparent or not depending on if the function uses spiro
@@ -116,6 +116,7 @@ private:
     void _bspline_doEffect(SPCurve * curve);
     //function spiro cloned from lpe-spiro.cpp
     void _spiro_doEffect(SPCurve * curve);
+
 	void _setInitialPoint(Geom::Point const p);
 	void _setSubsequentPoint(Geom::Point const p, bool statusbar, guint status = 0);
 	void _setCtrl(Geom::Point const p, guint state);
diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp
index 8fe01a852..6216af295 100644
--- a/src/ui/tools/pencil-tool.cpp
+++ b/src/ui/tools/pencil-tool.cpp
@@ -115,7 +115,7 @@ void PencilTool::_endpointSnap(Geom::Point &p, guint const state) {
  * Callback for handling all pencil context events.
  */
 bool PencilTool::root_handler(GdkEvent* event) {
-    gint ret = FALSE;
+    bool ret = false;
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
@@ -149,17 +149,14 @@ bool PencilTool::root_handler(GdkEvent* event) {
     return ret;
 }
 
-gint PencilTool::_handleButtonPress(GdkEventButton const &bevent) {
-    gint ret = FALSE;
-    ToolBase *event_context = SP_EVENT_CONTEXT(this);
-    if ( bevent.button == 1  && !event_context->space_panning) {
+bool PencilTool::_handleButtonPress(GdkEventButton const &bevent) {
+    bool ret = false;
 
-        FreehandBase *dc = SP_DRAW_CONTEXT (this);
-        SPDesktop *desktop = dc->desktop;
+    if ( bevent.button == 1  && !this->space_panning) {
         Inkscape::Selection *selection = sp_desktop_selection(desktop);
 
-        if (Inkscape::have_viable_layer(desktop, dc->message_context) == false) {
-            return TRUE;
+        if (Inkscape::have_viable_layer(desktop, this->message_context) == false) {
+            return true;
         }
 
         if (!this->grab) {
@@ -185,7 +182,7 @@ gint PencilTool::_handleButtonPress(GdkEventButton const &bevent) {
         switch (this->state) {
             case SP_PENCIL_CONTEXT_ADDLINE:
                 /* Current segment will be finished with release */
-                ret = TRUE;
+                ret = true;
                 break;
             default:
                 /* Set first point of sequence */
@@ -196,7 +193,7 @@ gint PencilTool::_handleButtonPress(GdkEventButton const &bevent) {
                     if (!(bevent.state & GDK_SHIFT_MASK)) {
                         m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_NODE_HANDLE);
                       }
-                    spdc_create_single_dot(event_context, p, "/tools/freehand/pencil", bevent.state);
+                    spdc_create_single_dot(this, p, "/tools/freehand/pencil", bevent.state);
                     m.unSetup();
                     ret = true;
                     break;
@@ -222,7 +219,7 @@ gint PencilTool::_handleButtonPress(GdkEventButton const &bevent) {
                 }
                 this->sa = anchor;
                 this->_setStartpoint(p);
-                ret = TRUE;
+                ret = true;
                 break;
         }
 
@@ -231,26 +228,24 @@ gint PencilTool::_handleButtonPress(GdkEventButton const &bevent) {
     return ret;
 }
 
-gint PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
-    SPDesktop *const dt = this->desktop;
-
+bool PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
     if ((mevent.state & GDK_CONTROL_MASK) && (mevent.state & GDK_BUTTON1_MASK)) {
         // mouse was accidentally moved during Ctrl+click;
         // ignore the motion and create a single point
         this->is_drawing = false;
-        return TRUE;
+        return true;
     }
-    gint ret = FALSE;
 
-    ToolBase *event_context = SP_EVENT_CONTEXT(this);
-    if (event_context->space_panning || mevent.state & GDK_BUTTON2_MASK || mevent.state & GDK_BUTTON3_MASK) {
+    bool ret = false;
+
+    if (this->space_panning || (mevent.state & GDK_BUTTON2_MASK) || (mevent.state & GDK_BUTTON3_MASK)) {
         // allow scrolling
-        return FALSE;
+        return false;
     }
 
     if ( ( mevent.state & GDK_BUTTON1_MASK ) && !this->grab && this->is_drawing) {
         /* Grab mouse, so release will not pass unnoticed */
-        this->grab = SP_CANVAS_ITEM(dt->acetate);
+        this->grab = SP_CANVAS_ITEM(desktop->acetate);
         sp_canvas_item_grab(this->grab, ( GDK_KEY_PRESS_MASK | GDK_BUTTON_PRESS_MASK   |
                                         GDK_BUTTON_RELEASE_MASK |
                                         GDK_POINTER_MOTION_MASK  ),
@@ -258,7 +253,7 @@ gint PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
     }
 
     /* Find desktop coordinates */
-    Geom::Point p = dt->w2d(Geom::Point(mevent.x, mevent.y));
+    Geom::Point p = desktop->w2d(Geom::Point(mevent.x, mevent.y));
 
     /* Test whether we hit any anchor. */
     SPDrawAnchor *anchor = spdc_test_inside(this, Geom::Point(mevent.x, mevent.y));
@@ -267,7 +262,7 @@ gint PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         gint const tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
         if ( Geom::LInfty( Geom::Point(mevent.x,mevent.y) - pencil_drag_origin_w ) < tolerance ) {
-            return FALSE;   // Do not drag if we're within tolerance from origin.
+            return false;   // Do not drag if we're within tolerance from origin.
         }
     }
 
@@ -287,13 +282,13 @@ gint PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                 p = ptnr;
             }
             this->_setEndpoint(p);
-            ret = TRUE;
+            ret = true;
             break;
         default:
             /* We may be idle or already freehand */
-            if ( mevent.state & GDK_BUTTON1_MASK && this->is_drawing ) {
+            if ( (mevent.state & GDK_BUTTON1_MASK) && this->is_drawing ) {
                 if (this->state == SP_PENCIL_CONTEXT_IDLE) {
-                    sp_event_context_discard_delayed_snap_event(event_context);
+                    sp_event_context_discard_delayed_snap_event(this);
                 }
                 this->state = SP_PENCIL_CONTEXT_FREEHAND;
 
@@ -314,7 +309,7 @@ gint PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
                         this->ps.push_back(this->p[0]);
                     }
                     this->_addFreehandPoint(p, mevent.state);
-                    ret = TRUE;
+                    ret = true;
                 }
 
                 if (anchor && !this->anchor_statusbar) {
@@ -341,8 +336,8 @@ gint PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
             // a) press the mousebutton to start a freehand drawing, or
             // b) release the mousebutton to finish a freehand drawing
             if (!this->sp_event_context_knot_mouseover()) {
-                SnapManager &m = dt->namedview->snap_manager;
-                m.setup(dt);
+                SnapManager &m = desktop->namedview->snap_manager;
+                m.setup(desktop);
                 m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_NODE_HANDLE));
                 m.unSetup();
             }
@@ -351,21 +346,17 @@ gint PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
     return ret;
 }
 
-gint PencilTool::_handleButtonRelease(GdkEventButton const &revent) {
-    gint ret = FALSE;
-
-    ToolBase *event_context = SP_EVENT_CONTEXT(this);
-    if ( revent.button == 1 && this->is_drawing && !event_context->space_panning) {
-        SPDesktop *const dt = this->desktop;
+bool PencilTool::_handleButtonRelease(GdkEventButton const &revent) {
+    bool ret = false;
 
+    if ( revent.button == 1 && this->is_drawing && !this->space_panning) {
         this->is_drawing = false;
 
         /* Find desktop coordinates */
-        Geom::Point p = dt->w2d(Geom::Point(revent.x, revent.y));
+        Geom::Point p = desktop->w2d(Geom::Point(revent.x, revent.y));
 
         /* Test whether we hit any anchor. */
-        SPDrawAnchor *anchor = spdc_test_inside(this, Geom::Point(revent.x,
-                                                              revent.y));
+        SPDrawAnchor *anchor = spdc_test_inside(this, Geom::Point(revent.x, revent.y));
 
         switch (this->state) {
             case SP_PENCIL_CONTEXT_IDLE:
@@ -375,7 +366,7 @@ gint PencilTool::_handleButtonRelease(GdkEventButton const &revent) {
                     // Ctrl+click creates a single point so only set context in ADDLINE mode when Ctrl isn't pressed
                     this->state = SP_PENCIL_CONTEXT_ADDLINE;
                 }
-                ret = TRUE;
+                ret = true;
                 break;
             case SP_PENCIL_CONTEXT_ADDLINE:
                 /* Finish segment now */
@@ -389,13 +380,12 @@ gint PencilTool::_handleButtonRelease(GdkEventButton const &revent) {
                 this->_setEndpoint(p);
                 this->_finishEndpoint();
                 this->state = SP_PENCIL_CONTEXT_IDLE;
-                sp_event_context_discard_delayed_snap_event(event_context);
-                ret = TRUE;
+                sp_event_context_discard_delayed_snap_event(this);
+                ret = true;
                 break;
             case SP_PENCIL_CONTEXT_FREEHAND:
                 if (revent.state & GDK_MOD1_MASK) {
                     /* sketch mode: interpolate the sketched path and improve the current output path with the new interpolation. don't finish sketch */
-
                     this->_sketchInterpolate();
 
                     if (this->green_anchor) {
@@ -421,7 +411,7 @@ gint PencilTool::_handleButtonRelease(GdkEventButton const &revent) {
                     this->ea = anchor;
                     /* Write curves to object */
 
-                    dt->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Finishing freehand"));
+                    desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Finishing freehand"));
 
                     this->_interpolate();
                     spdc_concat_colors_and_flush(this, FALSE);
@@ -434,7 +424,7 @@ gint PencilTool::_handleButtonRelease(GdkEventButton const &revent) {
                     // reset sketch mode too
                     this->sketch_n = 0;
                 }
-                ret = TRUE;
+                ret = true;
                 break;
             case SP_PENCIL_CONTEXT_SKETCH:
             default:
@@ -447,7 +437,7 @@ gint PencilTool::_handleButtonRelease(GdkEventButton const &revent) {
             this->grab = NULL;
         }
 
-        ret = TRUE;
+        ret = true;
     }
     return ret;
 }
@@ -461,7 +451,7 @@ void PencilTool::_cancel() {
 
     this->is_drawing = false;
     this->state = SP_PENCIL_CONTEXT_IDLE;
-    sp_event_context_discard_delayed_snap_event(SP_EVENT_CONTEXT(this));
+    sp_event_context_discard_delayed_snap_event(this);
 
     this->red_curve->reset();
     sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
@@ -480,8 +470,9 @@ void PencilTool::_cancel() {
     this->desktop->canvas->endForcedFullRedraws();
 }
 
-gint PencilTool::_handleKeyPress(guint const keyval, guint const state) {
-    gint ret = FALSE;
+bool PencilTool::_handleKeyPress(guint const keyval, guint const state) {
+    bool ret = false;
+
     switch (keyval) {
         case GDK_KEY_Up:
         case GDK_KEY_Down:
@@ -489,7 +480,7 @@ gint PencilTool::_handleKeyPress(guint const keyval, guint const state) {
         case GDK_KEY_KP_Down:
             // Prevent the zoom field from activation.
             if (!mod_ctrl_only(state)) {
-                ret = TRUE;
+                ret = true;
             }
             break;
         case GDK_KEY_Escape:
@@ -497,7 +488,7 @@ gint PencilTool::_handleKeyPress(guint const keyval, guint const state) {
                 // if drawing, cancel, otherwise pass it up for deselecting
                 if (this->state != SP_PENCIL_CONTEXT_IDLE) {
                     this->_cancel();
-                    ret = TRUE;
+                    ret = true;
                 }
             }
             break;
@@ -507,14 +498,14 @@ gint PencilTool::_handleKeyPress(guint const keyval, guint const state) {
                 // if drawing, cancel, otherwise pass it up for undo
                 if (this->state != SP_PENCIL_CONTEXT_IDLE) {
                     this->_cancel();
-                    ret = TRUE;
+                    ret = true;
                 }
             }
             break;
         case GDK_KEY_g:
         case GDK_KEY_G:
             if (mod_shift_only(state)) {
-                sp_selection_to_guides(SP_EVENT_CONTEXT(this)->desktop);
+                sp_selection_to_guides(this->desktop);
                 ret = true;
             }
             break;
@@ -532,15 +523,15 @@ gint PencilTool::_handleKeyPress(guint const keyval, guint const state) {
     return ret;
 }
 
-gint PencilTool::_handleKeyRelease(guint const keyval, guint const /*state*/) {
-    gint ret = FALSE;
+bool PencilTool::_handleKeyRelease(guint const keyval, guint const /*state*/) {
+    bool ret = false;
     switch (keyval) {
         case GDK_KEY_Alt_L:
         case GDK_KEY_Alt_R:
         case GDK_KEY_Meta_L:
         case GDK_KEY_Meta_R:
             if (this->state == SP_PENCIL_CONTEXT_SKETCH) {
-                spdc_concat_colors_and_flush(this, FALSE);
+                spdc_concat_colors_and_flush(this, false);
                 this->sketch_n = 0;
                 this->sa = NULL;
                 this->ea = NULL;
@@ -548,9 +539,9 @@ gint PencilTool::_handleKeyRelease(guint const keyval, guint const /*state*/) {
                     this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
                 }
                 this->state = SP_PENCIL_CONTEXT_IDLE;
-                sp_event_context_discard_delayed_snap_event(SP_EVENT_CONTEXT(this));
+                sp_event_context_discard_delayed_snap_event(this);
                 this->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Finishing freehand sketch"));
-                ret = TRUE;
+                ret = true;
             }
             break;
         default:
@@ -656,32 +647,24 @@ void PencilTool::_interpolate() {
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     double const tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 1.0, 100.0) * 0.4;
-    double const tolerance_sq = 0.02 * square( this->desktop->w2d().descrim() *
-                                               tol) * exp(0.2*tol - 2);
+    double const tolerance_sq = 0.02 * square(this->desktop->w2d().descrim() * tol) * exp(0.2 * tol - 2);
 
-    g_assert(is_zero(this->req_tangent)
-             || is_unit_vector(this->req_tangent));
-    Geom::Point const tHatEnd(0, 0);
+    g_assert(is_zero(this->req_tangent) || is_unit_vector(this->req_tangent));
 
-    guint n_points  = this->ps.size();
     this->green_curve->reset();
     this->red_curve->reset();
     this->red_curve_is_valid = false;
 
-    Geom::Point * b = g_new(Geom::Point, 4*n_points);
-    Geom::Point * points = g_new(Geom::Point, 4*n_points);
-    for (unsigned int i = 0; i < this->ps.size(); i++) {
-        points[i] = this->ps[i];
-    }
+    int n_points = this->ps.size();
 
     // worst case gives us a segment per point
-    int max_segs = 4*n_points;
+    int max_segs = 4 * n_points;
 
-    int const n_segs = Geom::bezier_fit_cubic_r(b, points, n_points,
-                                             tolerance_sq, max_segs);
+    std::vector<Geom::Point> b(max_segs);
 
-    if ( n_segs > 0)
-    {
+    int const n_segs = Geom::bezier_fit_cubic_r(b.data(), this->ps.data(), n_points, tolerance_sq, max_segs);
+
+    if (n_segs > 0) {
         /* Fit and draw and reset state */
 
         this->green_curve->moveto(b[0]);
@@ -696,9 +679,8 @@ void PencilTool::_interpolate() {
                 CP = Geom::Point(CP[X] + 0.0001,CP[Y] + 0.0001);
                 this->green_curve->curveto(BP,CP,b[4*c+3]);
             }else{
-                this->green_curve->curveto(b[4*c+1], b[4*c+2], b[4*c+3]);
+                this->green_curve->curveto(b[4 * c + 1], b[4 * c + 2], b[4 * c + 3]);
             }
-
         }
 
         sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->green_curve);
@@ -720,8 +702,7 @@ void PencilTool::_interpolate() {
                                 : Geom::unit_vector(req_vec) );
         }
     }
-    g_free(b);
-    g_free(points);
+
     this->ps.clear();
 }
 
@@ -734,41 +715,36 @@ void PencilTool::_sketchInterpolate() {
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     double const tol = prefs->getDoubleLimited("/tools/freehand/pencil/tolerance", 10.0, 1.0, 100.0) * 0.4;
-    double const tolerance_sq = 0.02 * square( this->desktop->w2d().descrim() *
-                                               tol) * exp(0.2*tol - 2);
+    double const tolerance_sq = 0.02 * square(this->desktop->w2d().descrim() * tol) * exp(0.2 * tol - 2);
 
     bool average_all_sketches = prefs->getBool("/tools/freehand/pencil/average_all_sketches", true);
 
-    g_assert(is_zero(this->req_tangent)
-             || is_unit_vector(this->req_tangent));
-    Geom::Point const tHatEnd(0, 0);
+    g_assert(is_zero(this->req_tangent) || is_unit_vector(this->req_tangent));
 
-    guint n_points  = this->ps.size();
     this->red_curve->reset();
     this->red_curve_is_valid = false;
 
-    Geom::Point * b = g_new(Geom::Point, 4*n_points);
-    Geom::Point * points = g_new(Geom::Point, 4*n_points);
-    for (unsigned i = 0; i < this->ps.size(); i++) {
-        points[i] = this->ps[i];
-    }
+    int n_points = this->ps.size();
 
     // worst case gives us a segment per point
-    int max_segs = 4*n_points;
+    int max_segs = 4 * n_points;
 
-    int const n_segs = Geom::bezier_fit_cubic_r(b, points, n_points,
-                                             tolerance_sq, max_segs);
+    std::vector<Geom::Point> b(max_segs);
 
-    if ( n_segs > 0)
-    {
+    int const n_segs = Geom::bezier_fit_cubic_r(b.data(), this->ps.data(), n_points, tolerance_sq, max_segs);
+
+    if (n_segs > 0) {
         Geom::Path fit(b[0]);
+
         for (int c = 0; c < n_segs; c++) {
-            fit.appendNew<Geom::CubicBezier>(b[4*c+1], b[4*c+2], b[4*c+3]);
+            fit.appendNew<Geom::CubicBezier>(b[4 * c + 1], b[4 * c + 2], b[4 * c + 3]);
         }
+
         Geom::Piecewise<Geom::D2<Geom::SBasis> > fit_pwd2 = fit.toPwSb();
 
-        if ( this->sketch_n > 0 ) {
-            double t =0.;
+        if (this->sketch_n > 0) {
+            double t;
+
             if (average_all_sketches) {
                 // Average = (sum of all) / n
                 //         = (sum of all + new one) / n+1
@@ -777,18 +753,21 @@ void PencilTool::_sketchInterpolate() {
             } else {
                 t = 0.5;
             }
+
             this->sketch_interpolation = Geom::lerp(t, fit_pwd2, this->sketch_interpolation);
+
             // simplify path, to eliminate small segments
-            Path *path = new Path;
-            path->LoadPathVector(Geom::path_from_piecewise(this->sketch_interpolation, 0.01));
-            path->Simplify(0.5);
-            Geom::PathVector *pathv = path->MakePathVector();
+            Path path;
+            path.LoadPathVector(Geom::path_from_piecewise(this->sketch_interpolation, 0.01));
+            path.Simplify(0.5);
+
+            Geom::PathVector *pathv = path.MakePathVector();
             this->sketch_interpolation = (*pathv)[0].toPwSb();
-            delete path;
             delete pathv;
         } else {
             this->sketch_interpolation = fit_pwd2;
         }
+
         this->sketch_n++;
 
         this->green_curve->reset();
@@ -812,8 +791,7 @@ void PencilTool::_sketchInterpolate() {
                                 : Geom::unit_vector(req_vec) );
         }
     }
-    g_free(b);
-    g_free(points);
+
     this->ps.clear();
 }
 
diff --git a/src/ui/tools/pencil-tool.h b/src/ui/tools/pencil-tool.h
index efc1f60e0..e01b0afb5 100644
--- a/src/ui/tools/pencil-tool.h
+++ b/src/ui/tools/pencil-tool.h
@@ -7,6 +7,10 @@
 
 #include "ui/tools/freehand-base.h"
 
+#include <2geom/piecewise.h>
+#include <2geom/d2.h>
+#include <2geom/sbasis.h>
+
 #define SP_PENCIL_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::PencilTool*>((ToolBase*)obj))
 #define SP_IS_PENCIL_CONTEXT(obj) (dynamic_cast<const Inkscape::UI::Tools::PencilTool*>((const ToolBase*)obj) != NULL)
 
@@ -50,11 +54,11 @@ protected:
 	virtual bool root_handler(GdkEvent* event);
 
 private:
-	gint _handleButtonPress(GdkEventButton const &bevent);
-	gint _handleMotionNotify(GdkEventMotion const &mevent);
-	gint _handleButtonRelease(GdkEventButton const &revent);
-	gint _handleKeyPress(guint const keyval, guint const state);
-	gint _handleKeyRelease(guint const keyval, guint const state);
+	bool _handleButtonPress(GdkEventButton const &bevent);
+	bool _handleMotionNotify(GdkEventMotion const &mevent);
+	bool _handleButtonRelease(GdkEventButton const &revent);
+	bool _handleKeyPress(guint const keyval, guint const state);
+	bool _handleKeyRelease(guint const keyval, guint const state);
 
 	void _setStartpoint(Geom::Point const &p);
 	void _setEndpoint(Geom::Point const &p);
diff --git a/src/ui/tools/tool-base.cpp b/src/ui/tools/tool-base.cpp
index 752053be1..96ac95926 100644
--- a/src/ui/tools/tool-base.cpp
+++ b/src/ui/tools/tool-base.cpp
@@ -57,6 +57,7 @@
 #include "shape-editor.h"
 #include "sp-guide.h"
 #include "color.h"
+#include "knot.h"
 
 // globals for temporary switching to selector by space
 static bool selector_toggled = FALSE;
diff --git a/src/ui/tools/tool-base.h b/src/ui/tools/tool-base.h
index def6e3d91..e11a22296 100644
--- a/src/ui/tools/tool-base.h
+++ b/src/ui/tools/tool-base.h
@@ -12,25 +12,29 @@
  * Released under GNU GPL, read the file 'COPYING' for more information
  */
 
-#include <glib-object.h>
+#include <stddef.h>
+#include <string>
+
+#include <2geom/point.h>
 #include <gdk/gdk.h>
+#include <glib-object.h>
 #include <sigc++/trackable.h>
 #include "knot.h"
 
-#include "2geom/forward.h"
 #include "preferences.h"
 
-class  GrDrag;
-class  SPDesktop;
-class  SPItem;
-class  ShapeEditor;
+namespace Glib {
+    class ustring;
+}
+
+class GrDrag;
+class SPDesktop;
+class SPItem;
+class ShapeEditor;
 
 namespace Inkscape {
     class MessageContext;
     class SelCue;
-    namespace XML {
-        class Node;
-    }
 }
 
 #define SP_EVENT_CONTEXT(obj) (dynamic_cast<Inkscape::UI::Tools::ToolBase*>((Inkscape::UI::Tools::ToolBase*)obj))
@@ -45,8 +49,7 @@ class ToolBase;
 gboolean sp_event_context_snap_watchdog_callback(gpointer data);
 void sp_event_context_discard_delayed_snap_event(ToolBase *ec);
 
-class DelayedSnapEvent
-{
+class DelayedSnapEvent {
 public:
     enum DelayedSnapEventOrigin {
         UNDEFINED_HANDLER = 0,
@@ -60,12 +63,19 @@ public:
     };
 
     DelayedSnapEvent(ToolBase *event_context, gpointer const dse_item, gpointer dse_item2, GdkEventMotion const *event, DelayedSnapEvent::DelayedSnapEventOrigin const origin)
-    : _timer_id(0), _event(NULL), _item(dse_item), _item2(dse_item2), _origin(origin), _event_context(event_context)
+        : _timer_id(0)
+        , _event(NULL)
+        , _item(dse_item)
+        , _item2(dse_item2)
+        , _origin(origin)
+        , _event_context(event_context)
     {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
         double value = prefs->getDoubleLimited("/options/snapdelay/value", 0, 0, 1000);
+
         _timer_id = g_timeout_add(value, &sp_event_context_snap_watchdog_callback, this);
         _event = gdk_event_copy((GdkEvent*) event);
+
         ((GdkEventMotion *)_event)->time = GDK_CURRENT_TIME;
     }
 
@@ -74,11 +84,25 @@ public:
         if (_event != NULL) gdk_event_free(_event); // Remove the copy of the original event
     }
 
-    ToolBase* getEventContext() {return _event_context;}
-    DelayedSnapEventOrigin getOrigin() {return _origin;}
-    GdkEvent* getEvent() {return _event;}
-    gpointer getItem() {return _item;}
-    gpointer getItem2() {return _item2;}
+    ToolBase* getEventContext() {
+        return _event_context;
+    }
+
+    DelayedSnapEventOrigin getOrigin() {
+        return _origin;
+    }
+
+    GdkEvent* getEvent() {
+        return _event;
+    }
+
+    gpointer getItem() {
+        return _item;
+    }
+
+    gpointer getItem2() {
+        return _item2;
+    }
 
 private:
     guint _timer_id;
@@ -137,7 +161,10 @@ public:
     Inkscape::SelCue *_selcue;
 
     GrDrag *_grdrag;
-    GrDrag *get_drag () {return _grdrag;}
+
+    GrDrag *get_drag () {
+        return _grdrag;
+    }
 
     ShapeEditor* shape_editor;
 
@@ -162,8 +189,10 @@ public:
 	 */
 	class ToolPrefObserver: public Inkscape::Preferences::Observer {
 	public:
-	    ToolPrefObserver(Glib::ustring const &path, ToolBase *ec) :
-	        Inkscape::Preferences::Observer(path), ec(ec) {
+	    ToolPrefObserver(Glib::ustring const &path, ToolBase *ec)
+	        : Inkscape::Preferences::Observer(path)
+	        , ec(ec)
+	    {
 	    }
 
 	    virtual void notify(Inkscape::Preferences::Entry const &val) {
@@ -189,7 +218,6 @@ protected:
 
     /// The cursor's hot spot
     gint hot_x, hot_y;
-    /// Whether the tool should receive delayed snap events
 
     bool sp_event_context_knot_mouseover() const;
 
@@ -226,28 +254,6 @@ void sp_toggle_dropper(SPDesktop *dt);
 bool sp_event_context_knot_mouseover(ToolBase *ec);
 
 } // namespace Tools
-
-//#include <type_traits>
-
-namespace Tool {
-
-template<class Derived, typename T>
-bool is_a(const T* t) {
-    //static_assert(std::is_base_of<Tools::ToolBase, Derived>(), "Destination type not derived from ToolBase.");
-    //static_assert(std::is_convertible<const Tools::ToolBase*, const T*>(), "Cannot cast passed pointer to ToolBase*.");
-
-    return dynamic_cast<const Derived*>(static_cast<const Tools::ToolBase*>(t)) != NULL;
-}
-
-template<class Derived, typename T>
-Derived* to(T* t) {
-    //static_assert(std::is_base_of<Tools::ToolBase, Derived>(), "Destination type not derived from ToolBase.");
-    //static_assert(std::is_convertible<Tools::ToolBase*, T*>(), "Cannot cast passed pointer to ToolBase*.");
-
-    return dynamic_cast<Derived*>(static_cast<Tools::ToolBase*>(t));
-}
-
-} // namespace Tool
 } // namespace UI
 } // namespace Inkscape