fix: Stack swapping fixes

Author: mmstick

src/auto_tiler.ts

@@ -48,26 +48,26 @@ export class AutoTiler {
 
         if (!a_fork || !b_fork) return;
 
-        function stack_detach(ext: Ext, win: ShellWindow): null | number {
-            const win_stack = win.stack;
-            if (win.stack !== null) ext.auto_tiler
-                ?.forest.stacks.get(win.stack)
-                ?.deactivate(win);
-            return win_stack;
-        }
+        const a_stack = a_win.stack, b_stack = b_win.stack;
 
-        const a_stack = stack_detach(ext, a_win);
-        const b_stack = stack_detach(ext, b_win);
+        if (ext.auto_tiler) {
+            if (a_win.stack !== null) ext.auto_tiler.forest.stacks.get(a_win.stack)?.deactivate(a_win);
+            if (b_win.stack !== null) ext.auto_tiler.forest.stacks.get(b_win.stack)?.deactivate(b_win);
+        }
 
-        a_fork.replace_window(ext, a_win, b_win);
+        const a_fn = a_fork.replace_window(ext, a_win, b_win);
         this.attached.insert(b, a_ent);
-        a_win.stack = b_stack;
         this.tile(ext, a_fork, a_fork.area);
 
-        b_fork.replace_window(ext, b_win, a_win);
+        const b_fn = b_fork.replace_window(ext, b_win, a_win);
         this.attached.insert(a, b_ent);
-        b_win.stack = a_stack;
         this.tile(ext, b_fork, b_fork.area);
+
+        if (a_fn) a_fn();
+        if (b_fn) b_fn();
+
+        a_win.stack = b_stack;
+        b_win.stack = a_stack;
     }
 
     update_toplevel(ext: Ext, fork: Fork, monitor: number, smart_gaps: boolean) {

src/fork.ts

@@ -118,39 +118,57 @@ export class Fork {
     }
 
     /** Replaces the association of a window in a fork with another */
-    replace_window(ext: Ext, a: ShellWindow, b: ShellWindow): boolean {
-        if (!this.right) return false;
-
+    replace_window(ext: Ext, a: ShellWindow, b: ShellWindow): null | (() => void) {
         switch (this.left.inner.kind) {
             case 2:
-                if (Ecs.entity_eq(this.left.inner.entity, a.entity)) {
-                    this.left.inner.entity = b.entity;
-                } else if (this.right.inner.kind === 2) {
-                    this.right.inner.entity = b.entity;
-                } else if (this.right.inner.kind === 3) {
-                    const idx = node.stack_find(this.right.inner, a.entity);
-                    if (idx === null) return false;
-                    node.stack_replace(ext, this.right.inner, idx, b.entity);
-                    this.right.inner.entities[idx] = b.entity;
+                const inner = this.left.inner;
+                if (Ecs.entity_eq(inner.entity, a.entity)) {
+                    return () => {
+                        inner.entity = b.entity;
+                    }
+                } else if (this.right) {
+                    const inner = this.right.inner;
+                    if (inner.kind === 2) {
+                        return () => {
+                            inner.entity = b.entity;
+                        };
+                    } else if (inner.kind === 3) {
+                        const idx = node.stack_find(inner, a.entity);
+                        if (idx === null) return null;
+
+                        return () => {
+                            node.stack_replace(ext, inner, idx, b);
+                            inner.entities[idx] = b.entity;
+                        };
+                    }
                 }
 
                 break
             case 3:
-                let idx = node.stack_find(this.left.inner, a.entity);
+                const inner_s = this.left.inner as node.NodeStack;
+                let idx = node.stack_find(inner_s, a.entity);
                 if (idx !== null) {
-                    node.stack_replace(ext, this.left.inner, idx, b.entity);
-                    this.left.inner.entities[idx] = b.entity;
-                } else if (this.right.inner.kind === 2) {
-                    this.right.inner.entity = b.entity;
-                } else if (this.right.inner.kind === 3) {
-                    const idx = node.stack_find(this.right.inner, a.entity);
-                    if (idx === null) return false;
-                    node.stack_replace(ext, this.right.inner, idx, b.entity);
-                    this.right.inner.entities[idx] = b.entity;
+                    const id = idx;
+                    return () => {
+                        node.stack_replace(ext, inner_s, id, b);
+                        inner_s.entities[id] = b.entity;
+                    }
+                } else if (this.right) {
+                    const inner = this.right.inner;
+                    if (inner.kind === 2) {
+                        return () => inner.entity = b.entity;
+                    } else if (inner.kind === 3) {
+                        const idx = node.stack_find(inner, a.entity);
+                        if (idx === null) return null;
+                        return () => {
+                            node.stack_replace(ext, inner, idx, b);
+                            inner.entities[idx] = b.entity;
+                        };
+                    }
                 }
         }
 
-        return true;
+        return null;
     }
 
     /** Sets a new area for this fork */

src/node.ts

@@ -8,6 +8,7 @@ import type { Entity } from 'ecs';
 import type { Ext } from 'extension';
 import type { Rectangle } from 'rectangle';
 import type { Stack } from 'stack';
+import { ShellWindow } from './window';
 
 /** A node is either a fork a window */
 export enum NodeKind {
@@ -116,14 +117,13 @@ export function stack_move_right(ext: Ext, forest: Forest, node: NodeStack, enti
     return moved;
 }
 
-export function stack_replace(ext: Ext, node: NodeStack, from: number, window: Entity) {
+export function stack_replace(ext: Ext, node: NodeStack, from: number, window: ShellWindow) {
     if (!ext.auto_tiler) return;
 
     const stack = ext.auto_tiler.forest.stacks.get(node.idx);
     if (!stack) return;
 
-    const win = ext.windows.get(window);
-    if (win) stack.replace(from, win)
+    stack.replace(from, window)
 }
 
 /** Removes a window from a stack */

src/stack.ts

@@ -237,7 +237,8 @@ export class Stack {
         const c = this.components[idx];
         if (c) {
             for (const s of c.signals) c.meta.disconnect(s);
-            c.meta.get_compositor_private()?.show();
+
+            const actor = window.meta.get_compositor_private();
 
             if (this.active_meta === c.meta) {
                 if (this.active_signal) this.active_meta.disconnect(this.active_signal);
@@ -246,9 +247,9 @@ export class Stack {
                     this.update_positions(window.meta.get_frame_rect());
                 });
                 this.active = window.entity;
-                window.meta.get_compositor_private()?.show();
+                actor?.show();
             } else {
-                window.meta.get_compositor_private()?.hide();
+                actor?.hide();
             }
 
             c.meta = window.meta;

src/tiling.ts

@@ -628,6 +628,8 @@ export class Tiler {
                     ext.size_signals_unblock(meta);
                     ext.add_tag(meta_entity, Tags.Tiled);
                 });
+
+                ext.active_hint?.track_window(ext, meta, false);
             }
         }
 

src/window.ts

@@ -175,6 +175,7 @@ export class ShellWindow {
                 ext.tween_signals.delete(entity_string);
                 if (ext.active_hint?.is_tracking(this.entity)) {
                     ext.active_hint.track_window(ext, this);
+                    ext.active_hint.show();
                 }
             };