feat: adding in demo settings page for gnome extensions

.gitignore

@@ -3,4 +3,3 @@ node_modules
 dist
 /schemas/gschemas.compiled
 /aerospike.zip
-/debug.log

.nvmrc

@@ -1 +0,0 @@
-v20

ambient.d.ts

@@ -2,10 +2,3 @@ import "@girs/gjs";
 import "@girs/gjs/dom";
 import "@girs/gnome-shell/ambient";
 import "@girs/gnome-shell/extensions/global";
-
-// Extend Meta.Window with our custom property
-declare namespace Meta {
-    interface Window {
-        _aerospikeData?: any;
-    }
-}

extension.ts

@@ -1,56 +1,264 @@
+import GLib from 'gi://GLib';
+import St from 'gi://St';
 import Meta from 'gi://Meta';
 import {Extension, ExtensionMetadata} from 'resource:///org/gnome/shell/extensions/extension.js';
+import Mtk from "@girs/mtk-16";
+
 import * as Main from 'resource:///org/gnome/shell/ui/main.js';
 import Gio from 'gi://Gio';
 import Shell from 'gi://Shell';
-import WindowManager from './src/wm/windowManager.js'
+
-import {Logger} from "./src/utils/logger.js";
+import { WindowTree, WindowNode, createWindowNode, addNodeChild, removeNode, findNodeByWindowId, calculateLayout } from './src/winGroup.js';
+
+type Signal = {
+    name: string;
+    id: number;
+}
+
+type WinWrapper = {
+    window: Meta.Window | null;
+    signals: Signal[] | null;
+}
+
+type WorkspaceMonitorKey = `${number}-${number}`; // format: "workspace-monitor"
+
+type DraggedWindowInfo = {
+    id: number;
+    originalMonitor: number;
+    originalWorkspace: number;
+}
 
 export default class aerospike extends Extension {
     settings: Gio.Settings;
     keyBindings: Map<string, number>;
-    windowManager: WindowManager;
+    borderActor: St.Widget | null;
+    focusWindowSignals: any[];
+    lastFocusedWindow: Meta.Window | null;
+    _focusSignal: number | null;
+    _windowCreateId: number | null;
+    _windows: Map<number, WinWrapper>;
+    _windowTrees: Map<WorkspaceMonitorKey, WindowTree>;
+    _activeWindowId: number | null;
+    _windowDragBeginId: number | null;
+    _windowDragEndId: number | null;
+    _draggedWindowInfo: DraggedWindowInfo | null;
+    _workspaceChangedId: number | null;
 
     constructor(metadata: ExtensionMetadata) {
         super(metadata);
         this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
         this.keyBindings = new Map();
-        this.windowManager = new WindowManager();
+        // Initialize instance variables
+        this.borderActor = null;
+        this.focusWindowSignals = [];
+        this.lastFocusedWindow = null;
+        this._focusSignal = null;
+        this._windowCreateId = null;
+        this._windows = new Map<number, WinWrapper>();
+        this._windowTrees = new Map<WorkspaceMonitorKey, WindowTree>();
+        this._activeWindowId = null;
+        this._windowDragBeginId = null;
+        this._windowDragEndId = null;
+        this._draggedWindowInfo = null;
+        this._workspaceChangedId = null;
     }
 
     enable() {
-        Logger.log("STARTING AEROSPIKE!")
+        try {
-        this.bindSettings();
+            console.log("STARTING AEROSPIKE!");
-        this.setupKeybindings();
+            
-        this.windowManager.enable()
+            // Initialize data structures
+            this._windows = new Map<number, WinWrapper>();
+            this._windowTrees = new Map<WorkspaceMonitorKey, WindowTree>();
+            this._activeWindowId = null;
+            this._draggedWindowInfo = null;
+            
+            // Connect to window creation
+            this._windowCreateId = global.display.connect(
+                'window-created',
+                (display, window) => {
+                    try {
+                        this.handleWindowCreated(window);
+                    } catch (e) {
+                        console.error("Error handling window creation:", e);
+                    }
+                }
+            );
+
+            // Connect to window drag operations
+            this._connectDraggingSignals();
+            
+            // Connect to workspace change signals
+            this._workspaceChangedId = global.workspace_manager.connect(
+                'workspace-switched',
+                (_workspaceManager, _oldWorkspaceIndex, _newWorkspaceIndex) => {
+                    try {
+                        this._refreshActiveWorkspace();
+                    } catch (e) {
+                        console.error("Error refreshing workspace:", e);
+                    }
+                }
+            );
+            
+            // Setup keybindings
+            this.bindSettings();
+            
+            // Capture existing windows - do this last
+            this._captureExistingWindows();
+            
+            console.log("AEROSPIKE STARTED SUCCESSFULLY");
+        } catch (e) {
+            console.error("Error enabling Aerospike:", e);
+            // Perform cleanup if something failed
+            this.disable();
+        }
     }
 
-    disable() {
+    _connectDraggingSignals() {
-        this.windowManager.disable()
+        // Handle window drag begin
-        this.removeKeybindings()
+        this._windowDragBeginId = global.display.connect(
+            'grab-op-begin',
+            (_display, window, op) => {
+                if (window && (op === Meta.GrabOp.MOVING || op === Meta.GrabOp.KEYBOARD_MOVING)) {
+                    this._handleDragBegin(window);
+                }
+            }
+        );
+        
+        // Handle window drag end
+        this._windowDragEndId = global.display.connect(
+            'grab-op-end',
+            (_display, window, op) => {
+                if (window && (op === Meta.GrabOp.MOVING || op === Meta.GrabOp.KEYBOARD_MOVING)) {
+                    this._handleDragEnd(window);
+                }
+            }
+        );
     }
 
+    _handleDragBegin(window: Meta.Window) {
+        try {
+            if (!window) {
+                console.error("Received null window in _handleDragBegin");
+                return;
+            }
+            
+            const workspace = window.get_workspace();
+            if (!workspace) {
+                console.error("Window has no workspace in _handleDragBegin");
+                return;
+            }
+            
+            const id = window.get_id();
+            console.log(`Drag begin for window ${id}`);
+            
+            this._draggedWindowInfo = {
+                id: id,
+                originalMonitor: window.get_monitor(),
+                originalWorkspace: workspace.index()
+            };
+            
+            console.log(`Original location: workspace ${this._draggedWindowInfo.originalWorkspace}, monitor ${this._draggedWindowInfo.originalMonitor}`);
+        } catch (e) {
+            console.error("Error in _handleDragBegin:", e);
+            this._draggedWindowInfo = null;
+        }
+    }
+
+    _handleDragEnd(window: Meta.Window) {
+        try {
+            if (!window) {
+                console.error("Received null window in _handleDragEnd");
+                this._draggedWindowInfo = null;
+                return;
+            }
+            
+            if (!this._draggedWindowInfo) {
+                console.log("No drag info available, ignoring drag end");
+                return;
+            }
+            
+            const workspace = window.get_workspace();
+            if (!workspace) {
+                console.error("Window has no workspace in _handleDragEnd");
+                this._draggedWindowInfo = null;
+                return;
+            }
+            
+            const id = window.get_id();
+            const newMonitor = window.get_monitor();
+            const newWorkspace = workspace.index();
+            
+            console.log(`Drag end for window ${id}: new location - workspace ${newWorkspace}, monitor ${newMonitor}`);
+            
+            // Check if monitor or workspace changed
+            if (this._draggedWindowInfo.originalMonitor !== newMonitor || 
+                this._draggedWindowInfo.originalWorkspace !== newWorkspace) {
+                
+                console.log(`Window moved from workspace ${this._draggedWindowInfo.originalWorkspace}, monitor ${this._draggedWindowInfo.originalMonitor}`);
+                console.log(`to workspace ${newWorkspace}, monitor ${newMonitor}`);
+                
+                // Remove from old tree
+                const oldKey = `${this._draggedWindowInfo.originalWorkspace}-${this._draggedWindowInfo.originalMonitor}` as WorkspaceMonitorKey;
+                this._removeWindowFromTree(id, oldKey);
+                
+                // Add to new tree
+                this._addWindowToTree(window, newWorkspace, newMonitor);
+                
+                // Retile both affected trees with a small delay
+                GLib.timeout_add(GLib.PRIORITY_DEFAULT, 50, () => {
+                    try {
+                        this._tileWindowsInTree(oldKey);
+                        this._tileWindowsInTree(`${newWorkspace}-${newMonitor}` as WorkspaceMonitorKey);
+                    } catch (e) {
+                        console.error("Error retiling after drag:", e);
+                    }
+                    return GLib.SOURCE_REMOVE;
+                });
+            } else {
+                console.log("Window position unchanged after drag");
+            }
+        } catch (e) {
+            console.error("Error in _handleDragEnd:", e);
+        } finally {
+            this._draggedWindowInfo = null;
+        }
+    }
+
+    _refreshActiveWorkspace() {
+        // Refresh all trees in the current workspace
+        const workspace = global.workspace_manager.get_active_workspace();
+        const workspaceIndex = workspace.index();
+        
+        // Find all trees in the current workspace
+        for (const key of this._windowTrees.keys()) {
+            const [wsIndex, _] = key.split('-').map(Number);
+            if (wsIndex === workspaceIndex) {
+                this._tileWindowsInTree(key as WorkspaceMonitorKey);
+            }
+        }
+    }
 
     private bindSettings() {
         // Monitor settings changes
-        this.settings.connect('changed::move-left', () => {
+        this.settings.connect('changed::keybinding-1', () => {
-            log(`Keybinding 1 changed to: ${this.settings.get_strv('move-left')}`);
+            log(`Keybinding 1 changed to: ${this.settings.get_strv('keybinding-1')}`);
-            this.refreshKeybinding('move-left');
+            this.refreshKeybinding('keybinding-1');
         });
 
-        this.settings.connect('changed::move-right', () => {
+        this.settings.connect('changed::keybinding-2', () => {
-            log(`Keybinding 2 changed to: ${this.settings.get_strv('move-right')}`);
+            log(`Keybinding 2 changed to: ${this.settings.get_strv('keybinding-2')}`);
-            this.refreshKeybinding('move-right');
+            this.refreshKeybinding('keybinding-2');
         });
 
-        this.settings.connect('changed::join-with-left', () => {
+        this.settings.connect('changed::keybinding-3', () => {
-            log(`Keybinding 3 changed to: ${this.settings.get_strv('join-with-left')}`);
+            log(`Keybinding 3 changed to: ${this.settings.get_strv('keybinding-3')}`);
-            this.refreshKeybinding('join-with-left');
+            this.refreshKeybinding('keybinding-3');
         });
 
-        this.settings.connect('changed::join-with-right', () => {
+        this.settings.connect('changed::keybinding-4', () => {
-            log(`Keybinding 4 changed to: ${this.settings.get_strv('join-with-right')}`);
+            log(`Keybinding 4 changed to: ${this.settings.get_strv('keybinding-4')}`);
-            this.refreshKeybinding('join-with-right');
+            this.refreshKeybinding('keybinding-4');
         });
 
         this.settings.connect('changed::dropdown-option', () => {
@@ -61,6 +269,7 @@ export default class aerospike extends Extension {
             log(`Color selection changed to: ${this.settings.get_string('color-selection')}`);
         });
     }
+    
     private refreshKeybinding(settingName: string) {
         if (this.keyBindings.has(settingName)) {
             Main.wm.removeKeybinding(settingName);
@@ -68,24 +277,24 @@ export default class aerospike extends Extension {
         }
 
         switch (settingName) {
-            case 'move-left':
+            case 'keybinding-1':
-                this.bindKeybinding('move-left', () => {
+                this.bindKeybinding('keybinding-1', () => {
-                    Logger.info('Keybinding 1 was pressed!');
+                    log('Keybinding 1 was pressed!');
                 });
                 break;
-            case 'move-right':
+            case 'keybinding-2':
-                this.bindKeybinding('move-right', () => {
+                this.bindKeybinding('keybinding-2', () => {
-                    Logger.info('Keybinding 2 was pressed!');
+                    log('Keybinding 2 was pressed!');
                 });
                 break;
-            case 'join-with-left':
+            case 'keybinding-3':
-                this.bindKeybinding('join-with-left', () => {
+                this.bindKeybinding('keybinding-3', () => {
-                    Logger.info('Keybinding 3 was pressed!');
+                    log('Keybinding 3 was pressed!');
                 });
                 break;
-            case 'join-with-right':
+            case 'keybinding-4':
-                this.bindKeybinding('join-with-right', () => {
+                this.bindKeybinding('keybinding-4', () => {
-                    Logger.info('Keybinding 4 was pressed!');
+                    log('Keybinding 4 was pressed!');
                 });
                 break;
         }
@@ -99,20 +308,20 @@ export default class aerospike extends Extension {
     }
 
     private setupKeybindings() {
-        this.bindKeybinding('move-left', () => {
+        this.bindKeybinding('keybinding-1', () => {
-            Logger.info('Keybinding 1 was pressed!');
+            log('Keybinding 1 was pressed!');
         });
 
-        this.bindKeybinding('move-right', () => {
+        this.bindKeybinding('keybinding-2', () => {
-            Logger.info('Keybinding 2 was pressed!');
+            log('Keybinding 2 was pressed!');
         });
 
-        this.bindKeybinding('join-with-left', () => {
+        this.bindKeybinding('keybinding-3', () => {
-            Logger.info('Keybinding 3 was pressed!');
+            log('Keybinding 3 was pressed!');
         });
 
-        this.bindKeybinding('join-with-right', () => {
+        this.bindKeybinding('keybinding-4', () => {
-            Logger.info('Keybinding 4 was pressed!');
+            log('Keybinding 4 was pressed!');
         });
     }
 
@@ -126,7 +335,7 @@ export default class aerospike extends Extension {
         const keyBindingAction = Main.wm.addKeybinding(
             settingName,
             this.settings,
-            Meta.KeyBindingFlags.NONE,
+            Meta.KeyBindingFlags.IGNORE_AUTOREPEAT,
             Shell.ActionMode.NORMAL,
             callback
         );
@@ -134,6 +343,566 @@ export default class aerospike extends Extension {
         this.keyBindings.set(settingName, keyBindingAction);
     }
 
+    handleWindowCreated(window: Meta.Window) {
+        try {
+            if (!window) {
+                console.error("Received null or undefined window");
+                return;
+            }
+            
+            console.log("WINDOW CREATED", window);
+            
+            if (!this._isWindowTileable(window)) {
+                console.log("Window is not tileable, ignoring");
+                return;
+            }
+            
+            console.log("WINDOW IS TILABLE");
+            
+            const actor = window.get_compositor_private();
+            if (!actor) {
+                console.log("Window has no compositor actor, ignoring");
+                return;
+            }
+            
+            // Get workspace safely
+            const workspace = window.get_workspace();
+            if (!workspace) {
+                console.error("Window has no workspace, ignoring");
+                return;
+            }
+            
+            // Track window for signal management
+            this._addWindow(window);
+            
+            // Add to appropriate tree
+            const workspaceIndex = workspace.index();
+            const monitor = window.get_monitor();
+            
+            console.log(`Adding window to workspace ${workspaceIndex}, monitor ${monitor}`);
+            this._addWindowToTree(window, workspaceIndex, monitor);
+        } catch (e) {
+            console.error("Error in handleWindowCreated:", e);
+        }
+    }
 
+    _captureExistingWindows() {
+        try {
+            console.log("CAPTURING WINDOWS");
+            
+            // Get all workspaces
+            const workspaceCount = global.workspace_manager.get_n_workspaces();
+            const monitorCount = global.display.get_n_monitors();
+            
+            console.log(`Found ${workspaceCount} workspaces and ${monitorCount} monitors`);
+            
+            // Initialize trees for all workspace-monitor combinations
+            for (let wsIndex = 0; wsIndex < workspaceCount; wsIndex++) {
+                const workspace = global.workspace_manager.get_workspace_by_index(wsIndex);
+                if (!workspace) {
+                    console.error(`Workspace at index ${wsIndex} not found`);
+                    continue;
+                }
+                
+                for (let monIndex = 0; monIndex < monitorCount; monIndex++) {
+                    try {
+                        // Create empty tree for this workspace-monitor combination
+                        this._getWindowTree(wsIndex, monIndex);
+                        
+                        // Get windows for this workspace
+                        const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
+                        console.log(`Found ${windows.length} windows in workspace ${wsIndex}`);
+                        
+                        // Add tileable windows to the appropriate tree
+                        let addedWindows = 0;
+                        for (const window of windows) {
+                            try {
+                                if (window && this._isWindowTileable(window) && window.get_monitor() === monIndex) {
+                                    // Track window for signal management
+                                    this._addWindow(window);
+                                    
+                                    // Add to tree
+                                    this._addWindowToTree(window, wsIndex, monIndex);
+                                    addedWindows++;
+                                }
+                            } catch (e) {
+                                console.error(`Error processing window in workspace ${wsIndex}, monitor ${monIndex}:`, e);
+                            }
+                        }
+                        
+                        console.log(`Added ${addedWindows} windows to workspace ${wsIndex}, monitor ${monIndex}`);
+                    } catch (e) {
+                        console.error(`Error processing monitor ${monIndex} in workspace ${wsIndex}:`, e);
+                    }
+                }
+            }
+            
+            // Tile all trees with a slight delay to ensure all windows are ready
+            GLib.timeout_add(GLib.PRIORITY_DEFAULT, 100, () => {
+                try {
+                    for (const key of this._windowTrees.keys()) {
+                        this._tileWindowsInTree(key as WorkspaceMonitorKey);
+                    }
+                } catch (e) {
+                    console.error("Error tiling windows:", e);
+                }
+                return GLib.SOURCE_REMOVE;
+            });
+            
+            console.log("FINISHED CAPTURING WINDOWS");
+        } catch (e) {
+            console.error("Error in _captureExistingWindows:", e);
+        }
+    }
+    
+    _getWindowTree(workspace: number, monitor: number): WindowTree {
+        const key: WorkspaceMonitorKey = `${workspace}-${monitor}` as WorkspaceMonitorKey;
+        
+        if (!this._windowTrees.has(key)) {
+            this._windowTrees.set(key, {
+                root: null,
+                monitor: monitor,
+                workspace: workspace
+            });
+        }
+        
+        return this._windowTrees.get(key)!;
+    }
+    
+    _addWindowToTree(window: Meta.Window, workspace: number, monitor: number) {
+        const tree = this._getWindowTree(workspace, monitor);
+        const windowNode = createWindowNode(window);
+        
+        if (!tree.root) {
+            // First window in this tree
+            tree.root = windowNode;
+        } else {
+            // Add to existing tree
+            addNodeChild(tree.root, windowNode);
+        }
+        
+        // Update the layout
+        this._tileWindowsInTree(`${workspace}-${monitor}` as WorkspaceMonitorKey);
+    }
+    
+    _removeWindowFromTree(windowId: number, key: WorkspaceMonitorKey) {
+        const tree = this._windowTrees.get(key);
+        if (!tree) return;
+        
+        const node = findNodeByWindowId(tree, windowId);
+        if (node) {
+            removeNode(node, tree);
+        }
+    }
+    
+    _tileWindowsInTree(key: WorkspaceMonitorKey) {
+        try {
+            console.log(`Tiling windows for ${key}`);
+            
+            const tree = this._windowTrees.get(key);
+            if (!tree || !tree.root) {
+                console.log(`No tree or empty tree for ${key}`);
+                return;
+            }
+            
+            // Get workspace and monitor info
+            const [workspaceIndex, monitorIndex] = key.split('-').map(Number);
+            
+            const workspace = global.workspace_manager.get_workspace_by_index(workspaceIndex);
+            if (!workspace) {
+                console.error(`Workspace ${workspaceIndex} not found`);
+                return;
+            }
+            
+            const workArea = workspace.get_work_area_for_monitor(monitorIndex);
+            if (!workArea) {
+                console.error(`WorkArea for monitor ${monitorIndex} in workspace ${workspaceIndex} not found`);
+                return;
+            }
+            
+            console.log(`Work area for ${key}: ${workArea.x},${workArea.y} ${workArea.width}x${workArea.height}`);
+            
+            // Calculate layout
+            calculateLayout(tree.root, {
+                x: workArea.x,
+                y: workArea.y,
+                width: workArea.width,
+                height: workArea.height
+            });
+            
+            // Apply layout to all windows in the tree
+            this._applyLayoutToTree(tree.root);
+            
+            console.log(`Finished tiling windows for ${key}`);
+        } catch (e) {
+            console.error(`Error tiling windows for ${key}:`, e);
+        }
+    }
+    
+    _applyLayoutToTree(node: WindowNode) {
+        try {
+            // Apply layout to this node
+            if (node.window) {
+                // Validate window object
+                if (!node.window.get_compositor_private) {
+                    console.error(`Window at node ${node.windowId} is invalid`);
+                    return;
+                }
+                
+                // Check for valid rect dimensions
+                if (node.rect.width <= 0 || node.rect.height <= 0) {
+                    console.error(`Invalid rect dimensions for window ${node.windowId}: ${node.rect.width}x${node.rect.height}`);
+                    return;
+                }
+                
+                // Resize window
+                this.safelyResizeWindow(
+                    node.window,
+                    node.rect.x,
+                    node.rect.y,
+                    node.rect.width,
+                    node.rect.height
+                );
+            }
+            
+            // Apply layout to all children
+            for (const child of node.children) {
+                try {
+                    this._applyLayoutToTree(child);
+                } catch (e) {
+                    console.error(`Error applying layout to child node:`, e);
+                }
+            }
+        } catch (e) {
+            console.error(`Error in _applyLayoutToTree:`, e);
+        }
+    }
 
+    getUsableMonitorSpace(window: Meta.Window) {
+        // Get the current workspace
+        const workspace = window.get_workspace();
+
+        // Get the monitor index that this window is on
+        const monitorIndex = window.get_monitor();
+
+        // Get the work area
+        const workArea = workspace.get_work_area_for_monitor(monitorIndex);
+
+        return {
+            x: workArea.x,
+            y: workArea.y,
+            width: workArea.width,
+            height: workArea.height
+        };
+    }
+
+    // Function to safely resize a window after it's ready
+    safelyResizeWindow(win: Meta.Window, x: number, y: number, width: number, height: number): void {
+        const actor = win.get_compositor_private();
+
+        if (!actor) {
+            console.log("No actor available, can't resize safely yet");
+            return;
+        }
+        
+        // Check if the window type needs special handling
+        const windowType = win.get_window_type();
+        
+        // Try immediate resize first for most window types
+        if (windowType === Meta.WindowType.NORMAL) {
+            // Standard resizing path with safety checks
+            this.resizeWindow(win, x, y, width, height);
+            
+            // Set up a verification check
+            GLib.timeout_add(GLib.PRIORITY_DEFAULT, 100, () => {
+                const rect = win.get_frame_rect();
+                
+                // If window didn't resize well, try again with the first-frame signal
+                if (Math.abs(rect.width - width) > 5 || Math.abs(rect.height - height) > 5) {
+                    this._setupFirstFrameResize(win, actor, x, y, width, height);
+                }
+                
+                return GLib.SOURCE_REMOVE;
+            });
+        } else {
+            // For non-standard windows, use the original approach
+            this._setupFirstFrameResize(win, actor, x, y, width, height);
+        }
+    }
+    
+    _setupFirstFrameResize(win: Meta.Window, actor: any, x: number, y: number, width: number, height: number): void {
+        // Set a flag to track if the resize has been done
+        let resizeDone = false;
+
+        // Connect to the first-frame signal
+        const id = actor.connect('first-frame', () => {
+            // Disconnect the signal handler
+            actor.disconnect(id);
+
+            if (!resizeDone) {
+                resizeDone = true;
+
+                // Add a small delay
+                GLib.timeout_add(GLib.PRIORITY_DEFAULT, 150, () => {
+                    try {
+                        this.resizeWindow(win, x, y, width, height);
+                    } catch (e) {
+                        console.error("Error resizing window:", e);
+                    }
+                    return GLib.SOURCE_REMOVE;
+                });
+            }
+        });
+
+        // Fallback timeout in case the first-frame signal doesn't fire
+        // (for windows that are already mapped)
+        GLib.timeout_add(GLib.PRIORITY_DEFAULT, 50, () => {
+            if (!resizeDone) {
+                resizeDone = true;
+                try {
+                    this.resizeWindow(win, x, y, width, height);
+                } catch (e) {
+                    console.error("Error resizing window (fallback):", e);
+                }
+            }
+            return GLib.SOURCE_REMOVE;
+        });
+    }
+
+    resizeWindow(win: Meta.Window, x:number, y:number, width:number, height:number) {
+        // First, ensure window is not maximized or fullscreen
+        const wasMaximized = win.get_maximized();
+        const wasFullscreen = win.is_fullscreen();
+        
+        if (wasMaximized) {
+            console.log("WINDOW MAXIMIZED")
+            win.unmaximize(Meta.MaximizeFlags.BOTH);
+        }
+
+        if (wasFullscreen) {
+            console.log("WINDOW IS FULLSCREEN")
+            win.unmake_fullscreen();
+        }
+        
+        // Wait for state change to complete if needed
+        if (wasMaximized || wasFullscreen) {
+            GLib.idle_add(GLib.PRIORITY_DEFAULT, () => {
+                this._performResize(win, x, y, width, height);
+                return GLib.SOURCE_REMOVE;
+            });
+        } else {
+            // Immediate resize if no state change needed
+            this._performResize(win, x, y, width, height);
+        }
+    }
+    
+    _performResize(win: Meta.Window, x:number, y:number, width:number, height:number) {
+        console.log("WINDOW", win.get_window_type(), win.allows_move());
+        console.log("MONITOR INFO", this.getUsableMonitorSpace(win));
+        console.log("NEW_SIZE", x, y, width, height);
+        
+        // Perform the actual resize
+        win.move_resize_frame(false, x, y, width, height);
+        
+        // Check result
+        const newRect = win.get_frame_rect();
+        console.log("RESIZED WINDOW", newRect.height, newRect.width, newRect.x, newRect.y);
+        
+        // Validate the resize was successful
+        if (Math.abs(newRect.x - x) > 5 || Math.abs(newRect.y - y) > 5 || 
+            Math.abs(newRect.width - width) > 5 || Math.abs(newRect.height - height) > 5) {
+            console.warn(`Resize did not achieve expected dimensions for window ${win.get_id()}`);
+            
+            // Try a second time if the resize didn't work well
+            GLib.timeout_add(GLib.PRIORITY_DEFAULT, 50, () => {
+                win.move_resize_frame(false, x, y, width, height);
+                return GLib.SOURCE_REMOVE;
+            });
+        }
+    }
+
+    _addWindow(window: Meta.Window) {
+        const windowId = window.get_id();
+
+        // Connect to window signals
+        const signals: Signal[] = [];
+        console.log("ADDING WINDOW", window);
+
+        const destroyId = window.connect('unmanaging', () => {
+            console.log("REMOVING WINDOW", windowId);
+            this._handleWindowClosed(windowId);
+        });
+        signals.push({name: 'unmanaging', id: destroyId});
+
+        const focusId = window.connect('notify::has-focus', () => {
+            if (window.has_focus()) {
+                this._activeWindowId = windowId;
+            }
+        });
+        signals.push({name: 'notify::has-focus', id: focusId});
+        
+        // Monitor change signal
+        const monitorChangedId = window.connect('notify::monitor', () => {
+            this._handleWindowMonitorChanged(window);
+        });
+        signals.push({name: 'notify::monitor', id: monitorChangedId});
+        
+        // Workspace change signal
+        const workspaceChangedId = window.connect('workspace-changed', () => {
+            this._handleWindowWorkspaceChanged(window);
+        });
+        signals.push({name: 'workspace-changed', id: workspaceChangedId});
+
+        // Add window to managed windows
+        this._windows.set(windowId, {
+            window: window,
+            signals: signals
+        });
+
+        // If this is the first window, make it the active one
+        if (this._windows.size === 1 || window.has_focus()) {
+            this._activeWindowId = windowId;
+        }
+    }
+    
+    _handleWindowMonitorChanged(window: Meta.Window) {
+        const windowId = window.get_id();
+        
+        // Find which tree this window is in
+        for (const [key, tree] of this._windowTrees.entries()) {
+            const node = findNodeByWindowId(tree, windowId);
+            if (node) {
+                // Found the window - get new workspace/monitor
+                const newWorkspace = window.get_workspace().index();
+                const newMonitor = window.get_monitor();
+                const newKey = `${newWorkspace}-${newMonitor}` as WorkspaceMonitorKey;
+                
+                // Skip if it's already in the right tree
+                if (key === newKey) return;
+                
+                // Remove from old tree
+                this._removeWindowFromTree(windowId, key as WorkspaceMonitorKey);
+                
+                // Add to new tree
+                this._addWindowToTree(window, newWorkspace, newMonitor);
+                
+                // Retile both trees
+                this._tileWindowsInTree(key as WorkspaceMonitorKey);
+                this._tileWindowsInTree(newKey);
+                
+                return;
+            }
+        }
+    }
+    
+    _handleWindowWorkspaceChanged(window: Meta.Window) {
+        // Similar to monitor change, but for workspace changes
+        this._handleWindowMonitorChanged(window); // This handles both cases
+    }
+
+    _handleWindowClosed(windowId: number) {
+        print("closing window", windowId);
+        const windowData = this._windows.get(windowId);
+        if (!windowData) {
+            return;
+        }
+
+        // Disconnect signals
+        if (windowData.signals) {
+            windowData.signals.forEach(signal => {
+                try {
+                    if (windowData.window != null) {
+                        windowData.window.disconnect(signal.id);
+                    }
+                } catch (e) {
+                    // Window might already be gone
+                }
+            });
+        }
+
+        // Remove from managed windows
+        this._windows.delete(windowId);
+
+        // Remove from all trees
+        for (const key of this._windowTrees.keys()) {
+            this._removeWindowFromTree(windowId, key as WorkspaceMonitorKey);
+            this._tileWindowsInTree(key as WorkspaceMonitorKey);
+        }
+
+        // If this was the active window, find a new one
+        if (this._activeWindowId === windowId && this._windows.size > 0) {
+            this._activeWindowId = Array.from(this._windows.keys())[0];
+        } else if (this._windows.size === 0) {
+            this._activeWindowId = null;
+        }
+    }
+
+    _isWindowTileable(window: Meta.Window) {
+        if (!window || !window.get_compositor_private()) {
+            return false;
+        }
+
+        const windowType = window.get_window_type();
+        console.log("WINDOW TYPE", windowType);
+        // Skip certain types of windows
+        return !window.is_skip_taskbar() &&
+            windowType !== Meta.WindowType.DESKTOP &&
+            windowType !== Meta.WindowType.DOCK &&
+            windowType !== Meta.WindowType.DIALOG &&
+            windowType !== Meta.WindowType.MODAL_DIALOG &&
+            windowType !== Meta.WindowType.UTILITY &&
+            windowType !== Meta.WindowType.MENU;
+    }
+
+    disable() {
+        console.log("DISABLED AEROSPIKE!")
+        
+        // Disconnect window creation signal
+        if (this._windowCreateId) {
+            global.display.disconnect(this._windowCreateId);
+            this._windowCreateId = null;
+        }
+        
+        // Disconnect workspace signals
+        if (this._workspaceChangedId) {
+            global.workspace_manager.disconnect(this._workspaceChangedId);
+            this._workspaceChangedId = null;
+        }
+        
+        // Disconnect drag signals
+        if (this._windowDragBeginId) {
+            global.display.disconnect(this._windowDragBeginId);
+            this._windowDragBeginId = null;
+        }
+        
+        if (this._windowDragEndId) {
+            global.display.disconnect(this._windowDragEndId);
+            this._windowDragEndId = null;
+        }
+        
+        // Disconnect all window signals
+        this._windows.forEach((windowData) => {
+            if (windowData.signals && windowData.window) {
+                windowData.signals.forEach(signal => {
+                    try {
+                        windowData.window!.disconnect(signal.id);
+                    } catch (e) {
+                        // Window might already be gone
+                    }
+                });
+            }
+        });
+        
+        // Clear all window data
+        this._windows.clear();
+        this._windowTrees.clear();
+        
+        // Remove keybindings
+        this.removeKeybindings();
+        
+        // Reset state
+        this._activeWindowId = null;
+        this.lastFocusedWindow = null;
+        this._draggedWindowInfo = null;
+    }
 }

justfile

@@ -32,9 +32,6 @@ run:
 
 install-and-run: install run
 
-live-debug:
-    journalctl /usr/bin/gnome-shell -f -o cat | tee debug.log
-
 #pack: build
 #    gnome-extensions pack dist \
 #        --force \

package.json

@@ -18,8 +18,8 @@
   "devDependencies": {
     "@girs/gjs": "4.0.0-beta.23",
     "@girs/gnome-shell": "^48.0.2",
-    "eslint": "^9.27.0",
+    "eslint": "^9.24.0",
-    "eslint-plugin-jsdoc": "^50.6.17",
+    "eslint-plugin-jsdoc": "^50.6.9",
     "typescript": "^5.8.3"
   },
   "dependencies": {

pnpm-lock.yaml

@@ -19,23 +19,23 @@ importers:
         specifier: ^48.0.2
         version: 48.0.2
       eslint:
-        specifier: ^9.27.0
+        specifier: ^9.24.0
-        version: 9.27.0
+        version: 9.24.0
       eslint-plugin-jsdoc:
-        specifier: ^50.6.17
+        specifier: ^50.6.9
-        version: 50.6.17(eslint@9.27.0)
+        version: 50.6.9(eslint@9.24.0)
       typescript:
         specifier: ^5.8.3
         version: 5.8.3
 
 packages:
 
-  '@es-joy/jsdoccomment@0.50.2':
+  '@es-joy/jsdoccomment@0.49.0':
-    resolution: {integrity: sha512-YAdE/IJSpwbOTiaURNCKECdAwqrJuFiZhylmesBcIRawtYKnBR2wxPhoIewMg+Yu+QuYvHfJNReWpoxGBKOChA==}
+    resolution: {integrity: sha512-xjZTSFgECpb9Ohuk5yMX5RhUEbfeQcuOp8IF60e+wyzWEF0M5xeSgqsfLtvPEX8BIyOX9saZqzuGPmZ8oWc+5Q==}
-    engines: {node: '>=18'}
+    engines: {node: '>=16'}
 
-  '@eslint-community/eslint-utils@4.7.0':
+  '@eslint-community/eslint-utils@4.5.1':
-    resolution: {integrity: sha512-dyybb3AcajC7uha6CvhdVRJqaKyn7w2YKqKyAN37NKYgZT36w+iRb0Dymmc5qEJ549c/S31cMMSFd75bteCpCw==}
+    resolution: {integrity: sha512-soEIOALTfTK6EjmKMMoLugwaP0rzkad90iIWd1hMO9ARkSAyjfMfkRRhLvD5qH7vvM0Cg72pieUfR6yh6XxC4w==}
     engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
     peerDependencies:
       eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
@@ -48,28 +48,32 @@ packages:
     resolution: {integrity: sha512-fxlS1kkIjx8+vy2SjuCB94q3htSNrufYTXubwiBFeaQHbH6Ipi43gFJq2zCMt6PHhImH3Xmr0NksKDvchWlpQQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@eslint/config-helpers@0.2.2':
+  '@eslint/config-helpers@0.2.1':
-    resolution: {integrity: sha512-+GPzk8PlG0sPpzdU5ZvIRMPidzAnZDl/s9L+y13iodqvb8leL53bTannOrQ/Im7UkpsmFU5Ily5U60LWixnmLg==}
+    resolution: {integrity: sha512-RI17tsD2frtDu/3dmI7QRrD4bedNKPM08ziRYaC5AhkGrzIAJelm9kJU1TznK+apx6V+cqRz8tfpEeG3oIyjxw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@eslint/core@0.14.0':
+  '@eslint/core@0.12.0':
-    resolution: {integrity: sha512-qIbV0/JZr7iSDjqAc60IqbLdsj9GDt16xQtWD+B78d/HAlvysGdZZ6rpJHGAc2T0FQx1X6thsSPdnoiGKdNtdg==}
+    resolution: {integrity: sha512-cmrR6pytBuSMTaBweKoGMwu3EiHiEC+DoyupPmlZ0HxBJBtIxwe+j/E4XPIKNx+Q74c8lXKPwYawBf5glsTkHg==}
+    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
+
+  '@eslint/core@0.13.0':
+    resolution: {integrity: sha512-yfkgDw1KR66rkT5A8ci4irzDysN7FRpq3ttJolR88OqQikAWqwA8j5VZyas+vjyBNFIJ7MfybJ9plMILI2UrCw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/eslintrc@3.3.1':
     resolution: {integrity: sha512-gtF186CXhIl1p4pJNGZw8Yc6RlshoePRvE0X91oPGb3vZ8pM3qOS9W9NGPat9LziaBV7XrJWGylNQXkGcnM3IQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@eslint/js@9.27.0':
+  '@eslint/js@9.24.0':
-    resolution: {integrity: sha512-G5JD9Tu5HJEu4z2Uo4aHY2sLV64B7CDMXxFzqzjl3NKd6RVzSXNoE80jk7Y0lJkTTkjiIhBAqmlYwjuBY3tvpA==}
+    resolution: {integrity: sha512-uIY/y3z0uvOGX8cp1C2fiC4+ZmBhp6yZWkojtHL1YEMnRt1Y63HB9TM17proGEmeG7HeUY+UP36F0aknKYTpYA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@eslint/object-schema@2.1.6':
     resolution: {integrity: sha512-RBMg5FRL0I0gs51M/guSAj5/e14VQ4tpZnQNWwuDT66P14I43ItmPfIZRhO9fUVIPOAQXU47atlywZ/czoqFPA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  '@eslint/plugin-kit@0.3.1':
+  '@eslint/plugin-kit@0.2.8':
-    resolution: {integrity: sha512-0J+zgWxHN+xXONWIyPWKFMgVuJoZuGiIFu8yxk7RJjxkzpGmyja5wRFqZIVtjDVOQpV+Rw0iOAjYPE2eQyjr0w==}
+    resolution: {integrity: sha512-ZAoA40rNMPwSm+AeHpCq8STiNAwzWLJuP8Xv4CHIc9wv/PSuExjMrmjfYNj682vW0OOiZ1HKxzvjQr9XZIisQA==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
   '@girs/accountsservice-1.0@1.0.0-4.0.0-beta.23':
@@ -214,20 +218,20 @@ packages:
     resolution: {integrity: sha512-JBxkERygn7Bv/GbN5Rv8Ul6LVknS+5Bp6RgDC/O8gEBU/yeH5Ui5C/OlWrTb6qct7LjjfT6Re2NxB0ln0yYybA==}
     engines: {node: '>=18.18'}
 
-  '@humanwhocodes/retry@0.4.3':
+  '@humanwhocodes/retry@0.4.2':
-    resolution: {integrity: sha512-bV0Tgo9K4hfPCek+aMAn81RppFKv2ySDQeMoSZuvTASywNTnVJCArCZE2FWqpvIatKu7VMRLWlR1EazvVhDyhQ==}
+    resolution: {integrity: sha512-xeO57FpIu4p1Ri3Jq/EXq4ClRm86dVF2z/+kvFnyqVYRavTZmaFaUBbWCOuuTh0o/g7DSsk6kc2vrS4Vl5oPOQ==}
     engines: {node: '>=18.18'}
 
+  '@pkgr/core@0.1.2':
+    resolution: {integrity: sha512-fdDH1LSGfZdTH2sxdpVMw31BanV28K/Gry0cVFxaNP77neJSkd82mM8ErPNYs9e+0O7SdHBLTDzDgwUuy18RnQ==}
+    engines: {node: ^12.20.0 || ^14.18.0 || >=16.0.0}
+
   '@types/estree@1.0.7':
     resolution: {integrity: sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ==}
 
   '@types/json-schema@7.0.15':
     resolution: {integrity: sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==}
 
-  '@typescript-eslint/types@8.32.1':
-    resolution: {integrity: sha512-YmybwXUJcgGqgAp6bEsgpPXEg6dcCyPyCSr0CAAueacR/CCBi25G3V8gGQ2kRzQRBNol7VQknxMs9HvVa9Rvfg==}
-    engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
-
   acorn-jsx@5.3.2:
     resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
     peerDependencies:
@@ -284,8 +288,8 @@ packages:
     resolution: {integrity: sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==}
     engines: {node: '>= 8'}
 
-  debug@4.4.1:
+  debug@4.4.0:
-    resolution: {integrity: sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==}
+    resolution: {integrity: sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==}
     engines: {node: '>=6.0'}
     peerDependencies:
       supports-color: '*'
@@ -296,12 +300,15 @@ packages:
   deep-is@0.1.4:
     resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
 
+  es-module-lexer@1.6.0:
+    resolution: {integrity: sha512-qqnD1yMU6tk/jnaMosogGySTZP8YtUgAffA9nMN+E/rjxcfRQ6IEk7IiozUjgxKoFHBGjTLnrHB/YC45r/59EQ==}
+
   escape-string-regexp@4.0.0:
     resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
     engines: {node: '>=10'}
 
-  eslint-plugin-jsdoc@50.6.17:
+  eslint-plugin-jsdoc@50.6.9:
-    resolution: {integrity: sha512-hq+VQylhd12l8qjexyriDsejZhqiP33WgMTy2AmaGZ9+MrMWVqPECsM87GPxgHfQn0zw+YTuhqjUfk1f+q67aQ==}
+    resolution: {integrity: sha512-7/nHu3FWD4QRG8tCVqcv+BfFtctUtEDWc29oeDXB4bwmDM2/r1ndl14AG/2DUntdqH7qmpvdemJKwb3R97/QEw==}
     engines: {node: '>=18'}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0 || ^9.0.0
@@ -318,8 +325,8 @@ packages:
     resolution: {integrity: sha512-UyLnSehNt62FFhSwjZlHmeokpRK59rcz29j+F1/aDgbkbRTk7wIc9XzdoasMUbRNKDM0qQt/+BJ4BrpFeABemw==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
 
-  eslint@9.27.0:
+  eslint@9.24.0:
-    resolution: {integrity: sha512-ixRawFQuMB9DZ7fjU3iGGganFDp3+45bPOdaRurcFHSXO1e/sYwUX/FtQZpLZJR6SjMoJH8hR2pPEAfDyCoU2Q==}
+    resolution: {integrity: sha512-eh/jxIEJyZrvbWRe4XuVclLPDYSYYYgLy5zXGGxD6j8zjSAxFEzI2fL/8xNq6O2yKqVt+eF2YhV+hxjV6UKXwQ==}
     engines: {node: ^18.18.0 || ^20.9.0 || >=21.1.0}
     hasBin: true
     peerDependencies:
@@ -463,11 +470,9 @@ packages:
     resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
     engines: {node: '>=6'}
 
-  parse-imports-exports@0.2.4:
+  parse-imports@2.2.1:
-    resolution: {integrity: sha512-4s6vd6dx1AotCx/RCI2m7t7GCh5bDRUtGNvRfHSP2wbBQdMi67pPe7mtzmgwcaQ8VKK/6IB7Glfyu3qdZJPybQ==}
+    resolution: {integrity: sha512-OL/zLggRp8mFhKL0rNORUTR4yBYujK/uU+xZL+/0Rgm2QE4nLO9v8PzEweSJEbMGKmDRjJE4R3IMJlL2di4JeQ==}
-
+    engines: {node: '>= 18'}
-  parse-statements@1.0.11:
-    resolution: {integrity: sha512-HlsyYdMBnbPQ9Jr/VgJ1YF4scnldvJpJxCVx6KgqPL4dxppsWrJHCIIxQXMJrqGnsRkNPATbeMJ8Yxu7JMsYcA==}
 
   path-exists@4.0.0:
     resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
@@ -489,8 +494,8 @@ packages:
     resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
     engines: {node: '>=4'}
 
-  semver@7.7.2:
+  semver@7.7.1:
-    resolution: {integrity: sha512-RF0Fw+rO5AMf9MAyaRXI4AV0Ulj5lMHqVxxdSgiVbixSCXoEmmX/jk0CuJw4+3SqroYO9VoUh+HcuJivvtJemA==}
+    resolution: {integrity: sha512-hlq8tAfn0m/61p4BVRcPzIGr6LKiMwo4VM6dGi6pt4qcRkmNzTcWq6eCEjEh+qXjkMDvPlOFFSGwQjoEa6gyMA==}
     engines: {node: '>=10'}
     hasBin: true
 
@@ -502,6 +507,9 @@ packages:
     resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
     engines: {node: '>=8'}
 
+  slashes@3.0.12:
+    resolution: {integrity: sha512-Q9VME8WyGkc7pJf6QEkj3wE+2CnvZMI+XJhwdTPR8Z/kWQRXi7boAWLDibRPyHRTUTPx5FaU7MsyrjI3yLB4HA==}
+
   spdx-exceptions@2.5.0:
     resolution: {integrity: sha512-PiU42r+xO4UbUS1buo3LPJkjlO7430Xn5SVAhdpzzsPHsjbYVflnnFdATgabnLude+Cqu25p6N+g2lw/PFsa4w==}
 
@@ -519,6 +527,13 @@ packages:
     resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
     engines: {node: '>=8'}
 
+  synckit@0.9.2:
+    resolution: {integrity: sha512-vrozgXDQwYO72vHjUb/HnFbQx1exDjoKzqx23aXEg2a9VIg2TSFZ8FmeZpTjUCFMYw7mpX4BE2SFu8wI7asYsw==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+
+  tslib@2.8.1:
+    resolution: {integrity: sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==}
+
   type-check@0.4.0:
     resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
     engines: {node: '>= 0.8.0'}
@@ -546,17 +561,15 @@ packages:
 
 snapshots:
 
-  '@es-joy/jsdoccomment@0.50.2':
+  '@es-joy/jsdoccomment@0.49.0':
     dependencies:
-      '@types/estree': 1.0.7
-      '@typescript-eslint/types': 8.32.1
       comment-parser: 1.4.1
       esquery: 1.6.0
       jsdoc-type-pratt-parser: 4.1.0
 
-  '@eslint-community/eslint-utils@4.7.0(eslint@9.27.0)':
+  '@eslint-community/eslint-utils@4.5.1(eslint@9.24.0)':
     dependencies:
-      eslint: 9.27.0
+      eslint: 9.24.0
       eslint-visitor-keys: 3.4.3
 
   '@eslint-community/regexpp@4.12.1': {}
@@ -564,21 +577,25 @@ snapshots:
   '@eslint/config-array@0.20.0':
     dependencies:
       '@eslint/object-schema': 2.1.6
-      debug: 4.4.1
+      debug: 4.4.0
       minimatch: 3.1.2
     transitivePeerDependencies:
       - supports-color
 
-  '@eslint/config-helpers@0.2.2': {}
+  '@eslint/config-helpers@0.2.1': {}
 
-  '@eslint/core@0.14.0':
+  '@eslint/core@0.12.0':
+    dependencies:
+      '@types/json-schema': 7.0.15
+
+  '@eslint/core@0.13.0':
     dependencies:
       '@types/json-schema': 7.0.15
 
   '@eslint/eslintrc@3.3.1':
     dependencies:
       ajv: 6.12.6
-      debug: 4.4.1
+      debug: 4.4.0
       espree: 10.3.0
       globals: 14.0.0
       ignore: 5.3.2
@@ -589,13 +606,13 @@ snapshots:
     transitivePeerDependencies:
       - supports-color
 
-  '@eslint/js@9.27.0': {}
+  '@eslint/js@9.24.0': {}
 
   '@eslint/object-schema@2.1.6': {}
 
-  '@eslint/plugin-kit@0.3.1':
+  '@eslint/plugin-kit@0.2.8':
     dependencies:
-      '@eslint/core': 0.14.0
+      '@eslint/core': 0.13.0
       levn: 0.4.1
 
   '@girs/accountsservice-1.0@1.0.0-4.0.0-beta.23':
@@ -1054,14 +1071,14 @@ snapshots:
 
   '@humanwhocodes/retry@0.3.1': {}
 
-  '@humanwhocodes/retry@0.4.3': {}
+  '@humanwhocodes/retry@0.4.2': {}
+
+  '@pkgr/core@0.1.2': {}
 
   '@types/estree@1.0.7': {}
 
   '@types/json-schema@7.0.15': {}
 
-  '@typescript-eslint/types@8.32.1': {}
-
   acorn-jsx@5.3.2(acorn@8.14.1):
     dependencies:
       acorn: 8.14.1
@@ -1113,27 +1130,30 @@ snapshots:
       shebang-command: 2.0.0
       which: 2.0.2
 
-  debug@4.4.1:
+  debug@4.4.0:
     dependencies:
       ms: 2.1.3
 
   deep-is@0.1.4: {}
 
+  es-module-lexer@1.6.0: {}
+
   escape-string-regexp@4.0.0: {}
 
-  eslint-plugin-jsdoc@50.6.17(eslint@9.27.0):
+  eslint-plugin-jsdoc@50.6.9(eslint@9.24.0):
     dependencies:
-      '@es-joy/jsdoccomment': 0.50.2
+      '@es-joy/jsdoccomment': 0.49.0
       are-docs-informative: 0.0.2
       comment-parser: 1.4.1
-      debug: 4.4.1
+      debug: 4.4.0
       escape-string-regexp: 4.0.0
-      eslint: 9.27.0
+      eslint: 9.24.0
       espree: 10.3.0
       esquery: 1.6.0
-      parse-imports-exports: 0.2.4
+      parse-imports: 2.2.1
-      semver: 7.7.2
+      semver: 7.7.1
       spdx-expression-parse: 4.0.0
+      synckit: 0.9.2
     transitivePeerDependencies:
       - supports-color
 
@@ -1146,25 +1166,25 @@ snapshots:
 
   eslint-visitor-keys@4.2.0: {}
 
-  eslint@9.27.0:
+  eslint@9.24.0:
     dependencies:
-      '@eslint-community/eslint-utils': 4.7.0(eslint@9.27.0)
+      '@eslint-community/eslint-utils': 4.5.1(eslint@9.24.0)
       '@eslint-community/regexpp': 4.12.1
       '@eslint/config-array': 0.20.0
-      '@eslint/config-helpers': 0.2.2
+      '@eslint/config-helpers': 0.2.1
-      '@eslint/core': 0.14.0
+      '@eslint/core': 0.12.0
       '@eslint/eslintrc': 3.3.1
-      '@eslint/js': 9.27.0
+      '@eslint/js': 9.24.0
-      '@eslint/plugin-kit': 0.3.1
+      '@eslint/plugin-kit': 0.2.8
       '@humanfs/node': 0.16.6
       '@humanwhocodes/module-importer': 1.0.1
-      '@humanwhocodes/retry': 0.4.3
+      '@humanwhocodes/retry': 0.4.2
       '@types/estree': 1.0.7
       '@types/json-schema': 7.0.15
       ajv: 6.12.6
       chalk: 4.1.2
       cross-spawn: 7.0.6
-      debug: 4.4.1
+      debug: 4.4.0
       escape-string-regexp: 4.0.0
       eslint-scope: 8.3.0
       eslint-visitor-keys: 4.2.0
@@ -1307,11 +1327,10 @@ snapshots:
     dependencies:
       callsites: 3.1.0
 
-  parse-imports-exports@0.2.4:
+  parse-imports@2.2.1:
     dependencies:
-      parse-statements: 1.0.11
+      es-module-lexer: 1.6.0
-
+      slashes: 3.0.12
-  parse-statements@1.0.11: {}
 
   path-exists@4.0.0: {}
 
@@ -1323,7 +1342,7 @@ snapshots:
 
   resolve-from@4.0.0: {}
 
-  semver@7.7.2: {}
+  semver@7.7.1: {}
 
   shebang-command@2.0.0:
     dependencies:
@@ -1331,6 +1350,8 @@ snapshots:
 
   shebang-regex@3.0.0: {}
 
+  slashes@3.0.12: {}
+
   spdx-exceptions@2.5.0: {}
 
   spdx-expression-parse@4.0.0:
@@ -1346,6 +1367,13 @@ snapshots:
     dependencies:
       has-flag: 4.0.0
 
+  synckit@0.9.2:
+    dependencies:
+      '@pkgr/core': 0.1.2
+      tslib: 2.8.1
+
+  tslib@2.8.1: {}
+
   type-check@0.4.0:
     dependencies:
       prelude-ls: 1.2.1

prefs.ts

@@ -1,4 +1,4 @@
 // This file is just a wrapper around the compiled TypeScript code
-import AerospikeExtensions from './src/prefs/prefs.js';
+import MyExtensionPreferences from './src/prefs.js';
 
-export default AerospikeExtensions;
+export default MyExtensionPreferences;

schemas/org.gnome.shell.extensions.aerospike.gschema.xml

@@ -1,6 +1,30 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <schemalist>
     <schema id="org.gnome.shell.extensions.aerospike" path="/org/gnome/shell/extensions/aerospike/">
+        <key name="keybinding-1" type="as">
+            <default><![CDATA[['<Super>1']]]></default>
+            <summary>Keybinding for action 1</summary>
+            <description>Keyboard shortcut for triggering action 1</description>
+        </key>
+
+        <key name="keybinding-2" type="as">
+            <default><![CDATA[['<Super>2']]]></default>
+            <summary>Keybinding for action 2</summary>
+            <description>Keyboard shortcut for triggering action 2</description>
+        </key>
+
+        <key name="keybinding-3" type="as">
+            <default><![CDATA[['<Super>3']]]></default>
+            <summary>Keybinding for action 3</summary>
+            <description>Keyboard shortcut for triggering action 3</description>
+        </key>
+
+        <key name="keybinding-4" type="as">
+            <default><![CDATA[['<Super>4']]]></default>
+            <summary>Keybinding for action 4</summary>
+            <description>Keyboard shortcut for triggering action 4</description>
+        </key>
+
         <key name="dropdown-option" type="s">
             <default>'option1'</default>
             <summary>Dropdown selection</summary>
@@ -12,30 +36,5 @@
             <summary>Selected color</summary>
             <description>Color chosen from the color picker</description>
         </key>
-
-        <key name="move-left" type="as">
-            <default><![CDATA[['<Super>1']]]></default>
-            <summary>Keybinding for action 1</summary>
-            <description>Keyboard shortcut for triggering action 1</description>
-        </key>
-
-        <key name="move-right" type="as">
-            <default><![CDATA[['<Super>2']]]></default>
-            <summary>Keybinding for action 2</summary>
-            <description>Keyboard shortcut for triggering action 2</description>
-        </key>
-
-        <key name="join-with-left" type="as">
-            <default><![CDATA[['<Super>3']]]></default>
-            <summary>Keybinding for action 3</summary>
-            <description>Keyboard shortcut for triggering action 3</description>
-        </key>
-
-        <key name="join-with-right" type="as">
-            <default><![CDATA[['<Super>4']]]></default>
-            <summary>Keybinding for action 4</summary>
-            <description>Keyboard shortcut for triggering action 4</description>
-        </key>
-
     </schema>
 </schemalist>

src/prefs.ts

@@ -3,10 +3,8 @@ import Gio from 'gi://Gio';
 import Gtk from 'gi://Gtk';
 import Gdk from 'gi://Gdk';
 import { ExtensionPreferences, gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
-import {Logger} from "../utils/logger.js";
-import {EntryRow} from "./keybindings.js";
 
-export default class AerospikeExtensions extends ExtensionPreferences {
+export default class MyExtensionPreferences extends ExtensionPreferences {
     async fillPreferencesWindow(window: Adw.PreferencesWindow) {
         // Create settings object
         const settings = this.getSettings('org.gnome.shell.extensions.aerospike');
@@ -18,6 +16,17 @@ export default class AerospikeExtensions extends ExtensionPreferences {
         });
         window.add(page);
 
+        // Create keybindings group
+        const keybindingsGroup = new Adw.PreferencesGroup({
+            title: _('Keyboard Shortcuts'),
+        });
+        page.add(keybindingsGroup);
+
+        // Add keybinding rows
+        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-1', _('Action 1'));
+        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-2', _('Action 2'));
+        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-3', _('Action 3'));
+        this.addKeybindingRow(keybindingsGroup, settings, 'keybinding-4', _('Action 4'));
 
         // Create options group
         const optionsGroup = new Adw.PreferencesGroup({
@@ -105,82 +114,79 @@ export default class AerospikeExtensions extends ExtensionPreferences {
             const color = colorButton.get_rgba().to_string();
             settings.set_string('color-selection', color);
         });
-
-        // Create keybindings group
-        const keybindingsGroup = new Adw.PreferencesGroup({
-            title: _('Keyboard Shortcuts'),
-            description: `${_("Syntax")}: <Super>h, <Shift>g, <Super><Shift>h
-            ${_("Legend")}: <Super> - ${_("Windows key")}, <Primary> - ${_("Control key")}
-            ${_("Delete text to unset. Press Return key to accept.")}`,
-        });
-        page.add(keybindingsGroup);
-
-        // Add keybinding rows as EntryRows with proper mapping
-        // Use the helper function to create the map object
-        const keybindingMap = this.createKeybindingMap();
-        
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Action 1'),
-                settings: settings,
-                bind: 'move-left',
-                map: keybindingMap
-            })
-        );
-        
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Action 2'),
-                settings: settings,
-                bind: 'move-right',
-                map: keybindingMap
-            })
-        );
-        
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Action 3'),
-                settings: settings,
-                bind: 'join-with-left',
-                map: keybindingMap
-            })
-        );
-        
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Action 4'),
-                settings: settings,
-                bind: 'join-with-right',
-                map: keybindingMap
-            })
-        );
-
-
     }
 
-    // Helper function to create a keybinding mapping object
+    private addKeybindingRow(
-    private createKeybindingMap() {
+        group: Adw.PreferencesGroup,
-        return {
+        settings: Gio.Settings,
-            from(settings: Gio.Settings, bind: string) {
+        key: string,
-                return settings.get_strv(bind).join(',');
+        title: string
-            },
+    ) {
-            to(settings: Gio.Settings, bind: string, value: string) {
+        const shortcutsRow = new Adw.ActionRow({
-                if (!!value) {
+            title: title,
-                    const mappings = value.split(',').map((x) => {
+        });
-                        const [, key, mods] = Gtk.accelerator_parse(x);
+
-                        return Gtk.accelerator_valid(key, mods) && Gtk.accelerator_name(key, mods);
+        group.add(shortcutsRow);
-                    });
+
-                    // Filter out any false values to ensure we only have strings
+        // Create a button for setting shortcuts
-                    const stringMappings = mappings.filter((x): x is string => typeof x === 'string');
+        const shortcutButton = new Gtk.Button({
-                    if (stringMappings.length > 0) {
+            valign: Gtk.Align.CENTER,
-                        Logger.debug("setting", bind, "to", stringMappings);
+            label: settings.get_strv(key)[0] || _("Disabled")
-                        settings.set_strv(bind, stringMappings);
+        });
-                    }
+
-                } else {
+        shortcutsRow.add_suffix(shortcutButton);
-                    // If value deleted, unset the mapping
+        shortcutsRow.set_activatable_widget(shortcutButton);
-                    settings.set_strv(bind, []);
+
+        // When clicking the button, show a dialog or start listening for keystroke
+        shortcutButton.connect('clicked', () => {
+            // Show a simple popup stating that the shortcut is being recorded
+            const dialog = new Gtk.MessageDialog({
+                modal: true,
+                text: _("Press a key combination to set as shortcut"),
+                secondary_text: _("Press Esc to cancel or Backspace to disable"),
+                buttons: Gtk.ButtonsType.CANCEL,
+                transient_for: group.get_root() as Gtk.Window
+            });
+
+            // Create a keypress event controller
+            const controller = new Gtk.EventControllerKey();
+            dialog.add_controller(controller);
+
+            controller.connect('key-pressed', (_controller, keyval, keycode, state) => {
+                // Get the key name
+                let keyName = Gdk.keyval_name(keyval);
+
+                // Handle special cases
+                if (keyName === 'Escape') {
+                    dialog.response(Gtk.ResponseType.CANCEL);
+                    return Gdk.EVENT_STOP;
+                } else if (keyName === 'BackSpace') {
+                    // Clear the shortcut
+                    settings.set_strv(key, []);
+                    shortcutButton.set_label(_("Disabled"));
+                    dialog.response(Gtk.ResponseType.OK);
+                    return Gdk.EVENT_STOP;
                 }
-            },
+
-        };
+                // Convert modifier state to keybinding modifiers
+                let modifiers = state & Gtk.accelerator_get_default_mod_mask();
+
+                // Ignore standalone modifier keys
+                if (Gdk.ModifierType.SHIFT_MASK <= keyval && keyval <= Gdk.ModifierType.META_MASK)
+                    return Gdk.EVENT_STOP;
+
+                // Create accelerator string
+                let accelerator = Gtk.accelerator_name(keyval, modifiers);
+                if (accelerator) {
+                    settings.set_strv(key, [accelerator]);
+                    shortcutButton.set_label(accelerator);
+                    dialog.response(Gtk.ResponseType.OK);
+                }
+
+                return Gdk.EVENT_STOP;
+            });
+
+            dialog.present();
+        });
     }
 }

src/prefs/keybindings.ts

@@ -1,83 +0,0 @@
-// Gnome imports
-import Adw from 'gi://Adw';
-import Gtk from 'gi://Gtk';
-import Gio from 'gi://Gio';
-import GObject from 'gi://GObject';
-import { gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
-import { Logger } from '../utils/logger.js';
-
-/**
- * EntryRow class for handling text input including keybindings
- */
-export class EntryRow extends Adw.EntryRow {
-    static {
-        GObject.registerClass(this);
-    }
-
-    constructor(params: {
-        title: string,
-        settings: Gio.Settings,
-        bind: string,
-        map?: {
-            from: (settings: Gio.Settings, bind: string) => string,
-            to: (settings: Gio.Settings, bind: string, value: string) => void
-        }
-    }) {
-        super({ title: params.title });
-        
-        const { settings, bind, map } = params;
-
-        // When text changes, update settings
-        this.connect('changed', () => {
-            const text = this.get_text();
-            if (typeof text === 'string') {
-                if (map) {
-                    map.to(settings, bind, text);
-                } else {
-                    settings.set_string(bind, text);
-                }
-            }
-        });
-
-        // Set initial text from settings
-        const current = map ? map.from(settings, bind) : settings.get_string(bind);
-        this.set_text(current ?? '');
-
-        // Add reset button
-        this.add_suffix(
-            new ResetButton({
-                settings,
-                bind,
-                onReset: () => {
-                    this.set_text((map ? map.from(settings, bind) : settings.get_string(bind)) ?? '');
-                },
-            })
-        );
-    }
-}
-
-/**
- * Reset button for settings
- */
-export class ResetButton extends Gtk.Button {
-    static {
-        GObject.registerClass(this);
-    }
-
-    constructor(params: {
-        settings?: Gio.Settings,
-        bind: string,
-        onReset?: () => void
-    }) {
-        super({
-            icon_name: 'edit-clear-symbolic',
-            tooltip_text: _('Reset'),
-            valign: Gtk.Align.CENTER,
-        });
-
-        this.connect('clicked', () => {
-            params.settings?.reset(params.bind);
-            params.onReset?.();
-        });
-    }
-}

src/utils.ts

@@ -0,0 +1,20 @@
+// Utility functions and type definitions
+
+/**
+ * Interface for the extension settings
+ */
+export interface ExtensionSettings {
+    keybinding1: string[];
+    keybinding2: string[];
+    keybinding3: string[];
+    keybinding4: string[];
+    dropdownOption: string;
+    colorSelection: string;
+}
+
+/**
+ * Log a message with the extension name prefix
+ */
+export function log(message: string): void {
+    console.log(`[MyExtension] ${message}`);
+}

src/utils/events.ts

@@ -1,20 +0,0 @@
-import GLib from "gi://GLib";
-
-
-export type QueuedEvent = {
-    name: string;
-    callback: () => void;
-}
-
-const queuedEvents: QueuedEvent[] = [];
-
-export default function queueEvent(event: QueuedEvent, interval = 200) {
-    queuedEvents.push(event);
-    GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
-        const e = queuedEvents.pop()
-        if (e) {
-            e.callback();
-        }
-        return queuedEvents.length !== 0;
-    });
-}

src/utils/logger.ts

@@ -1,30 +0,0 @@
-export class Logger {
-
-    static fatal(...args: any[]) {
-        console.log(`[Aerospike] [FATAL]`, ...args);
-    }
-
-    static error(...args: any[]) {
-        console.log(`[Aerospike] [ERROR]`, ...args);
-    }
-
-    static warn(...args: any[]) {
-        console.log(`[Aerospike] [WARN]`, ...args);
-    }
-
-    static info(...args: any[]) {
-        console.log(`[Aerospike] [INFO]`, ...args);
-    }
-
-    static debug(...args: any[]) {
-        console.log(`[Aerospike] [DEBUG]`, ...args);
-    }
-
-    static trace(...args: any[]) {
-        console.log(`[Aerospike] [TRACE]`, ...args);
-    }
-
-    static log(...args: any[]) {
-        console.log(`[Aerospike] [LOG]`, ...args);
-    }
-}

src/utils/rect.ts

@@ -1,6 +0,0 @@
-export type Rect = {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}

src/winGroup.ts

@@ -0,0 +1,164 @@
+import Meta from 'gi://Meta';
+import Mtk from '@girs/mtk-16';
+
+export interface WindowTree {
+  root: WindowNode | null;
+  monitor: number;
+  workspace: number;
+}
+
+export interface WindowNode {
+  window: Meta.Window | null;
+  windowId: number | null;
+  children: WindowNode[];
+  parent: WindowNode | null;
+  splitRatio: number;
+  splitDirection: 'horizontal' | 'vertical';
+  rect: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+  };
+}
+
+export function createWindowNode(window: Meta.Window | null = null): WindowNode {
+  return {
+    window: window,
+    windowId: window ? window.get_id() : null,
+    children: [],
+    parent: null,
+    splitRatio: 1.0,
+    splitDirection: 'horizontal',
+    rect: { x: 0, y: 0, width: 0, height: 0 }
+  };
+}
+
+export function addNodeChild(parent: WindowNode, child: WindowNode): void {
+  child.parent = parent;
+  parent.children.push(child);
+  
+  // Update split ratios to be equal
+  const childCount = parent.children.length;
+  parent.children.forEach(node => {
+    node.splitRatio = 1.0 / childCount;
+  });
+}
+
+export function removeNode(node: WindowNode, tree: WindowTree): WindowNode | null {
+  if (!node.parent) {
+    // This is the root node
+    if (node.children.length > 0) {
+      // Promote first child to root
+      const newRoot = node.children[0];
+      newRoot.parent = null;
+      
+      // Transfer any other children to the new root
+      for (let i = 1; i < node.children.length; i++) {
+        addNodeChild(newRoot, node.children[i]);
+      }
+      
+      tree.root = newRoot;
+      return newRoot;
+    } else {
+      // No children, tree is now empty
+      tree.root = null;
+      return null;
+    }
+  } else {
+    // Remove from parent's children
+    const parent = node.parent;
+    const index = parent.children.indexOf(node);
+    if (index !== -1) {
+      parent.children.splice(index, 1);
+    }
+    
+    // Update split ratios of remaining siblings
+    if (parent.children.length > 0) {
+      const ratio = 1.0 / parent.children.length;
+      parent.children.forEach(child => {
+        child.splitRatio = ratio;
+      });
+    }
+    
+    // Transfer any children to the parent
+    node.children.forEach(child => {
+      addNodeChild(parent, child);
+    });
+    
+    return parent;
+  }
+}
+
+export function findNodeByWindowId(tree: WindowTree, windowId: number): WindowNode | null {
+  if (!tree.root) return null;
+  
+  function search(node: WindowNode): WindowNode | null {
+    if (node.windowId === windowId) return node;
+    
+    for (const child of node.children) {
+      const result = search(child);
+      if (result) return result;
+    }
+    
+    return null;
+  }
+  
+  return search(tree.root);
+}
+
+export function calculateLayout(node: WindowNode, rect: {x: number, y: number, width: number, height: number}): void {
+  // Update node's rect
+  node.rect = {...rect};
+  
+  // Process children recursively
+  if (node.children.length > 0) {
+    if (node.splitDirection === 'horizontal') {
+      // Divide width with remainder handling
+      let currentX = rect.x;
+      let remainingWidth = rect.width;
+      const lastChildIndex = node.children.length - 1;
+      
+      node.children.forEach((child, index) => {
+        const isLastChild = index === lastChildIndex;
+        // Last child gets remainder to avoid gaps
+        const childWidth = isLastChild ? 
+            remainingWidth : 
+            Math.floor(rect.width * child.splitRatio);
+        
+        calculateLayout(child, {
+          x: currentX,
+          y: rect.y,
+          width: childWidth,
+          height: rect.height
+        });
+        
+        currentX += childWidth;
+        remainingWidth -= childWidth;
+      });
+    } else {
+      // Divide height with remainder handling
+      let currentY = rect.y;
+      let remainingHeight = rect.height;
+      const lastChildIndex = node.children.length - 1;
+      
+      node.children.forEach((child, index) => {
+        const isLastChild = index === lastChildIndex;
+        // Last child gets remainder to avoid gaps
+        const childHeight = isLastChild ? 
+            remainingHeight : 
+            Math.floor(rect.height * child.splitRatio);
+        
+        calculateLayout(child, {
+          x: rect.x,
+          y: currentY,
+          width: rect.width,
+          height: childHeight
+        });
+        
+        currentY += childHeight;
+        remainingHeight -= childHeight;
+      });
+    }
+  }
+}

src/wm/container.ts

@@ -1,205 +0,0 @@
-import {WindowWrapper} from "./window.js";
-import {Logger} from "../utils/logger.js";
-import Meta from "gi://Meta";
-import queueEvent from "../utils/events.js";
-import {Rect} from "../utils/rect.js";
-
-enum Orientation {
-    HORIZONTAL = 0,
-    VERTICAL = 1,
-}
-
-
-export default class WindowContainer {
-
-    _tiledItems: (WindowWrapper | WindowContainer)[];
-    _tiledWindowLookup: Map<number, WindowWrapper>;
-    _orientation: Orientation = Orientation.HORIZONTAL;
-    _workArea: Rect;
-
-    constructor(workspaceArea: Rect,) {
-        // this._id = monitorId;
-        this._tiledItems = [];
-        this._tiledWindowLookup = new Map<number, WindowWrapper>();
-        this._workArea = workspaceArea;
-    }
-
-
-    move(rect: Rect): void {
-        this._workArea = rect;
-        this.tileWindows();
-    }
-
-    addWindow(winWrap: WindowWrapper): void {
-        // Add window to managed windows
-        this._tiledItems.push(winWrap);
-        this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
-        // winWrap.setParent(this);
-        queueEvent({
-            name: "tiling-windows",
-            callback: () => {
-                this.tileWindows();
-            }
-        }, 100)
-
-    }
-
-    getWindow(win_id: number): WindowWrapper | undefined {
-        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 {
-        if (this._tiledWindowLookup.has(win_id)) {
-            this._tiledWindowLookup.delete(win_id);
-            const index = this._getIndexOfWindow(win_id)
-            this._tiledItems.splice(index, 1);
-        } else {
-            for (const item of this._tiledItems) {
-                if (item instanceof WindowContainer) {
-                    item.removeWindow(win_id);
-                }
-            }
-        }
-        this.tileWindows()
-    }
-
-    disconnectSignals(): void {
-        this._tiledItems.forEach((item) => {
-                if (item instanceof WindowContainer) {
-                    item.disconnectSignals()
-                } else {
-                    item.disconnectWindowSignals();
-                }
-            }
-        )
-    }
-
-    removeAllWindows(): void {
-        this._tiledItems = []
-        this._tiledWindowLookup.clear()
-    }
-
-    tileWindows() {
-        Logger.log("TILING WINDOWS IN CONTAINER")
-
-        Logger.log("WorkArea", this._workArea);
-
-        // Get all windows for current workspaceArea
-        this._tileItems()
-
-        return true
-    }
-
-    _tileItems() {
-        if (this._tiledItems.length === 0) {
-            return;
-        }
-        const bounds = this.getBounds();
-        this._tiledItems.forEach((item, index) => {
-            const rect = bounds[index];
-            if (item instanceof WindowContainer) {
-                item.move(rect);
-            } else {
-                item.safelyResizeWindow(rect);
-            }
-        })
-    }
-
-
-    getBounds(): Rect[] {
-        if (this._orientation === Orientation.HORIZONTAL) {
-            return this.getHorizontalBounds();
-        }
-        return this.getVerticalBounds();
-    }
-
-    getVerticalBounds(): Rect[] {
-        const items = this._tiledItems
-        const containerHeight = Math.floor(this._workArea.height / items.length);
-        return items.map((_, index) => {
-            const y = this._workArea.y + (index * containerHeight);
-            return {
-                x: this._workArea.x,
-                y: y,
-                width: this._workArea.width,
-                height: containerHeight
-            } as Rect;
-        });
-    }
-
-    getHorizontalBounds(): Rect[] {
-        const windowWidth = Math.floor(this._workArea.width / this._tiledItems.length);
-
-        return this._tiledItems.map((_, index) => {
-            const x = this._workArea.x + (index * windowWidth);
-            return {
-                x: x,
-                y: this._workArea.y,
-                width: windowWidth,
-                height: this._workArea.height
-            } as Rect;
-        });
-    }
-
-    getIndexOfItemNested(item: WindowWrapper): number {
-        for (let i = 0; i < this._tiledItems.length; i++) {
-            const container = this._tiledItems[i];
-            if (container instanceof WindowContainer) {
-                const index = container.getIndexOfItemNested(item);
-                if (index !== -1) {
-                    return i;
-                }
-            } else if (container.getWindowId() === item.getWindowId()) {
-                return i;
-            }
-        }
-        return -1;
-    }
-
-    // TODO: update this to work with nested containers - all other logic should already be working
-    itemDragged(item: WindowWrapper, x: number, y: number): void {
-        let original_index = this.getIndexOfItemNested(item);
-
-        if (original_index === -1) {
-            Logger.error("Item not found in container during drag op", item.getWindowId());
-            return;
-        }
-        let new_index = this.getIndexOfItemNested(item);
-        this.getBounds().forEach((rect, index) => {
-            if (rect.x < x && rect.x + rect.width > x && rect.y < y && rect.y + rect.height > y) {
-                new_index = index;
-            }
-        })
-        if (original_index !== new_index) {
-            this._tiledItems.splice(original_index, 1);
-            this._tiledItems.splice(new_index, 0, item);
-            this.tileWindows()
-        }
-
-    }
-
-
-}

src/wm/monitor.ts

@@ -1,86 +0,0 @@
-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(this._workArea));
-        }
-    }
-
-    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();
-        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()
-    }
-
-    removeWorkspace(workspaceId: number): void {
-        this._workspaces.splice(workspaceId, 1);
-    }
-
-    addWorkspace(): void {
-        this._workspaces.push(new WindowContainer(this._workArea));
-    }
-
-    itemDragged(item: WindowWrapper, x: number, y: number): void {
-        this._workspaces[item.getWorkspace()].itemDragged(item, x, y);
-    }
-
-}

src/wm/window.ts

@@ -1,148 +0,0 @@
-import Meta from 'gi://Meta';
-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 _signals: number[] = [];
-    _parent: WindowContainer | null = null;
-    _dragging: boolean = false;
-
-    constructor(
-        window: Meta.Window,
-        winMinimized: WindowMinimizedHandler
-    ) {
-        this._window = window;
-        this._windowMinimizedHandler = winMinimized;
-    }
-
-    getWindow(): Meta.Window {
-        return this._window;
-    }
-
-    getWindowId(): number {
-        return this._window.get_id();
-    }
-
-    getWorkspace(): number {
-        return this._window.get_workspace().index();
-    }
-
-    getMonitor(): number {
-        return this._window.get_monitor();
-    }
-
-    getRect(): Rect {
-        return this._window.get_frame_rect();
-    }
-
-    startDragging(): void {
-        this._dragging = true;
-    }
-    stopDragging(): void {
-        Logger.log("STOPPED DRAGGING")
-        this._dragging = false;
-    }
-
-    // setParent(parent: WindowContainer): void {
-    //     this._parent = parent;
-    // }
-    //
-    // getParent(): WindowContainer | null {
-    //     if (this._parent == null) {
-    //         Logger.warn(`Attempting to get parent for window without parent ${JSON.stringify(this)}`);
-    //     }
-    //     return this._parent
-    // }
-
-    connectWindowSignals(
-        windowManager: IWindowManager,
-    ): void {
-        const windowId = this._window.get_id()
-        // Handle window destruction
-        this._signals.push(
-            this._window.connect('unmanaging', window => {
-                Logger.log("REMOVING WINDOW", windowId);
-                windowManager.handleWindowClosed(this)
-            }),
-            this._window.connect('notify::minimized', (we) => {
-                if (this._window.minimized) {
-                    Logger.log(`Window minimized: ${windowId}`);
-                    windowManager.handleWindowMinimized(this);
-
-                } else if (!this._window.minimized) {
-                    Logger.log(`Window unminimized: ${windowId}`);
-                    windowManager.handleWindowUnminimized(this);
-
-                }
-            }),
-            this._window.connect('notify::has-focus', () => {
-                if (this._window.has_focus()) {
-                    windowManager._activeWindowId = windowId;
-                }
-            }),
-            this._window.connect('notify::maximized-horizontally', () => {
-                if (this._window.get_maximized()) {
-                    Logger.log(`Window maximized: ${windowId}`);
-                } else {
-                    Logger.log(`Window unmaximized: ${windowId}`);
-                }
-            }),
-            this._window.connect("workspace-changed", (_metaWindow) => {
-                Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
-                windowManager.handleWindowChangedWorkspace(this);
-            }),
-            this._window.connect("position-changed", (_metaWindow) => {
-                windowManager.handleWindowPositionChanged(this);
-            }),
-        );
-    }
-
-    disconnectWindowSignals(): void {
-
-        if (this._signals) {
-            this._signals.forEach(signal => {
-                try {
-                    if (this._window != null) {
-                        this._window.disconnect(signal);
-                    }
-                } catch (e) {
-                    Logger.warn("error disconnecting signal", signal, e);
-                }
-            });
-        }
-    }
-
-    safelyResizeWindow(rect: Rect): void {
-        // Keep minimal logging
-        if (this._dragging) {
-            Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED")
-            return;
-        }
-        Logger.log("SAFELY RESIZE", rect.x, rect.y, rect.width, rect.height);
-        const actor = this._window.get_compositor_private();
-
-        if (!actor) {
-            Logger.log("No actor available, can't resize safely yet");
-            return;
-        }
-        let windowActor = this._window.get_compositor_private() as Clutter.Actor;
-        if (!windowActor) return;
-        windowActor.remove_all_transitions();
-        Logger.info("MOVING")
-        this._window.move_frame(true, rect.x, rect.y);
-        Logger.info("RESIZING MOVING")
-        this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);
-
-    }
-
-
-}

src/wm/windowManager.ts

@@ -1,429 +0,0 @@
-import Meta from "gi://Meta";
-// import Gio from "gi://Gio";
-// import GLib from "gi://GLib";
-
-import {WindowWrapper} from './window.js';
-import * as Main from "resource:///org/gnome/shell/ui/main.js";
-// import Mtk from "@girs/mtk-16";
-import {Logger} from "../utils/logger.js";
-import Monitor from "./monitor.js";
-
-
-export interface IWindowManager {
-    _activeWindowId: number | null;
-
-    // addWindow(window: Meta.Window): void;
-
-    handleWindowClosed(winWrap: WindowWrapper): void;
-
-    handleWindowMinimized(winWrap: WindowWrapper): void;
-
-    handleWindowUnminimized(winWrap: WindowWrapper): void;
-
-    handleWindowChangedWorkspace(winWrap: WindowWrapper): void;
-
-    handleWindowPositionChanged(winWrap: WindowWrapper): void;
-
-    syncActiveWindow(): number | null;
-}
-
-
-const _UNUSED_MONITOR_ID = -1
-const _UNUSED_WINDOW_ID = -1
-
-export default class WindowManager implements IWindowManager {
-    _displaySignals: number[] = [];
-    _windowManagerSignals: number[] = [];
-    _workspaceManagerSignals: number[] = [];
-    _overviewSignals: number[] = [];
-
-    _activeWindowId: number | null = null;
-    _monitors: Map<number, Monitor> = new Map<number, Monitor>();
-
-    _minimizedItems: Map<number, WindowWrapper> = new Map<number, WindowWrapper>();
-
-    _grabbedWindowMonitor: number = _UNUSED_MONITOR_ID;
-    _grabbedWindowId: number = _UNUSED_WINDOW_ID;
-    _changingGrabbedMonitor: boolean = false;
-
-    _showingOverview: boolean = false;
-
-    constructor() {
-
-
-    }
-
-    public enable(): void {
-        Logger.log("Starting Aerospike Window Manager");
-        // Connect window signals
-        this.instantiateDisplaySignals();
-
-        const mon_count = global.display.get_n_monitors();
-        for (let i = 0; i < mon_count; i++) {
-            this._monitors.set(i, new Monitor(i));
-        }
-
-        this.captureExistingWindows();
-    }
-
-    instantiateDisplaySignals(): void {
-        this._displaySignals.push(
-            global.display.connect("grab-op-begin", (display, window, op) => {
-                this.handleGrabOpBegin(display, window, op)
-            }),
-            global.display.connect("grab-op-end", (display, window, op) => {
-                this.handleGrabOpEnd(display, window, op)
-            }),
-            global.display.connect("window-entered-monitor", (display, monitor, window) => {
-                Logger.log("WINDOW HAS ENTERED NEW MONITOR!")
-                if (this._showingOverview) {
-                    if (this._getWrappedWindow(window) !== undefined) {
-                        Logger.log("OVERVIEW - MOVING")
-                        this._moveWindowToMonitor(window, monitor)
-                    }
-                }
-            }),
-            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",);
-                console.log(display.get_workspace_manager().get_active_workspace_index())
-            }),
-            global.display.connect("in-fullscreen-changed", () => {
-                Logger.log("IN FULL SCREEN CHANGED");
-            }),
-        )
-
-        // this._windowManagerSignals = [
-        //     global.window_manager.connect("show-tile-preview", (_, _metaWindow, _rect, _num) => {
-        //         Logger.log("SHOW TITLE PREVIEW!")
-        //     }),
-        // ];
-
-        this._workspaceManagerSignals = [
-            global.workspace_manager.connect("showing-desktop-changed", () => {
-                Logger.log("SHOWING DESKTOP CHANGED AT WORKSPACE LEVEL");
-            }),
-            global.workspace_manager.connect("workspace-added", (_, wsIndex) => {
-                Logger.log("WORKSPACE ADDED", wsIndex);
-                this._monitors.forEach((monitor: Monitor) => {
-                    monitor.addWorkspace();
-                })
-            }),
-            global.workspace_manager.connect("workspace-removed", (_, wsIndex) => {
-                Logger.log("WORKSPACE REMOVED", wsIndex);
-                this._monitors.forEach((monitor: Monitor) => {
-                    monitor.removeWorkspace(wsIndex);
-                })
-            }),
-            global.workspace_manager.connect("active-workspace-changed", (source) => {
-                Logger.log("Active workspace-changed", source.get_active_workspace().index());
-            }),
-        ];
-
-        this._overviewSignals = [
-            Main.overview.connect("hiding", () => {
-                // this.fromOverview = true;
-                Logger.log("HIDING OVERVIEW")
-                this._showingOverview = false;
-                this._tileMonitors();
-                // const eventObj = {
-                //     name: "focus-after-overview",
-                //     callback: () => {
-                //         Logger.log("FOCUSING AFTER OVERVIEW");
-                //     },
-                // };
-                // this.queueEvent(eventObj);
-            }),
-            Main.overview.connect("showing", () => {
-                this._showingOverview = true;
-                Logger.log("SHOWING OVERVIEW");
-            }),
-        ];
-
-
-    }
-
-    public disable(): void {
-        Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!")
-        // Disconnect the focus signal and remove any existing borders
-        this.disconnectSignals();
-        this.removeAllWindows();
-    }
-
-    removeAllWindows(): void {
-        this._monitors.forEach((monitor: Monitor) => {
-            monitor.removeAllWindows();
-        })
-        this._minimizedItems.clear();
-    }
-
-
-    disconnectSignals(): void {
-        this.disconnectDisplaySignals();
-        this.disconnectMonitorSignals();
-        this.disconnectMinimizedSignals();
-    }
-
-    disconnectMonitorSignals(): void {
-        this._monitors.forEach((monitor: Monitor) => {
-            monitor.disconnectSignals();
-        })
-    }
-
-    disconnectDisplaySignals(): void {
-        this._displaySignals.forEach((signal) => {
-            global.display.disconnect(signal)
-        })
-        this._windowManagerSignals.forEach((signal) => {
-            global.window_manager.disconnect(signal)
-        })
-        this._workspaceManagerSignals.forEach((signal) => {
-            global.workspace_manager.disconnect(signal)
-        })
-        this._overviewSignals.forEach((signal) => {
-            Main.overview.disconnect(signal)
-        })
-    }
-
-    disconnectMinimizedSignals(): void {
-        this._minimizedItems.forEach((item) => {
-            item.disconnectWindowSignals();
-        })
-    }
-
-
-    handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
-        if (op === Meta.GrabOp.MOVING_UNCONSTRAINED){
-
-        }
-        Logger.log("Grab Op Start", op);
-        Logger.log(display, window, op)
-        Logger.log(window.get_monitor())
-        this._getWrappedWindow(window)?.startDragging();
-        this._grabbedWindowMonitor = window.get_monitor();
-        this._grabbedWindowId = window.get_id();
-    }
-
-    handleGrabOpEnd(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
-        Logger.log("Grab Op End ", op);
-        Logger.log("primary display", display.get_primary_monitor())
-        this._grabbedWindowId = _UNUSED_WINDOW_ID;
-        this._getWrappedWindow(window)?.stopDragging();
-        this._tileMonitors();
-        Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
-    }
-
-    _getWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
-        let wrapped = undefined;
-        for (const monitor of this._monitors.values()) {
-            wrapped = monitor.getWindow(window.get_id());
-            if (wrapped !== undefined) {
-                break;
-            }
-        }
-        return wrapped;
-    }
-
-    _getAndRemoveWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
-        let wrapped = undefined;
-        for (const monitor of this._monitors.values()) {
-            wrapped = monitor.getWindow(window.get_id());
-            if (wrapped !== undefined) {
-                monitor.removeWindow(wrapped);
-                break;
-            }
-        }
-        return wrapped;
-    }
-
-    _moveWindowToMonitor(window: Meta.Window, monitorId: number): void {
-        Logger.info("MOVING WINDOW TO MONITOR", window.get_id(), monitorId);
-        let wrapped = this._getAndRemoveWrappedWindow(window);
-        if (wrapped === undefined) {
-            Logger.error("WINDOW NOT DEFINED")
-            wrapped = new WindowWrapper(window, this.handleWindowMinimized);
-            wrapped.connectWindowSignals(this);
-        }
-
-        // wrapped.startDragging()
-        let new_mon = this._monitors.get(monitorId);
-        new_mon?.addWindow(wrapped)
-        Logger.info("UPDATE MONITOR", new_mon);
-        this._grabbedWindowMonitor = monitorId;
-        // wrapped.stopDragging();
-    }
-
-    public handleWindowPositionChanged(winWrap: WindowWrapper): void {
-        if (this._changingGrabbedMonitor) {
-            return;
-        }
-        if (winWrap.getWindowId() === this._grabbedWindowId) {
-            const [mouseX, mouseY, _] = global.get_pointer();
-
-            let monitorIndex = -1;
-            for (let i = 0; i < global.display.get_n_monitors(); i++) {
-                const workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(i);
-                if (mouseX >= workArea.x && mouseX < workArea.x + workArea.width &&
-                    mouseY >= workArea.y && mouseY < workArea.y + workArea.height) {
-                    monitorIndex = i;
-                    break;
-                }
-            }
-            if (monitorIndex === -1) {
-                return
-            }
-
-            if (monitorIndex !== this._grabbedWindowMonitor) {
-                this._changingGrabbedMonitor = true;
-                Logger.log("CHANGING MONITOR FOR WINDOW");
-                this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex);
-                this._changingGrabbedMonitor = false
-            }
-            this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
-        }
-    }
-
-
-    public handleWindowMinimized(winWrap: WindowWrapper): void {
-        const monitor_id = winWrap.getWindow().get_monitor()
-        this._minimizedItems.set(winWrap.getWindowId(), winWrap);
-        this._monitors.get(monitor_id)?.removeWindow(winWrap);
-        this._tileMonitors()
-    }
-
-    public handleWindowUnminimized(winWrap: WindowWrapper): void {
-        this._minimizedItems.delete(winWrap.getWindowId());
-        this._addWindowWrapperToMonitor(winWrap);
-        this._tileMonitors()
-    }
-
-
-    public handleWindowChangedWorkspace(winWrap: WindowWrapper): void {
-        const monitor = winWrap.getWindow().get_monitor();
-        this._monitors.get(monitor)?.removeWindow(winWrap);
-        this._monitors.get(monitor)?.addWindow(winWrap);
-    }
-
-    public captureExistingWindows() {
-        const workspace = global.workspace_manager.get_active_workspace();
-        const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
-        windows.forEach(window => {
-            if (this._isWindowTileable(window)) {
-                this.addWindowToMonitor(window);
-            }
-        });
-
-        this._tileMonitors();
-    }
-
-
-    handleWindowCreated(display: Meta.Display, window: Meta.Window) {
-        Logger.log("WINDOW CREATED ON DISPLAY", window, display);
-        if (!this._isWindowTileable(window)) {
-            return;
-        }
-        Logger.log("WINDOW IS TILABLE");
-        this.addWindowToMonitor(window);
-    }
-
-
-    /**
-     * Handle window closed event
-     */
-    handleWindowClosed(window: WindowWrapper): void {
-
-        const mon_id = window._window.get_monitor();
-
-        this._monitors.get(mon_id)?.removeWindow(window);
-
-        window.disconnectWindowSignals()
-        // Remove from managed windows
-        this.syncActiveWindow();
-        // Retile remaining windows
-        this._tileMonitors();
-    }
-
-
-    public addWindowToMonitor(window: Meta.Window) {
-
-        Logger.log("ADDING WINDOW TO MONITOR", window, window);
-        var wrapper = new WindowWrapper(window, this.handleWindowMinimized)
-        wrapper.connectWindowSignals(this);
-        this._addWindowWrapperToMonitor(wrapper);
-
-    }
-
-    _addWindowWrapperToMonitor(winWrap: WindowWrapper) {
-        if (winWrap.getWindow().minimized) {
-            this._minimizedItems.set(winWrap.getWindow().get_id(), winWrap);
-        } else {
-            this._monitors.get(winWrap.getWindow().get_monitor())?.addWindow(winWrap)
-        }
-    }
-
-    _tileMonitors(): void {
-
-        for (const monitor of this._monitors.values()) {
-            monitor.tileWindows()
-        }
-    }
-
-    block_titles = [
-        "org.gnome.Shell.Extensions",
-    ]
-
-    _isWindowTilingBlocked(window: Meta.Window) : boolean {
-        Logger.info("title", window.get_title());
-        Logger.info("description", window.get_description());
-        Logger.info("class", window.get_wm_class());
-        Logger.info("class", window.get_wm_class_instance());
-        return this.block_titles.some((title) => {
-            if (window.get_title() === title) {
-                Logger.log("WINDOW BLOCKED FROM TILING", window.get_title());
-                return true;
-            }
-            return false;
-        });
-    }
-
-    _isWindowTileable(window: Meta.Window) {
-
-        if (!window || !window.get_compositor_private()) {
-            return false;
-        }
-        if (this._isWindowTilingBlocked(window)) {
-            return false;
-        }
-        const windowType = window.get_window_type();
-        Logger.log("WINDOW TILING CHECK",);
-
-        // Skip certain types of windows
-        return !window.is_skip_taskbar() &&
-            windowType !== Meta.WindowType.DESKTOP &&
-            windowType !== Meta.WindowType.DOCK &&
-            windowType !== Meta.WindowType.DIALOG &&
-            windowType !== Meta.WindowType.MODAL_DIALOG &&
-            windowType !== Meta.WindowType.UTILITY &&
-            windowType !== Meta.WindowType.MENU;
-    }
-
-    /**
-     * Synchronizes the active window with GNOME's currently active window
-     *
-     * This function queries GNOME Shell for the current focused window and
-     * updates the extension's active window tracking to match.
-     *
-     * @returns The window ID of the active window, or null if no window is active
-     */
-    public syncActiveWindow(): number | null {
-        return null;
-    }
-
-
-}

tsconfig.json

@@ -16,6 +16,7 @@
     "src/**/*"
   ],
   "files": [
-    "extension.ts"
+    "extension.ts",
+    "src/winGroup.ts"
   ],
 }