bump package to 0.7.2

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

@@ -1,19 +0,0 @@
----
-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

@@ -1,14 +0,0 @@
----
-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

@@ -1,22 +0,0 @@
----
-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

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

Makefile

@@ -1,43 +1,32 @@
-VERSION = $(shell grep '"Version":' ./package/metadata.json | grep -o '[0-9\.]*')
-CHECKS := true
-
 .PHONY: *
 
-build: lint test
-	tsc -p ./src/main --outFile ./package/contents/code/main.js
+TSC_SCRIPT_FLAGS = --lib es2020 ./src/extern/qt.d.ts
+VERSION = $(shell grep '"Version":' ./package/metadata.json | grep -o '[0-9\.]*')
+
+config:
 	mkdir -p ./package/contents/config
-	./run-ts.sh ./src/generators/config > ./package/contents/config/main.xml
+	tsc ${TSC_SCRIPT_FLAGS} ./src/config/definition.ts ./generators/config/kcfg.ts --outFile /dev/stdout | node - > ./package/contents/config/main.xml
 
-npm-install:
-	npm install
+build:
+	tsc --outFile ./package/contents/code/main.js
 
-lint: npm-install
-ifeq (${CHECKS}, true)
-	npx eslint ./src
-endif
-
-lint-fix: npm-install
-	npx eslint ./src --fix
-
-test:
-ifeq (${CHECKS}, true)
-	./run-ts.sh ./src/tests
-endif
-
-install: build
-	kpackagetool6 --type=KWin/Script --install=./package || kpackagetool6 --type=KWin/Script --upgrade=./package
+install: build config
+	kpackagetool5 --type=KWin/Script -i ./package || kpackagetool5 --type=KWin/Script -u ./package
 
 uninstall:
-	kpackagetool6 --type=KWin/Script --remove=karousel
+	kpackagetool5 --type=KWin/Script -r ./package
 
-package: build
-	tar -czf ./karousel_${subst .,_,${VERSION}}.tar.gz ./package --transform s/package/karousel/
+package: build config
+	tar -czf ./karousel_${subst .,_,${VERSION}}.tar.gz ./package
+
+logs:
+	journalctl -t kwin_x11 -g '^qml:|^file://.*karousel' -f
 
 docs-key-bindings-bbcode:
-	@./run-ts.sh ./src/generators/docs/keyBindingsBbcode
+	@tsc ${TSC_SCRIPT_FLAGS} ./src/keyBindings/definition.ts ./generators/docs/keyBindings.ts ./generators/docs/keyBindingsBbcode.ts --outFile /dev/stdout | node -
 
-docs-key-bindings-markdown:
-	@./run-ts.sh ./src/generators/docs/keyBindingsMarkdown
+docs-key-bindings-table:
+	@tsc ${TSC_SCRIPT_FLAGS} ./src/keyBindings/definition.ts ./generators/docs/keyBindings.ts ./generators/docs/keyBindingsTable.ts --outFile /dev/stdout | node -
 
 docs-key-bindings-fmt:
-	@./run-ts.sh ./src/generators/docs/keyBindingsFmt
+	@tsc ${TSC_SCRIPT_FLAGS} ./src/keyBindings/definition.ts ./generators/docs/keyBindings.ts ./generators/docs/keyBindingsFmt.ts --outFile /dev/stdout | node -

README.md

@@ -1,11 +1,17 @@
 # Karousel
-Scrollable tiling Kwin script. Works especially well with ultrawide screens.
+KWin tiling script with scrolling. 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
 
-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.
+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.
 
 Similar window managers include [PaperWM](https://github.com/paperwm/PaperWM),
 [Niri](https://github.com/YaLTeR/niri), and
@@ -13,7 +19,7 @@ Similar window managers include [PaperWM](https://github.com/paperwm/PaperWM),
 
 ## Dependencies
 Karousel requires the following QML modules:
-- QtQuick 6.0
+- QtQuick 2.15
 - org.kde.kwin 3.0
 - org.kde.notification 1.0
 
@@ -22,13 +28,6 @@ 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:
@@ -39,30 +38,22 @@ 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 (Only the active window visible)                                                      |
+| Meta+X                   | Toggle stacked layout for focused column (One window in the column visible, others shaded; not supported on Wayland)           |
 | 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                                                                                                 |
@@ -70,7 +61,6 @@ 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

@@ -1,15 +0,0 @@
-// @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],
-    },
-  }
-);

generators/docs/keyBindings.ts

