lucasoskorep/aerospike-gnome
1
0
Fork 0
Code Issues 3 Pull Requests 2 Actions Packages Projects Releases 3 Wiki Activity

refactor: code review cleanup pass
All checks were successful
Build and Test / build (pull_request) Successful in 23s
Details
Build and Test / release (pull_request) Has been skipped
Details

Browse Source 
- Collapse getHorizontalBounds/getVerticalBounds into _computeBounds(axis)
- Delete dead adjustBoundaryBothAxes method
- Collapse double-loop in getContainerForWindow into one pass
- Remove _findActiveContainer/_findContainerHoldingWindow duplication;
  call _findContainerForWindowAcrossMonitors directly
- Pass Gio.Settings via WindowManager constructor instead of public field
- Introduce keybindingActions() in extension.ts to unify setupKeybindings
  and refreshKeybinding; collapse 7-block bindSettings pattern into a loop
- Promote WindowWrapper.RESIZE_TOLERANCE to private static readonly
- Simplify redundant else-if in minimized handler
- Remove unused imports in monitor.ts (queueEvent, Mtk, Window alias)
- Deduplicate get_active_workspace() call in monitor.tileWindows()
- Strip redundant JSDoc and inline comments throughout
This commit is contained in:
Lucas Oskorep
2026-02-25 11:24:13 -05:00
parent 241f90299c
commit 22c9851886
6 changed files with 116 additions and 529 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
extension.ts
View File

@@ -15,12 +15,11 @@ export default class aerospike extends Extension {
super(metadata); super(metadata);
this.settings = this.getSettings('org.gnome.shell.extensions.aerospike'); this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
this.keyBindings = new Map(); this.keyBindings = new Map();
this.windowManager = new WindowManager(); this.windowManager = new WindowManager(this.settings);
} }
enable() { enable() {
Logger.log("STARTING AEROSPIKE!") Logger.log("STARTING AEROSPIKE!")
this.windowManager._settings = this.settings;
this.bindSettings(); this.bindSettings();
this.setupKeybindings(); this.setupKeybindings();
this.windowManager.enable() this.windowManager.enable()
@@ -31,42 +30,25 @@ export default class aerospike extends Extension {
this.removeKeybindings() this.removeKeybindings()
} }
private keybindingActions(): Record<string, () => 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() { private bindSettings() {
// Monitor settings changes const keybindings = Object.keys(this.keybindingActions());
this.settings.connect('changed::move-left', () => { keybindings.forEach(name => {
log(`Keybinding 1 changed to: ${this.settings.get_strv('move-left')}`); this.settings.connect(`changed::${name}`, () => {
this.refreshKeybinding('move-left'); log(`${name} keybinding changed to: ${this.settings.get_strv(name)}`);
}); this.refreshKeybinding(name);
});
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');
});
this.settings.connect('changed::reset-ratios', () => {
log(`Reset ratios keybinding changed to: ${this.settings.get_strv('reset-ratios')}`);
this.refreshKeybinding('reset-ratios');
}); });
this.settings.connect('changed::dropdown-option', () => { this.settings.connect('changed::dropdown-option', () => {
@@ -77,49 +59,15 @@ export default class aerospike extends Extension {
log(`Color selection changed to: ${this.settings.get_string('color-selection')}`); log(`Color selection changed to: ${this.settings.get_string('color-selection')}`);
}); });
} }
private refreshKeybinding(settingName: string) { private refreshKeybinding(settingName: string) {
if (this.keyBindings.has(settingName)) { if (this.keyBindings.has(settingName)) {
Main.wm.removeKeybinding(settingName); Main.wm.removeKeybinding(settingName);
this.keyBindings.delete(settingName); this.keyBindings.delete(settingName);
} }
switch (settingName) { const action = this.keybindingActions()[settingName];
case 'move-left': if (action) this.bindKeybinding(settingName, action);
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;
case 'reset-ratios':
this.bindKeybinding('reset-ratios', () => {
this.windowManager.resetActiveContainerRatios();
});
break;
}
} }
private removeKeybindings() { private removeKeybindings() {
@@ -130,33 +78,10 @@ export default class aerospike extends Extension {
} }
private setupKeybindings() { private setupKeybindings() {
this.bindKeybinding('move-left', () => { const actions = this.keybindingActions();
Logger.info('Keybinding 1 was pressed!'); for (const [name, action] of Object.entries(actions)) {
}); this.bindKeybinding(name, action);
}
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();
});
this.bindKeybinding('reset-ratios', () => {
this.windowManager.resetActiveContainerRatios();
});
} }
private bindKeybinding(settingName: string, callback: () => void) { private bindKeybinding(settingName: string, callback: () => void) {
@@ -176,7 +101,4 @@ export default class aerospike extends Extension {
this.keyBindings.set(settingName, keyBindingAction); this.keyBindings.set(settingName, keyBindingAction);
} }
} }

7
src/utils/events.ts
View File

