bump package to 0.14

.gitignore

@@ -2,4 +2,6 @@
 /package/contents/config/main.xml
 /karousel*.tar.gz
 run-ts-tmp.js
+
+/node_modules
 /.idea

Makefile

@@ -1,15 +1,26 @@
 VERSION = $(shell grep '"Version":' ./package/metadata.json | grep -o '[0-9\.]*')
-TESTS := true
+CHECKS := true
 
 .PHONY: *
 
-build: tests
+build: lint tests
 	tsc -p ./src/main --outFile ./package/contents/code/main.js
 	mkdir -p ./package/contents/config
 	./run-ts.sh ./src/generators/config > ./package/contents/config/main.xml
 
+npm-install:
+	npm install
+
+lint: npm-install
+ifeq (${CHECKS}, true)
+	npx eslint ./src
+endif
+
+lint-fix: npm-install
+	npx eslint ./src --fix
+
 tests:
-ifeq (${TESTS}, true)
+ifeq (${CHECKS}, true)
 	./run-ts.sh ./src/tests
 endif
 

README.md

@@ -27,7 +27,7 @@ First install the _org.kde.notification_ QML module (_qml-module-org-kde-notific
 
 Then download the [latest release](https://github.com/peterfajdiga/karousel/releases/latest) and extract it into _~/.local/share/kwin/scripts/_.
 
-Or clone the repo and run `make install` (requires node and tsc).
+Or clone the repo and run `make install` (requires npm, node, and tsc).
 
 ## Key bindings
 The key bindings can be configured in KDE System Settings among KWin's own keyboard shortcuts.

eslint.config.mjs

@@ -0,0 +1,15 @@
+// @ts-check
+
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  {
+    extends: [tseslint.configs.stylistic],
+    rules: {
+      "@typescript-eslint/no-empty-function": "off",
+      "semi": "error",
+      "comma-dangle": ["error", "always-multiline"],
+      "indent": ["error", 4],
+    },
+  }
+);

package.json

@@ -0,0 +1,6 @@
+{
+  "devDependencies": {
+    "eslint": "^9.24.0",
+    "typescript-eslint": "^8.30.1"
+  }
+}

package/contents/ui/config.ui

@@ -29,6 +29,16 @@
                                                 </property>
                                             </widget>
                                         </item>
+                                        <item>
+                                            <widget class="QCheckBox" name="kcfg_cursorFollowsFocus">
+                                                <property name="text">
+                                                    <string>Cursor follows focus</string>
+                                                </property>
+                                                <property name="toolTip">
+                                                    <string>When a window gains focus, move the cursor to it</string>
+                                                </property>
+                                            </widget>
+                                        </item>
                                         <item>
                                             <widget class="QCheckBox" name="kcfg_stackColumnsByDefault">
                                                 <property name="text">
@@ -101,6 +111,35 @@
                                 </widget>
                             </item>
 
+                            <item>
+                                <widget class="QGroupBox">
+                                    <property name="title">
+                                        <string>Touchpad scrolling (Wayland only)</string>
+                                    </property>
+                                    <layout class="QVBoxLayout">
+                                        <item>
+                                            <widget class="QCheckBox" name="kcfg_gestureScroll">
+                                                <property name="text">
+                                                    <string>Enable scrolling with touchpad gestures
+(please don't forget to disable KDE's workspace switching gestures)</string>
+                                                </property>
+                                                <property name="toolTip">
+                                                    <string>Scroll with a three-finger horizontal swipe gesture</string>
+                                                </property>
+                                            </widget>
+                                        </item>
+
+                                        <item>
+                                            <widget class="QCheckBox" name="kcfg_gestureScrollInvert">
+                                                <property name="text">
+                                                    <string>Invert scroll direction (Natural scrolling)</string>
+                                                </property>
+                                            </widget>
+                                        </item>
+                                    </layout>
+                                </widget>
+                            </item>
+
                             <item>
                                 <widget class="QGroupBox">
                                     <property name="title">
@@ -343,6 +382,36 @@
                             </item>
 
                             <item row="9" column="0">
+                                <widget class="QLabel" name="label_gestureScrollStep">
+                                    <property name="text">
+                                        <string>Touchpad gesture scrolling speed:</string>
+                                    </property>
+                                    <property name="toolTip">
+                                        <string>The amount to scroll per edge-to-edge gesture</string>
+                                    </property>
+                                </widget>
+                            </item>
+                            <item row="9" column="1">
+                                <widget class="QSpinBox" name="kcfg_gestureScrollStep">
+                                    <property name="suffix">
+                                        <string> px</string>
+                                    </property>
+                                    <property name="maximum">
+                                        <number>10000</number>
+                                    </property>
+                                    <property name="minimum">
+                                        <number>100</number>
+                                    </property>
+                                    <property name="singleStep">
+                                        <number>100</number>
+                                    </property>
+                                    <property name="value">
+                                        <number>1920</number>
+                                    </property>
+                                </widget>
+                            </item>
+
+                            <item row="10" column="0">
                                 <widget class="QLabel" name="label_presetWidths">
                                     <property name="text">
                                         <string>Preset widths:</string>
@@ -352,7 +421,7 @@
                                     </property>
                                 </widget>
                             </item>
-                            <item row="9" column="1">
+                            <item row="10" column="1">
                                 <widget class="QLineEdit" name="kcfg_presetWidths">
                                     <property name="toolTip">
                                         <string>Comma-separated list of widths. Supported units: "px" and "%".</string>
@@ -360,14 +429,14 @@
                                 </widget>
                             </item>
 
-                            <item row="10" column="0">
+                            <item row="11" column="0">
                                 <widget class="QLabel" name="label_offScreenOpacity">
                                     <property name="text">
                                         <string>Obscured window opacity:</string>
                                     </property>
                                 </widget>
                             </item>
-                            <item row="10" column="1">
+                            <item row="11" column="1">
                                 <widget class="QSpinBox" name="kcfg_offScreenOpacity">
                                     <property name="suffix">
                                         <string> %</string>
@@ -380,6 +449,7 @@
                                     </property>
                                 </widget>
                             </item>
+
                         </layout>
                     </widget>
 

package/contents/ui/main.qml

@@ -35,4 +35,29 @@ Item {
         flags: Notification.Persistent
         urgency: Notification.HighUrgency
     }
+
+    SwipeGestureHandler {
+        direction: SwipeGestureHandler.Direction.Left
+        fingerCount: 3
+        onActivated: qmlBase.karouselInstance.gestureScrollFinish()
+        onCancelled: qmlBase.karouselInstance.gestureScrollFinish()
+        onProgressChanged: qmlBase.karouselInstance.gestureScroll(-progress)
+    }
+
+    SwipeGestureHandler {
+        direction: SwipeGestureHandler.Direction.Right
+        fingerCount: 3
+        onActivated: qmlBase.karouselInstance.gestureScrollFinish()
+        onCancelled: qmlBase.karouselInstance.gestureScrollFinish()
+        onProgressChanged: qmlBase.karouselInstance.gestureScroll(progress)
+    }
+
+    DBusCall {
+        id: moveCursorToFocus
+
+        service: "org.kde.kglobalaccel"
+        path: "/component/kwin"
+        method: "invokeShortcut"
+        arguments: ["MoveMouseToFocus"]
+    }
 }

package/metadata.json

@@ -9,7 +9,7 @@
             "Name": "Peter Fajdiga"
         }],
         "Id": "karousel",
-        "Version": "0.12",
+        "Version": "0.14",
         "License": "GPLv3",
         "Website": "https://github.com/peterfajdiga/karousel",
         "BugReportUrl": "https://github.com/peterfajdiga/karousel/issues"

src/extern/global.d.ts

@@ -4,3 +4,4 @@ declare const Workspace: Workspace;
 declare const qmlBase: QmlObject;
 declare const notificationInvalidWindowRules: Notification;
 declare const notificationInvalidPresetWidths: Notification;
+declare const moveCursorToFocus: DBusCall;

src/generators/docs/keyBindings.ts

@@ -1,7 +1,7 @@
-type DocsKeyBinding = {
+interface DocsKeyBinding {
     description: string;
     keySequence: string;
-};
+}
 
 function formatDescription(item: {description: string, comment?: string}) {
     const suffix = item.comment === undefined ? "" : ` (${item.comment})`;
@@ -15,9 +15,9 @@ function printCols(...columns: (string[] | string)[]) {
     }
 
     let nRows = Math.min(...columns.filter(
-        (column: string[] | string) => column instanceof Array
+        (column: string[] | string) => column instanceof Array,
     ).map(
-        (column: string[] | string) => column.length
+        (column: string[] | string) => column.length,
     ));
     if (nRows === Infinity) {
         // we only have single string columns
@@ -28,12 +28,12 @@ function printCols(...columns: (string[] | string)[]) {
         (column: string[] | string) => {
             if (column instanceof Array) {
                 return Math.max(...column.map(
-                    (cell: string) => cell.length
+                    (cell: string) => cell.length,
-                ))
+                ));
             } else {
                 return column.length;
             }
-        }
+        },
     );
 
     function getCell(col: number, row: number) {

src/lib/behavior/columnResizer/ContextualResizer.ts

@@ -13,8 +13,8 @@ class ContextualResizer {
             return;
         }
 
-        let leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange, true);
+        const leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange, true);
-        let rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange, true);
+        const rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange, true);
         if (leftVisibleColumn === null || rightVisibleColumn === null) {
             console.assert(false); // should at least see self
             return;
@@ -31,7 +31,7 @@ class ContextualResizer {
                 ...this.presetWidths.getWidths(minWidth, maxWidth),
             ],
             width => width - column.getWidth(),
-        )
+        );
         if (newWidth === undefined) {
             return;
         }
@@ -78,7 +78,7 @@ class ContextualResizer {
                 ...this.presetWidths.getWidths(minWidth, maxWidth),
             ],
             width => column.getWidth() - width,
-        )
+        );
         if (newWidth === undefined) {
             return;
         }

src/lib/behavior/scrollClamper/CenterClamper.ts

@@ -6,8 +6,8 @@ class CenterClamper {
         }
         const lastColumn = desktop.grid.getLastColumn()!;
 
-        let minScroll = Math.round((firstColumn.getWidth() - desktop.tilingArea.width) / 2);
+        const minScroll = Math.round((firstColumn.getWidth() - desktop.tilingArea.width) / 2);
-        let maxScroll = Math.round(desktop.grid.getWidth() - (desktop.tilingArea.width + lastColumn.getWidth()) / 2);
+        const maxScroll = Math.round(desktop.grid.getWidth() - (desktop.tilingArea.width + lastColumn.getWidth()) / 2);
         return clamp(x, minScroll, maxScroll);
     }
 }

src/lib/behavior/scrollClamper/EdgeClamper.ts

