@n1h/sweetview 0.0.0-stage → 0.1.1

package/src/native/win32/folder-picker.ts

@@ -0,0 +1,121 @@
+// Native Windows folder picker: IFileOpenDialog (the modern Vista+ dialog)
+// driven directly over COM vtables with bun:ffi. No child process.
+//
+// Must be called on the thread that owns the window (the webview UI thread),
+// which is already COM-initialised (apartment threaded) by WebView2.
+
+import { CFunction, FFIType, dlopen, ptr, read, toArrayBuffer, type Pointer } from "bun:ffi";
+import type { WindowHandle } from "../window";
+import { asPointer, toPointer, wstr } from "./api";
+
+const ole32 = dlopen("ole32.dll", {
+  CoInitializeEx: { args: [FFIType.ptr, FFIType.u32], returns: FFIType.i32 },
+  CoCreateInstance: { args: [FFIType.ptr, FFIType.ptr, FFIType.u32, FFIType.ptr, FFIType.ptr], returns: FFIType.i32 },
+  CoTaskMemFree: { args: [FFIType.ptr], returns: FFIType.void },
+});
+
+const COINIT_APARTMENTTHREADED = 0x2;
+const CLSCTX_INPROC_SERVER = 0x1;
+const CLSID_FileOpenDialog = guid("DC1C5A9C-E88A-4DDE-A5A1-60F82A20AEF7");
+const IID_IFileOpenDialog = guid("D57C7288-D4AD-4768-BE02-9D969532D960");
+
+const FOS_NOCHANGEDIR = 0x8;
+const FOS_PICKFOLDERS = 0x20;
+const FOS_FORCEFILESYSTEM = 0x40;
+const FOS_PATHMUSTEXIST = 0x800;
+const SIGDN_FILESYSPATH = 0x80058000;
+const HRESULT_CANCELLED = 0x800704c7 | 0; // HRESULT_FROM_WIN32(ERROR_CANCELLED)
+
+// vtable slots (shobjidl_core.h)
+const IUnknown_Release = 2;
+const IModalWindow_Show = 3;
+const IFileDialog_SetOptions = 9;
+const IFileDialog_GetOptions = 10;
+const IFileDialog_SetTitle = 17;
+const IFileDialog_GetResult = 20;
+const IShellItem_GetDisplayName = 5;
+
+type Fn = (...args: unknown[]) => number;
+
+function guid(s: string): Uint8Array {
+  const hex = s.replace(/-/g, "");
+  const b = new Uint8Array(16);
+  const view = new DataView(b.buffer);
+  view.setUint32(0, parseInt(hex.slice(0, 8), 16), true);
+  view.setUint16(4, parseInt(hex.slice(8, 12), 16), true);
+  view.setUint16(6, parseInt(hex.slice(12, 16), 16), true);
+  for (let i = 0; i < 8; i++) b[8 + i] = parseInt(hex.slice(16 + i * 2, 18 + i * 2), 16);
+  return b;
+}
+
+function method(obj: Pointer, slot: number, args: FFIType[], returns: FFIType): Fn {
+  const vtable = asPointer(read.ptr(obj, 0));
+  const fn = asPointer(read.ptr(vtable, slot * 8));
+  return CFunction({ ptr: fn, args, returns }) as unknown as Fn;
+}
+
+function release(obj: Pointer) {
+  method(obj, IUnknown_Release, [FFIType.ptr], FFIType.u32)(obj);
+}
+
+function readWide(p: Pointer): string {
+  let n = 0;
+  while (read.u16(p, n * 2) !== 0) n++;
+  return new TextDecoder("utf-16le").decode(toArrayBuffer(p, 0, n * 2));
+}
+
+function check(hr: number, what: string) {
+  if (hr < 0) throw new Error(`${what} failed: HRESULT 0x${(hr >>> 0).toString(16)}`);
+}
+
+/** Opens the native folder dialog owned by `owner`. Returns the path, or null if cancelled. */
+export function pickFolder(owner: WindowHandle, title: string): string | null {
+  const hwnd = toPointer(owner);
+  // S_OK or S_FALSE (already initialised on this thread by WebView2).
+  check(ole32.symbols.CoInitializeEx(null, COINIT_APARTMENTTHREADED), "CoInitializeEx");
+
+  const out = new BigUint64Array(1);
+  check(
+    ole32.symbols.CoCreateInstance(ptr(CLSID_FileOpenDialog), null, CLSCTX_INPROC_SERVER, ptr(IID_IFileOpenDialog), ptr(out)),
+    "CoCreateInstance(FileOpenDialog)",
+  );
+  const dialog = asPointer(out[0]!);
+
+  try {
+    const opts = new Uint32Array(1);
+    check(method(dialog, IFileDialog_GetOptions, [FFIType.ptr, FFIType.ptr], FFIType.i32)(dialog, ptr(opts)), "GetOptions");
+    check(
+      method(dialog, IFileDialog_SetOptions, [FFIType.ptr, FFIType.u32], FFIType.i32)(
+        dialog,
+        (opts[0]! | FOS_PICKFOLDERS | FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_NOCHANGEDIR) >>> 0,
+      ),
+      "SetOptions",
+    );
+    check(method(dialog, IFileDialog_SetTitle, [FFIType.ptr, FFIType.ptr], FFIType.i32)(dialog, wstr(title)), "SetTitle");
+
+    const hr = method(dialog, IModalWindow_Show, [FFIType.ptr, FFIType.ptr], FFIType.i32)(dialog, hwnd);
+    if (hr === HRESULT_CANCELLED) return null;
+    check(hr, "Show");
+
+    out[0] = 0n;
+    check(method(dialog, IFileDialog_GetResult, [FFIType.ptr, FFIType.ptr], FFIType.i32)(dialog, ptr(out)), "GetResult");
+    const item = asPointer(out[0]!);
+    try {
+      out[0] = 0n;
+      check(
+        method(item, IShellItem_GetDisplayName, [FFIType.ptr, FFIType.u32, FFIType.ptr], FFIType.i32)(item, SIGDN_FILESYSPATH, ptr(out)),
+        "GetDisplayName",
+      );
+      const pwsz = asPointer(out[0]!);
+      try {
+        return readWide(pwsz);
+      } finally {
+        ole32.symbols.CoTaskMemFree(pwsz);
+      }
+    } finally {
+      release(item);
+    }
+  } finally {
+    release(dialog);
+  }
+}

