bump version to 0.9

Makefile

@@ -11,12 +11,12 @@ build:
 	tsc --outFile ./package/contents/code/main.js
 
 install: build config
-	kpackagetool5 --type=KWin/Script -i ./package || kpackagetool5 --type=KWin/Script -u ./package
+	kpackagetool6 --type=KWin/Script -i ./package || kpackagetool6 --type=KWin/Script -u ./package
 
 uninstall:
-	kpackagetool5 --type=KWin/Script -r ./package
+	kpackagetool6 --type=KWin/Script -r karousel
 
-package:
+package: build config
 	tar -czf ./karousel_${subst .,_,${VERSION}}.tar.gz ./package
 
 logs:

README.md

@@ -19,7 +19,7 @@ Similar window managers include [PaperWM](https://github.com/paperwm/PaperWM),
 
 ## Dependencies
 Karousel requires the following QML modules:
-- QtQuick 2.15
+- QtQuick 6.0
 - org.kde.kwin 3.0
 - org.kde.notification 1.0
 

generators/docs/keyBindings.ts

@@ -3,7 +3,6 @@ type KeyBinding = {
     description: string;
     comment?: string;
     defaultKeySequence: string;
-    action: string;
 }
 
 type NumKeyBinding = {
@@ -12,7 +11,6 @@ type NumKeyBinding = {
     comment?: string;
     defaultModifiers: string;
     fKeys: boolean;
-    action: string;
 }
 
 function formatComment(comment: string | undefined) {
@@ -21,7 +19,7 @@ function formatComment(comment: string | undefined) {
 
 function printCols(...columns: (string[] | string)[]) {
     const nCols = columns.length;
-    if (nCols == 0) {
+    if (nCols === 0) {
         return;
     }
 
@@ -30,7 +28,7 @@ function printCols(...columns: (string[] | string)[]) {
     ).map(
         (column: string[] | string) => column.length
     ));
-    if (nRows == Infinity) {
+    if (nRows === Infinity) {
         // we only have single string columns
         nRows = 1;
     }

package/contents/ui/config.ui

@@ -121,6 +121,13 @@
                                                 </property>
                                             </widget>
                                         </item>
+                                        <item>
+                                            <widget class="QRadioButton" name="kcfg_noLayering">
+                                                <property name="text">
+                                                    <string>No layering</string>
+                                                </property>
+                                            </widget>
+                                        </item>
                                     </layout>
                                 </widget>
                             </item>

package/contents/ui/main.qml

@@ -1,7 +1,7 @@
-import QtQuick 2.15
+import QtQuick 6.0
 import org.kde.kwin 3.0
 import org.kde.notification 1.0
-import "./main.js" as Karousel
+import "../code/main.js" as Karousel
 
 Item {
     id: qmlBase

package/metadata.json

@@ -1,20 +1,21 @@
 {
+    "KPackageStructure": "KWin/Script",
     "KPlugin": {
         "Name": "Karousel",
-        "Description": "Manual columnar tiling extension for KWin",
+        "Description": "Scrollable tiling extension for KWin",
         "Icon": "preferences-system-windows",
         "Authors": [{
             "Email": "peter.fajdiga@gmail.com",
             "Name": "Peter Fajdiga"
         }],
         "Id": "karousel",
-        "ServiceTypes": ["KWin/Script"],
-        "Version": "0.7.1",
+        "Version": "0.9",
         "License": "GPLv3",
         "Website": "https://github.com/peterfajdiga/karousel",
         "BugReportUrl": "https://github.com/peterfajdiga/karousel/issues"
     },
     "X-Plasma-API": "declarativescript",
-    "X-Plasma-MainScript": "code/main.qml",
+    "X-Plasma-API-Minimum-Version": "6.0",
+    "X-Plasma-MainScript": "ui/main.qml",
     "X-KDE-ConfigModule": "kwin/effects/configs/kcm_kwin4_genericscripted"
 }

src/Actions.ts

@@ -1,7 +1,7 @@
 namespace Actions {
-    export function init(world: World, config: Config) {
-        return {
-            focusLeft: () => {
+    export function getAction(world: World, config: Config, name: string) {
+        switch (name) {
+            case "focus-left": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const prevColumn = grid.getPrevColumn(column);
                     if (prevColumn === null) {
@@ -9,9 +9,9 @@ namespace Actions {
                     }
                     prevColumn.focus();
                 });
-            },
+            };
 
-            focusRight: () => {
+            case "focus-right": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const nextColumn = grid.getNextColumn(column);
                     if (nextColumn === null) {
@@ -19,9 +19,9 @@ namespace Actions {
                     }
                     nextColumn.focus();
                 });
-            },
+            };
 
-            focusUp: () => {
+            case "focus-up": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const prevWindow = column.getPrevWindow(window);
                     if (prevWindow === null) {
@@ -29,9 +29,9 @@ namespace Actions {
                     }
                     prevWindow.focus();
                 });
-            },
+            };
 
-            focusDown: () => {
+            case "focus-down": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const nextWindow = column.getNextWindow(window);
                     if (nextWindow === null) {
@@ -39,9 +39,9 @@ namespace Actions {
                     }
                     nextWindow.focus();
                 });
-            },
+            };
 
-            focusStart: () => {
+            case "focus-start": return () => {
                 world.do((clientManager, desktopManager) => {
                     const grid = desktopManager.getCurrentDesktop().grid;
                     const firstColumn = grid.getFirstColumn();
@@ -50,9 +50,9 @@ namespace Actions {
                     }
                     firstColumn.focus();
                 });
-            },
+            };
 
-            focusEnd: () => {
+            case "focus-end": return () => {
                 world.do((clientManager, desktopManager) => {
                     const grid = desktopManager.getCurrentDesktop().grid;
                     const lastColumn = grid.getLastColumn();
@@ -61,9 +61,9 @@ namespace Actions {
                     }
                     lastColumn.focus();
                 });
-            },
+            };
 
-            windowMoveLeft: () => {
+            case "window-move-left": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     if (column.getWindowCount() === 1) {
                         // move from own column into existing column
@@ -79,9 +79,9 @@ namespace Actions {
                         window.moveToColumn(newColumn);
                     }
                 });
-            },
+            };
 
-            windowMoveRight: () => {
+            case "window-move-right": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     if (column.getWindowCount() === 1) {
                         // move from own column into existing column
@@ -97,176 +97,100 @@ namespace Actions {
                         window.moveToColumn(newColumn);
                     }
                 });
-            },
+            };
 
-            windowMoveUp: () => {
+            case "window-move-up": return () => {
                 // TODO (optimization): only arrange moved windows
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     column.moveWindowUp(window);
                 });
-            },
+            };
 
-            windowMoveDown: () => {
+            case "window-move-down": return () => {
                 // TODO (optimization): only arrange moved windows
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     column.moveWindowDown(window);
                 });
-            },
+            };
 
-            windowMoveStart: () => {
+            case "window-move-start": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const newColumn = new Column(grid, null);
                     window.moveToColumn(newColumn);
                 });
-            },
+            };
 
-            windowMoveEnd: () => {
+            case "window-move-end": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const newColumn = new Column(grid, grid.getLastColumn());
                     window.moveToColumn(newColumn);
                 });
-            },
+            };
 
-            windowToggleFloating: () => {
-                const kwinClient = workspace.activeClient;
+            case "window-toggle-floating": return () => {
+                const kwinClient = Workspace.activeWindow;
                 world.do((clientManager, desktopManager) => {
                     clientManager.toggleFloatingClient(kwinClient);
                 });
-            },
+            };
 
-            columnMoveLeft: () => {
+            case "column-move-left": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     grid.moveColumnLeft(column);
                 });
-            },
+            };
 
-            columnMoveRight: () => {
+            case "column-move-right": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     grid.moveColumnRight(column);
                 });
-            },
+            };
 
-            columnMoveStart: () => {
+            case "column-move-start": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     column.moveAfter(null);
                 });
-            },
+            };
 
-            columnMoveEnd: () => {
+            case "column-move-end": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     column.moveAfter(grid.getLastColumn());
                 });
-            },
+            };
 
-            columnToggleStacked: () => {
+            case "column-toggle-stacked": return () => {
                 world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
                     column.toggleStacked();
                 });
-            },
+            };
 
-            columnWidthIncrease: () => {
+            case "column-width-increase": return () => {
                 world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
-                    const desktop = grid.desktop;
-                    const visibleRange = desktop.getCurrentVisibleRange();
-                    if(!column.isVisible(visibleRange, true) || column.getWidth() >= column.getMaxWidth()) {
-                        return;
-                    }
-
-                    let leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange, true);
-                    let rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange, true);
-                    if (leftVisibleColumn === null || rightVisibleColumn === null) {
-                        console.assert(false); // should at least see self
-                        return;
-                    }
-
-                    const leftSpace = leftVisibleColumn.getLeft() - visibleRange.getLeft();
-                    const rightSpace = visibleRange.getRight() - rightVisibleColumn.getRight();
-
-                    const newWidth = findNextStep(
-                        [
-                            visibleRange.getWidth(),
-                            column.getWidth() + config.manualResizeStep,
-                            column.getWidth() + leftSpace + rightSpace,
-                            column.getWidth() + leftSpace + rightSpace + leftVisibleColumn.getWidth() + grid.config.gapsInnerHorizontal,
-                            column.getWidth() + leftSpace + rightSpace + rightVisibleColumn.getWidth() + grid.config.gapsInnerHorizontal,
-                        ],
-                        width => width - column.getWidth(),
-                    )
-                    if (newWidth === undefined) {
-                        return;
-                    }
-
-                    column.setWidth(newWidth, true);
-                    desktop.scrollCenterVisible(column, false);
-                    desktop.onLayoutChanged();
-                    desktop.autoAdjustScroll();
+                    config.columnResizer.increaseWidth(column, config.manualResizeStep);
                 });
-            },
+            };
 
-            columnWidthDecrease: () => {
+            case "column-width-decrease": return () => {
                 world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
-                    const desktop = grid.desktop;
-                    const visibleRange = desktop.getCurrentVisibleRange();
-                    if(!column.isVisible(visibleRange, true) || column.getWidth() <= column.getMinWidth()) {
-                        return;
-                    }
-
-                    const leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange, true);
-                    const rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange, true);
-                    if (leftVisibleColumn === null || rightVisibleColumn === null) {
-                        console.assert(false); // should at least see self
-                        return;
-                    }
-
-                    let leftOffScreenColumn = grid.getPrevColumn(leftVisibleColumn);
-                    if (leftOffScreenColumn === column) {
-                        leftOffScreenColumn = null;
-                    }
-                    let rightOffScreenColumn = grid.getNextColumn(rightVisibleColumn);
-                    if (rightOffScreenColumn === column) {
-                        rightOffScreenColumn = null;
-                    }
-
-                    const visibleColumnsWidth = rightVisibleColumn.getRight() - leftVisibleColumn.getLeft();
-                    const unusedWidth = visibleRange.getWidth() - visibleColumnsWidth;
-                    const leftOffScreen = leftOffScreenColumn === null ? 0 : leftOffScreenColumn.getWidth() + grid.config.gapsInnerHorizontal - unusedWidth;
-                    const rightOffScreen = rightOffScreenColumn === null ? 0 : rightOffScreenColumn.getWidth() + grid.config.gapsInnerHorizontal - unusedWidth;
-
-                    const newWidth = findNextStep(
-                        [
-                            visibleRange.getWidth(),
-                            column.getWidth() - config.manualResizeStep,
-                            column.getWidth() - leftOffScreen,
-                            column.getWidth() - rightOffScreen,
-                        ],
-                        width => column.getWidth() - width,
-                    )
-                    if (newWidth === undefined) {
-                        return;
-                    }
-
-                    column.setWidth(newWidth, true);
-                    desktop.scrollCenterVisible(column, true);
-                    desktop.onLayoutChanged();
-                    desktop.autoAdjustScroll();
+                    config.columnResizer.decreaseWidth(column, config.manualResizeStep);
                 });
