Add doc rotate with panning

(bzr r15142.1.21)

4 files changed, 417 insertions, 409 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index fa4d73b70..1102bf4bf 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -494,6 +494,8 @@ if(WIN32)
   
   # Build the windows MS-DOS console executable.
   add_executable(inkscape_com winconsole.cpp)
+  set_target_properties(inkscape_com
+                        PROPERTIES LINK_FLAGS "-mconsole")
 endif()
 
 # make executables for inkscape and inkview
diff --git a/src/display/sp-canvas.cpp b/src/display/sp-canvas.cpp
index 745896dd7..2f6caadd3 100644
--- a/src/display/sp-canvas.cpp
+++ b/src/display/sp-canvas.cpp
@@ -2077,22 +2077,31 @@ void SPCanvas::startRotateTo(double angle)
     cairo_paint(cr);
     cairo_destroy(cr);
     surface_origin  = new_backing_store_grey;
-    gtk_widget_queue_draw(GTK_WIDGET(this));
-    dirtyAll();
-    addIdle();
+    clearRotateTo(true);
 }
 
-void SPCanvas::endRotateTo()
+bool SPCanvas::endRotateTo()
 {
-    if (!_backing_store) {
-        return; 
+    if (!started) {
+        return false; 
     }
     started = false;
     surface_rotated = NULL;
     surface_origin  = NULL;
+    clearRotateTo(true);
+    return true;
+}
+
+void SPCanvas::clearRotateTo(bool clear)
+{
+    if (!started) {
+        return; 
+    }
     gtk_widget_queue_draw(GTK_WIDGET(this));
     dirtyAll();
-    addIdle();
+    if (clear) {
+        addIdle();
+    }
 }
 
 void SPCanvas::rotateTo(SPCanvasItem * item, double angle, bool widget)
@@ -2199,7 +2208,7 @@ void SPCanvas::rotateTo(SPCanvasItem * item, double angle, bool widget)
         cairo_translate(cr, (-half_w + 10) * -1 ,(-half_h + 55) * -1);
         cairo_translate(cr, -half_w + 10 ,-half_h + 70);
         s.str("");
-        s << _("+ALT, Reset");
+        s << _("+CTRL+SHIFT, Reset");
         cairo_text_path(cr, s.str().c_str());
         cairo_fill(cr);
         //cairo_translate(cr, (-half_w + 10) * -1 ,(-half_h + 60) * -1);
@@ -2208,8 +2217,7 @@ void SPCanvas::rotateTo(SPCanvasItem * item, double angle, bool widget)
     cairo_surface_destroy(_backing_store);
     _backing_store = new_backing_store;
     cairo_pattern_destroy (source_pattern);
-    gtk_widget_queue_draw(GTK_WIDGET(this));
-    addIdle();
+    clearRotateTo(false);
 }
 
 void SPCanvas::updateNow()
diff --git a/src/display/sp-canvas.h b/src/display/sp-canvas.h
index 5c4cd5047..122cc2d8c 100644
--- a/src/display/sp-canvas.h
+++ b/src/display/sp-canvas.h
@@ -74,7 +74,8 @@ struct SPCanvas {
     void scrollTo(double cx, double cy, unsigned int clear, bool is_scrolling = false);
     void startRotateTo(double angle);
     void rotateTo(SPCanvasItem * item, double angle, bool widget = false);
-    void endRotateTo();
+    bool endRotateTo();
+    void clearRotateTo(bool clear);
     /// Synchronously updates the canvas if necessary.
     void updateNow();
 
diff --git a/src/ui/tools/tool-base.cpp b/src/ui/tools/tool-base.cpp
index d8800284b..87f808039 100644
--- a/src/ui/tools/tool-base.cpp
+++ b/src/ui/tools/tool-base.cpp
@@ -334,129 +334,127 @@ bool ToolBase::root_handler(GdkEvent* event) {
     /// @todo REmove redundant /value in preference keys
     tolerance = prefs->getIntLimited("/options/dragtolerance/value", 0, 0, 100);
     bool allow_panning = prefs->getBool("/options/spacebarpans/value");
+    bool clear = true;
     gint ret = FALSE;
 
     switch (event->type) {
-    case GDK_2BUTTON_PRESS:
-        if (panning) {
-            panning = 0;
-            sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), event->button.time);
-            ret = TRUE;
-        } else {
-            /* sp_desktop_dialog(); */
-        }
-        break;
+        case GDK_2BUTTON_PRESS:
+            if (panning) {
+                panning = 0;
+                sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), event->button.time);
+                ret = TRUE;
+            } else {
+                /* sp_desktop_dialog(); */
+            }
+            desktop->canvas->clearRotateTo();
+            break;
 