@@ -1,11 +1,22 @@
-interface DocsKeyBinding {
+type KeyBinding = {
+    name: string;
     description: string;
-    keySequence: string;
+    comment?: string;
+    defaultKeySequence: string;
+    action: string;
 }
 
-function formatDescription(item: {description: string, comment?: string}) {
-    const suffix = item.comment === undefined ? "" : ` (${item.comment})`;
-    return `${applyMacro(item.description, "N")}${suffix}`;
+type NumKeyBinding = {
+    name: string;
+    description: string;
+    comment?: string;
+    defaultModifiers: string;
+    fKeys: boolean;
+    action: string;
+}
+
+function formatComment(comment: string | undefined) {
+    return comment === undefined ? "" : ` (${comment})`;
 }
 
 function printCols(...columns: (string[] | string)[]) {
@@ -15,9 +26,9 @@ function printCols(...columns: (string[] | string)[]) {
     }
 
     let nRows = Math.min(...columns.filter(
-        (column: string[] | string) => column instanceof Array,
+        (column: string[] | string) => column instanceof Array
     ).map(
-        (column: string[] | string) => column.length,
+        (column: string[] | string) => column.length
     ));
     if (nRows === Infinity) {
         // we only have single string columns
@@ -28,12 +39,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) {
@@ -54,15 +65,3 @@ 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]`,
-    })),
-);

generators/docs/keyBindingsBbcode.ts

@@ -0,0 +1,12 @@
+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(`[/list]`);

generators/docs/keyBindingsFmt.ts

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

generators/docs/keyBindingsTable.ts

@@ -0,0 +1,18 @@
+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, " |");

package.json

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

package/contents/code/main.qml

@@ -0,0 +1,28 @@
+import QtQuick 2.15
+import org.kde.kwin 3.0
+import org.kde.notification 1.0
+import "./main.js" as Karousel
+
+Item {
+    id: qmlBase
+
+    property var karouselInstance
+
+    Component.onCompleted: {
+        qmlBase.karouselInstance = Karousel.init();
+    }
+
+    Component.onDestruction: {
+        qmlBase.karouselInstance.destroy();
+    }
+
+    Notification {
+        id: notificationInvalidWindowRules
+        componentName: "plasma_workspace"
+        eventId: "notification"
+        title: "Karousel"
+        text: "Your Window Rules JSON is malformed, please review your Karousel configuration"
+        flags: Notification.Persistent
+        urgency: Notification.HighUrgency
+    }
+}

package/contents/ui/config.ui

@@ -29,23 +29,13 @@
                                                 </property>
                                             </widget>
                                         </item>
-                                        <item>
-                                            <widget class="QCheckBox" name="kcfg_cursorFollowsFocus">
-                                                <property name="text">
-                                                    <string>Cursor follows focus (experimental)</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 (only the active window visible)</string>
+                                                    <string>New columns start in stacked mode (one window in the column visible, others shaded). Not supported on Wayland.</string>
                                                 </property>
                                             </widget>
                                         </item>
@@ -111,35 +101,6 @@
                                 </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">
@@ -149,21 +110,14 @@
                                         <item>
                                             <widget class="QRadioButton" name="kcfg_tiledKeepBelow">
                                                 <property name="text">
-                                                    <string>Set "Keep Below" for tiled windows</string>
+                                                    <string>Keep tiled windows below</string>
                                                 </property>
                                             </widget>
                                         </item>
                                         <item>
                                             <widget class="QRadioButton" name="kcfg_floatingKeepAbove">
                                                 <property name="text">
-                                                    <string>Set "Keep Above" for floating windows</string>
-                                                </property>
-                                            </widget>
-                                        </item>
-                                        <item>
-                                            <widget class="QRadioButton" name="kcfg_noLayering">
-                                                <property name="text">
-                                                    <string>No layering</string>
+                                                    <string>Keep floating windows above</string>
                                                 </property>
                                             </widget>
                                         </item>
@@ -319,55 +273,13 @@
                             </item>
 
                             <item row="6" column="0">
-                                <widget class="QLabel" name="label_stackOffsetX">
-                                    <property name="text">
-                                        <string>Horizontal offset for stacked columns:</string>
-                                    </property>
-                                </widget>
-                            </item>
-                            <item row="6" column="1">
-                                <widget class="QSpinBox" name="kcfg_stackOffsetX">
-                                    <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="7" column="0">
-                                <widget class="QLabel" name="label_stackOffsetY">
-                                    <property name="text">
-                                        <string>Vertical offset for stacked columns:</string>
-                                    </property>
-                                </widget>
-                            </item>
-                            <item row="7" column="1">
-                                <widget class="QSpinBox" name="kcfg_stackOffsetY">
-                                    <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="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">
+                            <item row="6" column="1">
                                 <widget class="QSpinBox" name="kcfg_manualScrollStep">
                                     <property name="suffix">
                                         <string> px</string>
@@ -381,62 +293,35 @@
                                 </widget>
                             </item>
 
-                            <item row="9" column="0">
-                                <widget class="QLabel" name="label_gestureScrollStep">
+                            <item row="7" column="0">
+                                <widget class="QLabel" name="label_manualResizeStep">
                                     <property name="text">
-                                        <string>Touchpad gesture scrolling speed:</string>
-                                    </property>
-                                    <property name="toolTip">
-                                        <string>The amount to scroll per edge-to-edge gesture</string>
+                                        <string>Manual resize step size:</string>
                                     </property>
                                 </widget>
                             </item>
-                            <item row="9" column="1">
-                                <widget class="QSpinBox" name="kcfg_gestureScrollStep">
+                            <item row="7" column="1">
+                                <widget class="QSpinBox" name="kcfg_manualResizeStep">
                                     <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>
+                                        <number>999</number>
                                     </property>
                                     <property name="value">
-                                        <number>1920</number>
+                                        <number>0</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">
+                            <item row="8" column="0">
                                 <widget class="QLabel" name="label_offScreenOpacity">
                                     <property name="text">
                                         <string>Obscured window opacity:</string>
                                     </property>
                                 </widget>
                             </item>
-                            <item row="11" column="1">
+                            <item row="8" column="1">
                                 <widget class="QSpinBox" name="kcfg_offScreenOpacity">
                                     <property name="suffix">
                                         <string> %</string>
@@ -449,7 +334,6 @@
                                     </property>
                                 </widget>
                             </item>
-
                         </layout>
                     </widget>
 
@@ -458,27 +342,6 @@
                             <string>Window Rules</string>
                         </attribute>
                         <layout class="QVBoxLayout">
-                            <item>
-                                <layout class="QHBoxLayout">
-                                    <item>
-                                        <widget class="QLabel" name="label_desktops">
-                                            <property name="text">
-                                                <string>Tiled desktops:</string>
-                                            </property>
-                                            <property name="wordWrap">
-                                                <bool>true</bool>
-                                            </property>
-                                        </widget>
-                                    </item>
-                                    <item>
-                                        <widget class="QLineEdit" name="kcfg_tiledDesktops">
-                                            <property name="toolTip">
-                                                <string>Regex string to match desktops by desktop name"</string>
-                                            </property>
-                                        </widget>
-                                    </item>
-                                </layout>
-                            </item>
                             <item>
                                 <widget class="QPlainTextEdit" name="kcfg_windowRules">
                                     <property name="tabChangesFocus">

package/contents/ui/main.qml

@@ -1,73 +0,0 @@
-import QtQuick 6.0
-import org.kde.kwin 3.0
-import org.kde.notification 1.0
-import "../code/main.js" as Karousel
-
-Item {
-    id: qmlBase
-
-    property var karouselInstance
-
-    Component.onCompleted: {
-        qmlBase.karouselInstance = Karousel.init();
-    }
-
-    Component.onDestruction: {
-        qmlBase.karouselInstance.destroy();
-    }
-
-    Notification {
-        id: notificationInvalidTiledDesktops
-        componentName: "plasma_workspace"
-        eventId: "notification"
-        title: "Karousel"
-        text: "Your Tiled Desktops regex is malformed, please review your Karousel configuration"
-        flags: Notification.Persistent
-        urgency: Notification.HighUrgency
-    }
-
-    Notification {
-        id: notificationInvalidWindowRules
-        componentName: "plasma_workspace"
-        eventId: "notification"
-        title: "Karousel"
-        text: "Your Window Rules JSON is malformed, please review your Karousel configuration"
-        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

@@ -1,5 +1,4 @@
 {
-    "KPackageStructure": "KWin/Script",
     "KPlugin": {
         "Name": "Karousel",
         "Description": "Scrollable tiling extension for KWin",
@@ -9,13 +8,13 @@
             "Name": "Peter Fajdiga"
         }],
         "Id": "karousel",
-        "Version": "0.16",
+        "ServiceTypes": ["KWin/Script"],
+        "Version": "0.7.2",
         "License": "GPLv3",
         "Website": "https://github.com/peterfajdiga/karousel",
         "BugReportUrl": "https://github.com/peterfajdiga/karousel/issues"
     },
     "X-Plasma-API": "declarativescript",
-    "X-Plasma-API-Minimum-Version": "6.0",
-    "X-Plasma-MainScript": "ui/main.qml",
+    "X-Plasma-MainScript": "code/main.qml",
     "X-KDE-ConfigModule": "kwin/effects/configs/kcm_kwin4_genericscripted"
 }

run-ts.sh

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

src/Actions.ts

@@ -0,0 +1,336 @@
+namespace Actions {
+    export function init(world: World, config: Config) {
+        return {
+            focusLeft: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    const prevColumn = grid.getPrevColumn(column);
+                    if (prevColumn === null) {
+                        return;
+                    }
+                    prevColumn.focus();
+                });
+            },
+
+            focusRight: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    const nextColumn = grid.getNextColumn(column);
+                    if (nextColumn === null) {
+                        return;
+                    }
+                    nextColumn.focus();
+                });
+            },
+
+            focusUp: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    const prevWindow = column.getPrevWindow(window);
+                    if (prevWindow === null) {
+                        return;
+                    }
+                    prevWindow.focus();
+                });
+            },
+
+            focusDown: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    const nextWindow = column.getNextWindow(window);
+                    if (nextWindow === null) {
+                        return;
+                    }
+                    nextWindow.focus();
+                });
+            },
+
+            focusStart: () => {
+                world.do((clientManager, desktopManager) => {
+                    const grid = desktopManager.getCurrentDesktop().grid;
+                    const firstColumn = grid.getFirstColumn();
+                    if (firstColumn === null) {
+                        return;
+                    }
+                    firstColumn.focus();
+                });
+            },
+
+            focusEnd: () => {
+                world.do((clientManager, desktopManager) => {
+                    const grid = desktopManager.getCurrentDesktop().grid;
+                    const lastColumn = grid.getLastColumn();
+                    if (lastColumn === null) {
+                        return;
+                    }
+                    lastColumn.focus();
+                });
+            },
+
+            windowMoveLeft: () => {
+                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);
+                    }
+                });
+            },
+
+            windowMoveRight: () => {
+                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);
+                    }
+                });
+            },
+
+            windowMoveUp: () => {
+                // TODO (optimization): only arrange moved windows
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    column.moveWindowUp(window);
+                });
+            },
+
+            windowMoveDown: () => {
+                // TODO (optimization): only arrange moved windows
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    column.moveWindowDown(window);
+                });
+            },
+
+            windowMoveStart: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    const newColumn = new Column(grid, null);
+                    window.moveToColumn(newColumn);
+                });
+            },
+
+            windowMoveEnd: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    const newColumn = new Column(grid, grid.getLastColumn());
+                    window.moveToColumn(newColumn);
+                });
+            },
+
+            windowToggleFloating: () => {
+                const kwinClient = workspace.activeClient;
+                world.do((clientManager, desktopManager) => {
+                    clientManager.toggleFloatingClient(kwinClient);
+                });
+            },
+
+            columnMoveLeft: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    grid.moveColumnLeft(column);
+                });
+            },
+
+            columnMoveRight: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    grid.moveColumnRight(column);
+                });
+            },
+
+            columnMoveStart: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    column.moveAfter(null);
+                });
+            },
+
+            columnMoveEnd: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    column.moveAfter(grid.getLastColumn());
+                });
+            },
+
+            columnToggleStacked: () => {
+                world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
+                    column.toggleStacked();
+                });
+            },
+
+            columnWidthIncrease: () => {
+                world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
+                    config.columnResizer.increaseWidth(column, config.manualResizeStep);
+                });
+            },
+
+            columnWidthDecrease: () => {
+                world.doIfTiledFocused(false, (clientManager, desktopManager, window, column, grid) => {
+                    config.columnResizer.decreaseWidth(column, config.manualResizeStep);
+                });
+            },
+
+            columnsWidthEqualize: () => {
+                world.do((clientManager, desktopManager) => {
+                    desktopManager.getCurrentDesktop().equalizeVisibleColumnsWidths();
+                });
+            },
+
+            gridScrollLeft: () => {
+                gridScroll(world, -config.manualScrollStep);
+            },
+
+            gridScrollRight: () => {
+                gridScroll(world, config.manualScrollStep);
+            },
+
+            gridScrollStart: () => {
+                world.do((clientManager, desktopManager) => {
+                    const grid = desktopManager.getCurrentDesktop().grid;
+                    const firstColumn = grid.getFirstColumn();
+                    if (firstColumn === null) {
+                        return;
+                    }
+                    grid.desktop.scrollToColumn(firstColumn);
+                });
+            },
+
+            gridScrollEnd: () => {
+                world.do((clientManager, desktopManager) => {
+                    const grid = desktopManager.getCurrentDesktop().grid;
+                    const lastColumn = grid.getLastColumn();
+                    if (lastColumn === null) {
+                        return;
+                    }
+                    grid.desktop.scrollToColumn(lastColumn);
+                });
+            },
+
+            gridScrollFocused: () => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, grid) => {
+                    grid.desktop.scrollCenterRange(column);
+                })
+            },
+
+            gridScrollLeftColumn: () => {
+                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);
+                });
+            },
+
+            gridScrollRightColumn: () => {
+                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);
+                });
+            },
+        };
+    }
+
+    export function initNum(world: World) {
+        return {
+            focusColumn: (columnIndex: number) => {
+                world.do((clientManager, desktopManager) => {
+                    const grid = desktopManager.getCurrentDesktop().grid;
+                    const targetColumn = grid.getColumnAtIndex(columnIndex);
+                    if (targetColumn === null) {
+                        return;
+                    }
+                    targetColumn.focus();
+                });
+            },
+
+            windowMoveToColumn: (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();
+                });
+            },
+
+            columnMoveToColumn: (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));
+                    }
+                });
+            },
+
+            columnMoveToDesktop: (desktopIndex: number) => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, oldGrid) => {
+                    const desktopNumber = desktopIndex + 1;
+                    const newGrid = desktopManager.getDesktopInCurrentActivity(desktopNumber).grid;
+                    if (newGrid === null || newGrid === oldGrid) {
+                        return;
+                    }
+                    column.moveToGrid(newGrid, newGrid.getLastColumn());
+                });
+            },
+
+            tailMoveToDesktop: (desktopIndex: number) => {
+                world.doIfTiledFocused(true, (clientManager, desktopManager, window, column, oldGrid) => {
+                    const desktopNumber = desktopIndex + 1;
+                    const newGrid = desktopManager.getDesktopInCurrentActivity(desktopNumber).grid;
+                    if (newGrid === null || newGrid === oldGrid) {
+                        return;
+                    }
+                    oldGrid.evacuateTail(newGrid, column);
+                });
+            },
+        };
+    }
+
+    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/behavior/columnResizer/ContextualResizer.ts

@@ -1,20 +1,14 @@
 class ContextualResizer {
-    constructor(
-        private readonly presetWidths: { getWidths: (minWidth: number, maxWidth: number) => number[] },
-    ) {}
-
-    public increaseWidth(column: Column) {
+    public increaseWidth(column: Column, step: number) {
         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() >= maxWidth) {
+        if(!column.isVisible(visibleRange, true) || column.getWidth() >= column.getMaxWidth()) {
             return;
         }
 
-        const leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange);
-        const rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange);
+        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;
@@ -23,15 +17,16 @@ class ContextualResizer {
         const leftSpace = leftVisibleColumn.getLeft() - visibleRange.getLeft();
         const rightSpace = visibleRange.getRight() - rightVisibleColumn.getRight();
 
-        const newWidth = findMinPositive(
+        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,
-                ...this.presetWidths.getWidths(minWidth, maxWidth),
             ],
             width => width - column.getWidth(),
-        );
+        )
         if (newWidth === undefined) {
             return;
         }
@@ -40,28 +35,26 @@ class ContextualResizer {
         desktop.scrollCenterVisible(column);
     }
 
-    public decreaseWidth(column: Column) {
+    public decreaseWidth(column: Column, step: number) {
         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) {
+        if(!column.isVisible(visibleRange, true) || column.getWidth() <= column.getMinWidth()) {
             return;
         }
 
-        const leftVisibleColumn = grid.getLeftmostVisibleColumn(visibleRange);
-        const rightVisibleColumn = grid.getRightmostVisibleColumn(visibleRange);
+        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);
+        let leftOffScreenColumn = grid.getPrevColumn(leftVisibleColumn);
         if (leftOffScreenColumn === column) {
             leftOffScreenColumn = null;
         }
-        let rightOffScreenColumn = grid.getRightColumn(rightVisibleColumn);
+        let rightOffScreenColumn = grid.getNextColumn(rightVisibleColumn);
         if (rightOffScreenColumn === column) {
             rightOffScreenColumn = null;
         }
@@ -71,14 +64,15 @@ 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 = findMinPositive(
+        const newWidth = ContextualResizer.findNextStep(
             [
+                visibleRange.getWidth(),
+                column.getWidth() - step,
                 column.getWidth() - leftOffScreen,
                 column.getWidth() - rightOffScreen,
-                ...this.presetWidths.getWidths(minWidth, maxWidth),
             ],
             width => column.getWidth() - width,
-        );
+        )
         if (newWidth === undefined) {
             return;
         }
@@ -87,21 +81,16 @@ class ContextualResizer {
         desktop.scrollCenterVisible(column);
     }
 
-    public maximizeWidth(column: Column) {
-        const grid = column.grid;
-        const desktop = grid.desktop;
-        const presetWidths = this.presetWidths.getWidths(column.getMinWidth(), column.getMaxWidth());
-        const maxWidth = presetWidths[presetWidths.length-1];
-        column.setWidth(maxWidth, true);
-        desktop.scrollCenterVisible(column);
-    }
-
-    public minimizeWidth(column: Column) {
-        const grid = column.grid;
-        const desktop = grid.desktop;
-        const presetWidths = this.presetWidths.getWidths(column.getMinWidth(), column.getMaxWidth());
-        const minWidth = presetWidths[0];
-        column.setWidth(minWidth, true);
-        desktop.scrollCenterVisible(column);
+    private static findNextStep(steps: number[], evaluate: (step: number) => number) {
+        let bestScore = Infinity;
+        let bestStep = undefined;
+        for (const step of steps) {
+            const score = evaluate(step);
+            if (score > 0 && score < bestScore) {
+                bestScore = score;
+                bestStep = step;
+            }
+        }
+        return bestStep;
     }
 }

src/behavior/columnResizer/RawResizer.ts

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

src/behavior/scrollClamper/CenterClamper.ts

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

src/behavior/scrollClamper/EdgeClamper.ts

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

src/config/config.ts

@@ -0,0 +1,22 @@
+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,
+};

src/config/definition.ts

@@ -1,44 +1,46 @@
 const defaultWindowRules = `[
     {
-        "class": "(org\\\\.kde\\\\.)?plasmashell",
+        "class": "ksmserver-logout-greeter",
         "tile": false
     },
     {
-        "class": "(org\\\\.kde\\\\.)?polkit-kde-authentication-agent-1",
+        "class": "kcalc",
         "tile": false
     },
     {
-        "class": "(org\\\\.kde\\\\.)?kded6",
+        "class": "org.kde.kcalc",
         "tile": false
     },
     {
-        "class": "(org\\\\.kde\\\\.)?kcalc",
-        "tile": false
-    },
-    {
-        "class": "(org\\\\.kde\\\\.)?kfind",
+        "class": "kfind",
         "tile": true
     },
     {
-        "class": "(org\\\\.kde\\\\.)?kruler",
+        "class": "org.kde.kfind",
+        "tile": true
+    },
+    {
+        "class": "kruler",
         "tile": false
     },
     {
-        "class": "(org\\\\.kde\\\\.)?krunner",
+        "class": "org.kde.kruler",
         "tile": false
     },
     {
-        "class": "(org\\\\.kde\\\\.)?yakuake",
+        "class": "krunner",
         "tile": false
     },
     {
-        "class": "wl-copy|wl-paste",
-        "caption": "wl-clipboard",
+        "class": "org.kde.krunner",
         "tile": false
     },
     {
-        "class": "steam",
-        "caption": "Steam Big Picture Mode",
+        "class": "yakuake",
+        "tile": false
+    },
+    {
+        "class": "org.kde.yakuake",
         "tile": false
     },
     {
@@ -47,12 +49,22 @@ const defaultWindowRules = `[
         "tile": false
     },
     {
-        "class": "jetbrains-.*",
+        "class": "jetbrains-idea",
         "caption": "splash",
         "tile": false
     },
     {
-        "class": "jetbrains-.*",
+        "class": "jetbrains-studio",
+        "caption": "splash",
+        "tile": false
+    },
+    {
+        "class": "jetbrains-idea",
+        "caption": "Unstash Changes|Paths Affected by stash@.*",
+        "tile": true
+    },
+    {
+        "class": "jetbrains-studio",
         "caption": "Unstash Changes|Paths Affected by stash@.*",
         "tile": true
     }
@@ -62,42 +74,32 @@ const configDef = [
     {
         name: "gapsOuterTop",
         type: "UInt",
-        default: 16,
+        default: 18,
     },
     {
         name: "gapsOuterBottom",
         type: "UInt",
-        default: 16,
+        default: 18,
     },
     {
         name: "gapsOuterLeft",
         type: "UInt",
-        default: 16,
+        default: 18,
     },
     {
         name: "gapsOuterRight",
         type: "UInt",
-        default: 16,
+        default: 18,
     },
     {
         name: "gapsInnerHorizontal",
         type: "UInt",
-        default: 8,
+        default: 18,
     },
     {
         name: "gapsInnerVertical",
         type: "UInt",
-        default: 8,
-    },
-    {
-        name: "stackOffsetX",
-        type: "UInt",
-        default: 8,
-    },
-    {
-        name: "stackOffsetY",
-        type: "UInt",
-        default: 32,
+        default: 18,
     },
     {
         name: "manualScrollStep",
@@ -105,9 +107,9 @@ const configDef = [
         default: 200,
     },
     {
-        name: "presetWidths",
-        type: "String",
-        default: "50%, 100%",
+        name: "manualResizeStep",
+        type: "UInt",
+        default: 600,
     },
     {
         name: "offScreenOpacity",
@@ -119,11 +121,6 @@ const configDef = [
         type: "Bool",
         default: true,
     },
-    {
-        name: "cursorFollowsFocus",
-        type: "Bool",
-        default: false,
-    },
     {
         name: "stackColumnsByDefault",
         type: "Bool",
@@ -159,21 +156,6 @@ 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",
@@ -184,19 +166,9 @@ const configDef = [
         type: "Bool",
         default: false,
     },
-    {
-        name: "noLayering",
-        type: "Bool",
-        default: false,
-    },
     {
         name: "windowRules",
         type: "String",
         default: defaultWindowRules,
-    },
-    {
-        name: "tiledDesktops",
-        type: "String",
-        default: ".*",
-    },
+    }
 ];

src/config/loader.ts

@@ -1,7 +1,3 @@
-function init() {
-    return new World(loadConfig());
-}
-
 function loadConfig(): Config {
     const config: any = {};
     for (const entry of configDef) {

src/extern/global.d.ts

@@ -1,8 +1,6 @@
-declare const Qt: Qt;
-declare const KWin: KWin;
-declare const Workspace: Workspace;
 declare const qmlBase: QmlObject;
-declare const notificationInvalidTiledDesktops: Notification;
 declare const notificationInvalidWindowRules: Notification;
-declare const notificationInvalidPresetWidths: Notification;
-declare const moveCursorToFocus: DBusCall;
+
+type Notification = {
+    sendEvent(): void;
+};

src/extern/kwin.d.ts

@@ -0,0 +1,79 @@
+declare const KWin: {
+    readConfig(key: string, defaultValue: any): any;
+    registerShortcut(name: string, description: string, keySequence: string, callback: () => void): void;
+};
+
+declare const workspace: {
+    readonly desktops: number;
+    readonly currentDesktop: number;
+    readonly currentActivity: string;
+
+    activeClient: KwinClient;
+
+    readonly currentDesktopChanged: QSignal<[]>
+    readonly clientAdded: QSignal<[KwinClient]>;
+    readonly clientRemoved: QSignal<[KwinClient]>;
+    readonly clientMinimized: QSignal<[KwinClient]>;
+    readonly clientUnminimized: QSignal<[KwinClient]>;
+    readonly clientMaximizeSet: QSignal<[KwinClient, horizontally: boolean, vertically: boolean]>;
+    readonly clientActivated: QSignal<[KwinClient]>;
+    readonly numberDesktopsChanged: QSignal<[]>;
+    readonly currentActivityChanged: QSignal<[]>;
+    readonly virtualScreenSizeChanged: QSignal<[]>;
+
+    clientArea(option: ClientAreaOption, screenNumber: number, desktopNumber: number);
+    clientList(): KwinClient[];
+};
+
+const enum ClientAreaOption {
+    PlacementArea,
+    MovementArea,
+    MaximizeArea,
+    MaximizeFullArea,
+    FullScreenArea,
+    WorkArea,
+    FullArea,
+    ScreenArea,
+}
+
+type Tile = unknown;
+
+interface KwinClient {
+    readonly shadeable: boolean;
+    readonly caption: string;
+    readonly minSize: QmlSize;
+    readonly transient: boolean;
+    readonly transientFor: KwinClient;
+    readonly move: boolean;
+    readonly resize: boolean;
+    readonly resizeable: boolean;
+    readonly screen: number;
+    readonly resourceClass: QByteArray;
+    readonly dock: boolean;
+    readonly normalWindow: boolean;
+    readonly managed: boolean;
+
+    opacity: number;
+    fullScreen: boolean;
+    activities: string[]; // empty array means all activities
+    skipSwitcher: boolean;
+    keepAbove: boolean;
+    keepBelow: boolean;
+    shade: boolean;
+    minimized: boolean;
+    frameGeometry: QmlRect;
+    desktop: number; // -1 means all desktops
+    tile: Tile;
+
+    readonly fullScreenChanged: QSignal<[]>;
+    readonly desktopChanged: QSignal<[]>;
+    readonly activitiesChanged: QSignal<[]>;
+    readonly captionChanged: QSignal<[]>;
+    readonly tileChanged: QSignal<[]>;
+    readonly moveResizedChanged: QSignal<[]>;
+    readonly moveResizeCursorChanged: QSignal<[]>;
+    readonly clientStartUserMovedResized: QSignal<[]>;
+    readonly frameGeometryChanged: QSignal<[KwinClient, oldGeometry: QmlRect]>;
+
+    setMaximize(vertically: boolean, horizontally: boolean): void;
+}

src/extern/qt.d.ts

@@ -0,0 +1,42 @@
+declare const console: {
+    log(...args: any[]);
+    trace();
+    assert(boolean);
+};
+
+declare const Qt: {
+    rect(x: number, y: number, width: number, height: number): QmlRect;
+    createQmlObject(qml: string, parent: QmlObject);
+};
+
+type QmlObject = unknown;
+
+type QByteArray = string;
+
+type QmlRect = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    bottom: number; // top + height
+    left: number;
+    right: number; // left + width
+};
+
+type QmlSize = {
+    width: number;
+    height: number;
+};
+
+type QSignal<T extends unknown[]> = {
+    connect(handler: (...args: [...T]) => void): void;
+    disconnect(handler: (...args: [...T]) => void): void;
+};
+
+type QmlTimer = {
+    interval: number;
+    readonly triggered: QSignal<[]>;
+    restart(): void;
+    destroy(): void;
+};

src/generators/config/tsconfig.json

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

src/generators/docs/keyBindingsBbcode/main.ts

@@ -1,7 +0,0 @@
-console.log(`[list]`);
-
-for (const binding of keyBindings) {
-    console.log(`    [*] ${binding.keySequence} — ${binding.description}`);
-}
-
-console.log(`[/list]`);

src/generators/docs/keyBindingsBbcode/tsconfig.json

@@ -1,9 +0,0 @@
-{
-    "extends": "../../../tsconfig.json",
-    "include": [
-        "../../../extern/**/*",
-        "../../../lib/**/*",
-        "../keyBindings.ts",
-        "./**/*"
-    ]
-}

src/generators/docs/keyBindingsFmt/main.ts

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

src/generators/docs/keyBindingsFmt/tsconfig.json

@@ -1,9 +0,0 @@
-{
-    "extends": "../../../tsconfig.json",
-    "include": [
-        "../../../extern/**/*",
-        "../../../lib/**/*",
-        "../keyBindings.ts",
-        "./**/*"
-    ]
-}

src/generators/docs/keyBindingsMarkdown/main.ts

@@ -1,13 +0,0 @@
-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,9 +0,0 @@
-{
-    "extends": "../../../tsconfig.json",
-    "include": [
-        "../../../extern/**/*",
-        "../../../lib/**/*",
-        "../keyBindings.ts",
-        "./**/*"
-    ]
-}

src/keyBindings/definition.ts

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

src/keyBindings/loader.ts

@@ -0,0 +1,70 @@
+type KeyBinding = {
+    name: string;
+    description: string;
+    comment?: string;
+    defaultKeySequence: string;
+    action: keyof ReturnType<typeof Actions.init>;
+};
+
+type NumKeyBinding = {
+    name: string;
+    description: string;
+    comment?: string;
+    defaultModifiers: string;
+    fKeys: boolean;
+    action: keyof ReturnType<typeof Actions.initNum>;
+};
+
+function catchWrap(f: () => void) {
+    return () => {
+        try {
+            f();
+        } catch (error: any) {
+            log(error);
+            log(error.stack);
+        }
+    };
+}
+
+function registerKeyBinding(name: string, description: string, keySequence: string, callback: () => void) {
+    KWin.registerShortcut(
+        "karousel-" + name,
+        "Karousel: " + description,
+        keySequence,
+        catchWrap(callback),
+    );
+}
+
+function registerNumKeyBindings(name: string, description: string, modifiers: string, fKeys: boolean, callback: (i: number) => void) {
+    const numPrefix = fKeys ? "F" : "";
+    const n = fKeys ? 12 : 9;
+    for (let i = 0; i < 12; i++) {
+        const numKey = String(i + 1);
+        const keySequence = i < n ?
+            modifiers + "+" + numPrefix + numKey :
+            "";
+        registerKeyBinding(
+            name + numKey,
+            description + numKey,
+            keySequence,
+            () => callback(i),
+        );
+    }
+}
+
+function registerKeyBindings(world: World, config: Config) {
+    const actions = Actions.init(world, {
+        manualScrollStep: config.manualScrollStep,
+        manualResizeStep: config.manualResizeStep,
+        columnResizer: config.scrollingCentered ? new RawResizer() : new ContextualResizer(),
+    });
+
+    for (const binding of keyBindings) {
+        registerKeyBinding(binding.name, binding.description, binding.defaultKeySequence, actions[binding.action]);
+    }
+
+    const numActions = Actions.initNum(world);
+    for (const binding of numKeyBindings) {
+        registerNumKeyBindings(binding.name, binding.description, binding.defaultModifiers, binding.fKeys, numActions[binding.action]);
+    }
+}

src/layout/Column.ts

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

src/layout/Desktop.ts

@@ -1,38 +1,35 @@
 class Desktop {
     public readonly grid: Grid;
+    public readonly desktopNumber: number;
+    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(
-        public readonly kwinDesktop: KwinDesktop,
-        private readonly pinManager: PinManager,
-        private readonly config: Desktop.Config,
-        private readonly getScreen: () => Output,
-        layoutConfig: LayoutConfig,
-        focusPasser: FocusPassing.Passer,
-    ) {
+    constructor(desktopNumber: number, pinManager: PinManager, config: Desktop.Config, layoutConfig: LayoutConfig) {
+        this.pinManager = pinManager;
+        this.config = config;
         this.scrollX = 0;
-        this.gestureScrollXInitial = null;
         this.dirty = true;
         this.dirtyScroll = true;
         this.dirtyPins = true;
-        this.grid = new Grid(this, layoutConfig, focusPasser);
-        this.clientArea = Desktop.getClientArea(this.getScreen(), kwinDesktop);
-        this.tilingArea = Desktop.getTilingArea(this.clientArea, kwinDesktop, pinManager, config);
+        this.desktopNumber = desktopNumber;
+        this.grid = new Grid(this, layoutConfig);
+        this.clientArea = Desktop.getClientArea(desktopNumber);
+        this.tilingArea = Desktop.getTilingArea(this.clientArea, desktopNumber, pinManager, config);
     }
 
     private updateArea() {
-        const newClientArea = Desktop.getClientArea(this.getScreen(), this.kwinDesktop);
-        if (rectEquals(newClientArea, this.clientArea) && !this.dirtyPins) {
+        const newClientArea = Desktop.getClientArea(this.desktopNumber);
+        if (newClientArea === this.clientArea && !this.dirtyPins) {
             return;
         }
         this.clientArea = newClientArea;
-        this.tilingArea = Desktop.getTilingArea(newClientArea, this.kwinDesktop, this.pinManager, this.config);
+        this.tilingArea = Desktop.getTilingArea(newClientArea, this.desktopNumber, this.pinManager, this.config);
         this.dirty = true;
         this.dirtyScroll = true;
         this.dirtyPins = false;
@@ -40,12 +37,12 @@ class Desktop {
         this.autoAdjustScroll();
     }
 
-    private static getClientArea(screen: Output, kwinDesktop: KwinDesktop) {
-        return Workspace.clientArea(ClientAreaOption.PlacementArea, screen, kwinDesktop);
+    private static getClientArea(desktopNumber: number) {
+        return workspace.clientArea(ClientAreaOption.PlacementArea, 0, desktopNumber);
     }
 
-    private static getTilingArea(clientArea: QmlRect, kwinDesktop: KwinDesktop, pinManager: PinManager, config: Desktop.Config) {
-        const availableSpace = pinManager.getAvailableSpace(kwinDesktop, clientArea);
+    private static getTilingArea(clientArea: QmlRect, desktopNumber: number, pinManager: PinManager, config: Desktop.Config) {
+        const availableSpace = pinManager.getAvailableSpace(desktopNumber, clientArea);
         const top = availableSpace.top + config.marginTop;
         const bottom = availableSpace.bottom - config.marginBottom;
         const left = availableSpace.left + config.marginLeft;
@@ -55,10 +52,10 @@ class Desktop {
             top,
             right - left,
             bottom - top,
-        );
+        )
     }
 
-    public scrollIntoView(range: Range) {
+    public scrollIntoView(range: Desktop.Range) {
         const left = range.getLeft();
         const right = range.getRight();
         const initialVisibleRange = this.getCurrentVisibleRange();
@@ -75,9 +72,10 @@ class Desktop {
         this.setScroll(targetScrollX, false);
     }
 
-    public scrollCenterRange(range: Range) {
-        const scrollAmount = Range.minus(range, this.getCurrentVisibleRange());
-        this.adjustScroll(scrollAmount, true);
+    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 scrollCenterVisible(focusedColumn: Column) {
@@ -93,17 +91,17 @@ class Desktop {
             return;
         }
 
-        this.scrollToColumn(focusedColumn, false);
+        this.scrollToColumn(focusedColumn);
     }
 
-    public scrollToColumn(column: Column, force: boolean) {
-        if (force || this.dirtyScroll || !Range.contains(this.getCurrentVisibleRange(), column)) {
+    public scrollToColumn(column: Column) {
+        if (this.dirtyScroll || !column.isVisible(this.getCurrentVisibleRange(), true)) {
             this.config.scroller.scrollToColumn(this, column);
         }
     }
 
     private getVisibleRange(scrollX: number) {
-        return Range.create(scrollX, this.tilingArea.width);
+        return new Desktop.RangeImpl(scrollX, this.tilingArea.width);
     }
 
     public getCurrentVisibleRange() {
@@ -127,34 +125,38 @@ class Desktop {
         this.setScroll(this.scrollX + dx, force);
     }
 
-    public gestureScroll(amount: number) {
-        if (!this.config.gestureScroll) {
-            return;
-        }
-        if (this.gestureScrollXInitial === null) {
-            this.gestureScrollXInitial = this.scrollX;
-        }
-
-        if (this.config.gestureScrollInvert) {
-            amount = -amount;
-        }
-        this.setScroll(this.gestureScrollXInitial + this.config.gestureScrollStep * amount, false);
-    }
-
-    public gestureScrollFinish(focusedWindow: Window|null) {
-        const scrolledRight = this.scrollX > this.gestureScrollXInitial!;
-        this.gestureScrollXInitial = null;
-
+    public equalizeVisibleColumnsWidths() {
         const visibleRange = this.getCurrentVisibleRange();
-        if (focusedWindow !== null && !Range.contains(visibleRange, focusedWindow.column)) {
-            // the focused window is no longer visible, find a new window to focus
-            const focusTargetColumn = scrolledRight ?
-                this.grid.getLeftmostVisibleColumn(visibleRange) :
-                this.grid.getRightmostVisibleColumn(visibleRange);
-            if (focusTargetColumn !== null) {
-                focusTargetColumn.getWindowToFocus().focus();
+        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--;
             }
         }
+
+        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--;
+            }
+        }
+
+        this.scrollCenterRange(Desktop.RangeImpl.fromRanges(
+            visibleColumns[0],
+            visibleColumns[visibleColumns.length - 1],
+        ));
     }
 
     public arrange() {
@@ -167,10 +169,6 @@ class Desktop {
         this.dirty = false;
     }
 
-    public forceArrange() {
-        this.dirty = true;
-    }
-
     public onLayoutChanged() {
         this.dirty = true;
         this.dirtyScroll = true;
@@ -188,16 +186,47 @@ class Desktop {
 }
 
 namespace Desktop {
-    export interface Config {
-        marginTop: number;
-        marginBottom: number;
-        marginLeft: number;
-        marginRight: number;
-        gestureScroll: boolean;
-        gestureScrollInvert: boolean;
-        gestureScrollStep: number;
-        scroller: Desktop.Scroller;
-        clamper: Desktop.Clamper;
+    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 class ColumnRange {
@@ -211,7 +240,7 @@ namespace Desktop {
             this.width = initialColumn.getWidth();
         }
 
-        public addNeighbors(visibleRange: Range, gap: number) {
+        public addNeighbors(visibleRange: Desktop.Range, gap: number) {
             const grid = this.left.grid;
 
             const columnRange = this;
@@ -222,8 +251,8 @@ namespace Desktop {
                 return column !== null && canFit(column);
             }
 
-            let leftColumn = grid.getLeftColumn(this.left);
-            let rightColumn = grid.getRightColumn(this.right);
+            let leftColumn = grid.getPrevColumn(this.left);
+            let rightColumn = grid.getNextColumn(this.right);
             function checkColumns() {
                 if (!isUsable(leftColumn)) {
                     leftColumn = null;
@@ -240,10 +269,10 @@ namespace Desktop {
                 const rightToCenter = rightColumn === null ? Infinity : Math.abs(rightColumn.getRight() - visibleCenter);
                 if (leftToCenter < rightToCenter) {
                     this.addLeft(leftColumn!, gap);
-                    leftColumn = grid.getLeftColumn(leftColumn!);
+                    leftColumn = grid.getPrevColumn(leftColumn!);
                 } else {
                     this.addRight(rightColumn!, gap);
-                    rightColumn = grid.getRightColumn(rightColumn!);
+                    rightColumn = grid.getNextColumn(rightColumn!);
                 }
                 checkColumns();
             }
@@ -272,11 +301,11 @@ namespace Desktop {
         }
     }
 
-    export interface Scroller {
+    export type Scroller = {
         scrollToColumn(desktop: Desktop, column: Column): void;
     }
 
-    export interface Clamper {
+    export type Clamper = {
         clampScrollX(desktop: Desktop, x: number): number;
     }
 }

src/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, focusPasser: FocusPassing.Passer) {
+    constructor(desktop: Desktop, config: LayoutConfig) {
         this.desktop = desktop;
         this.config = config;
-        this.focusPasser = focusPasser;
         this.columns = new LinkedList();
         this.lastFocusedColumn = null;
         this.width = 0;
@@ -24,18 +24,6 @@ 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);
@@ -44,11 +32,11 @@ class Grid {
     }
 
     public moveColumnRight(column: Column) {
-        const rightColumn = this.columns.getNext(column);
-        if (rightColumn === null) {
+        const nextColumn = this.columns.getNext(column);
+        if (nextColumn === null) {
             return;
         }
-        this.moveColumnLeft(rightColumn);
+        this.moveColumnLeft(nextColumn);
     }
 
     public getWidth() {
@@ -59,11 +47,11 @@ class Grid {
         return this.userResize;
     }
 
-    public getLeftColumn(column: Column) {
+    public getPrevColumn(column: Column) {
         return this.columns.getPrev(column);
     }
 
-    public getRightColumn(column: Column) {
+    public getNextColumn(column: Column) {
         return this.columns.getNext(column);
     }
 
@@ -106,19 +94,19 @@ class Grid {
         this.width = x - this.config.gapsInnerHorizontal;
     }
 
-    public getLeftmostVisibleColumn(visibleRange: Range) {
+    public getLeftmostVisibleColumn(visibleRange: Desktop.Range, fullyVisible: boolean) {
         for (const column of this.columns.iterator()) {
-            if (Range.contains(visibleRange, column)) {
+            if (column.isVisible(visibleRange, fullyVisible)) {
                 return column;
             }
         }
         return null;
     }
 
-    public getRightmostVisibleColumn(visibleRange: Range) {
+    public getRightmostVisibleColumn(visibleRange: Desktop.Range, fullyVisible: boolean) {
         let last = null;
         for (const column of this.columns.iterator()) {
-            if (Range.contains(visibleRange, column)) {
+            if (column.isVisible(visibleRange, fullyVisible)) {
                 last = column;
             } else if (last !== null) {
                 break;
@@ -127,14 +115,29 @@ class Grid {
         return last;
     }
 
-    public *getVisibleColumns(visibleRange: Range) {
+    public *getVisibleColumns(visibleRange: Desktop.Range, fullyVisible: boolean) {
         for (const column of this.columns.iterator()) {
-            if (Range.contains(visibleRange, column)) {
+            if (column.isVisible(visibleRange, fullyVisible)) {
                 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);
@@ -147,58 +150,61 @@ class Grid {
         }
     }
 
-    public onColumnAdded(column: Column, leftColumn: Column|null) {
-        if (leftColumn === null) {
+    public onColumnAdded(column: Column, prevColumn: Column|null) {
+        if (prevColumn === null) {
             this.columns.insertStart(column);
         } else {
-            this.columns.insertAfter(column, leftColumn);
+            this.columns.insertAfter(column, prevColumn);
         }
         this.columnsSetX(column);
         this.desktop.onLayoutChanged();
         this.desktop.autoAdjustScroll();
     }
 
-    public onColumnRemoved(column: Column, passFocus: FocusPassing.Type) {
+    public onColumnRemoved(column: Column, passFocus: boolean) {
         const isLastColumn = this.columns.length() === 1;
-        const rightColumn = this.getRightColumn(column);
-        const columnToFocus = isLastColumn ? null : this.getLeftColumn(column) ?? rightColumn;
+        const nextColumn = this.getNextColumn(column);
+        const columnToFocus = isLastColumn ? null : this.getPrevColumn(column) ?? nextColumn;
         if (column === this.lastFocusedColumn) {
             this.lastFocusedColumn = columnToFocus;
         }
 
         this.columns.remove(column);
-        this.columnsSetX(rightColumn);
+        this.columnsSetX(nextColumn);
 
         this.desktop.onLayoutChanged();
-        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;
-            }
+        if (passFocus && columnToFocus !== null) {
+            columnToFocus.focus();
+        } else {
+            this.desktop.autoAdjustScroll();
         }
+    }
+
+    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 rightColumn = this.columns.getNext(column);
-        this.columnsSetX(rightColumn);
+        const nextColumn = this.columns.getNext(column);
+        this.columnsSetX(nextColumn);
         this.desktop.onLayoutChanged();
         if (!this.userResize) {
             this.desktop.autoAdjustScroll();
         }
     }
 
-    public onColumnFocused(column: Column, window: Window) {
+    public onColumnFocused(column: Column) {
         const lastFocusedColumn = this.getLastFocusedColumn();
         if (lastFocusedColumn !== null) {
-            lastFocusedColumn.restoreToTiled(window);
+            lastFocusedColumn.restoreToTiled();
         }
         this.lastFocusedColumn = column;
-        this.desktop.scrollToColumn(column, false);
+        this.desktop.scrollToColumn(column);
     }
 
     public onScreenSizeChanged() {

src/layout/LayoutConfig.ts

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

src/layout/Window.ts

@@ -7,29 +7,24 @@ class Window {
 
     constructor(client: ClientWrapper, column: Column) {
         this.client = client;
-        this.height = client.kwinClient.frameGeometry.height.round();
-
-        let maximizedMode = this.client.getMaximizedMode();
-        if (maximizedMode === undefined) {
-            maximizedMode = MaximizedMode.Unmaximized; // defaulting to unmaximized, as this is set in Tiled.prepareClientForTiling
-        }
+        this.height = client.kwinClient.frameGeometry.height;
         this.focusedState = {
-            fullScreen: this.client.kwinClient.fullScreen,
-            maximizedMode: maximizedMode,
+            fullScreen: false,
+            maximizedHorizontally: false,
+            maximizedVertically: false,
         };
-
-        this.skipArrange = this.client.kwinClient.fullScreen || maximizedMode !== MaximizedMode.Unmaximized;
+        this.skipArrange = false;
         this.column = column;
-        column.onWindowAdded(this, true);
+        column.onWindowAdded(this);
     }
 
-    public moveToColumn(targetColumn: Column, bottom: boolean, passFocus: FocusPassing.Type) {
+    public moveToColumn(targetColumn: Column) {
         if (targetColumn === this.column) {
             return;
         }
-        this.column.onWindowRemoved(this, passFocus);
+        this.column.onWindowRemoved(this, false);
         this.column = targetColumn;
-        targetColumn.onWindowAdded(this, bottom);
+        targetColumn.onWindowAdded(this);
     }
 
     public arrange(x: number, y: number, width: number, height: number) {
@@ -42,11 +37,8 @@ class Window {
         if (this.column.grid.config.reMaximize && this.isFocused()) {
             // do this here rather than in `onFocused` to ensure it happens after placement
             // (otherwise placement may not happen at all)
-            if (this.focusedState.maximizedMode !== MaximizedMode.Unmaximized) {
-                this.client.setMaximize(
-                    this.focusedState.maximizedMode === MaximizedMode.Horizontally || this.focusedState.maximizedMode === MaximizedMode.Maximized,
-                    this.focusedState.maximizedMode === MaximizedMode.Vertically || this.focusedState.maximizedMode === MaximizedMode.Maximized,
-                );
+            if (this.focusedState.maximizedVertically || this.focusedState.maximizedHorizontally) {
+                this.client.setMaximize(this.focusedState.maximizedVertically, this.focusedState.maximizedHorizontally);
                 maximized = true;
             }
             if (this.focusedState.fullScreen) {
@@ -60,12 +52,11 @@ class Window {
     }
 
     public focus() {
-        this.client.focus();
-        const kwinClient = this.client.kwinClient;
-        if (!this.isFocused()) {
-            // in some situations focus assignment just doesn't work, let's do it later
-            this.column.grid.focusPasser.request(kwinClient);
+        if (this.client.isShaded()) {
+            // workaround for KWin deactivating clients when unshading immediately after activation
+            this.client.setShade(false);
         }
+        this.client.focus();
     }
 
     public isFocused() {
@@ -73,14 +64,6 @@ 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);
     }
 
@@ -90,10 +73,11 @@ class Window {
         }
         this.client.setFullScreen(false);
         this.client.setMaximize(false, false);
+        this.column.grid.desktop.onLayoutChanged();
     }
 
-    public onMaximizedChanged(maximizedMode: MaximizedMode) {
-        const maximized = maximizedMode !== MaximizedMode.Unmaximized;
+    public onMaximizedChanged(horizontally: boolean, vertically: boolean) {
+        const maximized = horizontally || vertically;
         this.skipArrange = maximized;
         if (this.column.grid.config.tiledKeepBelow) {
             this.client.kwinClient.keepBelow = !maximized;
@@ -102,7 +86,8 @@ class Window {
             this.client.kwinClient.keepAbove = maximized;
         }
         if (this.isFocused()) {
-            this.focusedState.maximizedMode = maximizedMode;
+            this.focusedState.maximizedHorizontally = horizontally;
+            this.focusedState.maximizedVertically = vertically;
         }
         this.column.grid.desktop.onLayoutChanged();
     }
@@ -121,20 +106,46 @@ 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.round(), true);
+        this.column.setWidth(newGeometry.width, true);
         this.column.grid.desktop.onLayoutChanged();
     }
 
-    public destroy(passFocus: FocusPassing.Type) {
+    public destroy(passFocus: boolean) {
         this.column.onWindowRemoved(this, passFocus);
     }
 }
 
 namespace Window {
-    export interface State {
-        fullScreen: boolean;
-        maximizedMode: MaximizedMode;
+    export type State = {
+        fullScreen: boolean,
+        maximizedHorizontally: boolean,
+        maximizedVertically: boolean,
     }
 }

src/lib/behavior/PresetWidths.ts

@@ -1,62 +0,0 @@
-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/RawResizer.ts

@@ -1,43 +0,0 @@
-class RawResizer {
-    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) {
-        const newWidth = findMinPositive(
-            [
-                ...this.presetWidths.getWidths(column.getMinWidth(), column.getMaxWidth()),
-            ],
-            width => column.getWidth() - width,
-        );
-        if (newWidth === undefined) {
-            return;
-        }
-        column.setWidth(newWidth, true);
-    }
-
-    public maximizeWidth(column: Column) {
-        const presetWidths = this.presetWidths.getWidths(column.getMinWidth(), column.getMaxWidth());
-        const maxWidth = presetWidths[presetWidths.length-1];
-        column.setWidth(maxWidth, true);
-    }
-
-    public minimizeWidth(column: Column) {
-        const presetWidths = this.presetWidths.getWidths(column.getMinWidth(), column.getMaxWidth());
-        const minWidth = presetWidths[0];
-        column.setWidth(minWidth, true);
-    }
-}

src/lib/config/config.ts

@@ -1,29 +0,0 @@
-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;
-    tiledDesktops: string;
-}

src/lib/extern/dbuscall.ts

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

src/lib/extern/global.d.ts

@@ -1 +0,0 @@
-declare const console: Console;

src/lib/extern/kwin.ts

@@ -1,111 +0,0 @@
-interface KWin {
-    __brand: "KWin";
-
-    readConfig(key: string, defaultValue: any): any;
-}
-
-interface Workspace {
-    __brand: "Workspace";
-
-    readonly activities: string[];
-    readonly desktops: KwinDesktop[];
-    readonly currentDesktop: KwinDesktop;
-    readonly currentActivity: string;
-    readonly activeScreen: Output;
-    readonly windows: KwinClient[];
-    readonly cursorPos: Readonly<QmlPoint>;
-
-    activeWindow: KwinClient|null;
-
-    readonly currentDesktopChanged: QSignal<[]>;
-    readonly windowAdded: QSignal<[KwinClient]>;
-    readonly windowRemoved: QSignal<[KwinClient]>;
-    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,
-    MovementArea,
-    MaximizeArea,
-    MaximizeFullArea,
-    FullScreenArea,
-    WorkArea,
-    FullArea,
-    ScreenArea,
-}
-
-const enum MaximizedMode {
-    Unmaximized,
-    Vertically,
-    Horizontally,
-    Maximized,
-}
-
-interface Tile { __brand: "Tile" }
-interface Output { __brand: "Output" }
-
-interface KwinClient {
-    __brand: "KwinClient";
-
-    readonly caption: string;
-    readonly minSize: Readonly<QmlSize>;
-    readonly transient: boolean;
-    readonly transientFor: KwinClient | null;
-    readonly clientGeometry: Readonly<QmlRect>;
-    readonly move: boolean;
-    readonly resize: boolean;
-    readonly moveable: boolean;
-    readonly resizeable: boolean;
-    readonly fullScreenable: boolean;
-    readonly maximizable: boolean;
-    readonly output: Output;
-    readonly resourceClass: string;
-    readonly dock: boolean;
-    readonly normalWindow: boolean;
-    readonly managed: boolean;
-    readonly popupWindow: boolean;
-    readonly pid: number;
-
-    fullScreen: boolean;
-    activities: string[]; // empty array means all activities
-    skipSwitcher: boolean;
-    keepAbove: boolean;
-    keepBelow: boolean;
-    minimized: boolean;
-    frameGeometry: QmlRect;
-    desktops: KwinDesktop[]; // empty array means all desktops
-    tile: Tile|null;
-    opacity: number;
-
-    readonly fullScreenChanged: QSignal<[]>;
-    readonly desktopsChanged: QSignal<[]>;
-    readonly activitiesChanged: QSignal<[]>;
-    readonly minimizedChanged: QSignal<[]>;
-    readonly maximizedAboutToChange: QSignal<[MaximizedMode]>;
-    readonly captionChanged: QSignal<[]>;
-    readonly tileChanged: QSignal<[]>;
-    readonly interactiveMoveResizeStarted: QSignal<[]>;
-    readonly interactiveMoveResizeFinished: QSignal<[]>;
-    readonly frameGeometryChanged: QSignal<[oldGeometry: QmlRect]>;
-
-    setMaximize(vertically: boolean, horizontally: boolean): void;
-}
-
-interface KwinDesktop {
-    __brand: "KwinDesktop";
-
-    readonly id: string;
-    readonly name: string;
-}
-
-interface ShortcutHandler extends QmlObject {
-    readonly activated: QSignal<[]>;
-    destroy(): void;
-}

src/lib/extern/notification.ts

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

src/lib/extern/qt.ts

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

src/lib/keyBindings/Actions.ts

@@ -1,486 +0,0 @@
-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 desktop = dm.getCurrentDesktop();
-        if (desktop === undefined) {
-            return;
-        }
-        const grid = desktop.grid;
-        const firstColumn = grid.getFirstColumn();
-        if (firstColumn === null) {
-            return;
-        }
-        firstColumn.getWindowToFocus().focus();
-    };
-
-    public readonly focusEnd = (cm: ClientManager, dm: DesktopManager) => {
-        const desktop = dm.getCurrentDesktop();
-        if (desktop === undefined) {
-            return;
-        }
-        const grid = desktop.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 columnWidthMaximize = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
-        this.config.columnResizer.maximizeWidth(column);
-    };
-
-
-    public readonly columnWidthMinimize = (cm: ClientManager, dm: DesktopManager, window: Window, column: Column, grid: Grid) => {
-        this.config.columnResizer.minimizeWidth(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();
-        if (desktop === undefined) {
-            return;
-        }
-        const visibleRange = desktop.getCurrentVisibleRange();
-        const visibleColumns = Array.from(desktop.grid.getVisibleColumns(visibleRange));
-
-        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));
-        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));
-        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) => {
-        const desktop = desktopManager.getCurrentDesktop();
-        if (desktop !== undefined) {
-            desktop.adjustScroll(amount, false);
-        }
-    };
-
-    public readonly gridScrollStart = (cm: ClientManager, dm: DesktopManager) => {
-        const desktop = dm.getCurrentDesktop();
-        if (desktop === undefined) {
-            return;
-        }
-        const grid = desktop.grid;
-        const firstColumn = grid.getFirstColumn();
-        if (firstColumn === null) {
-            return;
-        }
-        grid.desktop.scrollToColumn(firstColumn, false);
-    };
-
-    public readonly gridScrollEnd = (cm: ClientManager, dm: DesktopManager) => {
-        const desktop = dm.getCurrentDesktop();
-        if (desktop === undefined) {
-            return;
-        }
-        const grid = desktop.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 desktop = dm.getCurrentDesktop();
-        if (desktop === undefined) {
-            return;
-        }
-        const grid = desktop.grid;
-        const column = grid.getLeftmostVisibleColumn(grid.desktop.getCurrentVisibleRange());
-        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 desktop = dm.getCurrentDesktop();
-        if (desktop === undefined) {
-            return;
-        }
-        const grid = desktop.grid;
-        const column = grid.getRightmostVisibleColumn(grid.desktop.getCurrentVisibleRange());
-        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 desktop = dm.getCurrentDesktop();
-        if (desktop === undefined) {
-            return;
-        }
-        const grid = desktop.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 newDesktop = dm.getDesktopInCurrentActivity(kwinDesktop);
-        if (newDesktop === undefined) {
-            return;
-        }
-        const newGrid = newDesktop.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 newDesktop = dm.getDesktopInCurrentActivity(kwinDesktop);
-        if (newDesktop === undefined) {
-            return;
-        }
-        const newGrid = newDesktop.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;
-        maximizeWidth(column: Column): void;
-        minimizeWidth(column: Column): void;
-    }
-}

src/lib/keyBindings/definition.ts

@@ -1,283 +0,0 @@
-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: "column-width-maximize",
-            description: "Increase column width to maximum",
-            action: () => world.doIfTiledFocused(actions.columnWidthMaximize),
-        },
-        {
-            name: "column-width-minimize",
-            description: "Decrease column width to minimum",
-            action: () => world.doIfTiledFocused(actions.columnWidthMinimize),
-        },
-        {
-            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),
-        },
-    ];
-}
-
-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,68 +0,0 @@
-interface KeyBinding {
-    name: string;
-    description: string;
-    comment?: string;
-    defaultKeySequence?: string;
-    action: () => void;
-}
-
-interface NumKeyBinding {
-    name: string;
-    description: string;
-    comment?: string;
-    defaultModifiers: string;
-    fKeys: boolean;
-    action: (i: number) => void;
-}
-
-function catchWrap(f: () => void) {
-    return () => {
-        try {
-            f();
-        } catch (error: any) {
-            log(error);
-            log(error.stack);
-        }
-    };
-}
-
-function registerKeyBinding(shortcutActions: ShortcutAction[], keyBinding: KeyBinding) {
-    shortcutActions.push(new ShortcutAction(
-        keyBinding,
-        catchWrap(keyBinding.action),
-    ));
-}
-
-function registerNumKeyBindings(shortcutActions: ShortcutAction[], numKeyBinding: NumKeyBinding) {
-    const numPrefix = numKeyBinding.fKeys ? "F" : "";
-    const n = numKeyBinding.fKeys ? 12 : 9;
-    for (let i = 0; i < 12; i++) {
-        const numKey = String(i + 1);
-        const keySequence = i < n ?
-            numKeyBinding.defaultModifiers + "+" + numPrefix + numKey :
-            "";
-        shortcutActions.push(new ShortcutAction(
-            {
-                name: applyMacro(numKeyBinding.name, numKey),
-                description: applyMacro(numKeyBinding.description, numKey),
-                defaultKeySequence: keySequence,
-            },
-            catchWrap(() => numKeyBinding.action(i)),
-        ));
-    }
-}
-
-function registerKeyBindings(world: World, config: Actions.Config) {
-    const actions = new Actions(config);
-    const shortcutActions: ShortcutAction[] = [];
-
-    for (const keyBinding of getKeyBindings(world, actions)) {
-        registerKeyBinding(shortcutActions, keyBinding);
-    }
-
-    for (const numKeyBinding of getNumKeyBindings(world, actions)) {
-        registerNumKeyBindings(shortcutActions, numKeyBinding);
-    }
-
-    return shortcutActions;
-}

src/lib/layout/LayoutConfig.ts

@@ -1,14 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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/rules/ClientMatcher.ts

@@ -1,19 +0,0 @@
-class ClientMatcher {
-    private readonly regex: RegExp;
-
-    constructor(regex: RegExp) {
-        this.regex = regex;
-    }
-
-    public matches(kwinClient: KwinClient) {
-        return this.regex.test(ClientMatcher.getClientString(kwinClient));
-    }
-
-    public static getClientString(kwinClient: KwinClient) {
-        return ClientMatcher.getRuleString(kwinClient.resourceClass, kwinClient.caption);
-    }
-
-    public static getRuleString(ruleClass: string, ruleCaption: string) {
-        return ruleClass + "\0" + ruleCaption;
-    }
-}

src/lib/rules/DesktopFilter.ts

@@ -1,30 +0,0 @@
-class DesktopFilter {
-    private readonly desktopRegex: RegExp | null; // null means all desktops
-
-    constructor(desktopsConfig: string) {
-        this.desktopRegex = DesktopFilter.parseDesktopConfig(desktopsConfig);
-    }
-
-    public shouldWorkOnDesktop(kwinDesktop: KwinDesktop): boolean {
-        if (this.desktopRegex === null) {
-            return true; // Work on all desktops
-        }
-        return this.desktopRegex.test(kwinDesktop.name);
-    }
-
-    private static parseDesktopConfig(config: string): RegExp | null {
-        const trimmed = config.trim();
-
-        if (trimmed.length === 0) {
-            return null; // Empty config means work on all desktops
-        }
-
-        try {
-            return new RegExp(`^${trimmed}$`);
-        } catch (e) {
-            notificationInvalidTiledDesktops.sendEvent();
-            log(`Invalid regex pattern in tiledDesktops config: ${trimmed}. Working on all desktops.`);
-            return null; // Invalid regex means work on all desktops as fallback
-        }
-    }
-}

src/lib/rules/WindowRule.ts

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

src/lib/rules/WindowRuleEnforcer.ts

@@ -1,95 +0,0 @@
-class WindowRuleEnforcer {
-    private readonly preferFloating: ClientMatcher;
-    private readonly preferTiling: ClientMatcher;
-    private readonly followCaption: RegExp;
-
-    constructor(windowRules: WindowRule[]) {
-        const [floatRegex, tileRegex, followCaptionRegex] = WindowRuleEnforcer.createWindowRuleRegexes(windowRules);
-        this.preferFloating = new ClientMatcher(floatRegex);
-        this.preferTiling = new ClientMatcher(tileRegex);
-        this.followCaption = followCaptionRegex;
-    }
-
-    public shouldTile(kwinClient: KwinClient) {
-        return this.preferTiling.matches(kwinClient) || (
-            kwinClient.normalWindow &&
-            !kwinClient.transient &&
-            kwinClient.managed &&
-            kwinClient.pid > -1 &&
-            !kwinClient.fullScreen &&
-            !Clients.isFullScreenGeometry(kwinClient) &&
-            !this.preferFloating.matches(kwinClient)
-        );
-    }
-
-    public initClientSignalManager(world: World, kwinClient: KwinClient) {
-        if (!this.followCaption.test(kwinClient.resourceClass)) {
-            return null;
-        }
-
-        const enforcer = this;
-        const manager = new SignalManager();
-        manager.connect(kwinClient.captionChanged, () => {
-            const shouldTile = Clients.canTileNow(kwinClient) && enforcer.shouldTile(kwinClient);
-            world.do((clientManager, desktopManager) => {
-                const desktop = desktopManager.getDesktopForClient(kwinClient);
-                if (shouldTile && desktop !== undefined) {
-                    clientManager.tileKwinClient(kwinClient, desktop.grid);
-                } else {
-                    clientManager.floatKwinClient(kwinClient);
-                }
-            });
-        });
-        return manager;
-    }
-
-    private static createWindowRuleRegexes(windowRules: WindowRule[]) {
-        const floatRegexes: string[] = [];
-        const tileRegexes: string[] = [];
-        const followCaptionRegexes: string[] = [];
-        for (const windowRule of windowRules) {
-            const ruleClass = WindowRuleEnforcer.parseRegex(windowRule.class);
-            const ruleCaption = WindowRuleEnforcer.parseRegex(windowRule.caption);
-            const ruleString = ClientMatcher.getRuleString(
-                WindowRuleEnforcer.wrapParens(ruleClass),
-                WindowRuleEnforcer.wrapParens(ruleCaption),
-            );
-
-            (windowRule.tile ? tileRegexes : floatRegexes).push(ruleString);
-            if (ruleCaption !== ".*") {
-                followCaptionRegexes.push(ruleClass);
-            }
-        }
-
-        return [
-            WindowRuleEnforcer.joinRegexes(floatRegexes),
-            WindowRuleEnforcer.joinRegexes(tileRegexes),
-            WindowRuleEnforcer.joinRegexes(followCaptionRegexes),
-        ];
-    }
-
-    private static parseRegex(rawRule: string | undefined) {
-        if (rawRule === undefined || rawRule === "" || rawRule === ".*") {
-            return ".*";
-        } else {
-            return rawRule;
-        }
-    }
-
-    private static joinRegexes(regexes: string[]) {
-        if (regexes.length === 0) {
-            return new RegExp("a^"); // match nothing
-        }
-
-        if (regexes.length === 1) {
-            return new RegExp("^(" + regexes[0] + ")$");
-        }
-
-        const joinedRegexes = regexes.map(WindowRuleEnforcer.wrapParens).join("|");
-        return new RegExp("^(" + joinedRegexes + ")$");
-    }
-
-    private static wrapParens(str: string) {
-        return "(" + str + ")";
-    }
-}

src/lib/utils/RateLimiter.ts

@@ -1,24 +0,0 @@
-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,37 +0,0 @@
-class ShortcutAction {
-    private readonly shortcutHandler: ShortcutHandler;
-
-    constructor(keyBinding: ShortcutAction.KeyBinding, f: () => void) {
-        this.shortcutHandler = ShortcutAction.initShortcutHandler(keyBinding);
-        this.shortcutHandler.activated.connect(f);
-    }
-
-    public destroy() {
-        this.shortcutHandler.destroy();
-    }
-
-    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}";
-${sequenceLine}}`,
-            qmlBase,
-        ) as ShortcutHandler;
-    }
-}
-
-namespace ShortcutAction {
-    export interface KeyBinding {
-        name: string;
-        description: string;
-        defaultKeySequence?: string;
-    }
-}

src/lib/utils/collections.ts

@@ -1,39 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

@@ -1,28 +0,0 @@
-interface Number {
-    round(this: number): number;
-    floor(this: number): number;
-    ceil(this: number): number;
-}
-
-Number.prototype.round = function() {
-    return Math.round(this);
-};
-
-Number.prototype.floor = function() {
-    return Math.floor(this);
-};
-
-Number.prototype.ceil = function() {
-    return Math.ceil(this);
-};
-
-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

@@ -1,57 +0,0 @@
-function clamp(value: number, min: number, max: number) {
-    if (value < min) {
-        return min;
-    }
-    if (value > max) {
-        return max;
-    }
-    return value;
-}
-
-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 rectRight(rect: QmlRect) {
-    return rect.x + rect.width;
-}
-
-function rectBottom(rect: QmlRect) {
-    return rect.y + rect.height;
-}
-
-function rectContainsPoint(rect: QmlRect, point: QmlPoint) {
-    return rect.x <= point.x &&
-        rectRight(rect) >= point.x &&
-        rect.y <= point.y &&
-        rectBottom(rect) >= point.y;
-}
-
-function roundQtRect(rect: QmlRect) {
-    return Qt.rect(
-        rect.x.round(),
-        rect.y.round(),
-        rect.width.round(),
-        rect.height.round(),
-    );
-}
-
-function rectRightRound(rect: QmlRect) {
-    return rect.x.round() + rect.width.round();
-}
-
-function rectBottomRound(rect: QmlRect) {
-    return rect.y.round() + rect.height.round();
-}

src/lib/utils/strings.ts

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

src/lib/workspace.ts

@@ -1,58 +0,0 @@
-function initWorkspaceSignalHandlers(world: World, focusPasser: FocusPassing.Passer) {
-    const manager = new SignalManager();
-
-    manager.connect(Workspace.windowAdded, (kwinClient: KwinClient) => {
-        world.do((clientManager, desktopManager) => {
-            clientManager.addClient(kwinClient);
-        });
-    });
-
-    manager.connect(Workspace.windowRemoved, (kwinClient: KwinClient) => {
-        world.do((clientManager, desktopManager) => {
-            clientManager.removeClient(kwinClient, FocusPassing.Type.Immediate);
-        });
-    });
-
-    manager.connect(Workspace.windowActivated, (kwinClient: KwinClient|null) => {
-        if (kwinClient === null) {
-            focusPasser.activate();
-        } else {
-            focusPasser.clearIfDifferent(kwinClient);
-            world.do((clientManager, desktopManager) => {
-                clientManager.onClientFocused(kwinClient);
-            });
-        }
-    });
-
-    manager.connect(Workspace.currentDesktopChanged, () => {
-        world.do(() => {}); // re-arrange desktop
-    });
-
-    manager.connect(Workspace.currentActivityChanged, () => {
-        world.do(() => {}); // re-arrange desktop
-    });
-
-    manager.connect(Workspace.screensChanged, () => {
-        world.do((clientManager, desktopManager) => {
-            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, () => {
-        world.onScreenResized();
-    });
-
-    return manager;
-}

src/lib/world/Clients.ts

@@ -1,61 +0,0 @@
-namespace Clients {
-    const prohibitedClasses = [
-        "ksmserver-logout-greeter",
-        "xwaylandvideobridge",
-    ];
-
-    export function canTileEver(kwinClient: KwinClient) {
-        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;
-    }
-
-    export function makeTileable(kwinClient: KwinClient) {
-        if (kwinClient.minimized) {
-            kwinClient.minimized = false;
-        }
-        if (kwinClient.desktops.length !== 1) {
-            kwinClient.desktops = [Workspace.currentDesktop];
-        }
-        if (kwinClient.activities.length !== 1) {
-            kwinClient.activities = [Workspace.currentActivity];
-        }
-    }
-
-    export function getKwinDesktopApprox(kwinClient: KwinClient) {
-        switch (kwinClient.desktops.length) {
-        case 0:
-            return Workspace.currentDesktop;
-        case 1:
-            return kwinClient.desktops[0];
-        default:
-            if (kwinClient.desktops.includes(Workspace.currentDesktop)) {
-                return Workspace.currentDesktop;
-            } else {
-                return kwinClient.desktops[0];
-            }
-        }
-    }
-
-    export function isFullScreenGeometry(kwinClient: KwinClient) {
-        const fullScreenArea = Workspace.clientArea(ClientAreaOption.FullScreenArea, kwinClient.output, getKwinDesktopApprox(kwinClient));
-        return kwinClient.clientGeometry.width.round() >= fullScreenArea.width &&
-            kwinClient.clientGeometry.height.round() >= fullScreenArea.height;
-    }
-
-    export function isOnVirtualDesktop(kwinClient: KwinClient, kwinDesktop: KwinDesktop) {
-        return kwinClient.desktops.length === 0 || kwinClient.desktops.includes(kwinDesktop);
-    }
-
-    export function isOnOneOfVirtualDesktops(kwinClient: KwinClient, kwinDesktops: KwinDesktop[]) {
-        return kwinClient.desktops.length === 0 || kwinClient.desktops.some(d => kwinDesktops.includes(d));
-    }
-}

src/lib/world/DesktopManager.ts

@@ -1,145 +0,0 @@
-class DesktopManager {
-    private readonly desktops: Map<string, Desktop>; // key is activityId|desktopId
-    private selectedScreen: Output;
-    private kwinActivities: Set<string>;
-    private kwinDesktops: Set<KwinDesktop>;
-
-    constructor(
-        private readonly pinManager: PinManager,
-        private readonly config: Desktop.Config,
-        private readonly layoutConfig: LayoutConfig,
-        private readonly focusPasser: FocusPassing.Passer,
-        private readonly desktopFilter: DesktopFilter,
-    ) {
-        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);
-    }
-
-    public getDesktop(activity: string, kwinDesktop: KwinDesktop) {
-        if (!this.desktopFilter.shouldWorkOnDesktop(kwinDesktop)) {
-            return undefined;
-        }
-        const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
-        const desktop = this.desktops.get(desktopKey);
-        if (desktop !== undefined) {
-            return desktop;
-        } else {
-            return this.addDesktop(activity, kwinDesktop);
-        }
-    }
-
-    public getCurrentDesktop() {
-        return this.getDesktop(Workspace.currentActivity, Workspace.currentDesktop);
-    }
-
-    public getDesktopInCurrentActivity(kwinDesktop: KwinDesktop) {
-        return this.getDesktop(Workspace.currentActivity, kwinDesktop);
-    }
-
-    public getDesktopForClient(kwinClient: KwinClient) {
-        if (kwinClient.activities.length !== 1 || kwinClient.desktops.length !== 1) {
-            return undefined;
-        }
-        return this.getDesktop(kwinClient.activities[0], kwinClient.desktops[0]);
-    }
-
-    private addDesktop(activity: string, kwinDesktop: KwinDesktop) {
-        const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
-        const desktop = new Desktop(
-            kwinDesktop,
-            this.pinManager,
-            this.config,
-            () => this.selectedScreen,
-            this.layoutConfig,
-            this.focusPasser,
-        );
-        this.desktops.set(desktopKey, desktop);
-        return desktop;
-    }
-
-    private static getDesktopKey(activity: string, kwinDesktop: KwinDesktop) {
-        return activity + "|" + kwinDesktop.id;
-    }
-
-    public updateActivities() {
-        const newActivities = new Set(Workspace.activities);
-        for (const activity of this.kwinActivities) {
-            if (!newActivities.has(activity)) {
-                this.removeActivity(activity);
-            }
-        }
-        this.kwinActivities = newActivities;
-    }
-
-    public updateDesktops() {
-        const newDesktops = new Set(Workspace.desktops);
-        for (const desktop of this.kwinDesktops) {
-            if (!newDesktops.has(desktop)) {
-                this.removeKwinDesktop(desktop);
-            }
-        }
-        this.kwinDesktops = newDesktops;
-    }
-
-    public selectScreen(screen: Output) {
-        this.selectedScreen = screen;
-    }
-
-    private removeActivity(activity: string) {
-        for (const kwinDesktop of this.kwinDesktops) {
-            this.destroyDesktop(activity, kwinDesktop);
-        }
-    }
-
-    private removeKwinDesktop(kwinDesktop: KwinDesktop) {
-        for (const activity of this.kwinActivities) {
-            this.destroyDesktop(activity, kwinDesktop);
-        }
-    }
-
-    private destroyDesktop(activity: string, kwinDesktop: KwinDesktop) {
-        const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
-        const desktop = this.desktops.get(desktopKey);
-        if (desktop !== undefined) {
-            desktop.destroy();
-            this.desktops.delete(desktopKey);
-        }
-    }
-
-    public destroy() {
-        for (const desktop of this.desktops.values()) {
-            desktop.destroy();
-        }
-    }
-
-    public *getAllDesktops() {
-        for (const desktop of this.desktops.values()) {
-            yield desktop;
-        }
-    }
-
-    public getDesktopsForClient(kwinClient: KwinClient) {
-        const desktops = this.getDesktops(kwinClient.activities, kwinClient.desktops); // workaround for QTBUG-109880
-        return desktops;
-    }
-
-    // empty array means all
-    public *getDesktops(activities: string[], kwinDesktops: KwinDesktop[]) {
-        const matchedActivities = activities.length > 0 ? activities : this.kwinActivities.keys();
-        const matchedDesktops = kwinDesktops.length > 0 ? kwinDesktops : this.kwinDesktops.keys();
-        for (const matchedActivity of matchedActivities) {
-            for (const matchedDesktop of matchedDesktops) {
-                const desktopKey = DesktopManager.getDesktopKey(matchedActivity, matchedDesktop);
-                const desktop = this.desktops.get(desktopKey);
-                if (desktop !== undefined) {
-                    yield desktop;
-                }
-            }
-        }
-    }
-}

src/lib/world/FocusPassing.ts

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

src/lib/world/World.ts

@@ -1,182 +0,0 @@
-class World {
-    private readonly desktopManager: DesktopManager;
-    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) {
-        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,
-            presetWidths: presetWidths,
-            columnResizer: config.scrollingCentered ? new RawResizer(presetWidths) : new ContextualResizer(presetWidths),
-        });
-
-        this.screenResizedDelayer = new Delayer(1000, () => {
-            // this delay ensures that docks are taken into account by `Workspace.clientArea`
-            for (const desktop of this.desktopManager.getAllDesktops()) {
-                desktop.onLayoutChanged();
-            }
-            this.update();
-        });
-
-        this.pinManager = new PinManager();
-
-        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,
-            reMaximize: config.reMaximize,
-            skipSwitcher: config.skipSwitcher,
-            tiledKeepBelow: config.tiledKeepBelow,
-            maximizedKeepAbove: config.floatingKeepAbove,
-            untileOnDrag: config.untileOnDrag,
-        };
-
-        this.desktopManager = new DesktopManager(
-            this.pinManager,
-            {
-                marginTop: config.gapsOuterTop,
-                marginBottom: config.gapsOuterBottom,
-                marginLeft: config.gapsOuterLeft,
-                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,
-            new DesktopFilter(config.tiledDesktops),
-        );
-        this.clientManager = new ClientManager(config, this, this.desktopManager, this.pinManager);
-        this.addExistingClients();
-        this.update();
-    }
-
-    private static createScroller(config: Config) {
-        if (config.scrollingLazy) {
-            return new LazyScroller();
-        } else if (config.scrollingCentered) {
-            return new CenteredScroller();
-        } else if (config.scrollingGrouped) {
-            return new GroupedScroller();
-        } else {
-            log("No scrolling mode selected, using default");
-            return new LazyScroller();
-        }
-    }
-
-    private addExistingClients() {
-        for (const kwinClient of Workspace.windows) {
-            this.clientManager.addClient(kwinClient);
-        }
-    }
-
-    private update() {
-        const currentDesktop = this.desktopManager.getCurrentDesktop();
-        if (currentDesktop !== undefined) {
-            currentDesktop.arrange();
-            this.moveCursorToFocus();
-        }
-    }
-
-    private moveCursorToFocus() {
-        if (this.cursorFollowsFocus && Workspace.activeWindow !== null) {
-            // Only move cursor for tiled windows
-            const tiledWindow = this.clientManager.findTiledWindow(Workspace.activeWindow);
-            if (tiledWindow === null) {
-                return;
-            }
-            const cursorAlreadyInFocus = rectContainsPoint(roundQtRect(Workspace.activeWindow.frameGeometry), Workspace.cursorPos);
-            if (cursorAlreadyInFocus) {
-                return;
-            }
-            moveCursorToFocus.call();
-        }
-    }
-
-    public do(f: (clientManager: ClientManager, desktopManager: DesktopManager) => void) {
-        f(this.clientManager, this.desktopManager);
-        this.update();
-    }
-
-    public doIfTiled(
-        kwinClient: KwinClient,
-        f: (clientManager: ClientManager, desktopManager: DesktopManager, window: Window, column: Column, grid: Grid) => void,
-    ) {
-        const window = this.clientManager.findTiledWindow(kwinClient);
-        if (window === null) {
-            return;
-        }
-        const column = window.column;
-        const grid = column.grid;
-        f(this.clientManager, this.desktopManager, window, column, grid);
-        this.update();
-    }
-
-    public doIfTiledFocused(
-        f: (clientManager: ClientManager, desktopManager: DesktopManager, window: Window, column: Column, grid: Grid) => void,
-    ) {
-        if (Workspace.activeWindow === null) {
-            return;
-        }
-        this.doIfTiled(Workspace.activeWindow, f);
-    }
-
-    public gestureScroll(amount: number) {
-        this.do((clientManager, desktopManager) => {
-            const currentDesktop = desktopManager.getCurrentDesktop();
-            if (currentDesktop !== undefined) {
-                currentDesktop.gestureScroll(amount);
-            }
-        });
-    }
-
-    public gestureScrollFinish() {
-        this.do((clientManager, desktopManager) => {
-            const focusedWindow = Workspace.activeWindow === null ? null : clientManager.findTiledWindow(Workspace.activeWindow);
-            const currentDesktop = desktopManager.getCurrentDesktop();
-            if (currentDesktop !== undefined) {
-                console.assert(focusedWindow === null || focusedWindow.column.grid.desktop === currentDesktop);
-                currentDesktop.gestureScrollFinish(focusedWindow);
-            }
-        });
-    }
-
-    public destroy() {
-        this.workspaceSignalManager.destroy();
-        for (const shortcutAction of this.shortcutActions) {
-            shortcutAction.destroy();
-        }
-        this.clientManager.destroy();
-        this.desktopManager.destroy();
-    }
-
-    public onScreenResized() {
-        this.screenResizedDelayer.run();
-    }
-}

src/lib/world/clientState/Tiled.ts

@@ -1,266 +0,0 @@
-namespace ClientState {
-    export class Tiled implements State {
-        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 };
-            Tiled.prepareClientForTiling(client, grid.config);
-
-            const column = new Column(grid, grid.getLastFocusedColumn() ?? grid.getLastColumn());
-            const window = new Window(client, column);
-
-            this.window = window;
-            this.signalManager = Tiled.initSignalManager(world, window, grid.config);
-        }
-
-        public destroy(passFocus: FocusPassing.Type) {
-            this.signalManager.destroy();
-
-            const window = this.window;
-            const grid = window.column.grid;
-            const client = window.client;
-            window.destroy(passFocus);
-
-            Tiled.restoreClientAfterTiling(client, grid.config, this.defaultState, grid.desktop.clientArea);
-        }
-
-        private static initSignalManager(world: World, window: Window, config: LayoutConfig) {
-            const client = window.client;
-            const kwinClient = client.kwinClient;
-            const manager = new SignalManager();
-
-            manager.connect(kwinClient.desktopsChanged, () => {
-                world.do((clientManager, desktopManager) => {
-                    const desktop = desktopManager.getDesktopForClient(kwinClient);
-                    if (desktop === undefined) {
-                        // windows on multiple desktops are not supported
-                        clientManager.floatClient(client);
-                        return;
-                    }
-                    Tiled.moveWindowToGrid(window, desktop.grid);
-                });
-            });
-
-            manager.connect(kwinClient.activitiesChanged, () => {
-                world.do((clientManager, desktopManager) => {
-                    const desktop = desktopManager.getDesktopForClient(kwinClient);
-                    if (desktop === undefined) {
-                        // windows on multiple activities are not supported
-                        clientManager.floatClient(client);
-                        return;
-                    }
-                    Tiled.moveWindowToGrid(window, desktop.grid);
-                });
-            });
-
-            manager.connect(kwinClient.minimizedChanged, () => {
-                console.assert(kwinClient.minimized);
-                world.do((clientManager, desktopManager) => {
-                    clientManager.minimizeClient(kwinClient);
-                });
-            });
-
-            manager.connect(kwinClient.maximizedAboutToChange, (maximizedMode: MaximizedMode) => {
-                world.do(() => {
-                    window.onMaximizedChanged(maximizedMode);
-                });
-            });
-
-            let moving = false;
-            let resizing = false;
-            let resizeStartWidth = 0;
-            let resizeNeighbor: { column: Column, startWidth: number } | undefined;
-            manager.connect(kwinClient.interactiveMoveResizeStarted, () => {
-                if (kwinClient.move) {
-                    if (config.untileOnDrag) {
-                        world.do((clientManager, desktopManager) => {
-                            clientManager.floatClient(client);
-                        });
-                    } else {
-                        moving = true;
-                    }
-                    return;
-                }
-
-                if (kwinClient.resize) {
-                    resizing = true;
-                    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) {
-                    world.do((clientManager, desktopManager) => {
-                        clientManager.pinClient(kwinClient);
-                    });
-                    return;
-                }
-
-                const newGeometry = roundQtRect(client.kwinClient.frameGeometry);
-                if (rectEquals(oldGeometry, newGeometry)) {
-                    // no real changes, nothing to do
-                    return;
-                }
-
-                const oldCenterX = oldGeometry.x + oldGeometry.width/2;
-                const oldCenterY = oldGeometry.y + oldGeometry.height/2;
-                const newCenterX = newGeometry.x + newGeometry.width/2;
-                const newCenterY = newGeometry.y + newGeometry.height/2;
-                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(() => {
-                        if (newGeometry.width !== oldGeometry.width) {
-                            window.column.onUserResizeWidth(
-                                resizeStartWidth,
-                                newGeometry.width - resizeStartWidth,
-                                newGeometry.x !== oldGeometry.x,
-                                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
-                ) {
-                    if (externalFrameGeometryChangedRateLimiter.acquire()) {
-                        world.do(() => window.onFrameGeometryChanged());
-                    }
-                }
-            });
-
-            manager.connect(kwinClient.fullScreenChanged, () => {
-                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, () => {
-                // on X11, this fires after `frameGeometryChanged`
-                if (kwinClient.tile !== null) {
-                    world.do((clientManager, desktopManager) => {
-                        clientManager.pinClient(kwinClient);
-                    });
-                }
-            });
-
-            return manager;
-        }
-
-        private static getResizeNeighborColumn(window: Window) {
-            const kwinClient = window.client.kwinClient;
-            const column = window.column;
-            if (Workspace.cursorPos.x > rectRightRound(kwinClient.clientGeometry)) {
-                return column.grid.getRightColumn(column);
-            } else if (Workspace.cursorPos.x < kwinClient.clientGeometry.x.round()) {
-                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
-                return;
-            }
-
-            const newColumn = new Column(grid, grid.getLastFocusedColumn() ?? grid.getLastColumn());
-            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 (client.kwinClient.fullScreen) {
-                if (config.maximizedKeepAbove) {
-                    client.kwinClient.keepAbove = true;
-                }
-            } else {
-                if (config.tiledKeepBelow) {
-                    client.kwinClient.keepBelow = true;
-                }
-                client.kwinClient.keepAbove = false;
-            }
-
-            if (client.kwinClient.tile !== null) {
-                client.setMaximize(false, true); // disable quick tile mode
-            }
-            client.setMaximize(false, false);
-        }
-
-        private static restoreClientAfterTiling(client: ClientWrapper, config: LayoutConfig, defaultState: Tiled.WindowState, screenSize: QmlRect) {
-            if (config.skipSwitcher) {
-                client.kwinClient.skipSwitcher = defaultState.skipSwitcher;
-            }
-            if (config.tiledKeepBelow) {
-                client.kwinClient.keepBelow = false;
-            }
-            if (config.offScreenOpacity < 1.0) {
-                client.kwinClient.opacity = 1.0;
-            }
-            client.setFullScreen(false);
-            if (client.kwinClient.tile === null) {
-                client.setMaximize(false, false);
-            }
-            client.ensureVisible(screenSize);
-        }
-    }
-
-    namespace Tiled {
-        export interface WindowState {
-            skipSwitcher: boolean;
-        }
-    }
-}

src/lib/world/clientState/TiledMinimized.ts

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

src/main.ts

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

src/main/tsconfig.json

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

src/rules/ClientMatcher.ts

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

src/rules/WindowRule.ts

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

src/rules/WindowRuleEnforcer.ts

@@ -0,0 +1,90 @@
+class WindowRuleEnforcer {
+    private readonly preferFloating: ClientMatcher;
+    private readonly preferTiling: ClientMatcher;
+    private readonly followCaption: Set<string>;
+
+    constructor(windowRules: WindowRule[]) {
+        const [mapFloat, mapTile] = WindowRuleEnforcer.createWindowRuleMaps(windowRules);
+        this.preferFloating = new ClientMatcher(mapFloat);
+        this.preferTiling = new ClientMatcher(mapTile);
+        this.followCaption = new Set([...mapFloat.keys(), ...mapTile.keys()]);
+    }
+
+    public shouldTile(kwinClient: KwinClient) {
+        return Clients.canTileNow(kwinClient) && (
+            this.preferTiling.matches(kwinClient) || (
+                kwinClient.normalWindow &&
+                !kwinClient.transient &&
+                kwinClient.managed &&
+                !this.preferFloating.matches(kwinClient)
+            )
+        );
+    }
+
+    public initClientSignalManager(world: World, kwinClient: KwinClient) {
+        if (!this.followCaption.has(kwinClient.resourceClass)) {
+            return null;
+        }
+
+        const enforcer = this;
+        const manager = new SignalManager();
+        manager.connect(kwinClient.captionChanged, () => {
+            const shouldTile = enforcer.shouldTile(kwinClient);
+            world.do((clientManager, desktopManager) => {
+                const desktop = desktopManager.getDesktopForClient(kwinClient);
+                if (shouldTile && desktop !== undefined) {
+                    clientManager.tileClient(kwinClient, desktop.grid);
+                } else {
+                    clientManager.untileClient(kwinClient);
+                }
+            });
+        });
+        return manager;
+    }
+
+    private static createWindowRuleMaps(windowRules: WindowRule[]) {
+        const mapFloat = new Map<string, string[]>();
+        const mapTile = new Map<string, string[]>();
+        for (const windowRule of windowRules) {
+            const map = windowRule.tile ? mapTile : mapFloat;
+            let captions = map.get(windowRule.class);
+            if (captions === undefined) {
+                captions = [];
+                map.set(windowRule.class, captions);
+            }
+            if (windowRule.caption !== undefined) {
+                captions.push(windowRule.caption);
+            }
+        }
+
+        return [
+            WindowRuleEnforcer.createWindowRuleRegexMap(mapFloat),
+            WindowRuleEnforcer.createWindowRuleRegexMap(mapTile),
+        ];
+    }
+
+    private static createWindowRuleRegexMap(windowRuleMap: Map<string, string[]>) {
+        const regexMap = new Map<string, RegExp>;
+        for (const [k, v] of windowRuleMap) {
+            regexMap.set(k, WindowRuleEnforcer.joinRegexes(v));
+        }
+        return regexMap;
+    }
+
+    private static joinRegexes(regexes: string[]) {
+        if (regexes.length === 0) {
+            return new RegExp("");
+        }
+
+        if (regexes.length === 1) {
+            return new RegExp("^" + regexes[0] + "$");
+        }
+
+        const joinedRegexes = regexes.map(WindowRuleEnforcer.wrapParens).join("|");
+        return new RegExp("^" + joinedRegexes + "$");
+    }
+
+    private static wrapParens(str: string) {
+        return "(" + str + ")";
+    }
+}

src/tests/flows/centerFocused.ts

@@ -1,43 +0,0 @@
-tests.register("Center focused", 5, () => {
-    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.getActualFrameGeometry());
-    Assert.fullyVisible(client2.getActualFrameGeometry());
-
-    // 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.getActualFrameGeometry());
-    Assert.fullyVisible(client2.getActualFrameGeometry());
-
-    // 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.getActualFrameGeometry());
-    Assert.fullyVisible(client2.getActualFrameGeometry());
-
-    // 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

@@ -1,124 +0,0 @@
-tests.register("columns squeeze side", 5, () => {
-    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].getActualFrameGeometry().width, testCase.widths[i], assertOpt);
-                }
-            }
-        }
-
-        const frames = clients.map(client => client.getActualFrameGeometry());
-        qtMock.fireShortcut(testCase.action);
-        const newFrames = clients.map(client => client.getActualFrameGeometry());
-        for (let i = 0; i < clients.length; i++) {
-            Assert.equalRects(frames[i], newFrames[i], assertOpt);
-        }
-    }
-});
-
-tests.register("columns squeeze side (just scroll)", 5, () => {
-    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: MockKwinClient[], visible: boolean[]) {
-            for (let i = 0; i < clients.length; i++) {
-                if (visible[i]) {
-                    Assert.fullyVisible(clients[i].getActualFrameGeometry(), { message: assertMsg, skip: 1 });
-                } else {
-                    Assert.notFullyVisible(clients[i].getActualFrameGeometry(), { 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.getActualFrameGeometry());
-        qtMock.fireShortcut(testCase.action);
-        const newFrames = clients.map(client => client.getActualFrameGeometry());
-        for (let i = 0; i < clients.length; i++) {
-            Assert.equalRects(frames[i], newFrames[i], { message: assertMsg });
-        }
-    }
-});

src/tests/flows/cursorFollowsFocus.ts

@@ -1,82 +0,0 @@
-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.getActualFrameGeometry(), initialCursorPos), { message: "invalid test setup" });
-    workspaceMock.cursorPos = initialCursorPos.clone();
-
-    runOneOf(
-        () => { Workspace.activeWindow = client1; },
-        () => { qtMock.fireShortcut("karousel-focus-1"); },
-    );
-    Assert.assert(rectContainsPoint(client1.getActualFrameGeometry(), Workspace.cursorPos));
-    Assert.assert(!rectContainsPoint(client2.getActualFrameGeometry(), 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.getActualFrameGeometry(), Workspace.cursorPos));
-    Assert.assert(rectContainsPoint(client2.getActualFrameGeometry(), Workspace.cursorPos));
-
-    runOneOf(
-        () => { Workspace.activeWindow = client1; },
-        () => { qtMock.fireShortcut("karousel-focus-1"); },
-    );
-    Assert.assert(rectContainsPoint(client1.getActualFrameGeometry(), Workspace.cursorPos));
-    Assert.assert(!rectContainsPoint(client2.getActualFrameGeometry(), Workspace.cursorPos));
-    const lastCursorPos = workspaceMock.cursorPos.clone();
-
-    Workspace.activeWindow = null;
-    Assert.assert(pointEquals(Workspace.cursorPos, lastCursorPos), { message: "Cursor should not have been moved" });
-});
-
-tests.register("Cursor follows focus only on matched desktops", 1, () => {
-    // Test that cursor follow focus only works for windows on matched desktops (tiled windows)
-    const config = getDefaultConfig();
-    config.cursorFollowsFocus = true;
-    config.tiledDesktops = "^Desktop 1$"; // Only work on Desktop 1
-    const { workspaceMock, world } = init(config);
-
-    // Create a client on Desktop 1 (matched desktop) - should be tiled
-    const client1 = new MockKwinClient();
-    client1.desktops = [workspaceMock.desktops[0]]; // Desktop 1
-    workspaceMock.createWindows(client1);
-
-    // Create a client on Desktop 2 (non-matched desktop) - should be floating
-    const client2 = new MockKwinClient();
-    client2.desktops = [workspaceMock.desktops[1]]; // Desktop 2
-    workspaceMock.createWindows(client2);
-
-    // Set initial cursor position outside both windows
-    const initialCursorPos = new MockQmlPoint(10, 10);
-    workspaceMock.cursorPos = initialCursorPos.clone();
-
-    // Test 1: Focus client1 on matched desktop (Desktop 1) - cursor should move
-    workspaceMock.currentDesktop = workspaceMock.desktops[0]; // Switch to Desktop 1
-    Workspace.activeWindow = client1;
-    world.do(() => {});
-    Assert.assert(rectContainsPoint(client1.getActualFrameGeometry(), Workspace.cursorPos),
-        { message: "Cursor should have moved to tiled window on matched desktop" });
-
-    // Test 2: Switch to non-matched desktop (Desktop 2) and focus client2 - cursor should NOT move
-    workspaceMock.cursorPos = initialCursorPos.clone();
-    workspaceMock.currentDesktop = workspaceMock.desktops[1]; // Switch to Desktop 2
-    Workspace.activeWindow = client2;
-    world.do(() => {});
-    Assert.assert(pointEquals(Workspace.cursorPos, initialCursorPos),
-        { message: "Cursor should NOT move on non-matched desktop" });
-
-    // Test 3: Even if we focus client1 (tiled) while on Desktop 2, cursor should NOT move
-    // because the current desktop is not matched
-    workspaceMock.cursorPos = initialCursorPos.clone();
-    workspaceMock.currentDesktop = workspaceMock.desktops[1]; // Stay on Desktop 2
-    Workspace.activeWindow = client1;
-    world.do(() => {});
-    Assert.assert(pointEquals(Workspace.cursorPos, initialCursorPos),
-        { message: "Cursor should NOT move even for tiled window when current desktop is not matched" });
-});