-            },
+            };
 
-            columnsWidthEqualize: () => {
+            case "columns-width-equalize": return () => {
                 world.do((clientManager, desktopManager) => {
                     desktopManager.getCurrentDesktop().equalizeVisibleColumnsWidths();
                 });
-            },
+            };
 
-            gridScrollLeft: () => {
+            case "grid-scroll-left": return () => {
                 gridScroll(world, -config.manualScrollStep);
-            },
+            };
 
-            gridScrollRight: () => {
+            case "grid-scroll-right": return () => {
                 gridScroll(world, config.manualScrollStep);
-            },
+            };
 
-            gridScrollStart: () => {
+            case "grid-scroll-start": return () => {
                 world.do((clientManager, desktopManager) => {
                     const grid = desktopManager.getCurrentDesktop().grid;
                     const firstColumn = grid.getFirstColumn();
@@ -275,9 +199,9 @@ namespace Actions {
                     }
                     grid.desktop.scrollToColumn(firstColumn);
                 });
-            },
+            };
 
-            gridScrollEnd: () => {
+            case "grid-scroll-end": return () => {
                 world.do((clientManager, desktopManager) => {
                     const grid = desktopManager.getCurrentDesktop().grid;
                     const lastColumn = grid.getLastColumn();
@@ -286,15 +210,15 @@ namespace Actions {
                     }
                     grid.desktop.scrollToColumn(lastColumn);
                 });
-            },
+            };
 
-            gridScrollFocused: () => {
+            case "grid-scroll-focused": return () => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     grid.desktop.scrollCenterRange(column);
                 })
-            },
+            };
 
-            gridScrollLeftColumn: () => {
+            case "grid-scroll-left-column": return () => {
                 world.do((clientManager, desktopManager) => {
                     const grid = desktopManager.getCurrentDesktop().grid;
                     const column = grid.getLeftmostVisibleColumn(grid.desktop.getCurrentVisibleRange(), true);
@@ -309,9 +233,9 @@ namespace Actions {
 
                     grid.desktop.scrollToColumn(prevColumn);
                 });
-            },
+            };
 
-            gridScrollRightColumn: () => {
+            case "grid-scroll-right-column": return () => {
                 world.do((clientManager, desktopManager) => {
                     const grid = desktopManager.getCurrentDesktop().grid;
                     const column = grid.getRightmostVisibleColumn(grid.desktop.getCurrentVisibleRange(), true);
@@ -326,39 +250,41 @@ namespace Actions {
 
                     grid.desktop.scrollToColumn(nextColumn);
                 });
-            },
-        };
+            };
+
+            default: throw new Error("unknown action: " + name);
+        }
     }
 
-    export function initNum(world: World) {
-        return {
-            focusColumn: (columnIndex: number) => {
+    export function getNumAction(world: World, name: string) {
+        switch (name) {
+            case "focus-": return (columnIndex: number) => {
                 world.do((clientManager, desktopManager) => {
                     const grid = desktopManager.getCurrentDesktop().grid;
                     const targetColumn = grid.getColumnAtIndex(columnIndex);
                     if (targetColumn === null) {
-                        return null;
+                        return;
                     }
                     targetColumn.focus();
                 });
-            },
+            };
 
-            windowMoveToColumn: (columnIndex: number) => {
+            case "window-move-to-column-": return (columnIndex: number) => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const targetColumn = grid.getColumnAtIndex(columnIndex);
                     if (targetColumn === null) {
-                        return null;
+                        return;
                     }
                     window.moveToColumn(targetColumn);
                     grid.desktop.autoAdjustScroll();
                 });
-            },
+            };
 
-            columnMoveToColumn: (columnIndex: number) => {
+            case "column-move-to-column-": return (columnIndex: number) => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
                     const targetColumn = grid.getColumnAtIndex(columnIndex);
                     if (targetColumn === null || targetColumn === column) {
-                        return null;
+                        return;
                     }
                     if (targetColumn.isAfter(column)) {
                         column.moveAfter(targetColumn);
@@ -366,30 +292,38 @@ namespace Actions {
                         column.moveAfter(grid.getPrevColumn(targetColumn));
                     }
                 });
-            },
+            };
 
-            columnMoveToDesktop: (desktopIndex: number) => {
+            case "column-move-to-desktop-": return (desktopIndex: number) => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, oldGrid) => {
-                    const desktopNumber = desktopIndex + 1;
-                    const newGrid = desktopManager.getDesktopInCurrentActivity(desktopNumber).grid;
+                    const kwinDesktop = Workspace.desktops[desktopIndex];
+                    if (kwinDesktop === undefined) {
+                        return;
+                    }
+                    const newGrid = desktopManager.getDesktopInCurrentActivity(kwinDesktop).grid;
                     if (newGrid === null || newGrid === oldGrid) {
                         return;
                     }
                     column.moveToGrid(newGrid, newGrid.getLastColumn());
                 });
-            },
+            };
 
-            tailMoveToDesktop: (desktopIndex: number) => {
+            case "tail-move-to-desktop-": return (desktopIndex: number) => {
                 world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, oldGrid) => {
-                    const desktopNumber = desktopIndex + 1;
-                    const newGrid = desktopManager.getDesktopInCurrentActivity(desktopNumber).grid;
+                    const kwinDesktop = Workspace.desktops[desktopIndex];
+                    if (kwinDesktop === undefined) {
+                        return;
+                    }
+                    const newGrid = desktopManager.getDesktopInCurrentActivity(kwinDesktop).grid;
                     if (newGrid === null || newGrid === oldGrid) {
                         return;
                     }
                     oldGrid.evacuateTail(newGrid, column);
                 });
-            },
-        };
+            };
+
+            default: throw new Error("unknown num action: " + name);
+        }
     }
 
     function gridScroll(world: World, amount: number) {
@@ -399,21 +333,14 @@ namespace Actions {
         });
     }
 
-    function findNextStep(steps: number[], evaluate: (step: number) => number) {
-        let bestScore = Infinity;
-        let bestStep = undefined;
-        for (const step of steps) {
-            const score = evaluate(step);
-            if (score > 0 && score < bestScore) {
-                bestScore = score;
-                bestStep = step;
-            }
-        }
-        return bestStep;
-    }
-
     export type Config = {
         manualScrollStep: number,
         manualResizeStep: number,
+        columnResizer: ColumnResizer,
     };
+
+    export type ColumnResizer = {
+        increaseWidth(column: Column, step: number): void,
+        decreaseWidth(column: Column, step: number): void,
+    }
 }

src/ClientAreaOption.ts

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

src/behavior/columnResizer/ContextualResizer.ts

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

src/behavior/columnResizer/RawResizer.ts

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

src/behavior/scrollClamper/CenterClamper.ts

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

src/behavior/scrollClamper/EdgeClamper.ts

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

src/behavior/scroller/CenteredScroller.ts

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

src/behavior/scroller/GroupedScroller.ts

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

src/behavior/scroller/LazyScroller.ts

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

src/config/definition.ts

