Cleaned up a bit.

(bzr r11608.1.102)

1 files changed, 121 insertions, 159 deletions

diff --git a/src/arc-context.cpp b/src/arc-context.cpp
index bb24cba28..5851df26f 100644
--- a/src/arc-context.cpp
+++ b/src/arc-context.cpp
@@ -49,11 +49,6 @@
 
 using Inkscape::DocumentUndo;
 
-static void sp_arc_drag(SPArcContext *ec, Geom::Point pt, guint state);
-static void sp_arc_finish(SPArcContext *ec);
-static void sp_arc_cancel(SPArcContext *ec);
-
-
 #include "tool-factory.h"
 
 namespace {
@@ -72,124 +67,89 @@ const std::string SPArcContext::prefsPath = "/tools/shapes/arc";
 
 
 SPArcContext::SPArcContext() : SPEventContext() {
-	SPArcContext* arc_context = this;
-
-	arc_context->_message_context = 0;
-
-    SPEventContext *event_context = SP_EVENT_CONTEXT(arc_context);
-
-    event_context->cursor_shape = cursor_ellipse_xpm;
-    event_context->hot_x = 4;
-    event_context->hot_y = 4;
-    event_context->xp = 0;
-    event_context->yp = 0;
-    event_context->tolerance = 0;
-    event_context->within_tolerance = false;
-    event_context->item_to_select = NULL;
-    event_context->tool_url = "/tools/shapes/arc";
-
-    arc_context->item = NULL;
-
-    //new (&arc_context->sel_changed_connection) sigc::connection();
+	this->_message_context = 0;
+    this->cursor_shape = cursor_ellipse_xpm;
+    this->hot_x = 4;
+    this->hot_y = 4;
+    this->xp = 0;
+    this->yp = 0;
+    this->tolerance = 0;
+    this->within_tolerance = false;
+    this->item_to_select = NULL;
+    this->tool_url = "/tools/shapes/arc";
+
+    this->arc = NULL;
 }
 
 void SPArcContext::finish() {
-	SPEventContext* ec = this;
-
-    SPArcContext *ac = SP_ARC_CONTEXT(ec);
-    SPDesktop *desktop = ec->desktop;
-
     sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), GDK_CURRENT_TIME);
-    sp_arc_finish(ac);
-    ac->sel_changed_connection.disconnect();
+    this->finishItem();
+    this->sel_changed_connection.disconnect();
 