-    case GDK_BUTTON_PRESS:
-        // save drag origin
-        xp = (gint) event->button.x;
-        yp = (gint) event->button.y;
-        within_tolerance = true;
+        case GDK_BUTTON_PRESS:
+            // save drag origin
+            xp = (gint) event->button.x;
+            yp = (gint) event->button.y;
+            within_tolerance = true;
 
-        button_w = Geom::Point(event->button.x, event->button.y);
+            button_w = Geom::Point(event->button.x, event->button.y);
+            switch (event->button.button) {
+            case 1:
+                if (this->space_panning) {
+                    // When starting panning, make sure there are no snap events pending because these might disable the panning again
+                    if (_uses_snap) {
+                        sp_event_context_discard_delayed_snap_event(this);
+                    }
+                    panning = 1;
 
-        switch (event->button.button) {
-        case 1:
-            if (this->space_panning) {
-                // When starting panning, make sure there are no snap events pending because these might disable the panning again
-                if (_uses_snap) {
-                    sp_event_context_discard_delayed_snap_event(this);
+                    sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
+                            GDK_KEY_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK
+                                    | GDK_POINTER_MOTION_MASK
+                                    | GDK_POINTER_MOTION_HINT_MASK, NULL,
+                            event->button.time - 1);
+
+                    ret = TRUE;
                 }
-                panning = 1;
+                break;
 
-                sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
-                        GDK_KEY_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK
-                                | GDK_POINTER_MOTION_MASK
-                                | GDK_POINTER_MOTION_HINT_MASK, NULL,
-                        event->button.time - 1);
+            case 2:
+                if (event->button.state & GDK_SHIFT_MASK) {
+                    zoom_rb = 2;
+                } else {
+                    // When starting panning, make sure there are no snap events pending because these might disable the panning again
+                    if (_uses_snap) {
+                        sp_event_context_discard_delayed_snap_event(this);
+                    }
+                    panning = 2;
 
-                ret = TRUE;
-            }
-            break;
+                    sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
+                            GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK
+                                    | GDK_POINTER_MOTION_HINT_MASK, NULL,
+                            event->button.time - 1);
 
-        case 2:
-            if (event->button.state & GDK_SHIFT_MASK) {
-                zoom_rb = 2;
-            } else {
-                // When starting panning, make sure there are no snap events pending because these might disable the panning again
-                if (_uses_snap) {
-                    sp_event_context_discard_delayed_snap_event(this);
                 }
-                panning = 2;
-
-                sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
-                        GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK
-                                | GDK_POINTER_MOTION_HINT_MASK, NULL,
-                        event->button.time - 1);
 
-            }
+                ret = TRUE;
+                break;
 
-            ret = TRUE;
-            break;
+            case 3:
+    //            if ((event->button.state & GDK_SHIFT_MASK) || (event->button.state & GDK_CONTROL_MASK)) {
+    //                // When starting panning, make sure there are no snap events pending because these might disable the panning again
+    //                if (_uses_snap) {
+    //                    sp_event_context_discard_delayed_snap_event(this);
+    //                }
+    //                panning = 3;
+
+    //                sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
+    //                        GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK
+    //                                | GDK_POINTER_MOTION_HINT_MASK, NULL,
+    //                        event->button.time);
+
+    //                ret = TRUE;
+    //            } else 
+                if( !this->space_panning ) {
+                    sp_event_root_menu_popup(desktop, NULL, event);
+                }
+                break;
 
-        case 3:
-//            if ((event->button.state & GDK_SHIFT_MASK) || (event->button.state & GDK_CONTROL_MASK)) {
-//                // When starting panning, make sure there are no snap events pending because these might disable the panning again
-//                if (_uses_snap) {
-//                    sp_event_context_discard_delayed_snap_event(this);
-//                }
-//                panning = 3;
-
-//                sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
-//                        GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK
-//                                | GDK_POINTER_MOTION_HINT_MASK, NULL,
-//                        event->button.time);
-
-//                ret = TRUE;
-//            } else 
-            if( !this->space_panning ) {
-                sp_event_root_menu_popup(desktop, NULL, event);
-            } else {
-                panning = 5;
-                desktop->canvas->startRotateTo(desktop->namedview->document_rotation);
+            default:
+                break;
             }
             break;
 