@@ -1,25 +1,18 @@
import GLib from "gi://GLib"; import GLib from "gi://GLib";
export type QueuedEvent = { export type QueuedEvent = {
name: string; name: string;
callback: () => void; callback: () => void;
} }
// Pending events indexed by name so that duplicate events collapse into one.
// Only the most-recently-queued callback for a given name is kept.
const pendingEvents: Map<string, QueuedEvent> = new Map(); const pendingEvents: Map<string, QueuedEvent> = new Map();
export default function queueEvent(event: QueuedEvent, interval = 200) { export default function queueEvent(event: QueuedEvent, interval = 200) {
// Overwrite any earlier pending event with the same name — the latest
// callback is always the most up-to-date one.
pendingEvents.set(event.name, event); pendingEvents.set(event.name, event);
GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => { GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
const e = pendingEvents.get(event.name); const e = pendingEvents.get(event.name);
if (e && e === event) { if (e && e === event) {
// Only fire if this is still the current callback for this name
// (a newer call may have replaced it).
pendingEvents.delete(event.name); pendingEvents.delete(event.name);
e.callback(); e.callback();
} }

171
src/wm/container.ts
View File

@@ -1,6 +1,5 @@
import {WindowWrapper} from "./window.js"; 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";
@@ -9,35 +8,22 @@ enum Orientation {
VERTICAL = 1, VERTICAL = 1,
} }
/** // Returns equal ratios summing exactly to 1.0, with float drift absorbed by the last slot.
* Build a split-ratio array of length `n` where every element equals 1/n,
* with the last slot absorbing any floating-point remainder so the array
* always sums to exactly 1.0.
*/
function equalRatios(n: number): number[] { function equalRatios(n: number): number[] {
if (n <= 0) return []; if (n <= 0) return [];
const base = 1 / n; const base = 1 / n;
const ratios = Array(n).fill(base); const ratios = Array(n).fill(base);
// Fix floating-point drift: make last slot exact
const sumExceptLast = ratios.slice(0, -1).reduce((a, b) => a + b, 0); const sumExceptLast = ratios.slice(0, -1).reduce((a, b) => a + b, 0);
ratios[n - 1] = 1 - sumExceptLast; ratios[n - 1] = 1 - sumExceptLast;
return ratios; return ratios;
} }
export default class WindowContainer { export default class WindowContainer {
_tiledItems: (WindowWrapper | WindowContainer)[]; _tiledItems: (WindowWrapper | WindowContainer)[];
_tiledWindowLookup: Map<number, WindowWrapper>; _tiledWindowLookup: Map<number, WindowWrapper>;
_orientation: Orientation = Orientation.HORIZONTAL; _orientation: Orientation = Orientation.HORIZONTAL;
_workArea: Rect; _workArea: Rect;
/**
* Per-child split ratios. Always satisfies:
* _splitRatios.length === _tiledItems.length
* _splitRatios.reduce((a,b) => a+b, 0) === 1.0 (within floating-point epsilon)
* every element >= MIN_RATIO
*/
_splitRatios: number[]; _splitRatios: number[];
constructor(workspaceArea: Rect) { constructor(workspaceArea: Rect) {
@@ -49,20 +35,10 @@ export default class WindowContainer {
// ─── Helpers ──────────────────────────────────────────────────────────────── // ─── Helpers ────────────────────────────────────────────────────────────────
/** Rebuild _splitRatios as equal fractions after any structural change. */
private _resetRatios(): void { private _resetRatios(): void {
this._splitRatios = equalRatios(this._tiledItems.length); this._splitRatios = equalRatios(this._tiledItems.length);
} }
/**
* Called after a new item has been pushed onto _tiledItems.
* The new window (last slot) gets 1/n of the space; existing windows
* are scaled down proportionally so their ratios relative to each other
* are preserved and the total remains 1.0.
*
* e.g. [0.33, 0.166, 0.5] + new → new=0.25, existing scaled by 0.75
* → [0.2475, 0.1245, 0.375, 0.25]
*/
private _addRatioForNewWindow(): void { private _addRatioForNewWindow(): void {
const n = this._tiledItems.length; const n = this._tiledItems.length;
if (n <= 1) { if (n <= 1) {
@@ -70,15 +46,13 @@ export default class WindowContainer {
return; return;
} }
const newRatio = 1 / n; const newRatio = 1 / n;
const scale = 1 - newRatio; // existing windows share this fraction const scale = 1 - newRatio;
const scaled = this._splitRatios.map(r => r * scale); const scaled = this._splitRatios.map(r => r * scale);
// Absorb all floating-point drift into the last slot so sum is exactly 1.0
const partialSum = scaled.reduce((a, b) => a + b, 0) + newRatio; const partialSum = scaled.reduce((a, b) => a + b, 0) + newRatio;
scaled[scaled.length - 1] += (1.0 - partialSum); scaled[scaled.length - 1] += (1.0 - partialSum);
this._splitRatios = [...scaled, newRatio]; this._splitRatios = [...scaled, newRatio];
} }
/** Total dimension for the active orientation (width for H, height for V). */
private _totalDimension(): number { private _totalDimension(): number {
return this._orientation === Orientation.HORIZONTAL return this._orientation === Orientation.HORIZONTAL
? this._workArea.width ? this._workArea.width
@@ -106,9 +80,7 @@ export default class WindowContainer {
this._addRatioForNewWindow(); this._addRatioForNewWindow();
queueEvent({ queueEvent({
name: "tiling-windows", name: "tiling-windows",
callback: () => { callback: () => this.tileWindows(),
this.tileWindows();
}
}, 100); }, 100);
} }
@@ -119,9 +91,7 @@ export default class WindowContainer {
for (const item of this._tiledItems) { for (const item of this._tiledItems) {
if (item instanceof WindowContainer) { if (item instanceof WindowContainer) {
const win = item.getWindow(win_id); const win = item.getWindow(win_id);
if (win) { if (win) return win;
return win;
}
} else if (item.getWindowId() === win_id) { } else if (item.getWindowId() === win_id) {
return item; return item;
} }
@@ -173,17 +143,15 @@ export default class WindowContainer {
this._splitRatios = []; this._splitRatios = [];
} }
tileWindows() { tileWindows(): void {
Logger.log("TILING WINDOWS IN CONTAINER"); Logger.log("TILING WINDOWS IN CONTAINER");
Logger.log("WorkArea", this._workArea); Logger.log("WorkArea", this._workArea);
this._tileItems(); this._tileItems();
return true;
} }
_tileItems() { _tileItems() {
if (this._tiledItems.length === 0) { if (this._tiledItems.length === 0) return;
return;
}
const bounds = this.getBounds(); 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(', ')}]`); 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) => { this._tiledItems.forEach((item, index) => {
@@ -200,71 +168,33 @@ export default class WindowContainer {
// ─── Bounds Calculation ────────────────────────────────────────────────────── // ─── Bounds Calculation ──────────────────────────────────────────────────────
getBounds(): Rect[] { getBounds(): Rect[] {
if (this._orientation === Orientation.HORIZONTAL) { return this._orientation === Orientation.HORIZONTAL
return this.getHorizontalBounds(); ? this._computeBounds('horizontal')
} : this._computeBounds('vertical');
return this.getVerticalBounds();
} }
getVerticalBounds(): Rect[] { private _computeBounds(axis: 'horizontal' | 'vertical'): Rect[] {
const items = this._tiledItems; const isHorizontal = axis === 'horizontal';
const totalHeight = this._workArea.height; const total = isHorizontal ? this._workArea.width : this._workArea.height;
let usedHeight = 0; let used = 0;
return items.map((_, index) => {
const y = this._workArea.y + usedHeight;
let height: number;
if (index === items.length - 1) {
// Last item gets the remainder to avoid pixel gaps from rounding
height = totalHeight - usedHeight;
} else {
height = Math.floor(this._splitRatios[index] * totalHeight);
}
usedHeight += height;
return {
x: this._workArea.x,
y: y,
width: this._workArea.width,
height: height,
} as Rect;
});
}
getHorizontalBounds(): Rect[] {
const totalWidth = this._workArea.width;
let usedWidth = 0;
return this._tiledItems.map((_, index) => { return this._tiledItems.map((_, index) => {
const x = this._workArea.x + usedWidth; const offset = used;
let width: number; const size = index === this._tiledItems.length - 1
if (index === this._tiledItems.length - 1) { ? total - used
// Last item gets the remainder to avoid pixel gaps from rounding : Math.floor(this._splitRatios[index] * total);
width = totalWidth - usedWidth; used += size;
} else {
width = Math.floor(this._splitRatios[index] * totalWidth); return isHorizontal
} ? { x: this._workArea.x + offset, y: this._workArea.y, width: size, height: this._workArea.height }
usedWidth += width; : { x: this._workArea.x, y: this._workArea.y + offset, width: this._workArea.width, height: size };
return {
x: x,
y: this._workArea.y,
width: width,
height: this._workArea.height,
} as Rect;
}); });
} }
// ─── Boundary / Ratio Adjustment ───────────────────────────────────────────── // ─── Boundary Adjustment ─────────────────────────────────────────────────────
/** // Shifts the boundary between item[boundaryIndex] and item[boundaryIndex+1] by
* Adjust the boundary between item[boundaryIndex] and item[boundaryIndex+1] // deltaPixels. Returns false if the delta would violate minRatio on either side.
* by deltaPixels (positive = move right/down, negative = move left/up).
*
* Both affected ratios are clamped to [_minRatio, 1 - _minRatio] so no
* window can be squashed below the configured minimum.
*
* Returns true if the adjustment was applied, false if it was rejected
* (e.g. out of bounds index or clamping would violate minimum).
*/
adjustBoundary(boundaryIndex: number, deltaPixels: number, minRatio: number = 0.10): boolean { adjustBoundary(boundaryIndex: number, deltaPixels: number, minRatio: number = 0.10): boolean {
if (boundaryIndex < 0 || boundaryIndex >= this._tiledItems.length - 1) { if (boundaryIndex < 0 || boundaryIndex >= this._tiledItems.length - 1) {
Logger.warn(`adjustBoundary: invalid boundaryIndex ${boundaryIndex}`); Logger.warn(`adjustBoundary: invalid boundaryIndex ${boundaryIndex}`);
@@ -275,9 +205,8 @@ export default class WindowContainer {
if (totalDim === 0) return false; if (totalDim === 0) return false;
const ratioDelta = deltaPixels / totalDim; const ratioDelta = deltaPixels / totalDim;
const newLeft = this._splitRatios[boundaryIndex] + ratioDelta;
const newLeft = this._splitRatios[boundaryIndex] + ratioDelta; const newRight = this._splitRatios[boundaryIndex + 1] - ratioDelta;
const newRight = this._splitRatios[boundaryIndex + 1] - ratioDelta;
if (newLeft < minRatio || newRight < minRatio) { if (newLeft < minRatio || newRight < minRatio) {
Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}, min=${minRatio}`); Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}, min=${minRatio}`);
@@ -291,38 +220,13 @@ export default class WindowContainer {
return true; return true;
} }
/**
* Adjust boundaries on BOTH axes simultaneously for corner resize ops.
* horizontalDelta applies to this container if HORIZONTAL, verticalDelta if VERTICAL.
* For nested containers the perpendicular delta is forwarded to the child container.
*
* boundaryIndex: the slot index whose right/bottom edge is being dragged.
*/
adjustBoundaryBothAxes(
boundaryIndex: number,
horizontalDelta: number,
verticalDelta: number,
): void {
if (this._orientation === Orientation.HORIZONTAL) {
this.adjustBoundary(boundaryIndex, horizontalDelta);
} else {
this.adjustBoundary(boundaryIndex, verticalDelta);
}
}
// ─── Container Lookup ──────────────────────────────────────────────────────── // ─── Container Lookup ────────────────────────────────────────────────────────
/**
* Returns the direct-parent WindowContainer that contains win_id as an
* immediate child (not recursed further). Returns null if not found.
*/
getContainerForWindow(win_id: number): WindowContainer | null { getContainerForWindow(win_id: number): WindowContainer | null {
for (const item of this._tiledItems) { for (const item of this._tiledItems) {
if (item instanceof WindowWrapper && item.getWindowId() === win_id) { if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
return this; return this;
} }
}
for (const item of this._tiledItems) {
if (item instanceof WindowContainer) { if (item instanceof WindowContainer) {
const found = item.getContainerForWindow(win_id); const found = item.getContainerForWindow(win_id);
if (found !== null) return found; if (found !== null) return found;
@@ -335,10 +239,7 @@ export default class WindowContainer {
for (let i = 0; i < this._tiledItems.length; i++) { for (let i = 0; i < this._tiledItems.length; i++) {
const container = this._tiledItems[i]; const container = this._tiledItems[i];
if (container instanceof WindowContainer) { if (container instanceof WindowContainer) {
const index = container.getIndexOfItemNested(item); if (container.getIndexOfItemNested(item) !== -1) return i;
if (index !== -1) {
return i;
}
} else if (container.getWindowId() === item.getWindowId()) { } else if (container.getWindowId() === item.getWindowId()) {
return i; return i;
} }
@@ -348,34 +249,28 @@ export default class WindowContainer {
// TODO: update this to work with nested containers - all other logic should already be working // TODO: update this to work with nested containers - all other logic should already be working
itemDragged(item: WindowWrapper, x: number, y: number): void { itemDragged(item: WindowWrapper, x: number, y: number): void {
let original_index = this.getIndexOfItemNested(item); const original_index = this.getIndexOfItemNested(item);
if (original_index === -1) { if (original_index === -1) {
Logger.error("Item not found in container during drag op", item.getWindowId()); Logger.error("Item not found in container during drag op", item.getWindowId());
return; return;
} }
let new_index = original_index; let new_index = original_index;
this.getBounds().forEach((rect, index) => { this.getBounds().forEach((rect, index) => {
if (rect.x < x && rect.x + rect.width > x && rect.y < y && rect.y + rect.height > y) { if (rect.x < x && rect.x + rect.width > x && rect.y < y && rect.y + rect.height > y) {
new_index = index; new_index = index;
} }
}); });
if (original_index !== new_index) { if (original_index !== new_index) {
// Swap only the items — ratios stay with their slots. Logger.info(`itemDragged: swapped slots ${original_index}<->${new_index}, ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
// e.g. slot 0 = 40%, slot 1 = 60%: when the window in slot 1 drags
// into slot 0, it takes slot 0's 40% size. The window it displaces
// moves to slot 1 and takes the 60% size. The slot ratios are unchanged.
[this._tiledItems[original_index], this._tiledItems[new_index]] = [this._tiledItems[original_index], this._tiledItems[new_index]] =
[this._tiledItems[new_index], this._tiledItems[original_index]]; [this._tiledItems[new_index], this._tiledItems[original_index]];
Logger.info(`itemDragged: swapped slots ${original_index}<->${new_index}, ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
this.tileWindows(); this.tileWindows();
} }
} }
/**
* Reset all split ratios in this container to equal fractions.
* Called when the user explicitly requests an equal-split reset (e.g. Ctrl+Z).
*/
resetRatios(): void { resetRatios(): void {
this._resetRatios(); this._resetRatios();
this.tileWindows(); this.tileWindows();

17
src/wm/monitor.ts
View File

@@ -1,12 +1,9 @@
import {WindowWrapper} from "./window.js"; import {WindowWrapper} from "./window.js";
import {Rect} from "../utils/rect.js"; import {Rect} from "../utils/rect.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 Meta from "gi://Meta";
import Mtk from "@girs/mtk-17";
import WindowContainer from "./container.js"; import WindowContainer from "./container.js";
import Window = Meta.Window;
export default class Monitor { export default class Monitor {
@@ -20,7 +17,7 @@ export default class Monitor {
this._workArea = workspace.get_work_area_for_monitor(this._id); this._workArea = workspace.get_work_area_for_monitor(this._id);
Logger.log("CREATING MONITOR", monitorId); Logger.log("CREATING MONITOR", monitorId);
Logger.log("WorkArea", this._workArea.x, this._workArea.y, this._workArea.width, this._workArea.height); 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); Logger.log("Workspace Count", workspaceCount);
for (let i = 0; i < workspaceCount; i++) { for (let i = 0; i < workspaceCount; i++) {
this._workspaces.push(new WindowContainer(this._workArea)); this._workspaces.push(new WindowContainer(this._workArea));
@@ -42,9 +39,7 @@ export default class Monitor {
getWindow(windowId: number): WindowWrapper | undefined { getWindow(windowId: number): WindowWrapper | undefined {
for (const container of this._workspaces) { for (const container of this._workspaces) {
const win = container.getWindow(windowId); const win = container.getWindow(windowId);
if (win) { if (win) return win;
return win;
}
} }
return undefined; return undefined;
} }
@@ -52,8 +47,7 @@ export default class Monitor {
removeWindow(winWrap: WindowWrapper) { removeWindow(winWrap: WindowWrapper) {
const windowId = winWrap.getWindowId(); const windowId = winWrap.getWindowId();
for (const container of this._workspaces) { for (const container of this._workspaces) {
const win = container.getWindow(windowId); if (container.getWindow(windowId)) {
if (win) {
container.removeWindow(windowId); container.removeWindow(windowId);
} }
} }
@@ -65,9 +59,9 @@ export default class Monitor {
} }
tileWindows(): void { 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(); const activeWorkspace = global.workspace_manager.get_active_workspace();
// move() already calls tileWindows() internally — don't call it again 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()].move(this._workArea);
} }
@@ -82,5 +76,4 @@ export default class Monitor {
itemDragged(item: WindowWrapper, x: number, y: number): void { itemDragged(item: WindowWrapper, x: number, y: number): void {
this._workspaces[item.getWorkspace()].itemDragged(item, x, y); this._workspaces[item.getWorkspace()].itemDragged(item, x, y);
} }
} }

55
src/wm/window.ts
View File

@@ -11,6 +11,8 @@ type WindowMinimizedHandler = (window: WindowWrapper) => void;
type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void; type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void;
export class WindowWrapper { export class WindowWrapper {
private static readonly RESIZE_TOLERANCE = 2;
readonly _window: Meta.Window; readonly _window: Meta.Window;
readonly _windowMinimizedHandler: WindowMinimizedHandler; readonly _windowMinimizedHandler: WindowMinimizedHandler;
readonly _signals: number[] = []; readonly _signals: number[] = [];
@@ -48,41 +50,26 @@ export class WindowWrapper {
startDragging(): void { startDragging(): void {
this._dragging = true; this._dragging = true;
} }
stopDragging(): void { stopDragging(): void {
Logger.log("STOPPED DRAGGING") Logger.log("STOPPED DRAGGING")
this._dragging = false; this._dragging = false;
} }
// setParent(parent: WindowContainer): void { connectWindowSignals(windowManager: IWindowManager): void {
// this._parent = parent; const windowId = this._window.get_id();
// }
//
// getParent(): WindowContainer | null {
// if (this._parent == null) {
// Logger.warn(`Attempting to get parent for window without parent ${JSON.stringify(this)}`);
// }
// return this._parent
// }
connectWindowSignals(
windowManager: IWindowManager,
): void {
const windowId = this._window.get_id()
// Handle window destruction
this._signals.push( this._signals.push(
this._window.connect('unmanaging', window => { this._window.connect('unmanaging', () => {
Logger.log("REMOVING WINDOW", windowId); 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) { if (this._window.minimized) {
Logger.log(`Window minimized: ${windowId}`); Logger.log(`Window minimized: ${windowId}`);
windowManager.handleWindowMinimized(this); windowManager.handleWindowMinimized(this);
} else {
} else if (!this._window.minimized) {
Logger.log(`Window unminimized: ${windowId}`); Logger.log(`Window unminimized: ${windowId}`);
windowManager.handleWindowUnminimized(this); windowManager.handleWindowUnminimized(this);
} }
}), }),
this._window.connect('notify::maximized-horizontally', () => { this._window.connect('notify::maximized-horizontally', () => {
@@ -92,21 +79,20 @@ export class WindowWrapper {
Logger.log(`Window unmaximized: ${windowId}`); 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()); Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
windowManager.handleWindowChangedWorkspace(this); windowManager.handleWindowChangedWorkspace(this);
}), }),
this._window.connect("position-changed", (_metaWindow) => { this._window.connect("position-changed", () => {
windowManager.handleWindowPositionChanged(this); windowManager.handleWindowPositionChanged(this);
}), }),
this._window.connect("size-changed", (_metaWindow) => { this._window.connect("size-changed", () => {
windowManager.handleWindowPositionChanged(this); windowManager.handleWindowPositionChanged(this);
}), }),
); );
} }
disconnectWindowSignals(): void { disconnectWindowSignals(): void {
if (this._signals) { if (this._signals) {
this._signals.forEach(signal => { this._signals.forEach(signal => {
try { try {
@@ -133,17 +119,14 @@ export class WindowWrapper {
} }
actor.remove_all_transitions(); actor.remove_all_transitions();
// Single call: move + resize atomically
this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height); this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);
const new_rect = this._window.get_frame_rect(); const new_rect = this._window.get_frame_rect();
const TOLERANCE = 2; // pixels — allow compositor rounding
const mismatch = const mismatch =
Math.abs(new_rect.x - rect.x) > TOLERANCE || Math.abs(new_rect.x - rect.x) > WindowWrapper.RESIZE_TOLERANCE ||
Math.abs(new_rect.y - rect.y) > TOLERANCE || Math.abs(new_rect.y - rect.y) > WindowWrapper.RESIZE_TOLERANCE ||
Math.abs(new_rect.width - rect.width) > TOLERANCE || Math.abs(new_rect.width - rect.width) > WindowWrapper.RESIZE_TOLERANCE ||
Math.abs(new_rect.height - rect.height) > TOLERANCE; Math.abs(new_rect.height - rect.height) > WindowWrapper.RESIZE_TOLERANCE;
if (_retry > 0 && mismatch) { if (_retry > 0 && mismatch) {
Logger.warn("RESIZE MISMATCH, retrying", Logger.warn("RESIZE MISMATCH, retrying",
@@ -151,12 +134,8 @@ export class WindowWrapper {
`got(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`); `got(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`);
queueEvent({ queueEvent({
name: `delayed_resize_${this.getWindowId()}`, name: `delayed_resize_${this.getWindowId()}`,
callback: () => { callback: () => this.safelyResizeWindow(rect, _retry - 1),
this.safelyResizeWindow(rect, _retry - 1);
}
}, 50); }, 50);
} }
} }
} }

263
src/wm/windowManager.ts
View File

@@ -1,10 +1,8 @@
import Meta from "gi://Meta"; import Meta from "gi://Meta";
import Gio from "gi://Gio"; import Gio from "gi://Gio";
// import GLib from "gi://GLib";
import {WindowWrapper} from './window.js'; import {WindowWrapper} from './window.js';
import * as Main from "resource:///org/gnome/shell/ui/main.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 {Logger} from "../utils/logger.js";
import Monitor from "./monitor.js"; import Monitor from "./monitor.js";
import WindowContainer from "./container.js"; import WindowContainer from "./container.js";
@@ -14,8 +12,6 @@ import {Rect} from "../utils/rect.js";
export interface IWindowManager { export interface IWindowManager {
_activeWindowId: number | null; _activeWindowId: number | null;
// addWindow(window: Meta.Window): void;
handleWindowClosed(winWrap: WindowWrapper): void; handleWindowClosed(winWrap: WindowWrapper): void;
handleWindowMinimized(winWrap: WindowWrapper): void; handleWindowMinimized(winWrap: WindowWrapper): void;
@@ -30,8 +26,8 @@ export interface IWindowManager {
} }
const _UNUSED_MONITOR_ID = -1 const _UNUSED_MONITOR_ID = -1;
const _UNUSED_WINDOW_ID = -1 const _UNUSED_WINDOW_ID = -1;
export default class WindowManager implements IWindowManager { export default class WindowManager implements IWindowManager {
_displaySignals: number[] = []; _displaySignals: number[] = [];
@@ -41,37 +37,33 @@ export default class WindowManager implements IWindowManager {
_activeWindowId: number | null = null; _activeWindowId: number | null = null;
_monitors: Map<number, Monitor> = new Map<number, Monitor>(); _monitors: Map<number, Monitor> = new Map<number, Monitor>();
_minimizedItems: Map<number, WindowWrapper> = new Map<number, WindowWrapper>(); _minimizedItems: Map<number, WindowWrapper> = new Map<number, WindowWrapper>();
_grabbedWindowMonitor: number = _UNUSED_MONITOR_ID; _grabbedWindowMonitor: number = _UNUSED_MONITOR_ID;
_grabbedWindowId: number = _UNUSED_WINDOW_ID; _grabbedWindowId: number = _UNUSED_WINDOW_ID;
_changingGrabbedMonitor: boolean = false; _changingGrabbedMonitor: boolean = false;
_showingOverview: boolean = false; _showingOverview: boolean = false;
// ── Resize-drag tracking ────────────────────────────────────────────────── // ── Resize-drag tracking ──────────────────────────────────────────────────
_isResizeDrag: boolean = false; _isResizeDrag: boolean = false;
_resizeDragWindowId: number = _UNUSED_WINDOW_ID; _resizeDragWindowId: number = _UNUSED_WINDOW_ID;
_resizeDragOp: Meta.GrabOp = Meta.GrabOp.NONE; _resizeDragOp: Meta.GrabOp = Meta.GrabOp.NONE;
/** Mouse position at the start of each incremental resize step. */
_resizeDragLastMouseX: number = 0; _resizeDragLastMouseX: number = 0;
_resizeDragLastMouseY: number = 0; _resizeDragLastMouseY: number = 0;
/** Re-entrancy guard: true while tileWindows is propagating position-changed events. */
_isTiling: boolean = false; _isTiling: boolean = false;
_settings: Gio.Settings | null = null; private readonly _settings: Gio.Settings;
constructor() {} constructor(settings: Gio.Settings) {
this._settings = settings;
}
/** Returns the live min-ratio value from settings, falling back to 0.10. */
private _getMinRatio(): number { private _getMinRatio(): number {
return this._settings?.get_double('min-window-size-percent') ?? 0.10; return this._settings.get_double('min-window-size-percent');
} }
public enable(): void { public enable(): void {
Logger.log("Starting Aerospike Window Manager"); Logger.log("Starting Aerospike Window Manager");
// Connect window signals
this.instantiateDisplaySignals(); this.instantiateDisplaySignals();
const mon_count = global.display.get_n_monitors(); const mon_count = global.display.get_n_monitors();
@@ -80,8 +72,6 @@ export default class WindowManager implements IWindowManager {
} }
this.captureExistingWindows(); this.captureExistingWindows();
// Sync the initially focused window
this.syncActiveWindow(); this.syncActiveWindow();
} }
@@ -108,7 +98,6 @@ export default class WindowManager implements IWindowManager {
global.display.connect('notify::focus-window', () => { global.display.connect('notify::focus-window', () => {
this.syncActiveWindow(); this.syncActiveWindow();
}), }),
global.display.connect("showing-desktop-changed", () => { global.display.connect("showing-desktop-changed", () => {
Logger.log("SHOWING DESKTOP CHANGED"); Logger.log("SHOWING DESKTOP CHANGED");
}), }),
@@ -119,13 +108,7 @@ export default class WindowManager implements IWindowManager {
global.display.connect("in-fullscreen-changed", () => { global.display.connect("in-fullscreen-changed", () => {
Logger.log("IN FULL SCREEN 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 = [ this._workspaceManagerSignals = [
global.workspace_manager.connect("showing-desktop-changed", () => { global.workspace_manager.connect("showing-desktop-changed", () => {
@@ -150,45 +133,31 @@ export default class WindowManager implements IWindowManager {
this._overviewSignals = [ this._overviewSignals = [
Main.overview.connect("hiding", () => { Main.overview.connect("hiding", () => {
// this.fromOverview = true;
Logger.log("HIDING OVERVIEW") Logger.log("HIDING OVERVIEW")
this._showingOverview = false; this._showingOverview = false;
this._tileMonitors(); this._tileMonitors();
// const eventObj = {
// name: "focus-after-overview",
// callback: () => {
// Logger.log("FOCUSING AFTER OVERVIEW");
// },
// };
// this.queueEvent(eventObj);
}), }),
Main.overview.connect("showing", () => { Main.overview.connect("showing", () => {
this._showingOverview = true; this._showingOverview = true;
Logger.log("SHOWING OVERVIEW"); Logger.log("SHOWING OVERVIEW");
}), }),
]; ];
} }
public disable(): void { public disable(): void {
Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!") Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!")
// Disconnect the focus signal and remove any existing borders
this.disconnectSignals(); this.disconnectSignals();
this.removeAllWindows(); this.removeAllWindows();
} }
removeAllWindows(): void { removeAllWindows(): void {
// Disconnect signals from minimized windows before clearing
this.disconnectMinimizedSignals(); this.disconnectMinimizedSignals();
this._minimizedItems.clear(); this._minimizedItems.clear();
this._monitors.forEach((monitor: Monitor) => { this._monitors.forEach((monitor: Monitor) => {
monitor.removeAllWindows(); monitor.removeAllWindows();
}) })
} }
disconnectSignals(): void { disconnectSignals(): void {
this.disconnectDisplaySignals(); this.disconnectDisplaySignals();
this.disconnectMonitorSignals(); this.disconnectMonitorSignals();
@@ -222,10 +191,6 @@ export default class WindowManager implements IWindowManager {
}) })
} }
/**
* Returns true if the grab op is a resize operation (any edge or corner).
*/
_isResizeOp(op: Meta.GrabOp): boolean { _isResizeOp(op: Meta.GrabOp): boolean {
return op === Meta.GrabOp.RESIZING_E || return op === Meta.GrabOp.RESIZING_E ||
op === Meta.GrabOp.RESIZING_W || op === Meta.GrabOp.RESIZING_W ||
@@ -241,7 +206,6 @@ export default class WindowManager implements IWindowManager {
Logger.log("Grab Op Start", op); Logger.log("Grab Op Start", op);
if (this._isResizeOp(op)) { if (this._isResizeOp(op)) {
// ── Resize drag ──────────────────────────────────────────────────
Logger.log("Resize drag begin, op=", op); Logger.log("Resize drag begin, op=", op);
this._isResizeDrag = true; this._isResizeDrag = true;
this._resizeDragWindowId = window.get_id(); this._resizeDragWindowId = window.get_id();
@@ -249,11 +213,8 @@ export default class WindowManager implements IWindowManager {
const [startMouseX, startMouseY] = global.get_pointer(); const [startMouseX, startMouseY] = global.get_pointer();
this._resizeDragLastMouseX = startMouseX; this._resizeDragLastMouseX = startMouseX;
this._resizeDragLastMouseY = startMouseY; this._resizeDragLastMouseY = startMouseY;
// Mark the window as dragging so safelyResizeWindow skips it while
// we tile the other windows in response to ratio changes.
this._getWrappedWindow(window)?.startDragging(); this._getWrappedWindow(window)?.startDragging();
} else { } else {
// ── Move drag (existing behaviour) ───────────────────────────────
this._getWrappedWindow(window)?.startDragging(); this._getWrappedWindow(window)?.startDragging();
this._grabbedWindowMonitor = window.get_monitor(); this._grabbedWindowMonitor = window.get_monitor();
this._grabbedWindowId = window.get_id(); this._grabbedWindowId = window.get_id();
@@ -264,19 +225,15 @@ export default class WindowManager implements IWindowManager {
Logger.log("Grab Op End ", op); Logger.log("Grab Op End ", op);
if (this._isResizeDrag) { if (this._isResizeDrag) {
// ── Resize drag end ──────────────────────────────────────────────
Logger.log("Resize drag end, op=", op); Logger.log("Resize drag end, op=", op);
this._isResizeDrag = false; this._isResizeDrag = false;
this._resizeDragWindowId = _UNUSED_WINDOW_ID; this._resizeDragWindowId = _UNUSED_WINDOW_ID;
this._resizeDragLastMouseX = 0; this._resizeDragLastMouseX = 0;
this._resizeDragLastMouseY = 0; this._resizeDragLastMouseY = 0;
this._resizeDragOp = Meta.GrabOp.NONE; this._resizeDragOp = Meta.GrabOp.NONE;
// Stop suppressing the window, then snap everything to computed ratios
this._getWrappedWindow(window)?.stopDragging(); this._getWrappedWindow(window)?.stopDragging();
this._tileMonitors(); this._tileMonitors();
} else { } else {
// ── Move drag end (existing behaviour) ───────────────────────────
Logger.log("primary display", display.get_primary_monitor())
this._grabbedWindowId = _UNUSED_WINDOW_ID; this._grabbedWindowId = _UNUSED_WINDOW_ID;
this._getWrappedWindow(window)?.stopDragging(); this._getWrappedWindow(window)?.stopDragging();
this._tileMonitors(); this._tileMonitors();
@@ -288,9 +245,7 @@ export default class WindowManager implements IWindowManager {
let wrapped: WindowWrapper | undefined = undefined; let wrapped: WindowWrapper | undefined = undefined;
for (const monitor of this._monitors.values()) { for (const monitor of this._monitors.values()) {
wrapped = monitor.getWindow(window.get_id()); wrapped = monitor.getWindow(window.get_id());
if (wrapped !== undefined) { if (wrapped !== undefined) break;
break;
}
} }
return wrapped; return wrapped;
} }
@@ -320,21 +275,13 @@ export default class WindowManager implements IWindowManager {
} }
public handleWindowPositionChanged(winWrap: WindowWrapper): void { public handleWindowPositionChanged(winWrap: WindowWrapper): void {
// Ignore position changes that we triggered ourselves via tileWindows if (this._isTiling || this._changingGrabbedMonitor) return;
if (this._isTiling) {
return;
}
if (this._changingGrabbedMonitor) {
return;
}
// ── Live resize-drag handling ─────────────────────────────────────────
if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) { if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) {
this._handleResizeDragUpdate(winWrap); this._handleResizeDragUpdate(winWrap);
return; return;
} }
// ── Move-drag handling (existing behaviour) ───────────────────────────
if (winWrap.getWindowId() === this._grabbedWindowId) { if (winWrap.getWindowId() === this._grabbedWindowId) {
const [mouseX, mouseY, _] = global.get_pointer(); const [mouseX, mouseY, _] = global.get_pointer();
@@ -347,17 +294,14 @@ export default class WindowManager implements IWindowManager {
break; break;
} }
} }
if (monitorIndex === -1) { if (monitorIndex === -1) return;
return;
}
if (monitorIndex !== this._grabbedWindowMonitor) { if (monitorIndex !== this._grabbedWindowMonitor) {
this._changingGrabbedMonitor = true; this._changingGrabbedMonitor = true;
this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex); this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex);
this._changingGrabbedMonitor = false; this._changingGrabbedMonitor = false;
} }
// Guard _isTiling so that tileWindows() calls triggered by itemDragged
// (which repositions the displaced window) don't re-enter this handler.
this._isTiling = true; this._isTiling = true;
try { try {
this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY); this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
@@ -367,29 +311,19 @@ export default class WindowManager implements IWindowManager {
} }
} }
/**
* Called on every position-changed event while a resize drag is in progress.
* Computes the pixel delta from the drag-start rect, maps it to the correct
* container boundary, and calls adjustBoundary() for live feedback.
*/
private _handleResizeDragUpdate(winWrap: WindowWrapper): void { private _handleResizeDragUpdate(winWrap: WindowWrapper): void {
const op = this._resizeDragOp; const op = this._resizeDragOp;
const winId = winWrap.getWindowId(); const winId = winWrap.getWindowId();
// Read the current mouse position — this is unclamped by the compositor
// and always reflects the true user intent, unlike the window's frame rect
// which gets clamped when adjacent windows block expansion.
const [mouseX, mouseY] = global.get_pointer(); const [mouseX, mouseY] = global.get_pointer();
const dx = mouseX - this._resizeDragLastMouseX; const dx = mouseX - this._resizeDragLastMouseX;
const dy = mouseY - this._resizeDragLastMouseY; const dy = mouseY - this._resizeDragLastMouseY;
if (dx === 0 && dy === 0) return; if (dx === 0 && dy === 0) return;
// Update last position first so even if we return early the baseline advances
this._resizeDragLastMouseX = mouseX; this._resizeDragLastMouseX = mouseX;
this._resizeDragLastMouseY = mouseY; this._resizeDragLastMouseY = mouseY;
// Find the container that directly holds this window
const container = this._findContainerForWindowAcrossMonitors(winId); const container = this._findContainerForWindowAcrossMonitors(winId);
if (!container) { if (!container) {
Logger.warn("_handleResizeDragUpdate: no container found for window", winId); Logger.warn("_handleResizeDragUpdate: no container found for window", winId);
@@ -399,17 +333,10 @@ export default class WindowManager implements IWindowManager {
const itemIndex = container._getIndexOfWindow(winId); const itemIndex = container._getIndexOfWindow(winId);
if (itemIndex === -1) return; if (itemIndex === -1) return;
const isHorizontal = container._orientation === 0; // Orientation.HORIZONTAL const isHorizontal = container._orientation === 0;
// Map the mouse delta to the correct boundary.
//
// East/South edge → boundary AFTER the item (boundaryIndex = itemIndex)
// positive dx/dy grows this item, shrinks the next one.
// West/North edge → boundary BEFORE the item (boundaryIndex = itemIndex - 1)
// positive dx/dy moves the left edge right, growing the left neighbour
// and shrinking this item — so we negate the delta.
const minRatio = this._getMinRatio(); const minRatio = this._getMinRatio();
// E/S edge → boundary after the item; W/N edge → boundary before it.
let adjusted = false; let adjusted = false;
if (isHorizontal) { if (isHorizontal) {
if (op === Meta.GrabOp.RESIZING_E || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_SE) { if (op === Meta.GrabOp.RESIZING_E || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_SE) {
@@ -425,8 +352,6 @@ export default class WindowManager implements IWindowManager {
} }
} }
// Tile all windows with the updated ratios, guarded so the resulting
// position-changed events don't re-enter this handler.
if (adjusted) { if (adjusted) {
this._isTiling = true; this._isTiling = true;
try { try {
@@ -437,21 +362,16 @@ export default class WindowManager implements IWindowManager {
} }
} }
/**
* Searches all monitors for the WindowContainer that directly holds win_id.
*/
private _findContainerForWindowAcrossMonitors(winId: number): WindowContainer | null { private _findContainerForWindowAcrossMonitors(winId: number): WindowContainer | null {
const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index(); const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
for (const monitor of this._monitors.values()) { for (const monitor of this._monitors.values()) {
if (activeWorkspaceIndex >= monitor._workspaces.length) continue; if (activeWorkspaceIndex >= monitor._workspaces.length) continue;
const workspace = monitor._workspaces[activeWorkspaceIndex]; const container = monitor._workspaces[activeWorkspaceIndex].getContainerForWindow(winId);
const container = workspace.getContainerForWindow(winId);
if (container !== null) return container; if (container !== null) return container;
} }
return null; return null;
} }
public handleWindowMinimized(winWrap: WindowWrapper): void { public handleWindowMinimized(winWrap: WindowWrapper): void {
const monitor_id = winWrap.getWindow().get_monitor() const monitor_id = winWrap.getWindow().get_monitor()
this._minimizedItems.set(winWrap.getWindowId(), winWrap); this._minimizedItems.set(winWrap.getWindowId(), winWrap);
@@ -465,7 +385,6 @@ export default class WindowManager implements IWindowManager {
this._tileMonitors() this._tileMonitors()
} }
public handleWindowChangedWorkspace(winWrap: WindowWrapper): void { public handleWindowChangedWorkspace(winWrap: WindowWrapper): void {
const monitor = winWrap.getWindow().get_monitor(); const monitor = winWrap.getWindow().get_monitor();
this._monitors.get(monitor)?.removeWindow(winWrap); this._monitors.get(monitor)?.removeWindow(winWrap);
@@ -484,41 +403,26 @@ export default class WindowManager implements IWindowManager {
this._tileMonitors(); this._tileMonitors();
} }
handleWindowCreated(display: Meta.Display, window: Meta.Window) { handleWindowCreated(display: Meta.Display, window: Meta.Window) {
Logger.log("WINDOW CREATED ON DISPLAY", window, display); Logger.log("WINDOW CREATED ON DISPLAY", window, display);
if (!this._isWindowTileable(window)) { if (!this._isWindowTileable(window)) return;
return;
}
Logger.log("WINDOW IS TILABLE"); Logger.log("WINDOW IS TILABLE");
this.addWindowToMonitor(window); this.addWindowToMonitor(window);
} }
/**
* Handle window closed event
*/
handleWindowClosed(window: WindowWrapper): void { handleWindowClosed(window: WindowWrapper): void {
const mon_id = window._window.get_monitor(); const mon_id = window._window.get_monitor();
this._monitors.get(mon_id)?.removeWindow(window); this._monitors.get(mon_id)?.removeWindow(window);
window.disconnectWindowSignals() window.disconnectWindowSignals()
// Remove from managed windows
this.syncActiveWindow(); this.syncActiveWindow();
// Retile remaining windows
this._tileMonitors(); this._tileMonitors();
} }
public addWindowToMonitor(window: Meta.Window) { public addWindowToMonitor(window: Meta.Window) {
Logger.log("ADDING WINDOW TO MONITOR", window, window); Logger.log("ADDING WINDOW TO MONITOR", window, window);
var wrapper = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap)) var wrapper = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap))
wrapper.connectWindowSignals(this); wrapper.connectWindowSignals(this);
this._addWindowWrapperToMonitor(wrapper); this._addWindowWrapperToMonitor(wrapper);
} }
_addWindowWrapperToMonitor(winWrap: WindowWrapper) { _addWindowWrapperToMonitor(winWrap: WindowWrapper) {
@@ -544,7 +448,7 @@ export default class WindowManager implements IWindowManager {
"org.gnome.Shell.Extensions", "org.gnome.Shell.Extensions",
] ]
_isWindowTilingBlocked(window: Meta.Window) : boolean { _isWindowTilingBlocked(window: Meta.Window): boolean {
Logger.info("title", window.get_title()); Logger.info("title", window.get_title());
Logger.info("description", window.get_description()); Logger.info("description", window.get_description());
Logger.info("class", window.get_wm_class()); Logger.info("class", window.get_wm_class());
@@ -559,17 +463,12 @@ export default class WindowManager implements IWindowManager {
} }
_isWindowTileable(window: Meta.Window) { _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(); const windowType = window.get_window_type();
Logger.log("WINDOW TILING CHECK",); Logger.log("WINDOW TILING CHECK",);
// Skip certain types of windows
return !window.is_skip_taskbar() && return !window.is_skip_taskbar() &&
windowType !== Meta.WindowType.DESKTOP && windowType !== Meta.WindowType.DESKTOP &&
windowType !== Meta.WindowType.DOCK && windowType !== Meta.WindowType.DOCK &&
@@ -579,14 +478,6 @@ export default class WindowManager implements IWindowManager {
windowType !== Meta.WindowType.MENU; 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 { public syncActiveWindow(): number | null {
const focusWindow = global.display.focus_window; const focusWindow = global.display.focus_window;
if (focusWindow) { if (focusWindow) {
@@ -599,102 +490,33 @@ export default class WindowManager implements IWindowManager {
return this._activeWindowId; return this._activeWindowId;
} }
/**
* Toggles the orientation of the active container (the container holding the active window)
*/
public toggleActiveContainerOrientation(): void { public toggleActiveContainerOrientation(): void {
if (this._activeWindowId === null) { if (this._activeWindowId === null) {
Logger.warn("No active window, cannot toggle container orientation"); Logger.warn("No active window, cannot toggle container orientation");
return; return;
} }
const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
// Find the active window's container if (container) {
const activeContainer = this._findActiveContainer(); container.toggleOrientation();
if (activeContainer) {
activeContainer.toggleOrientation();
} else { } else {
Logger.warn("Could not find container for active window"); Logger.warn("Could not find container for active window");
} }
} }
/**
* Resets all split ratios in the active window's container to equal fractions.
* Bound to Ctrl+Z by default.
*/
public resetActiveContainerRatios(): void { public resetActiveContainerRatios(): void {
if (this._activeWindowId === null) { if (this._activeWindowId === null) {
Logger.warn("No active window, cannot reset container ratios"); Logger.warn("No active window, cannot reset container ratios");
return; return;
} }
const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
const activeContainer = this._findActiveContainer(); if (container) {
if (activeContainer) {
Logger.info("Resetting container ratios to equal splits"); Logger.info("Resetting container ratios to equal splits");
activeContainer.resetRatios(); container.resetRatios();
} else { } else {
Logger.warn("Could not find container for active window"); 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 {
if (this._activeWindowId === null) {
return null;
}
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;
}
}
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 { public printTreeStructure(): void {
Logger.info("=".repeat(80)); Logger.info("=".repeat(80));
Logger.info("WINDOW TREE STRUCTURE"); Logger.info("WINDOW TREE STRUCTURE");
@@ -707,19 +529,15 @@ export default class WindowManager implements IWindowManager {
this._monitors.forEach((monitor: Monitor, monitorId: number) => { this._monitors.forEach((monitor: Monitor, monitorId: number) => {
const isActiveMonitor = this._activeWindowId !== null && const isActiveMonitor = this._activeWindowId !== null &&
monitor.getWindow(this._activeWindowId) !== undefined; 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}`); 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) => { monitor._workspaces.forEach((workspace, workspaceIndex) => {
const isActiveWorkspace = workspaceIndex === activeWorkspaceIndex; const isActiveWorkspace = workspaceIndex === activeWorkspaceIndex;
const workspaceMarker = isActiveWorkspace && isActiveMonitor ? ' *' : ''; Logger.info(` Workspace ${workspaceIndex}${isActiveWorkspace && isActiveMonitor ? ' *' : ''}:`);
Logger.info(` Workspace ${workspaceIndex}${workspaceMarker}:`);
Logger.info(` Orientation: ${workspace._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'}`); Logger.info(` Orientation: ${workspace._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'}`);
Logger.info(` Items: ${workspace._tiledItems.length}`); Logger.info(` Items: ${workspace._tiledItems.length}`);
this._printContainerTree(workspace, 4); this._printContainerTree(workspace, 4);
}); });
}); });
@@ -727,31 +545,20 @@ export default class WindowManager implements IWindowManager {
Logger.info("=".repeat(80)); Logger.info("=".repeat(80));
} }
/** private _printContainerTree(container: WindowContainer, indentLevel: number): void {
* 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 {
const indent = " ".repeat(indentLevel); const indent = " ".repeat(indentLevel);
container._tiledItems.forEach((item: any, index: number) => { container._tiledItems.forEach((item, index) => {
if (item instanceof WindowContainer) { if (item instanceof WindowContainer) {
// Check if this container contains the active window const containsActive = this._activeWindowId !== null &&
const containsActiveWindow = this._activeWindowId !== null && item.getWindow(this._activeWindowId) !== undefined;
item.getWindow(this._activeWindowId) !== undefined; Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containsActive ? ' *' : ''}:`);
const containerMarker = containsActiveWindow ? ' *' : '';
Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containerMarker}:`);
Logger.info(`${indent} Items: ${item._tiledItems.length}`); 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}`); 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); this._printContainerTree(item, indentLevel + 4);
} else { } else {
const window = item.getWindow(); const window = item.getWindow();
const isActiveWindow = this._activeWindowId === item.getWindowId(); Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${this._activeWindowId === item.getWindowId() ? ' *' : ''}`);
const windowMarker = isActiveWindow ? ' *' : '';
Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${windowMarker}`);
Logger.info(`${indent} Title: "${window.get_title()}"`); Logger.info(`${indent} Title: "${window.get_title()}"`);
Logger.info(`${indent} Class: ${window.get_wm_class()}`); Logger.info(`${indent} Class: ${window.get_wm_class()}`);
const rect = item.getRect(); const rect = item.getRect();
@@ -759,6 +566,4 @@ export default class WindowManager implements IWindowManager {
} }
}); });
} }
} }