bump package to 0.7.2

.gitignore

@@ -1,4 +1,4 @@
 /package/contents/code/main.js
 /package/contents/config/main.xml
-/karousel.tar.gz
+/karousel*.tar.gz
 /.idea

Makefile

@@ -1,6 +1,7 @@
 .PHONY: *
 
 TSC_SCRIPT_FLAGS = --lib es2020 ./src/extern/qt.d.ts
+VERSION = $(shell grep '"Version":' ./package/metadata.json | grep -o '[0-9\.]*')
 
 config:
 	mkdir -p ./package/contents/config
@@ -15,8 +16,8 @@ install: build config
 uninstall:
 	kpackagetool5 --type=KWin/Script -r ./package
 
-package:
+package: build config
-	tar -czf ./karousel.tar.gz ./package
+	tar -czf ./karousel_${subst .,_,${VERSION}}.tar.gz ./package
 
 logs:
 	journalctl -t kwin_x11 -g '^qml:|^file://.*karousel' -f

generators/docs/keyBindings.ts

@@ -21,7 +21,7 @@ function formatComment(comment: string | undefined) {
 
 function printCols(...columns: (string[] | string)[]) {
     const nCols = columns.length;
-    if (nCols == 0) {
+    if (nCols === 0) {
         return;
     }
 
@@ -30,7 +30,7 @@ function printCols(...columns: (string[] | string)[]) {
     ).map(
         (column: string[] | string) => column.length
     ));
-    if (nRows == Infinity) {
+    if (nRows === Infinity) {
         // we only have single string columns
         nRows = 1;
     }

package/metadata.json

@@ -1,7 +1,7 @@
 {
     "KPlugin": {
         "Name": "Karousel",
-        "Description": "Manual columnar tiling extension for KWin",
+        "Description": "Scrollable tiling extension for KWin",
         "Icon": "preferences-system-windows",
         "Authors": [{
             "Email": "peter.fajdiga@gmail.com",
@@ -9,7 +9,7 @@
         }],
         "Id": "karousel",
         "ServiceTypes": ["KWin/Script"],
-        "Version": "0.7",
+        "Version": "0.7.2",
         "License": "GPLv3",
         "Website": "https://github.com/peterfajdiga/karousel",
         "BugReportUrl": "https://github.com/peterfajdiga/karousel/issues"

src/Actions.ts

@@ -166,89 +166,13 @@ namespace Actions {
 
             columnWidthIncrease: () => {
                 world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
-                    const desktop = grid.desktop;
+                    config.columnResizer.increaseWidth(column, config.manualResizeStep);
-                    const visibleRange = desktop.getCurrentVisibleRange();
-                    if(!column.isVisible(visibleRange, true) || column.getWidth() >= column.getMaxWidth()) {
-                        return;
-                    }
-
-                    let leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange, true);
-                    let rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange, true);
-                    if (leftVisibleColumn === null || rightVisibleColumn === null) {
-                        console.assert(false); // should at least see self
-                        return;
-                    }
-
-                    const leftSpace = leftVisibleColumn.getLeft() - visibleRange.getLeft();
-                    const rightSpace = visibleRange.getRight() - rightVisibleColumn.getRight();
-
-                    const newWidth = findNextStep(
-                        [
-                            visibleRange.getWidth(),
-                            column.getWidth() + config.manualResizeStep,
-                            column.getWidth() + leftSpace + rightSpace,
-                            column.getWidth() + leftSpace + rightSpace + leftVisibleColumn.getWidth() + grid.config.gapsInnerHorizontal,
-                            column.getWidth() + leftSpace + rightSpace + rightVisibleColumn.getWidth() + grid.config.gapsInnerHorizontal,
-                        ],
-                        width => width - column.getWidth(),
-                    )
-                    if (newWidth === undefined) {
-                        return;
-                    }
-
-                    column.setWidth(newWidth, true);
-                    desktop.scrollCenterVisible(column, false);
-                    desktop.onLayoutChanged();
-                    desktop.autoAdjustScroll();
                 });
             },
 
             columnWidthDecrease: () => {
                 world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
-                    const desktop = grid.desktop;
+                    config.columnResizer.decreaseWidth(column, config.manualResizeStep);
-                    const visibleRange = desktop.getCurrentVisibleRange();
-                    if(!column.isVisible(visibleRange, true) || column.getWidth() <= column.getMinWidth()) {
-                        return;
-                    }
-
-                    const leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange, true);
-                    const rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange, true);
-                    if (leftVisibleColumn === null || rightVisibleColumn === null) {
-                        console.assert(false); // should at least see self
-                        return;
-                    }
-
-                    let leftOffScreenColumn = grid.getPrevColumn(leftVisibleColumn);
-                    if (leftOffScreenColumn === column) {
-                        leftOffScreenColumn = null;
-                    }
-                    let rightOffScreenColumn = grid.getNextColumn(rightVisibleColumn);
-                    if (rightOffScreenColumn === column) {
-                        rightOffScreenColumn = null;
-                    }
-
-                    const visibleColumnsWidth = rightVisibleColumn.getRight() - leftVisibleColumn.getLeft();
-                    const unusedWidth = visibleRange.getWidth() - visibleColumnsWidth;
-                    const leftOffScreen = leftOffScreenColumn === null ? 0 : leftOffScreenColumn.getWidth() + grid.config.gapsInnerHorizontal - unusedWidth;
-                    const rightOffScreen = rightOffScreenColumn === null ? 0 : rightOffScreenColumn.getWidth() + grid.config.gapsInnerHorizontal - unusedWidth;
-
-                    const newWidth = findNextStep(
-                        [
-                            visibleRange.getWidth(),
-                            column.getWidth() - config.manualResizeStep,
-                            column.getWidth() - leftOffScreen,
-                            column.getWidth() - rightOffScreen,
-                        ],
-                        width => column.getWidth() - width,
-                    )
-                    if (newWidth === undefined) {
-                        return;
-                    }
-
-                    column.setWidth(newWidth, true);
-                    desktop.scrollCenterVisible(column, true);
-                    desktop.onLayoutChanged();
-                    desktop.autoAdjustScroll();
                 });
             },
 
@@ -337,7 +261,7 @@ namespace Actions {
                     const grid = desktopManager.getCurrentDesktop().grid;
                     const targetColumn = grid.getColumnAtIndex(columnIndex);
                     if (targetColumn === null) {
-                        return null;
+                        return;
                     }
                     targetColumn.focus();
                 });
