feat: add BrowserWindow restore, isFocused, fullscreen, alwaysOnTop, and destroy on both platforms

Author: ipfizz

src/main/api/browser-window.ts

@@ -240,6 +240,26 @@ export class BrowserWindow extends EventEmitter {
     return this.#native.isMinimized();
   }
 
+  restore(): void {
+    this.#native.restore();
+  }
+
+  isFocused(): boolean {
+    return this.#native.isFocused();
+  }
+
+  setFullScreen(flag: boolean): void {
+    this.#native.setFullScreen(flag);
+  }
+
+  isFullScreen(): boolean {
+    return this.#native.isFullScreen();
+  }
+
+  setAlwaysOnTop(flag: boolean): void {
+    this.#native.setAlwaysOnTop(flag);
+  }
+
   isDestroyed(): boolean {
     return this.#destroyed;
   }
@@ -248,6 +268,11 @@ export class BrowserWindow extends EventEmitter {
     this.#native.close();
   }
 
+  /** Force-close the window without consulting `close` listeners. */
+  destroy(): void {
+    this.#native.destroy();
+  }
+
   /** All open windows, in creation order. */
   static getAllWindows(): BrowserWindow[] {
     return [...registry.values()];

src/main/platform/linux/gtk-ffi.ts

@@ -92,6 +92,18 @@ export const GTK_FFI_SYMBOLS = {
     args: [],
     returns: FFIType.pointer,
   },
+  gtk_window_fullscreen: {
+    args: [FFIType.pointer],
+    returns: FFIType.void,
+  },
+  gtk_window_unfullscreen: {
+    args: [FFIType.pointer],
+    returns: FFIType.void,
+  },
+  gtk_window_is_fullscreen: {
+    args: [FFIType.pointer],
+    returns: FFIType.i32,
+  },
 } as const;
 
 const cache: { ffi: ReturnType<typeof dlopen<typeof GTK_FFI_SYMBOLS>> | undefined } = {

src/main/platform/linux/linux-backend.ts

@@ -471,6 +471,35 @@ class LinuxWindow implements NativeWindow {
     return this.#minimized;
   }
 
+  restore(): void {
+    const gtk = loadGtkFFI();
+    gtk.symbols.gtk_window_unminimize(this.#window);
+    this.#minimized = false;
+  }
+
+  isFocused(): boolean {
+    const gtk = loadGtkFFI();
+    return gtk.symbols.gtk_window_is_active(this.#window) !== 0;
+  }
+
+  setFullScreen(flag: boolean): void {
+    const gtk = loadGtkFFI();
+    if (flag) {
+      gtk.symbols.gtk_window_fullscreen(this.#window);
+    } else {
+      gtk.symbols.gtk_window_unfullscreen(this.#window);
+    }
+  }
+
+  isFullScreen(): boolean {
+    const gtk = loadGtkFFI();
+    return gtk.symbols.gtk_window_is_fullscreen(this.#window) !== 0;
+  }
+
+  setAlwaysOnTop(_flag: boolean): void {
+    // GTK4 dropped keep-above; no portable client API. No-op (best-effort).
+  }
+
   close(): void {
     if (this.#closed) {
       return;
@@ -488,6 +517,15 @@ class LinuxWindow implements NativeWindow {
     gtk.symbols.gtk_window_destroy(this.#window);
   }
 
+  destroy(): void {
+    if (this.#closed) {
+      return;
+    }
+    // Force-close: run teardown then destroy WITHOUT consulting the veto.
+    this.#handleClosed();
+    loadGtkFFI().symbols.gtk_window_destroy(this.#window);
+  }
+
   onClosed(callback: () => void): void {
     this.#closedCallbacks.push(callback);
   }

src/main/platform/macos/cocoa-backend.ts

@@ -30,6 +30,7 @@ import {
   msgSendPtr4,
   msgSendPtrI64U8Ptr,
   msgSendPtrPtr,
+  msgSendReturnsI64,
   msgSendReturnsU8,
   msgSendSize,
   msgSendU8,
@@ -58,6 +59,10 @@ const log = createLogger('macos-backend');
 
 const NS_BACKING_STORE_BUFFERED = 2n;
 const NS_ACTIVATION_POLICY_REGULAR = 0n;
+/** `NSWindowStyleMaskFullScreen` (1 << 14). */
+const NS_FULLSCREEN_STYLE_MASK = 16384n;
+/** `NSFloatingWindowLevel` — above normal windows. */
+const NS_FLOATING_WINDOW_LEVEL = 3n;
 const WK_INJECTION_TIME_AT_DOCUMENT_START = 0n;
 const SCRIPT_MESSAGE_HANDLER_NAME = 'sambar';
 /** Page-world handler name `executeJavaScript` posts its result to (D022). */
@@ -443,6 +448,33 @@ class MacOSWindow implements NativeWindow {
     return msgSendReturnsU8(this.#window, cocoa().selectors.get('isMiniaturized')) === 1;
   }
 
+  restore(): void {
+    msgSendPtr(this.#window, cocoa().selectors.get('deminiaturize:'), 0n);
+  }
+
+  isFocused(): boolean {
+    return msgSendReturnsU8(this.#window, cocoa().selectors.get('isKeyWindow')) === 1;
+  }
+
+  isFullScreen(): boolean {
+    const styleMask = msgSendReturnsI64(this.#window, cocoa().selectors.get('styleMask'));
+    return (styleMask & NS_FULLSCREEN_STYLE_MASK) !== 0n;
+  }
+
+  setFullScreen(flag: boolean): void {
+    if (flag !== this.isFullScreen()) {
+      msgSendPtr(this.#window, cocoa().selectors.get('toggleFullScreen:'), 0n);
+    }
+  }
+
+  setAlwaysOnTop(flag: boolean): void {
+    msgSendI64(
+      this.#window,
+      cocoa().selectors.get('setLevel:'),
+      flag ? NS_FLOATING_WINDOW_LEVEL : 0n,
+    );
+  }
+
   close(): void {
     if (this.#tornDown) {
       return;
@@ -455,6 +487,15 @@ class MacOSWindow implements NativeWindow {
     msgSendPtr(this.#window, cocoa().selectors.get('performClose:'), 0n);
   }
 
+  destroy(): void {
+    if (this.#tornDown) {
+      return;
+    }
+    // `-close` (not `-performClose:`) fires windowWillClose: (teardown + closed)
+    // WITHOUT windowShouldClose:, so it bypasses the preventable veto.
+    cocoa().msgSend(this.#window, cocoa().selectors.get('close'));
+  }
+
   onClosed(callback: () => void): void {
     this.#onClosed = callback;
   }

src/main/platform/native.ts

@@ -130,8 +130,19 @@ export interface NativeWindow {
   unmaximize(): void;
   isMaximized(): boolean;
   isMinimized(): boolean;
+  /** Restore a minimized window. */
+  restore(): void;
+  /** Whether the window currently has keyboard focus. */
+  isFocused(): boolean;
+  /** Enter or leave fullscreen. */
+  setFullScreen(flag: boolean): void;
+  isFullScreen(): boolean;
+  /** Keep the window above others (macOS; best-effort/no-op elsewhere). */
+  setAlwaysOnTop(flag: boolean): void;
   /** Close and destroy the window. Idempotent. */
   close(): void;
+  /** Force-close the window, bypassing the preventable `close` listener. */
+  destroy(): void;
   /** Register a callback fired once when the window is closed. */
   onClosed(callback: () => void): void;
   /**

tests/unit/main/api/browser-window.test.ts

@@ -41,6 +41,8 @@ const makeFakeWindow = (options: NativeWindowOptions): FakeWindow => {
   let bounds: Rect = { x: 0, y: 0, width: options.width, height: options.height };
   let maximized = false;
   let minimized = false;
+  let fullscreen = false;
+  let focused = false;
   let onClosed: (() => void) | undefined;
   let onClose: (() => boolean) | undefined;
   let teardowns = 0;
@@ -88,6 +90,7 @@ const makeFakeWindow = (options: NativeWindowOptions): FakeWindow => {
     isVisible: () => visible,
     focus: () => {
       visible = true;
+      focused = true;
     },
     minimize: () => {
       minimized = true;
@@ -100,6 +103,15 @@ const makeFakeWindow = (options: NativeWindowOptions): FakeWindow => {
     },
     isMaximized: () => maximized,
     isMinimized: () => minimized,
+    restore: () => {
+      minimized = false;
+    },
+    isFocused: () => focused,
+    setFullScreen: (flag) => {
+      fullscreen = flag;
+    },
+    isFullScreen: () => fullscreen,
+    setAlwaysOnTop: () => undefined,
     close: () => {
       // A real backend routes programmatic close through the same delegate path:
       // consult the veto, and only on a non-veto run teardown + fire closed.
@@ -109,6 +121,10 @@ const makeFakeWindow = (options: NativeWindowOptions): FakeWindow => {
       teardown();
       onClosed?.();
     },
+    destroy: () => {
+      teardown();
+      onClosed?.();
+    },
     onClosed: (cb) => {
       onClosed = cb;
     },
@@ -470,3 +486,42 @@ describe('App-level window events', () => {
     expect(appExitCodes()).toEqual([]);
   });
 });
+
+describe('BrowserWindow window controls', () => {
+  test('restore clears the minimized state', () => {
+    const win = new BrowserWindow();
+    win.minimize();
+    expect(win.isMinimized()).toBe(true);
+    win.restore();
+    expect(win.isMinimized()).toBe(false);
+  });
+
+  test('isFocused reflects the native state', () => {
+    const win = new BrowserWindow();
+    expect(win.isFocused()).toBe(false);
+    win.focus();
+    expect(win.isFocused()).toBe(true);
+  });
+
+  test('setFullScreen toggles isFullScreen', () => {
+    const win = new BrowserWindow();
+    expect(win.isFullScreen()).toBe(false);
+    win.setFullScreen(true);
+    expect(win.isFullScreen()).toBe(true);
+    win.setFullScreen(false);
+    expect(win.isFullScreen()).toBe(false);
+  });
+
+  test('setAlwaysOnTop does not throw', () => {
+    const win = new BrowserWindow();
+    expect(() => win.setAlwaysOnTop(true)).not.toThrow();
+  });
+
+  test('destroy force-closes even when a close listener vetoes', () => {
+    const win = new BrowserWindow();
+    win.on('close', (event) => event.preventDefault());
+    win.destroy();
+    expect(win.isDestroyed()).toBe(true);
+    expect(BrowserWindow.fromId(win.id)).toBeUndefined();
+  });
+});

tests/unit/main/platform/linux/gtk-ffi.test.ts

@@ -63,6 +63,13 @@ describe('GTK_FFI_SYMBOLS (shape-only ABI assertions)', () => {
     expect(GTK_FFI_SYMBOLS.gtk_about_dialog_new.returns).toBe(FFIType.pointer);
   });
 
+  it('declares fullscreen/unfullscreen as [ptr] -> void and is_fullscreen as [ptr] -> i32', () => {
+    expect(GTK_FFI_SYMBOLS.gtk_window_fullscreen.args).toEqual([FFIType.pointer]);
+    expect(GTK_FFI_SYMBOLS.gtk_window_fullscreen.returns).toBe(FFIType.void);
+    expect(GTK_FFI_SYMBOLS.gtk_window_unfullscreen.returns).toBe(FFIType.void);
+    expect(GTK_FFI_SYMBOLS.gtk_window_is_fullscreen.returns).toBe(FFIType.i32);
+  });
+
   it('reads the title as a nullable pointer (not cstring) so 0 can be guarded', () => {
     expect(GTK_FFI_SYMBOLS.gtk_window_get_title.args).toEqual([FFIType.pointer]);
     expect(GTK_FFI_SYMBOLS.gtk_window_get_title.returns).toBe(FFIType.pointer);