bump package to 0.14

* fix: float polkit authentication window

* fix: ignore polkit windows on X11

Co-authored-by: Peter Fajdiga <peter.fajdiga@gmail.com>

---------

Co-authored-by: Peter Fajdiga <peter.fajdiga@gmail.com>

.github/ISSUE_TEMPLATE/1-compatibility-issue.md

@@ -0,0 +1,19 @@
+---
+name: Compatibility issue
+about: Report an issue with a specific application or window
+title: "[Compatibility]"
+labels: ''
+assignees: ''
+
+---
+
+Karousel version:
+Plasma version:
+X11 / Wayland:
+
+Window class:
+Window caption (title):
+Window type:
+(Get this info [here](https://github.com/peterfajdiga/karousel/wiki/Getting-window-info))
+
+Description:

.github/ISSUE_TEMPLATE/2-bug-report.md

@@ -0,0 +1,14 @@
+---
+name: Generic bug report
+about: Report a bug
+title: "[Bug]"
+labels: ''
+assignees: ''
+
+---
+
+Karousel version:
+Plasma version:
+X11 / Wayland:
+
+Description:

.github/ISSUE_TEMPLATE/3-feature_request.md

@@ -0,0 +1,22 @@
+---
+name: Feature request
+about: Request a feature
+title: "[Feature]"
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.
+
+These sections are just guidelines, feel free to remove them.

.gitignore

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

Makefile

@@ -1,29 +1,43 @@
+VERSION = $(shell grep '"Version":' ./package/metadata.json | grep -o '[0-9\.]*')
+CHECKS := true
+
 .PHONY: *
 
-VERSION = $(shell grep '"Version":' ./package/metadata.json | grep -o '[0-9\.]*')
-
-build: tests
+build: lint tests
 	tsc -p ./src/main --outFile ./package/contents/code/main.js
 	mkdir -p ./package/contents/config
 	./run-ts.sh ./src/generators/config > ./package/contents/config/main.xml
 
+npm-install:
+	npm install
+
+lint: npm-install
+ifeq (${CHECKS}, true)
+	npx eslint ./src
+endif
+
+lint-fix: npm-install
+	npx eslint ./src --fix
+
 tests:
+ifeq (${CHECKS}, true)
 	./run-ts.sh ./src/tests
+endif
 
 install: build
-	kpackagetool6 --type=KWin/Script -i ./package || kpackagetool6 --type=KWin/Script -u ./package
+	kpackagetool6 --type=KWin/Script --install=./package || kpackagetool6 --type=KWin/Script --upgrade=./package
 
 uninstall:
-	kpackagetool6 --type=KWin/Script -r karousel
+	kpackagetool6 --type=KWin/Script --remove=karousel
 
 package: build
-	tar -czf ./karousel_${subst .,_,${VERSION}}.tar.gz ./package
+	tar -czf ./karousel_${subst .,_,${VERSION}}.tar.gz ./package --transform s/package/karousel/
 
 docs-key-bindings-bbcode:
 	@./run-ts.sh ./src/generators/docs/keyBindingsBbcode
 
-docs-key-bindings-table:
-	@./run-ts.sh ./src/generators/docs/keyBindingsTable
+docs-key-bindings-markdown:
+	@./run-ts.sh ./src/generators/docs/keyBindingsMarkdown
 
 docs-key-bindings-fmt:
 	@./run-ts.sh ./src/generators/docs/keyBindingsFmt

README.md

@@ -1,17 +1,11 @@
 # Karousel
-KWin tiling script with scrolling. Works especially well with ultrawide screens.
+Scrollable tiling Kwin script. Works especially well with ultrawide screens.
 Use with [this](https://github.com/peterfajdiga/kwin4_effect_geometry_change) for animations.
 
 https://github.com/peterfajdiga/karousel/assets/22796326/2ab62d18-09c7-45f9-8fda-e5e36b8d7a02
 
-Karousel works differently from most tiling window managers in that it does not maximize the width
-of windows, as this can be undesirable with wider screens, where it results in excessively wide
-windows that require large return sweeps when reading their content.
-Instead, it leaves the width of windows to the user's control. This additionally prevents
-unprompted reflow of window content.
-
-Windows are automatically centered when possible. And when running out of width, windows can be
-scrolled through horizontally.
+A scrollable tiling window manager tiles windows, but it does not maximize their widths. Instead, it leaves the width of windows to the user's control.
+Windows are automatically centered when possible. And when running out of width, windows can be scrolled through horizontally.
 
 Similar window managers include [PaperWM](https://github.com/paperwm/PaperWM),
 [Niri](https://github.com/YaLTeR/niri), and
@@ -28,6 +22,13 @@ Karousel requires the following QML modules:
 - Doesn't support windows on all desktops
 - Doesn't support windows on multiple activities
 
+## Installation
+First install the _org.kde.notification_ QML module (_qml-module-org-kde-notifications_ package on Ubuntu).
+
+Then download the [latest release](https://github.com/peterfajdiga/karousel/releases/latest) and extract it into _~/.local/share/kwin/scripts/_.
+
+Or clone the repo and run `make install` (requires npm, node, and tsc).
+
 ## Key bindings
 The key bindings can be configured in KDE System Settings among KWin's own keyboard shortcuts.
 Here's the default ones:
@@ -38,22 +39,30 @@ Here's the default ones:
 | Meta+D                   | Move focus right (Clashes with default KDE shortcuts, may require manual remapping)                                            |
 | Meta+W                   | Move focus up (Clashes with default KDE shortcuts, may require manual remapping)                                               |
 | Meta+S                   | Move focus down (Clashes with default KDE shortcuts, may require manual remapping)                                             |
+| (unassigned)             | Move focus to the next window in grid                                                                                          |
+| (unassigned)             | Move focus to the previous window in grid                                                                                      |
 | Meta+Home                | Move focus to start                                                                                                            |
 | Meta+End                 | Move focus to end                                                                                                              |
 | Meta+Shift+A             | Move window left (Moves window out of and into columns)                                                                        |
 | Meta+Shift+D             | Move window right (Moves window out of and into columns)                                                                       |
 | Meta+Shift+W             | Move window up                                                                                                                 |
 | Meta+Shift+S             | Move window down                                                                                                               |
+| (unassigned)             | Move window to the next position in grid                                                                                       |
+| (unassigned)             | Move window to the previous position in grid                                                                                   |
 | Meta+Shift+Home          | Move window to start                                                                                                           |
 | Meta+Shift+End           | Move window to end                                                                                                             |
-| Meta+X                   | Toggle stacked layout for focused column (One window in the column visible, others shaded; not supported on Wayland)           |
+| Meta+X                   | Toggle stacked layout for focused column (Only the active window visible)                                                      |
 | Meta+Ctrl+Shift+A        | Move column left                                                                                                               |
 | Meta+Ctrl+Shift+D        | Move column right                                                                                                              |
 | Meta+Ctrl+Shift+Home     | Move column to start                                                                                                           |
 | Meta+Ctrl+Shift+End      | Move column to end                                                                                                             |
 | Meta+Ctrl++              | Increase column width                                                                                                          |
 | Meta+Ctrl+-              | Decrease column width                                                                                                          |
+| Meta+R                   | Cycle through preset column widths                                                                                             |
+| Meta+Shift+R             | Cycle through preset column widths in reverse                                                                                  |
 | Meta+Ctrl+X              | Equalize widths of visible columns                                                                                             |
+| Meta+Ctrl+A              | Squeeze left column onto the screen (Clashes with default KDE shortcuts, may require manual remapping)                         |
+| Meta+Ctrl+D              | Squeeze right column onto the screen                                                                                           |
 | Meta+Alt+Return          | Center focused window (Scrolls so that the focused window is centered in the screen)                                           |
 | Meta+Alt+A               | Scroll one column to the left                                                                                                  |
 | Meta+Alt+D               | Scroll one column to the right                                                                                                 |
@@ -61,6 +70,7 @@ Here's the default ones:
 | Meta+Alt+PgDown          | Scroll right                                                                                                                   |
 | Meta+Alt+Home            | Scroll to start                                                                                                                |
 | Meta+Alt+End             | Scroll to end                                                                                                                  |
+| Meta+Ctrl+Return         | Move Karousel grid to the current screen                                                                                       |
 | Meta+[N]                 | Move focus to column N (Clashes with default KDE shortcuts, may require manual remapping)                                      |
 | Meta+Shift+[N]           | Move window to column N (Requires manual remapping according to your keyboard layout, e.g. Meta+Shift+1 -> Meta+!)             |
 | Meta+Ctrl+Shift+[N]      | Move column to position N (Requires manual remapping according to your keyboard layout, e.g. Meta+Ctrl+Shift+1 -> Meta+Ctrl+!) |

eslint.config.mjs

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

package.json

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

package/contents/ui/config.ui

@@ -29,13 +29,23 @@
                                                 </property>
                                             </widget>
                                         </item>
+                                        <item>
+                                            <widget class="QCheckBox" name="kcfg_cursorFollowsFocus">
+                                                <property name="text">
+                                                    <string>Cursor follows focus</string>
+                                                </property>
+                                                <property name="toolTip">
+                                                    <string>When a window gains focus, move the cursor to it</string>
+                                                </property>
+                                            </widget>
+                                        </item>
                                         <item>
                                             <widget class="QCheckBox" name="kcfg_stackColumnsByDefault">
                                                 <property name="text">
                                                     <string>Stack columns by default</string>
                                                 </property>
                                                 <property name="toolTip">
-                                                    <string>New columns start in stacked mode (one window in the column visible, others shaded). Not supported on Wayland.</string>
+                                                    <string>New columns start in stacked mode (only the active window visible)</string>
                                                 </property>
                                             </widget>
                                         </item>
@@ -101,6 +111,35 @@
                                 </widget>
                             </item>
 
+                            <item>
+                                <widget class="QGroupBox">
+                                    <property name="title">
+                                        <string>Touchpad scrolling (Wayland only)</string>
+                                    </property>
+                                    <layout class="QVBoxLayout">
+                                        <item>
+                                            <widget class="QCheckBox" name="kcfg_gestureScroll">
+                                                <property name="text">
+                                                    <string>Enable scrolling with touchpad gestures
+(please don't forget to disable KDE's workspace switching gestures)</string>
+                                                </property>
+                                                <property name="toolTip">
+                                                    <string>Scroll with a three-finger horizontal swipe gesture</string>
+                                                </property>
+                                            </widget>
+                                        </item>
+
+                                        <item>
+                                            <widget class="QCheckBox" name="kcfg_gestureScrollInvert">
+                                                <property name="text">
+                                                    <string>Invert scroll direction (Natural scrolling)</string>
+                                                </property>
+                                            </widget>
+                                        </item>
+                                    </layout>
+                                </widget>
+                            </item>
+
                             <item>
                                 <widget class="QGroupBox">
                                     <property name="title">
@@ -280,14 +319,14 @@
                             </item>
 
                             <item row="6" column="0">
-                                <widget class="QLabel" name="label_manualScrollStep">
+                                <widget class="QLabel" name="label_stackOffsetX">
                                     <property name="text">
-                                        <string>Manual scroll step size:</string>
+                                        <string>Horizontal offset for stacked columns:</string>
                                     </property>
                                 </widget>
                             </item>
                             <item row="6" column="1">
-                                <widget class="QSpinBox" name="kcfg_manualScrollStep">
+                                <widget class="QSpinBox" name="kcfg_stackOffsetX">
                                     <property name="suffix">
                                         <string> px</string>
                                     </property>
@@ -301,14 +340,14 @@
                             </item>
 
                             <item row="7" column="0">
-                                <widget class="QLabel" name="label_manualResizeStep">
+                                <widget class="QLabel" name="label_stackOffsetY">
                                     <property name="text">
-                                        <string>Manual resize step size:</string>
+                                        <string>Vertical offset for stacked columns:</string>
                                     </property>
                                 </widget>
                             </item>
                             <item row="7" column="1">
-                                <widget class="QSpinBox" name="kcfg_manualResizeStep">
+                                <widget class="QSpinBox" name="kcfg_stackOffsetY">
                                     <property name="suffix">
                                         <string> px</string>
                                     </property>
@@ -322,13 +361,82 @@
                             </item>
 
                             <item row="8" column="0">
+                                <widget class="QLabel" name="label_manualScrollStep">
+                                    <property name="text">
+                                        <string>Manual scroll step size:</string>
+                                    </property>
+                                </widget>
+                            </item>
+                            <item row="8" column="1">
+                                <widget class="QSpinBox" name="kcfg_manualScrollStep">
+                                    <property name="suffix">
+                                        <string> px</string>
+                                    </property>
+                                    <property name="maximum">
+                                        <number>999</number>
+                                    </property>
+                                    <property name="value">
+                                        <number>0</number>
+                                    </property>
+                                </widget>
+                            </item>
+
+                            <item row="9" column="0">
+                                <widget class="QLabel" name="label_gestureScrollStep">
+                                    <property name="text">
+                                        <string>Touchpad gesture scrolling speed:</string>
+                                    </property>
+                                    <property name="toolTip">
+                                        <string>The amount to scroll per edge-to-edge gesture</string>
+                                    </property>
+                                </widget>
+                            </item>
+                            <item row="9" column="1">
+                                <widget class="QSpinBox" name="kcfg_gestureScrollStep">
+                                    <property name="suffix">
+                                        <string> px</string>
+                                    </property>
+                                    <property name="maximum">
+                                        <number>10000</number>
+                                    </property>
+                                    <property name="minimum">
+                                        <number>100</number>
+                                    </property>
+                                    <property name="singleStep">
+                                        <number>100</number>
+                                    </property>
+                                    <property name="value">
+                                        <number>1920</number>
+                                    </property>
+                                </widget>
+                            </item>
+
+                            <item row="10" column="0">
+                                <widget class="QLabel" name="label_presetWidths">
+                                    <property name="text">
+                                        <string>Preset widths:</string>
+                                    </property>
+                                    <property name="toolTip">
+                                        <string>Widths used for cycling through widths</string>
+                                    </property>
+                                </widget>
+                            </item>
+                            <item row="10" column="1">
+                                <widget class="QLineEdit" name="kcfg_presetWidths">
+                                    <property name="toolTip">
+                                        <string>Comma-separated list of widths. Supported units: "px" and "%".</string>
+                                    </property>
+                                </widget>
+                            </item>
+
+                            <item row="11" column="0">
                                 <widget class="QLabel" name="label_offScreenOpacity">
                                     <property name="text">
                                         <string>Obscured window opacity:</string>
                                     </property>
                                 </widget>
                             </item>
-                            <item row="8" column="1">
+                            <item row="11" column="1">
                                 <widget class="QSpinBox" name="kcfg_offScreenOpacity">
                                     <property name="suffix">
                                         <string> %</string>
@@ -341,6 +449,7 @@
                                     </property>
                                 </widget>
                             </item>
+
                         </layout>
                     </widget>
 

package/contents/ui/main.qml

@@ -25,4 +25,39 @@ Item {
         flags: Notification.Persistent
         urgency: Notification.HighUrgency
     }
+
+    Notification {
+        id: notificationInvalidPresetWidths
+        componentName: "plasma_workspace"
+        eventId: "notification"
+        title: "Karousel"
+        text: "Your preset widths are malformed, please review your Karousel configuration"
+        flags: Notification.Persistent
+        urgency: Notification.HighUrgency
+    }
+
+    SwipeGestureHandler {
+        direction: SwipeGestureHandler.Direction.Left
+        fingerCount: 3
+        onActivated: qmlBase.karouselInstance.gestureScrollFinish()
+        onCancelled: qmlBase.karouselInstance.gestureScrollFinish()
+        onProgressChanged: qmlBase.karouselInstance.gestureScroll(-progress)
+    }
+
+    SwipeGestureHandler {
+        direction: SwipeGestureHandler.Direction.Right
+        fingerCount: 3
+        onActivated: qmlBase.karouselInstance.gestureScrollFinish()
+        onCancelled: qmlBase.karouselInstance.gestureScrollFinish()
+        onProgressChanged: qmlBase.karouselInstance.gestureScroll(progress)
+    }
+
+    DBusCall {
+        id: moveCursorToFocus
+
+        service: "org.kde.kglobalaccel"
+        path: "/component/kwin"
+        method: "invokeShortcut"
+        arguments: ["MoveMouseToFocus"]
+    }
 }

package/metadata.json

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

run-ts.sh

@@ -1,2 +1,8 @@
 #!/bin/bash
-tsc -p "$1" --outFile ./run-ts-tmp.js && node ./run-ts-tmp.js && rm ./run-ts-tmp.js
+set -e
+set -o pipefail
+
+JS_FILE='./run-ts-tmp.js'
+
+tsc -p "$1" --outFile "$JS_FILE"
+node "$JS_FILE"

src/extern/global.d.ts

@@ -0,0 +1,7 @@
+declare const Qt: Qt;
+declare const KWin: KWin;
+declare const Workspace: Workspace;
+declare const qmlBase: QmlObject;
+declare const notificationInvalidWindowRules: Notification;
+declare const notificationInvalidPresetWidths: Notification;
+declare const moveCursorToFocus: DBusCall;

src/generators/config/tsconfig.json

@@ -1,4 +1,8 @@
 {
     "extends": "../../tsconfig.json",
-    "include": ["../../lib/**/*", "./**/*"]
+    "include": [
+        "../../extern/**/*",
+        "../../lib/**/*",
+        "./**/*"
+    ]
 }

src/generators/docs/keyBindings.ts

@@ -1,5 +1,11 @@
-function formatComment(comment: string | undefined) {
-    return comment === undefined ? "" : ` (${comment})`;
+interface DocsKeyBinding {
+    description: string;
+    keySequence: string;
+}
+
+function formatDescription(item: {description: string, comment?: string}) {
+    const suffix = item.comment === undefined ? "" : ` (${item.comment})`;
+    return `${applyMacro(item.description, "N")}${suffix}`;
 }
 
 function printCols(...columns: (string[] | string)[]) {
@@ -9,9 +15,9 @@ function printCols(...columns: (string[] | string)[]) {
     }
 
     let nRows = Math.min(...columns.filter(
-        (column: string[] | string) => column instanceof Array
+        (column: string[] | string) => column instanceof Array,
     ).map(
-        (column: string[] | string) => column.length
+        (column: string[] | string) => column.length,
     ));
     if (nRows === Infinity) {
         // we only have single string columns
@@ -22,12 +28,12 @@ function printCols(...columns: (string[] | string)[]) {
         (column: string[] | string) => {
             if (column instanceof Array) {
                 return Math.max(...column.map(
-                    (cell: string) => cell.length
-                ))
+                    (cell: string) => cell.length,
+                ));
             } else {
                 return column.length;
             }
-        }
+        },
     );
 
     function getCell(col: number, row: number) {
@@ -48,3 +54,15 @@ function printCols(...columns: (string[] | string)[]) {
         console.log(line);
     }
 }
+
+const empty: any = {};
+const keyBindings: DocsKeyBinding[] = Array.prototype.concat(
+    getKeyBindings(empty, empty).map(binding => ({
+        description: formatDescription(binding),
+        keySequence: binding.defaultKeySequence || "(unassigned)",
+    })),
+    getNumKeyBindings(empty, empty).map(binding => ({
+        description: formatDescription(binding),
+        keySequence: `${binding.defaultModifiers}+${binding.fKeys ? "F" : ""}[N]`,
+    })),
+);

src/generators/docs/keyBindingsBbcode/main.ts

@@ -1,12 +1,7 @@
 console.log(`[list]`);
 
 for (const binding of keyBindings) {
-    console.log(`    [*] ${binding.defaultKeySequence} — ${binding.description}${formatComment(binding.comment)}`);
-}
-
-for (const binding of numKeyBindings) {
-    const numPrefix = binding.fKeys ? "F" : "";
-    console.log(`    [*] ${binding.defaultModifiers}+${numPrefix}[N] — ${binding.description}N${formatComment(binding.comment)}`);
+    console.log(`    [*] ${binding.keySequence} — ${binding.description}`);
 }
 
 console.log(`[/list]`);

src/generators/docs/keyBindingsBbcode/tsconfig.json

@@ -1,6 +1,7 @@
 {
     "extends": "../../../tsconfig.json",
     "include": [
+        "../../../extern/**/*",
         "../../../lib/**/*",
         "../keyBindings.ts",
         "./**/*"

src/generators/docs/keyBindingsFmt/main.ts

@@ -1,14 +1,9 @@
 const colLeft = [
-    ...keyBindings.map((binding: KeyBinding) => binding.defaultKeySequence),
-    ...numKeyBindings.map((binding: NumKeyBinding) => {
-        const numPrefix = binding.fKeys ? "F" : "";
-        return `${binding.defaultModifiers}+${numPrefix}[N]`;
-    }),
+    ...keyBindings.map(binding => binding.keySequence),
 ];
 
 const colRight = [
-    ...keyBindings.map((binding: KeyBinding) => `${binding.description}${formatComment(binding.comment)}`),
-    ...numKeyBindings.map((binding: NumKeyBinding) => `${binding.description}N${formatComment(binding.comment)}`),
+    ...keyBindings.map(binding => binding.description),
 ];
 
 printCols(colLeft, " ", colRight);

src/generators/docs/keyBindingsFmt/tsconfig.json

@@ -1,6 +1,7 @@
 {
     "extends": "../../../tsconfig.json",
     "include": [
+        "../../../extern/**/*",
         "../../../lib/**/*",
         "../keyBindings.ts",
         "./**/*"

src/generators/docs/keyBindingsMarkdown/main.ts

@@ -0,0 +1,13 @@
+const colLeft = [
+    "Shortcut",
+    "---",
+    ...keyBindings.map(binding => binding.keySequence),
+];
+
+const colRight = [
+    "Action",
+    "---",
+    ...keyBindings.map(binding => binding.description),
+];
+
+printCols("| ", colLeft, " | ", colRight, " |");

src/generators/docs/keyBindingsMarkdown/tsconfig.json

@@ -1,6 +1,7 @@
 {
     "extends": "../../../tsconfig.json",
     "include": [
+        "../../../extern/**/*",
         "../../../lib/**/*",
         "../keyBindings.ts",
         "./**/*"

src/generators/docs/keyBindingsTable/main.ts

@@ -1,18 +0,0 @@
-const colLeft = [
-    "Shortcut",
-    "---",
-    ...keyBindings.map((binding: KeyBinding) => binding.defaultKeySequence),
-    ...numKeyBindings.map((binding: NumKeyBinding) => {
-        const numPrefix = binding.fKeys ? "F" : "";
-        return `${binding.defaultModifiers}+${numPrefix}[N]`;
-    }),
-];
-
-const colRight = [
-    "Action",
-    "---",
-    ...keyBindings.map((binding: KeyBinding) => `${binding.description}${formatComment(binding.comment)}`),
-    ...numKeyBindings.map((binding: NumKeyBinding) => `${binding.description}N${formatComment(binding.comment)}`),
-];
-
-printCols("| ", colLeft, " | ", colRight, " |");

src/lib/Actions.ts

@@ -1,346 +0,0 @@
-namespace Actions {
-    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) {
-                        return;
-                    }
-                    prevColumn.focus();
-                });
-            };
-
-            case "focus-right": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    const nextColumn = grid.getNextColumn(column);
-                    if (nextColumn === null) {
-                        return;
-                    }
-                    nextColumn.focus();
-                });
-            };
-
-            case "focus-up": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    const prevWindow = column.getPrevWindow(window);
-                    if (prevWindow === null) {
-                        return;
-                    }
-                    prevWindow.focus();
-                });
-            };
-
-            case "focus-down": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    const nextWindow = column.getNextWindow(window);
-                    if (nextWindow === null) {
-                        return;
-                    }
-                    nextWindow.focus();
-                });
-            };
-
-            case "focus-start": return () => {
-                world.do((clientManager, desktopManager) => {
-                    const grid = desktopManager.getCurrentDesktop().grid;
-                    const firstColumn = grid.getFirstColumn();
-                    if (firstColumn === null) {
-                        return;
-                    }
-                    firstColumn.focus();
-                });
-            };
-
-            case "focus-end": return () => {
-                world.do((clientManager, desktopManager) => {
-                    const grid = desktopManager.getCurrentDesktop().grid;
-                    const lastColumn = grid.getLastColumn();
-                    if (lastColumn === null) {
-                        return;
-                    }
-                    lastColumn.focus();
-                });
-            };
-
-            case "window-move-left": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    if (column.getWindowCount() === 1) {
-                        // move from own column into existing column
-                        const prevColumn = grid.getPrevColumn(column);
-                        if (prevColumn === null) {
-                            return;
-                        }
-                        window.moveToColumn(prevColumn);
-                        grid.desktop.autoAdjustScroll();
-                    } else {
-                        // move from shared column into own column
-                        const newColumn = new Column(grid, grid.getPrevColumn(column));
-                        window.moveToColumn(newColumn);
-                    }
-                });
-            };
-
-            case "window-move-right": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    if (column.getWindowCount() === 1) {
-                        // move from own column into existing column
-                        const nextColumn = grid.getNextColumn(column);
-                        if (nextColumn === null) {
-                            return;
-                        }
-                        window.moveToColumn(nextColumn);
-                        grid.desktop.autoAdjustScroll();
-                    } else {
-                        // move from shared column into own column
-                        const newColumn = new Column(grid, column);
-                        window.moveToColumn(newColumn);
-                    }
-                });
-            };
-
-            case "window-move-up": return () => {
-                // TODO (optimization): only arrange moved windows
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    column.moveWindowUp(window);
-                });
-            };
-
-            case "window-move-down": return () => {
-                // TODO (optimization): only arrange moved windows
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    column.moveWindowDown(window);
-                });
-            };
-
-            case "window-move-start": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    const newColumn = new Column(grid, null);
-                    window.moveToColumn(newColumn);
-                });
-            };
-
-            case "window-move-end": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    const newColumn = new Column(grid, grid.getLastColumn());
-                    window.moveToColumn(newColumn);
-                });
-            };
-
-            case "window-toggle-floating": return () => {
-                const kwinClient = Workspace.activeWindow;
-                world.do((clientManager, desktopManager) => {
-                    clientManager.toggleFloatingClient(kwinClient);
-                });
-            };
-
-            case "column-move-left": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    grid.moveColumnLeft(column);
-                });
-            };
-
-            case "column-move-right": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    grid.moveColumnRight(column);
-                });
-            };
-
-            case "column-move-start": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    column.moveAfter(null);
-                });
-            };
-
-            case "column-move-end": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    column.moveAfter(grid.getLastColumn());
-                });
-            };
-
-            case "column-toggle-stacked": return () => {
-                world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
-                    column.toggleStacked();
-                });
-            };
-
-            case "column-width-increase": return () => {
-                world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
-                    config.columnResizer.increaseWidth(column, config.manualResizeStep);
-                });
-            };
-
-            case "column-width-decrease": return () => {
-                world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
-                    config.columnResizer.decreaseWidth(column, config.manualResizeStep);
-                });
-            };
-
-            case "columns-width-equalize": return () => {
-                world.do((clientManager, desktopManager) => {
-                    desktopManager.getCurrentDesktop().equalizeVisibleColumnsWidths();
-                });
-            };
-
-            case "grid-scroll-left": return () => {
-                gridScroll(world, -config.manualScrollStep);
-            };
-
-            case "grid-scroll-right": return () => {
-                gridScroll(world, config.manualScrollStep);
-            };
-
-            case "grid-scroll-start": return () => {
-                world.do((clientManager, desktopManager) => {
-                    const grid = desktopManager.getCurrentDesktop().grid;
-                    const firstColumn = grid.getFirstColumn();
-                    if (firstColumn === null) {
-                        return;
-                    }
-                    grid.desktop.scrollToColumn(firstColumn);
-                });
-            };
-
-            case "grid-scroll-end": return () => {
-                world.do((clientManager, desktopManager) => {
-                    const grid = desktopManager.getCurrentDesktop().grid;
-                    const lastColumn = grid.getLastColumn();
-                    if (lastColumn === null) {
-                        return;
-                    }
-                    grid.desktop.scrollToColumn(lastColumn);
-                });
-            };
-
-            case "grid-scroll-focused": return () => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
-                    grid.desktop.scrollCenterRange(column);
-                })
-            };
-
-            case "grid-scroll-left-column": return () => {
-                world.do((clientManager, desktopManager) => {
-                    const grid = desktopManager.getCurrentDesktop().grid;
-                    const column = grid.getLeftmostVisibleColumn(grid.desktop.getCurrentVisibleRange(), true);
-                    if (column === null) {
-                        return;
-                    }
-
-                    const prevColumn = grid.getPrevColumn(column);
-                    if (prevColumn === null) {
-                        return;
-                    }
-
-                    grid.desktop.scrollToColumn(prevColumn);
-                });
-            };
-
-            case "grid-scroll-right-column": return () => {
-                world.do((clientManager, desktopManager) => {
-                    const grid = desktopManager.getCurrentDesktop().grid;
-                    const column = grid.getRightmostVisibleColumn(grid.desktop.getCurrentVisibleRange(), true);
-                    if (column === null) {
-                        return;
-                    }
-
-                    const nextColumn = grid.getNextColumn(column);
-                    if (nextColumn === null) {
-                        return;
-                    }
-
-                    grid.desktop.scrollToColumn(nextColumn);
-                });
-            };
-
-            default: throw new Error("unknown action: " + name);
-        }
-    }
-
-    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;
-                    }
-                    targetColumn.focus();
-                });
-            };
-
-            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;
-                    }
-                    window.moveToColumn(targetColumn);
-                    grid.desktop.autoAdjustScroll();
-                });
-            };
-
-            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;
-                    }
-                    if (targetColumn.isAfter(column)) {
-                        column.moveAfter(targetColumn);
-                    } else {
-                        column.moveAfter(grid.getPrevColumn(targetColumn));
-                    }
-                });
-            };
-
-            case "column-move-to-desktop-": return (desktopIndex: number) => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, oldGrid) => {
-                    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());
-                });
-            };
-
-            case "tail-move-to-desktop-": return (desktopIndex: number) => {
-                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, oldGrid) => {
-                    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) {
-        world.do((clientManager, desktopManager) => {
-            const grid = desktopManager.getCurrentDesktop().grid;
-            grid.desktop.adjustScroll(amount, false);
-        });
-    }
-
-    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/lib/behavior/PresetWidths.ts

