feat: refactored to monitor -> workspace -> container -> window workflow

src/container.ts

@@ -1,116 +1,180 @@
 import {WindowWrapper} from "./window.js";
 import {Logger} from "./utils/logger.js";
-import Mtk from "@girs/mtk-16";
 import Meta from "gi://Meta";
-import GLib from "gi://GLib";
 import queueEvent from "./utils/events.js";
 import {Rect} from "./utils/rect.js";
 
+enum Orientation {
+    HORIZONTAL = 0,
+    VERTICAL = 1,
+}
+
 
 export default class WindowContainer {
 
     _id: number;
-    _windows: Map<number, WindowWrapper>;
+    _tiledItems: (WindowWrapper | WindowContainer)[];
-    _minimizedWindows: Map<number, WindowWrapper>;
+    _tiledWindowLookup: Map<number, WindowWrapper>;
+    _workspace: number;
+    _orientation: Orientation = Orientation.HORIZONTAL;
     _workArea: Rect;
 
-    constructor(monitorId: number, workspaceArea: Rect) {
+    constructor(monitorId: number, workspaceArea: Rect, workspace: number) {
-        this._windows = new Map<number, WindowWrapper>();
-        this._minimizedWindows = new Map<number, WindowWrapper>();
-        const workspace = global.workspace_manager.get_active_workspace();
         this._id = monitorId;
-        const _workArea = workspace.get_work_area_for_monitor(
+        this._workspace = workspace;
-            this._id
+        this._tiledItems = [];
-        );
+        this._tiledWindowLookup = new Map<number, WindowWrapper>();
+        this._workArea = workspaceArea;
+    }
+
+    getWorkspace(): number {
+        return this._workspace;
+    }
+
+    move(rect: Rect): void {
+        this._workArea = rect;
+        this.tileWindows();
     }
 
     addWindow(winWrap: WindowWrapper): void {
         // Add window to managed windows
-        this._windows.set(winWrap.getWindowId(), winWrap);
+        this._tiledItems.push(winWrap);
+        this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
         queueEvent({
             name: "tiling-windows",
             callback: () => {
-                this._tileWindows();
+                this.tileWindows();
             }
         }, 100)
+
     }
 
     getWindow(win_id: number): WindowWrapper | undefined {
-        return this._windows.get(win_id)
+        if (this._tiledWindowLookup.has(win_id)) {
+            return this._tiledWindowLookup.get(win_id);
+        }
+        for (const item of this._tiledItems) {
+            if (item instanceof WindowContainer) {
+                const win = item.getWindow(win_id);
+                if (win) {
+                    return win;
+                }
+            } else if (item.getWindowId() === win_id) {
+                return item;
+            }
+        }
+        return undefined
+    }
+
+    _getIndexOfWindow(win_id: number) {
+        for (let i = 0; i < this._tiledItems.length; i++) {
+            const item = this._tiledItems[i];
+            if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
+                return i;
+            }
+        }
+        return -1
     }
 
     removeWindow(win_id: number): void {
-        this._windows.delete(win_id)
+        if (this._tiledWindowLookup.has(win_id)) {
-        // TODO: Should there be re-tiling in this function?
+            this._tiledWindowLookup.delete(win_id);
-        this._tileWindows()
+            const index = this._getIndexOfWindow(win_id)
-    }
+            this._tiledItems.splice(index, 1);
-
+        } else {
-    minimizeWindow(winWrap: WindowWrapper): void {
+            for (const item of this._tiledItems) {
-        this._windows.delete(winWrap.getWindowId())
+                if (item instanceof WindowContainer) {
-        this._minimizedWindows.set(winWrap.getWindowId(), winWrap)
+                    item.removeWindow(win_id);
-    }
+                }
-
+            }
-    unminimizeWindow(winWrap: WindowWrapper): void {
-        if (this._minimizedWindows.has(winWrap.getWindowId())) {
-            this._windows.set(winWrap.getWindowId(), winWrap);
-            this._minimizedWindows.delete(winWrap.getWindowId());
         }
+        this.tileWindows()
     }
 
     disconnectSignals(): void {
-        this._windows.forEach((window) => {
+        this._tiledItems.forEach((item) => {
-                window.disconnectWindowSignals();
+                if (item instanceof WindowContainer) {
+                    item.disconnectSignals()
+                } else {
+                    item.disconnectWindowSignals();
+                }
             }
         )
     }
 
     removeAllWindows(): void {
-        this._windows.clear()
+        this._tiledItems = []
+        this._tiledWindowLookup.clear()
     }
 
-    _tileWindows() {
+    tileWindows() {
         Logger.log("TILING WINDOWS ON MONITOR", this._id)
-        const workspace = global.workspace_manager.get_active_workspace();
-        const workArea = workspace.get_work_area_for_monitor(
-            this._id
-        );
 
-        Logger.log("Workspace", workspace);
+        Logger.log("Workspace", this._workspace);
-        Logger.log("WorkArea", workArea);
+        Logger.log("WorkArea", this._workArea);
 
         // Get all windows for current workspace
+        let tilable = this._getTilableItems();
 
-        let windows = this._getTilableWindows(workspace)
+        if (tilable.length !== 0) {
-
+            this._tileItems(tilable)
-        if (windows.length !== 0) {
-            this._tileHorizontally(windows, workArea)
         }
         return true
     }
 
-    _getTilableWindows(workspace: Meta.Workspace): WindowWrapper[] {
+    _getTilableItems(): (WindowWrapper | WindowContainer)[] {
-
+        return Array.from(this._tiledItems.values())
-        return Array.from(this._windows.values())
-            .filter(({_window}) => {
-                Logger.log("TILING WINDOW:", _window.get_id())
-                return _window.get_workspace() === workspace;
-            })
-            .map(x => x);
     }
 
-    _tileHorizontally(windows: (WindowWrapper)[], workArea: Mtk.Rectangle) {
+    _tileItems(windows: (WindowWrapper | WindowContainer)[]) {
-        const windowWidth = Math.floor(workArea.width / windows.length);
+        if (windows.length === 0) {
+            return;
+        }
+        if (this._orientation === Orientation.HORIZONTAL) {
+            this._tileHorizontally(windows);
+        } else {
+            this._tileVertically(windows);
+        }
+    }
 
-        windows.forEach((window, index) => {
+    _tileVertically(items: (WindowWrapper | WindowContainer)[]) {
-            const x = workArea.x + (index * windowWidth);
+        const containerHeight = Math.floor(this._workArea.height / items.length);
+
+        items.forEach((item, index) => {
+            const y = this._workArea.y + (index * containerHeight);
+            const rect = {
+                x: this._workArea.x,
+                y: y,
+                width: this._workArea.width,
+                height: containerHeight
+            };
+            if (item != null) {
+                if (item instanceof WindowContainer) {
+                    item.move(rect)
+                } else {
+                    item.safelyResizeWindow(rect);
+                }
+            }
+        });
+    }
+
+    _tileHorizontally(windows: (WindowWrapper | WindowContainer)[]) {
+        const windowWidth = Math.floor(this._workArea.width / windows.length);
+
+        windows.forEach((item, index) => {
+            const x = this._workArea.x + (index * windowWidth);
             const rect = {
                 x: x,
-                y: workArea.y,
+                y: this._workArea.y,
                 width: windowWidth,
-                height: workArea.height
+                height: this._workArea.height
             };
-            if (window != null) {
+            if (item != null) {
-                window.safelyResizeWindow(rect);
+                if (item instanceof WindowContainer) {
+                    item.move(rect)
+                } else {
+                    item.safelyResizeWindow(rect);
+                }
             }
         });
     }

src/monitor.ts

@@ -0,0 +1,75 @@
+import {WindowWrapper} from "./window.js";
+import {Rect} from "./utils/rect.js";
+import queueEvent from "./utils/events.js";
+import {Logger} from "./utils/logger.js";
+import Meta from "gi://Meta";
+import Mtk from "@girs/mtk-16";
+
+import WindowContainer from "./container.js";
+import Window = Meta.Window;
+
+export default class Monitor {
+
+    _id: number;
+    _workArea: Rect;
+    _workspaces: WindowContainer[] = [];
+
+    constructor(monitorId: number) {
+        this._id = monitorId;
+        const workspace = global.workspace_manager.get_active_workspace();
+        this._workArea = workspace.get_work_area_for_monitor(this._id);
+        Logger.log("CREATING MONITOR", monitorId);
+        Logger.log("WorkArea", this._workArea.x, this._workArea.y, this._workArea.width, this._workArea.height);
+        const workspaceCount = global.workspace_manager.get_n_workspaces()
+        Logger.log("Workspace Count", workspaceCount);
+        for (let i = 0; i < workspaceCount; i++) {
+            this._workspaces.push(new WindowContainer(monitorId, this._workArea, i));
+        }
+    }
+
+    disconnectSignals() {
+        for (const container of this._workspaces) {
+            container.disconnectSignals();
+        }
+    }
+
+    removeAllWindows(): void {
+        for (const container of this._workspaces) {
+            container.removeAllWindows();
+        }
+    }
+
+    getWindow(windowId: number): WindowWrapper | undefined {
+        for (const container of this._workspaces) {
+            const win = container.getWindow(windowId);
+            if (win) {
+                return win;
+            }
+        }
+        return undefined;
+    }
+
+    removeWindow(winWrap: WindowWrapper) {
+        const windowId = winWrap.getWindowId();
+        for (const container of this._workspaces) {
+            const win = container.getWindow(windowId);
+            if (win) {
+                container.removeWindow(windowId);
+            }
+        }
+    }
+
+    addWindow(winWrap: WindowWrapper) {
+        const window_workspace = winWrap.getWindow().get_workspace().index();
+        Logger.log("Adding window to workspace",  window_workspace);
+        this._workspaces[window_workspace].addWindow(winWrap);
+    }
+
+    tileWindows(): void {
+        this._workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(this._id);
+        const activeWorkspace = global.workspace_manager.get_active_workspace();
+        this._workspaces[activeWorkspace.index()].move(this._workArea);
+        this._workspaces[activeWorkspace.index()].tileWindows()
+    }
+
+}

src/window.ts

@@ -3,16 +3,22 @@ import Clutter from "gi://Clutter";
 import {IWindowManager} from "./windowManager.js";
 import {Logger} from "./utils/logger.js";
 import {Rect} from "./utils/rect.js";
+import WindowContainer from "./container.js";
 
 
 type WindowMinimizedHandler = (window: WindowWrapper) => void;
+type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void;
 
 export class WindowWrapper {
     readonly _window: Meta.Window;
     readonly _windowMinimizedHandler: WindowMinimizedHandler;
+    // readonly _windowWorkspaceChangedHandler: WindowWorkspaceChangedHandler;
     readonly _signals: number[];
 
-    constructor(window: Meta.Window, winMinimized: WindowMinimizedHandler) {
+    constructor(
+        window: Meta.Window,
+        winMinimized: WindowMinimizedHandler
+    ) {
         this._window = window;
         this._signals = [];
         this._windowMinimizedHandler = winMinimized;
@@ -36,7 +42,7 @@ export class WindowWrapper {
                 Logger.log("REMOVING WINDOW", windowId);
                 windowManager.handleWindowClosed(this)
             }),
-            this._window.connect('notify::minimized', () => {
+            this._window.connect('notify::minimized', (we) => {
                 if (this._window.minimized) {
                     Logger.log(`Window minimized: ${windowId}`);
                     windowManager.handleWindowMinimized(this);
@@ -59,6 +65,9 @@ export class WindowWrapper {
                     Logger.log(`Window unmaximized: ${windowId}`);
                 }
             }),
+            this._window.connect("workspace-changed", (_metaWindow) => {
+                Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
+            }),
         );
     }
 

src/windowManager.ts

@@ -9,6 +9,7 @@ import {Logger} from "./utils/logger.js";
 import WindowContainer from "./container.js";
 import {MessageTray} from "@girs/gnome-shell/ui/messageTray";
 import queueEvent, {QueuedEvent} from "./utils/events.js";
+import Monitor from "./monitor.js";
 
 
 export interface IWindowManager {
@@ -17,7 +18,9 @@ export interface IWindowManager {
     // addWindow(window: Meta.Window): void;
 
     handleWindowClosed(winWrap: WindowWrapper): void;
+
     handleWindowMinimized(winWrap: WindowWrapper): void;
+
     handleWindowUnminimized(winWrap: WindowWrapper): void;
 
 
@@ -35,11 +38,13 @@ export default class WindowManager implements IWindowManager {
 
     _activeWindowId: number | null;
     _grabbedWindowMonitor: number;
-    _monitors: Map<number, WindowContainer>;
+    _monitors: Map<number, Monitor>;
     _sessionProxy: Gio.DBusProxy | null;
     _lockedSignalId: number | null;
     _isScreenLocked: boolean;
 
+    _minimizedItems: Map<number, WindowWrapper>;
+
     constructor() {
         this._displaySignals = [];
         this._windowManagerSignals = [];
@@ -47,11 +52,13 @@ export default class WindowManager implements IWindowManager {
         this._overviewSignals = [];
         this._activeWindowId = null;
         this._grabbedWindowMonitor = _UNUSED_MONITOR_ID;
-        this._monitors = new Map<number, WindowContainer>();
+        this._monitors = new Map<number, Monitor>();
         this._sessionProxy = null;
         this._lockedSignalId = null;
         this._isScreenLocked = false; // Initialize to unlocked state
 
+        this._minimizedItems = new Map<number, WindowWrapper>();
+
     }
 
     public enable(): void {
@@ -61,7 +68,7 @@ export default class WindowManager implements IWindowManager {
 
         const mon_count = global.display.get_n_monitors();
         for (let i = 0; i < mon_count; i++) {
-            this._monitors.set(i, new WindowContainer(i));
+            this._monitors.set(i, new Monitor(i));
         }
 
         this.captureExistingWindows();
@@ -81,11 +88,13 @@ export default class WindowManager implements IWindowManager {
             global.display.connect('window-created', (display, window) => {
                 this.handleWindowCreated(display, window);
             }),
+
             global.display.connect("showing-desktop-changed", () => {
                 Logger.log("SHOWING DESKTOP CHANGED");
             }),
             global.display.connect("workareas-changed", (display) => {
-                Logger.log("WORK AREAS CHANGED");
+                Logger.log("WORK AREAS CHANGED", );
+                console.log(display.get_workspace_manager().get_active_workspace_index())
             }),
             global.display.connect("in-fullscreen-changed", () => {
                 Logger.log("IN FULL SCREEN CHANGED");
@@ -103,13 +112,13 @@ export default class WindowManager implements IWindowManager {
                 Logger.log("SHOWING DESKTOP CHANGED AT WORKSPACE LEVEL");
             }),
             global.workspace_manager.connect("workspace-added", (_, wsIndex) => {
-                Logger.log("WORKSPACE ADDED");
+                Logger.log("WORKSPACE ADDED", wsIndex);
             }),
             global.workspace_manager.connect("workspace-removed", (_, wsIndex) => {
-                Logger.log("WORKSPACE REMOVED");
+                Logger.log("WORKSPACE REMOVED", wsIndex);
             }),
-            global.workspace_manager.connect("active-workspace-changed", () => {
+            global.workspace_manager.connect("active-workspace-changed", (source) => {
-                Logger.log("Active workspace-changed");
+                Logger.log("Active workspace-changed", source.get_active_workspace().index());
             }),
         ];
 
@@ -117,6 +126,7 @@ export default class WindowManager implements IWindowManager {
             Main.overview.connect("hiding", () => {
                 // this.fromOverview = true;
                 Logger.log("HIDING OVERVIEW")
+                this._tileMonitors();
                 // const eventObj = {
                 //     name: "focus-after-overview",
                 //     callback: () => {
@@ -142,19 +152,21 @@ export default class WindowManager implements IWindowManager {
     }
 
     removeAllWindows(): void {
-        this._monitors.forEach((monitor: WindowContainer) => {
+        this._monitors.forEach((monitor: Monitor) => {
             monitor.removeAllWindows();
         })
+        this._minimizedItems.clear();
     }
 
 
     disconnectSignals(): void {
         this.disconnectDisplaySignals();
         this.disconnectMonitorSignals();
+        this.disconnectMinimizedSignals();
     }
 
     disconnectMonitorSignals(): void {
-        this._monitors.forEach((monitor: WindowContainer) => {
+        this._monitors.forEach((monitor: Monitor) => {
             monitor.disconnectSignals();
         })
     }
@@ -174,6 +186,12 @@ export default class WindowManager implements IWindowManager {
         })
     }
 
+    disconnectMinimizedSignals(): void {
+        this._minimizedItems.forEach((item) => {
+            item.disconnectWindowSignals();
+        })
+    }
+
 
     handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
         Logger.log("Grab Op Start");
@@ -198,11 +216,12 @@ export default class WindowManager implements IWindowManager {
             if (old_mon === undefined || new_mon === undefined) {
                 return;
             }
+
             let wrapped = old_mon.getWindow(window.get_id())
             if (wrapped === undefined) {
                 wrapped = new WindowWrapper(window, this.handleWindowMinimized);
             } else {
-                old_mon.removeWindow(window.get_id())
+                old_mon.removeWindow(wrapped)
             }
             new_mon.addWindow(wrapped)
         }
@@ -212,18 +231,25 @@ export default class WindowManager implements IWindowManager {
 
     public handleWindowMinimized(winWrap: WindowWrapper): void {
         Logger.warn("WARNING MINIMIZING WINDOW");
-        Logger.log("WARNING MINIMIZED", winWrap);
+        Logger.log("WARNING MINIMIZED", JSON.stringify(winWrap));
         const monitor_id = winWrap.getWindow().get_monitor()
         Logger.log("WARNING MINIMIZED", monitor_id);
         Logger.warn("WARNING MINIMIZED", this._monitors);
-        this._monitors.get(monitor_id)?.minimizeWindow(winWrap);
+
+        this._minimizedItems.set(winWrap.getWindowId(), winWrap);
+        this._monitors.get(monitor_id)?.removeWindow(winWrap);
+
+        Logger.warn("WARNING MINIMIZED ITEMS", JSON.stringify(this._minimizedItems));
         this._tileMonitors()
     }
 
     public handleWindowUnminimized(winWrap: WindowWrapper): void {
         Logger.log("WINDOW UNMINIMIZED");
-        const monitor_id = winWrap.getWindow().get_monitor()
+        Logger.log("WINDOW UNMINIMIZED", winWrap == null);
-        this._monitors.get(monitor_id)?.unminimizeWindow(winWrap);
+        // Logger.log("WINDOW UNMINIMIZED", winWrap);
+        // Logger.log("WINDOW UNMINIMIZED", winWrap.getWindowId());
+        this._minimizedItems.delete(winWrap.getWindowId());
+        this._addWindowWrapperToMonitor(winWrap);
         this._tileMonitors()
     }
 
@@ -257,10 +283,11 @@ export default class WindowManager implements IWindowManager {
      */
     handleWindowClosed(window: WindowWrapper): void {
 
-        // window.disconnectWindowSignals()
         const mon_id = window._window.get_monitor();
-        this._monitors.get(mon_id)?.removeWindow(window.getWindowId());
 
+        this._monitors.get(mon_id)?.removeWindow(window);
+
+        window.disconnectWindowSignals()
         // Remove from managed windows
         this.syncActiveWindow();
         // Retile remaining windows
@@ -269,17 +296,24 @@ export default class WindowManager implements IWindowManager {
 
 
     public addWindowToMonitor(window: Meta.Window) {
+
         Logger.log("ADDING WINDOW TO MONITOR", window, window);
         var wrapper = new WindowWrapper(window, this.handleWindowMinimized)
         wrapper.connectWindowSignals(this);
-        // wrapper.connectWindowSignals(this)
+        this._addWindowWrapperToMonitor(wrapper);
-        this._monitors.get(window.get_monitor())?.addWindow(wrapper)
+
+    }
+    _addWindowWrapperToMonitor(winWrap: WindowWrapper) {
+        if (winWrap.getWindow().minimized) {
+            this._minimizedItems.set(winWrap.getWindow().get_id(), winWrap);
+        }
+        this._monitors.get(winWrap.getWindow().get_monitor())?.addWindow(winWrap)
     }
 
     _tileMonitors(): void {
 
         for (const monitor of this._monitors.values()) {
-            monitor._tileWindows()
+            monitor.tileWindows()
         }
     }