From 7f44d23dd0226d748729587e3626c0fe62140eaf Mon Sep 17 00:00:00 2001
From: Peter Fajdiga <peter.fajdiga@gmail.com>
Date: Wed, 20 Sep 2023 20:13:23 +0200
Subject: [PATCH] kwin.d.ts: merge `AbstractClient` and `TopLevel`

---
 src/extern/kwin.d.ts              | 42 ++++++++++++-------------------
 src/rules/ClientMatcher.ts        |  2 +-
 src/rules/WindowRuleEnforcer.ts   |  4 +--
 src/workspace.ts                  | 10 ++++----
 src/world/ClientManager.ts        | 30 +++++++++++-----------
 src/world/ClientWrapper.ts        |  4 +--
 src/world/Clients.ts              | 14 +++++------
 src/world/DesktopManager.ts       |  4 +--
 src/world/PinManager.ts           |  6 ++---
 src/world/World.ts                |  2 +-
 src/world/clientState/Docked.ts   |  6 ++---
 src/world/clientState/Floating.ts |  2 +-
 src/world/clientState/Pinned.ts   |  8 +++---
 src/world/clientState/Tiled.ts    |  2 +-
 14 files changed, 63 insertions(+), 73 deletions(-)

diff --git a/src/extern/kwin.d.ts b/src/extern/kwin.d.ts
index 4d128ca..26f096c 100644
--- a/src/extern/kwin.d.ts
+++ b/src/extern/kwin.d.ts
@@ -16,31 +16,36 @@ declare const workspace: {
     // Signals
     currentDesktopChanged: QSignal<[oldDesktopNumber: number]>
     clientAdded: QSignal<[KwinClient]>;
-    clientRemoved: QSignal<[AbstractClient]>;
-    clientMinimized: QSignal<[AbstractClient]>;
-    clientUnminimized: QSignal<[AbstractClient]>;
-    clientMaximizeSet: QSignal<[AbstractClient, horizontally: boolean, vertically: boolean]>;
-    clientActivated: QSignal<[AbstractClient]>;
+    clientRemoved: QSignal<[KwinClient]>;
+    clientMinimized: QSignal<[KwinClient]>;
+    clientUnminimized: QSignal<[KwinClient]>;
+    clientMaximizeSet: QSignal<[KwinClient, horizontally: boolean, vertically: boolean]>;
+    clientActivated: QSignal<[KwinClient]>;
     numberDesktopsChanged: QSignal<[oldNumberOfVirtualDesktops: number]>;
     currentActivityChanged: QSignal<[newActivity: string]>;
     virtualScreenSizeChanged: QSignal<[void]>;
 
     // Functions
     clientArea(option: ClientAreaOption, screenNumber: number, desktopNumber: number);
-    clientList(): TopLevel[];
+    clientList(): KwinClient[];
 };
 
 type Tile = any;
 
