Some refactoring in RectContext and StarContext.

(bzr r11608.1.101)

1 files changed, 134 insertions, 181 deletions

diff --git a/src/rect-context.cpp b/src/rect-context.cpp
index b61446b34..3b1169017 100644
--- a/src/rect-context.cpp
+++ b/src/rect-context.cpp
@@ -61,157 +61,116 @@ const std::string& SPRectContext::getPrefsPath() {
 	return SPRectContext::prefsPath;
 }
 
-//static const double goldenratio = 1.61803398874989484820; // golden ratio
-
-static void sp_rect_drag(SPRectContext &rc, Geom::Point const pt, guint state);
-static void sp_rect_finish(SPRectContext *rc);
-static void sp_rect_cancel(SPRectContext *rc);
-
-
 const std::string SPRectContext::prefsPath = "/tools/shapes/rect";
 
 SPRectContext::SPRectContext() : SPEventContext() {
-	SPRectContext* rect_context = this;
-
-    SPEventContext *event_context = SP_EVENT_CONTEXT(rect_context);
-
-    rect_context->_message_context = 0;
-
-    event_context->cursor_shape = cursor_rect_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/rect";
-
-    rect_context->item = NULL;
-
-    rect_context->rx = 0.0;
-    rect_context->ry = 0.0;
-
-    //new (&rect_context->sel_changed_connection) sigc::connection();
+    this->_message_context = 0;
+
+    this->cursor_shape = cursor_rect_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/rect";
+
+    this->rect = NULL;
+
+    this->rx = 0.0;
+    this->ry = 0.0;
 }
 
 void SPRectContext::finish() {
-	SPEventContext* ec = this;
-
-    SPRectContext *rc = SP_RECT_CONTEXT(ec);
-    SPDesktop *desktop = ec->desktop;
+    SPDesktop *desktop = this->desktop;
 
     sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), GDK_CURRENT_TIME);
-    sp_rect_finish(rc);
-    rc->sel_changed_connection.disconnect();
+    
+    this->finishItem();
+    this->sel_changed_connection.disconnect();
 