-        default:
-            break;
-        }
-        break;
-
-    case GDK_MOTION_NOTIFY:
-        if (panning) {
-            if (panning == 5) {
-                button_w = Geom::Point(event->motion.x, event->motion.y);
-                Geom::Point const motion_dt(desktop->w2d(button_w));
-                Geom::Rect view = desktop->get_display_area();
-                Geom::Point view_center = desktop->doc2dt(view.midpoint());
-                Geom::Ray center_ray(motion_dt,view_center);
-                if (event->motion.state & GDK_BUTTON3_MASK) {
+        case GDK_MOTION_NOTIFY:
+            if (panning) {
+                if (panning == 4 && !xp && !yp ) {
+                    // <Space> + mouse panning started, save location and grab canvas
+                    xp = event->motion.x;
+                    yp = event->motion.y;
+                    button_w = Geom::Point(event->motion.x, event->motion.y);
+
+                    sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
+                            GDK_KEY_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK
+                                    | GDK_POINTER_MOTION_MASK
+                                    | GDK_POINTER_MOTION_HINT_MASK, NULL,
+                            event->motion.time - 1);
+                } else if (this->space_panning && event->motion.state & GDK_BUTTON3_MASK) {
+                    clear = false;
+                    sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate), event->button.time);
                     desktop->canvas->startRotateTo(desktop->namedview->document_rotation);
-                    if (event->motion.state & GDK_SHIFT_MASK) {
-                        angle = floor(center_ray.angle()/5) * 5;
-                    } else if (event->motion.state & GDK_CONTROL_MASK) {
-                        angle = center_ray.angle();
-                    } else if (event->motion.state & GDK_KEY_Alt_L ||
-                              event->motion.state & GDK_KEY_Alt_R){
+                    button_w = Geom::Point(event->motion.x, event->motion.y);
+                    Geom::Point const motion_dt(desktop->w2d(button_w));
+                    Geom::Rect view = desktop->get_display_area();
+                    Geom::Point view_center = desktop->doc2dt(view.midpoint());
+                    Geom::Ray center_ray(view_center, motion_dt);
+                    desktop->canvas->startRotateTo(desktop->namedview->document_rotation);
+                    angle = Geom::deg_from_rad(center_ray.angle()) - 90;
+                    if (event->motion.state & GDK_SHIFT_MASK && event->motion.state & GDK_CONTROL_MASK) {
                         angle = desktop->namedview->document_rotation;
+                    } else if (event->motion.state & GDK_SHIFT_MASK) {
+                        angle = floor(angle/5) * 5;
+                    } else if (event->motion.state & GDK_CONTROL_MASK) {
+                        //Decimal raw angle
                     } else {
-                        angle = floor(center_ray.angle());
+                        angle = floor(angle);
                     }
                     desktop->canvas->rotateTo(desktop->getDrawing(), angle);
-                }
-            } else if (panning == 4 && !xp && !yp ) {
-                // <Space> + mouse panning started, save location and grab canvas
-                xp = event->motion.x;
-                yp = event->motion.y;
-                button_w = Geom::Point(event->motion.x, event->motion.y);
-
-                sp_canvas_item_grab(SP_CANVAS_ITEM(desktop->acetate),
-                        GDK_KEY_RELEASE_MASK | GDK_BUTTON_RELEASE_MASK
-                                | GDK_POINTER_MOTION_MASK
-                                | GDK_POINTER_MOTION_HINT_MASK, NULL,
-                        event->motion.time - 1);
-            }
-            if (panning != 5) {
+                } 
                 if ((panning == 2 && !(event->motion.state & GDK_BUTTON2_MASK))
                         || (panning == 1 && !(event->motion.state & GDK_BUTTON1_MASK))
                         || (panning == 3 && !(event->motion.state & GDK_BUTTON3_MASK))) {
@@ -493,373 +491,372 @@ bool ToolBase::root_handler(GdkEvent* event) {
                     this->desktop->scroll_world(moved_w, true); // we're still scrolling, do not redraw
                     ret = TRUE;
                 }
-            }
-        } else if (zoom_rb) {
-            Geom::Point const motion_w(event->motion.x, event->motion.y);
-            Geom::Point const motion_dt(desktop->w2d(motion_w));
-
-            if (within_tolerance && (abs((gint) event->motion.x - xp)
-                    < tolerance) && (abs((gint) event->motion.y - yp)
-                    < 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 move the object, not click), then always process the
-            // motion notify coordinates as given (no snapping back to origin)
-            within_tolerance = false;
+            } else if (zoom_rb) {
+                Geom::Point const motion_w(event->motion.x, event->motion.y);
+                Geom::Point const motion_dt(desktop->w2d(motion_w));
+
+                if (within_tolerance && (abs((gint) event->motion.x - xp)
+                        < tolerance) && (abs((gint) event->motion.y - yp)
+                        < tolerance)) {
+                    break; // do not drag if we're within tolerance from origin
+                }
 
-            if (Inkscape::Rubberband::get(desktop)->is_started()) {
-                Inkscape::Rubberband::get(desktop)->move(motion_dt);
-            } else {
-                Inkscape::Rubberband::get(desktop)->start(desktop, motion_dt);
-            }
+                // 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)
+                within_tolerance = false;
 
-            if (zoom_rb == 2) {
-                gobble_motion_events(GDK_BUTTON2_MASK);
-            }
-        }
-        break;
+                if (Inkscape::Rubberband::get(desktop)->is_started()) {
+                    Inkscape::Rubberband::get(desktop)->move(motion_dt);
+                } else {
+                    Inkscape::Rubberband::get(desktop)->start(desktop, motion_dt);
+                }
 
-    case GDK_BUTTON_RELEASE:
-        if (panning == 5) {
-            desktop->canvas->endRotateTo();
-            sp_repr_set_svg_double(desktop->namedview->getRepr(), "inkscape:document-rotation", angle);
-            SPObject *updated = SP_OBJECT(desktop->namedview);
-            if (updated) {
-                updated->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
-            }
-        } else {
-            xp = yp = 0;
-            if (panning_cursor == 1) {
-                panning_cursor = 0;
-                GtkWidget *w = GTK_WIDGET(this->desktop->getCanvas());
-                gdk_window_set_cursor(gtk_widget_get_window (w), this->cursor);
+                if (zoom_rb == 2) {
+                    gobble_motion_events(GDK_BUTTON2_MASK);
+                }
             }
+            break;
 
-            if (within_tolerance && (panning || zoom_rb)) {
-                zoom_rb = 0;
-
-                if (panning) {
-                    panning = 0;
-                    sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
-                            event->button.time);
+        case GDK_BUTTON_RELEASE:
+            if (this->space_panning && event->button.button == 3) {
+                if (desktop->canvas->endRotateTo()) {
+                    sp_repr_set_svg_double(desktop->namedview->getRepr(), "inkscape:document-rotation", angle);
+                    SPObject *updated = SP_OBJECT(desktop->namedview);
+                    if (updated) {
+                        updated->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG);
+                    }
+                }
+            } else {
+                xp = yp = 0;
+                if (panning_cursor == 1) {
+                    panning_cursor = 0;
+                    GtkWidget *w = GTK_WIDGET(this->desktop->getCanvas());
+                    gdk_window_set_cursor(gtk_widget_get_window (w), this->cursor);
                 }
 
-                Geom::Point const event_w(event->button.x, event->button.y);
-                Geom::Point const event_dt(desktop->w2d(event_w));
+                if (within_tolerance && (panning || zoom_rb)) {
+                    zoom_rb = 0;
 
-                double const zoom_inc = prefs->getDoubleLimited(
-                        "/options/zoomincrement/value", M_SQRT2, 1.01, 10);
+                    if (panning) {
+                        panning = 0;
+                        sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
+                                event->button.time);
+                    }
 
-                desktop->zoom_relative_keep_point(event_dt, (event->button.state
-                        & GDK_SHIFT_MASK) ? 1 / zoom_inc : zoom_inc);
+                    Geom::Point const event_w(event->button.x, event->button.y);
+                    Geom::Point const event_dt(desktop->w2d(event_w));
 
-                desktop->updateNow();
-                ret = TRUE;
-            } else if (panning == event->button.button) {
-                panning = 0;
-                sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
-                        event->button.time);
+                    double const zoom_inc = prefs->getDoubleLimited(
+                            "/options/zoomincrement/value", M_SQRT2, 1.01, 10);
 
-                // in slow complex drawings, some of the motion events are lost;
-                // to make up for this, we scroll it once again to the button-up event coordinates
-                // (i.e. canvas will always get scrolled all the way to the mouse release point,
-                // even if few intermediate steps were visible)
-                Geom::Point const motion_w(event->button.x, event->button.y);
-                Geom::Point const moved_w(motion_w - button_w);
+                    desktop->zoom_relative_keep_point(event_dt, (event->button.state
+                            & GDK_SHIFT_MASK) ? 1 / zoom_inc : zoom_inc);
 
-                this->desktop->scroll_world(moved_w);
-                desktop->updateNow();
-                ret = TRUE;
-            } else if (zoom_rb == event->button.button) {
-                zoom_rb = 0;
+                    desktop->updateNow();
+                    ret = TRUE;
+                } else if (panning == event->button.button) {
+                    panning = 0;
+                    sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
+                            event->button.time);
 
-                Geom::OptRect const b = Inkscape::Rubberband::get(desktop)->getRectangle();
-                Inkscape::Rubberband::get(desktop)->stop();
+                    // in slow complex drawings, some of the motion events are lost;
+                    // to make up for this, we scroll it once again to the button-up event coordinates
+                    // (i.e. canvas will always get scrolled all the way to the mouse release point,
+                    // even if few intermediate steps were visible)
+                    Geom::Point const motion_w(event->button.x, event->button.y);
+                    Geom::Point const moved_w(motion_w - button_w);
 
-                if (b && !within_tolerance) {
-                    desktop->set_display_area(*b, 10);
-                }
+                    this->desktop->scroll_world(moved_w);
+                    desktop->updateNow();
+                    ret = TRUE;
+                } else if (zoom_rb == event->button.button) {
+                    zoom_rb = 0;
 
-                ret = TRUE;
-            }
-        }
-        break;
+                    Geom::OptRect const b = Inkscape::Rubberband::get(desktop)->getRectangle();
+                    Inkscape::Rubberband::get(desktop)->stop();
 