package/src/native/win32/icon.ts

@@ -0,0 +1,85 @@
+// Icon bytes to GDI objects: an HICON for the tray, toasts and window
+// captions; an HBITMAP for menu items (menus take bitmaps, not icons, and
+// want 32bpp premultiplied alpha). The .ico is decoded in JS so both paths
+// scale to the DPI's size instead of letting the menu stretch a 16px image.
+
+import { ptr, toArrayBuffer } from "bun:ffi";
+import { icoRgba, parseIco, pickIcoEntry } from "../icon";
+import { ICON_BIG, ICON_SMALL, SM_CXICON, SM_CXSMICON, WM_SETICON, gdi32, lastError, user32 } from "./api";
+
+const IDI_APPLICATION = 32512n;
+const LR_DEFAULTCOLOR = 0;
+const DIB_RGB_COLORS = 0;
+
+export type LoadedIcon = { handle: bigint; owned: boolean };
+
+/** HICON from .ico bytes at the small-icon size (or `metric`); the stock application icon when there are none. */
+export function loadIcon(ico: Uint8Array | undefined, metric: number = SM_CXSMICON): LoadedIcon {
+  if (ico) {
+    const want = user32.GetSystemMetrics(metric) || (metric === SM_CXICON ? 32 : 16);
+    const entry = pickIcoEntry(parseIco(ico), want);
+    const bits = ico.subarray(entry.offset, entry.offset + entry.size);
+    const handle = user32.CreateIconFromResourceEx(bits, bits.length, 1, 0x00030000, want, want, LR_DEFAULTCOLOR);
+    if (handle !== 0n) return { handle, owned: true };
+    console.error(`sweetnative: CreateIconFromResourceEx failed (${lastError()}); using the default icon`);
+  }
+  return { handle: user32.LoadIconW(0n, IDI_APPLICATION), owned: false };
+}
+
+export const releaseIcon = (icon: LoadedIcon) => {
+  if (icon.owned) user32.DestroyIcon(icon.handle);
+};
+
+/**
+ * A 32bpp premultiplied-alpha HBITMAP of the .ico at `size` px (default the
+ * small-icon metric), for MENUITEMINFO.hbmpItem. 0n, with the reason logged,
+ * when the .ico cannot be decoded. The caller owns it: DeleteObject when done.
+ */
+export function iconBitmap(ico: Uint8Array, size: number = user32.GetSystemMetrics(SM_CXSMICON) || 16): bigint {
+  let rgba: Uint8Array;
+  try {
+    rgba = icoRgba(ico, size);
+  } catch (err) {
+    console.error(`sweetnative: menu icon skipped: ${err instanceof Error ? err.message : err}`);
+    return 0n;
+  }
+  const info = new Uint8Array(40); // BITMAPINFOHEADER; no colour table for BI_RGB 32bpp
+  const dv = new DataView(info.buffer);
+  dv.setUint32(0, 40, true);
+  dv.setInt32(4, size, true);
+  dv.setInt32(8, -size, true); // negative: top-down, so the RGBA rows copy straight in
+  dv.setUint16(12, 1, true);
+  dv.setUint16(14, 32, true);
+  const bitsOut = new BigUint64Array(1);
+  const hbm = gdi32.CreateDIBSection(0n, info, DIB_RGB_COLORS, ptr(bitsOut), 0n, 0);
+  if (hbm === 0n || bitsOut[0] === 0n) {
+    console.error(`sweetnative: CreateDIBSection failed (${lastError()})`);
+    return 0n;
+  }
+  const bits = new Uint8Array(toArrayBuffer(Number(bitsOut[0]) as never, 0, size * size * 4));
+  for (let i = 0; i < rgba.length; i += 4) {
+    const a = rgba[i + 3]!;
+    bits[i] = Math.round((rgba[i + 2]! * a) / 255); // B
+    bits[i + 1] = Math.round((rgba[i + 1]! * a) / 255); // G
+    bits[i + 2] = Math.round((rgba[i]! * a) / 255); // R
+    bits[i + 3] = a;
+  }
+  return hbm;
+}
+
+const windowIcons = new Map<bigint, LoadedIcon[]>();
+
+/**
+ * Sets a window's caption and taskbar icons (WM_SETICON small + big) from .ico
+ * bytes, or back to the stock icon when undefined. The HICONs live until the
+ * next call for the same window; Windows draws from them, so they cannot be
+ * destroyed right away.
+ */
+export function setWindowIcon(hwnd: bigint, ico: Uint8Array | undefined): void {
+  const small = loadIcon(ico, SM_CXSMICON);
+  const big = loadIcon(ico, SM_CXICON);
+  user32.SendMessageW(hwnd, WM_SETICON, ICON_SMALL, BigInt.asIntN(64, small.handle));
+  user32.SendMessageW(hwnd, WM_SETICON, ICON_BIG, BigInt.asIntN(64, big.handle));
+  windowIcons.get(hwnd)?.forEach(releaseIcon);
+  windowIcons.set(hwnd, [small, big]);
+}

