quickwin 2026.5.2-3.145209

package/lib/preact/props.ts

@@ -0,0 +1,119 @@
+import * as gui from 'gui'
+import * as ffi from 'ffi'
+import * as win from 'win'
+
+const FFI_PTR = ffi.FFI_TYPE_POINTER
+const FFI_S32 = ffi.FFI_TYPE_SINT32
+const FFI_U32 = ffi.FFI_TYPE_UINT32
+const FFI_U64 = ffi.FFI_TYPE_UINT64
+
+const _user32 = win.LoadLibrary('user32.dll')
+
+const MoveWindow_proc = _user32 ? win.GetProcAddress(_user32, 'MoveWindow') : 0
+const EnableWindow_proc = _user32 ? win.GetProcAddress(_user32, 'EnableWindow') : 0
+const ShowWindow_proc = _user32 ? win.GetProcAddress(_user32, 'ShowWindow') : 0
+const SendMessageW_proc = _user32 ? win.GetProcAddress(_user32, 'SendMessageW') : 0
+const DestroyWindow_proc = _user32 ? win.GetProcAddress(_user32, 'DestroyWindow') : 0
+
+const SW_HIDE = gui.ShowWindowCmd.HIDE
+const SW_SHOW = gui.ShowWindowCmd.SHOW
+
+const BM_GETCHECK = gui.ButtonMsg.GETCHECK
+const BM_SETCHECK = gui.ButtonMsg.SETCHECK
+const BST_CHECKED = gui.ButtonCheckState.CHECKED
+const BST_UNCHECKED = gui.ButtonCheckState.UNCHECKED
+const EM_SETCUEBANNER = gui.EditMsg.SETCUEBANNER
+const EM_SETPASSWORDCHAR = gui.EditMsg.SETPASSWORDCHAR
+const CB_ADDSTRING = gui.ComboBoxMsg.ADDSTRING
+const LB_ADDSTRING = gui.LbMsg.ADDSTRING
+const PBM_SETRANGE32 = gui.ProgressMsg.SETRANGE32
+const PBM_SETPOS = gui.ProgressMsg.SETPOS
+
+export interface WProps {
+    type?: string
+    text?: string
+    value?: string
+    disabled?: boolean
+    visible?: boolean
+    style?: Record<string, any>
+    onEvent?: (e: Record<string, any>) => void
+    placeholder?: string
+    password?: boolean
+    checked?: boolean
+    items?: string[]
+    max?: number
+    children?: any
+}
+
+export function applyProps(hwnd: number, props: WProps, vnode?: Record<string, any>): void {
+    if (props.text !== undefined) {
+        gui.SetWindowText(hwnd as gui.HWND, props.text)
+    }
+    if (props.value !== undefined) {
+        gui.SetWindowText(hwnd as gui.HWND, props.value)
+    }
+    if (props.disabled !== undefined && EnableWindow_proc) {
+        ffi.ffiCall(EnableWindow_proc, [FFI_U64, FFI_U32] as const, [hwnd, props.disabled ? 0 : 1], FFI_U32)
+    }
+    if (props.visible !== undefined && ShowWindow_proc) {
+        ffi.ffiCall(ShowWindow_proc, [FFI_U64, FFI_S32] as const, [hwnd, props.visible ? SW_SHOW : SW_HIDE], FFI_U32)
+    }
+    if (props.onEvent !== undefined && vnode) {
+        const h = hwnd as unknown as gui.HWND
+        const oldProc = vnode._oldProc || gui.GetWindowLongPtr(h, gui.Gwlp.WNDPROC)
+        vnode._oldProc = oldProc
+        gui.SetWindowProc(h, (hw, msg, wParam, lParam) => {
+            const cb = vnode!.props?.onEvent
+            if (cb) cb({ hwnd: hw as unknown as number, msg, wParam, lParam })
+            return gui.CallWindowProc(oldProc as unknown as gui.WNDPROC, hw, msg, wParam, lParam)
+        })
+    }
+    if (props.placeholder !== undefined && SendMessageW_proc) {
+        ffi.ffiCall(SendMessageW_proc, [FFI_U64, FFI_S32, FFI_U32, FFI_PTR] as const, [hwnd, EM_SETCUEBANNER, 0, strToWide(props.placeholder)], FFI_U64)
+    }
+    if (props.password !== undefined && SendMessageW_proc) {
+        ffi.ffiCall(SendMessageW_proc, [FFI_U64, FFI_U64, FFI_U64, FFI_U64] as const, [hwnd, EM_SETPASSWORDCHAR, props.password ? 42 : 0, 0], FFI_U64)
+    }
+    if (props.checked !== undefined && SendMessageW_proc) {
+        ffi.ffiCall(SendMessageW_proc, [FFI_U64, FFI_U64, FFI_U64, FFI_U64] as const, [hwnd, BM_SETCHECK, props.checked ? BST_CHECKED : BST_UNCHECKED, 0], FFI_U64)
+    }
+    if (props.items && SendMessageW_proc) {
+        const msg = props.type === 'combobox' ? CB_ADDSTRING : LB_ADDSTRING
+        for (const item of props.items) {
+            ffi.ffiCall(SendMessageW_proc, [FFI_U64, FFI_S32, FFI_U32, FFI_PTR] as const, [hwnd, msg, 0, strToWide(item)], FFI_U64)
+        }
+    }
+    if (props.max !== undefined && SendMessageW_proc) {
+        ffi.ffiCall(SendMessageW_proc, [FFI_U64, FFI_U64, FFI_U64, FFI_U64] as const, [hwnd, PBM_SETRANGE32, 0, props.max], FFI_U64)
+    }
+    if (props.value !== undefined && props.type === 'progressbar' && SendMessageW_proc) {
+        ffi.ffiCall(SendMessageW_proc, [FFI_U64, FFI_U64, FFI_U64, FFI_U64] as const, [hwnd, PBM_SETPOS, Number(props.value), 0], FFI_U64)
+    }
+}
+
+const wideCache = new Map<string, ArrayBuffer>()
+const MAX_WIDE_CACHE = 50
+
+function strToWide(str: string): ArrayBuffer {
+    const cached = wideCache.get(str)
+    if (cached) return cached
+    const buf = new ArrayBuffer((str.length + 1) * 2)
+    const dv = new DataView(buf)
+    for (let i = 0; i < str.length; i++) dv.setUint16(i * 2, str.charCodeAt(i), true)
+    if (wideCache.size >= MAX_WIDE_CACHE) {
+        const key = wideCache.keys().next().value
+        if (key !== undefined) wideCache.delete(key)
+    }
+    wideCache.set(str, buf)
+    return buf
+}
+
+export function moveWindow(hwnd: number, x: number, y: number, w: number, h: number): void {
+    if (!MoveWindow_proc) return
+    ffi.ffiCall(MoveWindow_proc, [FFI_U64, FFI_S32, FFI_S32, FFI_S32, FFI_S32, FFI_U32] as const, [hwnd, x, y, w, h, 1], FFI_U32)
+}
+
+export function destroyWindow(hwnd: number): boolean {
+    if (!DestroyWindow_proc) return false
+    return !!ffi.ffiCall(DestroyWindow_proc, [FFI_U64] as const, [hwnd], FFI_U32)
+}