-    case GDK_KEY_PRESS: {
-        double const acceleration = prefs->getDoubleLimited(
-                "/options/scrollingacceleration/value", 0, 0, 6);
-        int const key_scroll = prefs->getIntLimited("/options/keyscroll/value",
-                10, 0, 1000);
-
-        switch (get_group0_keyval(&event->key)) {
-        // GDK insists on stealing these keys (F1 for no idea what, tab for cycling widgets
-        // in the editing window). So we resteal them back and run our regular shortcut
-        // invoker on them.
-        unsigned int shortcut;
-        case GDK_KEY_Tab:
-        case GDK_KEY_ISO_Left_Tab:
-        case GDK_KEY_F1:
-            shortcut = get_group0_keyval(&event->key);
-
-            if (event->key.state & GDK_SHIFT_MASK) {
-                shortcut |= SP_SHORTCUT_SHIFT_MASK;
-            }
+                    if (b && !within_tolerance) {
+                        desktop->set_display_area(*b, 10);
+                    }
 
-            if (event->key.state & GDK_CONTROL_MASK) {
-                shortcut |= SP_SHORTCUT_CONTROL_MASK;
+                    ret = TRUE;
+                }
             }
+            break;
 
-            if (event->key.state & GDK_MOD1_MASK) {
-                shortcut |= SP_SHORTCUT_ALT_MASK;
-            }
+        case GDK_KEY_PRESS: {
+            double const acceleration = prefs->getDoubleLimited(
+                    "/options/scrollingacceleration/value", 0, 0, 6);
+            int const key_scroll = prefs->getIntLimited("/options/keyscroll/value",
+                    10, 0, 1000);
+
+            switch (get_group0_keyval(&event->key)) {
+            // GDK insists on stealing these keys (F1 for no idea what, tab for cycling widgets
+            // in the editing window). So we resteal them back and run our regular shortcut
+            // invoker on them.
+            unsigned int shortcut;
+            case GDK_KEY_Tab:
+            case GDK_KEY_ISO_Left_Tab:
+            case GDK_KEY_F1:
+                shortcut = get_group0_keyval(&event->key);
+
+                if (event->key.state & GDK_SHIFT_MASK) {
+                    shortcut |= SP_SHORTCUT_SHIFT_MASK;
+                }
 
-            ret = sp_shortcut_invoke(shortcut, desktop);
-            break;
+                if (event->key.state & GDK_CONTROL_MASK) {
+                    shortcut |= SP_SHORTCUT_CONTROL_MASK;
+                }
 
-        case GDK_KEY_Q:
-        case GDK_KEY_q:
-            if (desktop->quick_zoomed()) {
-                ret = TRUE;
-            }
-            if (!MOD__SHIFT(event) && !MOD__CTRL(event) && !MOD__ALT(event)) {
-                desktop->zoom_quick(true);
-                ret = TRUE;
-            }
-            break;
+                if (event->key.state & GDK_MOD1_MASK) {
+                    shortcut |= SP_SHORTCUT_ALT_MASK;
+                }
 
-        case GDK_KEY_W:
-        case GDK_KEY_w:
-        case GDK_KEY_F4:
-            /* Close view */
-            if (MOD__CTRL_ONLY(event)) {
-                sp_ui_close_view(NULL);
-                ret = TRUE;
-            }
-            break;
+                ret = sp_shortcut_invoke(shortcut, desktop);
+                break;
+
+            case GDK_KEY_Q:
+            case GDK_KEY_q:
+                if (desktop->quick_zoomed()) {
+                    ret = TRUE;
+                }
+                if (!MOD__SHIFT(event) && !MOD__CTRL(event) && !MOD__ALT(event)) {
+                    desktop->zoom_quick(true);
+                    ret = TRUE;
+                }
+                break;
 
-        case GDK_KEY_Left: // Ctrl Left
-        case GDK_KEY_KP_Left:
-        case GDK_KEY_KP_4:
-            if (MOD__CTRL_ONLY(event)) {
-                int i = (int) floor(key_scroll * accelerate_scroll(event,
-                        acceleration, desktop->getCanvas()));
+            case GDK_KEY_W:
+            case GDK_KEY_w:
+            case GDK_KEY_F4:
+                /* Close view */
+                if (MOD__CTRL_ONLY(event)) {
+                    sp_ui_close_view(NULL);
+                    ret = TRUE;
+                }
+                break;
 
-                gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK);
-                this->desktop->scroll_world(i, 0);
-                ret = TRUE;
-            }
-            break;
+            case GDK_KEY_Left: // Ctrl Left
+            case GDK_KEY_KP_Left:
+            case GDK_KEY_KP_4:
+                if (MOD__CTRL_ONLY(event)) {
+                    int i = (int) floor(key_scroll * accelerate_scroll(event,
+                            acceleration, desktop->getCanvas()));
 
-        case GDK_KEY_Up: // Ctrl Up
-        case GDK_KEY_KP_Up:
-        case GDK_KEY_KP_8:
-            if (MOD__CTRL_ONLY(event)) {
-                int i = (int) floor(key_scroll * accelerate_scroll(event,
-                        acceleration, desktop->getCanvas()));
+                    gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK);
+                    this->desktop->scroll_world(i, 0);
+                    ret = TRUE;
+                }
+                break;
 
-                gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK);
-                this->desktop->scroll_world(0, i);
-                ret = TRUE;
-            }
-            break;
+            case GDK_KEY_Up: // Ctrl Up
+            case GDK_KEY_KP_Up:
+            case GDK_KEY_KP_8:
+                if (MOD__CTRL_ONLY(event)) {
+                    int i = (int) floor(key_scroll * accelerate_scroll(event,
+                            acceleration, desktop->getCanvas()));
 
-        case GDK_KEY_Right: // Ctrl Right
-        case GDK_KEY_KP_Right:
-        case GDK_KEY_KP_6:
-            if (MOD__CTRL_ONLY(event)) {
-                int i = (int) floor(key_scroll * accelerate_scroll(event,
-                        acceleration, desktop->getCanvas()));
+                    gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK);
+                    this->desktop->scroll_world(0, i);
+                    ret = TRUE;
+                }
+                break;
 