@@ -347,7 +271,7 @@ namespace Actions {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const targetColumn = grid.getColumnAtIndex(columnIndex);
                     if (targetColumn === null) {
-                        return null;
+                        return;
                     }
                     window.moveToColumn(targetColumn);
                     grid.desktop.autoAdjustScroll();
@@ -358,7 +282,7 @@ namespace Actions {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const targetColumn = grid.getColumnAtIndex(columnIndex);
                     if (targetColumn === null || targetColumn === column) {
-                        return null;
+                        return;
                     }
                     if (targetColumn.isAfter(column)) {
                         column.moveAfter(targetColumn);
@@ -399,21 +323,14 @@ namespace Actions {
         });
     }
 
-    function findNextStep(steps: number[], evaluate: (step: number) => number) {
-        let bestScore = Infinity;
-        let bestStep = undefined;
-        for (const step of steps) {
-            const score = evaluate(step);
-            if (score > 0 && score < bestScore) {
-                bestScore = score;
-                bestStep = step;
-            }
-        }
-        return bestStep;
-    }
-
     export type Config = {
         manualScrollStep: number,
         manualResizeStep: number,
+        columnResizer: ColumnResizer,
     };
+
+    export type ColumnResizer = {
+        increaseWidth(column: Column, step: number): void,
+        decreaseWidth(column: Column, step: number): void,
+    }
 }

src/ClientAreaOption.ts

@@ -1,10 +0,0 @@
-enum ClientAreaOption {
-    PlacementArea,
-    MovementArea,
-    MaximizeArea,
-    MaximizeFullArea,
-    FullScreenArea,
-    WorkArea,
-    FullArea,
-    ScreenArea,
-}

src/behavior/columnResizer/ContextualResizer.ts

@@ -0,0 +1,96 @@
+class ContextualResizer {
+    public increaseWidth(column: Column, step: number) {
+        const grid = column.grid;
+        const desktop = grid.desktop;
+        const visibleRange = desktop.getCurrentVisibleRange();
+        if(!column.isVisible(visibleRange, true) || column.getWidth() >= column.getMaxWidth()) {
+            return;
+        }
+
+        let leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange, true);
+        let rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange, true);
+        if (leftVisibleColumn === null || rightVisibleColumn === null) {
+            console.assert(false); // should at least see self
+            return;
+        }
+
+        const leftSpace = leftVisibleColumn.getLeft() - visibleRange.getLeft();
+        const rightSpace = visibleRange.getRight() - rightVisibleColumn.getRight();
+
+        const newWidth = ContextualResizer.findNextStep(
+            [
+                visibleRange.getWidth(),
+                column.getWidth() + step,
+                column.getWidth() + leftSpace + rightSpace,
+                column.getWidth() + leftSpace + rightSpace + leftVisibleColumn.getWidth() + grid.config.gapsInnerHorizontal,
+                column.getWidth() + leftSpace + rightSpace + rightVisibleColumn.getWidth() + grid.config.gapsInnerHorizontal,
+            ],
+            width => width - column.getWidth(),
+        )
+        if (newWidth === undefined) {
+            return;
+        }
+
+        column.setWidth(newWidth, true);
+        desktop.scrollCenterVisible(column);
+    }
+
+    public decreaseWidth(column: Column, step: number) {
+        const grid = column.grid;
+        const desktop = grid.desktop;
+        const visibleRange = desktop.getCurrentVisibleRange();
+        if(!column.isVisible(visibleRange, true) || column.getWidth() <= column.getMinWidth()) {
+            return;
+        }
+
+        const leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange, true);
+        const rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange, true);
+        if (leftVisibleColumn === null || rightVisibleColumn === null) {
+            console.assert(false); // should at least see self
+            return;
+        }
+
+        let leftOffScreenColumn = grid.getPrevColumn(leftVisibleColumn);
+        if (leftOffScreenColumn === column) {
+            leftOffScreenColumn = null;
+        }
+        let rightOffScreenColumn = grid.getNextColumn(rightVisibleColumn);
+        if (rightOffScreenColumn === column) {
+            rightOffScreenColumn = null;
+        }
+
+        const visibleColumnsWidth = rightVisibleColumn.getRight() - leftVisibleColumn.getLeft();
+        const unusedWidth = visibleRange.getWidth() - visibleColumnsWidth;
+        const leftOffScreen = leftOffScreenColumn === null ? 0 : leftOffScreenColumn.getWidth() + grid.config.gapsInnerHorizontal - unusedWidth;
+        const rightOffScreen = rightOffScreenColumn === null ? 0 : rightOffScreenColumn.getWidth() + grid.config.gapsInnerHorizontal - unusedWidth;
+
+        const newWidth = ContextualResizer.findNextStep(
+            [
+                visibleRange.getWidth(),
+                column.getWidth() - step,
+                column.getWidth() - leftOffScreen,
+                column.getWidth() - rightOffScreen,
+            ],
+            width => column.getWidth() - width,
+        )
+        if (newWidth === undefined) {
+            return;
+        }
+
+        column.setWidth(newWidth, true);
+        desktop.scrollCenterVisible(column);
+    }
+
+    private static findNextStep(steps: number[], evaluate: (step: number) => number) {
+        let bestScore = Infinity;
+        let bestStep = undefined;
+        for (const step of steps) {
+            const score = evaluate(step);
+            if (score > 0 && score < bestScore) {
+                bestScore = score;
+                bestStep = step;
+            }
+        }
+        return bestStep;
+    }
+}

src/behavior/columnResizer/RawResizer.ts

@@ -0,0 +1,9 @@
+class RawResizer {
+    public increaseWidth(column: Column, step: number) {
+        column.adjustWidth(step, true);
+    }
+
+    public decreaseWidth(column: Column, step: number) {
+        column.adjustWidth(-step, true);
+    }
+}

src/behavior/scrollClamper/CenterClamper.ts

