Added some consts. Turned functions to member functions.

(bzr r13089)

21 files changed, 982 insertions, 1060 deletions

diff --git a/src/knotholder.cpp b/src/knotholder.cpp
index 71bccca16..bef89f3af 100644
--- a/src/knotholder.cpp
+++ b/src/knotholder.cpp
@@ -103,10 +103,10 @@ void KnotHolder::update_knots()
 /**
  * Returns true if at least one of the KnotHolderEntities has the mouse hovering above it.
  */
-bool KnotHolder::knot_mouseover()
-{
-    for(std::list<KnotHolderEntity *>::iterator i = entity.begin(); i != entity.end(); ++i) {
-        SPKnot *knot = (*i)->knot;
+bool KnotHolder::knot_mouseover() const {
+    for (std::list<KnotHolderEntity *>::const_iterator i = entity.begin(); i != entity.end(); ++i) {
+        const SPKnot *knot = (*i)->knot;
+
         if (knot && (knot->flags & SP_KNOT_MOUSEOVER)) {
             return true;
         }
diff --git a/src/knotholder.h b/src/knotholder.h
index eab981184..25557bef2 100644
--- a/src/knotholder.h
+++ b/src/knotholder.h
@@ -57,7 +57,7 @@ public:
 
     const SPItem *getItem() { return item; }
 
-    bool knot_mouseover();
+    bool knot_mouseover() const;
 
     friend class ShapeEditor;
     friend class Inkscape::LivePathEffect::PowerStrokePointArrayParamKnotHolderEntity;
diff --git a/src/shape-editor.cpp b/src/shape-editor.cpp
index 59d43f24c..bf53e8bc3 100644
--- a/src/shape-editor.cpp
+++ b/src/shape-editor.cpp
@@ -235,11 +235,11 @@ bool ShapeEditor::has_selection() {
 /**
  * Returns true if this ShapeEditor has a knot above which the mouse currently hovers.
  */
-bool ShapeEditor::knot_mouseover()
-{
+bool ShapeEditor::knot_mouseover() const {
     if (this->knotholder) {
         return knotholder->knot_mouseover();
     }
+
     return false;
 }
 
diff --git a/src/shape-editor.h b/src/shape-editor.h
index 9b3771fee..ec4b50fa3 100644
--- a/src/shape-editor.h
+++ b/src/shape-editor.h
@@ -64,7 +64,7 @@ public:
     // this one is only public because it's called from non-C++ repr changed callback
     void shapeeditor_event_attr_changed(gchar const *name);
 
-    bool knot_mouseover();
+    bool knot_mouseover() const;
     
     static void blockSetItem(bool b) {_blockSetItem = b;}
 
diff --git a/src/ui/tools/arc-tool.cpp b/src/ui/tools/arc-tool.cpp
index 435f4aa4b..43f8eb9e1 100644
--- a/src/ui/tools/arc-tool.cpp
+++ b/src/ui/tools/arc-tool.cpp
@@ -198,7 +198,7 @@ bool ArcTool::root_handler(GdkEvent* event) {
                 gobble_motion_events(GDK_BUTTON1_MASK);
 
                 handled = true;
-            } else if (!sp_event_context_knot_mouseover(this)){
+            } else if (!this->sp_event_context_knot_mouseover()){
                 SnapManager &m = desktop->namedview->snap_manager;
                 m.setup(desktop);
 
diff --git a/src/ui/tools/box3d-tool.cpp b/src/ui/tools/box3d-tool.cpp
index f0381a4a5..e00894d55 100644
--- a/src/ui/tools/box3d-tool.cpp
+++ b/src/ui/tools/box3d-tool.cpp
@@ -313,7 +313,7 @@ bool Box3dTool::root_handler(GdkEvent* event) {
             this->drag(event->motion.state);
 
             ret = TRUE;
-        } else if (!sp_event_context_knot_mouseover(this)) {
+        } else if (!this->sp_event_context_knot_mouseover()) {
             SnapManager &m = desktop->namedview->snap_manager;
             m.setup(desktop);
 
diff --git a/src/ui/tools/connector-tool.cpp b/src/ui/tools/connector-tool.cpp
index 391bae2e5..d2e23837c 100644
--- a/src/ui/tools/connector-tool.cpp
+++ b/src/ui/tools/connector-tool.cpp
@@ -115,40 +115,19 @@ namespace Inkscape {
 namespace UI {
 namespace Tools {
 
-// Stuff borrowed from DrawContext
-static void spcc_connector_set_initial_point(ConnectorTool *cc, Geom::Point const p);
-static void spcc_connector_set_subsequent_point(ConnectorTool *cc, Geom::Point const p);
-static void spcc_connector_finish_segment(ConnectorTool *cc, Geom::Point p);
-static void spcc_reset_colors(ConnectorTool *cc);
-static void spcc_connector_finish(ConnectorTool *cc);
-static void spcc_concat_colors_and_flush(ConnectorTool *cc);
-static void spcc_flush_white(ConnectorTool *cc, SPCurve *gc);
-
-// Context event handlers
-static gint connector_handle_button_press(ConnectorTool *const cc, GdkEventButton const &bevent);
-static gint connector_handle_motion_notify(ConnectorTool *const cc, GdkEventMotion const &mevent);
-static gint connector_handle_button_release(ConnectorTool *const cc, GdkEventButton const &revent);
-static gint connector_handle_key_press(ConnectorTool *const cc, guint const keyval);
-
-static void cc_active_shape_add_knot(ConnectorTool *cc, SPItem* item);
-static void cc_set_active_shape(ConnectorTool *cc, SPItem *item);
 static void cc_clear_active_knots(SPKnotList k);
-static void cc_clear_active_shape(ConnectorTool *cc);
-static void cc_set_active_conn(ConnectorTool *cc, SPItem *item);
-static void cc_clear_active_conn(ConnectorTool *cc);
-static bool conn_pt_handle_test(ConnectorTool *cc, Geom::Point& p, gchar **href);
-static void cc_select_handle(SPKnot* knot);
-static void cc_deselect_handle(SPKnot* knot);
-static bool cc_item_is_shape(SPItem *item);
-static void cc_connector_rerouting_finish(ConnectorTool *const cc,
-        Geom::Point *const p);
 
 static void shape_event_attr_deleted(Inkscape::XML::Node *repr,
         Inkscape::XML::Node *child, Inkscape::XML::Node *ref, gpointer data);
+
 static void shape_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
         gchar const *old_value, gchar const *new_value, bool is_interactive,
         gpointer data);
 
+static void cc_select_handle(SPKnot* knot);
+static void cc_deselect_handle(SPKnot* knot);
+static bool cc_item_is_shape(SPItem *item);
+
 /*static Geom::Point connector_drag_origin_w(0, 0);
 static bool connector_within_tolerance = false;*/
 
@@ -247,7 +226,7 @@ void ConnectorTool::setup() {
 
     this->sel_changed_connection.disconnect();
     this->sel_changed_connection = this->selection->connectChanged(
-    	sigc::mem_fun(this, &ConnectorTool::selection_changed)
+    	sigc::mem_fun(this, &ConnectorTool::_selectionChanged)
     );
 
     /* Create red bpath */
@@ -264,7 +243,7 @@ void ConnectorTool::setup() {
 
     // Notice the initial selection.
     //cc_selection_changed(this->selection, (gpointer) this);
-    this->selection_changed(this->selection);
+    this->_selectionChanged(this->selection);
 
     this->within_tolerance = false;
 
@@ -293,7 +272,7 @@ void ConnectorTool::set(const Inkscape::Preferences::Entry& val) {
 }
 
 void ConnectorTool::finish() {
-    spcc_connector_finish(this);
+    this->_finish();
     this->state = SP_CONNECTOR_CONTEXT_IDLE;
 
     ToolBase::finish();
@@ -302,8 +281,8 @@ void ConnectorTool::finish() {
         this->selection = NULL;
     }
 
-    cc_clear_active_shape(this);
-    cc_clear_active_conn(this);
+    this->cc_clear_active_shape();
+    this->cc_clear_active_conn();
 
     // Restore the default event generating behaviour.
     this->desktop->canvas->gen_all_enter_events = false;
@@ -312,28 +291,26 @@ void ConnectorTool::finish() {
 //-----------------------------------------------------------------------------
 
 
-static void
-cc_clear_active_shape(ConnectorTool *cc)
-{
-    if (cc->active_shape == NULL) {
+void ConnectorTool::cc_clear_active_shape() {
+    if (this->active_shape == NULL) {
         return;
     }
-    g_assert( cc->active_shape_repr );
-    g_assert( cc->active_shape_layer_repr );
+    g_assert( this->active_shape_repr );
+    g_assert( this->active_shape_layer_repr );
 
-    cc->active_shape = NULL;
+    this->active_shape = NULL;
 
-    if (cc->active_shape_repr) {
-        sp_repr_remove_listener_by_data(cc->active_shape_repr, cc);
-        Inkscape::GC::release(cc->active_shape_repr);
-        cc->active_shape_repr = NULL;
+    if (this->active_shape_repr) {
+        sp_repr_remove_listener_by_data(this->active_shape_repr, this);
+        Inkscape::GC::release(this->active_shape_repr);
+        this->active_shape_repr = NULL;
 
-        sp_repr_remove_listener_by_data(cc->active_shape_layer_repr, cc);
-        Inkscape::GC::release(cc->active_shape_layer_repr);
-        cc->active_shape_layer_repr = NULL;
+        sp_repr_remove_listener_by_data(this->active_shape_layer_repr, this);
+        Inkscape::GC::release(this->active_shape_layer_repr);
+        this->active_shape_layer_repr = NULL;
     }
 
-    cc_clear_active_knots(cc->knots);
+    cc_clear_active_knots(this->knots);
 }
 
 static void
@@ -347,38 +324,34 @@ cc_clear_active_knots(SPKnotList k)
     }
 }
 
-static void
-cc_clear_active_conn(ConnectorTool *cc)
-{
-    if (cc->active_conn == NULL) {
+void ConnectorTool::cc_clear_active_conn() {
+    if (this->active_conn == NULL) {
         return;
     }
-    g_assert( cc->active_conn_repr );
+    g_assert( this->active_conn_repr );
 
-    cc->active_conn = NULL;
+    this->active_conn = NULL;
 
-    if (cc->active_conn_repr) {
-        sp_repr_remove_listener_by_data(cc->active_conn_repr, cc);
-        Inkscape::GC::release(cc->active_conn_repr);
-        cc->active_conn_repr = NULL;
+    if (this->active_conn_repr) {
+        sp_repr_remove_listener_by_data(this->active_conn_repr, this);
+        Inkscape::GC::release(this->active_conn_repr);
+        this->active_conn_repr = NULL;
     }
 
     // Hide the endpoint handles.
     for (int i = 0; i < 2; ++i) {
-        if (cc->endpt_handle[i]) {
-            sp_knot_hide(cc->endpt_handle[i]);
+        if (this->endpt_handle[i]) {
+            sp_knot_hide(this->endpt_handle[i]);
         }
     }
 }
 
 
-static bool
-conn_pt_handle_test(ConnectorTool *cc, Geom::Point& p, gchar **href)
-{
-    if (cc->active_handle && (cc->knots.find(cc->active_handle) != cc->knots.end()))
+bool ConnectorTool::_ptHandleTest(Geom::Point& p, gchar **href) {
+    if (this->active_handle && (this->knots.find(this->active_handle) != this->knots.end()))
     {
-        p = cc->active_handle->pos;
-        *href = g_strdup_printf("#%s", cc->active_handle->owner->getId());
+        p = this->active_handle->pos;
+        *href = g_strdup_printf("#%s", this->active_handle->owner->getId());
         return true;
     }
     *href = NULL;
@@ -414,7 +387,7 @@ bool ConnectorTool::item_handler(SPItem* item, GdkEvent* event) {
         case GDK_BUTTON_RELEASE:
             if (event->button.button == 1 && !this->space_panning) {
                 if ((this->state == SP_CONNECTOR_CONTEXT_DRAGGING) && this->within_tolerance) {
-                    spcc_reset_colors(this);
+                    this->_resetColors();
                     this->state = SP_CONNECTOR_CONTEXT_IDLE;
                 }
 
@@ -435,7 +408,7 @@ bool ConnectorTool::item_handler(SPItem* item, GdkEvent* event) {
                     */
 
                     if (item != this->active_shape && !cc_item_is_connector(item)) {
-                        cc_set_active_shape(this, item);
+                        this->_setActiveShape(item);
                     }
                 }
 
@@ -446,7 +419,7 @@ bool ConnectorTool::item_handler(SPItem* item, GdkEvent* event) {
         case GDK_ENTER_NOTIFY:
             if (!this->selected_handle) {
                 if (cc_item_is_shape(item)) {
-                    cc_set_active_shape(this, item);
+                    this->_setActiveShape(item);
                 }
 
                 ret = TRUE;
@@ -465,19 +438,19 @@ bool ConnectorTool::root_handler(GdkEvent* event) {
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
-            ret = connector_handle_button_press(this, event->button);
+            ret = this->_handleButtonPress(event->button);
             break;
 
         case GDK_MOTION_NOTIFY:
-            ret = connector_handle_motion_notify(this, event->motion);
+            ret = this->_handleMotionNotify(event->motion);
             break;
 
         case GDK_BUTTON_RELEASE:
-            ret = connector_handle_button_release(this, event->button);
+            ret = this->_handleButtonRelease(event->button);
             break;
 
         case GDK_KEY_PRESS:
-            ret = connector_handle_key_press(this, get_group0_keyval (&event->key));
+            ret = this->_handleKeyPress(get_group0_keyval (&event->key));
             break;
 
         default:
@@ -492,82 +465,80 @@ bool ConnectorTool::root_handler(GdkEvent* event) {
 }
 
 
-static gint
-connector_handle_button_press(ConnectorTool *const cc, GdkEventButton const &bevent)
-{
+gint ConnectorTool::_handleButtonPress(GdkEventButton const &bevent) {
     Geom::Point const event_w(bevent.x, bevent.y);
     /* Find desktop coordinates */
-    Geom::Point p = cc->desktop->w2d(event_w);
-    ToolBase *event_context = SP_EVENT_CONTEXT(cc);
+    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 = cc->desktop;
+            SPDesktop *desktop = this->desktop;
 
-            if (Inkscape::have_viable_layer(desktop, cc->message_context) == false) {
+            if (Inkscape::have_viable_layer(desktop, this->message_context) == false) {
                 return TRUE;
             }
 
             Geom::Point const event_w(bevent.x,
                                     bevent.y);
 
-            cc->xp = bevent.x;
-            cc->yp = bevent.y;
-            cc->within_tolerance = true;
+            this->xp = bevent.x;
+            this->yp = bevent.y;
+            this->within_tolerance = true;
 
-            Geom::Point const event_dt = cc->desktop->w2d(event_w);
+            Geom::Point const event_dt = this->desktop->w2d(event_w);
 
-            SnapManager &m = cc->desktop->namedview->snap_manager;
+            SnapManager &m = this->desktop->namedview->snap_manager;
 
-            switch (cc->state) {
+            switch (this->state) {
                 case SP_CONNECTOR_CONTEXT_STOP:
                     /* This is allowed, if we just canceled curve */
                 case SP_CONNECTOR_CONTEXT_IDLE:
                 {
-                    if ( cc->npoints == 0 ) {
-                        cc_clear_active_conn(cc);
+                    if ( this->npoints == 0 ) {
+                        this->cc_clear_active_conn();
 
-                        cc->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Creating new connector"));
+                        this->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Creating new connector"));
 
                         /* Set start anchor */
                         /* Create green anchor */
                         Geom::Point p = event_dt;
 
                         // Test whether we clicked on a connection point
-                        bool found = conn_pt_handle_test(cc, p, &cc->shref);
+                        bool found = this->_ptHandleTest(p, &this->shref);
 
                         if (!found) {
                             // This is the first point, so just snap it to the grid
                             // as there's no other points to go off.
-                            m.setup(cc->desktop);
+                            m.setup(this->desktop);
                             m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_OTHER_HANDLE);
                             m.unSetup();
                         }
-                        spcc_connector_set_initial_point(cc, p);
+                        this->_setInitialPoint(p);
 
                     }
-                    cc->state = SP_CONNECTOR_CONTEXT_DRAGGING;
+                    this->state = SP_CONNECTOR_CONTEXT_DRAGGING;
                     ret = TRUE;
                     break;
                 }
                 case SP_CONNECTOR_CONTEXT_DRAGGING:
                 {
                     // This is the second click of a connector creation.
-                    m.setup(cc->desktop);
+                    m.setup(this->desktop);
                     m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_OTHER_HANDLE);
                     m.unSetup();
 
-                    spcc_connector_set_subsequent_point(cc, p);
-                    spcc_connector_finish_segment(cc, p);
+                    this->_setSubsequentPoint(p);
+                    this->_finishSegment(p);
                    
-                    conn_pt_handle_test(cc, p, &cc->ehref);
-                    if (cc->npoints != 0) {
-                        spcc_connector_finish(cc);
+                    this->_ptHandleTest(p, &this->ehref);
+                    if (this->npoints != 0) {
+                        this->_finish();
                     }
-                    cc_set_active_conn(cc, cc->newconn);
-                    cc->state = SP_CONNECTOR_CONTEXT_IDLE;
+                    this->cc_set_active_conn(this->newconn);
+                    this->state = SP_CONNECTOR_CONTEXT_IDLE;
                     ret = TRUE;
                     break;
                 }
@@ -580,30 +551,28 @@ connector_handle_button_press(ConnectorTool *const cc, GdkEventButton const &bev
                     break;
             }
         } else if (bevent.button == 3) {
-            if (cc->state == SP_CONNECTOR_CONTEXT_REROUTING) {
+            if (this->state == SP_CONNECTOR_CONTEXT_REROUTING) {
                 // A context menu is going to be triggered here,
                 // so end the rerouting operation.
-                cc_connector_rerouting_finish(cc, &p);
+                this->_reroutingFinish(&p);
 
-                cc->state = SP_CONNECTOR_CONTEXT_IDLE;
+                this->state = SP_CONNECTOR_CONTEXT_IDLE;
 
                 // Don't set ret to TRUE, so we drop through to the
                 // parent handler which will open the context menu.
             }
-            else if (cc->npoints != 0) {
-                spcc_connector_finish(cc);
-                cc->state = SP_CONNECTOR_CONTEXT_IDLE;
+            else if (this->npoints != 0) {
+                this->_finish();
+                this->state = SP_CONNECTOR_CONTEXT_IDLE;
                 ret = TRUE;
             }
         }
     return ret;
 }
 
-static gint
-connector_handle_motion_notify(ConnectorTool *const cc, GdkEventMotion const &mevent)
-{
+gint ConnectorTool::_handleMotionNotify(GdkEventMotion const &mevent) {
     gint ret = FALSE;
-    ToolBase *event_context = SP_EVENT_CONTEXT(cc);
+    ToolBase *event_context = SP_EVENT_CONTEXT(this);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
     if (event_context->space_panning || mevent.state & GDK_BUTTON2_MASK || mevent.state & GDK_BUTTON3_MASK) {
@@ -613,36 +582,36 @@ connector_handle_motion_notify(ConnectorTool *const cc, GdkEventMotion const &me
 
     Geom::Point const event_w(mevent.x, mevent.y);
 
-    if (cc->within_tolerance) {
-        cc->tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
-        if ( ( abs( (gint) mevent.x - cc->xp ) < cc->tolerance ) &&
-             ( abs( (gint) mevent.y - cc->yp ) < cc->tolerance ) ) {
+    if (this->within_tolerance) {
+        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.
         }
     }
     // Once the user has moved farther than tolerance from the original location
     // (indicating they intend to move the object, not click), then always process
     // the motion notify coordinates as given (no snapping back to origin)
-    cc->within_tolerance = false;
+    this->within_tolerance = false;
 
-    SPDesktop *const dt = cc->desktop;
+    SPDesktop *const dt = this->desktop;
 
     /* Find desktop coordinates */
     Geom::Point p = dt->w2d(event_w);
 
         SnapManager &m = dt->namedview->snap_manager;
 
-        switch (cc->state) {
+        switch (this->state) {
             case SP_CONNECTOR_CONTEXT_DRAGGING:
             {
                 gobble_motion_events(mevent.state);
                 // This is movement during a connector creation.
-                if ( cc->npoints > 0 ) {
+                if ( this->npoints > 0 ) {
                     m.setup(dt);
                     m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_OTHER_HANDLE);
                     m.unSetup();
-                    cc->selection->clear();
-                    spcc_connector_set_subsequent_point(cc, p);
+                    this->selection->clear();
+                    this->_setSubsequentPoint(p);
                     ret = TRUE;
                 }
                 break;
@@ -650,32 +619,32 @@ connector_handle_motion_notify(ConnectorTool *const cc, GdkEventMotion const &me
             case SP_CONNECTOR_CONTEXT_REROUTING:
             {
                 gobble_motion_events(GDK_BUTTON1_MASK);
-                g_assert( SP_IS_PATH(cc->clickeditem));
+                g_assert( SP_IS_PATH(this->clickeditem));
 
                 m.setup(dt);
                 m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_OTHER_HANDLE);
                 m.unSetup();
 
                 // Update the hidden path
-                Geom::Affine i2d ( (cc->clickeditem)->i2dt_affine() );
+                Geom::Affine i2d ( (this->clickeditem)->i2dt_affine() );
                 Geom::Affine d2i = i2d.inverse();
-                SPPath *path = SP_PATH(cc->clickeditem);
+                SPPath *path = SP_PATH(this->clickeditem);
                 SPCurve *curve = path->get_curve();
-                if (cc->clickedhandle == cc->endpt_handle[0]) {
-                    Geom::Point o = cc->endpt_handle[1]->pos;
+                if (this->clickedhandle == this->endpt_handle[0]) {
+                    Geom::Point o = this->endpt_handle[1]->pos;
                     curve->stretch_endpoints(p * d2i, o * d2i);
                 }
                 else {
-                    Geom::Point o = cc->endpt_handle[0]->pos;
+                    Geom::Point o = this->endpt_handle[0]->pos;
                     curve->stretch_endpoints(o * d2i, p * d2i);
                 }
                 sp_conn_reroute_path_immediate(path);
 
                 // Copy this to the temporary visible path
-                cc->red_curve = path->get_curve_for_edit();
-                cc->red_curve->transform(i2d);
+                this->red_curve = path->get_curve_for_edit();
+                this->red_curve->transform(i2d);
 
-                sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), cc->red_curve);
+                sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
                 ret = TRUE;
                 break;
             }
@@ -683,7 +652,7 @@ connector_handle_motion_notify(ConnectorTool *const cc, GdkEventMotion const &me
                 /* This is perfectly valid */
                 break;
             default:
-                if (!sp_event_context_knot_mouseover(cc)) {
+                if (!this->sp_event_context_knot_mouseover()) {
                     m.setup(dt);
                     m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_OTHER_HANDLE));
                     m.unSetup();
@@ -693,14 +662,12 @@ connector_handle_motion_notify(ConnectorTool *const cc, GdkEventMotion const &me
     return ret;
 }
 
-static gint
-connector_handle_button_release(ConnectorTool *const cc, GdkEventButton const &revent)
-{
+gint ConnectorTool::_handleButtonRelease(GdkEventButton const &revent) {
     gint ret = FALSE;
-    ToolBase *event_context = SP_EVENT_CONTEXT(cc);
+    ToolBase *event_context = SP_EVENT_CONTEXT(this);
     if ( revent.button == 1 && !event_context->space_panning ) {
 
-        SPDesktop *desktop = cc->desktop;
+        SPDesktop *desktop = this->desktop;
         SPDocument *doc = sp_desktop_document(desktop);
 
         SnapManager &m = desktop->namedview->snap_manager;
@@ -708,9 +675,9 @@ connector_handle_button_release(ConnectorTool *const cc, GdkEventButton const &r
         Geom::Point const event_w(revent.x, revent.y);
 
         /* Find desktop coordinates */
-        Geom::Point p = cc->desktop->w2d(event_w);
+        Geom::Point p = this->desktop->w2d(event_w);
 
-            switch (cc->state) {
+            switch (this->state) {
                 //case SP_CONNECTOR_CONTEXT_POINT:
                 case SP_CONNECTOR_CONTEXT_DRAGGING:
                 {
@@ -718,21 +685,21 @@ connector_handle_button_release(ConnectorTool *const cc, GdkEventButton const &r
                     m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_OTHER_HANDLE);
                     m.unSetup();
 
-                    if (cc->within_tolerance)
+                    if (this->within_tolerance)
                     {
-                        spcc_connector_finish_segment(cc, p);
+                        this->_finishSegment(p);
                         return TRUE;
                     }
                     // Connector has been created via a drag, end it now.
-                    spcc_connector_set_subsequent_point(cc, p);
-                    spcc_connector_finish_segment(cc, p);
+                    this->_setSubsequentPoint(p);
+                    this->_finishSegment(p);
                     // Test whether we clicked on a connection point
-                    conn_pt_handle_test(cc, p, &cc->ehref);
-                    if (cc->npoints != 0) {
-                        spcc_connector_finish(cc);
+                    this->_ptHandleTest(p, &this->ehref);
+                    if (this->npoints != 0) {
+                        this->_finish();
                     }
-                    cc_set_active_conn(cc, cc->newconn);
-                    cc->state = SP_CONNECTOR_CONTEXT_IDLE;
+                    this->cc_set_active_conn(this->newconn);
+                    this->state = SP_CONNECTOR_CONTEXT_IDLE;
                     break;
                 }
                 case SP_CONNECTOR_CONTEXT_REROUTING:
@@ -740,10 +707,10 @@ connector_handle_button_release(ConnectorTool *const cc, GdkEventButton const &r
                     m.setup(desktop);
                     m.freeSnapReturnByRef(p, Inkscape::SNAPSOURCE_OTHER_HANDLE);
                     m.unSetup();
-                    cc_connector_rerouting_finish(cc, &p);
+                    this->_reroutingFinish(&p);
 
                     doc->ensureUpToDate();
-                    cc->state = SP_CONNECTOR_CONTEXT_IDLE;
+                    this->state = SP_CONNECTOR_CONTEXT_IDLE;
                     return TRUE;
                     break;
                 }
@@ -758,39 +725,37 @@ connector_handle_button_release(ConnectorTool *const cc, GdkEventButton const &r
     return ret;
 }
 
-static gint
-connector_handle_key_press(ConnectorTool *const cc, guint const keyval)
-{
+gint ConnectorTool::_handleKeyPress(guint const keyval) {
     gint ret = FALSE;
 
         switch (keyval) {
             case GDK_KEY_Return:
             case GDK_KEY_KP_Enter:
-                if (cc->npoints != 0) {
-                    spcc_connector_finish(cc);
-                    cc->state = SP_CONNECTOR_CONTEXT_IDLE;
+                if (this->npoints != 0) {
+                    this->_finish();
+                    this->state = SP_CONNECTOR_CONTEXT_IDLE;
                     ret = TRUE;
                 }
                 break;
             case GDK_KEY_Escape:
-                if (cc->state == SP_CONNECTOR_CONTEXT_REROUTING) {
+                if (this->state == SP_CONNECTOR_CONTEXT_REROUTING) {
 
-                    SPDesktop *desktop = cc->desktop;
+                    SPDesktop *desktop = this->desktop;
                     SPDocument *doc = sp_desktop_document(desktop);
 
-                    cc_connector_rerouting_finish(cc, NULL);
+                    this->_reroutingFinish(NULL);
 
                     DocumentUndo::undo(doc);
 
-                    cc->state = SP_CONNECTOR_CONTEXT_IDLE;
+                    this->state = SP_CONNECTOR_CONTEXT_IDLE;
                     desktop->messageStack()->flash( Inkscape::NORMAL_MESSAGE,
                             _("Connector endpoint drag cancelled."));
                     ret = TRUE;
                 }
-                else if (cc->npoints != 0) {
+                else if (this->npoints != 0) {
                     // if drawing, cancel, otherwise pass it up for deselecting
-                    cc->state = SP_CONNECTOR_CONTEXT_STOP;
-                    spcc_reset_colors(cc);
+                    this->state = SP_CONNECTOR_CONTEXT_STOP;
+                    this->_resetColors();
                     ret = TRUE;
                 }
                 break;
@@ -800,95 +765,84 @@ connector_handle_key_press(ConnectorTool *const cc, guint const keyval)
     return ret;
 }
 
-
-static void
-cc_connector_rerouting_finish(ConnectorTool *const cc, Geom::Point *const p)
-{
-    SPDesktop *desktop = cc->desktop;
+void ConnectorTool::_reroutingFinish(Geom::Point *const p) {
+    SPDesktop *desktop = this->desktop;
     SPDocument *doc = sp_desktop_document(desktop);
 
     // Clear the temporary path:
-    cc->red_curve->reset();
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), NULL);
+    this->red_curve->reset();
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
 
     if (p != NULL)
     {
         // Test whether we clicked on a connection point
         gchar *shape_label;
-        bool found = conn_pt_handle_test(cc, *p, &shape_label);
+        bool found = this->_ptHandleTest(*p, &shape_label);
 
         if (found) {
-            if (cc->clickedhandle == cc->endpt_handle[0]) {
-                cc->clickeditem->setAttribute("inkscape:connection-start", shape_label, NULL);
+            if (this->clickedhandle == this->endpt_handle[0]) {
+                this->clickeditem->setAttribute("inkscape:connection-start", shape_label, NULL);
             }
             else {
-                cc->clickeditem->setAttribute("inkscape:connection-end", shape_label, NULL);
+                this->clickeditem->setAttribute("inkscape:connection-end", shape_label, NULL);
             }
             g_free(shape_label);
         }
     }
-    cc->clickeditem->setHidden(false);
-    sp_conn_reroute_path_immediate(SP_PATH(cc->clickeditem));
-    cc->clickeditem->updateRepr();
+    this->clickeditem->setHidden(false);
+    sp_conn_reroute_path_immediate(SP_PATH(this->clickeditem));
+    this->clickeditem->updateRepr();
     DocumentUndo::done(doc, SP_VERB_CONTEXT_CONNECTOR,
                      _("Reroute connector"));
-    cc_set_active_conn(cc, cc->clickeditem);
+    this->cc_set_active_conn(this->clickeditem);
 }
 
 
-static void
-spcc_reset_colors(ConnectorTool *cc)
-{
+void ConnectorTool::_resetColors() {
     /* Red */
-    cc->red_curve->reset();
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), NULL);
+    this->red_curve->reset();
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
 
-    cc->green_curve->reset();
-    cc->npoints = 0;
+    this->green_curve->reset();
+    this->npoints = 0;
 }
 
+void ConnectorTool::_setInitialPoint(Geom::Point const p) {
+    g_assert( this->npoints == 0 );
 
-static void
-spcc_connector_set_initial_point(ConnectorTool *const cc, Geom::Point const p)
-{
-    g_assert( cc->npoints == 0 );
-
-    cc->p[0] = p;
-    cc->p[1] = p;
-    cc->npoints = 2;
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), NULL);
+    this->p[0] = p;
+    this->p[1] = p;
+    this->npoints = 2;
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
 }
 
+void ConnectorTool::_setSubsequentPoint(Geom::Point const p) {
+    g_assert( this->npoints != 0 );
 
-static void
-spcc_connector_set_subsequent_point(ConnectorTool *const cc, Geom::Point const p)
-{
-    g_assert( cc->npoints != 0 );
-
-    SPDesktop *dt = cc->desktop;
-    Geom::Point o = dt->dt2doc(cc->p[0]);
+    SPDesktop *dt = this->desktop;
+    Geom::Point o = dt->dt2doc(this->p[0]);
     Geom::Point d = dt->dt2doc(p);
     Avoid::Point src(o[Geom::X], o[Geom::Y]);
     Avoid::Point dst(d[Geom::X], d[Geom::Y]);
 
-    if (!cc->newConnRef) {
+    if (!this->newConnRef) {
         Avoid::Router *router = sp_desktop_document(dt)->router;
-        cc->newConnRef = new Avoid::ConnRef(router);
-        cc->newConnRef->setEndpoint(Avoid::VertID::src, src);
-        if (cc->isOrthogonal)
-            cc->newConnRef->setRoutingType(Avoid::ConnType_Orthogonal);
+        this->newConnRef = new Avoid::ConnRef(router);
+        this->newConnRef->setEndpoint(Avoid::VertID::src, src);
+        if (this->isOrthogonal)
+            this->newConnRef->setRoutingType(Avoid::ConnType_Orthogonal);
         else
-            cc->newConnRef->setRoutingType(Avoid::ConnType_PolyLine);
+            this->newConnRef->setRoutingType(Avoid::ConnType_PolyLine);
     }
     // Set new endpoint.
-    cc->newConnRef->setEndpoint(Avoid::VertID::tar, dst);
+    this->newConnRef->setEndpoint(Avoid::VertID::tar, dst);
     // Immediately generate new routes for connector.
-    cc->newConnRef->makePathInvalid();
-    cc->newConnRef->router()->processTransaction();
+    this->newConnRef->makePathInvalid();
+    this->newConnRef->router()->processTransaction();
     // Recreate curve from libavoid route.
-    recreateCurve( cc->red_curve, cc->newConnRef, cc->curvature );
-    cc->red_curve->transform(dt->doc2dt());
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), cc->red_curve);
+    recreateCurve( this->red_curve, this->newConnRef, this->curvature );
+    this->red_curve->transform(dt->doc2dt());
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
 }
 
 
@@ -897,21 +851,19 @@ spcc_connector_set_subsequent_point(ConnectorTool *const cc, Geom::Point const p
  * If any anchors are defined, process these, optionally removing curves from white list
  * Invoke _flush_white to write result back to object.
  */
-static void
-spcc_concat_colors_and_flush(ConnectorTool *cc)
-{
-    SPCurve *c = cc->green_curve;
-    cc->green_curve = new SPCurve();
+void ConnectorTool::_concatColorsAndFlush() {
+    SPCurve *c = this->green_curve;
+    this->green_curve = new SPCurve();
 
-    cc->red_curve->reset();
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(cc->red_bpath), NULL);
+    this->red_curve->reset();
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
 
     if (c->is_empty()) {
         c->unref();
         return;
     }
 
-    spcc_flush_white(cc, c);
+    this->_flushWhite(c);
 
     c->unref();
 }
@@ -925,9 +877,7 @@ spcc_concat_colors_and_flush(ConnectorTool *cc)
  *
  */
 
-static void
-spcc_flush_white(ConnectorTool *cc, SPCurve *gc)
-{
+void ConnectorTool::_flushWhite(SPCurve *gc) {
     SPCurve *c;
 
     if (gc) {
@@ -938,9 +888,9 @@ spcc_flush_white(ConnectorTool *cc, SPCurve *gc)
     }
 
     /* Now we have to go back to item coordinates at last */
-    c->transform(cc->desktop->dt2doc());
+    c->transform(this->desktop->dt2doc());
 
-    SPDesktop *desktop = cc->desktop;
+    SPDesktop *desktop = this->desktop;
     SPDocument *doc = sp_desktop_document(desktop);
     Inkscape::XML::Document *xml_doc = doc->getReprDoc();
 
@@ -957,42 +907,42 @@ spcc_flush_white(ConnectorTool *cc, SPCurve *gc)
         g_free(str);
 
         /* Attach repr */
-        cc->newconn = SP_ITEM(desktop->currentLayer()->appendChildRepr(repr));
-        cc->newconn->transform = SP_ITEM(desktop->currentLayer())->i2doc_affine().inverse();
+        this->newconn = SP_ITEM(desktop->currentLayer()->appendChildRepr(repr));
+        this->newconn->transform = SP_ITEM(desktop->currentLayer())->i2doc_affine().inverse();
 
         bool connection = false;
-        cc->newconn->setAttribute( "inkscape:connector-type",
-                                   cc->isOrthogonal ? "orthogonal" : "polyline", NULL );
-        cc->newconn->setAttribute( "inkscape:connector-curvature",
-                                   Glib::Ascii::dtostr(cc->curvature).c_str(), NULL );
-        if (cc->shref)
+        this->newconn->setAttribute( "inkscape:connector-type",
+                                   this->isOrthogonal ? "orthogonal" : "polyline", NULL );
+        this->newconn->setAttribute( "inkscape:connector-curvature",
+                                   Glib::Ascii::dtostr(this->curvature).c_str(), NULL );
+        if (this->shref)
         {
-            cc->newconn->setAttribute( "inkscape:connection-start", cc->shref, NULL);
+            this->newconn->setAttribute( "inkscape:connection-start", this->shref, NULL);
             connection = true;
         }
 
-        if (cc->ehref)
+        if (this->ehref)
         {
-            cc->newconn->setAttribute( "inkscape:connection-end", cc->ehref, NULL);
+            this->newconn->setAttribute( "inkscape:connection-end", this->ehref, NULL);
             connection = true;
         }
         // Process pending updates.
-        cc->newconn->updateRepr();
+        this->newconn->updateRepr();
         doc->ensureUpToDate();
 
         if (connection) {
             // Adjust endpoints to shape edge.
-            sp_conn_reroute_path_immediate(SP_PATH(cc->newconn));
-            cc->newconn->updateRepr();
+            sp_conn_reroute_path_immediate(SP_PATH(this->newconn));
+            this->newconn->updateRepr();
         }
 
-        cc->newconn->doWriteTransform(cc->newconn->getRepr(), cc->newconn->transform, NULL, true);
+        this->newconn->doWriteTransform(this->newconn->getRepr(), this->newconn->transform, NULL, true);
 
         // Only set the selection after we are finished with creating the attributes of
         // the connector.  Otherwise, the selection change may alter the defaults for
         // values like curvature in the connector context, preventing subsequent lookup
         // of their original values.
-        cc->selection->set(repr);
+        this->selection->set(repr);
         Inkscape::GC::release(repr);
     }
 
@@ -1002,36 +952,31 @@ spcc_flush_white(ConnectorTool *cc, SPCurve *gc)
 }
 
 
-static void
-spcc_connector_finish_segment(ConnectorTool *const cc, Geom::Point const /*p*/)
-{
-    if (!cc->red_curve->is_empty()) {
-        cc->green_curve->append_continuous(cc->red_curve, 0.0625);
+void ConnectorTool::_finishSegment(Geom::Point const /*p*/) {
+    if (!this->red_curve->is_empty()) {
+        this->green_curve->append_continuous(this->red_curve, 0.0625);
 
-        cc->p[0] = cc->p[3];
-        cc->p[1] = cc->p[4];
-        cc->npoints = 2;
+        this->p[0] = this->p[3];
+        this->p[1] = this->p[4];
+        this->npoints = 2;
 
-        cc->red_curve->reset();
+        this->red_curve->reset();
     }
 }
 
-
-static void
-spcc_connector_finish(ConnectorTool *const cc)
-{
-    SPDesktop *const desktop = cc->desktop;
+void ConnectorTool::_finish() {
+    SPDesktop *const desktop = this->desktop;
     desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Finishing connector"));
 
-    cc->red_curve->reset();
-    spcc_concat_colors_and_flush(cc);
+    this->red_curve->reset();
+    this->_concatColorsAndFlush();
 
-    cc->npoints = 0;
+    this->npoints = 0;
 
-    if (cc->newConnRef) {
-        cc->newConnRef->removeFromGraph();
-        delete cc->newConnRef;
-        cc->newConnRef = NULL;
+    if (this->newConnRef) {
+        this->newConnRef->removeFromGraph();
+        delete this->newConnRef;
+        this->newConnRef = NULL;
     }
 }
 
@@ -1102,7 +1047,7 @@ endpt_handler(SPKnot */*knot*/, GdkEvent *event, ConnectorTool *cc)
             if (cc->state == SP_CONNECTOR_CONTEXT_IDLE) {
                 cc->clickeditem = cc->active_conn;
                 cc->clickedhandle = cc->active_handle;
-                cc_clear_active_conn(cc);
+                cc->cc_clear_active_conn();
                 cc->state = SP_CONNECTOR_CONTEXT_REROUTING;
 
                 // Disconnect from attached shape
@@ -1137,9 +1082,8 @@ endpt_handler(SPKnot */*knot*/, GdkEvent *event, ConnectorTool *cc)
     return consumed;
 }
 
-static void cc_active_shape_add_knot(ConnectorTool *cc, SPItem* item)
-{
-        SPDesktop *desktop = cc->desktop;
+void ConnectorTool::_activeShapeAddKnot(SPItem* item) {
+        SPDesktop *desktop = this->desktop;
         SPKnot *knot = sp_knot_new(desktop, 0);
 
         knot->owner = item;
@@ -1158,48 +1102,47 @@ static void cc_active_shape_add_knot(ConnectorTool *cc, SPItem* item)
                 G_CALLBACK(cc_generic_knot_handler), knot);
         sp_knot_set_position(knot, item->avoidRef->getConnectionPointPos() * desktop->doc2dt(), 0);
         sp_knot_show(knot);
-        cc->knots[knot] = 1;
+        this->knots[knot] = 1;
 }
 
-static void cc_set_active_shape(ConnectorTool *cc, SPItem *item)
-{
+void ConnectorTool::_setActiveShape(SPItem *item) {
     g_assert(item != NULL );
 
-    if (cc->active_shape != item)
+    if (this->active_shape != item)
     {
         // The active shape has changed
         // Rebuild everything
-        cc->active_shape = item;
+        this->active_shape = item;
         // Remove existing active shape listeners
-        if (cc->active_shape_repr) {
-            sp_repr_remove_listener_by_data(cc->active_shape_repr, cc);
-            Inkscape::GC::release(cc->active_shape_repr);
+        if (this->active_shape_repr) {
+            sp_repr_remove_listener_by_data(this->active_shape_repr, this);
+            Inkscape::GC::release(this->active_shape_repr);
 
-            sp_repr_remove_listener_by_data(cc->active_shape_layer_repr, cc);
-            Inkscape::GC::release(cc->active_shape_layer_repr);
+            sp_repr_remove_listener_by_data(this->active_shape_layer_repr, this);
+            Inkscape::GC::release(this->active_shape_layer_repr);
         }
 
         // Listen in case the active shape changes
-        cc->active_shape_repr = item->getRepr();
-        if (cc->active_shape_repr) {
-            Inkscape::GC::anchor(cc->active_shape_repr);
-            sp_repr_add_listener(cc->active_shape_repr, &shape_repr_events, cc);
-
-            cc->active_shape_layer_repr = cc->active_shape_repr->parent();
-            Inkscape::GC::anchor(cc->active_shape_layer_repr);
-            sp_repr_add_listener(cc->active_shape_layer_repr, &layer_repr_events, cc);
+        this->active_shape_repr = item->getRepr();
+        if (this->active_shape_repr) {
+            Inkscape::GC::anchor(this->active_shape_repr);
+            sp_repr_add_listener(this->active_shape_repr, &shape_repr_events, this);
+
+            this->active_shape_layer_repr = this->active_shape_repr->parent();
+            Inkscape::GC::anchor(this->active_shape_layer_repr);
+            sp_repr_add_listener(this->active_shape_layer_repr, &layer_repr_events, this);
         }
 
-        cc_clear_active_knots(cc->knots);
+        cc_clear_active_knots(this->knots);
 
         // The idea here is to try and add a group's children to solidify
         // connection handling. We react to path objects with only one node.
         for (SPObject *child = item->firstChild() ; child ; child = child->getNext() ) {
           if (SP_IS_PATH(child) && SP_PATH(child)->nodesInPath() == 1) {
-              cc_active_shape_add_knot(cc, (SPItem *) child);
+              this->_activeShapeAddKnot((SPItem *) child);
           }
         }
-        cc_active_shape_add_knot(cc, item);
+        this->_activeShapeAddKnot(item);
 
     }
     else
@@ -1210,58 +1153,55 @@ static void cc_set_active_shape(ConnectorTool *cc, SPItem *item)
     }
 }
 
-
-static void
-cc_set_active_conn(ConnectorTool *cc, SPItem *item)
-{
+void ConnectorTool::cc_set_active_conn(SPItem *item) {
     g_assert( SP_IS_PATH(item) );
 
     const SPCurve *curve = SP_PATH(item)->get_curve_reference();
     Geom::Affine i2dt = item->i2dt_affine();
 
-    if (cc->active_conn == item)
+    if (this->active_conn == item)
     {
         if (curve->is_empty())
         {
             // Connector is invisible because it is clipped to the boundary of
             // two overlpapping shapes.
-            sp_knot_hide(cc->endpt_handle[0]);
-            sp_knot_hide(cc->endpt_handle[1]);
+            sp_knot_hide(this->endpt_handle[0]);
+            sp_knot_hide(this->endpt_handle[1]);
         }
         else
         {
             // Just adjust handle positions.
             Geom::Point startpt = *(curve->first_point()) * i2dt;
-            sp_knot_set_position(cc->endpt_handle[0], startpt, 0);
+            sp_knot_set_position(this->endpt_handle[0], startpt, 0);
 
             Geom::Point endpt = *(curve->last_point()) * i2dt;
-            sp_knot_set_position(cc->endpt_handle[1], endpt, 0);
+            sp_knot_set_position(this->endpt_handle[1], endpt, 0);
         }
 
         return;
     }
 
-    cc->active_conn = item;
+    this->active_conn = item;
 
     // Remove existing active conn listeners
-    if (cc->active_conn_repr) {
-        sp_repr_remove_listener_by_data(cc->active_conn_repr, cc);
-        Inkscape::GC::release(cc->active_conn_repr);
-        cc->active_conn_repr = NULL;
+    if (this->active_conn_repr) {
+        sp_repr_remove_listener_by_data(this->active_conn_repr, this);
+        Inkscape::GC::release(this->active_conn_repr);
+        this->active_conn_repr = NULL;
     }
 
     // Listen in case the active conn changes
-    cc->active_conn_repr = item->getRepr();
-    if (cc->active_conn_repr) {
-        Inkscape::GC::anchor(cc->active_conn_repr);
-        sp_repr_add_listener(cc->active_conn_repr, &shape_repr_events, cc);
+    this->active_conn_repr = item->getRepr();
+    if (this->active_conn_repr) {
+        Inkscape::GC::anchor(this->active_conn_repr);
+        sp_repr_add_listener(this->active_conn_repr, &shape_repr_events, this);
     }
 
     for (int i = 0; i < 2; ++i) {
 
         // Create the handle if it doesn't exist
-        if ( cc->endpt_handle[i] == NULL ) {
-            SPKnot *knot = sp_knot_new(cc->desktop,
+        if ( this->endpt_handle[i] == NULL ) {
+            SPKnot *knot = sp_knot_new(this->desktop,
                     _("<b>Connector endpoint</b>: drag to reroute or connect to new shapes"));
 
             knot->setShape(SP_KNOT_SHAPE_SQUARE);
@@ -1280,23 +1220,23 @@ cc_set_active_conn(ConnectorTool *cc, SPItem *item)
             g_signal_connect(G_OBJECT(knot->item), "event",
                     G_CALLBACK(cc_generic_knot_handler), knot);
 
-            cc->endpt_handle[i] = knot;
+            this->endpt_handle[i] = knot;
         }
 
         // Remove any existing handlers
-        if (cc->endpt_handler_id[i]) {
+        if (this->endpt_handler_id[i]) {
             g_signal_handlers_disconnect_by_func(
-                    G_OBJECT(cc->endpt_handle[i]->item),
-                    (void*)G_CALLBACK(endpt_handler), (gpointer) cc );
-            cc->endpt_handler_id[i] = 0;
+                    G_OBJECT(this->endpt_handle[i]->item),
+                    (void*)G_CALLBACK(endpt_handler), (gpointer) this );
+            this->endpt_handler_id[i] = 0;
         }
 
         // Setup handlers for connector endpoints, this is
         // is as 'after' so that cc_generic_knot_handler is
         // triggered first for any endpoint.
-        cc->endpt_handler_id[i] = g_signal_connect_after(
-                G_OBJECT(cc->endpt_handle[i]->item), "event",
-                G_CALLBACK(endpt_handler), cc);
+        this->endpt_handler_id[i] = g_signal_connect_after(
+                G_OBJECT(this->endpt_handle[i]->item), "event",
+                G_CALLBACK(endpt_handler), this);
     }
 
     if (curve->is_empty())
@@ -1307,13 +1247,13 @@ cc_set_active_conn(ConnectorTool *cc, SPItem *item)
     }
 
     Geom::Point startpt = *(curve->first_point()) * i2dt;
-    sp_knot_set_position(cc->endpt_handle[0], startpt, 0);
+    sp_knot_set_position(this->endpt_handle[0], startpt, 0);
 
     Geom::Point endpt = *(curve->last_point()) * i2dt;
-    sp_knot_set_position(cc->endpt_handle[1], endpt, 0);
+    sp_knot_set_position(this->endpt_handle[1], endpt, 0);
 
-    sp_knot_show(cc->endpt_handle[0]);
-    sp_knot_show(cc->endpt_handle[1]);
+    sp_knot_show(this->endpt_handle[0]);
+    sp_knot_show(this->endpt_handle[1]);
 }
 
 void cc_create_connection_point(ConnectorTool* cc)
@@ -1412,7 +1352,7 @@ void cc_selection_set_avoid(bool const set_avoid)
     DocumentUndo::done(document, SP_VERB_CONTEXT_CONNECTOR, event_desc);
 }
 
-void ConnectorTool::selection_changed(Inkscape::Selection *selection) {
+void ConnectorTool::_selectionChanged(Inkscape::Selection *selection) {
     SPItem *item = selection->singleItem();
 
     if (this->active_conn == item) {
@@ -1421,12 +1361,12 @@ void ConnectorTool::selection_changed(Inkscape::Selection *selection) {
     }
 
     if (item == NULL) {
-        cc_clear_active_conn(this);
+        this->cc_clear_active_conn();
         return;
     }
 
     if (cc_item_is_connector(item)) {
-        cc_set_active_conn(this, item);
+        this->cc_set_active_conn(item);
     }
 }
 
@@ -1439,7 +1379,7 @@ shape_event_attr_deleted(Inkscape::XML::Node */*repr*/, Inkscape::XML::Node *chi
 
     if (child == cc->active_shape_repr) {
         // The active shape has been deleted.  Clear active shape.
-        cc_clear_active_shape(cc);
+        cc->cc_clear_active_shape();
     }
 }
 
@@ -1459,12 +1399,12 @@ shape_event_attr_changed(Inkscape::XML::Node *repr, gchar const *name,
     {
         if (repr == cc->active_shape_repr) {
             // Active shape has moved. Clear active shape.
-            cc_clear_active_shape(cc);
+            cc->cc_clear_active_shape();
         }
         else if (repr == cc->active_conn_repr) {
             // The active conn has been moved.
             // Set it again, which just sets new handle positions.
-            cc_set_active_conn(cc, cc->active_conn);
+            cc->cc_set_active_conn(cc->active_conn);
         }
     }
 }
diff --git a/src/ui/tools/connector-tool.h b/src/ui/tools/connector-tool.h
index 7cd6a6dad..59534a173 100644
--- a/src/ui/tools/connector-tool.h
+++ b/src/ui/tools/connector-tool.h
@@ -108,8 +108,31 @@ public:
 
 	virtual const std::string& getPrefsPath();
 
+    void cc_clear_active_shape();
+    void cc_set_active_conn(SPItem *item);
+    void cc_clear_active_conn();
+
 private:
-	void selection_changed(Inkscape::Selection *selection);
+	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);
+
+	void _setInitialPoint(Geom::Point const p);
+	void _setSubsequentPoint(Geom::Point const p);
+	void _finishSegment(Geom::Point p);
+	void _resetColors();
+	void _finish();
+	void _concatColorsAndFlush();
+	void _flushWhite(SPCurve *gc);
+
+	void _activeShapeAddKnot(SPItem* item);
+	void _setActiveShape(SPItem *item);
+	bool _ptHandleTest(Geom::Point& p, gchar **href);
+
+	void _reroutingFinish(Geom::Point *const p);
 };
 
 void cc_selection_set_avoid(bool const set_ignore);
diff --git a/src/ui/tools/freehand-base.cpp b/src/ui/tools/freehand-base.cpp
index 2fb4a3481..288a200f4 100644
--- a/src/ui/tools/freehand-base.cpp
+++ b/src/ui/tools/freehand-base.cpp
@@ -331,7 +331,7 @@ static void spdc_check_for_and_apply_waiting_LPE(FreehandBase *dc, SPItem *item,
             }
         }
         if (SP_IS_PEN_CONTEXT(dc)) {
-            sp_pen_context_set_polyline_mode(SP_PEN_CONTEXT(dc));
+            SP_PEN_CONTEXT(dc)->setPolylineMode();
         }
     }
 }
diff --git a/src/ui/tools/lpe-tool.cpp b/src/ui/tools/lpe-tool.cpp
index 6c41bb160..9ab6d7814 100644
--- a/src/ui/tools/lpe-tool.cpp
+++ b/src/ui/tools/lpe-tool.cpp
@@ -191,7 +191,7 @@ bool LpeTool::root_handler(GdkEvent* event) {
 
     bool ret = false;
 
-    if (sp_pen_context_has_waiting_LPE(this)) {
+    if (this->hasWaitingLPE()) {
         // quit when we are waiting for a LPE to be applied
         //ret = ((ToolBaseClass *) sp_lpetool_context_parent_class)->root_handler(event_context, event);
 	return PenTool::root_handler(event);
@@ -222,7 +222,7 @@ bool LpeTool::root_handler(GdkEvent* event) {
 
                 //bool over_stroke = lc->shape_editor->is_over_stroke(Geom::Point(event->button.x, event->button.y), true);
 
-                sp_pen_context_wait_for_LPE_mouse_clicks(this, type, Inkscape::LivePathEffect::Effect::acceptsNumClicks(type));
+                this->waitForLPEMouseClicks(type, Inkscape::LivePathEffect::Effect::acceptsNumClicks(type));
 
                 // we pass the mouse click on to pen tool as the first click which it should collect
                 //ret = ((ToolBaseClass *) sp_lpetool_context_parent_class)->root_handler(event_context, event);
diff --git a/src/ui/tools/pen-tool.cpp b/src/ui/tools/pen-tool.cpp
index 39b69f576..7228690b1 100644
--- a/src/ui/tools/pen-tool.cpp
+++ b/src/ui/tools/pen-tool.cpp
@@ -50,29 +50,8 @@ namespace Inkscape {
 namespace UI {
 namespace Tools {
 
-static void spdc_pen_set_initial_point(PenTool *pc, Geom::Point const p);
-static void spdc_pen_set_subsequent_point(PenTool *const pc, Geom::Point const p, bool statusbar, guint status = 0);
-static void spdc_pen_set_ctrl(PenTool *pc, Geom::Point const p, guint state);
-static void spdc_pen_finish_segment(PenTool *pc, Geom::Point p, guint state);
-
-static void spdc_pen_finish(PenTool *pc, gboolean closed);
-
-static gint pen_handle_button_press(PenTool *const pc, GdkEventButton const &bevent);
-static gint pen_handle_motion_notify(PenTool *const pc, GdkEventMotion const &mevent);
-static gint pen_handle_button_release(PenTool *const pc, GdkEventButton const &revent);
-static gint pen_handle_2button_press(PenTool *const pc, GdkEventButton const &bevent);
-static gint pen_handle_key_press(PenTool *const pc, GdkEvent *event);
-static void spdc_reset_colors(PenTool *pc);
-
-static void pen_disable_events(PenTool *const pc);
-static void pen_enable_events(PenTool *const pc);
-
 static Geom::Point pen_drag_origin_w(0, 0);
 static bool pen_within_tolerance = false;
-
-static int pen_next_paraxial_direction(const PenTool *const pc, Geom::Point const &pt, Geom::Point const &origin, guint state);
-static void pen_set_to_nearest_horiz_vert(const PenTool *const pc, Geom::Point &pt, guint const state, bool snap);
-
 static int pen_last_paraxial_dir = 0; // last used direction in horizontal/vertical mode; 0 = horizontal, 1 = vertical
 
 namespace {
@@ -153,11 +132,11 @@ PenTool::~PenTool() {
     }
 }
 
-void sp_pen_context_set_polyline_mode(PenTool *const pc) {
+void PenTool::setPolylineMode() {
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     guint mode = prefs->getInt("/tools/freehand/pen/freehand-mode", 0);
-    pc->polylines_only = (mode == 2 || mode == 3);
-    pc->polylines_paraxial = (mode == 3);
+    this->polylines_only = (mode == 2 || mode == 3);
+    this->polylines_paraxial = (mode == 3);
 }
 
 /**
@@ -187,7 +166,7 @@ void PenTool::setup() {
 
     this->anchor_statusbar = false;
 
-    sp_pen_context_set_polyline_mode(this);
+    this->setPolylineMode();
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     if (prefs->getBool("/tools/freehand/pen/selcue")) {
@@ -195,19 +174,18 @@ void PenTool::setup() {
     }
 }
 
-static void pen_cancel (PenTool *const pc)
-{
-    pc->num_clicks = 0;
-    pc->state = PenTool::STOP;
-    spdc_reset_colors(pc);
-    sp_canvas_item_hide(pc->c0);
-    sp_canvas_item_hide(pc->c1);
-    sp_canvas_item_hide(pc->cl0);
-    sp_canvas_item_hide(pc->cl1);
-    pc->message_context->clear();
-    pc->message_context->flash(Inkscape::NORMAL_MESSAGE, _("Drawing cancelled"));
-
-    pc->desktop->canvas->endForcedFullRedraws();
+void PenTool::_cancel() {
+    this->num_clicks = 0;
+    this->state = PenTool::STOP;
+    this->_resetColors();
+    sp_canvas_item_hide(this->c0);
+    sp_canvas_item_hide(this->c1);
+    sp_canvas_item_hide(this->cl0);
+    sp_canvas_item_hide(this->cl1);
+    this->message_context->clear();
+    this->message_context->flash(Inkscape::NORMAL_MESSAGE, _("Drawing cancelled"));
+
+    this->desktop->canvas->endForcedFullRedraws();
 }
 
 /**
@@ -217,7 +195,7 @@ void PenTool::finish() {
     sp_event_context_discard_delayed_snap_event(this);
 
     if (this->npoints != 0) {
-        pen_cancel(this);
+        this->_cancel();
     }
 
     FreehandBase::finish();
@@ -238,26 +216,31 @@ void PenTool::set(const Inkscape::Preferences::Entry& val) {
     }
 }
 
+bool PenTool::hasWaitingLPE() {
+    // note: waiting_LPE_type is defined in SPDrawContext
+    return (this->waiting_LPE != NULL ||
+            this->waiting_LPE_type != Inkscape::LivePathEffect::INVALID_LPE);
+}
+
 /**
  * Snaps new node relative to the previous node.
  */
-static void spdc_endpoint_snap(PenTool const *const pc, Geom::Point &p, guint const state)
-{
-    if ((state & GDK_CONTROL_MASK) && !pc->polylines_paraxial) { //CTRL enables angular snapping
-        if (pc->npoints > 0) {
-            spdc_endpoint_snap_rotation(pc, p, pc->p[0], state);
+void PenTool::_endpointSnap(Geom::Point &p, guint const state) const {
+    if ((state & GDK_CONTROL_MASK) && !this->polylines_paraxial) { //CTRL enables angular snapping
+        if (this->npoints > 0) {
+            spdc_endpoint_snap_rotation(this, p, this->p[0], state);
         }
     } else {
         // We cannot use shift here to disable snapping because the shift-key is already used
         // to toggle the paraxial direction; if the user wants to disable snapping (s)he will
         // have to use the %-key, the menu, or the snap toolbar
-        if ((pc->npoints > 0) && pc->polylines_paraxial) {
+        if ((this->npoints > 0) && this->polylines_paraxial) {
             // snap constrained
-            pen_set_to_nearest_horiz_vert(pc, p, state, true);
+            this->_setToNearestHorizVert(p, state, true);
         } else {
             // snap freely
-            boost::optional<Geom::Point> origin = pc->npoints > 0 ? pc->p[0] : boost::optional<Geom::Point>();
-            spdc_endpoint_snap_free(pc, p, origin, state); // pass the origin, to allow for perpendicular / tangential snapping
+            boost::optional<Geom::Point> origin = this->npoints > 0 ? this->p[0] : boost::optional<Geom::Point>();
+            spdc_endpoint_snap_free(this, p, origin, state); // pass the origin, to allow for perpendicular / tangential snapping
         }
     }
 }
@@ -265,17 +248,16 @@ static void spdc_endpoint_snap(PenTool const *const pc, Geom::Point &p, guint co
 /**
  * Snaps new node's handle relative to the new node.
  */
-static void spdc_endpoint_snap_handle(PenTool const *const pc, Geom::Point &p, guint const state)
-{
-    g_return_if_fail(( pc->npoints == 2 ||
-                       pc->npoints == 5   ));
+void PenTool::_endpointSnapHandle(Geom::Point &p, guint const state) const {
+    g_return_if_fail(( this->npoints == 2 ||
+            this->npoints == 5   ));
 
     if ((state & GDK_CONTROL_MASK)) { //CTRL enables angular snapping
-        spdc_endpoint_snap_rotation(pc, p, pc->p[pc->npoints - 2], state);
+        spdc_endpoint_snap_rotation(this, p, this->p[this->npoints - 2], state);
     } else {
         if (!(state & GDK_SHIFT_MASK)) { //SHIFT disables all snapping, except the angular snapping above
-            boost::optional<Geom::Point> origin = pc->p[pc->npoints - 2];
-            spdc_endpoint_snap_free(pc, p, origin, state);
+            boost::optional<Geom::Point> origin = this->p[this->npoints - 2];
+            spdc_endpoint_snap_free(this, p, origin, state);
         }
     }
 }
@@ -285,10 +267,10 @@ bool PenTool::item_handler(SPItem* item, GdkEvent* event) {
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
-            ret = pen_handle_button_press(this, event->button);
+            ret = this->_handleButtonPress(event->button);
             break;
         case GDK_BUTTON_RELEASE:
-            ret = pen_handle_button_release(this, event->button);
+            ret = this->_handleButtonRelease(event->button);
             break;
         default:
             break;
@@ -309,23 +291,23 @@ bool PenTool::root_handler(GdkEvent* event) {
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
-            ret = pen_handle_button_press(this, event->button);
+            ret = this->_handleButtonPress(event->button);
             break;
 
         case GDK_MOTION_NOTIFY:
-            ret = pen_handle_motion_notify(this, event->motion);
+            ret = this->_handleMotionNotify(event->motion);
             break;
 
         case GDK_BUTTON_RELEASE:
-            ret = pen_handle_button_release(this, event->button);
+            ret = this->_handleButtonRelease(event->button);
             break;
 
         case GDK_2BUTTON_PRESS:
-            ret = pen_handle_2button_press(this, event->button);
+            ret = this->_handle2ButtonPress(event->button);
             break;
 
         case GDK_KEY_PRESS:
-            ret = pen_handle_key_press(this, event);
+            ret = this->_handleKeyPress(event);
             break;
 
         default:
@@ -342,32 +324,31 @@ bool PenTool::root_handler(GdkEvent* event) {
 /**
  * Handle mouse button press event.
  */
-static gint pen_handle_button_press(PenTool *const pc, GdkEventButton const &bevent)
-{
-    if (pc->events_disabled) {
+gint PenTool::_handleButtonPress(GdkEventButton const &bevent) {
+    if (this->events_disabled) {
         // skip event processing if events are disabled
         return FALSE;
     }
 
-    FreehandBase * const dc = SP_DRAW_CONTEXT(pc);
+    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));
-    ToolBase *event_context = SP_EVENT_CONTEXT(pc);
+    ToolBase *event_context = SP_EVENT_CONTEXT(this);
 
     gint ret = FALSE;
     if (bevent.button == 1 && !event_context->space_panning
         // make sure this is not the last click for a waiting LPE (otherwise we want to finish the path)
-        && pc->expecting_clicks_for_LPE != 1) {
+        && this->expecting_clicks_for_LPE != 1) {
 
         if (Inkscape::have_viable_layer(desktop, dc->message_context) == false) {
             return TRUE;
         }
 
-        if (!pc->grab ) {
+        if (!this->grab ) {
             // Grab mouse, so release will not pass unnoticed
-            pc->grab = SP_CANVAS_ITEM(desktop->acetate);
-            sp_canvas_item_grab(pc->grab, ( GDK_KEY_PRESS_MASK | GDK_BUTTON_PRESS_MASK   |
+            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  ),
                                 NULL, bevent.time);
@@ -377,33 +358,33 @@ static gint pen_handle_button_press(PenTool *const pc, GdkEventButton const &bev
         pen_within_tolerance = true;
 
         // Test whether we hit any anchor.
-        SPDrawAnchor * const anchor = spdc_test_inside(pc, event_w);
+        SPDrawAnchor * const anchor = spdc_test_inside(this, event_w);
 
-        switch (pc->mode) {
+        switch (this->mode) {
             case PenTool::MODE_CLICK:
                 // In click mode we add point on release
-                switch (pc->state) {
+                switch (this->state) {
                     case PenTool::POINT:
                     case PenTool::CONTROL:
                     case PenTool::CLOSE:
                         break;
                     case PenTool::STOP:
                         // This is allowed, if we just canceled curve
-                        pc->state = PenTool::POINT;
+                        this->state = PenTool::POINT;
                         break;
                     default:
                         break;
                 }
                 break;
             case PenTool::MODE_DRAG:
-                switch (pc->state) {
+                switch (this->state) {
                     case PenTool::STOP:
                         // This is allowed, if we just canceled curve
                     case PenTool::POINT:
-                        if (pc->npoints == 0) {
+                        if (this->npoints == 0) {
 
                             Geom::Point p;
-                            if ((bevent.state & GDK_CONTROL_MASK) && (pc->polylines_only || pc->polylines_paraxial)) {
+                            if ((bevent.state & GDK_CONTROL_MASK) && (this->polylines_only || this->polylines_paraxial)) {
                                 p = event_dt;
                                 if (!(bevent.state & GDK_SHIFT_MASK)) {
                                     SnapManager &m = desktop->namedview->snap_manager;
@@ -420,8 +401,8 @@ static gint pen_handle_button_press(PenTool *const pc, GdkEventButton const &bev
                             // distinction so that the case of a waiting LPE is treated separately
 
                             // Set start anchor
-                            pc->sa = anchor;
-                            if (anchor && !sp_pen_context_has_waiting_LPE(pc)) {
+                            this->sa = anchor;
+                            if (anchor && !this->hasWaitingLPE()) {
                                 // Adjust point to anchor if needed; if we have a waiting LPE, we need
                                 // a fresh path to be created so don't continue an existing one
                                 p = anchor->dp;
@@ -431,7 +412,7 @@ static gint pen_handle_button_press(PenTool *const pc, GdkEventButton const &bev
                                 // this curve is not combined with it (unless it is drawn from its
                                 // anchor, which is handled by the sibling branch above)
                                 Inkscape::Selection * const selection = sp_desktop_selection(desktop);
-                                if (!(bevent.state & GDK_SHIFT_MASK) || sp_pen_context_has_waiting_LPE(pc)) {
+                                if (!(bevent.state & GDK_SHIFT_MASK) || this->hasWaitingLPE()) {
                                     // if we have a waiting LPE, we need a fresh path to be created
                                     // so don't append to an existing one
                                     selection->clear();
@@ -442,22 +423,22 @@ static gint pen_handle_button_press(PenTool *const pc, GdkEventButton const &bev
 
                                 // Create green anchor
                                 p = event_dt;
-                                spdc_endpoint_snap(pc, p, bevent.state);
-                                pc->green_anchor = sp_draw_anchor_new(pc, pc->green_curve, TRUE, p);
+                                this->_endpointSnap(p, bevent.state);
+                                this->green_anchor = sp_draw_anchor_new(this, this->green_curve, TRUE, p);
                             }
-                            spdc_pen_set_initial_point(pc, p);
+                            this->_setInitialPoint(p);
                         } else {
 
                             // Set end anchor
-                            pc->ea = anchor;
+                            this->ea = anchor;
                             Geom::Point p;
                             if (anchor) {
                                 p = anchor->dp;
                                 // we hit an anchor, will finish the curve (either with or without closing)
                                 // in release handler
-                                pc->state = PenTool::CLOSE;
+                                this->state = PenTool::CLOSE;
 
-                                if (pc->green_anchor && pc->green_anchor->active) {
+                                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;
@@ -467,12 +448,12 @@ static gint pen_handle_button_press(PenTool *const pc, GdkEventButton const &bev
 
                             } else {
                                 p = event_dt;
-                                spdc_endpoint_snap(pc, p, bevent.state); // Snap node only if not hitting anchor.
-                                spdc_pen_set_subsequent_point(pc, p, true);
+                                this->_endpointSnap(p, bevent.state); // Snap node only if not hitting anchor.
+                                this->_setSubsequentPoint(p, true);
                             }
                         }
 
-                        pc->state = pc->polylines_only ? PenTool::POINT : PenTool::CONTROL;
+                        this->state = this->polylines_only ? PenTool::POINT : PenTool::CONTROL;
                         ret = TRUE;
                         break;
                     case PenTool::CONTROL:
@@ -488,26 +469,26 @@ static gint pen_handle_button_press(PenTool *const pc, GdkEventButton const &bev
             default:
                 break;
         }
-    } else if (pc->expecting_clicks_for_LPE == 1 && pc->npoints != 0) {
+    } else if (this->expecting_clicks_for_LPE == 1 && this->npoints != 0) {
         // when the last click for a waiting LPE occurs we want to finish the path
-        spdc_pen_finish_segment(pc, event_dt, bevent.state);
-        if (pc->green_closed) {
+        this->_finishSegment(event_dt, bevent.state);
+        if (this->green_closed) {
             // finishing at the start anchor, close curve
-            spdc_pen_finish(pc, TRUE);
+            this->_finish(TRUE);
         } else {
             // finishing at some other anchor, finish curve but not close
-            spdc_pen_finish(pc, FALSE);
+            this->_finish(FALSE);
         }
 
         ret = TRUE;
-    } else if (bevent.button == 3 && pc->npoints != 0) {
+    } else if (bevent.button == 3 && this->npoints != 0) {
         // right click - finish path
-        spdc_pen_finish(pc, FALSE);
+        this->_finish(FALSE);
         ret = TRUE;
     }
 
-    if (pc->expecting_clicks_for_LPE > 0) {
-        --pc->expecting_clicks_for_LPE;
+    if (this->expecting_clicks_for_LPE > 0) {
+        --this->expecting_clicks_for_LPE;
     }
 
     return ret;
@@ -516,11 +497,10 @@ static gint pen_handle_button_press(PenTool *const pc, GdkEventButton const &bev
 /**
  * Handle motion_notify event.
  */
-static gint pen_handle_motion_notify(PenTool *const pc, GdkEventMotion const &mevent)
-{
+gint PenTool::_handleMotionNotify(GdkEventMotion const &mevent) {
     gint ret = FALSE;
 
-    ToolBase *event_context = SP_EVENT_CONTEXT(pc);
+    ToolBase *event_context = SP_EVENT_CONTEXT(this);
     SPDesktop * const dt = event_context->desktop;
 
     if (event_context->space_panning || mevent.state & GDK_BUTTON2_MASK || mevent.state & GDK_BUTTON3_MASK) {
@@ -528,7 +508,7 @@ static gint pen_handle_motion_notify(PenTool *const pc, GdkEventMotion const &me
         return FALSE;
     }
 
-    if (pc->events_disabled) {
+    if (this->events_disabled) {
         // skip motion events if pen events are disabled
         return FALSE;
     }
@@ -551,18 +531,18 @@ static gint pen_handle_motion_notify(PenTool *const pc, GdkEventMotion const &me
     Geom::Point p = dt->w2d(event_w);
 
     // Test, whether we hit any anchor
-    SPDrawAnchor *anchor = spdc_test_inside(pc, event_w);
+    SPDrawAnchor *anchor = spdc_test_inside(this, event_w);
 
-    switch (pc->mode) {
+    switch (this->mode) {
         case PenTool::MODE_CLICK:
-            switch (pc->state) {
+            switch (this->state) {
                 case PenTool::POINT:
-                    if ( pc->npoints != 0 ) {
+                    if ( this->npoints != 0 ) {
                         // Only set point, if we are already appending
-                        spdc_endpoint_snap(pc, p, mevent.state);
-                        spdc_pen_set_subsequent_point(pc, p, true);
+                        this->_endpointSnap(p, mevent.state);
+                        this->_setSubsequentPoint(p, true);
                         ret = TRUE;
-                    } else if (!sp_event_context_knot_mouseover(pc)) {
+                    } else if (!this->sp_event_context_knot_mouseover()) {
                         SnapManager &m = dt->namedview->snap_manager;
                         m.setup(dt);
                         m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_NODE_HANDLE));
@@ -572,8 +552,8 @@ static gint pen_handle_motion_notify(PenTool *const pc, GdkEventMotion const &me
                 case PenTool::CONTROL:
                 case PenTool::CLOSE:
                     // Placing controls is last operation in CLOSE state
-                    spdc_endpoint_snap(pc, p, mevent.state);
-                    spdc_pen_set_ctrl(pc, p, mevent.state);
+                    this->_endpointSnap(p, mevent.state);
+                    this->_setCtrl(p, mevent.state);
                     ret = TRUE;
                     break;
                 case PenTool::STOP:
@@ -584,36 +564,36 @@ static gint pen_handle_motion_notify(PenTool *const pc, GdkEventMotion const &me
             }
             break;
         case PenTool::MODE_DRAG:
-            switch (pc->state) {
+            switch (this->state) {
                 case PenTool::POINT:
-                    if ( pc->npoints > 0 ) {
+                    if ( this->npoints > 0 ) {
                         // Only set point, if we are already appending
 
                         if (!anchor) {   // Snap node only if not hitting anchor
-                            spdc_endpoint_snap(pc, p, mevent.state);
-                            spdc_pen_set_subsequent_point(pc, p, true, mevent.state);
+                            this->_endpointSnap(p, mevent.state);
+                            this->_setSubsequentPoint(p, true, mevent.state);
                         } else {
-                            spdc_pen_set_subsequent_point(pc, anchor->dp, false, mevent.state);
+                            this->_setSubsequentPoint(anchor->dp, false, mevent.state);
                         }
 
-                        if (anchor && !pc->anchor_statusbar) {
-                            pc->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to close and finish the path."));
-                            pc->anchor_statusbar = true;
-                        } else if (!anchor && pc->anchor_statusbar) {
-                            pc->message_context->clear();
-                            pc->anchor_statusbar = false;
+                        if (anchor && !this->anchor_statusbar) {
+                            this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to close and finish the path."));
+                            this->anchor_statusbar = true;
+                        } else if (!anchor && this->anchor_statusbar) {
+                            this->message_context->clear();
+                            this->anchor_statusbar = false;
                         }
 
                         ret = TRUE;
                     } else {
-                        if (anchor && !pc->anchor_statusbar) {
-                            pc->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to continue the path from this point."));
-                            pc->anchor_statusbar = true;
-                        } else if (!anchor && pc->anchor_statusbar) {
-                            pc->message_context->clear();
-                            pc->anchor_statusbar = false;
+                        if (anchor && !this->anchor_statusbar) {
+                            this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Click</b> or <b>click and drag</b> to continue the path from this point."));
+                            this->anchor_statusbar = true;
+                        } else if (!anchor && this->anchor_statusbar) {
+                            this->message_context->clear();
+                            this->anchor_statusbar = false;
                         }
-                        if (!sp_event_context_knot_mouseover(pc)) {
+                        if (!this->sp_event_context_knot_mouseover()) {
                             SnapManager &m = dt->namedview->snap_manager;
                             m.setup(dt);
                             m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_NODE_HANDLE));
@@ -626,12 +606,12 @@ static gint pen_handle_motion_notify(PenTool *const pc, GdkEventMotion const &me
                     // Placing controls is last operation in CLOSE state
 
                     // snap the handle
-                    spdc_endpoint_snap_handle(pc, p, mevent.state);
+                    this->_endpointSnapHandle(p, mevent.state);
 
-                    if (!pc->polylines_only) {
-                        spdc_pen_set_ctrl(pc, p, mevent.state);
+                    if (!this->polylines_only) {
+                        this->_setCtrl(p, mevent.state);
                     } else {
-                        spdc_pen_set_ctrl(pc, pc->p[1], mevent.state);
+                        this->_setCtrl(this->p[1], mevent.state);
                     }
                     gobble_motion_events(GDK_BUTTON1_MASK);
                     ret = TRUE;
@@ -640,7 +620,7 @@ static gint pen_handle_motion_notify(PenTool *const pc, GdkEventMotion const &me
                     // This is perfectly valid
                     break;
                 default:
-                    if (!sp_event_context_knot_mouseover(pc)) {
+                    if (!this->sp_event_context_knot_mouseover()) {
                         SnapManager &m = dt->namedview->snap_manager;
                         m.setup(dt);
                         m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_NODE_HANDLE));
@@ -658,68 +638,67 @@ static gint pen_handle_motion_notify(PenTool *const pc, GdkEventMotion const &me
 /**
  * Handle mouse button release event.
  */
-static gint pen_handle_button_release(PenTool *const pc, GdkEventButton const &revent)
-{
-    if (pc->events_disabled) {
+gint PenTool::_handleButtonRelease(GdkEventButton const &revent) {
+    if (this->events_disabled) {
         // skip event processing if events are disabled
         return FALSE;
     }
 
     gint ret = FALSE;
-    ToolBase *event_context = SP_EVENT_CONTEXT(pc);
+    ToolBase *event_context = SP_EVENT_CONTEXT(this);
     if ( revent.button == 1  && !event_context->space_panning) {
 
-        FreehandBase *dc = SP_DRAW_CONTEXT (pc);
+        FreehandBase *dc = SP_DRAW_CONTEXT (this);
 
         Geom::Point const event_w(revent.x,
                                 revent.y);
         // Find desktop coordinates
-        Geom::Point p = pc->desktop->w2d(event_w);
+        Geom::Point p = this->desktop->w2d(event_w);
 
         // Test whether we hit any anchor.
-        SPDrawAnchor *anchor = spdc_test_inside(pc, event_w);
+        SPDrawAnchor *anchor = spdc_test_inside(this, event_w);
 
-        switch (pc->mode) {
+        switch (this->mode) {
             case PenTool::MODE_CLICK:
-                switch (pc->state) {
+                switch (this->state) {
                     case PenTool::POINT:
-                        if ( pc->npoints == 0 ) {
+                        if ( this->npoints == 0 ) {
                             // Start new thread only with button release
                             if (anchor) {
                                 p = anchor->dp;
                             }
-                            pc->sa = anchor;
-                            spdc_pen_set_initial_point(pc, p);
+                            this->sa = anchor;
+                            this->_setInitialPoint(p);
                         } else {
                             // Set end anchor here
-                            pc->ea = anchor;
+                            this->ea = anchor;
                             if (anchor) {
                                 p = anchor->dp;
                             }
                         }
-                        pc->state = PenTool::CONTROL;
+                        this->state = PenTool::CONTROL;
                         ret = TRUE;
                         break;
                     case PenTool::CONTROL:
                         // End current segment
-                        spdc_endpoint_snap(pc, p, revent.state);
-                        spdc_pen_finish_segment(pc, p, revent.state);
-                        pc->state = PenTool::POINT;
+                        this->_endpointSnap(p, revent.state);
+                        this->_finishSegment(p, revent.state);
+                        this->state = PenTool::POINT;
                         ret = TRUE;
                         break;
                     case PenTool::CLOSE:
                         // End current segment
                         if (!anchor) {   // Snap node only if not hitting anchor
-                            spdc_endpoint_snap(pc, p, revent.state);
+                            this->_endpointSnap(p, revent.state);
                         }
-                        spdc_pen_finish_segment(pc, p, revent.state);
-                        spdc_pen_finish(pc, TRUE);
-                        pc->state = PenTool::POINT;
+                        this->_finishSegment(p, revent.state);
+                        this->_finish(TRUE);
+                        this->state = PenTool::POINT;
                         ret = TRUE;
                         break;
                     case PenTool::STOP:
                         // This is allowed, if we just canceled curve
-                        pc->state = PenTool::POINT;
+                        this->state = PenTool::POINT;
                         ret = TRUE;
                         break;
                     default:
@@ -727,21 +706,21 @@ static gint pen_handle_button_release(PenTool *const pc, GdkEventButton const &r
                 }
                 break;
             case PenTool::MODE_DRAG:
-                switch (pc->state) {
+                switch (this->state) {
                     case PenTool::POINT:
                     case PenTool::CONTROL:
-                        spdc_endpoint_snap(pc, p, revent.state);
-                        spdc_pen_finish_segment(pc, p, revent.state);
+                        this->_endpointSnap(p, revent.state);
+                        this->_finishSegment(p, revent.state);
                         break;
                     case PenTool::CLOSE:
-                        spdc_endpoint_snap(pc, p, revent.state);
-                        spdc_pen_finish_segment(pc, p, revent.state);
-                        if (pc->green_closed) {
+                        this->_endpointSnap(p, revent.state);
+                        this->_finishSegment(p, revent.state);
+                        if (this->green_closed) {
                             // finishing at the start anchor, close curve
-                            spdc_pen_finish(pc, TRUE);
+                            this->_finish(TRUE);
                         } else {
                             // finishing at some other anchor, finish curve but not close
-                            spdc_pen_finish(pc, FALSE);
+                            this->_finish(FALSE);
                         }
                         break;
                     case PenTool::STOP:
@@ -750,17 +729,17 @@ static gint pen_handle_button_release(PenTool *const pc, GdkEventButton const &r
                     default:
                         break;
                 }
-                pc->state = PenTool::POINT;
+                this->state = PenTool::POINT;
                 ret = TRUE;
                 break;
             default:
                 break;
         }
 
-        if (pc->grab) {
+        if (this->grab) {
             // Release grab now
-            sp_canvas_item_ungrab(pc->grab, revent.time);
-            pc->grab = NULL;
+            sp_canvas_item_ungrab(this->grab, revent.time);
+            this->grab = NULL;
         }
 
         ret = TRUE;
@@ -770,17 +749,17 @@ static gint pen_handle_button_release(PenTool *const pc, GdkEventButton const &r
 
     // TODO: can we be sure that the path was created correctly?
     // TODO: should we offer an option to collect the clicks in a list?
-    if (pc->expecting_clicks_for_LPE == 0 && sp_pen_context_has_waiting_LPE(pc)) {
-        sp_pen_context_set_polyline_mode(pc);
+    if (this->expecting_clicks_for_LPE == 0 && this->hasWaitingLPE()) {
+        this->setPolylineMode();
 
-        ToolBase *ec = SP_EVENT_CONTEXT(pc);
+        ToolBase *ec = SP_EVENT_CONTEXT(this);
         Inkscape::Selection *selection = sp_desktop_selection (ec->desktop);
 
-        if (pc->waiting_LPE) {
+        if (this->waiting_LPE) {
             // we have an already created LPE waiting for a path
-            pc->waiting_LPE->acceptParamPath(SP_PATH(selection->singleItem()));
-            selection->add(SP_OBJECT(pc->waiting_item));
-            pc->waiting_LPE = NULL;
+            this->waiting_LPE->acceptParamPath(SP_PATH(selection->singleItem()));
+            selection->add(SP_OBJECT(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
             // handled in spdc_check_for_and_apply_waiting_LPE() in draw-context.cpp
@@ -790,125 +769,118 @@ static gint pen_handle_button_release(PenTool *const pc, GdkEventButton const &r
     return ret;
 }
 
-static gint pen_handle_2button_press(PenTool *const pc, GdkEventButton const &bevent)
-{
+gint PenTool::_handle2ButtonPress(GdkEventButton const &bevent) {
     gint ret = FALSE;
     // only end on LMB double click. Otherwise horizontal scrolling causes ending of the path
-    if (pc->npoints != 0 && bevent.button == 1) {
-        spdc_pen_finish(pc, FALSE);
+    if (this->npoints != 0 && bevent.button == 1) {
+        this->_finish(FALSE);
         ret = TRUE;
     }
     return ret;
 }
 
-static void pen_redraw_all (PenTool *const pc)
-{
+void PenTool::_redrawAll() {
     // green
-    if (pc->green_bpaths) {
+    if (this->green_bpaths) {
         // remove old piecewise green canvasitems
-        while (pc->green_bpaths) {
-            sp_canvas_item_destroy(SP_CANVAS_ITEM(pc->green_bpaths->data));
-            pc->green_bpaths = g_slist_remove(pc->green_bpaths, pc->green_bpaths->data);
+        while (this->green_bpaths) {
+            sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
+            this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
         }
         // one canvas bpath for all of green_curve
-        SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(pc->desktop), pc->green_curve);
-        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), pc->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+        SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(this->desktop), this->green_curve);
+        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
         sp_canvas_bpath_set_fill(SP_CANVAS_BPATH(cshape), 0, SP_WIND_RULE_NONZERO);
 
-        pc->green_bpaths = g_slist_prepend(pc->green_bpaths, cshape);
+        this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
     }
 
-    if (pc->green_anchor)
-        SP_CTRL(pc->green_anchor->ctrl)->moveto(pc->green_anchor->dp);
+    if (this->green_anchor)
+        SP_CTRL(this->green_anchor->ctrl)->moveto(this->green_anchor->dp);
 
-    pc->red_curve->reset();
-    pc->red_curve->moveto(pc->p[0]);
-    pc->red_curve->curveto(pc->p[1], pc->p[2], pc->p[3]);
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->red_curve);
+    this->red_curve->reset();
+    this->red_curve->moveto(this->p[0]);
+    this->red_curve->curveto(this->p[1], this->p[2], this->p[3]);
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
 
     // handles
-    if (pc->p[0] != pc->p[1]) {
-        SP_CTRL(pc->c1)->moveto(pc->p[1]);
-        pc->cl1->setCoords(pc->p[0], pc->p[1]);
-        sp_canvas_item_show(pc->c1);
-        sp_canvas_item_show(pc->cl1);
+    if (this->p[0] != this->p[1]) {
+        SP_CTRL(this->c1)->moveto(this->p[1]);
+        this->cl1->setCoords(this->p[0], this->p[1]);
+        sp_canvas_item_show(this->c1);
+        sp_canvas_item_show(this->cl1);
     } else {
-        sp_canvas_item_hide(pc->c1);
-        sp_canvas_item_hide(pc->cl1);
+        sp_canvas_item_hide(this->c1);
+        sp_canvas_item_hide(this->cl1);
     }
 
-    Geom::Curve const * last_seg = pc->green_curve->last_segment();
+    Geom::Curve const * last_seg = this->green_curve->last_segment();
     if (last_seg) {
         Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const *>( last_seg );
         if ( cubic &&
-             (*cubic)[2] != pc->p[0] )
+             (*cubic)[2] != this->p[0] )
         {
             Geom::Point p2 = (*cubic)[2];
-            SP_CTRL(pc->c0)->moveto(p2);
-            pc->cl0->setCoords(p2, pc->p[0]);
-            sp_canvas_item_show(pc->c0);
-            sp_canvas_item_show(pc->cl0);
+            SP_CTRL(this->c0)->moveto(p2);
+            this->cl0->setCoords(p2, this->p[0]);
+            sp_canvas_item_show(this->c0);
+            sp_canvas_item_show(this->cl0);
         } else {
-            sp_canvas_item_hide(pc->c0);
-            sp_canvas_item_hide(pc->cl0);
+            sp_canvas_item_hide(this->c0);
+            sp_canvas_item_hide(this->cl0);
         }
     }
 }
 
-static void pen_lastpoint_move (PenTool *const pc, gdouble x, gdouble y)
-{
-    if (pc->npoints != 5)
+void PenTool::_lastpointMove(gdouble x, gdouble y) {
+    if (this->npoints != 5)
         return;
 
     // green
-    if (!pc->green_curve->is_empty()) {
-        pc->green_curve->last_point_additive_move( Geom::Point(x,y) );
+    if (!this->green_curve->is_empty()) {
+        this->green_curve->last_point_additive_move( Geom::Point(x,y) );
     } else {
         // start anchor too
-        if (pc->green_anchor) {
-            pc->green_anchor->dp += Geom::Point(x, y);
+        if (this->green_anchor) {
+            this->green_anchor->dp += Geom::Point(x, y);
         }
     }
 
     // red
-    pc->p[0] += Geom::Point(x, y);
-    pc->p[1] += Geom::Point(x, y);
-    pen_redraw_all(pc);
+    this->p[0] += Geom::Point(x, y);
+    this->p[1] += Geom::Point(x, y);
+    this->_redrawAll();
 }
 
-static void pen_lastpoint_move_screen (PenTool *const pc, gdouble x, gdouble y)
-{
-    pen_lastpoint_move (pc, x / pc->desktop->current_zoom(), y / pc->desktop->current_zoom());
+void PenTool::_lastpointMoveScreen(gdouble x, gdouble y) {
+    this->_lastpointMove(x / this->desktop->current_zoom(), y / this->desktop->current_zoom());
 }
 
-static void pen_lastpoint_tocurve (PenTool *const pc)
-{
-    if (pc->npoints != 5)
+void PenTool::_lastpointToCurve() {
+    if (this->npoints != 5)
         return;
 
-    Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const *>( pc->green_curve->last_segment() );
+    Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const *>( this->green_curve->last_segment() );
     if ( cubic ) {
-        pc->p[1] = pc->p[0] + (Geom::Point)( (*cubic)[3] - (*cubic)[2] );
+        this->p[1] = this->p[0] + (Geom::Point)( (*cubic)[3] - (*cubic)[2] );
     } else {
-        pc->p[1] = pc->p[0] + (1./3)*(pc->p[3] - pc->p[0]);
+        this->p[1] = this->p[0] + (1./3)*(this->p[3] - this->p[0]);
     }
 
-    pen_redraw_all(pc);
+    this->_redrawAll();
 }
 
-static void pen_lastpoint_toline (PenTool *const pc)
-{
-    if (pc->npoints != 5)
+void PenTool::_lastpointToLine() {
+    if (this->npoints != 5)
         return;
 
-    pc->p[1] = pc->p[0];
+    this->p[1] = this->p[0];
 
-    pen_redraw_all(pc);
+    this->_redrawAll();
 }
 
 
-static gint pen_handle_key_press(PenTool *const pc, GdkEvent *event)
-{
+gint PenTool::_handleKeyPress(GdkEvent *event) {
 
     gint ret = FALSE;
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -920,12 +892,12 @@ static gint pen_handle_key_press(PenTool *const pc, GdkEvent *event)
         case GDK_KEY_KP_Left:
             if (!MOD__CTRL(event)) { // not ctrl
                 if (MOD__ALT(event)) { // alt
-                    if (MOD__SHIFT(event)) pen_lastpoint_move_screen(pc, -10, 0); // shift
-                    else pen_lastpoint_move_screen(pc, -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)) pen_lastpoint_move(pc, -10*nudge, 0); // shift
-                    else pen_lastpoint_move(pc, -nudge, 0); // no shift
+                    if (MOD__SHIFT(event)) this->_lastpointMove(-10*nudge, 0); // shift
+                    else this->_lastpointMove(-nudge, 0); // no shift
                 }
                 ret = TRUE;
             }
@@ -934,12 +906,12 @@ static gint pen_handle_key_press(PenTool *const pc, GdkEvent *event)
         case GDK_KEY_KP_Up:
             if (!MOD__CTRL(event)) { // not ctrl
                 if (MOD__ALT(event)) { // alt
-                    if (MOD__SHIFT(event)) pen_lastpoint_move_screen(pc, 0, 10); // shift
-                    else pen_lastpoint_move_screen(pc, 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)) pen_lastpoint_move(pc, 0, 10*nudge); // shift
-                    else pen_lastpoint_move(pc, 0, nudge); // no shift
+                    if (MOD__SHIFT(event)) this->_lastpointMove(0, 10*nudge); // shift
+                    else this->_lastpointMove(0, nudge); // no shift
                 }
                 ret = TRUE;
             }
@@ -948,12 +920,12 @@ static gint pen_handle_key_press(PenTool *const pc, GdkEvent *event)
         case GDK_KEY_KP_Right:
             if (!MOD__CTRL(event)) { // not ctrl
                 if (MOD__ALT(event)) { // alt
-                    if (MOD__SHIFT(event)) pen_lastpoint_move_screen(pc, 10, 0); // shift
-                    else pen_lastpoint_move_screen(pc, 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)) pen_lastpoint_move(pc, 10*nudge, 0); // shift
-                    else pen_lastpoint_move(pc, nudge, 0); // no shift
+                    if (MOD__SHIFT(event)) this->_lastpointMove(10*nudge, 0); // shift
+                    else this->_lastpointMove(nudge, 0); // no shift
                 }
                 ret = TRUE;
             }
@@ -962,12 +934,12 @@ static gint pen_handle_key_press(PenTool *const pc, GdkEvent *event)
         case GDK_KEY_KP_Down:
             if (!MOD__CTRL(event)) { // not ctrl
                 if (MOD__ALT(event)) { // alt
-                    if (MOD__SHIFT(event)) pen_lastpoint_move_screen(pc, 0, -10); // shift
-                    else pen_lastpoint_move_screen(pc, 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)) pen_lastpoint_move(pc, 0, -10*nudge); // shift
-                    else pen_lastpoint_move(pc, 0, -nudge); // no shift
+                    if (MOD__SHIFT(event)) this->_lastpointMove(0, -10*nudge); // shift
+                    else this->_lastpointMove(0, -nudge); // no shift
                 }
                 ret = TRUE;
             }
@@ -1010,90 +982,90 @@ static gint pen_handle_key_press(PenTool *const pc, GdkEvent *event)
         case GDK_KEY_U:
         case GDK_KEY_u:
             if (MOD__SHIFT_ONLY(event)) {
-                pen_lastpoint_tocurve(pc);
+                this->_lastpointToCurve();
                 ret = TRUE;
             }
             break;
         case GDK_KEY_L:
         case GDK_KEY_l:
             if (MOD__SHIFT_ONLY(event)) {
-                pen_lastpoint_toline(pc);
+                this->_lastpointToLine();
                 ret = TRUE;
             }
             break;
 
         case GDK_KEY_Return:
         case GDK_KEY_KP_Enter:
-            if (pc->npoints != 0) {
-                spdc_pen_finish(pc, FALSE);
+            if (this->npoints != 0) {
+                this->_finish(FALSE);
                 ret = TRUE;
             }
             break;
         case GDK_KEY_Escape:
-            if (pc->npoints != 0) {
+            if (this->npoints != 0) {
                 // if drawing, cancel, otherwise pass it up for deselecting
-                pen_cancel (pc);
+                this->_cancel ();
                 ret = TRUE;
             }
             break;
         case GDK_KEY_z:
         case GDK_KEY_Z:
-            if (MOD__CTRL_ONLY(event) && pc->npoints != 0) {
+            if (MOD__CTRL_ONLY(event) && this->npoints != 0) {
                 // if drawing, cancel, otherwise pass it up for undo
-                pen_cancel (pc);
+                this->_cancel ();
                 ret = TRUE;
             }
             break;
         case GDK_KEY_g:
         case GDK_KEY_G:
             if (MOD__SHIFT_ONLY(event)) {
-                sp_selection_to_guides(SP_EVENT_CONTEXT(pc)->desktop);
+                sp_selection_to_guides(SP_EVENT_CONTEXT(this)->desktop);
                 ret = true;
             }
             break;
         case GDK_KEY_BackSpace:
         case GDK_KEY_Delete:
         case GDK_KEY_KP_Delete:
-            if ( pc->green_curve->is_empty() || (pc->green_curve->last_segment() == NULL) ) {
-                if (!pc->red_curve->is_empty()) {
-                    pen_cancel (pc);
+            if ( this->green_curve->is_empty() || (this->green_curve->last_segment() == NULL) ) {
+                if (!this->red_curve->is_empty()) {
+                    this->_cancel ();
                     ret = TRUE;
                 } else {
                     // do nothing; this event should be handled upstream
                 }
             } else {
                 // Reset red curve
-                pc->red_curve->reset();
+                this->red_curve->reset();
                 // Destroy topmost green bpath
-                if (pc->green_bpaths) {
-                    if (pc->green_bpaths->data)
-                        sp_canvas_item_destroy(SP_CANVAS_ITEM(pc->green_bpaths->data));
-                    pc->green_bpaths = g_slist_remove(pc->green_bpaths, pc->green_bpaths->data);
+                if (this->green_bpaths) {
+                    if (this->green_bpaths->data)
+                        sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
+                    this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
                 }
                 // Get last segment
-                if ( pc->green_curve->is_empty() ) {
+                if ( this->green_curve->is_empty() ) {
                     g_warning("pen_handle_key_press, case GDK_KP_Delete: Green curve is empty");
                     break;
                 }
                 // The code below assumes that pc->green_curve has only ONE path !
-                Geom::Curve const * crv = pc->green_curve->last_segment();
-                pc->p[0] = crv->initialPoint();
+                Geom::Curve const * crv = this->green_curve->last_segment();
+                this->p[0] = crv->initialPoint();
                 if ( Geom::CubicBezier const * cubic = dynamic_cast<Geom::CubicBezier const *>(crv)) {
-                    pc->p[1] = (*cubic)[1];
+                    this->p[1] = (*cubic)[1];
                 } else {
-                    pc->p[1] = pc->p[0];
+                    this->p[1] = this->p[0];
                 }
-                Geom::Point const pt(( pc->npoints < 4
+                Geom::Point const pt(( this->npoints < 4
                                      ? (Geom::Point)(crv->finalPoint())
-                                     : pc->p[3] ));
-                pc->npoints = 2;
-                pc->green_curve->backspace();
-                sp_canvas_item_hide(pc->c0);
-                sp_canvas_item_hide(pc->c1);
-                sp_canvas_item_hide(pc->cl0);
-                sp_canvas_item_hide(pc->cl1);
-                pc->state = PenTool::POINT;
-                spdc_pen_set_subsequent_point(pc, pt, true);
+                                     : this->p[3] ));
+                this->npoints = 2;
+                this->green_curve->backspace();
+                sp_canvas_item_hide(this->c0);
+                sp_canvas_item_hide(this->c1);
+                sp_canvas_item_hide(this->cl0);
+                sp_canvas_item_hide(this->cl1);
+                this->state = PenTool::POINT;
+                this->_setSubsequentPoint(pt, true);
                 pen_last_paraxial_dir = !pen_last_paraxial_dir;
                 ret = TRUE;
             }
@@ -1104,40 +1076,38 @@ static gint pen_handle_key_press(PenTool *const pc, GdkEvent *event)
     return ret;
 }
 
-static void spdc_reset_colors(PenTool *pc)
-{
+void PenTool::_resetColors() {
     // Red
-    pc->red_curve->reset();
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), NULL);
+    this->red_curve->reset();
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
     // Blue
-    pc->blue_curve->reset();
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->blue_bpath), NULL);
+    this->blue_curve->reset();
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->blue_bpath), NULL);
     // Green
-    while (pc->green_bpaths) {
-        sp_canvas_item_destroy(SP_CANVAS_ITEM(pc->green_bpaths->data));
-        pc->green_bpaths = g_slist_remove(pc->green_bpaths, pc->green_bpaths->data);
+    while (this->green_bpaths) {
+        sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
+        this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
     }
-    pc->green_curve->reset();
-    if (pc->green_anchor) {
-        pc->green_anchor = sp_draw_anchor_destroy(pc->green_anchor);
+    this->green_curve->reset();
+    if (this->green_anchor) {
+        this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
     }
-    pc->sa = NULL;
-    pc->ea = NULL;
-    pc->npoints = 0;
-    pc->red_curve_is_valid = false;
+    this->sa = NULL;
+    this->ea = NULL;
+    this->npoints = 0;
+    this->red_curve_is_valid = false;
 }
 
 
-static void spdc_pen_set_initial_point(PenTool *const pc, Geom::Point const p)
-{
-    g_assert( pc->npoints == 0 );
+void PenTool::_setInitialPoint(Geom::Point const p) {
+    g_assert( this->npoints == 0 );
 
-    pc->p[0] = p;
-    pc->p[1] = p;
-    pc->npoints = 2;
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), NULL);
+    this->p[0] = p;
+    this->p[1] = p;
+    this->npoints = 2;
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
 
-    pc->desktop->canvas->forceFullRedrawAfterInterruptions(5);
+    this->desktop->canvas->forceFullRedrawAfterInterruptions(5);
 }
 
 /**
@@ -1145,14 +1115,13 @@ static void spdc_pen_set_initial_point(PenTool *const pc, Geom::Point const p)
  * This type of message always shows angle/distance as the last
  * two parameters ("angle %3.2f&#176;, distance %s").
  */
-static void spdc_pen_set_angle_distance_status_message(PenTool *const pc, Geom::Point const p, int pc_point_to_compare, gchar const *message)
-{
-    g_assert(pc != NULL);
+void PenTool::_setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_to_compare, gchar const *message) {
+    g_assert(this != NULL);
     g_assert((pc_point_to_compare == 0) || (pc_point_to_compare == 3)); // exclude control handles
     g_assert(message != NULL);
 
-    SPDesktop *desktop = SP_EVENT_CONTEXT(pc)->desktop;
-    Geom::Point rel = p - pc->p[pc_point_to_compare];
+    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());
     double angle = atan2(rel[Geom::Y], rel[Geom::X]) * 180 / M_PI;
@@ -1164,192 +1133,178 @@ static void spdc_pen_set_angle_distance_status_message(PenTool *const pc, Geom::
         }
     }
 
-    pc->message_context->setF(Inkscape::IMMEDIATE_MESSAGE, message, angle, dist->str);
+    this->message_context->setF(Inkscape::IMMEDIATE_MESSAGE, message, angle, dist->str);
     g_string_free(dist, FALSE);
 }
 
-static void spdc_pen_set_subsequent_point(PenTool *const pc, Geom::Point const p, bool statusbar, guint status)
-{
-    g_assert( pc->npoints != 0 );
+void PenTool::_setSubsequentPoint(Geom::Point const p, bool statusbar, guint status) {
+    g_assert( this->npoints != 0 );
     // todo: Check callers to see whether 2 <= npoints is guaranteed.
 
-    pc->p[2] = p;
-    pc->p[3] = p;
-    pc->p[4] = p;
-    pc->npoints = 5;
-    pc->red_curve->reset();
+    this->p[2] = p;
+    this->p[3] = p;
+    this->p[4] = p;
+    this->npoints = 5;
+    this->red_curve->reset();
     bool is_curve;
-    pc->red_curve->moveto(pc->p[0]);
-    if (pc->polylines_paraxial && !statusbar) {
+    this->red_curve->moveto(this->p[0]);
+    if (this->polylines_paraxial && !statusbar) {
         // we are drawing horizontal/vertical lines and hit an anchor;
-        Geom::Point const origin = pc->p[0];
+        Geom::Point const origin = this->p[0];
         // if the previous point and the anchor are not aligned either horizontally or vertically...
         if ((abs(p[Geom::X] - origin[Geom::X]) > 1e-9) && (abs(p[Geom::Y] - origin[Geom::Y]) > 1e-9)) {
             // ...then we should draw an L-shaped path, consisting of two paraxial segments
             Geom::Point intermed = p;
-            pen_set_to_nearest_horiz_vert(pc, intermed, status, false);
-            pc->red_curve->lineto(intermed);
+            this->_setToNearestHorizVert(intermed, status, false);
+            this->red_curve->lineto(intermed);
         }
-        pc->red_curve->lineto(p);
+        this->red_curve->lineto(p);
         is_curve = false;
     } else {
         // one of the 'regular' modes
-        if (pc->p[1] != pc->p[0]) {
-            pc->red_curve->curveto(pc->p[1], p, p);
+        if (this->p[1] != this->p[0]) {
+            this->red_curve->curveto(this->p[1], p, p);
             is_curve = true;
         } else {
-            pc->red_curve->lineto(p);
+            this->red_curve->lineto(p);
             is_curve = false;
         }
     }
 
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->red_curve);
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
 
     if (statusbar) {
         gchar *message = is_curve ?
             _("<b>Curve segment</b>: angle %3.2f&#176;, distance %s; with <b>Ctrl</b> to snap angle, <b>Enter</b> to finish the path" ):
             _("<b>Line segment</b>: angle %3.2f&#176;, distance %s; with <b>Ctrl</b> to snap angle, <b>Enter</b> to finish the path");
-        spdc_pen_set_angle_distance_status_message(pc, p, 0, message);
+        this->_setAngleDistanceStatusMessage(p, 0, message);
     }
 }
 
-static void spdc_pen_set_ctrl(PenTool *const pc, Geom::Point const p, guint const state)
-{
-    sp_canvas_item_show(pc->c1);
-    sp_canvas_item_show(pc->cl1);
-
-    if ( pc->npoints == 2 ) {
-        pc->p[1] = p;
-        sp_canvas_item_hide(pc->c0);
-        sp_canvas_item_hide(pc->cl0);
-        SP_CTRL(pc->c1)->moveto(pc->p[1]);
-        pc->cl1->setCoords(pc->p[0], pc->p[1]);
-
-        spdc_pen_set_angle_distance_status_message(pc, p, 0, _("<b>Curve handle</b>: angle %3.2f&#176;, length %s; with <b>Ctrl</b> to snap angle"));
-    } else if ( pc->npoints == 5 ) {
-        pc->p[4] = p;
-        sp_canvas_item_show(pc->c0);
-        sp_canvas_item_show(pc->cl0);
+void PenTool::_setCtrl(Geom::Point const p, guint const state) {
+    sp_canvas_item_show(this->c1);
+    sp_canvas_item_show(this->cl1);
+
+    if ( this->npoints == 2 ) {
+        this->p[1] = p;
+        sp_canvas_item_hide(this->c0);
+        sp_canvas_item_hide(this->cl0);
+        SP_CTRL(this->c1)->moveto(this->p[1]);
+        this->cl1->setCoords(this->p[0], this->p[1]);
+
+        this->_setAngleDistanceStatusMessage(p, 0, _("<b>Curve handle</b>: angle %3.2f&#176;, length %s; with <b>Ctrl</b> to snap angle"));
+    } else if ( this->npoints == 5 ) {
+        this->p[4] = p;
+        sp_canvas_item_show(this->c0);
+        sp_canvas_item_show(this->cl0);
         bool is_symm = false;
-        if ( ( ( pc->mode == PenTool::MODE_CLICK ) && ( state & GDK_CONTROL_MASK ) ) ||
-             ( ( pc->mode == PenTool::MODE_DRAG ) &&  !( state & GDK_SHIFT_MASK  ) ) ) {
-            Geom::Point delta = p - pc->p[3];
-            pc->p[2] = pc->p[3] - delta;
+        if ( ( ( this->mode == PenTool::MODE_CLICK ) && ( state & GDK_CONTROL_MASK ) ) ||
+             ( ( this->mode == PenTool::MODE_DRAG ) &&  !( state & GDK_SHIFT_MASK  ) ) ) {
+            Geom::Point delta = p - this->p[3];
+            this->p[2] = this->p[3] - delta;
             is_symm = true;
-            pc->red_curve->reset();
-            pc->red_curve->moveto(pc->p[0]);
-            pc->red_curve->curveto(pc->p[1], pc->p[2], pc->p[3]);
-            sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->red_curve);
+            this->red_curve->reset();
+            this->red_curve->moveto(this->p[0]);
+            this->red_curve->curveto(this->p[1], this->p[2], this->p[3]);
+            sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
         }
-        SP_CTRL(pc->c0)->moveto(pc->p[2]);
-        pc->cl0 ->setCoords(pc->p[3], pc->p[2]);
-        SP_CTRL(pc->c1)->moveto(pc->p[4]);
-        pc->cl1->setCoords(pc->p[3], pc->p[4]);
+        SP_CTRL(this->c0)->moveto(this->p[2]);
+        this->cl0 ->setCoords(this->p[3], this->p[2]);
+        SP_CTRL(this->c1)->moveto(this->p[4]);
+        this->cl1->setCoords(this->p[3], this->p[4]);
 
         gchar *message = is_symm ?
             _("<b>Curve handle, symmetric</b>: angle %3.2f&#176;, length %s; with <b>Ctrl</b> to snap angle, with <b>Shift</b> to move this handle only") :
             _("<b>Curve handle</b>: angle %3.2f&#176;, length %s; with <b>Ctrl</b> to snap angle, with <b>Shift</b> to move this handle only");
-        spdc_pen_set_angle_distance_status_message(pc, p, 3, message);
+        this->_setAngleDistanceStatusMessage(p, 3, message);
     } else {
-        g_warning("Something bad happened - npoints is %d", pc->npoints);
+        g_warning("Something bad happened - npoints is %d", this->npoints);
     }
 }
 
-static void spdc_pen_finish_segment(PenTool *const pc, Geom::Point const p, guint const state)
-{
-    if (pc->polylines_paraxial) {
-        pen_last_paraxial_dir = pen_next_paraxial_direction(pc, p, pc->p[0], state);
+void PenTool::_finishSegment(Geom::Point const p, guint const state) {
+    if (this->polylines_paraxial) {
+        pen_last_paraxial_dir = this->nextParaxialDirection(p, this->p[0], state);
     }
 
-    ++pc->num_clicks;
+    ++this->num_clicks;
 
-    if (!pc->red_curve->is_empty()) {
-        pc->green_curve->append_continuous(pc->red_curve, 0.0625);
-        SPCurve *curve = pc->red_curve->copy();
+    if (!this->red_curve->is_empty()) {
+        this->green_curve->append_continuous(this->red_curve, 0.0625);
+        SPCurve *curve = this->red_curve->copy();
         /// \todo fixme:
-        SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(pc->desktop), curve);
+        SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(this->desktop), curve);
         curve->unref();
-        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), pc->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
 
-        pc->green_bpaths = g_slist_prepend(pc->green_bpaths, cshape);
+        this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
 
-        pc->p[0] = pc->p[3];
-        pc->p[1] = pc->p[4];
-        pc->npoints = 2;
+        this->p[0] = this->p[3];
+        this->p[1] = this->p[4];
+        this->npoints = 2;
 
-        pc->red_curve->reset();
+        this->red_curve->reset();
     }
 }
 
-static void spdc_pen_finish(PenTool *const pc, gboolean const closed)
-{
-    if (pc->expecting_clicks_for_LPE > 1) {
+void PenTool::_finish(gboolean const closed) {
+    if (this->expecting_clicks_for_LPE > 1) {
         // don't let the path be finished before we have collected the required number of mouse clicks
         return;
     }
 
-    pc->num_clicks = 0;
+    this->num_clicks = 0;
 
-    pen_disable_events(pc);
+    this->_disableEvents();
 
-    SPDesktop *const desktop = pc->desktop;
-    pc->message_context->clear();
+    SPDesktop *const desktop = this->desktop;
+    this->message_context->clear();
     desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Drawing finished"));
 
-    pc->red_curve->reset();
-    spdc_concat_colors_and_flush(pc, closed);
-    pc->sa = NULL;
-    pc->ea = NULL;
+    this->red_curve->reset();
+    spdc_concat_colors_and_flush(this, closed);
+    this->sa = NULL;
+    this->ea = NULL;
 
-    pc->npoints = 0;
-    pc->state = PenTool::POINT;
+    this->npoints = 0;
+    this->state = PenTool::POINT;
 
-    sp_canvas_item_hide(pc->c0);
-    sp_canvas_item_hide(pc->c1);
-    sp_canvas_item_hide(pc->cl0);
-    sp_canvas_item_hide(pc->cl1);
+    sp_canvas_item_hide(this->c0);
+    sp_canvas_item_hide(this->c1);
+    sp_canvas_item_hide(this->cl0);
+    sp_canvas_item_hide(this->cl1);
 
-    if (pc->green_anchor) {
-        pc->green_anchor = sp_draw_anchor_destroy(pc->green_anchor);
+    if (this->green_anchor) {
+        this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
     }
 
 
-    pc->desktop->canvas->endForcedFullRedraws();
+    this->desktop->canvas->endForcedFullRedraws();
 
-    pen_enable_events(pc);
+    this->_enableEvents();
 }
 
-static void pen_disable_events(PenTool *const pc) {
-    pc->events_disabled = true;
+void PenTool::_disableEvents() {
+    this->events_disabled = true;
 }
 
-static void pen_enable_events(PenTool *const pc) {
-    g_return_if_fail(pc->events_disabled != 0);
+void PenTool::_enableEvents() {
+    g_return_if_fail(this->events_disabled != 0);
 
-    pc->events_disabled = false;
+    this->events_disabled = false;
 }
 
-void sp_pen_context_wait_for_LPE_mouse_clicks(PenTool *pc, Inkscape::LivePathEffect::EffectType effect_type,
-                                         unsigned int num_clicks, bool use_polylines)
-{
+void PenTool::waitForLPEMouseClicks(Inkscape::LivePathEffect::EffectType effect_type, unsigned int num_clicks, bool use_polylines) {
     if (effect_type == Inkscape::LivePathEffect::INVALID_LPE)
         return;
 
-    pc->waiting_LPE_type = effect_type;
-    pc->expecting_clicks_for_LPE = num_clicks;
-    pc->polylines_only = use_polylines;
-    pc->polylines_paraxial = false; // TODO: think if this is correct for all cases
+    this->waiting_LPE_type = effect_type;
+    this->expecting_clicks_for_LPE = num_clicks;
+    this->polylines_only = use_polylines;
+    this->polylines_paraxial = false; // TODO: think if this is correct for all cases
 }
 
-void sp_pen_context_cancel_waiting_for_LPE(PenTool *pc)
-{
-    pc->waiting_LPE_type = Inkscape::LivePathEffect::INVALID_LPE;
-    pc->expecting_clicks_for_LPE = 0;
-    sp_pen_context_set_polyline_mode(pc);
-}
-
-static int pen_next_paraxial_direction(const PenTool *const pc,
-                                       Geom::Point const &pt, Geom::Point const &origin, guint state) {
+int PenTool::nextParaxialDirection(Geom::Point const &pt, Geom::Point const &origin, guint state) const {
     //
     // after the first mouse click we determine whether the mouse pointer is closest to a
     // horizontal or vertical segment; for all subsequent mouse clicks, we use the direction
@@ -1359,7 +1314,7 @@ static int pen_next_paraxial_direction(const PenTool *const pc,
     // (on first mouse release), in which case num_clicks immediately becomes 1.
     // if (pc->num_clicks == 0) {
 
-    if (pc->green_curve->is_empty()) {
+    if (this->green_curve->is_empty()) {
         // first mouse click
         double dist_h = fabs(pt[Geom::X] - origin[Geom::X]);
         double dist_v = fabs(pt[Geom::Y] - origin[Geom::Y]);
@@ -1372,11 +1327,10 @@ static int pen_next_paraxial_direction(const PenTool *const pc,
     }
 }
 
-void pen_set_to_nearest_horiz_vert(const PenTool *const pc, Geom::Point &pt, guint const state, bool snap)
-{
-    Geom::Point const origin = pc->p[0];
+void PenTool::_setToNearestHorizVert(Geom::Point &pt, guint const state, bool snap) const {
+    Geom::Point const origin = this->p[0];
 
-    int next_dir = pen_next_paraxial_direction(pc, pt, origin, state);
+    int next_dir = this->nextParaxialDirection(pt, origin, state);
 
     if (!snap) {
         if (next_dir == 0) {
@@ -1391,13 +1345,13 @@ void pen_set_to_nearest_horiz_vert(const PenTool *const pc, Geom::Point &pt, gui
         Inkscape::Snapper::SnapConstraint cl(origin, next_dir ? Geom::Point(0, 1) : Geom::Point(1, 0));
 
         // Snap along the constraint line; if we didn't snap then still the constraint will be applied
-        SnapManager &m = pc->desktop->namedview->snap_manager;
+        SnapManager &m = this->desktop->namedview->snap_manager;
 
-        Inkscape::Selection *selection = sp_desktop_selection (pc->desktop);
+        Inkscape::Selection *selection = sp_desktop_selection (this->desktop);
         // selection->singleItem() is the item that is currently being drawn. This item will not be snapped to (to avoid self-snapping)
         // TODO: Allow snapping to the stationary parts of the item, and only ignore the last segment
 
-        m.setup(pc->desktop, true, selection->singleItem());
+        m.setup(this->desktop, true, selection->singleItem());
         m.constrainedSnapReturnByRef(pt, Inkscape::SNAPSOURCE_NODE_HANDLE, cl);
         m.unSetup();
     }
diff --git a/src/ui/tools/pen-tool.h b/src/ui/tools/pen-tool.h
index f2b1ee04a..182d270ee 100644
--- a/src/ui/tools/pen-tool.h
+++ b/src/ui/tools/pen-tool.h
@@ -67,26 +67,52 @@ public:
 
 	virtual const std::string& getPrefsPath();
 
+	int nextParaxialDirection(Geom::Point const &pt, Geom::Point const &origin, guint state) const;
+	void setPolylineMode();
+	bool hasWaitingLPE();
+    void waitForLPEMouseClicks(Inkscape::LivePathEffect::EffectType effect_type, unsigned int num_clicks, bool use_polylines = true);
+
 protected:
 	virtual void setup();
 	virtual void finish();
 	virtual void set(const Inkscape::Preferences::Entry& val);
 	virtual bool root_handler(GdkEvent* event);
 	virtual bool item_handler(SPItem* item, GdkEvent* event);
-};
 
-inline bool sp_pen_context_has_waiting_LPE(PenTool *pc) {
-    // note: waiting_LPE_type is defined in SPDrawContext
-    return (pc->waiting_LPE != NULL ||
-            pc->waiting_LPE_type != Inkscape::LivePathEffect::INVALID_LPE);
-}
+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);
+
+	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);
+	void _finishSegment(Geom::Point p, guint state);
+
+	void _finish(gboolean closed);
+
+	void _resetColors();
 
-void sp_pen_context_set_polyline_mode(PenTool *const pc);
-void sp_pen_context_wait_for_LPE_mouse_clicks(PenTool *pc, Inkscape::LivePathEffect::EffectType effect_type,
-                                              unsigned int num_clicks, bool use_polylines = true);
-void sp_pen_context_cancel_waiting_for_LPE(PenTool *pc);
-void sp_pen_context_put_into_waiting_mode(SPDesktop *desktop, Inkscape::LivePathEffect::EffectType effect_type,
-                                          unsigned int num_clicks, bool use_polylines = true);
+	void _disableEvents();
+	void _enableEvents();
+
+	void _setToNearestHorizVert(Geom::Point &pt, guint const state, bool snap) const;
+
+	void _setAngleDistanceStatusMessage(Geom::Point const p, int pc_point_to_compare, gchar const *message);
+
+	void _lastpointToLine();
+	void _lastpointToCurve();
+	void _lastpointMoveScreen(gdouble x, gdouble y);
+	void _lastpointMove(gdouble x, gdouble y);
+	void _redrawAll();
+
+	void _endpointSnapHandle(Geom::Point &p, guint const state) const;
+	void _endpointSnap(Geom::Point &p, guint const state) const;
+
+	void _cancel();
+};
 
 }
 }
diff --git a/src/ui/tools/pencil-tool.cpp b/src/ui/tools/pencil-tool.cpp
index 4fbaa50f3..230ec62af 100644
--- a/src/ui/tools/pencil-tool.cpp
+++ b/src/ui/tools/pencil-tool.cpp
@@ -50,20 +50,6 @@ namespace Inkscape {
 namespace UI {
 namespace Tools {
 
-static gint pencil_handle_button_press(PencilTool *const pc, GdkEventButton const &bevent);
-static gint pencil_handle_motion_notify(PencilTool *const pc, GdkEventMotion const &mevent);
-static gint pencil_handle_button_release(PencilTool *const pc, GdkEventButton const &revent);
-static gint pencil_handle_key_press(PencilTool *const pc, guint const keyval, guint const state);
-static gint pencil_handle_key_release(PencilTool *const pc, guint const keyval, guint const state);
-
-static void spdc_set_startpoint(PencilTool *pc, Geom::Point const &p);
-static void spdc_set_endpoint(PencilTool *pc, Geom::Point const &p);
-static void spdc_finish_endpoint(PencilTool *pc);
-static void spdc_add_freehand_point(PencilTool *pc, Geom::Point const &p, guint state);
-static void fit_and_split(PencilTool *pc);
-static void interpolate(PencilTool *pc);
-static void sketch_interpolate(PencilTool *pc);
-
 static Geom::Point pencil_drag_origin_w(0, 0);
 static bool pencil_within_tolerance = false;
 
@@ -110,19 +96,17 @@ PencilTool::~PencilTool() {
 }
 
 /** Snaps new node relative to the previous node. */
-static void
-spdc_endpoint_snap(PencilTool const *pc, Geom::Point &p, guint const state)
-{
+void PencilTool::_endpointSnap(Geom::Point &p, guint const state) {
     if ((state & GDK_CONTROL_MASK)) { //CTRL enables constrained snapping
-        if (pc->npoints > 0) {
-            spdc_endpoint_snap_rotation(pc, p, pc->p[0], state);
+        if (this->npoints > 0) {
+            spdc_endpoint_snap_rotation(this, p, this->p[0], state);
         }
     } else {
         if (!(state & GDK_SHIFT_MASK)) { //SHIFT disables all snapping, except the angular snapping above
                                          //After all, the user explicitely asked for angular snapping by
                                          //pressing CTRL
-            boost::optional<Geom::Point> origin = pc->npoints > 0 ? pc->p[0] : boost::optional<Geom::Point>();
-            spdc_endpoint_snap_free(pc, p, origin, state);
+            boost::optional<Geom::Point> origin = this->npoints > 0 ? this->p[0] : boost::optional<Geom::Point>();
+            spdc_endpoint_snap_free(this, p, origin, state);
         }
     }
 }
@@ -135,23 +119,23 @@ bool PencilTool::root_handler(GdkEvent* event) {
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
-            ret = pencil_handle_button_press(this, event->button);
+            ret = this->_handleButtonPress(event->button);
             break;
 
         case GDK_MOTION_NOTIFY:
-            ret = pencil_handle_motion_notify(this, event->motion);
+            ret = this->_handleMotionNotify(event->motion);
             break;
 
         case GDK_BUTTON_RELEASE:
-            ret = pencil_handle_button_release(this, event->button);
+            ret = this->_handleButtonRelease(event->button);
             break;
 
         case GDK_KEY_PRESS:
-            ret = pencil_handle_key_press(this, get_group0_keyval (&event->key), event->key.state);
+            ret = this->_handleKeyPress(get_group0_keyval (&event->key), event->key.state);
             break;
 
         case GDK_KEY_RELEASE:
-            ret = pencil_handle_key_release(this, get_group0_keyval (&event->key), event->key.state);
+            ret = this->_handleKeyRelease(get_group0_keyval (&event->key), event->key.state);
             break;
 
         default:
@@ -165,14 +149,12 @@ bool PencilTool::root_handler(GdkEvent* event) {
     return ret;
 }
 
-static gint
-pencil_handle_button_press(PencilTool *const pc, GdkEventButton const &bevent)
-{
+gint PencilTool::_handleButtonPress(GdkEventButton const &bevent) {
     gint ret = FALSE;
-    ToolBase *event_context = SP_EVENT_CONTEXT(pc);
+    ToolBase *event_context = SP_EVENT_CONTEXT(this);
     if ( bevent.button == 1  && !event_context->space_panning) {
 
-        FreehandBase *dc = SP_DRAW_CONTEXT (pc);
+        FreehandBase *dc = SP_DRAW_CONTEXT (this);
         SPDesktop *desktop = dc->desktop;
         Inkscape::Selection *selection = sp_desktop_selection(desktop);
 
@@ -180,10 +162,10 @@ pencil_handle_button_press(PencilTool *const pc, GdkEventButton const &bevent)
             return TRUE;
         }
 
-        if (!pc->grab) {
+        if (!this->grab) {
             /* Grab mouse, so release will not pass unnoticed */
-            pc->grab = SP_CANVAS_ITEM(desktop->acetate);
-            sp_canvas_item_grab(pc->grab, ( GDK_KEY_PRESS_MASK | GDK_BUTTON_PRESS_MASK   |
+            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  ),
                                 NULL, bevent.time);
@@ -192,15 +174,15 @@ pencil_handle_button_press(PencilTool *const pc, GdkEventButton const &bevent)
         Geom::Point const button_w(bevent.x, bevent.y);
 
         /* Find desktop coordinates */
-        Geom::Point p = pc->desktop->w2d(button_w);
+        Geom::Point p = this->desktop->w2d(button_w);
 
         /* Test whether we hit any anchor. */
-        SPDrawAnchor *anchor = spdc_test_inside(pc, button_w);
+        SPDrawAnchor *anchor = spdc_test_inside(this, button_w);
 
         pencil_drag_origin_w = Geom::Point(bevent.x,bevent.y);
         pencil_within_tolerance = true;
 
-        switch (pc->state) {
+        switch (this->state) {
             case SP_PENCIL_CONTEXT_ADDLINE:
                 /* Current segment will be finished with release */
                 ret = TRUE;
@@ -237,40 +219,38 @@ pencil_handle_button_press(PencilTool *const pc, GdkEventButton const &bevent)
                     }
                     m.unSetup();
                 }
-                pc->sa = anchor;
-                spdc_set_startpoint(pc, p);
+                this->sa = anchor;
+                this->_setStartpoint(p);
                 ret = TRUE;
                 break;
         }
 
-        pc->is_drawing = true;
+        this->is_drawing = true;
     }
     return ret;
 }
 
-static gint
-pencil_handle_motion_notify(PencilTool *const pc, GdkEventMotion const &mevent)
-{
-    SPDesktop *const dt = pc->desktop;
+gint PencilTool::_handleMotionNotify(GdkEventMotion const &mevent) {
+    SPDesktop *const dt = this->desktop;
 
     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
-        pc->is_drawing = false;
+        this->is_drawing = false;
         return TRUE;
     }
     gint ret = FALSE;
 
-    ToolBase *event_context = SP_EVENT_CONTEXT(pc);
+    ToolBase *event_context = SP_EVENT_CONTEXT(this);
     if (event_context->space_panning || mevent.state & GDK_BUTTON2_MASK || mevent.state & GDK_BUTTON3_MASK) {
         // allow scrolling
         return FALSE;
     }
 
-    if ( ( mevent.state & GDK_BUTTON1_MASK ) && !pc->grab && pc->is_drawing) {
+    if ( ( mevent.state & GDK_BUTTON1_MASK ) && !this->grab && this->is_drawing) {
         /* Grab mouse, so release will not pass unnoticed */
-        pc->grab = SP_CANVAS_ITEM(dt->acetate);
-        sp_canvas_item_grab(pc->grab, ( GDK_KEY_PRESS_MASK | GDK_BUTTON_PRESS_MASK   |
+        this->grab = SP_CANVAS_ITEM(dt->acetate);
+        sp_canvas_item_grab(this->grab, ( GDK_KEY_PRESS_MASK | GDK_BUTTON_PRESS_MASK   |
                                         GDK_BUTTON_RELEASE_MASK |
                                         GDK_POINTER_MOTION_MASK  ),
                             NULL, mevent.time);
@@ -280,7 +260,7 @@ pencil_handle_motion_notify(PencilTool *const pc, GdkEventMotion const &mevent)
     Geom::Point p = dt->w2d(Geom::Point(mevent.x, mevent.y));
 
     /* Test whether we hit any anchor. */
-    SPDrawAnchor *anchor = spdc_test_inside(pc, Geom::Point(mevent.x, mevent.y));
+    SPDrawAnchor *anchor = spdc_test_inside(this, Geom::Point(mevent.x, mevent.y));
 
     if (pencil_within_tolerance) {
         Inkscape::Preferences *prefs = Inkscape::Preferences::get();
@@ -295,71 +275,71 @@ pencil_handle_motion_notify(PencilTool *const pc, GdkEventMotion const &mevent)
     // motion notify coordinates as given (no snapping back to origin)
     pencil_within_tolerance = false;
 
-    switch (pc->state) {
+    switch (this->state) {
         case SP_PENCIL_CONTEXT_ADDLINE:
             /* Set red endpoint */
             if (anchor) {
                 p = anchor->dp;
             } else {
                 Geom::Point ptnr(p);
-                spdc_endpoint_snap(pc, ptnr, mevent.state);
+                this->_endpointSnap(ptnr, mevent.state);
                 p = ptnr;
             }
-            spdc_set_endpoint(pc, p);
+            this->_setEndpoint(p);
             ret = TRUE;
             break;
         default:
             /* We may be idle or already freehand */
-            if ( mevent.state & GDK_BUTTON1_MASK && pc->is_drawing ) {
-                if (pc->state == SP_PENCIL_CONTEXT_IDLE) {
+            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);
                 }
-                pc->state = SP_PENCIL_CONTEXT_FREEHAND;
+                this->state = SP_PENCIL_CONTEXT_FREEHAND;
 
-                if ( !pc->sa && !pc->green_anchor ) {
+                if ( !this->sa && !this->green_anchor ) {
                     /* Create green anchor */
-                    pc->green_anchor = sp_draw_anchor_new(pc, pc->green_curve, TRUE, pc->p[0]);
+                    this->green_anchor = sp_draw_anchor_new(this, this->green_curve, TRUE, this->p[0]);
                 }
                 if (anchor) {
                     p = anchor->dp;
                 }
 
-                if ( pc->npoints != 0) { // buttonpress may have happened before we entered draw context!
-                    if (pc->ps.empty()) {
+                if ( this->npoints != 0) { // buttonpress may have happened before we entered draw context!
+                    if (this->ps.empty()) {
                         // Only in freehand mode we have to add the first point also to pc->ps (apparently)
                         // - We cannot add this point in spdc_set_startpoint, because we only need it for freehand
                         // - We cannot do this in the button press handler because at that point we don't know yet
                         //   wheter we're going into freehand mode or not
-                        pc->ps.push_back(pc->p[0]);
+                        this->ps.push_back(this->p[0]);
                     }
-                    spdc_add_freehand_point(pc, p, mevent.state);
+                    this->_addFreehandPoint(p, mevent.state);
                     ret = TRUE;
                 }
 
-                if (anchor && !pc->anchor_statusbar) {
-                    pc->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Release</b> here to close and finish the path."));
-                    pc->anchor_statusbar = true;
-                } else if (!anchor && pc->anchor_statusbar) {
-                    pc->message_context->clear();
-                    pc->anchor_statusbar = false;
+                if (anchor && !this->anchor_statusbar) {
+                    this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Release</b> here to close and finish the path."));
+                    this->anchor_statusbar = true;
+                } else if (!anchor && this->anchor_statusbar) {
+                    this->message_context->clear();
+                    this->anchor_statusbar = false;
                 } else if (!anchor) {
-                    pc->message_context->set(Inkscape::NORMAL_MESSAGE, _("Drawing a freehand path"));
+                    this->message_context->set(Inkscape::NORMAL_MESSAGE, _("Drawing a freehand path"));
                 }
 
             } else {
-                if (anchor && !pc->anchor_statusbar) {
-                    pc->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Drag</b> to continue the path from this point."));
-                    pc->anchor_statusbar = true;
-                } else if (!anchor && pc->anchor_statusbar) {
-                    pc->message_context->clear();
-                    pc->anchor_statusbar = false;
+                if (anchor && !this->anchor_statusbar) {
+                    this->message_context->set(Inkscape::NORMAL_MESSAGE, _("<b>Drag</b> to continue the path from this point."));
+                    this->anchor_statusbar = true;
+                } else if (!anchor && this->anchor_statusbar) {
+                    this->message_context->clear();
+                    this->anchor_statusbar = false;
                 }
             }
 
             // Show the pre-snap indicator to communicate to the user where we would snap to if he/she were to
             // a) press the mousebutton to start a freehand drawing, or
             // b) release the mousebutton to finish a freehand drawing
-            if (!sp_event_context_knot_mouseover(pc)) {
+            if (!this->sp_event_context_knot_mouseover()) {
                 SnapManager &m = dt->namedview->snap_manager;
                 m.setup(dt);
                 m.preSnap(Inkscape::SnapCandidatePoint(p, Inkscape::SNAPSOURCE_NODE_HANDLE));
@@ -370,31 +350,29 @@ pencil_handle_motion_notify(PencilTool *const pc, GdkEventMotion const &mevent)
     return ret;
 }
 
-static gint
-pencil_handle_button_release(PencilTool *const pc, GdkEventButton const &revent)
-{
+gint PencilTool::_handleButtonRelease(GdkEventButton const &revent) {
     gint ret = FALSE;
 
-    ToolBase *event_context = SP_EVENT_CONTEXT(pc);
-    if ( revent.button == 1 && pc->is_drawing && !event_context->space_panning) {
-        SPDesktop *const dt = pc->desktop;
+    ToolBase *event_context = SP_EVENT_CONTEXT(this);
+    if ( revent.button == 1 && this->is_drawing && !event_context->space_panning) {
+        SPDesktop *const dt = this->desktop;
 
-        pc->is_drawing = false;
+        this->is_drawing = false;
 
         /* Find desktop coordinates */
         Geom::Point p = dt->w2d(Geom::Point(revent.x, revent.y));
 
         /* Test whether we hit any anchor. */
-        SPDrawAnchor *anchor = spdc_test_inside(pc, Geom::Point(revent.x,
+        SPDrawAnchor *anchor = spdc_test_inside(this, Geom::Point(revent.x,
                                                               revent.y));
 
-        switch (pc->state) {
+        switch (this->state) {
             case SP_PENCIL_CONTEXT_IDLE:
                 /* Releasing button in idle mode means single click */
                 /* We have already set up start point/anchor in button_press */
                 if (!(revent.state & GDK_CONTROL_MASK)) {
                     // Ctrl+click creates a single point so only set context in ADDLINE mode when Ctrl isn't pressed
-                    pc->state = SP_PENCIL_CONTEXT_ADDLINE;
+                    this->state = SP_PENCIL_CONTEXT_ADDLINE;
                 }
                 ret = TRUE;
                 break;
@@ -403,12 +381,12 @@ pencil_handle_button_release(PencilTool *const pc, GdkEventButton const &revent)
                 if (anchor) {
                     p = anchor->dp;
                 } else {
-                    spdc_endpoint_snap(pc, p, revent.state);
+                    this->_endpointSnap(p, revent.state);
                 }
-                pc->ea = anchor;
-                spdc_set_endpoint(pc, p);
-                spdc_finish_endpoint(pc);
-                pc->state = SP_PENCIL_CONTEXT_IDLE;
+                this->ea = anchor;
+                this->_setEndpoint(p);
+                this->_finishEndpoint();
+                this->state = SP_PENCIL_CONTEXT_IDLE;
                 sp_event_context_discard_delayed_snap_event(event_context);
                 ret = TRUE;
                 break;
@@ -416,13 +394,13 @@ pencil_handle_button_release(PencilTool *const pc, GdkEventButton const &revent)
                 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 */
 
-                    sketch_interpolate(pc);
+                    this->_sketchInterpolate();
 
-                    if (pc->green_anchor) {
-                        pc->green_anchor = sp_draw_anchor_destroy(pc->green_anchor);
+                    if (this->green_anchor) {
+                        this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
                     }
 
-                    pc->state = SP_PENCIL_CONTEXT_SKETCH;
+                    this->state = SP_PENCIL_CONTEXT_SKETCH;
                 } else {
                     /* Finish segment now */
                     /// \todo fixme: Clean up what follows (Lauris)
@@ -430,28 +408,28 @@ pencil_handle_button_release(PencilTool *const pc, GdkEventButton const &revent)
                         p = anchor->dp;
                     } else {
                         Geom::Point p_end = p;
-                        spdc_endpoint_snap(pc, p_end, revent.state);
+                        this->_endpointSnap(p_end, revent.state);
                         if (p_end != p) {
                             // then we must have snapped!
-                            spdc_add_freehand_point(pc, p_end, revent.state);
+                            this->_addFreehandPoint(p_end, revent.state);
                         }
                     }
 
-                    pc->ea = anchor;
+                    this->ea = anchor;
                     /* Write curves to object */
 
                     dt->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Finishing freehand"));
 
-                    interpolate(pc);
-                    spdc_concat_colors_and_flush(pc, FALSE);
-                    pc->sa = NULL;
-                    pc->ea = NULL;
-                    if (pc->green_anchor) {
-                        pc->green_anchor = sp_draw_anchor_destroy(pc->green_anchor);
+                    this->_interpolate();
+                    spdc_concat_colors_and_flush(this, FALSE);
+                    this->sa = NULL;
+                    this->ea = NULL;
+                    if (this->green_anchor) {
+                        this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
                     }
-                    pc->state = SP_PENCIL_CONTEXT_IDLE;
+                    this->state = SP_PENCIL_CONTEXT_IDLE;
                     // reset sketch mode too
-                    pc->sketch_n = 0;
+                    this->sketch_n = 0;
                 }
                 ret = TRUE;
                 break;
@@ -460,10 +438,10 @@ pencil_handle_button_release(PencilTool *const pc, GdkEventButton const &revent)
                 break;
         }
 
-        if (pc->grab) {
+        if (this->grab) {
             /* Release grab now */
-            sp_canvas_item_ungrab(pc->grab, revent.time);
-            pc->grab = NULL;
+            sp_canvas_item_ungrab(this->grab, revent.time);
+            this->grab = NULL;
         }
 
         ret = TRUE;
@@ -471,39 +449,35 @@ pencil_handle_button_release(PencilTool *const pc, GdkEventButton const &revent)
     return ret;
 }
 
-static void
-pencil_cancel (PencilTool *const pc)
-{
-    if (pc->grab) {
+void PencilTool::_cancel() {
+    if (this->grab) {
         /* Release grab now */
-        sp_canvas_item_ungrab(pc->grab, 0);
-        pc->grab = NULL;
+        sp_canvas_item_ungrab(this->grab, 0);
+        this->grab = NULL;
     }
 
-    pc->is_drawing = false;
-    pc->state = SP_PENCIL_CONTEXT_IDLE;
-    sp_event_context_discard_delayed_snap_event(SP_EVENT_CONTEXT(pc));
-
-    pc->red_curve->reset();
-    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), NULL);
-    while (pc->green_bpaths) {
-        sp_canvas_item_destroy(SP_CANVAS_ITEM(pc->green_bpaths->data));
-        pc->green_bpaths = g_slist_remove(pc->green_bpaths, pc->green_bpaths->data);
+    this->is_drawing = false;
+    this->state = SP_PENCIL_CONTEXT_IDLE;
+    sp_event_context_discard_delayed_snap_event(SP_EVENT_CONTEXT(this));
+
+    this->red_curve->reset();
+    sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
+    while (this->green_bpaths) {
+        sp_canvas_item_destroy(SP_CANVAS_ITEM(this->green_bpaths->data));
+        this->green_bpaths = g_slist_remove(this->green_bpaths, this->green_bpaths->data);
     }
-    pc->green_curve->reset();
-    if (pc->green_anchor) {
-        pc->green_anchor = sp_draw_anchor_destroy(pc->green_anchor);
+    this->green_curve->reset();
+    if (this->green_anchor) {
+        this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
     }
 
-    pc->message_context->clear();
-    pc->message_context->flash(Inkscape::NORMAL_MESSAGE, _("Drawing cancelled"));
+    this->message_context->clear();
+    this->message_context->flash(Inkscape::NORMAL_MESSAGE, _("Drawing cancelled"));
 
-    pc->desktop->canvas->endForcedFullRedraws();
+    this->desktop->canvas->endForcedFullRedraws();
 }
 
-static gint
-pencil_handle_key_press(PencilTool *const pc, guint const keyval, guint const state)
-{
+gint PencilTool::_handleKeyPress(guint const keyval, guint const state) {
     gint ret = FALSE;
     switch (keyval) {
         case GDK_KEY_Up:
@@ -516,20 +490,20 @@ pencil_handle_key_press(PencilTool *const pc, guint const keyval, guint const st
             }
             break;
         case GDK_KEY_Escape:
-            if (pc->npoints != 0) {
+            if (this->npoints != 0) {
                 // if drawing, cancel, otherwise pass it up for deselecting
-                if (pc->state != SP_PENCIL_CONTEXT_IDLE) {
-                    pencil_cancel (pc);
+                if (this->state != SP_PENCIL_CONTEXT_IDLE) {
+                    this->_cancel();
                     ret = TRUE;
                 }
             }
             break;
         case GDK_KEY_z:
         case GDK_KEY_Z:
-            if (mod_ctrl_only(state) && pc->npoints != 0) {
+            if (mod_ctrl_only(state) && this->npoints != 0) {
                 // if drawing, cancel, otherwise pass it up for undo
-                if (pc->state != SP_PENCIL_CONTEXT_IDLE) {
-                    pencil_cancel (pc);
+                if (this->state != SP_PENCIL_CONTEXT_IDLE) {
+                    this->_cancel();
                     ret = TRUE;
                 }
             }
@@ -537,7 +511,7 @@ pencil_handle_key_press(PencilTool *const pc, guint const keyval, guint const st
         case GDK_KEY_g:
         case GDK_KEY_G:
             if (mod_shift_only(state)) {
-                sp_selection_to_guides(SP_EVENT_CONTEXT(pc)->desktop);
+                sp_selection_to_guides(SP_EVENT_CONTEXT(this)->desktop);
                 ret = true;
             }
             break;
@@ -545,8 +519,8 @@ pencil_handle_key_press(PencilTool *const pc, guint const keyval, guint const st
         case GDK_KEY_Alt_R:
         case GDK_KEY_Meta_L:
         case GDK_KEY_Meta_R:
-            if (pc->state == SP_PENCIL_CONTEXT_IDLE) {
-                pc->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("<b>Sketch mode</b>: holding <b>Alt</b> interpolates between sketched paths. Release <b>Alt</b> to finalize."));
+            if (this->state == SP_PENCIL_CONTEXT_IDLE) {
+                this->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("<b>Sketch mode</b>: holding <b>Alt</b> interpolates between sketched paths. Release <b>Alt</b> to finalize."));
             }
             break;
         default:
@@ -555,26 +529,24 @@ pencil_handle_key_press(PencilTool *const pc, guint const keyval, guint const st
     return ret;
 }
 
-static gint
-pencil_handle_key_release(PencilTool *const pc, guint const keyval, guint const /*state*/)
-{
+gint PencilTool::_handleKeyRelease(guint const keyval, guint const /*state*/) {
     gint 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 (pc->state == SP_PENCIL_CONTEXT_SKETCH) {
-                spdc_concat_colors_and_flush(pc, FALSE);
-                pc->sketch_n = 0;
-                pc->sa = NULL;
-                pc->ea = NULL;
-                if (pc->green_anchor) {
-                    pc->green_anchor = sp_draw_anchor_destroy(pc->green_anchor);
+            if (this->state == SP_PENCIL_CONTEXT_SKETCH) {
+                spdc_concat_colors_and_flush(this, FALSE);
+                this->sketch_n = 0;
+                this->sa = NULL;
+                this->ea = NULL;
+                if (this->green_anchor) {
+                    this->green_anchor = sp_draw_anchor_destroy(this->green_anchor);
                 }
-                pc->state = SP_PENCIL_CONTEXT_IDLE;
-                sp_event_context_discard_delayed_snap_event(SP_EVENT_CONTEXT(pc));
-                pc->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Finishing freehand sketch"));
+                this->state = SP_PENCIL_CONTEXT_IDLE;
+                sp_event_context_discard_delayed_snap_event(SP_EVENT_CONTEXT(this));
+                this->desktop->messageStack()->flash(Inkscape::NORMAL_MESSAGE, _("Finishing freehand sketch"));
                 ret = TRUE;
             }
             break;
@@ -587,13 +559,11 @@ pencil_handle_key_release(PencilTool *const pc, guint const keyval, guint const
 /**
  * Reset points and set new starting point.
  */
-static void
-spdc_set_startpoint(PencilTool *const pc, Geom::Point const &p)
-{
-    pc->npoints = 0;
-    pc->red_curve_is_valid = false;
+void PencilTool::_setStartpoint(Geom::Point const &p) {
+    this->npoints = 0;
+    this->red_curve_is_valid = false;
     if (in_svg_plane(p)) {
-        pc->p[pc->npoints++] = p;
+        this->p[this->npoints++] = p;
     }
 }
 
@@ -607,31 +577,29 @@ spdc_set_startpoint(PencilTool *const pc, Geom::Point const &p)
  * Number of points is (re)set to 2 always, 2nd point is modified.
  * We change RED curve.
  */
-static void
-spdc_set_endpoint(PencilTool *const pc, Geom::Point const &p)
-{
-    if (pc->npoints == 0) {
+void PencilTool::_setEndpoint(Geom::Point const &p) {
+    if (this->npoints == 0) {
         return;
         /* May occur if first point wasn't in SVG plane (e.g. weird w2d transform, perhaps from bad
          * zoom setting).
          */
     }
-    g_return_if_fail( pc->npoints > 0 );
+    g_return_if_fail( this->npoints > 0 );
 
-    pc->red_curve->reset();
-    if ( ( p == pc->p[0] )
+    this->red_curve->reset();
+    if ( ( p == this->p[0] )
          || !in_svg_plane(p) )
     {
-        pc->npoints = 1;
+        this->npoints = 1;
     } else {
-        pc->p[1] = p;
-        pc->npoints = 2;
+        this->p[1] = p;
+        this->npoints = 2;
 
-        pc->red_curve->moveto(pc->p[0]);
-        pc->red_curve->lineto(pc->p[1]);
-        pc->red_curve_is_valid = true;
+        this->red_curve->moveto(this->p[0]);
+        this->red_curve->lineto(this->p[1]);
+        this->red_curve_is_valid = true;
 
-        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->red_curve);
+        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
     }
 }
 
@@ -642,35 +610,30 @@ spdc_set_endpoint(PencilTool *const pc, Geom::Point const &p)
  * fixme: I'd like remove red reset from concat colors (lauris).
  * Still not sure, how it will make most sense.
  */
-static void
-spdc_finish_endpoint(PencilTool *const pc)
-{
-    if ( ( pc->red_curve->is_empty() )
-         || ( *(pc->red_curve->first_point()) == *(pc->red_curve->second_point())   ) )
+void PencilTool::_finishEndpoint() {
+    if ( ( this->red_curve->is_empty() )
+         || ( *(this->red_curve->first_point()) == *(this->red_curve->second_point())   ) )
     {
-        pc->red_curve->reset();
-        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), NULL);
+        this->red_curve->reset();
+        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), NULL);
     } else {
         /* Write curves to object. */
-        spdc_concat_colors_and_flush(pc, FALSE);
-        pc->sa = NULL;
-        pc->ea = NULL;
+        spdc_concat_colors_and_flush(this, FALSE);
+        this->sa = NULL;
+        this->ea = NULL;
     }
 }
 
+void PencilTool::_addFreehandPoint(Geom::Point const &p, guint /*state*/) {
+    g_assert( this->npoints > 0 );
+    g_return_if_fail(unsigned(this->npoints) < G_N_ELEMENTS(this->p));
 
-static void
-spdc_add_freehand_point(PencilTool *pc, Geom::Point const &p, guint /*state*/)
-{
-    g_assert( pc->npoints > 0 );
-    g_return_if_fail(unsigned(pc->npoints) < G_N_ELEMENTS(pc->p));
-
-    if ( ( p != pc->p[ pc->npoints - 1 ] )
+    if ( ( p != this->p[ this->npoints - 1 ] )
          && in_svg_plane(p) )
     {
-        pc->ps.push_back(p);
-        pc->p[pc->npoints++] = p;
-        fit_and_split(pc);
+        this->ps.push_back(p);
+        this->p[this->npoints++] = p;
+        this->_fitAndSplit();
     }
 }
 
@@ -680,31 +643,29 @@ square(double const x)
     return x * x;
 }
 
-static void
-interpolate(PencilTool *pc)
-{
-    if ( pc->ps.size() <= 1 ) {
+void PencilTool::_interpolate() {
+    if ( this->ps.size() <= 1 ) {
         return;
     }
 
     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( pc->desktop->w2d().descrim() *
+    double const tolerance_sq = 0.02 * square( this->desktop->w2d().descrim() *
                                                tol) * exp(0.2*tol - 2);
 
-    g_assert(is_zero(pc->req_tangent)
-             || is_unit_vector(pc->req_tangent));
+    g_assert(is_zero(this->req_tangent)
+             || is_unit_vector(this->req_tangent));
     Geom::Point const tHatEnd(0, 0);
 
-    guint n_points  = pc->ps.size();
-    pc->green_curve->reset();
-    pc->red_curve->reset();
-    pc->red_curve_is_valid = false;
+    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 < pc->ps.size(); i++) {
-        points[i] = pc->ps[i];
+    for (unsigned int i = 0; i < this->ps.size(); i++) {
+        points[i] = this->ps[i];
     }
 
     // worst case gives us a segment per point
@@ -716,62 +677,60 @@ interpolate(PencilTool *pc)
     if ( n_segs > 0)
     {
         /* Fit and draw and reset state */
-        pc->green_curve->moveto(b[0]);
+        this->green_curve->moveto(b[0]);
         for (int c = 0; c < n_segs; c++) {
-            pc->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(pc->red_bpath), pc->green_curve);
+        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->green_curve);
 
         /* Fit and draw and copy last point */
-        g_assert(!pc->green_curve->is_empty());
+        g_assert(!this->green_curve->is_empty());
 
         /* Set up direction of next curve. */
         {
-            Geom::Curve const * last_seg = pc->green_curve->last_segment();
+            Geom::Curve const * last_seg = this->green_curve->last_segment();
             g_assert( last_seg );      // Relevance: validity of (*last_seg)
-            pc->p[0] = last_seg->finalPoint();
-            pc->npoints = 1;
+            this->p[0] = last_seg->finalPoint();
+            this->npoints = 1;
             Geom::Curve *last_seg_reverse = last_seg->reverse();
             Geom::Point const req_vec( -last_seg_reverse->unitTangentAt(0) );
             delete last_seg_reverse;
-            pc->req_tangent = ( ( Geom::is_zero(req_vec) || !in_svg_plane(req_vec) )
+            this->req_tangent = ( ( Geom::is_zero(req_vec) || !in_svg_plane(req_vec) )
                                 ? Geom::Point(0, 0)
                                 : Geom::unit_vector(req_vec) );
         }
     }
     g_free(b);
     g_free(points);
-    pc->ps.clear();
+    this->ps.clear();
 }
 
 
 /* interpolates the sketched curve and tweaks the current sketch interpolation*/
-static void
-sketch_interpolate(PencilTool *pc)
-{
-    if ( pc->ps.size() <= 1 ) {
+void PencilTool::_sketchInterpolate() {
+    if ( this->ps.size() <= 1 ) {
         return;
     }
 
     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( pc->desktop->w2d().descrim() *
+    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(pc->req_tangent)
-             || is_unit_vector(pc->req_tangent));
+    g_assert(is_zero(this->req_tangent)
+             || is_unit_vector(this->req_tangent));
     Geom::Point const tHatEnd(0, 0);
 
-    guint n_points  = pc->ps.size();
-    pc->red_curve->reset();
-    pc->red_curve_is_valid = false;
+    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 < pc->ps.size(); i++) {
-        points[i] = pc->ps[i];
+    for (unsigned i = 0; i < this->ps.size(); i++) {
+        points[i] = this->ps[i];
     }
 
     // worst case gives us a segment per point
@@ -788,110 +747,108 @@ sketch_interpolate(PencilTool *pc)
         }
         Geom::Piecewise<Geom::D2<Geom::SBasis> > fit_pwd2 = fit.toPwSb();
 
-        if ( pc->sketch_n > 0 ) {
+        if ( this->sketch_n > 0 ) {
             double t =0.;
             if (average_all_sketches) {
                 // Average = (sum of all) / n
                 //         = (sum of all + new one) / n+1
                 //         = ((old average)*n + new one) / n+1
-                t = pc->sketch_n / (pc->sketch_n + 1.);
+                t = this->sketch_n / (this->sketch_n + 1.);
             } else {
                 t = 0.5;
             }
-            pc->sketch_interpolation = Geom::lerp(t, fit_pwd2, pc->sketch_interpolation);
+            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(pc->sketch_interpolation, 0.01));
+            path->LoadPathVector(Geom::path_from_piecewise(this->sketch_interpolation, 0.01));
             path->Simplify(0.5);
             Geom::PathVector *pathv = path->MakePathVector();
-            pc->sketch_interpolation = (*pathv)[0].toPwSb();
+            this->sketch_interpolation = (*pathv)[0].toPwSb();
             delete path;
             delete pathv;
         } else {
-            pc->sketch_interpolation = fit_pwd2;
+            this->sketch_interpolation = fit_pwd2;
         }
-        pc->sketch_n++;
+        this->sketch_n++;
 
-        pc->green_curve->reset();
-        pc->green_curve->set_pathvector(Geom::path_from_piecewise(pc->sketch_interpolation, 0.01));
-        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->green_curve);
+        this->green_curve->reset();
+        this->green_curve->set_pathvector(Geom::path_from_piecewise(this->sketch_interpolation, 0.01));
+        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->green_curve);
 
         /* Fit and draw and copy last point */
-        g_assert(!pc->green_curve->is_empty());
+        g_assert(!this->green_curve->is_empty());
 
         /* Set up direction of next curve. */
         {
-            Geom::Curve const * last_seg = pc->green_curve->last_segment();
+            Geom::Curve const * last_seg = this->green_curve->last_segment();
             g_assert( last_seg );      // Relevance: validity of (*last_seg)
-            pc->p[0] = last_seg->finalPoint();
-            pc->npoints = 1;
+            this->p[0] = last_seg->finalPoint();
+            this->npoints = 1;
             Geom::Curve *last_seg_reverse = last_seg->reverse();
             Geom::Point const req_vec( -last_seg_reverse->unitTangentAt(0) );
             delete last_seg_reverse;
-            pc->req_tangent = ( ( Geom::is_zero(req_vec) || !in_svg_plane(req_vec) )
+            this->req_tangent = ( ( Geom::is_zero(req_vec) || !in_svg_plane(req_vec) )
                                 ? Geom::Point(0, 0)
                                 : Geom::unit_vector(req_vec) );
         }
     }
     g_free(b);
     g_free(points);
-    pc->ps.clear();
+    this->ps.clear();
 }
 
-static void
-fit_and_split(PencilTool *pc)
-{
-    g_assert( pc->npoints > 1 );
+void PencilTool::_fitAndSplit() {
+    g_assert( this->npoints > 1 );
 
     double const tolerance_sq = 0;
 
     Geom::Point b[4];
-    g_assert(is_zero(pc->req_tangent)
-             || is_unit_vector(pc->req_tangent));
+    g_assert(is_zero(this->req_tangent)
+             || is_unit_vector(this->req_tangent));
     Geom::Point const tHatEnd(0, 0);
-    int const n_segs = Geom::bezier_fit_cubic_full(b, NULL, pc->p, pc->npoints,
-                                                pc->req_tangent, tHatEnd,
+    int const n_segs = Geom::bezier_fit_cubic_full(b, NULL, this->p, this->npoints,
+                                                this->req_tangent, tHatEnd,
                                                 tolerance_sq, 1);
     if ( n_segs > 0
-         && unsigned(pc->npoints) < G_N_ELEMENTS(pc->p) )
+         && unsigned(this->npoints) < G_N_ELEMENTS(this->p) )
     {
         /* Fit and draw and reset state */
-        pc->red_curve->reset();
-        pc->red_curve->moveto(b[0]);
-        pc->red_curve->curveto(b[1], b[2], b[3]);
-        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(pc->red_bpath), pc->red_curve);
-        pc->red_curve_is_valid = true;
+        this->red_curve->reset();
+        this->red_curve->moveto(b[0]);
+        this->red_curve->curveto(b[1], b[2], b[3]);
+        sp_canvas_bpath_set_bpath(SP_CANVAS_BPATH(this->red_bpath), this->red_curve);
+        this->red_curve_is_valid = true;
     } else {
         /* Fit and draw and copy last point */
 
-        g_assert(!pc->red_curve->is_empty());
+        g_assert(!this->red_curve->is_empty());
 
         /* Set up direction of next curve. */
         {
-            Geom::Curve const * last_seg = pc->red_curve->last_segment();
+            Geom::Curve const * last_seg = this->red_curve->last_segment();
             g_assert( last_seg );      // Relevance: validity of (*last_seg)
-            pc->p[0] = last_seg->finalPoint();
-            pc->npoints = 1;
+            this->p[0] = last_seg->finalPoint();
+            this->npoints = 1;
             Geom::Curve *last_seg_reverse = last_seg->reverse();
             Geom::Point const req_vec( -last_seg_reverse->unitTangentAt(0) );
             delete last_seg_reverse;
-            pc->req_tangent = ( ( Geom::is_zero(req_vec) || !in_svg_plane(req_vec) )
+            this->req_tangent = ( ( Geom::is_zero(req_vec) || !in_svg_plane(req_vec) )
                                 ? Geom::Point(0, 0)
                                 : Geom::unit_vector(req_vec) );
         }
 
 
-        pc->green_curve->append_continuous(pc->red_curve, 0.0625);
-        SPCurve *curve = pc->red_curve->copy();
+        this->green_curve->append_continuous(this->red_curve, 0.0625);
+        SPCurve *curve = this->red_curve->copy();
 
         /// \todo fixme:
-        SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(pc->desktop), curve);
+        SPCanvasItem *cshape = sp_canvas_bpath_new(sp_desktop_sketch(this->desktop), curve);
         curve->unref();
-        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), pc->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
+        sp_canvas_bpath_set_stroke(SP_CANVAS_BPATH(cshape), this->green_color, 1.0, SP_STROKE_LINEJOIN_MITER, SP_STROKE_LINECAP_BUTT);
 
-        pc->green_bpaths = g_slist_prepend(pc->green_bpaths, cshape);
+        this->green_bpaths = g_slist_prepend(this->green_bpaths, cshape);
 
-        pc->red_curve_is_valid = false;
+        this->red_curve_is_valid = false;
     }
 }
 
diff --git a/src/ui/tools/pencil-tool.h b/src/ui/tools/pencil-tool.h
index 6ced9eb56..efc1f60e0 100644
--- a/src/ui/tools/pencil-tool.h
+++ b/src/ui/tools/pencil-tool.h
@@ -48,6 +48,24 @@ public:
 protected:
 	virtual void setup();
 	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);
+
+	void _setStartpoint(Geom::Point const &p);
+	void _setEndpoint(Geom::Point const &p);
+	void _finishEndpoint();
+	void _addFreehandPoint(Geom::Point const &p, guint state);
+	void _fitAndSplit();
+	void _interpolate();
+	void _sketchInterpolate();
+
+	void _cancel();
+	void _endpointSnap(Geom::Point &p, guint const state);
 };
 
 }
diff --git a/src/ui/tools/rect-tool.cpp b/src/ui/tools/rect-tool.cpp
index f5153e8ce..39f422c1a 100644
--- a/src/ui/tools/rect-tool.cpp
+++ b/src/ui/tools/rect-tool.cpp
@@ -235,7 +235,7 @@ bool RectTool::root_handler(GdkEvent* event) {
             this->drag(motion_dt, event->motion.state); // this will also handle the snapping
             gobble_motion_events(GDK_BUTTON1_MASK);
             ret = TRUE;
-        } else if (!sp_event_context_knot_mouseover(this)) {
+        } else if (!this->sp_event_context_knot_mouseover()) {
             SnapManager &m = desktop->namedview->snap_manager;
             m.setup(desktop);
 
diff --git a/src/ui/tools/spiral-tool.cpp b/src/ui/tools/spiral-tool.cpp
index 7d33b0f67..5ae229df8 100644
--- a/src/ui/tools/spiral-tool.cpp
+++ b/src/ui/tools/spiral-tool.cpp
@@ -209,7 +209,7 @@ bool SpiralTool::root_handler(GdkEvent* event) {
                 gobble_motion_events(GDK_BUTTON1_MASK);
 
                 ret = TRUE;
-            } else if (!sp_event_context_knot_mouseover(this)) {
+            } else if (!this->sp_event_context_knot_mouseover()) {
                 SnapManager &m = desktop->namedview->snap_manager;
                 m.setup(desktop);
                 Geom::Point const motion_w(event->motion.x, event->motion.y);
diff --git a/src/ui/tools/star-tool.cpp b/src/ui/tools/star-tool.cpp
index 42010788f..68f998920 100644
--- a/src/ui/tools/star-tool.cpp
+++ b/src/ui/tools/star-tool.cpp
@@ -218,7 +218,7 @@ bool StarTool::root_handler(GdkEvent* event) {
             gobble_motion_events(GDK_BUTTON1_MASK);
 
             ret = TRUE;
-        } else if (!sp_event_context_knot_mouseover(this)) {
+        } else if (!this->sp_event_context_knot_mouseover()) {
             SnapManager &m = desktop->namedview->snap_manager;
             m.setup(desktop);
 
diff --git a/src/ui/tools/text-tool.cpp b/src/ui/tools/text-tool.cpp
index 00f6a853c..4a171d1bd 100644
--- a/src/ui/tools/text-tool.cpp
+++ b/src/ui/tools/text-tool.cpp
@@ -602,7 +602,7 @@ bool TextTool::root_handler(GdkEvent* event) {
                 g_string_free(xs, FALSE);
                 g_string_free(ys, FALSE);
 
-            } else if (!sp_event_context_knot_mouseover(this)) {
+            } else if (!this->sp_event_context_knot_mouseover()) {
                 SnapManager &m = desktop->namedview->snap_manager;
                 m.setup(desktop);
 
diff --git a/src/ui/tools/tool-base.cpp b/src/ui/tools/tool-base.cpp
index 99b72c386..45b519fb4 100644
--- a/src/ui/tools/tool-base.cpp
+++ b/src/ui/tools/tool-base.cpp
@@ -143,9 +143,9 @@ ToolBase::~ToolBase() {
 /**
  * Set the cursor to a standard GDK cursor
  */
-static void sp_event_context_set_cursor(ToolBase *event_context, GdkCursorType cursor_type) {
+void ToolBase::sp_event_context_set_cursor(GdkCursorType cursor_type) {
 
-    GtkWidget *w = GTK_WIDGET(sp_desktop_canvas(event_context->desktop));
+    GtkWidget *w = GTK_WIDGET(sp_desktop_canvas(this->desktop));
     GdkDisplay *display = gdk_display_get_default();
     GdkCursor *cursor = gdk_cursor_new_for_display(display, cursor_type);
 
@@ -480,7 +480,7 @@ bool ToolBase::root_handler(GdkEvent* event) {
 
                 if (panning_cursor == 0) {
                     panning_cursor = 1;
-                    sp_event_context_set_cursor(this, GDK_FLEUR);
+                    this->sp_event_context_set_cursor(GDK_FLEUR);
                 }
 
                 Geom::Point const motion_w(event->motion.x, event->motion.y);
@@ -876,10 +876,9 @@ bool ToolBase::item_handler(SPItem* item, GdkEvent* event) {
 /**
  * Returns true if we're hovering above a knot (needed because we don't want to pre-snap in that case).
  */
-bool sp_event_context_knot_mouseover(ToolBase *ec)
-{
-    if (ec->shape_editor) {
-        return ec->shape_editor->knot_mouseover();
+bool ToolBase::sp_event_context_knot_mouseover() const {
+    if (this->shape_editor) {
+        return this->shape_editor->knot_mouseover();
     }
 
     return false;
diff --git a/src/ui/tools/tool-base.h b/src/ui/tools/tool-base.h
index 79bdfe89d..3a536fc2c 100644
--- a/src/ui/tools/tool-base.h
+++ b/src/ui/tools/tool-base.h
@@ -186,9 +186,14 @@ protected:
     /// The cursor's hot spot
     gint hot_x, hot_y;
 
+    bool sp_event_context_knot_mouseover() const;
+
 private:
 	ToolBase(const ToolBase&);
 	ToolBase& operator=(const ToolBase&);
+
+	void sp_event_context_set_cursor(GdkCursorType cursor_type);
+
 };
 
 void sp_event_context_read(ToolBase *ec, gchar const *key);
diff --git a/src/widgets/pencil-toolbar.cpp b/src/widgets/pencil-toolbar.cpp
index 7ad23bbbd..eb55f9219 100644
--- a/src/widgets/pencil-toolbar.cpp
+++ b/src/widgets/pencil-toolbar.cpp
@@ -112,7 +112,7 @@ static void freehand_mode_changed(EgeSelectOneAction* act, GObject* tbl)
 
     if (Tool::is_a<PenTool>(desktop->event_context)) {
         PenTool* pc = Tool::to<PenTool>(desktop->event_context);
-        sp_pen_context_set_polyline_mode(pc);
+        pc->setPolylineMode();
     }
 }