-                gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK);
-                this->desktop->scroll_world(-i, 0);
-                ret = TRUE;
-            }
-            break;
+            case GDK_KEY_Right: // Ctrl Right
+            case GDK_KEY_KP_Right:
+            case GDK_KEY_KP_6:
+                if (MOD__CTRL_ONLY(event)) {
+                    int i = (int) floor(key_scroll * accelerate_scroll(event,
+                            acceleration, desktop->getCanvas()));
 
-        case GDK_KEY_Down: // Ctrl Down
-        case GDK_KEY_KP_Down:
-        case GDK_KEY_KP_2:
-            if (MOD__CTRL_ONLY(event)) {
-                int i = (int) floor(key_scroll * accelerate_scroll(event,
-                        acceleration, desktop->getCanvas()));
+                    gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK);
+                    this->desktop->scroll_world(-i, 0);
+                    ret = TRUE;
+                }
+                break;
 
-                gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK);
-                this->desktop->scroll_world(0, -i);
-                ret = TRUE;
-            }
-            break;
+            case GDK_KEY_Down: // Ctrl Down
+            case GDK_KEY_KP_Down:
+            case GDK_KEY_KP_2:
+                if (MOD__CTRL_ONLY(event)) {
+                    int i = (int) floor(key_scroll * accelerate_scroll(event,
+                            acceleration, desktop->getCanvas()));
 
-        case GDK_KEY_Menu:
-            sp_event_root_menu_popup(desktop, NULL, event);
-            ret = TRUE;
-            break;
+                    gobble_key_events(get_group0_keyval(&event->key), GDK_CONTROL_MASK);
+                    this->desktop->scroll_world(0, -i);
+                    ret = TRUE;
+                }
+                break;
 