package/src/native/win32/menu.ts

@@ -0,0 +1,107 @@
+// Popup menus: a MenuTemplate becomes an HMENU tree, shown modally with
+// TrackPopupMenu, then destroyed. Built fresh for every showing, so dynamic
+// labels and check marks cost nothing. Item icons are 32bpp bitmaps
+// (MENUITEMINFO.hbmpItem), which DestroyMenu does not free, so the build
+// keeps a list to delete afterwards.
+
+import { isSeparator, isSubmenu, type MenuTemplate } from "../menu";
+import { WM_NULL, gdi32, lastError, user32, wstr } from "./api";
+import { iconBitmap } from "./icon";
+
+const MF_STRING = 0x0;
+const MF_GRAYED = 0x1;
+const MF_CHECKED = 0x8;
+const MF_POPUP = 0x10;
+const MF_SEPARATOR = 0x800;
+
+const TPM_RIGHTBUTTON = 0x0002;
+const TPM_BOTTOMALIGN = 0x0020;
+const TPM_RETURNCMD = 0x0100;
+
+// MENUITEMINFOW, x64 (sizeof = 80).
+export const MII_SIZE = 80;
+export const MII_MASK = 4;
+export const MII_HBMPITEM = 72;
+const MIIM_BITMAP = 0x80;
+
+/** A literal ampersand in a menu label is an accelerator prefix unless doubled. */
+export const escapeLabel = (label: string) => label.replaceAll("&", "&&");
+
+/** The MENUITEMINFOW that sets only hbmpItem. */
+export function bitmapItemInfo(hbm: bigint): Uint8Array {
+  const mii = new Uint8Array(MII_SIZE);
+  const dv = new DataView(mii.buffer);
+  dv.setUint32(0, MII_SIZE, true);
+  dv.setUint32(MII_MASK, MIIM_BITMAP, true);
+  dv.setBigUint64(MII_HBMPITEM, hbm, true);
+  return mii;
+}
+
+type Built = { hmenu: bigint; commands: Map<number, () => void>; bitmaps: bigint[] };
+
+function build(template: MenuTemplate): Built {
+  const built: Built = { hmenu: user32.CreatePopupMenu(), commands: new Map(), bitmaps: [] };
+  if (built.hmenu === 0n) throw new Error("sweetnative: CreatePopupMenu failed");
+  try {
+    fill(built.hmenu, template, built);
+  } catch (err) {
+    destroy(built);
+    throw err;
+  }
+  return built;
+}
+
+function destroy(built: Built): void {
+  user32.DestroyMenu(built.hmenu); // takes the submenus with it
+  for (const hbm of built.bitmaps) gdi32.DeleteObject(hbm);
+}
+
+function fill(hmenu: bigint, template: MenuTemplate, built: Built): void {
+  template.forEach((item, position) => {
+    if (isSeparator(item)) {
+      user32.AppendMenuW(hmenu, MF_SEPARATOR, 0n, null);
+      return;
+    }
+    const grayed = item.enabled === false ? MF_GRAYED : 0;
+    const label = wstr(escapeLabel(item.label)); // AppendMenuW copies the text
+    if (isSubmenu(item)) {
+      const sub = user32.CreatePopupMenu();
+      if (sub === 0n) throw new Error("sweetnative: CreatePopupMenu failed");
+      fill(sub, item.submenu, built);
+      user32.AppendMenuW(hmenu, MF_POPUP | MF_STRING | grayed, sub, label);
+    } else {
+      const id = built.commands.size + 1; // command ids are 1-based; 0 means "nothing chosen"
+      built.commands.set(id, item.click ?? (() => {}));
+      const checked = item.checked ? MF_CHECKED : 0;
+      user32.AppendMenuW(hmenu, MF_STRING | grayed | checked, BigInt(id), label);
+    }
+    const ico = item.icon?.windows?.ico;
+    if (ico !== undefined) {
+      const hbm = iconBitmap(ico);
+      if (hbm !== 0n) {
+        built.bitmaps.push(hbm);
+        if (!user32.SetMenuItemInfoW(hmenu, position, 1, bitmapItemInfo(hbm))) console.error(`sweetnative: SetMenuItemInfoW(hbmpItem) failed (${lastError()})`);
+      }
+    }
+  });
+}
+
+/**
+ * Shows `template` at the cursor, owned by `owner`, and runs the chosen item's
+ * click handler. Blocks until the menu closes. Returns true when an item was chosen.
+ */
+export function popupMenuAtCursor(owner: bigint, template: MenuTemplate): boolean {
+  const pt = new Int32Array(2);
+  user32.GetCursorPos(pt);
+  const built = build(template);
+  // The owner must be the foreground window or the menu will not dismiss when
+  // the user clicks elsewhere; the WM_NULL afterwards is the documented nudge
+  // that makes the menu close correctly next time (KB 135788).
+  user32.SetForegroundWindow(owner);
+  const chosen = user32.TrackPopupMenu(built.hmenu, TPM_RIGHTBUTTON | TPM_BOTTOMALIGN | TPM_RETURNCMD, pt[0]!, pt[1]!, 0, owner, null);
+  user32.PostMessageW(owner, WM_NULL, 0n, 0n);
+  destroy(built);
+  const handler = built.commands.get(chosen);
+  handler?.();
+  return handler !== undefined;
+}

