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

feat: refactored to monitor -> workspace -> container -> window workflow

Browse Source
This commit is contained in:
Lucas Oskorep
2025-05-16 02:01:11 -04:00
parent c23b9113ab
commit c7f45ecf3b
4 changed files with 174 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
src/container.ts
View File

@@ -13,8 +13,8 @@ enum Orientation {
export default class WindowContainer { export default class WindowContainer {
_id: number; _id: number;
_items: Map<number, WindowWrapper | WindowContainer>; _tiledItems: (WindowWrapper | WindowContainer)[];
_minimizedItems: Map<number, WindowWrapper>; _tiledWindowLookup: Map<number, WindowWrapper>;
_workspace: number; _workspace: number;
_orientation: Orientation = Orientation.HORIZONTAL; _orientation: Orientation = Orientation.HORIZONTAL;
_workArea: Rect; _workArea: Rect;
@@ -22,8 +22,8 @@ export default class WindowContainer {
constructor(monitorId: number, workspaceArea: Rect, workspace: number) { constructor(monitorId: number, workspaceArea: Rect, workspace: number) {
this._id = monitorId; this._id = monitorId;
this._workspace = workspace; this._workspace = workspace;
this._items = new Map<number, WindowWrapper>(); this._tiledItems = [];
this._minimizedItems = new Map<number, WindowWrapper>(); this._tiledWindowLookup = new Map<number, WindowWrapper>();
this._workArea = workspaceArea; this._workArea = workspaceArea;
} }
@@ -33,47 +33,66 @@ export default class WindowContainer {
move(rect: Rect): void { move(rect: Rect): void {
this._workArea = rect; this._workArea = rect;
this._tileWindows(); this.tileWindows();
} }
addWindow(winWrap: WindowWrapper): void { addWindow(winWrap: WindowWrapper): void {
// Add window to managed windows // Add window to managed windows
if (!winWrap.getWindow().minimized) { this._tiledItems.push(winWrap);
this._items.set(winWrap.getWindowId(), winWrap); this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
queueEvent({ queueEvent({
name: "tiling-windows", name: "tiling-windows",
callback: () => { callback: () => {
this._tileWindows(); this.tileWindows();
} }
}, 100) }, 100)
} else {
this._minimizedItems.set(winWrap.getWindowId(), winWrap);
}
} }
getWindow(win_id: number): WindowWrapper | WindowContainer | undefined { getWindow(win_id: number): WindowWrapper | undefined {
return this._items.get(win_id) if (this._tiledWindowLookup.has(win_id)) {
return this._tiledWindowLookup.get(win_id);
}
for (const item of this._tiledItems) {
if (item instanceof WindowContainer) {
const win = item.getWindow(win_id);
if (win) {
return win;
}
} else if (item.getWindowId() === win_id) {
return item;
}
}
return undefined
}
_getIndexOfWindow(win_id: number) {
for (let i = 0; i < this._tiledItems.length; i++) {
const item = this._tiledItems[i];
if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
return i;
}
}
return -1
} }
removeWindow(win_id: number): void { removeWindow(win_id: number): void {
this._items.delete(win_id) if (this._tiledWindowLookup.has(win_id)) {
this._tileWindows() this._tiledWindowLookup.delete(win_id);
} const index = this._getIndexOfWindow(win_id)
this._tiledItems.splice(index, 1);
minimizeWindow(winWrap: WindowWrapper): void { } else {
this._items.delete(winWrap.getWindowId()) for (const item of this._tiledItems) {
this._minimizedItems.set(winWrap.getWindowId(), winWrap) if (item instanceof WindowContainer) {
} item.removeWindow(win_id);
}
unminimizeWindow(winWrap: WindowWrapper): void { }
if (this._minimizedItems.has(winWrap.getWindowId())) {
this._items.set(winWrap.getWindowId(), winWrap);
this._minimizedItems.delete(winWrap.getWindowId());
} }
this.tileWindows()
} }
disconnectSignals(): void { disconnectSignals(): void {
this._items.forEach((item) => { this._tiledItems.forEach((item) => {
if (item instanceof WindowContainer) { if (item instanceof WindowContainer) {
item.disconnectSignals() item.disconnectSignals()
} else { } else {
@@ -84,10 +103,11 @@ export default class WindowContainer {
} }
removeAllWindows(): void { removeAllWindows(): void {
this._items.clear() this._tiledItems = []
this._tiledWindowLookup.clear()
} }
_tileWindows() { tileWindows() {
Logger.log("TILING WINDOWS ON MONITOR", this._id) Logger.log("TILING WINDOWS ON MONITOR", this._id)
Logger.log("Workspace", this._workspace); Logger.log("Workspace", this._workspace);
@@ -97,18 +117,17 @@ export default class WindowContainer {
let tilable = this._getTilableItems(); let tilable = this._getTilableItems();
if (tilable.length !== 0) { if (tilable.length !== 0) {
this._tileHorizontally(tilable, ) this._tileItems(tilable)
} }
return true return true
} }
_getTilableItems(): (WindowWrapper|WindowContainer)[] { _getTilableItems(): (WindowWrapper | WindowContainer)[] {
return Array.from(this._items.values()) return Array.from(this._tiledItems.values())
} }
_tileItems(windows: (WindowWrapper | WindowContainer)[]) {
_tileItems(windows: (WindowWrapper|WindowContainer)[]) { if (windows.length === 0) {
if (windows.length === 0){
return; return;
} }
if (this._orientation === Orientation.HORIZONTAL) { if (this._orientation === Orientation.HORIZONTAL) {
@@ -118,7 +137,7 @@ export default class WindowContainer {
} }
} }
_tileVertically(items: (WindowWrapper|WindowContainer)[]) { _tileVertically(items: (WindowWrapper | WindowContainer)[]) {
const containerHeight = Math.floor(this._workArea.height / items.length); const containerHeight = Math.floor(this._workArea.height / items.length);
items.forEach((item, index) => { items.forEach((item, index) => {
@@ -139,7 +158,7 @@ export default class WindowContainer {
}); });
} }
_tileHorizontally(windows: (WindowWrapper|WindowContainer)[]) { _tileHorizontally(windows: (WindowWrapper | WindowContainer)[]) {
const windowWidth = Math.floor(this._workArea.width / windows.length); const windowWidth = Math.floor(this._workArea.width / windows.length);
windows.forEach((item, index) => { windows.forEach((item, index) => {

61
src/monitor.ts
View File

@@ -12,21 +12,64 @@ export default class Monitor {
_id: number; _id: number;
_workArea: Rect; _workArea: Rect;
// _activeWorkspace: number; _workspaces: WindowContainer[] = [];
// _workspaces: Map<number, WindowContainer>;
constructor(monitorId: number) { constructor(monitorId: number) {
this._id = monitorId; this._id = monitorId;
const workspace = global.workspace_manager.get_active_workspace(); const workspace = global.workspace_manager.get_active_workspace();
this._workArea = workspace.get_work_area_for_monitor(this._id); this._workArea = workspace.get_work_area_for_monitor(this._id);
// this._activeWorkspace = workspace
Logger.log("CREATING MONITOR", monitorId); Logger.log("CREATING MONITOR", monitorId);
const workspaces = global.workspace_manager.get_n_workspaces(); Logger.log("WorkArea", this._workArea.x, this._workArea.y, this._workArea.width, this._workArea.height);
Logger.log("WORKSPACE COUNT", workspaces); const workspaceCount = global.workspace_manager.get_n_workspaces()
// this._rootContainer = new WindowContainer(monitorId, this._workArea, ); Logger.log("Workspace Count", workspaceCount);
for (let i = 0; i < workspaceCount; i++) {
this._workspaces.push(new WindowContainer(monitorId, this._workArea, i));
}
}
disconnectSignals() {
for (const container of this._workspaces) {
container.disconnectSignals();
}
}
removeAllWindows(): void {
for (const container of this._workspaces) {
container.removeAllWindows();
}
}
getWindow(windowId: number): WindowWrapper | undefined {
for (const container of this._workspaces) {
const win = container.getWindow(windowId);
if (win) {
return win;
}
}
return undefined;
}
removeWindow(winWrap: WindowWrapper) {
const windowId = winWrap.getWindowId();
for (const container of this._workspaces) {
const win = container.getWindow(windowId);
if (win) {
container.removeWindow(windowId);
}
}
}
addWindow(winWrap: WindowWrapper) {
const window_workspace = winWrap.getWindow().get_workspace().index();
Logger.log("Adding window to workspace", window_workspace);
this._workspaces[window_workspace].addWindow(winWrap);
}
tileWindows(): void {
this._workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(this._id);
const activeWorkspace = global.workspace_manager.get_active_workspace();
this._workspaces[activeWorkspace.index()].move(this._workArea);
this._workspaces[activeWorkspace.index()].tileWindows()
} }
// removeAllWindows(): void {
// for (WindowContainer container of this._workspaces.values()) {}
// }
} }

21
src/window.ts
View File

@@ -3,16 +3,22 @@ import Clutter from "gi://Clutter";
import {IWindowManager} from "./windowManager.js"; import {IWindowManager} from "./windowManager.js";
import {Logger} from "./utils/logger.js"; import {Logger} from "./utils/logger.js";
import {Rect} from "./utils/rect.js"; import {Rect} from "./utils/rect.js";
import WindowContainer from "./container.js";
type WindowMinimizedHandler = (window: WindowWrapper) => void; type WindowMinimizedHandler = (window: WindowWrapper) => void;
type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void;
export class WindowWrapper { export class WindowWrapper {
readonly _window: Meta.Window; readonly _window: Meta.Window;
readonly _windowMinimizedHandler: WindowMinimizedHandler; readonly _windowMinimizedHandler: WindowMinimizedHandler;
// readonly _windowWorkspaceChangedHandler: WindowWorkspaceChangedHandler;
readonly _signals: number[]; readonly _signals: number[];
constructor(window: Meta.Window, winMinimized: WindowMinimizedHandler) { constructor(
window: Meta.Window,
winMinimized: WindowMinimizedHandler
) {
this._window = window; this._window = window;
this._signals = []; this._signals = [];
this._windowMinimizedHandler = winMinimized; this._windowMinimizedHandler = winMinimized;
@@ -47,16 +53,6 @@ export class WindowWrapper {
} }
}), }),
this._window.connect(
'workspace-changed',
(window) => {
const workspace = window.get_workspace();
const workspaceIndex = workspace ? workspace.index() : -1;
console.log(`Window moved to workspace ${workspaceIndex}`);
},
this
);
,
this._window.connect('notify::has-focus', () => { this._window.connect('notify::has-focus', () => {
if (this._window.has_focus()) { if (this._window.has_focus()) {
windowManager._activeWindowId = windowId; windowManager._activeWindowId = windowId;
@@ -69,6 +65,9 @@ export class WindowWrapper {
Logger.log(`Window unmaximized: ${windowId}`); Logger.log(`Window unmaximized: ${windowId}`);
} }
}), }),
this._window.connect("workspace-changed", (_metaWindow) => {
Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
}),
); );
} }

83
src/windowManager.ts
View File

@@ -43,6 +43,8 @@ export default class WindowManager implements IWindowManager {
_lockedSignalId: number | null; _lockedSignalId: number | null;
_isScreenLocked: boolean; _isScreenLocked: boolean;
_minimizedItems: Map<number, WindowWrapper>;
constructor() { constructor() {
this._displaySignals = []; this._displaySignals = [];
this._windowManagerSignals = []; this._windowManagerSignals = [];
@@ -50,11 +52,13 @@ export default class WindowManager implements IWindowManager {
this._overviewSignals = []; this._overviewSignals = [];
this._activeWindowId = null; this._activeWindowId = null;
this._grabbedWindowMonitor = _UNUSED_MONITOR_ID; this._grabbedWindowMonitor = _UNUSED_MONITOR_ID;
this._monitors = new Map<number, WindowContainer>(); this._monitors = new Map<number, Monitor>();
this._sessionProxy = null; this._sessionProxy = null;
this._lockedSignalId = null; this._lockedSignalId = null;
this._isScreenLocked = false; // Initialize to unlocked state this._isScreenLocked = false; // Initialize to unlocked state
this._minimizedItems = new Map<number, WindowWrapper>();
} }
public enable(): void { public enable(): void {
@@ -84,11 +88,13 @@ export default class WindowManager implements IWindowManager {
global.display.connect('window-created', (display, window) => { global.display.connect('window-created', (display, window) => {
this.handleWindowCreated(display, window); this.handleWindowCreated(display, window);
}), }),
global.display.connect("showing-desktop-changed", () => { global.display.connect("showing-desktop-changed", () => {
Logger.log("SHOWING DESKTOP CHANGED"); Logger.log("SHOWING DESKTOP CHANGED");
}), }),
global.display.connect("workareas-changed", (display) => { global.display.connect("workareas-changed", (display) => {
Logger.log("WORK AREAS CHANGED", display.); Logger.log("WORK AREAS CHANGED", );
console.log(display.get_workspace_manager().get_active_workspace_index())
}), }),
global.display.connect("in-fullscreen-changed", () => { global.display.connect("in-fullscreen-changed", () => {
Logger.log("IN FULL SCREEN CHANGED"); Logger.log("IN FULL SCREEN CHANGED");
@@ -146,23 +152,23 @@ export default class WindowManager implements IWindowManager {
} }
removeAllWindows(): void { removeAllWindows(): void {
//TODO: RECONNECT this._monitors.forEach((monitor: Monitor) => {
// this._monitors.forEach((monitor: Monitor) => { monitor.removeAllWindows();
// monitor.removeAllWindows(); })
// }) this._minimizedItems.clear();
} }
disconnectSignals(): void { disconnectSignals(): void {
this.disconnectDisplaySignals(); this.disconnectDisplaySignals();
this.disconnectMonitorSignals(); this.disconnectMonitorSignals();
this.disconnectMinimizedSignals();
} }
disconnectMonitorSignals(): void { disconnectMonitorSignals(): void {
//TODO: RECONNECT this._monitors.forEach((monitor: Monitor) => {
// this._monitors.forEach((monitor: Monitor) => { monitor.disconnectSignals();
// monitor.disconnectSignals(); })
// })
} }
disconnectDisplaySignals(): void { disconnectDisplaySignals(): void {
@@ -180,6 +186,12 @@ export default class WindowManager implements IWindowManager {
}) })
} }
disconnectMinimizedSignals(): void {
this._minimizedItems.forEach((item) => {
item.disconnectWindowSignals();
})
}
handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void { handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
Logger.log("Grab Op Start"); Logger.log("Grab Op Start");
@@ -204,15 +216,14 @@ export default class WindowManager implements IWindowManager {
if (old_mon === undefined || new_mon === undefined) { if (old_mon === undefined || new_mon === undefined) {
return; return;
} }
//TODO: RECONNECT
// let wrapped = old_mon.getWindow(window.get_id()) let wrapped = old_mon.getWindow(window.get_id())
// if (wrapped === undefined) { if (wrapped === undefined) {
// wrapped = new WindowWrapper(window, this.handleWindowMinimized); wrapped = new WindowWrapper(window, this.handleWindowMinimized);
// } else { } else {
// old_mon.removeWindow(window.get_id()) old_mon.removeWindow(wrapped)
// } }
// new_mon.addWindow(wrapped) new_mon.addWindow(wrapped)
} }
this._tileMonitors(); this._tileMonitors();
Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor()); Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
@@ -220,20 +231,25 @@ export default class WindowManager implements IWindowManager {
public handleWindowMinimized(winWrap: WindowWrapper): void { public handleWindowMinimized(winWrap: WindowWrapper): void {
Logger.warn("WARNING MINIMIZING WINDOW"); Logger.warn("WARNING MINIMIZING WINDOW");
Logger.log("WARNING MINIMIZED", winWrap); Logger.log("WARNING MINIMIZED", JSON.stringify(winWrap));
const monitor_id = winWrap.getWindow().get_monitor() const monitor_id = winWrap.getWindow().get_monitor()
Logger.log("WARNING MINIMIZED", monitor_id); Logger.log("WARNING MINIMIZED", monitor_id);
Logger.warn("WARNING MINIMIZED", this._monitors); Logger.warn("WARNING MINIMIZED", this._monitors);
//TODO: RECONNECT
// this._monitors.get(monitor_id)?.minimizeWindow(winWrap); this._minimizedItems.set(winWrap.getWindowId(), winWrap);
this._monitors.get(monitor_id)?.removeWindow(winWrap);
Logger.warn("WARNING MINIMIZED ITEMS", JSON.stringify(this._minimizedItems));
this._tileMonitors() this._tileMonitors()
} }
public handleWindowUnminimized(winWrap: WindowWrapper): void { public handleWindowUnminimized(winWrap: WindowWrapper): void {
Logger.log("WINDOW UNMINIMIZED"); Logger.log("WINDOW UNMINIMIZED");
const monitor_id = winWrap.getWindow().get_monitor() Logger.log("WINDOW UNMINIMIZED", winWrap == null);
//TODO: RECONNECT // Logger.log("WINDOW UNMINIMIZED", winWrap);
// this._monitors.get(monitor_id)?.unminimizeWindow(winWrap); // Logger.log("WINDOW UNMINIMIZED", winWrap.getWindowId());
this._minimizedItems.delete(winWrap.getWindowId());
this._addWindowWrapperToMonitor(winWrap);
this._tileMonitors() this._tileMonitors()
} }
@@ -267,11 +283,11 @@ export default class WindowManager implements IWindowManager {
*/ */
handleWindowClosed(window: WindowWrapper): void { handleWindowClosed(window: WindowWrapper): void {
// window.disconnectWindowSignals()
const mon_id = window._window.get_monitor(); const mon_id = window._window.get_monitor();
//TODO: RECONNECT
// this._monitors.get(mon_id)?.removeWindow(window.getWindowId());
this._monitors.get(mon_id)?.removeWindow(window);
window.disconnectWindowSignals()
// Remove from managed windows // Remove from managed windows
this.syncActiveWindow(); this.syncActiveWindow();
// Retile remaining windows // Retile remaining windows
@@ -284,17 +300,20 @@ export default class WindowManager implements IWindowManager {
Logger.log("ADDING WINDOW TO MONITOR", window, window); Logger.log("ADDING WINDOW TO MONITOR", window, window);
var wrapper = new WindowWrapper(window, this.handleWindowMinimized) var wrapper = new WindowWrapper(window, this.handleWindowMinimized)
wrapper.connectWindowSignals(this); wrapper.connectWindowSignals(this);
//TODO: RECONNECT this._addWindowWrapperToMonitor(wrapper);
// this._monitors.get(window.get_monitor())?.addWindow(wrapper) }
_addWindowWrapperToMonitor(winWrap: WindowWrapper) {
if (winWrap.getWindow().minimized) {
this._minimizedItems.set(winWrap.getWindow().get_id(), winWrap);
}
this._monitors.get(winWrap.getWindow().get_monitor())?.addWindow(winWrap)
} }
_tileMonitors(): void { _tileMonitors(): void {
for (const monitor of this._monitors.values()) { for (const monitor of this._monitors.values()) {
//TODO: RECONNECT monitor.tileWindows()
// monitor._tileWindows()
} }
} }