-interface AbstractClient {
+interface KwinClient {
     // Read-only Properties
     readonly caption: string;
     readonly minSize: QSize;
     readonly transient: boolean;
-    readonly transientFor: AbstractClient;
+    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;
 
     // Read-write Properties
     fullScreen: boolean;
@@ -49,6 +54,8 @@ interface AbstractClient {
     keepBelow: boolean;
     shade: boolean;
     minimized: boolean;
+    frameGeometry: QRect;
+    desktop: number; // -1 means all desktops
     tile: Tile;
 
     // Signals
@@ -60,25 +67,8 @@ interface AbstractClient {
     moveResizedChanged: QSignal<[void]>;
     moveResizeCursorChanged: QSignal<[void]>;
     clientStartUserMovedResized: QSignal<[void]>;
+    frameGeometryChanged: QSignal<[KwinClient, oldGeometry: QRect]>;
 
     // Functions
     setMaximize(vertically: boolean, horizontally: boolean): void;
 }
-
-interface TopLevel extends AbstractClient {
-    // Read-only Properties
-    readonly screen: number;
-    readonly resourceClass: QByteArray;
-    readonly dock: boolean;
-    readonly normalWindow: boolean;
-    readonly managed: boolean;
-
-    // Read-write Properties
-    frameGeometry: QRect;
-    desktop: number; // -1 means all desktops
-
-    // Signals
-    frameGeometryChanged: QSignal<[TopLevel, oldGeometry: QRect]>;
-}
-
-interface KwinClient extends TopLevel {}
diff --git a/src/rules/ClientMatcher.ts b/src/rules/ClientMatcher.ts
index a0e0450..a98694f 100644
--- a/src/rules/ClientMatcher.ts
+++ b/src/rules/ClientMatcher.ts
@@ -5,7 +5,7 @@ class ClientMatcher {
         this.rules = rules;
     }
 
-    public matches(kwinClient: TopLevel) {
+    public matches(kwinClient: KwinClient) {
         const rule = this.rules.get(kwinClient.resourceClass);
         if (rule === undefined) {
             return false;
diff --git a/src/rules/WindowRuleEnforcer.ts b/src/rules/WindowRuleEnforcer.ts
index 53f3489..b3d52a3 100644
--- a/src/rules/WindowRuleEnforcer.ts
+++ b/src/rules/WindowRuleEnforcer.ts
@@ -10,7 +10,7 @@ class WindowRuleEnforcer {
         this.followCaption = new Set([...mapFloat.keys(), ...mapTile.keys()]);
     }
 
-    public shouldTile(kwinClient: TopLevel) {
+    public shouldTile(kwinClient: KwinClient) {
         return Clients.canTileNow(kwinClient) && (
             this.preferTiling.matches(kwinClient) || (
                 kwinClient.normalWindow &&
@@ -21,7 +21,7 @@ class WindowRuleEnforcer {
         );
     }
 
-    public initClientSignalManager(world: World, kwinClient: TopLevel) {
+    public initClientSignalManager(world: World, kwinClient: KwinClient) {
         if (!this.followCaption.has(kwinClient.resourceClass)) {
             return null;
         }
diff --git a/src/workspace.ts b/src/workspace.ts
index 524df53..4f66dcf 100644
--- a/src/workspace.ts
+++ b/src/workspace.ts
@@ -16,25 +16,25 @@ function initWorkspaceSignalHandlers(world: World) {
         });
     });
 
-    manager.connect(workspace.clientRemoved, (kwinClient: AbstractClient) => {
+    manager.connect(workspace.clientRemoved, (kwinClient: KwinClient) => {
         world.do((clientManager, desktopManager) => {
             clientManager.removeClient(kwinClient, true);
         });
     });
 
-    manager.connect(workspace.clientMinimized, (kwinClient: AbstractClient) => {
+    manager.connect(workspace.clientMinimized, (kwinClient: KwinClient) => {
         world.do((clientManager, desktopManager) => {
             clientManager.minimizeClient(kwinClient);
         });
     });
 
-    manager.connect(workspace.clientUnminimized, (kwinClient: AbstractClient) => {
+    manager.connect(workspace.clientUnminimized, (kwinClient: KwinClient) => {
         world.do((clientManager, desktopManager) => {
             clientManager.unminimizeClient(kwinClient);
         });
     });
 
-    manager.connect(workspace.clientMaximizeSet, (kwinClient: AbstractClient, horizontally: boolean, vertically: boolean) => {
+    manager.connect(workspace.clientMaximizeSet, (kwinClient: KwinClient, horizontally: boolean, vertically: boolean) => {
         if ((horizontally || vertically) && kwinClient.tile !== null) {
             kwinClient.tile = null;
         }
@@ -43,7 +43,7 @@ function initWorkspaceSignalHandlers(world: World) {
         });
     });
 
-    manager.connect(workspace.clientActivated, (kwinClient: AbstractClient) => {
+    manager.connect(workspace.clientActivated, (kwinClient: KwinClient) => {
         if (kwinClient === null) {
             return;
         }
diff --git a/src/world/ClientManager.ts b/src/world/ClientManager.ts
index 51e8da2..2c4fd31 100644
--- a/src/world/ClientManager.ts
+++ b/src/world/ClientManager.ts
@@ -3,8 +3,8 @@ class ClientManager {
     private readonly config: ClientManager.Config;
     private readonly desktopManager: DesktopManager;
     private readonly pinManager: PinManager;
-    private readonly clientMap: Map<AbstractClient, ClientWrapper>;
-    private lastFocusedClient: AbstractClient|null;
+    private readonly clientMap: Map<KwinClient, ClientWrapper>;
+    private lastFocusedClient: KwinClient|null;
     private readonly windowRuleEnforcer: WindowRuleEnforcer;
 
     constructor(config: Config, world: World, desktopManager: DesktopManager, pinManager: PinManager) {
@@ -25,7 +25,7 @@ class ClientManager {
         this.windowRuleEnforcer = new WindowRuleEnforcer(parsedWindowRules);
     }
 
-    public addClient(kwinClient: TopLevel) {
+    public addClient(kwinClient: KwinClient) {
         console.assert(!this.hasClient(kwinClient));
 
         let constructState: (client: ClientWrapper) => ClientState.State;
@@ -47,7 +47,7 @@ class ClientManager {
         this.clientMap.set(kwinClient, client);
     }
 
-    public removeClient(kwinClient: AbstractClient, passFocus: boolean) {
+    public removeClient(kwinClient: KwinClient, passFocus: boolean) {
         console.assert(this.hasClient(kwinClient));
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
@@ -57,7 +57,7 @@ class ClientManager {
         this.clientMap.delete(kwinClient);
     }
 
-    private findTransientFor(kwinClient: AbstractClient) {
+    private findTransientFor(kwinClient: KwinClient) {
         if (!kwinClient.transient) {
             return null;
         }
@@ -70,7 +70,7 @@ class ClientManager {
         return transientFor;
     }
 
-    public minimizeClient(kwinClient: AbstractClient) {
+    public minimizeClient(kwinClient: KwinClient) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
@@ -80,7 +80,7 @@ class ClientManager {
         }
     }
 
-    public unminimizeClient(kwinClient: AbstractClient) {
+    public unminimizeClient(kwinClient: KwinClient) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
@@ -91,7 +91,7 @@ class ClientManager {
         }
     }
 
-    public tileClient(kwinClient: AbstractClient) {
+    public tileClient(kwinClient: KwinClient) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
@@ -103,7 +103,7 @@ class ClientManager {
         client.stateManager.setState(() => new ClientState.Tiled(this.world, client, grid), false);
     }
 
-    public untileClient(kwinClient: TopLevel) {
+    public untileClient(kwinClient: KwinClient) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
@@ -113,7 +113,7 @@ class ClientManager {
         }
     }
 
-    public pinClient(kwinClient: TopLevel, mode: Clients.QuickTileMode) {
+    public pinClient(kwinClient: KwinClient, mode: Clients.QuickTileMode) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
@@ -125,7 +125,7 @@ class ClientManager {
         }
     }
 
-    public unpinClient(kwinClient: TopLevel) {
+    public unpinClient(kwinClient: KwinClient) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
@@ -138,7 +138,7 @@ class ClientManager {
         }
     }
 
-    public toggleFloatingClient(kwinClient: TopLevel) {
+    public toggleFloatingClient(kwinClient: KwinClient) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return;
@@ -154,11 +154,11 @@ class ClientManager {
         }
     }
 
-    public hasClient(kwinClient: AbstractClient) {
+    public hasClient(kwinClient: KwinClient) {
         return this.clientMap.has(kwinClient);
     }
 
-    public onClientFocused(kwinClient: AbstractClient) {
+    public onClientFocused(kwinClient: KwinClient) {
         this.lastFocusedClient = kwinClient;
         const window = this.findTiledWindow(kwinClient, true);
         if (window !== null) {
@@ -166,7 +166,7 @@ class ClientManager {
         }
     }
 
-    public findTiledWindow(kwinClient: AbstractClient, followTransient: boolean) {
+    public findTiledWindow(kwinClient: KwinClient, followTransient: boolean) {
         const client = this.clientMap.get(kwinClient);
         if (client === undefined) {
             return null;
diff --git a/src/world/ClientWrapper.ts b/src/world/ClientWrapper.ts
index b391a85..3e15f0a 100644
--- a/src/world/ClientWrapper.ts
+++ b/src/world/ClientWrapper.ts
@@ -1,5 +1,5 @@
 class ClientWrapper {
-    public readonly kwinClient: TopLevel;
+    public readonly kwinClient: KwinClient;
     public readonly stateManager: ClientState.Manager;
     public transientFor: ClientWrapper | null;
     private readonly transients: ClientWrapper[];
@@ -9,7 +9,7 @@ class ClientWrapper {
     private lastPlacement: QRect | null; // workaround for issue #19
 
     constructor(
-        kwinClient: TopLevel,
+        kwinClient: KwinClient,
         constructInitialState: (client: ClientWrapper) => ClientState.State,
         transientFor: ClientWrapper | null,
         rulesSignalManager: SignalManager | null,
diff --git a/src/world/Clients.ts b/src/world/Clients.ts
index e75fe0a..f8c76d1 100644
--- a/src/world/Clients.ts
+++ b/src/world/Clients.ts
@@ -1,13 +1,13 @@
 namespace Clients {
-    export function canTileEver(kwinClient: AbstractClient) {
+    export function canTileEver(kwinClient: KwinClient) {
         return kwinClient.resizeable;
     }
 
-    export function canTileNow(kwinClient: TopLevel) {
+    export function canTileNow(kwinClient: KwinClient) {
         return canTileEver(kwinClient) && !kwinClient.minimized && kwinClient.desktop > 0 && kwinClient.activities.length === 1;
     }
 
-    export function makeTileable(kwinClient: TopLevel) {
+    export function makeTileable(kwinClient: KwinClient) {
         if (kwinClient.minimized) {
             kwinClient.minimized = false;
         }
@@ -19,21 +19,21 @@ namespace Clients {
         }
     }
 
-    export function isMaximizedGeometry(kwinClient: TopLevel) {
+    export function isMaximizedGeometry(kwinClient: KwinClient) {
         const maximizeArea = workspace.clientArea(ClientAreaOption.MaximizeArea, kwinClient.screen, kwinClient.desktop);
         return kwinClient.frameGeometry === maximizeArea;
     }
 
-    export function isFullScreenGeometry(kwinClient: TopLevel) {
+    export function isFullScreenGeometry(kwinClient: KwinClient) {
         const fullScreenArea = workspace.clientArea(ClientAreaOption.FullScreenArea, kwinClient.screen, kwinClient.desktop);
         return kwinClient.frameGeometry === fullScreenArea;
     }
 
-    export function isOnVirtualDesktop(kwinClient: TopLevel, desktopNumber: number) {
+    export function isOnVirtualDesktop(kwinClient: KwinClient, desktopNumber: number) {
         return kwinClient.desktop === desktopNumber || kwinClient.desktop === -1;
     }
 
-    export function guessQuickTileMode(kwinClient: TopLevel) {
+    export function guessQuickTileMode(kwinClient: KwinClient) {
         const clientArea = workspace.clientArea(ClientAreaOption.PlacementArea, 0, kwinClient.desktop);
         const frame = kwinClient.frameGeometry;
         const top = frame.top === clientArea.top;
diff --git a/src/world/DesktopManager.ts b/src/world/DesktopManager.ts
index 7c01c91..f57d103 100644
--- a/src/world/DesktopManager.ts
+++ b/src/world/DesktopManager.ts
@@ -38,7 +38,7 @@ class DesktopManager {
         return this.getDesktop(workspace.currentActivity, desktopNumber);
     }
 
-    public getDesktopForClient(kwinClient: TopLevel) {
+    public getDesktopForClient(kwinClient: KwinClient) {
         console.assert(kwinClient.activities.length === 1 && kwinClient.desktop > 0);
         return this.getDesktop(kwinClient.activities[0], kwinClient.desktop);
     }
@@ -106,7 +106,7 @@ class DesktopManager {
         }
     }
 
-    public *getDesktopsForClient(kwinClient: TopLevel) {
+    public *getDesktopsForClient(kwinClient: KwinClient) {
         const activities = kwinClient.activities.length > 0 ? kwinClient.activities : this.desktopsPerActivity.keys();
         for (const activity of activities) {
             if (!this.desktopsPerActivity.has(activity)) {
diff --git a/src/world/PinManager.ts b/src/world/PinManager.ts
index 2a46dbf..bbfcffc 100644
--- a/src/world/PinManager.ts
+++ b/src/world/PinManager.ts
@@ -1,15 +1,15 @@
 class PinManager {
-    private readonly pinnedClients: Map<TopLevel, Clients.QuickTileMode>;
+    private readonly pinnedClients: Map<KwinClient, Clients.QuickTileMode>;
 
     constructor() {
         this.pinnedClients = new Map();
     }
 
-    public setClient(kwinClient: TopLevel, mode: Clients.QuickTileMode) {
+    public setClient(kwinClient: KwinClient, mode: Clients.QuickTileMode) {
         this.pinnedClients.set(kwinClient, mode);
     }
 
-    public removeClient(kwinClient: TopLevel) {
+    public removeClient(kwinClient: KwinClient) {
         this.pinnedClients.delete(kwinClient);
     }
 
diff --git a/src/world/World.ts b/src/world/World.ts
index da050a8..0c73921 100644
--- a/src/world/World.ts
+++ b/src/world/World.ts
@@ -68,7 +68,7 @@ class World {
     }
 
     public doIfTiled(
-        kwinClient: AbstractClient,
+        kwinClient: KwinClient,
         followTransient: boolean,
         f: (clientManager: ClientManager, desktopManager: DesktopManager, window: Window, column: Column, grid: Grid) => void,
     ) {
diff --git a/src/world/clientState/Docked.ts b/src/world/clientState/Docked.ts
index 5cb9fa2..91fb673 100644
--- a/src/world/clientState/Docked.ts
+++ b/src/world/clientState/Docked.ts
@@ -3,7 +3,7 @@ namespace ClientState {
         private readonly world: World;
         private readonly signalManager: SignalManager;
 
-        constructor(world: World, kwinClient: TopLevel) {
+        constructor(world: World, kwinClient: KwinClient) {
             this.world = world;
             this.signalManager = Docked.initSignalManager(world, kwinClient);
             world.onScreenResized();
@@ -14,9 +14,9 @@ namespace ClientState {
             this.world.onScreenResized();
         }
 
-        private static initSignalManager(world: World, kwinClient: TopLevel) {
+        private static initSignalManager(world: World, kwinClient: KwinClient) {
             const manager = new SignalManager();
-            manager.connect(kwinClient.frameGeometryChanged, (kwinClient: TopLevel, oldGeometry: QRect) => {
+            manager.connect(kwinClient.frameGeometryChanged, (kwinClient: KwinClient, oldGeometry: QRect) => {
                 world.onScreenResized();
             });
             return manager;
diff --git a/src/world/clientState/Floating.ts b/src/world/clientState/Floating.ts
index b8a0d88..0a7cbd1 100644
--- a/src/world/clientState/Floating.ts
+++ b/src/world/clientState/Floating.ts
@@ -35,7 +35,7 @@ namespace ClientState {
             );
         }
 
-        private static initSignalManager(world: World, kwinClient: TopLevel) {
+        private static initSignalManager(world: World, kwinClient: KwinClient) {
             const manager = new SignalManager();
 
             manager.connect(kwinClient.tileChanged, () => {
diff --git a/src/world/clientState/Pinned.ts b/src/world/clientState/Pinned.ts
index 2f13269..35cad26 100644
--- a/src/world/clientState/Pinned.ts
+++ b/src/world/clientState/Pinned.ts
@@ -1,12 +1,12 @@
 namespace ClientState {
     export class Pinned implements State {
-        private readonly kwinClient: TopLevel;
+        private readonly kwinClient: KwinClient;
         private readonly pinManager: PinManager;
         private readonly desktopManager: DesktopManager;
         private readonly config: ClientManager.Config;
         private readonly signalManager: SignalManager;
 
-        constructor(world: World, pinManager: PinManager, desktopManager: DesktopManager, kwinClient: TopLevel, config: ClientManager.Config) {
+        constructor(world: World, pinManager: PinManager, desktopManager: DesktopManager, kwinClient: KwinClient, config: ClientManager.Config) {
             this.kwinClient = kwinClient;
             this.pinManager = pinManager;
             this.desktopManager = desktopManager;
@@ -28,7 +28,7 @@ namespace ClientState {
             }
         }
 
-        private static initSignalManager(world: World, pinManager: PinManager, kwinClient: TopLevel) {
+        private static initSignalManager(world: World, pinManager: PinManager, kwinClient: KwinClient) {
             const manager = new SignalManager();
             let oldDesktopNumber = kwinClient.desktop;
             let oldActivities = kwinClient.activities;
@@ -42,7 +42,7 @@ namespace ClientState {
                 }
             });
 
-            manager.connect(kwinClient.frameGeometryChanged, (kwinClient: TopLevel, oldGeometry: QRect) => {
+            manager.connect(kwinClient.frameGeometryChanged, (kwinClient: KwinClient, oldGeometry: QRect) => {
                 const quickTileMode = Clients.guessQuickTileMode(kwinClient);
                 if (quickTileMode === Clients.QuickTileMode.Untiled) {
                     world.do((clientManager, desktopManager) => {
diff --git a/src/world/clientState/Tiled.ts b/src/world/clientState/Tiled.ts
index 4f9765e..5cb142b 100644
--- a/src/world/clientState/Tiled.ts
+++ b/src/world/clientState/Tiled.ts
@@ -79,7 +79,7 @@ namespace ClientState {
                 cursorChangedAfterResizeStart = false;
             });
 
-            manager.connect(kwinClient.frameGeometryChanged, (kwinClient: TopLevel, oldGeometry: QRect) => {
+            manager.connect(kwinClient.frameGeometryChanged, (kwinClient: KwinClient, oldGeometry: QRect) => {
                 // on Wayland, this fires after `tileChanged`
                 if (kwinClient.tile !== null) {
                     const quickTileMode = Clients.guessQuickTileMode(kwinClient);