@@ -1,7 +1,7 @@
 class EdgeClamper {
     public clampScrollX(desktop: Desktop, x: number) {
-        let minScroll = 0;
+        const minScroll = 0;
-        let maxScroll = desktop.grid.getWidth() - desktop.tilingArea.width;
+        const maxScroll = desktop.grid.getWidth() - desktop.tilingArea.width;
         if (maxScroll < 0) {
             return Math.round(maxScroll / 2);
         }

src/lib/config/config.ts

@@ -1,4 +1,4 @@
-type Config = {
+interface Config {
     gapsOuterTop: number;
     gapsOuterBottom: number;
     gapsOuterLeft: number;
@@ -11,6 +11,7 @@ type Config = {
     presetWidths: string;
     offScreenOpacity: number;
     untileOnDrag: boolean;
+    cursorFollowsFocus: boolean;
     stackColumnsByDefault: boolean;
     resizeNeighborColumn: boolean;
     reMaximize: boolean;
@@ -18,7 +19,10 @@ type Config = {
     scrollingLazy: boolean;
     scrollingCentered: boolean;
     scrollingGrouped: boolean;
+    gestureScroll: boolean;
+    gestureScrollInvert: boolean;
+    gestureScrollStep: number;
     tiledKeepBelow: boolean;
     floatingKeepAbove: boolean;
     windowRules: string;
-};
+}

src/lib/config/definition.ts

@@ -114,6 +114,11 @@ const configDef = [
         type: "Bool",
         default: true,
     },
+    {
+        name: "cursorFollowsFocus",
+        type: "Bool",
+        default: false,
+    },
     {
         name: "stackColumnsByDefault",
         type: "Bool",
@@ -149,6 +154,21 @@ const configDef = [
         type: "Bool",
         default: false,
     },
+    {
+        name: "gestureScroll",
+        type: "Bool",
+        default: false,
+    },
+    {
+        name: "gestureScrollInvert",
+        type: "Bool",
+        default: false,
+    },
+    {
+        name: "gestureScrollStep",
+        type: "UInt",
+        default: 1920,
+    },
     {
         name: "tiledKeepBelow",
         type: "Bool",
@@ -168,5 +188,5 @@ const configDef = [
         name: "windowRules",
         type: "String",
         default: defaultWindowRules,
-    }
+    },
 ];

src/lib/extern/dbuscall.ts

@@ -0,0 +1,3 @@
+interface DBusCall extends QmlObject {
+    call(): void;
+}

src/lib/extern/kwin.ts

@@ -1,10 +1,10 @@
-type KWin = {
+interface KWin {
     __brand: "KWin";
 
     readConfig(key: string, defaultValue: any): any;
-};
+}
 
-type Workspace = {
+interface Workspace {
     __brand: "Workspace";
 
     readonly activities: string[];
@@ -28,7 +28,7 @@ type Workspace = {
     readonly virtualScreenSizeChanged: QSignal<[]>;
 
     clientArea(option: ClientAreaOption, output: Output, kwinDesktop: KwinDesktop): QmlRect;
-};
+}
 
 const enum ClientAreaOption {
     PlacementArea,
@@ -48,10 +48,10 @@ const enum MaximizedMode {
     Maximized,
 }
 
-type Tile = { __brand: "Tile" };
+interface Tile { __brand: "Tile" }
-type Output = { __brand: "Output" };
+interface Output { __brand: "Output" }
 
-type KwinClient = {
+interface KwinClient {
     __brand: "KwinClient";
 
     readonly caption: string;
@@ -96,15 +96,15 @@ type KwinClient = {
     readonly frameGeometryChanged: QSignal<[oldGeometry: QmlRect]>;
 
     setMaximize(vertically: boolean, horizontally: boolean): void;
-};
+}
 
-type KwinDesktop = {
+interface KwinDesktop {
     __brand: "KwinDesktop";
 
     readonly id: string;
-};
+}
 
-type ShortcutHandler = QmlObject & {
+interface ShortcutHandler extends QmlObject {
     readonly activated: QSignal<[]>;
     destroy(): void;
-};
+}

src/lib/extern/notification.ts

@@ -1,3 +1,3 @@
-type Notification = QmlObject & {
+interface Notification extends QmlObject {
     sendEvent(): void;
-};
+}

src/lib/extern/qt.ts

@@ -1,27 +1,27 @@
-type Console = {
+interface Console {
     __brand: "Console";
 
     log(...args: any[]): void;
     assert(assertion: boolean, message?: string): void;
-};
+}
 
-type Qt = {
+interface Qt {
     __brand: "Qt";
 
     rect(x: number, y: number, width: number, height: number): QmlRect;
     createQmlObject(qml: string, parent: QmlObject): QmlObject;
-};
+}
 
-type QmlObject = { __brand: "QmlObject" };
+interface QmlObject { __brand: "QmlObject" }
 
-type QmlPoint = {
+interface QmlPoint {
     __brand: "QmlPoint";
 
     x: number;
     y: number;
-};
+}
 
-type QmlRect = {
+interface QmlRect {
     __brand: "QmlRect";
 
     x: number;
@@ -32,25 +32,25 @@ type QmlRect = {
     readonly bottom: number; // top + height
     readonly left: number;
     readonly right: number; // left + width
-};
+}
 
-type QmlSize = {
+interface QmlSize {
     __brand: "QmlSize";
 
     width: number;
     height: number;
-};
+}
 
-type QSignal<T extends unknown[]> = {
+interface QSignal<T extends unknown[]> {
     __brand: "QSignal";
 
     connect(handler: (...args: [...T]) => void): void;
     disconnect(handler: (...args: [...T]) => void): void;
-};
+}
 
-type QmlTimer = QmlObject & {
+interface QmlTimer extends QmlObject {
     interval: number;
     readonly triggered: QSignal<[]>;
     restart(): void;
     destroy(): void;
-};
+}

src/lib/keyBindings/Actions.ts

@@ -8,16 +8,16 @@ class Actions {
         if (leftColumn === null) {
             return;
         }
-        leftColumn.focus();
+        leftColumn.getWindowToFocus().focus();
-    }
+    };
 
     public readonly focusRight = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const rightColumn = grid.getRightColumn(column);
         if (rightColumn === null) {
             return;
         }
-        rightColumn.focus();
+        rightColumn.getWindowToFocus().focus();
-    }
+    };
 
     public readonly focusUp = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const aboveWindow = column.getAboveWindow(window);
@@ -25,7 +25,7 @@ class Actions {
             return;
         }
         aboveWindow.focus();
-    }
+    };
 
     public readonly focusDown = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const belowWindow = column.getBelowWindow(window);
@@ -33,7 +33,7 @@ class Actions {
             return;
         }
         belowWindow.focus();
-    }
+    };
 
     public readonly focusNext = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const belowWindow = column.getBelowWindow(window);
@@ -46,7 +46,7 @@ class Actions {
             }
             rightColumn.getFirstWindow().focus();
         }
-    }
+    };
 
     public readonly focusPrevious = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const aboveWindow = column.getAboveWindow(window);
@@ -59,7 +59,7 @@ class Actions {
             }
             leftColumn.getLastWindow().focus();
         }
-    }
+    };
 
     public readonly focusStart = (cm: ClientManager, dm: DesktopManager) => {
         const grid = dm.getCurrentDesktop().grid;
@@ -67,8 +67,8 @@ class Actions {
         if (firstColumn === null) {
             return;
         }
-        firstColumn.focus();
+        firstColumn.getWindowToFocus().focus();
-    }
+    };
 
     public readonly focusEnd = (cm: ClientManager, dm: DesktopManager) => {
         const grid = dm.getCurrentDesktop().grid;
@@ -76,8 +76,8 @@ class Actions {
         if (lastColumn === null) {
             return;
         }
-        lastColumn.focus();
+        lastColumn.getWindowToFocus().focus();
-    }
+    };
 
     public readonly windowMoveLeft = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         if (column.getWindowCount() === 1) {
@@ -86,40 +86,40 @@ class Actions {
             if (leftColumn === null) {
                 return;
             }
-            window.moveToColumn(leftColumn, true);
+            window.moveToColumn(leftColumn, true, FocusPassing.Type.None);
             grid.desktop.autoAdjustScroll();
         } else {
             // move from shared column into own column
             const newColumn = new Column(grid, grid.getLeftColumn(column));
-            window.moveToColumn(newColumn, true);
+            window.moveToColumn(newColumn, true, FocusPassing.Type.None);
         }
-    }
+    };
 
-    public readonly windowMoveRight = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid, bottom: boolean = true) => {
+    public readonly windowMoveRight = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid, bottom = true) => {
         if (column.getWindowCount() === 1) {
             // move from own column into existing column
             const rightColumn = grid.getRightColumn(column);
             if (rightColumn === null) {
                 return;
             }
-            window.moveToColumn(rightColumn, bottom);
+            window.moveToColumn(rightColumn, bottom, FocusPassing.Type.None);
             grid.desktop.autoAdjustScroll();
         } else {
             // move from shared column into own column
             const newColumn = new Column(grid, column);
-            window.moveToColumn(newColumn, true);
+            window.moveToColumn(newColumn, true, FocusPassing.Type.None);
         }
-    }
+    };
 
     // TODO (optimization): only arrange moved windows
     public readonly windowMoveUp = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         column.moveWindowUp(window);
-    }
+    };
 
     // TODO (optimization): only arrange moved windows
     public readonly windowMoveDown = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         column.moveWindowDown(window);
-    }
+    };
 
     public readonly windowMoveNext = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const canMoveDown = window !== column.getLastWindow();
@@ -128,7 +128,7 @@ class Actions {
         } else {
             this.windowMoveRight(cm, dm, window, column, grid, false);
         }
-    }
+    };
 
     public readonly windowMovePrevious = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const canMoveUp = window !== column.getFirstWindow();
@@ -137,62 +137,62 @@ class Actions {
         } else {
             this.windowMoveLeft(cm, dm, window, column, grid);
         }
-    }
+    };
 
     public readonly windowMoveStart = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const newColumn = new Column(grid, null);
-        window.moveToColumn(newColumn, true);
+        window.moveToColumn(newColumn, true, FocusPassing.Type.None);
-    }
+    };
 
     public readonly windowMoveEnd = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const newColumn = new Column(grid, grid.getLastColumn());
-        window.moveToColumn(newColumn, true);
+        window.moveToColumn(newColumn, true, FocusPassing.Type.None);
-    }
+    };
 
     public readonly windowToggleFloating = (cm: ClientManager, dm: DesktopManager) => {
         if (Workspace.activeWindow === null) {
             return;
         }
         cm.toggleFloatingClient(Workspace.activeWindow);
-    }
+    };
 
     public readonly columnMoveLeft = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         grid.moveColumnLeft(column);
-    }
+    };
 
     public readonly columnMoveRight = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         grid.moveColumnRight(column);
-    }
+    };
 
     public readonly columnMoveStart = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         grid.moveColumn(column, null);
-    }
+    };
 
     public readonly columnMoveEnd = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         grid.moveColumn(column, grid.getLastColumn());
-    }
+    };
 
     public readonly columnToggleStacked = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         column.toggleStacked();
-    }
+    };
 
     public readonly columnWidthIncrease = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         this.config.columnResizer.increaseWidth(column);
-    }
+    };
 
     public readonly columnWidthDecrease = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         this.config.columnResizer.decreaseWidth(column);
-    }
+    };
 
     public readonly cyclePresetWidths = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const nextWidth = this.config.presetWidths.next(column.getWidth(), column.getMinWidth(), column.getMaxWidth());
         column.setWidth(nextWidth, true);
-    }
+    };
 
     public readonly cyclePresetWidthsReverse = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const nextWidth = this.config.presetWidths.prev(column.getWidth(), column.getMinWidth(), column.getMaxWidth());
         column.setWidth(nextWidth, true);
-    }
+    };
 
     public readonly columnsWidthEqualize = (cm: ClientManager, dm: DesktopManager) => {
         const desktop = dm.getCurrentDesktop();
@@ -211,7 +211,7 @@ class Actions {
             visibleColumns[0],
             visibleColumns[visibleColumns.length - 1],
         ));
-    }
+    };
 
     public readonly columnsSqueezeLeft = (cm: ClientManager, dm: DesktopManager, window: Window, focusedColumn: Column, grid: Grid) => {
         const visibleRange = grid.desktop.getCurrentVisibleRange();
@@ -238,7 +238,7 @@ class Actions {
                 break; // don't scroll past the currently focused column
             }
         }
-    }
+    };
 
     public readonly columnsSqueezeRight = (cm: ClientManager, dm: DesktopManager, window: Window, focusedColumn: Column, grid: Grid) => {
         const visibleRange = grid.desktop.getCurrentVisibleRange();
@@ -265,7 +265,7 @@ class Actions {
                 break; // don't scroll past the currently focused column
             }
         }
-    }
+    };
 
     private readonly squeezeColumns = (columns: Column[]) => {
         const firstColumn = columns[0];
@@ -286,19 +286,19 @@ class Actions {
         columns.forEach((column, index) => column.setWidth(widths[index], true));
         desktop.scrollCenterRange(Range.fromRanges(firstColumn, lastColumn));
         return true;
-    }
+    };
 
     public readonly gridScrollLeft = (cm: ClientManager, dm: DesktopManager) => {
         this.gridScroll(dm, -this.config.manualScrollStep);
-    }
+    };
 
     public readonly gridScrollRight = (cm: ClientManager, dm: DesktopManager) => {
         this.gridScroll(dm, this.config.manualScrollStep);
-    }
+    };
 
     private readonly gridScroll = (desktopManager: DesktopManager, amount: number) => {
         desktopManager.getCurrentDesktop().adjustScroll(amount, false);
-    }
+    };
 
     public readonly gridScrollStart = (cm: ClientManager, dm: DesktopManager) => {
         const grid = dm.getCurrentDesktop().grid;
@@ -307,7 +307,7 @@ class Actions {
             return;
         }
         grid.desktop.scrollToColumn(firstColumn, false);
-    }
+    };
 
     public readonly gridScrollEnd = (cm: ClientManager, dm: DesktopManager) => {
         const grid = dm.getCurrentDesktop().grid;
@@ -316,7 +316,7 @@ class Actions {
             return;
         }
         grid.desktop.scrollToColumn(lastColumn, false);
-    }
+    };
 
     public readonly gridScrollFocused = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
         const scrollAmount = Range.minus(column, grid.desktop.getCurrentVisibleRange());
@@ -325,7 +325,7 @@ class Actions {
         } else {
             grid.desktop.scrollToColumn(column, true);
         }
