feat: update version in package.json

fix: tab bars no longer shown in overview.  Tab bars show name of app with pipe and then title of the app

.gitea/workflows/build.yaml

@@ -10,13 +10,13 @@ on:
 
 jobs:
   build:
-    runs-on: ubuntu-latest
+    runs-on: archlinux
     container:
-      image: node:20
+      image: node:25
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Install pnpm and TypeScript
         run: npm install -g pnpm typescript@5.8.3
@@ -48,16 +48,16 @@ jobs:
 
   release:
     needs: build
-    runs-on: ubuntu-latest
+    runs-on: archlinux
     if: github.ref == 'refs/heads/main' && github.event_name == 'push'
     environment:
       name: production
     container:
-      image: node:20
+      image: node:25
 
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
 
       - name: Download artifact
         uses: actions/download-artifact@v3

.nvmrc

@@ -1 +1 @@
-v20
+24

README.md

@@ -1 +1,30 @@
-# Aerospike Gnome (Tiling Window Manager)
+# Aerospike Gnome (Tiling Window Manager)
+
+Aerospike is a simple and opinionated tiling window manager for gnome.
+
+This project takes inspiration from previous gnome tiling window managers such
+as [forge](https://github.com/forge-ext/forge)
+and [cosmic-shell](https://github.com/pop-os/gnome-shell-extension-pop-cosmic) as well as
+MacOS tiling WMs, mainly [Aerospace](https://github.com/nikitabobko/AeroSpace) (not affiliated).
+
+## Current Features
+
+- Auto-tiling
+- Accordion layouts with variable sizes
+- Tabbed layouts
+- Tree-based (albeit set depth of 2 for now) container-window paired layout similar to Aerospace
+- Diagram for this is pending
+
+## Planned functionality
+
+- Full Keyboard control w/window movement
+- Sub-containers (more tree layers than the 1 supported for now)
+- Gap size customization
+
+## Not currently planned
+
+- Active window borders
+    - See my other extension for a rainbow or static border - [PrettyBorders](https://github.com//pretty-borders)
+- complicated window dragging features and uis
+    - Aerospace supports control + drag to combine windows while moving with the mouse, and normal window dragging.
+

extension.ts

@@ -1,9 +1,10 @@
 import Meta from 'gi://Meta';
-import {Extension, ExtensionMetadata} from 'resource:///org/gnome/shell/extensions/extension.js';
+import {Extension} from 'resource:///org/gnome/shell/extensions/extension.js';
 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 {Direction} from './src/wm/container.js'
 import {Logger} from "./src/utils/logger.js";
 
 export default class aerospike extends Extension {
@@ -11,18 +12,23 @@ export default class aerospike extends Extension {
     keyBindings: Map<string, number>;
     windowManager: WindowManager;
 
-    constructor(metadata: ExtensionMetadata) {
+    constructor(metadata: ConstructorParameters<typeof Extension>[0]) {
         super(metadata);
         this.settings = this.getSettings('org.gnome.shell.extensions.aerospike');
         this.keyBindings = new Map();
-        this.windowManager = new WindowManager();
+        this.windowManager = new WindowManager(this.settings);
     }
 
     enable() {
-        Logger.log("STARTING AEROSPIKE!")
+        try {
-        this.bindSettings();
+            Logger.log("STARTING AEROSPIKE!")
-        this.setupKeybindings();
+            this.bindSettings();
-        this.windowManager.enable()
+            this.setupKeybindings();
+            this.windowManager.enable()
+            Logger.log("AEROSPIKE ENABLED SUCCESSFULLY")
+        } catch (e) {
+            Logger.error("AEROSPIKE ENABLE FAILED", e);
+        }
     }
 
     disable() {
@@ -30,85 +36,41 @@ export default class aerospike extends Extension {
         this.removeKeybindings()
     }
 
+    private keybindingActions(): Record<string, () => void> {
+        return {
+            'print-tree':         () => { this.windowManager.printTreeStructure(); },
+            'toggle-orientation': () => { this.windowManager.toggleActiveContainerOrientation(); },
+            'reset-ratios':       () => { this.windowManager.resetActiveContainerRatios(); },
+            'toggle-tabbed':      () => { this.windowManager.toggleActiveContainerTabbed(); },
+            'focus-left':         () => { this.windowManager.focusInDirection(Direction.LEFT); },
+            'focus-right':        () => { this.windowManager.focusInDirection(Direction.RIGHT); },
+            'focus-up':           () => { this.windowManager.focusInDirection(Direction.UP); },
+            'focus-down':         () => { this.windowManager.focusInDirection(Direction.DOWN); },
+            'move-left':          () => { this.windowManager.moveInDirection(Direction.LEFT); },
+            'move-right':         () => { this.windowManager.moveInDirection(Direction.RIGHT); },
+            'move-up':            () => { this.windowManager.moveInDirection(Direction.UP); },
+            'move-down':          () => { this.windowManager.moveInDirection(Direction.DOWN); },
+        };
+    }
 
     private bindSettings() {
-        // Monitor settings changes
+        const keybindings = Object.keys(this.keybindingActions());
-        this.settings.connect('changed::move-left', () => {
+        keybindings.forEach(name => {
-            log(`Keybinding 1 changed to: ${this.settings.get_strv('move-left')}`);
+            this.settings.connect(`changed::${name}`, () => {
-            this.refreshKeybinding('move-left');
+                log(`${name} keybinding changed to: ${this.settings.get_strv(name)}`);
-        });
+                this.refreshKeybinding(name);
-
+            });
-        this.settings.connect('changed::move-right', () => {
-            log(`Keybinding 2 changed to: ${this.settings.get_strv('move-right')}`);
-            this.refreshKeybinding('move-right');
-        });
-
-        this.settings.connect('changed::join-with-left', () => {
-            log(`Keybinding 3 changed to: ${this.settings.get_strv('join-with-left')}`);
-            this.refreshKeybinding('join-with-left');
-        });
-
-        this.settings.connect('changed::join-with-right', () => {
-            log(`Keybinding 4 changed to: ${this.settings.get_strv('join-with-right')}`);
-            this.refreshKeybinding('join-with-right');
-        });
-
-        this.settings.connect('changed::print-tree', () => {
-            log(`Print tree keybinding changed to: ${this.settings.get_strv('print-tree')}`);
-            this.refreshKeybinding('print-tree');
-        });
-
-        this.settings.connect('changed::toggle-orientation', () => {
-            log(`Toggle orientation keybinding changed to: ${this.settings.get_strv('toggle-orientation')}`);
-            this.refreshKeybinding('toggle-orientation');
-        });
-
-        this.settings.connect('changed::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);
         }
 
-        switch (settingName) {
+        const action = this.keybindingActions()[settingName];
-            case 'move-left':
+        if (action) this.bindKeybinding(settingName, action);
-                this.bindKeybinding('move-left', () => {
-                    Logger.info('Keybinding 1 was pressed!');
-                });
-                break;
-            case 'move-right':
-                this.bindKeybinding('move-right', () => {
-                    Logger.info('Keybinding 2 was pressed!');
-                });
-                break;
-            case 'join-with-left':
-                this.bindKeybinding('join-with-left', () => {
-                    Logger.info('Keybinding 3 was pressed!');
-                });
-                break;
-            case 'join-with-right':
-                this.bindKeybinding('join-with-right', () => {
-                    Logger.info('Keybinding 4 was pressed!');
-                });
-                break;
-            case 'print-tree':
-                this.bindKeybinding('print-tree', () => {
-                    this.windowManager.printTreeStructure();
-                });
-                break;
-            case 'toggle-orientation':
-                this.bindKeybinding('toggle-orientation', () => {
-                    this.windowManager.toggleActiveContainerOrientation();
-                });
-                break;
-        }
     }
 
     private removeKeybindings() {
@@ -119,29 +81,10 @@ export default class aerospike extends Extension {
     }
 
     private setupKeybindings() {
-        this.bindKeybinding('move-left', () => {
+        const actions = this.keybindingActions();
-            Logger.info('Keybinding 1 was pressed!');
+        for (const [name, action] of Object.entries(actions)) {
-        });
+            this.bindKeybinding(name, action);
-
+        }
-        this.bindKeybinding('move-right', () => {
-            Logger.info('Keybinding 2 was pressed!');
-        });
-
-        this.bindKeybinding('join-with-left', () => {
-            Logger.info('Keybinding 3 was pressed!');
-        });
-
-        this.bindKeybinding('join-with-right', () => {
-            Logger.info('Keybinding 4 was pressed!');
-        });
-
-        this.bindKeybinding('print-tree', () => {
-            this.windowManager.printTreeStructure();
-        });
-
-        this.bindKeybinding('toggle-orientation', () => {
-            this.windowManager.toggleActiveContainerOrientation();
-        });
     }
 
     private bindKeybinding(settingName: string, callback: () => void) {
@@ -161,7 +104,4 @@ export default class aerospike extends Extension {
 
         this.keyBindings.set(settingName, keyBindingAction);
     }
-
+}
-
-
-}

justfile

@@ -8,7 +8,7 @@ packages:
 
 build: packages && build-schemas
     rm -rf dist/*
-    tsc
+    pnpm exec tsc
     cp metadata.json dist/
     cp stylesheet.css dist/
     mkdir -p dist/schemas

package.json

@@ -1,6 +1,6 @@
 {
   "name": "aerospike",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A TypeScript GNOME Extension for Pretty Borders",
   "type": "module",
   "private": true,
@@ -9,7 +9,7 @@
     "url": "git+https://gitlab.com/lucasoskorep/aerospike"
   },
   "author": "Lucas Oskorep <lucas.oskorep@gmail.com>",
-  "license": "LGPL-3.0-or-later",
+  "license": "GPL-3.0-only",
   "bugs": {
     "url": "https://github.com/example/my-extension/issues"
   },
@@ -22,12 +22,12 @@
   },
   "devDependencies": {
     "@girs/gjs": "4.0.0-beta.38",
-    "@girs/gnome-shell": "49.0.1",
+    "@girs/gnome-shell": "49.1.0",
-    "@jest/globals": "^29.7.0",
+    "@jest/globals": "^30.0.0",
-    "@types/jest": "^29.5.12",
+    "@types/jest": "^30.0.0",
-    "eslint": "^9.36.0",
+    "eslint": "^10.0.0",
-    "eslint-plugin-jsdoc": "^50.8.0",
+    "eslint-plugin-jsdoc": "^62.0.0",
-    "jest": "^29.7.0",
+    "jest": "^30.0.0",
     "ts-jest": "^29.1.2",
     "typescript": "^5.9.2"
   },

renovate.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "extends": [
+    "config:recommended"
+  ],
+  "packageRules": [
+    {
+      "matchPackageNames": ["actions/upload-artifact", "actions/download-artifact"],
+      "allowedVersions": "<4"
+    }
+  ]
+}

schemas/org.gnome.shell.extensions.aerospike.gschema.xml

@@ -1,40 +1,72 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <schemalist>
     <schema id="org.gnome.shell.extensions.aerospike" path="/org/gnome/shell/extensions/aerospike/">
-        <key name="dropdown-option" type="s">
+
-            <default>'option1'</default>
+        <key name="focus-left" type="as">
-            <summary>Dropdown selection</summary>
+            <default><![CDATA[['<Super>h']]]></default>
-            <description>Option selected from the dropdown menu</description>
+            <summary>Focus window to the left</summary>
+            <description>Move focus to the window to the left of the current window. In tabbed mode, switches to the previous tab.</description>
         </key>
 
-        <key name="color-selection" type="s">
+        <key name="focus-right" type="as">
-            <default>'rgb(255,0,0)'</default>
+            <default><![CDATA[['<Super>l']]]></default>
-            <summary>Selected color</summary>
+            <summary>Focus window to the right</summary>
-            <description>Color chosen from the color picker</description>
+            <description>Move focus to the window to the right of the current window. In tabbed mode, switches to the next tab.</description>
         </key>
 
+        <key name="focus-up" type="as">
+            <default><![CDATA[['<Super>k']]]></default>
+            <summary>Focus window above</summary>
+            <description>Move focus to the window above the current window.</description>
+        </key>
+
+        <key name="focus-down" type="as">
+            <default><![CDATA[['<Super>j']]]></default>
+            <summary>Focus window below</summary>
+            <description>Move focus to the window below the current window.</description>
+        </key>
+
+
         <key name="move-left" type="as">
-            <default><![CDATA[['<Super>1']]]></default>
+            <default><![CDATA[['<Super><Shift>h']]]></default>
-            <summary>Keybinding for action 1</summary>
+            <summary>Move window to the left</summary>
-            <description>Keyboard shortcut for triggering action 1</description>
+            <description>Move the active window one position to the left within its container</description>
         </key>
 
         <key name="move-right" type="as">
-            <default><![CDATA[['<Super>2']]]></default>
+            <default><![CDATA[['<Super><Shift>l']]]></default>
-            <summary>Keybinding for action 2</summary>
+            <summary>Move window to the right</summary>
-            <description>Keyboard shortcut for triggering action 2</description>
+            <description>Move the active window one position to the right within its container</description>
         </key>
 
-        <key name="join-with-left" type="as">
+        <key name="move-up" type="as">
-            <default><![CDATA[['<Super>3']]]></default>
+            <default><![CDATA[['<Super><Shift>k']]]></default>
-            <summary>Keybinding for action 3</summary>
+            <summary>Move window up</summary>
-            <description>Keyboard shortcut for triggering action 3</description>
+            <description>Move the active window one position up within its container</description>
         </key>
 
-        <key name="join-with-right" type="as">
+        <key name="move-down" type="as">
-            <default><![CDATA[['<Super>4']]]></default>
+            <default><![CDATA[['<Super><Shift>j']]]></default>
-            <summary>Keybinding for action 4</summary>
+            <summary>Move window down</summary>
-            <description>Keyboard shortcut for triggering action 4</description>
+            <description>Move the active window one position down within its container</description>
+        </key>
+
+        <key name="toggle-orientation" type="as">
+            <default><![CDATA[['<Super>comma']]]></default>
+            <summary>Toggle active container orientation</summary>
+            <description>Toggles the orientation of the container holding the active window between horizontal and vertical</description>
+        </key>
+
+        <key name="reset-ratios" type="as">
+            <default><![CDATA[['<Super>z']]]></default>
+            <summary>Reset container ratios to equal splits</summary>
+            <description>Resets all window size ratios in the active window's container to equal splits</description>
+        </key>
+
+        <key name="toggle-tabbed" type="as">
+            <default><![CDATA[['<Super>slash']]]></default>
+            <summary>Toggle tabbed container mode</summary>
+            <description>Toggles the active window's container between tabbed and accordion layout modes</description>
         </key>
 
         <key name="print-tree" type="as">
@@ -43,11 +75,5 @@
             <description>Prints the current tree of containers and windows per monitor to logs</description>
         </key>
 
-        <key name="toggle-orientation" type="as">
-            <default><![CDATA[['<Super><Shift>comma']]]></default>
-            <summary>Toggle active container orientation</summary>
-            <description>Toggles the orientation of the container holding the active window between horizontal and vertical</description>
-        </key>
-
     </schema>
 </schemalist>

src/__tests__/container.test.ts

@@ -20,25 +20,38 @@ jest.mock('../utils/events.js', () => ({
 
 describe('Container Logic Tests', () => {
   describe('Orientation Toggle Logic', () => {
-    enum Orientation {
+    enum Layout {
       HORIZONTAL = 0,
       VERTICAL = 1,
+      TABBED = 2,
     }
 
-    const toggleOrientation = (current: Orientation): Orientation => {
+    const toggleOrientation = (current: Layout): Layout => {
-      return current === Orientation.HORIZONTAL
+      if (current === Layout.TABBED) return Layout.HORIZONTAL;
-        ? Orientation.VERTICAL
+      return current === Layout.HORIZONTAL
-        : Orientation.HORIZONTAL;
+        ? Layout.VERTICAL
+        : Layout.HORIZONTAL;
     };
 
     test('should toggle from HORIZONTAL to VERTICAL', () => {
-      const result = toggleOrientation(Orientation.HORIZONTAL);
+      const result = toggleOrientation(Layout.HORIZONTAL);
-      expect(result).toBe(Orientation.VERTICAL);
+      expect(result).toBe(Layout.VERTICAL);
     });
 
     test('should toggle from VERTICAL to HORIZONTAL', () => {
-      const result = toggleOrientation(Orientation.VERTICAL);
+      const result = toggleOrientation(Layout.VERTICAL);
-      expect(result).toBe(Orientation.HORIZONTAL);
+      expect(result).toBe(Layout.HORIZONTAL);
+    });
+
+    test('should toggle from TABBED to HORIZONTAL', () => {
+      const result = toggleOrientation(Layout.TABBED);
+      expect(result).toBe(Layout.HORIZONTAL);
+    });
+
+    test('enum reverse mapping should return string names', () => {
+      expect(Layout[Layout.HORIZONTAL]).toBe('HORIZONTAL');
+      expect(Layout[Layout.VERTICAL]).toBe('VERTICAL');
+      expect(Layout[Layout.TABBED]).toBe('TABBED');
     });
   });
 
@@ -100,6 +113,71 @@ describe('Container Logic Tests', () => {
     });
   });
 
+  describe('Tabbed Bounds Calculation', () => {
+    const TAB_BAR_HEIGHT = 24;
+
+    test('should give all items the same content rect in tabbed mode', () => {
+      const workArea = { x: 100, y: 0, width: 1000, height: 500 };
+      const itemCount = 3;
+
+      const contentRect = {
+        x: workArea.x,
+        y: workArea.y + TAB_BAR_HEIGHT,
+        width: workArea.width,
+        height: workArea.height - TAB_BAR_HEIGHT,
+      };
+
+      const bounds = Array.from({ length: itemCount }, () => contentRect);
+
+      expect(bounds.length).toBe(3);
+      // All bounds should be identical
+      bounds.forEach(b => {
+        expect(b.x).toBe(100);
+        expect(b.y).toBe(TAB_BAR_HEIGHT);
+        expect(b.width).toBe(1000);
+        expect(b.height).toBe(500 - TAB_BAR_HEIGHT);
+      });
+    });
+
+    test('tab bar rect should occupy top of work area', () => {
+      const workArea = { x: 200, y: 50, width: 800, height: 600 };
+
+      const tabBarRect = {
+        x: workArea.x,
+        y: workArea.y,
+        width: workArea.width,
+        height: TAB_BAR_HEIGHT,
+      };
+
+      expect(tabBarRect.x).toBe(200);
+      expect(tabBarRect.y).toBe(50);
+      expect(tabBarRect.width).toBe(800);
+      expect(tabBarRect.height).toBe(TAB_BAR_HEIGHT);
+    });
+
+    test('active tab index should clamp after removal', () => {
+      let activeTabIndex = 2;
+      const itemCount = 2; // after removing one from 3
+
+      if (activeTabIndex >= itemCount) {
+        activeTabIndex = itemCount - 1;
+      }
+
+      expect(activeTabIndex).toBe(1);
+    });
+
+    test('active tab index should stay at 0 when first item removed', () => {
+      let activeTabIndex = 0;
+      const itemCount = 2; // after removing one from 3
+
+      if (activeTabIndex >= itemCount) {
+        activeTabIndex = itemCount - 1;
+      }
+
+      expect(activeTabIndex).toBe(0);
+    });
+  });
+
   describe('Window Index Finding', () => {
     test('should find window index in array', () => {
       const windows = [

src/prefs/prefs.ts

@@ -2,7 +2,7 @@ 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 {ExtensionPreferences, gettext as _} from 'resource:///org/gnome/Shell/Extensions/js/extensions/prefs.js';
 import {Logger} from "../utils/logger.js";
 import {EntryRow} from "./keybindings.js";
 
@@ -11,160 +11,115 @@ export default class AerospikeExtensions extends ExtensionPreferences {
         // Create settings object
         const settings = this.getSettings('org.gnome.shell.extensions.aerospike');
 
-        // Create a preferences page
+        // Create keybindings page (top-level)
-        const page = new Adw.PreferencesPage({
+        const keybindingsPage = new Adw.PreferencesPage({
-            title: _('Settings'),
+            title: _('Keybindings'),
-            icon_name: 'preferences-system-symbolic',
+            icon_name: 'input-keyboard-symbolic',
         });
-        window.add(page);
+        window.add(keybindingsPage);
 
+        const keybindingMap = this.createKeybindingMap();
 
-        // Create options group
+        // Top-level Keybindings header group with syntax help
-        const optionsGroup = new Adw.PreferencesGroup({
+        const keybindingsHeader = new Adw.PreferencesGroup({
-            title: _('Options'),
+            title: _('Keybindings'),
-        });
-        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);
+        keybindingsPage.add(keybindingsHeader);
 
-        // Add keybinding rows as EntryRows with proper mapping
+        // --- Focus group ---
-        // Use the helper function to create the map object
+        const focusGroup = new Adw.PreferencesGroup({
-        const keybindingMap = this.createKeybindingMap();
+            title: _('Focus'),
-        
+        });
-        keybindingsGroup.add(
+        keybindingsPage.add(focusGroup);
+
+        focusGroup.add(
             new EntryRow({
-                title: _('Action 1'),
+                title: _('Focus Left'),
+                settings: settings,
+                bind: 'focus-left',
+                map: keybindingMap
+            })
+        );
+
+        focusGroup.add(
+            new EntryRow({
+                title: _('Focus Right'),
+                settings: settings,
+                bind: 'focus-right',
+                map: keybindingMap
+            })
+        );
+
+        focusGroup.add(
+            new EntryRow({
+                title: _('Focus Up'),
+                settings: settings,
+                bind: 'focus-up',
+                map: keybindingMap
+            })
+        );
+
+        focusGroup.add(
+            new EntryRow({
+                title: _('Focus Down'),
+                settings: settings,
+                bind: 'focus-down',
+                map: keybindingMap
+            })
+        );
+
+        // --- Move group ---
+        const moveGroup = new Adw.PreferencesGroup({
+            title: _('Move'),
+        });
+        keybindingsPage.add(moveGroup);
+
+        moveGroup.add(
+            new EntryRow({
+                title: _('Move Left'),
                 settings: settings,
                 bind: 'move-left',
                 map: keybindingMap
             })
         );
-        
+
-        keybindingsGroup.add(
+        moveGroup.add(
             new EntryRow({
-                title: _('Action 2'),
+                title: _('Move Right'),
                 settings: settings,
                 bind: 'move-right',
                 map: keybindingMap
             })
         );
-        
+
-        keybindingsGroup.add(
+        moveGroup.add(
             new EntryRow({
-                title: _('Action 3'),
+                title: _('Move Up'),
                 settings: settings,
-                bind: 'join-with-left',
+                bind: 'move-up',
-                map: keybindingMap
-            })
-        );
-        
-        keybindingsGroup.add(
-            new EntryRow({
-                title: _('Action 4'),
-                settings: settings,
-                bind: 'join-with-right',
                 map: keybindingMap
             })
         );
 
-        keybindingsGroup.add(
+        moveGroup.add(
             new EntryRow({
-                title: _('Print Tree Structure'),
+                title: _('Move Down'),
                 settings: settings,
-                bind: 'print-tree',
+                bind: 'move-down',
                 map: keybindingMap
             })
         );
 
-        keybindingsGroup.add(
+        // --- Container Interactions group ---
+        const containerGroup = new Adw.PreferencesGroup({
+            title: _('Container Interactions'),
+        });
+        keybindingsPage.add(containerGroup);
+
+        containerGroup.add(
             new EntryRow({
                 title: _('Toggle Orientation'),
                 settings: settings,
@@ -173,6 +128,38 @@ export default class AerospikeExtensions extends ExtensionPreferences {
             })
         );
 
+        containerGroup.add(
+            new EntryRow({
+                title: _('Reset Container Ratios to Equal'),
+                settings: settings,
+                bind: 'reset-ratios',
+                map: keybindingMap
+            })
+        );
+
+        containerGroup.add(
+            new EntryRow({
+                title: _('Toggle Tabbed Mode'),
+                settings: settings,
+                bind: 'toggle-tabbed',
+                map: keybindingMap
+            })
+        );
+
+        // --- Debugging group ---
+        const debuggingGroup = new Adw.PreferencesGroup({
+            title: _('Debugging'),
+        });
+        keybindingsPage.add(debuggingGroup);
+
+        debuggingGroup.add(
+            new EntryRow({
+                title: _('Print Tree Structure'),
+                settings: settings,
+                bind: 'print-tree',
+                map: keybindingMap
+            })
+        );
 
     }
 

src/utils/events.ts

@@ -1,20 +1,21 @@
 import GLib from "gi://GLib";
 
-
 export type QueuedEvent = {
     name: string;
     callback: () => void;
 }
 
-const queuedEvents: QueuedEvent[] = [];
+const pendingEvents: Map<string, QueuedEvent> = new Map();
 
 export default function queueEvent(event: QueuedEvent, interval = 200) {
-    queuedEvents.push(event);
+    pendingEvents.set(event.name, event);
+
     GLib.timeout_add(GLib.PRIORITY_DEFAULT, interval, () => {
-        const e = queuedEvents.pop()
+        const e = pendingEvents.get(event.name);
-        if (e) {
+        if (e && e === event) {
+            pendingEvents.delete(event.name);
             e.callback();
         }
-        return queuedEvents.length !== 0;
+        return GLib.SOURCE_REMOVE;
     });
-}
+}

src/wm/container.ts

@@ -1,52 +1,229 @@
 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";
+import {TabBar, TAB_BAR_HEIGHT} from "./tabBar.js";
 
-enum Orientation {
+export enum Layout {
-    HORIZONTAL = 0,
+    ACC_HORIZONTAL = 0,
-    VERTICAL = 1,
+    ACC_VERTICAL = 1,
+    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 [];
+    const base = 1 / n;
+    const ratios = Array(n).fill(base);
+    const sumExceptLast = ratios.slice(0, -1).reduce((a, b) => a + b, 0);
+    ratios[n - 1] = 1 - sumExceptLast;
+    return ratios;
+}
 
 export default class WindowContainer {
 
     _tiledItems: (WindowWrapper | WindowContainer)[];
     _tiledWindowLookup: Map<number, WindowWrapper>;
-    _orientation: Orientation = Orientation.HORIZONTAL;
+    _orientation: Layout = Layout.ACC_HORIZONTAL;
     _workArea: Rect;
 
-    constructor(workspaceArea: Rect,) {
+    // -- Accordion Mode States
+
+    _splitRatios: number[];
+
+    // -- Tabbed mode state -----------------------------------------------------
+    _activeTabIndex: number = 0;
+    _tabBar: TabBar | null = null;
+
+    constructor(workspaceArea: Rect) {
         this._tiledItems = [];
         this._tiledWindowLookup = new Map<number, WindowWrapper>();
         this._workArea = workspaceArea;
+        this._splitRatios = [];
     }
 
+    // --- Helpers ----------------------------------------------------------------
+
+    private _resetRatios(): void {
+        this._splitRatios = equalRatios(this._tiledItems.length);
+    }
+
+    /**
+     * Proportionally shrink existing ratios to carve out space for a new item
+     * at the given index. If no index is supplied the ratio is appended at the end.
+     */
+    private _addRatioForNewWindow(index?: number): void {
+        const n = this._tiledItems.length;
+        if (n <= 1) {
+            this._splitRatios = [1.0];
+            return;
+        }
+        const newRatio = 1 / n;
+        const scale = 1 - newRatio;
+        const scaled = this._splitRatios.map(r => r * scale);
+        const partialSum = scaled.reduce((a, b) => a + b, 0) + newRatio;
+        scaled[scaled.length - 1] += (1.0 - partialSum);
+
+        const insertAt = index ?? scaled.length;
+        scaled.splice(insertAt, 0, newRatio);
+        this._splitRatios = scaled;
+    }
+
+    private _totalDimension(): number {
+        return this._orientation === Layout.ACC_HORIZONTAL
+            ? this._workArea.width
+            : this._workArea.height;
+    }
+
+    isTabbed(): boolean {
+        return this._orientation === Layout.TABBED;
+    }
+
+    // --- Public API -------------------------------------------------------------
 
     move(rect: Rect): void {
         this._workArea = rect;
-        this.tileWindows();
+        this.drawWindows();
     }
 
     toggleOrientation(): void {
-        this._orientation = this._orientation === Orientation.HORIZONTAL
+        if (this._orientation === Layout.TABBED) {
-            ? Orientation.VERTICAL
+            // Tabbed → Horizontal: restore accordion mode
-            : Orientation.HORIZONTAL;
+            this.setAccordion(Layout.ACC_HORIZONTAL);
-        Logger.info(`Container orientation toggled to ${this._orientation === Orientation.HORIZONTAL ? 'HORIZONTAL' : 'VERTICAL'}`);
+        } else {
-        this.tileWindows();
+            this._orientation = this._orientation === Layout.ACC_HORIZONTAL
+                ? Layout.ACC_VERTICAL
+                : Layout.ACC_HORIZONTAL;
+            Logger.info(`Container orientation toggled to ${Layout[this._orientation]}`);
+            this.drawWindows();
+        }
     }
 
-    addWindow(winWrap: WindowWrapper): void {
+    /**
-        this._tiledItems.push(winWrap);
+     * Switch this container to tabbed mode.
+     */
+    setTabbed(): void {
+        if (this._orientation === Layout.TABBED) return;
+
+        Logger.info("Container switching to TABBED mode");
+        this._orientation = Layout.TABBED;
+
+        // Clamp active tab index
+        if (this._activeTabIndex < 0 || this._activeTabIndex >= this._tiledItems.length) {
+            this._activeTabIndex = 0;
+        }
+
+        // Create tab bar
+        this._tabBar = new TabBar((index) => {
+            this.setActiveTab(index);
+        });
+
+        this.drawWindows();
+    }
+
+    /**
+     * Switch this container back to accordion (H or V) mode.
+     */
+    setAccordion(orientation: Layout.ACC_HORIZONTAL | Layout.ACC_VERTICAL): void {
+        if (this._orientation !== Layout.TABBED) {
+            // Already accordion — just set the orientation
+            this._orientation = orientation;
+            this.drawWindows();
+            return;
+        }
+
+        Logger.info(`Container switching from TABBED to ${Layout[orientation]}`);
+        this._orientation = orientation;
+
+        // Destroy tab bar
+        if (this._tabBar) {
+            this._tabBar.destroy();
+            this._tabBar = null;
+        }
+
+        // Show all windows (they may have been hidden in tabbed mode)
+        this._showAllWindows();
+
+        this.drawWindows();
+    }
+
+    /**
+     * Set the active tab by index. Shows that window, hides others, updates tab bar.
+     */
+    setActiveTab(index: number): void {
+        if (!this.isTabbed()) return;
+        if (index < 0 || index >= this._tiledItems.length) return;
+
+        this._activeTabIndex = index;
+        Logger.info(`Active tab set to ${index}`);
+
+        this._applyTabVisibility();
+        this._updateTabBar();
+
+        // Tile to resize the active window to the content area
+        this.drawWindows();
+    }
+
+    getActiveTabIndex(): number {
+        return this._activeTabIndex;
+    }
+
+    /**
+     * If the given window is a tab in this container, make it the active tab.
+     * Returns true if the window was found and activated.
+     */
+    focusWindowTab(windowId: number): boolean {
+        if (!this.isTabbed()) return false;
+
+        const index = this._getIndexOfWindow(windowId);
+        if (index !== -1 && index !== this._activeTabIndex) {
+            this.setActiveTab(index);
+            return true;
+        }
+        return index !== -1;
+    }
+
+    hideTabBar(): void {
+        this._tabBar?.hide();
+    }
+
+    showTabBar(): void {
+        if (this.isTabbed() && this._tabBar) {
+            this._tabBar.show();
+        }
+    }
+
+    /**
+     * Add a window to this container.
+     * If `index` is omitted the window is appended at the end.
+     * A negative index (e.g. -1) is treated as "append at end".
+     */
+    addWindow(winWrap: WindowWrapper, index?: number): void {
+        const insertAt = (index === undefined || index < 0)
+            ? this._tiledItems.length
+            : Math.min(index, this._tiledItems.length);
+
+        this._tiledItems.splice(insertAt, 0, winWrap);
         this._tiledWindowLookup.set(winWrap.getWindowId(), winWrap);
+        this._addRatioForNewWindow(insertAt);
+
+        if (this.isTabbed()) {
+            // TODO: make it so that when tabs are added they are made the current active tab
+            this._applyTabVisibility();
+            this._updateTabBar();
+        }
+
         queueEvent({
             name: "tiling-windows",
-            callback: () => {
+            callback: () => this.drawWindows(),
-                this.tileWindows();
+        }, 100);
-            }
-        }, 100)
-
     }
 
     getWindow(win_id: number): WindowWrapper | undefined {
@@ -56,34 +233,48 @@ export default class WindowContainer {
         for (const item of this._tiledItems) {
             if (item instanceof WindowContainer) {
                 const win = item.getWindow(win_id);
-                if (win) {
+                if (win) return win;
-                    return win;
-                }
             } else if (item.getWindowId() === win_id) {
                 return item;
             }
         }
-        return undefined
+        return undefined;
     }
 
-    _getIndexOfWindow(win_id: number) {
+    _getIndexOfWindow(win_id: number): 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
+        return -1;
     }
 
     removeWindow(win_id: number): void {
         if (this._tiledWindowLookup.has(win_id)) {
-            // Get index before deleting from lookup to avoid race condition
             const index = this._getIndexOfWindow(win_id);
             this._tiledWindowLookup.delete(win_id);
             if (index !== -1) {
+                // If removing the window that was hidden in tabbed mode,
+                // make sure to show it first so it doesn't stay invisible
+                const item = this._tiledItems[index];
+                if (item instanceof WindowWrapper) {
+                    item.showWindow();
+                }
                 this._tiledItems.splice(index, 1);
             }
+            this._resetRatios();
+
+            if (this.isTabbed()) {
+                if (this._tiledItems.length === 0) {
+                    this._activeTabIndex = 0;
+                } else if (this._activeTabIndex >= this._tiledItems.length) {
+                    this._activeTabIndex = this._tiledItems.length - 1;
+                }
+                this._applyTabVisibility();
+                this._updateTabBar();
+            }
         } else {
             for (const item of this._tiledItems) {
                 if (item instanceof WindowContainer) {
@@ -91,94 +282,243 @@ export default class WindowContainer {
                 }
             }
         }
-        this.tileWindows()
+        this.drawWindows();
     }
 
     disconnectSignals(): void {
         this._tiledItems.forEach((item) => {
-                if (item instanceof WindowContainer) {
+            if (item instanceof WindowContainer) {
-                    item.disconnectSignals()
+                item.disconnectSignals();
-                } else {
+            } else {
-                    item.disconnectWindowSignals();
+                item.disconnectWindowSignals();
-                }
             }
-        )
+        });
     }
 
     removeAllWindows(): void {
-        this._tiledItems = []
+        // tabbed mode hides all windows - this ensures they are available before removal
-        this._tiledWindowLookup.clear()
+        this._showAllWindows();
+
+        if (this._tabBar) {
+            this._tabBar.destroy();
+            this._tabBar = null;
+        }
+
+        this._tiledItems = [];
+        this._tiledWindowLookup.clear();
+        this._splitRatios = [];
+        this._activeTabIndex = 0;
     }
 
-    tileWindows() {
+    drawWindows(): void {
-        Logger.log("TILING WINDOWS IN CONTAINER")
+        Logger.log("TILING WINDOWS IN CONTAINER");
-
         Logger.log("WorkArea", this._workArea);
 
-        this._tileItems()
+        if (this.isTabbed()) {
-
+            this._tileTab();
-        return true
+        } else {
+            this._tileAccordion();
+        }
     }
 
-    _tileItems() {
+    _tileAccordion() {
-        if (this._tiledItems.length === 0) {
+        if (this._tiledItems.length === 0) return;
-            return;
+
-        }
         const bounds = this.getBounds();
+        Logger.info(`_tileAccordion: ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}] bounds=[${bounds.map(b => `(${b.x},${b.y},${b.width},${b.height})`).join(', ')}]`);
         this._tiledItems.forEach((item, index) => {
             const rect = bounds[index];
             if (item instanceof WindowContainer) {
                 item.move(rect);
             } else {
+                Logger.info(`_tileAccordion: window[${index}] id=${item.getWindowId()} dragging=${item._dragging} → rect=(${rect.x},${rect.y},${rect.width},${rect.height})`);
                 item.safelyResizeWindow(rect);
             }
-        })
+        });
     }
 
+    private _tileTab(): void {
+        if (this._tiledItems.length === 0) return;
+
+        const tabBarRect: Rect = {
+            x: this._workArea.x,
+            y: this._workArea.y,
+            width: this._workArea.width,
+            height: TAB_BAR_HEIGHT,
+        };
+
+        const contentRect: Rect = {
+            x: this._workArea.x,
+            y: this._workArea.y + TAB_BAR_HEIGHT,
+            width: this._workArea.width,
+            height: this._workArea.height - TAB_BAR_HEIGHT,
+        };
+
+        // Position and show the tab bar
+        if (this._tabBar) {
+            this._tabBar.setPosition(tabBarRect);
+            if (!this._tabBar.isVisible()) {
+                this._rebuildAndShowTabBar();
+            }
+        }
+
+        this._applyTabVisibility();
+
+        const activeItem = this._tiledItems[this._activeTabIndex];
+        if (activeItem) {
+            if (activeItem instanceof WindowContainer) {
+                activeItem.move(contentRect);
+            } else {
+                Logger.info(`_tileTabbed: active tab[${this._activeTabIndex}] id=${activeItem.getWindowId()} → rect=(${contentRect.x},${contentRect.y},${contentRect.width},${contentRect.height})`);
+                activeItem.safelyResizeWindow(contentRect);
+            }
+        }
+    }
+
+    /**
+     * Show the active tab window, hide all others.
+     */
+    private _applyTabVisibility(): void {
+        this._tiledItems.forEach((item, index) => {
+            if (item instanceof WindowWrapper) {
+                if (index === this._activeTabIndex) {
+                    item.showWindow();
+                } else {
+                    item.hideWindow();
+                }
+            }
+        });
+    }
+
+    /**
+     * Show all windows (used when leaving tabbed mode).
+     */
+    private _showAllWindows(): void {
+        this._tiledItems.forEach((item) => {
+            if (item instanceof WindowWrapper) {
+                item.showWindow();
+            }
+        });
+    }
+
+    /**
+     * Rebuild the tab bar buttons and show it.
+     */
+    private _rebuildAndShowTabBar(): void {
+        if (!this._tabBar) return;
+
+        const windowItems = this._tiledItems.filter(
+            (item): item is WindowWrapper => item instanceof WindowWrapper
+        );
+
+        this._tabBar.rebuild(windowItems, this._activeTabIndex);
+        this._tabBar.show();
+    }
+
+    /**
+     * Public entry point to refresh tab titles (e.g. when a window title changes).
+     */
+    refreshTabTitles(): void {
+        this._updateTabBar();
+    }
+
+    /**
+     * Update tab bar state (active highlight, titles) without a full rebuild.
+     */
+    private _updateTabBar(): void {
+        if (!this._tabBar) return;
+
+        // Rebuild is cheap — just recreate buttons from the current items
+        const windowItems = this._tiledItems.filter(
+            (item): item is WindowWrapper => item instanceof WindowWrapper
+        );
+
+        this._tabBar.rebuild(windowItems, this._activeTabIndex);
+    }
 
     getBounds(): Rect[] {
-        if (this._orientation === Orientation.HORIZONTAL) {
+        if (this._orientation === Layout.TABBED) {
-            return this.getHorizontalBounds();
+            // In tabbed mode, all items share the same content rect
-        }
+            const contentRect: Rect = {
-        return this.getVerticalBounds();
-    }
-
-    getVerticalBounds(): Rect[] {
-        const items = this._tiledItems
-        const containerHeight = Math.floor(this._workArea.height / items.length);
-        return items.map((_, index) => {
-            const y = this._workArea.y + (index * containerHeight);
-            return {
                 x: this._workArea.x,
-                y: y,
+                y: this._workArea.y + TAB_BAR_HEIGHT,
                 width: this._workArea.width,
-                height: containerHeight
+                height: this._workArea.height - TAB_BAR_HEIGHT,
-            } as Rect;
+            };
-        });
+            return this._tiledItems.map(() => contentRect);
+        }
+
+        return this._orientation === Layout.ACC_HORIZONTAL
+            ? this._computeBounds('horizontal')
+            : this._computeBounds('vertical');
     }
 
-    getHorizontalBounds(): Rect[] {
+    private _computeBounds(axis: 'horizontal' | 'vertical'): Rect[] {
-        const windowWidth = Math.floor(this._workArea.width / this._tiledItems.length);
+        const isHorizontal = axis === 'horizontal';
+        const total = isHorizontal ? this._workArea.width : this._workArea.height;
+        let used = 0;
 
         return this._tiledItems.map((_, index) => {
-            const x = this._workArea.x + (index * windowWidth);
+            const offset = used;
-            return {
+            const size = index === this._tiledItems.length - 1
-                x: x,
+                ? total - used
-                y: this._workArea.y,
+                : Math.floor(this._splitRatios[index] * total);
-                width: windowWidth,
+            used += size;
-                height: this._workArea.height
+
-            } as Rect;
+            return isHorizontal
+                ? {x: this._workArea.x + offset, y: this._workArea.y, width: size, height: this._workArea.height}
+                : {x: this._workArea.x, y: this._workArea.y + offset, width: this._workArea.width, height: size};
         });
     }
 
+    adjustBoundary(boundaryIndex: number, deltaPixels: number): boolean {
+        // No boundary adjustment in tabbed mode
+        if (this.isTabbed()) return false;
+
+        if (boundaryIndex < 0 || boundaryIndex >= this._tiledItems.length - 1) {
+            Logger.warn(`adjustBoundary: invalid boundaryIndex ${boundaryIndex}`);
+            return false;
+        }
+
+        const totalDim = this._totalDimension();
+        if (totalDim === 0) return false;
+
+        const ratioDelta = deltaPixels / totalDim;
+        const newLeft = this._splitRatios[boundaryIndex] + ratioDelta;
+        const newRight = this._splitRatios[boundaryIndex + 1] - ratioDelta;
+
+        if (newLeft <= 0 || newRight <= 0) {
+            Logger.log(`adjustBoundary: clamped — newLeft=${newLeft.toFixed(3)}, newRight=${newRight.toFixed(3)}`);
+            return false;
+        }
+
+        this._splitRatios[boundaryIndex] = newLeft;
+        this._splitRatios[boundaryIndex + 1] = newRight;
+
+        Logger.info(`adjustBoundary: boundary=${boundaryIndex} ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
+        return true;
+    }
+
+    // --- Container Lookup --------------------------------------------------------
+
+    getContainerForWindow(win_id: number): WindowContainer | null {
+        for (const item of this._tiledItems) {
+            if (item instanceof WindowWrapper && item.getWindowId() === win_id) {
+                return this;
+            }
+            if (item instanceof WindowContainer) {
+                const found = item.getContainerForWindow(win_id);
+                if (found !== null) return found;
+            }
+        }
+        return null;
+    }
+
     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 (container.getIndexOfItemNested(item) !== -1) return i;
-                if (index !== -1) {
-                    return i;
-                }
             } else if (container.getWindowId() === item.getWindowId()) {
                 return i;
             }
@@ -188,25 +528,177 @@ export default class WindowContainer {
 
     // 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);
+        // In tabbed mode, dragging reorders tabs but doesn't change layout
+        if (this.isTabbed()) {
+            // Don't reorder during tabbed mode — tabs have a fixed visual layout
+            return;
+        }
+
+        const original_index = this.getIndexOfItemNested(item);
 
         if (original_index === -1) {
             Logger.error("Item not found in container during drag op", item.getWindowId());
             return;
         }
-        let new_index = this.getIndexOfItemNested(item);
+
+        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()
-        }
 
+        if (original_index !== new_index) {
+            Logger.info(`itemDragged: swapped slots ${original_index}<->${new_index}, ratios=[${this._splitRatios.map(r => r.toFixed(3)).join(', ')}]`);
+            [this._tiledItems[original_index], this._tiledItems[new_index]] =
+                [this._tiledItems[new_index], this._tiledItems[original_index]];
+            this.drawWindows();
+        }
     }
 
+    resetRatios(): void {
+        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;
+    }
+}

src/wm/monitor.ts

@@ -1,12 +1,8 @@
 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 {
 
@@ -20,7 +16,7 @@ export default class Monitor {
         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()
+        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));
@@ -42,9 +38,7 @@ export default class Monitor {
     getWindow(windowId: number): WindowWrapper | undefined {
         for (const container of this._workspaces) {
             const win = container.getWindow(windowId);
-            if (win) {
+            if (win) return win;
-                return win;
-            }
         }
         return undefined;
     }
@@ -52,23 +46,22 @@ export default class Monitor {
     removeWindow(winWrap: WindowWrapper) {
         const windowId = winWrap.getWindowId();
         for (const container of this._workspaces) {
-            const win = container.getWindow(windowId);
+            if (container.getWindow(windowId)) {
-            if (win) {
                 container.removeWindow(windowId);
             }
         }
     }
 
-    addWindow(winWrap: WindowWrapper) {
+    addWindow(winWrap: WindowWrapper, index?: number) {
         const window_workspace = winWrap.getWindow().get_workspace().index();
-        this._workspaces[window_workspace].addWindow(winWrap);
+        this._workspaces[window_workspace].addWindow(winWrap, index);
     }
 
     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._workArea = activeWorkspace.get_work_area_for_monitor(this._id);
+        // move() calls tileWindows() internally
         this._workspaces[activeWorkspace.index()].move(this._workArea);
-        this._workspaces[activeWorkspace.index()].tileWindows()
     }
 
     removeWorkspace(workspaceId: number): void {
@@ -79,8 +72,32 @@ export default class Monitor {
         this._workspaces.push(new WindowContainer(this._workArea));
     }
 
+    focusWindowTab(windowId: number): void {
+        for (const container of this._workspaces) {
+            if (container.focusWindowTab(windowId)) return;
+        }
+    }
+
+    refreshTabTitlesForWindow(winWrap: WindowWrapper): void {
+        const wsId = winWrap.getWorkspace();
+        if (wsId >= 0 && wsId < this._workspaces.length) {
+            this._workspaces[wsId].refreshTabTitles();
+        }
+    }
+
+    hideTabBars(): void {
+        for (const container of this._workspaces) {
+            container.hideTabBar();
+        }
+    }
+
+    showTabBars(): void {
+        for (const container of this._workspaces) {
+            container.showTabBar();
+        }
+    }
+
     itemDragged(item: WindowWrapper, x: number, y: number): void {
         this._workspaces[item.getWorkspace()].itemDragged(item, x, y);
     }
-
+}
-}

src/wm/tabBar.ts

@@ -0,0 +1,131 @@
+import Clutter from 'gi://Clutter';
+import Pango from 'gi://Pango';
+import St from 'gi://St';
+import * as Main from 'resource:///org/gnome/shell/ui/main.js';
+import {Logger} from "../utils/logger.js";
+import {WindowWrapper} from "./window.js";
+import {Rect} from "../utils/rect.js";
+
+export const TAB_BAR_HEIGHT = 24;
+
+type TabClickedCallback = (index: number) => void;
+
+export class TabBar {
+    private _bar: St.BoxLayout;
+    private _buttons: St.Button[] = [];
+    private _activeIndex: number = 0;
+    private _onTabClicked: TabClickedCallback;
+    private _visible: boolean = false;
+
+    constructor(onTabClicked: TabClickedCallback) {
+        this._onTabClicked = onTabClicked;
+        this._bar = new St.BoxLayout({
+            style_class: 'aerospike-tab-bar',
+            vertical: false,
+            reactive: true,
+            can_focus: false,
+            track_hover: false,
+        });
+        // Force all tabs to equal width regardless of text length
+        (this._bar.layout_manager as Clutter.BoxLayout).homogeneous = true;
+    }
+
+    /**
+     * Rebuild all tab buttons from the current list of window items.
+     */
+    rebuild(items: WindowWrapper[], activeIndex: number): void {
+        // Remove old buttons
+        this._bar.destroy_all_children();
+        this._buttons = [];
+
+        items.forEach((item, index) => {
+            const label = new St.Label({
+                text: item.getTabLabel(),
+                style_class: 'aerospike-tab-label',
+                y_align: Clutter.ActorAlign.CENTER,
+                x_align: Clutter.ActorAlign.CENTER,
+                x_expand: true,
+            });
+            label.clutter_text.ellipsize = Pango.EllipsizeMode.END;
+
+            const button = new St.Button({
+                style_class: 'aerospike-tab',
+                reactive: true,
+                can_focus: false,
+                track_hover: true,
+                x_expand: true,
+                child: label,
+            });
+
+            button.connect('clicked', () => {
+                this._onTabClicked(index);
+            });
+
+            this._bar.add_child(button);
+            this._buttons.push(button);
+        });
+
+        this.setActive(activeIndex);
+    }
+
+    /**
+     * Update just the title text of a single tab (e.g. when a window title changes).
+     */
+    updateTabTitle(index: number, title: string): void {
+        if (index < 0 || index >= this._buttons.length) return;
+        const label = this._buttons[index].get_child() as St.Label;
+        if (label) label.set_text(title);
+    }
+
+    /**
+     * Highlight the active tab and dim the rest.
+     */
+    setActive(index: number): void {
+        this._activeIndex = index;
+        this._buttons.forEach((btn, i) => {
+            if (i === index) {
+                btn.add_style_class_name('aerospike-tab-active');
+            } else {
+                btn.remove_style_class_name('aerospike-tab-active');
+            }
+        });
+    }
+
+    /**
+     * Position and size the tab bar at the given screen rect.
+     */
+    setPosition(rect: Rect): void {
+        this._bar.set_position(rect.x, rect.y);
+        this._bar.set_size(rect.width, rect.height);
+    }
+
+    show(): void {
+        if (this._visible) return;
+        this._visible = true;
+        Main.layoutManager.uiGroup.add_child(this._bar);
+        this._bar.show();
+        Logger.log("TabBar shown");
+    }
+
+    hide(): void {
+        if (!this._visible) return;
+        this._visible = false;
+        this._bar.hide();
+        if (this._bar.get_parent()) {
+            Main.layoutManager.uiGroup.remove_child(this._bar);
+        }
+        Logger.log("TabBar hidden");
+    }
+
+    destroy(): void {
+        this.hide();
+        this._bar.destroy_all_children();
+        this._buttons = [];
+        this._bar.destroy();
+        Logger.log("TabBar destroyed");
+    }
+
+    isVisible(): boolean {
+        return this._visible;
+    }
+}

src/wm/window.ts

@@ -11,6 +11,8 @@ type WindowMinimizedHandler = (window: WindowWrapper) => void;
 type WindowWorkspaceChangedHandler = (window: WindowWrapper) => void;
 
 export class WindowWrapper {
+    private static readonly RESIZE_TOLERANCE = 2;
+
     readonly _window: Meta.Window;
     readonly _windowMinimizedHandler: WindowMinimizedHandler;
     readonly _signals: number[] = [];
@@ -45,44 +47,54 @@ export class WindowWrapper {
         return this._window.get_frame_rect();
     }
 
+    getTabLabel(): string {
+        const rawAppName = this._window.get_wm_class() ?? '';
+        // Strip reverse-domain prefix (e.g. "org.gnome.Nautilus" -> "Nautilus")
+        const lastName = rawAppName.includes('.')
+            ? (rawAppName.split('.').pop() ?? rawAppName)
+            : rawAppName;
+        // Capitalize first letter
+        const appName = lastName.charAt(0).toUpperCase() + lastName.slice(1);
+        const title = this._window.get_title() ?? 'Untitled';
+        if (appName && appName.toLowerCase() !== title.toLowerCase()) {
+            return `${appName} | ${title}`;
+        }
+        return title;
+    }
+
+    hideWindow(): void {
+        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
+        if (actor) actor.hide();
+    }
+
+    showWindow(): void {
+        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
+        if (actor) actor.show();
+    }
+
     startDragging(): void {
         this._dragging = true;
     }
+
     stopDragging(): void {
         Logger.log("STOPPED DRAGGING")
         this._dragging = false;
     }
 
-    // setParent(parent: WindowContainer): void {
+    connectWindowSignals(windowManager: IWindowManager): void {
-    //     this._parent = parent;
+        const windowId = this._window.get_id();
-    // }
-    //
-    // getParent(): WindowContainer | null {
-    //     if (this._parent == null) {
-    //         Logger.warn(`Attempting to get parent for window without parent ${JSON.stringify(this)}`);
-    //     }
-    //     return this._parent
-    // }
-
-    connectWindowSignals(
-        windowManager: IWindowManager,
-    ): void {
-        const windowId = this._window.get_id()
-        // Handle window destruction
         this._signals.push(
-            this._window.connect('unmanaging', window => {
+            this._window.connect('unmanaging', () => {
                 Logger.log("REMOVING WINDOW", windowId);
-                windowManager.handleWindowClosed(this)
+                windowManager.handleWindowClosed(this);
             }),
-            this._window.connect('notify::minimized', (we) => {
+            this._window.connect('notify::minimized', () => {
                 if (this._window.minimized) {
                     Logger.log(`Window minimized: ${windowId}`);
                     windowManager.handleWindowMinimized(this);
-
+                } else {
-                } else if (!this._window.minimized) {
                     Logger.log(`Window unminimized: ${windowId}`);
                     windowManager.handleWindowUnminimized(this);
-
                 }
             }),
             this._window.connect('notify::maximized-horizontally', () => {
@@ -92,18 +104,23 @@ export class WindowWrapper {
                     Logger.log(`Window unmaximized: ${windowId}`);
                 }
             }),
-            this._window.connect("workspace-changed", (_metaWindow) => {
+            this._window.connect("workspace-changed", () => {
                 Logger.log("WORKSPACE CHANGED FOR WINDOW", this._window.get_id());
                 windowManager.handleWindowChangedWorkspace(this);
             }),
-            this._window.connect("position-changed", (_metaWindow) => {
+            this._window.connect("position-changed", () => {
                 windowManager.handleWindowPositionChanged(this);
             }),
+            this._window.connect("size-changed", () => {
+                windowManager.handleWindowPositionChanged(this);
+            }),
+            this._window.connect('notify::title', () => {
+                windowManager.handleWindowTitleChanged(this);
+            }),
         );
     }
 
     disconnectWindowSignals(): void {
-
         if (this._signals) {
             this._signals.forEach(signal => {
                 try {
@@ -117,37 +134,54 @@ export class WindowWrapper {
         }
     }
 
-    safelyResizeWindow(rect: Rect, _retry: number = 2): void {
+    safelyResizeWindow(rect: Rect, _retry: number = 3): void {
-        // Keep minimal logging
         if (this._dragging) {
-            Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED")
+            Logger.info("STOPPED RESIZE BECAUSE ITEM IS BEING DRAGGED");
             return;
         }
-        // Logger.log("SAFELY RESIZE", rect.x, rect.y, rect.width, rect.height);
-        const actor = this._window.get_compositor_private();
 
+        const actor = this._window.get_compositor_private() as Clutter.Actor | null;
         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;
+        actor.remove_all_transitions();
-        windowActor.remove_all_transitions();
+
-        // Logger.info("MOVING")
+        // Move first to guarantee the window reaches the correct position even
+        // if the subsequent resize is clamped by minimum-size hints.
         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 ( _retry > 0 && (new_rect.x != rect.x || rect.y != new_rect.y || rect.width < new_rect.width || rect.height < new_rect.height)) {
+        const new_rect = this._window.get_frame_rect();
-            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);
+        const mismatch =
-            queueEvent({
+            Math.abs(new_rect.x      - rect.x)      > WindowWrapper.RESIZE_TOLERANCE ||
-                name: "attempting_delayed_resize",
+            Math.abs(new_rect.y      - rect.y)      > WindowWrapper.RESIZE_TOLERANCE ||
-                callback: () => {
+            Math.abs(new_rect.width  - rect.width)  > WindowWrapper.RESIZE_TOLERANCE ||
-                    this.safelyResizeWindow(rect, _retry-1);
+            Math.abs(new_rect.height - rect.height) > WindowWrapper.RESIZE_TOLERANCE;
-                }
+
-            })
+        if (_retry > 0 && mismatch) {
+            // If the window's actual size is larger than requested, it has a
+            // minimum-size constraint — retrying won't help.  Just make sure
+            // it's at the correct position with its actual size.
+            const sizeConstrained =
+                new_rect.width  > rect.width  + WindowWrapper.RESIZE_TOLERANCE ||
+                new_rect.height > rect.height + WindowWrapper.RESIZE_TOLERANCE;
+
+            if (sizeConstrained) {
+                Logger.info("Window has min-size constraint, accepting actual size",
+                    `want(${rect.x},${rect.y},${rect.width},${rect.height})`,
+                    `actual(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`);
+                this._window.move_frame(true, rect.x, rect.y);
+            } else {
+                Logger.warn("RESIZE MISMATCH, retrying",
+                    `want(${rect.x},${rect.y},${rect.width},${rect.height})`,
+                    `got(${new_rect.x},${new_rect.y},${new_rect.width},${new_rect.height})`);
+                queueEvent({
+                    name: `delayed_resize_${this.getWindowId()}`,
+                    callback: () => this.safelyResizeWindow(rect, _retry - 1),
+                }, 50);
+            }
         }
     }
-
-
 }

src/wm/windowManager.ts

@@ -1,20 +1,17 @@
 import Meta from "gi://Meta";
-// import Gio from "gi://Gio";
+import Gio from "gi://Gio";
-// import GLib from "gi://GLib";
 
 import {WindowWrapper} from './window.js';
 import * 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";
-import WindowContainer from "./container.js";
+import WindowContainer, {Direction, Layout} from "./container.js";
+import {Rect} from "../utils/rect.js";
 
 
 export interface IWindowManager {
     _activeWindowId: number | null;
 
-    // addWindow(window: Meta.Window): void;
-
     handleWindowClosed(winWrap: WindowWrapper): void;
 
     handleWindowMinimized(winWrap: WindowWrapper): void;
@@ -25,12 +22,14 @@ export interface IWindowManager {
 
     handleWindowPositionChanged(winWrap: WindowWrapper): void;
 
+    handleWindowTitleChanged(winWrap: WindowWrapper): void;
+
     syncActiveWindow(): number | null;
 }
 
 
-const _UNUSED_MONITOR_ID = -1
+const _UNUSED_MONITOR_ID = -1;
-const _UNUSED_WINDOW_ID = -1
+const _UNUSED_WINDOW_ID  = -1;
 
 export default class WindowManager implements IWindowManager {
     _displaySignals: number[] = [];
@@ -40,23 +39,29 @@ export default class WindowManager implements IWindowManager {
 
     _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;
-
     _showingOverview: boolean = false;
 
-    constructor() {
+    // -- Resize-drag tracking --------------------------------------------------
+    _isResizeDrag: boolean = false;
+    _resizeDragWindowId: number = _UNUSED_WINDOW_ID;
+    _resizeDragOp: Meta.GrabOp = Meta.GrabOp.NONE;
+    _resizeDragLastMouseX: number = 0;
+    _resizeDragLastMouseY: number = 0;
+    _isTiling: boolean = false;
 
+    private readonly _settings: Gio.Settings;
 
+    constructor(settings: Gio.Settings) {
+        this._settings = settings;
     }
 
     public enable(): void {
         Logger.log("Starting Aerospike Window Manager");
-        // Connect window signals
         this.instantiateDisplaySignals();
 
         const mon_count = global.display.get_n_monitors();
@@ -65,8 +70,6 @@ export default class WindowManager implements IWindowManager {
         }
 
         this.captureExistingWindows();
-
-        // Sync the initially focused window
         this.syncActiveWindow();
     }
 
@@ -93,7 +96,6 @@ export default class WindowManager implements IWindowManager {
             global.display.connect('notify::focus-window', () => {
                 this.syncActiveWindow();
             }),
-
             global.display.connect("showing-desktop-changed", () => {
                 Logger.log("SHOWING DESKTOP CHANGED");
             }),
@@ -103,14 +105,9 @@ export default class WindowManager implements IWindowManager {
             }),
             global.display.connect("in-fullscreen-changed", () => {
                 Logger.log("IN FULL SCREEN CHANGED");
+                this._syncFullscreenTabBars();
             }),
-        )
+        );
-
-        // 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", () => {
@@ -135,45 +132,37 @@ export default class WindowManager implements IWindowManager {
 
         this._overviewSignals = [
             Main.overview.connect("hiding", () => {
-                // this.fromOverview = true;
                 Logger.log("HIDING OVERVIEW")
                 this._showingOverview = false;
                 this._tileMonitors();
-                // const eventObj = {
+                for (const monitor of this._monitors.values()) {
-                //     name: "focus-after-overview",
+                    monitor.showTabBars();
-                //     callback: () => {
+                }
-                //         Logger.log("FOCUSING AFTER OVERVIEW");
-                //     },
-                // };
-                // this.queueEvent(eventObj);
             }),
             Main.overview.connect("showing", () => {
                 this._showingOverview = true;
                 Logger.log("SHOWING OVERVIEW");
+                for (const monitor of this._monitors.values()) {
+                    monitor.hideTabBars();
+                }
             }),
         ];
-
-
     }
 
     public disable(): void {
         Logger.log("DISABLED AEROSPIKE WINDOW MANAGER!")
-        // Disconnect the focus signal and remove any existing borders
         this.disconnectSignals();
         this.removeAllWindows();
     }
 
     removeAllWindows(): void {
-        // Disconnect signals from minimized windows before clearing
         this.disconnectMinimizedSignals();
         this._minimizedItems.clear();
-
         this._monitors.forEach((monitor: Monitor) => {
             monitor.removeAllWindows();
         })
     }
 
-
     disconnectSignals(): void {
         this.disconnectDisplaySignals();
         this.disconnectMonitorSignals();
@@ -207,35 +196,61 @@ export default class WindowManager implements IWindowManager {
         })
     }
 
+    _isResizeOp(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;
+    }
 
     handleGrabOpBegin(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
-        if (op === Meta.GrabOp.MOVING_UNCONSTRAINED){
-
-        }
         Logger.log("Grab Op Start", op);
-        Logger.log(display, window, op)
+
-        Logger.log(window.get_monitor())
+        if (this._isResizeOp(op)) {
-        this._getWrappedWindow(window)?.startDragging();
+            Logger.log("Resize drag begin, op=", op);
-        this._grabbedWindowMonitor = window.get_monitor();
+            this._isResizeDrag = true;
-        this._grabbedWindowId = window.get_id();
+            this._resizeDragWindowId = window.get_id();
+            this._resizeDragOp = op;
+            const [startMouseX, startMouseY] = global.get_pointer();
+            this._resizeDragLastMouseX = startMouseX;
+            this._resizeDragLastMouseY = startMouseY;
+            this._getWrappedWindow(window)?.startDragging();
+        } else {
+            this._getWrappedWindow(window)?.startDragging();
+            this._grabbedWindowMonitor = window.get_monitor();
+            this._grabbedWindowId = window.get_id();
+        }
     }
 
     handleGrabOpEnd(display: Meta.Display, window: Meta.Window, op: Meta.GrabOp): void {
         Logger.log("Grab Op End ", op);
-        Logger.log("primary display", display.get_primary_monitor())
+
-        this._grabbedWindowId = _UNUSED_WINDOW_ID;
+        if (this._isResizeDrag) {
-        this._getWrappedWindow(window)?.stopDragging();
+            Logger.log("Resize drag end, op=", op);
-        this._tileMonitors();
+            this._isResizeDrag = false;
-        Logger.info("monitor_start and monitor_end", this._grabbedWindowMonitor, window.get_monitor());
+            this._resizeDragWindowId = _UNUSED_WINDOW_ID;
+            this._resizeDragLastMouseX = 0;
+            this._resizeDragLastMouseY = 0;
+            this._resizeDragOp = Meta.GrabOp.NONE;
+            this._getWrappedWindow(window)?.stopDragging();
+            this._tileMonitors();
+        } else {
+            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: WindowWrapper | undefined = undefined;
         for (const monitor of this._monitors.values()) {
             wrapped = monitor.getWindow(window.get_id());
-            if (wrapped !== undefined) {
+            if (wrapped !== undefined) break;
-                break;
-            }
         }
         return wrapped;
     }
@@ -265,9 +280,13 @@ export default class WindowManager implements IWindowManager {
     }
 
     public handleWindowPositionChanged(winWrap: WindowWrapper): void {
-        if (this._changingGrabbedMonitor) {
+        if (this._isTiling || this._changingGrabbedMonitor) return;
+
+        if (this._isResizeDrag && winWrap.getWindowId() === this._resizeDragWindowId) {
+            this._handleResizeDragUpdate(winWrap);
             return;
         }
+
         if (winWrap.getWindowId() === this._grabbedWindowId) {
             const [mouseX, mouseY, _] = global.get_pointer();
 
@@ -280,19 +299,82 @@ export default class WindowManager implements IWindowManager {
                     break;
                 }
             }
-            if (monitorIndex === -1) {
+            if (monitorIndex === -1) return;
-                return
-            }
 
             if (monitorIndex !== this._grabbedWindowMonitor) {
                 this._changingGrabbedMonitor = true;
                 this._moveWindowToMonitor(winWrap.getWindow(), monitorIndex);
-                this._changingGrabbedMonitor = false
+                this._changingGrabbedMonitor = false;
+            }
+
+            this._isTiling = true;
+            try {
+                this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
+            } finally {
+                this._isTiling = false;
             }
-            this._monitors.get(monitorIndex)?.itemDragged(winWrap, mouseX, mouseY);
         }
     }
 
+    private _handleResizeDragUpdate(winWrap: WindowWrapper): void {
+        const op    = this._resizeDragOp;
+        const winId = winWrap.getWindowId();
+
+        const [mouseX, mouseY] = global.get_pointer();
+        const dx = mouseX - this._resizeDragLastMouseX;
+        const dy = mouseY - this._resizeDragLastMouseY;
+
+        if (dx === 0 && dy === 0) return;
+
+        this._resizeDragLastMouseX = mouseX;
+        this._resizeDragLastMouseY = mouseY;
+
+        const container = this._findContainerForWindowAcrossMonitors(winId);
+        if (!container) {
+            Logger.warn("_handleResizeDragUpdate: no container found for window", winId);
+            return;
+        }
+
+        const itemIndex = container._getIndexOfWindow(winId);
+        if (itemIndex === -1) return;
+
+        const isHorizontal = container._orientation === Layout.ACC_HORIZONTAL;
+
+        // E/S edge → boundary after the item; W/N edge → boundary before it.
+        let adjusted = false;
+        if (isHorizontal) {
+            if (op === Meta.GrabOp.RESIZING_E || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_SE) {
+                adjusted = container.adjustBoundary(itemIndex, dx);
+            } else if (op === Meta.GrabOp.RESIZING_W || op === Meta.GrabOp.RESIZING_NW || op === Meta.GrabOp.RESIZING_SW) {
+                adjusted = container.adjustBoundary(itemIndex - 1, dx);
+            }
+        } else {
+            if (op === Meta.GrabOp.RESIZING_S || op === Meta.GrabOp.RESIZING_SE || op === Meta.GrabOp.RESIZING_SW) {
+                adjusted = container.adjustBoundary(itemIndex, dy);
+            } else if (op === Meta.GrabOp.RESIZING_N || op === Meta.GrabOp.RESIZING_NE || op === Meta.GrabOp.RESIZING_NW) {
+                adjusted = container.adjustBoundary(itemIndex - 1, dy);
+            }
+        }
+
+        if (adjusted) {
+            this._isTiling = true;
+            try {
+                container.drawWindows();
+            } finally {
+                this._isTiling = false;
+            }
+        }
+    }
+
+    private _findContainerForWindowAcrossMonitors(winId: number): WindowContainer | null {
+        const activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
+        for (const monitor of this._monitors.values()) {
+            if (activeWorkspaceIndex >= monitor._workspaces.length) continue;
+            const container = monitor._workspaces[activeWorkspaceIndex].getContainerForWindow(winId);
+            if (container !== null) return container;
+        }
+        return null;
+    }
 
     public handleWindowMinimized(winWrap: WindowWrapper): void {
         const monitor_id = winWrap.getWindow().get_monitor()
@@ -307,7 +389,6 @@ export default class WindowManager implements IWindowManager {
         this._tileMonitors()
     }
 
-
     public handleWindowChangedWorkspace(winWrap: WindowWrapper): void {
         const monitor = winWrap.getWindow().get_monitor();
         this._monitors.get(monitor)?.removeWindow(winWrap);
@@ -326,41 +407,31 @@ export default class WindowManager implements IWindowManager {
         this._tileMonitors();
     }
 
-
     handleWindowCreated(display: Meta.Display, window: Meta.Window) {
         Logger.log("WINDOW CREATED ON DISPLAY", window, display);
-        if (!this._isWindowTileable(window)) {
+        if (!this._isWindowTileable(window)) return;
-            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();
     }
 
+    handleWindowTitleChanged(window: WindowWrapper): void {
+        const mon_id = window._window.get_monitor();
+        this._monitors.get(mon_id)?.refreshTabTitlesForWindow(window);
+    }
 
     public addWindowToMonitor(window: Meta.Window) {
-
         Logger.log("ADDING WINDOW TO MONITOR", window, window);
         var wrapper = new WindowWrapper(window, (winWrap) => this.handleWindowMinimized(winWrap))
         wrapper.connectWindowSignals(this);
         this._addWindowWrapperToMonitor(wrapper);
-
     }
 
     _addWindowWrapperToMonitor(winWrap: WindowWrapper) {
@@ -371,10 +442,26 @@ export default class WindowManager implements IWindowManager {
         }
     }
 
-    _tileMonitors(): void {
+    private _syncFullscreenTabBars(): void {
+        for (const [monitorId, monitor] of this._monitors.entries()) {
+            if (global.display.get_monitor_in_fullscreen(monitorId)) {
+                monitor.hideTabBars();
+            } else if (!this._showingOverview) {
+                monitor.showTabBars();
+            }
+        }
+    }
 
-        for (const monitor of this._monitors.values()) {
+    _tileMonitors(): void {
-            monitor.tileWindows()
+        this._isTiling = true;
+        try {
+            for (const monitor of this._monitors.values()) {
+                monitor.tileWindows();
+            }
+        } catch (e) {
+            Logger.error("_tileMonitors FAILED", e);
+        } finally {
+            this._isTiling = false;
         }
     }
 
@@ -382,7 +469,7 @@ export default class WindowManager implements IWindowManager {
         "org.gnome.Shell.Extensions",
     ]
 
-    _isWindowTilingBlocked(window: Meta.Window) : boolean {
+    _isWindowTilingBlocked(window: Meta.Window): boolean {
         Logger.info("title", window.get_title());
         Logger.info("description", window.get_description());
         Logger.info("class", window.get_wm_class());
@@ -397,17 +484,12 @@ export default class WindowManager implements IWindowManager {
     }
 
     _isWindowTileable(window: Meta.Window) {
+        if (!window || !window.get_compositor_private()) return false;
+        if (this._isWindowTilingBlocked(window)) return false;
 
-        if (!window || !window.get_compositor_private()) {
-            return false;
-        }
-        if (this._isWindowTilingBlocked(window)) {
-            return false;
-        }
         const windowType = window.get_window_type();
         Logger.log("WINDOW TILING CHECK",);
 
-        // Skip certain types of windows
         return !window.is_skip_taskbar() &&
             windowType !== Meta.WindowType.DESKTOP &&
             windowType !== Meta.WindowType.DOCK &&
@@ -417,19 +499,15 @@ export default class WindowManager implements IWindowManager {
             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 {
         const focusWindow = global.display.focus_window;
         if (focusWindow) {
             this._activeWindowId = focusWindow.get_id();
             Logger.debug(`Active window changed to: ${this._activeWindowId} (${focusWindow.get_title()})`);
+
+            // If the focused window is inside a tabbed container, make it the active tab
+            const monId = focusWindow.get_monitor();
+            this._monitors.get(monId)?.focusWindowTab(this._activeWindowId);
         } else {
             this._activeWindowId = null;
             Logger.debug('No active window');
@@ -437,83 +515,253 @@ export default class WindowManager implements IWindowManager {
         return this._activeWindowId;
     }
 
-    /**
-     * Toggles the orientation of the active container (the container holding the active window)
-     */
     public toggleActiveContainerOrientation(): void {
         if (this._activeWindowId === null) {
             Logger.warn("No active window, cannot toggle container orientation");
             return;
         }
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (container) {
+            container.toggleOrientation();
+        } else {
+            Logger.warn("Could not find container for active window");
+        }
+    }
 
-        // Find the active window's container
+    public resetActiveContainerRatios(): void {
-        const activeContainer = this._findActiveContainer();
+        if (this._activeWindowId === null) {
-        if (activeContainer) {
+            Logger.warn("No active window, cannot reset container ratios");
-            activeContainer.toggleOrientation();
+            return;
+        }
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (container) {
+            Logger.info("Resetting container ratios to equal splits");
+            container.resetRatios();
+        } else {
+            Logger.warn("Could not find container for active window");
+        }
+    }
+
+    public toggleActiveContainerTabbed(): void {
+        if (this._activeWindowId === null) {
+            Logger.warn("No active window, cannot toggle tabbed mode");
+            return;
+        }
+        const container = this._findContainerForWindowAcrossMonitors(this._activeWindowId);
+        if (container) {
+            if (container.isTabbed()) {
+                container.setAccordion(Layout.ACC_HORIZONTAL);
+            } else {
+                // Set the active tab to the focused window
+                const activeIndex = container._getIndexOfWindow(this._activeWindowId);
+                if (activeIndex !== -1) {
+                    container._activeTabIndex = activeIndex;
+                }
+                container.setTabbed();
+            }
+            this._tileMonitors();
         } else {
             Logger.warn("Could not find container for active window");
         }
     }
 
     /**
-     * Finds the container that directly contains the active window
+     * Move the active window in the given direction.
-     * @returns The container holding the active window, or null if not found
+     *
+     * 1. Find the container holding the active window.
+     * 2. Try to swap within the container (adjacent neighbour).
+     * 3. If already at the container edge, move the window to the
+     *    nearest monitor in that direction instead.
+     * 4. Re-tile to apply the new layout.
      */
-    private _findActiveContainer(): WindowContainer | null {
+    public moveInDirection(direction: Direction): void {
         if (this._activeWindowId === null) {
-            return 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();
+            return;
+        }
+
+        this._moveWindowCrossMonitor(this._activeWindowId, direction);
+    }
+
+    /**
+     * 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 activeWorkspaceIndex = global.workspace_manager.get_active_workspace().index();
+            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`);
+    }
 
-            // Bounds check to prevent accessing invalid workspace
+    /**
-            if (activeWorkspaceIndex >= monitor._workspaces.length || activeWorkspaceIndex < 0) {
+     * Find the adjacent monitor in the given direction from a current monitor.
-                Logger.warn(`Active workspace index ${activeWorkspaceIndex} out of bounds for monitor with ${monitor._workspaces.length} workspaces`);
+     * Returns the monitor ID or null if none exists in that direction.
-                continue;
+     */
+    private _findAdjacentMonitorId(currentMonitorId: number, direction: Direction): number | 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;
+
+        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;
             }
 
-            const workspace = monitor._workspaces[activeWorkspaceIndex];
+            if (isInDirection && distance < bestDistance) {
-
+                bestDistance = distance;
-            // Check if the window is directly in the workspace container
+                bestMonitorId = monId;
-            const windowWrapper = workspace.getWindow(this._activeWindowId);
-            if (windowWrapper) {
-                // Try to find the parent container
-                const container = this._findContainerHoldingWindow(workspace, this._activeWindowId);
-                return container;
             }
         }
 
+        return bestMonitorId;
+    }
+
+    /**
+     * Return the monitor ID that contains the given window, or null.
+     */
+    private _findMonitorIdForWindow(windowId: number): number | null {
+        for (const [monId, monitor] of this._monitors.entries()) {
+            if (monitor.getWindow(windowId) !== undefined) return monId;
+        }
         return null;
     }
 
     /**
-     * Recursively finds the container that directly contains a specific window
+     * When at the edge of a container, find the nearest window on the adjacent
-     * @param container The container to search
+     * monitor in the given direction.
-     * @param windowId The window ID to find
+     *
-     * @returns The container that directly contains the window, or null if not found
+     * On the target monitor, picks the edge-most window:
+     *   - Navigating LEFT/UP   → last (far-edge) leaf window
+     *   - Navigating RIGHT/DOWN → first (near-edge) leaf window
      */
-    private _findContainerHoldingWindow(container: WindowContainer, windowId: number): WindowContainer | null {
+    private _findCrossMonitorWindow(direction: Direction): number | null {
-        // Check if this container directly contains the window
+        if (this._activeWindowId === null) return null;
-        for (const item of container._tiledItems) {
-            if (item instanceof WindowContainer) {
-                // Recursively search nested containers
-                const result = this._findContainerHoldingWindow(item, windowId);
-                if (result) {
-                    return result;
-                }
-            } else if (item.getWindowId() === windowId) {
-                // Found it! Return this container as it directly holds the window
-                return container;
-            }
-        }
 
-        return null;
+        const currentMonitorId = this._findMonitorIdForWindow(this._activeWindowId);
+        if (currentMonitorId === null) return null;
+
+        const targetMonitorId = this._findAdjacentMonitorId(currentMonitorId, direction);
+        if (targetMonitorId === null) return null;
+
+        const targetMonitor = this._monitors.get(targetMonitorId)!;
+        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;
+
+        return (direction === Direction.LEFT || direction === Direction.UP)
+            ? targetContainer._lastLeafWindowId()
+            : targetContainer._firstLeafWindowId();
     }
 
     /**
-     * Prints the tree structure of all monitors, workspaces, containers, and windows to the logs
+     * Move a window to the adjacent monitor in the given direction.
+     *
+     * The window is inserted at the "entry edge" of the target container:
+     *   - Moving RIGHT/DOWN → position 0 (near edge)
+     *   - Moving LEFT/UP    → end of the container (far edge)
      */
+    private _moveWindowCrossMonitor(windowId: number, direction: Direction): void {
+        const currentMonitorId = this._findMonitorIdForWindow(windowId);
+        if (currentMonitorId === null) return;
+
+        const targetMonitorId = this._findAdjacentMonitorId(currentMonitorId, direction);
+        if (targetMonitorId === null) return;
+
+        const currentMonitor = this._monitors.get(currentMonitorId)!;
+        const wrapped = currentMonitor.getWindow(windowId);
+        if (!wrapped) return;
+
+        const targetMonitor = this._monitors.get(targetMonitorId)!;
+        const insertIndex = (direction === Direction.RIGHT || direction === Direction.DOWN) ? 0 : undefined;
+
+        currentMonitor.removeWindow(wrapped);
+        targetMonitor.addWindow(wrapped, insertIndex);
+
+        this._tileMonitors();
+        Logger.info(`Moved window ${windowId} to monitor ${targetMonitorId} (${direction})`);
+    }
+
     public printTreeStructure(): void {
         Logger.info("=".repeat(80));
         Logger.info("WINDOW TREE STRUCTURE");
@@ -526,19 +774,18 @@ export default class WindowManager implements IWindowManager {
         this._monitors.forEach((monitor: Monitor, monitorId: number) => {
             const isActiveMonitor = this._activeWindowId !== null &&
                                    monitor.getWindow(this._activeWindowId) !== undefined;
-            const monitorMarker = isActiveMonitor ? ' *' : '';
 
-            Logger.info(`Monitor ${monitorId}${monitorMarker}:`);
+            Logger.info(`Monitor ${monitorId}${isActiveMonitor ? ' *' : ''}:`);
             Logger.info(`  Work Area: x=${monitor._workArea.x}, y=${monitor._workArea.y}, w=${monitor._workArea.width}, h=${monitor._workArea.height}`);
 
             monitor._workspaces.forEach((workspace, workspaceIndex) => {
                 const isActiveWorkspace = workspaceIndex === activeWorkspaceIndex;
-                const workspaceMarker = isActiveWorkspace && isActiveMonitor ? ' *' : '';
+                Logger.info(`  Workspace ${workspaceIndex}${isActiveWorkspace && isActiveMonitor ? ' *' : ''}:`);
-
+                Logger.info(`    Orientation: ${Layout[workspace._orientation]}`);
-                Logger.info(`  Workspace ${workspaceIndex}${workspaceMarker}:`);
-                Logger.info(`    Orientation: ${workspace._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'}`);
                 Logger.info(`    Items: ${workspace._tiledItems.length}`);
-
+                if (workspace.isTabbed()) {
+                    Logger.info(`    Active Tab: ${workspace._activeTabIndex}`);
+                }
                 this._printContainerTree(workspace, 4);
             });
         });
@@ -546,31 +793,20 @@ export default class WindowManager implements IWindowManager {
         Logger.info("=".repeat(80));
     }
 
-    /**
+    private _printContainerTree(container: WindowContainer, indentLevel: number): void {
-     * Recursively prints the container tree structure
-     * @param container The container to print
-     * @param indentLevel The indentation level (number of spaces)
-     */
-    private _printContainerTree(container: any, indentLevel: number): void {
         const indent = " ".repeat(indentLevel);
 
-        container._tiledItems.forEach((item: any, index: number) => {
+        container._tiledItems.forEach((item, index) => {
             if (item instanceof WindowContainer) {
-                // Check if this container contains the active window
+                const containsActive = this._activeWindowId !== null &&
-                const containsActiveWindow = this._activeWindowId !== null &&
+                                       item.getWindow(this._activeWindowId) !== undefined;
-                                            item.getWindow(this._activeWindowId) !== undefined;
+                Logger.info(`${indent}[${index}] Container (${Layout[item._orientation]})${containsActive ? ' *' : ''}:`);
-                const containerMarker = containsActiveWindow ? ' *' : '';
-
-                Logger.info(`${indent}[${index}] Container (${item._orientation === 0 ? 'HORIZONTAL' : 'VERTICAL'})${containerMarker}:`);
                 Logger.info(`${indent}    Items: ${item._tiledItems.length}`);
                 Logger.info(`${indent}    Work Area: x=${item._workArea.x}, y=${item._workArea.y}, w=${item._workArea.width}, h=${item._workArea.height}`);
                 this._printContainerTree(item, indentLevel + 4);
             } else {
                 const window = item.getWindow();
-                const isActiveWindow = this._activeWindowId === item.getWindowId();
+                Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${this._activeWindowId === item.getWindowId() ? ' *' : ''}`);
-                const windowMarker = isActiveWindow ? ' *' : '';
-
-                Logger.info(`${indent}[${index}] Window ID: ${item.getWindowId()}${windowMarker}`);
                 Logger.info(`${indent}    Title: "${window.get_title()}"`);
                 Logger.info(`${indent}    Class: ${window.get_wm_class()}`);
                 const rect = item.getRect();
@@ -578,6 +814,4 @@ export default class WindowManager implements IWindowManager {
             }
         });
     }
-
-
 }

stylesheet.css

@@ -1,37 +1,33 @@
-/* Add your custom extension styling here */
+.aerospike-tab-bar {
-.active-window-border {
+    background-color: rgba(30, 30, 30, 0.95);
-    /*border: 2px solid rgba(191, 0, 255, 0.8);*/
+    border-bottom: 1px solid rgba(255, 255, 255, 0.08);
-    /*border-radius: 3px;*/
+    spacing: 1px;
-
+    padding: 2px 2px 0 2px;
-/*    border-image-source: linear-gradient(to left, #743ad5, #d53a9d);*/
-/*    !*border: 4px solid transparent;*!*/
-/*    !*border-radius: 5px;*!*/
-
-/*    !*!* Gradient border using border-image *!*/
-/*    border-image: linear-gradient(45deg, red, orange, yellow, green, blue, indigo, violet) 1;*/
-
 }
 
-/*.border-gradient-purple {*/
+.aerospike-tab {
-/*    border-image-source: linear-gradient(to left, #743ad5, #d53a9d);*/
+    background-color: rgba(50, 50, 50, 0.8);
-/*}*/
+    border-radius: 6px 6px 0 0;
+    padding: 2px 12px;
+    margin: 0 1px;
+    color: rgba(255, 255, 255, 0.5);
+    font-size: 11px;
+    font-weight: 400;
+    min-width: 0;
+}
 
-/*@keyframes rainbow-border {*/
+.aerospike-tab:hover {
-/*    0% {*/
+    background-color: rgba(70, 70, 70, 0.9);
-/*        border-image: linear-gradient(0deg, red, orange, yellow, green, blue, indigo, violet, red) 1;*/
+    color: rgba(255, 255, 255, 0.8);
-/*    }*/
+}
-/*    100% {*/
-/*        border-image: linear-gradient(360deg, red, orange, yellow, green, blue, indigo, violet, red) 1;*/
-/*    }*/
-/*}*/
 
-/*.active-window-border {*/
+.aerospike-tab-active {
-/*    border: 4px solid transparent;*/
+    background-color: rgba(80, 80, 80, 1);
-/*    border-radius: 5px;*/
+    color: rgba(255, 255, 255, 1);
+    font-weight: 500;
+}
 
-/*    !* Initial gradient border *!*/
+.aerospike-tab-label {
-/*    border-image: linear-gradient(0deg, red, orange, yellow, green, blue, indigo, violet, red) 1;*/
+    font-size: 11px;
-
+    min-width: 0;
-/*    !* Apply animation *!*/
+}
-/*    animation: rainbow-border 5s linear infinite;*/
-/*}*/