@@ -0,0 +1,62 @@
+class PresetWidths {
+    private readonly presets: ((maxWidth: number) => number)[];
+
+    constructor(presetWidths: string, spacing: number) {
+        this.presets = PresetWidths.parsePresetWidths(presetWidths, spacing);
+    }
+
+    public next(currentWidth: number, minWidth: number, maxWidth: number) {
+        const widths = this.getWidths(minWidth, maxWidth);
+        const nextIndex = widths.findIndex(width => width > currentWidth);
+        return nextIndex >= 0 ? widths[nextIndex] : widths[0];
+    }
+
+    public prev(currentWidth: number, minWidth: number, maxWidth: number) {
+        const widths = this.getWidths(minWidth, maxWidth).reverse();
+        const nextIndex = widths.findIndex(width => width < currentWidth);
+        return nextIndex >= 0 ? widths[nextIndex] : widths[0];
+    }
+
+    public getWidths(minWidth: number, maxWidth: number) {
+        const widths = this.presets.map(f => clamp(f(maxWidth), minWidth, maxWidth));
+        widths.sort((a, b) => a - b);
+        return uniq(widths);
+    }
+
+    private static parsePresetWidths(presetWidths: string, spacing: number): ((maxWidth: number) => number)[] {
+        function getRatioFunction(ratio: number) {
+            return (maxWidth: number) => Math.floor((maxWidth + spacing) * ratio - spacing);
+        }
+
+        return presetWidths.split(",").map((widthStr: string) => {
+            widthStr = widthStr.trim();
+
+            const widthPx = PresetWidths.parseNumberWithSuffix(widthStr, "px");
+            if (widthPx !== undefined) {
+                return () => widthPx;
+            }
+
+            const widthPct = PresetWidths.parseNumberWithSuffix(widthStr, "%");
+            if (widthPct !== undefined) {
+                return getRatioFunction(widthPct / 100.0);
+            }
+
+            return getRatioFunction(PresetWidths.parseNumberSafe(widthStr));
+        });
+    }
+
+    private static parseNumberSafe(str: string) {
+        const num = Number(str);
+        if (isNaN(num) || num <= 0) {
+            throw new Error("Invalid number: " + str);
+        }
+        return num;
+    }
+
+    private static parseNumberWithSuffix(str: string, suffix: string) {
+        if (!str.endsWith(suffix)) {
+            return undefined;
+        }
+        return PresetWidths.parseNumberSafe(str.substring(0, str.length-suffix.length).trim());
+    }
+}

src/lib/behavior/columnResizer/ContextualResizer.ts

@@ -1,45 +1,15 @@
 class ContextualResizer {
-    public increaseWidth(column: Column, step: number) {
+    constructor(
+        private readonly presetWidths: { getWidths: (minWidth: number, maxWidth: number) => number[] },
+    ) {}
+
+    public increaseWidth(column: Column) {
         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()) {
+        const minWidth = column.getMinWidth();
+        const maxWidth = column.getMaxWidth();
+        if(!Range.contains(visibleRange, column) || column.getWidth() >= maxWidth) {
             return;
         }
 
@@ -50,11 +20,48 @@ class ContextualResizer {
             return;
         }
 
-        let leftOffScreenColumn = grid.getPrevColumn(leftVisibleColumn);
+        const leftSpace = leftVisibleColumn.getLeft() - visibleRange.getLeft();
+        const rightSpace = visibleRange.getRight() - rightVisibleColumn.getRight();
+
+        const newWidth = findMinPositive(
+            [
+                column.getWidth() + leftSpace + rightSpace,
+                column.getWidth() + leftSpace + rightSpace + leftVisibleColumn.getWidth() + grid.config.gapsInnerHorizontal,
+                column.getWidth() + leftSpace + rightSpace + rightVisibleColumn.getWidth() + grid.config.gapsInnerHorizontal,
+                ...this.presetWidths.getWidths(minWidth, maxWidth),
+            ],
+            width => width - column.getWidth(),
+        );
+        if (newWidth === undefined) {
+            return;
+        }
+
+        column.setWidth(newWidth, true);
+        desktop.scrollCenterVisible(column);
+    }
+
+    public decreaseWidth(column: Column) {
+        const grid = column.grid;
+        const desktop = grid.desktop;
+        const visibleRange = desktop.getCurrentVisibleRange();
+        const minWidth = column.getMinWidth();
+        const maxWidth = column.getMaxWidth();
+        if(!Range.contains(visibleRange, column) || column.getWidth() <= minWidth) {
+            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.getLeftColumn(leftVisibleColumn);
         if (leftOffScreenColumn === column) {
             leftOffScreenColumn = null;
         }
-        let rightOffScreenColumn = grid.getNextColumn(rightVisibleColumn);
+        let rightOffScreenColumn = grid.getRightColumn(rightVisibleColumn);
         if (rightOffScreenColumn === column) {
             rightOffScreenColumn = null;
         }
@@ -64,15 +71,14 @@ class ContextualResizer {
         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(
+        const newWidth = findMinPositive(
             [
-                visibleRange.getWidth(),
-                column.getWidth() - step,
                 column.getWidth() - leftOffScreen,
                 column.getWidth() - rightOffScreen,
+                ...this.presetWidths.getWidths(minWidth, maxWidth),
             ],
             width => column.getWidth() - width,
-        )
+        );
         if (newWidth === undefined) {
             return;
         }
@@ -80,17 +86,4 @@ class ContextualResizer {
         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/lib/behavior/columnResizer/RawResizer.ts

@@ -1,9 +1,31 @@
 class RawResizer {
-    public increaseWidth(column: Column, step: number) {
-        column.adjustWidth(step, true);
+    constructor(
+        private readonly presetWidths: { getWidths: (minWidth: number, maxWidth: number) => number[] },
+    ) {}
+
+    public increaseWidth(column: Column) {
+        const newWidth = findMinPositive(
+            [
+                ...this.presetWidths.getWidths(column.getMinWidth(), column.getMaxWidth()),
+            ],
+            width => width - column.getWidth(),
+        );
+        if (newWidth === undefined) {
+            return;
+        }
+        column.setWidth(newWidth, true);
     }
 
-    public decreaseWidth(column: Column, step: number) {
-        column.adjustWidth(-step, true);
+    public decreaseWidth(column: Column) {
+        const newWidth = findMinPositive(
+            [
+                ...this.presetWidths.getWidths(column.getMinWidth(), column.getMaxWidth()),
+            ],
+            width => column.getWidth() - width,
+        );
+        if (newWidth === undefined) {
+            return;
+        }
+        column.setWidth(newWidth, true);
     }
 }

src/lib/behavior/scrollClamper/CenterClamper.ts

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

src/lib/behavior/scrollClamper/EdgeClamper.ts

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

src/lib/config/config.ts

@@ -1,22 +1,28 @@
-type Config = {
-    gapsOuterTop: number,
-    gapsOuterBottom: number,
-    gapsOuterLeft: number,
-    gapsOuterRight: number,
-    gapsInnerHorizontal: number,
-    gapsInnerVertical: number,
-    manualScrollStep: number,
-    manualResizeStep: number,
-    offScreenOpacity: number,
-    untileOnDrag: boolean,
-    stackColumnsByDefault: boolean,
-    resizeNeighborColumn: boolean,
-    reMaximize: boolean,
-    skipSwitcher: boolean,
-    scrollingLazy: boolean,
-    scrollingCentered: boolean,
-    scrollingGrouped: boolean,
-    tiledKeepBelow: boolean,
-    floatingKeepAbove: boolean,
-    windowRules: string,
-};
+interface Config {
+    gapsOuterTop: number;
+    gapsOuterBottom: number;
+    gapsOuterLeft: number;
+    gapsOuterRight: number;
+    gapsInnerHorizontal: number;
+    gapsInnerVertical: number;
+    stackOffsetX: number;
+    stackOffsetY: number;
+    manualScrollStep: number;
+    presetWidths: string;
+    offScreenOpacity: number;
+    untileOnDrag: boolean;
+    cursorFollowsFocus: boolean;
+    stackColumnsByDefault: boolean;
+    resizeNeighborColumn: boolean;
+    reMaximize: boolean;
+    skipSwitcher: boolean;
+    scrollingLazy: boolean;
+    scrollingCentered: boolean;
+    scrollingGrouped: boolean;
+    gestureScroll: boolean;
+    gestureScrollInvert: boolean;
+    gestureScrollStep: number;
+    tiledKeepBelow: boolean;
+    floatingKeepAbove: boolean;
+    windowRules: string;
+}

src/lib/config/definition.ts

@@ -1,16 +1,12 @@
 const defaultWindowRules = `[
-    {
-        "class": "ksmserver-logout-greeter",
-        "tile": false
-    },
-    {
-        "class": "xwaylandvideobridge",
-        "tile": false
-    },
     {
         "class": "(org\\\\.kde\\\\.)?plasmashell",
         "tile": false
     },
+    {
+        "class": "(org\\\\.kde\\\\.)?polkit-kde-authentication-agent-1",
+        "tile": false
+    },
     {
         "class": "(org\\\\.kde\\\\.)?kded6",
         "tile": false
@@ -35,28 +31,23 @@ const defaultWindowRules = `[
         "class": "(org\\\\.kde\\\\.)?yakuake",
         "tile": false
     },
+    {
+        "class": "steam",
+        "caption": "Steam Big Picture Mode",
+        "tile": false
+    },
     {
         "class": "zoom",
         "caption": "Zoom Cloud Meetings|zoom|zoom <2>",
         "tile": false
     },
     {
-        "class": "jetbrains-idea",
+        "class": "jetbrains-.*",
         "caption": "splash",
         "tile": false
     },
     {
-        "class": "jetbrains-studio",
-        "caption": "splash",
-        "tile": false
-    },
-    {
-        "class": "jetbrains-idea",
-        "caption": "Unstash Changes|Paths Affected by stash@.*",
-        "tile": true
-    },
-    {
-        "class": "jetbrains-studio",
+        "class": "jetbrains-.*",
         "caption": "Unstash Changes|Paths Affected by stash@.*",
         "tile": true
     }
@@ -66,32 +57,42 @@ const configDef = [
     {
         name: "gapsOuterTop",
         type: "UInt",
-        default: 18,
+        default: 16,
     },
     {
         name: "gapsOuterBottom",
         type: "UInt",
-        default: 18,
+        default: 16,
     },
     {
         name: "gapsOuterLeft",
         type: "UInt",
-        default: 18,
+        default: 16,
     },
     {
         name: "gapsOuterRight",
         type: "UInt",
-        default: 18,
+        default: 16,
     },
     {
         name: "gapsInnerHorizontal",
         type: "UInt",
-        default: 18,
+        default: 8,
     },
     {
         name: "gapsInnerVertical",
         type: "UInt",
-        default: 18,
+        default: 8,
+    },
+    {
+        name: "stackOffsetX",
+        type: "UInt",
+        default: 8,
+    },
+    {
+        name: "stackOffsetY",
+        type: "UInt",
+        default: 32,
     },
     {
         name: "manualScrollStep",
@@ -99,9 +100,9 @@ const configDef = [
         default: 200,
     },
     {
-        name: "manualResizeStep",
-        type: "UInt",
-        default: 600,
+        name: "presetWidths",
+        type: "String",
+        default: "50%, 100%",
     },
     {
         name: "offScreenOpacity",
@@ -113,6 +114,11 @@ const configDef = [
         type: "Bool",
         default: true,
     },
+    {
+        name: "cursorFollowsFocus",
+        type: "Bool",
+        default: false,
+    },
     {
         name: "stackColumnsByDefault",
         type: "Bool",
@@ -148,6 +154,21 @@ const configDef = [
         type: "Bool",
         default: false,
     },
+    {
+        name: "gestureScroll",
+        type: "Bool",
+        default: false,
+    },
+    {
+        name: "gestureScrollInvert",
+        type: "Bool",
+        default: false,
+    },
+    {
+        name: "gestureScrollStep",
+        type: "UInt",
+        default: 1920,
+    },
     {
         name: "tiledKeepBelow",
         type: "Bool",
@@ -167,5 +188,5 @@ const configDef = [
         name: "windowRules",
         type: "String",
         default: defaultWindowRules,
-    }
+    },
 ];

src/lib/config/loader.ts

@@ -1,7 +0,0 @@
-function loadConfig(): Config {
-    const config: any = {};
-    for (const entry of configDef) {
-        config[entry.name] = KWin.readConfig(entry.name, entry.default);
-    }
-    return config;
-}

src/lib/extern/dbuscall.ts

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

src/lib/extern/global.d.ts

@@ -1,6 +1 @@
 declare const console: Console;
-declare const Qt: Qt;
-declare const KWin: KWin;
-declare const Workspace: Workspace;
-declare const qmlBase: QmlObject;
-declare const notificationInvalidWindowRules: Notification;

src/lib/extern/kwin.ts

@@ -1,8 +1,12 @@
-type KWin = {
-    readConfig(key: string, defaultValue: any): any;
-};
+interface KWin {
+    __brand: "KWin";
+
+    readConfig(key: string, defaultValue: any): any;
+}
+
+interface Workspace {
+    __brand: "Workspace";
 
-type Workspace = {
     readonly activities: string[];
     readonly desktops: KwinDesktop[];
     readonly currentDesktop: KwinDesktop;
@@ -11,19 +15,20 @@ type Workspace = {
     readonly windows: KwinClient[];
     readonly cursorPos: Readonly<QmlPoint>;
 
-    activeWindow: KwinClient;
+    activeWindow: KwinClient|null;
 
-    readonly currentDesktopChanged: QSignal<[]>
+    readonly currentDesktopChanged: QSignal<[]>;
     readonly windowAdded: QSignal<[KwinClient]>;
     readonly windowRemoved: QSignal<[KwinClient]>;
-    readonly windowActivated: QSignal<[KwinClient]>;
-    readonly desktopsChanged: QSignal<[]>;
+    readonly windowActivated: QSignal<[KwinClient|null]>;
+    readonly screensChanged: QSignal<[]>;
     readonly activitiesChanged: QSignal<[]>;
+    readonly desktopsChanged: QSignal<[]>;
     readonly currentActivityChanged: QSignal<[]>;
     readonly virtualScreenSizeChanged: QSignal<[]>;
 
     clientArea(option: ClientAreaOption, output: Output, kwinDesktop: KwinDesktop): QmlRect;
-};
+}
 
 const enum ClientAreaOption {
     PlacementArea,
@@ -43,15 +48,16 @@ const enum MaximizedMode {
     Maximized,
 }
 
-type Tile = unknown;
-type Output = unknown;
+interface Tile { __brand: "Tile" }
+interface Output { __brand: "Output" }
 
 interface KwinClient {
-    readonly shadeable: boolean;
+    __brand: "KwinClient";
+
     readonly caption: string;
     readonly minSize: Readonly<QmlSize>;
     readonly transient: boolean;
-    readonly transientFor: KwinClient;
+    readonly transientFor: KwinClient | null;
     readonly clientGeometry: Readonly<QmlRect>;
     readonly move: boolean;
     readonly resize: boolean;
@@ -72,18 +78,17 @@ interface KwinClient {
     skipSwitcher: boolean;
     keepAbove: boolean;
     keepBelow: boolean;
-    shade: boolean;
     minimized: boolean;
     frameGeometry: QmlRect;
     desktops: KwinDesktop[]; // empty array means all desktops
-    tile: Tile;
+    tile: Tile|null;
     opacity: number;
 
     readonly fullScreenChanged: QSignal<[]>;
     readonly desktopsChanged: QSignal<[]>;
     readonly activitiesChanged: QSignal<[]>;
     readonly minimizedChanged: QSignal<[]>;
-    readonly maximizedAboutToChange: QSignal<[MaximizedMode]>
+    readonly maximizedAboutToChange: QSignal<[MaximizedMode]>;
     readonly captionChanged: QSignal<[]>;
     readonly tileChanged: QSignal<[]>;
     readonly interactiveMoveResizeStarted: QSignal<[]>;
@@ -94,10 +99,12 @@ interface KwinClient {
 }
 
 interface KwinDesktop {
+    __brand: "KwinDesktop";
+
     readonly id: string;
 }
 
-type ShortcutHandler = {
+interface ShortcutHandler extends QmlObject {
     readonly activated: QSignal<[]>;
     destroy(): void;
-};
+}

src/lib/extern/notification.ts

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

src/lib/extern/qt.ts

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

src/lib/keyBindings/Actions.ts

@@ -0,0 +1,433 @@
+class Actions {
+    constructor(
+        private readonly config: Actions.Config,
+    ) {}
+
+    public readonly focusLeft = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const leftColumn = grid.getLeftColumn(column);
+        if (leftColumn === null) {
+            return;
+        }
+        leftColumn.getWindowToFocus().focus();
+    };
+
+    public readonly focusRight = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const rightColumn = grid.getRightColumn(column);
+        if (rightColumn === null) {
+            return;
+        }
+        rightColumn.getWindowToFocus().focus();
+    };
+
+    public readonly focusUp = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const aboveWindow = column.getAboveWindow(window);
+        if (aboveWindow === null) {
+            return;
+        }
+        aboveWindow.focus();
+    };
+
+    public readonly focusDown = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const belowWindow = column.getBelowWindow(window);
+        if (belowWindow === null) {
+            return;
+        }
+        belowWindow.focus();
+    };
+
+    public readonly focusNext = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const belowWindow = column.getBelowWindow(window);
+        if (belowWindow !== null) {
+            belowWindow.focus();
+        } else {
+            const rightColumn = grid.getRightColumn(column);
+            if (rightColumn === null) {
+                return;
+            }
+            rightColumn.getFirstWindow().focus();
+        }
+    };
+
+    public readonly focusPrevious = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const aboveWindow = column.getAboveWindow(window);
+        if (aboveWindow !== null) {
+            aboveWindow.focus();
+        } else {
+            const leftColumn = grid.getLeftColumn(column);
+            if (leftColumn === null) {
+                return;
+            }
+            leftColumn.getLastWindow().focus();
+        }
+    };
+
+    public readonly focusStart = (cm: ClientManager, dm: DesktopManager) => {
+        const grid = dm.getCurrentDesktop().grid;
+        const firstColumn = grid.getFirstColumn();
+        if (firstColumn === null) {
+            return;
+        }
+        firstColumn.getWindowToFocus().focus();
+    };
+
+    public readonly focusEnd = (cm: ClientManager, dm: DesktopManager) => {
+        const grid = dm.getCurrentDesktop().grid;
+        const lastColumn = grid.getLastColumn();
+        if (lastColumn === null) {
+            return;
+        }
+        lastColumn.getWindowToFocus().focus();
+    };
+
+    public readonly windowMoveLeft = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        if (column.getWindowCount() === 1) {
+            // move from own column into existing column
+            const leftColumn = grid.getLeftColumn(column);
+            if (leftColumn === null) {
+                return;
+            }
+            window.moveToColumn(leftColumn, true, FocusPassing.Type.None);
+            grid.desktop.autoAdjustScroll();
+        } else {
+            // move from shared column into own column
+            const newColumn = new Column(grid, grid.getLeftColumn(column));
+            window.moveToColumn(newColumn, true, FocusPassing.Type.None);
+        }
+    };
+
+    public readonly windowMoveRight = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid, bottom = true) => {
+        if (column.getWindowCount() === 1) {
+            // move from own column into existing column
+            const rightColumn = grid.getRightColumn(column);
+            if (rightColumn === null) {
+                return;
+            }
+            window.moveToColumn(rightColumn, bottom, FocusPassing.Type.None);
+            grid.desktop.autoAdjustScroll();
+        } else {
+            // move from shared column into own column
+            const newColumn = new Column(grid, column);
+            window.moveToColumn(newColumn, true, FocusPassing.Type.None);
+        }
+    };
+
+    // TODO (optimization): only arrange moved windows
+    public readonly windowMoveUp = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        column.moveWindowUp(window);
+    };
+
+    // TODO (optimization): only arrange moved windows
+    public readonly windowMoveDown = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        column.moveWindowDown(window);
+    };
+
+    public readonly windowMoveNext = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const canMoveDown = window !== column.getLastWindow();
+        if (canMoveDown) {
+            column.moveWindowDown(window);
+        } else {
+            this.windowMoveRight(cm, dm, window, column, grid, false);
+        }
+    };
+
+    public readonly windowMovePrevious = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const canMoveUp = window !== column.getFirstWindow();
+        if (canMoveUp) {
+            column.moveWindowUp(window);
+        } else {
+            this.windowMoveLeft(cm, dm, window, column, grid);
+        }
+    };
+
+    public readonly windowMoveStart = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const newColumn = new Column(grid, null);
+        window.moveToColumn(newColumn, true, FocusPassing.Type.None);
+    };
+
+    public readonly windowMoveEnd = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const newColumn = new Column(grid, grid.getLastColumn());
+        window.moveToColumn(newColumn, true, FocusPassing.Type.None);
+    };
+
+    public readonly windowToggleFloating = (cm: ClientManager, dm: DesktopManager) => {
+        if (Workspace.activeWindow === null) {
+            return;
+        }
+        cm.toggleFloatingClient(Workspace.activeWindow);
+    };
+
+    public readonly columnMoveLeft = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        grid.moveColumnLeft(column);
+    };
+
+    public readonly columnMoveRight = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        grid.moveColumnRight(column);
+    };
+
+    public readonly columnMoveStart = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        grid.moveColumn(column, null);
+    };
+
+    public readonly columnMoveEnd = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        grid.moveColumn(column, grid.getLastColumn());
+    };
+
+    public readonly columnToggleStacked = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        column.toggleStacked();
+    };
+
+    public readonly columnWidthIncrease = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        this.config.columnResizer.increaseWidth(column);
+    };
+
+    public readonly columnWidthDecrease = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        this.config.columnResizer.decreaseWidth(column);
+    };
+
+    public readonly cyclePresetWidths = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const nextWidth = this.config.presetWidths.next(column.getWidth(), column.getMinWidth(), column.getMaxWidth());
+        column.setWidth(nextWidth, true);
+    };
+
+    public readonly cyclePresetWidthsReverse = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const nextWidth = this.config.presetWidths.prev(column.getWidth(), column.getMinWidth(), column.getMaxWidth());
+        column.setWidth(nextWidth, true);
+    };
+
+    public readonly columnsWidthEqualize = (cm: ClientManager, dm: DesktopManager) => {
+        const desktop = dm.getCurrentDesktop();
+        const visibleRange = desktop.getCurrentVisibleRange();
+        const visibleColumns = Array.from(desktop.grid.getVisibleColumns(visibleRange, true));
+
+        const availableSpace = desktop.tilingArea.width;
+        const gapsWidth = desktop.grid.config.gapsInnerHorizontal * (visibleColumns.length-1);
+        const widths = fillSpace(
+            availableSpace - gapsWidth,
+            visibleColumns.map(column => ({ min: column.getMinWidth(), max: column.getMaxWidth() })),
+        );
+        visibleColumns.forEach((column, index) => column.setWidth(widths[index], true));
+
+        desktop.scrollCenterRange(Range.fromRanges(
+            visibleColumns[0],
+            visibleColumns[visibleColumns.length - 1],
+        ));
+    };
+
+    public readonly columnsSqueezeLeft = (cm: ClientManager, dm: DesktopManager, window: Window, focusedColumn: Column, grid: Grid) => {
+        const visibleRange = grid.desktop.getCurrentVisibleRange();
+        if (!Range.contains(visibleRange, focusedColumn)) {
+            return;
+        }
+
+        const currentVisibleColumns = Array.from(grid.getVisibleColumns(visibleRange, true));
+        console.assert(currentVisibleColumns.includes(focusedColumn), "should at least contain the focused column");
+
+        const targetColumn = grid.getLeftColumn(currentVisibleColumns[0]);
+        if (targetColumn === null) {
+            return;
+        }
+
+        const wantedVisibleColumns = [targetColumn, ...currentVisibleColumns];
+        while (true) {
+            const success = this.squeezeColumns(wantedVisibleColumns);
+            if (success) {
+                break;
+            }
+            const removedColumn = wantedVisibleColumns.pop();
+            if (removedColumn === focusedColumn) {
+                break; // don't scroll past the currently focused column
+            }
+        }
+    };
+
+    public readonly columnsSqueezeRight = (cm: ClientManager, dm: DesktopManager, window: Window, focusedColumn: Column, grid: Grid) => {
+        const visibleRange = grid.desktop.getCurrentVisibleRange();
+        if (!Range.contains(visibleRange, focusedColumn)) {
+            return;
+        }
+
+        const currentVisibleColumns = Array.from(grid.getVisibleColumns(visibleRange, true));
+        console.assert(currentVisibleColumns.includes(focusedColumn), "should at least contain the focused column");
+
+        const targetColumn = grid.getRightColumn(currentVisibleColumns[currentVisibleColumns.length-1]);
+        if (targetColumn === null) {
+            return;
+        }
+
+        const wantedVisibleColumns = [...currentVisibleColumns, targetColumn];
+        while (true) {
+            const success = this.squeezeColumns(wantedVisibleColumns);
+            if (success) {
+                break;
+            }
+            const removedColumn = wantedVisibleColumns.shift();
+            if (removedColumn === focusedColumn) {
+                break; // don't scroll past the currently focused column
+            }
+        }
+    };
+
+    private readonly squeezeColumns = (columns: Column[]) => {
+        const firstColumn = columns[0];
+        const lastColumn = columns[columns.length-1];
+        const grid = firstColumn.grid;
+        const desktop = grid.desktop;
+
+        const availableSpace = desktop.tilingArea.width;
+        const gapsWidth = grid.config.gapsInnerHorizontal * (columns.length-1);
+        const columnConstraints = columns.map(column => ({ min: column.getMinWidth(), max: column.getWidth() }));
+        const minTotalWidth = gapsWidth + columnConstraints.reduce((acc, constraint) => acc + constraint.min, 0);
+        if (minTotalWidth > availableSpace) {
+            // there's nothing we can do
+            return false;
+        }
+
+        const widths = fillSpace(availableSpace - gapsWidth, columnConstraints);
+        columns.forEach((column, index) => column.setWidth(widths[index], true));
+        desktop.scrollCenterRange(Range.fromRanges(firstColumn, lastColumn));
+        return true;
+    };
+
+    public readonly gridScrollLeft = (cm: ClientManager, dm: DesktopManager) => {
+        this.gridScroll(dm, -this.config.manualScrollStep);
+    };
+
+    public readonly gridScrollRight = (cm: ClientManager, dm: DesktopManager) => {
+        this.gridScroll(dm, this.config.manualScrollStep);
+    };
+
+    private readonly gridScroll = (desktopManager: DesktopManager, amount: number) => {
+        desktopManager.getCurrentDesktop().adjustScroll(amount, false);
+    };
+
+    public readonly gridScrollStart = (cm: ClientManager, dm: DesktopManager) => {
+        const grid = dm.getCurrentDesktop().grid;
+        const firstColumn = grid.getFirstColumn();
+        if (firstColumn === null) {
+            return;
+        }
+        grid.desktop.scrollToColumn(firstColumn, false);
+    };
+
+    public readonly gridScrollEnd = (cm: ClientManager, dm: DesktopManager) => {
+        const grid = dm.getCurrentDesktop().grid;
+        const lastColumn = grid.getLastColumn();
+        if (lastColumn === null) {
+            return;
+        }
+        grid.desktop.scrollToColumn(lastColumn, false);
+    };
+
+    public readonly gridScrollFocused = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const scrollAmount = Range.minus(column, grid.desktop.getCurrentVisibleRange());
+        if (scrollAmount !== 0) {
+            grid.desktop.adjustScroll(scrollAmount, true);
+        } else {
+            grid.desktop.scrollToColumn(column, true);
+        }
+    };
+
+    public readonly gridScrollLeftColumn = (cm: ClientManager, dm: DesktopManager) => {
+        const grid = dm.getCurrentDesktop().grid;
+        const column = grid.getLeftmostVisibleColumn(grid.desktop.getCurrentVisibleRange(), true);
+        if (column === null) {
+            return;
+        }
+
+        const leftColumn = grid.getLeftColumn(column);
+        if (leftColumn === null) {
+            return;
+        }
+
+        grid.desktop.scrollToColumn(leftColumn, false);
+    };
+
+    public readonly gridScrollRightColumn = (cm: ClientManager, dm: DesktopManager) => {
+        const grid = dm.getCurrentDesktop().grid;
+        const column = grid.getRightmostVisibleColumn(grid.desktop.getCurrentVisibleRange(), true);
+        if (column === null) {
+            return;
+        }
+
+        const rightColumn = grid.getRightColumn(column);
+        if (rightColumn === null) {
+            return;
+        }
+
+        grid.desktop.scrollToColumn(rightColumn, false);
+    };
+
+    public readonly screenSwitch = (cm: ClientManager, dm: DesktopManager) => {
+        dm.selectScreen(Workspace.activeScreen);
+    };
+
+    public readonly focus = (columnIndex: number, cm: ClientManager, dm: DesktopManager) => {
+        const grid = dm.getCurrentDesktop().grid;
+        const targetColumn = grid.getColumnAtIndex(columnIndex);
+        if (targetColumn === null) {
+            return;
+        }
+        targetColumn.getWindowToFocus().focus();
+    };
+
+    public readonly windowMoveToColumn = (columnIndex: number, cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const targetColumn = grid.getColumnAtIndex(columnIndex);
+        if (targetColumn === null) {
+            return;
+        }
+        window.moveToColumn(targetColumn, true, FocusPassing.Type.None);
+        grid.desktop.autoAdjustScroll();
+    };
+
+    public readonly columnMoveToColumn = (columnIndex: number, cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
+        const targetColumn = grid.getColumnAtIndex(columnIndex);
+        if (targetColumn === null || targetColumn === column) {
+            return;
+        }
+        if (targetColumn.isToTheRightOf(column)) {
+            grid.moveColumn(column, targetColumn);
+        } else {
+            grid.moveColumn(column, grid.getLeftColumn(targetColumn));
+        }
+    };
+
+    public readonly columnMoveToDesktop = (desktopIndex: number, cm: ClientManager, dm: DesktopManager, window: Window, column: Column, oldGrid: Grid) => {
+        const kwinDesktop = Workspace.desktops[desktopIndex];
+        if (kwinDesktop === undefined) {
+            return;
+        }
+        const newGrid = dm.getDesktopInCurrentActivity(kwinDesktop).grid;
+        if (newGrid === null || newGrid === oldGrid) {
+            return;
+        }
+        column.moveToGrid(newGrid, newGrid.getLastColumn());
+    };
+
+    public readonly tailMoveToDesktop = (desktopIndex: number, cm: ClientManager, dm: DesktopManager, window: Window, column: Column, oldGrid: Grid) => {
+        const kwinDesktop = Workspace.desktops[desktopIndex];
+        if (kwinDesktop === undefined) {
+            return;
+        }
+        const newGrid = dm.getDesktopInCurrentActivity(kwinDesktop).grid;
+        if (newGrid === null || newGrid === oldGrid) {
+            return;
+        }
+        oldGrid.evacuateTail(newGrid, column);
+    };
+}
+
+namespace Actions {
+    export interface Config {
+        manualScrollStep: number;
+        presetWidths: {
+            next: (currentWidth: number, minWidth: number, maxWidth: number) => number;
+            prev: (currentWidth: number, minWidth: number, maxWidth: number) => number
+};
+        columnResizer: ColumnResizer;
+    }
+
+    export interface ColumnResizer {
+        increaseWidth(column: Column): void;
+        decreaseWidth(column: Column): void;
+    }
+}

