feat: remove crap code

.gitignore

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

extension.ts

@@ -3,7 +3,7 @@ import {Extension, ExtensionMetadata} from 'resource:///org/gnome/shell/extensio
 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/windowManager.js'
+import WindowManager from './src/wm/windowManager.js'
 import {Logger} from "./src/utils/logger.js";
 
 export default class aerospike extends Extension {
@@ -21,6 +21,7 @@ export default class aerospike extends Extension {
     enable() {
         Logger.log("STARTING AEROSPIKE!")
         this.bindSettings();
+        this.setupKeybindings();
         this.windowManager.enable()
     }
 
@@ -32,24 +33,24 @@ export default class aerospike extends Extension {
 
     private bindSettings() {
         // Monitor settings changes
-        this.settings.connect('changed::keybinding-1', () => {
+        this.settings.connect('changed::move-left', () => {
-            log(`Keybinding 1 changed to: ${this.settings.get_strv('keybinding-1')}`);
+            log(`Keybinding 1 changed to: ${this.settings.get_strv('move-left')}`);
-            this.refreshKeybinding('keybinding-1');
+            this.refreshKeybinding('move-left');
         });
 
-        this.settings.connect('changed::keybinding-2', () => {
+        this.settings.connect('changed::move-right', () => {
-            log(`Keybinding 2 changed to: ${this.settings.get_strv('keybinding-2')}`);
+            log(`Keybinding 2 changed to: ${this.settings.get_strv('move-right')}`);
-            this.refreshKeybinding('keybinding-2');
+            this.refreshKeybinding('move-right');
         });
 
-        this.settings.connect('changed::keybinding-3', () => {
+        this.settings.connect('changed::join-with-left', () => {
-            log(`Keybinding 3 changed to: ${this.settings.get_strv('keybinding-3')}`);
+            log(`Keybinding 3 changed to: ${this.settings.get_strv('join-with-left')}`);
-            this.refreshKeybinding('keybinding-3');
+            this.refreshKeybinding('join-with-left');
         });
 
-        this.settings.connect('changed::keybinding-4', () => {
+        this.settings.connect('changed::join-with-right', () => {
-            log(`Keybinding 4 changed to: ${this.settings.get_strv('keybinding-4')}`);
+            log(`Keybinding 4 changed to: ${this.settings.get_strv('join-with-right')}`);
-            this.refreshKeybinding('keybinding-4');
+            this.refreshKeybinding('join-with-right');
         });
 
         this.settings.connect('changed::dropdown-option', () => {
@@ -67,24 +68,24 @@ export default class aerospike extends Extension {
         }
 
         switch (settingName) {
-            case 'keybinding-1':
+            case 'move-left':
-                this.bindKeybinding('keybinding-1', () => {
+                this.bindKeybinding('move-left', () => {
-                    log('Keybinding 1 was pressed!');
+                    Logger.info('Keybinding 1 was pressed!');
                 });
                 break;
-            case 'keybinding-2':
+            case 'move-right':
-                this.bindKeybinding('keybinding-2', () => {
+                this.bindKeybinding('move-right', () => {
-                    log('Keybinding 2 was pressed!');
+                    Logger.info('Keybinding 2 was pressed!');
                 });
                 break;
-            case 'keybinding-3':
+            case 'join-with-left':
-                this.bindKeybinding('keybinding-3', () => {
+                this.bindKeybinding('join-with-left', () => {
-                    log('Keybinding 3 was pressed!');
+                    Logger.info('Keybinding 3 was pressed!');
                 });
                 break;
-            case 'keybinding-4':
+            case 'join-with-right':
-                this.bindKeybinding('keybinding-4', () => {
+                this.bindKeybinding('join-with-right', () => {
-                    log('Keybinding 4 was pressed!');
+                    Logger.info('Keybinding 4 was pressed!');
                 });
                 break;
         }
@@ -98,20 +99,20 @@ export default class aerospike extends Extension {
     }
 
     private setupKeybindings() {
-        this.bindKeybinding('keybinding-1', () => {
+        this.bindKeybinding('move-left', () => {
-            log('Keybinding 1 was pressed!');
+            Logger.info('Keybinding 1 was pressed!');
         });
 
-        this.bindKeybinding('keybinding-2', () => {
+        this.bindKeybinding('move-right', () => {
-            log('Keybinding 2 was pressed!');
+            Logger.info('Keybinding 2 was pressed!');
         });
 
-        this.bindKeybinding('keybinding-3', () => {
+        this.bindKeybinding('join-with-left', () => {
-            log('Keybinding 3 was pressed!');
+            Logger.info('Keybinding 3 was pressed!');
         });
 
-        this.bindKeybinding('keybinding-4', () => {
+        this.bindKeybinding('join-with-right', () => {
-            log('Keybinding 4 was pressed!');
+            Logger.info('Keybinding 4 was pressed!');
         });
     }
 
@@ -125,7 +126,7 @@ export default class aerospike extends Extension {
         const keyBindingAction = Main.wm.addKeybinding(
             settingName,
             this.settings,
-            Meta.KeyBindingFlags.IGNORE_AUTOREPEAT,
+            Meta.KeyBindingFlags.NONE,
             Shell.ActionMode.NORMAL,
             callback
         );

metadata.json

@@ -4,7 +4,8 @@
   "uuid": "aerospike@lucaso.io",
   "settings-schema": "org.gnome.shell.extensions.aerospike",
   "shell-version": [
-    "48"
+    "48",
+    "49"
   ],
   "gettext-domain": "aerospike@lucaso.io",
   "url": "https://gitea.chaosdev.gay/lucasoskorep/aerospike@lucaso.io"

package.json

@@ -16,13 +16,33 @@
   "homepage": "https://github.com/example/my-extension#readme",
   "sideEffects": false,
   "devDependencies": {
-    "@girs/gjs": "^4.0.0-beta.23",
+    "@girs/gjs": "4.0.0-beta.38",
-    "@girs/gnome-shell": "^48.0.1",
+    "@girs/gnome-shell": "49.0.1",
-    "eslint": "^9.23.0",
+    "eslint": "^9.36.0",
-    "eslint-plugin-jsdoc": "^50.6.9",
+    "eslint-plugin-jsdoc": "^50.8.0",
-    "typescript": "^5.8.2"
+    "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@girs/mtk-16": "16.0.0-4.0.0-beta.23"
+    "@girs/mtk-17": "17.0.0-4.0.0-beta.38"
+  },
+  "pnpm": {
+    "overrides": {
+      "@girs/cairo-1.0": "1.0.0-4.0.0-beta.38",
+      "@girs/freetype2-2.0": "2.0.0-4.0.0-beta.38",
+      "@girs/gdk-4.0": "4.0.0-4.0.0-beta.38",
+      "@girs/gdkpixbuf-2.0": "2.0.0-4.0.0-beta.38",
+      "@girs/gio-2.0": "2.86.0-4.0.0-beta.38",
+      "@girs/gjs": "4.0.0-beta.38",
+      "@girs/glib-2.0": "2.86.0-4.0.0-beta.38",
+      "@girs/gmodule-2.0": "2.0.0-4.0.0-beta.38",
+      "@girs/gobject-2.0": "2.86.0-4.0.0-beta.38",
+      "@girs/graphene-1.0": "1.0.0-4.0.0-beta.38",
+      "@girs/gsk-4.0": "4.0.0-4.0.0-beta.38",
+      "@girs/gtk-4.0": "4.20.1-4.0.0-beta.38",
+      "@girs/harfbuzz-0.0": "11.5.0-4.0.0-beta.38",
+      "@girs/mtk-17": "17.0.0-4.0.0-beta.38",
+      "@girs/pango-1.0": "1.57.0-4.0.0-beta.38",
+      "@girs/pangocairo-1.0": "1.0.0-4.0.0-beta.38"
+    }
   }
 }

prefs.ts

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

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

@@ -1,30 +1,6 @@
 <?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>
@@ -36,5 +12,30 @@
             <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/keybindings.ts

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

@@ -3,8 +3,10 @@ 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 MyExtensionPreferences extends ExtensionPreferences {
+export default class AerospikeExtensions extends ExtensionPreferences {
     async fillPreferencesWindow(window: Adw.PreferencesWindow) {
         // Create settings object
         const settings = this.getSettings('org.gnome.shell.extensions.aerospike');
@@ -16,17 +18,6 @@ export default class MyExtensionPreferences 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({
@@ -114,79 +105,82 @@ export default class MyExtensionPreferences 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
+            })
+        );
+
+
     }
 
-    private addKeybindingRow(
+    // Helper function to create a keybinding mapping object
-        group: Adw.PreferencesGroup,
+    private createKeybindingMap() {
-        settings: Gio.Settings,
+        return {
-        key: string,
+            from(settings: Gio.Settings, bind: string) {
-        title: string
+                return settings.get_strv(bind).join(',');
-    ) {
+            },
-        const shortcutsRow = new Adw.ActionRow({
+            to(settings: Gio.Settings, bind: string, value: string) {
-            title: title,
+                if (!!value) {
+                    const mappings = value.split(',').map((x) => {
+                        const [, key, mods] = Gtk.accelerator_parse(x);
+                        return Gtk.accelerator_valid(key, mods) && Gtk.accelerator_name(key, mods);
                     });
-
+                    // Filter out any false values to ensure we only have strings
-        group.add(shortcutsRow);
+                    const stringMappings = mappings.filter((x): x is string => typeof x === 'string');
-
+                    if (stringMappings.length > 0) {
-        // Create a button for setting shortcuts
+                        Logger.debug("setting", bind, "to", stringMappings);
-        const shortcutButton = new Gtk.Button({
+                        settings.set_strv(bind, stringMappings);
-            valign: Gtk.Align.CENTER,
-            label: settings.get_strv(key)[0] || _("Disabled")
-        });
-
-        shortcutsRow.add_suffix(shortcutButton);
-        shortcutsRow.set_activatable_widget(shortcutButton);
-
-        // 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;
                     }
-
+                } else {
-                // Convert modifier state to keybinding modifiers
+                    // If value deleted, unset the mapping
-                let modifiers = state & Gtk.accelerator_get_default_mod_mask();
+                    settings.set_strv(bind, []);
-
-                // 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/wm/container.ts

@@ -1,8 +1,8 @@
 import {WindowWrapper} from "./window.js";
-import {Logger} from "./utils/logger.js";
+import {Logger} from "../utils/logger.js";
 import Meta from "gi://Meta";
-import queueEvent from "./utils/events.js";
+import queueEvent from "../utils/events.js";
-import {Rect} from "./utils/rect.js";
+import {Rect} from "../utils/rect.js";
 
 enum Orientation {
     HORIZONTAL = 0,
@@ -12,24 +12,20 @@ enum Orientation {
 
 export default class WindowContainer {
 
-    _id: number;
     _tiledItems: (WindowWrapper | WindowContainer)[];
     _tiledWindowLookup: Map<number, WindowWrapper>;
-    _workspace: number;
     _orientation: Orientation = Orientation.HORIZONTAL;
     _workArea: Rect;
+    _customSizes: Map<number, number>;  // Maps window ID to custom width (horizontal) or height (vertical)
 
-    constructor(monitorId: number, workspaceArea: Rect, workspace: number) {
+    constructor(workspaceArea: Rect,) {
-        this._id = monitorId;
+        // this._id = monitorId;
-        this._workspace = workspace;
         this._tiledItems = [];
         this._tiledWindowLookup = new Map<number, WindowWrapper>();
         this._workArea = workspaceArea;
+        this._customSizes = new Map<number, number>();
     }
 
-    getWorkspace(): number {
-        return this._workspace;
-    }
 
     move(rect: Rect): void {
         this._workArea = rect;
@@ -40,6 +36,7 @@ export default class WindowContainer {
         // Add window to managed windows
         this._tiledItems.push(winWrap);
         this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
+        // winWrap.setParent(this);
         queueEvent({
             name: "tiling-windows",
             callback: () => {
@@ -79,6 +76,7 @@ export default class WindowContainer {
     removeWindow(win_id: number): void {
         if (this._tiledWindowLookup.has(win_id)) {
             this._tiledWindowLookup.delete(win_id);
+            this._customSizes.delete(win_id);
             const index = this._getIndexOfWindow(win_id)
             this._tiledItems.splice(index, 1);
         } else {
@@ -108,75 +106,125 @@ export default class WindowContainer {
     }
 
     tileWindows() {
-        Logger.log("TILING WINDOWS ON MONITOR", this._id)
+        Logger.log("TILING WINDOWS IN CONTAINER")
 
-        Logger.log("Workspace", this._workspace);
         Logger.log("WorkArea", this._workArea);
 
-        // Get all windows for current workspace
+        // Get all windows for current workspaceArea
-        let tilable = this._getTilableItems();
+        this._tileItems()
 
-        if (tilable.length !== 0) {
-            this._tileItems(tilable)
-        }
         return true
     }
 
-    _getTilableItems(): (WindowWrapper | WindowContainer)[] {
+    _tileItems() {
-        return Array.from(this._tiledItems.values())
+        if (this._tiledItems.length === 0) {
-    }
-
-    _tileItems(windows: (WindowWrapper | WindowContainer)[]) {
-        if (windows.length === 0) {
             return;
         }
-        if (this._orientation === Orientation.HORIZONTAL) {
+        const bounds = this.getBounds();
-            this._tileHorizontally(windows);
+        this._tiledItems.forEach((item, index) => {
+            const rect = bounds[index];
+            if (item instanceof WindowContainer) {
+                item.move(rect);
             } else {
-            this._tileVertically(windows);
+                item.safelyResizeWindow(rect);
             }
+        })
     }
 
-    _tileVertically(items: (WindowWrapper | WindowContainer)[]) {
+
+    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) => {
-        items.forEach((item, index) => {
             const y = this._workArea.y + (index * containerHeight);
-            const rect = {
+            return {
                 x: this._workArea.x,
                 y: y,
                 width: this._workArea.width,
                 height: containerHeight
-            };
+            } as Rect;
-            if (item != null) {
-                if (item instanceof WindowContainer) {
-                    item.move(rect)
-                } else {
-                    item.safelyResizeWindow(rect);
-                }
-            }
         });
     }
 
-    _tileHorizontally(windows: (WindowWrapper | WindowContainer)[]) {
+    getHorizontalBounds(): Rect[] {
-        const windowWidth = Math.floor(this._workArea.width / windows.length);
+        const windowWidth = Math.floor(this._workArea.width / this._tiledItems.length);
 
-        windows.forEach((item, index) => {
+        return this._tiledItems.map((_, index) => {
             const x = this._workArea.x + (index * windowWidth);
-            const rect = {
+            return {
                 x: x,
                 y: this._workArea.y,
                 width: windowWidth,
                 height: this._workArea.height
-            };
+            } as Rect;
-            if (item != null) {
-                if (item instanceof WindowContainer) {
-                    item.move(rect)
-                } else {
-                    item.safelyResizeWindow(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()
+        }
+
+    }
+
+    windowManuallyResized(win_id: number): void {
+        const window = this.getWindow(win_id);
+        if (!window) {
+            // Check nested containers
+            for (const item of this._tiledItems) {
+                if (item instanceof WindowContainer) {
+                    item.windowManuallyResized(win_id);
+                }
+            }
+            return;
+        }
+
+        const rect = window.getRect();
+        if (this._orientation === Orientation.HORIZONTAL) {
+            this._customSizes.set(win_id, rect.width);
+            Logger.log(`Window ${win_id} manually resized to width: ${rect.width}`);
+        } else {
+            this._customSizes.set(win_id, rect.height);
+            Logger.log(`Window ${win_id} manually resized to height: ${rect.height}`);
+        }
+    }
+
+
 }

src/wm/monitor.ts

@@ -1,9 +1,9 @@
 import {WindowWrapper} from "./window.js";
-import {Rect} from "./utils/rect.js";
+import {Rect} from "../utils/rect.js";
-import queueEvent from "./utils/events.js";
+import queueEvent from "../utils/events.js";
-import {Logger} from "./utils/logger.js";
+import {Logger} from "../utils/logger.js";
 import Meta from "gi://Meta";
-import Mtk from "@girs/mtk-16";
+import Mtk from "@girs/mtk-17";
 
 import WindowContainer from "./container.js";
 import Window = Meta.Window;
@@ -23,7 +23,7 @@ export default class Monitor {
         const workspaceCount = global.workspace_manager.get_n_workspaces()
         Logger.log("Workspace Count", workspaceCount);
         for (let i = 0; i < workspaceCount; i++) {
-            this._workspaces.push(new WindowContainer(monitorId, this._workArea, i));
+            this._workspaces.push(new WindowContainer(this._workArea));
         }
     }
 
@@ -61,7 +61,6 @@ export default class Monitor {
 
     addWindow(winWrap: WindowWrapper) {
         const window_workspace = winWrap.getWindow().get_workspace().index();
-        Logger.log("Adding window to workspace",  window_workspace);
         this._workspaces[window_workspace].addWindow(winWrap);
     }
 
@@ -72,4 +71,27 @@ export default class Monitor {
         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);
+    }
+
+    windowManuallyResized(win_id: number): void {
+        // Find which workspace contains the window and notify it
+        for (const container of this._workspaces) {
+            const win = container.getWindow(win_id);
+            if (win) {
+                container.windowManuallyResized(win_id);
+                return;
+            }
+        }
+    }
+
 }

src/wm/window.ts

@@ -1,9 +1,10 @@
 import Meta from 'gi://Meta';
 import Clutter from "gi://Clutter";
 import {IWindowManager} from "./windowManager.js";
-import {Logger} from "./utils/logger.js";
+import {Logger} from "../utils/logger.js";
-import {Rect} from "./utils/rect.js";
+import {Rect} from "../utils/rect.js";
 import WindowContainer from "./container.js";
+import queueEvent from "../utils/events.js";
 
 
 type WindowMinimizedHandler = (window: WindowWrapper) => void;
@@ -12,15 +13,15 @@ type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void;
 export class WindowWrapper {
     readonly _window: Meta.Window;
     readonly _windowMinimizedHandler: WindowMinimizedHandler;
-    // readonly _windowWorkspaceChangedHandler: WindowWorkspaceChangedHandler;
+    readonly _signals: number[] = [];
-    readonly _signals: number[];
+    _parent: WindowContainer | null = null;
+    _dragging: boolean = false;
 
     constructor(
         window: Meta.Window,
         winMinimized: WindowMinimizedHandler
     ) {
         this._window = window;
-        this._signals = [];
         this._windowMinimizedHandler = winMinimized;
     }
 
@@ -32,6 +33,37 @@ export class WindowWrapper {
         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 {
@@ -59,7 +91,7 @@ export class WindowWrapper {
                 }
             }),
             this._window.connect('notify::maximized-horizontally', () => {
-                if (this._window.get_maximized()) {
+                if (this._window.is_maximized()) {
                     Logger.log(`Window maximized: ${windowId}`);
                 } else {
                     Logger.log(`Window unmaximized: ${windowId}`);
@@ -67,6 +99,10 @@ export class WindowWrapper {
             }),
             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);
             }),
         );
     }
@@ -86,10 +122,13 @@ export class WindowWrapper {
         }
     }
 
-    // This is meant to be an exact copy of Forge's move function, renamed to maintain your API
+    safelyResizeWindow(rect: Rect, _retry: number = 2): void {
-    safelyResizeWindow(rect: Rect): void {
         // Keep minimal logging
-        Logger.log("SAFELY RESIZE", rect.x, rect.y, rect.width, rect.height);
+        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) {
@@ -99,11 +138,20 @@ export class WindowWrapper {
         let windowActor = this._window.get_compositor_private() as Clutter.Actor;
         if (!windowActor) return;
         windowActor.remove_all_transitions();
-        Logger.info("MOVING")
+        // Logger.info("MOVING")
         this._window.move_frame(true, rect.x, rect.y);
-        Logger.info("RESIZING MOVING")
+        // Logger.info("RESIZING MOVING")
         this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);
-
+        let new_rect = this._window.get_frame_rect();
+        if ( _retry > 0 && (new_rect.x != rect.x || rect.y != new_rect.y || rect.width < new_rect.width || rect.height < new_rect.height)) {
+            Logger.warn("RESIZING FAILED AS SMALLER", new_rect.x, new_rect.y, new_rect.width, new_rect.height, rect.x, rect.y, rect.width, rect.height);
+            queueEvent({
+                name: "attempting_delayed_resize",
+                callback: () => {
+                    this.safelyResizeWindow(rect, _retry-1);
+                }
+            })
+        }
     }
 
 

src/wm/windowManager.ts

@@ -1,14 +1,11 @@
 import Meta from "gi://Meta";
-import Gio from "gi://Gio";
+// import Gio from "gi://Gio";
-import GLib from "gi://GLib";
+// 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 Mtk from "@girs/mtk-16";
-import {Logger} from "./utils/logger.js";
+import {Logger} from "../utils/logger.js";
-import WindowContainer from "./container.js";
-import {MessageTray} from "@girs/gnome-shell/ui/messageTray";
-import queueEvent, {QueuedEvent} from "./utils/events.js";
 import Monitor from "./monitor.js";
 
 
@@ -23,41 +20,36 @@ export interface IWindowManager {
 
     handleWindowUnminimized(winWrap: WindowWrapper): void;
 
+    handleWindowChangedWorkspace(winWrap: WindowWrapper): void;
+
+    handleWindowPositionChanged(winWrap: WindowWrapper): void;
 
-    // removeFromTree(window: Meta.Window): void;
     syncActiveWindow(): number | null;
 }
 
 
 const _UNUSED_MONITOR_ID = -1
+const _UNUSED_WINDOW_ID = -1
+
 export default class WindowManager implements IWindowManager {
-    _displaySignals: number[];
+    _displaySignals: number[] = [];
-    _windowManagerSignals: number[];
+    _windowManagerSignals: number[] = [];
-    _workspaceManagerSignals: number[];
+    _workspaceManagerSignals: number[] = [];
-    _overviewSignals: number[];
+    _overviewSignals: number[] = [];
 
-    _activeWindowId: number | null;
+    _activeWindowId: number | null = null;
-    _grabbedWindowMonitor: number;
+    _monitors: Map<number, Monitor> = new Map<number, Monitor>();
-    _monitors: Map<number, Monitor>;
-    _sessionProxy: Gio.DBusProxy | null;
-    _lockedSignalId: number | null;
-    _isScreenLocked: boolean;
 
-    _minimizedItems: Map<number, WindowWrapper>;
+    _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() {
-        this._displaySignals = [];
-        this._windowManagerSignals = [];
-        this._workspaceManagerSignals = [];
-        this._overviewSignals = [];
-        this._activeWindowId = null;
-        this._grabbedWindowMonitor = _UNUSED_MONITOR_ID;
-        this._monitors = new Map<number, Monitor>();
-        this._sessionProxy = null;
-        this._lockedSignalId = null;
-        this._isScreenLocked = false; // Initialize to unlocked state
 
-        this._minimizedItems = new Map<number, WindowWrapper>();
 
     }
 
@@ -84,6 +76,12 @@ export default class WindowManager implements IWindowManager {
             }),
             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);
@@ -101,11 +99,11 @@ export default class WindowManager implements IWindowManager {
             }),
         )
 
-        this._windowManagerSignals = [
+        // this._windowManagerSignals = [
-            global.window_manager.connect("show-tile-preview", (_, _metaWindow, _rect, _num) => {
+        //     global.window_manager.connect("show-tile-preview", (_, _metaWindow, _rect, _num) => {
-                Logger.log("SHOW TITLE PREVIEW!")
+        //         Logger.log("SHOW TITLE PREVIEW!")
-            }),
+        //     }),
-        ];
+        // ];
 
         this._workspaceManagerSignals = [
             global.workspace_manager.connect("showing-desktop-changed", () => {
@@ -113,9 +111,15 @@ export default class WindowManager implements IWindowManager {
             }),
             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());
@@ -126,6 +130,7 @@ export default class WindowManager implements IWindowManager {
             Main.overview.connect("hiding", () => {
                 // this.fromOverview = true;
                 Logger.log("HIDING OVERVIEW")
+                this._showingOverview = false;
                 this._tileMonitors();
                 // const eventObj = {
                 //     name: "focus-after-overview",
@@ -136,7 +141,7 @@ export default class WindowManager implements IWindowManager {
                 // this.queueEvent(eventObj);
             }),
             Main.overview.connect("showing", () => {
-                // this.toOverview = true;
+                this._showingOverview = true;
                 Logger.log("SHOWING OVERVIEW");
             }),
         ];
@@ -194,70 +199,134 @@ export default class WindowManager implements IWindowManager {
 
 
     handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
-        Logger.log("Grab Op Start");
+        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();
+    }
+
+    _isResizeOperation(op: Meta.GrabOp): boolean {
+        // Check if the operation is any kind of resize
+        return op === Meta.GrabOp.RESIZING_E ||
+               op === Meta.GrabOp.RESIZING_W ||
+               op === Meta.GrabOp.RESIZING_N ||
+               op === Meta.GrabOp.RESIZING_S ||
+               op === Meta.GrabOp.RESIZING_NE ||
+               op === Meta.GrabOp.RESIZING_NW ||
+               op === Meta.GrabOp.RESIZING_SE ||
+               op === Meta.GrabOp.RESIZING_SW;
     }
 
     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())
-        var rect = window.get_frame_rect()
-        Logger.info("Release Location", window.get_monitor(), rect.x, rect.y, rect.width, rect.height)
-        const old_mon_id = this._grabbedWindowMonitor;
-        const new_mon_id = window.get_monitor();
 
-        Logger.info("MONITOR MATCH", old_mon_id !== new_mon_id);
+        const isResizing = this._isResizeOperation(op);
-        if (old_mon_id !== new_mon_id) {
+
-            Logger.trace("MOVING MONITOR");
+        if (isResizing) {
-            let old_mon = this._monitors.get(old_mon_id);
+            // Window was manually resized - capture the new size
-            let new_mon = this._monitors.get(new_mon_id);
+            const monitor = this._monitors.get(window.get_monitor());
-            if (old_mon === undefined || new_mon === undefined) {
+            if (monitor) {
-                return;
+                monitor.windowManuallyResized(window.get_id());
+            }
         }
 
-            let wrapped = old_mon.getWindow(window.get_id())
+        this._grabbedWindowId = _UNUSED_WINDOW_ID;
-            if (wrapped === undefined) {
+        this._getWrappedWindow(window)?.stopDragging();
-                wrapped = new WindowWrapper(window, this.handleWindowMinimized);
-            } else {
-                old_mon.removeWindow(wrapped)
-            }
-            new_mon.addWindow(wrapped)
-        }
         this._tileMonitors();
         Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
     }
 
-    public handleWindowMinimized(winWrap: WindowWrapper): void {
+    _getWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
-        Logger.warn("WARNING MINIMIZING WINDOW");
+        let wrapped = undefined;
-        Logger.log("WARNING MINIMIZED", JSON.stringify(winWrap));
+        for (const monitor of this._monitors.values()) {
-        const monitor_id = winWrap.getWindow().get_monitor()
+            wrapped = monitor.getWindow(window.get_id());
-        Logger.log("WARNING MINIMIZED", monitor_id);
+            if (wrapped !== undefined) {
-        Logger.warn("WARNING MINIMIZED", this._monitors);
+                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 {
+        let wrapped = this._getAndRemoveWrappedWindow(window);
+        if (wrapped === undefined) {
+            Logger.error("WINDOW NOT DEFINED")
+            wrapped = new WindowWrapper(window, this.handleWindowMinimized);
+            wrapped.connectWindowSignals(this);
+        }
+        let new_mon = this._monitors.get(monitorId);
+        new_mon?.addWindow(wrapped)
+        this._grabbedWindowMonitor = monitorId;
+    }
+
+    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;
+                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);
-
-        Logger.warn("WARNING MINIMIZED ITEMS", JSON.stringify(this._minimizedItems));
         this._tileMonitors()
     }
 
     public handleWindowUnminimized(winWrap: WindowWrapper): void {
-        Logger.log("WINDOW UNMINIMIZED");
-        Logger.log("WINDOW UNMINIMIZED", winWrap == null);
-        // Logger.log("WINDOW UNMINIMIZED", winWrap);
-        // Logger.log("WINDOW UNMINIMIZED", winWrap.getWindowId());
         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() {
-        Logger.log("CAPTURING WINDOWS")
         const workspace = global.workspace_manager.get_active_workspace();
         const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
-        Logger.log("WINDOWS", windows);
         windows.forEach(window => {
             if (this._isWindowTileable(window)) {
                 this.addWindowToMonitor(window);
@@ -303,12 +372,14 @@ export default class WindowManager implements IWindowManager {
         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 {
 
@@ -317,14 +388,35 @@ export default class WindowManager implements IWindowManager {
         }
     }
 
+    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_wm_class() === 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 TYPE", windowType);
+        Logger.log("WINDOW TILING CHECK",);
+
         // Skip certain types of windows
         return !window.is_skip_taskbar() &&
             windowType !== Meta.WindowType.DESKTOP &&