diff --git a/extension.ts b/extension.ts index 1573223..c675673 100644 --- a/extension.ts +++ b/extension.ts @@ -15,7 +15,7 @@ export default class aerospike extends Extension { super(metadata); this.settings = this.getSettings('org.gnome.shell.extensions.aerospike'); this.keyBindings = new Map(); - this.windowManager = new WindowManager(); + this.windowManager = new WindowManager(this.settings); } enable() { @@ -30,37 +30,25 @@ export default class aerospike extends Extension { this.removeKeybindings() } + private keybindingActions(): Record void> { + return { + 'move-left': () => { Logger.info('Keybinding 1 was pressed!'); }, + 'move-right': () => { Logger.info('Keybinding 2 was pressed!'); }, + 'join-with-left': () => { Logger.info('Keybinding 3 was pressed!'); }, + 'join-with-right': () => { Logger.info('Keybinding 4 was pressed!'); }, + 'print-tree': () => { this.windowManager.printTreeStructure(); }, + 'toggle-orientation': () => { this.windowManager.toggleActiveContainerOrientation(); }, + 'reset-ratios': () => { this.windowManager.resetActiveContainerRatios(); }, + }; + } private bindSettings() { - // Monitor settings changes - this.settings.connect('changed::move-left', () => { - log(`Keybinding 1 changed to: ${this.settings.get_strv('move-left')}`); - this.refreshKeybinding('move-left'); - }); - - this.settings.connect('changed::move-right', () => { - log(`Keybinding 2 changed to: ${this.settings.get_strv('move-right')}`); - this.refreshKeybinding('move-right'); - }); - - this.settings.connect('changed::join-with-left', () => { - log(`Keybinding 3 changed to: ${this.settings.get_strv('join-with-left')}`); - this.refreshKeybinding('join-with-left'); - }); - - this.settings.connect('changed::join-with-right', () => { - log(`Keybinding 4 changed to: ${this.settings.get_strv('join-with-right')}`); - this.refreshKeybinding('join-with-right'); - }); - - this.settings.connect('changed::print-tree', () => { - log(`Print tree keybinding changed to: ${this.settings.get_strv('print-tree')}`); - this.refreshKeybinding('print-tree'); - }); - - this.settings.connect('changed::toggle-orientation', () => { - log(`Toggle orientation keybinding changed to: ${this.settings.get_strv('toggle-orientation')}`); - this.refreshKeybinding('toggle-orientation'); + const keybindings = Object.keys(this.keybindingActions()); + keybindings.forEach(name => { + this.settings.connect(`changed::${name}`, () => { + log(`${name} keybinding changed to: ${this.settings.get_strv(name)}`); + this.refreshKeybinding(name); + }); }); this.settings.connect('changed::dropdown-option', () => { @@ -71,44 +59,15 @@ 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); this.keyBindings.delete(settingName); } - switch (settingName) { - case 'move-left': - this.bindKeybinding('move-left', () => { - Logger.info('Keybinding 1 was pressed!'); - }); - break; - case 'move-right': - this.bindKeybinding('move-right', () => { - Logger.info('Keybinding 2 was pressed!'); - }); - break; - case 'join-with-left': - this.bindKeybinding('join-with-left', () => { - Logger.info('Keybinding 3 was pressed!'); - }); - break; - case 'join-with-right': - this.bindKeybinding('join-with-right', () => { - Logger.info('Keybinding 4 was pressed!'); - }); - break; - case 'print-tree': - this.bindKeybinding('print-tree', () => { - this.windowManager.printTreeStructure(); - }); - break; - case 'toggle-orientation': - this.bindKeybinding('toggle-orientation', () => { - this.windowManager.toggleActiveContainerOrientation(); - }); - break; - } + const action = this.keybindingActions()[settingName]; + if (action) this.bindKeybinding(settingName, action); } private removeKeybindings() { @@ -119,29 +78,10 @@ export default class aerospike extends Extension { } private setupKeybindings() { - this.bindKeybinding('move-left', () => { - Logger.info('Keybinding 1 was pressed!'); - }); - - this.bindKeybinding('move-right', () => { - Logger.info('Keybinding 2 was pressed!'); - }); - - this.bindKeybinding('join-with-left', () => { - Logger.info('Keybinding 3 was pressed!'); - }); - - this.bindKeybinding('join-with-right', () => { - Logger.info('Keybinding 4 was pressed!'); - }); - - this.bindKeybinding('print-tree', () => { - this.windowManager.printTreeStructure(); - }); - - this.bindKeybinding('toggle-orientation', () => { - this.windowManager.toggleActiveContainerOrientation(); - }); + const actions = this.keybindingActions(); + for (const [name, action] of Object.entries(actions)) { + this.bindKeybinding(name, action); + } } private bindKeybinding(settingName: string, callback: () => void) { @@ -161,7 +101,4 @@ export default class aerospike extends Extension { this.keyBindings.set(settingName, keyBindingAction); } - - - -} \ No newline at end of file +} diff --git a/schemas/org.gnome.shell.extensions.aerospike.gschema.xml b/schemas/org.gnome.shell.extensions.aerospike.gschema.xml index 2c31914..f0f74a4 100644 --- a/schemas/org.gnome.shell.extensions.aerospike.gschema.xml +++ b/schemas/org.gnome.shell.extensions.aerospike.gschema.xml @@ -49,5 +49,11 @@ Toggles the orientation of the container holding the active window between horizontal and vertical + + z']]]> + Reset container ratios to equal splits + Resets all window size ratios in the active window's container to equal splits + + \ No newline at end of file diff --git a/src/prefs/prefs.ts b/src/prefs/prefs.ts index bfee9e5..4daa950 100644 --- a/src/prefs/prefs.ts +++ b/src/prefs/prefs.ts @@ -173,6 +173,14 @@ export default class AerospikeExtensions extends ExtensionPreferences { }) ); + keybindingsGroup.add( + new EntryRow({ + title: _('Reset Container Ratios to Equal'), + settings: settings, + bind: 'reset-ratios', + map: keybindingMap + }) + ); } diff --git a/src/utils/events.ts b/src/utils/events.ts index 0332280..49a4404 100644 --- a/src/utils/events.ts +++ b/src/utils/events.ts @@ -1,20 +1,21 @@ import GLib from "gi://GLib"; - export type QueuedEvent = { name: string; callback: () => void; } -const queuedEvents: QueuedEvent[] = []; +const pendingEvents: Map = new Map(); export default function queueEvent(event: QueuedEvent, interval = 200) { - queuedEvents.push(event); + pendingEvents.set(event.name, event); + GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => { - const e = queuedEvents.pop() - if (e) { + const e = pendingEvents.get(event.name); + if (e && e === event) { + pendingEvents.delete(event.name); e.callback(); } - return queuedEvents.length !== 0; + return GLib.SOURCE_REMOVE; }); -} \ No newline at end of file +} diff --git a/src/wm/container.ts b/src/wm/container.ts index 5d97ee6..9ff86d7 100644 --- a/src/wm/container.ts +++ b/src/wm/container.ts @@ -1,6 +1,5 @@ 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"; @@ -9,6 +8,15 @@ enum Orientation { VERTICAL = 1, } +// Returns equal ratios summing exactly to 1.0, with float drift absorbed by the last slot. +function equalRatios(n: number): number[] { + if (n <= 0) return []; + const base = 1 / n; + const ratios = Array(n).fill(base); + const sumExceptLast = ratios.slice(0, -1).reduce((a, b) => a + b, 0); + ratios[n - 1] = 1 - sumExceptLast; + return ratios; +} export default class WindowContainer { @@ -16,13 +24,42 @@ export default class WindowContainer { _tiledWindowLookup: Map; _orientation: Orientation = Orientation.HORIZONTAL; _workArea: Rect; + _splitRatios: number[]; - constructor(workspaceArea: Rect,) { + constructor(workspaceArea: Rect) { this._tiledItems = []; this._tiledWindowLookup = new Map(); this._workArea = workspaceArea; + this._splitRatios = []; } + // ─── Helpers ──────────────────────────────────────────────────────────────── + + private _resetRatios(): void { + this._splitRatios = equalRatios(this._tiledItems.length); + } + + private _addRatioForNewWindow(): void { + const n = this._tiledItems.length; + if (n <= 1) { + this._splitRatios = [1.0]; + return; + } + const newRatio = 1 / n; + const scale = 1 - newRatio; + const scaled = this._splitRatios.map(r => r * scale); + const partialSum = scaled.reduce((a, b) => a + b, 0) + newRatio; + scaled[scaled.length - 1] += (1.0 - partialSum); + this._splitRatios = [...scaled, newRatio]; + } + + private _totalDimension(): number { + return this._orientation === Orientation.HORIZONTAL + ? this._workArea.width + : this._workArea.height; + } + + // ─── Public API ───────────────────────────────────────────────────────────── move(rect: Rect): void { this._workArea = rect; @@ -40,13 +77,11 @@ export default class WindowContainer { addWindow(winWrap: WindowWrapper): void { this._tiledItems.push(winWrap); this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap); + this._addRatioForNewWindow(); queueEvent({ name: "tiling-windows", - callback: () => { - this.tileWindows(); - } - }, 100) - + callback: () => this.tileWindows(), + }, 100); } getWindow(win_id: number): WindowWrapper | undefined { @@ -56,24 +91,22 @@ export default class WindowContainer { for (const item of this._tiledItems) { if (item instanceof WindowContainer) { const win = item.getWindow(win_id); - if (win) { - return win; - } + if (win) return win; } else if (item.getWindowId() === win_id) { return item; } } - return undefined + return undefined; } - _getIndexOfWindow(win_id: number) { + _getIndexOfWindow(win_id: number): 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 + return -1; } removeWindow(win_id: number): void { @@ -84,6 +117,7 @@ export default class WindowContainer { if (index !== -1) { this._tiledItems.splice(index, 1); } + this._resetRatios(); } else { for (const item of this._tiledItems) { if (item instanceof WindowContainer) { @@ -91,94 +125,120 @@ export default class WindowContainer { } } } - this.tileWindows() + this.tileWindows(); } disconnectSignals(): void { this._tiledItems.forEach((item) => { - if (item instanceof WindowContainer) { - item.disconnectSignals() - } else { - item.disconnectWindowSignals(); - } + if (item instanceof WindowContainer) { + item.disconnectSignals(); + } else { + item.disconnectWindowSignals(); } - ) + }); } removeAllWindows(): void { - this._tiledItems = [] - this._tiledWindowLookup.clear() + this._tiledItems = []; + this._tiledWindowLookup.clear(); + this._splitRatios = []; } - tileWindows() { - Logger.log("TILING WINDOWS IN CONTAINER") - + tileWindows(): void { + Logger.log("TILING WINDOWS IN CONTAINER"); Logger.log("WorkArea", this._workArea); - - this._tileItems() - - return true + this._tileItems(); } _tileItems() { - if (this._tiledItems.length === 0) { - return; - } + if (this._tiledItems.length === 0) return; + const bounds = this.getBounds(); + Logger.info(`_tileItems: ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}] bounds=[${bounds.map(b => `(${b.x},${b.y},${b.width},${b.height})`).join(', ')}]`); this._tiledItems.forEach((item, index) => { const rect = bounds[index]; if (item instanceof WindowContainer) { item.move(rect); } else { + Logger.info(`_tileItems: window[${index}] id=${item.getWindowId()} dragging=${item._dragging} → rect=(${rect.x},${rect.y},${rect.width},${rect.height})`); item.safelyResizeWindow(rect); } - }) + }); } + // ─── Bounds Calculation ────────────────────────────────────────────────────── getBounds(): Rect[] { - if (this._orientation === Orientation.HORIZONTAL) { - return this.getHorizontalBounds(); - } - return this.getVerticalBounds(); + return this._orientation === Orientation.HORIZONTAL + ? this._computeBounds('horizontal') + : this._computeBounds('vertical'); } - 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); + private _computeBounds(axis: 'horizontal' | 'vertical'): Rect[] { + const isHorizontal = axis === 'horizontal'; + const total = isHorizontal ? this._workArea.width : this._workArea.height; + let used = 0; 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; + const offset = used; + const size = index === this._tiledItems.length - 1 + ? total - used + : Math.floor(this._splitRatios[index] * total); + used += size; + + return isHorizontal + ? { x: this._workArea.x + offset, y: this._workArea.y, width: size, height: this._workArea.height } + : { x: this._workArea.x, y: this._workArea.y + offset, width: this._workArea.width, height: size }; }); } + // ─── Boundary Adjustment ───────────────────────────────────────────────────── + + adjustBoundary(boundaryIndex: number, deltaPixels: number): boolean { + if (boundaryIndex < 0 || boundaryIndex >= this._tiledItems.length - 1) { + Logger.warn(`adjustBoundary: invalid boundaryIndex ${boundaryIndex}`); + return false; + } + + const totalDim = this._totalDimension(); + if (totalDim === 0) return false; + + const ratioDelta = deltaPixels / totalDim; + const newLeft = this._splitRatios[boundaryIndex] + ratioDelta; + const newRight = this._splitRatios[boundaryIndex + 1] - ratioDelta; + + if (newLeft <= 0 || newRight <= 0) { + Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}`); + return false; + } + + this._splitRatios[boundaryIndex] = newLeft; + this._splitRatios[boundaryIndex + 1] = newRight; + + Logger.info(`adjustBoundary: boundary=${boundaryIndex} ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`); + return true; + } + + // ─── Container Lookup ──────────────────────────────────────────────────────── + + getContainerForWindow(win_id: number): WindowContainer | null { + for (const item of this._tiledItems) { + if (item instanceof WindowWrapper && item.getWindowId() === win_id) { + return this; + } + if (item instanceof WindowContainer) { + const found = item.getContainerForWindow(win_id); + if (found !== null) return found; + } + } + return null; + } + 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; - } + if (container.getIndexOfItemNested(item) !== -1) return i; } else if (container.getWindowId() === item.getWindowId()) { return i; } @@ -188,25 +248,30 @@ export default class WindowContainer { // 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); + const 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); + + let new_index = original_index; 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() - } + }); + if (original_index !== new_index) { + Logger.info(`itemDragged: swapped slots ${original_index}<->${new_index}, ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`); + [this._tiledItems[original_index], this._tiledItems[new_index]] = + [this._tiledItems[new_index], this._tiledItems[original_index]]; + this.tileWindows(); + } } - -} \ No newline at end of file + resetRatios(): void { + this._resetRatios(); + this.tileWindows(); + } +} diff --git a/src/wm/monitor.ts b/src/wm/monitor.ts index 640f74d..b020cb7 100644 --- a/src/wm/monitor.ts +++ b/src/wm/monitor.ts @@ -1,12 +1,9 @@ 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-17"; import WindowContainer from "./container.js"; -import Window = Meta.Window; export default class Monitor { @@ -20,7 +17,7 @@ export default class Monitor { 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() + 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)); @@ -42,9 +39,7 @@ export default class Monitor { getWindow(windowId: number): WindowWrapper | undefined { for (const container of this._workspaces) { const win = container.getWindow(windowId); - if (win) { - return win; - } + if (win) return win; } return undefined; } @@ -52,8 +47,7 @@ export default class Monitor { removeWindow(winWrap: WindowWrapper) { const windowId = winWrap.getWindowId(); for (const container of this._workspaces) { - const win = container.getWindow(windowId); - if (win) { + if (container.getWindow(windowId)) { container.removeWindow(windowId); } } @@ -65,10 +59,10 @@ export default class Monitor { } 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._workArea = activeWorkspace.get_work_area_for_monitor(this._id); + // move() calls tileWindows() internally this._workspaces[activeWorkspace.index()].move(this._workArea); - this._workspaces[activeWorkspace.index()].tileWindows() } removeWorkspace(workspaceId: number): void { @@ -82,5 +76,4 @@ export default class Monitor { itemDragged(item: WindowWrapper, x: number, y: number): void { this._workspaces[item.getWorkspace()].itemDragged(item, x, y); } - -} \ No newline at end of file +} diff --git a/src/wm/window.ts b/src/wm/window.ts index 70bb350..1f96b9e 100644 --- a/src/wm/window.ts +++ b/src/wm/window.ts @@ -11,6 +11,8 @@ type WindowMinimizedHandler = (window: WindowWrapper) => void; type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void; export class WindowWrapper { + private static readonly RESIZE_TOLERANCE = 2; + readonly _window: Meta.Window; readonly _windowMinimizedHandler: WindowMinimizedHandler; readonly _signals: number[] = []; @@ -48,41 +50,26 @@ export class WindowWrapper { 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 + connectWindowSignals(windowManager: IWindowManager): void { + const windowId = this._window.get_id(); this._signals.push( - this._window.connect('unmanaging', window => { + this._window.connect('unmanaging', () => { Logger.log("REMOVING WINDOW", windowId); - windowManager.handleWindowClosed(this) + windowManager.handleWindowClosed(this); }), - this._window.connect('notify::minimized', (we) => { + this._window.connect('notify::minimized', () => { if (this._window.minimized) { Logger.log(`Window minimized: ${windowId}`); windowManager.handleWindowMinimized(this); - - } else if (!this._window.minimized) { + } else { Logger.log(`Window unminimized: ${windowId}`); windowManager.handleWindowUnminimized(this); - } }), this._window.connect('notify::maximized-horizontally', () => { @@ -92,18 +79,20 @@ export class WindowWrapper { Logger.log(`Window unmaximized: ${windowId}`); } }), - this._window.connect("workspace-changed", (_metaWindow) => { + this._window.connect("workspace-changed", () => { Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id()); windowManager.handleWindowChangedWorkspace(this); }), - this._window.connect("position-changed", (_metaWindow) => { + this._window.connect("position-changed", () => { + windowManager.handleWindowPositionChanged(this); + }), + this._window.connect("size-changed", () => { windowManager.handleWindowPositionChanged(this); }), ); } disconnectWindowSignals(): void { - if (this._signals) { this._signals.forEach(signal => { try { @@ -117,37 +106,36 @@ export class WindowWrapper { } } - safelyResizeWindow(rect: Rect, _retry: number = 2): void { - // Keep minimal logging + safelyResizeWindow(rect: Rect, _retry: number = 3): void { if (this._dragging) { - Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED") + 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(); + const actor = this._window.get_compositor_private() as Clutter.Actor | null; 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") + + actor.remove_all_transitions(); 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); + + const new_rect = this._window.get_frame_rect(); + const mismatch = + Math.abs(new_rect.x - rect.x) > WindowWrapper.RESIZE_TOLERANCE || + Math.abs(new_rect.y - rect.y) > WindowWrapper.RESIZE_TOLERANCE || + Math.abs(new_rect.width - rect.width) > WindowWrapper.RESIZE_TOLERANCE || + Math.abs(new_rect.height - rect.height) > WindowWrapper.RESIZE_TOLERANCE; + + if (_retry > 0 && mismatch) { + Logger.warn("RESIZE MISMATCH, retrying", + `want(${rect.x},${rect.y},${rect.width},${rect.height})`, + `got(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`); queueEvent({ - name: "attempting_delayed_resize", - callback: () => { - this.safelyResizeWindow(rect, _retry-1); - } - }) + name: `delayed_resize_${this.getWindowId()}`, + callback: () => this.safelyResizeWindow(rect, _retry - 1), + }, 50); } } - - } diff --git a/src/wm/windowManager.ts b/src/wm/windowManager.ts index d9ce26d..fb9906b 100644 --- a/src/wm/windowManager.ts +++ b/src/wm/windowManager.ts @@ -1,20 +1,17 @@ import Meta from "gi://Meta"; -// import Gio from "gi://Gio"; -// import GLib from "gi://GLib"; +import Gio from "gi://Gio"; 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"; import WindowContainer from "./container.js"; +import {Rect} from "../utils/rect.js"; export interface IWindowManager { _activeWindowId: number | null; - // addWindow(window: Meta.Window): void; - handleWindowClosed(winWrap: WindowWrapper): void; handleWindowMinimized(winWrap: WindowWrapper): void; @@ -29,8 +26,8 @@ export interface IWindowManager { } -const _UNUSED_MONITOR_ID = -1 -const _UNUSED_WINDOW_ID = -1 +const _UNUSED_MONITOR_ID = -1; +const _UNUSED_WINDOW_ID = -1; export default class WindowManager implements IWindowManager { _displaySignals: number[] = []; @@ -40,23 +37,29 @@ export default class WindowManager implements IWindowManager { _activeWindowId: number | null = null; _monitors: Map = new Map(); - _minimizedItems: Map = new Map(); _grabbedWindowMonitor: number = _UNUSED_MONITOR_ID; _grabbedWindowId: number = _UNUSED_WINDOW_ID; _changingGrabbedMonitor: boolean = false; - _showingOverview: boolean = false; - constructor() { + // ── Resize-drag tracking ────────────────────────────────────────────────── + _isResizeDrag: boolean = false; + _resizeDragWindowId: number = _UNUSED_WINDOW_ID; + _resizeDragOp: Meta.GrabOp = Meta.GrabOp.NONE; + _resizeDragLastMouseX: number = 0; + _resizeDragLastMouseY: number = 0; + _isTiling: boolean = false; + private readonly _settings: Gio.Settings; + constructor(settings: Gio.Settings) { + this._settings = settings; } public enable(): void { Logger.log("Starting Aerospike Window Manager"); - // Connect window signals this.instantiateDisplaySignals(); const mon_count = global.display.get_n_monitors(); @@ -65,8 +68,6 @@ export default class WindowManager implements IWindowManager { } this.captureExistingWindows(); - - // Sync the initially focused window this.syncActiveWindow(); } @@ -93,7 +94,6 @@ export default class WindowManager implements IWindowManager { global.display.connect('notify::focus-window', () => { this.syncActiveWindow(); }), - global.display.connect("showing-desktop-changed", () => { Logger.log("SHOWING DESKTOP CHANGED"); }), @@ -104,13 +104,7 @@ export default class WindowManager implements IWindowManager { 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", () => { @@ -135,45 +129,31 @@ export default class WindowManager implements IWindowManager { 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 { - // Disconnect signals from minimized windows before clearing this.disconnectMinimizedSignals(); this._minimizedItems.clear(); - this._monitors.forEach((monitor: Monitor) => { monitor.removeAllWindows(); }) } - disconnectSignals(): void { this.disconnectDisplaySignals(); this.disconnectMonitorSignals(); @@ -207,35 +187,61 @@ export default class WindowManager implements IWindowManager { }) } + _isResizeOp(op: Meta.GrabOp): boolean { + 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; + } 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(); + + if (this._isResizeOp(op)) { + Logger.log("Resize drag begin, op=", op); + this._isResizeDrag = true; + this._resizeDragWindowId = window.get_id(); + this._resizeDragOp = op; + const [startMouseX, startMouseY] = global.get_pointer(); + this._resizeDragLastMouseX = startMouseX; + this._resizeDragLastMouseY = startMouseY; + this._getWrappedWindow(window)?.startDragging(); + } else { + 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()); + + if (this._isResizeDrag) { + Logger.log("Resize drag end, op=", op); + this._isResizeDrag = false; + this._resizeDragWindowId = _UNUSED_WINDOW_ID; + this._resizeDragLastMouseX = 0; + this._resizeDragLastMouseY = 0; + this._resizeDragOp = Meta.GrabOp.NONE; + this._getWrappedWindow(window)?.stopDragging(); + this._tileMonitors(); + } else { + 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: WindowWrapper | undefined = undefined; for (const monitor of this._monitors.values()) { wrapped = monitor.getWindow(window.get_id()); - if (wrapped !== undefined) { - break; - } + if (wrapped !== undefined) break; } return wrapped; } @@ -265,9 +271,13 @@ export default class WindowManager implements IWindowManager { } public handleWindowPositionChanged(winWrap: WindowWrapper): void { - if (this._changingGrabbedMonitor) { + if (this._isTiling || this._changingGrabbedMonitor) return; + + if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) { + this._handleResizeDragUpdate(winWrap); return; } + if (winWrap.getWindowId() === this._grabbedWindowId) { const [mouseX, mouseY, _] = global.get_pointer(); @@ -280,19 +290,82 @@ export default class WindowManager implements IWindowManager { break; } } - if (monitorIndex === -1) { - return - } + if (monitorIndex === -1) return; if (monitorIndex !== this._grabbedWindowMonitor) { this._changingGrabbedMonitor = true; this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex); - this._changingGrabbedMonitor = false + this._changingGrabbedMonitor = false; + } + + this._isTiling = true; + try { + this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY); + } finally { + this._isTiling = false; } - this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY); } } + private _handleResizeDragUpdate(winWrap: WindowWrapper): void { + const op = this._resizeDragOp; + const winId = winWrap.getWindowId(); + + const [mouseX, mouseY] = global.get_pointer(); + const dx = mouseX - this._resizeDragLastMouseX; + const dy = mouseY - this._resizeDragLastMouseY; + + if (dx === 0 && dy === 0) return; + + this._resizeDragLastMouseX = mouseX; + this._resizeDragLastMouseY = mouseY; + + const container = this._findContainerForWindowAcrossMonitors(winId); + if (!container) { + Logger.warn("_handleResizeDragUpdate: no container found for window", winId); + return; + } + + const itemIndex = container._getIndexOfWindow(winId); + if (itemIndex === -1) return; + + const isHorizontal = container._orientation === 0; + + // E/S edge → boundary after the item; W/N edge → boundary before it. + let adjusted = false; + if (isHorizontal) { + if (op === Meta.GrabOp.RESIZING_E || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_SE) { + adjusted = container.adjustBoundary(itemIndex, dx); + } else if (op === Meta.GrabOp.RESIZING_W || op === Meta.GrabOp.RESIZING_NW || op === Meta.GrabOp.RESIZING_SW) { + adjusted = container.adjustBoundary(itemIndex - 1, dx); + } + } else { + if (op === Meta.GrabOp.RESIZING_S || op === Meta.GrabOp.RESIZING_SE || op === Meta.GrabOp.RESIZING_SW) { + adjusted = container.adjustBoundary(itemIndex, dy); + } else if (op === Meta.GrabOp.RESIZING_N || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_NW) { + adjusted = container.adjustBoundary(itemIndex - 1, dy); + } + } + + if (adjusted) { + this._isTiling = true; + try { + container.tileWindows(); + } finally { + this._isTiling = false; + } + } + } + + private _findContainerForWindowAcrossMonitors(winId: number): WindowContainer | null { + const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index(); + for (const monitor of this._monitors.values()) { + if (activeWorkspaceIndex >= monitor._workspaces.length) continue; + const container = monitor._workspaces[activeWorkspaceIndex].getContainerForWindow(winId); + if (container !== null) return container; + } + return null; + } public handleWindowMinimized(winWrap: WindowWrapper): void { const monitor_id = winWrap.getWindow().get_monitor() @@ -307,7 +380,6 @@ export default class WindowManager implements IWindowManager { this._tileMonitors() } - public handleWindowChangedWorkspace(winWrap: WindowWrapper): void { const monitor = winWrap.getWindow().get_monitor(); this._monitors.get(monitor)?.removeWindow(winWrap); @@ -326,41 +398,26 @@ export default class WindowManager implements IWindowManager { this._tileMonitors(); } - handleWindowCreated(display: Meta.Display, window: Meta.Window) { Logger.log("WINDOW CREATED ON DISPLAY", window, display); - if (!this._isWindowTileable(window)) { - return; - } + 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, (winWrap) => this.handleWindowMinimized(winWrap)) wrapper.connectWindowSignals(this); this._addWindowWrapperToMonitor(wrapper); - } _addWindowWrapperToMonitor(winWrap: WindowWrapper) { @@ -372,9 +429,13 @@ export default class WindowManager implements IWindowManager { } _tileMonitors(): void { - - for (const monitor of this._monitors.values()) { - monitor.tileWindows() + this._isTiling = true; + try { + for (const monitor of this._monitors.values()) { + monitor.tileWindows(); + } + } finally { + this._isTiling = false; } } @@ -382,7 +443,7 @@ export default class WindowManager implements IWindowManager { "org.gnome.Shell.Extensions", ] - _isWindowTilingBlocked(window: Meta.Window) : boolean { + _isWindowTilingBlocked(window: Meta.Window): boolean { Logger.info("title", window.get_title()); Logger.info("description", window.get_description()); Logger.info("class", window.get_wm_class()); @@ -397,17 +458,12 @@ export default class WindowManager implements IWindowManager { } _isWindowTileable(window: Meta.Window) { + if (!window || !window.get_compositor_private()) return false; + if (this._isWindowTilingBlocked(window)) return false; - 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 && @@ -417,14 +473,6 @@ export default class WindowManager implements IWindowManager { 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 { const focusWindow = global.display.focus_window; if (focusWindow) { @@ -437,83 +485,33 @@ export default class WindowManager implements IWindowManager { return this._activeWindowId; } - /** - * Toggles the orientation of the active container (the container holding the active window) - */ public toggleActiveContainerOrientation(): void { if (this._activeWindowId === null) { Logger.warn("No active window, cannot toggle container orientation"); return; } - - // Find the active window's container - const activeContainer = this._findActiveContainer(); - if (activeContainer) { - activeContainer.toggleOrientation(); + const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId); + if (container) { + container.toggleOrientation(); } else { Logger.warn("Could not find container for active window"); } } - /** - * Finds the container that directly contains the active window - * @returns The container holding the active window, or null if not found - */ - private _findActiveContainer(): WindowContainer | null { + public resetActiveContainerRatios(): void { if (this._activeWindowId === null) { - return null; + Logger.warn("No active window, cannot reset container ratios"); + return; } - - for (const monitor of this._monitors.values()) { - const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index(); - - // Bounds check to prevent accessing invalid workspace - if (activeWorkspaceIndex >= monitor._workspaces.length || activeWorkspaceIndex < 0) { - Logger.warn(`Active workspace index ${activeWorkspaceIndex} out of bounds for monitor with ${monitor._workspaces.length} workspaces`); - continue; - } - - const workspace = monitor._workspaces[activeWorkspaceIndex]; - - // Check if the window is directly in the workspace container - const windowWrapper = workspace.getWindow(this._activeWindowId); - if (windowWrapper) { - // Try to find the parent container - const container = this._findContainerHoldingWindow(workspace, this._activeWindowId); - return container; - } + const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId); + if (container) { + Logger.info("Resetting container ratios to equal splits"); + container.resetRatios(); + } else { + Logger.warn("Could not find container for active window"); } - - return null; } - /** - * Recursively finds the container that directly contains a specific window - * @param container The container to search - * @param windowId The window ID to find - * @returns The container that directly contains the window, or null if not found - */ - private _findContainerHoldingWindow(container: WindowContainer, windowId: number): WindowContainer | null { - // Check if this container directly contains the window - for (const item of container._tiledItems) { - if (item instanceof WindowContainer) { - // Recursively search nested containers - const result = this._findContainerHoldingWindow(item, windowId); - if (result) { - return result; - } - } else if (item.getWindowId() === windowId) { - // Found it! Return this container as it directly holds the window - return container; - } - } - - return null; - } - - /** - * Prints the tree structure of all monitors, workspaces, containers, and windows to the logs - */ public printTreeStructure(): void { Logger.info("=".repeat(80)); Logger.info("WINDOW TREE STRUCTURE"); @@ -526,19 +524,15 @@ export default class WindowManager implements IWindowManager { this._monitors.forEach((monitor: Monitor, monitorId: number) => { const isActiveMonitor = this._activeWindowId !== null && monitor.getWindow(this._activeWindowId) !== undefined; - const monitorMarker = isActiveMonitor ? ' *' : ''; - Logger.info(`Monitor ${monitorId}${monitorMarker}:`); + Logger.info(`Monitor ${monitorId}${isActiveMonitor ? ' *' : ''}:`); Logger.info(` Work Area: x=${monitor._workArea.x}, y=${monitor._workArea.y}, w=${monitor._workArea.width}, h=${monitor._workArea.height}`); monitor._workspaces.forEach((workspace, workspaceIndex) => { const isActiveWorkspace = workspaceIndex === activeWorkspaceIndex; - const workspaceMarker = isActiveWorkspace && isActiveMonitor ? ' *' : ''; - - Logger.info(` Workspace ${workspaceIndex}${workspaceMarker}:`); + Logger.info(` Workspace ${workspaceIndex}${isActiveWorkspace && isActiveMonitor ? ' *' : ''}:`); Logger.info(` Orientation: ${workspace._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'}`); Logger.info(` Items: ${workspace._tiledItems.length}`); - this._printContainerTree(workspace, 4); }); }); @@ -546,31 +540,20 @@ export default class WindowManager implements IWindowManager { Logger.info("=".repeat(80)); } - /** - * Recursively prints the container tree structure - * @param container The container to print - * @param indentLevel The indentation level (number of spaces) - */ - private _printContainerTree(container: any, indentLevel: number): void { + private _printContainerTree(container: WindowContainer, indentLevel: number): void { const indent = " ".repeat(indentLevel); - container._tiledItems.forEach((item: any, index: number) => { + container._tiledItems.forEach((item, index) => { if (item instanceof WindowContainer) { - // Check if this container contains the active window - const containsActiveWindow = this._activeWindowId !== null && - item.getWindow(this._activeWindowId) !== undefined; - const containerMarker = containsActiveWindow ? ' *' : ''; - - Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containerMarker}:`); + const containsActive = this._activeWindowId !== null && + item.getWindow(this._activeWindowId) !== undefined; + Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containsActive ? ' *' : ''}:`); Logger.info(`${indent} Items: ${item._tiledItems.length}`); Logger.info(`${indent} Work Area: x=${item._workArea.x}, y=${item._workArea.y}, w=${item._workArea.width}, h=${item._workArea.height}`); this._printContainerTree(item, indentLevel + 4); } else { const window = item.getWindow(); - const isActiveWindow = this._activeWindowId === item.getWindowId(); - const windowMarker = isActiveWindow ? ' *' : ''; - - Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${windowMarker}`); + Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${this._activeWindowId === item.getWindowId() ? ' *' : ''}`); Logger.info(`${indent} Title: "${window.get_title()}"`); Logger.info(`${indent} Class: ${window.get_wm_class()}`); const rect = item.getRect(); @@ -578,6 +561,4 @@ export default class WindowManager implements IWindowManager { } }); } - - }