src/lib/keyBindings/definition.ts

@@ -1,185 +1,273 @@
-const keyBindings: KeyBinding[] = [
-    {
-        name: "window-toggle-floating",
-        description: "Toggle floating",
-        defaultKeySequence: "Meta+Space",
-    },
-    {
-        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",
-    },
-    {
-        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",
-    },
-    {
-        name: "focus-start",
-        description: "Move focus to start",
-        defaultKeySequence: "Meta+Home",
-    },
-    {
-        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",
-    },
-    {
-        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",
-    },
-    {
-        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",
-    },
-    {
-        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",
-    },
-    {
-        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",
-    },
-    {
-        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",
-    },
-    {
-        name: "column-width-increase",
-        description: "Increase column width",
-        defaultKeySequence: "Meta+Ctrl++",
-    },
-    {
-        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",
-    },
-    {
-        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",
-    },
-    {
-        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",
-    },
-    {
-        name: "grid-scroll-right",
-        description: "Scroll right",
-        defaultKeySequence: "Meta+Alt+PgDown",
-    },
-    {
-        name: "grid-scroll-start",
-        description: "Scroll to start",
-        defaultKeySequence: "Meta+Alt+Home",
-    },
-    {
-        name: "grid-scroll-end",
-        description: "Scroll to end",
-        defaultKeySequence: "Meta+Alt+End",
-    },
-];
+function getKeyBindings(world: World, actions: Actions): KeyBinding[] {
+    return [
+        {
+            name: "window-toggle-floating",
+            description: "Toggle floating",
+            defaultKeySequence: "Meta+Space",
+            action: () => world.do(actions.windowToggleFloating),
+        },
+        {
+            name: "focus-left",
+            description: "Move focus left",
+            defaultKeySequence: "Meta+A",
+            action: () => world.doIfTiledFocused(actions.focusLeft),
+        },
+        {
+            name: "focus-right",
+            description: "Move focus right",
+            comment: "Clashes with default KDE shortcuts, may require manual remapping",
+            defaultKeySequence: "Meta+D",
+            action: () => world.doIfTiledFocused(actions.focusRight),
+        },
+        {
+            name: "focus-up",
+            description: "Move focus up",
+            comment: "Clashes with default KDE shortcuts, may require manual remapping",
+            defaultKeySequence: "Meta+W",
+            action: () => world.doIfTiledFocused(actions.focusUp),
+        },
+        {
+            name: "focus-down",
+            description: "Move focus down",
+            comment: "Clashes with default KDE shortcuts, may require manual remapping",
+            defaultKeySequence: "Meta+S",
+            action: () => world.doIfTiledFocused(actions.focusDown),
+        },
+        {
+            name: "focus-next",
+            description: "Move focus to the next window in grid",
+            action: () => world.doIfTiledFocused(actions.focusNext),
+        },
+        {
+            name: "focus-previous",
+            description: "Move focus to the previous window in grid",
+            action: () => world.doIfTiledFocused(actions.focusPrevious),
+        },
+        {
+            name: "focus-start",
+            description: "Move focus to start",
+            defaultKeySequence: "Meta+Home",
+            action: () => world.do(actions.focusStart),
+        },
+        {
+            name: "focus-end",
+            description: "Move focus to end",
+            defaultKeySequence: "Meta+End",
+            action: () => world.do(actions.focusEnd),
+        },
+        {
+            name: "window-move-left",
+            description: "Move window left",
+            comment: "Moves window out of and into columns",
+            defaultKeySequence: "Meta+Shift+A",
+            action: () => world.doIfTiledFocused(actions.windowMoveLeft),
+        },
+        {
+            name: "window-move-right",
+            description: "Move window right",
+            comment: "Moves window out of and into columns",
+            defaultKeySequence: "Meta+Shift+D",
+            action: () => world.doIfTiledFocused(actions.windowMoveRight),
+        },
+        {
+            name: "window-move-up",
+            description: "Move window up",
+            defaultKeySequence: "Meta+Shift+W",
+            action: () => world.doIfTiledFocused(actions.windowMoveUp),
+        },
+        {
+            name: "window-move-down",
+            description: "Move window down",
+            defaultKeySequence: "Meta+Shift+S",
+            action: () => world.doIfTiledFocused(actions.windowMoveDown),
+        },
+        {
+            name: "window-move-next",
+            description: "Move window to the next position in grid",
+            action: () => world.doIfTiledFocused(actions.windowMoveNext),
+        },
+        {
+            name: "window-move-previous",
+            description: "Move window to the previous position in grid",
+            action: () => world.doIfTiledFocused(actions.windowMovePrevious),
+        },
+        {
+            name: "window-move-start",
+            description: "Move window to start",
+            defaultKeySequence: "Meta+Shift+Home",
+            action: () => world.doIfTiledFocused(actions.windowMoveStart),
+        },
+        {
+            name: "window-move-end",
+            description: "Move window to end",
+            defaultKeySequence: "Meta+Shift+End",
+            action: () => world.doIfTiledFocused(actions.windowMoveEnd),
+        },
+        {
+            name: "column-toggle-stacked",
+            description: "Toggle stacked layout for focused column",
+            comment: "Only the active window visible",
+            defaultKeySequence: "Meta+X",
+            action: () => world.doIfTiledFocused(actions.columnToggleStacked),
+        },
+        {
+            name: "column-move-left",
+            description: "Move column left",
+            defaultKeySequence: "Meta+Ctrl+Shift+A",
+            action: () => world.doIfTiledFocused(actions.columnMoveLeft),
+        },
+        {
+            name: "column-move-right",
+            description: "Move column right",
+            defaultKeySequence: "Meta+Ctrl+Shift+D",
+            action: () => world.doIfTiledFocused(actions.columnMoveRight),
+        },
+        {
+            name: "column-move-start",
+            description: "Move column to start",
+            defaultKeySequence: "Meta+Ctrl+Shift+Home",
+            action: () => world.doIfTiledFocused(actions.columnMoveStart),
+        },
+        {
+            name: "column-move-end",
+            description: "Move column to end",
+            defaultKeySequence: "Meta+Ctrl+Shift+End",
+            action: () => world.doIfTiledFocused(actions.columnMoveEnd),
+        },
+        {
+            name: "column-width-increase",
+            description: "Increase column width",
+            defaultKeySequence: "Meta+Ctrl++",
+            action: () => world.doIfTiledFocused(actions.columnWidthIncrease),
+        },
+        {
+            name: "column-width-decrease",
+            description: "Decrease column width",
+            defaultKeySequence: "Meta+Ctrl+-",
+            action: () => world.doIfTiledFocused(actions.columnWidthDecrease),
+        },
+        {
+            name: "cycle-preset-widths",
+            description: "Cycle through preset column widths",
+            defaultKeySequence: "Meta+R",
+            action: () => world.doIfTiledFocused(actions.cyclePresetWidths),
+        },
+        {
+            name: "cycle-preset-widths-reverse",
+            description: "Cycle through preset column widths in reverse",
+            defaultKeySequence: "Meta+Shift+R",
+            action: () => world.doIfTiledFocused(actions.cyclePresetWidthsReverse),
+        },
+        {
+            name: "columns-width-equalize",
+            description: "Equalize widths of visible columns",
+            defaultKeySequence: "Meta+Ctrl+X",
+            action: () => world.do(actions.columnsWidthEqualize),
+        },
+        {
+            name: "columns-squeeze-left",
+            description: "Squeeze left column onto the screen",
+            comment: "Clashes with default KDE shortcuts, may require manual remapping",
+            defaultKeySequence: "Meta+Ctrl+A",
+            action: () => world.doIfTiledFocused(actions.columnsSqueezeLeft),
+        },
+        {
+            name: "columns-squeeze-right",
+            description: "Squeeze right column onto the screen",
+            defaultKeySequence: "Meta+Ctrl+D",
+            action: () => world.doIfTiledFocused(actions.columnsSqueezeRight),
+        },
+        {
+            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: () => world.doIfTiledFocused(actions.gridScrollFocused),
+        },
+        {
+            name: "grid-scroll-left-column",
+            description: "Scroll one column to the left",
+            defaultKeySequence: "Meta+Alt+A",
+            action: () => world.do(actions.gridScrollLeftColumn),
+        },
+        {
+            name: "grid-scroll-right-column",
+            description: "Scroll one column to the right",
+            defaultKeySequence: "Meta+Alt+D",
+            action: () => world.do(actions.gridScrollRightColumn),
+        },
+        {
+            name: "grid-scroll-left",
+            description: "Scroll left",
+            defaultKeySequence: "Meta+Alt+PgUp",
+            action: () => world.do(actions.gridScrollLeft),
+        },
+        {
+            name: "grid-scroll-right",
+            description: "Scroll right",
+            defaultKeySequence: "Meta+Alt+PgDown",
+            action: () => world.do(actions.gridScrollRight),
+        },
+        {
+            name: "grid-scroll-start",
+            description: "Scroll to start",
+            defaultKeySequence: "Meta+Alt+Home",
+            action: () => world.do(actions.gridScrollStart),
+        },
+        {
+            name: "grid-scroll-end",
+            description: "Scroll to end",
+            defaultKeySequence: "Meta+Alt+End",
+            action: () => world.do(actions.gridScrollEnd),
+        },
+        {
+            name: "screen-switch",
+            description: "Move Karousel grid to the current screen",
+            defaultKeySequence: "Meta+Ctrl+Return",
+            action: () => world.do(actions.screenSwitch),
+        },
+    ];
+}
 
-const numKeyBindings: NumKeyBinding[] = [
-    {
-        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,
-    },
-    {
-        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,
-    },
-    {
-        name: "tail-move-to-desktop-",
-        description: "Move this and all following columns to desktop ",
-        defaultModifiers: "Meta+Ctrl+Shift+Alt",
-        fKeys: true,
-    },
-];
+function getNumKeyBindings(world: World, actions: Actions): NumKeyBinding[] {
+    return [
+        {
+            name: "focus-{}",
+            description: "Move focus to column {}",
+            comment: "Clashes with default KDE shortcuts, may require manual remapping",
+            defaultModifiers: "Meta",
+            fKeys: false,
+            action: (i: number) => world.do(actions.focus.partial(i)),
+        },
+        {
+            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: (i: number) => world.doIfTiledFocused(actions.windowMoveToColumn.partial(i)),
+        },
+        {
+            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: (i: number) => world.doIfTiledFocused(actions.columnMoveToColumn.partial(i)),
+        },
+        {
+            name: "column-move-to-desktop-{}",
+            description: "Move column to desktop {}",
+            defaultModifiers: "Meta+Ctrl+Shift",
+            fKeys: true,
+            action: (i: number) => world.doIfTiledFocused(actions.columnMoveToDesktop.partial(i)),
+        },
+        {
+            name: "tail-move-to-desktop-{}",
+            description: "Move this and all following columns to desktop {}",
+            defaultModifiers: "Meta+Ctrl+Shift+Alt",
+            fKeys: true,
+            action: (i: number) => world.doIfTiledFocused(actions.tailMoveToDesktop.partial(i)),
+        },
+    ];
+}

src/lib/keyBindings/loader.ts

@@ -1,17 +1,19 @@
-type KeyBinding = {
+interface KeyBinding {
     name: string;
     description: string;
     comment?: string;
-    defaultKeySequence: string;
-};
+    defaultKeySequence?: string;
+    action: () => void;
+}
 