-        case GDK_KEY_F10:
-            if (MOD__SHIFT_ONLY(event)) {
+            case GDK_KEY_Menu:
                 sp_event_root_menu_popup(desktop, NULL, event);
                 ret = TRUE;
-            }
-            break;
+                break;
 
-        case GDK_KEY_space:
-            within_tolerance = true;
-            xp = yp = 0;
-            if (!allow_panning) break;
-            panning = 4;
-            this->space_panning = true;
-            this->message_context->set(Inkscape::INFORMATION_MESSAGE,
-                    _("<b>Space+mouse move</b> to pan canvas"));
+            case GDK_KEY_F10:
+                if (MOD__SHIFT_ONLY(event)) {
+                    sp_event_root_menu_popup(desktop, NULL, event);
+                    ret = TRUE;
+                }
+                break;
 
-            ret = TRUE;
-            break;
+            case GDK_KEY_space:
+                within_tolerance = true;
+                xp = yp = 0;
+                if (!allow_panning) break;
+                panning = 4;
+                this->space_panning = true;
+                this->message_context->set(Inkscape::INFORMATION_MESSAGE,
+                        _("<b>Space+mouse move</b> to pan canvas"));
 
-        case GDK_KEY_z:
-        case GDK_KEY_Z:
-            if (MOD__ALT_ONLY(event)) {
-                desktop->zoom_grab_focus();
                 ret = TRUE;
+                break;
+
+            case GDK_KEY_z:
+            case GDK_KEY_Z:
+                if (MOD__ALT_ONLY(event)) {
+                    desktop->zoom_grab_focus();
+                    ret = TRUE;
+                }
+                break;
+
+            default:
+                break;
+                }
             }
             break;
 
