feat: adding active window selection and refactoring keybindings
This commit is contained in:
Lucas Oskorep
@@ -10,6 +10,13 @@ export enum Layout {
|
||||
TABBED = 2,
|
||||
}
|
||||
|
||||
export enum Direction {
|
||||
LEFT = 'left',
|
||||
RIGHT = 'right',
|
||||
UP = 'up',
|
||||
DOWN = 'down',
|
||||
}
|
||||
|
||||
// Returns equal ratios summing exactly to 1.0, with float drift absorbed by the last slot.
|
||||
function equalRatios(n: number): number[] {
|
||||
if (n <= 0) return [];
|
||||
@@ -537,4 +544,145 @@ export default class WindowContainer {
|
||||
this._resetRatios();
|
||||
this.drawWindows();
|
||||
}
|
||||
|
||||
// --- Directional Move (swap) ------------------------------------------------
|
||||
|
||||
/**
|
||||
* Swap the window at `windowId` with its neighbour in the given direction.
|
||||
* Returns true if the swap occurred, false if the window is already at the edge
|
||||
* or the direction is perpendicular to the container axis.
|
||||
*/
|
||||
swapWindowInDirection(windowId: number, direction: Direction): boolean {
|
||||
const currentIndex = this._getIndexOfWindow(windowId);
|
||||
if (currentIndex === -1) return false;
|
||||
|
||||
if (this.isTabbed()) {
|
||||
// Tabbed: left/up = swap toward start, right/down = swap toward end
|
||||
const delta = (direction === Direction.LEFT || direction === Direction.UP) ? -1 : 1;
|
||||
const newIndex = currentIndex + delta;
|
||||
if (newIndex < 0 || newIndex >= this._tiledItems.length) return false;
|
||||
|
||||
this._swapItems(currentIndex, newIndex);
|
||||
this._activeTabIndex = newIndex;
|
||||
this._updateTabBar();
|
||||
this.drawWindows();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Accordion mode — only swap along the container's axis
|
||||
const isAlongAxis =
|
||||
(this._orientation === Layout.ACC_HORIZONTAL && (direction === Direction.LEFT || direction === Direction.RIGHT)) ||
|
||||
(this._orientation === Layout.ACC_VERTICAL && (direction === Direction.UP || direction === Direction.DOWN));
|
||||
|
||||
if (!isAlongAxis) return false;
|
||||
|
||||
const delta = (direction === Direction.LEFT || direction === Direction.UP) ? -1 : 1;
|
||||
const newIndex = currentIndex + delta;
|
||||
if (newIndex < 0 || newIndex >= this._tiledItems.length) return false;
|
||||
|
||||
this._swapItems(currentIndex, newIndex);
|
||||
this.drawWindows();
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Swap two items in `_tiledItems` and their corresponding split ratios.
|
||||
*/
|
||||
private _swapItems(indexA: number, indexB: number): void {
|
||||
[this._tiledItems[indexA], this._tiledItems[indexB]] =
|
||||
[this._tiledItems[indexB], this._tiledItems[indexA]];
|
||||
[this._splitRatios[indexA], this._splitRatios[indexB]] =
|
||||
[this._splitRatios[indexB], this._splitRatios[indexA]];
|
||||
}
|
||||
|
||||
// --- Directional Navigation ------------------------------------------------
|
||||
|
||||
/**
|
||||
* Given a window inside this container and a direction, return the window ID
|
||||
* that should receive focus, or null if the edge of the container is reached.
|
||||
*
|
||||
* Behaviour by layout mode:
|
||||
* - ACC_HORIZONTAL: left/right moves to the prev/next item; up/down → null
|
||||
* - ACC_VERTICAL: up/down moves to the prev/next item; left/right → null
|
||||
* - TABBED: left/right moves to the prev/next tab; up/down → null
|
||||
*/
|
||||
getAdjacentWindowId(windowId: number, direction: Direction): number | null {
|
||||
const currentIndex = this._getIndexOfWindow(windowId);
|
||||
if (currentIndex === -1) return null;
|
||||
|
||||
if (this.isTabbed()) {
|
||||
// Tabbed: left/right cycle through tabs
|
||||
if (direction === Direction.LEFT || direction === Direction.UP) {
|
||||
const newIndex = currentIndex - 1;
|
||||
if (newIndex < 0) return null;
|
||||
return this._windowIdAtIndex(newIndex);
|
||||
}
|
||||
if (direction === Direction.RIGHT || direction === Direction.DOWN) {
|
||||
const newIndex = currentIndex + 1;
|
||||
if (newIndex >= this._tiledItems.length) return null;
|
||||
return this._windowIdAtIndex(newIndex);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
// Accordion mode – only navigate along the container's axis
|
||||
const isAlongAxis =
|
||||
(this._orientation === Layout.ACC_HORIZONTAL && (direction === Direction.LEFT || direction === Direction.RIGHT)) ||
|
||||
(this._orientation === Layout.ACC_VERTICAL && (direction === Direction.UP || direction === Direction.DOWN));
|
||||
|
||||
if (!isAlongAxis) return null;
|
||||
|
||||
const delta = (direction === Direction.LEFT || direction === Direction.UP) ? -1 : 1;
|
||||
const newIndex = currentIndex + delta;
|
||||
if (newIndex < 0 || newIndex >= this._tiledItems.length) return null;
|
||||
|
||||
return this._windowIdAtIndex(newIndex);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the "representative" window ID for the item at `index`.
|
||||
* If the item is a WindowWrapper, return its ID directly.
|
||||
* If it's a nested WindowContainer, return the first (or last) leaf window.
|
||||
*/
|
||||
private _windowIdAtIndex(index: number): number | null {
|
||||
const item = this._tiledItems[index];
|
||||
if (!item) return null;
|
||||
|
||||
if (item instanceof WindowWrapper) {
|
||||
return item.getWindowId();
|
||||
}
|
||||
if (item instanceof WindowContainer) {
|
||||
return item._firstLeafWindowId();
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the window ID of the first leaf window in this container (depth-first).
|
||||
*/
|
||||
_firstLeafWindowId(): number | null {
|
||||
for (const item of this._tiledItems) {
|
||||
if (item instanceof WindowWrapper) return item.getWindowId();
|
||||
if (item instanceof WindowContainer) {
|
||||
const id = item._firstLeafWindowId();
|
||||
if (id !== null) return id;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the window ID of the last leaf window in this container (depth-first from end).
|
||||
*/
|
||||
_lastLeafWindowId(): number | null {
|
||||
for (let i = this._tiledItems.length - 1; i >= 0; i--) {
|
||||
const item = this._tiledItems[i];
|
||||
if (item instanceof WindowWrapper) return item.getWindowId();
|
||||
if (item instanceof WindowContainer) {
|
||||
const id = item._lastLeafWindowId();
|
||||
if (id !== null) return id;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
+165
-1
@@ -5,7 +5,7 @@ import {WindowWrapper} from './window.js';
|
||||
import * as Main from "resource:///org/gnome/shell/ui/main.js";
|
||||
import {Logger} from "../utils/logger.js";
|
||||
import Monitor from "./monitor.js";
|
||||
import WindowContainer, {Layout} from "./container.js";
|
||||
import WindowContainer, {Direction, Layout} from "./container.js";
|
||||
import {Rect} from "../utils/rect.js";
|
||||
|
||||
|
||||
@@ -565,6 +565,170 @@ export default class WindowManager implements IWindowManager {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Move (swap) the active window in the given direction within its container.
|
||||
*
|
||||
* 1. Find the container holding the active window.
|
||||
* 2. Ask the container to swap the window with its neighbour in that direction.
|
||||
* 3. Re-tile to apply the new layout.
|
||||
*/
|
||||
public moveInDirection(direction: Direction): void {
|
||||
if (this._activeWindowId === null) {
|
||||
Logger.warn("No active window, cannot move in direction");
|
||||
return;
|
||||
}
|
||||
|
||||
const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
|
||||
if (!container) {
|
||||
Logger.warn("Could not find container for active window");
|
||||
return;
|
||||
}
|
||||
|
||||
const swapped = container.swapWindowInDirection(this._activeWindowId, direction);
|
||||
if (swapped) {
|
||||
Logger.info(`Moved window ${this._activeWindowId} ${direction}`);
|
||||
this._tileMonitors();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Move focus to the adjacent window in the given direction.
|
||||
*
|
||||
* 1. Find the container holding the active window.
|
||||
* 2. Ask the container for the adjacent window in that direction.
|
||||
* 3. If the container returns null (at the edge), try cross-monitor navigation.
|
||||
* 4. Activate (focus) the target window.
|
||||
*/
|
||||
public focusInDirection(direction: Direction): void {
|
||||
if (this._activeWindowId === null) {
|
||||
Logger.warn("No active window, cannot focus in direction");
|
||||
return;
|
||||
}
|
||||
|
||||
const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
|
||||
if (!container) {
|
||||
Logger.warn("Could not find container for active window");
|
||||
return;
|
||||
}
|
||||
|
||||
const targetId = container.getAdjacentWindowId(this._activeWindowId, direction);
|
||||
if (targetId !== null) {
|
||||
this._activateWindowById(targetId);
|
||||
return;
|
||||
}
|
||||
|
||||
// At the edge of the container — try cross-monitor navigation
|
||||
const crossMonitorId = this._findCrossMonitorWindow(direction);
|
||||
if (crossMonitorId !== null) {
|
||||
this._activateWindowById(crossMonitorId);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Focus a window by its ID. Finds the Meta.Window and calls activate().
|
||||
*/
|
||||
private _activateWindowById(windowId: number): void {
|
||||
for (const monitor of this._monitors.values()) {
|
||||
const wrapped = monitor.getWindow(windowId);
|
||||
if (wrapped) {
|
||||
const metaWindow = wrapped.getWindow();
|
||||
metaWindow.activate(global.get_current_time());
|
||||
return;
|
||||
}
|
||||
}
|
||||
Logger.warn(`_activateWindowById: window ${windowId} not found in any monitor`);
|
||||
}
|
||||
|
||||
/**
|
||||
* When at the edge of a container, find the nearest window on the adjacent
|
||||
* monitor in the given direction.
|
||||
*
|
||||
* Determines the adjacent monitor by comparing work-area centres:
|
||||
* - LEFT: monitor whose work-area is to the left of the current one
|
||||
* - RIGHT: monitor whose work-area is to the right of the current one
|
||||
* - UP: monitor whose work-area is above the current one
|
||||
* - DOWN: monitor whose work-area is below the current one
|
||||
*
|
||||
* On the target monitor, picks the edge-most window:
|
||||
* - Navigating LEFT → last (rightmost) window of the target container
|
||||
* - Navigating RIGHT → first (leftmost) window of the target container
|
||||
* - Navigating UP → last (bottommost) window
|
||||
* - Navigating DOWN → first (topmost) window
|
||||
*/
|
||||
private _findCrossMonitorWindow(direction: Direction): number | null {
|
||||
if (this._activeWindowId === null) return null;
|
||||
|
||||
// Find which monitor the active window is on
|
||||
let currentMonitorId: number | null = null;
|
||||
for (const [monId, monitor] of this._monitors.entries()) {
|
||||
if (monitor.getWindow(this._activeWindowId) !== undefined) {
|
||||
currentMonitorId = monId;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (currentMonitorId === null) return null;
|
||||
|
||||
const currentMonitor = this._monitors.get(currentMonitorId)!;
|
||||
const currentArea = currentMonitor._workArea;
|
||||
const currentCenterX = currentArea.x + currentArea.width / 2;
|
||||
const currentCenterY = currentArea.y + currentArea.height / 2;
|
||||
|
||||
// Find the best adjacent monitor in the given direction
|
||||
let bestMonitorId: number | null = null;
|
||||
let bestDistance = Infinity;
|
||||
|
||||
for (const [monId, monitor] of this._monitors.entries()) {
|
||||
if (monId === currentMonitorId) continue;
|
||||
|
||||
const area = monitor._workArea;
|
||||
const centerX = area.x + area.width / 2;
|
||||
const centerY = area.y + area.height / 2;
|
||||
|
||||
let isInDirection = false;
|
||||
let distance = Infinity;
|
||||
|
||||
switch (direction) {
|
||||
case Direction.LEFT:
|
||||
isInDirection = centerX < currentCenterX;
|
||||
distance = currentCenterX - centerX;
|
||||
break;
|
||||
case Direction.RIGHT:
|
||||
isInDirection = centerX > currentCenterX;
|
||||
distance = centerX - currentCenterX;
|
||||
break;
|
||||
case Direction.UP:
|
||||
isInDirection = centerY < currentCenterY;
|
||||
distance = currentCenterY - centerY;
|
||||
break;
|
||||
case Direction.DOWN:
|
||||
isInDirection = centerY > currentCenterY;
|
||||
distance = centerY - currentCenterY;
|
||||
break;
|
||||
}
|
||||
|
||||
if (isInDirection && distance < bestDistance) {
|
||||
bestDistance = distance;
|
||||
bestMonitorId = monId;
|
||||
}
|
||||
}
|
||||
|
||||
if (bestMonitorId === null) return null;
|
||||
|
||||
const targetMonitor = this._monitors.get(bestMonitorId)!;
|
||||
const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
|
||||
if (activeWorkspaceIndex >= targetMonitor._workspaces.length) return null;
|
||||
|
||||
const targetContainer = targetMonitor._workspaces[activeWorkspaceIndex];
|
||||
if (targetContainer._tiledItems.length === 0) return null;
|
||||
|
||||
// Pick the window on the "entry edge" of the target container
|
||||
if (direction === Direction.LEFT || direction === Direction.UP) {
|
||||
return targetContainer._lastLeafWindowId();
|
||||
} else {
|
||||
return targetContainer._firstLeafWindowId();
|
||||
}
|
||||
}
|
||||
|
||||
public printTreeStructure(): void {
|
||||
Logger.info("=".repeat(80));
|
||||
Logger.info("WINDOW TREE STRUCTURE");
|
||||
|
||||
Reference in New Issue
Block a user