Drag and drop windows while navigating

kludges.js

@@ -52,6 +52,11 @@ if (!global.display.get_monitor_neighbor_index) {
     }
 }
 
+
+if (!global.display.set_cursor) {
+    global.display.constructor.prototype.set_cursor = global.screen.set_cursor.bind(global.screen);
+}
+
 // polyfill for 3.28
 if (!Meta.DisplayDirection && Meta.ScreenDirection) {
     Meta.DisplayDirection = Meta.ScreenDirection;

navigator.js

@@ -153,14 +153,18 @@ var ActionDispatcher = class {
         let metaWindow = space.selectedWindow;
 
         if (action && action.options.activeInNavigator) {
-            if (action.options.opensMinimap) {
+            if (!Tiling.inGrab && action.options.opensMinimap) {
                 this.navigator._showMinimap(space);
             }
             action.handler(metaWindow, space, {navigator: this.navigator});
             if (space !== Tiling.spaces.selectedSpace) {
                 this.navigator.minimaps.forEach(m => typeof(m) === 'number' ?
                                                 Mainloop.source_remove(m) : m.hide());
             }
+            if (Tiling.inGrab && !Tiling.inGrab.dnd && Tiling.inGrab.window) {
+                Tiling.inGrab.beginDnD();
+            }
+
             return true;
         } else if (mutterActionId == Meta.KeyBindingAction.MINIMIZE) {
             metaWindow.minimize();
@@ -194,7 +198,6 @@ var Navigator = class Navigator {
         this._block = Main.wm._blockAnimations;
         Main.wm._blockAnimations = true;
         // Meta.disable_unredirect_for_screen(screen);
-
         this.space = Tiling.spaces.spaceOf(workspaceManager.get_active_workspace());
 
         this._startWindow = this.space.selectedWindow;
@@ -205,6 +208,7 @@ var Navigator = class Navigator {
 
         TopBar.fixTopBar();
 
+        Scratch.animateWindows();
         this.space.startAnimate();
     }
 
@@ -227,21 +231,25 @@ var Navigator = class Navigator {
         this.was_accepted = true;
     }
 
-    finish() {
+    finish(space, focus) {
         if (grab)
             return;
         this.accept();
-        this.destroy();
+        this.destroy(space, focus);
     }
 
-    destroy() {
+    destroy(space, focus) {
         this.minimaps.forEach(m => {
             if (typeof(m) === 'number')
                 Mainloop.source_remove(m);
             else
                 m.destroy();
         });
 
+        if (Tiling.inGrab && !Tiling.inGrab.dnd) {
+            Tiling.inGrab.beginDnD()
+        }
+
         if (Main.panel.statusArea.appMenu)
             Main.panel.statusArea.appMenu.container.show();
 
@@ -250,9 +258,10 @@ var Navigator = class Navigator {
 
         if (force) {
             this.space.monitor.clickOverlay.hide();
-            this.space = Tiling.spaces.selectedSpace;
         }
 
+        this.space = space || Tiling.spaces.selectedSpace;
+
         let from = this.from;
         let selected = this.space.selectedWindow;
         if(!this.was_accepted) {
@@ -264,46 +273,64 @@ var Navigator = class Navigator {
                 selected = display.focus_window;
         }
 
-        if (this.monitor !== this.space.monitor) {
-            this.space.setMonitor(this.monitor, true);
-        }
-
+        let visible = [];
         for (let monitor of Main.layoutManager.monitors) {
-            if (monitor === this.monitor || !monitor.clickOverlay)
+            visible.push( Tiling.spaces.monitors.get(monitor));
+            if (monitor === this.monitor)
                 continue;
             monitor.clickOverlay.activate();
         }
 
-        if (this.space === from && force) {
+        if (!visible.includes(space) && this.monitor !== this.space.monitor) {
+            this.space.setMonitor(this.monitor, true);
+        }
+
+        if (this.space === from) {
             // Animate the selected space into full view - normally this
             // happens on workspace switch, but activating the same workspace
             // again doesn't trigger a switch signal
-            Tiling.spaces.animateToSpace(this.space);
+            if (force) {
+                const workspaceId = this.space.workspace.index();
+                Tiling.spaces.switchWorkspace(null, workspaceId, workspaceId);
+            }
+        } else {
+            if (Tiling.inGrab && Tiling.inGrab.window) {
+                this.space.workspace.activate_with_focus(Tiling.inGrab.window, global.get_current_time());
+            } else {
+                this.space.workspace.activate(global.get_current_time());
+            }
         }
 
         selected = this.space.indexOf(selected) !== -1 ? selected :
                    this.space.selectedWindow;
-        if (selected &&
-            (!force ||
-             !(display.focus_window && display.focus_window.is_on_all_workspaces())) ) {
 
-            let hasFocus = selected.has_focus();
+        let curFocus = display.focus_window;
+        if (force && curFocus && curFocus.is_on_all_workspaces())
+            selected = curFocus;
+
+        if (focus)
+            selected = focus;
+
+        if (selected && !Tiling.inGrab) {
+            let hasFocus = selected && selected.has_focus();
             selected.foreach_transient(mw => hasFocus = mw.has_focus() || hasFocus);
-            if (!hasFocus) {
-                Main.activateWindow(selected);
+            if (hasFocus) {
+                Tiling.focus_handler(selected)
             } else {
-                // Typically on cancel - the `focus` signal won't run
-                // automatically, so we run it manually
-                Tiling.focus_handler(selected);
+                Main.activateWindow(selected);
             }
-            debug('#preview', 'Finish', selected.title);
-        } else {
-            this.space.workspace.activate(global.get_current_time());
         }
+        if (selected && Tiling.inGrab && !this.was_accepted) {
+            Tiling.focus_handler(selected)
+        }
+
+        if (!Tiling.inGrab)
+            Scratch.showWindows();
 
         TopBar.fixTopBar();
 
         Main.wm._blockAnimations = this._block;
+        this.space.moveDone();
 
         this.emit('destroy', this.was_accepted);
         navigator = false;

notes.org

@@ -290,3 +290,9 @@ The absolute path of the an extension: `Extension.dir.get_path()`
 Clutter prints the FPS at regular intervals if ~CLUTTER_SHOW_FPS~ is set when gnome-shell starts. Where the output ends up depends on how gnome-shell was started. On my system it ends up in the system journal (journalctl)
 
 To turn on off without disrupting flow too much use ~GLib.setenv("CLUTTER_SHOW_FPS", "1", true)~ and restart gnome-shell.
+* Invariants
+** Focus and active workspace
+It's not possible the have a focused window which doesn't belong to the active workspace
+~global.display.focus_window.workspace === workspaceManger.get_active_workspace()~
+* Clutter animation
+  ~time: 0~ does not result in an instant animation. A default duration seems to be selected instead.

scratch.js

@@ -199,6 +199,24 @@ function hide() {
     });
 }
 
+function animateWindows() {
+    let ws = getScratchWindows().filter(w => !w.minimized);
+    ws = global.display.sort_windows_by_stacking(ws);
+    for (let w of ws) {
+        let parent = w.clone.get_parent()
+        parent && parent.remove_child(w.clone);
+        Main.uiGroup.insert_child_below(w.clone, Main.layoutManager.panelBox)
+        let f = w.get_frame_rect();
+        w.clone.set_position(f.x, f.y);
+        Tiling.animateWindow(w);
+    }
+}
+
+function showWindows() {
+    let ws = getScratchWindows().filter(w => !w.minimized);
+    ws.forEach(Tiling.showWindow)
+}
+
 // Monkey patch the alt-space menu
 var PopupMenu = imports.ui.popupMenu;
 var WindowMenu = imports.ui.windowMenu;

stackoverlay.js

@@ -373,6 +373,8 @@ var StackOverlay = class StackOverlay {
         let column = space[index];
         this.target = mru.filter(w => column.includes(w))[0];
         let metaWindow = this.target;
+        if (!metaWindow)
+            return;
 
         let overlay = this.overlay;
         let actor = metaWindow.get_compositor_private();

tiling.js

@@ -540,7 +540,7 @@ class Space extends Array {
 
     isWindowAtPoint(metaWindow, x, y) {
         let clone = metaWindow.clone;
-        let wX = clone.targetX + this.cloneContainer.x;
+        let wX = clone.x + this.cloneContainer.x;
         return x >= wX && x <= wX + clone.width &&
             y >= clone.y && y <= clone.y + clone.height;
     }
@@ -622,6 +622,8 @@ class Space extends Array {
         this.visible.splice(this.visible.indexOf(metaWindow), 1);
 
         let clone = metaWindow.clone;
+        if (clone.get_parent() !== this.cloneContainer)
+            utils.trace('wrong parent', metaWindow);
         this.cloneContainer.remove_actor(clone);
         // Don't destroy the selection highlight widget
         if (clone.first_child.name === 'selection')
@@ -785,12 +787,23 @@ class Space extends Array {
         return column.indexOf(metaWindow);
     }
 
+    globalToViewport(gx, gy) {
+        let [ok, vx, vy] = this.actor.transform_stage_point(gx, gy);
+        return [Math.round(vx), Math.round(vy)];
+    }
+
     /** Transform global coordinates to scroll cooridinates (cloneContainer relative) */
-    globalToScroll(gx, gy, useTarget=false) {
-        // NB: must use this.cloneContainer.transform_stage_point(gx, gy) if stuff is not simply translated
-        let x = gx - this.monitor.x - (useTarget ? this.targetX : this.cloneContainer.x);
-        let y = gy - this.monitor.y - this.cloneContainer.y;
-        return [x, y];
+    globalToScroll(gx, gy, {useTarget = false} = {}) {
+        // Use the smart transform on the actor, as that's the one we scale etc.
+        // We can then use straight translation on the scroll which makes it possible to use target instead if wanted.
+        let [vx, vy] = this.globalToViewport(gx, gy);
+        let sx = vx - (useTarget ? this.targetX : this.cloneContainer.x);
+        let sy = vy - this.cloneContainer.y;
+        return [Math.round(sx), Math.round(sy)];
+    }
+
+    viewportToScroll(vx, vy=0) {
+        return [vx - this.cloneContainer.x, vy - this.cloneContainer.y];
     }
 
     moveDone() {
@@ -799,7 +812,7 @@ class Space extends Array {
             Navigator.navigating || inPreview ||
             Main.overview.visible ||
             // Block when we're carrying a window in dnd
-            (inGrab && inGrab.dnd && inGrab.window)
+            (inGrab && inGrab.window)
            ) {
             return;
         }
@@ -1057,16 +1070,55 @@ box-shadow: 0px 0px 8px 0px rgba(0, 0, 0, .7);
         this.signals.connect(
             this.background, 'button-press-event',
             (actor, event) => {
-                let [aX, aY, mask] = global.get_pointer();
-                let [ok, x, y] =
-                    this.actor.transform_stage_point(aX, aY);
+                if (inGrab) {
+                    return;
+                }
+                let [gx, gy, $] = global.get_pointer();
+                let [ok, x, y] = this.actor.transform_stage_point(gx, gy);
                 let windowAtPoint = !Gestures.gliding && this.getWindowAtPoint(x, y);
-                let nav = Navigator.getNavigator();
                 if (windowAtPoint) {
                     ensureViewport(windowAtPoint, this);
+                    inGrab = new Extension.imports.grab.MoveGrab(windowAtPoint, Meta.GrabOp.MOVING, this);
+                    inGrab.begin();
+                } else if (inPreview) {
+                    spaces.selectedSpace = this;
+                    Navigator.getNavigator().finish();
+                }
+            });
+
+        this.signals.connect(
+            this.background, 'scroll-event',
+            (actor, event) => {
+                if (!inGrab && !Navigator.navigating)
+                    return;
+                let dir = event.get_scroll_direction();
+                if (dir === Clutter.ScrollDirection.SMOOTH)
+                    return;
+                // print(dir, Clutter.ScrollDirection.SMOOTH, Clutter.ScrollDirection.UP, Clutter.ScrollDirection.DOWN)
+                let dx
+                log(utils.ppEnumValue(dir, Clutter.ScrollDirection))
+                // let dx = dir === Clutter.ScrollDirection.DOWN ? -1 : 1
+                // let [dx, dy] = event.get_scroll_delta()
+
+                let [gx, gy] = event.get_coords();
+                if (!gx) {
+                    print("Noooo");
+                    return;
                 }
-                spaces.selectedSpace = this;
-                nav.finish();
+                print(dx, gx, gy);
+
+                switch (dir) {
+                    case Clutter.ScrollDirection.LEFT:
+                    case Clutter.ScrollDirection.UP:
+                        this.switchLeft();
+                        break;
+                    case Clutter.ScrollDirection.RIGHT:
+                    case Clutter.ScrollDirection.DOWN:
+                        this.switchRight();
+                        break;
+                }
+                // spaces.selectedSpace = this;
+                // nav.finish();
             });
 
         this.signals.connect(
@@ -1565,6 +1617,19 @@ class Spaces extends Map {
         let toSpace = this.spaceOf(to);
         let fromSpace = this.spaceOf(from);
 
+        if (inGrab && inGrab.window) {
+            inGrab.window.change_workspace(toSpace.workspace);
+        }
+
+        for (let metaWindow of toSpace.getWindows()) {
+            // Make sure all windows belong to the correct workspace.
+            // Note: The 'switch-workspace' signal (this method) runs before mutter decides on focus window.
+            // This simplifies other code moving windows between workspaces.
+            // Eg.: The DnD-window defer changing its workspace until the workspace actually is activated.
+            //      This ensures the DnD window keep focus the whole time.
+            metaWindow.change_workspace(toSpace.workspace);
+        }
+
         if (inPreview === PreviewMode.NONE && toSpace.monitor === fromSpace.monitor) {
             // Only start an animation if we're moving between workspaces on the
             // same monitor
@@ -2641,10 +2706,13 @@ function grabBegin(metaWindow, type) {
         case Meta.GrabOp.MOVING:
             inGrab = new Extension.imports.grab.MoveGrab(metaWindow, type);
 
-            if (!inGrab.initialSpace || inGrab.initialSpace.indexOf(metaWindow) === -1)
-                return;
+            if (utils.getModiferState() & Clutter.ModifierType.CONTROL_MASK) {
+                inGrab.begin();
+                inGrab.beginDnD();
+            } else if (inGrab.initialSpace && inGrab.initialSpace.indexOf(metaWindow) > -1) {
+                inGrab.begin();
+            }
 
-            inGrab.begin();
             break;
         case Meta.GrabOp.RESIZING_NW:
         case Meta.GrabOp.RESIZING_N:
@@ -2669,7 +2737,7 @@ function grabBegin(metaWindow, type) {
 }
 
 function grabEnd(metaWindow, type) {
-    if (!inGrab)
+    if (!inGrab || inGrab.dnd || inGrab.grabbed)
         return;
 
     inGrab.end();