-//    if ((SP_EVENT_CONTEXT_CLASS(sp_arc_context_parent_class))->finish) {
-//        (SP_EVENT_CONTEXT_CLASS(sp_arc_context_parent_class))->finish(ec);
-//    }
     SPEventContext::finish();
 }
 
 SPArcContext::~SPArcContext() {
-    SPEventContext *ec = SP_EVENT_CONTEXT(this);
-    SPArcContext *ac = SP_ARC_CONTEXT(this);
-
-    ec->enableGrDrag(false);
+    this->enableGrDrag(false);
 
-    ac->sel_changed_connection.disconnect();
-    //ac->sel_changed_connection.~connection();
+    this->sel_changed_connection.disconnect();
 
-    delete ec->shape_editor;
-    ec->shape_editor = NULL;
+    delete this->shape_editor;
+    this->shape_editor = NULL;
 
     /* fixme: This is necessary because we do not grab */
-    if (ac->item) {
-        sp_arc_finish(ac);
+    if (this->arc) {
+        this->finishItem();
     }
 
-    delete ac->_message_context;
-
-    //G_OBJECT_CLASS(sp_arc_context_parent_class)->dispose(object);
+    delete this->_message_context;
 }
 
 /**
  * Callback that processes the "changed" signal on the selection;
  * destroys old and creates new knotholder.
  */
-static void sp_arc_context_selection_changed(Inkscape::Selection * selection, gpointer data)
-{
-    SPArcContext *ac = SP_ARC_CONTEXT(data);
-    SPEventContext *ec = SP_EVENT_CONTEXT(ac);
-
-    ec->shape_editor->unset_item(SH_KNOTHOLDER);
-    SPItem *item = selection->singleItem();
-    ec->shape_editor->set_item(item, SH_KNOTHOLDER);
+void SPArcContext::selection_changed(Inkscape::Selection* selection) {
+    this->shape_editor->unset_item(SH_KNOTHOLDER);
+    this->shape_editor->set_item(selection->singleItem(), SH_KNOTHOLDER);
 }
 
 void SPArcContext::setup() {
-	SPEventContext* ec = this;
-
-    SPArcContext *ac = SP_ARC_CONTEXT(ec);
-    Inkscape::Selection *selection = sp_desktop_selection(ec->desktop);
-
-//    if ((SP_EVENT_CONTEXT_CLASS(sp_arc_context_parent_class))->setup) {
-//        (SP_EVENT_CONTEXT_CLASS(sp_arc_context_parent_class))->setup(ec);
-//    }
     SPEventContext::setup();
 
-    ec->shape_editor = new ShapeEditor(ec->desktop);
+    Inkscape::Selection *selection = sp_desktop_selection(this->desktop);
 
-    SPItem *item = sp_desktop_selection(ec->desktop)->singleItem();
+    this->shape_editor = new ShapeEditor(this->desktop);
+
+    SPItem *item = sp_desktop_selection(this->desktop)->singleItem();
     if (item) {
-        ec->shape_editor->set_item(item, SH_KNOTHOLDER);
+        this->shape_editor->set_item(item, SH_KNOTHOLDER);
     }
 
-    ac->sel_changed_connection.disconnect();
-    ac->sel_changed_connection = selection->connectChanged(
-        sigc::bind(sigc::ptr_fun(&sp_arc_context_selection_changed), (gpointer) ac)
-        );
+    this->sel_changed_connection.disconnect();
+    this->sel_changed_connection = selection->connectChanged(
+        sigc::mem_fun(this, &SPArcContext::selection_changed)
+    );
 
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
     if (prefs->getBool("/tools/shapes/selcue")) {
-        ec->enableSelectionCue();
+        this->enableSelectionCue();
     }
 
     if (prefs->getBool("/tools/shapes/gradientdrag")) {
-        ec->enableGrDrag();
+        this->enableGrDrag();
     }
 
-    ac->_message_context = new Inkscape::MessageContext(ec->desktop->messageStack());
+    this->_message_context = new Inkscape::MessageContext(this->desktop->messageStack());
 }
 
 gint SPArcContext::item_handler(SPItem* item, GdkEvent* event) {
-	SPEventContext* event_context = this;
-
-    SPDesktop *desktop = event_context->desktop;
     gint ret = FALSE;
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
-            if (event->button.button == 1 && !event_context->space_panning) {
-                Inkscape::setup_for_drag_start(desktop, event_context, event);
+            if (event->button.button == 1 && !this->space_panning) {
+                Inkscape::setup_for_drag_start(desktop, this, event);
                 ret = TRUE;
             }
             break;
@@ -208,30 +168,26 @@ gint SPArcContext::item_handler(SPItem* item, GdkEvent* event) {
 }
 
 gint SPArcContext::root_handler(GdkEvent* event) {
-	SPEventContext* event_context = this;
-
     static bool dragging;
 
-    SPDesktop *desktop = event_context->desktop;
     Inkscape::Selection *selection = sp_desktop_selection(desktop);
-    SPArcContext *ac = SP_ARC_CONTEXT(event_context);
     Inkscape::Preferences *prefs = Inkscape::Preferences::get();
 
-    event_context->tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
+    this->tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
 
     gint ret = FALSE;
 
     switch (event->type) {
         case GDK_BUTTON_PRESS:
-            if (event->button.button == 1 && !event_context->space_panning) {
-
+            if (event->button.button == 1 && !this->space_panning) {
                 dragging = true;
-                ac->center = Inkscape::setup_for_drag_start(desktop, event_context, event);
+
+                this->center = Inkscape::setup_for_drag_start(desktop, this, event);
 
                 /* Snap center */
                 SnapManager &m = desktop->namedview->snap_manager;
                 m.setup(desktop);
-                m.freeSnapReturnByRef(ac->center, Inkscape::SNAPSOURCE_NODE_HANDLE);
+                m.freeSnapReturnByRef(this->center, Inkscape::SNAPSOURCE_NODE_HANDLE);
 
                 sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
                                     GDK_KEY_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
@@ -242,27 +198,26 @@ gint SPArcContext::root_handler(GdkEvent* event) {
             }
             break;
         case GDK_MOTION_NOTIFY:
-            if (dragging && (event->motion.state & GDK_BUTTON1_MASK) && !event_context->space_panning) {
-
-                if ( event_context->within_tolerance
-                     && ( abs( (gint) event->motion.x - event_context->xp ) < event_context->tolerance )
-                     && ( abs( (gint) event->motion.y - event_context->yp ) < event_context->tolerance ) ) {
+            if (dragging && (event->motion.state & GDK_BUTTON1_MASK) && !this->space_panning) {
+                if ( this->within_tolerance
+                     && ( abs( (gint) event->motion.x - this->xp ) < this->tolerance )
+                     && ( abs( (gint) event->motion.y - this->yp ) < this->tolerance ) ) {
                     break; // 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 draw, not click), then always process the
                 // motion notify coordinates as given (no snapping back to origin)
-                event_context->within_tolerance = false;
+                this->within_tolerance = false;
 
                 Geom::Point const motion_w(event->motion.x, event->motion.y);
                 Geom::Point motion_dt(desktop->w2d(motion_w));
 
-                sp_arc_drag(ac, motion_dt, event->motion.state);
+                this->drag(motion_dt, event->motion.state);
 
                 gobble_motion_events(GDK_BUTTON1_MASK);
 
                 ret = TRUE;
-            } else if (!sp_event_context_knot_mouseover(ac)){
+            } else if (!sp_event_context_knot_mouseover(this)){
                 SnapManager &m = desktop->namedview->snap_manager;
                 m.setup(desktop);
 
@@ -273,31 +228,34 @@ gint SPArcContext::root_handler(GdkEvent* event) {
             }
             break;
         case GDK_BUTTON_RELEASE:
-            event_context->xp = event_context->yp = 0;
-            if (event->button.button == 1 && !event_context->space_panning) {
+            this->xp = this->yp = 0;
+            if (event->button.button == 1 && !this->space_panning) {
                 dragging = false;
-                sp_event_context_discard_delayed_snap_event(event_context);
-                if (!event_context->within_tolerance) {
+                sp_event_context_discard_delayed_snap_event(this);
+
+                if (!this->within_tolerance) {
                     // we've been dragging, finish the arc
-                       sp_arc_finish(ac);
-                } else if (event_context->item_to_select) {
+                    this->finishItem();
+                } else if (this->item_to_select) {
                     // no dragging, select clicked item if any
                     if (event->button.state & GDK_SHIFT_MASK) {
-                        selection->toggle(event_context->item_to_select);
+                        selection->toggle(this->item_to_select);
                     } else {
-                        selection->set(event_context->item_to_select);
+                        selection->set(this->item_to_select);
                     }
                 } else {
                     // click in an empty space
                     selection->clear();
                 }
-                event_context->xp = 0;
-                event_context->yp = 0;
-                event_context->item_to_select = NULL;
+
+                this->xp = 0;
+                this->yp = 0;
+                this->item_to_select = NULL;
                 ret = TRUE;
             }
             sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), event->button.time);
             break;
+
         case GDK_KEY_PRESS:
             switch (get_group0_keyval (&event->key)) {
                 case GDK_KEY_Alt_L:
@@ -309,12 +267,13 @@ gint SPArcContext::root_handler(GdkEvent* event) {
                 case GDK_KEY_Meta_L:  // Meta is when you press Shift+Alt (at least on my machine)
                 case GDK_KEY_Meta_R:
                     if (!dragging) {
-                        sp_event_show_modifier_tip(event_context->defaultMessageContext(), event,
+                        sp_event_show_modifier_tip(this->defaultMessageContext(), event,
                                                    _("<b>Ctrl</b>: make circle or integer-ratio ellipse, snap arc/segment angle"),
                                                    _("<b>Shift</b>: draw around the starting point"),
                                                    NULL);
                     }
                     break;
+
                 case GDK_KEY_Up:
                 case GDK_KEY_Down:
                 case GDK_KEY_KP_Up:
@@ -323,6 +282,7 @@ gint SPArcContext::root_handler(GdkEvent* event) {
                     if (!MOD__CTRL_ONLY)
                         ret = TRUE;
                     break;
+
                 case GDK_KEY_x:
                 case GDK_KEY_X:
                     if (MOD__ALT_ONLY) {
@@ -330,38 +290,42 @@ gint SPArcContext::root_handler(GdkEvent* event) {
                         ret = TRUE;
                     }
                     break;
+
                 case GDK_KEY_Escape:
                     if (dragging) {
                         dragging = false;
-                        sp_event_context_discard_delayed_snap_event(event_context);
+                        sp_event_context_discard_delayed_snap_event(this);
                         // if drawing, cancel, otherwise pass it up for deselecting
-                        sp_arc_cancel(ac);
+                        this->cancel();
                         ret = TRUE;
                     }
                     break;
+
                 case GDK_KEY_space:
                     if (dragging) {
-                        sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
-                                              event->button.time);
+                        sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), event->button.time);
                         dragging = false;
-                        sp_event_context_discard_delayed_snap_event(event_context);
-                        if (!event_context->within_tolerance) {
+                        sp_event_context_discard_delayed_snap_event(this);
+
+                        if (!this->within_tolerance) {
                             // we've been dragging, finish the arc
-                            sp_arc_finish(ac);
+                            this->finishItem();
                         }
                         // do not return true, so that space would work switching to selector
                     }
                     break;
+
                 case GDK_KEY_Delete:
                 case GDK_KEY_KP_Delete:
                 case GDK_KEY_BackSpace:
-                    ret = event_context->deleteSelectedDrag(MOD__CTRL_ONLY);
+                    ret = this->deleteSelectedDrag(MOD__CTRL_ONLY);
                     break;
 
                 default:
                     break;
             }
             break;
+
         case GDK_KEY_RELEASE:
             switch (event->key.keyval) {
                 case GDK_KEY_Alt_L:
@@ -372,33 +336,28 @@ gint SPArcContext::root_handler(GdkEvent* event) {
                 case GDK_KEY_Shift_R:
                 case GDK_KEY_Meta_L:  // Meta is when you press Shift+Alt
                 case GDK_KEY_Meta_R:
-                    event_context->defaultMessageContext()->clear();
+                    this->defaultMessageContext()->clear();
                     break;
+
                 default:
                     break;
             }
             break;
+
         default:
             break;
     }
 
     if (!ret) {
-//        if ((SP_EVENT_CONTEXT_CLASS(sp_arc_context_parent_class))->root_handler) {
-//            ret = (SP_EVENT_CONTEXT_CLASS(sp_arc_context_parent_class))->root_handler(event_context, event);
-//        }
     	ret = SPEventContext::root_handler(event);
     }
 
     return ret;
 }
 
-static void sp_arc_drag(SPArcContext *ac, Geom::Point pt, guint state)
-{
-    SPDesktop *desktop = SP_EVENT_CONTEXT(ac)->desktop;
-
-    if (!ac->item) {
-
-        if (Inkscape::have_viable_layer(desktop, ac->_message_context) == false) {
+void SPArcContext::drag(Geom::Point pt, guint state) {
+    if (!this->arc) {
+        if (Inkscape::have_viable_layer(desktop, this->_message_context) == false) {
             return;
         }
 
@@ -410,33 +369,38 @@ static void sp_arc_drag(SPArcContext *ac, Geom::Point pt, guint state)
         // Set style
         sp_desktop_apply_style_tool(desktop, repr, "/tools/shapes/arc", false);
 
-        ac->item = SP_ITEM(desktop->currentLayer()->appendChildRepr(repr));
+        this->arc = SP_ARC(desktop->currentLayer()->appendChildRepr(repr));
         Inkscape::GC::release(repr);
-        ac->item->transform = SP_ITEM(desktop->currentLayer())->i2doc_affine().inverse();
-        ac->item->updateRepr();
+        this->arc->transform = SP_ITEM(desktop->currentLayer())->i2doc_affine().inverse();
+        this->arc->updateRepr();
 
         desktop->canvas->forceFullRedrawAfterInterruptions(5);
     }
 
     bool ctrl_save = false;
+
     if ((state & GDK_MOD1_MASK) && (state & GDK_CONTROL_MASK) && !(state & GDK_SHIFT_MASK)) {
         // if Alt is pressed without Shift in addition to Control, temporarily drop the CONTROL mask
         // so that the ellipse is not constrained to integer ratios
         ctrl_save = true;
         state = state ^ GDK_CONTROL_MASK;
     }
-    Geom::Rect r = Inkscape::snap_rectangular_box(desktop, ac->item, pt, ac->center, state);
+
+    Geom::Rect r = Inkscape::snap_rectangular_box(desktop, this->arc, pt, this->center, state);
+
     if (ctrl_save) {
         state = state ^ GDK_CONTROL_MASK;
     }
 
     Geom::Point dir = r.dimensions() / 2;
+
     if (state & GDK_MOD1_MASK) {
         /* With Alt let the ellipse pass through the mouse pointer */
         Geom::Point c = r.midpoint();
+
         if (!ctrl_save) {
             if (fabs(dir[Geom::X]) > 1E-6 && fabs(dir[Geom::Y]) > 1E-6) {
-                Geom::Affine const i2d ( (ac->item)->i2dt_affine() );
+                Geom::Affine const i2d ( (this->arc)->i2dt_affine() );
                 Geom::Point new_dir = pt * i2d - c;
                 new_dir[Geom::X] *= dir[Geom::Y] / dir[Geom::X];
                 double lambda = new_dir.length() / dir[Geom::Y];
@@ -451,7 +415,7 @@ static void sp_arc_drag(SPArcContext *ac, Geom::Point pt, guint state)
         }
     }
 
-    sp_arc_position_set(SP_ARC(ac->item),
+    sp_arc_position_set(SP_ARC(this->arc),
                         r.midpoint()[Geom::X], r.midpoint()[Geom::Y],
                         r.dimensions()[Geom::X] / 2, r.dimensions()[Geom::Y] / 2);
 
@@ -459,8 +423,10 @@ static void sp_arc_drag(SPArcContext *ac, Geom::Point pt, guint state)
     double rdimy = r.dimensions()[Geom::Y];
     GString *xs = SP_PX_TO_METRIC_STRING(rdimx, desktop->namedview->getDefaultMetric());
     GString *ys = SP_PX_TO_METRIC_STRING(rdimy, desktop->namedview->getDefaultMetric());
+
     if (state & GDK_CONTROL_MASK) {
         int ratio_x, ratio_y;
+
         if (fabs (rdimx) > fabs (rdimy)) {
             ratio_x = (int) rint (rdimx / rdimy);
             ratio_y = 1;
@@ -468,56 +434,52 @@ static void sp_arc_drag(SPArcContext *ac, Geom::Point pt, guint state)
             ratio_x = 1;
             ratio_y = (int) rint (rdimy / rdimx);
         }
-        ac->_message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Ellipse</b>: %s &#215; %s (constrained to ratio %d:%d); with <b>Shift</b> to draw around the starting point"), xs->str, ys->str, ratio_x, ratio_y);
+
+        this->_message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Ellipse</b>: %s &#215; %s (constrained to ratio %d:%d); with <b>Shift</b> to draw around the starting point"), xs->str, ys->str, ratio_x, ratio_y);
     } else {
-        ac->_message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Ellipse</b>: %s &#215; %s; with <b>Ctrl</b> to make square or integer-ratio ellipse; with <b>Shift</b> to draw around the starting point"), xs->str, ys->str);
+        this->_message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Ellipse</b>: %s &#215; %s; with <b>Ctrl</b> to make square or integer-ratio ellipse; with <b>Shift</b> to draw around the starting point"), xs->str, ys->str);
     }
+
     g_string_free(xs, FALSE);
     g_string_free(ys, FALSE);
 }
 
-static void sp_arc_finish(SPArcContext *ac)
-{
-    ac->_message_context->clear();
-
-    if (ac->item != NULL) {
+void SPArcContext::finishItem() {
+    this->_message_context->clear();
 
-        SPGenericEllipse *ge = SP_GENERICELLIPSE(SP_ARC(ac->item));
-        if (ge->rx.computed == 0 || ge->ry.computed == 0) {
-            sp_arc_cancel(ac); // Don't allow the creating of zero sized arc, for example when the start and and point snap to the snap grid point
+    if (this->arc != NULL) {
+        if (this->arc->rx.computed == 0 || this->arc->ry.computed == 0) {
+            this->cancel(); // Don't allow the creating of zero sized arc, for example when the start and and point snap to the snap grid point
             return;
         }
 
-        SPDesktop *desktop = SP_EVENT_CONTEXT(ac)->desktop;
+        SPDesktop *desktop = SP_EVENT_CONTEXT(this)->desktop;
 
-        SP_OBJECT(ac->item)->updateRepr();
+        this->arc->updateRepr();
 
         desktop->canvas->endForcedFullRedraws();
 
-        sp_desktop_selection(desktop)->set(ac->item);
-		DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_CONTEXT_ARC,
-                         _("Create ellipse"));
+        sp_desktop_selection(desktop)->set(this->arc);
 
-        ac->item = NULL;
+		DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_CONTEXT_ARC, _("Create ellipse"));
+
+        this->arc = NULL;
     }
 }
 
-static void sp_arc_cancel(SPArcContext *ac)
-{
-    SPDesktop *desktop = SP_EVENT_CONTEXT(ac)->desktop;
-
+void SPArcContext::cancel() {
     sp_desktop_selection(desktop)->clear();
     sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), 0);
 
-    if (ac->item != NULL) {
-        SP_OBJECT(ac->item)->deleteObject();
-        ac->item = NULL;
+    if (this->arc != NULL) {
+        this->arc->deleteObject();
+        this->arc = NULL;
     }
 
-    ac->within_tolerance = false;
-    ac->xp = 0;
-    ac->yp = 0;
-    ac->item_to_select = NULL;
+    this->within_tolerance = false;
+    this->xp = 0;
+    this->yp = 0;
+    this->item_to_select = NULL;
 
     desktop->canvas->endForcedFullRedraws();