src/tests/flows/desktopFiltering.ts

@@ -1,73 +0,0 @@
-tests.register("Desktop filtering", 1, () => {
-    // Test 1: Default config should work on all desktops
-    const config1 = getDefaultConfig();
-    const { workspaceMock: wm1, world: world1 } = init(config1);
-
-    const client1 = new MockKwinClient();
-    client1.desktops = [wm1.desktops[0]];
-    wm1.createWindows(client1);
-
-    world1.do((clientManager) => {
-        Assert.tiledClient(clientManager, client1, { message: "Client should be tiled on desktop1 with default config (*)" });
-    });
-});
-
-tests.register("Desktop filtering - specific desktop", 1, () => {
-    // Test 2: Specific desktop name - should work only on matching desktop
-    const config2 = getDefaultConfig();
-    config2.tiledDesktops = "^Desktop 1$";
-    const { workspaceMock: wm2, world: world2 } = init(config2);
-
-    const client1 = new MockKwinClient();
-    client1.desktops = [wm2.desktops[0]]; // Desktop 1
-    wm2.createWindows(client1);
-    world2.do((clientManager) => {
-        Assert.tiledClient(clientManager, client1, { message: "Client should be tiled on Desktop 1" });
-    });
-
-    wm2.removeWindow(client1);
-
-    const client2 = new MockKwinClient();
-    client2.desktops = [wm2.desktops[1]]; // Desktop 2
-    wm2.createWindows(client2);
-    world2.do((clientManager) => {
-        Assert.notTiledClient(clientManager, client2, { message: "Client should NOT be tiled on Desktop 2" });
-    });
-});
-
-tests.register("Desktop filtering - multiple desktops", 1, () => {
-    // Test 3: Multiple desktop names using regex alternation
-    const config3 = getDefaultConfig();
-    config3.tiledDesktops = "^Desktop [12]$";
-    const { workspaceMock: wm3, world: world3 } = init(config3);
-
-    const client1 = new MockKwinClient();
-    client1.desktops = [wm3.desktops[0]]; // Desktop 1
-    wm3.createWindows(client1);
-    world3.do((clientManager) => {
-        Assert.tiledClient(clientManager, client1, { message: "Client should be tiled on Desktop 1" });
-    });
-
-    wm3.removeWindow(client1);
-
-    const client2 = new MockKwinClient();
-    client2.desktops = [wm3.desktops[1]]; // Desktop 2
-    wm3.createWindows(client2);
-    world3.do((clientManager) => {
-        Assert.tiledClient(clientManager, client2, { message: "Client should be tiled on Desktop 2" });
-    });
-});
-
-tests.register("Desktop filtering - windows on multiple desktops", 1, () => {
-    // Test 4: Windows on multiple desktops should not be tiled (fallback to floating)
-    const config4 = getDefaultConfig();
-    config4.tiledDesktops = ".*";
-    const { workspaceMock: wm4, world: world4 } = init(config4);
-
-    const client1 = new MockKwinClient();
-    client1.desktops = [wm4.desktops[0], wm4.desktops[1]]; // Multiple desktops
-    wm4.createWindows(client1);
-    world4.do((clientManager) => {
-        Assert.notTiledClient(clientManager, client1, { message: "Client on multiple desktops should not be tiled" });
-    });
-});