@@ -4,43 +4,31 @@ const defaultWindowRules = `[
         "tile": false
     },
     {
-        "class": "kcalc",
+        "class": "(org\\\\.kde\\\\.)?plasmashell",
         "tile": false
     },
     {
-        "class": "org.kde.kcalc",
+        "class": "(org\\\\.kde\\\\.)?kded6",
         "tile": false
     },
     {
-        "class": "kfind",
+        "class": "(org\\\\.kde\\\\.)?kcalc",
+        "tile": false
+    },
+    {
+        "class": "(org\\\\.kde\\\\.)?kfind",
         "tile": true
     },
     {
-        "class": "org.kde.kfind",
-        "tile": true
-    },
-    {
-        "class": "kruler",
+        "class": "(org\\\\.kde\\\\.)?kruler",
         "tile": false
     },
     {
-        "class": "org.kde.kruler",
+        "class": "(org\\\\.kde\\\\.)?krunner",
         "tile": false
     },
     {
-        "class": "krunner",
-        "tile": false
-    },
-    {
-        "class": "org.kde.krunner",
-        "tile": false
-    },
-    {
-        "class": "yakuake",
-        "tile": false
-    },
-    {
-        "class": "org.kde.yakuake",
+        "class": "(org\\\\.kde\\\\.)?yakuake",
         "tile": false
     },
     {
@@ -72,103 +60,108 @@ const defaultWindowRules = `[
 
 const configDef = [
     {
-        "name": "gapsOuterTop",
-        "type": "UInt",
-        "default": 18
+        name: "gapsOuterTop",
+        type: "UInt",
+        default: 18,
     },
     {
-        "name": "gapsOuterBottom",
-        "type": "UInt",
-        "default": 18
+        name: "gapsOuterBottom",
+        type: "UInt",
+        default: 18,
     },
     {
-        "name": "gapsOuterLeft",
-        "type": "UInt",
-        "default": 18
+        name: "gapsOuterLeft",
+        type: "UInt",
+        default: 18,
     },
     {
-        "name": "gapsOuterRight",
-        "type": "UInt",
-        "default": 18
+        name: "gapsOuterRight",
+        type: "UInt",
+        default: 18,
     },
     {
-        "name": "gapsInnerHorizontal",
-        "type": "UInt",
-        "default": 18
+        name: "gapsInnerHorizontal",
+        type: "UInt",
+        default: 18,
     },
     {
-        "name": "gapsInnerVertical",
-        "type": "UInt",
-        "default": 18
+        name: "gapsInnerVertical",
+        type: "UInt",
+        default: 18,
     },
     {
-        "name": "manualScrollStep",
-        "type": "UInt",
-        "default": 200
+        name: "manualScrollStep",
+        type: "UInt",
+        default: 200,
     },
     {
-        "name": "manualResizeStep",
-        "type": "UInt",
-        "default": 600
+        name: "manualResizeStep",
+        type: "UInt",
+        default: 600,
     },
     {
-        "name": "offScreenOpacity",
-        "type": "UInt",
-        "default": 100
+        name: "offScreenOpacity",
+        type: "UInt",
+        default: 100,
     },
     {
-        "name": "untileOnDrag",
-        "type": "Bool",
-        "default": true
+        name: "untileOnDrag",
+        type: "Bool",
+        default: true,
     },
     {
-        "name": "stackColumnsByDefault",
-        "type": "Bool",
-        "default": false
+        name: "stackColumnsByDefault",
+        type: "Bool",
+        default: false,
     },
     {
-        "name": "resizeNeighborColumn",
-        "type": "Bool",
-        "default": false
+        name: "resizeNeighborColumn",
+        type: "Bool",
+        default: false,
     },
     {
-        "name": "reMaximize",
-        "type": "Bool",
-        "default": false
+        name: "reMaximize",
+        type: "Bool",
+        default: false,
     },
     {
-        "name": "skipSwitcher",
-        "type": "Bool",
-        "default": false
+        name: "skipSwitcher",
+        type: "Bool",
+        default: false,
     },
     {
-        "name": "scrollingLazy",
-        "type": "Bool",
-        "default": true
+        name: "scrollingLazy",
+        type: "Bool",
+        default: true,
     },
     {
-        "name": "scrollingCentered",
-        "type": "Bool",
-        "default": false
+        name: "scrollingCentered",
+        type: "Bool",
+        default: false,
     },
     {
-        "name": "scrollingGrouped",
-        "type": "Bool",
-        "default": false
+        name: "scrollingGrouped",
+        type: "Bool",
+        default: false,
     },
     {
-        "name": "tiledKeepBelow",
-        "type": "Bool",
-        "default": true
+        name: "tiledKeepBelow",
+        type: "Bool",
+        default: true,
     },
     {
-        "name": "floatingKeepAbove",
-        "type": "Bool",
-        "default": false
+        name: "floatingKeepAbove",
+        type: "Bool",
+        default: false,
     },
     {
-        "name": "windowRules",
-        "type": "String",
-        "default": defaultWindowRules
+        name: "noLayering",
+        type: "Bool",
+        default: false,
+    },
+    {
+        name: "windowRules",
+        type: "String",
+        default: defaultWindowRules,
     }
 ];

src/extern/kwin.d.ts

@@ -1,39 +1,52 @@
 declare const KWin: {
-    // Functions
     readConfig(key: string, defaultValue: any): any;
-    registerShortcut(name: string, description: string, keySequence: string, callback: () => void): void;
 };
 
-declare const workspace: {
-    // Read-write Properties
-    readonly desktops: number;
-    readonly currentDesktop: number;
+declare const Workspace: {
+    readonly activities: string[];
+    readonly desktops: KwinDesktop[];
+    readonly currentDesktop: KwinDesktop;
     readonly currentActivity: string;
+    readonly activeScreen: Output;
+    readonly windows: KwinClient[];
+    readonly cursorPos: QmlPoint;
 
-    // Read-write Properties
-    activeClient: KwinClient;
+    activeWindow: KwinClient;
 
-    // Signals
-    currentDesktopChanged: QSignal<[oldDesktopNumber: number]>
-    clientAdded: QSignal<[KwinClient]>;
-    clientRemoved: QSignal<[KwinClient]>;
-    clientMinimized: QSignal<[KwinClient]>;
-    clientUnminimized: QSignal<[KwinClient]>;
-    clientMaximizeSet: QSignal<[KwinClient, horizontally: boolean, vertically: boolean]>;
-    clientActivated: QSignal<[KwinClient]>;
-    numberDesktopsChanged: QSignal<[oldNumberOfVirtualDesktops: number]>;
-    currentActivityChanged: QSignal<[newActivity: string]>;
-    virtualScreenSizeChanged: QSignal<[void]>;
+    readonly currentDesktopChanged: QSignal<[]>
+    readonly windowAdded: QSignal<[KwinClient]>;
+    readonly windowRemoved: QSignal<[KwinClient]>;
+    readonly windowActivated: QSignal<[KwinClient]>;
+    readonly desktopsChanged: QSignal<[]>;
+    readonly activitiesChanged: QSignal<[]>;
+    readonly currentActivityChanged: QSignal<[]>;
+    readonly virtualScreenSizeChanged: QSignal<[]>;
 
-    // Functions
-    clientArea(option: ClientAreaOption, screenNumber: number, desktopNumber: number);
-    clientList(): KwinClient[];
+    clientArea(option: ClientAreaOption, output: Output, kwinDesktop: KwinDesktop);
 };
 
-type Tile = any;
+const enum ClientAreaOption {
+    PlacementArea,
+    MovementArea,
+    MaximizeArea,
+    MaximizeFullArea,
+    FullScreenArea,
+    WorkArea,
+    FullArea,
+    ScreenArea,
+}
+
+const enum MaximizedMode {
+    Unmaximized,
+    Vertically,
+    Horizontally,
+    Maximized,
+}
+
+type Tile = unknown;
+type Output = unknown;
 
 interface KwinClient {
-    // Read-only Properties
     readonly shadeable: boolean;
     readonly caption: string;
     readonly minSize: QmlSize;
@@ -41,15 +54,17 @@ interface KwinClient {
     readonly transientFor: KwinClient;
     readonly move: boolean;
     readonly resize: boolean;
+    readonly moveable: boolean;
     readonly resizeable: boolean;
-    readonly screen: number;
+    readonly fullScreenable: boolean;
+    readonly maximizable: boolean;
+    readonly output: Output;
     readonly resourceClass: QByteArray;
     readonly dock: boolean;
     readonly normalWindow: boolean;
     readonly managed: boolean;
-    opacity: number;
+    readonly popupWindow: boolean;
 
-    // Read-write Properties
     fullScreen: boolean;
     activities: string[]; // empty array means all activities
     skipSwitcher: boolean;
@@ -58,20 +73,29 @@ interface KwinClient {
     shade: boolean;
     minimized: boolean;
     frameGeometry: QmlRect;
-    desktop: number; // -1 means all desktops
+    desktops: KwinDesktop[]; // empty array means all desktops
     tile: Tile;
+    opacity: number;
 
-    // Signals
-    fullScreenChanged: QSignal<[void]>;
-    desktopChanged: QSignal<[void]>;
-    activitiesChanged: QSignal<[KwinClient]>;
-    captionChanged: QSignal<[void]>;
-    tileChanged: QSignal<[Tile]>;
-    moveResizedChanged: QSignal<[void]>;
-    moveResizeCursorChanged: QSignal<[void]>;
-    clientStartUserMovedResized: QSignal<[void]>;
-    frameGeometryChanged: QSignal<[KwinClient, oldGeometry: QmlRect]>;
+    readonly fullScreenChanged: QSignal<[]>;
+    readonly desktopsChanged: QSignal<[]>;
+    readonly activitiesChanged: QSignal<[]>;
+    readonly minimizedChanged: QSignal<[]>;
+    readonly maximizedAboutToChange: QSignal<[MaximizedMode]>
+    readonly captionChanged: QSignal<[]>;
+    readonly tileChanged: QSignal<[]>;
+    readonly interactiveMoveResizeStarted: QSignal<[]>;
+    readonly interactiveMoveResizeFinished: QSignal<[]>;
+    readonly frameGeometryChanged: QSignal<[oldGeometry: QmlRect]>;
 
-    // Functions
     setMaximize(vertically: boolean, horizontally: boolean): void;
 }
+
+interface KwinDesktop {
+    readonly id: string;
+}
+
+type ShortcutHandler = {
+    readonly activated: QSignal<[]>;
+    destroy(): void;
+};

src/extern/qt.d.ts

@@ -13,6 +13,11 @@ type QmlObject = unknown;
 
 type QByteArray = string;
 
+type QmlPoint = {
+    x: number;
+    y: number;
+}
+
 type QmlRect = {
     x: number;
     y: number;
@@ -36,7 +41,7 @@ type QSignal<T extends unknown[]> = {
 
 type QmlTimer = {
     interval: number;
-    triggered: QSignal<[void]>;
+    readonly triggered: QSignal<[]>;
     restart(): void;
     destroy(): void;
 };

src/keyBindings/definition.ts

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

src/keyBindings/loader.ts

@@ -3,7 +3,6 @@ type KeyBinding = {
     description: string;
     comment?: string;
     defaultKeySequence: string;
-    action: keyof ReturnType<typeof Actions.init>;
 };
 
 type NumKeyBinding = {
@@ -12,7 +11,6 @@ type NumKeyBinding = {
     comment?: string;
     defaultModifiers: string;
     fKeys: boolean;
-    action: keyof ReturnType<typeof Actions.initNum>;
 };
 
 function catchWrap(f: () => void) {
@@ -26,40 +24,44 @@ function catchWrap(f: () => void) {
     };
 }
 
-function registerKeyBinding(name: string, description: string, keySequence: string, callback: () => void) {
-    KWin.registerShortcut(
-        "karousel-" + name,
-        "Karousel: " + description,
-        keySequence,
-        catchWrap(callback),
-    );
+function registerKeyBinding(world: World, config: Actions.Config, shortcutActions: ShortcutAction[], keyBinding: KeyBinding) {
+    shortcutActions.push(new ShortcutAction(
+        keyBinding,
+        catchWrap(Actions.getAction(world, config, keyBinding.name)),
+    ));
 }
 
-function registerNumKeyBindings(name: string, description: string, modifiers: string, fKeys: boolean, callback: (i: number) => void) {
-    const numPrefix = fKeys ? "F" : "";
-    const n = fKeys ? 12 : 9;
+function registerNumKeyBindings(world: World, shortcutActions: ShortcutAction[], numKeyBinding: NumKeyBinding) {
+    const numPrefix = numKeyBinding.fKeys ? "F" : "";
+    const n = numKeyBinding.fKeys ? 12 : 9;
     for (let i = 0; i < 12; i++) {
         const numKey = String(i + 1);
         const keySequence = i < n ?
-            modifiers + "+" + numPrefix + numKey :
+            numKeyBinding.defaultModifiers + "+" + numPrefix + numKey :
             "";
-        registerKeyBinding(
-            name + numKey,
-            description + numKey,
-            keySequence,
-            () => callback(i),
-        );
+        const action = Actions.getNumAction(world, numKeyBinding.name);
+        shortcutActions.push(new ShortcutAction(
+            {
+                name: numKeyBinding.name + numKey,
+                description: numKeyBinding.description + numKey,
+                defaultKeySequence: keySequence,
+            },
+            catchWrap(() => action(i)),
+        ));
     }
 }
 
-function registerKeyBindings(world: World, config: Config) {
-    const actions = Actions.init(world, config);
-    for (const binding of keyBindings) {
-        registerKeyBinding(binding.name, binding.description, binding.defaultKeySequence, actions[binding.action]);
+// TODO: refactor
+function registerKeyBindings(world: World, config: Actions.Config) {
+    const shortcutActions: ShortcutAction[] = [];
+
+    for (const keyBinding of keyBindings) {
+        registerKeyBinding(world, config, shortcutActions, keyBinding);
     }
 
-    const numActions = Actions.initNum(world);
-    for (const binding of numKeyBindings) {
-        registerNumKeyBindings(binding.name, binding.description, binding.defaultModifiers, binding.fKeys, numActions[binding.action]);
+    for (const numKeyBinding of numKeyBindings) {
+        registerNumKeyBindings(world, shortcutActions, numKeyBinding);
     }
+
+    return shortcutActions;
 }

src/layout/Column.ts

@@ -25,7 +25,7 @@ class Column {
             this.grid = targetGrid;
             targetGrid.onColumnAdded(this, prevColumn);
             for (const window of this.windows.iterator()) {
-                window.client.kwinClient.desktop = targetGrid.desktop.desktopNumber;
+                window.client.kwinClient.desktops = [targetGrid.desktop.kwinDesktop];
             }
         }
     }
@@ -92,16 +92,17 @@ class Column {
 
     public setWidth(width: number, setPreferred: boolean) {
         width = clamp(width, this.getMinWidth(), this.getMaxWidth());
-        const oldWidth = this.width;
+        if (width === this.width) {
+            return;
+        }
+
         this.width = width;
         if (setPreferred) {
             for (const window of this.windows.iterator()) {
                 window.client.preferredWidth = width;
             }
         }
-        if (width !== oldWidth) {
-            this.grid.onColumnWidthChanged(this, oldWidth, width);
-        }
+        this.grid.onColumnWidthChanged(this);
     }
 
     public adjustWidth(widthDelta: number, setPreferred: boolean) {

src/layout/Desktop.ts

@@ -1,6 +1,6 @@
 class Desktop {
     public readonly grid: Grid;
-    public readonly desktopNumber: number;
+    public readonly kwinDesktop: KwinDesktop;
     private readonly pinManager: PinManager;
     private readonly config: Desktop.Config;
     private scrollX: number;
@@ -10,26 +10,26 @@ class Desktop {
     public clientArea: QmlRect;
     public tilingArea: QmlRect;
 
-    constructor(desktopNumber: number, pinManager: PinManager, config: Desktop.Config, layoutConfig: LayoutConfig) {
+    constructor(kwinDesktop: KwinDesktop, pinManager: PinManager, config: Desktop.Config, layoutConfig: LayoutConfig) {
         this.pinManager = pinManager;
         this.config = config;
         this.scrollX = 0;
         this.dirty = true;
         this.dirtyScroll = true;
         this.dirtyPins = true;
-        this.desktopNumber = desktopNumber;
+        this.kwinDesktop = kwinDesktop;
         this.grid = new Grid(this, layoutConfig);
-        this.clientArea = Desktop.getClientArea(desktopNumber);
-        this.tilingArea = Desktop.getTilingArea(this.clientArea, desktopNumber, pinManager, config);
+        this.clientArea = Desktop.getClientArea(kwinDesktop);
+        this.tilingArea = Desktop.getTilingArea(this.clientArea, kwinDesktop, pinManager, config);
     }
 
     private updateArea() {
-        const newClientArea = Desktop.getClientArea(this.desktopNumber);
+        const newClientArea = Desktop.getClientArea(this.kwinDesktop);
         if (newClientArea === this.clientArea && !this.dirtyPins) {
             return;
         }
         this.clientArea = newClientArea;
-        this.tilingArea = Desktop.getTilingArea(newClientArea, this.desktopNumber, this.pinManager, this.config);
+        this.tilingArea = Desktop.getTilingArea(newClientArea, this.kwinDesktop, this.pinManager, this.config);
         this.dirty = true;
         this.dirtyScroll = true;
         this.dirtyPins = false;
@@ -37,12 +37,12 @@ class Desktop {
         this.autoAdjustScroll();
     }
 
-    private static getClientArea(desktopNumber: number) {
-        return workspace.clientArea(ClientAreaOption.PlacementArea, 0, desktopNumber);
+    private static getClientArea(kwinDesktop: KwinDesktop) {
+        return Workspace.clientArea(ClientAreaOption.PlacementArea, Workspace.activeScreen, kwinDesktop);
     }
 
-    private static getTilingArea(clientArea: QmlRect, desktopNumber: number, pinManager: PinManager, config: Desktop.Config) {
-        const availableSpace = pinManager.getAvailableSpace(desktopNumber, clientArea);
+    private static getTilingArea(clientArea: QmlRect, kwinDesktop: KwinDesktop, pinManager: PinManager, config: Desktop.Config) {
+        const availableSpace = pinManager.getAvailableSpace(kwinDesktop, clientArea);
         const top = availableSpace.top + config.marginTop;
         const bottom = availableSpace.bottom - config.marginBottom;
         const left = availableSpace.left + config.marginLeft;
@@ -78,13 +78,10 @@ class Desktop {
         this.adjustScroll(Math.round(windowCenter - screenCenter), false);
     }
 
-    public scrollCenterVisible(focusedColumn: Column, prioritiseVisible: boolean) {
+    public scrollCenterVisible(focusedColumn: Column) {
         const columnRange = new Desktop.ColumnRange(focusedColumn);
         const visibleRange = this.getCurrentVisibleRange();
-        if (prioritiseVisible) {
-            columnRange.addNeighbors(visibleRange, this.grid.config.gapsInnerHorizontal, column => column.isVisible(visibleRange, true));
-        }
-        columnRange.addNeighbors(visibleRange, this.grid.config.gapsInnerHorizontal, () => true);
+        columnRange.addNeighbors(visibleRange, this.grid.config.gapsInnerHorizontal);
         this.scrollCenterRange(columnRange);
     }
 
@@ -112,7 +109,7 @@ class Desktop {
     }
 
     private clampScrollX(x: number) {
-        return this.config.scroller.clampScrollX(this, x);
+        return this.config.clamper.clampScrollX(this, x);
     }
 
     public setScroll(x: number, force: boolean) {
@@ -195,6 +192,7 @@ namespace Desktop {
         marginLeft: number,
         marginRight: number,
         scroller: Desktop.Scroller,
+        clamper: Desktop.Clamper,
     };
 
     export type Range = {
@@ -242,17 +240,15 @@ namespace Desktop {
             this.width = initialColumn.getWidth();
         }
 
-        public addNeighbors(visibleRange: Desktop.Range, gap: number, condition: (column: Column) => boolean) {
+        public addNeighbors(visibleRange: Desktop.Range, gap: number) {
             const grid = this.left.grid;
 
             const columnRange = this;
             function canFit(column: Column) {
-                return columnRange.width + gap + column.getWidth() <= visibleRange.getWidth()
+                return columnRange.width + gap + column.getWidth() <= visibleRange.getWidth();
             }
             function isUsable(column: Column|null) {
-                return column !== null &&
-                    canFit(column) &&
-                    condition(column)
+                return column !== null && canFit(column);
             }
 
             let leftColumn = grid.getPrevColumn(this.left);
@@ -267,10 +263,11 @@ namespace Desktop {
             }
             checkColumns();
 
+            const visibleCenter = visibleRange.getLeft() + visibleRange.getWidth() / 2;
             while (leftColumn !== null || rightColumn !== null) {
-                const leftWidth = leftColumn === null ? -Infinity : leftColumn.getWidth();
-                const rightWidth = rightColumn === null ? -Infinity : rightColumn.getWidth();
-                if (leftWidth > rightWidth) {
+                const leftToCenter = leftColumn === null ? Infinity : Math.abs(leftColumn.getLeft() - visibleCenter);
+                const rightToCenter = rightColumn === null ? Infinity : Math.abs(rightColumn.getRight() - visibleCenter);
+                if (leftToCenter < rightToCenter) {
                     this.addLeft(leftColumn!, gap);
                     leftColumn = grid.getPrevColumn(leftColumn!);
                 } else {
@@ -306,6 +303,9 @@ namespace Desktop {
 
     export type Scroller = {
         scrollToColumn(desktop: Desktop, column: Column): void;
+    }
+
+    export type Clamper = {
         clampScrollX(desktop: Desktop, x: number): number;
     }
 }

src/layout/Grid.ts

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

src/layout/ScrollerGrouped.ts

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

src/layout/Window.ts

@@ -10,8 +10,7 @@ class Window {
         this.height = client.kwinClient.frameGeometry.height;
         this.focusedState = {
             fullScreen: false,
-            maximizedHorizontally: false,
-            maximizedVertically: false,
+            maximizedMode: MaximizedMode.Unmaximized,
         };
         this.skipArrange = false;
         this.column = column;
@@ -37,8 +36,11 @@ class Window {
         if (this.column.grid.config.reMaximize && this.isFocused()) {
             // do this here rather than in `onFocused` to ensure it happens after placement
             // (otherwise placement may not happen at all)
-            if (this.focusedState.maximizedVertically || this.focusedState.maximizedHorizontally) {
-                this.client.setMaximize(this.focusedState.maximizedVertically, this.focusedState.maximizedHorizontally);
+            if (this.focusedState.maximizedMode > MaximizedMode.Unmaximized) {
+                this.client.setMaximize(
+                    this.focusedState.maximizedMode === MaximizedMode.Horizontally || this.focusedState.maximizedMode === MaximizedMode.Maximized,
+                    this.focusedState.maximizedMode === MaximizedMode.Vertically || this.focusedState.maximizedMode === MaximizedMode.Maximized,
+                );
                 maximized = true;
             }
             if (this.focusedState.fullScreen) {
@@ -76,8 +78,8 @@ class Window {
         this.column.grid.desktop.onLayoutChanged();
     }
 
-    public onMaximizedChanged(horizontally: boolean, vertically: boolean) {
-        const maximized = horizontally || vertically;
+    public onMaximizedChanged(maximizedMode: MaximizedMode) {
+        const maximized = maximizedMode > MaximizedMode.Unmaximized;
         this.skipArrange = maximized;
         if (this.column.grid.config.tiledKeepBelow) {
             this.client.kwinClient.keepBelow = !maximized;
@@ -86,8 +88,7 @@ class Window {
             this.client.kwinClient.keepAbove = maximized;
         }
         if (this.isFocused()) {
-            this.focusedState.maximizedHorizontally = horizontally;
-            this.focusedState.maximizedVertically = vertically;
+            this.focusedState.maximizedMode = maximizedMode;
         }
         this.column.grid.desktop.onLayoutChanged();
     }
@@ -145,7 +146,6 @@ class Window {
 namespace Window {
     export type State = {
         fullScreen: boolean,
-        maximizedHorizontally: boolean,
-        maximizedVertically: boolean,
+        maximizedMode: MaximizedMode,
     }
 }

src/main.ts

@@ -1,6 +1,3 @@
 function init() {
-    const config = loadConfig();
-    const world = new World(config);
-    registerKeyBindings(world, config);
-    return world;
+    return new World(loadConfig());
 }

src/rules/ClientMatcher.ts

@@ -1,15 +1,19 @@
 class ClientMatcher {
-    private readonly rules: Map<string, RegExp>;
+    private readonly regex: RegExp;
 
-    constructor(rules: Map<string, RegExp>) {
-        this.rules = rules;
+    constructor(regex: RegExp) {
+        this.regex = regex;
     }
 
     public matches(kwinClient: KwinClient) {
-        const rule = this.rules.get(kwinClient.resourceClass);
-        if (rule === undefined) {
-            return false;
-        }
-        return rule.test(kwinClient.caption);
+        return this.regex.test(ClientMatcher.getClientString(kwinClient));
+    }
+
+    public static getClientString(kwinClient: KwinClient) {
+        return ClientMatcher.getRuleString(kwinClient.resourceClass, kwinClient.caption);
+    }
+
+    public static getRuleString(ruleClass: string, ruleCaption: string) {
+        return ruleClass + "\0" + ruleCaption;
     }
 }

src/rules/WindowRule.ts

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

src/rules/WindowRuleEnforcer.ts

@@ -1,13 +1,16 @@
 class WindowRuleEnforcer {
     private readonly preferFloating: ClientMatcher;
     private readonly preferTiling: ClientMatcher;
-    private readonly followCaption: Set<string>;
+    private readonly followCaption: RegExp;
 
     constructor(windowRules: WindowRule[]) {
-        const [mapFloat, mapTile] = WindowRuleEnforcer.createWindowRuleMaps(windowRules);
-        this.preferFloating = new ClientMatcher(mapFloat);
-        this.preferTiling = new ClientMatcher(mapTile);
-        this.followCaption = new Set([...mapFloat.keys(), ...mapTile.keys()]);
+        const [floatRegex, tileRegex, followCaptionRegex] = WindowRuleEnforcer.createWindowRuleRegexes(windowRules);
+        log("floatRegex", floatRegex);
+        log("tileRegex", tileRegex);
+        log("followCaptionRegex", followCaptionRegex);
+        this.preferFloating = new ClientMatcher(floatRegex);
+        this.preferTiling = new ClientMatcher(tileRegex);
+        this.followCaption = followCaptionRegex;
     }
 
     public shouldTile(kwinClient: KwinClient) {
@@ -22,7 +25,7 @@ class WindowRuleEnforcer {
     }
 
     public initClientSignalManager(world: World, kwinClient: KwinClient) {
-        if (!this.followCaption.has(kwinClient.resourceClass)) {
+        if (!this.followCaption.test(kwinClient.resourceClass)) {
             return null;
         }
 
@@ -31,51 +34,53 @@ class WindowRuleEnforcer {
         manager.connect(kwinClient.captionChanged, () => {
             const shouldTile = enforcer.shouldTile(kwinClient);
             world.do((clientManager, desktopManager) => {
-                if (shouldTile) {
-                    clientManager.tileClient(kwinClient);
+                const desktop = desktopManager.getDesktopForClient(kwinClient);
+                if (shouldTile && desktop !== undefined) {
+                    clientManager.tileKwinClient(kwinClient, desktop.grid);
                 } else {
-                    clientManager.untileClient(kwinClient);
+                    clientManager.floatKwinClient(kwinClient);
                 }
             });
         });
         return manager;
     }
 
-    private static createWindowRuleMaps(windowRules: WindowRule[]) {
-        const mapFloat = new Map<string, string[]>();
-        const mapTile = new Map<string, string[]>();
+    private static createWindowRuleRegexes(windowRules: WindowRule[]) {
+        const floatRegexes: string[] = [];
+        const tileRegexes: string[] = [];
+        const followCaptionRegexes: string[] = [];
         for (const windowRule of windowRules) {
-            const map = windowRule.tile ? mapTile : mapFloat;
-            let captions = map.get(windowRule.class);
-            if (captions === undefined) {
-                captions = [];
-                map.set(windowRule.class, captions);
-            }
-            if (windowRule.caption !== undefined) {
-                captions.push(windowRule.caption);
+            const ruleClass = WindowRuleEnforcer.parseRegex(windowRule.class);
+            const ruleCaption = WindowRuleEnforcer.parseRegex(windowRule.caption);
+            const ruleString = ClientMatcher.getRuleString(ruleClass, ruleCaption);
+
+            (windowRule.tile ? tileRegexes : floatRegexes).push(ruleString);
+            if (ruleCaption !== ".*") {
+                followCaptionRegexes.push(ruleClass);
             }
         }
 
         return [
-            WindowRuleEnforcer.createWindowRuleRegexMap(mapFloat),
-            WindowRuleEnforcer.createWindowRuleRegexMap(mapTile),
+            WindowRuleEnforcer.joinRegexes(floatRegexes),
+            WindowRuleEnforcer.joinRegexes(tileRegexes),
+            WindowRuleEnforcer.joinRegexes(followCaptionRegexes),
         ];
     }
 
-    private static createWindowRuleRegexMap(windowRuleMap: Map<string, string[]>) {
-        const regexMap = new Map<string, RegExp>;
-        for (const [k, v] of windowRuleMap) {
-            regexMap.set(k, WindowRuleEnforcer.joinRegexes(v));
+    private static parseRegex(rawRule: string | undefined) {
+        if (rawRule === undefined || rawRule === "" || rawRule === ".*") {
+            return ".*";
+        } else {
+            return rawRule;
         }
-        return regexMap;
     }
 
     private static joinRegexes(regexes: string[]) {
-        if (regexes.length == 0) {
-            return new RegExp("");
+        if (regexes.length === 0) {
+            return new RegExp("a^"); // match nothing
         }
 
-        if (regexes.length == 1) {
+        if (regexes.length === 1) {
             return new RegExp("^" + regexes[0] + "$");
         }
 

src/utils/Delayer.ts

@@ -18,7 +18,7 @@ class Delayer {
 
 function initQmlTimer() {
     return Qt.createQmlObject(
-        `import QtQuick 2.15
+        `import QtQuick 6.0
         Timer {}`,
         qmlBase
     );

src/utils/ShortcutAction.ts

@@ -0,0 +1,25 @@
+class ShortcutAction {
+    private readonly shortcutHandler: ShortcutHandler;
+
+    constructor(keyBinding: KeyBinding, f: () => void) {
+        this.shortcutHandler = ShortcutAction.initShortcutHandler(keyBinding);
+        this.shortcutHandler.activated.connect(f);
+    }
+
+    public destroy() {
+        this.shortcutHandler.destroy();
+    }
+
+    private static initShortcutHandler(keyBinding: KeyBinding) {
+        return Qt.createQmlObject(
+            `import QtQuick 6.0
+import org.kde.kwin 3.0
+ShortcutHandler {
+    name: "karousel-${keyBinding.name}";
+    text: "Karousel: ${keyBinding.description}";
+    sequence: "${keyBinding.defaultKeySequence}";
+}`,
+            qmlBase,
+        );
+    }
+}

src/workspace.ts

@@ -1,49 +1,23 @@
 function initWorkspaceSignalHandlers(world: World) {
     const manager = new SignalManager();
 
-    manager.connect(workspace.clientAdded, (kwinClient: KwinClient) => {
+    manager.connect(Workspace.windowAdded, (kwinClient: KwinClient) => {
         if (Clients.canTileEver(kwinClient)) {
             // never open new tileable clients on all desktops or activities
-            if (kwinClient.desktop <= 0) {
-                kwinClient.desktop = workspace.currentDesktop;
-            }
-            if (kwinClient.activities.length !== 1) {
-                kwinClient.activities = [workspace.currentActivity];
-            }
+            Clients.makeTileable(kwinClient);
         }
         world.do((clientManager, desktopManager) => {
             clientManager.addClient(kwinClient)
         });
     });
 
-    manager.connect(workspace.clientRemoved, (kwinClient: KwinClient) => {
+    manager.connect(Workspace.windowRemoved, (kwinClient: KwinClient) => {
         world.do((clientManager, desktopManager) => {
             clientManager.removeClient(kwinClient, true);
         });
     });
 
-    manager.connect(workspace.clientMinimized, (kwinClient: KwinClient) => {
-        world.do((clientManager, desktopManager) => {
-            clientManager.minimizeClient(kwinClient);
-        });
-    });
-
-    manager.connect(workspace.clientUnminimized, (kwinClient: KwinClient) => {
-        world.do((clientManager, desktopManager) => {
-            clientManager.unminimizeClient(kwinClient);
-        });
-    });
-
-    manager.connect(workspace.clientMaximizeSet, (kwinClient: KwinClient, horizontally: boolean, vertically: boolean) => {
-        if ((horizontally || vertically) && kwinClient.tile !== null) {
-            kwinClient.tile = null;
-        }
-        world.doIfTiled(kwinClient, false, (clientManager, desktopManager, window, column, grid) => {
-            window.onMaximizedChanged(horizontally, vertically);
-        });
-    });
-
-    manager.connect(workspace.clientActivated, (kwinClient: KwinClient) => {
+    manager.connect(Workspace.windowActivated, (kwinClient: KwinClient) => {
         if (kwinClient === null) {
             return;
         }
@@ -52,19 +26,27 @@ function initWorkspaceSignalHandlers(world: World) {
         });
     });
 
-    manager.connect(workspace.currentDesktopChanged, () => {
+    manager.connect(Workspace.currentDesktopChanged, () => {
         world.do(() => {}); // re-arrange desktop
     });
 
-    manager.connect(workspace.currentActivityChanged, () => {
+    manager.connect(Workspace.currentActivityChanged, () => {
         world.do(() => {}); // re-arrange desktop
     });
 
-    manager.connect(workspace.numberDesktopsChanged, (oldNumberOfVirtualDesktops: number) => {
-        world.updateDesktops();
+    manager.connect(Workspace.desktopsChanged, () => {
+        world.do((clientManager, desktopManager) => {
+            desktopManager.updateDesktops();
+        })
     });
 
-    manager.connect(workspace.virtualScreenSizeChanged, () => {
+    manager.connect(Workspace.activitiesChanged, () => {
+        world.do((clientManager, desktopManager) => {
+            desktopManager.updateActivities();
+        })
+    });
+
+    manager.connect(Workspace.virtualScreenSizeChanged, () => {
         world.onScreenResized();
     });
 

src/world/ClientManager.ts

@@ -27,13 +27,13 @@ class ClientManager {
 
     public addClient(kwinClient: KwinClient) {
         console.assert(!this.hasClient(kwinClient));
+        const desktop = this.desktopManager.getDesktopForClient(kwinClient);
 
         let constructState: (client: ClientWrapper) => ClientState.State;
         if (kwinClient.dock) {
             constructState = () => new ClientState.Docked(this.world, kwinClient);
-        } else if (this.windowRuleEnforcer.shouldTile(kwinClient)) {
-            const grid = this.desktopManager.getDesktopForClient(kwinClient).grid;
-            constructState = (client: ClientWrapper) => new ClientState.Tiled(this.world, client, grid);
+        } else if (this.windowRuleEnforcer.shouldTile(kwinClient) && desktop !== undefined) {
+            constructState = (client: ClientWrapper) => new ClientState.Tiled(this.world, client, desktop.grid);
         } else {
             constructState = (client: ClientWrapper) => new ClientState.Floating(this.world, client, this.config, false);
         }
@@ -76,41 +76,41 @@ class ClientManager {
             return;
         }
         if (client.stateManager.getState() instanceof ClientState.Tiled) {
-            client.stateManager.setState(() => new ClientState.TiledMinimized(), kwinClient === this.lastFocusedClient);
+            client.stateManager.setState(
+                () => new ClientState.TiledMinimized(this.world, client),
+                kwinClient === this.lastFocusedClient,
+            );
         }
     }
 
-    public unminimizeClient(kwinClient: KwinClient) {
-        const client = this.clientMap.get(kwinClient);
-        if (client === undefined) {
-            return;
-        }
-        if (client.stateManager.getState() instanceof ClientState.TiledMinimized) {
-            const grid = this.desktopManager.getDesktopForClient(kwinClient).grid;
-            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), false);
-        }
-    }
-
-    public tileClient(kwinClient: KwinClient) {
-        const client = this.clientMap.get(kwinClient);
-        if (client === undefined) {
-            return;
-        }
+    public tileClient(client: ClientWrapper, grid: Grid) {
         if (client.stateManager.getState() instanceof ClientState.Tiled) {
             return;
         }
-        const grid = this.desktopManager.getDesktopForClient(kwinClient).grid;
         client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), false);
     }
 
-    public untileClient(kwinClient: KwinClient) {
+    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);
+    }
+
+    public tileKwinClient(kwinClient: KwinClient, grid: Grid) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
         }
-        if (client.stateManager.getState() instanceof ClientState.Tiled) {
-            client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), false);
+        this.tileClient(client, grid);
+    }
+
+    public floatKwinClient(kwinClient: KwinClient) {
+        const client = this.clientMap.get(kwinClient);
+        if (client === undefined) {
+            return;
         }
+        this.floatClient(client);
     }
 
     public pinClient(kwinClient: KwinClient) {
@@ -147,8 +147,11 @@ class ClientManager {
         const clientState = client.stateManager.getState();
         if ((clientState instanceof ClientState.Floating || clientState instanceof ClientState.Pinned) && Clients.canTileEver(kwinClient)) {
             Clients.makeTileable(kwinClient);
-            const grid = this.desktopManager.getDesktopForClient(kwinClient).grid;
-            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), false);
+            const desktop = this.desktopManager.getDesktopForClient(kwinClient);
+            if (desktop === undefined) {
+                return;
+            }
+            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, desktop.grid), false);
         } else if (clientState instanceof ClientState.Tiled) {
             client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), false);
         }

src/world/ClientWrapper.ts

@@ -3,8 +3,10 @@ class ClientWrapper {
     public readonly stateManager: ClientState.Manager;
     public transientFor: ClientWrapper | null;
     private readonly transients: ClientWrapper[];
+    private readonly signalManager: SignalManager;
     private readonly rulesSignalManager: SignalManager | null;
     public preferredWidth: number;
+    private maximizedMode: MaximizedMode | undefined;
     private readonly manipulatingGeometry: Doer;
     private lastPlacement: QmlRect | null; // workaround for issue #19
 
@@ -20,6 +22,7 @@ class ClientWrapper {
         if (transientFor !== null) {
             transientFor.addTransient(this);
         }
+        this.signalManager = ClientWrapper.initSignalManager(this);
         this.rulesSignalManager = rulesSignalManager;
         this.preferredWidth = kwinClient.frameGeometry.width;
         this.manipulatingGeometry = new Doer();
@@ -35,12 +38,18 @@ class ClientWrapper {
             }
             this.lastPlacement = Qt.rect(x, y, width, height);
             this.kwinClient.frameGeometry = this.lastPlacement;
+            if (this.kwinClient.frameGeometry !== this.lastPlacement) {
+                // frameGeometry assignment failed. This sometimes happens on Wayland
+                // when a window is off-screen, effectively making it stuck there.
+                this.kwinClient.frameGeometry.x = x; // This makes it unstuck.
+                this.kwinClient.frameGeometry = this.lastPlacement;
+            }
         });
     }
 
-    private moveTransient(dx: number, dy: number, desktopNumber: number) {
+    private moveTransient(dx: number, dy: number, kwinDesktops: KwinDesktop[]) {
         if (this.stateManager.getState() instanceof ClientState.Floating) {
-            if (this.kwinClient.desktop === desktopNumber) {
+            if (Clients.isOnOneOfVirtualDesktops(this.kwinClient, kwinDesktops)) {
                 const frame = this.kwinClient.frameGeometry;
                 this.kwinClient.frameGeometry = Qt.rect(
                     frame.x + dx,
@@ -51,32 +60,52 @@ class ClientWrapper {
             }
 
             for (const transient of this.transients) {
-                transient.moveTransient(dx, dy, desktopNumber);
+                transient.moveTransient(dx, dy, kwinDesktops);
             }
         }
     }
 
     public moveTransients(dx: number, dy: number) {
         for (const transient of this.transients) {
-            transient.moveTransient(dx, dy, this.kwinClient.desktop);
+            transient.moveTransient(dx, dy, this.kwinClient.desktops);
         }
     }
 
     public focus() {
-        workspace.activeClient = this.kwinClient;
+        Workspace.activeWindow = this.kwinClient;
     }
 
     public isFocused() {
-        return workspace.activeClient === this.kwinClient;
+        return Workspace.activeWindow === this.kwinClient;
     }
 
     public setMaximize(horizontally: boolean, vertically: boolean) {
+        if (!this.kwinClient.maximizable) {
+            return;
+        }
+
+        if (this.maximizedMode === undefined) {
+            if (horizontally && vertically) {
+                this.maximizedMode = MaximizedMode.Maximized;
+            } else if (horizontally) {
+                this.maximizedMode = MaximizedMode.Horizontally;
+            } else if (vertically) {
+                this.maximizedMode = MaximizedMode.Vertically;
+            } else {
+                this.maximizedMode = MaximizedMode.Unmaximized;
+            }
+        }
+
         this.manipulatingGeometry.do(() => {
             this.kwinClient.setMaximize(vertically, horizontally);
         });
     }
 
     public setFullScreen(fullScreen: boolean) {
+        if (!this.kwinClient.fullScreenable) {
+            return;
+        }
+
         this.manipulatingGeometry.do(() => {
             this.kwinClient.fullScreen = fullScreen;
         });
@@ -92,6 +121,10 @@ class ClientWrapper {
         return this.kwinClient.shade;
     }
 
+    public getMaximizedMode() {
+        return this.maximizedMode;
+    }
+
     public isManipulatingGeometry(newGeometry: QmlRect | null) {
         if (newGeometry !== null && newGeometry === this.lastPlacement) {
             return true;
@@ -118,7 +151,7 @@ class ClientWrapper {
     }
 
     public ensureVisible(screenSize: QmlRect) {
-        if (this.kwinClient.desktop !== workspace.currentDesktop) {
+        if (!Clients.isOnVirtualDesktop(this.kwinClient, Workspace.currentDesktop)) {
             return;
         }
         const frame = this.kwinClient.frameGeometry;
@@ -131,6 +164,7 @@ class ClientWrapper {
 
     public destroy(passFocus: boolean) {
         this.stateManager.destroy(passFocus);
+        this.signalManager.destroy();
         if (this.rulesSignalManager !== null) {
             this.rulesSignalManager.destroy();
         }
@@ -141,4 +175,17 @@ class ClientWrapper {
             transient.transientFor = null;
         }
     }
+
+    private static initSignalManager(client: ClientWrapper) {
+        const manager = new SignalManager();
+
+        manager.connect(client.kwinClient.maximizedAboutToChange, (maximizedMode: MaximizedMode) => {
+            if (maximizedMode > MaximizedMode.Unmaximized && client.kwinClient.tile !== null) {
+                client.kwinClient.tile = null;
+            }
+            client.maximizedMode = maximizedMode;
+        });
+
+        return manager;
+    }
 }

src/world/Clients.ts

@@ -1,35 +1,49 @@
 namespace Clients {
     export function canTileEver(kwinClient: KwinClient) {
-        return kwinClient.resizeable;
+        return kwinClient.moveable && kwinClient.resizeable && !kwinClient.popupWindow;
     }
 
     export function canTileNow(kwinClient: KwinClient) {
-        return canTileEver(kwinClient) && !kwinClient.minimized && kwinClient.desktop > 0 && kwinClient.activities.length === 1;
+        return canTileEver(kwinClient) && !kwinClient.minimized && kwinClient.desktops.length === 1 && kwinClient.activities.length === 1;
     }
 
     export function makeTileable(kwinClient: KwinClient) {
         if (kwinClient.minimized) {
             kwinClient.minimized = false;
         }
-        if (kwinClient.desktop <= 0) {
-            kwinClient.desktop = workspace.currentDesktop;
+        if (kwinClient.desktops.length !== 1) {
+            kwinClient.desktops = [Workspace.currentDesktop];
         }
         if (kwinClient.activities.length !== 1) {
-            kwinClient.activities = [workspace.currentActivity];
+            kwinClient.activities = [Workspace.currentActivity];
         }
     }
 
-    export function isMaximizedGeometry(kwinClient: KwinClient) {
-        const maximizeArea = workspace.clientArea(ClientAreaOption.MaximizeArea, kwinClient.screen, kwinClient.desktop);
-        return kwinClient.frameGeometry === maximizeArea;
+    export function getKwinDesktopApprox(kwinClient: KwinClient) {
+        switch (kwinClient.desktops.length) {
+            case 0:
+                return Workspace.currentDesktop;
+            case 1:
+                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.screen, kwinClient.desktop);
+        const fullScreenArea = Workspace.clientArea(ClientAreaOption.FullScreenArea, kwinClient.output, getKwinDesktopApprox(kwinClient));
         return kwinClient.frameGeometry === fullScreenArea;
     }
 
-    export function isOnVirtualDesktop(kwinClient: KwinClient, desktopNumber: number) {
-        return kwinClient.desktop === desktopNumber || kwinClient.desktop === -1;
+    export function isOnVirtualDesktop(kwinClient: KwinClient, kwinDesktop: KwinDesktop) {
+        return kwinClient.desktops.length === 0 || kwinClient.desktops.includes(kwinDesktop);
+    }
+
+    export function isOnOneOfVirtualDesktops(kwinClient: KwinClient, kwinDesktops: KwinDesktop[]) {
+        return kwinClient.desktops.length === 0 || kwinClient.desktops.some(d => kwinDesktops.includes(d));
     }
 }

src/world/DesktopManager.ts

@@ -2,145 +2,125 @@ class DesktopManager {
     private readonly pinManager: PinManager;
     private readonly config: Desktop.Config;
     public readonly layoutConfig: LayoutConfig;
-    private readonly desktopsPerActivity: Map<string, Desktop[]>;
-    private nVirtualDesktops: number;
+    private readonly desktops: Map<string, Desktop>; // key is activityId|desktopId
+    private kwinActivities: Set<string>;
+    private kwinDesktops: Set<KwinDesktop>;
 
-    constructor(pinManager: PinManager, config: Desktop.Config, layoutConfig: LayoutConfig, currentActivity: string) {
+    constructor(pinManager: PinManager, config: Desktop.Config, layoutConfig: LayoutConfig, currentActivity: string, currentDesktop: KwinDesktop) {
         this.pinManager = pinManager;
         this.config = config;
         this.layoutConfig = layoutConfig;
-        this.desktopsPerActivity = new Map();
-        this.nVirtualDesktops = 0;
-        this.update()
-        this.addActivity(currentActivity);
+        this.desktops = new Map();
+        this.kwinActivities = new Set(Workspace.activities);
+        this.kwinDesktops = new Set(Workspace.desktops);
+        this.addDesktop(currentActivity, currentDesktop);
     }
 
-    public update() {
-        this.setNVirtualDesktops(workspace.desktops);
-    }
-
-    public getDesktop(activity: string, desktopNumber: number) {
-        const desktopIndex = desktopNumber - 1;
-        if (desktopIndex >= this.nVirtualDesktops || desktopIndex < 0) {
-            throw new Error("invalid desktop number: " + String(desktopNumber));
+    public getDesktop(activity: string, kwinDesktop: KwinDesktop) {
+        const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
+        const desktop = this.desktops.get(desktopKey);
+        if (desktop !== undefined) {
+            return desktop;
+        } else {
+            return this.addDesktop(activity, kwinDesktop);
         }
-        if (!this.desktopsPerActivity.has(activity)) {
-            this.addActivity(activity);
-        }
-        return this.desktopsPerActivity.get(activity)![desktopIndex];
     }
 
     public getCurrentDesktop() {
-        return this.getDesktop(workspace.currentActivity, workspace.currentDesktop);
+        return this.getDesktop(Workspace.currentActivity, Workspace.currentDesktop);
     }
 
-    public getDesktopInCurrentActivity(desktopNumber: number) {
-        return this.getDesktop(workspace.currentActivity, desktopNumber);
+    public getDesktopInCurrentActivity(kwinDesktop: KwinDesktop) {
+        return this.getDesktop(Workspace.currentActivity, kwinDesktop);
     }
 
     public getDesktopForClient(kwinClient: KwinClient) {
-        console.assert(kwinClient.activities.length === 1 && kwinClient.desktop > 0);
-        return this.getDesktop(kwinClient.activities[0], kwinClient.desktop);
-    }
-
-    private setNVirtualDesktops(nVirtualDesktops: number) {
-        if (nVirtualDesktops > this.nVirtualDesktops) {
-            this.addDesktopsToActivities(nVirtualDesktops - this.nVirtualDesktops);
-        } else if (nVirtualDesktops < this.nVirtualDesktops) {
-            this.removeDesktopsFromActivities(this.nVirtualDesktops - nVirtualDesktops);
+        if (kwinClient.activities.length !== 1 || kwinClient.desktops.length !== 1) {
+            return undefined;
         }
-        this.nVirtualDesktops = nVirtualDesktops;
+        return this.getDesktop(kwinClient.activities[0], kwinClient.desktops[0]);
     }
 
-    private addDesktopsToActivities(n: number) {
-        for (const desktops of this.desktopsPerActivity.values()) {
-            this.addDesktops(desktops, n);
-        }
+    private addDesktop(activity: string, kwinDesktop: KwinDesktop) {
+        const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
+        const desktop = new Desktop(kwinDesktop, this.pinManager, this.config, this.layoutConfig);
+        this.desktops.set(desktopKey, desktop);
+        return desktop;
     }
 
-    private addDesktops(desktops: Desktop[], n: number) {
-        const nStart = desktops.length;
-        for (let i = 0; i < n; i++) {
-            const desktopNumber = nStart + i + 1;
-            desktops.push(new Desktop(desktopNumber, this.pinManager, this.config, this.layoutConfig));
-        }
+    private static getDesktopKey(activity: string, kwinDesktop: KwinDesktop) {
+        return activity + "|" + kwinDesktop.id;
     }
 
-    private removeDesktopsFromActivities(n: number) {
-        const lastRemainingDesktopIndex = this.nVirtualDesktops - n - 1;
-        for (const desktops of this.desktopsPerActivity.values()) {
-            const targetDesktop = desktops[lastRemainingDesktopIndex];
-            for (let i = 0; i < n; i++) {
-                const removedDesktop = desktops.pop()!;
-                removedDesktop.grid.evacuate(targetDesktop.grid);
+    public updateActivities() {
+        const newActivities = new Set(Workspace.activities);
+        for (const activity of this.kwinActivities) {
+            if (!newActivities.has(activity)) {
+                this.removeActivity(activity);
             }
         }
+        this.kwinActivities = newActivities;
     }
 
-    private addActivity(activity: string) {
-        const desktops: Desktop[] = [];
-        this.addDesktops(desktops, this.nVirtualDesktops);
-        this.desktopsPerActivity.set(activity, desktops);
+    public updateDesktops() {
+        const newDesktops = new Set(Workspace.desktops);
+        for (const desktop of this.kwinDesktops) {
+            if (!newDesktops.has(desktop)) {
+                this.removeKwinDesktop(desktop);
+            }
+        }
+        this.kwinDesktops = newDesktops;
     }
 
     private removeActivity(activity: string) {
-        const removedDesktops = this.desktopsPerActivity.get(activity)!;
-        this.desktopsPerActivity.delete(activity);
-        const targetActivityDesktops = this.desktopsPerActivity.values().next().value;
-        for (let i = 0; i < removedDesktops.length; i++) {
-            removedDesktops[i].grid.evacuate(targetActivityDesktops[i]);
+        for (const kwinDesktop of this.kwinDesktops) {
+            this.destroyDesktop(activity, kwinDesktop);
+        }
+    }
+
+    private removeKwinDesktop(kwinDesktop: KwinDesktop) {
+        for (const activity of this.kwinActivities) {
+            this.destroyDesktop(activity, kwinDesktop);
+        }
+    }
+
+    private destroyDesktop(activity: string, kwinDesktop: KwinDesktop) {
+        const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
+        const desktop = this.desktops.get(desktopKey);
+        if (desktop !== undefined) {
+            desktop.destroy();
+            this.desktops.delete(desktopKey);
         }
     }
 
     public destroy() {
-        for (const desktop of this.desktops()) {
+        for (const desktop of this.desktops.values()) {
             desktop.destroy();
         }
     }
 
-    public *desktops() {
-        for (const desktops of this.desktopsPerActivity.values()) {
-            for (const desktop of desktops) {
-                yield desktop;
-            }
+    public *getAllDesktops() {
+        for (const desktop of this.desktops.values()) {
+            yield desktop;
         }
     }
 
-    public *getDesktopsForClient(kwinClient: KwinClient) {
-        const activities = kwinClient.activities.length > 0 ? kwinClient.activities : this.desktopsPerActivity.keys();
-        for (const activity of activities) {
-            if (!this.desktopsPerActivity.has(activity)) {
-                this.addActivity(activity);
-            }
-            const activityDesktops = this.desktopsPerActivity.get(activity)!;
-            if (kwinClient.desktop === -1) {
-                for (const desktop of activityDesktops) {
-                    yield desktop;
-                }
-            } else {
-                const desktopIndex = kwinClient.desktop - 1;
-                yield activityDesktops[desktopIndex];
-            }
-        }
+    public getDesktopsForClient(kwinClient: KwinClient) {
+        const desktops = this.getDesktops(kwinClient.activities, kwinClient.desktops); // workaround for QTBUG-109880
+        return desktops;
     }
 
     // empty array means all
-    public *getDesktops(desktopNumbers: number[], inputActivities: string[]) {
-        const activities = inputActivities.length > 0 ? inputActivities : this.desktopsPerActivity.keys();
-        for (const activity of activities) {
-            if (!this.desktopsPerActivity.has(activity)) {
-                this.addActivity(activity);
-            }
-            const activityDesktops = this.desktopsPerActivity.get(activity)!;
-            if (desktopNumbers.length === 0) {
-                for (const desktop of activityDesktops) {
+    public *getDesktops(activities: string[], kwinDesktops: KwinDesktop[]) {
+        const matchedActivities = activities.length > 0 ? activities : this.kwinActivities.keys();
+        const matchedDesktops = kwinDesktops.length > 0 ? kwinDesktops : this.kwinDesktops.keys();
+        for (const matchedActivity of matchedActivities) {
+            for (const matchedDesktop of matchedDesktops) {
+                const desktopKey = DesktopManager.getDesktopKey(matchedActivity, matchedDesktop);
+                const desktop = this.desktops.get(desktopKey);
+                if (desktop !== undefined) {
                     yield desktop;
                 }
-            } else {
-                for (const desktopNumber of desktopNumbers) {
-                    const desktopIndex = desktopNumber - 1;
-                    yield activityDesktops[desktopIndex];
-                }
             }
         }
     }

src/world/PinManager.ts

@@ -13,11 +13,11 @@ class PinManager {
         this.pinnedClients.delete(kwinClient);
     }
 
-    public getAvailableSpace(desktopNumber: number, screen: QmlRect) {
+    public getAvailableSpace(kwinDesktop: KwinDesktop, screen: QmlRect) {
         const baseLot = new PinManager.Lot(screen.top, screen.bottom, screen.left, screen.right);
         let lots = [baseLot];
         for (const client of this.pinnedClients) {
-            if (!Clients.isOnVirtualDesktop(client, desktopNumber)) {
+            if (!Clients.isOnVirtualDesktop(client, kwinDesktop)) {
                 continue;
             }
 

src/world/World.ts

@@ -4,16 +4,21 @@ class World {
     public readonly clientManager: ClientManager;
     private readonly pinManager: PinManager;
     private readonly workspaceSignalManager: SignalManager;
+    private readonly shortcutActions: ShortcutAction[];
     private readonly screenResizedDelayer: Delayer;
 
     constructor(config: Config) {
         this.untileOnDrag = config.untileOnDrag;
         this.workspaceSignalManager = initWorkspaceSignalHandlers(this);
+        this.shortcutActions = registerKeyBindings(this, {
+            manualScrollStep: config.manualScrollStep,
+            manualResizeStep: config.manualResizeStep,
+            columnResizer: config.scrollingCentered ? new RawResizer() : new ContextualResizer(),
+        });
 
         this.screenResizedDelayer = new Delayer(1000, () => {
-            // this delay ensures that docks get taken into account by `workspace.clientArea`
-            const desktopManager = this.desktopManager; // workaround for bug in Qt5's JS engine
-            for (const desktop of desktopManager.desktops()) {
+            // this delay ensures that docks are taken into account by `Workspace.clientArea`
+            for (const desktop of this.desktopManager.getAllDesktops()) {
                 desktop.onLayoutChanged();
             }
             this.update();
@@ -40,13 +45,15 @@ class World {
                 marginBottom: config.gapsOuterBottom,
                 marginLeft: config.gapsOuterLeft,
                 marginRight: config.gapsOuterRight,
-                scroller: config.scrollingLazy ? new ScrollerLazy() :
-                    config.scrollingCentered ? new ScrollerCentered() :
-                    config.scrollingGrouped ? new ScrollerGrouped() :
+                scroller: config.scrollingLazy ? new LazyScroller() :
+                    config.scrollingCentered ? new CenteredScroller() :
+                    config.scrollingGrouped ? new GroupedScroller() :
                     console.assert(false),
+                clamper: config.scrollingLazy ? new EdgeClamper() : new CenterClamper(),
             },
             layoutConfig,
-            workspace.currentActivity,
+            Workspace.currentActivity,
+            Workspace.currentDesktop,
         );
         this.clientManager = new ClientManager(config, this, this.desktopManager, this.pinManager);
         this.addExistingClients();
@@ -54,17 +61,13 @@ class World {
     }
 
     private addExistingClients() {
-        const kwinClients = workspace.clientList();
+        const kwinClients = Workspace.windows;
         for (let i = 0; i < kwinClients.length; i++) {
             const kwinClient = kwinClients[i];
             this.clientManager.addClient(kwinClient);
         }
     }
 
-    public updateDesktops() {
-        this.desktopManager.update();
-    }
-
     private update() {
         this.desktopManager.getCurrentDesktop().arrange();
     }
@@ -93,11 +96,14 @@ class World {
         followTransient: boolean,
         f: (clientManager: ClientManager, desktopManager: DesktopManager, window: Window, column: Column, grid: Grid) => void,
     ) {
-        this.doIfTiled(workspace.activeClient, followTransient, f);
+        this.doIfTiled(Workspace.activeWindow, followTransient, f);
     }
 
     public destroy() {
         this.workspaceSignalManager.destroy();
+        for (const shortcutAction of this.shortcutActions) {
+            shortcutAction.destroy();
+        }
         this.clientManager.destroy();
         this.desktopManager.destroy();
     }

src/world/clientState/Docked.ts

@@ -16,7 +16,7 @@ namespace ClientState {
 
         private static initSignalManager(world: World, kwinClient: KwinClient) {
             const manager = new SignalManager();
-            manager.connect(kwinClient.frameGeometryChanged, (kwinClient: KwinClient, oldGeometry: QmlRect) => {
+            manager.connect(kwinClient.frameGeometryChanged, () => {
                 world.onScreenResized();
             });
             return manager;

src/world/clientState/Floating.ts

@@ -24,7 +24,11 @@ namespace ClientState {
         }
 
         private static limitHeight(client: ClientWrapper) {
-            const placementArea = workspace.clientArea(ClientAreaOption.PlacementArea, client.kwinClient.screen, client.kwinClient.desktop);
+            const placementArea = Workspace.clientArea(
+                ClientAreaOption.PlacementArea,
+                client.kwinClient.output,
+                Clients.getKwinDesktopApprox(client.kwinClient),
+            );
             const clientRect = client.kwinClient.frameGeometry;
             const width = client.preferredWidth;
             client.place(
@@ -54,7 +58,7 @@ namespace ClientState {
                         clientManager.pinClient(kwinClient);
                     });
                 }
-            })
+            });
 
             return manager;
         }

src/world/clientState/Pinned.ts

@@ -30,8 +30,8 @@ namespace ClientState {
 
         private static initSignalManager(world: World, pinManager: PinManager, kwinClient: KwinClient) {
             const manager = new SignalManager();
-            let oldDesktopNumber = kwinClient.desktop;
             let oldActivities = kwinClient.activities;
+            let oldDesktops = kwinClient.desktops;
 
             manager.connect(kwinClient.tileChanged, () => {
                 if (kwinClient.tile === null) {
@@ -41,7 +41,7 @@ namespace ClientState {
                 }
             });
 
-            manager.connect(kwinClient.frameGeometryChanged, (kwinClient: KwinClient, oldGeometry: QmlRect) => {
+            manager.connect(kwinClient.frameGeometryChanged, () => {
                 if (kwinClient.tile === null) {
                     world.do((clientManager, desktopManager) => {
                         clientManager.unpinClient(kwinClient);
@@ -56,25 +56,24 @@ namespace ClientState {
                 })
             });
 
-            manager.connect(kwinClient.desktopChanged, () => {
-                const changedDesktops = oldDesktopNumber === -1 || kwinClient.desktop === -1 ?
+            manager.connect(kwinClient.desktopsChanged, () => {
+                const changedDesktops = oldDesktops.length === 0 || kwinClient.desktops.length === 0 ?
                     [] :
-                    [oldDesktopNumber, kwinClient.desktop];
+                    union(oldDesktops, kwinClient.desktops);
                 world.do((clientManager, desktopManager) => {
-                    for (const desktop of desktopManager.getDesktops(changedDesktops, kwinClient.activities)) {
+                    for (const desktop of desktopManager.getDesktops(kwinClient.activities, changedDesktops)) {
                         desktop.onPinsChanged();
                     }
                 });
-                oldDesktopNumber = kwinClient.desktop;
+                oldDesktops = kwinClient.desktops;
             });
 
-            manager.connect(kwinClient.activitiesChanged, (kwinClient: KwinClient) => {
-                const desktops = kwinClient.desktop === -1 ? [] : [kwinClient.desktop];
+            manager.connect(kwinClient.activitiesChanged, () => {
                 const changedActivities = oldActivities.length === 0 || kwinClient.activities.length === 0 ?
                     [] :
                     union(oldActivities, kwinClient.activities);
                 world.do((clientManager, desktopManager) => {
-                    for (const desktop of desktopManager.getDesktops(desktops, changedActivities)) {
+                    for (const desktop of desktopManager.getDesktops(changedActivities, kwinClient.desktops)) {
                         desktop.onPinsChanged();
                     }
                 });

src/world/clientState/Tiled.ts

@@ -31,59 +31,71 @@ namespace ClientState {
             const kwinClient = client.kwinClient;
             const manager = new SignalManager();
 
-            manager.connect(kwinClient.desktopChanged, () => {
+            manager.connect(kwinClient.desktopsChanged, () => {
                 world.do((clientManager, desktopManager) => {
-                    if (kwinClient.desktop === -1) {
-                        // windows on all desktops are not supported
-                        clientManager.untileClient(kwinClient);
+                    const desktop = desktopManager.getDesktopForClient(kwinClient);
+                    if (desktop === undefined) {
+                        // windows on multiple desktops are not supported
+                        clientManager.floatKwinClient(kwinClient);
                         return;
                     }
-                    Tiled.moveWindowToCorrectGrid(desktopManager, window);
+                    Tiled.moveWindowToGrid(window, desktop.grid);
                 });
             });
 
             manager.connect(kwinClient.activitiesChanged, () => {
                 world.do((clientManager, desktopManager) => {
-                    if (kwinClient.activities.length !== 1) {
+                    const desktop = desktopManager.getDesktopForClient(kwinClient);
+                    if (desktop === undefined) {
                         // windows on multiple activities are not supported
-                        clientManager.untileClient(kwinClient);
+                        clientManager.floatKwinClient(kwinClient);
                         return;
                     }
-                    Tiled.moveWindowToCorrectGrid(desktopManager, window);
+                    Tiled.moveWindowToGrid(window, desktop.grid);
                 });
             })
 
-            let lastResize = false;
-            manager.connect(kwinClient.moveResizedChanged, () => {
+            manager.connect(kwinClient.minimizedChanged, () => {
+                console.assert(kwinClient.minimized);
                 world.do((clientManager, desktopManager) => {
-                    if (kwinClient.move) {
-                        if (world.untileOnDrag) {
-                            clientManager.untileClient(kwinClient);
-                        }
-                        return;
-                    }
-
-                    const grid = window.column.grid;
-                    const resize = kwinClient.resize;
-                    if (!lastResize && resize) {
-                        grid.onUserResizeStarted();
-                    }
-                    if (lastResize && !resize) {
-                        grid.onUserResizeFinished();
-                    }
-                    lastResize = resize;
+                    clientManager.minimizeClient(kwinClient);
                 });
             });
 
-            let cursorChangedAfterResizeStart = false;
-            manager.connect(kwinClient.moveResizeCursorChanged, () => {
-                cursorChangedAfterResizeStart = true;
-            });
-            manager.connect(kwinClient.clientStartUserMovedResized, () => {
-                cursorChangedAfterResizeStart = false;
+            manager.connect(kwinClient.maximizedAboutToChange, (maximizedMode: MaximizedMode) => {
+                world.do(() => {
+                    window.onMaximizedChanged(maximizedMode);
+                });
             });
 
-            manager.connect(kwinClient.frameGeometryChanged, (kwinClient: KwinClient, oldGeometry: QmlRect) => {
+            let resizing = false;
+            let resizingBorder = false;
+            manager.connect(kwinClient.interactiveMoveResizeStarted, () => {
+                if (kwinClient.move) {
+                    if (world.untileOnDrag) {
+                        world.do((clientManager, desktopManager) => {
+                            clientManager.floatKwinClient(kwinClient);
+                        });
+                    }
+                    return;
+                }
+
+                if (kwinClient.resize) {
+                    resizing = true;
+                    resizingBorder = Workspace.cursorPos.x > kwinClient.frameGeometry.right ||
+                        Workspace.cursorPos.x < kwinClient.frameGeometry.left;
+                    window.column.grid.onUserResizeStarted();
+                }
+            });
+
+            manager.connect(kwinClient.interactiveMoveResizeFinished, () => {
+                if (resizing) {
+                    resizing = false;
+                    window.column.grid.onUserResizeFinished();
+                }
+            });
+
+            manager.connect(kwinClient.frameGeometryChanged, (oldGeometry: QmlRect) => {
                 // on Wayland, this fires after `tileChanged`
                 if (kwinClient.tile !== null) {
                     world.do((clientManager, desktopManager) => {
@@ -104,10 +116,11 @@ namespace ClientState {
                 }
 
                 if (kwinClient.resize) {
-                    world.do(() => window.onUserResize(oldGeometry, !cursorChangedAfterResizeStart));
+                    world.do(() => window.onUserResize(oldGeometry, resizingBorder));
                 } else if (
+                    !window.column.grid.isUserResizing() &&
                     !client.isManipulatingGeometry(newGeometry) &&
-                    !Clients.isMaximizedGeometry(kwinClient) &&
+                    client.getMaximizedMode() === MaximizedMode.Unmaximized &&
                     !Clients.isFullScreenGeometry(kwinClient) // not using `kwinClient.fullScreen` because it may not be set yet at this point
                 ) {
                     world.do(() => window.onFrameGeometryChanged());
@@ -130,17 +143,13 @@ namespace ClientState {
             return manager;
         }
 
-        private static moveWindowToCorrectGrid(desktopManager: DesktopManager, window: Window) {
-            const kwinClient = window.client.kwinClient;
-
-            const oldGrid = window.column.grid;
-            const newGrid = desktopManager.getDesktopForClient(kwinClient).grid;
-            if (oldGrid === newGrid) {
-                // window already on the correct grid
+        private static moveWindowToGrid(window: Window, grid: Grid) {
+            if (grid === window.column.grid) {
+                // window already on the given grid
                 return;
             }
 
-            const newColumn = new Column(newGrid, newGrid.getLastFocusedColumn() ?? newGrid.getLastColumn());
+            const newColumn = new Column(grid, grid.getLastFocusedColumn() ?? grid.getLastColumn());
             window.moveToColumn(newColumn);
         }
 
@@ -165,6 +174,9 @@ namespace ClientState {
             if (config.tiledKeepBelow) {
                 client.kwinClient.keepBelow = false;
             }
+            if (config.offScreenOpacity < 1.0) {
+                client.kwinClient.opacity = 1.0;
+            }
             client.setShade(false);
             client.setFullScreen(false);
             if (client.kwinClient.tile === null) {

src/world/clientState/TiledMinimized.ts

@@ -1,5 +1,31 @@
 namespace ClientState {
     export class TiledMinimized implements State {
-        public destroy(passFocus: boolean) {}
+        private readonly signalManager: SignalManager;
+
+        constructor(world: World, client: ClientWrapper) {
+            this.signalManager = TiledMinimized.initSignalManager(world, client);
+        }
+
+        public destroy(passFocus: boolean) {
+            this.signalManager.destroy();
+        }
+
+        private static initSignalManager(world: World, client: ClientWrapper) {
+            const manager = new SignalManager();
+
+            manager.connect(client.kwinClient.minimizedChanged, () => {
+                console.assert(!client.kwinClient.minimized);
+                world.do((clientManager, desktopManager) => {
+                    const desktop = desktopManager.getDesktopForClient(client.kwinClient);
+                    if (desktop !== undefined) {
+                        clientManager.tileClient(client, desktop.grid);
+                    } else {
+                        clientManager.floatClient(client);
+                    }
+                });
+            });
+
+            return manager;
+        }
     }
 }