feat: upgrade packages and set parent for windows on add
This commit is contained in:
Lucas Oskorep
205
src/wm/container.ts
Normal file
205
src/wm/container.ts
Normal file
@@ -0,0 +1,205 @@
|
||||
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";
|
||||
|
||||
enum Orientation {
|
||||
HORIZONTAL = 0,
|
||||
VERTICAL = 1,
|
||||
}
|
||||
|
||||
|
||||
export default class WindowContainer {
|
||||
|
||||
_tiledItems: (WindowWrapper | WindowContainer)[];
|
||||
_tiledWindowLookup: Map<number, WindowWrapper>;
|
||||
_orientation: Orientation = Orientation.HORIZONTAL;
|
||||
_workArea: Rect;
|
||||
|
||||
constructor(workspaceArea: Rect,) {
|
||||
// this._id = monitorId;
|
||||
this._tiledItems = [];
|
||||
this._tiledWindowLookup = new Map<number, WindowWrapper>();
|
||||
this._workArea = workspaceArea;
|
||||
}
|
||||
|
||||
|
||||
move(rect: Rect): void {
|
||||
this._workArea = rect;
|
||||
this.tileWindows();
|
||||
}
|
||||
|
||||
addWindow(winWrap: WindowWrapper): void {
|
||||
// Add window to managed windows
|
||||
this._tiledItems.push(winWrap);
|
||||
this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
|
||||
winWrap.setParent(this);
|
||||
queueEvent({
|
||||
name: "tiling-windows",
|
||||
callback: () => {
|
||||
this.tileWindows();
|
||||
}
|
||||
}, 100)
|
||||
|
||||
}
|
||||
|
||||
getWindow(win_id: number): WindowWrapper | undefined {
|
||||
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 {
|
||||
if (this._tiledWindowLookup.has(win_id)) {
|
||||
this._tiledWindowLookup.delete(win_id);
|
||||
const index = this._getIndexOfWindow(win_id)
|
||||
this._tiledItems.splice(index, 1);
|
||||
} else {
|
||||
for (const item of this._tiledItems) {
|
||||
if (item instanceof WindowContainer) {
|
||||
item.removeWindow(win_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
this.tileWindows()
|
||||
}
|
||||
|
||||
disconnectSignals(): void {
|
||||
this._tiledItems.forEach((item) => {
|
||||
if (item instanceof WindowContainer) {
|
||||
item.disconnectSignals()
|
||||
} else {
|
||||
item.disconnectWindowSignals();
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
removeAllWindows(): void {
|
||||
this._tiledItems = []
|
||||
this._tiledWindowLookup.clear()
|
||||
}
|
||||
|
||||
tileWindows() {
|
||||
Logger.log("TILING WINDOWS IN CONTAINER")
|
||||
|
||||
Logger.log("WorkArea", this._workArea);
|
||||
|
||||
// Get all windows for current workspaceArea
|
||||
this._tileItems()
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
_tileItems() {
|
||||
if (this._tiledItems.length === 0) {
|
||||
return;
|
||||
}
|
||||
const bounds = this.getBounds();
|
||||
this._tiledItems.forEach((item, index) => {
|
||||
const rect = bounds[index];
|
||||
if (item instanceof WindowContainer) {
|
||||
item.move(rect);
|
||||
} else {
|
||||
item.safelyResizeWindow(rect);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
getBounds(): Rect[] {
|
||||
if (this._orientation === Orientation.HORIZONTAL) {
|
||||
return this.getHorizontalBounds();
|
||||
}
|
||||
return this.getVerticalBounds();
|
||||
}
|
||||
|
||||
getVerticalBounds(): Rect[] {
|
||||
const items = this._tiledItems
|
||||
const containerHeight = Math.floor(this._workArea.height / items.length);
|
||||
return items.map((_, index) => {
|
||||
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);
|
||||
|
||||
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;
|
||||
});
|
||||
}
|
||||
|
||||
getIndexOfItemNested(item: WindowWrapper): number {
|
||||
for (let i = 0; i < this._tiledItems.length; i++) {
|
||||
const container = this._tiledItems[i];
|
||||
if (container instanceof WindowContainer) {
|
||||
const index = container.getIndexOfItemNested(item);
|
||||
if (index !== -1) {
|
||||
return i;
|
||||
}
|
||||
} else if (container.getWindowId() === item.getWindowId()) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// TODO: update this to work with nested containers - all other logic should already be working
|
||||
itemDragged(item: WindowWrapper, x: number, y: number): void {
|
||||
let original_index = this.getIndexOfItemNested(item);
|
||||
|
||||
if (original_index === -1) {
|
||||
Logger.error("Item not found in container during drag op", item.getWindowId());
|
||||
return;
|
||||
}
|
||||
let new_index = this.getIndexOfItemNested(item);
|
||||
this.getBounds().forEach((rect, index) => {
|
||||
if (rect.x < x && rect.x + rect.width > x && rect.y < y && rect.y + rect.height > y) {
|
||||
new_index = index;
|
||||
}
|
||||
})
|
||||
if (original_index !== new_index) {
|
||||
this._tiledItems.splice(original_index, 1);
|
||||
this._tiledItems.splice(new_index, 0, item);
|
||||
this.tileWindows()
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
86
src/wm/monitor.ts
Normal file
86
src/wm/monitor.ts
Normal file
@@ -0,0 +1,86 @@
|
||||
import {WindowWrapper} from "./window.js";
|
||||
import {Rect} from "../utils/rect.js";
|
||||
import queueEvent from "../utils/events.js";
|
||||
import {Logger} from "../utils/logger.js";
|
||||
import Meta from "gi://Meta";
|
||||
import Mtk from "@girs/mtk-16";
|
||||
|
||||
import WindowContainer from "./container.js";
|
||||
import Window = Meta.Window;
|
||||
|
||||
export default class Monitor {
|
||||
|
||||
_id: number;
|
||||
_workArea: Rect;
|
||||
_workspaces: WindowContainer[] = [];
|
||||
|
||||
constructor(monitorId: number) {
|
||||
this._id = monitorId;
|
||||
const workspace = global.workspace_manager.get_active_workspace();
|
||||
this._workArea = workspace.get_work_area_for_monitor(this._id);
|
||||
Logger.log("CREATING MONITOR", monitorId);
|
||||
Logger.log("WorkArea", this._workArea.x, this._workArea.y, this._workArea.width, this._workArea.height);
|
||||
const workspaceCount = global.workspace_manager.get_n_workspaces()
|
||||
Logger.log("Workspace Count", workspaceCount);
|
||||
for (let i = 0; i < workspaceCount; i++) {
|
||||
this._workspaces.push(new WindowContainer(this._workArea));
|
||||
}
|
||||
}
|
||||
|
||||
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();
|
||||
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()
|
||||
}
|
||||
|
||||
removeWorkspace(workspaceId: number): void {
|
||||
this._workspaces.splice(workspaceId, 1);
|
||||
}
|
||||
|
||||
addWorkspace(): void {
|
||||
this._workspaces.push(new WindowContainer(this._workArea));
|
||||
}
|
||||
|
||||
itemDragged(item: WindowWrapper, x: number, y: number): void {
|
||||
this._workspaces[item.getWorkspace()].itemDragged(item, x, y);
|
||||
}
|
||||
|
||||
}
|
||||
136
src/wm/window.ts
Normal file
136
src/wm/window.ts
Normal file
@@ -0,0 +1,136 @@
|
||||
import Meta from 'gi://Meta';
|
||||
import Clutter from "gi://Clutter";
|
||||
import {IWindowManager} from "./windowManager.js";
|
||||
import {Logger} from "../utils/logger.js";
|
||||
import {Rect} from "../utils/rect.js";
|
||||
import WindowContainer from "./container.js";
|
||||
|
||||
|
||||
type WindowMinimizedHandler = (window: WindowWrapper) => void;
|
||||
type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void;
|
||||
|
||||
export class WindowWrapper {
|
||||
readonly _window: Meta.Window;
|
||||
readonly _windowMinimizedHandler: WindowMinimizedHandler;
|
||||
readonly _signals: number[] = [];
|
||||
_parent: WindowContainer | null = null;
|
||||
|
||||
constructor(
|
||||
window: Meta.Window,
|
||||
winMinimized: WindowMinimizedHandler
|
||||
) {
|
||||
this._window = window;
|
||||
this._windowMinimizedHandler = winMinimized;
|
||||
}
|
||||
|
||||
getWindow(): Meta.Window {
|
||||
return this._window;
|
||||
}
|
||||
|
||||
getWindowId(): number {
|
||||
return this._window.get_id();
|
||||
}
|
||||
|
||||
getWorkspace(): number {
|
||||
return this._window.get_workspace().index();
|
||||
}
|
||||
|
||||
getMonitor(): number {
|
||||
return this._window.get_monitor();
|
||||
}
|
||||
|
||||
getRect(): Rect {
|
||||
return this._window.get_frame_rect();
|
||||
}
|
||||
|
||||
setParent(parent: WindowContainer): void {
|
||||
this._parent = parent;
|
||||
}
|
||||
|
||||
getParent(): WindowContainer | null {
|
||||
if (this._parent == null) {
|
||||
Logger.warn(`Attempting to get parent for window without parent ${JSON.stringify(this)}`);
|
||||
}
|
||||
return this._parent
|
||||
}
|
||||
|
||||
connectWindowSignals(
|
||||
windowManager: IWindowManager,
|
||||
): void {
|
||||
const windowId = this._window.get_id()
|
||||
// Handle window destruction
|
||||
this._signals.push(
|
||||
this._window.connect('unmanaging', window => {
|
||||
Logger.log("REMOVING WINDOW", windowId);
|
||||
windowManager.handleWindowClosed(this)
|
||||
}),
|
||||
this._window.connect('notify::minimized', (we) => {
|
||||
if (this._window.minimized) {
|
||||
Logger.log(`Window minimized: ${windowId}`);
|
||||
windowManager.handleWindowMinimized(this);
|
||||
|
||||
} else if (!this._window.minimized) {
|
||||
Logger.log(`Window unminimized: ${windowId}`);
|
||||
windowManager.handleWindowUnminimized(this);
|
||||
|
||||
}
|
||||
}),
|
||||
this._window.connect('notify::has-focus', () => {
|
||||
if (this._window.has_focus()) {
|
||||
windowManager._activeWindowId = windowId;
|
||||
}
|
||||
}),
|
||||
this._window.connect('notify::maximized-horizontally', () => {
|
||||
if (this._window.get_maximized()) {
|
||||
Logger.log(`Window maximized: ${windowId}`);
|
||||
} else {
|
||||
Logger.log(`Window unmaximized: ${windowId}`);
|
||||
}
|
||||
}),
|
||||
this._window.connect("workspace-changed", (_metaWindow) => {
|
||||
Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
|
||||
windowManager.handleWindowChangedWorkspace(this);
|
||||
}),
|
||||
this._window.connect("position-changed", (_metaWindow) => {
|
||||
windowManager.handleWindowPositionChanged(this);
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
disconnectWindowSignals(): void {
|
||||
|
||||
if (this._signals) {
|
||||
this._signals.forEach(signal => {
|
||||
try {
|
||||
if (this._window != null) {
|
||||
this._window.disconnect(signal);
|
||||
}
|
||||
} catch (e) {
|
||||
Logger.warn("error disconnecting signal", signal, e);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// This is meant to be an exact copy of Forge's move function, renamed to maintain your API
|
||||
safelyResizeWindow(rect: Rect): void {
|
||||
// Keep minimal logging
|
||||
Logger.log("SAFELY RESIZE", rect.x, rect.y, rect.width, rect.height);
|
||||
const actor = this._window.get_compositor_private();
|
||||
|
||||
if (!actor) {
|
||||
Logger.log("No actor available, can't resize safely yet");
|
||||
return;
|
||||
}
|
||||
let windowActor = this._window.get_compositor_private() as Clutter.Actor;
|
||||
if (!windowActor) return;
|
||||
windowActor.remove_all_transitions();
|
||||
Logger.info("MOVING")
|
||||
this._window.move_frame(true, rect.x, rect.y);
|
||||
Logger.info("RESIZING MOVING")
|
||||
this._window.move_resize_frame(true, rect.x, rect.y, rect.width, rect.height);
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
394
src/wm/windowManager.ts
Normal file
394
src/wm/windowManager.ts
Normal file
@@ -0,0 +1,394 @@
|
||||
import Meta from "gi://Meta";
|
||||
// import Gio from "gi://Gio";
|
||||
// import GLib from "gi://GLib";
|
||||
|
||||
import {WindowWrapper} from './window.js';
|
||||
import * as Main from "resource:///org/gnome/shell/ui/main.js";
|
||||
// import Mtk from "@girs/mtk-16";
|
||||
import {Logger} from "../utils/logger.js";
|
||||
import Monitor from "./monitor.js";
|
||||
|
||||
|
||||
export interface IWindowManager {
|
||||
_activeWindowId: number | null;
|
||||
|
||||
// addWindow(window: Meta.Window): void;
|
||||
|
||||
handleWindowClosed(winWrap: WindowWrapper): void;
|
||||
|
||||
handleWindowMinimized(winWrap: WindowWrapper): void;
|
||||
|
||||
handleWindowUnminimized(winWrap: WindowWrapper): void;
|
||||
|
||||
handleWindowChangedWorkspace(winWrap: WindowWrapper): void;
|
||||
|
||||
handleWindowPositionChanged(winWrap: WindowWrapper): void;
|
||||
|
||||
syncActiveWindow(): number | null;
|
||||
}
|
||||
|
||||
|
||||
const _UNUSED_MONITOR_ID = -1
|
||||
const _UNUSED_WINDOW_ID = -1
|
||||
|
||||
export default class WindowManager implements IWindowManager {
|
||||
_displaySignals: number[] = [];
|
||||
_windowManagerSignals: number[] = [];
|
||||
_workspaceManagerSignals: number[] = [];
|
||||
_overviewSignals: number[] = [];
|
||||
|
||||
_activeWindowId: number | null = null;
|
||||
_monitors: Map<number, Monitor> = new Map<number, Monitor>();
|
||||
|
||||
_minimizedItems: Map<number, WindowWrapper> = new Map<number, WindowWrapper>();
|
||||
|
||||
_grabbedWindowMonitor: number = _UNUSED_MONITOR_ID;
|
||||
_grabbedWindowId: number = _UNUSED_WINDOW_ID;
|
||||
|
||||
constructor() {
|
||||
|
||||
|
||||
}
|
||||
|
||||
public enable(): void {
|
||||
Logger.log("Starting Aerospike Window Manager");
|
||||
// Connect window signals
|
||||
this.instantiateDisplaySignals();
|
||||
|
||||
const mon_count = global.display.get_n_monitors();
|
||||
for (let i = 0; i < mon_count; i++) {
|
||||
this._monitors.set(i, new Monitor(i));
|
||||
}
|
||||
|
||||
this.captureExistingWindows();
|
||||
}
|
||||
|
||||
instantiateDisplaySignals(): void {
|
||||
this._displaySignals.push(
|
||||
global.display.connect("grab-op-begin", (display, window, op) => {
|
||||
this.handleGrabOpBegin(display, window, op)
|
||||
}),
|
||||
global.display.connect("grab-op-end", (display, window, op) => {
|
||||
this.handleGrabOpEnd(display, window, op)
|
||||
}),
|
||||
global.display.connect("window-entered-monitor", (display, monitor, window) => {
|
||||
Logger.log("WINDOW HAS ENTERED NEW MONITOR!")
|
||||
// this._moveWindowToMonitor(window, monitor);
|
||||
}),
|
||||
global.display.connect('window-created', (display, window) => {
|
||||
this.handleWindowCreated(display, window);
|
||||
}),
|
||||
|
||||
global.display.connect("showing-desktop-changed", () => {
|
||||
Logger.log("SHOWING DESKTOP CHANGED");
|
||||
}),
|
||||
global.display.connect("workareas-changed", (display) => {
|
||||
Logger.log("WORK AREAS CHANGED",);
|
||||
console.log(display.get_workspace_manager().get_active_workspace_index())
|
||||
}),
|
||||
global.display.connect("in-fullscreen-changed", () => {
|
||||
Logger.log("IN FULL SCREEN CHANGED");
|
||||
}),
|
||||
)
|
||||
|
||||
this._windowManagerSignals = [
|
||||
global.window_manager.connect("show-tile-preview", (_, _metaWindow, _rect, _num) => {
|
||||
Logger.log("SHOW TITLE PREVIEW!")
|
||||
}),
|
||||
];
|
||||
|
||||
this._workspaceManagerSignals = [
|
||||
global.workspace_manager.connect("showing-desktop-changed", () => {
|
||||
Logger.log("SHOWING DESKTOP CHANGED AT WORKSPACE LEVEL");
|
||||
}),
|
||||
global.workspace_manager.connect("workspace-added", (_, wsIndex) => {
|
||||
Logger.log("WORKSPACE ADDED", wsIndex);
|
||||
this._monitors.forEach((monitor: Monitor) => {
|
||||
monitor.addWorkspace();
|
||||
})
|
||||
}),
|
||||
global.workspace_manager.connect("workspace-removed", (_, wsIndex) => {
|
||||
Logger.log("WORKSPACE REMOVED", wsIndex);
|
||||
this._monitors.forEach((monitor: Monitor) => {
|
||||
monitor.removeWorkspace(wsIndex);
|
||||
})
|
||||
}),
|
||||
global.workspace_manager.connect("active-workspace-changed", (source) => {
|
||||
Logger.log("Active workspace-changed", source.get_active_workspace().index());
|
||||
}),
|
||||
];
|
||||
|
||||
this._overviewSignals = [
|
||||
Main.overview.connect("hiding", () => {
|
||||
// this.fromOverview = true;
|
||||
Logger.log("HIDING OVERVIEW")
|
||||
this._tileMonitors();
|
||||
// const eventObj = {
|
||||
// name: "focus-after-overview",
|
||||
// callback: () => {
|
||||
// Logger.log("FOCUSING AFTER OVERVIEW");
|
||||
// },
|
||||
// };
|
||||
// this.queueEvent(eventObj);
|
||||
}),
|
||||
Main.overview.connect("showing", () => {
|
||||
// this.toOverview = true;
|
||||
Logger.log("SHOWING OVERVIEW");
|
||||
}),
|
||||
];
|
||||
|
||||
|
||||
}
|
||||
|
||||
public disable(): void {
|
||||
Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!")
|
||||
// Disconnect the focus signal and remove any existing borders
|
||||
this.disconnectSignals();
|
||||
this.removeAllWindows();
|
||||
}
|
||||
|
||||
removeAllWindows(): void {
|
||||
this._monitors.forEach((monitor: Monitor) => {
|
||||
monitor.removeAllWindows();
|
||||
})
|
||||
this._minimizedItems.clear();
|
||||
}
|
||||
|
||||
|
||||
disconnectSignals(): void {
|
||||
this.disconnectDisplaySignals();
|
||||
this.disconnectMonitorSignals();
|
||||
this.disconnectMinimizedSignals();
|
||||
}
|
||||
|
||||
disconnectMonitorSignals(): void {
|
||||
this._monitors.forEach((monitor: Monitor) => {
|
||||
monitor.disconnectSignals();
|
||||
})
|
||||
}
|
||||
|
||||
disconnectDisplaySignals(): void {
|
||||
this._displaySignals.forEach((signal) => {
|
||||
global.display.disconnect(signal)
|
||||
})
|
||||
this._windowManagerSignals.forEach((signal) => {
|
||||
global.window_manager.disconnect(signal)
|
||||
})
|
||||
this._workspaceManagerSignals.forEach((signal) => {
|
||||
global.workspace_manager.disconnect(signal)
|
||||
})
|
||||
this._overviewSignals.forEach((signal) => {
|
||||
Main.overview.disconnect(signal)
|
||||
})
|
||||
}
|
||||
|
||||
disconnectMinimizedSignals(): void {
|
||||
this._minimizedItems.forEach((item) => {
|
||||
item.disconnectWindowSignals();
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
|
||||
Logger.log("Grab Op Start");
|
||||
Logger.log(display, window, op)
|
||||
Logger.log(window.get_monitor())
|
||||
|
||||
this._grabbedWindowMonitor = window.get_monitor();
|
||||
this._grabbedWindowId = window.get_id();
|
||||
}
|
||||
|
||||
handleGrabOpEnd(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
|
||||
Logger.log("Grab Op End ", op);
|
||||
Logger.log("primary display", display.get_primary_monitor())
|
||||
this._grabbedWindowId = _UNUSED_WINDOW_ID;
|
||||
var rect = window.get_frame_rect()
|
||||
Logger.info("Release Location", window.get_monitor(), rect.x, rect.y, rect.width, rect.height)
|
||||
const old_mon_id = this._grabbedWindowMonitor;
|
||||
const new_mon_id = window.get_monitor();
|
||||
|
||||
Logger.info("MONITOR MATCH", old_mon_id !== new_mon_id);
|
||||
if (old_mon_id !== new_mon_id) {
|
||||
Logger.trace("MOVING MONITOR");
|
||||
let old_mon = this._monitors.get(old_mon_id);
|
||||
let new_mon = this._monitors.get(new_mon_id);
|
||||
if (old_mon === undefined || new_mon === undefined) {
|
||||
return;
|
||||
}
|
||||
|
||||
let wrapped = old_mon.getWindow(window.get_id())
|
||||
if (wrapped === undefined) {
|
||||
wrapped = new WindowWrapper(window, this.handleWindowMinimized);
|
||||
} else {
|
||||
old_mon.removeWindow(wrapped)
|
||||
}
|
||||
new_mon.addWindow(wrapped)
|
||||
}
|
||||
this._tileMonitors();
|
||||
Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
|
||||
}
|
||||
|
||||
_moveWindowToMonitor(window: Meta.Window, monitorId: number): void {
|
||||
let wrapped = undefined;
|
||||
for (const monitor of this._monitors.values()) {
|
||||
wrapped = monitor.getWindow(window.get_id());
|
||||
if (wrapped !== undefined) {
|
||||
monitor.removeWindow(wrapped);
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (wrapped === undefined) {
|
||||
wrapped = new WindowWrapper(window, this.handleWindowMinimized);
|
||||
wrapped.connectWindowSignals(this);
|
||||
}
|
||||
let new_mon = this._monitors.get(monitorId);
|
||||
new_mon?.addWindow(wrapped)
|
||||
this._tileMonitors();
|
||||
}
|
||||
|
||||
public handleWindowPositionChanged(winWrap: WindowWrapper): void {
|
||||
if (winWrap.getWindowId() === this._grabbedWindowId) {
|
||||
const rect = winWrap.getRect();
|
||||
// Logger.log("GRABBED WINDOW POSITION CHANGED", rect.x);
|
||||
const [mouseX, mouseY, _] = global.get_pointer();
|
||||
this._monitors.get(winWrap.getMonitor())?.itemDragged(winWrap, mouseX, mouseY);
|
||||
|
||||
// Log or use the coordinates
|
||||
// console.log(`Mouse position: X=${mouseX}, Y=${mouseY}`);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public handleWindowMinimized(winWrap: WindowWrapper): void {
|
||||
Logger.warn("WARNING MINIMIZING WINDOW");
|
||||
Logger.log("WARNING MINIMIZED", JSON.stringify(winWrap));
|
||||
const monitor_id = winWrap.getWindow().get_monitor()
|
||||
Logger.log("WARNING MINIMIZED", monitor_id);
|
||||
Logger.warn("WARNING MINIMIZED", this._monitors);
|
||||
|
||||
this._minimizedItems.set(winWrap.getWindowId(), winWrap);
|
||||
this._monitors.get(monitor_id)?.removeWindow(winWrap);
|
||||
|
||||
Logger.warn("WARNING MINIMIZED ITEMS", JSON.stringify(this._minimizedItems));
|
||||
this._tileMonitors()
|
||||
}
|
||||
|
||||
public handleWindowUnminimized(winWrap: WindowWrapper): void {
|
||||
Logger.log("WINDOW UNMINIMIZED");
|
||||
Logger.log("WINDOW UNMINIMIZED", winWrap == null);
|
||||
// Logger.log("WINDOW UNMINIMIZED", winWrap);
|
||||
// Logger.log("WINDOW UNMINIMIZED", winWrap.getWindowId());
|
||||
this._minimizedItems.delete(winWrap.getWindowId());
|
||||
this._addWindowWrapperToMonitor(winWrap);
|
||||
this._tileMonitors()
|
||||
}
|
||||
|
||||
|
||||
public handleWindowChangedWorkspace(winWrap: WindowWrapper): void {
|
||||
const monitor = winWrap.getWindow().get_monitor();
|
||||
this._monitors.get(monitor)?.removeWindow(winWrap);
|
||||
this._monitors.get(monitor)?.addWindow(winWrap);
|
||||
}
|
||||
|
||||
public captureExistingWindows() {
|
||||
Logger.log("CAPTURING WINDOWS")
|
||||
const workspace = global.workspace_manager.get_active_workspace();
|
||||
const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
|
||||
Logger.log("WINDOWS", windows);
|
||||
windows.forEach(window => {
|
||||
if (this._isWindowTileable(window)) {
|
||||
this.addWindowToMonitor(window);
|
||||
}
|
||||
});
|
||||
|
||||
this._tileMonitors();
|
||||
}
|
||||
|
||||
|
||||
handleWindowCreated(display: Meta.Display, window: Meta.Window) {
|
||||
Logger.log("WINDOW CREATED ON DISPLAY", window, display);
|
||||
if (!this._isWindowTileable(window)) {
|
||||
return;
|
||||
}
|
||||
Logger.log("WINDOW IS TILABLE");
|
||||
this.addWindowToMonitor(window);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Handle window closed event
|
||||
*/
|
||||
handleWindowClosed(window: WindowWrapper): void {
|
||||
|
||||
const mon_id = window._window.get_monitor();
|
||||
|
||||
this._monitors.get(mon_id)?.removeWindow(window);
|
||||
|
||||
window.disconnectWindowSignals()
|
||||
// Remove from managed windows
|
||||
this.syncActiveWindow();
|
||||
// Retile remaining windows
|
||||
this._tileMonitors();
|
||||
}
|
||||
|
||||
|
||||
public addWindowToMonitor(window: Meta.Window) {
|
||||
|
||||
Logger.log("ADDING WINDOW TO MONITOR", window, window);
|
||||
var wrapper = new WindowWrapper(window, this.handleWindowMinimized)
|
||||
wrapper.connectWindowSignals(this);
|
||||
this._addWindowWrapperToMonitor(wrapper);
|
||||
|
||||
}
|
||||
|
||||
_addWindowWrapperToMonitor(winWrap: WindowWrapper) {
|
||||
Logger.log("Adding window", JSON.stringify(winWrap));
|
||||
Logger.log("Adding window raw", JSON.stringify(winWrap.getWindow()));
|
||||
Logger.log("Adding window raw", JSON.stringify(winWrap.getWindow().minimized));
|
||||
if (winWrap.getWindow().minimized) {
|
||||
this._minimizedItems.set(winWrap.getWindow().get_id(), winWrap);
|
||||
} else {
|
||||
this._monitors.get(winWrap.getWindow().get_monitor())?.addWindow(winWrap)
|
||||
}
|
||||
}
|
||||
|
||||
_tileMonitors(): void {
|
||||
|
||||
for (const monitor of this._monitors.values()) {
|
||||
monitor.tileWindows()
|
||||
}
|
||||
}
|
||||
|
||||
_isWindowTileable(window: Meta.Window) {
|
||||
|
||||
if (!window || !window.get_compositor_private()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const windowType = window.get_window_type();
|
||||
Logger.log("WINDOW TYPE", windowType);
|
||||
// Skip certain types of windows
|
||||
return !window.is_skip_taskbar() &&
|
||||
windowType !== Meta.WindowType.DESKTOP &&
|
||||
windowType !== Meta.WindowType.DOCK &&
|
||||
windowType !== Meta.WindowType.DIALOG &&
|
||||
windowType !== Meta.WindowType.MODAL_DIALOG &&
|
||||
windowType !== Meta.WindowType.UTILITY &&
|
||||
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 {
|
||||
return null;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user