@@ -1,13 +1,5 @@
-class ScrollerCentered {
+class CenterClamper {
-    public scrollToColumn(desktop: Desktop, column: Column) {
-        desktop.scrollCenterRange(column);
-    }
-
     public clampScrollX(desktop: Desktop, x: number) {
-        return ScrollerCentered.clampScrollX(desktop, x);
-    }
-
-    public static clampScrollX(desktop: Desktop, x: number) {
         const firstColumn = desktop.grid.getFirstColumn();
         if (firstColumn === null) {
             return 0;

src/behavior/scrollClamper/EdgeClamper.ts

@@ -1,8 +1,4 @@
-class ScrollerLazy {
+class EdgeClamper {
-    public scrollToColumn(desktop: Desktop, column: Column) {
-        desktop.scrollIntoView(column);
-    }
-
     public clampScrollX(desktop: Desktop, x: number) {
         let minScroll = 0;
         let maxScroll = desktop.grid.getWidth() - desktop.tilingArea.width;

src/behavior/scroller/CenteredScroller.ts

@@ -0,0 +1,5 @@
+class CenteredScroller {
+    public scrollToColumn(desktop: Desktop, column: Column) {
+        desktop.scrollCenterRange(column);
+    }
+}

src/behavior/scroller/GroupedScroller.ts

@@ -0,0 +1,5 @@
+class GroupedScroller {
+    public scrollToColumn(desktop: Desktop, column: Column) {
+        desktop.scrollCenterVisible(column);
+    }
+}

src/behavior/scroller/LazyScroller.ts

@@ -0,0 +1,5 @@
+class LazyScroller {
+    public scrollToColumn(desktop: Desktop, column: Column) {
+        desktop.scrollIntoView(column);
+    }
+}

src/config/definition.ts

@@ -72,103 +72,103 @@ const defaultWindowRules = `[
 
 const configDef = [
     {
-        "name": "gapsOuterTop",
+        name: "gapsOuterTop",
-        "type": "UInt",
+        type: "UInt",
-        "default": 18
+        default: 18,
     },
     {
-        "name": "gapsOuterBottom",
+        name: "gapsOuterBottom",
-        "type": "UInt",
+        type: "UInt",
-        "default": 18
+        default: 18,
     },
     {
-        "name": "gapsOuterLeft",
+        name: "gapsOuterLeft",
-        "type": "UInt",
+        type: "UInt",
-        "default": 18
+        default: 18,
     },
     {
-        "name": "gapsOuterRight",
+        name: "gapsOuterRight",
-        "type": "UInt",
+        type: "UInt",
-        "default": 18
+        default: 18,
     },
     {
-        "name": "gapsInnerHorizontal",
+        name: "gapsInnerHorizontal",
-        "type": "UInt",
+        type: "UInt",
-        "default": 18
+        default: 18,
     },
     {
-        "name": "gapsInnerVertical",
+        name: "gapsInnerVertical",
-        "type": "UInt",
+        type: "UInt",
-        "default": 18
+        default: 18,
     },
     {
-        "name": "manualScrollStep",
+        name: "manualScrollStep",
-        "type": "UInt",
+        type: "UInt",
-        "default": 200
+        default: 200,
     },
     {
-        "name": "manualResizeStep",
+        name: "manualResizeStep",
-        "type": "UInt",
+        type: "UInt",
-        "default": 600
+        default: 600,
     },
     {
-        "name": "offScreenOpacity",
+        name: "offScreenOpacity",
-        "type": "UInt",
+        type: "UInt",
-        "default": 100
+        default: 100,
     },
     {
-        "name": "untileOnDrag",
+        name: "untileOnDrag",
-        "type": "Bool",
+        type: "Bool",
-        "default": true
+        default: true,
     },
     {
-        "name": "stackColumnsByDefault",
+        name: "stackColumnsByDefault",
-        "type": "Bool",
+        type: "Bool",
-        "default": false
+        default: false,
     },
     {
-        "name": "resizeNeighborColumn",
+        name: "resizeNeighborColumn",
-        "type": "Bool",
+        type: "Bool",
-        "default": false
+        default: false,
     },
     {
-        "name": "reMaximize",
+        name: "reMaximize",
-        "type": "Bool",
+        type: "Bool",
-        "default": false
+        default: false,
     },
     {
-        "name": "skipSwitcher",
+        name: "skipSwitcher",
-        "type": "Bool",
+        type: "Bool",
-        "default": false
+        default: false,
     },
     {
-        "name": "scrollingLazy",
+        name: "scrollingLazy",
-        "type": "Bool",
+        type: "Bool",
-        "default": true
+        default: true,
     },
     {
-        "name": "scrollingCentered",
+        name: "scrollingCentered",
-        "type": "Bool",
+        type: "Bool",
-        "default": false
+        default: false,
     },
     {
-        "name": "scrollingGrouped",
+        name: "scrollingGrouped",
-        "type": "Bool",
+        type: "Bool",
-        "default": false
+        default: false,
     },
     {
-        "name": "tiledKeepBelow",
+        name: "tiledKeepBelow",
-        "type": "Bool",
+        type: "Bool",
-        "default": true
+        default: true,
     },
     {
-        "name": "floatingKeepAbove",
+        name: "floatingKeepAbove",
-        "type": "Bool",
+        type: "Bool",
-        "default": false
+        default: false,
     },
     {
-        "name": "windowRules",
+        name: "windowRules",
-        "type": "String",
+        type: "String",
-        "default": defaultWindowRules
+        default: defaultWindowRules,
     }
 ];

src/extern/kwin.d.ts

@@ -1,39 +1,44 @@
 declare const KWin: {
-    // Functions
     readConfig(key: string, defaultValue: any): any;
     registerShortcut(name: string, description: string, keySequence: string, callback: () => void): void;
 };
 
 declare const workspace: {
-    // Read-write Properties
     readonly desktops: number;
     readonly currentDesktop: number;
     readonly currentActivity: string;
 
-    // Read-write Properties
     activeClient: KwinClient;
 
-    // Signals
+    readonly currentDesktopChanged: QSignal<[]>
-    currentDesktopChanged: QSignal<[oldDesktopNumber: number]>
+    readonly clientAdded: QSignal<[KwinClient]>;
-    clientAdded: QSignal<[KwinClient]>;
+    readonly clientRemoved: QSignal<[KwinClient]>;
-    clientRemoved: QSignal<[KwinClient]>;
+    readonly clientMinimized: QSignal<[KwinClient]>;
-    clientMinimized: QSignal<[KwinClient]>;
+    readonly clientUnminimized: QSignal<[KwinClient]>;
-    clientUnminimized: QSignal<[KwinClient]>;
+    readonly clientMaximizeSet: QSignal<[KwinClient, horizontally: boolean, vertically: boolean]>;
-    clientMaximizeSet: QSignal<[KwinClient, horizontally: boolean, vertically: boolean]>;
+    readonly clientActivated: QSignal<[KwinClient]>;
-    clientActivated: QSignal<[KwinClient]>;
+    readonly numberDesktopsChanged: QSignal<[]>;
-    numberDesktopsChanged: QSignal<[oldNumberOfVirtualDesktops: number]>;
+    readonly currentActivityChanged: QSignal<[]>;
-    currentActivityChanged: QSignal<[newActivity: string]>;
+    readonly virtualScreenSizeChanged: QSignal<[]>;
-    virtualScreenSizeChanged: QSignal<[void]>;
 
-    // Functions
     clientArea(option: ClientAreaOption, screenNumber: number, desktopNumber: number);
     clientList(): KwinClient[];
 };
 
-type Tile = any;
+const enum ClientAreaOption {
+    PlacementArea,
+    MovementArea,
+    MaximizeArea,
+    MaximizeFullArea,
+    FullScreenArea,
+    WorkArea,
+    FullArea,
+    ScreenArea,
+}
+
+type Tile = unknown;
 
 interface KwinClient {
-    // Read-only Properties
     readonly shadeable: boolean;
     readonly caption: string;
     readonly minSize: QmlSize;
@@ -47,9 +52,8 @@ interface KwinClient {
     readonly dock: boolean;
     readonly normalWindow: boolean;
     readonly managed: boolean;
-    opacity: number;
 
-    // Read-write Properties
+    opacity: number;
     fullScreen: boolean;
     activities: string[]; // empty array means all activities
     skipSwitcher: boolean;
@@ -61,17 +65,15 @@ interface KwinClient {
     desktop: number; // -1 means all desktops
     tile: Tile;
 
-    // Signals
+    readonly fullScreenChanged: QSignal<[]>;
-    fullScreenChanged: QSignal<[void]>;
+    readonly desktopChanged: QSignal<[]>;
-    desktopChanged: QSignal<[void]>;
+    readonly activitiesChanged: QSignal<[]>;
-    activitiesChanged: QSignal<[KwinClient]>;
+    readonly captionChanged: QSignal<[]>;
-    captionChanged: QSignal<[void]>;
+    readonly tileChanged: QSignal<[]>;
-    tileChanged: QSignal<[Tile]>;
+    readonly moveResizedChanged: QSignal<[]>;
-    moveResizedChanged: QSignal<[void]>;
+    readonly moveResizeCursorChanged: QSignal<[]>;
-    moveResizeCursorChanged: QSignal<[void]>;
+    readonly clientStartUserMovedResized: QSignal<[]>;
-    clientStartUserMovedResized: QSignal<[void]>;
+    readonly frameGeometryChanged: QSignal<[KwinClient, oldGeometry: QmlRect]>;
-    frameGeometryChanged: QSignal<[KwinClient, oldGeometry: QmlRect]>;
 
-    // Functions
     setMaximize(vertically: boolean, horizontally: boolean): void;
 }

src/extern/qt.d.ts

@@ -1,5 +1,6 @@
 declare const console: {
     log(...args: any[]);
+    trace();
     assert(boolean);
 };
 
@@ -35,7 +36,7 @@ type QSignal<T extends unknown[]> = {
 
 type QmlTimer = {
     interval: number;
-    triggered: QSignal<[void]>;
+    readonly triggered: QSignal<[]>;
     restart(): void;
     destroy(): void;
 };

src/keyBindings/definition.ts

@@ -1,218 +1,218 @@
 const keyBindings: KeyBinding[] = [
     {
-        "name": "window-toggle-floating",
+        name: "window-toggle-floating",
-        "description": "Toggle floating",
+        description: "Toggle floating",
-        "defaultKeySequence": "Meta+Space",
+        defaultKeySequence: "Meta+Space",
-        "action": "windowToggleFloating",
+        action: "windowToggleFloating",
     },
     {
-        "name": "focus-left",
+        name: "focus-left",
-        "description": "Move focus left",
+        description: "Move focus left",
-        "defaultKeySequence": "Meta+A",
+        defaultKeySequence: "Meta+A",
-        "action": "focusLeft",
+        action: "focusLeft",
     },
     {
-        "name": "focus-right",
+        name: "focus-right",
-        "description": "Move focus right",
+        description: "Move focus right",
-        "comment": "Clashes with default KDE shortcuts, may require manual remapping",
+        comment: "Clashes with default KDE shortcuts, may require manual remapping",
-        "defaultKeySequence": "Meta+D",
+        defaultKeySequence: "Meta+D",
-        "action": "focusRight",
+        action: "focusRight",
     },
     {
-        "name": "focus-up",
+        name: "focus-up",
-        "description": "Move focus up",
+        description: "Move focus up",
-        "comment": "Clashes with default KDE shortcuts, may require manual remapping",
+        comment: "Clashes with default KDE shortcuts, may require manual remapping",
-        "defaultKeySequence": "Meta+W",
+        defaultKeySequence: "Meta+W",
-        "action": "focusUp",
+        action: "focusUp",
     },
     {
-        "name": "focus-down",
+        name: "focus-down",
-        "description": "Move focus down",
+        description: "Move focus down",
-        "comment": "Clashes with default KDE shortcuts, may require manual remapping",
+        comment: "Clashes with default KDE shortcuts, may require manual remapping",
-        "defaultKeySequence": "Meta+S",
+        defaultKeySequence: "Meta+S",
-        "action": "focusDown",
+        action: "focusDown",
     },
     {
-        "name": "focus-start",
+        name: "focus-start",
-        "description": "Move focus to start",
+        description: "Move focus to start",
-        "defaultKeySequence": "Meta+Home",
+        defaultKeySequence: "Meta+Home",
-        "action": "focusStart",
+        action: "focusStart",
     },
     {
-        "name": "focus-end",
+        name: "focus-end",
-        "description": "Move focus to end",
+        description: "Move focus to end",
-        "defaultKeySequence": "Meta+End",
+        defaultKeySequence: "Meta+End",
-        "action": "focusEnd",
+        action: "focusEnd",
     },
     {
-        "name": "window-move-left",
+        name: "window-move-left",
-        "description": "Move window left",
+        description: "Move window left",
-        "comment": "Moves window out of and into columns",
+        comment: "Moves window out of and into columns",
-        "defaultKeySequence": "Meta+Shift+A",
+        defaultKeySequence: "Meta+Shift+A",
-        "action": "windowMoveLeft",
+        action: "windowMoveLeft",
     },
     {
-        "name": "window-move-right",
+        name: "window-move-right",
-        "description": "Move window right",
+        description: "Move window right",
-        "comment": "Moves window out of and into columns",
+        comment: "Moves window out of and into columns",
-        "defaultKeySequence": "Meta+Shift+D",
+        defaultKeySequence: "Meta+Shift+D",
-        "action": "windowMoveRight",
+        action: "windowMoveRight",
     },
     {
-        "name": "window-move-up",
+        name: "window-move-up",
-        "description": "Move window up",
+        description: "Move window up",
-        "defaultKeySequence": "Meta+Shift+W",
+        defaultKeySequence: "Meta+Shift+W",
-        "action": "windowMoveUp",
+        action: "windowMoveUp",
     },
     {
-        "name": "window-move-down",
+        name: "window-move-down",
-        "description": "Move window down",
+        description: "Move window down",
-        "defaultKeySequence": "Meta+Shift+S",
+        defaultKeySequence: "Meta+Shift+S",
-        "action": "windowMoveDown",
+        action: "windowMoveDown",
     },
     {
-        "name": "window-move-start",
+        name: "window-move-start",
-        "description": "Move window to start",
+        description: "Move window to start",
-        "defaultKeySequence": "Meta+Shift+Home",
+        defaultKeySequence: "Meta+Shift+Home",
-        "action": "windowMoveStart",
+        action: "windowMoveStart",
     },
     {
-        "name": "window-move-end",
+        name: "window-move-end",
-        "description": "Move window to end",
+        description: "Move window to end",
-        "defaultKeySequence": "Meta+Shift+End",
+        defaultKeySequence: "Meta+Shift+End",
-        "action": "windowMoveEnd",
+        action: "windowMoveEnd",
     },
     {
-        "name": "column-toggle-stacked",
+        name: "column-toggle-stacked",
-        "description": "Toggle stacked layout for focused column",
+        description: "Toggle stacked layout for focused column",
-        "comment": "One window in the column visible, others shaded; not supported on Wayland",
+        comment: "One window in the column visible, others shaded; not supported on Wayland",
-        "defaultKeySequence": "Meta+X",
+        defaultKeySequence: "Meta+X",
-        "action": "columnToggleStacked",
+        action: "columnToggleStacked",
     },
     {
-        "name": "column-move-left",
+        name: "column-move-left",
-        "description": "Move column left",
+        description: "Move column left",
-        "defaultKeySequence": "Meta+Ctrl+Shift+A",
+        defaultKeySequence: "Meta+Ctrl+Shift+A",
-        "action": "columnMoveLeft",
+        action: "columnMoveLeft",
     },
     {
-        "name": "column-move-right",
+        name: "column-move-right",
-        "description": "Move column right",
+        description: "Move column right",
-        "defaultKeySequence": "Meta+Ctrl+Shift+D",
+        defaultKeySequence: "Meta+Ctrl+Shift+D",
-        "action": "columnMoveRight",
+        action: "columnMoveRight",
     },
     {
-        "name": "column-move-start",
+        name: "column-move-start",
-        "description": "Move column to start",
+        description: "Move column to start",
-        "defaultKeySequence": "Meta+Ctrl+Shift+Home",
+        defaultKeySequence: "Meta+Ctrl+Shift+Home",
-        "action": "columnMoveStart",
+        action: "columnMoveStart",
     },
     {
-        "name": "column-move-end",
+        name: "column-move-end",
-        "description": "Move column to end",
+        description: "Move column to end",
-        "defaultKeySequence": "Meta+Ctrl+Shift+End",
+        defaultKeySequence: "Meta+Ctrl+Shift+End",
-        "action": "columnMoveEnd",
+        action: "columnMoveEnd",
     },
     {
-        "name": "column-width-increase",
+        name: "column-width-increase",
-        "description": "Increase column width",
+        description: "Increase column width",
-        "defaultKeySequence": "Meta+Ctrl++",
+        defaultKeySequence: "Meta+Ctrl++",
-        "action": "columnWidthIncrease",
+        action: "columnWidthIncrease",
     },
     {
-        "name": "column-width-decrease",
+        name: "column-width-decrease",
-        "description": "Decrease column width",
+        description: "Decrease column width",
-        "defaultKeySequence": "Meta+Ctrl+-",
+        defaultKeySequence: "Meta+Ctrl+-",
-        "action": "columnWidthDecrease",
+        action: "columnWidthDecrease",
     },
     {
-        "name": "columns-width-equalize",
+        name: "columns-width-equalize",
-        "description": "Equalize widths of visible columns",
+        description: "Equalize widths of visible columns",
-        "defaultKeySequence": "Meta+Ctrl+X",
+        defaultKeySequence: "Meta+Ctrl+X",
-        "action": "columnsWidthEqualize",
+        action: "columnsWidthEqualize",
     },
     {
-        "name": "grid-scroll-focused",
+        name: "grid-scroll-focused",
-        "description": "Center focused window",
+        description: "Center focused window",
-        "comment": "Scrolls so that the focused window is centered in the screen",
+        comment: "Scrolls so that the focused window is centered in the screen",
-        "defaultKeySequence": "Meta+Alt+Return",
+        defaultKeySequence: "Meta+Alt+Return",
-        "action": "gridScrollFocused",
+        action: "gridScrollFocused",
     },
     {
-        "name": "grid-scroll-left-column",
+        name: "grid-scroll-left-column",
-        "description": "Scroll one column to the left",
+        description: "Scroll one column to the left",
-        "defaultKeySequence": "Meta+Alt+A",
+        defaultKeySequence: "Meta+Alt+A",
-        "action": "gridScrollLeftColumn",
+        action: "gridScrollLeftColumn",
     },
     {
-        "name": "grid-scroll-right-column",
+        name: "grid-scroll-right-column",
-        "description": "Scroll one column to the right",
+        description: "Scroll one column to the right",
-        "defaultKeySequence": "Meta+Alt+D",
+        defaultKeySequence: "Meta+Alt+D",
-        "action": "gridScrollRightColumn",
+        action: "gridScrollRightColumn",
     },
     {
-        "name": "grid-scroll-left",
+        name: "grid-scroll-left",
-        "description": "Scroll left",
+        description: "Scroll left",
-        "defaultKeySequence": "Meta+Alt+PgUp",
+        defaultKeySequence: "Meta+Alt+PgUp",
-        "action": "gridScrollLeft",
+        action: "gridScrollLeft",
     },
     {
-        "name": "grid-scroll-right",
+        name: "grid-scroll-right",
-        "description": "Scroll right",
+        description: "Scroll right",
-        "defaultKeySequence": "Meta+Alt+PgDown",
+        defaultKeySequence: "Meta+Alt+PgDown",
-        "action": "gridScrollRight",
+        action: "gridScrollRight",
     },
     {
-        "name": "grid-scroll-start",
+        name: "grid-scroll-start",
-        "description": "Scroll to start",
+        description: "Scroll to start",
-        "defaultKeySequence": "Meta+Alt+Home",
+        defaultKeySequence: "Meta+Alt+Home",
-        "action": "gridScrollStart",
+        action: "gridScrollStart",
     },
     {
-        "name": "grid-scroll-end",
+        name: "grid-scroll-end",
-        "description": "Scroll to end",
+        description: "Scroll to end",
-        "defaultKeySequence": "Meta+Alt+End",
+        defaultKeySequence: "Meta+Alt+End",
-        "action": "gridScrollEnd",
+        action: "gridScrollEnd",
     },
 ];
 
 const numKeyBindings: NumKeyBinding[] = [
     {
-        "name": "focus-",
+        name: "focus-",
-        "description": "Move focus to column ",
+        description: "Move focus to column ",
-        "comment": "Clashes with default KDE shortcuts, may require manual remapping",
+        comment: "Clashes with default KDE shortcuts, may require manual remapping",
-        "defaultModifiers": "Meta",
+        defaultModifiers: "Meta",
-        "fKeys": false,
+        fKeys: false,
-        "action": "focusColumn",
+        action: "focusColumn",
     },
     {
-        "name": "window-move-to-column-",
+        name: "window-move-to-column-",
-        "description": "Move window to column ",
+        description: "Move window to column ",
-        "comment": "Requires manual remapping according to your keyboard layout, e.g. Meta+Shift+1 -> Meta+!",
+        comment: "Requires manual remapping according to your keyboard layout, e.g. Meta+Shift+1 -> Meta+!",
-        "defaultModifiers": "Meta+Shift",
+        defaultModifiers: "Meta+Shift",
-        "fKeys": false,
+        fKeys: false,
-        "action": "windowMoveToColumn",
+        action: "windowMoveToColumn",
     },
     {
-        "name": "column-move-to-column-",
+        name: "column-move-to-column-",
-        "description": "Move column to position ",
+        description: "Move column to position ",
-        "comment": "Requires manual remapping according to your keyboard layout, e.g. Meta+Ctrl+Shift+1 -> Meta+Ctrl+!",
+        comment: "Requires manual remapping according to your keyboard layout, e.g. Meta+Ctrl+Shift+1 -> Meta+Ctrl+!",
-        "defaultModifiers": "Meta+Ctrl+Shift",
+        defaultModifiers: "Meta+Ctrl+Shift",
-        "fKeys": false,
+        fKeys: false,
-        "action": "columnMoveToColumn",
+        action: "columnMoveToColumn",
     },
     {
-        "name": "column-move-to-desktop-",
+        name: "column-move-to-desktop-",
-        "description": "Move column to desktop ",
+        description: "Move column to desktop ",
-        "defaultModifiers": "Meta+Ctrl+Shift",
+        defaultModifiers: "Meta+Ctrl+Shift",
-        "fKeys": true,
+        fKeys: true,
-        "action": "columnMoveToDesktop",
+        action: "columnMoveToDesktop",
     },
     {
-        "name": "tail-move-to-desktop-",
+        name: "tail-move-to-desktop-",
-        "description": "Move this and all following columns to desktop ",
+        description: "Move this and all following columns to desktop ",
-        "defaultModifiers": "Meta+Ctrl+Shift+Alt",
+        defaultModifiers: "Meta+Ctrl+Shift+Alt",
-        "fKeys": true,
+        fKeys: true,
-        "action": "tailMoveToDesktop",
+        action: "tailMoveToDesktop",
     },
 ];

src/keyBindings/loader.ts

@@ -53,7 +53,12 @@ function registerNumKeyBindings(name: string, description: string, modifiers: st
 }
 
 function registerKeyBindings(world: World, config: Config) {
-    const actions = Actions.init(world, config);
+    const actions = Actions.init(world, {
+        manualScrollStep: config.manualScrollStep,
+        manualResizeStep: config.manualResizeStep,
+        columnResizer: config.scrollingCentered ? new RawResizer() : new ContextualResizer(),
+    });
+
     for (const binding of keyBindings) {
         registerKeyBinding(binding.name, binding.description, binding.defaultKeySequence, actions[binding.action]);
     }

src/layout/Column.ts

@@ -92,16 +92,17 @@ class Column {
 
     public setWidth(width: number, setPreferred: boolean) {
         width = clamp(width, this.getMinWidth(), this.getMaxWidth());
-        const oldWidth = this.width;
+        if (width === this.width) {
+            return;
+        }
+
         this.width = width;
         if (setPreferred) {
             for (const window of this.windows.iterator()) {
                 window.client.preferredWidth = width;
             }
         }
-        if (width !== oldWidth) {
+        this.grid.onColumnWidthChanged(this);
-            this.grid.onColumnWidthChanged(this, oldWidth, width);
-        }
     }
 
     public adjustWidth(widthDelta: number, setPreferred: boolean) {

src/layout/Desktop.ts

@@ -78,13 +78,10 @@ class Desktop {
         this.adjustScroll(Math.round(windowCenter - screenCenter), false);
     }
 
-    public scrollCenterVisible(focusedColumn: Column, prioritiseVisible: boolean) {
+    public scrollCenterVisible(focusedColumn: Column) {
         const columnRange = new Desktop.ColumnRange(focusedColumn);
         const visibleRange = this.getCurrentVisibleRange();
-        if (prioritiseVisible) {
+        columnRange.addNeighbors(visibleRange, this.grid.config.gapsInnerHorizontal);
-            columnRange.addNeighbors(visibleRange, this.grid.config.gapsInnerHorizontal, column => column.isVisible(visibleRange, true));
-        }
-        columnRange.addNeighbors(visibleRange, this.grid.config.gapsInnerHorizontal, () => true);
         this.scrollCenterRange(columnRange);
     }
 
@@ -112,7 +109,7 @@ class Desktop {
     }
 
     private clampScrollX(x: number) {
-        return this.config.scroller.clampScrollX(this, x);
+        return this.config.clamper.clampScrollX(this, x);
     }
 
     public setScroll(x: number, force: boolean) {
@@ -195,6 +192,7 @@ namespace Desktop {
         marginLeft: number,
         marginRight: number,
         scroller: Desktop.Scroller,
+        clamper: Desktop.Clamper,
     };
 
     export type Range = {
@@ -242,17 +240,15 @@ namespace Desktop {
             this.width = initialColumn.getWidth();
         }
 
-        public addNeighbors(visibleRange: Desktop.Range, gap: number, condition: (column: Column) => boolean) {
+        public addNeighbors(visibleRange: Desktop.Range, gap: number) {
             const grid = this.left.grid;
 
             const columnRange = this;
             function canFit(column: Column) {
-                return columnRange.width + gap + column.getWidth() <= visibleRange.getWidth()
+                return columnRange.width + gap + column.getWidth() <= visibleRange.getWidth();
             }
             function isUsable(column: Column|null) {
-                return column !== null &&
+                return column !== null && canFit(column);
-                    canFit(column) &&
-                    condition(column)
             }
 
             let leftColumn = grid.getPrevColumn(this.left);
@@ -267,10 +263,11 @@ namespace Desktop {
             }
             checkColumns();
 
+            const visibleCenter = visibleRange.getLeft() + visibleRange.getWidth() / 2;
             while (leftColumn !== null || rightColumn !== null) {
-                const leftWidth = leftColumn === null ? 0 : leftColumn.getWidth();
+                const leftToCenter = leftColumn === null ? Infinity : Math.abs(leftColumn.getLeft() - visibleCenter);
-                const rightWidth = rightColumn === null ? 0 : rightColumn.getWidth();
+                const rightToCenter = rightColumn === null ? Infinity : Math.abs(rightColumn.getRight() - visibleCenter);
-                if (leftWidth > rightWidth) {
+                if (leftToCenter < rightToCenter) {
                     this.addLeft(leftColumn!, gap);
                     leftColumn = grid.getPrevColumn(leftColumn!);
                 } else {
@@ -306,6 +303,9 @@ namespace Desktop {
 
     export type Scroller = {
         scrollToColumn(desktop: Desktop, column: Column): void;
+    }
+
+    export type Clamper = {
         clampScrollX(desktop: Desktop, x: number): number;
     }
 }

src/layout/Grid.ts

@@ -43,6 +43,10 @@ class Grid {
         return this.width;
     }
 
+    public isUserResizing() {
+        return this.userResize;
+    }
+
     public getPrevColumn(column: Column) {
         return this.columns.getPrev(column);
     }
@@ -185,7 +189,7 @@ class Grid {
         this.desktop.autoAdjustScroll();
     }
 
-    public onColumnWidthChanged(column: Column, oldWidth: number, width: number) {
+    public onColumnWidthChanged(column: Column) {
         const nextColumn = this.columns.getNext(column);
         this.columnsSetX(nextColumn);
         this.desktop.onLayoutChanged();

src/layout/ScrollerGrouped.ts

@@ -1,9 +0,0 @@
-class ScrollerGrouped {
-    public scrollToColumn(desktop: Desktop, column: Column) {
-        desktop.scrollCenterVisible(column, true);
-    }
-
-    public clampScrollX(desktop: Desktop, x: number) {
-        return ScrollerCentered.clampScrollX(desktop, x);
-    }
-}

src/rules/WindowRuleEnforcer.ts

@@ -31,8 +31,9 @@ class WindowRuleEnforcer {
         manager.connect(kwinClient.captionChanged, () => {
             const shouldTile = enforcer.shouldTile(kwinClient);
             world.do((clientManager, desktopManager) => {
-                if (shouldTile) {
+                const desktop = desktopManager.getDesktopForClient(kwinClient);
-                    clientManager.tileClient(kwinClient);
+                if (shouldTile && desktop !== undefined) {
+                    clientManager.tileClient(kwinClient, desktop.grid);
                 } else {
                     clientManager.untileClient(kwinClient);
                 }
@@ -71,11 +72,11 @@ class WindowRuleEnforcer {
     }
 
     private static joinRegexes(regexes: string[]) {
-        if (regexes.length == 0) {
+        if (regexes.length === 0) {
             return new RegExp("");
         }
 
-        if (regexes.length == 1) {
+        if (regexes.length === 1) {
             return new RegExp("^" + regexes[0] + "$");
         }
 

src/workspace.ts

@@ -60,7 +60,7 @@ function initWorkspaceSignalHandlers(world: World) {
         world.do(() => {}); // re-arrange desktop
     });
 
-    manager.connect(workspace.numberDesktopsChanged, (oldNumberOfVirtualDesktops: number) => {
+    manager.connect(workspace.numberDesktopsChanged, () => {
         world.updateDesktops();
     });
 

src/world/ClientManager.ts

@@ -27,13 +27,13 @@ class ClientManager {
 
     public addClient(kwinClient: KwinClient) {
         console.assert(!this.hasClient(kwinClient));
+        const desktop = this.desktopManager.getDesktopForClient(kwinClient);
 
         let constructState: (client: ClientWrapper) => ClientState.State;
         if (kwinClient.dock) {
             constructState = () => new ClientState.Docked(this.world, kwinClient);
-        } else if (this.windowRuleEnforcer.shouldTile(kwinClient)) {
+        } else if (this.windowRuleEnforcer.shouldTile(kwinClient) && desktop !== undefined) {
-            const grid = this.desktopManager.getDesktopForClient(kwinClient).grid;
+            constructState = (client: ClientWrapper) => new ClientState.Tiled(this.world, client, desktop.grid);
-            constructState = (client: ClientWrapper) => new ClientState.Tiled(this.world, client, grid);
         } else {
             constructState = (client: ClientWrapper) => new ClientState.Floating(this.world, client, this.config, false);
         }
@@ -86,12 +86,16 @@ class ClientManager {
             return;
         }
         if (client.stateManager.getState() instanceof ClientState.TiledMinimized) {
-            const grid = this.desktopManager.getDesktopForClient(kwinClient).grid;
+            const desktop = this.desktopManager.getDesktopForClient(kwinClient);
-            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), false);
+            if (desktop !== undefined) {
+                client.stateManager.setState(() => new ClientState.Tiled(this.world, client, desktop.grid), false);
+            } else {
+                client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, false), false);
+            }
         }
     }
 
-    public tileClient(kwinClient: KwinClient) {
+    public tileClient(kwinClient: KwinClient, grid: Grid) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
@@ -99,7 +103,6 @@ class ClientManager {
         if (client.stateManager.getState() instanceof ClientState.Tiled) {
             return;
         }
-        const grid = this.desktopManager.getDesktopForClient(kwinClient).grid;
         client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), false);
     }
 
@@ -147,8 +150,11 @@ class ClientManager {
         const clientState = client.stateManager.getState();
         if ((clientState instanceof ClientState.Floating || clientState instanceof ClientState.Pinned) && Clients.canTileEver(kwinClient)) {
             Clients.makeTileable(kwinClient);
-            const grid = this.desktopManager.getDesktopForClient(kwinClient).grid;
+            const desktop = this.desktopManager.getDesktopForClient(kwinClient);
-            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), false);
+            if (desktop === undefined) {
+                return;
+            }
+            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, desktop.grid), false);
         } else if (clientState instanceof ClientState.Tiled) {
             client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), false);
         }

src/world/ClientWrapper.ts

@@ -33,8 +33,15 @@ class ClientWrapper {
                 // window is being manually resized, prevent fighting with the user
                 return;
             }
-            this.lastPlacement = Qt.rect(x, y, width, height);
+            const clientWrapper = this; // workaround for bug in Qt5's JS engine
-            this.kwinClient.frameGeometry = this.lastPlacement;
+            clientWrapper.lastPlacement = Qt.rect(x, y, width, height);
+            clientWrapper.kwinClient.frameGeometry = clientWrapper.lastPlacement;
+            if (clientWrapper.kwinClient.frameGeometry !== clientWrapper.lastPlacement) {
+                // frameGeometry assignment failed. This sometimes happens on Wayland
+                // when a window is off-screen, effectively making it stuck there.
+                clientWrapper.kwinClient.frameGeometry.x = x; // This makes it unstuck.
+                clientWrapper.kwinClient.frameGeometry = clientWrapper.lastPlacement;
+            }
         });
     }
 

src/world/DesktopManager.ts

@@ -39,7 +39,9 @@ class DesktopManager {
     }
 
     public getDesktopForClient(kwinClient: KwinClient) {
-        console.assert(kwinClient.activities.length === 1 && kwinClient.desktop > 0);
+        if (kwinClient.activities.length !== 1 || kwinClient.desktop <= 0) {
+            return undefined;
+        }
         return this.getDesktop(kwinClient.activities[0], kwinClient.desktop);
     }
 

src/world/World.ts

@@ -11,7 +11,7 @@ class World {
         this.workspaceSignalManager = initWorkspaceSignalHandlers(this);
 
         this.screenResizedDelayer = new Delayer(1000, () => {
-            // this delay ensures that docks get taken into account by `workspace.clientArea`
+            // this delay ensures that docks are taken into account by `workspace.clientArea`
             const desktopManager = this.desktopManager; // workaround for bug in Qt5's JS engine
             for (const desktop of desktopManager.desktops()) {
                 desktop.onLayoutChanged();
@@ -40,10 +40,11 @@ class World {
                 marginBottom: config.gapsOuterBottom,
                 marginLeft: config.gapsOuterLeft,
                 marginRight: config.gapsOuterRight,
-                scroller: config.scrollingLazy ? new ScrollerLazy() :
+                scroller: config.scrollingLazy ? new LazyScroller() :
-                    config.scrollingCentered ? new ScrollerCentered() :
+                    config.scrollingCentered ? new CenteredScroller() :
-                    config.scrollingGrouped ? new ScrollerGrouped() :
+                    config.scrollingGrouped ? new GroupedScroller() :
                     console.assert(false),
+                clamper: config.scrollingLazy ? new EdgeClamper() : new CenterClamper(),
             },
             layoutConfig,
             workspace.currentActivity,

src/world/clientState/Floating.ts

@@ -54,7 +54,7 @@ namespace ClientState {
                         clientManager.pinClient(kwinClient);
                     });
                 }
-            })
+            });
 
             return manager;
         }

src/world/clientState/Pinned.ts

@@ -68,7 +68,7 @@ namespace ClientState {
                 oldDesktopNumber = kwinClient.desktop;
             });
 
-            manager.connect(kwinClient.activitiesChanged, (kwinClient: KwinClient) => {
+            manager.connect(kwinClient.activitiesChanged, () => {
                 const desktops = kwinClient.desktop === -1 ? [] : [kwinClient.desktop];
                 const changedActivities = oldActivities.length === 0 || kwinClient.activities.length === 0 ?
                     [] :

src/world/clientState/Tiled.ts

@@ -33,23 +33,25 @@ namespace ClientState {
 
             manager.connect(kwinClient.desktopChanged, () => {
                 world.do((clientManager, desktopManager) => {
-                    if (kwinClient.desktop === -1) {
+                    const desktop = desktopManager.getDesktopForClient(kwinClient);
+                    if (desktop === undefined) {
                         // windows on all desktops are not supported
                         clientManager.untileClient(kwinClient);
                         return;
                     }
-                    Tiled.moveWindowToCorrectGrid(desktopManager, window);
+                    Tiled.moveWindowToGrid(window, desktop.grid);
                 });
             });
 
             manager.connect(kwinClient.activitiesChanged, () => {
                 world.do((clientManager, desktopManager) => {
-                    if (kwinClient.activities.length !== 1) {
+                    const desktop = desktopManager.getDesktopForClient(kwinClient);
+                    if (desktop === undefined) {
                         // windows on multiple activities are not supported
                         clientManager.untileClient(kwinClient);
                         return;
                     }
-                    Tiled.moveWindowToCorrectGrid(desktopManager, window);
+                    Tiled.moveWindowToGrid(window, desktop.grid);
                 });
             })
 
@@ -106,6 +108,7 @@ namespace ClientState {
                 if (kwinClient.resize) {
                     world.do(() => window.onUserResize(oldGeometry, !cursorChangedAfterResizeStart));
                 } else if (
+                    !window.column.grid.isUserResizing() &&
                     !client.isManipulatingGeometry(newGeometry) &&
                     !Clients.isMaximizedGeometry(kwinClient) &&
                     !Clients.isFullScreenGeometry(kwinClient) // not using `kwinClient.fullScreen` because it may not be set yet at this point
@@ -130,17 +133,13 @@ namespace ClientState {
             return manager;
         }
 
-        private static moveWindowToCorrectGrid(desktopManager: DesktopManager, window: Window) {
+        private static moveWindowToGrid(window: Window, grid: Grid) {
-            const kwinClient = window.client.kwinClient;
+            if (grid === window.column.grid) {
-
+                // window already on the given grid
-            const oldGrid = window.column.grid;
-            const newGrid = desktopManager.getDesktopForClient(kwinClient).grid;
-            if (oldGrid === newGrid) {
-                // window already on the correct grid
                 return;
             }
 
-            const newColumn = new Column(newGrid, newGrid.getLastFocusedColumn() ?? newGrid.getLastColumn());
+            const newColumn = new Column(grid, grid.getLastFocusedColumn() ?? grid.getLastColumn());
             window.moveToColumn(newColumn);
         }