feat: adding support for changing the size of windows during window resize events to aerospike. Also cleaning up imports and simplifying some of the settings logic.

2026-02-25 11:33:12 -05:00
parent 3d2da0a4bc
commit 4be7602316
8 changed files with 388 additions and 409 deletions
--- 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<number, WindowWrapper>;
    _orientation: Orientation = Orientation.HORIZONTAL;
    _workArea: Rect;
+    _splitRatios: number[];

-    constructor(workspaceArea: Rect,) {
+    constructor(workspaceArea: Rect) {
        this._tiledItems = [];
        this._tiledWindowLookup = new Map<number, WindowWrapper>();
        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();
+        }
    }

-
-}
+    resetRatios(): void {
+        this._resetRatios();
+        this.tileWindows();
+    }
+}