package/src/native/win32/message-window.ts

@@ -0,0 +1,72 @@
+// A never-shown top-level window whose window procedure is a JSCallback.
+// Shell_NotifyIcon posts tray clicks to it, SetTimer posts WM_TIMER to it, and
+// TrackPopupMenu needs an owner window that can take the foreground. It is a
+// real (not message-only) window so it also receives the TaskbarCreated
+// broadcast when Explorer restarts.
+
+import { FFIType, JSCallback, ptr } from "bun:ffi";
+import { WM_CLOSE, hInstance, lastError, user32, wstr } from "./api";
+
+const CLASS_NAME = "NativeShellMessageWindow";
+const WS_EX_TOOLWINDOW = 0x00000080;
+const WS_OVERLAPPED = 0x00000000;
+const WNDCLASSEXW_SIZE = 80;
+
+export type MessageHandler = (message: number, wParam: bigint, lParam: bigint) => void;
+
+export type MessageWindow = {
+  readonly hwnd: bigint;
+  readonly destroy: () => void;
+};
+
+const handlers = new Map<bigint, MessageHandler>();
+
+// Retained for the process: the registered class calls it until exit.
+let wndProc: JSCallback | undefined;
+
+function ensureClass(): void {
+  if (wndProc !== undefined) return;
+  wndProc = new JSCallback(
+    (hwnd: bigint, message: number, wParam: bigint, lParam: bigint): bigint => {
+      try {
+        handlers.get(hwnd)?.(message, wParam, lParam);
+      } catch (err) {
+        // Never let an exception unwind into user32.
+        console.error("sweetnative: tray handler threw:", err);
+      }
+      // Only destroy() tears this window down; an external WM_CLOSE is ignored.
+      return message === WM_CLOSE ? 0n : user32.DefWindowProcW(hwnd, message, wParam, lParam);
+    },
+    { args: [FFIType.u64, FFIType.u32, FFIType.u64, FFIType.i64], returns: FFIType.i64 },
+  );
+  if (wndProc.ptr === null) throw new Error("sweetnative: could not allocate the window procedure");
+
+  const wc = new Uint8Array(WNDCLASSEXW_SIZE);
+  const dv = new DataView(wc.buffer);
+  const className = wstr(CLASS_NAME);
+  dv.setUint32(0, WNDCLASSEXW_SIZE, true); // cbSize
+  dv.setBigUint64(8, BigInt(wndProc.ptr), true); // lpfnWndProc
+  dv.setBigUint64(24, hInstance(), true); // hInstance
+  dv.setBigUint64(64, BigInt(ptr(className)), true); // lpszClassName
+  if (user32.RegisterClassExW(ptr(wc)) === 0) {
+    throw new Error(`sweetnative: RegisterClassExW failed (${lastError()})`);
+  }
+}
+
+export function createMessageWindow(handler: MessageHandler): MessageWindow {
+  ensureClass();
+  const className = wstr(CLASS_NAME);
+  const hwnd = user32.CreateWindowExW(WS_EX_TOOLWINDOW, className, null, WS_OVERLAPPED, 0, 0, 0, 0, 0n, 0n, hInstance(), null);
+  if (hwnd === 0n) throw new Error(`sweetnative: CreateWindowExW failed (${lastError()})`);
+  handlers.set(hwnd, handler);
+  let destroyed = false;
+  return {
+    hwnd,
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      handlers.delete(hwnd);
+      user32.DestroyWindow(hwnd);
+    },
+  };
+}

package/src/native/win32/notifier.ts

@@ -0,0 +1,28 @@
+// Windows notifications: the tray icon's balloon, which Windows 10/11 renders
+// as a regular toast in the notification centre, with our own icon. Flat C,
+// no WinRT, no AppUserModelID registration. The toast belongs to the tray
+// icon, so the tray must exist first.
+
+import type { Notifier, NotifierOptions } from "../notifications";
+import { currentTray } from "./tray";
+
+const activeNotifier = new WeakMap<object, symbol>(); // each tray has one balloon click handler; its newest notifier owns it
+
+export function createNotifier(options: NotifierOptions = {}): Notifier {
+  const tray = currentTray();
+  if (!tray) throw new Error("sweetnative: on Windows, create the tray before the notifier (toasts hang off the tray icon)");
+  tray.balloon.onClick(options.onClick);
+  const me = Symbol("notifier");
+  activeNotifier.set(tray, me);
+  let disposed = false;
+  return {
+    notify(n) {
+      return !disposed && tray.balloon.show(n);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (activeNotifier.get(tray) === me) tray.balloon.onClick(undefined); // a newer notifier owns the handler otherwise
+    },
+  };
+}