Compare commits
25 Commits
fe4558d628
...
feat/bad-r
| Author | SHA1 | Date | |
|---|---|---|---|
|
d911f434af | ||
|
|
5aef762e5f | ||
|
|
c4d4768d29 | ||
|
|
fe069b1de0 | ||
|
|
2446520ced | ||
|
|
265ff05436 | ||
|
|
2b86856a97 | ||
|
|
a858af73f4 | ||
|
|
ecb5a568cd | ||
|
|
5e9bc796ea | ||
|
|
04f402c686 | ||
|
|
1d3d9dc402 | ||
|
|
c7f45ecf3b | ||
|
|
c23b9113ab | ||
|
|
50ceb02124 | ||
|
|
717c240d70 | ||
|
|
822a7bd2e4 | ||
|
|
4543c98de8 | ||
|
|
d59a0fef6d | ||
|
|
ed661b3fa6 | ||
|
|
6a19b77742 | ||
|
|
7b0f37f3f9 | ||
|
|
e1e240924a | ||
|
|
185a8e233c | ||
|
|
84777c4db1 |
1
.gitignore
vendored
1
.gitignore
vendored
@@ -3,3 +3,4 @@ node_modules
|
||||
dist
|
||||
/schemas/gschemas.compiled
|
||||
/aerospike.zip
|
||||
/debug.log
|
||||
|
||||
36
Makefile
36
Makefile
@@ -1,36 +0,0 @@
|
||||
NAME=aerospike
|
||||
DOMAIN=lucaso.io
|
||||
|
||||
.PHONY: all pack install clean
|
||||
|
||||
all: dist/extension.js
|
||||
|
||||
node_modules: package.json
|
||||
pnpm install
|
||||
|
||||
dist/extension.js : node_modules
|
||||
tsc
|
||||
|
||||
schemas/gschemas.compiled: schemas/org.gnome.shell.extensions.$(NAME).gschema.xml
|
||||
glib-compile-schemas schemas
|
||||
|
||||
$(NAME).zip: dist/extension.js dist/prefs.js schemas/gschemas.compiled
|
||||
@rm -rf dist/*
|
||||
@cp metadata.json dist/
|
||||
@cp stylesheet.css dist/
|
||||
@mkdir dist/schemas
|
||||
@cp schemas/*.compiled dist/schemas/
|
||||
@(cd dist && zip ../$(NAME).zip -9r .)
|
||||
|
||||
pack: $(NAME).zip
|
||||
|
||||
install: $(NAME).zip
|
||||
|
||||
clean:
|
||||
@rm -rf dist node_modules $(NAME).zip
|
||||
|
||||
test:
|
||||
@dbus-run-session -- gnome-shell --nested --wayland
|
||||
|
||||
.PHONY: install-and-test
|
||||
install-and-test: install test
|
||||
7
ambient.d.ts
vendored
7
ambient.d.ts
vendored
@@ -2,3 +2,10 @@ import "@girs/gjs";
|
||||
import "@girs/gjs/dom";
|
||||
import "@girs/gnome-shell/ambient";
|
||||
import "@girs/gnome-shell/extensions/global";
|
||||
|
||||
// Extend Meta.Window with our custom property
|
||||
declare namespace Meta {
|
||||
interface Window {
|
||||
_aerospikeData?: any;
|
||||
}
|
||||
}
|
||||
|
||||
434
extension.ts
434
extension.ts
@@ -1,319 +1,153 @@
|
||||
import GLib from 'gi://GLib';
|
||||
import St from 'gi://St';
|
||||
import Meta from 'gi://Meta';
|
||||
import {Extension, ExtensionMetadata} from 'resource:///org/gnome/shell/extensions/extension.js';
|
||||
|
||||
// import Gio from 'gi://Gio';
|
||||
// import cairo from "cairo";
|
||||
// import Shell from 'gi://Shell';
|
||||
// import * as Main from 'resource:///org/gnome/shell/ui/main.js';
|
||||
|
||||
type WinWrapper = {
|
||||
window: Meta.Window | null;
|
||||
signals: Signal[] | null;
|
||||
}
|
||||
|
||||
type Signal = {
|
||||
name: string;
|
||||
id: number;
|
||||
}
|
||||
import * as Main from 'resource:///org/gnome/shell/ui/main.js';
|
||||
import Gio from 'gi://Gio';
|
||||
import Shell from 'gi://Shell';
|
||||
import WindowManager from './src/wm/windowManager.js'
|
||||
import {Logger} from "./src/utils/logger.js";
|
||||
|
||||
export default class aerospike extends Extension {
|
||||
|
||||
borderActor: St.Widget | null;
|
||||
focusWindowSignals: any[];
|
||||
lastFocusedWindow: Meta.Window | null;
|
||||
_focusSignal: number | null;
|
||||
_windowCreateId: number | null;
|
||||
_windows: Map<number, WinWrapper>;
|
||||
_activeWindowId: number | null;
|
||||
settings: Gio.Settings;
|
||||
keyBindings: Map<string, number>;
|
||||
windowManager: WindowManager;
|
||||
|
||||
constructor(metadata: ExtensionMetadata) {
|
||||
super(metadata);
|
||||
// Initialize instance variables
|
||||
this.borderActor = null;
|
||||
this.focusWindowSignals = [];
|
||||
this.lastFocusedWindow = null;
|
||||
this._focusSignal = null;
|
||||
this._windowCreateId = null;
|
||||
this._windows = new Map<number, WinWrapper>();
|
||||
this._activeWindowId = null;
|
||||
|
||||
this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
|
||||
this.keyBindings = new Map();
|
||||
this.windowManager = new WindowManager();
|
||||
}
|
||||
|
||||
enable() {
|
||||
console.log("STARTING AEROSPIKE!")
|
||||
|
||||
// this._captureExistingWindows();
|
||||
// Connect window signals
|
||||
this._windowCreateId = global.display.connect(
|
||||
'window-created',
|
||||
(display, window) => {
|
||||
this.handleWindowCreated(window);
|
||||
}
|
||||
);
|
||||
Logger.log("STARTING AEROSPIKE!")
|
||||
this.bindSettings();
|
||||
this.setupKeybindings();
|
||||
this.windowManager.enable()
|
||||
}
|
||||
|
||||
handleWindowCreated(window: Meta.Window) {
|
||||
console.log("WINDOW CREATED", window);
|
||||
if (!this._isWindowTileable(window)) {
|
||||
return;
|
||||
}
|
||||
console.log("WINDOW IS TILABLE");
|
||||
const actor = window.get_compositor_private();
|
||||
if (!actor) {
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
this._addWindow(window);
|
||||
}
|
||||
|
||||
// _captureExistingWindows() {
|
||||
// console.log("CAPTURING WINDOWS")
|
||||
// const workspace = global.workspace_manager.get_active_workspace();
|
||||
// const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
|
||||
// console.log("WINDOWS", windows);
|
||||
// windows.forEach(window => {
|
||||
// if (this._isWindowTileable(window)) {
|
||||
// this._addWindow(window);
|
||||
// }
|
||||
// });
|
||||
//
|
||||
// // this._tileWindows();
|
||||
// }
|
||||
|
||||
getUsableMonitorSpace(window: Meta.Window) {
|
||||
// Get the current workspace
|
||||
const workspace = window.get_workspace();
|
||||
|
||||
// Get the monitor index that this window is on
|
||||
const monitorIndex = window.get_monitor();
|
||||
|
||||
// Get the work area
|
||||
const workArea = workspace.get_work_area_for_monitor(monitorIndex);
|
||||
|
||||
return {
|
||||
x: workArea.x,
|
||||
y: workArea.y,
|
||||
width: workArea.width,
|
||||
height: workArea.height
|
||||
};
|
||||
}
|
||||
|
||||
resizeWindow(win: Meta.Window, x:number, y:number, width:number, height:number) {
|
||||
// First, ensure window is not maximized or fullscreen
|
||||
// if (win.get_maximized()) {
|
||||
// console.log("WINDOW MAXIMIZED")
|
||||
// win.unmaximize(Meta.MaximizeFlags.BOTH);
|
||||
// }
|
||||
//
|
||||
// if (win.is_fullscreen()) {
|
||||
// console.log("WINDOW IS FULLSCREEN")
|
||||
// win.unmake_fullscreen();
|
||||
// }
|
||||
console.log("WINDOW", win.get_window_type(), win.allows_move());
|
||||
console.log("MONITOR INFO", this.getUsableMonitorSpace(win));
|
||||
console.log("NEW_SIZE", x, y, width, height);
|
||||
win.move_resize_frame(false, 50, 50, 300, 300);
|
||||
console.log("RESIZED WINDOW", win.get_frame_rect().height, win.get_frame_rect().width, win.get_frame_rect().x, win.get_frame_rect().y);
|
||||
}
|
||||
|
||||
_addWindow(window: Meta.Window) {
|
||||
const windowId = window.get_id();
|
||||
|
||||
// Connect to window signals
|
||||
const signals: Signal[] = [];
|
||||
console.log("ADDING WINDOW", window);
|
||||
// const act = window.get_compositor_private();
|
||||
// const id = act.connect('first-frame', _ => {
|
||||
// this.resizeWindow(window);
|
||||
// act.disconnect(id);
|
||||
// });
|
||||
|
||||
// const destroyId = window.connect('unmanaging', () => {
|
||||
// console.log("REMOVING WINDOW", windowId);
|
||||
// this._handleWindowClosed(windowId);
|
||||
// });
|
||||
// signals.push({name: 'unmanaging', id: destroyId});
|
||||
|
||||
// const focusId = window.connect('notify::has-focus', () => {
|
||||
// if (window.has_focus()) {
|
||||
// this._activeWindowId = windowId;
|
||||
// }
|
||||
// });
|
||||
// signals.push({name: 'notify::has-focus', id: focusId});
|
||||
|
||||
// Add window to managed windows
|
||||
this._windows.set(windowId, {
|
||||
window: window,
|
||||
signals: signals
|
||||
});
|
||||
|
||||
// If this is the first window, make it the active one
|
||||
if (this._windows.size === 1 || window.has_focus()) {
|
||||
this._activeWindowId = windowId;
|
||||
}
|
||||
|
||||
this._tileWindows();
|
||||
}
|
||||
|
||||
_handleWindowClosed(windowId: number) {
|
||||
|
||||
const windowData = this._windows.get(windowId);
|
||||
if (!windowData) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Disconnect signals
|
||||
if (windowData.signals) {
|
||||
windowData.signals.forEach(signal => {
|
||||
try {
|
||||
|
||||
if (windowData.window != null) {
|
||||
windowData.window.disconnect(signal.id);
|
||||
}
|
||||
} catch (e) {
|
||||
// Window might already be gone
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// Remove from managed windows
|
||||
this._windows.delete(windowId);
|
||||
|
||||
// If this was the active window, find a new one
|
||||
if (this._activeWindowId === windowId && this._windows.size > 0) {
|
||||
this._activeWindowId = Array.from(this._windows.keys())[0];
|
||||
} else if (this._windows.size === 0) {
|
||||
this._activeWindowId = null;
|
||||
}
|
||||
|
||||
// Retile remaining windows
|
||||
this._tileWindows();
|
||||
}
|
||||
|
||||
|
||||
_tileWindows() {
|
||||
console.log("TILING WINDOWS")
|
||||
const workspace = global.workspace_manager.get_active_workspace();
|
||||
const workArea = workspace.get_work_area_for_monitor(
|
||||
global.display.get_primary_monitor()
|
||||
);
|
||||
console.log("Workspace", workspace);
|
||||
console.log("WorkArea", workArea);
|
||||
|
||||
// Get all windows for current workspace
|
||||
const windows = Array.from(this._windows.values())
|
||||
// .filter(({window}) => {
|
||||
//
|
||||
// if (window != null) {
|
||||
// return window.get_workspace() === workspace;
|
||||
// }
|
||||
// })
|
||||
.map(({window}) => window);
|
||||
|
||||
if (windows.length === 0) {
|
||||
return;
|
||||
}
|
||||
this._tileHorizontally(windows, workArea)
|
||||
|
||||
}
|
||||
|
||||
_tileHorizontally(windows: (Meta.Window | null)[], workArea: Mtk.Rectangle) {
|
||||
const windowWidth = Math.floor(workArea.width / windows.length);
|
||||
|
||||
windows.forEach((window, index) => {
|
||||
const x = workArea.x + (index * windowWidth);
|
||||
const rect = {
|
||||
x: x,
|
||||
y: workArea.y,
|
||||
width: windowWidth,
|
||||
height: workArea.height
|
||||
};
|
||||
if (window != null) {
|
||||
this.resizeWindow(window, rect.x, rect.y, rect.width, rect.height);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
_isWindowTileable(window: Meta.Window) {
|
||||
if (!window || !window.get_compositor_private()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
const windowType = window.get_window_type();
|
||||
console.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;
|
||||
}
|
||||
|
||||
// _updateBorder(window: Meta.Window) {
|
||||
// console.log("UPDATING THE BORDER")
|
||||
// // Clear the previous border
|
||||
// this._clearBorder();
|
||||
// // Set a new border for the currently focused window
|
||||
// if (window) {
|
||||
// this._setBorder(window);
|
||||
// this.lastFocusedWindow = window;
|
||||
// }
|
||||
// }
|
||||
//
|
||||
// _setBorder(window: Meta.Window) {
|
||||
// console.log("SETTING THE BORDER")
|
||||
// if (!window) return;
|
||||
//
|
||||
// const rect = window.get_frame_rect();
|
||||
// if (!rect) return;
|
||||
//
|
||||
// // Create a new actor for the border using St.Widget
|
||||
// this.borderActor = new St.Widget({
|
||||
// name: 'active-window-border',
|
||||
// // style_class: 'active-window-border',
|
||||
// reactive: false,
|
||||
// x: rect.x - 1, // Adjust for border width
|
||||
// y: rect.y - 1,
|
||||
// width: rect.width + 2, // Increased to accommodate border
|
||||
// height: rect.height + 2,
|
||||
// // Initial style with default color.ts
|
||||
// // style: `border: 4px solid hsl(${this.hue}, 100%, 50%); border-radius: 5px;`,
|
||||
// // style: `border: 2px solid rgba(0, 0, 0, 0.5); border-radius: 3px;`
|
||||
// });
|
||||
//
|
||||
// // Add the border actor to the UI group
|
||||
// global.window_group.add_child(this.borderActor);
|
||||
// // Main.layoutManager.uiGroup.add_child(this.borderActor);
|
||||
//
|
||||
// // Listen to window's changes in position and size
|
||||
// this.focusWindowSignals?.push(window.connect('position-changed', () => this._updateBorderPosition(window)));
|
||||
// this.focusWindowSignals?.push(window.connect('size-changed', () => this._updateBorderPosition(window)));
|
||||
// this.focusWindowSignals?.push(window.connect('unmanaged', () => this._clearBorder()));
|
||||
//
|
||||
// this._updateBorderPosition(window);
|
||||
//
|
||||
// // Start the color.ts cycling
|
||||
// this._startColorCycle();
|
||||
// }
|
||||
|
||||
|
||||
disable() {
|
||||
console.log("DISABLED AEROSPIKE!")
|
||||
// Disconnect the focus signal and remove any existing borders
|
||||
if (this._focusSignal) {
|
||||
global.display.disconnect(this._focusSignal);
|
||||
this._focusSignal = null;
|
||||
this.windowManager.disable()
|
||||
this.removeKeybindings()
|
||||
}
|
||||
|
||||
|
||||
private bindSettings() {
|
||||
// Monitor settings changes
|
||||
this.settings.connect('changed::move-left', () => {
|
||||
log(`Keybinding 1 changed to: ${this.settings.get_strv('move-left')}`);
|
||||
this.refreshKeybinding('move-left');
|
||||
});
|
||||
|
||||
this.settings.connect('changed::move-right', () => {
|
||||
log(`Keybinding 2 changed to: ${this.settings.get_strv('move-right')}`);
|
||||
this.refreshKeybinding('move-right');
|
||||
});
|
||||
|
||||
this.settings.connect('changed::join-with-left', () => {
|
||||
log(`Keybinding 3 changed to: ${this.settings.get_strv('join-with-left')}`);
|
||||
this.refreshKeybinding('join-with-left');
|
||||
});
|
||||
|
||||
this.settings.connect('changed::join-with-right', () => {
|
||||
log(`Keybinding 4 changed to: ${this.settings.get_strv('join-with-right')}`);
|
||||
this.refreshKeybinding('join-with-right');
|
||||
});
|
||||
|
||||
this.settings.connect('changed::reset-window-sizes', () => {
|
||||
log(`Reset window sizes keybinding changed to: ${this.settings.get_strv('reset-window-sizes')}`);
|
||||
this.refreshKeybinding('reset-window-sizes');
|
||||
});
|
||||
|
||||
this.settings.connect('changed::dropdown-option', () => {
|
||||
log(`Dropdown option changed to: ${this.settings.get_string('dropdown-option')}`);
|
||||
});
|
||||
|
||||
this.settings.connect('changed::color-selection', () => {
|
||||
log(`Color selection changed to: ${this.settings.get_string('color-selection')}`);
|
||||
});
|
||||
}
|
||||
private refreshKeybinding(settingName: string) {
|
||||
if (this.keyBindings.has(settingName)) {
|
||||
Main.wm.removeKeybinding(settingName);
|
||||
this.keyBindings.delete(settingName);
|
||||
}
|
||||
|
||||
// Clear the border on the last focused window if it exists
|
||||
// this._clearBorder();
|
||||
this.lastFocusedWindow = null;
|
||||
switch (settingName) {
|
||||
case 'move-left':
|
||||
this.bindKeybinding('move-left', () => {
|
||||
Logger.info('Keybinding 1 was pressed!');
|
||||
});
|
||||
break;
|
||||
case 'move-right':
|
||||
this.bindKeybinding('move-right', () => {
|
||||
Logger.info('Keybinding 2 was pressed!');
|
||||
});
|
||||
break;
|
||||
case 'join-with-left':
|
||||
this.bindKeybinding('join-with-left', () => {
|
||||
Logger.info('Keybinding 3 was pressed!');
|
||||
});
|
||||
break;
|
||||
case 'join-with-right':
|
||||
this.bindKeybinding('join-with-right', () => {
|
||||
Logger.info('Keybinding 4 was pressed!');
|
||||
});
|
||||
break;
|
||||
case 'reset-window-sizes':
|
||||
this.bindKeybinding('reset-window-sizes', () => {
|
||||
this.windowManager.resetAllWindowSizes();
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
private removeKeybindings() {
|
||||
this.keyBindings.forEach((_, key) => {
|
||||
Main.wm.removeKeybinding(key);
|
||||
});
|
||||
this.keyBindings.clear();
|
||||
}
|
||||
|
||||
private setupKeybindings() {
|
||||
this.bindKeybinding('move-left', () => {
|
||||
Logger.info('Keybinding 1 was pressed!');
|
||||
});
|
||||
|
||||
this.bindKeybinding('move-right', () => {
|
||||
Logger.info('Keybinding 2 was pressed!');
|
||||
});
|
||||
|
||||
this.bindKeybinding('join-with-left', () => {
|
||||
Logger.info('Keybinding 3 was pressed!');
|
||||
});
|
||||
|
||||
this.bindKeybinding('join-with-right', () => {
|
||||
Logger.info('Keybinding 4 was pressed!');
|
||||
});
|
||||
|
||||
this.bindKeybinding('reset-window-sizes', () => {
|
||||
this.windowManager.resetAllWindowSizes();
|
||||
});
|
||||
}
|
||||
|
||||
private bindKeybinding(settingName: string, callback: () => void) {
|
||||
const keyBindingSettings = this.settings.get_strv(settingName);
|
||||
|
||||
if (keyBindingSettings.length === 0 || keyBindingSettings[0] === '') {
|
||||
return;
|
||||
}
|
||||
|
||||
const keyBindingAction = Main.wm.addKeybinding(
|
||||
settingName,
|
||||
this.settings,
|
||||
Meta.KeyBindingFlags.NONE,
|
||||
Shell.ActionMode.NORMAL,
|
||||
callback
|
||||
);
|
||||
|
||||
this.keyBindings.set(settingName, keyBindingAction);
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
27
justfile
27
justfile
@@ -1,19 +1,22 @@
|
||||
set dotenv-load
|
||||
NAME:="aerospike"
|
||||
DOMAIN:="lucaso.io"
|
||||
FULL_NAME:=NAME + "@" + DOMAIN
|
||||
|
||||
packages:
|
||||
pnpm install
|
||||
|
||||
build: packages
|
||||
build: packages && build-schemas
|
||||
rm -rf dist/*
|
||||
tsc
|
||||
glib-compile-schemas schemas
|
||||
cp metadata.json dist/
|
||||
cp stylesheet.css dist/
|
||||
mkdir dist/schemas
|
||||
cp schemas/*.compiled dist/schemas/
|
||||
mkdir -p dist/schemas
|
||||
|
||||
build-schemas:
|
||||
glib-compile-schemas schemas
|
||||
cp schemas/org.gnome.shell.extensions.aerospike.gschema.xml dist/schemas/
|
||||
cp schemas/gschemas.compiled dist/schemas/
|
||||
|
||||
build-package: build
|
||||
cd dist && zip ../{{NAME}}.zip -9r .
|
||||
@@ -21,10 +24,22 @@ build-package: build
|
||||
|
||||
install: build
|
||||
mkdir -p ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}
|
||||
rm -rf /.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/*
|
||||
rm -rf ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/*
|
||||
cp -r dist/* ~/.local/share/gnome-shell/extensions/{{NAME}}@{{DOMAIN}}/
|
||||
|
||||
run:
|
||||
dbus-run-session -- gnome-shell --nested --wayland
|
||||
env MUTTER_DEBUG_DUMMY_MODE_SPECS=1280x720 dbus-run-session -- gnome-shell --devkit
|
||||
|
||||
install-and-run: install run
|
||||
|
||||
live-debug:
|
||||
journalctl /usr/bin/gnome-shell -f -o cat | tee debug.log
|
||||
|
||||
#pack: build
|
||||
# gnome-extensions pack dist \
|
||||
# --force \
|
||||
# --out-dir . \
|
||||
# --schema ../schemas/org.gnome.shell.extensions.aerospike.gschema.xml
|
||||
#
|
||||
#install-pack: pack
|
||||
# gnome-extensions install ./{{FULL_NAME}}.shell-extension.zip --force
|
||||
@@ -1,9 +1,12 @@
|
||||
{
|
||||
"name": "aerospike",
|
||||
"description": "Adds pretty rainbow or static borders to the active and inactive windows",
|
||||
"description": "I3 Like Tiling Window Manager for Gnome",
|
||||
"uuid": "aerospike@lucaso.io",
|
||||
"settings-schema": "org.gnome.shell.extensions.aerospike",
|
||||
"shell-version": [
|
||||
"47",
|
||||
"48"
|
||||
]
|
||||
"48",
|
||||
"49"
|
||||
],
|
||||
"gettext-domain": "aerospike@lucaso.io",
|
||||
"url": "https://gitea.chaosdev.gay/lucasoskorep/aerospike@lucaso.io"
|
||||
}
|
||||
|
||||
32
package.json
32
package.json
@@ -16,13 +16,33 @@
|
||||
"homepage": "https://github.com/example/my-extension#readme",
|
||||
"sideEffects": false,
|
||||
"devDependencies": {
|
||||
"@girs/gjs": "^4.0.0-beta.23",
|
||||
"@girs/gnome-shell": "^48.0.1",
|
||||
"eslint": "^9.23.0",
|
||||
"eslint-plugin-jsdoc": "^50.6.9",
|
||||
"typescript": "^5.8.2"
|
||||
"@girs/gjs": "4.0.0-beta.38",
|
||||
"@girs/gnome-shell": "49.0.1",
|
||||
"eslint": "^9.36.0",
|
||||
"eslint-plugin-jsdoc": "^50.8.0",
|
||||
"typescript": "^5.9.2"
|
||||
},
|
||||
"dependencies": {
|
||||
"@girs/mtk-16": "16.0.0-4.0.0-beta.23"
|
||||
"@girs/mtk-17": "17.0.0-4.0.0-beta.38"
|
||||
},
|
||||
"pnpm": {
|
||||
"overrides": {
|
||||
"@girs/cairo-1.0": "1.0.0-4.0.0-beta.38",
|
||||
"@girs/freetype2-2.0": "2.0.0-4.0.0-beta.38",
|
||||
"@girs/gdk-4.0": "4.0.0-4.0.0-beta.38",
|
||||
"@girs/gdkpixbuf-2.0": "2.0.0-4.0.0-beta.38",
|
||||
"@girs/gio-2.0": "2.86.0-4.0.0-beta.38",
|
||||
"@girs/gjs": "4.0.0-beta.38",
|
||||
"@girs/glib-2.0": "2.86.0-4.0.0-beta.38",
|
||||
"@girs/gmodule-2.0": "2.0.0-4.0.0-beta.38",
|
||||
"@girs/gobject-2.0": "2.86.0-4.0.0-beta.38",
|
||||
"@girs/graphene-1.0": "1.0.0-4.0.0-beta.38",
|
||||
"@girs/gsk-4.0": "4.0.0-4.0.0-beta.38",
|
||||
"@girs/gtk-4.0": "4.20.1-4.0.0-beta.38",
|
||||
"@girs/harfbuzz-0.0": "11.5.0-4.0.0-beta.38",
|
||||
"@girs/mtk-17": "17.0.0-4.0.0-beta.38",
|
||||
"@girs/pango-1.0": "1.57.0-4.0.0-beta.38",
|
||||
"@girs/pangocairo-1.0": "1.0.0-4.0.0-beta.38"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
1207
pnpm-lock.yaml
generated
1207
pnpm-lock.yaml
generated
File diff suppressed because it is too large
Load Diff
54
prefs.ts
54
prefs.ts
@@ -1,52 +1,4 @@
|
||||
import Gtk from 'gi://Gtk';
|
||||
import Adw from 'gi://Adw';
|
||||
import Gio from 'gi://Gio';
|
||||
import { ExtensionPreferences, gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
|
||||
// This file is just a wrapper around the compiled TypeScript code
|
||||
import AerospikeExtensions from './src/prefs/prefs.js';
|
||||
|
||||
export default class GnomeRectanglePreferences extends ExtensionPreferences {
|
||||
_settings?: Gio.Settings
|
||||
|
||||
fillPreferencesWindow(window: Adw.PreferencesWindow): Promise<void> {
|
||||
this._settings = this.getSettings();
|
||||
|
||||
const page = new Adw.PreferencesPage({
|
||||
title: _('General'),
|
||||
iconName: 'dialog-information-symbolic',
|
||||
});
|
||||
|
||||
const animationGroup = new Adw.PreferencesGroup({
|
||||
title: _('Animation'),
|
||||
description: _('Configure move/resize animation'),
|
||||
});
|
||||
page.add(animationGroup);
|
||||
|
||||
const animationEnabled = new Adw.SwitchRow({
|
||||
title: _('Enabled'),
|
||||
subtitle: _('Wether to animate windows'),
|
||||
});
|
||||
animationGroup.add(animationEnabled);
|
||||
|
||||
const paddingGroup = new Adw.PreferencesGroup({
|
||||
title: _('Paddings'),
|
||||
description: _('Configure the padding between windows'),
|
||||
});
|
||||
page.add(paddingGroup);
|
||||
|
||||
const paddingInner = new Adw.SpinRow({
|
||||
title: _('Inner'),
|
||||
subtitle: _('Padding between windows'),
|
||||
adjustment: new Gtk.Adjustment({
|
||||
lower: 0,
|
||||
upper: 1000,
|
||||
stepIncrement: 1
|
||||
})
|
||||
});
|
||||
paddingGroup.add(paddingInner);
|
||||
|
||||
window.add(page)
|
||||
|
||||
this._settings!.bind('animate', animationEnabled, 'active', Gio.SettingsBindFlags.DEFAULT);
|
||||
this._settings!.bind('padding-inner', paddingInner, 'value', Gio.SettingsBindFlags.DEFAULT);
|
||||
return Promise.resolve();
|
||||
}
|
||||
}
|
||||
export default AerospikeExtensions;
|
||||
@@ -1,10 +1,47 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<schemalist>
|
||||
<schema id="org.gnome.shell.extensions.aerospike" path="/org/gnome/shell/extensions/aerospike/">
|
||||
<key name="tiling-type" type="s">
|
||||
<default>"Horizontal"</default>
|
||||
<summary>Type of tiling</summary>
|
||||
<description>The type of tiling provided by aerospace</description>
|
||||
<key name="dropdown-option" type="s">
|
||||
<default>'option1'</default>
|
||||
<summary>Dropdown selection</summary>
|
||||
<description>Option selected from the dropdown menu</description>
|
||||
</key>
|
||||
|
||||
<key name="color-selection" type="s">
|
||||
<default>'rgb(255,0,0)'</default>
|
||||
<summary>Selected color</summary>
|
||||
<description>Color chosen from the color picker</description>
|
||||
</key>
|
||||
|
||||
<key name="move-left" type="as">
|
||||
<default><![CDATA[['<Super>1']]]></default>
|
||||
<summary>Keybinding for action 1</summary>
|
||||
<description>Keyboard shortcut for triggering action 1</description>
|
||||
</key>
|
||||
|
||||
<key name="move-right" type="as">
|
||||
<default><![CDATA[['<Super>2']]]></default>
|
||||
<summary>Keybinding for action 2</summary>
|
||||
<description>Keyboard shortcut for triggering action 2</description>
|
||||
</key>
|
||||
|
||||
<key name="join-with-left" type="as">
|
||||
<default><![CDATA[['<Super>3']]]></default>
|
||||
<summary>Keybinding for action 3</summary>
|
||||
<description>Keyboard shortcut for triggering action 3</description>
|
||||
</key>
|
||||
|
||||
<key name="join-with-right" type="as">
|
||||
<default><![CDATA[['<Super>4']]]></default>
|
||||
<summary>Keybinding for action 4</summary>
|
||||
<description>Keyboard shortcut for triggering action 4</description>
|
||||
</key>
|
||||
|
||||
<key name="reset-window-sizes" type="as">
|
||||
<default><![CDATA[['<Alt>z']]]></default>
|
||||
<summary>Reset all window sizes</summary>
|
||||
<description>Remove all custom window sizes and return to equal distribution</description>
|
||||
</key>
|
||||
|
||||
</schema>
|
||||
</schemalist>
|
||||
83
src/prefs/keybindings.ts
Normal file
83
src/prefs/keybindings.ts
Normal file
@@ -0,0 +1,83 @@
|
||||
// Gnome imports
|
||||
import Adw from 'gi://Adw';
|
||||
import Gtk from 'gi://Gtk';
|
||||
import Gio from 'gi://Gio';
|
||||
import GObject from 'gi://GObject';
|
||||
import { gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
|
||||
import { Logger } from '../utils/logger.js';
|
||||
|
||||
/**
|
||||
* EntryRow class for handling text input including keybindings
|
||||
*/
|
||||
export class EntryRow extends Adw.EntryRow {
|
||||
static {
|
||||
GObject.registerClass(this);
|
||||
}
|
||||
|
||||
constructor(params: {
|
||||
title: string,
|
||||
settings: Gio.Settings,
|
||||
bind: string,
|
||||
map?: {
|
||||
from: (settings: Gio.Settings, bind: string) => string,
|
||||
to: (settings: Gio.Settings, bind: string, value: string) => void
|
||||
}
|
||||
}) {
|
||||
super({ title: params.title });
|
||||
|
||||
const { settings, bind, map } = params;
|
||||
|
||||
// When text changes, update settings
|
||||
this.connect('changed', () => {
|
||||
const text = this.get_text();
|
||||
if (typeof text === 'string') {
|
||||
if (map) {
|
||||
map.to(settings, bind, text);
|
||||
} else {
|
||||
settings.set_string(bind, text);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
// Set initial text from settings
|
||||
const current = map ? map.from(settings, bind) : settings.get_string(bind);
|
||||
this.set_text(current ?? '');
|
||||
|
||||
// Add reset button
|
||||
this.add_suffix(
|
||||
new ResetButton({
|
||||
settings,
|
||||
bind,
|
||||
onReset: () => {
|
||||
this.set_text((map ? map.from(settings, bind) : settings.get_string(bind)) ?? '');
|
||||
},
|
||||
})
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset button for settings
|
||||
*/
|
||||
export class ResetButton extends Gtk.Button {
|
||||
static {
|
||||
GObject.registerClass(this);
|
||||
}
|
||||
|
||||
constructor(params: {
|
||||
settings?: Gio.Settings,
|
||||
bind: string,
|
||||
onReset?: () => void
|
||||
}) {
|
||||
super({
|
||||
icon_name: 'edit-clear-symbolic',
|
||||
tooltip_text: _('Reset'),
|
||||
valign: Gtk.Align.CENTER,
|
||||
});
|
||||
|
||||
this.connect('clicked', () => {
|
||||
params.settings?.reset(params.bind);
|
||||
params.onReset?.();
|
||||
});
|
||||
}
|
||||
}
|
||||
186
src/prefs/prefs.ts
Normal file
186
src/prefs/prefs.ts
Normal file
@@ -0,0 +1,186 @@
|
||||
import Adw from 'gi://Adw';
|
||||
import Gio from 'gi://Gio';
|
||||
import Gtk from 'gi://Gtk';
|
||||
import Gdk from 'gi://Gdk';
|
||||
import { ExtensionPreferences, gettext as _ } from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
|
||||
import {Logger} from "../utils/logger.js";
|
||||
import {EntryRow} from "./keybindings.js";
|
||||
|
||||
export default class AerospikeExtensions extends ExtensionPreferences {
|
||||
async fillPreferencesWindow(window: Adw.PreferencesWindow) {
|
||||
// Create settings object
|
||||
const settings = this.getSettings('org.gnome.shell.extensions.aerospike');
|
||||
|
||||
// Create a preferences page
|
||||
const page = new Adw.PreferencesPage({
|
||||
title: _('Settings'),
|
||||
icon_name: 'preferences-system-symbolic',
|
||||
});
|
||||
window.add(page);
|
||||
|
||||
|
||||
// Create options group
|
||||
const optionsGroup = new Adw.PreferencesGroup({
|
||||
title: _('Options'),
|
||||
});
|
||||
page.add(optionsGroup);
|
||||
|
||||
// Add dropdown
|
||||
const dropdownRow = new Adw.ComboRow({
|
||||
title: _('Select an option'),
|
||||
});
|
||||
optionsGroup.add(dropdownRow);
|
||||
|
||||
// Create dropdown model
|
||||
const dropdownModel = new Gtk.StringList();
|
||||
dropdownModel.append(_('Option 1'));
|
||||
dropdownModel.append(_('Option 2'));
|
||||
dropdownModel.append(_('Option 3'));
|
||||
dropdownModel.append(_('Option 4'));
|
||||
|
||||
dropdownRow.set_model(dropdownModel);
|
||||
|
||||
// Set the active option based on settings
|
||||
const currentOption = settings.get_string('dropdown-option');
|
||||
switch (currentOption) {
|
||||
case 'option1':
|
||||
dropdownRow.set_selected(0);
|
||||
break;
|
||||
case 'option2':
|
||||
dropdownRow.set_selected(1);
|
||||
break;
|
||||
case 'option3':
|
||||
dropdownRow.set_selected(2);
|
||||
break;
|
||||
case 'option4':
|
||||
dropdownRow.set_selected(3);
|
||||
break;
|
||||
default:
|
||||
dropdownRow.set_selected(0);
|
||||
}
|
||||
|
||||
// Connect dropdown change signal
|
||||
dropdownRow.connect('notify::selected', () => {
|
||||
const selected = dropdownRow.get_selected();
|
||||
let optionValue: string;
|
||||
|
||||
switch (selected) {
|
||||
case 0:
|
||||
optionValue = 'option1';
|
||||
break;
|
||||
case 1:
|
||||
optionValue = 'option2';
|
||||
break;
|
||||
case 2:
|
||||
optionValue = 'option3';
|
||||
break;
|
||||
case 3:
|
||||
optionValue = 'option4';
|
||||
break;
|
||||
default:
|
||||
optionValue = 'option1';
|
||||
}
|
||||
|
||||
settings.set_string('dropdown-option', optionValue);
|
||||
});
|
||||
|
||||
// Add color button
|
||||
const colorRow = new Adw.ActionRow({
|
||||
title: _('Choose a color'),
|
||||
});
|
||||
optionsGroup.add(colorRow);
|
||||
|
||||
const colorButton = new Gtk.ColorButton();
|
||||
colorRow.add_suffix(colorButton);
|
||||
colorRow.set_activatable_widget(colorButton);
|
||||
|
||||
// Set current color from settings
|
||||
const colorStr = settings.get_string('color-selection');
|
||||
const rgba = new Gdk.RGBA();
|
||||
rgba.parse(colorStr);
|
||||
colorButton.set_rgba(rgba);
|
||||
|
||||
// Connect color button signal
|
||||
colorButton.connect('color-set', () => {
|
||||
const color = colorButton.get_rgba().to_string();
|
||||
settings.set_string('color-selection', color);
|
||||
});
|
||||
|
||||
// Create keybindings group
|
||||
const keybindingsGroup = new Adw.PreferencesGroup({
|
||||
title: _('Keyboard Shortcuts'),
|
||||
description: `${_("Syntax")}: <Super>h, <Shift>g, <Super><Shift>h
|
||||
${_("Legend")}: <Super> - ${_("Windows key")}, <Primary> - ${_("Control key")}
|
||||
${_("Delete text to unset. Press Return key to accept.")}`,
|
||||
});
|
||||
page.add(keybindingsGroup);
|
||||
|
||||
// Add keybinding rows as EntryRows with proper mapping
|
||||
// Use the helper function to create the map object
|
||||
const keybindingMap = this.createKeybindingMap();
|
||||
|
||||
keybindingsGroup.add(
|
||||
new EntryRow({
|
||||
title: _('Action 1'),
|
||||
settings: settings,
|
||||
bind: 'move-left',
|
||||
map: keybindingMap
|
||||
})
|
||||
);
|
||||
|
||||
keybindingsGroup.add(
|
||||
new EntryRow({
|
||||
title: _('Action 2'),
|
||||
settings: settings,
|
||||
bind: 'move-right',
|
||||
map: keybindingMap
|
||||
})
|
||||
);
|
||||
|
||||
keybindingsGroup.add(
|
||||
new EntryRow({
|
||||
title: _('Action 3'),
|
||||
settings: settings,
|
||||
bind: 'join-with-left',
|
||||
map: keybindingMap
|
||||
})
|
||||
);
|
||||
|
||||
keybindingsGroup.add(
|
||||
new EntryRow({
|
||||
title: _('Action 4'),
|
||||
settings: settings,
|
||||
bind: 'join-with-right',
|
||||
map: keybindingMap
|
||||
})
|
||||
);
|
||||
|
||||
|
||||
}
|
||||
|
||||
// Helper function to create a keybinding mapping object
|
||||
private createKeybindingMap() {
|
||||
return {
|
||||
from(settings: Gio.Settings, bind: string) {
|
||||
return settings.get_strv(bind).join(',');
|
||||
},
|
||||
to(settings: Gio.Settings, bind: string, value: string) {
|
||||
if (!!value) {
|
||||
const mappings = value.split(',').map((x) => {
|
||||
const [, key, mods] = Gtk.accelerator_parse(x);
|
||||
return Gtk.accelerator_valid(key, mods) && Gtk.accelerator_name(key, mods);
|
||||
});
|
||||
// Filter out any false values to ensure we only have strings
|
||||
const stringMappings = mappings.filter((x): x is string => typeof x === 'string');
|
||||
if (stringMappings.length > 0) {
|
||||
Logger.debug("setting", bind, "to", stringMappings);
|
||||
settings.set_strv(bind, stringMappings);
|
||||
}
|
||||
} else {
|
||||
// If value deleted, unset the mapping
|
||||
settings.set_strv(bind, []);
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
}
|
||||
20
src/utils/events.ts
Normal file
20
src/utils/events.ts
Normal file
@@ -0,0 +1,20 @@
|
||||
import GLib from "gi://GLib";
|
||||
|
||||
|
||||
export type QueuedEvent = {
|
||||
name: string;
|
||||
callback: () => void;
|
||||
}
|
||||
|
||||
const queuedEvents: QueuedEvent[] = [];
|
||||
|
||||
export default function queueEvent(event: QueuedEvent, interval = 200) {
|
||||
queuedEvents.push(event);
|
||||
GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
|
||||
const e = queuedEvents.pop()
|
||||
if (e) {
|
||||
e.callback();
|
||||
}
|
||||
return queuedEvents.length !== 0;
|
||||
});
|
||||
}
|
||||
30
src/utils/logger.ts
Normal file
30
src/utils/logger.ts
Normal file
@@ -0,0 +1,30 @@
|
||||
export class Logger {
|
||||
|
||||
static fatal(...args: any[]) {
|
||||
console.log(`[Aerospike] [FATAL]`, ...args);
|
||||
}
|
||||
|
||||
static error(...args: any[]) {
|
||||
console.log(`[Aerospike] [ERROR]`, ...args);
|
||||
}
|
||||
|
||||
static warn(...args: any[]) {
|
||||
console.log(`[Aerospike] [WARN]`, ...args);
|
||||
}
|
||||
|
||||
static info(...args: any[]) {
|
||||
console.log(`[Aerospike] [INFO]`, ...args);
|
||||
}
|
||||
|
||||
static debug(...args: any[]) {
|
||||
console.log(`[Aerospike] [DEBUG]`, ...args);
|
||||
}
|
||||
|
||||
static trace(...args: any[]) {
|
||||
console.log(`[Aerospike] [TRACE]`, ...args);
|
||||
}
|
||||
|
||||
static log(...args: any[]) {
|
||||
console.log(`[Aerospike] [LOG]`, ...args);
|
||||
}
|
||||
}
|
||||
6
src/utils/rect.ts
Normal file
6
src/utils/rect.ts
Normal file
@@ -0,0 +1,6 @@
|
||||
export type Rect = {
|
||||
x: number;
|
||||
y: number;
|
||||
width: number;
|
||||
height: number;
|
||||
}
|
||||
484
src/wm/container.ts
Normal file
484
src/wm/container.ts
Normal file
@@ -0,0 +1,484 @@
|
||||
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;
|
||||
_customSizes: Map<number, number>; // Maps index to custom width (horizontal) or height (vertical)
|
||||
|
||||
constructor(workspaceArea: Rect,) {
|
||||
this._tiledItems = [];
|
||||
this._tiledWindowLookup = new Map<number, WindowWrapper>();
|
||||
this._workArea = workspaceArea;
|
||||
this._customSizes = new Map<number, number>();
|
||||
}
|
||||
|
||||
|
||||
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);
|
||||
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);
|
||||
// Shift custom sizes after removed index
|
||||
this._shiftCustomSizesAfterRemoval(index);
|
||||
} else {
|
||||
for (const item of this._tiledItems) {
|
||||
if (item instanceof WindowContainer) {
|
||||
item.removeWindow(win_id);
|
||||
}
|
||||
}
|
||||
}
|
||||
this.tileWindows()
|
||||
}
|
||||
|
||||
_shiftCustomSizesAfterRemoval(removedIndex: number): void {
|
||||
Logger.log(`=== _shiftCustomSizesAfterRemoval called ===`);
|
||||
Logger.log(`Removed index: ${removedIndex}`);
|
||||
Logger.log(`Total items after removal: ${this._tiledItems.length}`);
|
||||
Logger.log(`Custom sizes Map size: ${this._customSizes.size}`);
|
||||
|
||||
// Convert Map to readable string
|
||||
let customSizesStr = "{ ";
|
||||
this._customSizes.forEach((size, index) => {
|
||||
customSizesStr += `${index}: ${size}px, `;
|
||||
});
|
||||
customSizesStr += "}";
|
||||
Logger.log(`Custom sizes before shift: ${customSizesStr}`);
|
||||
|
||||
// Calculate the removed window's size (could be custom or flexible)
|
||||
let removedSize = this._customSizes.get(removedIndex);
|
||||
|
||||
if (removedSize === undefined) {
|
||||
// Window didn't have custom size, calculate its flexible size
|
||||
// Count items BEFORE removal (add 1 to current length)
|
||||
const numItemsBeforeRemoval = this._tiledItems.length + 1;
|
||||
let totalCustomSize = 0;
|
||||
let numFlexibleItemsBeforeRemoval = 0;
|
||||
|
||||
this._customSizes.forEach((size, index) => {
|
||||
totalCustomSize += size;
|
||||
// Don't count this in flexible if it's the removed index
|
||||
});
|
||||
numFlexibleItemsBeforeRemoval = numItemsBeforeRemoval - this._customSizes.size;
|
||||
|
||||
const containerSize = this._orientation === Orientation.HORIZONTAL ? this._workArea.width : this._workArea.height;
|
||||
const remainingSize = containerSize - totalCustomSize;
|
||||
removedSize = numFlexibleItemsBeforeRemoval > 0 ? Math.floor(remainingSize / numFlexibleItemsBeforeRemoval) : 0;
|
||||
|
||||
Logger.log(`Removed window was flexible, calculated size: ${removedSize}px (${numFlexibleItemsBeforeRemoval} flexible windows before removal)`);
|
||||
} else {
|
||||
Logger.log(`Removed window had custom size: ${removedSize}px`);
|
||||
}
|
||||
|
||||
// Rebuild the custom sizes map with shifted indices
|
||||
const newCustomSizes = new Map<number, number>();
|
||||
this._customSizes.forEach((size, index) => {
|
||||
if (index < removedIndex) {
|
||||
// Keep indices before removal
|
||||
Logger.log(`Keeping index ${index} with size ${size}`);
|
||||
newCustomSizes.set(index, size);
|
||||
} else if (index > removedIndex) {
|
||||
// Shift down indices after removal
|
||||
Logger.log(`Shifting index ${index} -> ${index - 1} with size ${size}`);
|
||||
newCustomSizes.set(index - 1, size);
|
||||
}
|
||||
// Skip the removed index
|
||||
});
|
||||
|
||||
Logger.log(`New custom sizes Map size after shift: ${newCustomSizes.size}`);
|
||||
let afterShiftStr = "{ ";
|
||||
newCustomSizes.forEach((size, index) => {
|
||||
afterShiftStr += `${index}: ${size}px, `;
|
||||
});
|
||||
afterShiftStr += "}";
|
||||
Logger.log(`Custom sizes after index shift: ${afterShiftStr}`);
|
||||
|
||||
// Distribute removed window's size among remaining custom-sized windows only
|
||||
// Flexible windows will naturally absorb their share through the bounds calculation
|
||||
const remainingWindowCount = this._tiledItems.length;
|
||||
const numCustomWindows = newCustomSizes.size;
|
||||
|
||||
if (removedSize > 0 && remainingWindowCount > 0 && numCustomWindows > 0) {
|
||||
const sizePerCustomWindow = Math.floor(removedSize / numCustomWindows);
|
||||
|
||||
Logger.log(`Distributing ${removedSize}px among ${numCustomWindows} custom-sized windows (${sizePerCustomWindow}px each)`);
|
||||
Logger.log(`Flexible windows will naturally absorb remaining space`);
|
||||
|
||||
// Add proportional size only to windows that already have custom sizes
|
||||
newCustomSizes.forEach((size, index) => {
|
||||
const newSize = size + sizePerCustomWindow;
|
||||
Logger.log(`Index ${index}: ${size}px + ${sizePerCustomWindow}px = ${newSize}px`);
|
||||
newCustomSizes.set(index, newSize);
|
||||
});
|
||||
} else {
|
||||
Logger.log(`Not distributing space - removedSize: ${removedSize}, remainingWindows: ${remainingWindowCount}, customWindows: ${numCustomWindows}`);
|
||||
}
|
||||
|
||||
let finalStr = "{ ";
|
||||
newCustomSizes.forEach((size, index) => {
|
||||
finalStr += `${index}: ${size}px, `;
|
||||
});
|
||||
finalStr += "}";
|
||||
Logger.log(`Final custom sizes: ${finalStr}`);
|
||||
|
||||
this._customSizes = newCustomSizes;
|
||||
Logger.log(`=== _shiftCustomSizesAfterRemoval complete ===`);
|
||||
}
|
||||
|
||||
disconnectSignals(): void {
|
||||
this._tiledItems.forEach((item) => {
|
||||
if (item instanceof WindowContainer) {
|
||||
item.disconnectSignals()
|
||||
} else {
|
||||
item.disconnectWindowSignals();
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
removeAllWindows(): void {
|
||||
this._tiledItems = []
|
||||
this._tiledWindowLookup.clear()
|
||||
}
|
||||
|
||||
tileWindows(skipRetry: boolean = false) {
|
||||
Logger.log("TILING WINDOWS IN CONTAINER")
|
||||
Logger.log("WorkArea", this._workArea);
|
||||
this._tileItems(skipRetry)
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
_tileItems(skipRetry: boolean = false) {
|
||||
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, 2, skipRetry);
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
getBounds(): Rect[] {
|
||||
if (this._orientation === Orientation.HORIZONTAL) {
|
||||
return this.getHorizontalBounds();
|
||||
}
|
||||
return this.getVerticalBounds();
|
||||
}
|
||||
|
||||
getVerticalBounds(): Rect[] {
|
||||
// Calculate available height after accounting for custom-sized windows
|
||||
let totalCustomHeight = 0;
|
||||
let numFlexibleItems = 0;
|
||||
|
||||
this._tiledItems.forEach((item, index) => {
|
||||
if (this._customSizes.has(index)) {
|
||||
totalCustomHeight += this._customSizes.get(index)!;
|
||||
} else {
|
||||
numFlexibleItems++;
|
||||
}
|
||||
});
|
||||
|
||||
// Ensure custom sizes don't exceed container height
|
||||
if (totalCustomHeight > this._workArea.height) {
|
||||
Logger.warn("Custom heights exceed container, resetting all sizes");
|
||||
this._customSizes.clear();
|
||||
totalCustomHeight = 0;
|
||||
numFlexibleItems = this._tiledItems.length;
|
||||
}
|
||||
|
||||
const remainingHeight = this._workArea.height - totalCustomHeight;
|
||||
const flexHeight = numFlexibleItems > 0 ? Math.floor(remainingHeight / numFlexibleItems) : 0;
|
||||
|
||||
// Build the bounds array
|
||||
let currentY = this._workArea.y;
|
||||
return this._tiledItems.map((item, index) => {
|
||||
let height = flexHeight;
|
||||
if (this._customSizes.has(index)) {
|
||||
height = this._customSizes.get(index)!;
|
||||
}
|
||||
|
||||
const rect = {
|
||||
x: this._workArea.x,
|
||||
y: currentY,
|
||||
width: this._workArea.width,
|
||||
height: height
|
||||
} as Rect;
|
||||
currentY += height;
|
||||
return rect;
|
||||
});
|
||||
}
|
||||
|
||||
getHorizontalBounds(): Rect[] {
|
||||
// Calculate available width after accounting for custom-sized windows
|
||||
let totalCustomWidth = 0;
|
||||
let numFlexibleItems = 0;
|
||||
|
||||
this._tiledItems.forEach((item, index) => {
|
||||
if (this._customSizes.has(index)) {
|
||||
totalCustomWidth += this._customSizes.get(index)!;
|
||||
} else {
|
||||
numFlexibleItems++;
|
||||
}
|
||||
});
|
||||
|
||||
// Ensure custom sizes don't exceed container width
|
||||
if (totalCustomWidth > this._workArea.width) {
|
||||
Logger.warn("Custom widths exceed container, resetting all sizes");
|
||||
this._customSizes.clear();
|
||||
totalCustomWidth = 0;
|
||||
numFlexibleItems = this._tiledItems.length;
|
||||
}
|
||||
|
||||
const remainingWidth = this._workArea.width - totalCustomWidth;
|
||||
const flexWidth = numFlexibleItems > 0 ? Math.floor(remainingWidth / numFlexibleItems) : 0;
|
||||
|
||||
// Build the bounds array
|
||||
let currentX = this._workArea.x;
|
||||
return this._tiledItems.map((item, index) => {
|
||||
let width = flexWidth;
|
||||
if (this._customSizes.has(index)) {
|
||||
width = this._customSizes.get(index)!;
|
||||
}
|
||||
|
||||
const rect = {
|
||||
x: currentX,
|
||||
y: this._workArea.y,
|
||||
width: width,
|
||||
height: this._workArea.height
|
||||
} as Rect;
|
||||
currentX += width;
|
||||
return 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 = original_index;
|
||||
this.getBounds().forEach((rect, index) => {
|
||||
if (rect.x < x && rect.x + rect.width > x && rect.y < y && rect.y + rect.height > y) {
|
||||
new_index = index;
|
||||
}
|
||||
})
|
||||
if (original_index !== new_index) {
|
||||
this._tiledItems.splice(original_index, 1);
|
||||
this._tiledItems.splice(new_index, 0, item);
|
||||
this.tileWindows()
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
windowManuallyResized(win_id: number): void {
|
||||
const window = this.getWindow(win_id);
|
||||
if (!window) {
|
||||
// Check nested containers
|
||||
for (const item of this._tiledItems) {
|
||||
if (item instanceof WindowContainer) {
|
||||
item.windowManuallyResized(win_id);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Find the index of the window
|
||||
const index = this._getIndexOfWindow(win_id);
|
||||
if (index === -1) {
|
||||
Logger.error("Window not found in container during resize");
|
||||
return;
|
||||
}
|
||||
|
||||
const rect = window.getRect();
|
||||
if (this._orientation === Orientation.HORIZONTAL) {
|
||||
this._customSizes.set(index, rect.width);
|
||||
Logger.log(`Window at index ${index} manually resized to width: ${rect.width}`);
|
||||
} else {
|
||||
this._customSizes.set(index, rect.height);
|
||||
Logger.log(`Window at index ${index} manually resized to height: ${rect.height}`);
|
||||
}
|
||||
}
|
||||
|
||||
resetAllWindowSizes(): void {
|
||||
Logger.log("Clearing all custom window sizes in container");
|
||||
this._customSizes.clear();
|
||||
// Also clear nested containers
|
||||
for (const item of this._tiledItems) {
|
||||
if (item instanceof WindowContainer) {
|
||||
item.resetAllWindowSizes();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
windowResizing(win_id: number, resizeOp: Meta.GrabOp): void {
|
||||
const window = this.getWindow(win_id);
|
||||
if (!window) {
|
||||
// Check nested containers
|
||||
for (const item of this._tiledItems) {
|
||||
if (item instanceof WindowContainer) {
|
||||
item.windowResizing(win_id, resizeOp);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if the resize direction matches the container orientation
|
||||
const isHorizontalResize = resizeOp === Meta.GrabOp.RESIZING_E || resizeOp === Meta.GrabOp.RESIZING_W;
|
||||
const isVerticalResize = resizeOp === Meta.GrabOp.RESIZING_N || resizeOp === Meta.GrabOp.RESIZING_S;
|
||||
|
||||
if ((this._orientation === Orientation.HORIZONTAL && !isHorizontalResize) ||
|
||||
(this._orientation === Orientation.VERTICAL && !isVerticalResize)) {
|
||||
// Resize direction doesn't match container orientation, ignore
|
||||
return;
|
||||
}
|
||||
|
||||
// Find the index of the window
|
||||
const index = this._getIndexOfWindow(win_id);
|
||||
if (index === -1) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Get the new size
|
||||
const rect = window.getRect();
|
||||
const newSize = this._orientation === Orientation.HORIZONTAL ? rect.width : rect.height;
|
||||
const oldSize = this._customSizes.get(index);
|
||||
|
||||
if (oldSize === undefined) {
|
||||
// First time resizing this window, just set the size
|
||||
this._customSizes.set(index, newSize);
|
||||
this.tileWindows(true);
|
||||
return;
|
||||
}
|
||||
|
||||
// Calculate the delta (how much the window changed)
|
||||
const delta = newSize - oldSize;
|
||||
|
||||
// If delta is 0, the window didn't actually resize (hit its minimum)
|
||||
if (delta === 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Determine which adjacent window to adjust based on resize direction
|
||||
let adjacentIndex = -1;
|
||||
if (resizeOp === Meta.GrabOp.RESIZING_E || resizeOp === Meta.GrabOp.RESIZING_S) {
|
||||
// Resizing right/down edge - adjust the next window
|
||||
adjacentIndex = index + 1;
|
||||
} else if (resizeOp === Meta.GrabOp.RESIZING_W || resizeOp === Meta.GrabOp.RESIZING_N) {
|
||||
// Resizing left/up edge - adjust the previous window
|
||||
adjacentIndex = index - 1;
|
||||
}
|
||||
|
||||
// Update current window size
|
||||
this._customSizes.set(index, newSize);
|
||||
|
||||
// Adjust adjacent window only if it has a custom size
|
||||
// When both windows have custom sizes, always apply opposite delta to maintain total width
|
||||
let oldAdjacentSize: number | undefined = undefined;
|
||||
if (adjacentIndex >= 0 && adjacentIndex < this._tiledItems.length &&
|
||||
this._customSizes.has(adjacentIndex)) {
|
||||
const adjacentItem = this._tiledItems[adjacentIndex];
|
||||
if (adjacentItem instanceof WindowWrapper) {
|
||||
oldAdjacentSize = this._customSizes.get(adjacentIndex)!;
|
||||
const newAdjacentSize = oldAdjacentSize - delta;
|
||||
|
||||
// Check if adjacent window allows resize
|
||||
if (!adjacentItem.getWindow().allows_resize()) {
|
||||
Logger.log("Adjacent window doesn't allow resize, reverting");
|
||||
this._customSizes.set(index, oldSize);
|
||||
} else {
|
||||
// Always apply the opposite delta to the adjacent window
|
||||
// This keeps the total width constant
|
||||
this._customSizes.set(adjacentIndex, newAdjacentSize);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Call tileWindows during resize to update all window positions
|
||||
// Skip retry logic during active resize to avoid jitter
|
||||
this.tileWindows(true);
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
113
src/wm/monitor.ts
Normal file
113
src/wm/monitor.ts
Normal file
@@ -0,0 +1,113 @@
|
||||
import {WindowWrapper} from "./window.js";
|
||||
import {Rect} from "../utils/rect.js";
|
||||
import queueEvent from "../utils/events.js";
|
||||
import {Logger} from "../utils/logger.js";
|
||||
import Meta from "gi://Meta";
|
||||
import Mtk from "@girs/mtk-17";
|
||||
|
||||
import WindowContainer from "./container.js";
|
||||
import Window = Meta.Window;
|
||||
|
||||
export default class Monitor {
|
||||
|
||||
_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);
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
|
||||
windowManuallyResized(win_id: number): void {
|
||||
// Find which workspace contains the window and notify it
|
||||
for (const container of this._workspaces) {
|
||||
const win = container.getWindow(win_id);
|
||||
if (win) {
|
||||
container.windowManuallyResized(win_id);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
resetAllWindowSizes(): void {
|
||||
for (const container of this._workspaces) {
|
||||
container.resetAllWindowSizes();
|
||||
}
|
||||
}
|
||||
|
||||
windowResizing(win_id: number, resizeOp: Meta.GrabOp): void {
|
||||
// Find which workspace contains the window and notify it
|
||||
for (const container of this._workspaces) {
|
||||
const win = container.getWindow(win_id);
|
||||
if (win) {
|
||||
container.windowResizing(win_id, resizeOp);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
159
src/wm/window.ts
Normal file
159
src/wm/window.ts
Normal file
@@ -0,0 +1,159 @@
|
||||
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";
|
||||
import queueEvent from "../utils/events.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;
|
||||
_dragging: boolean = false;
|
||||
|
||||
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();
|
||||
}
|
||||
|
||||
startDragging(): void {
|
||||
this._dragging = true;
|
||||
}
|
||||
stopDragging(): void {
|
||||
Logger.log("STOPPED DRAGGING")
|
||||
this._dragging = false;
|
||||
}
|
||||
|
||||
// setParent(parent: WindowContainer): void {
|
||||
// this._parent = parent;
|
||||
// }
|
||||
//
|
||||
// getParent(): WindowContainer | null {
|
||||
// if (this._parent == null) {
|
||||
// Logger.warn(`Attempting to get parent for window without parent ${JSON.stringify(this)}`);
|
||||
// }
|
||||
// return this._parent
|
||||
// }
|
||||
|
||||
connectWindowSignals(
|
||||
windowManager: IWindowManager,
|
||||
): void {
|
||||
const windowId = this._window.get_id()
|
||||
// Handle window destruction
|
||||
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.is_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);
|
||||
}),
|
||||
this._window.connect("size-changed", (_metaWindow) => {
|
||||
windowManager.handleWindowSizeChanged(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);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
safelyResizeWindow(rect: Rect, _retry: number = 2, _skipRetry: boolean = false): void {
|
||||
// Keep minimal logging
|
||||
// Note: we allow resizing even during drag operations to support position updates
|
||||
// The dragging flag only prevents REORDERING, not position/size changes
|
||||
// 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);
|
||||
let new_rect = this._window.get_frame_rect();
|
||||
if (!_skipRetry && _retry > 0 && (new_rect.x != rect.x || rect.y != new_rect.y || rect.width < new_rect.width || rect.height < new_rect.height)) {
|
||||
Logger.warn("RESIZING FAILED AS SMALLER", new_rect.x, new_rect.y, new_rect.width, new_rect.height, rect.x, rect.y, rect.width, rect.height);
|
||||
queueEvent({
|
||||
name: "attempting_delayed_resize",
|
||||
callback: () => {
|
||||
this.safelyResizeWindow(rect, _retry-1, _skipRetry);
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
487
src/wm/windowManager.ts
Normal file
487
src/wm/windowManager.ts
Normal file
@@ -0,0 +1,487 @@
|
||||
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;
|
||||
|
||||
handleWindowSizeChanged(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;
|
||||
_changingGrabbedMonitor: boolean = false;
|
||||
_resizingWindow: boolean = false;
|
||||
_resizeOp: Meta.GrabOp | null = null;
|
||||
|
||||
_showingOverview: boolean = false;
|
||||
|
||||
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!")
|
||||
if (this._showingOverview) {
|
||||
if (this._getWrappedWindow(window) !== undefined) {
|
||||
Logger.log("OVERVIEW - MOVING")
|
||||
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._showingOverview = false;
|
||||
this._tileMonitors();
|
||||
// const eventObj = {
|
||||
// name: "focus-after-overview",
|
||||
// callback: () => {
|
||||
// Logger.log("FOCUSING AFTER OVERVIEW");
|
||||
// },
|
||||
// };
|
||||
// this.queueEvent(eventObj);
|
||||
}),
|
||||
Main.overview.connect("showing", () => {
|
||||
this._showingOverview = true;
|
||||
Logger.log("SHOWING OVERVIEW");
|
||||
}),
|
||||
];
|
||||
|
||||
|
||||
}
|
||||
|
||||
public disable(): void {
|
||||
Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!")
|
||||
// Disconnect the focus signal and remove any existing borders
|
||||
this.disconnectSignals();
|
||||
this.removeAllWindows();
|
||||
}
|
||||
|
||||
removeAllWindows(): void {
|
||||
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", op);
|
||||
Logger.log(display, window, op)
|
||||
Logger.log(window.get_monitor())
|
||||
|
||||
const isResizing = this._isResizeOperation(op);
|
||||
if (isResizing) {
|
||||
this._resizingWindow = true;
|
||||
this._resizeOp = op;
|
||||
// Don't mark as dragging during resize - we need to update positions freely
|
||||
} else {
|
||||
this._getWrappedWindow(window)?.startDragging();
|
||||
}
|
||||
|
||||
this._grabbedWindowMonitor = window.get_monitor();
|
||||
this._grabbedWindowId = window.get_id();
|
||||
}
|
||||
|
||||
_isResizeOperation(op: Meta.GrabOp): boolean {
|
||||
return op === Meta.GrabOp.RESIZING_E ||
|
||||
op === Meta.GrabOp.RESIZING_W ||
|
||||
op === Meta.GrabOp.RESIZING_N ||
|
||||
op === Meta.GrabOp.RESIZING_S ||
|
||||
op === Meta.GrabOp.RESIZING_NE ||
|
||||
op === Meta.GrabOp.RESIZING_NW ||
|
||||
op === Meta.GrabOp.RESIZING_SE ||
|
||||
op === Meta.GrabOp.RESIZING_SW;
|
||||
}
|
||||
|
||||
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())
|
||||
|
||||
// Check if this was a resize operation
|
||||
if (this._isResizeOperation(op)) {
|
||||
const monitor = this._monitors.get(window.get_monitor());
|
||||
if (monitor) {
|
||||
monitor.windowManuallyResized(window.get_id());
|
||||
}
|
||||
}
|
||||
|
||||
this._resizingWindow = false;
|
||||
this._resizeOp = null;
|
||||
this._grabbedWindowId = _UNUSED_WINDOW_ID;
|
||||
this._getWrappedWindow(window)?.stopDragging();
|
||||
this._tileMonitors();
|
||||
Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
|
||||
}
|
||||
|
||||
_getWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
|
||||
let wrapped = undefined;
|
||||
for (const monitor of this._monitors.values()) {
|
||||
wrapped = monitor.getWindow(window.get_id());
|
||||
if (wrapped !== undefined) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return wrapped;
|
||||
}
|
||||
|
||||
_getAndRemoveWrappedWindow(window: Meta.Window): WindowWrapper | undefined {
|
||||
let wrapped = undefined;
|
||||
for (const monitor of this._monitors.values()) {
|
||||
wrapped = monitor.getWindow(window.get_id());
|
||||
if (wrapped !== undefined) {
|
||||
monitor.removeWindow(wrapped);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return wrapped;
|
||||
}
|
||||
|
||||
_moveWindowToMonitor(window: Meta.Window, monitorId: number): void {
|
||||
let wrapped = this._getAndRemoveWrappedWindow(window);
|
||||
if (wrapped === undefined) {
|
||||
Logger.error("WINDOW NOT DEFINED")
|
||||
wrapped = new WindowWrapper(window, this.handleWindowMinimized.bind(this));
|
||||
wrapped.connectWindowSignals(this);
|
||||
}
|
||||
let new_mon = this._monitors.get(monitorId);
|
||||
new_mon?.addWindow(wrapped)
|
||||
this._grabbedWindowMonitor = monitorId;
|
||||
}
|
||||
|
||||
public handleWindowPositionChanged(winWrap: WindowWrapper): void {
|
||||
if (this._changingGrabbedMonitor) {
|
||||
return;
|
||||
}
|
||||
if (winWrap.getWindowId() === this._grabbedWindowId) {
|
||||
// Check if we're doing a pure NSEW resize - if so, don't allow position-based swapping
|
||||
if (this._resizingWindow && this._resizeOp) {
|
||||
const isPureNSEWResize =
|
||||
this._resizeOp === Meta.GrabOp.RESIZING_E ||
|
||||
this._resizeOp === Meta.GrabOp.RESIZING_W ||
|
||||
this._resizeOp === Meta.GrabOp.RESIZING_N ||
|
||||
this._resizeOp === Meta.GrabOp.RESIZING_S;
|
||||
|
||||
if (isPureNSEWResize) {
|
||||
// Skip itemDragged - don't allow swaps during NSEW resize
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
const [mouseX, mouseY, _] = global.get_pointer();
|
||||
|
||||
let monitorIndex = -1;
|
||||
for (let i = 0; i < global.display.get_n_monitors(); i++) {
|
||||
const workArea = global.workspace_manager.get_active_workspace().get_work_area_for_monitor(i);
|
||||
if (mouseX >= workArea.x && mouseX < workArea.x + workArea.width &&
|
||||
mouseY >= workArea.y && mouseY < workArea.y + workArea.height) {
|
||||
monitorIndex = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (monitorIndex === -1) {
|
||||
return
|
||||
}
|
||||
|
||||
if (monitorIndex !== this._grabbedWindowMonitor) {
|
||||
this._changingGrabbedMonitor = true;
|
||||
this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex);
|
||||
this._changingGrabbedMonitor = false
|
||||
}
|
||||
this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
|
||||
}
|
||||
}
|
||||
|
||||
public handleWindowSizeChanged(winWrap: WindowWrapper): void {
|
||||
if (this._resizingWindow && winWrap.getWindowId() === this._grabbedWindowId) {
|
||||
// Check if this is a valid resize direction for the container
|
||||
const monitor = this._monitors.get(winWrap.getWindow().get_monitor());
|
||||
if (monitor && this._resizeOp) {
|
||||
monitor.windowResizing(winWrap.getWindowId(), this._resizeOp);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public handleWindowMinimized(winWrap: WindowWrapper): void {
|
||||
const monitor_id = winWrap.getWindow().get_monitor()
|
||||
this._minimizedItems.set(winWrap.getWindowId(), winWrap);
|
||||
this._monitors.get(monitor_id)?.removeWindow(winWrap);
|
||||
this._tileMonitors()
|
||||
}
|
||||
|
||||
public handleWindowUnminimized(winWrap: WindowWrapper): void {
|
||||
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() {
|
||||
const workspace = global.workspace_manager.get_active_workspace();
|
||||
const windows = global.display.get_tab_list(Meta.TabList.NORMAL, workspace);
|
||||
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.bind(this))
|
||||
wrapper.connectWindowSignals(this);
|
||||
this._addWindowWrapperToMonitor(wrapper);
|
||||
|
||||
}
|
||||
|
||||
_addWindowWrapperToMonitor(winWrap: WindowWrapper) {
|
||||
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()
|
||||
}
|
||||
}
|
||||
|
||||
block_titles = [
|
||||
"org.gnome.Shell.Extensions",
|
||||
]
|
||||
|
||||
_isWindowTilingBlocked(window: Meta.Window) : boolean {
|
||||
Logger.info("title", window.get_title());
|
||||
Logger.info("description", window.get_description());
|
||||
Logger.info("class", window.get_wm_class());
|
||||
Logger.info("class", window.get_wm_class_instance());
|
||||
return this.block_titles.some((title) => {
|
||||
if (window.get_wm_class() === title) {
|
||||
Logger.log("WINDOW BLOCKED FROM TILING", window.get_title());
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
});
|
||||
}
|
||||
|
||||
_isWindowTileable(window: Meta.Window) {
|
||||
|
||||
if (!window || !window.get_compositor_private()) {
|
||||
return false;
|
||||
}
|
||||
if (this._isWindowTilingBlocked(window)) {
|
||||
return false;
|
||||
}
|
||||
const windowType = window.get_window_type();
|
||||
Logger.log("WINDOW TILING CHECK",);
|
||||
|
||||
// Skip certain types of windows
|
||||
return !window.is_skip_taskbar() &&
|
||||
windowType !== Meta.WindowType.DESKTOP &&
|
||||
windowType !== Meta.WindowType.DOCK &&
|
||||
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;
|
||||
}
|
||||
|
||||
public resetAllWindowSizes(): void {
|
||||
Logger.log("Resetting all custom window sizes");
|
||||
this._monitors.forEach((monitor: Monitor) => {
|
||||
monitor.resetAllWindowSizes();
|
||||
});
|
||||
this._tileMonitors();
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -12,10 +12,10 @@
|
||||
},
|
||||
"include": [
|
||||
"ambient.d.ts",
|
||||
"prefs.ts",
|
||||
"src/**/*"
|
||||
],
|
||||
"files": [
|
||||
"extension.ts",
|
||||
"winGroup.ts",
|
||||
"prefs.ts"
|
||||
"extension.ts"
|
||||
],
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user