src/tests/flows/dragTiled.ts

@@ -1,34 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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.x + Math.round((tilingArea.width - width) / 2),
-            tilingArea.y,
-            width,
-            tilingArea.height,
-        );
-    }
-
-    const [client] = workspaceMock.createClientsWithFrames(getClientDesiredFrame(100));
-    Assert.equalRects(client.getActualFrameGeometry(), getTiledFrame(100), { message: "We should tile the window, respecting its desired width" });
-
-    function testExternalResizing() {
-        client.frameGeometry = getClientDesiredFrame(110);
-        Assert.equalRects(client.getActualFrameGeometry(), getTiledFrame(110), { message: "We should re-arrange the window, respecting its new desired width" });
-
-        client.frameGeometry = getClientDesiredFrame(120);
-        Assert.equalRects(client.getActualFrameGeometry(), getTiledFrame(120), { message: "We should re-arrange the window, respecting its new desired width" });
-
-        client.frameGeometry = getClientDesiredFrame(130);
-        Assert.equalRects(client.getActualFrameGeometry(), getTiledFrame(130), { message: "We should re-arrange the window, respecting its new desired width" });
-
-        client.frameGeometry = getClientDesiredFrame(140);
-        Assert.equalRects(client.getActualFrameGeometry(), getTiledFrame(140), { message: "We should re-arrange the window, respecting its new desired width" });
-
-        client.frameGeometry = getClientDesiredFrame(200);
-        Assert.equalRects(client.getActualFrameGeometry(), 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

@@ -1,10 +0,0 @@
-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

@@ -1,191 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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: MockKwinClient[][]) {
-        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

@@ -1,47 +0,0 @@
-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(rectRight(client3.getActualFrameGeometry()), rectRight(tilingArea));
-
-    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(rectRight(client3.getActualFrameGeometry()), rectRight(tilingArea));
-
-    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.getActualFrameGeometry().x, tilingArea.x);
-
-    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.getActualFrameGeometry().x, tilingArea.x);
-});