-//    if (((SPEventContextClass *) sp_rect_context_parent_class)->finish) {
-//        ((SPEventContextClass *) sp_rect_context_parent_class)->finish(ec);
-//    }
     SPEventContext::finish();
 }
 
 SPRectContext::~SPRectContext() {
-    SPRectContext *rc = SP_RECT_CONTEXT(this);
-    SPEventContext *ec = SP_EVENT_CONTEXT(this);
-
-    ec->enableGrDrag(false);
+    this->enableGrDrag(false);
 
-    rc->sel_changed_connection.disconnect();
-    //rc->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 (rc->item) {
-        sp_rect_finish(rc);
+    if (this->rect) {
+        this->finishItem();
     }
 
-    if (rc->_message_context) {
-        delete rc->_message_context;
+    if (this->_message_context) {
+        delete this->_message_context;
     }
-
-    //G_OBJECT_CLASS(sp_rect_context_parent_class)->dispose(object);
 }
 
 /**
  * Callback that processes the "changed" signal on the selection;
  * destroys old and creates new knotholder.
  */
-static void sp_rect_context_selection_changed(Inkscape::Selection *selection, gpointer data)
-{
-    SPRectContext *rc = SP_RECT_CONTEXT(data);
-    SPEventContext *ec = SP_EVENT_CONTEXT(rc);
-
-    ec->shape_editor->unset_item(SH_KNOTHOLDER);
-    SPItem *item = selection->singleItem();
-    ec->shape_editor->set_item(item, SH_KNOTHOLDER);
+void SPRectContext::selection_changed(Inkscape::Selection* selection) {
+    this->shape_editor->unset_item(SH_KNOTHOLDER);
+    this->shape_editor->set_item(selection->singleItem(), SH_KNOTHOLDER);
 }
 
 void SPRectContext::setup() {
-	SPRectContext* ec = this;
-
-    SPRectContext *rc = SP_RECT_CONTEXT(ec);
-
-//    if (((SPEventContextClass *) sp_rect_context_parent_class)->setup) {
-//        ((SPEventContextClass *) sp_rect_context_parent_class)->setup(ec);
-//    }
     SPEventContext::setup();
 
-    ec->shape_editor = new ShapeEditor(ec->desktop);
+    this->shape_editor = new ShapeEditor(this->desktop);
 
-    SPItem *item = sp_desktop_selection(ec->desktop)->singleItem();
+    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);
     }
 
-    rc->sel_changed_connection.disconnect();
-    rc->sel_changed_connection = sp_desktop_selection(ec->desktop)->connectChanged(
-        sigc::bind(sigc::ptr_fun(&sp_rect_context_selection_changed), (gpointer)rc)
+    this->sel_changed_connection.disconnect();
+    this->sel_changed_connection = sp_desktop_selection(this->desktop)->connectChanged(
+    	sigc::mem_fun(this, &SPRectContext::selection_changed)
     );
 
-    sp_event_context_read(ec, "rx");
-    sp_event_context_read(ec, "ry");
+    sp_event_context_read(this, "rx");
+    sp_event_context_read(this, "ry");
 
     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();
     }
 
-    rc->_message_context = new Inkscape::MessageContext((ec->desktop)->messageStack());
+    this->_message_context = new Inkscape::MessageContext(this->desktop->messageStack());
 }
 
 void SPRectContext::set(Inkscape::Preferences::Entry* val) {
-	SPEventContext* ec = this;
-
-    SPRectContext *rc = SP_RECT_CONTEXT(ec);
-
     /* fixme: Proper error handling for non-numeric data.  Use a locale-independent function like
      * g_ascii_strtod (or a thin wrapper that does the right thing for invalid values inf/nan). */
     Glib::ustring name = val->getEntryName();
+    
     if ( name == "rx" ) {
-        rc->rx = val->getDoubleLimited(); // prevents NaN and +/-Inf from messing up
+        this->rx = val->getDoubleLimited(); // prevents NaN and +/-Inf from messing up
     } else if ( name == "ry" ) {
-        rc->ry = val->getDoubleLimited();
+        this->ry = val->getDoubleLimited();
     }
 }
 
 gint SPRectContext::item_handler(SPItem* item, GdkEvent* event) {
-	SPEventContext* event_context = this;
-
-    SPDesktop *desktop = event_context->desktop;
+    SPDesktop *desktop = this->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;
@@ -230,45 +189,42 @@ gint SPRectContext::item_handler(SPItem* item, GdkEvent* event) {
 }
 
 gint SPRectContext::root_handler(GdkEvent* event) {
-	SPEventContext* event_context = this;
-
     static bool dragging;
 
-    SPDesktop *desktop = event_context->desktop;
+    SPDesktop *desktop = this->desktop;
     Inkscape::Selection *selection = sp_desktop_selection (desktop);
 
-    SPRectContext *rc = SP_RECT_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) {
-            Geom::Point const button_w(event->button.x,
-                                     event->button.y);
+        if (event->button.button == 1 && !this->space_panning) {
+            Geom::Point const button_w(event->button.x, event->button.y);
 
             // save drag origin
-            event_context->xp = (gint) button_w[Geom::X];
-            event_context->yp = (gint) button_w[Geom::Y];
-            event_context->within_tolerance = true;
+            this->xp = (gint) button_w[Geom::X];
+            this->yp = (gint) button_w[Geom::Y];
+            this->within_tolerance = true;
 
             // remember clicked item, disregarding groups, honoring Alt
-            event_context->item_to_select = sp_event_context_find_item (desktop, button_w, event->button.state & GDK_MOD1_MASK, TRUE);
+            this->item_to_select = sp_event_context_find_item (desktop, button_w, event->button.state & GDK_MOD1_MASK, TRUE);
 
             dragging = true;
 
             /* Position center */
             Geom::Point button_dt(desktop->w2d(button_w));
-            rc->center = button_dt;
+            this->center = button_dt;
 
             /* Snap center */
             SnapManager &m = desktop->namedview->snap_manager;
             m.setup(desktop);
             m.freeSnapReturnByRef(button_dt, Inkscape::SNAPSOURCE_NODE_HANDLE);
             m.unSetup();
-            rc->center = button_dt;
+            this->center = button_dt;
 
             sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
                                 ( GDK_KEY_PRESS_MASK |
@@ -283,25 +239,25 @@ gint SPRectContext::root_handler(GdkEvent* event) {
         break;
     case GDK_MOTION_NOTIFY:
         if ( dragging
-             && (event->motion.state & GDK_BUTTON1_MASK) && !event_context->space_panning)
+             && (event->motion.state & GDK_BUTTON1_MASK) && !this->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 ( 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_rect_drag(*rc, motion_dt, event->motion.state); // this will also handle the snapping
+            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(rc)) {
+        } else if (!sp_event_context_knot_mouseover(this)) {
             SnapManager &m = desktop->namedview->snap_manager;
             m.setup(desktop);
 
@@ -313,27 +269,27 @@ gint SPRectContext::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);
+            sp_event_context_discard_delayed_snap_event(this);
 
-            if (!event_context->within_tolerance) {
+            if (!this->within_tolerance) {
                 // we've been dragging, finish the rect
-                sp_rect_finish(rc);
-            } 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->item_to_select = NULL;
+            this->item_to_select = NULL;
             ret = TRUE;
             sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
                                   event->button.time);
@@ -350,7 +306,7 @@ gint SPRectContext::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 square or integer-ratio rect, lock a rounded corner circular"),
                                             _("<b>Shift</b>: draw around the starting point"),
                                             NULL);
@@ -384,9 +340,9 @@ gint SPRectContext::root_handler(GdkEvent* event) {
         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_rect_cancel(rc);
+                this->cancel();
                 ret = TRUE;
             }
             break;
@@ -396,10 +352,11 @@ gint SPRectContext::root_handler(GdkEvent* event) {
                 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 rect
-                    sp_rect_finish(rc);
+                    this->finishItem();
                 }
                 // do not return true, so that space would work switching to selector
             }
@@ -408,7 +365,7 @@ gint SPRectContext::root_handler(GdkEvent* event) {
         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:
@@ -425,7 +382,7 @@ gint SPRectContext::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;
@@ -436,137 +393,133 @@ gint SPRectContext::root_handler(GdkEvent* event) {
     }
 
     if (!ret) {
-//        if (((SPEventContextClass *) sp_rect_context_parent_class)->root_handler) {
-//            ret = ((SPEventContextClass *) sp_rect_context_parent_class)->root_handler(event_context, event);
-//        }
     	ret = SPEventContext::root_handler(event);
     }
 
     return ret;
 }
 
-static void sp_rect_drag(SPRectContext &rc, Geom::Point const pt, guint state)
-{
-    SPDesktop *desktop = SP_EVENT_CONTEXT(&rc)->desktop;
-
-    if (!rc.item) {
+void SPRectContext::drag(Geom::Point const pt, guint state) {
+    SPDesktop *desktop = this->desktop;
 
-        if (Inkscape::have_viable_layer(desktop, rc._message_context) == false) {
+    if (!this->rect) {
+        if (Inkscape::have_viable_layer(desktop, this->_message_context) == false) {
             return;
         }
 
         // Create object
-        Inkscape::XML::Document *xml_doc = SP_EVENT_CONTEXT_DOCUMENT(&rc)->getReprDoc();
+        Inkscape::XML::Document *xml_doc = this->desktop->doc()->getReprDoc();
         Inkscape::XML::Node *repr = xml_doc->createElement("svg:rect");
 
         // Set style
         sp_desktop_apply_style_tool (desktop, repr, "/tools/shapes/rect", false);
 
-        rc.item = (SPItem *) desktop->currentLayer()->appendChildRepr(repr);
+        this->rect = SP_RECT(desktop->currentLayer()->appendChildRepr(repr));
         Inkscape::GC::release(repr);
-        rc.item->transform = SP_ITEM(desktop->currentLayer())->i2doc_affine().inverse();
-        rc.item->updateRepr();
+
+        this->rect->transform = SP_ITEM(desktop->currentLayer())->i2doc_affine().inverse();
+        this->rect->updateRepr();
 
         desktop->canvas->forceFullRedrawAfterInterruptions(5);
     }
 
-    Geom::Rect const r = Inkscape::snap_rectangular_box(desktop, rc.item, pt, rc.center, state);
+    Geom::Rect const r = Inkscape::snap_rectangular_box(desktop, this->rect, pt, this->center, state);
 
-    SP_RECT(rc.item)->setPosition(r.min()[Geom::X], r.min()[Geom::Y], r.dimensions()[Geom::X], r.dimensions()[Geom::Y]);
+    this->rect->setPosition(r.min()[Geom::X], r.min()[Geom::Y], r.dimensions()[Geom::X], r.dimensions()[Geom::Y]);
 
-    if ( rc.rx != 0.0 ) {
-    	SP_RECT(rc.item)->setRx(true, rc.rx);
+    if (this->rx != 0.0) {
+    	this->rect->setRx(true, this->rx);
     }
 
-    if ( rc.ry != 0.0 ) {
-        if (rc.rx == 0.0)
-        	SP_RECT(rc.item)->setRy(true, CLAMP(rc.ry, 0, MIN(r.dimensions()[Geom::X], r.dimensions()[Geom::Y])/2));
+    if (this->ry != 0.0) {
+        if (this->rx == 0.0)
+        	this->rect->setRy(true, CLAMP(this->ry, 0, MIN(r.dimensions()[Geom::X], r.dimensions()[Geom::Y])/2));
         else
-        	SP_RECT(rc.item)->setRy(true, CLAMP(rc.ry, 0, r.dimensions()[Geom::Y]));
+        	this->rect->setRy(true, CLAMP(this->ry, 0, r.dimensions()[Geom::Y]));
     }
 
     // status text
     double rdimx = r.dimensions()[Geom::X];
     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;
         bool is_golden_ratio = false;
+
         if (fabs (rdimx) > fabs (rdimy)) {
             if (fabs(rdimx / rdimy - goldenratio) < 1e-6) {
                 is_golden_ratio = true;
             }
+
             ratio_x = (int) rint (rdimx / rdimy);
             ratio_y = 1;
         } else {
             if (fabs(rdimy / rdimx - goldenratio) < 1e-6) {
                 is_golden_ratio = true;
             }
+
             ratio_x = 1;
             ratio_y = (int) rint (rdimy / rdimx);
         }
+
         if (!is_golden_ratio) {
-            rc._message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Rectangle</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>Rectangle</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 {
             if (ratio_y == 1) {
-                rc._message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Rectangle</b>: %s &#215; %s (constrained to golden ratio 1.618 : 1); with <b>Shift</b> to draw around the starting point"), xs->str, ys->str);
+                this->_message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Rectangle</b>: %s &#215; %s (constrained to golden ratio 1.618 : 1); with <b>Shift</b> to draw around the starting point"), xs->str, ys->str);
             } else {
-                rc._message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Rectangle</b>: %s &#215; %s (constrained to golden ratio 1 : 1.618); with <b>Shift</b> to draw around the starting point"), xs->str, ys->str);
+                this->_message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Rectangle</b>: %s &#215; %s (constrained to golden ratio 1 : 1.618); with <b>Shift</b> to draw around the starting point"), xs->str, ys->str);
             }
         }
     } else {
-        rc._message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Rectangle</b>: %s &#215; %s; with <b>Ctrl</b> to make square or integer-ratio rectangle; with <b>Shift</b> to draw around the starting point"), xs->str, ys->str);
+        this->_message_context->setF(Inkscape::IMMEDIATE_MESSAGE, _("<b>Rectangle</b>: %s &#215; %s; with <b>Ctrl</b> to make square or integer-ratio rectangle; 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_rect_finish(SPRectContext *rc)
-{
-    rc->_message_context->clear();
+void SPRectContext::finishItem() {
+    this->_message_context->clear();
 
-    if ( rc->item != NULL ) {
-        SPRect *rect = SP_RECT(rc->item);
-        if (rect->width.computed == 0 || rect->height.computed == 0) {
-            sp_rect_cancel(rc); // Don't allow the creating of zero sized rectangle, for example when the start and and point snap to the snap grid point
+    if (this->rect != NULL) {
+        if (this->rect->width.computed == 0 || this->rect->height.computed == 0) {
+            this->cancel(); // Don't allow the creating of zero sized rectangle, for example when the start and and point snap to the snap grid point
             return;
         }
 
-        SPDesktop *desktop = SP_EVENT_CONTEXT_DESKTOP(rc);
+        this->rect->updateRepr();
 
-        SP_OBJECT(rc->item)->updateRepr();
+        this->desktop->canvas->endForcedFullRedraws();
 
-        desktop->canvas->endForcedFullRedraws();
+        sp_desktop_selection(this->desktop)->set(this->rect);
 
-        sp_desktop_selection(desktop)->set(rc->item);
-        DocumentUndo::done(sp_desktop_document(desktop), SP_VERB_CONTEXT_RECT,
-                           _("Create rectangle"));
+        DocumentUndo::done(sp_desktop_document(this->desktop), SP_VERB_CONTEXT_RECT, _("Create rectangle"));
 
-        rc->item = NULL;
+        this->rect = NULL;
     }
 }
 
-static void sp_rect_cancel(SPRectContext *rc)
-{
-    SPDesktop *desktop = SP_EVENT_CONTEXT(rc)->desktop;
-
-    sp_desktop_selection(desktop)->clear();
-    sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), 0);
+void SPRectContext::cancel(){
+    sp_desktop_selection(this->desktop)->clear();
+    sp_canvas_item_ungrab(SP_CANVAS_ITEM(this->desktop->acetate), 0);
 
-    if (rc->item != NULL) {
-        SP_OBJECT(rc->item)->deleteObject();
-        rc->item = NULL;
+    if (this->rect != NULL) {
+        this->rect->deleteObject();
+        this->rect = NULL;
     }
 
-    rc->within_tolerance = false;
-    rc->xp = 0;
-    rc->yp = 0;
-    rc->item_to_select = NULL;
+    this->within_tolerance = false;
+    this->xp = 0;
+    this->yp = 0;
+    this->item_to_select = NULL;
 
-    desktop->canvas->endForcedFullRedraws();
+    this->desktop->canvas->endForcedFullRedraws();
 
-    DocumentUndo::cancel(sp_desktop_document(desktop));
+    DocumentUndo::cancel(sp_desktop_document(this->desktop));
 }