package/lib/preact/render.js

@@ -0,0 +1,320 @@
+import '../polyfill.js';
+import * as gui from 'gui';
+import * as os from 'os';
+import { applyProps, destroyWindow } from './props.js';
+import { layout as doLayout } from './layout.js';
+import { options } from './preact.js';
+const scaleFactor = gui.GetScaleFactor();
+const dpiFont = gui.CreateSystemDpiFont();
+const HWND_PROP = '__qw_hwnd';
+const STYLE_PROP = '__qw_style';
+const CHILDREN_HWNDS_PROP = '__qw_children';
+const RENDERED_VNODE_PROP = '__qw_rendered';
+let rootHwnd = null;
+let rootVNode = null;
+const WIN32_CLASS = {
+    button: 'BUTTON', edit: 'EDIT', static: 'STATIC',
+    checkbox: 'BUTTON', groupbox: 'BUTTON', combobox: 'COMBOBOX',
+    listbox: 'LISTBOX', progressbar: 'msctls_progress32',
+};
+const WIN32_STYLE = {
+    button: 0 /* gui.ButtonStyle.PUSHBUTTON */,
+    edit: 8388608 /* gui.WindowStyle.BORDER */ | 128 /* gui.EditStyle.AUTOHSCROLL */,
+    static: 0 /* gui.StaticStyle.LEFT */,
+    checkbox: 3 /* gui.ButtonStyle.AUTOCHECKBOX */,
+    groupbox: 7 /* gui.ButtonStyle.GROUPBOX */,
+    combobox: 3 /* gui.ComboBoxStyle.DROPDOWNLIST */,
+    listbox: 1 /* gui.ListBoxStyle.NOTIFY */ | 2097152 /* gui.WindowStyle.VSCROLL */,
+    progressbar: 0,
+};
+function createControl(type, parentHwnd, vnode) {
+    const base = 1073741824 /* gui.WindowStyle.CHILD */ | 268435456 /* gui.WindowStyle.VISIBLE */;
+    const winClass = WIN32_CLASS[type] || 'STATIC';
+    const style = base | (WIN32_STYLE[type] ?? 0 /* gui.StaticStyle.LEFT */);
+    const text = (vnode.props?.text || vnode.props?.value || '');
+    const hwnd = gui.CreateWindow(winClass, text, style, 0, 0, 0, 0, parentHwnd, null);
+    if (!hwnd)
+        return 0;
+    gui.SendMessage(hwnd, 48 /* gui.WmMsg.SETFONT */, dpiFont, 1);
+    applyProps(hwnd, vnode.props || {}, vnode);
+    return hwnd;
+}
+function isVNode(val) {
+    return val != null && typeof val === 'object' && val.constructor === undefined && val.type !== undefined;
+}
+function getChildren(vnode) {
+    const children = vnode.props?.children;
+    if (children == null)
+        return [];
+    if (Array.isArray(children))
+        return children.filter((c) => c != null && c !== false && c !== true);
+    if (typeof children === 'object' && children.type !== undefined)
+        return [children];
+    return [];
+}
+function renderToWin32(vnode, parentHwnd, context) {
+    if (vnode == null || vnode === false || vnode === true)
+        return 0;
+    if (typeof vnode === 'string' || typeof vnode === 'number') {
+        const hwnd = gui.CreateWindow('STATIC', String(vnode), 1073741824 /* gui.WindowStyle.CHILD */ | 268435456 /* gui.WindowStyle.VISIBLE */ | 0 /* gui.StaticStyle.LEFT */, 0, 0, 0, 0, parentHwnd, null);
+        if (hwnd)
+            gui.SendMessage(hwnd, 48 /* gui.WmMsg.SETFONT */, dpiFont, 1);
+        return hwnd;
+    }
+    if (Array.isArray(vnode)) {
+        for (const child of vnode)
+            renderToWin32(child, parentHwnd, context);
+        return 0;
+    }
+    if (!isVNode(vnode))
+        return 0;
+    if (typeof vnode.type === 'function') {
+        return renderComponent(vnode, parentHwnd, context);
+    }
+    if (vnode.type === 'w') {
+        const ctrlType = vnode.props?.type || '';
+        let hwnd;
+        if (ctrlType) {
+            hwnd = createControl(ctrlType, parentHwnd, vnode);
+        }
+        else {
+            hwnd = gui.CreateWindow('STATIC', '', 1073741824 /* gui.WindowStyle.CHILD */ | 268435456 /* gui.WindowStyle.VISIBLE */, 0, 0, 0, 0, parentHwnd, null);
+            if (hwnd) {
+                gui.SendMessage(hwnd, 48 /* gui.WmMsg.SETFONT */, dpiFont, 1);
+                applyProps(hwnd, vnode.props || {}, vnode);
+            }
+        }
+        if (!hwnd)
+            return 0;
+        vnode[HWND_PROP] = hwnd;
+        vnode[STYLE_PROP] = vnode.props?.style ?? {};
+        const children = getChildren(vnode);
+        const childHwnds = [];
+        for (const child of children) {
+            const childHwnd = renderToWin32(child, hwnd, context);
+            if (childHwnd)
+                childHwnds.push(childHwnd);
+        }
+        vnode[CHILDREN_HWNDS_PROP] = childHwnds;
+        return hwnd;
+    }
+    return 0;
+}
+function invokeComponent(component, vnode) {
+    options._diff?.(vnode);
+    options._render?.(vnode);
+    try {
+        const fn = vnode.type;
+        return fn.call(component, component.props, component.context);
+    }
+    catch (e) {
+        const errHandler = component._errorHandler;
+        if (errHandler) {
+            errHandler(e);
+            return null;
+        }
+        console.log('[preact-render] render threw: ' + e);
+        return null;
+    }
+    finally {
+        options.diffed?.(vnode);
+    }
+}
+function renderComponent(vnode, parentHwnd, context) {
+    const rendered = invokeComponent(newComponent(vnode, parentHwnd, context), vnode);
+    if (rendered == null)
+        return 0;
+    const resultHwnd = renderToWin32(rendered, parentHwnd, context);
+    vnode[HWND_PROP] = resultHwnd;
+    vnode[RENDERED_VNODE_PROP] = rendered;
+    return resultHwnd;
+}
+function newComponent(vnode, parentHwnd, context) {
+    const component = {
+        _vnode: vnode,
+        props: vnode.props,
+        context,
+        __hooks: { _list: [], _pendingEffects: [] },
+        _renderCallbacks: [],
+        _parentDom: true,
+        _qw_parent_hwnd: parentHwnd,
+        _dirty: false,
+        _forceUpdate() {
+            component._dirty = true;
+            scheduleUpdate(component);
+        },
+    };
+    vnode._component = component;
+    return component;
+}
+function destroyHwnd(hwnd) {
+    if (!hwnd)
+        return;
+    gui.RemoveWindow(hwnd);
+    destroyWindow(hwnd);
+}
+function destroyVNode(vnode) {
+    options.unmount?.(vnode);
+    const hwnd = vnode[HWND_PROP];
+    if (hwnd)
+        destroyHwnd(hwnd);
+    vnode[HWND_PROP] = 0;
+    for (const child of getChildren(vnode)) {
+        if (isVNode(child))
+            destroyVNode(child);
+    }
+    const extra = vnode[CHILDREN_HWNDS_PROP];
+    if (extra) {
+        for (const h of extra)
+            destroyHwnd(h);
+    }
+    vnode[CHILDREN_HWNDS_PROP] = [];
+}
+function reconcile(oldVNode, newVNode, parentHwnd, context) {
+    if (oldVNode == null || oldVNode === false || oldVNode === true) {
+        return renderToWin32(newVNode, parentHwnd, context);
+    }
+    if (newVNode == null || newVNode === false || newVNode === true) {
+        if (isVNode(oldVNode))
+            destroyVNode(oldVNode);
+        return 0;
+    }
+    if (typeof oldVNode !== typeof newVNode ||
+        typeof oldVNode === 'string' || typeof oldVNode === 'number' ||
+        Array.isArray(oldVNode) || Array.isArray(newVNode)) {
+        if (isVNode(oldVNode))
+            destroyVNode(oldVNode);
+        return renderToWin32(newVNode, parentHwnd, context);
+    }
+    if (!isVNode(oldVNode) || !isVNode(newVNode)) {
+        return renderToWin32(newVNode, parentHwnd, context);
+    }
+    const o = oldVNode;
+    const n = newVNode;
+    if (typeof n.type === 'function') {
+        const oldComp = o._component;
+        let comp;
+        if (oldComp) {
+            oldComp._vnode = n;
+            oldComp.props = n.props;
+            oldComp._qw_parent_hwnd = parentHwnd;
+            comp = oldComp;
+        }
+        else {
+            comp = newComponent(n, parentHwnd, context);
+        }
+        n._component = comp;
+        const oldResult = o[RENDERED_VNODE_PROP];
+        const newResult = invokeComponent(comp, n);
+        let resultHwnd;
+        if (newResult != null) {
+            resultHwnd = reconcile(oldResult || null, newResult, parentHwnd, context);
+        }
+        else {
+            if (oldResult && isVNode(oldResult))
+                destroyVNode(oldResult);
+            resultHwnd = 0;
+        }
+        n[HWND_PROP] = resultHwnd;
+        n[RENDERED_VNODE_PROP] = newResult;
+        return resultHwnd;
+    }
+    if (o.type === 'w' && n.type === 'w') {
+        const oldCtrl = o.props?.type || '';
+        const newCtrl = n.props?.type || '';
+        if (oldCtrl === newCtrl) {
+            const hwnd = o[HWND_PROP];
+            if (hwnd) {
+                n[HWND_PROP] = hwnd;
+                n[STYLE_PROP] = n.props?.style ?? {};
+                n._oldProc = o._oldProc;
+                applyProps(hwnd, n.props || {}, n);
+                const oldChildren = getChildren(o);
+                const newChildren = getChildren(n);
+                const oldChildHwnds = o[CHILDREN_HWNDS_PROP];
+                const childHwnds = [];
+                const maxLen = Math.max(oldChildren.length, newChildren.length);
+                for (let i = 0; i < maxLen; i++) {
+                    const oc = oldChildren[i];
+                    const nc = newChildren[i];
+                    if (oc != null && oc !== false && oc !== true) {
+                        if (nc != null && nc !== false && nc !== true) {
+                            if (typeof oc === 'string' && typeof nc === 'string') {
+                                if (oc !== nc && oldChildHwnds && oldChildHwnds[i]) {
+                                    applyProps(oldChildHwnds[i], { text: nc });
+                                }
+                                if (oldChildHwnds && oldChildHwnds[i])
+                                    childHwnds.push(oldChildHwnds[i]);
+                            }
+                            else {
+                                const ch = reconcile(oc, nc, hwnd, context);
+                                if (ch)
+                                    childHwnds.push(ch);
+                            }
+                        }
+                        else {
+                            if (isVNode(oc))
+                                destroyVNode(oc);
+                            else if (oldChildHwnds && oldChildHwnds[i])
+                                destroyHwnd(oldChildHwnds[i]);
+                        }
+                    }
+                    else if (nc != null && nc !== false && nc !== true) {
+                        const ch = renderToWin32(nc, hwnd, context);
+                        if (ch)
+                            childHwnds.push(ch);
+                    }
+                }
+                n[CHILDREN_HWNDS_PROP] = childHwnds;
+                return hwnd;
+            }
+        }
+    }
+    destroyVNode(o);
+    return renderToWin32(n, parentHwnd, context);
+}
+function scheduleUpdate(component) {
+    if (!component._dirty)
+        return;
+    os.setTimeout(() => {
+        if (!component._dirty)
+            return;
+        component._dirty = false;
+        const vnode = component._vnode;
+        const parentHwnd = component._qw_parent_hwnd;
+        if (!parentHwnd)
+            return;
+        const oldRendered = vnode[RENDERED_VNODE_PROP];
+        const rendered = invokeComponent(component, vnode);
+        if (rendered != null) {
+            reconcile(oldRendered || null, rendered, parentHwnd, component.context);
+        }
+        else if (oldRendered) {
+            if (isVNode(oldRendered))
+                destroyVNode(oldRendered);
+        }
+        vnode[RENDERED_VNODE_PROP] = rendered;
+        const commitQueue = [component];
+        options._commit?.(vnode, commitQueue);
+        if (rootHwnd && rootVNode) {
+            doLayout(rootHwnd, rootVNode);
+        }
+    }, 0);
+}
+export function notifyResize(hwnd) {
+    if (rootVNode)
+        doLayout(hwnd, rootVNode);
+}
+export function render(vnode, containerHwnd) {
+    rootHwnd = containerHwnd;
+    rootVNode = vnode;
+    renderToWin32(vnode, containerHwnd, {});
+    if (vnode._component) {
+        const commitQueue = [vnode._component];
+        options._commit?.(vnode, commitQueue);
+    }
+    doLayout(containerHwnd, vnode);
+    return containerHwnd;
+}
+export { HWND_PROP, STYLE_PROP, CHILDREN_HWNDS_PROP, RENDERED_VNODE_PROP, isVNode, getChildren };
+export { scaleFactor };