src/tests/flows/maximization.ts

@@ -1,341 +0,0 @@
-{
-    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.x + tilingArea.width/2 - 300/2;
-            const columnTopY = tilingArea.y;
-            const columnHeight = tilingArea.height;
-            Assert.assert(!kwinClient.fullScreen);
-            Assert.equal(kwinClient.keepBelow, shouldKeepBelow(true));
-            Assert.equal(kwinClient.keepAbove, shouldKeepAbove(true));
-            Assert.rect(kwinClient.getActualFrameGeometry(), 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.getActualFrameGeometry(), screen);
-
-            kwinClient.fullScreen = false;
-            Assert.assert(!kwinClient.fullScreen);
-            Assert.equal(kwinClient.keepBelow, shouldKeepBelow(true));
-            Assert.equal(kwinClient.keepAbove, shouldKeepAbove(true));
-            Assert.rect(kwinClient.getActualFrameGeometry(), 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.getActualFrameGeometry(), screen);
-
-            kwinClient.setMaximize(true, false);
-            Assert.assert(!kwinClient.fullScreen);
-            Assert.equal(kwinClient.keepBelow, shouldKeepBelow(false));
-            Assert.equal(kwinClient.keepAbove, shouldKeepAbove(false));
-            Assert.rect(kwinClient.getActualFrameGeometry(), 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.getActualFrameGeometry(), 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.getActualFrameGeometry(), 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.getActualFrameGeometry(), 14, 24, 50, 50);
-            Assert.equal(parent.keepBelow, shouldKeepBelow(false));
-            Assert.equal(parent.keepAbove, shouldKeepAbove(false));
-            Assert.equalRects(parent.getActualFrameGeometry(), screen);
-        });
-
-        {
-            function assertWindowed(config: Config, clients: MockKwinClient[]) {
-                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: MockKwinClient[]) {
-                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].getActualFrameGeometry(), 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.getActualFrameGeometry(), 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.getActualFrameGeometry(), 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.getActualFrameGeometry(), 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.getActualFrameGeometry(), 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

@@ -1,37 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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.getActualFrameGeometry(), screenHalfLeft);
-    Assert.grid(config, tilingAreaHalfRight, 100, [ [tiled1], [tiled2] ], true);
-
-    pinned.pin(screenHalfRight);
-    Assert.equalRects(pinned.getActualFrameGeometry(), screenHalfRight);
-    Assert.grid(config, tilingAreaHalfLeft, 100, [ [tiled1], [tiled2] ], true);
-
-    pinned.unpin();
-    Assert.equalRects(pinned.getActualFrameGeometry(), screenHalfRight);
-    Assert.grid(config, tilingArea, 100, [ [tiled1], [tiled2] ], true);
-
-    pinned.pin(screenHalfRight);
-    Assert.equalRects(pinned.getActualFrameGeometry(), 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.getActualFrameGeometry(), 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

@@ -1,232 +0,0 @@
-tests.register("Preset Widths default", 5, () => {
-    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.x + (tilingArea.width - columnWidth) / 2,
-            tilingArea.y,
-            columnWidth,
-            tilingArea.height,
-        );
-    }
-
-    const [kwinClient] = workspaceMock.createClientsWithWidths(300);
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(300));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(halfWidth));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(maxWidth));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-decrease"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(halfWidth));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(maxWidth));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-decrease"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(halfWidth));
-});
-
-tests.register("Preset Widths custom", 5, () => {
-    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.x + (tilingArea.width - columnWidth) / 2,
-            tilingArea.y,
-            columnWidth,
-            tilingArea.height,
-        );
-    }
-
-    const [kwinClient] = workspaceMock.createClientsWithWidths(200);
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(200));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(250));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(halfWidth));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(500));
-
-    qtMock.fireShortcut("karousel-cycle-preset-widths");
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(100));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(250));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths-reverse"),
-        () => qtMock.fireShortcut("karousel-column-width-decrease"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(100));
-
-    qtMock.fireShortcut("karousel-cycle-preset-widths-reverse");
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(500));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths-reverse"),
-        () => qtMock.fireShortcut("karousel-column-width-decrease"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(halfWidth));
-});
-
-tests.register("Preset Widths custom percentages", 5, () => {
-    const config = getDefaultConfig();
-    config.presetWidths = "25%, 50%, 75%, 100%";
-    const { qtMock, workspaceMock, world } = init(config);
-
-    const width100 = tilingArea.width;
-    const width75 = width100*0.75 - config.gapsInnerHorizontal*0.25;
-    const width50 = width100*0.50 - config.gapsInnerHorizontal*0.50;
-    const width25 = width100*0.25 - config.gapsInnerHorizontal*0.75;
-
-    function getRect(columnWidth: number) {
-        return new MockQmlRect(
-            tilingArea.x + (tilingArea.width - columnWidth) / 2,
-            tilingArea.y,
-            columnWidth,
-            tilingArea.height,
-        );
-    }
-
-    const [kwinClient] = workspaceMock.createClientsWithWidths(200);
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(200));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(width50));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(width75));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths"),
-        () => qtMock.fireShortcut("karousel-column-width-increase"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(width100));
-
-    qtMock.fireShortcut("karousel-cycle-preset-widths");
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(width25));
-
-    qtMock.fireShortcut("karousel-cycle-preset-widths-reverse");
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(width100));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths-reverse"),
-        () => qtMock.fireShortcut("karousel-column-width-decrease"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(width75));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths-reverse"),
-        () => qtMock.fireShortcut("karousel-column-width-decrease"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(width50));
-
-    runOneOf(
-        () => qtMock.fireShortcut("karousel-cycle-preset-widths-reverse"),
-        () => qtMock.fireShortcut("karousel-column-width-decrease"),
-    );
-    Assert.equalRects(kwinClient.getActualFrameGeometry(), getRect(width25));
-});
-
-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.x;
-        const right = rectRight(tilingArea);
-        const maxLeftoverPx = nColumns - 1;
-        const eps = Math.ceil(maxLeftoverPx / 2);
-        Assert.between(firstClient!.getActualFrameGeometry().x, left, left+eps, { message: `nColumns: ${nColumns}` });
-        Assert.between(rectRight(lastClient!.getActualFrameGeometry()), 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.x;
-    const left2 = left1 + config.gapsInnerHorizontal + quarterWidth;
-    const left3 = left2 + config.gapsInnerHorizontal + quarterWidth;
-
-    Assert.rect(clientThin1.getActualFrameGeometry(), left1, tilingArea.y, quarterWidth, height);
-    Assert.rect(clientThin2.getActualFrameGeometry(), left2, tilingArea.y, quarterWidth, height);
-    Assert.rect(clientWide.getActualFrameGeometry(), left3, tilingArea.y, halfWidth, height);
-    Assert.equal(rectRight(clientWide.getActualFrameGeometry()), rectRight(tilingArea));
-});

src/tests/flows/stacked.ts

@@ -1,30 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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.getActualFrameGeometry(), left, tilingArea.y, leftWidth, tilingArea.height);
-        Assert.rect(clientRightTop.getActualFrameGeometry(), left+leftWidth+gapH, tilingArea.y, rightWidth, topHeight);
-        Assert.rect(clientRightBottom.getActualFrameGeometry(), left+leftWidth+gapH, tilingArea.y+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.getActualFrameGeometry(), left, tilingArea.y, leftWidth, topHeight);
-            Assert.rect(clientLeftBottom.getActualFrameGeometry(), left, tilingArea.y+topHeight+gapV, leftWidth, bottomHeight);
-            Assert.rect(clientRight.getActualFrameGeometry(), left+leftWidth+gapH, tilingArea.y, 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

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