-type NumKeyBinding = {
+interface NumKeyBinding {
     name: string;
     description: string;
     comment?: string;
     defaultModifiers: string;
     fKeys: boolean;
-};
+    action: (i: number) => void;
+}
 
 function catchWrap(f: () => void) {
     return () => {
@@ -24,14 +26,14 @@ function catchWrap(f: () => void) {
     };
 }
 
-function registerKeyBinding(world: World, config: Actions.Config, shortcutActions: ShortcutAction[], keyBinding: KeyBinding) {
+function registerKeyBinding(shortcutActions: ShortcutAction[], keyBinding: KeyBinding) {
     shortcutActions.push(new ShortcutAction(
         keyBinding,
-        catchWrap(Actions.getAction(world, config, keyBinding.name)),
+        catchWrap(keyBinding.action),
     ));
 }
 
-function registerNumKeyBindings(world: World, shortcutActions: ShortcutAction[], numKeyBinding: NumKeyBinding) {
+function registerNumKeyBindings(shortcutActions: ShortcutAction[], numKeyBinding: NumKeyBinding) {
     const numPrefix = numKeyBinding.fKeys ? "F" : "";
     const n = numKeyBinding.fKeys ? 12 : 9;
     for (let i = 0; i < 12; i++) {
@@ -39,28 +41,27 @@ function registerNumKeyBindings(world: World, shortcutActions: ShortcutAction[],
         const keySequence = i < n ?
             numKeyBinding.defaultModifiers + "+" + numPrefix + numKey :
             "";
-        const action = Actions.getNumAction(world, numKeyBinding.name);
         shortcutActions.push(new ShortcutAction(
             {
-                name: numKeyBinding.name + numKey,
-                description: numKeyBinding.description + numKey,
+                name: applyMacro(numKeyBinding.name, numKey),
+                description: applyMacro(numKeyBinding.description, numKey),
                 defaultKeySequence: keySequence,
             },
-            catchWrap(() => action(i)),
+            catchWrap(() => numKeyBinding.action(i)),
         ));
     }
 }
 
-// TODO: refactor
 function registerKeyBindings(world: World, config: Actions.Config) {
+    const actions = new Actions(config);
     const shortcutActions: ShortcutAction[] = [];
 
-    for (const keyBinding of keyBindings) {
-        registerKeyBinding(world, config, shortcutActions, keyBinding);
+    for (const keyBinding of getKeyBindings(world, actions)) {
+        registerKeyBinding(shortcutActions, keyBinding);
     }
 
-    for (const numKeyBinding of numKeyBindings) {
-        registerNumKeyBindings(world, shortcutActions, numKeyBinding);
+    for (const numKeyBinding of getNumKeyBindings(world, actions)) {
+        registerNumKeyBindings(shortcutActions, numKeyBinding);
     }
 
     return shortcutActions;

src/lib/layout/Column.ts

@@ -5,46 +5,39 @@ class Column {
     private readonly windows: LinkedList<Window>;
     private stacked: boolean;
     private focusTaker: Window|null;
-    private static readonly minWidth = 10;
+    private static readonly minWidth = 40;
 
-    constructor(grid: Grid, prevColumn: Column|null) {
+    constructor(grid: Grid, leftColumn: Column|null) {
         this.gridX = 0;
         this.width = 0;
         this.windows = new LinkedList();
         this.stacked = grid.config.stackColumnsByDefault;
         this.focusTaker = null;
         this.grid = grid;
-        this.grid.onColumnAdded(this, prevColumn);
+        this.grid.onColumnAdded(this, leftColumn);
     }
 
-    public moveToGrid(targetGrid: Grid, prevColumn: Column|null) {
+    public moveToGrid(targetGrid: Grid, leftColumn: Column|null) {
         if (targetGrid === this.grid) {
-            this.grid.onColumnMoved(this, prevColumn);
+            this.grid.moveColumn(this, leftColumn);
         } else {
-            this.grid.onColumnRemoved(this, false);
+            this.grid.onColumnRemoved(this, this.isFocused() ? FocusPassing.Type.Immediate : FocusPassing.Type.None);
             this.grid = targetGrid;
-            targetGrid.onColumnAdded(this, prevColumn);
+            targetGrid.onColumnAdded(this, leftColumn);
             for (const window of this.windows.iterator()) {
                 window.client.kwinClient.desktops = [targetGrid.desktop.kwinDesktop];
             }
         }
     }
 
-    public moveAfter(prevColumn: Column|null) {
-        if (prevColumn === this) {
-            return;
-        }
-        this.grid.onColumnMoved(this, prevColumn);
-    }
-
-    public isAfter(other: Column) {
-        return this.gridX > other.gridX;
-    }
-
-    public isBefore(other: Column) {
+    public isToTheLeftOf(other: Column) {
         return this.gridX < other.gridX;
     }
 
+    public isToTheRightOf(other: Column) {
+        return this.gridX > other.gridX;
+    }
+
     public moveWindowUp(window: Window) {
         this.windows.moveBack(window);
         this.grid.desktop.onLayoutChanged();
@@ -63,11 +56,19 @@ class Column {
         return this.getWindowCount() === 0;
     }
 
-    public getPrevWindow(window: Window) {
+    public getFirstWindow(): Window {
+        return this.windows.getFirst()!;
+    }
+
+    public getLastWindow(): Window {
+        return this.windows.getLast()!;
+    }
+
+    public getAboveWindow(window: Window) {
         return this.windows.getPrev(window);
     }
 
-    public getNextWindow(window: Window) {
+    public getBelowWindow(window: Window) {
         return this.windows.getNext(window);
     }
 
@@ -132,6 +133,27 @@ class Column {
         return this.gridX + this.width;
     }
 
+    public onUserResizeWidth(
+        startWidth: number,
+        currentDelta: number,
+        resizingLeftSide: boolean,
+        neighbor?: { column: Column, startWidth: number },
+    ) {
+        const oldColumnWidth = this.getWidth();
+        this.setWidth(startWidth + currentDelta, true);
+        const actualDelta = this.getWidth() - startWidth;
+
+        let leftEdgeDeltaStep = resizingLeftSide ? oldColumnWidth - this.getWidth() : 0;
+        if (neighbor !== undefined) {
+            const oldNeighborWidth = neighbor.column.getWidth();
+            neighbor.column.setWidth(neighbor.startWidth - actualDelta, true);
+            if (resizingLeftSide) {
+                leftEdgeDeltaStep -= neighbor.column.getWidth() - oldNeighborWidth;
+            }
+        }
+        this.grid.desktop.adjustScroll(-leftEdgeDeltaStep, true);
+    }
+
     public adjustWindowHeight(window: Window, heightDelta: number, top: boolean) {
         const otherWindow = top ? this.windows.getPrev(window) : this.windows.getNext(window);
         if (otherWindow === null) {
@@ -173,58 +195,48 @@ class Column {
         return this.focusTaker;
     }
 
-    public focus() {
-        const window = this.getFocusTaker() ?? this.windows.getFirst();
-        if (window === null) {
-            return;
+    public getWindowToFocus() {
+        return this.getFocusTaker() ?? this.windows.getFirst()!;
+    }
+
+    public isFocused() {
+        const lastFocusedWindow = this.grid.getLastFocusedWindow();
+        if (lastFocusedWindow === null) {
+            return false;
         }
-        window.focus();
+        return lastFocusedWindow.column === this && lastFocusedWindow.isFocused();
     }
 
     public arrange(x: number, visibleRange: Range, forceOpaque: boolean) {
         if (this.grid.config.offScreenOpacity < 1.0 && !forceOpaque) {
-            const opacity = this.isVisible(visibleRange, true) ? 100 : this.grid.config.offScreenOpacity;
+            const opacity = Range.contains(visibleRange, this) ? 100 : this.grid.config.offScreenOpacity;
             for (const window of this.windows.iterator()) {
                 window.client.kwinClient.opacity = opacity;
             }
         }
 
-        if (this.stacked && this.windows.length() >= 2 && this.canStack()) {
+        if (this.stacked && this.windows.length() >= 2) {
             this.arrangeStacked(x);
             return;
         }
         let y = this.grid.desktop.tilingArea.y;
         for (const window of this.windows.iterator()) {
-            window.client.setShade(false);
             window.arrange(x, y, this.width, window.height);
             y += window.height + this.grid.config.gapsInnerVertical;
         }
     }
 
     public arrangeStacked(x: number) {
-        const expandedWindow = this.getFocusTaker();
-        let collapsedHeight;
-        for (const window of this.windows.iterator()) {
-            if (window === expandedWindow) {
-                window.client.setShade(false);
-            } else {
-                window.client.setShade(true);
-                collapsedHeight = window.client.kwinClient.frameGeometry.height;
-            }
-        }
+        const nWindows = this.windows.length();
+        const windowWidth = this.width - (nWindows - 1) * this.grid.config.stackOffsetX;
+        const windowHeight = this.grid.desktop.tilingArea.height - (nWindows - 1) * this.grid.config.stackOffsetY;
 
-        const nCollapsed = this.getWindowCount() - 1;
-        const expandedHeight = this.grid.desktop.tilingArea.height - nCollapsed * (collapsedHeight! + this.grid.config.gapsInnerVertical);
-        let y = this.grid.desktop.tilingArea.y;
+        let windowX = x;
+        let windowY = this.grid.desktop.tilingArea.y;
         for (const window of this.windows.iterator()) {
-            if (window === expandedWindow) {
-                window.arrange(x, y, this.width, expandedHeight);
-                y += expandedHeight;
-            } else {
-                window.arrange(x, y, this.width, window.height);
-                y += collapsedHeight!;
-            }
-            y += this.grid.config.gapsInnerVertical;
+            window.arrange(windowX, windowY, windowWidth, windowHeight);
+            windowX += this.grid.config.stackOffsetX;
+            windowY += this.grid.config.stackOffsetY;
         }
     }
 
@@ -236,27 +248,13 @@ class Column {
         this.grid.desktop.onLayoutChanged();
     }
 
-    private canStack() {
-        for (const window of this.windows.iterator()) {
-            if (!window.client.kwinClient.shadeable) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    public isVisible(visibleRange: Desktop.Range, fullyVisible: boolean) {
-        if (fullyVisible) {
-            return this.getLeft() >= visibleRange.getLeft() &&
-                this.getRight() <= visibleRange.getRight();
+    public onWindowAdded(window: Window, bottom: boolean) {
+        if (bottom) {
+            this.windows.insertEnd(window);
         } else {
-            return this.getRight() + this.grid.config.gapsInnerHorizontal > visibleRange.getLeft() &&
-                this.getLeft() - this.grid.config.gapsInnerHorizontal < visibleRange.getRight();
+            this.windows.insertStart(window);
         }
-    }
 
-    public onWindowAdded(window: Window) {
-        this.windows.insertEnd(window);
         if (this.width === 0) {
             this.setWidth(window.client.preferredWidth, false);
         }
@@ -271,9 +269,9 @@ class Column {
         this.grid.desktop.onLayoutChanged();
     }
 
-    public onWindowRemoved(window: Window, passFocus: boolean) {
+    public onWindowRemoved(window: Window, passFocus: FocusPassing.Type) {
         const lastWindow = this.windows.length() === 1;
-        const windowToFocus = this.getPrevWindow(window) ?? this.getNextWindow(window);
+        const windowToFocus = this.getAboveWindow(window) ?? this.getBelowWindow(window);
 
         this.windows.remove(window);
 
@@ -286,8 +284,15 @@ class Column {
             this.destroy(passFocus);
         } else {
             this.resizeWindows();
-            if (passFocus && windowToFocus !== null) {
-                windowToFocus.focus();
+            if (windowToFocus !== null) {
+                switch (passFocus) {
+                case FocusPassing.Type.Immediate:
+                    windowToFocus.focus();
+                    break;
+                case FocusPassing.Type.OnUnfocus:
+                    this.grid.focusPasser.request(windowToFocus.client.kwinClient);
+                    break;
+                }
             }
         }
 
@@ -295,18 +300,18 @@ class Column {
     }
 
     public onWindowFocused(window: Window) {
-        this.grid.onColumnFocused(this);
+        this.grid.onColumnFocused(this, window);
         this.focusTaker = window;
     }
 
-    public restoreToTiled() {
+    public restoreToTiled(focusedWindow: Window) {
         const lastFocusedWindow = this.getFocusTaker();
-        if (lastFocusedWindow !== null) {
+        if (lastFocusedWindow !== null && lastFocusedWindow !== focusedWindow) {
             lastFocusedWindow.restoreToTiled();
         }
     }
 
-    private destroy(passFocus: boolean) {
+    private destroy(passFocus: FocusPassing.Type) {
         this.grid.onColumnRemoved(this, passFocus);
     }
 }

src/lib/layout/Desktop.ts

@@ -1,31 +1,34 @@
 class Desktop {
     public readonly grid: Grid;
-    public readonly kwinDesktop: KwinDesktop;
-    private readonly pinManager: PinManager;
-    private readonly config: Desktop.Config;
     private scrollX: number;
+    private gestureScrollXInitial: number | null;
     private dirty: boolean;
     private dirtyScroll: boolean;
     private dirtyPins: boolean;
     public clientArea: QmlRect;
     public tilingArea: QmlRect;
 
-    constructor(kwinDesktop: KwinDesktop, pinManager: PinManager, config: Desktop.Config, layoutConfig: LayoutConfig) {
-        this.pinManager = pinManager;
-        this.config = config;
+    constructor(
+        public readonly kwinDesktop: KwinDesktop,
+        private readonly pinManager: PinManager,
+        private readonly config: Desktop.Config,
+        private readonly getScreen: () => Output,
+        layoutConfig: LayoutConfig,
+        focusPasser: FocusPassing.Passer,
+    ) {
         this.scrollX = 0;
+        this.gestureScrollXInitial = null;
         this.dirty = true;
         this.dirtyScroll = true;
         this.dirtyPins = true;
-        this.kwinDesktop = kwinDesktop;
-        this.grid = new Grid(this, layoutConfig);
-        this.clientArea = Desktop.getClientArea(kwinDesktop);
+        this.grid = new Grid(this, layoutConfig, focusPasser);
+        this.clientArea = Desktop.getClientArea(this.getScreen(), kwinDesktop);
         this.tilingArea = Desktop.getTilingArea(this.clientArea, kwinDesktop, pinManager, config);
     }
 
     private updateArea() {
-        const newClientArea = Desktop.getClientArea(this.kwinDesktop);
-        if (newClientArea === this.clientArea && !this.dirtyPins) {
+        const newClientArea = Desktop.getClientArea(this.getScreen(), this.kwinDesktop);
+        if (rectEquals(newClientArea, this.clientArea) && !this.dirtyPins) {
             return;
         }
         this.clientArea = newClientArea;
@@ -37,8 +40,8 @@ class Desktop {
         this.autoAdjustScroll();
     }
 
-    private static getClientArea(kwinDesktop: KwinDesktop) {
-        return Workspace.clientArea(ClientAreaOption.PlacementArea, Workspace.activeScreen, kwinDesktop);
+    private static getClientArea(screen: Output, kwinDesktop: KwinDesktop) {
+        return Workspace.clientArea(ClientAreaOption.PlacementArea, screen, kwinDesktop);
     }
 
     private static getTilingArea(clientArea: QmlRect, kwinDesktop: KwinDesktop, pinManager: PinManager, config: Desktop.Config) {
@@ -52,10 +55,10 @@ class Desktop {
             top,
             right - left,
             bottom - top,
-        )
+        );
     }
 
-    public scrollIntoView(range: Desktop.Range) {
+    public scrollIntoView(range: Range) {
         const left = range.getLeft();
         const right = range.getRight();
         const initialVisibleRange = this.getCurrentVisibleRange();
@@ -72,10 +75,9 @@ class Desktop {
         this.setScroll(targetScrollX, false);
     }
 
-    public scrollCenterRange(range: Desktop.Range) {
-        const windowCenter = range.getLeft() + range.getWidth() / 2;
-        const screenCenter = this.scrollX + this.tilingArea.width / 2;
-        this.adjustScroll(Math.round(windowCenter - screenCenter), false);
+    public scrollCenterRange(range: Range) {
+        const scrollAmount = Range.minus(range, this.getCurrentVisibleRange());
+        this.adjustScroll(scrollAmount, true);
     }
 
     public scrollCenterVisible(focusedColumn: Column) {
@@ -91,17 +93,17 @@ class Desktop {
             return;
         }
 
-        this.scrollToColumn(focusedColumn);
+        this.scrollToColumn(focusedColumn, false);
     }
 
-    public scrollToColumn(column: Column) {
-        if (this.dirtyScroll || !column.isVisible(this.getCurrentVisibleRange(), true)) {
+    public scrollToColumn(column: Column, force: boolean) {
+        if (force || this.dirtyScroll || !Range.contains(this.getCurrentVisibleRange(), column)) {
             this.config.scroller.scrollToColumn(this, column);
         }
     }
 
     private getVisibleRange(scrollX: number) {
-        return new Desktop.RangeImpl(scrollX, this.tilingArea.width);
+        return Range.create(scrollX, this.tilingArea.width);
     }
 
     public getCurrentVisibleRange() {
@@ -125,38 +127,22 @@ class Desktop {
         this.setScroll(this.scrollX + dx, force);
     }
 
-    public equalizeVisibleColumnsWidths() {
-        const visibleRange = this.getCurrentVisibleRange();
-        const visibleColumns = Array.from(this.grid.getVisibleColumns(visibleRange, true));
-
-        let remainingWidth = this.tilingArea.width - (visibleColumns.length-1) * this.grid.config.gapsInnerHorizontal;
-        let remainingColumns = visibleColumns.length;
-
-        const minWidths = visibleColumns.map(column => column.getMinWidth()).sort((a, b) => b - a);
-        for (const minWidth of minWidths) {
-            if (minWidth > remainingWidth / remainingColumns) {
-                remainingWidth -= minWidth;
-                remainingColumns--;
-            }
+    public gestureScroll(amount: number) {
+        if (!this.config.gestureScroll) {
+            return;
+        }
+        if (this.gestureScrollXInitial === null) {
+            this.gestureScrollXInitial = this.scrollX;
         }
 
-        const avgWidth = remainingWidth / remainingColumns;
-        for (const column of visibleColumns) {
-            const minWidth = column.getMinWidth();
-            if (minWidth > avgWidth) {
-                column.setWidth(minWidth, true);
-            } else {
-                const columnWidth = Math.round(remainingWidth / remainingColumns);
-                column.setWidth(columnWidth, true);
-                remainingWidth -= column.getWidth();
-                remainingColumns--;
-            }
+        if (this.config.gestureScrollInvert) {
+            amount = -amount;
         }
+        this.setScroll(this.gestureScrollXInitial + this.config.gestureScrollStep * amount, false);
+    }
 
-        this.scrollCenterRange(Desktop.RangeImpl.fromRanges(
-            visibleColumns[0],
-            visibleColumns[visibleColumns.length - 1],
-        ));
+    public gestureScrollFinish() {
+        this.gestureScrollXInitial = null;
     }
 
     public arrange() {
@@ -169,6 +155,10 @@ class Desktop {
         this.dirty = false;
     }
 
+    public forceArrange() {
+        this.dirty = true;
+    }
+
     public onLayoutChanged() {
         this.dirty = true;
         this.dirtyScroll = true;
@@ -186,47 +176,16 @@ class Desktop {
 }
 
 namespace Desktop {
-    export type Config = {
-        marginTop: number,
-        marginBottom: number,
-        marginLeft: number,
-        marginRight: number,
-        scroller: Desktop.Scroller,
-        clamper: Desktop.Clamper,
-    };
-
-    export type Range = {
-        getLeft(): number;
-        getRight(): number;
-        getWidth(): number;
-    }
-
-    export class RangeImpl {
-        private readonly x: number;
-        private readonly width: number;
-
-        constructor(x: number, width: number) {
-            this.x = x;
-            this.width = width;
-        }
-
-        public getLeft() {
-            return this.x;
-        }
-
-        public getRight() {
-            return this.x + this.width;
-        }
-
-        public getWidth() {
-            return this.width;
-        }
-
-        public static fromRanges(leftRange: Range, rightRange: Range) {
-            const left = leftRange.getLeft();
-            const right = rightRange.getRight();
-            return new RangeImpl(left, right - left);
-        }
+    export interface Config {
+        marginTop: number;
+        marginBottom: number;
+        marginLeft: number;
+        marginRight: number;
+        gestureScroll: boolean;
+        gestureScrollInvert: boolean;
+        gestureScrollStep: number;
+        scroller: Desktop.Scroller;
+        clamper: Desktop.Clamper;
     }
 
     export class ColumnRange {
@@ -240,7 +199,7 @@ namespace Desktop {
             this.width = initialColumn.getWidth();
         }
 
-        public addNeighbors(visibleRange: Desktop.Range, gap: number) {
+        public addNeighbors(visibleRange: Range, gap: number) {
             const grid = this.left.grid;
 
             const columnRange = this;
@@ -251,8 +210,8 @@ namespace Desktop {
                 return column !== null && canFit(column);
             }
 
-            let leftColumn = grid.getPrevColumn(this.left);
-            let rightColumn = grid.getNextColumn(this.right);
+            let leftColumn = grid.getLeftColumn(this.left);
+            let rightColumn = grid.getRightColumn(this.right);
             function checkColumns() {
                 if (!isUsable(leftColumn)) {
                     leftColumn = null;
@@ -269,10 +228,10 @@ namespace Desktop {
                 const rightToCenter = rightColumn === null ? Infinity : Math.abs(rightColumn.getRight() - visibleCenter);
                 if (leftToCenter < rightToCenter) {
                     this.addLeft(leftColumn!, gap);
-                    leftColumn = grid.getPrevColumn(leftColumn!);
+                    leftColumn = grid.getLeftColumn(leftColumn!);
                 } else {
                     this.addRight(rightColumn!, gap);
-                    rightColumn = grid.getNextColumn(rightColumn!);
+                    rightColumn = grid.getRightColumn(rightColumn!);
                 }
                 checkColumns();
             }
@@ -301,11 +260,11 @@ namespace Desktop {
         }
     }
 
-    export type Scroller = {
+    export interface Scroller {
         scrollToColumn(desktop: Desktop, column: Column): void;
     }
 
-    export type Clamper = {
+    export interface Clamper {
         clampScrollX(desktop: Desktop, x: number): number;
     }
 }

src/lib/layout/Grid.ts

@@ -1,17 +1,17 @@
-import Range = Desktop.Range;
-
 class Grid {
     public readonly desktop: Desktop;
     public readonly config: LayoutConfig;
+    public readonly focusPasser: FocusPassing.Passer;
     private readonly columns: LinkedList<Column>;
     private lastFocusedColumn: Column|null;
     private width: number;
     private userResize: boolean; // is any part of the grid being resized by the user
     private readonly userResizeFinishedDelayer: Delayer;
 
-    constructor(desktop: Desktop, config: LayoutConfig) {
+    constructor(desktop: Desktop, config: LayoutConfig, focusPasser: FocusPassing.Passer) {
         this.desktop = desktop;
         this.config = config;
+        this.focusPasser = focusPasser;
         this.columns = new LinkedList();
         this.lastFocusedColumn = null;
         this.width = 0;
@@ -24,6 +24,18 @@ class Grid {
         });
     }
 
+    public moveColumn(column: Column, leftColumn: Column|null) {
+        if (column === leftColumn) {
+            return;
+        }
+        const movedLeft = leftColumn === null ? true : column.isToTheRightOf(leftColumn);
+        const firstMovedColumn = movedLeft ? column : this.getRightColumn(column);
+        this.columns.move(column, leftColumn);
+        this.columnsSetX(firstMovedColumn);
+        this.desktop.onLayoutChanged();
+        this.desktop.autoAdjustScroll();
+    }
+
     public moveColumnLeft(column: Column) {
         this.columns.moveBack(column);
         this.columnsSetX(column);
@@ -32,11 +44,11 @@ class Grid {
     }
 
     public moveColumnRight(column: Column) {
-        const nextColumn = this.columns.getNext(column);
-        if (nextColumn === null) {
+        const rightColumn = this.columns.getNext(column);
+        if (rightColumn === null) {
             return;
         }
-        this.moveColumnLeft(nextColumn);
+        this.moveColumnLeft(rightColumn);
     }
 
     public getWidth() {
@@ -47,11 +59,11 @@ class Grid {
         return this.userResize;
     }
 
-    public getPrevColumn(column: Column) {
+    public getLeftColumn(column: Column) {
         return this.columns.getPrev(column);
     }
 
-    public getNextColumn(column: Column) {
+    public getRightColumn(column: Column) {
         return this.columns.getNext(column);
     }
 
@@ -94,19 +106,19 @@ class Grid {
         this.width = x - this.config.gapsInnerHorizontal;
     }
 
-    public getLeftmostVisibleColumn(visibleRange: Desktop.Range, fullyVisible: boolean) {
+    public getLeftmostVisibleColumn(visibleRange: Range, fullyVisible: boolean) {
         for (const column of this.columns.iterator()) {
-            if (column.isVisible(visibleRange, fullyVisible)) {
+            if (Range.contains(visibleRange, column)) {
                 return column;
             }
         }
         return null;
     }
 
-    public getRightmostVisibleColumn(visibleRange: Desktop.Range, fullyVisible: boolean) {
+    public getRightmostVisibleColumn(visibleRange: Range, fullyVisible: boolean) {
         let last = null;
         for (const column of this.columns.iterator()) {
-            if (column.isVisible(visibleRange, fullyVisible)) {
+            if (Range.contains(visibleRange, column)) {
                 last = column;
             } else if (last !== null) {
                 break;
@@ -115,29 +127,14 @@ class Grid {
         return last;
     }
 
-    public *getVisibleColumns(visibleRange: Desktop.Range, fullyVisible: boolean) {
+    public *getVisibleColumns(visibleRange: Range, fullyVisible: boolean) {
         for (const column of this.columns.iterator()) {
-            if (column.isVisible(visibleRange, fullyVisible)) {
+            if (Range.contains(visibleRange, column)) {
                 yield column;
             }
         }
     }
 
-    public getVisibleColumnsWidth(visibleRange: Desktop.Range, fullyVisible: boolean) {
-        let width = 0;
-        let nVisible = 0;
-        for (const column of this.getVisibleColumns(visibleRange, fullyVisible)) {
-            width += column.getWidth();
-            nVisible++;
-        }
-
-        if (nVisible > 0) {
-            width += (nVisible-1) * this.config.gapsInnerHorizontal;
-        }
-
-        return width;
-    }
-
     public arrange(x: number, visibleRange: Range) {
         for (const column of this.columns.iterator()) {
             column.arrange(x, visibleRange, this.userResize);
@@ -150,61 +147,58 @@ class Grid {
         }
     }
 
-    public onColumnAdded(column: Column, prevColumn: Column|null) {
-        if (prevColumn === null) {
+    public onColumnAdded(column: Column, leftColumn: Column|null) {
+        if (leftColumn === null) {
             this.columns.insertStart(column);
         } else {
-            this.columns.insertAfter(column, prevColumn);
+            this.columns.insertAfter(column, leftColumn);
         }
         this.columnsSetX(column);
         this.desktop.onLayoutChanged();
         this.desktop.autoAdjustScroll();
     }
 
-    public onColumnRemoved(column: Column, passFocus: boolean) {
+    public onColumnRemoved(column: Column, passFocus: FocusPassing.Type) {
         const isLastColumn = this.columns.length() === 1;
-        const nextColumn = this.getNextColumn(column);
-        const columnToFocus = isLastColumn ? null : this.getPrevColumn(column) ?? nextColumn;
+        const rightColumn = this.getRightColumn(column);
+        const columnToFocus = isLastColumn ? null : this.getLeftColumn(column) ?? rightColumn;
         if (column === this.lastFocusedColumn) {
             this.lastFocusedColumn = columnToFocus;
         }
 
         this.columns.remove(column);
-        this.columnsSetX(nextColumn);
+        this.columnsSetX(rightColumn);
 
         this.desktop.onLayoutChanged();
-        if (passFocus && columnToFocus !== null) {
-            columnToFocus.focus();
-        } else {
-            this.desktop.autoAdjustScroll();
+        if (columnToFocus !== null) {
+            switch (passFocus) {
+            case FocusPassing.Type.Immediate:
+                columnToFocus.getWindowToFocus().focus();
+                return;
+            case FocusPassing.Type.OnUnfocus:
+                this.focusPasser.request(columnToFocus.getWindowToFocus().client.kwinClient);
+                return;
+            }
         }
-    }
-
-    public onColumnMoved(column: Column, prevColumn: Column|null) {
-        const movedLeft = prevColumn === null ? true : column.isAfter(prevColumn);
-        const firstMovedColumn = movedLeft ? column : this.getNextColumn(column);
-        this.columns.move(column, prevColumn);
-        this.columnsSetX(firstMovedColumn);
-        this.desktop.onLayoutChanged();
         this.desktop.autoAdjustScroll();
     }
 
     public onColumnWidthChanged(column: Column) {
-        const nextColumn = this.columns.getNext(column);
-        this.columnsSetX(nextColumn);
+        const rightColumn = this.columns.getNext(column);
+        this.columnsSetX(rightColumn);
         this.desktop.onLayoutChanged();
         if (!this.userResize) {
             this.desktop.autoAdjustScroll();
         }
     }
 
-    public onColumnFocused(column: Column) {
+    public onColumnFocused(column: Column, window: Window) {
         const lastFocusedColumn = this.getLastFocusedColumn();
         if (lastFocusedColumn !== null) {
-            lastFocusedColumn.restoreToTiled();
+            lastFocusedColumn.restoreToTiled(window);
         }
         this.lastFocusedColumn = column;
-        this.desktop.scrollToColumn(column);
+        this.desktop.scrollToColumn(column, false);
     }
 
     public onScreenSizeChanged() {

src/lib/layout/LayoutConfig.ts

@@ -1,11 +1,14 @@
-type LayoutConfig = {
-    gapsInnerHorizontal: number,
-    gapsInnerVertical: number,
-    offScreenOpacity: number,
-    stackColumnsByDefault: boolean,
-    resizeNeighborColumn: boolean,
-    reMaximize: boolean,
-    skipSwitcher: boolean,
-    tiledKeepBelow: boolean,
-    maximizedKeepAbove: boolean,
-};
+interface LayoutConfig {
+    gapsInnerHorizontal: number;
+    gapsInnerVertical: number;
+    stackOffsetX: number;
+    stackOffsetY: number;
+    offScreenOpacity: number;
+    stackColumnsByDefault: boolean;
+    resizeNeighborColumn: boolean;
+    reMaximize: boolean;
+    skipSwitcher: boolean;
+    tiledKeepBelow: boolean;
+    maximizedKeepAbove: boolean;
+    untileOnDrag: boolean;
+}

src/lib/layout/Range.ts

@@ -0,0 +1,47 @@
+interface Range {
+    getLeft(): number;
+    getRight(): number;
+    getWidth(): number;
+}
+
+namespace Range {
+    export function create(x: number, width: number) {
+        return new Basic(x, width);
+    }
+
+    export function fromRanges(leftRange: Range, rightRange: Range) {
+        const left = leftRange.getLeft();
+        const right = rightRange.getRight();
+        return new Basic(left, right - left);
+    }
+
+    export function contains(parent: Range, child: Range) {
+        return child.getLeft() >= parent.getLeft() &&
+            child.getRight() <= parent.getRight();
+    }
+
+    export function minus(a: Range, b: Range) {
+        const aCenter = a.getLeft() + a.getWidth() / 2;
+        const bCenter = b.getLeft() + b.getWidth() / 2;
+        return Math.round(aCenter - bCenter);
+    }
+
+    class Basic {
+        constructor(
+            private readonly x: number,
+            private readonly width: number,
+        ) {}
+
+        public getLeft() {
+            return this.x;
+        }
+
+        public getRight() {
+            return this.x + this.width;
+        }
+
+        public getWidth() {
+            return this.width;
+        }
+    }
+}

src/lib/layout/Window.ts

@@ -8,22 +8,28 @@ class Window {
     constructor(client: ClientWrapper, column: Column) {
         this.client = client;
         this.height = client.kwinClient.frameGeometry.height;
+
+        let maximizedMode = this.client.getMaximizedMode();
+        if (maximizedMode === undefined) {
+            maximizedMode = MaximizedMode.Unmaximized; // defaulting to unmaximized, as this is set in Tiled.prepareClientForTiling
+        }
         this.focusedState = {
-            fullScreen: false,
-            maximizedMode: MaximizedMode.Unmaximized,
+            fullScreen: this.client.kwinClient.fullScreen,
+            maximizedMode: maximizedMode,
         };
-        this.skipArrange = false;
+
+        this.skipArrange = this.client.kwinClient.fullScreen || maximizedMode !== MaximizedMode.Unmaximized;
         this.column = column;
-        column.onWindowAdded(this);
+        column.onWindowAdded(this, true);
     }
 
-    public moveToColumn(targetColumn: Column) {
+    public moveToColumn(targetColumn: Column, bottom: boolean, passFocus: FocusPassing.Type) {
         if (targetColumn === this.column) {
             return;
         }
-        this.column.onWindowRemoved(this, false);
+        this.column.onWindowRemoved(this, passFocus);
         this.column = targetColumn;
-        targetColumn.onWindowAdded(this);
+        targetColumn.onWindowAdded(this, bottom);
     }
 
     public arrange(x: number, y: number, width: number, height: number) {
@@ -54,11 +60,12 @@ class Window {
     }
 
     public focus() {
-        if (this.client.isShaded()) {
-            // workaround for KWin deactivating clients when unshading immediately after activation
-            this.client.setShade(false);
-        }
         this.client.focus();
+        const kwinClient = this.client.kwinClient;
+        if (!this.isFocused()) {
+            // in some situations focus assignment just doesn't work, let's do it later
+            this.column.grid.focusPasser.request(kwinClient);
+        }
     }
 
     public isFocused() {
@@ -66,6 +73,14 @@ class Window {
     }
 
     public onFocused() {
+        if (this.column.grid.config.reMaximize && (
+            this.focusedState.maximizedMode !== MaximizedMode.Unmaximized ||
+            this.focusedState.fullScreen
+        )) {
+            // We need to maximize/fullscreen this window, but we can't do it here.
+            // We need to do it in `arrange` to ensure it happens after placement.
+            this.column.grid.desktop.forceArrange();
+        }
         this.column.onWindowFocused(this);
     }
 
@@ -75,7 +90,6 @@ class Window {
         }
         this.client.setFullScreen(false);
         this.client.setMaximize(false, false);
-        this.column.grid.desktop.onLayoutChanged();
     }
 
     public onMaximizedChanged(maximizedMode: MaximizedMode) {
@@ -107,45 +121,20 @@ class Window {
         this.column.grid.desktop.onLayoutChanged();
     }
 
-    public onUserResize(oldGeometry: QmlRect, resizeNeighborColumn: boolean) {
-        const newGeometry = this.client.kwinClient.frameGeometry;
-        const widthDelta = newGeometry.width - oldGeometry.width;
-        const heightDelta = newGeometry.height - oldGeometry.height;
-        if (widthDelta !== 0) {
-            this.column.adjustWidth(widthDelta, true);
-            let leftEdgeDelta = newGeometry.left - oldGeometry.left;
-            const resizingLeftSide = leftEdgeDelta !== 0;
-            if (resizeNeighborColumn && this.column.grid.config.resizeNeighborColumn) {
-                const neighborColumn = resizingLeftSide ? this.column.grid.getPrevColumn(this.column) : this.column.grid.getNextColumn(this.column);
-                if (neighborColumn !== null) {
-                    const oldNeighborWidth = neighborColumn.getWidth();
-                    neighborColumn.adjustWidth(-widthDelta, true);
-                    if (resizingLeftSide) {
-                        leftEdgeDelta -= neighborColumn.getWidth() - oldNeighborWidth;
-                    }
-                }
-            }
-            this.column.grid.desktop.adjustScroll(-leftEdgeDelta, true);
-        }
-        if (heightDelta !== 0) {
-            this.column.adjustWindowHeight(this, heightDelta, newGeometry.y !== oldGeometry.y);
-        }
-    }
-
     public onFrameGeometryChanged() {
         const newGeometry = this.client.kwinClient.frameGeometry;
         this.column.setWidth(newGeometry.width, true);
         this.column.grid.desktop.onLayoutChanged();
     }
 
-    public destroy(passFocus: boolean) {
+    public destroy(passFocus: FocusPassing.Type) {
         this.column.onWindowRemoved(this, passFocus);
     }
 }
 
 namespace Window {
-    export type State = {
-        fullScreen: boolean,
-        maximizedMode: MaximizedMode,
+    export interface State {
+        fullScreen: boolean;
+        maximizedMode: MaximizedMode;
     }
 }

src/lib/rules/WindowRule.ts

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

src/lib/rules/WindowRuleEnforcer.ts

@@ -11,14 +11,14 @@ class WindowRuleEnforcer {
     }
 
     public shouldTile(kwinClient: KwinClient) {
-        return Clients.canTileNow(kwinClient) && (
-            this.preferTiling.matches(kwinClient) || (
-                kwinClient.normalWindow &&
-                !kwinClient.transient &&
-                kwinClient.managed &&
-                kwinClient.pid > -1 &&
-                !this.preferFloating.matches(kwinClient)
-            )
+        return this.preferTiling.matches(kwinClient) || (
+            kwinClient.normalWindow &&
+            !kwinClient.transient &&
+            kwinClient.managed &&
+            kwinClient.pid > -1 &&
+            !kwinClient.fullScreen &&
+            !Clients.isFullScreenGeometry(kwinClient) &&
+            !this.preferFloating.matches(kwinClient)
         );
     }
 
@@ -30,7 +30,7 @@ class WindowRuleEnforcer {
         const enforcer = this;
         const manager = new SignalManager();
         manager.connect(kwinClient.captionChanged, () => {
-            const shouldTile = enforcer.shouldTile(kwinClient);
+            const shouldTile = Clients.canTileNow(kwinClient) && enforcer.shouldTile(kwinClient);
             world.do((clientManager, desktopManager) => {
                 const desktop = desktopManager.getDesktopForClient(kwinClient);
                 if (shouldTile && desktop !== undefined) {
@@ -52,7 +52,7 @@ class WindowRuleEnforcer {
             const ruleCaption = WindowRuleEnforcer.parseRegex(windowRule.caption);
             const ruleString = ClientMatcher.getRuleString(
                 WindowRuleEnforcer.wrapParens(ruleClass),
-                WindowRuleEnforcer.wrapParens(ruleCaption)
+                WindowRuleEnforcer.wrapParens(ruleCaption),
             );
 
             (windowRule.tile ? tileRegexes : floatRegexes).push(ruleString);

src/lib/utils/Delayer.ts

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

src/lib/utils/RateLimiter.ts

@@ -0,0 +1,24 @@
+class RateLimiter {
+    private i = 0;
+    private intervalStart = 0;
+
+    constructor(
+        private readonly n: number,
+        private readonly intervalMs: number,
+    ) {}
+
+    public acquire() {
+        const now = Date.now();
+        if (now - this.intervalStart >= this.intervalMs) {
+            this.i = 0;
+            this.intervalStart = now;
+        }
+
+        if (this.i < this.n) {
+            this.i++;
+            return true;
+        } else {
+            return false;
+        }
+    }
+}

src/lib/utils/ShortcutAction.ts

@@ -1,7 +1,7 @@
 class ShortcutAction {
     private readonly shortcutHandler: ShortcutHandler;
 
-    constructor(keyBinding: KeyBinding, f: () => void) {
+    constructor(keyBinding: ShortcutAction.KeyBinding, f: () => void) {
         this.shortcutHandler = ShortcutAction.initShortcutHandler(keyBinding);
         this.shortcutHandler.activated.connect(f);
     }
@@ -10,16 +10,28 @@ class ShortcutAction {
         this.shortcutHandler.destroy();
     }
 
-    private static initShortcutHandler(keyBinding: KeyBinding) {
-        return <ShortcutHandler>Qt.createQmlObject(
+    private static initShortcutHandler(keyBinding: ShortcutAction.KeyBinding) {
+        const sequenceLine = keyBinding.defaultKeySequence !== undefined ?
+            `    sequence: "${keyBinding.defaultKeySequence}";
+` :
+            "";
+
+        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}";
-}`,
+${sequenceLine}}`,
             qmlBase,
-        );
+        ) as ShortcutHandler;
+    }
+}
+
+namespace ShortcutAction {
+    export interface KeyBinding {
+        name: string;
+        description: string;
+        defaultKeySequence?: string;
     }
 }

src/lib/utils/collections.ts

@@ -0,0 +1,39 @@
+function union<T>(array0: T[], array1: T[]) {
+    const set = new Set([...array0, ...array1]);
+    return [...set];
+}
+
+function uniq(sortedArray: any[]) {
+    const filtered = [];
+    let lastItem;
+    for (const item of sortedArray) {
+        if (item !== lastItem) {
+            filtered.push(item);
+            lastItem = item;
+        }
+    }
+    return filtered;
+}
+
+function mapGetOrInit<K, V>(map: Map<K, V>, key: K, defaultItem: V) {
+    const item = map.get(key);
+    if (item !== undefined) {
+        return item;
+    } else {
+        map.set(key, defaultItem);
+        return defaultItem;
+    }
+}
+
+function findMinPositive<T>(items: T[], evaluate: (item: T) => number) {
+    let bestScore = Infinity;
+    let bestItem = undefined;
+    for (const item of items) {
+        const score = evaluate(item);
+        if (score > 0 && score < bestScore) {
+            bestScore = score;
+            bestItem = item;
+        }
+    }
+    return bestItem;
+}

src/lib/utils/fillSpace.ts

@@ -0,0 +1,98 @@
+function fillSpace(availableSpace: number, items: { min: number, max: number }[]) {
+    if (items.length === 0) {
+        return [];
+    }
+
+    const middleSize = findMiddleSize(availableSpace, items);
+    const sizes = items.map(item => clamp(middleSize, item.min, item.max));
+    if (middleSize !== Math.floor(availableSpace / items.length)) {
+        distributeRemainder(availableSpace, middleSize, sizes, items);
+    }
+    return sizes;
+
+    function findMiddleSize(availableSpace: number, items: { min: number, max: number }[]) {
+        const ranges = buildRanges(items);
+        let requiredSpace = items.reduce((acc, item) => acc + item.min, 0);
+        for (const range of ranges) {
+            const rangeSize = range.end - range.start;
+            const maxRequiredSpaceDelta = rangeSize * range.n;
+            if (requiredSpace + maxRequiredSpaceDelta >= availableSpace) {
+                const positionInRange = (availableSpace - requiredSpace) / maxRequiredSpaceDelta;
+                return Math.floor(range.start + rangeSize * positionInRange);
+            }
+            requiredSpace += maxRequiredSpaceDelta;
+        }
+        return ranges[ranges.length-1].end;
+    }
+
+    function buildRanges(items: { min: number, max: number }[]) {
+        const fenceposts = extractFenceposts(items);
+        if (fenceposts.length === 1) {
+            return [{
+                start: fenceposts[0].value,
+                end: fenceposts[0].value,
+                n: items.length,
+            }];
+        }
+
+        const ranges: Range[] = [];
+        let n = 0;
+        for (let i = 1; i < fenceposts.length; i++) {
+            const startFencepost = fenceposts[i-1];
+            const endFencepost = fenceposts[i];
+            n = n - startFencepost.nMax + startFencepost.nMin;
+            ranges.push({
+                start: startFencepost.value,
+                end: endFencepost.value,
+                n: n,
+            });
+        }
+        return ranges;
+    }
+
+    function extractFenceposts(items: { min: number, max: number }[]) {
+        const fenceposts = new Map<number, Fencepost>();
+        for (const item of items) {
+            mapGetOrInit(fenceposts, item.min, { value: item.min, nMin: 0, nMax: 0 }).nMin++;
+            mapGetOrInit(fenceposts, item.max, { value: item.max, nMin: 0, nMax: 0 }).nMax++;
+        }
+
+        const array = Array.from(fenceposts.values());
+        array.sort((a, b) => a.value - b.value);
+        return array;
+    }
+
+    function distributeRemainder(availableSpace: number, middleSize: number, sizes: number[], constraints: { max: number }[]) {
+        const indexes = Array.from(sizes.keys())
+            .filter(i => sizes[i] === middleSize);
+        indexes.sort((a, b) => constraints[a].max - constraints[b].max);
+
+        const requiredSpace = sum(...sizes);
+        let remainder = availableSpace - requiredSpace;
+        let n = indexes.length;
+        for (const i of indexes) {
+            if (remainder <= 0) {
+                break;
+            }
+            const enlargable = constraints[i].max - sizes[i];
+            if (enlargable > 0) {
+                const enlarge = Math.min(enlargable, Math.ceil(remainder / n));
+                sizes[i] += enlarge;
+                remainder -= enlarge;
+            }
+            n--;
+        }
+    }
+
+    interface Range {
+        start: number,
+        end: number,
+        n: number,
+    }
+
+    interface Fencepost {
+        value: number,
+        nMin: number,
+        nMax: number,
+    }
+}

src/lib/utils/functions.ts

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

src/lib/utils/math.ts

@@ -8,7 +8,25 @@ function clamp(value: number, min: number, max: number) {
     return value;
 }
 
-function union<T>(array0: T[], array1: T[]) {
-    const set = new Set([...array0, ...array1]);
-    return [...set];
+function sum(...list: number[]) {
+    return list.reduce((acc, val) => acc + val);
+}
+
+function rectEquals(a: QmlRect, b: QmlRect) {
+    return a.x === b.x &&
+        a.y === b.y &&
+        a.width === b.width &&
+        a.height === b.height;
+}
+
+function pointEquals(a: QmlPoint, b: QmlPoint) {
+    return a.x === b.x &&
+        a.y === b.y;
+}
+
+function rectContainsPoint(rect: QmlRect, point: QmlPoint) {
+    return rect.left <= point.x &&
+        rect.right >= point.x &&
+        rect.top <= point.y &&
+        rect.bottom >= point.y;
 }

src/lib/utils/strings.ts

@@ -0,0 +1,3 @@
+function applyMacro(base: string, value: string) {
+    return base.replace("{}", String(value));
+}

src/lib/workspace.ts

@@ -1,29 +1,27 @@
-function initWorkspaceSignalHandlers(world: World) {
+function initWorkspaceSignalHandlers(world: World, focusPasser: FocusPassing.Passer) {
     const manager = new SignalManager();
 
     manager.connect(Workspace.windowAdded, (kwinClient: KwinClient) => {
-        if (Clients.canTileEver(kwinClient)) {
-            // never open new tileable clients on all desktops or activities
-            Clients.makeTileable(kwinClient);
-        }
         world.do((clientManager, desktopManager) => {
-            clientManager.addClient(kwinClient)
+            clientManager.addClient(kwinClient);
         });
     });
 
     manager.connect(Workspace.windowRemoved, (kwinClient: KwinClient) => {
         world.do((clientManager, desktopManager) => {
-            clientManager.removeClient(kwinClient, true);
+            clientManager.removeClient(kwinClient, FocusPassing.Type.Immediate);
         });
     });
 
-    manager.connect(Workspace.windowActivated, (kwinClient: KwinClient) => {
+    manager.connect(Workspace.windowActivated, (kwinClient: KwinClient|null) => {
         if (kwinClient === null) {
-            return;
+            focusPasser.activate();
+        } else {
+            focusPasser.clearIfDifferent(kwinClient);
+            world.do((clientManager, desktopManager) => {
+                clientManager.onClientFocused(kwinClient);
+            });
         }
-        world.do((clientManager, desktopManager) => {
-            clientManager.onClientFocused(kwinClient);
-        });
     });
 
     manager.connect(Workspace.currentDesktopChanged, () => {
@@ -34,16 +32,22 @@ function initWorkspaceSignalHandlers(world: World) {
         world.do(() => {}); // re-arrange desktop
     });
 
-    manager.connect(Workspace.desktopsChanged, () => {
+    manager.connect(Workspace.screensChanged, () => {
         world.do((clientManager, desktopManager) => {
-            desktopManager.updateDesktops();
-        })
+            desktopManager.selectScreen(Workspace.activeScreen);
+        });
     });
 
     manager.connect(Workspace.activitiesChanged, () => {
         world.do((clientManager, desktopManager) => {
             desktopManager.updateActivities();
-        })
+        });
+    });
+
+    manager.connect(Workspace.desktopsChanged, () => {
+        world.do((clientManager, desktopManager) => {
+            desktopManager.updateDesktops();
+        });
     });
 
     manager.connect(Workspace.virtualScreenSizeChanged, () => {

src/lib/world/ClientManager.ts

@@ -1,15 +1,17 @@
 class ClientManager {
-    private readonly world: World;
     private readonly config: ClientManager.Config;
-    private readonly desktopManager: DesktopManager;
-    private readonly pinManager: PinManager;
     private readonly clientMap: Map<KwinClient, ClientWrapper>;
     private lastFocusedClient: KwinClient|null;
     private readonly windowRuleEnforcer: WindowRuleEnforcer;
 
-    constructor(config: Config, world: World, desktopManager: DesktopManager, pinManager: PinManager) {
+    constructor(
+        config: Config,
+        private readonly world: World,
+        private readonly desktopManager: DesktopManager,
+        private readonly pinManager: PinManager,
+    ) {
         this.world = world;
-        this.config = { keepAbove: config.floatingKeepAbove };
+        this.config = config;
         this.desktopManager = desktopManager;
         this.pinManager = pinManager;
         this.clientMap = new Map();
@@ -27,13 +29,19 @@ 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) && desktop !== undefined) {
-            constructState = (client: ClientWrapper) => new ClientState.Tiled(this.world, client, desktop.grid);
+        } else if (
+            Clients.canTileEver(kwinClient) &&
+            this.windowRuleEnforcer.shouldTile(kwinClient)
+        ) {
+            Clients.makeTileable(kwinClient);
+            console.assert(Clients.canTileNow(kwinClient));
+            const desktop = this.desktopManager.getDesktopForClient(kwinClient);
+            console.assert(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);
         }
@@ -47,18 +55,21 @@ class ClientManager {
         this.clientMap.set(kwinClient, client);
     }
 
-    public removeClient(kwinClient: KwinClient, passFocus: boolean) {
+    public removeClient(kwinClient: KwinClient, passFocus: FocusPassing.Type) {
         console.assert(this.hasClient(kwinClient));
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
         }
-        client.destroy(passFocus && kwinClient === this.lastFocusedClient);
+        if (kwinClient !== this.lastFocusedClient) {
+            passFocus = FocusPassing.Type.None;
+        }
+        client.destroy(passFocus);
         this.clientMap.delete(kwinClient);
     }
 
     private findTransientFor(kwinClient: KwinClient) {
-        if (!kwinClient.transient) {
+        if (!kwinClient.transient || kwinClient.transientFor === null) {
             return null;
         }
 
@@ -76,9 +87,10 @@ class ClientManager {
             return;
         }
         if (client.stateManager.getState() instanceof ClientState.Tiled) {
+            const passFocus = kwinClient === this.lastFocusedClient ? FocusPassing.Type.Immediate : FocusPassing.Type.None;
             client.stateManager.setState(
                 () => new ClientState.TiledMinimized(this.world, client),
-                kwinClient === this.lastFocusedClient,
+                passFocus,
             );
         }
     }
@@ -87,14 +99,14 @@ class ClientManager {
         if (client.stateManager.getState() instanceof ClientState.Tiled) {
             return;
         }
-        client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), false);
+        client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), FocusPassing.Type.None);
     }
 
     public floatClient(client: ClientWrapper) {
         if (client.stateManager.getState() instanceof ClientState.Floating) {
             return;
         }
-        client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), false);
+        client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), FocusPassing.Type.None);
     }
 
     public tileKwinClient(kwinClient: KwinClient, grid: Grid) {
@@ -123,7 +135,7 @@ class ClientManager {
             kwinClient.tile = null;
             return;
         }
-        client.stateManager.setState(() => new ClientState.Pinned(this.world, this.pinManager, this.desktopManager, kwinClient, this.config), false);
+        client.stateManager.setState(() => new ClientState.Pinned(this.world, this.pinManager, this.desktopManager, kwinClient, this.config), FocusPassing.Type.None);
         this.pinManager.addClient(kwinClient);
         for (const desktop of this.desktopManager.getDesktopsForClient(kwinClient)) {
             desktop.onPinsChanged();
@@ -136,7 +148,7 @@ class ClientManager {
             return;
         }
         console.assert(client.stateManager.getState() instanceof ClientState.Pinned);
-        client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, false), false);
+        client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, false), FocusPassing.Type.None);
         this.pinManager.removeClient(kwinClient);
         for (const desktop of this.desktopManager.getDesktopsForClient(kwinClient)) {
             desktop.onPinsChanged();
@@ -156,9 +168,9 @@ class ClientManager {
             if (desktop === undefined) {
                 return;
             }
-            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, desktop.grid), false);
+            client.stateManager.setState(() => new ClientState.Tiled(this.world, client, desktop.grid), FocusPassing.Type.None);
         } else if (clientState instanceof ClientState.Tiled) {
-            client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), false);
+            client.stateManager.setState(() => new ClientState.Floating(this.world, client, this.config, true), FocusPassing.Type.None);
         }
     }
 
@@ -168,27 +180,27 @@ class ClientManager {
 
     public onClientFocused(kwinClient: KwinClient) {
         this.lastFocusedClient = kwinClient;
-        const window = this.findTiledWindow(kwinClient, true);
+        const window = this.findTiledWindow(kwinClient);
         if (window !== null) {
             window.onFocused();
         }
     }
 
-    public findTiledWindow(kwinClient: KwinClient, followTransient: boolean) {
+    public findTiledWindow(kwinClient: KwinClient) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return null;
         }
 
-        return this.findTiledWindowOfClient(client, followTransient);
+        return this.findTiledWindowOfClient(client);
     }
 
-    private findTiledWindowOfClient(client: ClientWrapper, followTransient: boolean): Window|null {
+    private findTiledWindowOfClient(client: ClientWrapper): Window|null {
         const clientState = client.stateManager.getState();
         if (clientState instanceof ClientState.Tiled) {
             return clientState.window;
-        } else if (followTransient && client.transientFor !== null) {
-            return this.findTiledWindowOfClient(client.transientFor, true);
+        } else if (client.transientFor !== null) {
+            return this.findTiledWindowOfClient(client.transientFor);
         } else {
             return null;
         }
@@ -196,7 +208,7 @@ class ClientManager {
 
     private removeAllClients() {
         for (const kwinClient of Array.from(this.clientMap.keys())) {
-            this.removeClient(kwinClient, false);
+            this.removeClient(kwinClient, FocusPassing.Type.None);
         }
     }
 
@@ -206,7 +218,7 @@ class ClientManager {
 }
 
 namespace ClientManager {
-    export type Config = {
-        keepAbove: boolean,
+    export interface Config {
+        floatingKeepAbove: boolean;
     }
 }

src/lib/world/ClientWrapper.ts

@@ -1,20 +1,17 @@
 class ClientWrapper {
-    public readonly kwinClient: KwinClient;
     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
 
     constructor(
-        kwinClient: KwinClient,
+        public readonly kwinClient: KwinClient,
         constructInitialState: (client: ClientWrapper) => ClientState.State,
-        transientFor: ClientWrapper | null,
-        rulesSignalManager: SignalManager | null,
+        public transientFor: ClientWrapper | null,
+        private readonly rulesSignalManager: SignalManager | null,
     ) {
         this.kwinClient = kwinClient;
         this.transientFor = transientFor;
@@ -81,6 +78,7 @@ class ClientWrapper {
 
     public setMaximize(horizontally: boolean, vertically: boolean) {
         if (!this.kwinClient.maximizable) {
+            this.maximizedMode = MaximizedMode.Unmaximized;
             return;
         }
 
@@ -111,16 +109,6 @@ class ClientWrapper {
         });
     }
 
-    public setShade(shade: boolean) {
-        this.manipulatingGeometry.do(() => {
-            this.kwinClient.shade = shade;
-        });
-    }
-
-    public isShaded() {
-        return this.kwinClient.shade;
-    }
-
     public getMaximizedMode() {
         return this.maximizedMode;
     }
@@ -162,7 +150,7 @@ class ClientWrapper {
         }
     }
 
-    public destroy(passFocus: boolean) {
+    public destroy(passFocus: FocusPassing.Type) {
         this.stateManager.destroy(passFocus);
         this.signalManager.destroy();
         if (this.rulesSignalManager !== null) {

src/lib/world/Clients.ts

@@ -1,10 +1,21 @@
 namespace Clients {
+    const prohibitedClasses = [
+        "ksmserver-logout-greeter",
+        "xwaylandvideobridge",
+    ];
+
     export function canTileEver(kwinClient: KwinClient) {
-        return kwinClient.moveable && kwinClient.resizeable && !kwinClient.popupWindow;
+        const shapeable = (kwinClient.moveable && kwinClient.resizeable) || kwinClient.fullScreen; // full-screen windows may become shapeable after exiting full-screen mode
+        return shapeable &&
+            !kwinClient.popupWindow &&
+            !prohibitedClasses.includes(kwinClient.resourceClass);
     }
 
     export function canTileNow(kwinClient: KwinClient) {
-        return canTileEver(kwinClient) && !kwinClient.minimized && kwinClient.desktops.length === 1 && kwinClient.activities.length === 1;
+        return canTileEver(kwinClient) &&
+            !kwinClient.minimized &&
+            kwinClient.desktops.length === 1 &&
+            kwinClient.activities.length === 1;
     }
 
     export function makeTileable(kwinClient: KwinClient) {
@@ -21,22 +32,23 @@ namespace Clients {
 
     export function getKwinDesktopApprox(kwinClient: KwinClient) {
         switch (kwinClient.desktops.length) {
-            case 0:
+        case 0:
+            return Workspace.currentDesktop;
+        case 1:
+            return kwinClient.desktops[0];
+        default:
+            if (kwinClient.desktops.includes(Workspace.currentDesktop)) {
                 return Workspace.currentDesktop;
-            case 1:
+            } else {
                 return kwinClient.desktops[0];
-            default:
-                if (kwinClient.desktops.includes(Workspace.currentDesktop)) {
-                    return Workspace.currentDesktop;
-                } else {
-                    return kwinClient.desktops[0];
-                }
+            }
         }
     }
 
     export function isFullScreenGeometry(kwinClient: KwinClient) {
         const fullScreenArea = Workspace.clientArea(ClientAreaOption.FullScreenArea, kwinClient.output, getKwinDesktopApprox(kwinClient));
-        return kwinClient.frameGeometry === fullScreenArea;
+        return kwinClient.clientGeometry.width >= fullScreenArea.width &&
+            kwinClient.clientGeometry.height >= fullScreenArea.height;
     }
 
     export function isOnVirtualDesktop(kwinClient: KwinClient, kwinDesktop: KwinDesktop) {

src/lib/world/DesktopManager.ts

@@ -1,16 +1,22 @@
 class DesktopManager {
-    private readonly pinManager: PinManager;
-    private readonly config: Desktop.Config;
-    public readonly layoutConfig: LayoutConfig;
     private readonly desktops: Map<string, Desktop>; // key is activityId|desktopId
+    private selectedScreen: Output;
     private kwinActivities: Set<string>;
     private kwinDesktops: Set<KwinDesktop>;
 
-    constructor(pinManager: PinManager, config: Desktop.Config, layoutConfig: LayoutConfig, currentActivity: string, currentDesktop: KwinDesktop) {
+    constructor(
+        private readonly pinManager: PinManager,
+        private readonly config: Desktop.Config,
+        private readonly layoutConfig: LayoutConfig,
+        private readonly focusPasser: FocusPassing.Passer,
+        currentActivity: string,
+        currentDesktop: KwinDesktop,
+    ) {
         this.pinManager = pinManager;
         this.config = config;
         this.layoutConfig = layoutConfig;
         this.desktops = new Map();
+        this.selectedScreen = Workspace.activeScreen;
         this.kwinActivities = new Set(Workspace.activities);
         this.kwinDesktops = new Set(Workspace.desktops);
         this.addDesktop(currentActivity, currentDesktop);
@@ -43,7 +49,14 @@ class DesktopManager {
 
     private addDesktop(activity: string, kwinDesktop: KwinDesktop) {
         const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
-        const desktop = new Desktop(kwinDesktop, this.pinManager, this.config, this.layoutConfig);
+        const desktop = new Desktop(
+            kwinDesktop,
+            this.pinManager,
+            this.config,
+            () => this.selectedScreen,
+            this.layoutConfig,
+            this.focusPasser,
+        );
         this.desktops.set(desktopKey, desktop);
         return desktop;
     }
@@ -72,6 +85,10 @@ class DesktopManager {
         this.kwinDesktops = newDesktops;
     }
 
+    public selectScreen(screen: Output) {
+        this.selectedScreen = screen;
+    }
+
     private removeActivity(activity: string) {
         for (const kwinDesktop of this.kwinDesktops) {
             this.destroyDesktop(activity, kwinDesktop);

src/lib/world/FocusPassing.ts

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

src/lib/world/PinManager.ts

@@ -17,7 +17,7 @@ class PinManager {
         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, kwinDesktop)) {
+            if (!Clients.isOnVirtualDesktop(client, kwinDesktop) || client.minimized) {
                 continue;
             }
 

src/lib/world/World.ts

@@ -1,19 +1,33 @@
 class World {
-    public readonly untileOnDrag: boolean;
     private readonly desktopManager: DesktopManager;
-    public readonly clientManager: ClientManager;
+    private readonly clientManager: ClientManager;
     private readonly pinManager: PinManager;
     private readonly workspaceSignalManager: SignalManager;
     private readonly shortcutActions: ShortcutAction[];
     private readonly screenResizedDelayer: Delayer;
+    private readonly cursorFollowsFocus: boolean;
 
     constructor(config: Config) {
-        this.untileOnDrag = config.untileOnDrag;
-        this.workspaceSignalManager = initWorkspaceSignalHandlers(this);
+        const focusPasser = new FocusPassing.Passer();
+        this.workspaceSignalManager = initWorkspaceSignalHandlers(this, focusPasser);
+        this.cursorFollowsFocus = config.cursorFollowsFocus;
+
+        let presetWidths = {
+            next: (currentWidth: number, minWidth: number, maxWidth: number) => currentWidth,
+            prev: (currentWidth: number, minWidth: number, maxWidth: number) => currentWidth,
+            getWidths: (minWidth: number, maxWidth: number): number[] => [],
+        };
+        try {
+            presetWidths = new PresetWidths(config.presetWidths, config.gapsInnerHorizontal);
+        } catch (error: any) {
+            notificationInvalidPresetWidths.sendEvent();
+            log("failed to parse presetWidths:", error);
+        }
+
         this.shortcutActions = registerKeyBindings(this, {
             manualScrollStep: config.manualScrollStep,
-            manualResizeStep: config.manualResizeStep,
-            columnResizer: config.scrollingCentered ? new RawResizer() : new ContextualResizer(),
+            presetWidths: presetWidths,
+            columnResizer: config.scrollingCentered ? new RawResizer(presetWidths) : new ContextualResizer(presetWidths),
         });
 
         this.screenResizedDelayer = new Delayer(1000, () => {
@@ -29,6 +43,8 @@ class World {
         const layoutConfig = {
             gapsInnerHorizontal: config.gapsInnerHorizontal,
             gapsInnerVertical: config.gapsInnerVertical,
+            stackOffsetX: config.stackOffsetX,
+            stackOffsetY: config.stackOffsetY,
             offScreenOpacity: config.offScreenOpacity / 100.0,
             stackColumnsByDefault: config.stackColumnsByDefault,
             resizeNeighborColumn: config.resizeNeighborColumn,
@@ -36,6 +52,7 @@ class World {
             skipSwitcher: config.skipSwitcher,
             tiledKeepBelow: config.tiledKeepBelow,
             maximizedKeepAbove: config.floatingKeepAbove,
+            untileOnDrag: config.untileOnDrag,
         };
 
         this.desktopManager = new DesktopManager(
@@ -47,8 +64,12 @@ class World {
                 marginRight: config.gapsOuterRight,
                 scroller: World.createScroller(config),
                 clamper: config.scrollingLazy ? new EdgeClamper() : new CenterClamper(),
+                gestureScroll: config.gestureScroll,
+                gestureScrollInvert: config.gestureScrollInvert,
+                gestureScrollStep: config.gestureScrollStep,
             },
             layoutConfig,
+            focusPasser,
             Workspace.currentActivity,
             Workspace.currentDesktop,
         );
@@ -71,15 +92,24 @@ class World {
     }
 
     private addExistingClients() {
-        const kwinClients = Workspace.windows;
-        for (let i = 0; i < kwinClients.length; i++) {
-            const kwinClient = kwinClients[i];
+        for (const kwinClient of Workspace.windows) {
             this.clientManager.addClient(kwinClient);
         }
     }
 
     private update() {
         this.desktopManager.getCurrentDesktop().arrange();
+        this.moveCursorToFocus();
+    }
+
+    private moveCursorToFocus() {
+        if (this.cursorFollowsFocus && Workspace.activeWindow !== null) {
+            const cursorAlreadyInFocus = rectContainsPoint(Workspace.activeWindow.frameGeometry, Workspace.cursorPos);
+            if (cursorAlreadyInFocus) {
+                return;
+            }
+            moveCursorToFocus.call();
+        }
     }
 
     public do(f: (clientManager: ClientManager, desktopManager: DesktopManager) => void) {
@@ -89,10 +119,9 @@ class World {
 
     public doIfTiled(
         kwinClient: KwinClient,
-        followTransient: boolean,
         f: (clientManager: ClientManager, desktopManager: DesktopManager, window: Window, column: Column, grid: Grid) => void,
     ) {
-        const window = this.clientManager.findTiledWindow(kwinClient, followTransient);
+        const window = this.clientManager.findTiledWindow(kwinClient);
         if (window === null) {
             return;
         }
@@ -103,10 +132,20 @@ class World {
     }
 
     public doIfTiledFocused(
-        followTransient: boolean,
         f: (clientManager: ClientManager, desktopManager: DesktopManager, window: Window, column: Column, grid: Grid) => void,
     ) {
-        this.doIfTiled(Workspace.activeWindow, followTransient, f);
+        if (Workspace.activeWindow === null) {
+            return;
+        }
+        this.doIfTiled(Workspace.activeWindow, f);
+    }
+
+    public gestureScroll(amount: number) {
+        this.do((clientManager, desktopManager) => desktopManager.getCurrentDesktop().gestureScroll(amount));
+    }
+
+    public gestureScrollFinish() {
+        this.do((clientManager, desktopManager) => desktopManager.getCurrentDesktop().gestureScrollFinish());
     }
 
     public destroy() {

src/lib/world/clientState/Docked.ts

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

src/lib/world/clientState/Floating.ts

@@ -7,7 +7,7 @@ namespace ClientState {
         constructor(world: World, client: ClientWrapper, config: ClientManager.Config, limitHeight: boolean) {
             this.client = client;
             this.config = config;
-            if (config.keepAbove) {
+            if (config.floatingKeepAbove) {
                 client.kwinClient.keepAbove = true;
             }
             if (limitHeight && client.kwinClient.tile === null) {
@@ -16,13 +16,11 @@ namespace ClientState {
             this.signalManager = Floating.initSignalManager(world, client.kwinClient);
         }
 
-        public destroy(passFocus: boolean) {
+        public destroy(passFocus: FocusPassing.Type) {
             this.signalManager.destroy();
-            if (this.config.keepAbove) {
-                this.client.kwinClient.keepAbove = false;
-            }
         }
 
+        // TODO: move to `Tiled.restoreClientAfterTiling`
         private static limitHeight(client: ClientWrapper) {
             const placementArea = Workspace.clientArea(
                 ClientAreaOption.PlacementArea,
@@ -50,7 +48,7 @@ namespace ClientState {
                     });
                 }
             });
-            
+
             manager.connect(kwinClient.frameGeometryChanged, () => {
                 // on Wayland, this fires after `tileChanged`
                 if (kwinClient.tile !== null) {

src/lib/world/clientState/Manager.ts

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

src/lib/world/clientState/Pinned.ts

@@ -11,17 +11,14 @@ namespace ClientState {
             this.pinManager = pinManager;
             this.desktopManager = desktopManager;
             this.config = config;
-            if (config.keepAbove) {
+            if (config.floatingKeepAbove) {
                 kwinClient.keepAbove = true;
             }
             this.signalManager = Pinned.initSignalManager(world, pinManager, kwinClient);
         }
 
-        public destroy(passFocus: boolean) {
+        public destroy(passFocus: FocusPassing.Type) {
             this.signalManager.destroy();
-            if (this.config.keepAbove) {
-                this.kwinClient.keepAbove = true;
-            }
             this.pinManager.removeClient(this.kwinClient);
             for (const desktop of this.desktopManager.getDesktopsForClient(this.kwinClient)) {
                 desktop.onPinsChanged();
@@ -53,7 +50,15 @@ namespace ClientState {
                     for (const desktop of desktopManager.getDesktopsForClient(kwinClient)) {
                         desktop.onPinsChanged();
                     }
-                })
+                });
+            });
+
+            manager.connect(kwinClient.minimizedChanged, () => {
+                world.do((clientManager, desktopManager) => {
+                    for (const desktop of desktopManager.getDesktopsForClient(kwinClient)) {
+                        desktop.onPinsChanged();
+                    }
+                });
             });
 
             manager.connect(kwinClient.desktopsChanged, () => {

src/lib/world/clientState/Tiled.ts

@@ -3,6 +3,7 @@ namespace ClientState {
         public readonly window: Window;
         private readonly defaultState: Tiled.WindowState;
         private readonly signalManager: SignalManager;
+        private static readonly maxExternalFrameGeometryChangedIntervalMs = 1000;
 
         constructor(world: World, client: ClientWrapper, grid: Grid) {
             this.defaultState = { skipSwitcher: client.kwinClient.skipSwitcher };
@@ -12,10 +13,10 @@ namespace ClientState {
             const window = new Window(client, column);
 
             this.window = window;
-            this.signalManager = Tiled.initSignalManager(world, window);
+            this.signalManager = Tiled.initSignalManager(world, window, grid.config);
         }
 
-        public destroy(passFocus: boolean) {
+        public destroy(passFocus: FocusPassing.Type) {
             this.signalManager.destroy();
 
             const window = this.window;
@@ -26,7 +27,7 @@ namespace ClientState {
             Tiled.restoreClientAfterTiling(client, grid.config, this.defaultState, grid.desktop.clientArea);
         }
 
-        private static initSignalManager(world: World, window: Window) {
+        private static initSignalManager(world: World, window: Window, config: LayoutConfig) {
             const client = window.client;
             const kwinClient = client.kwinClient;
             const manager = new SignalManager();
@@ -36,7 +37,7 @@ namespace ClientState {
                     const desktop = desktopManager.getDesktopForClient(kwinClient);
                     if (desktop === undefined) {
                         // windows on multiple desktops are not supported
-                        clientManager.floatKwinClient(kwinClient);
+                        clientManager.floatClient(client);
                         return;
                     }
                     Tiled.moveWindowToGrid(window, desktop.grid);
@@ -48,12 +49,12 @@ namespace ClientState {
                     const desktop = desktopManager.getDesktopForClient(kwinClient);
                     if (desktop === undefined) {
                         // windows on multiple activities are not supported
-                        clientManager.floatKwinClient(kwinClient);
+                        clientManager.floatClient(client);
                         return;
                     }
                     Tiled.moveWindowToGrid(window, desktop.grid);
                 });
-            })
+            });
 
             manager.connect(kwinClient.minimizedChanged, () => {
                 console.assert(kwinClient.minimized);
@@ -68,33 +69,51 @@ namespace ClientState {
                 });
             });
 
+            let moving = false;
             let resizing = false;
-            let resizingBorder = false;
+            let resizeStartWidth = 0;
+            let resizeNeighbor: { column: Column, startWidth: number } | undefined;
             manager.connect(kwinClient.interactiveMoveResizeStarted, () => {
                 if (kwinClient.move) {
-                    if (world.untileOnDrag) {
+                    if (config.untileOnDrag) {
                         world.do((clientManager, desktopManager) => {
-                            clientManager.floatKwinClient(kwinClient);
+                            clientManager.floatClient(client);
                         });
+                    } else {
+                        moving = true;
                     }
                     return;
                 }
 
                 if (kwinClient.resize) {
                     resizing = true;
-                    resizingBorder = Workspace.cursorPos.x > kwinClient.clientGeometry.right ||
-                        Workspace.cursorPos.x < kwinClient.clientGeometry.left;
+                    resizeStartWidth = window.column.getWidth();
+                    if (config.resizeNeighborColumn) {
+                        const resizeNeighborColumn = Tiled.getResizeNeighborColumn(window);
+                        if (resizeNeighborColumn !== null) {
+                            resizeNeighbor = {
+                                column: resizeNeighborColumn,
+                                startWidth: resizeNeighborColumn.getWidth(),
+                            };
+                        }
+                    }
                     window.column.grid.onUserResizeStarted();
                 }
             });
 
             manager.connect(kwinClient.interactiveMoveResizeFinished, () => {
+                if (moving) {
+                    moving = false;
+                    world.do(() => window.column.grid.desktop.onLayoutChanged()); // move the dragged window back to its position
+                }
                 if (resizing) {
                     resizing = false;
+                    resizeNeighbor = undefined;
                     window.column.grid.onUserResizeFinished();
                 }
             });
 
+            const externalFrameGeometryChangedRateLimiter = new RateLimiter(4, Tiled.maxExternalFrameGeometryChangedIntervalMs);
             manager.connect(kwinClient.frameGeometryChanged, (oldGeometry: QmlRect) => {
                 // on Wayland, this fires after `tileChanged`
                 if (kwinClient.tile !== null) {
@@ -112,23 +131,51 @@ namespace ClientState {
                 const dx = Math.round(newCenterX - oldCenterX);
                 const dy = Math.round(newCenterY - oldCenterY);
                 if (dx !== 0 || dy !== 0) {
+                    // TODO: instead of passing dx and dy, remember relative (to the parent) x and y for each
+                    // transient window and use them for `moveTransients` and `ensureTransientsVisible`
                     client.moveTransients(dx, dy);
                 }
 
                 if (kwinClient.resize) {
-                    world.do(() => window.onUserResize(oldGeometry, resizingBorder));
+                    world.do(() => {
+                        if (newGeometry.width !== oldGeometry.width) {
+                            window.column.onUserResizeWidth(
+                                resizeStartWidth,
+                                newGeometry.width - resizeStartWidth,
+                                newGeometry.left !== oldGeometry.left,
+                                resizeNeighbor,
+                            );
+                        }
+                        if (newGeometry.height !== oldGeometry.height) {
+                            window.column.adjustWindowHeight(
+                                window,
+                                newGeometry.height - oldGeometry.height,
+                                newGeometry.y !== oldGeometry.y,
+                            );
+                        }
+                    });
                 } else if (
                     !window.column.grid.isUserResizing() &&
                     !client.isManipulatingGeometry(newGeometry) &&
                     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());
+                    if (externalFrameGeometryChangedRateLimiter.acquire()) {
+                        world.do(() => window.onFrameGeometryChanged());
+                    }
                 }
             });
 
             manager.connect(kwinClient.fullScreenChanged, () => {
-                world.do(() => window.onFullScreenChanged(kwinClient.fullScreen));
+                world.do((clientManager, desktopManager) => {
+                    // some clients only turn out to be untileable after exiting full-screen mode
+                    if (!Clients.canTileEver(kwinClient)) {
+                        clientManager.floatClient(client);
+                        return;
+                    }
+
+                    window.onFullScreenChanged(kwinClient.fullScreen);
+                });
             });
 
             manager.connect(kwinClient.tileChanged, () => {
@@ -143,6 +190,18 @@ namespace ClientState {
             return manager;
         }
 
+        private static getResizeNeighborColumn(window: Window) {
+            const kwinClient = window.client.kwinClient;
+            const column = window.column;
+            if (Workspace.cursorPos.x > kwinClient.clientGeometry.right) {
+                return column.grid.getRightColumn(column);
+            } else if (Workspace.cursorPos.x < kwinClient.clientGeometry.left) {
+                return column.grid.getLeftColumn(column);
+            } else {
+                return null;
+            }
+        }
+
         private static moveWindowToGrid(window: Window, grid: Grid) {
             if (grid === window.column.grid) {
                 // window already on the given grid
@@ -150,17 +209,26 @@ namespace ClientState {
             }
 
             const newColumn = new Column(grid, grid.getLastFocusedColumn() ?? grid.getLastColumn());
-            window.moveToColumn(newColumn);
+            const passFocus = window.isFocused() ? FocusPassing.Type.OnUnfocus : FocusPassing.Type.None;
+            window.moveToColumn(newColumn, true, passFocus);
         }
 
         private static prepareClientForTiling(client: ClientWrapper, config: LayoutConfig) {
             if (config.skipSwitcher) {
                 client.kwinClient.skipSwitcher = true;
             }
-            if (config.tiledKeepBelow) {
-                client.kwinClient.keepBelow = true;
+
+            if (client.kwinClient.fullScreen) {
+                if (config.maximizedKeepAbove) {
+                    client.kwinClient.keepAbove = true;
+                }
+            } else {
+                if (config.tiledKeepBelow) {
+                    client.kwinClient.keepBelow = true;
+                }
+                client.kwinClient.keepAbove = false;
             }
-            client.setFullScreen(false);
+
             if (client.kwinClient.tile !== null) {
                 client.setMaximize(false, true); // disable quick tile mode
             }
@@ -177,7 +245,6 @@ namespace ClientState {
             if (config.offScreenOpacity < 1.0) {
                 client.kwinClient.opacity = 1.0;
             }
-            client.setShade(false);
             client.setFullScreen(false);
             if (client.kwinClient.tile === null) {
                 client.setMaximize(false, false);
@@ -187,8 +254,8 @@ namespace ClientState {
     }
 
     namespace Tiled {
-        export type WindowState = {
-            skipSwitcher: boolean,
+        export interface WindowState {
+            skipSwitcher: boolean;
         }
     }
 }

src/lib/world/clientState/TiledMinimized.ts

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

src/main/main.ts

@@ -1,3 +1,11 @@
 function init() {
     return new World(loadConfig());
 }
+
+function loadConfig(): Config {
+    const config: any = {};
+    for (const entry of configDef) {
+        config[entry.name] = KWin.readConfig(entry.name, entry.default);
+    }
+    return config;
+}

src/main/tsconfig.json

@@ -1,4 +1,8 @@
 {
     "extends": "../tsconfig.json",
-    "include": ["../lib/**/*", "./**/*"]
+    "include": [
+        "../extern/**/*",
+        "../lib/**/*",
+        "./**/*"
+    ]
 }

src/tests/flows/centerFocused.ts

@@ -0,0 +1,43 @@
+tests.register("Center focused", 1, () => {
+    const config = getDefaultConfig();
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const [client0, client1, client2] = workspaceMock.createClientsWithWidths(300, 152, 300);
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.hasClient(client0));
+        Assert.assert(clientManager.hasClient(client1));
+        Assert.assert(clientManager.hasClient(client2));
+    });
+    Assert.assert(workspaceMock.activeWindow === client2);
+    Assert.columnsFillTilingArea([client0, client1, client2]);
+
+    // center client2
+    qtMock.fireShortcut("karousel-grid-scroll-focused");
+    Assert.centered(config, tilingArea, client2);
+    Assert.fullyVisible(client1.frameGeometry);
+    Assert.fullyVisible(client2.frameGeometry);
+
+    // undo center client2
+    qtMock.fireShortcut("karousel-grid-scroll-focused");
+    Assert.columnsFillTilingArea([client0, client1, client2]);
+
+    // center client2
+    qtMock.fireShortcut("karousel-grid-scroll-focused");
+    Assert.centered(config, tilingArea, client2);
+    Assert.fullyVisible(client1.frameGeometry);
+    Assert.fullyVisible(client2.frameGeometry);
+
+    // focus client1 (no scrolling should occur)
+    qtMock.fireShortcut("karousel-focus-left");
+    Assert.centered(config, tilingArea, client2, { message: "No scrolling should have occured" });
+    Assert.fullyVisible(client1.frameGeometry);
+    Assert.fullyVisible(client2.frameGeometry);
+
+    // center client1
+    qtMock.fireShortcut("karousel-grid-scroll-focused");
+    Assert.columnsFillTilingArea([client0, client1, client2]);
+
+    // undo center client1 (no scrolling should occur, because all clients are already visible and centered)
+    qtMock.fireShortcut("karousel-grid-scroll-focused");
+    Assert.columnsFillTilingArea([client0, client1, client2]);
+});

src/tests/flows/columnsSqueezeSide.ts

@@ -0,0 +1,124 @@
+tests.register("columns squeeze side", 1, () => {
+    const baseTestCases = [
+        { widths: [500, 500], blocked: [false, false], possible: true },
+        { widths: [500, 768], blocked: [false, false], possible: true },
+        { widths: [500, 500], blocked: [false, true], possible: true },
+        { widths: [500, 200, 200], blocked: [false, false, false], possible: true },
+        { widths: [500, 200, 200], blocked: [false, false, true], possible: true },
+        { widths: [500, 200, 200], blocked: [true, false, true], possible: true },
+        { widths: [500, 500, 500], blocked: [false, true, true], possible: false },
+    ];
+
+    const testCasesLeft = baseTestCases.map((baseTestCase, i) => ({
+        ...baseTestCase,
+        name: "left " + i,
+        action: "karousel-columns-squeeze-left",
+        focus: baseTestCase.widths.length-1,
+    }));
+
+    const testCasesRight = baseTestCases.map((baseTestCase, i) => ({
+        ...baseTestCase,
+        widths: baseTestCase.widths.slice().reverse(),
+        blocked: baseTestCase.blocked.slice().reverse(),
+        name: "right " + i,
+        action: "karousel-columns-squeeze-right",
+        focus: 0,
+    }));
+
+    const testCases = [...testCasesLeft, ...testCasesRight];
+
+    for (const testCase of testCases) {
+        const assertOpt = { message: `Case: ${testCase.name}` };
+
+        const config = getDefaultConfig();
+        const { qtMock, workspaceMock, world } = init(config);
+
+        const clients = workspaceMock.createClientsWithWidths(...testCase.widths);
+        workspaceMock.activeWindow = clients[testCase.focus];
+        for (let i = 0; i < clients.length; i++) {
+            if (testCase.blocked[i]) {
+                clients[i].minSize = new MockQmlSize(testCase.widths[i], 100);
+            }
+        }
+
+        if (testCase.possible) {
+            qtMock.fireShortcut(testCase.action);
+            Assert.columnsFillTilingArea(clients, assertOpt);
+            for (let i = 0; i < clients.length; i++) {
+                if (testCase.blocked[i]) {
+                    Assert.equal(clients[i].frameGeometry.width, testCase.widths[i], assertOpt);
+                }
+            }
+        }
+
+        const frames = clients.map(client => client.frameGeometry);
+        qtMock.fireShortcut(testCase.action);
+        const newFrames = clients.map(client => client.frameGeometry);
+        for (let i = 0; i < clients.length; i++) {
+            Assert.equalRects(frames[i], newFrames[i], assertOpt);
+        }
+    }
+});
+
+tests.register("columns squeeze side (just scroll)", 1, () => {
+    const baseTestCases = [
+        { focus: 0, startVisible: [true, true, false], endVisible: [true, true, false] },
+        { focus: 1, startVisible: [false, true, true], endVisible: [true, true, false] },
+        { focus: 2, startVisible: [false, true, true], endVisible: [false, true, true] },
+    ];
+
+    const testCasesLeft = baseTestCases.map((baseTestCase, i) => ({
+        ...baseTestCase,
+        name: "left " + i,
+        action: "karousel-columns-squeeze-left",
+        scrollStart: false,
+    }));
+
+    const testCasesRight = baseTestCases.map((baseTestCase, i) => ({
+        focus: 2 - baseTestCase.focus,
+        startVisible: baseTestCase.startVisible.slice().reverse(),
+        endVisible: baseTestCase.endVisible.slice().reverse(),
+        name: "right " + i,
+        action: "karousel-columns-squeeze-right",
+        scrollStart: true,
+    }));
+
+    const testCases = [...testCasesLeft, ...testCasesRight];
+
+    for (const testCase of testCases) {
+        const assertMsg = `Case: ${testCase.name}`;
+
+        const config = getDefaultConfig();
+        const { qtMock, workspaceMock, world } = init(config);
+
+        function assertVisible(clients: KwinClient[], visible: boolean[]) {
+            for (let i = 0; i < clients.length; i++) {
+                if (visible[i]) {
+                    Assert.fullyVisible(clients[i].frameGeometry, { message: assertMsg, skip: 1 });
+                } else {
+                    Assert.notFullyVisible(clients[i].frameGeometry, { message: assertMsg, skip: 1 });
+                }
+            }
+        }
+
+        const clients = workspaceMock.createClientsWithWidths(300, 300, 300);
+        for (const client of clients) {
+            client.minSize = new MockQmlSize(300, 100);
+        }
+        if (testCase.scrollStart) {
+            qtMock.fireShortcut("karousel-grid-scroll-start");
+        }
+        workspaceMock.activeWindow = clients[testCase.focus];
+        assertVisible(clients, testCase.startVisible);
+
+        qtMock.fireShortcut(testCase.action);
+        assertVisible(clients, testCase.endVisible);
+
+        const frames = clients.map(client => client.frameGeometry);
+        qtMock.fireShortcut(testCase.action);
+        const newFrames = clients.map(client => client.frameGeometry);
+        for (let i = 0; i < clients.length; i++) {
+            Assert.equalRects(frames[i], newFrames[i], { message: assertMsg });
+        }
+    }
+});

src/tests/flows/cursorFollowsFocus.ts

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

src/tests/flows/dragTiled.ts

@@ -0,0 +1,34 @@
+tests.register("Drag tiled window, untile", 20, () => {
+    const config = getDefaultConfig();
+    config.untileOnDrag = true;
+    const { qtMock, workspaceMock, world } = init(config);
+    const clientManager = getClientManager(world);
+
+    const [client0, client1] = workspaceMock.createClients(2);
+    Assert.tiledClient(clientManager, client0);
+    Assert.tiledClient(clientManager, client1);
+    Assert.grid(config, tilingArea, 100, [[client0], [client1]], true);
+
+    workspaceMock.moveWindow(client0, new MockQmlPoint(10, 10));
+    Assert.notTiledClient(clientManager, client0);
+    Assert.tiledClient(clientManager, client1);
+    Assert.grid(config, tilingArea, 100, [[client1]], true);
+});
+
+tests.register("Drag tiled window, keep tiled", 20, () => {
+    const config = getDefaultConfig();
+    config.untileOnDrag = false;
+    const { qtMock, workspaceMock, world } = init(config);
+    const clientManager = getClientManager(world);
+
+    const [client0, client1] = workspaceMock.createClients(2);
+    Assert.tiledClient(clientManager, client0);
+    Assert.tiledClient(clientManager, client1);
+    Assert.grid(config, tilingArea, 100, [[client0], [client1]], true);
+
+    const move = new MockQmlPoint(10, 10);
+    workspaceMock.moveWindow(client0, move, move, move, move, move, move, move, move, move); // many moves in order to trigger externalFrameGeometryChangedRateLimiter
+    Assert.tiledClient(clientManager, client0);
+    Assert.tiledClient(clientManager, client1);
+    Assert.grid(config, tilingArea, 100, [[client0], [client1]], true);
+});

src/tests/flows/externalResize.ts

@@ -0,0 +1,44 @@
+tests.register("External resize", 1, () => {
+    const config = getDefaultConfig();
+    const { qtMock, workspaceMock, world } = init(config);
+
+    function getClientDesiredFrame(width: number) {
+        return new MockQmlRect(10, 10, width, 200);
+    }
+
+    function getTiledFrame(width: number) {
+        return new MockQmlRect(
+            tilingArea.left + Math.round((tilingArea.width - width) / 2),
+            tilingArea.top,
+            width,
+            tilingArea.height,
+        );
+    }
+
+    const [client] = workspaceMock.createClientsWithFrames(getClientDesiredFrame(100));
+    Assert.equalRects(client.frameGeometry, getTiledFrame(100), { message: "We should tile the window, respecting its desired width" });
+
+    function testExternalResizing() {
+        client.frameGeometry = getClientDesiredFrame(110);
+        Assert.equalRects(client.frameGeometry, getTiledFrame(110), { message: "We should re-arrange the window, respecting its new desired width" });
+
+        client.frameGeometry = getClientDesiredFrame(120);
+        Assert.equalRects(client.frameGeometry, getTiledFrame(120), { message: "We should re-arrange the window, respecting its new desired width" });
+
+        client.frameGeometry = getClientDesiredFrame(130);
+        Assert.equalRects(client.frameGeometry, getTiledFrame(130), { message: "We should re-arrange the window, respecting its new desired width" });
+
+        client.frameGeometry = getClientDesiredFrame(140);
+        Assert.equalRects(client.frameGeometry, getTiledFrame(140), { message: "We should re-arrange the window, respecting its new desired width" });
+
+        client.frameGeometry = getClientDesiredFrame(200);
+        Assert.equalRects(client.frameGeometry, getClientDesiredFrame(200), { message: "We should give up and let the client have its desired frame" });
+    }
+
+    timeControl(addTime => {
+        testExternalResizing();
+        addTime(1000);
+        // the concession has expired, let's test again
+        testExternalResizing();
+    });
+});

src/tests/flows/followWindowToDesktop.ts

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

src/tests/flows/layering.ts

@@ -0,0 +1,191 @@
+tests.register("tiledKeepBelow", 10, () => {
+    const config = getDefaultConfig();
+    config.tiledKeepBelow = true;
+    config.floatingKeepAbove = false;
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const pinGeometry = new MockQmlRect(0, 0, 200, screen.height);
+
+    const [client] = workspaceMock.createClients(1);
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) !== null);
+    });
+    Assert.assert(client.keepBelow);
+    Assert.assert(!client.keepAbove);
+
+    qtMock.fireShortcut("karousel-window-toggle-floating");
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) === null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(!client.keepAbove);
+
+    client.pin(pinGeometry);
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) === null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(!client.keepAbove);
+
+    client.unpin();
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) === null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(!client.keepAbove);
+
+    qtMock.fireShortcut("karousel-window-toggle-floating");
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) !== null);
+    });
+    Assert.assert(client.keepBelow);
+    Assert.assert(!client.keepAbove);
+
+    client.pin(pinGeometry);
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) === null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(!client.keepAbove);
+
+    qtMock.fireShortcut("karousel-window-toggle-floating");
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) !== null);
+    });
+    Assert.assert(client.keepBelow);
+    Assert.assert(!client.keepAbove);
+});
+
+tests.register("floatingKeepAbove", 10, () => {
+    const config = getDefaultConfig();
+    config.tiledKeepBelow = false;
+    config.floatingKeepAbove = true;
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const pinGeometry = new MockQmlRect(0, 0, 200, screen.height);
+
+    const [client] = workspaceMock.createClients(1);
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) !== null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(!client.keepAbove);
+
+    qtMock.fireShortcut("karousel-window-toggle-floating");
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) === null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(client.keepAbove);
+
+    client.pin(pinGeometry);
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) === null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(client.keepAbove);
+
+    client.unpin();
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) === null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(client.keepAbove);
+
+    qtMock.fireShortcut("karousel-window-toggle-floating");
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) !== null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(!client.keepAbove);
+
+    client.pin(pinGeometry);
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) === null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(client.keepAbove);
+
+    qtMock.fireShortcut("karousel-window-toggle-floating");
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.findTiledWindow(client) !== null);
+    });
+    Assert.assert(!client.keepBelow);
+    Assert.assert(!client.keepAbove);
+});
+
+tests.register("No layering", 10, () => {
+    const config = getDefaultConfig();
+    config.tiledKeepBelow = false;
+    config.floatingKeepAbove = false;
+    // In this mode, Karousel shouldn't change keepBelow or keepAbove.
+    // Except when tiling a window, keepAbove should still be cleared.
+
+    const pinGeometry = new MockQmlRect(0, 0, 200, screen.height);
+
+    const testCases = [
+        { keepBelow: false, keepAbove: false },
+        { keepBelow: false, keepAbove: true },
+        { keepBelow: true,  keepAbove: false },
+        { keepBelow: true,  keepAbove: true },
+    ];
+
+    for (const testCase of testCases) {
+        const assertOptions = { message: JSON.stringify(testCase) };
+
+        const { qtMock, workspaceMock, world } = init(config);
+
+        const [client] = workspaceMock.createClients(1);
+        client.keepBelow = testCase.keepBelow;
+        client.keepAbove = testCase.keepAbove;
+
+        world.do((clientManager, desktopManager) => {
+            Assert.assert(clientManager.findTiledWindow(client) !== null, assertOptions);
+        });
+        Assert.equal(client.keepBelow, testCase.keepBelow, assertOptions);
+        Assert.equal(client.keepAbove, testCase.keepAbove, assertOptions);
+
+        qtMock.fireShortcut("karousel-window-toggle-floating");
+        world.do((clientManager, desktopManager) => {
+            Assert.assert(clientManager.findTiledWindow(client) === null, assertOptions);
+        });
+        Assert.equal(client.keepBelow, testCase.keepBelow, assertOptions);
+        Assert.equal(client.keepAbove, testCase.keepAbove, assertOptions);
+
+        client.pin(pinGeometry);
+        world.do((clientManager, desktopManager) => {
+            Assert.assert(clientManager.findTiledWindow(client) === null, assertOptions);
+        });
+        Assert.equal(client.keepBelow, testCase.keepBelow, assertOptions);
+        Assert.equal(client.keepAbove, testCase.keepAbove, assertOptions);
+
+        client.unpin();
+        world.do((clientManager, desktopManager) => {
+            Assert.assert(clientManager.findTiledWindow(client) === null, assertOptions);
+        });
+        Assert.equal(client.keepBelow, testCase.keepBelow, assertOptions);
+        Assert.equal(client.keepAbove, testCase.keepAbove, assertOptions);
+
+        qtMock.fireShortcut("karousel-window-toggle-floating");
+        world.do((clientManager, desktopManager) => {
+            Assert.assert(clientManager.findTiledWindow(client) !== null, assertOptions);
+        });
+        Assert.equal(client.keepBelow, testCase.keepBelow, assertOptions);
+        Assert.assert(!client.keepAbove, assertOptions);
+        client.keepAbove = testCase.keepAbove;
+
+        client.pin(pinGeometry);
+        world.do((clientManager, desktopManager) => {
+            Assert.assert(clientManager.findTiledWindow(client) === null, assertOptions);
+        });
+        Assert.equal(client.keepBelow, testCase.keepBelow, assertOptions);
+        Assert.equal(client.keepAbove, testCase.keepAbove, assertOptions);
+
+        qtMock.fireShortcut("karousel-window-toggle-floating");
+        world.do((clientManager, desktopManager) => {
+            Assert.assert(clientManager.findTiledWindow(client) !== null, assertOptions);
+        });
+        Assert.equal(client.keepBelow, testCase.keepBelow, assertOptions);
+        Assert.assert(!client.keepAbove, assertOptions);
+    }
+});

src/tests/flows/layout.ts

@@ -0,0 +1,98 @@
+tests.register("Focus and move windows", 1, () => {
+    const config = getDefaultConfig();
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const [client1, client2, client3] = workspaceMock.createClients(3);
+    world.do((clientManager, desktopManager) => {
+        Assert.assert(clientManager.hasClient(client1));
+        Assert.assert(clientManager.hasClient(client2));
+        Assert.assert(clientManager.hasClient(client3));
+    });
+    Assert.assert(workspaceMock.activeWindow === client3);
+
+    function testLayout(shortcutName: string, grid: KwinClient[][]) {
+        qtMock.fireShortcut(shortcutName);
+        Assert.grid(config, tilingArea, 100, grid, true, [], { skip: 1 });
+    }
+
+    function testFocus(shortcutName: string, expectedFocus: KwinClient) {
+        qtMock.fireShortcut(shortcutName);
+        Assert.assert(workspaceMock.activeWindow === expectedFocus, {
+            message: `wrong activeWindow: ${workspaceMock.activeWindow?.pid}`,
+            skip: 1,
+        });
+    };
+
+    testLayout("karousel-column-move-right",       [ [client1], [client2], [client3] ]);
+
+    testLayout("karousel-window-move-left",        [ [client1],    [client2,client3] ]);
+    testLayout("karousel-window-move-left",        [ [client1], [client3], [client2] ]);
+    testLayout("karousel-window-move-left",        [ [client1,client3],    [client2] ]);
+    testFocus("karousel-focus-right", client2);
+    testLayout("karousel-window-move-left",        [    [client1,client3,client2]    ]);
+    testLayout("karousel-window-move-left",        [ [client2],    [client1,client3] ]);
+    testLayout("karousel-window-move-left",        [ [client2],    [client1,client3] ]);
+    testFocus("karousel-focus-2", client3);
+    testFocus("karousel-focus-up", client1);
+    testLayout("karousel-column-move-left",        [ [client1,client3],    [client2] ]);
+    testLayout("karousel-window-move-right",       [ [client3], [client1], [client2] ]);
+
+    testFocus("karousel-focus-3", client2);
+    testLayout("karousel-window-move-start",       [ [client2], [client3], [client1] ]);
+    testLayout("karousel-window-move-to-column-3", [ [client3],    [client1,client2] ]);
+    testLayout("karousel-column-move-left",        [ [client1,client2],    [client3] ]);
+    testLayout("karousel-column-move-end",         [ [client3],    [client1,client2] ]);
+    testLayout("karousel-column-move-to-column-1", [ [client1,client2],    [client3] ]);
+    testLayout("karousel-column-move-right",       [ [client3],    [client1,client2] ]);
+
+    testLayout("karousel-window-move-previous",    [ [client3],    [client2,client1] ]);
+    testLayout("karousel-window-move-previous",    [ [client3], [client2], [client1] ]);
+    testLayout("karousel-window-move-previous",    [ [client3,client2],    [client1] ]);
+    testLayout("karousel-window-move-previous",    [ [client2,client3],    [client1] ]);
+    testLayout("karousel-window-move-previous",    [ [client2], [client3], [client1] ]);
+    testLayout("karousel-window-move-previous",    [ [client2], [client3], [client1] ]);
+    testLayout("karousel-window-move-next",        [ [client2,client3],    [client1] ]);
+    testLayout("karousel-window-move-next",        [ [client3,client2],    [client1] ]);
+    testLayout("karousel-window-move-next",        [ [client3], [client2], [client1] ]);
+    testLayout("karousel-window-move-next",        [ [client3],    [client2,client1] ]);
+    testLayout("karousel-window-move-next",        [ [client3],    [client1,client2] ]);
+    testLayout("karousel-window-move-next",        [ [client3], [client1], [client2] ]);
+    testLayout("karousel-window-move-next",        [ [client3], [client1], [client2] ]);
+    testLayout("karousel-window-move-left",        [ [client3],    [client1,client2] ]);
+
+    const col1Win1 = client3;
+    const col2Win1 = client1;
+    const col2Win2 = client2;
+
+    testFocus("karousel-focus-up", col2Win1);
+    testFocus("karousel-focus-up", col2Win1);
+    testFocus("karousel-focus-down", col2Win2);
+    testFocus("karousel-focus-left", col1Win1);
+    testFocus("karousel-focus-left", col1Win1);
+    testFocus("karousel-focus-right", col2Win2);
+    testFocus("karousel-focus-right", col2Win2);
+
+    testFocus("karousel-focus-2", col2Win2);
+    testFocus("karousel-focus-1", col1Win1);
+    testFocus("karousel-focus-2", col2Win2);
+    testFocus("karousel-focus-start", col1Win1);
+    testFocus("karousel-focus-end", col2Win2);
+
+    testFocus("karousel-focus-up", col2Win1);
+    testFocus("karousel-focus-left", col1Win1);
+    testFocus("karousel-focus-right", col2Win1);
+    testFocus("karousel-focus-2", col2Win1);
+    testFocus("karousel-focus-1", col1Win1);
+    testFocus("karousel-focus-2", col2Win1);
+    testFocus("karousel-focus-start", col1Win1);
+    testFocus("karousel-focus-end", col2Win1);
+
+    testFocus("karousel-focus-down", col2Win2);
+    testFocus("karousel-focus-start", col1Win1);
+    testFocus("karousel-focus-next", col2Win1);
+    testFocus("karousel-focus-next", col2Win2);
+    testFocus("karousel-focus-next", col2Win2);
+    testFocus("karousel-focus-previous", col2Win1);
+    testFocus("karousel-focus-previous", col1Win1);
+    testFocus("karousel-focus-previous", col1Win1);
+});

src/tests/flows/lazyScroller.ts

@@ -0,0 +1,47 @@
+tests.register("LazyScroller", 20, () => {
+    const config = getDefaultConfig();
+    config.scrollingLazy = true;
+    config.scrollingCentered = false;
+    config.scrollingGrouped = false;
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const [client1] = workspaceMock.createClientsWithWidths(300);
+    Assert.grid(config, tilingArea, 300, [[client1]], true);
+
+    const [client2] = workspaceMock.createClientsWithWidths(300);
+    Assert.grid(config, tilingArea, 300, [[client1], [client2]], true);
+
+    const [client3] = workspaceMock.createClientsWithWidths(300);
+    Assert.grid(config, tilingArea, 300, [[client1], [client2], [client3]], false);
+    Assert.equal(client3.frameGeometry.right, tilingArea.right);
+
+    runOneOf(
+        () => { workspaceMock.activeWindow = client2; },
+        () => { qtMock.fireShortcut("karousel-focus-2"); },
+        () => { qtMock.fireShortcut("karousel-focus-left"); },
+    );
+    Assert.grid(config, tilingArea, 300, [[client1], [client2], [client3]], false);
+    Assert.equal(client3.frameGeometry.right, tilingArea.right);
+
+    runOneOf(
+        () => { workspaceMock.activeWindow = client1; },
+        () => { qtMock.fireShortcut("karousel-focus-1"); },
+        () => { qtMock.fireShortcut("karousel-focus-left"); },
+        () => { qtMock.fireShortcut("karousel-focus-start"); },
+    );
+    workspaceMock.activeWindow = client1;
+    Assert.grid(config, tilingArea, 300, [[client1], [client2], [client3]], false);
+    Assert.equal(client1.frameGeometry.left, tilingArea.left);
+
+    qtMock.fireShortcut("karousel-grid-scroll-focused");
+    Assert.grid(config, tilingArea, 300, [[client1], [client2], [client3]], false);
+    Assert.grid(config, tilingArea, 300, [[client1]], true);
+
+    runOneOf(
+        () => { workspaceMock.activeWindow = client2; },
+        () => { qtMock.fireShortcut("karousel-focus-2"); },
+        () => { qtMock.fireShortcut("karousel-focus-right"); },
+    );
+    Assert.grid(config, tilingArea, 300, [[client1], [client2], [client3]], false);
+    Assert.equal(client1.frameGeometry.left, tilingArea.left);
+});

src/tests/flows/maximization.ts

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

src/tests/flows/passFocus.ts

@@ -0,0 +1,37 @@
+tests.register("Pass focus", 100, () => {
+    const config = getDefaultConfig();
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const [client0, client1a, client1b, client1c, client4, client5, client6] = workspaceMock.createClients(7);
+    workspaceMock.activeWindow = client1b;
+    qtMock.fireShortcut("karousel-window-move-left");
+    workspaceMock.activeWindow = client1c;
+    qtMock.fireShortcut("karousel-window-move-left");
+    workspaceMock.activeWindow = client1b;
+    workspaceMock.activeWindow = client5;
+
+    function removeWindow(client: MockKwinClient) {
+        runOneOf(
+            () => workspaceMock.removeWindow(client),
+            () => client.desktops = [workspaceMock.desktops[1]],
+        );
+    }
+
+    removeWindow(client5);
+    Assert.equal(workspaceMock.activeWindow, client4);
+
+    qtMock.fireShortcut("karousel-column-move-to-desktop-2");
+    Assert.equal(workspaceMock.activeWindow, client1b);
+
+    removeWindow(client1b);
+    Assert.equal(workspaceMock.activeWindow, client1a);
+
+    removeWindow(client1a);
+    Assert.equal(workspaceMock.activeWindow, client1c);
+
+    removeWindow(client1c);
+    Assert.equal(workspaceMock.activeWindow, client0);
+
+    removeWindow(client0);
+    Assert.equal(workspaceMock.activeWindow, client6);
+});

src/tests/flows/pinning.ts

@@ -0,0 +1,52 @@
+tests.register("Pin", 20, () => {
+    const config = getDefaultConfig();
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const screenHalfLeft = new MockQmlRect(0, 0, screen.width/2, screen.height);
+    const screenHalfRight = new MockQmlRect(screen.width/2, 0, screen.width/2, screen.height);
+
+    const tilingAreaHalfLeft = new MockQmlRect(
+        tilingArea.x,
+        tilingArea.y,
+        screen.width/2 - config.gapsOuterLeft - config.gapsOuterRight,
+        tilingArea.height,
+    );
+    const tilingAreaHalfRight = new MockQmlRect(
+        screen.width/2 + config.gapsOuterLeft,
+        tilingArea.y,
+        screen.width/2 - config.gapsOuterLeft - config.gapsOuterRight,
+        tilingArea.height,
+    );
+
+    const [pinned, tiled1, tiled2] = workspaceMock.createClients(3);
+    Assert.grid(config, tilingArea, 100, [ [pinned], [tiled1], [tiled2] ], true);
+
+    pinned.pin(screenHalfLeft);
+    Assert.equalRects(pinned.frameGeometry, screenHalfLeft);
+    Assert.grid(config, tilingAreaHalfRight, 100, [ [tiled1], [tiled2] ], true);
+
+    pinned.pin(screenHalfRight);
+    Assert.equalRects(pinned.frameGeometry, screenHalfRight);
+    Assert.grid(config, tilingAreaHalfLeft, 100, [ [tiled1], [tiled2] ], true);
+
+    pinned.unpin();
+    Assert.equalRects(pinned.frameGeometry, screenHalfRight);
+    Assert.grid(config, tilingArea, 100, [ [tiled1], [tiled2] ], true);
+
+    pinned.pin(screenHalfRight);
+    Assert.equalRects(pinned.frameGeometry, screenHalfRight);
+    Assert.grid(config, tilingAreaHalfLeft, 100, [ [tiled1], [tiled2] ], true);
+
+    pinned.minimized = true;
+    Assert.grid(config, tilingArea, 100, [ [tiled1], [tiled2] ], true);
+
+    pinned.minimized = false;
+    Assert.equalRects(pinned.frameGeometry, screenHalfRight);
+    Assert.grid(config, tilingAreaHalfLeft, 100, [ [tiled1], [tiled2] ], true);
+
+    workspaceMock.activeWindow = pinned;
+    qtMock.fireShortcut("karousel-window-toggle-floating");
+    Assert.assert(pinned.tile === null);
+    pinned.frameGeometry = new MockQmlRect(10, 20, 100, 200); // This is needed because the window's preferredWidth can change when pinning, because frameGeometryChanged can fire before tileChanged. TODO: Ensure pinned window keeps its preferredWidth.
+    Assert.grid(config, tilingArea, 100, [ [tiled1], [tiled2], [pinned] ], true);
+});

src/tests/flows/presetWidths.ts

@@ -0,0 +1,134 @@
+tests.register("Preset Widths default", 1, () => {
+    const config = getDefaultConfig();
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const maxWidth = tilingArea.width;
+    const halfWidth = maxWidth/2 - config.gapsInnerHorizontal/2;
+
+    function getRect(columnWidth: number) {
+        return new MockQmlRect(
+            tilingArea.left + (tilingArea.width - columnWidth) / 2,
+            tilingArea.top,
+            columnWidth,
+            tilingArea.height,
+        );
+    }
+
+    const [kwinClient] = workspaceMock.createClientsWithWidths(300);
+    Assert.equalRects(kwinClient.frameGeometry, getRect(300));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(halfWidth));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(maxWidth));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(halfWidth));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths-reverse");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(maxWidth));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths-reverse");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(halfWidth));
+});
+
+tests.register("Preset Widths custom", 1, () => {
+    const config = getDefaultConfig();
+    config.presetWidths = "500px, 250px, 100px, 50%";
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const maxWidth = tilingArea.width;
+    const halfWidth = maxWidth/2 - config.gapsInnerHorizontal/2;
+
+    function getRect(columnWidth: number) {
+        return new MockQmlRect(
+            tilingArea.left + (tilingArea.width - columnWidth) / 2,
+            tilingArea.top,
+            columnWidth,
+            tilingArea.height,
+        );
+    }
+
+    const [kwinClient] = workspaceMock.createClientsWithWidths(200);
+    Assert.equalRects(kwinClient.frameGeometry, getRect(200));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(250));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(halfWidth));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(500));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(100));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(250));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths-reverse");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(100));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths-reverse");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(500));
+
+    qtMock.fireShortcut("karousel-cycle-preset-widths-reverse");
+    Assert.equalRects(kwinClient.frameGeometry, getRect(halfWidth));
+});
+
+tests.register("Preset Widths fill screen uniform", 1, () => {
+    for (let nColumns = 1; nColumns < 10; nColumns++) {
+        const config = getDefaultConfig();
+        config.presetWidths = String(1 / nColumns);
+        const { qtMock, workspaceMock, world } = init(config);
+
+        let firstClient, lastClient;
+        for (let i = 0; i < nColumns; i++) {
+            const [kwinClient] = workspaceMock.createClientsWithWidths(300);
+            if (i === 0) {
+                firstClient = kwinClient;
+            }
+            if (i === nColumns-1) {
+                lastClient = kwinClient;
+            }
+            qtMock.fireShortcut("karousel-cycle-preset-widths");
+        }
+
+        const left = tilingArea.left;
+        const right = tilingArea.right;
+        const maxLeftoverPx = nColumns - 1;
+        const eps = Math.ceil(maxLeftoverPx / 2);
+        Assert.between(firstClient!.frameGeometry.left, left, left+eps, { message: `nColumns: ${nColumns}` });
+        Assert.between(lastClient!.frameGeometry.right, right-eps, right, { message: `nColumns: ${nColumns}` });
+    }
+});
+
+tests.register("Preset Widths fill screen non-uniform", 1, () => {
+    const config = getDefaultConfig();
+    config.presetWidths = String("50%, 25%");
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const [clientThin1] = workspaceMock.createClientsWithWidths(100);
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+
+    const [clientThin2] = workspaceMock.createClientsWithWidths(100);
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+
+    const [clientWide] = workspaceMock.createClientsWithWidths(300);
+    qtMock.fireShortcut("karousel-cycle-preset-widths");
+
+    const maxWidth = tilingArea.width;
+    const halfWidth = maxWidth/2 - config.gapsInnerHorizontal/2;
+    const quarterWidth = halfWidth/2 - config.gapsInnerHorizontal/2;
+    const height = tilingArea.height;
+    const left1 = tilingArea.left;
+    const left2 = left1 + config.gapsInnerHorizontal + quarterWidth;
+    const left3 = left2 + config.gapsInnerHorizontal + quarterWidth;
+
+    Assert.rect(clientThin1.frameGeometry, left1, tilingArea.top, quarterWidth, height);
+    Assert.rect(clientThin2.frameGeometry, left2, tilingArea.top, quarterWidth, height);
+    Assert.rect(clientWide.frameGeometry, left3, tilingArea.top, halfWidth, height);
+    Assert.equal(clientWide.frameGeometry.right, tilingArea.right);
+});

src/tests/flows/stacked.ts

@@ -0,0 +1,30 @@
+tests.register("Stacked", 5, () => {
+    const config = getDefaultConfig();
+    const { qtMock, workspaceMock, world } = init(config);
+
+    const [leftTop, leftBottom, rightTop, rightBottom] = workspaceMock.createClients(4);
+    const grid = [[leftTop, leftBottom], [rightTop, rightBottom]];
+    workspaceMock.activeWindow = rightBottom;
+    qtMock.fireShortcut("karousel-window-move-left");
+    workspaceMock.activeWindow = leftBottom;
+    qtMock.fireShortcut("karousel-window-move-left");
+    Assert.grid(config, tilingArea, 100, grid, true);
+
+    qtMock.fireShortcut("karousel-column-toggle-stacked");
+    Assert.grid(config, tilingArea, 100, grid, true, [0]);
+
+    qtMock.fireShortcut("karousel-focus-up");
+    Assert.grid(config, tilingArea, 100, grid, true, [0]);
+
+    qtMock.fireShortcut("karousel-focus-down");
+    Assert.grid(config, tilingArea, 100, grid, true, [0]);
+
+    qtMock.fireShortcut("karousel-window-move-up");
+    Assert.grid(config, tilingArea, 100, [[leftBottom, leftTop], [rightTop, rightBottom]], true, [0]);
+
+    qtMock.fireShortcut("karousel-window-move-down");
+    Assert.grid(config, tilingArea, 100, grid, true, [0]);
+
+    qtMock.fireShortcut("karousel-column-toggle-stacked");
+    Assert.grid(config, tilingArea, 100, grid, true);
+});

src/tests/flows/userResize.ts

@@ -0,0 +1,110 @@
+tests.register("User resize", 10, () => {
+    const config = getDefaultConfig();
+    config.resizeNeighborColumn = true;
+
+    const h = getWindowHeight(2);
+    let clientLeft: MockKwinClient, clientRightTop: MockKwinClient, clientRightBottom: MockKwinClient;
+    function assertSizes(leftWidth: number, rightWidth: number, topHeight: number, bottomHeight: number) {
+        const { left, right } = getGridBounds(clientLeft, clientRightTop);
+        Assert.rect(clientLeft.frameGeometry, left, tilingArea.top, leftWidth, tilingArea.height);
+        Assert.rect(clientRightTop.frameGeometry, left+leftWidth+gapH, tilingArea.top, rightWidth, topHeight);
+        Assert.rect(clientRightBottom.frameGeometry, left+leftWidth+gapH, tilingArea.top+topHeight+gapV, rightWidth, bottomHeight);
+    }
+
+    {
+        const { qtMock, workspaceMock, world } = init(config);
+        [clientLeft, clientRightTop, clientRightBottom] = workspaceMock.createClientsWithWidths(300, 300, 200);
+        qtMock.fireShortcut("karousel-window-move-left");
+        assertSizes(300, 300, h, h);
+
+        workspaceMock.resizeWindow(clientLeft, false, false, false, new MockQmlSize(10, 20));
+        assertSizes(310, 300, h, h);
+
+        workspaceMock.resizeWindow(clientLeft, true, false, false, new MockQmlSize(10, 0), new MockQmlSize(-10, 0));
+        assertSizes(310, 300, h, h);
+
+        workspaceMock.resizeWindow(clientRightTop, false, false, false, new MockQmlSize(-5, -10), new MockQmlSize(-5, -10));
+        assertSizes(310, 290, h-20, h+20);
+
+        workspaceMock.resizeWindow(clientRightBottom, false, false, false, new MockQmlSize(-10, 20));
+        assertSizes(310, 280, h-20, h+20);
+
+        workspaceMock.resizeWindow(clientRightBottom, false, false, true, new MockQmlSize(0, 20));
+        assertSizes(310, 280, h-40, h+40);
+    }
+
+    {
+        const { qtMock, workspaceMock, world } = init(config);
+        [clientLeft, clientRightTop, clientRightBottom] = workspaceMock.createClientsWithWidths(300, 300, 200);
+        qtMock.fireShortcut("karousel-window-move-left");
+        assertSizes(300, 300, h, h);
+
+        workspaceMock.resizeWindow(clientLeft, true, false, false, new MockQmlSize(10, 20));
+        assertSizes(310, 290, h, h);
+
+        workspaceMock.resizeWindow(clientLeft, true, false, false, new MockQmlSize(10, 0), new MockQmlSize(-10, 0));
+        assertSizes(310, 290, h, h);
+
+        workspaceMock.resizeWindow(clientRightTop, true, false, false, new MockQmlSize(-5, -10), new MockQmlSize(-5, -10));
+        assertSizes(310, 280, h-20, h+20);
+
+        workspaceMock.resizeWindow(clientRightBottom, true, true, false, new MockQmlSize(-10, 20));
+        assertSizes(320, 270, h-20, h+20);
+
+        workspaceMock.resizeWindow(clientRightBottom, true, false, true, new MockQmlSize(0, 20));
+        assertSizes(320, 270, h-40, h+40);
+    }
+
+    {
+        const { qtMock, workspaceMock, world } = init(config);
+        [clientLeft, clientRightTop, clientRightBottom] = workspaceMock.createClientsWithWidths(300, 300, 200);
+        clientRightBottom.minSize = new MockQmlSize(295, h-20);
+        qtMock.fireShortcut("karousel-window-move-left");
+        assertSizes(300, 300, h, h);
+
+        workspaceMock.resizeWindow(clientLeft, true, false, false, new MockQmlSize(10, 20));
+        assertSizes(310, 295, h, h);
+
+        workspaceMock.resizeWindow(clientLeft, true, false, false, new MockQmlSize(10, 0), new MockQmlSize(-10, 0));
+        assertSizes(310, 295, h, h);
+
+        workspaceMock.resizeWindow(clientRightTop, true, false, false, new MockQmlSize(-5, -10), new MockQmlSize(-5, -10));
+        assertSizes(310, 295, h-20, h+20);
+
+        workspaceMock.resizeWindow(clientRightBottom, true, true, false, new MockQmlSize(-10, 20));
+        assertSizes(310, 295, h-20, h+20);
+
+        workspaceMock.resizeWindow(clientRightTop, true, true, false, new MockQmlSize(-10, 0));
+        assertSizes(310, 295, h-20, h+20);
+
+        // TODO
+        // workspaceMock.resizeWindow(clientRightBottom, true, false, true, new MockQmlSize(0, -80));
+        // assertSizes(310, 295, h+60, h-20);
+    }
+
+    {
+        const { qtMock, workspaceMock, world } = init(config);
+        const [clientLeftTop, clientLeftBottom, clientRight] = workspaceMock.createClientsWithWidths(300, 200, 300);
+        clientLeftBottom.minSize = new MockQmlSize(295, h-20);
+
+        function assertSizes(leftWidth: number, rightWidth: number, topHeight: number, bottomHeight: number) {
+            const { left, right } = getGridBounds(clientLeftTop, clientRight);
+            Assert.rect(clientLeftTop.frameGeometry, left, tilingArea.top, leftWidth, topHeight);
+            Assert.rect(clientLeftBottom.frameGeometry, left, tilingArea.top+topHeight+gapV, leftWidth, bottomHeight);
+            Assert.rect(clientRight.frameGeometry, left+leftWidth+gapH, tilingArea.top, rightWidth, tilingArea.height);
+        }
+
+        workspaceMock.activeWindow = clientLeftBottom;
+        qtMock.fireShortcut("karousel-window-move-left");
+        assertSizes(300, 300, h, h);
+
+        workspaceMock.resizeWindow(clientLeftTop, true, false, false, new MockQmlSize(-10, 0));
+        assertSizes(295, 305, h, h);
+
+        workspaceMock.resizeWindow(clientLeftTop, true, false, false, new MockQmlSize(10, 0));
+        assertSizes(305, 295, h, h);
+
+        workspaceMock.resizeWindow(clientLeftTop, true, false, false, new MockQmlSize(-20, 0), new MockQmlSize(20, 0));
+        assertSizes(305, 295, h, h);
+    }
+});

src/tests/main.ts

@@ -0,0 +1 @@
+tests.run();

src/tests/rules/WindowRuleEnforcer.ts

@@ -1,36 +0,0 @@
-{
-    const testCases = [
-        {tiledByDefault: true, resourceClass: "unknown", caption: "anything", shouldTile: true},
-        {tiledByDefault: false, resourceClass: "unknown", caption: "anything", shouldTile: false},
-        {tiledByDefault: true, resourceClass: "ksmserver-logout-greeter", caption: "anything", shouldTile: false},
-        {tiledByDefault: true, resourceClass: "org.kde.plasmashell", caption: "something", shouldTile: false},
-        {tiledByDefault: true, resourceClass: "plasmashell", caption: "something", shouldTile: false},
-        {tiledByDefault: false, resourceClass: "org.kde.kfind", caption: "something", shouldTile: true},
-        {tiledByDefault: false, resourceClass: "kfind", caption: "something", shouldTile: true},
-        {tiledByDefault: true, resourceClass: "zoom", caption: "something", shouldTile: true},
-        {tiledByDefault: true, resourceClass: "zoom", caption: "zoom", shouldTile: false},
-    ];
-
-    const enforcer = new WindowRuleEnforcer(JSON.parse(defaultWindowRules));
-    for (const testCase of testCases) {
-        const kwinClient: any = createKwinClient(testCase.tiledByDefault, testCase.resourceClass, testCase.caption);
-        assert(enforcer.shouldTile(kwinClient) === testCase.shouldTile, "failed case: " + JSON.stringify(testCase));
-    }
-
-    function createKwinClient(normalWindow: boolean, resoureClass: string, caption: string) {
-        return {
-            normalWindow: normalWindow,
-            transient: false,
-            managed: true,
-            pid: 100,
-            moveable: true,
-            resizeable: true,
-            popupWindow: false,
-            minimized: false,
-            desktops: [1],
-            activities: [1],
-            resourceClass: resoureClass,
-            caption: caption,
-        }
-    }
-}

src/tests/tests.ts

@@ -1,17 +0,0 @@
-declare const process: {
-    exit(code?: number): void,
-};
-
-function assert(assertion: boolean, message?: string) {
-    if (assertion) {
-        return;
-    }
-
-    if (message != undefined) {
-        console.assert(assertion, message);
-    } else {
-        console.assert(assertion);
-    }
-    console.trace();
-    process.exit(1);
-}

src/tests/tsconfig.json

@@ -1,4 +1,10 @@
 {
     "extends": "../tsconfig.json",
-    "include": ["../lib/**/*", "./**/*"]
+    "include": [
+        "../lib/**/*",
+        "./utils/**/*",
+        "./units/**/*",
+        "./flows/**/*",
+        "./main.ts"
+    ]
 }

src/tests/units/behavior/PresetWidths.ts

@@ -0,0 +1,45 @@
+tests.register("PresetWidths", 1, () => {
+    const minWidth = 50;
+    const maxWidth = 800;
+    const spacing = 10;
+
+    const testCases = [
+        { str: "100%, 50%", result: [395, 800] },
+        { str: "105%, 50%", result: [395, 800] },
+        { str: "100px,50 px", result: [50, 100] },
+        { str: "900px,25 px", result: [50, 800] },
+        { str: " 100px, 25 % , 0.1 ", result: [71, 100, 192] },
+        { str: "100px, 25%, 0.1, 100px", result: [71, 100, 192] },
+        { str: "100px, -25 % , 0.1 ", error: true },
+        { str: "100px, 25 % , -0.1 ", error: true },
+        { str: "100px, 25 % , 0.1p", error: true },
+        { str: "100px, % , 0.1 ", error: true },
+        { str: "100px,  , 0.1 ", error: true },
+        { str: "100px, 0, 0.1 ", error: true },
+        { str: "100px,, 0.1 ", error: true },
+        { str: "100px, 25 % , ", error: true },
+        { str: "asdf", error: true },
+        { str: "", error: true },
+        { str: " ", error: true },
+    ];
+
+    function assertWidths(presetWidths: PresetWidths, expectedWidths: number[]) {
+        let currentWidth = 0;
+        for (const expectedWidth of expectedWidths) {
+            currentWidth = presetWidths.next(currentWidth, minWidth, maxWidth);
+            Assert.equal(currentWidth, expectedWidth);
+        }
+        const repeatedWidth = presetWidths.next(currentWidth, minWidth, maxWidth);
+        Assert.equal(repeatedWidth, expectedWidths[0]);
+    }
+
+    for (const testCase of testCases) {
+        try {
+            const presetWidths = new PresetWidths(testCase.str, spacing);
+            Assert.assert(!testCase.error);
+            assertWidths(presetWidths, testCase.result!);
+        } catch (error) {
+            Assert.assert(testCase.error === true);
+        }
+    }
+});

src/tests/units/rules/WindowRuleEnforcer.ts

@@ -0,0 +1,44 @@
+tests.register("WindowRuleEnforcer", 1, () => {
+    screen = new MockQmlRect(0, 0, 800, 600);
+    Workspace = new MockWorkspace();
+
+    const testCases = [
+        { tiledByDefault: true, resourceClass: "unknown", caption: "anything", shouldTile: true },
+        { tiledByDefault: false, resourceClass: "unknown", caption: "anything", shouldTile: false },
+        { tiledByDefault: true, resourceClass: "org.kde.plasmashell", caption: "something", shouldTile: false },
+        { tiledByDefault: true, resourceClass: "plasmashell", caption: "something", shouldTile: false },
+        { tiledByDefault: false, resourceClass: "org.kde.kfind", caption: "something", shouldTile: true },
+        { tiledByDefault: false, resourceClass: "kfind", caption: "something", shouldTile: true },
+        { tiledByDefault: true, resourceClass: "org.kde.kruler", caption: "anything", shouldTile: false },
+        { tiledByDefault: true, resourceClass: "kruler", caption: "anything", shouldTile: false },
+        { tiledByDefault: true, resourceClass: "zoom", caption: "something", shouldTile: true },
+        { tiledByDefault: true, resourceClass: "zoom", caption: "zoom", shouldTile: false },
+    ];
+
+    const enforcer = new WindowRuleEnforcer(JSON.parse(defaultWindowRules));
+    for (const testCase of testCases) {
+        const kwinClient: any = createKwinClient(testCase.tiledByDefault, testCase.resourceClass, testCase.caption);
+        Assert.assert(
+            enforcer.shouldTile(kwinClient) === testCase.shouldTile,
+            { message: "failed case: " + JSON.stringify(testCase) },
+        );
+    }
+
+    function createKwinClient(normalWindow: boolean, resourceClass: string, caption: string) {
+        return {
+            normalWindow: normalWindow,
+            transient: false,
+            clientGeometry: new MockQmlRect(0, 0, 200, 200),
+            managed: true,
+            pid: 100,
+            moveable: true,
+            resizeable: true,
+            popupWindow: false,
+            minimized: false,
+            desktops: [1],
+            activities: [1],
+            resourceClass: resourceClass,
+            caption: caption,
+        };
+    }
+});

src/tests/units/utils/RateLimiter.ts

@@ -0,0 +1,22 @@
+tests.register("RateLimiter", 1, () => {
+    const rateLimiter = new RateLimiter(3, 100);
+
+    function testRateLimiter() {
+        Assert.assert(rateLimiter.acquire());
+        Assert.assert(rateLimiter.acquire());
+        Assert.assert(rateLimiter.acquire());
+        Assert.assert(!rateLimiter.acquire());
+        Assert.assert(!rateLimiter.acquire());
+    }
+
+    timeControl(addTime => {
+        testRateLimiter();
+
+        addTime(10);
+        Assert.assert(!rateLimiter.acquire(), { message: "The interval hasn't expired yet" });
+
+        addTime(90);
+        // the rate limiter interval has expired, let's test again
+        testRateLimiter();
+    });
+});

src/tests/units/utils/fillSpace.ts

@@ -0,0 +1,246 @@
+tests.register("fillSpace", 1, () => {
+    const testCases: {
+        availableSpace: number,
+        items: { min: number, max: number }[],
+        expected: number[],
+    }[] = [
+        {
+            availableSpace: 600,
+            items: [],
+            expected: [],
+        },
+        {
+            availableSpace: 600,
+            items: [
+                { min: 10, max: 600 },
+                { min: 10, max: 600 },
+            ],
+            expected: [300, 300],
+        },
+        {
+            availableSpace: 700,
+            items: [
+                { min: 300, max: 300 },
+                { min: 300, max: 300 },
+            ],
+            expected: [300, 300],
+        },
+        {
+            availableSpace: 700,
+            items: [
+                { min: 300, max: 300 },
+                { min: 300, max: 300 },
+                { min: 10,  max: 900 },
+            ],
+            expected: [300, 300, 100],
+        },
+        {
+            availableSpace: 600,
+            items: [
+                { min: 10, max: 250 },
+                { min: 10, max: 500 },
+            ],
+            expected: [250, 350],
+        },
+        {
+            availableSpace: 600,
+            items: [
+                { min: 10, max: 250 },
+                { min: 400, max: 500 },
+            ],
+            expected: [200, 400],
+        },
+        {
+            availableSpace: 765,
+            items: [
+                { min: 10, max: 250 },
+                { min: 10, max: 254 },
+                { min: 10, max: 500 },
+            ],
+            expected: [250, 254, 261],
+        },
+        {
+            availableSpace: 600,
+            items: [
+                { min: 10, max: 150 },
+                { min: 400, max: 500 },
+            ],
+            expected: [150, 450],
+        },
+        {
+            availableSpace: 750,
+            items: [
+                { min: 10, max: 250 },
+                { min: 10, max: 250 },
+                { min: 400, max: 500 },
+                { min: 10, max: 300 },
+            ],
+            expected: [117, 117, 400, 116],
+        },
+        {
+            availableSpace: 750,
+            items: [
+                { min: 10, max: 250 },
+                { min: 120, max: 250 },
+                { min: 400, max: 500 },
+                { min: 10, max: 300 },
+            ],
+            expected: [115, 120, 400, 115],
+        },
+        {
+            availableSpace: 1200,
+            items: [
+                { min: 10, max: 250 },
+                { min: 10, max: 500 },
+            ],
+            expected: [250, 500],
+        },
+        {
+            availableSpace: 5,
+            items: [
+                { min: 10, max: 250 },
+                { min: 10, max: 500 },
+            ],
+            expected: [10, 10],
+        },
+        {
+            availableSpace: 800,
+            items: [
+                { min: 114, max: 800 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 109, max: 800 },
+                { min: 10, max: 800 },
+            ],
+            expected: [114, 93, 93, 93, 93, 93, 111, 110],
+        },
+        {
+            availableSpace: 801,
+            items: [
+                { min: 114, max: 800 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 109, max: 800 },
+                { min: 10, max: 800 },
+            ],
+            expected: [114, 93, 93, 93, 93, 93, 111, 111],
+        },
+        {
+            availableSpace: 801,
+            items: [
+                { min: 114, max: 800 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 109, max: 800 },
+                { min: 10, max: 95 },
+            ],
+            expected: [121, 93, 93, 93, 93, 93, 120, 95],
+        },
+        {
+            availableSpace: 799,
+            items: [
+                { min: 10, max: 86 },
+                { min: 107, max: 800 },
+                { min: 107, max: 800 },
+                { min: 107, max: 800 },
+                { min: 107, max: 800 },
+                { min: 107, max: 800 },
+                { min: 10, max: 91},
+                { min: 105, max: 800 },
+            ],
+            expected: [80, 107, 107, 107, 107, 107, 79, 105],
+        },
+        {
+            availableSpace: 1029,
+            items: [
+                { min: 114, max: 800 },
+                { min: 114, max: 800 },
+                { min: 114, max: 800 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 10, max: 93 },
+                { min: 109, max: 800 },
+                { min: 10, max: 800 },
+            ],
+            expected: [114, 114, 114, 93, 93, 93, 93, 93, 111, 111],
+        },
+        {
+            availableSpace: 602,
+            items: [
+                { min: 10, max: 600 },
+                { min: 10, max: 600 },
+                { min: 10, max: 600 },
+            ],
+            expected: [200, 200, 200],
+        },
+        {
+            availableSpace: 602,
+            items: [
+                { min: 204, max: 600 },
+                { min: 202, max: 600 },
+                { min: 10, max: 600 },
+            ],
+            expected: [204, 202, 196],
+        },
+        {
+            availableSpace: 803,
+            items: [
+                { min: 204, max: 600 },
+                { min: 10, max: 600 },
+                { min: 10, max: 600 },
+                { min: 10, max: 600 },
+            ],
+            expected: [204, 200, 200, 199],
+        },
+        {
+            availableSpace: 900,
+            items: [
+                { min: 10, max: 120 },
+                { min: 10, max: 250 },
+                { min: 500, max: 500 },
+                { min: 300, max: 500 },
+            ],
+            expected: [50, 50, 500, 300],
+        },
+        {
+            availableSpace: 845,
+            items: [
+                { min: 5, max: 5 },
+                { min: 10, max: 40 },
+                { min: 500, max: 500 },
+                { min: 300, max: 500 },
+            ],
+            expected: [5, 40, 500, 300],
+        },
+        {
+            availableSpace: 800,
+            items: [
+                { min: 10, max: 20 },
+                { min: 220, max: 221 },
+                { min: 250, max: 260 },
+                { min: 300, max: 305 },
+            ],
+            expected: [20, 221, 259, 300],
+        },
+    ];
+
+    for (const testCase of testCases) {
+        const result = fillSpace(testCase.availableSpace, testCase.items);
+        Assert.equalArrays(
+            result,
+            testCase.expected,
+            { message: JSON.stringify(testCase) },
+        );
+    }
+});

src/tests/units/utils/math.ts

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

src/tests/units/world/Clients.ts

@@ -0,0 +1,36 @@
+tests.register("Clients.canTileEver", 1, () => {
+    const testCases = [
+        { clientProperties: { resourceClass: "app", caption: "Title" }, tileable: true },
+        { clientProperties: { resourceClass: "app", caption: "Title", moveable: false }, tileable: false },
+        { clientProperties: { resourceClass: "app", caption: "Caption", resizeable: false }, tileable: false },
+        { clientProperties: { resourceClass: "app", caption: "Caption", normalWindow: false, popupWindow: true }, tileable: false },
+        { clientProperties: { resourceClass: "app", caption: "Caption", moveable: false, resizeable: false, fullScreen: true }, tileable: true },
+        { clientProperties: { resourceClass: "ksmserver-logout-greeter", caption: "Caption" }, tileable: false },
+        { clientProperties: { resourceClass: "xwaylandvideobridge", caption: "" }, tileable: false },
+    ];
+
+    for (const testCase of testCases) {
+        const kwinClient: any = createKwinClient(testCase.clientProperties);
+        Assert.assert(
+            Clients.canTileEver(kwinClient) === testCase.tileable,
+            { message: "failed case: " + JSON.stringify(testCase) },
+        );
+    }
+
+    function createKwinClient(properties: { resourceClass: string, caption: string }) {
+        const defaultProperties = {
+            normalWindow: true,
+            transient: false,
+            managed: true,
+            pid: 100,
+            moveable: true,
+            resizeable: true,
+            fullScreen: false,
+            popupWindow: false,
+            minimized: false,
+            desktops: [1],
+            activities: [1],
+        };
+        return { ...defaultProperties, ...properties };
+    }
+});

src/tests/utils/Assert.ts

@@ -0,0 +1,295 @@
+namespace Assert {
+    interface Options {
+        message?: string,
+        skip?: number,
+    }
+
+    export function assert(
+        assertion: boolean,
+        { message, skip=0 }: Options = {},
+    ) {
+        if (assertion) {
+            return;
+        }
+
+        if (message != undefined) {
+            console.assert(assertion, message);
+        } else {
+            console.assert(assertion);
+        }
+
+        console.log(getStackTrace(skip+1));
+
+        console.log("Random branches:");
+        if (runLog !== undefined) {
+            for (const message of runLog) {
+                console.log("    " + message);
+            }
+        }
+
+        process.exit(1);
+    }
+
+    function getStackTrace(skip: number) {
+        return new Error().stack!.split("\n").slice(skip+2).join("\n");
+    }
+
+    function appendMessage(base: string, message?: string) {
+        if (message === undefined) {
+            return base;
+        }
+        return `${base}
+    Message: ${message}`;
+    }
+
+    function buildMessage(actual: any, expected: any, header: string, message?: string) {
+        return appendMessage(
+            `${header}
+    Expected: ${expected}
+    Actual: ${actual}`,
+            message,
+        );
+    }
+
+    export function equal(
+        actual: any,
+        expected: any,
+        { message, skip=0 }: Options = {},
+    ) {
+        assert(
+            expected === actual,
+            {
+                message: buildMessage(actual, expected, "Values not equal", message),
+                skip: skip + 1,
+            },
+        );
+    }
+
+    export function equalArrays(
+        actual: any[],
+        expected: any[],
+        { message, skip=0 }: Options = {},
+    ) {
+        assert(
+            actual.length === expected.length && actual.every((item, index) => item === expected[index]),
+            {
+                message: buildMessage(actual, expected, "Arrays not equal", message),
+                skip: skip + 1,
+            },
+        );
+    }
+
+    export function between(
+        actual: any,
+        min: any,
+        max: any,
+        { message, skip=0 }: Options = {},
+    ) {
+        assert(
+            actual >= min && actual <= max,
+            {
+                message: buildMessage(actual, `[${min}, ${max}]`, "Value not in range", message),
+                skip: skip + 1,
+            },
+        );
+    }
+
+    export function equalRects(
+        actual: QmlRect,
+        expected: QmlRect,
+        { message, skip=0 }: Options = {},
+    ) {
+        assert(
+            rectEquals(expected, actual),
+            {
+                message: buildMessage(actual, expected, "QmlRect not equal", message),
+                skip: skip + 1,
+            },
+        );
+    }
+
+    export function rect(
+        actual: QmlRect,
+        x: number,
+        y: number,
+        width: number,
+        height: number,
+        { message, skip=0 }: Options = {},
+    ) {
+        equalRects(
+            actual,
+            new MockQmlRect(x, y, width, height),
+            { message: message, skip: skip+1 },
+        );
+    }
+
+    export function grid(
+        config: Config,
+        tilingArea: QmlRect,
+        columnWidths: number[] | number,
+        grid: KwinClient[][],
+        centered: boolean,
+        stackedColumns: number[] = [],
+        { message, skip=0 }: Options = {},
+    ) {
+        const nColumns = grid.length;
+        function getGridWidth() {
+            function getColumnsWidth() {
+                if (columnWidths instanceof Array) {
+                    let columnsWidth = 0;
+                    for (const columnWidth of columnWidths) {
+                        columnsWidth += columnWidth;
+                    }
+                    return columnsWidth;
+                } else {
+                    return nColumns * columnWidths;
+                }
+            }
+
+            const gapsWidth = (nColumns-1) * config.gapsInnerHorizontal;
+            return getColumnsWidth() + gapsWidth;
+        }
+
+        function getColumnWidth(column: number) {
+            if (columnWidths instanceof Array) {
+                return columnWidths[column];
+            } else {
+                return columnWidths;
+            }
+        }
+
+        const gridWidth = getGridWidth();
+        const startX = centered ?
+            tilingArea.x + (tilingArea.width - gridWidth) / 2 :
+            grid[0][0].frameGeometry.x;
+
+        function getColumnX(column: number) {
+            if (columnWidths instanceof Array) {
+                let x = startX;
+                for (let i = 0; i < column; i++) {
+                    x += columnWidths[i] + config.gapsInnerHorizontal;
+                }
+                return x;
+            } else {
+                return startX + column * (columnWidths + config.gapsInnerHorizontal);
+            }
+        }
+
+        // assumes uniformly sized windows within columns of uniform width
+        function getRectInGrid(column: number, window: number, nColumns: number, nWindows: number) {
+            const columnWidth = getColumnWidth(column);
+            const windowHeight = (tilingArea.height - config.gapsInnerVertical * (nWindows-1)) / nWindows;
+            return new MockQmlRect(
+                getColumnX(column),
+                tilingArea.y + (windowHeight + config.gapsInnerVertical) * window,
+                columnWidth,
+                (tilingArea.height - config.gapsInnerVertical * (nWindows-1)) / nWindows,
+            );
+        }
+
+        function getRectInGridStacked(column: number, window: number, nColumns: number, nWindows: number) {
+            const columnWidth = getColumnWidth(column);
+            return new MockQmlRect(
+                getColumnX(column) + window * config.stackOffsetX,
+                tilingArea.y + window * config.stackOffsetY,
+                columnWidth - (nWindows-1) * config.stackOffsetX,
+                tilingArea.height - (nWindows-1) * config.stackOffsetY,
+            );
+        }
+
+        for (let iColumn = 0; iColumn < nColumns; iColumn++) {
+            const column = grid[iColumn];
+            const stacked = stackedColumns.includes(iColumn);
+            const getRect = stacked ? getRectInGridStacked : getRectInGrid;
+            const nWindows = column.length;
+            for (let iWindow = 0; iWindow < nWindows; iWindow++) {
+                const window = column[iWindow];
+                equalRects(
+                    window.frameGeometry,
+                    getRect(iColumn, iWindow, nColumns, nWindows),
+                    { message: appendMessage(`column ${iColumn}, window ${iWindow}`, message), skip: skip+1 },
+                );
+            }
+        }
+    }
+
+    export function centered(
+        config: Config,
+        tilingArea: QmlRect,
+        client:KwinClient,
+        { message, skip=0 }: Options = {},
+    ) {
+        grid(
+            config,
+            tilingArea,
+            client.frameGeometry.width,
+            [[client]],
+            true,
+            [],
+            { message: appendMessage("Window not centered", message), skip: skip+1 },
+        );
+    }
+
+    export function fullyVisible(
+        rect: QmlRect,
+        { message, skip=0 }: Options = {},
+    ) {
+        assert(
+            rect.left >= tilingArea.left && rect.right <= tilingArea.right,
+            {
+                message: appendMessage(`Rect ${rect} not fully visible`, message),
+                skip: skip + 1,
+            },
+        );
+    }
+
+    export function notFullyVisible(
+        rect: QmlRect,
+        { message, skip=0 }: Options = {},
+    ) {
+        assert(
+            rect.left < tilingArea.left || rect.right > tilingArea.right,
+            {
+                message: appendMessage(`Rect ${rect} is fully visible, but shouldn't be`, message),
+                skip: skip + 1,
+            },
+        );
+    }
+
+    export function columnsFillTilingArea(
+        columns: KwinClient[],
+        { message, skip=0 }: Options = {},
+    ) {
+        const options = { message: message, skip: skip+1 };
+        let x = tilingArea.left;
+        for (const column of columns) {
+            const width = column.frameGeometry.width;
+            fullyVisible(column.frameGeometry, options);
+            rect(column.frameGeometry, x, tilingArea.top, width, tilingArea.height, options);
+            x += width + gapH;
+        }
+        equal(columns[columns.length-1].frameGeometry.right, tilingArea.right, options);
+    }
+
+    export function tiledClient(
+        clientManager: ClientManager,
+        client: KwinClient,
+        { message, skip=0 }: Options = {},
+    ) {
+        assert(
+            clientManager.findTiledWindow(client) !== null,
+            { message: message, skip: skip+1 },
+        );
+    }
+
+    export function notTiledClient(
+        clientManager: ClientManager,
+        client: KwinClient,
+        { message, skip=0 }: Options = {},
+    ) {
+        assert(
+            clientManager.findTiledWindow(client) === null,
+            { message: message, skip: skip+1 },
+        );
+    }
+}

src/tests/utils/TestRunner.ts

@@ -0,0 +1,26 @@
+class TestRunner {
+    private readonly tests: TestRunner.Test[] = [];
+
+    public register(name: string, count: number, f: () => void) {
+        this.tests.push({ name: name, count: count, f: f });
+    }
+
+    public run() {
+        for (const test of this.tests) {
+            console.log("Running test " + test.name);
+            for (let i = 0; i < test.count; i++) {
+                test.f();
+            }
+        }
+    }
+}
+
+namespace TestRunner {
+    export interface Test {
+        name: string,
+        count: number,
+        f: () => void,
+    }
+}
+
+const tests = new TestRunner();

src/tests/utils/config.ts

@@ -0,0 +1,7 @@
+function getDefaultConfig(): Config {
+    const config: any = {};
+    for (const prop of configDef) {
+        config[prop.name] = prop.default;
+    }
+    return config;
+}