-        default:
-            break;
+        case GDK_KEY_RELEASE:
+            // Stop panning on any key release
+            if (this->space_panning) {
+                this->space_panning = false;
+                this->message_context->clear();
             }
-        }
-        break;
 
-    case GDK_KEY_RELEASE:
-        // Stop panning on any key release
-        if (this->space_panning) {
-            this->space_panning = false;
-            this->message_context->clear();
-        }
-
-        if (panning) {
-            panning = 0;
-            xp = yp = 0;
-
-            sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
-                    event->key.time);
-
-            desktop->updateNow();
-        }
-
-        if (panning_cursor == 1) {
-            panning_cursor = 0;
-            GtkWidget *w = GTK_WIDGET(this->desktop->getCanvas());
-            gdk_window_set_cursor(gtk_widget_get_window (w), this->cursor);
-        }
+            if (panning) {
+                panning = 0;
+                xp = yp = 0;
 
-        switch (get_group0_keyval(&event->key)) {
-        case GDK_KEY_space:
-            if (within_tolerance) {
-                // Space was pressed, but not panned
-                sp_toggle_selector(desktop);
+                sp_canvas_item_ungrab(SP_CANVAS_ITEM(desktop->acetate),
+                        event->key.time);
 
-                // Be careful, sp_toggle_selector will delete ourselves.
-                // Thus, make sure we return immediately.
-                return true;
+                desktop->updateNow();
             }
 
-            break;
-
-        case GDK_KEY_Q:
-        case GDK_KEY_q:
-            if (desktop->quick_zoomed()) {
-                desktop->zoom_quick(false);
-                ret = TRUE;
+            if (panning_cursor == 1) {
+                panning_cursor = 0;
+                GtkWidget *w = GTK_WIDGET(this->desktop->getCanvas());
+                gdk_window_set_cursor(gtk_widget_get_window (w), this->cursor);
             }
-            break;
-
-        default:
-            break;
-        }
-        break;
 
-    case GDK_SCROLL: {
-        bool ctrl = (event->scroll.state & GDK_CONTROL_MASK);
-        bool wheelzooms = prefs->getBool("/options/wheelzooms/value");
+            switch (get_group0_keyval(&event->key)) {
+            case GDK_KEY_space:
+                if (within_tolerance) {
+                    // Space was pressed, but not panned
+                    sp_toggle_selector(desktop);
 
-        int const wheel_scroll = prefs->getIntLimited(
-                "/options/wheelscroll/value", 40, 0, 1000);
-
-        // Size of smooth-scrolls (only used in GTK+ 3)
-        gdouble delta_x = 0;
-        gdouble delta_y = 0;
-
-        /* shift + wheel, pan left--right */
-        if (event->scroll.state & GDK_SHIFT_MASK) {
-            switch (event->scroll.direction) {
-            case GDK_SCROLL_UP:
-                desktop->scroll_world(wheel_scroll, 0);
+                    // Be careful, sp_toggle_selector will delete ourselves.
+                    // Thus, make sure we return immediately.
+                    return true;
+                }
                 break;
 
-            case GDK_SCROLL_DOWN:
-                desktop->scroll_world(-wheel_scroll, 0);
+            case GDK_KEY_Q:
+            case GDK_KEY_q:
+                if (desktop->quick_zoomed()) {
+                    desktop->zoom_quick(false);
+                    ret = TRUE;
+                }
                 break;
 
             default:
                 break;
             }
+            break;
 
-            /* ctrl + wheel, zoom in--out */
-        } else if ((ctrl && !wheelzooms) || (!ctrl && wheelzooms)) {
-            double rel_zoom;
-            double const zoom_inc = prefs->getDoubleLimited(
-                    "/options/zoomincrement/value", M_SQRT2, 1.01, 10);
+        case GDK_SCROLL: {
+            bool ctrl = (event->scroll.state & GDK_CONTROL_MASK);
+            bool wheelzooms = prefs->getBool("/options/wheelzooms/value");
 
-            switch (event->scroll.direction) {
-            case GDK_SCROLL_UP:
-                rel_zoom = zoom_inc;
-                break;
+            int const wheel_scroll = prefs->getIntLimited(
+                    "/options/wheelscroll/value", 40, 0, 1000);
 
-            case GDK_SCROLL_DOWN:
-                rel_zoom = 1 / zoom_inc;
-                break;
+            // Size of smooth-scrolls (only used in GTK+ 3)
+            gdouble delta_x = 0;
+            gdouble delta_y = 0;
 
-            default:
-                rel_zoom = 0.0;
-                break;
-            }
+            /* shift + wheel, pan left--right */
+            if (event->scroll.state & GDK_SHIFT_MASK) {
+                switch (event->scroll.direction) {
+                case GDK_SCROLL_UP:
+                    desktop->scroll_world(wheel_scroll, 0);
+                    break;
 
-            if (rel_zoom != 0.0) {
-                Geom::Point const scroll_dt = desktop->point();
-                desktop->zoom_relative_keep_point(scroll_dt, rel_zoom);
-            }
+                case GDK_SCROLL_DOWN:
+                    desktop->scroll_world(-wheel_scroll, 0);
+                    break;
 
-            /* no modifier, pan up--down (left--right on multiwheel mice?) */
-        } else {
-            switch (event->scroll.direction) {
-            case GDK_SCROLL_UP:
-                desktop->scroll_world(0, wheel_scroll);
-                break;
+                default:
+                    break;
+                }
 
-            case GDK_SCROLL_DOWN:
-                desktop->scroll_world(0, -wheel_scroll);
-                break;
+                /* ctrl + wheel, zoom in--out */
+            } else if ((ctrl && !wheelzooms) || (!ctrl && wheelzooms)) {
+                double rel_zoom;
+                double const zoom_inc = prefs->getDoubleLimited(
+                        "/options/zoomincrement/value", M_SQRT2, 1.01, 10);
 
-            case GDK_SCROLL_LEFT:
-                desktop->scroll_world(wheel_scroll, 0);
-                break;
+                switch (event->scroll.direction) {
+                case GDK_SCROLL_UP:
+                    rel_zoom = zoom_inc;
+                    break;
 
-            case GDK_SCROLL_RIGHT:
-                desktop->scroll_world(-wheel_scroll, 0);
-                break;
+                case GDK_SCROLL_DOWN:
+                    rel_zoom = 1 / zoom_inc;
+                    break;
 
-            case GDK_SCROLL_SMOOTH:
-                gdk_event_get_scroll_deltas(event, &delta_x, &delta_y);
-                desktop->scroll_world(delta_x, delta_y);
-                break;
+                default:
+                    rel_zoom = 0.0;
+                    break;
+                }
+
+                if (rel_zoom != 0.0) {
+                    Geom::Point const scroll_dt = desktop->point();
+                    desktop->zoom_relative_keep_point(scroll_dt, rel_zoom);
+                }
+
+                /* no modifier, pan up--down (left--right on multiwheel mice?) */
+            } else {
+                switch (event->scroll.direction) {
+                case GDK_SCROLL_UP:
+                    desktop->scroll_world(0, wheel_scroll);
+                    break;
+
+                case GDK_SCROLL_DOWN:
+                    desktop->scroll_world(0, -wheel_scroll);
+                    break;
+
+                case GDK_SCROLL_LEFT:
+                    desktop->scroll_world(wheel_scroll, 0);
+                    break;
+
+                case GDK_SCROLL_RIGHT:
+                    desktop->scroll_world(-wheel_scroll, 0);
+                    break;
+
+                case GDK_SCROLL_SMOOTH:
+                    gdk_event_get_scroll_deltas(event, &delta_x, &delta_y);
+                    desktop->scroll_world(delta_x, delta_y);
+                    break;
+                }
             }
+            break;
         }
-        break;
-    }
-    default:
-        break;
+        default:
+            break;
     }
-
+    desktop->canvas->clearRotateTo(clear);
     return ret;
 }