-    }
+    };
 
     public readonly gridScrollLeftColumn = (cm: ClientManager, dm: DesktopManager) => {
         const grid = dm.getCurrentDesktop().grid;
@@ -340,7 +340,7 @@ class Actions {
         }
 
         grid.desktop.scrollToColumn(leftColumn, false);
-    }
+    };
 
     public readonly gridScrollRightColumn = (cm: ClientManager, dm: DesktopManager) => {
         const grid = dm.getCurrentDesktop().grid;
@@ -355,11 +355,11 @@ class Actions {
         }
 
         grid.desktop.scrollToColumn(rightColumn, false);
-    }
+    };
 
     public readonly screenSwitch = (cm: ClientManager, dm: DesktopManager) => {
         dm.selectScreen(Workspace.activeScreen);
-    }
+    };
 
     public readonly focus = (columnIndex: number, cm: ClientManager, dm: DesktopManager) => {
         const grid = dm.getCurrentDesktop().grid;
@@ -367,7 +367,7 @@ class Actions {
         if (targetColumn === null) {
             return;
         }
-        targetColumn.focus();
+        targetColumn.getWindowToFocus().focus();
     };
 
     public readonly windowMoveToColumn = (columnIndex: number, cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
@@ -375,7 +375,7 @@ class Actions {
         if (targetColumn === null) {
             return;
         }
-        window.moveToColumn(targetColumn, true);
+        window.moveToColumn(targetColumn, true, FocusPassing.Type.None);
         grid.desktop.autoAdjustScroll();
     };
 
@@ -417,17 +417,17 @@ class Actions {
 }
 
 namespace Actions {
-    export type Config = {
+    export interface Config {
         manualScrollStep: number;
         presetWidths: {
             next: (currentWidth: number, minWidth: number, maxWidth: number) => number;
             prev: (currentWidth: number, minWidth: number, maxWidth: number) => number
 };
         columnResizer: ColumnResizer;
-    };
+    }
 
-    export type ColumnResizer = {
+    export interface ColumnResizer {
         increaseWidth(column: Column): void;
         decreaseWidth(column: Column): void;
-    };
+    }
 }

src/lib/keyBindings/loader.ts

@@ -1,19 +1,19 @@
-type KeyBinding = {
+interface KeyBinding {
     name: string;
     description: string;
     comment?: string;
     defaultKeySequence?: string;
     action: () => void;
-};
+}
 
-type NumKeyBinding = {
+interface NumKeyBinding {
     name: string;
     description: string;
     comment?: string;
     defaultModifiers: string;
     fKeys: boolean;
     action: (i: number) => void;
-};
+}
 
 function catchWrap(f: () => void) {
     return () => {

src/lib/layout/Column.ts

@@ -21,7 +21,7 @@ class Column {
         if (targetGrid === this.grid) {
             this.grid.moveColumn(this, leftColumn);
         } else {
-            this.grid.onColumnRemoved(this, this.isFocused());
+            this.grid.onColumnRemoved(this, this.isFocused() ? FocusPassing.Type.Immediate : FocusPassing.Type.None);
             this.grid = targetGrid;
             targetGrid.onColumnAdded(this, leftColumn);
             for (const window of this.windows.iterator()) {
@@ -195,12 +195,8 @@ class Column {
         return this.focusTaker;
     }
 
-    public focus() {
+    public getWindowToFocus() {
-        const window = this.getFocusTaker() ?? this.windows.getFirst();
+        return this.getFocusTaker() ?? this.windows.getFirst()!;
-        if (window === null) {
-            return;
-        }
-        window.focus();
     }
 
     public isFocused() {
@@ -273,7 +269,7 @@ class Column {
         this.grid.desktop.onLayoutChanged();
     }
 
-    public onWindowRemoved(window: Window, passFocus: boolean) {
+    public onWindowRemoved(window: Window, passFocus: FocusPassing.Type) {
         const lastWindow = this.windows.length() === 1;
         const windowToFocus = this.getAboveWindow(window) ?? this.getBelowWindow(window);
 
@@ -288,8 +284,15 @@ class Column {
             this.destroy(passFocus);
         } else {
             this.resizeWindows();
-            if (passFocus && windowToFocus !== null) {
+            if (windowToFocus !== null) {
-                windowToFocus.focus();
+                switch (passFocus) {
+                case FocusPassing.Type.Immediate:
+                    windowToFocus.focus();
+                    break;
+                case FocusPassing.Type.OnUnfocus:
+                    this.grid.focusPasser.request(windowToFocus.client.kwinClient);
+                    break;
+                }
             }
         }
 
@@ -297,18 +300,18 @@ class Column {
     }
 
     public onWindowFocused(window: Window) {
-        this.grid.onColumnFocused(this);
+        this.grid.onColumnFocused(this, window);
         this.focusTaker = window;
     }
 
-    public restoreToTiled() {
+    public restoreToTiled(focusedWindow: Window) {
         const lastFocusedWindow = this.getFocusTaker();
-        if (lastFocusedWindow !== null) {
+        if (lastFocusedWindow !== null && lastFocusedWindow !== focusedWindow) {
             lastFocusedWindow.restoreToTiled();
         }
     }
 
-    private destroy(passFocus: boolean) {
+    private destroy(passFocus: FocusPassing.Type) {
         this.grid.onColumnRemoved(this, passFocus);
     }
 }

src/lib/layout/Desktop.ts

@@ -1,6 +1,7 @@
 class Desktop {
     public readonly grid: Grid;
     private scrollX: number;
+    private gestureScrollXInitial: number | null;
     private dirty: boolean;
     private dirtyScroll: boolean;
     private dirtyPins: boolean;
@@ -13,12 +14,14 @@ class Desktop {
         private readonly config: Desktop.Config,
         private readonly getScreen: () => Output,
         layoutConfig: LayoutConfig,
+        focusPasser: FocusPassing.Passer,
     ) {
         this.scrollX = 0;
+        this.gestureScrollXInitial = null;
         this.dirty = true;
         this.dirtyScroll = true;
         this.dirtyPins = true;
-        this.grid = new Grid(this, layoutConfig);
+        this.grid = new Grid(this, layoutConfig, focusPasser);
         this.clientArea = Desktop.getClientArea(this.getScreen(), kwinDesktop);
         this.tilingArea = Desktop.getTilingArea(this.clientArea, kwinDesktop, pinManager, config);
     }
@@ -52,7 +55,7 @@ class Desktop {
             top,
             right - left,
             bottom - top,
-        )
+        );
     }
 
     public scrollIntoView(range: Range) {
@@ -124,6 +127,24 @@ class Desktop {
         this.setScroll(this.scrollX + dx, force);
     }
 
+    public gestureScroll(amount: number) {
+        if (!this.config.gestureScroll) {
+            return;
+        }
+        if (this.gestureScrollXInitial === null) {
+            this.gestureScrollXInitial = this.scrollX;
+        }
+
+        if (this.config.gestureScrollInvert) {
+            amount = -amount;
+        }
+        this.setScroll(this.gestureScrollXInitial + this.config.gestureScrollStep * amount, false);
+    }
+
+    public gestureScrollFinish() {
+        this.gestureScrollXInitial = null;
+    }
+
     public arrange() {
         // TODO (optimization): only arrange visible windows
         this.updateArea();
@@ -155,14 +176,17 @@ class Desktop {
 }
 
 namespace Desktop {
-    export type Config = {
+    export interface Config {
         marginTop: number;
         marginBottom: number;
         marginLeft: number;
         marginRight: number;
+        gestureScroll: boolean;
+        gestureScrollInvert: boolean;
+        gestureScrollStep: number;
         scroller: Desktop.Scroller;
         clamper: Desktop.Clamper;
-    };
+    }
 
     export class ColumnRange {
         private left: Column;
@@ -236,11 +260,11 @@ namespace Desktop {
         }
     }
 
-    export type Scroller = {
+    export interface Scroller {
         scrollToColumn(desktop: Desktop, column: Column): void;
-    };
+    }
 
-    export type Clamper = {
+    export interface Clamper {
         clampScrollX(desktop: Desktop, x: number): number;
-    };
+    }
 }

src/lib/layout/Grid.ts

@@ -1,15 +1,17 @@
 class Grid {
     public readonly desktop: Desktop;
     public readonly config: LayoutConfig;
+    public readonly focusPasser: FocusPassing.Passer;
     private readonly columns: LinkedList<Column>;
     private lastFocusedColumn: Column|null;
     private width: number;
     private userResize: boolean; // is any part of the grid being resized by the user
     private readonly userResizeFinishedDelayer: Delayer;
 
-    constructor(desktop: Desktop, config: LayoutConfig) {
+    constructor(desktop: Desktop, config: LayoutConfig, focusPasser: FocusPassing.Passer) {
         this.desktop = desktop;
         this.config = config;
+        this.focusPasser = focusPasser;
         this.columns = new LinkedList();
         this.lastFocusedColumn = null;
         this.width = 0;
@@ -156,7 +158,7 @@ class Grid {
         this.desktop.autoAdjustScroll();
     }
 
-    public onColumnRemoved(column: Column, passFocus: boolean) {
+    public onColumnRemoved(column: Column, passFocus: FocusPassing.Type) {
         const isLastColumn = this.columns.length() === 1;
         const rightColumn = this.getRightColumn(column);
         const columnToFocus = isLastColumn ? null : this.getLeftColumn(column) ?? rightColumn;
@@ -168,11 +170,17 @@ class Grid {
         this.columnsSetX(rightColumn);
 
         this.desktop.onLayoutChanged();
-        if (passFocus && columnToFocus !== null) {
+        if (columnToFocus !== null) {
-            columnToFocus.focus();
+            switch (passFocus) {
-        } else {
+            case FocusPassing.Type.Immediate:
-            this.desktop.autoAdjustScroll();
+                columnToFocus.getWindowToFocus().focus();
+                return;
+            case FocusPassing.Type.OnUnfocus:
+                this.focusPasser.request(columnToFocus.getWindowToFocus().client.kwinClient);
+                return;
+            }
         }
+        this.desktop.autoAdjustScroll();
     }
 
     public onColumnWidthChanged(column: Column) {
@@ -184,10 +192,10 @@ class Grid {
         }
     }
 
-    public onColumnFocused(column: Column) {
+    public onColumnFocused(column: Column, window: Window) {
         const lastFocusedColumn = this.getLastFocusedColumn();
-        if (lastFocusedColumn !== null && lastFocusedColumn !== column) {
+        if (lastFocusedColumn !== null) {
-            lastFocusedColumn.restoreToTiled();
+            lastFocusedColumn.restoreToTiled(window);
         }
         this.lastFocusedColumn = column;
         this.desktop.scrollToColumn(column, false);

src/lib/layout/LayoutConfig.ts

@@ -1,4 +1,4 @@
-type LayoutConfig = {
+interface LayoutConfig {
     gapsInnerHorizontal: number;
     gapsInnerVertical: number;
     stackOffsetX: number;
@@ -11,4 +11,4 @@ type LayoutConfig = {
     tiledKeepBelow: boolean;
     maximizedKeepAbove: boolean;
     untileOnDrag: boolean;
-};
+}

src/lib/layout/Range.ts

@@ -1,8 +1,8 @@
-type Range = {
+interface Range {
     getLeft(): number;
     getRight(): number;
     getWidth(): number;
-};
+}
 
 namespace Range {
     export function create(x: number, width: number) {

src/lib/layout/Window.ts

@@ -23,11 +23,11 @@ class Window {
         column.onWindowAdded(this, true);
     }
 
-    public moveToColumn(targetColumn: Column, bottom: boolean) {
+    public moveToColumn(targetColumn: Column, bottom: boolean, passFocus: FocusPassing.Type) {
         if (targetColumn === this.column) {
             return;
         }
-        this.column.onWindowRemoved(this, this.isFocused() && targetColumn.grid !== this.column.grid);
+        this.column.onWindowRemoved(this, passFocus);
         this.column = targetColumn;
         targetColumn.onWindowAdded(this, bottom);
     }
@@ -61,6 +61,11 @@ class Window {
 
     public focus() {
         this.client.focus();
+        const kwinClient = this.client.kwinClient;
+        if (!this.isFocused()) {
+            // in some situations focus assignment just doesn't work, let's do it later
+            this.column.grid.focusPasser.request(kwinClient);
+        }
     }
 
     public isFocused() {
@@ -122,14 +127,14 @@ class Window {
         this.column.grid.desktop.onLayoutChanged();
     }
 
-    public destroy(passFocus: boolean) {
+    public destroy(passFocus: FocusPassing.Type) {
         this.column.onWindowRemoved(this, passFocus);
     }
 }
 
 namespace Window {
-    export type State = {
+    export interface State {
         fullScreen: boolean;
         maximizedMode: MaximizedMode;
-    };
+    }
 }

src/lib/rules/WindowRule.ts

@@ -1,5 +1,5 @@
-type WindowRule = {
+interface WindowRule {
     class: string | undefined;
     caption: string | undefined;
     tile: boolean;
-};
+}

src/lib/rules/WindowRuleEnforcer.ts

@@ -52,7 +52,7 @@ class WindowRuleEnforcer {
             const ruleCaption = WindowRuleEnforcer.parseRegex(windowRule.caption);
             const ruleString = ClientMatcher.getRuleString(
                 WindowRuleEnforcer.wrapParens(ruleClass),
-                WindowRuleEnforcer.wrapParens(ruleCaption)
+                WindowRuleEnforcer.wrapParens(ruleCaption),
             );
 
             (windowRule.tile ? tileRegexes : floatRegexes).push(ruleString);

src/lib/utils/Delayer.ts

@@ -17,9 +17,9 @@ class Delayer {
 }
 
 function initQmlTimer() {
-    return <QmlTimer>Qt.createQmlObject(
+    return Qt.createQmlObject(
         `import QtQuick 6.0
         Timer {}`,
-        qmlBase
+        qmlBase,
-    );
+    ) as QmlTimer;
 }

src/lib/utils/ShortcutAction.ts

@@ -16,7 +16,7 @@ class ShortcutAction {
 ` :
             "";
 
-        return <ShortcutHandler>Qt.createQmlObject(
+        return Qt.createQmlObject(
             `import QtQuick 6.0
 import org.kde.kwin 3.0
 ShortcutHandler {
@@ -24,14 +24,14 @@ ShortcutHandler {
     text: "Karousel: ${keyBinding.description}";
 ${sequenceLine}}`,
             qmlBase,
-        );
+        ) as ShortcutHandler;
     }
 }
 
 namespace ShortcutAction {
-    export type KeyBinding = {
+    export interface KeyBinding {
         name: string;
         description: string;
         defaultKeySequence?: string;
-    };
+    }
 }

src/lib/utils/fillSpace.ts

@@ -84,13 +84,13 @@ function fillSpace(availableSpace: number, items: { min: number, max: number }[]
         }
     }
 
-    type Range = {
+    interface Range {
         start: number,
         end: number,
         n: number,
-    };
+    }
 
-    type Fencepost = {
+    interface Fencepost {
         value: number,
         nMin: number,
         nMax: number,

src/lib/utils/functions.ts

@@ -7,4 +7,4 @@ interface Function {
 
 Function.prototype.partial = function<H extends any[], T extends any[]>(...head: H) {
     return (...tail: T) => this(...head, ...tail);
-}
+};

src/lib/utils/math.ts

@@ -18,3 +18,15 @@ function rectEquals(a: QmlRect, b: QmlRect) {
         a.width === b.width &&
         a.height === b.height;
 }
+
+function pointEquals(a: QmlPoint, b: QmlPoint) {
+    return a.x === b.x &&
+        a.y === b.y;
+}
+
+function rectContainsPoint(rect: QmlRect, point: QmlPoint) {
+    return rect.left <= point.x &&
+        rect.right >= point.x &&
+        rect.top <= point.y &&
+        rect.bottom >= point.y;
+}

src/lib/workspace.ts

@@ -1,25 +1,27 @@
-function initWorkspaceSignalHandlers(world: World) {
+function initWorkspaceSignalHandlers(world: World, focusPasser: FocusPassing.Passer) {
     const manager = new SignalManager();
 
     manager.connect(Workspace.windowAdded, (kwinClient: KwinClient) => {
         world.do((clientManager, desktopManager) => {
-            clientManager.addClient(kwinClient)
+            clientManager.addClient(kwinClient);
         });
     });
 
     manager.connect(Workspace.windowRemoved, (kwinClient: KwinClient) => {
         world.do((clientManager, desktopManager) => {
-            clientManager.removeClient(kwinClient, true);
+            clientManager.removeClient(kwinClient, FocusPassing.Type.Immediate);
         });
     });
 
     manager.connect(Workspace.windowActivated, (kwinClient: KwinClient|null) => {
         if (kwinClient === null) {
-            return;
+            focusPasser.activate();
+        } else {
+            focusPasser.clearIfDifferent(kwinClient);
+            world.do((clientManager, desktopManager) => {
+                clientManager.onClientFocused(kwinClient);
+            });
         }
-        world.do((clientManager, desktopManager) => {
-            clientManager.onClientFocused(kwinClient);
-        });
     });
 
     manager.connect(Workspace.currentDesktopChanged, () => {

src/lib/world/ClientManager.ts

@@ -55,13 +55,16 @@ class ClientManager {
         this.clientMap.set(kwinClient, client);
     }
 
-    public removeClient(kwinClient: KwinClient, passFocus: boolean) {
+    public removeClient(kwinClient: KwinClient, passFocus: FocusPassing.Type) {
         console.assert(this.hasClient(kwinClient));
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
         }
-        client.destroy(passFocus && kwinClient === this.lastFocusedClient);
+        if (kwinClient !== this.lastFocusedClient) {
+            passFocus = FocusPassing.Type.None;
+        }
+        client.destroy(passFocus);
         this.clientMap.delete(kwinClient);
     }
 
@@ -84,9 +87,10 @@ class ClientManager {
             return;
         }
         if (client.stateManager.getState() instanceof ClientState.Tiled) {
+            const passFocus = kwinClient === this.lastFocusedClient ? FocusPassing.Type.Immediate : FocusPassing.Type.None;
             client.stateManager.setState(
                 () => new ClientState.TiledMinimized(this.world, client),
-                kwinClient === this.lastFocusedClient,
+                passFocus,
             );
         }
     }
@@ -95,14 +99,14 @@ class ClientManager {
         if (client.stateManager.getState() instanceof ClientState.Tiled) {
             return;
         }
-        client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), false);
+        client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), FocusPassing.Type.None);
     }
 
     public floatClient(client: ClientWrapper) {
         if (client.stateManager.getState() instanceof ClientState.Floating) {
             return;
         }
-        client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), false);
+        client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), FocusPassing.Type.None);
     }
 
     public tileKwinClient(kwinClient: KwinClient, grid: Grid) {
@@ -131,7 +135,7 @@ class ClientManager {
             kwinClient.tile = null;
             return;
         }
-        client.stateManager.setState(() => new ClientState.Pinned(this.world, this.pinManager, this.desktopManager, kwinClient, this.config), false);
+        client.stateManager.setState(() => new ClientState.Pinned(this.world, this.pinManager, this.desktopManager, kwinClient, this.config), FocusPassing.Type.None);
         this.pinManager.addClient(kwinClient);
         for (const desktop of this.desktopManager.getDesktopsForClient(kwinClient)) {
             desktop.onPinsChanged();
@@ -144,7 +148,7 @@ class ClientManager {
             return;
         }
         console.assert(client.stateManager.getState() instanceof ClientState.Pinned);
-        client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, false), false);
+        client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, false), FocusPassing.Type.None);
         this.pinManager.removeClient(kwinClient);
         for (const desktop of this.desktopManager.getDesktopsForClient(kwinClient)) {
             desktop.onPinsChanged();
@@ -164,9 +168,9 @@ class ClientManager {
             if (desktop === undefined) {
                 return;
             }
-            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, desktop.grid), false);
+            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, desktop.grid), FocusPassing.Type.None);
         } else if (clientState instanceof ClientState.Tiled) {
-            client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), false);
+            client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), FocusPassing.Type.None);
         }
     }
 
@@ -204,7 +208,7 @@ class ClientManager {
 
     private removeAllClients() {
         for (const kwinClient of Array.from(this.clientMap.keys())) {
-            this.removeClient(kwinClient, false);
+            this.removeClient(kwinClient, FocusPassing.Type.None);
         }
     }
 
@@ -214,7 +218,7 @@ class ClientManager {
 }
 
 namespace ClientManager {
-    export type Config = {
+    export interface Config {
         floatingKeepAbove: boolean;
-    };
+    }
 }

src/lib/world/ClientWrapper.ts

@@ -78,6 +78,7 @@ class ClientWrapper {
 
     public setMaximize(horizontally: boolean, vertically: boolean) {
         if (!this.kwinClient.maximizable) {
+            this.maximizedMode = MaximizedMode.Unmaximized;
             return;
         }
 
@@ -149,7 +150,7 @@ class ClientWrapper {
         }
     }
 
-    public destroy(passFocus: boolean) {
+    public destroy(passFocus: FocusPassing.Type) {
         this.stateManager.destroy(passFocus);
         this.signalManager.destroy();
         if (this.rulesSignalManager !== null) {

src/lib/world/Clients.ts

@@ -32,23 +32,23 @@ namespace Clients {
 
     export function getKwinDesktopApprox(kwinClient: KwinClient) {
         switch (kwinClient.desktops.length) {
-            case 0:
+        case 0:
+            return Workspace.currentDesktop;
+        case 1:
+            return kwinClient.desktops[0];
+        default:
+            if (kwinClient.desktops.includes(Workspace.currentDesktop)) {
                 return Workspace.currentDesktop;
-            case 1:
+            } else {
                 return kwinClient.desktops[0];
-            default:
+            }
-                if (kwinClient.desktops.includes(Workspace.currentDesktop)) {
-                    return Workspace.currentDesktop;
-                } else {
-                    return kwinClient.desktops[0];
-                }
         }
     }
 
     export function isFullScreenGeometry(kwinClient: KwinClient) {
         const fullScreenArea = Workspace.clientArea(ClientAreaOption.FullScreenArea, kwinClient.output, getKwinDesktopApprox(kwinClient));
-        return kwinClient.clientGeometry.width === fullScreenArea.width &&
+        return kwinClient.clientGeometry.width >= fullScreenArea.width &&
-            kwinClient.clientGeometry.height === fullScreenArea.height;
+            kwinClient.clientGeometry.height >= fullScreenArea.height;
     }
 
     export function isOnVirtualDesktop(kwinClient: KwinClient, kwinDesktop: KwinDesktop) {

src/lib/world/DesktopManager.ts

@@ -7,7 +7,8 @@ class DesktopManager {
     constructor(
         private readonly pinManager: PinManager,
         private readonly config: Desktop.Config,
-        public readonly layoutConfig: LayoutConfig,
+        private readonly layoutConfig: LayoutConfig,
+        private readonly focusPasser: FocusPassing.Passer,
         currentActivity: string,
         currentDesktop: KwinDesktop,
     ) {
@@ -54,6 +55,7 @@ class DesktopManager {
             this.config,
             () => this.selectedScreen,
             this.layoutConfig,
+            this.focusPasser,
         );
         this.desktops.set(desktopKey, desktop);
         return desktop;

src/lib/world/FocusPassing.ts

@@ -0,0 +1,51 @@
+namespace FocusPassing {
+    export const enum Type {
+        None,
+        Immediate,
+        OnUnfocus,
+    }
+
+    export class Passer {
+        private currentRequest: Request | null = null;
+
+        public request(target: KwinClient) {
+            this.currentRequest = new Request(target, Date.now());
+        }
+
+        public clear() {
+            this.currentRequest = null;
+        }
+
+        public clearIfDifferent(kwinClient: KwinClient) {
+            if (this.currentRequest !== null && this.currentRequest.target !== kwinClient) {
+                this.clear();
+            }
+        }
+
+        public activate() {
+            if (this.currentRequest === null) {
+                return;
+            }
+
+            if (this.currentRequest.isExpired()) {
+                this.clear();
+                return;
+            }
+
+            Workspace.activeWindow = this.currentRequest.target;
+        }
+    }
+
+    class Request {
+        private static readonly validMs = 200;
+
+        constructor(
+            public readonly target: KwinClient,
+            private readonly time: number,
+        ) {}
+
+        public isExpired() {
+            return Date.now() - this.time > Request.validMs;
+        }
+    }
+}

src/lib/world/World.ts

@@ -5,9 +5,12 @@ class World {
     private readonly workspaceSignalManager: SignalManager;
     private readonly shortcutActions: ShortcutAction[];
     private readonly screenResizedDelayer: Delayer;
+    private readonly cursorFollowsFocus: boolean;
 
     constructor(config: Config) {
-        this.workspaceSignalManager = initWorkspaceSignalHandlers(this);
+        const focusPasser = new FocusPassing.Passer();
+        this.workspaceSignalManager = initWorkspaceSignalHandlers(this, focusPasser);
+        this.cursorFollowsFocus = config.cursorFollowsFocus;
 
         let presetWidths = {
             next: (currentWidth: number, minWidth: number, maxWidth: number) => currentWidth,
@@ -61,8 +64,12 @@ class World {
                 marginRight: config.gapsOuterRight,
                 scroller: World.createScroller(config),
                 clamper: config.scrollingLazy ? new EdgeClamper() : new CenterClamper(),
+                gestureScroll: config.gestureScroll,
+                gestureScrollInvert: config.gestureScrollInvert,
+                gestureScrollStep: config.gestureScrollStep,
             },
             layoutConfig,
+            focusPasser,
             Workspace.currentActivity,
             Workspace.currentDesktop,
         );
@@ -85,15 +92,24 @@ class World {
     }
 
     private addExistingClients() {
-        const kwinClients = Workspace.windows;
+        for (const kwinClient of Workspace.windows) {
-        for (let i = 0; i < kwinClients.length; i++) {
-            const kwinClient = kwinClients[i];
             this.clientManager.addClient(kwinClient);
         }
     }
 
     private update() {
         this.desktopManager.getCurrentDesktop().arrange();
+        this.moveCursorToFocus();
+    }
+
+    private moveCursorToFocus() {
+        if (this.cursorFollowsFocus && Workspace.activeWindow !== null) {
+            const cursorAlreadyInFocus = rectContainsPoint(Workspace.activeWindow.frameGeometry, Workspace.cursorPos);
+            if (cursorAlreadyInFocus) {
+                return;
+            }
+            moveCursorToFocus.call();
+        }
     }
 
     public do(f: (clientManager: ClientManager, desktopManager: DesktopManager) => void) {
@@ -124,6 +140,14 @@ class World {
         this.doIfTiled(Workspace.activeWindow, f);
     }
 
+    public gestureScroll(amount: number) {
+        this.do((clientManager, desktopManager) => desktopManager.getCurrentDesktop().gestureScroll(amount));
+    }
+
+    public gestureScrollFinish() {
+        this.do((clientManager, desktopManager) => desktopManager.getCurrentDesktop().gestureScrollFinish());
+    }
+
     public destroy() {
         this.workspaceSignalManager.destroy();
         for (const shortcutAction of this.shortcutActions) {

src/lib/world/clientState/Docked.ts

@@ -9,7 +9,7 @@ namespace ClientState {
             world.onScreenResized();
         }
 
-        public destroy(passFocus: boolean) {
+        public destroy(passFocus: FocusPassing.Type) {
             this.signalManager.destroy();
             this.world.onScreenResized();
         }

src/lib/world/clientState/Floating.ts

@@ -16,7 +16,7 @@ namespace ClientState {
             this.signalManager = Floating.initSignalManager(world, client.kwinClient);
         }
 
-        public destroy(passFocus: boolean) {
+        public destroy(passFocus: FocusPassing.Type) {
             this.signalManager.destroy();
         }
 

src/lib/world/clientState/Manager.ts

@@ -6,7 +6,7 @@ namespace ClientState {
             this.state = initialState;
         }
 
-        public setState(constructNewState: () => State, passFocus: boolean) {
+        public setState(constructNewState: () => State, passFocus: FocusPassing.Type) {
             this.state.destroy(passFocus);
             this.state = constructNewState();
         }
@@ -15,12 +15,12 @@ namespace ClientState {
             return this.state;
         }
 
-        public destroy(passFocus: boolean) {
+        public destroy(passFocus: FocusPassing.Type) {
             this.state.destroy(passFocus);
         }
     }
 
-    export type State = {
+    export interface State {
-        destroy(passFocus: boolean): void;
+        destroy(passFocus: FocusPassing.Type): void;
-    };
+    }
 }

src/lib/world/clientState/Pinned.ts

@@ -17,7 +17,7 @@ namespace ClientState {
             this.signalManager = Pinned.initSignalManager(world, pinManager, kwinClient);
         }
 
-        public destroy(passFocus: boolean) {
+        public destroy(passFocus: FocusPassing.Type) {
             this.signalManager.destroy();
             this.pinManager.removeClient(this.kwinClient);
             for (const desktop of this.desktopManager.getDesktopsForClient(this.kwinClient)) {

src/lib/world/clientState/Tiled.ts

@@ -16,7 +16,7 @@ namespace ClientState {
             this.signalManager = Tiled.initSignalManager(world, window, grid.config);
         }
 
-        public destroy(passFocus: boolean) {
+        public destroy(passFocus: FocusPassing.Type) {
             this.signalManager.destroy();
 
             const window = this.window;
@@ -54,7 +54,7 @@ namespace ClientState {
                     }
                     Tiled.moveWindowToGrid(window, desktop.grid);
                 });
-            })
+            });
 
             manager.connect(kwinClient.minimizedChanged, () => {
                 console.assert(kwinClient.minimized);
@@ -113,7 +113,7 @@ namespace ClientState {
                 }
             });
 
-            let externalFrameGeometryChangedRateLimiter = new RateLimiter(4, Tiled.maxExternalFrameGeometryChangedIntervalMs);
+            const externalFrameGeometryChangedRateLimiter = new RateLimiter(4, Tiled.maxExternalFrameGeometryChangedIntervalMs);
             manager.connect(kwinClient.frameGeometryChanged, (oldGeometry: QmlRect) => {
                 // on Wayland, this fires after `tileChanged`
                 if (kwinClient.tile !== null) {
@@ -209,17 +209,26 @@ namespace ClientState {
             }
 
             const newColumn = new Column(grid, grid.getLastFocusedColumn() ?? grid.getLastColumn());
-            window.moveToColumn(newColumn, true);
+            const passFocus = window.isFocused() ? FocusPassing.Type.OnUnfocus : FocusPassing.Type.None;
+            window.moveToColumn(newColumn, true, passFocus);
         }
 
         private static prepareClientForTiling(client: ClientWrapper, config: LayoutConfig) {
             if (config.skipSwitcher) {
                 client.kwinClient.skipSwitcher = true;
             }
-            if (config.tiledKeepBelow) {
+
-                client.kwinClient.keepBelow = true;
+            if (client.kwinClient.fullScreen) {
+                if (config.maximizedKeepAbove) {
+                    client.kwinClient.keepAbove = true;
+                }
+            } else {
+                if (config.tiledKeepBelow) {
+                    client.kwinClient.keepBelow = true;
+                }
+                client.kwinClient.keepAbove = false;
             }
-            client.kwinClient.keepAbove = false;
+
             if (client.kwinClient.tile !== null) {
                 client.setMaximize(false, true); // disable quick tile mode
             }
@@ -245,8 +254,8 @@ namespace ClientState {
     }
 
     namespace Tiled {
-        export type WindowState = {
+        export interface WindowState {
             skipSwitcher: boolean;
-        };
+        }
     }
 }

src/lib/world/clientState/TiledMinimized.ts

@@ -6,7 +6,7 @@ namespace ClientState {
             this.signalManager = TiledMinimized.initSignalManager(world, client);
         }
 
-        public destroy(passFocus: boolean) {
+        public destroy(passFocus: FocusPassing.Type) {
             this.signalManager.destroy();
         }
 

src/tests/flows/cursorFollowsFocus.ts

@@ -0,0 +1,36 @@
+tests.register("Drag tiled window, untile", 10, () => {
+    const config = getDefaultConfig();
+    config.cursorFollowsFocus = true;
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const [client1, client2] = workspaceMock.createClients(2);
+    const initialCursorPos = new MockQmlPoint(380, 20);
+    Assert.assert(rectContainsPoint(client1.frameGeometry, initialCursorPos), { message: "invalid test setup" });
+    workspaceMock.cursorPos = initialCursorPos.clone();
+
+    runOneOf(
+        () => { Workspace.activeWindow = client1; },
+        () => { qtMock.fireShortcut("karousel-focus-1"); },
+    );
+    Assert.assert(rectContainsPoint(client1.frameGeometry, Workspace.cursorPos));
+    Assert.assert(!rectContainsPoint(client2.frameGeometry, Workspace.cursorPos));
+    Assert.assert(pointEquals(Workspace.cursorPos, initialCursorPos), { message: "Cursor should not have been moved because it was already within the focused client" });
+
+    runOneOf(
+        () => { Workspace.activeWindow = client2; },
+        () => { qtMock.fireShortcut("karousel-focus-2"); },
+    );
+    Assert.assert(!rectContainsPoint(client1.frameGeometry, Workspace.cursorPos));
+    Assert.assert(rectContainsPoint(client2.frameGeometry, Workspace.cursorPos));
+
+    runOneOf(
+        () => { Workspace.activeWindow = client1; },
+        () => { qtMock.fireShortcut("karousel-focus-1"); },
+    );
+    Assert.assert(rectContainsPoint(client1.frameGeometry, Workspace.cursorPos));
+    Assert.assert(!rectContainsPoint(client2.frameGeometry, Workspace.cursorPos));
+    const lastCursorPos = workspaceMock.cursorPos.clone();
+
+    Workspace.activeWindow = null;
+    Assert.assert(pointEquals(Workspace.cursorPos, lastCursorPos), { message: "Cursor should not have been moved" });
+});

src/tests/flows/followWindowToDesktop.ts

@@ -0,0 +1,10 @@
+tests.register("Move and follow window to desktop", 20, () => {
+    // This tests the Kwin shortcuts for moving windows to adjacent desktops.
+
+    const config = getDefaultConfig();
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const [client0, client1] = workspaceMock.createClients(2);
+    client1.moveAndFollowToDesktop(workspaceMock.desktops[1], workspaceMock);
+    Assert.equal(workspaceMock.activeWindow, client1);
+});

src/tests/flows/lazyScroller.ts

@@ -16,18 +16,18 @@ tests.register("LazyScroller", 20, () => {
     Assert.equal(client3.frameGeometry.right, tilingArea.right);
 
     runOneOf(
-        () => workspaceMock.activeWindow = client2,
+        () => { workspaceMock.activeWindow = client2; },
-        () => qtMock.fireShortcut("karousel-focus-2"),
+        () => { qtMock.fireShortcut("karousel-focus-2"); },
-        () => qtMock.fireShortcut("karousel-focus-left"),
+        () => { qtMock.fireShortcut("karousel-focus-left"); },
     );
     Assert.grid(config, tilingArea, 300, [[client1], [client2], [client3]], false);
     Assert.equal(client3.frameGeometry.right, tilingArea.right);
 
     runOneOf(
-        () => workspaceMock.activeWindow = client1,
+        () => { workspaceMock.activeWindow = client1; },
-        () => qtMock.fireShortcut("karousel-focus-1"),
+        () => { qtMock.fireShortcut("karousel-focus-1"); },
-        () => qtMock.fireShortcut("karousel-focus-left"),
+        () => { qtMock.fireShortcut("karousel-focus-left"); },
-        () => qtMock.fireShortcut("karousel-focus-start"),
+        () => { qtMock.fireShortcut("karousel-focus-start"); },
     );
     workspaceMock.activeWindow = client1;
     Assert.grid(config, tilingArea, 300, [[client1], [client2], [client3]], false);
@@ -38,9 +38,9 @@ tests.register("LazyScroller", 20, () => {
     Assert.grid(config, tilingArea, 300, [[client1]], true);
 
     runOneOf(
-        () => workspaceMock.activeWindow = client2,
+        () => { workspaceMock.activeWindow = client2; },
-        () => qtMock.fireShortcut("karousel-focus-2"),
+        () => { qtMock.fireShortcut("karousel-focus-2"); },
-        () => qtMock.fireShortcut("karousel-focus-right"),
+        () => { qtMock.fireShortcut("karousel-focus-right"); },
     );
     Assert.grid(config, tilingArea, 300, [[client1], [client2], [client3]], false);
     Assert.equal(client1.frameGeometry.left, tilingArea.left);

src/tests/flows/maximization.ts

@@ -1,214 +1,341 @@
-tests.register("Maximization", 100, () => {
+{
-    const config = getDefaultConfig();
+    function registerTests(
-    const { qtMock, workspaceMock, world } = init(config);
+        suffix: string,
+        getConfig: () => Config,
+        shouldKeepBelow: (tiled: boolean) => boolean,
+        shouldKeepAbove: (tiled: boolean) => boolean,
+    ) {
+        tests.register("Maximization " + suffix, 100, () => {
+            const config = getConfig();
+            const { qtMock, workspaceMock, world } = init(config);
 
-    const [kwinClient] = workspaceMock.createClientsWithWidths(300);
+            const [kwinClient] = workspaceMock.createClientsWithWidths(300);
-    world.do((clientManager, desktopManager) => {
+            world.do((clientManager, desktopManager) => {
-        Assert.assert(clientManager.hasClient(kwinClient));
+                Assert.assert(clientManager.hasClient(kwinClient));
-    });
+            });
 
-    const columnLeftX = tilingArea.left + tilingArea.width/2 - 300/2;
+            const columnLeftX = tilingArea.left + tilingArea.width/2 - 300/2;
-    const columnTopY = tilingArea.top;
+            const columnTopY = tilingArea.top;
-    const columnHeight = tilingArea.height;
+            const columnHeight = tilingArea.height;
-    Assert.rect(kwinClient.frameGeometry, columnLeftX, columnTopY, 300, columnHeight);
+            Assert.assert(!kwinClient.fullScreen);
+            Assert.equal(kwinClient.keepBelow, shouldKeepBelow(true));
+            Assert.equal(kwinClient.keepAbove, shouldKeepAbove(true));
+            Assert.rect(kwinClient.frameGeometry, columnLeftX, columnTopY, 300, columnHeight);
 
-    kwinClient.fullScreen = true;
+            kwinClient.fullScreen = true;
-    Assert.equalRects(kwinClient.frameGeometry, screen);
+            Assert.assert(kwinClient.fullScreen);
+            Assert.equal(kwinClient.keepBelow, shouldKeepBelow(false));
+            Assert.equal(kwinClient.keepAbove, shouldKeepAbove(false));
+            Assert.equalRects(kwinClient.frameGeometry, screen);
 
-    kwinClient.fullScreen = false;
+            kwinClient.fullScreen = false;
-    Assert.rect(kwinClient.frameGeometry, columnLeftX, columnTopY, 300, columnHeight);
+            Assert.assert(!kwinClient.fullScreen);
+            Assert.equal(kwinClient.keepBelow, shouldKeepBelow(true));
+            Assert.equal(kwinClient.keepAbove, shouldKeepAbove(true));
+            Assert.rect(kwinClient.frameGeometry, columnLeftX, columnTopY, 300, columnHeight);
 
-    kwinClient.setMaximize(true, true);
+            kwinClient.setMaximize(true, true);
-    Assert.equalRects(kwinClient.frameGeometry, screen);
+            Assert.assert(!kwinClient.fullScreen);
+            Assert.equal(kwinClient.keepBelow, shouldKeepBelow(false));
+            Assert.equal(kwinClient.keepAbove, shouldKeepAbove(false));
+            Assert.equalRects(kwinClient.frameGeometry, screen);
 
-    kwinClient.setMaximize(true, false);
+            kwinClient.setMaximize(true, false);
-    Assert.rect(kwinClient.frameGeometry, columnLeftX, 0, 300, screen.height);
+            Assert.assert(!kwinClient.fullScreen);
+            Assert.equal(kwinClient.keepBelow, shouldKeepBelow(false));
+            Assert.equal(kwinClient.keepAbove, shouldKeepAbove(false));
+            Assert.rect(kwinClient.frameGeometry, columnLeftX, 0, 300, screen.height);
 
-    kwinClient.setMaximize(false, false);
+            kwinClient.setMaximize(false, false);
-    Assert.rect(kwinClient.frameGeometry, columnLeftX, columnTopY, 300, columnHeight);
+            Assert.assert(!kwinClient.fullScreen);
-});
+            Assert.equal(kwinClient.keepBelow, shouldKeepBelow(true));
+            Assert.equal(kwinClient.keepAbove, shouldKeepAbove(true));
+            Assert.rect(kwinClient.frameGeometry, columnLeftX, columnTopY, 300, columnHeight);
+        });
 
-tests.register("Maximize with transient", 100, () => {
+        tests.register("Maximize with transient " + suffix, 100, () => {
-    const config = getDefaultConfig();
+            const config = getConfig();
-    const { qtMock, workspaceMock, world } = init(config);
+            const { qtMock, workspaceMock, world } = init(config);
 
-    const parent = new MockKwinClient(new MockQmlRect(10, 20, 300, 200));
+            const parent = new MockKwinClient(new MockQmlRect(10, 20, 300, 200));
-    const child = new MockKwinClient(new MockQmlRect(14, 24, 50, 50), parent);
+            const child = new MockKwinClient(new MockQmlRect(14, 24, 50, 50), parent);
 
-    workspaceMock.createWindows(parent);
+            workspaceMock.createWindows(parent);
-    world.do((clientManager, desktopManager) => {
+            world.do((clientManager, desktopManager) => {
-        Assert.assert(clientManager.hasClient(parent));
+                Assert.assert(clientManager.hasClient(parent));
-    });
+            });
 
-    runOneOf(
+            runOneOf(
-        () => parent.fullScreen = true,
+                () => { parent.fullScreen = true; },
-        () => parent.setMaximize(true, true),
+                () => { parent.setMaximize(true, true); },
-    );
+            );
-    Assert.equalRects(parent.frameGeometry, screen);
+            Assert.equal(parent.keepBelow, shouldKeepBelow(false));
+            Assert.equal(parent.keepAbove, shouldKeepAbove(false));
+            Assert.equalRects(parent.frameGeometry, screen);
 
-    workspaceMock.createWindows(child);
+            workspaceMock.createWindows(child);
-    world.do((clientManager, desktopManager) => {
+            world.do((clientManager, desktopManager) => {
-        Assert.assert(clientManager.hasClient(child));
+                Assert.assert(clientManager.hasClient(child));
-    });
+            });
-    Assert.rect(child.frameGeometry, 14, 24, 50, 50);
+            Assert.assert(!child.fullScreen);
-    Assert.equalRects(parent.frameGeometry, screen);
+            Assert.equal(child.keepBelow, shouldKeepBelow(false));
-});
+            Assert.equal(child.keepAbove, shouldKeepAbove(false));
+            Assert.rect(child.frameGeometry, 14, 24, 50, 50);
+            Assert.equal(parent.keepBelow, shouldKeepBelow(false));
+            Assert.equal(parent.keepAbove, shouldKeepAbove(false));
+            Assert.equalRects(parent.frameGeometry, screen);
+        });
 
-tests.register("Re-maximize disabled", 100, () => {
+        {
-    const config = getDefaultConfig();
+            function assertWindowed(config: Config, clients: KwinClient[]) {
-    config.reMaximize = false;
+                Assert.assert(!clients[0].fullScreen);
-    const { qtMock, workspaceMock, world } = init(config);
+                Assert.equal(clients[0].keepBelow, shouldKeepBelow(true));
+                Assert.equal(clients[0].keepAbove, shouldKeepAbove(true));
+                Assert.assert(!clients[1].fullScreen);
+                Assert.equal(clients[1].keepBelow, shouldKeepBelow(true));
+                Assert.equal(clients[1].keepAbove, shouldKeepAbove(true));
+                Assert.assert(!clients[2].fullScreen);
+                Assert.equal(clients[2].keepBelow, shouldKeepBelow(true));
+                Assert.equal(clients[2].keepAbove, shouldKeepAbove(true));
+                Assert.grid(config, tilingArea, [300, 400], [[clients[0]], [clients[1], clients[2]]], true);
+            }
 
-    const [client1, client2] = workspaceMock.createClientsWithWidths(300, 400);
+            function assertFullScreenOrMaximized(clients: KwinClient[]) {
-    world.do((clientManager, desktopManager) => {
+                Assert.assert(!clients[0].fullScreen);
-        Assert.assert(clientManager.hasClient(client1));
+                Assert.equal(clients[0].keepBelow, shouldKeepBelow(true));
-        Assert.assert(clientManager.hasClient(client2));
+                Assert.equal(clients[0].keepAbove, shouldKeepAbove(true));
-    });
+                Assert.assert(!clients[1].fullScreen);
+                Assert.equal(clients[1].keepBelow, shouldKeepBelow(true));
+                Assert.equal(clients[1].keepAbove, shouldKeepAbove(true));
+                Assert.equal(clients[2].keepBelow, shouldKeepBelow(false));
+                Assert.equal(clients[2].keepAbove, shouldKeepAbove(false));
+                Assert.equalRects(clients[2].frameGeometry, screen);
+            }
 
-    const columnsWidth = 300 + 400 + config.gapsInnerHorizontal;
+            tests.register("Re-maximize disabled " + suffix, 100, () => {
-    const column1LeftX = tilingArea.left + tilingArea.width/2 - columnsWidth/2;
+                const config = getConfig();
-    const column2LeftX = column1LeftX + 300 + config.gapsInnerHorizontal;
+                config.reMaximize = false;
-    const columnTopY = tilingArea.top;
+                const { qtMock, workspaceMock, world } = init(config);
-    const columnHeight = tilingArea.height;
-    Assert.rect(client1.frameGeometry, column1LeftX, columnTopY, 300, columnHeight);
-    Assert.rect(client2.frameGeometry, column2LeftX, columnTopY, 400, columnHeight);
 
-    runOneOf(
+                const clients = workspaceMock.createClientsWithWidths(300, 400, 400);
-        () => client2.fullScreen = true,
+                qtMock.fireShortcut("karousel-window-move-left");
-        () => client2.setMaximize(true, true),
-    );
-    Assert.rect(client1.frameGeometry, column1LeftX, columnTopY, 300, columnHeight);
-    Assert.equalRects(client2.frameGeometry, screen);
 
-    runOneOf(
+                assertWindowed(config, clients);
-        () => workspaceMock.activeWindow = client1,
-        () => qtMock.fireShortcut("karousel-focus-1"),
-        () => qtMock.fireShortcut("karousel-focus-left"),
-        () => qtMock.fireShortcut("karousel-focus-start"),
-    );
-    Assert.rect(client1.frameGeometry, column1LeftX, columnTopY, 300, columnHeight);
-    Assert.rect(client2.frameGeometry, column2LeftX, columnTopY, 400, columnHeight);
 
-    runOneOf(
+                runOneOf(
-        () => workspaceMock.activeWindow = client2,
+                    () => { clients[2].fullScreen = true; },
-        () => qtMock.fireShortcut("karousel-focus-2"),
+                    () => { clients[2].setMaximize(true, true); },
-        () => qtMock.fireShortcut("karousel-focus-right"),
+                );
-        () => qtMock.fireShortcut("karousel-focus-end"),
+                assertFullScreenOrMaximized(clients);
-    );
-    Assert.rect(client1.frameGeometry, column1LeftX, columnTopY, 300, columnHeight);
-    Assert.rect(client2.frameGeometry, column2LeftX, columnTopY, 400, columnHeight);
-});
 
-tests.register("Re-maximize enabled", 100, () => {
+                runOneOf(
-    const config = getDefaultConfig();
+                    () => { workspaceMock.activeWindow = clients[0]; },
-    config.reMaximize = true;
+                    () => { qtMock.fireShortcut("karousel-focus-1"); },
-    const { qtMock, workspaceMock, world } = init(config);
+                    () => { qtMock.fireShortcut("karousel-focus-left"); },
+                    () => { qtMock.fireShortcut("karousel-focus-start"); },
+                );
+                assertWindowed(config, clients);
 
-    const [client1, client2] = workspaceMock.createClientsWithWidths(300, 400);
+                runOneOf(
-    world.do((clientManager, desktopManager) => {
+                    () => { workspaceMock.activeWindow = clients[2]; },
-        Assert.assert(clientManager.hasClient(client1));
+                    () => { qtMock.fireShortcut("karousel-focus-2"); },
-        Assert.assert(clientManager.hasClient(client2));
+                    () => { qtMock.fireShortcut("karousel-focus-right"); },
-    });
+                    () => { qtMock.fireShortcut("karousel-focus-end"); },
+                );
+                assertWindowed(config, clients);
 
-    const columnsWidth = 300 + 400 + config.gapsInnerHorizontal;
+                runOneOf(
-    const column1LeftX = tilingArea.left + tilingArea.width/2 - columnsWidth/2;
+                    () => { clients[2].fullScreen = true; },
-    const column2LeftX = column1LeftX + 300 + config.gapsInnerHorizontal;
+                    () => { clients[2].setMaximize(true, true); },
-    const columnTopY = tilingArea.top;
+                );
-    const columnHeight = tilingArea.height;
+                assertFullScreenOrMaximized(clients);
-    Assert.rect(client1.frameGeometry, column1LeftX, columnTopY, 300, columnHeight);
-    Assert.rect(client2.frameGeometry, column2LeftX, columnTopY, 400, columnHeight);
 
-    runOneOf(
+                runOneOf(
-        () => client2.fullScreen = true,
+                    () => { workspaceMock.activeWindow = clients[1]; },
-        () => client2.setMaximize(true, true),
+                    () => { qtMock.fireShortcut("karousel-focus-up"); },
-    );
+                );
-    Assert.rect(client1.frameGeometry, column1LeftX, columnTopY, 300, columnHeight);
+                assertWindowed(config, clients);
-    Assert.equalRects(client2.frameGeometry, screen);
 
-    runOneOf(
+                runOneOf(
-        () => workspaceMock.activeWindow = client1,
+                    () => { workspaceMock.activeWindow = clients[2]; },
-        () => qtMock.fireShortcut("karousel-focus-1"),
+                    () => { qtMock.fireShortcut("karousel-focus-down"); },
-        () => qtMock.fireShortcut("karousel-focus-left"),
+                );
-        () => qtMock.fireShortcut("karousel-focus-start"),
+                assertWindowed(config, clients);
-    );
+            });
-    Assert.rect(client1.frameGeometry, column1LeftX, columnTopY, 300, columnHeight);
-    Assert.rect(client2.frameGeometry, column2LeftX, columnTopY, 400, columnHeight);
 
-    runOneOf(
+            tests.register("Re-maximize enabled " + suffix, 100, () => {
-        () => workspaceMock.activeWindow = client2,
+                const config = getConfig();
-        () => qtMock.fireShortcut("karousel-focus-2"),
+                config.reMaximize = true;
-        () => qtMock.fireShortcut("karousel-focus-right"),
+                const { qtMock, workspaceMock, world } = init(config);
-        () => qtMock.fireShortcut("karousel-focus-end"),
-    );
-    Assert.rect(client1.frameGeometry, column1LeftX, columnTopY, 300, columnHeight);
-    Assert.equalRects(client2.frameGeometry, screen);
-});
 
-tests.register("Start full-screen", 100, () => {
+                const clients = workspaceMock.createClientsWithWidths(300, 400, 400);
-    const config = getDefaultConfig();
+                qtMock.fireShortcut("karousel-window-move-left");
-    config.reMaximize = true;
-    const { qtMock, workspaceMock, world } = init(config);
 
-    const [windowedClient] = workspaceMock.createClientsWithWidths(300);
+                assertWindowed(config, clients);
-    const fullScreenClient = new MockKwinClient(new MockQmlRect(0, 0, 400, 200));
-    fullScreenClient.resourceClass = "full-screen-app";
-    fullScreenClient.fullScreen = true;
-    workspaceMock.createWindows(fullScreenClient);
 
-    world.do((clientManager, desktopManager) => {
+                runOneOf(
-        Assert.assert(clientManager.hasClient(windowedClient));
+                    () => { clients[2].fullScreen = true; },
-        Assert.assert(clientManager.hasClient(fullScreenClient));
+                    () => { clients[2].setMaximize(true, true); },
-    });
+                );
+                assertFullScreenOrMaximized(clients);
 
-    Assert.centered(config, tilingArea, windowedClient);
+                runOneOf(
-    Assert.equalRects(fullScreenClient.frameGeometry, screen);
+                    () => { workspaceMock.activeWindow = clients[0]; },
-    Assert.equal(Workspace.activeWindow, fullScreenClient);
+                    () => { qtMock.fireShortcut("karousel-focus-1"); },
+                    () => { qtMock.fireShortcut("karousel-focus-left"); },
+                    () => { qtMock.fireShortcut("karousel-focus-start"); },
+                );
+                assertWindowed(config, clients);
 
-    {
+                runOneOf(
-        qtMock.fireShortcut("karousel-focus-left");
+                    () => { workspaceMock.activeWindow = clients[2]; },
-        const opts = { message: "fullScreenClient is not in the grid, so we can't move focus directionally" };
+                    () => { qtMock.fireShortcut("karousel-focus-2"); },
-        Assert.centered(config, tilingArea, windowedClient, opts);
+                    () => { qtMock.fireShortcut("karousel-focus-right"); },
-        Assert.equalRects(fullScreenClient.frameGeometry, screen, opts);
+                    () => { qtMock.fireShortcut("karousel-focus-end"); },
-        Assert.equal(Workspace.activeWindow, fullScreenClient, opts);
+                );
+                assertFullScreenOrMaximized(clients);
+
+                runOneOf(
+                    () => { workspaceMock.activeWindow = clients[1]; },
+                    () => { qtMock.fireShortcut("karousel-focus-up"); },
+                );
+                assertWindowed(config, clients);
+
+                runOneOf(
+                    () => { workspaceMock.activeWindow = clients[2]; },
+                    () => { qtMock.fireShortcut("karousel-focus-down"); },
+                );
+                assertFullScreenOrMaximized(clients);
+            });
+        }
+
+        tests.register("Start full-screen " + suffix, 100, () => {
+            const config = getConfig();
+            config.reMaximize = true;
+            const { qtMock, workspaceMock, world } = init(config);
+
+            const [windowedClient] = workspaceMock.createClientsWithWidths(300);
+            const fullScreenClient = new MockKwinClient(new MockQmlRect(0, 0, 400, 200));
+            fullScreenClient.resourceClass = "full-screen-app";
+            fullScreenClient.fullScreen = true;
+            workspaceMock.createWindows(fullScreenClient);
+
+            world.do((clientManager, desktopManager) => {
+                Assert.assert(clientManager.hasClient(windowedClient));
+                Assert.assert(clientManager.hasClient(fullScreenClient));
+            });
+
+            Assert.assert(!windowedClient.fullScreen);
+            Assert.equal(windowedClient.keepBelow, shouldKeepBelow(true));
+            Assert.equal(windowedClient.keepAbove, shouldKeepAbove(true));
+            Assert.centered(config, tilingArea, windowedClient);
+            Assert.assert(fullScreenClient.fullScreen);
+            Assert.equal(fullScreenClient.keepBelow, shouldKeepBelow(false));
+            Assert.equal(fullScreenClient.keepAbove, shouldKeepAbove(false));
+            Assert.equalRects(fullScreenClient.frameGeometry, screen);
+            Assert.equal(Workspace.activeWindow, fullScreenClient);
+
+            {
+                qtMock.fireShortcut("karousel-focus-left");
+                const opts = { message: "fullScreenClient is not in the grid, so we can't move focus directionally" };
+                Assert.assert(!windowedClient.fullScreen);
+                Assert.equal(windowedClient.keepBelow, shouldKeepBelow(true));
+                Assert.equal(windowedClient.keepAbove, shouldKeepAbove(true));
+                Assert.centered(config, tilingArea, windowedClient);
+                Assert.assert(fullScreenClient.fullScreen);
+                Assert.equal(fullScreenClient.keepBelow, shouldKeepBelow(false));
+                Assert.equal(fullScreenClient.keepAbove, shouldKeepAbove(false));
+                Assert.equalRects(fullScreenClient.frameGeometry, screen);
+                Assert.equal(Workspace.activeWindow, fullScreenClient, opts);
+            }
+
+            {
+                qtMock.fireShortcut("karousel-focus-1");
+                const opts = { message: "fullScreenClient is not in grid, so it should stay full-screen" };
+                Assert.assert(!windowedClient.fullScreen);
+                Assert.equal(windowedClient.keepBelow, shouldKeepBelow(true));
+                Assert.equal(windowedClient.keepAbove, shouldKeepAbove(true));
+                Assert.centered(config, tilingArea, windowedClient);
+                Assert.assert(fullScreenClient.fullScreen);
+                Assert.equal(fullScreenClient.keepBelow, shouldKeepBelow(false));
+                Assert.equal(fullScreenClient.keepAbove, shouldKeepAbove(false));
+                Assert.equalRects(fullScreenClient.frameGeometry, screen);
+                Assert.equal(Workspace.activeWindow, windowedClient);
+            }
+        });
+
+        tests.register("Start full-screen (force tiling) " + suffix, 100, () => {
+            const config = getConfig();
+            config.reMaximize = true;
+            config.windowRules = '[{ "class": "full-screen-app", "tile": true }]';
+            const { qtMock, workspaceMock, world } = init(config);
+
+            const column1Width = 300;
+            const [windowedClient] = workspaceMock.createClientsWithWidths(column1Width);
+            const fullScreenClient = new MockKwinClient(new MockQmlRect(0, 0, 400, 200));
+            fullScreenClient.resourceClass = "full-screen-app";
+            fullScreenClient.fullScreen = true;
+            workspaceMock.createWindows(fullScreenClient);
+
+            world.do((clientManager, desktopManager) => {
+                Assert.assert(clientManager.hasClient(windowedClient));
+                Assert.assert(clientManager.hasClient(fullScreenClient));
+            });
+            Assert.assert(!windowedClient.fullScreen);
+            Assert.equal(windowedClient.keepBelow, shouldKeepBelow(true));
+            Assert.equal(windowedClient.keepAbove, shouldKeepAbove(true));
+            Assert.grid(config, tilingArea, [column1Width], [[windowedClient]], false);
+            Assert.assert(fullScreenClient.fullScreen);
+            Assert.equal(fullScreenClient.keepBelow, shouldKeepBelow(false));
+            Assert.equal(fullScreenClient.keepAbove, shouldKeepAbove(false));
+            Assert.equalRects(fullScreenClient.frameGeometry, screen);
+            Assert.equal(Workspace.activeWindow, fullScreenClient);
+
+            let expectedColumn2Width = 0;
+            let expectedActiveWindow;
+            runOneOf(
+                () => {
+                    fullScreenClient.fullScreen = false;
+                    expectedColumn2Width = 400;
+                    expectedActiveWindow = fullScreenClient;
+                },
+                () => {
+                    qtMock.fireShortcut("karousel-focus-left");
+                    expectedColumn2Width = tilingArea.width;
+                    expectedActiveWindow = windowedClient;
+                },
+            );
+
+            const opts = { message: "fullScreenClient should be restored from full-screen mode to tiled mode" };
+            Assert.assert(!windowedClient.fullScreen);
+            Assert.equal(windowedClient.keepBelow, shouldKeepBelow(true));
+            Assert.equal(windowedClient.keepAbove, shouldKeepAbove(true));
+            Assert.assert(!fullScreenClient.fullScreen);
+            Assert.equal(fullScreenClient.keepBelow, shouldKeepBelow(true));
+            Assert.equal(fullScreenClient.keepAbove, shouldKeepAbove(true));
+            Assert.grid(config, tilingArea, [column1Width, expectedColumn2Width], [[windowedClient], [fullScreenClient]], false, [], opts);
+            Assert.equal(Workspace.activeWindow, expectedActiveWindow);
+        });
     }
 
-    {
+    function getConfig(floatingKeepAbove: boolean) {
-        qtMock.fireShortcut("karousel-focus-1");
+        const config = getDefaultConfig();
-        const opts = { message: "fullScreenClient is not in grid, so it should stay full-screen" };
+        config.tiledKeepBelow = !floatingKeepAbove;
-        Assert.centered(config, tilingArea, windowedClient, opts);
+        config.floatingKeepAbove = floatingKeepAbove;
-        Assert.equalRects(fullScreenClient.frameGeometry, screen, opts);
+        return config;
-        Assert.equal(Workspace.activeWindow, windowedClient);
     }
-});
 
-tests.register("Start full-screen (force tiling)", 100, () => {
+    registerTests(
-    const config = getDefaultConfig();
+        "(tiled below)",
-    config.reMaximize = true;
+        getConfig.partial(false),
-    config.windowRules = '[{ "class": "full-screen-app", "tile": true }]';
+        tiled => tiled,
-    const { qtMock, workspaceMock, world } = init(config);
+        tiled => false,
+    );
 
-    const column1Width = 300;
+    registerTests(
-    const [windowedClient] = workspaceMock.createClientsWithWidths(column1Width);
+        "(floating above)",
-    const fullScreenClient = new MockKwinClient(new MockQmlRect(0, 0, 400, 200));
+        getConfig.partial(true),
-    fullScreenClient.resourceClass = "full-screen-app";
+        tiled => false,
-    fullScreenClient.fullScreen = true;
+        tiled => !tiled,
-    workspaceMock.createWindows(fullScreenClient);
+    );
-
+}
-    world.do((clientManager, desktopManager) => {
-        Assert.assert(clientManager.hasClient(windowedClient));
-        Assert.assert(clientManager.hasClient(fullScreenClient));
-    });
-    Assert.equalRects(fullScreenClient.frameGeometry, screen);
-    Assert.equal(Workspace.activeWindow, fullScreenClient);
-
-    const column2Width = tilingArea.width;
-    const column1LeftX = tilingArea.left;
-    const column2LeftX = column1LeftX + column1Width + gapH;
-    const columnTopY = tilingArea.top;
-    const columnHeight = tilingArea.height;
-    qtMock.fireShortcut("karousel-focus-left");
-    const opts = { message: "fullScreenClient should be restored from full-screen mode to tiled mode" };
-    Assert.rect(windowedClient.frameGeometry, column1LeftX, columnTopY, column1Width, columnHeight, opts);
-    Assert.rect(fullScreenClient.frameGeometry, column2LeftX, columnTopY, column2Width, columnHeight, opts);
-    Assert.equal(Workspace.activeWindow, windowedClient);
-});

src/tests/flows/passFocus.ts

@@ -1,4 +1,4 @@
-tests.register("Pass focus", 20, () => {
+tests.register("Pass focus", 100, () => {
     const config = getDefaultConfig();
     const { qtMock, workspaceMock, world } = init(config);
 
@@ -34,7 +34,4 @@ tests.register("Pass focus", 20, () => {
 
     removeWindow(client0);
     Assert.equal(workspaceMock.activeWindow, client6);
-
-    removeWindow(client6);
-    Assert.equal(workspaceMock.activeWindow, null);
 });

src/tests/units/utils/math.ts

@@ -0,0 +1,53 @@
+tests.register("math", 1, () => {
+    const rect = new MockQmlRect(100, 200, 10, 20);
+    const testCases: {
+        rect: QmlRect,
+        point: QmlPoint,
+        contained: boolean,
+    }[] = [
+        {
+            rect: rect,
+            point: new MockQmlPoint(100, 200),
+            contained: true,
+        },
+        {
+            rect: rect,
+            point: new MockQmlPoint(110, 220),
+            contained: true,
+        },
+        {
+            rect: rect,
+            point: new MockQmlPoint(105, 205),
+            contained: true,
+        },
+        {
+            rect: rect,
+            point: new MockQmlPoint(110.01, 205),
+            contained: false,
+        },
+        {
+            rect: rect,
+            point: new MockQmlPoint(105, 220.01),
+            contained: false,
+        },
+        {
+            rect: rect,
+            point: new MockQmlPoint(16, 205),
+            contained: false,
+        },
+        {
+            rect: rect,
+            point: new MockQmlPoint(105, 16),
+            contained: false,
+        },
+    ];
+
+    for (const testCase of testCases) {
+        const result = rectContainsPoint(testCase.rect, testCase.point);
+        Assert.equal(
+            result,
+            testCase.contained,
+            { message: JSON.stringify(testCase) },
+        );
+    }
+});

src/tests/utils/Assert.ts

@@ -1,5 +1,5 @@
 namespace Assert {
-    type Options = {
+    interface Options {
         message?: string,
         skip?: number,
     }
@@ -126,23 +126,61 @@ namespace Assert {
     export function grid(
         config: Config,
         tilingArea: QmlRect,
-        columnWidth: number,
+        columnWidths: number[] | number,
         grid: KwinClient[][],
         centered: boolean,
         stackedColumns: number[] = [],
         { message, skip=0 }: Options = {},
     ) {
         const nColumns = grid.length;
-        const columnsWidth = nColumns * columnWidth + (nColumns-1) * config.gapsInnerHorizontal;
+        function getGridWidth() {
+            function getColumnsWidth() {
+                if (columnWidths instanceof Array) {
+                    let columnsWidth = 0;
+                    for (const columnWidth of columnWidths) {
+                        columnsWidth += columnWidth;
+                    }
+                    return columnsWidth;
+                } else {
+                    return nColumns * columnWidths;
+                }
+            }
+
+            const gapsWidth = (nColumns-1) * config.gapsInnerHorizontal;
+            return getColumnsWidth() + gapsWidth;
+        }
+
+        function getColumnWidth(column: number) {
+            if (columnWidths instanceof Array) {
+                return columnWidths[column];
+            } else {
+                return columnWidths;
+            }
+        }
+
+        const gridWidth = getGridWidth();
         const startX = centered ?
-            tilingArea.x + (tilingArea.width - columnsWidth) / 2 :
+            tilingArea.x + (tilingArea.width - gridWidth) / 2 :
             grid[0][0].frameGeometry.x;
 
+        function getColumnX(column: number) {
+            if (columnWidths instanceof Array) {
+                let x = startX;
+                for (let i = 0; i < column; i++) {
+                    x += columnWidths[i] + config.gapsInnerHorizontal;
+                }
+                return x;
+            } else {
+                return startX + column * (columnWidths + config.gapsInnerHorizontal);
+            }
+        }
+
         // assumes uniformly sized windows within columns of uniform width
         function getRectInGrid(column: number, window: number, nColumns: number, nWindows: number) {
+            const columnWidth = getColumnWidth(column);
             const windowHeight = (tilingArea.height - config.gapsInnerVertical * (nWindows-1)) / nWindows;
             return new MockQmlRect(
-                startX + column * (columnWidth + config.gapsInnerHorizontal),
+                getColumnX(column),
                 tilingArea.y + (windowHeight + config.gapsInnerVertical) * window,
                 columnWidth,
                 (tilingArea.height - config.gapsInnerVertical * (nWindows-1)) / nWindows,
@@ -150,9 +188,9 @@ namespace Assert {
         }
 
         function getRectInGridStacked(column: number, window: number, nColumns: number, nWindows: number) {
-            const columnX = startX + column * (columnWidth + config.gapsInnerHorizontal);
+            const columnWidth = getColumnWidth(column);
             return new MockQmlRect(
-                columnX + window * config.stackOffsetX,
+                getColumnX(column) + window * config.stackOffsetX,
                 tilingArea.y + window * config.stackOffsetY,
                 columnWidth - (nWindows-1) * config.stackOffsetX,
                 tilingArea.height - (nWindows-1) * config.stackOffsetY,

src/tests/utils/TestRunner.ts

@@ -16,7 +16,7 @@ class TestRunner {
 }
 
 namespace TestRunner {
-    export type Test = {
+    export interface Test {
         name: string,
         count: number,
         f: () => void,

src/tests/utils/global.ts

@@ -4,6 +4,7 @@ let Workspace: Workspace;
 let qmlBase: QmlObject;
 let notificationInvalidWindowRules: Notification;
 let notificationInvalidPresetWidths: Notification;
+let moveCursorToFocus: DBusCall;
 
 let screen: MockQmlRect;
 let tilingArea: MockQmlRect;
@@ -28,6 +29,15 @@ function init(config: Config) {
 
     Qt = qtMock;
     Workspace = workspaceMock;
+    moveCursorToFocus = {
+        __brand: "QmlObject",
+        call: () => {
+            Assert.assert(Workspace.activeWindow !== null, { message: "moveCursorToFocus should never be called if there's no focused window" });
+            const frame = Workspace.activeWindow!.frameGeometry;
+            workspaceMock.cursorPos.x = Math.floor(frame.x + frame.width/2);
+            workspaceMock.cursorPos.y = Math.floor(frame.y + frame.height/2);
+        },
+    };
 
     const world = new World(config);
     return { qtMock, workspaceMock, world };
@@ -51,3 +61,10 @@ function getClientManager(world: World): ClientManager {
     world.do((cm, dm) => clientManager = cm);
     return clientManager!;
 }
+
+function activateRandomWindowOnDesktop(desktop: KwinDesktop) {
+    const windows = Workspace.windows.filter(w => w.desktops.includes(desktop));
+    if (windows.length > 0) {
+        Workspace.activeWindow = randomItem(windows);
+    }
+}

src/tests/utils/mocks/MockKwinClient.ts

@@ -6,8 +6,8 @@ class MockKwinClient {
     public caption = "App";
     public minSize: Readonly<QmlSize> = new MockQmlSize(0, 0);
     public readonly transient: boolean;
-    public move: boolean = false;
+    public move = false;
-    public resize: boolean = false;
+    public resize = false;
     public readonly fullScreenable: boolean = true;
     public readonly maximizable: boolean = true;
     public readonly output: Output = { __brand: "Output" };
@@ -18,17 +18,17 @@ class MockKwinClient {
     public readonly popupWindow: boolean = false;
     public readonly pid = 1;
 
-    private _maximizedVertically: boolean = false;
+    private _maximizedVertically = false;
-    private _maximizedHorizontally: boolean = false;
+    private _maximizedHorizontally = false;
-    private _fullScreen: boolean = false;
+    private _fullScreen = false;
     public activities: string[] = [];
-    public skipSwitcher: boolean = false;
+    public skipSwitcher = false;
-    public keepAbove: boolean = false;
+    public keepAbove = false;
-    public keepBelow: boolean = false;
+    public keepBelow = false;
-    private _minimized: boolean = false;
+    private _minimized = false;
     private _desktops: KwinDesktop[] = [];
     private _tile: Tile|null = null;
-    public opacity: number = 1.0;
+    public opacity = 1.0;
 
     public readonly fullScreenChanged = new MockQSignal<[]>();
     public readonly desktopsChanged = new MockQSignal<[]>();
@@ -42,8 +42,8 @@ class MockKwinClient {
     public readonly frameGeometryChanged = new MockQSignal<[oldGeometry: QmlRect]>();
 
     private windowedFrameGeometry: MockQmlRect;
-    private windowed: boolean = true;
+    private windowed = true;
-    private hasBorder: boolean = true;
+    private hasBorder = true;
 
     constructor(
         private _frameGeometry: MockQmlRect = new MockQmlRect(10, 10, 100, 200),
@@ -68,7 +68,7 @@ class MockKwinClient {
                 horizontally ? MaximizedMode.Maximized : MaximizedMode.Vertically
             ) : (
                 horizontally ? MaximizedMode.Horizontally : MaximizedMode.Unmaximized
-            )
+            ),
         );
 
         this.frameGeometry = new MockQmlRect(
@@ -88,7 +88,15 @@ class MockKwinClient {
                 this.frameGeometry.height - 2 * MockKwinClient.borderThickness,
             );
         } else {
-            return this.frameGeometry;
+            return runOneOf(
+                () => this.frameGeometry,
+                () => new MockQmlRect(
+                    this.frameGeometry.x - 20,
+                    this.frameGeometry.y - 20,
+                    this.frameGeometry.width + 40,
+                    this.frameGeometry.height + 40,
+                ), // some full-screen windows that manage their own window decorations can temporarily have a client geometry bigger than the screen
+            );
         }
     }
 
@@ -107,6 +115,7 @@ class MockKwinClient {
     public set fullScreen(fullScreen: boolean) {
         const oldFullScreen = this._fullScreen;
         this.hasBorder = !fullScreen;
+        const targetFrameGeometry = fullScreen ? screen : this.windowedFrameGeometry;
 
         runReorder(
             () => {
@@ -118,34 +127,34 @@ class MockKwinClient {
             () => {
                 if (oldFullScreen && !fullScreen) {
                     // when switching from full-screen to windowed, Kwin sometimes first adds the frame before changing the frameGeometry to the final value
-                    if (rectEquals(this.frameGeometry, this.windowedFrameGeometry)) {
+                    if (!rectEquals(this.frameGeometry, screen)) {
                         // already has windowed frame geometry, don't undo that
                         return;
                     }
                     runOneOf(
-                        () => this.frameGeometry = new MockQmlRect(
+                        () => {
-                            0,
+                            this.frameGeometry = new MockQmlRect(
-                            0,
+                                0,
-                            screen.width + 2 * MockKwinClient.borderThickness,
+                                0,
-                            screen.height + 2 * MockKwinClient.borderThickness,
+                                screen.width + 2 * MockKwinClient.borderThickness,
-                        ),
+                                screen.height + 2 * MockKwinClient.borderThickness,
-                        () => this.frameGeometry = new MockQmlRect(
+                            );
-                            -MockKwinClient.borderThickness,
+                        },
-                            -MockKwinClient.borderThickness,
+                        () => {
-                            screen.width + 2 * MockKwinClient.borderThickness,
+                            this.frameGeometry = new MockQmlRect(
-                            screen.height + 2 * MockKwinClient.borderThickness,
+                                -MockKwinClient.borderThickness,
-                        ),
+                                -MockKwinClient.borderThickness,
+                                screen.width + 2 * MockKwinClient.borderThickness,
+                                screen.height + 2 * MockKwinClient.borderThickness,
+                            );
+                        },
                         () => {},
                     );
                 }
             },
             () => {
                 this.windowed = !fullScreen;
-                if (fullScreen) {
+                this.frameGeometry = targetFrameGeometry;
-                    this.frameGeometry = screen;
-                } else {
-                    this.frameGeometry = this.windowedFrameGeometry;
-                }
             },
         );
     }
@@ -189,9 +198,20 @@ class MockKwinClient {
         this.desktopsChanged.fire();
         if (Workspace.activeWindow === this && !desktops.includes(Workspace.currentDesktop)) {
             Workspace.activeWindow = null;
+            runMaybe(() => Workspace.activeWindow = null); // fired again for some reason
+            if (Workspace.activeWindow === null) {
+                activateRandomWindowOnDesktop(Workspace.currentDesktop);
+            }
         };
     }
 
+    public moveAndFollowToDesktop(desktop: KwinDesktop, workspaceMock: MockWorkspace) {
+        Assert.assert(workspaceMock.activeWindow === this);
+        this._desktops = [desktop];
+        this.desktopsChanged.fire();
+        workspaceMock.currentDesktop = desktop;
+    }
+
     public get tile() {
         return this._tile;
     }

src/tests/utils/mocks/MockQSignal.ts

@@ -1,7 +1,7 @@
 class MockQSignal<T extends unknown[]> {
     public readonly __brand = "QSignal";
 
-    private readonly handlers: Set<(...args: [...T]) => void> = new Set();
+    private readonly handlers = new Set<(...args: [...T]) => void>();
 
     public connect(handler: (...args: [...T]) => void) {
         this.handlers.add(handler);

src/tests/utils/mocks/MockQmlPoint.ts

@@ -5,4 +5,11 @@ class MockQmlPoint {
         public x: number,
         public y: number,
     ) {}
+
+    public clone() {
+        return new MockQmlPoint(
+            this.x,
+            this.y,
+        );
+    }
 }

src/tests/utils/mocks/MockWorkspace.ts

@@ -4,14 +4,14 @@ class MockWorkspace {
     public activities = ["test-activity"];
     public desktops: KwinDesktop[] = [
         { __brand: "KwinDesktop", id: "desktop1" },
-        { __brand: "KwinDesktop", id: "desktop2" }
+        { __brand: "KwinDesktop", id: "desktop2" },
     ];
-    public currentDesktop = this.desktops[0];
     public currentActivity = this.activities[0];
     public activeScreen: Output = { __brand: "Output" };
     public readonly windows: MockKwinClient[] = [];
     public cursorPos = new MockQmlPoint(0, 0);
 
+    private _currentDesktop = this.desktops[0];
     private _activeWindow: KwinClient|null = null;
 
     public readonly currentDesktopChanged = new MockQSignal<[]>();
@@ -52,13 +52,13 @@ class MockWorkspace {
     }
 
     public removeWindow(window: MockKwinClient) {
+        this.activeWindow = null;
         runReorder(
             () => this.windows.splice(this.windows.indexOf(window), 1),
             () => this.windowRemoved.fire(window),
         );
-        if (window === this.activeWindow) {
+        if (this.activeWindow === null) {
-            const windows = this.windows.filter(w => w.desktops.includes(this.currentDesktop));
+            activateRandomWindowOnDesktop(this.currentDesktop);
-            Workspace.activeWindow = windows.length > 0 ? randomItem(windows) : null;
         };
     }
 
@@ -123,6 +123,15 @@ class MockWorkspace {
         window.interactiveMoveResizeFinished.fire();
     }
 
+    public get currentDesktop() {
+        return this._currentDesktop;
+    }
+
+    public set currentDesktop(currentDesktop: KwinDesktop) {
+        this._currentDesktop = currentDesktop;
+        this.currentDesktopChanged.fire();
+    }
+
     public get activeWindow() {
         return this._activeWindow;
     }

src/tests/utils/random.ts

@@ -4,10 +4,10 @@ function runMaybe(f: () => void) {
     }
 }
 
-function runOneOf(...fs: (() => void)[]) {
+function runOneOf<T>(...fs: (() => T)[]) {
     const index = randomInt(fs.length);
     runLog.push(`${getStackFrame(1)} - Chose ${index}`);
-    fs[index]();
+    return fs[index]();
 }
 
 function runReorder(...fs: (() => void)[]) {
@@ -22,6 +22,12 @@ function runReorder(...fs: (() => void)[]) {
     }
 }
 
+function runReorderDebug(order: number[], ...fs: (() => void)[]) {
+    for (const index of order) {
+        fs[index]();
+    }
+}
+
 function randomInt(n: number) {
     return Math.floor(Math.random() * n);
 }