quickwin 2026.5.2-3.145209

package/lib/preact/layout.js

@@ -0,0 +1,153 @@
+import * as ffi from 'ffi';
+import * as win from 'win';
+import * as gui from 'gui';
+import { HWND_PROP, STYLE_PROP, RENDERED_VNODE_PROP, isVNode, getChildren } from './render.js';
+import { moveWindow } from './props.js';
+const scaleFactor = gui.GetScaleFactor();
+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 GetClientRect_proc = _user32 ? win.GetProcAddress(_user32, 'GetClientRect') : 0;
+function getClientSize(hwnd) {
+    if (!GetClientRect_proc)
+        return { w: 0, h: 0 };
+    const rectBuf = new ArrayBuffer(16);
+    const ok = ffi.ffiCall(GetClientRect_proc, [FFI_U64, FFI_PTR], [hwnd, rectBuf], FFI_U32);
+    if (!ok)
+        return { w: 0, h: 0 };
+    const dv = new DataView(rectBuf);
+    return { w: dv.getInt32(8, true), h: dv.getInt32(12, true) };
+}
+function resolveSize(val, available) {
+    if (val === undefined)
+        return -1;
+    if (typeof val === 'number')
+        return Math.floor(val * scaleFactor);
+    if (typeof val === 'string' && val.endsWith('%')) {
+        const pct = parseFloat(val);
+        if (!isNaN(pct))
+            return Math.floor(available * pct / 100);
+    }
+    return -1;
+}
+const DEFAULT_SIZES = {
+    button: Math.floor(24 * scaleFactor), edit: Math.floor(24 * scaleFactor),
+    static: Math.floor(20 * scaleFactor), checkbox: Math.floor(24 * scaleFactor),
+    groupbox: Math.floor(48 * scaleFactor), combobox: Math.floor(200 * scaleFactor),
+    listbox: Math.floor(100 * scaleFactor), progressbar: Math.floor(24 * scaleFactor),
+};
+function getDefaultChildSize(vnode) {
+    const ctrlType = typeof vnode.props === 'object' ? vnode.props?.type : undefined;
+    return DEFAULT_SIZES[ctrlType] ?? Math.floor(30 * scaleFactor);
+}
+function getLayoutChildren(vnode) {
+    const result = [];
+    if (vnode.type !== 'w')
+        return result;
+    for (const child of getChildren(vnode)) {
+        if (!isVNode(child))
+            continue;
+        const childHwnd = child[HWND_PROP];
+        if (childHwnd) {
+            result.push({ hwnd: childHwnd, style: child[STYLE_PROP] || {}, vnode: child });
+        }
+    }
+    return result;
+}
+function layoutNode(hwnd, vnode, availableRect) {
+    if (!isVNode(vnode) || vnode.type !== 'w')
+        return;
+    const style = vnode[STYLE_PROP] || {};
+    const dir = style.flexDirection || 'column';
+    const gap = Math.floor((style.gap || 0) * scaleFactor);
+    const padding = Math.floor((style.padding || 0) * scaleFactor);
+    const margin = Math.floor((style.margin || 0) * scaleFactor);
+    const fixedW = resolveSize(style.width, availableRect.w);
+    const fixedH = resolveSize(style.height, availableRect.h);
+    const nodeW = fixedW >= 0 ? fixedW : availableRect.w - margin * 2;
+    const nodeH = fixedH >= 0 ? fixedH : availableRect.h - margin * 2;
+    const nodeX = availableRect.x + margin;
+    const nodeY = availableRect.y + margin;
+    moveWindow(hwnd, nodeX, nodeY, nodeW, nodeH);
+    const children = getLayoutChildren(vnode);
+    if (children.length === 0)
+        return;
+    const isRow = dir === 'row';
+    const totalGap = gap * Math.max(0, children.length - 1);
+    const mainSize = (isRow ? nodeW : nodeH) - padding * 2 - totalGap;
+    const crossSize = (isRow ? nodeH : nodeW) - padding * 2;
+    let totalFlex = 0;
+    let fixedMainTotal = 0;
+    for (const child of children) {
+        const fg = child.style.flexGrow || 0;
+        const fixedMain = isRow
+            ? resolveSize(child.style.width, mainSize)
+            : resolveSize(child.style.height, mainSize);
+        if (fg > 0) {
+            totalFlex += fg;
+        }
+        else if (fixedMain >= 0) {
+            fixedMainTotal += fixedMain;
+        }
+        else {
+            fixedMainTotal += getDefaultChildSize(child.vnode);
+        }
+    }
+    const flexUnit = totalFlex > 0 ? Math.max(0, mainSize - fixedMainTotal) / totalFlex : 0;
+    let offset = 0;
+    for (const child of children) {
+        const fg = child.style.flexGrow || 0;
+        let childMain;
+        if (fg > 0) {
+            childMain = Math.floor(fg * flexUnit);
+        }
+        else {
+            const fixed = isRow
+                ? resolveSize(child.style.width, mainSize)
+                : resolveSize(child.style.height, mainSize);
+            childMain = fixed >= 0 ? fixed : getDefaultChildSize(child.vnode);
+        }
+        const childCross = isRow
+            ? resolveSize(child.style.height, crossSize)
+            : resolveSize(child.style.width, crossSize);
+        const actualCross = childCross >= 0 ? childCross : crossSize;
+        const childMargin = Math.floor((child.style.margin || 0) * scaleFactor);
+        const relX = isRow ? padding + offset : padding + childMargin;
+        const relY = isRow ? padding + childMargin : padding + offset;
+        const cw = isRow ? childMain : actualCross - childMargin * 2;
+        const ch = isRow ? actualCross - childMargin * 2 : childMain;
+        moveWindow(child.hwnd, relX, relY, Math.max(cw, 0), Math.max(ch, 0));
+        if (isVNode(child.vnode) && child.vnode.type === 'w') {
+            layoutNode(child.hwnd, child.vnode, { x: relX, y: relY, w: Math.max(cw, 0), h: Math.max(ch, 0) });
+        }
+        offset += childMain + gap;
+    }
+}
+function resolveToElementVNode(vnode) {
+    if (!isVNode(vnode))
+        return null;
+    if (vnode.type === 'w')
+        return vnode;
+    if (typeof vnode.type === 'function') {
+        const rendered = vnode[RENDERED_VNODE_PROP];
+        if (rendered && isVNode(rendered)) {
+            return resolveToElementVNode(rendered);
+        }
+    }
+    return null;
+}
+export function layout(rootHwnd, vnode) {
+    const clientSize = getClientSize(rootHwnd);
+    if (clientSize.w <= 0 || clientSize.h <= 0)
+        return;
+    const targetVNode = resolveToElementVNode(vnode);
+    if (!targetVNode)
+        return;
+    const targetHwnd = targetVNode[HWND_PROP];
+    if (!targetHwnd)
+        return;
+    moveWindow(targetHwnd, 0, 0, clientSize.w, clientSize.h);
+    layoutNode(targetHwnd, targetVNode, { x: 0, y: 0, w: clientSize.w, h: clientSize.h });
+}

package/lib/preact/layout.ts

@@ -0,0 +1,183 @@
+import * as ffi from 'ffi'
+import * as win from 'win'
+import * as gui from 'gui'
+import { HWND_PROP, STYLE_PROP, CHILDREN_HWNDS_PROP, RENDERED_VNODE_PROP, isVNode, getChildren, type VNode } from './render.js'
+import { moveWindow } from './props.js'
+
+const scaleFactor = gui.GetScaleFactor()
+
+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 GetClientRect_proc = _user32 ? win.GetProcAddress(_user32, 'GetClientRect') : 0
+
+export interface LayoutStyle {
+    flexDirection?: 'row' | 'column'
+    justifyContent?: string
+    alignItems?: string
+    flexGrow?: number
+    width?: number | string
+    height?: number | string
+    padding?: number
+    margin?: number
+    gap?: number
+}
+
+interface LayoutRect {
+    x: number
+    y: number
+    w: number
+    h: number
+}
+
+function getClientSize(hwnd: number): { w: number; h: number } {
+    if (!GetClientRect_proc) return { w: 0, h: 0 }
+    const rectBuf = new ArrayBuffer(16)
+    const ok = ffi.ffiCall(GetClientRect_proc, [FFI_U64, FFI_PTR], [hwnd, rectBuf], FFI_U32) as number
+    if (!ok) return { w: 0, h: 0 }
+    const dv = new DataView(rectBuf)
+    return { w: dv.getInt32(8, true), h: dv.getInt32(12, true) }
+}
+
+function resolveSize(val: number | string | undefined, available: number): number {
+    if (val === undefined) return -1
+    if (typeof val === 'number') return Math.floor(val * scaleFactor)
+    if (typeof val === 'string' && val.endsWith('%')) {
+        const pct = parseFloat(val)
+        if (!isNaN(pct)) return Math.floor(available * pct / 100)
+    }
+    return -1
+}
+
+const DEFAULT_SIZES: Record<string, number> = {
+    button: Math.floor(24 * scaleFactor), edit: Math.floor(24 * scaleFactor),
+    static: Math.floor(20 * scaleFactor), checkbox: Math.floor(24 * scaleFactor),
+    groupbox: Math.floor(48 * scaleFactor), combobox: Math.floor(200 * scaleFactor),
+    listbox: Math.floor(100 * scaleFactor), progressbar: Math.floor(24 * scaleFactor),
+}
+
+function getDefaultChildSize(vnode: VNode): number {
+    const ctrlType = typeof vnode.props === 'object' ? vnode.props?.type : undefined
+    return DEFAULT_SIZES[ctrlType as string] ?? Math.floor(30 * scaleFactor)
+}
+
+function getLayoutChildren(vnode: VNode): { hwnd: number; style: LayoutStyle; vnode: VNode }[] {
+    const result: { hwnd: number; style: LayoutStyle; vnode: VNode }[] = []
+    if (vnode.type !== 'w') return result
+
+    for (const child of getChildren(vnode)) {
+        if (!isVNode(child)) continue
+        const childHwnd = child[HWND_PROP] as number | undefined
+        if (childHwnd) {
+            result.push({ hwnd: childHwnd, style: (child[STYLE_PROP] as LayoutStyle) || {}, vnode: child })
+        }
+    }
+    return result
+}
+
+function layoutNode(hwnd: number, vnode: VNode, availableRect: LayoutRect): void {
+    if (!isVNode(vnode) || vnode.type !== 'w') return
+
+    const style = (vnode[STYLE_PROP] as LayoutStyle) || {}
+    const dir = style.flexDirection || 'column'
+    const gap = Math.floor((style.gap || 0) * scaleFactor)
+    const padding = Math.floor((style.padding || 0) * scaleFactor)
+    const margin = Math.floor((style.margin || 0) * scaleFactor)
+
+    const fixedW = resolveSize(style.width, availableRect.w)
+    const fixedH = resolveSize(style.height, availableRect.h)
+    const nodeW = fixedW >= 0 ? fixedW : availableRect.w - margin * 2
+    const nodeH = fixedH >= 0 ? fixedH : availableRect.h - margin * 2
+
+    const nodeX = availableRect.x + margin
+    const nodeY = availableRect.y + margin
+    moveWindow(hwnd, nodeX, nodeY, nodeW, nodeH)
+
+    const children = getLayoutChildren(vnode)
+    if (children.length === 0) return
+
+    const isRow = dir === 'row'
+    const totalGap = gap * Math.max(0, children.length - 1)
+    const mainSize = (isRow ? nodeW : nodeH) - padding * 2 - totalGap
+    const crossSize = (isRow ? nodeH : nodeW) - padding * 2
+
+    let totalFlex = 0
+    let fixedMainTotal = 0
+    for (const child of children) {
+        const fg = child.style.flexGrow || 0
+        const fixedMain = isRow
+            ? resolveSize(child.style.width, mainSize)
+            : resolveSize(child.style.height, mainSize)
+        if (fg > 0) {
+            totalFlex += fg
+        } else if (fixedMain >= 0) {
+            fixedMainTotal += fixedMain
+        } else {
+            fixedMainTotal += getDefaultChildSize(child.vnode)
+        }
+    }
+
+    const flexUnit = totalFlex > 0 ? Math.max(0, mainSize - fixedMainTotal) / totalFlex : 0
+
+    let offset = 0
+    for (const child of children) {
+        const fg = child.style.flexGrow || 0
+        let childMain: number
+        if (fg > 0) {
+            childMain = Math.floor(fg * flexUnit)
+        } else {
+            const fixed = isRow
+                ? resolveSize(child.style.width, mainSize)
+                : resolveSize(child.style.height, mainSize)
+            childMain = fixed >= 0 ? fixed : getDefaultChildSize(child.vnode)
+        }
+
+        const childCross = isRow
+            ? resolveSize(child.style.height, crossSize)
+            : resolveSize(child.style.width, crossSize)
+        const actualCross = childCross >= 0 ? childCross : crossSize
+
+        const childMargin = Math.floor((child.style.margin || 0) * scaleFactor)
+        const relX = isRow ? padding + offset : padding + childMargin
+        const relY = isRow ? padding + childMargin : padding + offset
+        const cw = isRow ? childMain : actualCross - childMargin * 2
+        const ch = isRow ? actualCross - childMargin * 2 : childMain
+
+        moveWindow(child.hwnd, relX, relY, Math.max(cw, 0), Math.max(ch, 0))
+
+        if (isVNode(child.vnode) && child.vnode.type === 'w') {
+            layoutNode(child.hwnd, child.vnode, { x: relX, y: relY, w: Math.max(cw, 0), h: Math.max(ch, 0) })
+        }
+
+        offset += childMain + gap
+    }
+}
+
+function resolveToElementVNode(vnode: VNode): VNode | null {
+    if (!isVNode(vnode)) return null
+    if (vnode.type === 'w') return vnode
+    if (typeof vnode.type === 'function') {
+        const rendered = vnode[RENDERED_VNODE_PROP]
+        if (rendered && isVNode(rendered)) {
+            return resolveToElementVNode(rendered)
+        }
+    }
+    return null
+}
+
+export function layout(rootHwnd: number, vnode: any): void {
+    const clientSize = getClientSize(rootHwnd)
+    if (clientSize.w <= 0 || clientSize.h <= 0) return
+
+    const targetVNode = resolveToElementVNode(vnode)
+    if (!targetVNode) return
+
+    const targetHwnd = targetVNode[HWND_PROP] as number
+    if (!targetHwnd) return
+
+    moveWindow(targetHwnd, 0, 0, clientSize.w, clientSize.h)
+    layoutNode(targetHwnd, targetVNode, { x: 0, y: 0, w: clientSize.w, h: clientSize.h })
+}

package/lib/preact/preact.js

@@ -0,0 +1,54 @@
+// Minimal Preact - VNode creation + Options
+// Based on https://github.com/preactjs/preact (src/create-element.js, src/options.js, src/constants.js)
+// DOM dependencies removed - for custom renderers only
+let vnodeId = 0;
+export const options = {};
+export function createElement(type, props, ...children) {
+    let normalizedProps = {};
+    let key = null;
+    let ref = null;
+    if (props != null) {
+        for (const i in props) {
+            if (i === 'key')
+                key = props[i] ?? null;
+            else if (i === 'ref' && typeof type !== 'function')
+                ref = props[i] ?? null;
+            else
+                normalizedProps[i] = props[i];
+        }
+    }
+    if (children.length > 0) {
+        normalizedProps.children = children.length === 1 ? children[0] : children;
+    }
+    return createVNode(type, normalizedProps, key, ref, null);
+}
+export function createVNode(type, props, key, ref, original) {
+    const vnode = {
+        type,
+        props: props,
+        key,
+        ref,
+        _children: [],
+        _parent: null,
+        _depth: 0,
+        _dom: null,
+        _component: null,
+        constructor: undefined,
+        _original: original == null ? ++vnodeId : original,
+        _index: -1,
+        _flags: 0,
+    };
+    if (original == null && options.vnode)
+        options.vnode(vnode);
+    return vnode;
+}
+export function createRef() {
+    return { current: null };
+}
+export function Fragment(props) {
+    return props.children;
+}
+export function isValidElement(vnode) {
+    return vnode != null && vnode.constructor === undefined;
+}
+export const h = createElement;

package/lib/preact/preact.ts

@@ -0,0 +1,133 @@
+// Minimal Preact - VNode creation + Options
+// Based on https://github.com/preactjs/preact (src/create-element.js, src/options.js, src/constants.js)
+// DOM dependencies removed - for custom renderers only
+
+let vnodeId = 0
+
+export type Key = string | number | null
+
+export interface Ref<T = any> {
+    current: T | null
+}
+
+export type ComponentChild = VNode<any> | string | number | boolean | null | undefined
+export type ComponentChildren = ComponentChild[] | ComponentChild
+
+export type FunctionComponent<P = {}> = {
+    (props: P, context?: any): VNode<any> | null
+    defaultProps?: Partial<P>
+    displayName?: string
+}
+
+export type ComponentType<P = {}> = FunctionComponent<P>
+
+export interface VNode<P = any> {
+    type: string | ComponentType<P>
+    props: P & { children?: ComponentChildren }
+    key: Key
+    ref: Ref<any>
+    _children: VNode[]
+    _parent: VNode | null
+    _depth: number
+    _dom: unknown
+    _component: Component<{}, {}> | null
+    constructor: undefined
+    _original: number
+    _index: number
+    _flags: number
+    _mask?: number[]
+}
+
+export interface Component<P = {}, S = {}> {
+    props: P
+    context: Record<string, unknown>
+    _vnode: VNode | null
+    _renderCallbacks: Array<() => void>
+    _parentDom: unknown
+    __hooks: { _list: any[]; _pendingEffects: any[] } | null
+    _forceUpdate(): void
+}
+
+export interface Options {
+    vnode?(vnode: VNode): void
+    _diff?(vnode: VNode): void
+    _render?(vnode: VNode): void
+    diffed?(vnode: VNode): void
+    _commit?(vnode: VNode, commitQueue: Component[]): void
+    unmount?(vnode: VNode): void
+    _root?(vnode: VNode, parentDom: unknown): void
+    _catchError?(error: unknown, vnode: VNode, oldVNode?: VNode): unknown
+    debounceRendering?(cb: () => void): void
+    requestAnimationFrame?: ((cb: () => void) => void) | null
+    useDebugValue?(value: unknown): void
+    _hook?(component: Component, index: number, type: number): void
+    _skipEffects?: boolean
+}
+
+export const options: Options = {}
+
+export function createElement<P extends Record<string, any> = {}>(
+    type: string | ComponentType<P>,
+    props: (P & { key?: Key; ref?: Ref }) | null,
+    ...children: ComponentChildren[]
+): VNode<P> {
+    let normalizedProps: Record<string, any> = {}
+    let key: Key = null
+    let ref: Ref | null = null
+
+    if (props != null) {
+        for (const i in props) {
+            if (i === 'key') key = props[i] ?? null
+            else if (i === 'ref' && typeof type !== 'function') ref = props[i] ?? null
+            else normalizedProps[i] = props[i]
+        }
+    }
+
+    if (children.length > 0) {
+        normalizedProps.children = children.length === 1 ? children[0] : children
+    }
+
+    return createVNode(type, normalizedProps as P, key, ref!, null)
+}
+
+export function createVNode<P = {}>(
+    type: string | ComponentType<P>,
+    props: P,
+    key: Key,
+    ref: Ref,
+    original: number | null
+): VNode<P> {
+    const vnode: VNode<P> = {
+        type,
+        props: props as VNode<P>['props'],
+        key,
+        ref,
+        _children: [],
+        _parent: null,
+        _depth: 0,
+        _dom: null,
+        _component: null,
+        constructor: undefined,
+        _original: original == null ? ++vnodeId : original,
+        _index: -1,
+        _flags: 0,
+    }
+
+    if (original == null && options.vnode) options.vnode(vnode)
+
+    return vnode
+}
+
+export function createRef<T = null>(): Ref<T> {
+    return { current: null }
+}
+
+export function Fragment<P extends { children?: ComponentChildren }>(props: P): ComponentChildren {
+    return props.children
+}
+
+export function isValidElement(vnode: unknown): vnode is VNode {
+    return vnode != null && (vnode as any).constructor === undefined
+}
+
+export const h = createElement

package/lib/preact/props.js

@@ -0,0 +1,99 @@
+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 = 0 /* gui.ShowWindowCmd.HIDE */;
+const SW_SHOW = 5 /* gui.ShowWindowCmd.SHOW */;
+const BM_GETCHECK = 240 /* gui.ButtonMsg.GETCHECK */;
+const BM_SETCHECK = 241 /* gui.ButtonMsg.SETCHECK */;
+const BST_CHECKED = 1 /* gui.ButtonCheckState.CHECKED */;
+const BST_UNCHECKED = 0 /* gui.ButtonCheckState.UNCHECKED */;
+const EM_SETCUEBANNER = 5377 /* gui.EditMsg.SETCUEBANNER */;
+const EM_SETPASSWORDCHAR = 204 /* gui.EditMsg.SETPASSWORDCHAR */;
+const CB_ADDSTRING = 323 /* gui.ComboBoxMsg.ADDSTRING */;
+const LB_ADDSTRING = 384 /* gui.LbMsg.ADDSTRING */;
+const PBM_SETRANGE32 = 1030 /* gui.ProgressMsg.SETRANGE32 */;
+const PBM_SETPOS = 1026 /* gui.ProgressMsg.SETPOS */;
+export function applyProps(hwnd, props, vnode) {
+    if (props.text !== undefined) {
+        gui.SetWindowText(hwnd, props.text);
+    }
+    if (props.value !== undefined) {
+        gui.SetWindowText(hwnd, props.value);
+    }
+    if (props.disabled !== undefined && EnableWindow_proc) {
+        ffi.ffiCall(EnableWindow_proc, [FFI_U64, FFI_U32], [hwnd, props.disabled ? 0 : 1], FFI_U32);
+    }
+    if (props.visible !== undefined && ShowWindow_proc) {
+        ffi.ffiCall(ShowWindow_proc, [FFI_U64, FFI_S32], [hwnd, props.visible ? SW_SHOW : SW_HIDE], FFI_U32);
+    }
+    if (props.onEvent !== undefined && vnode) {
+        const h = hwnd;
+        const oldProc = vnode._oldProc || gui.GetWindowLongPtr(h, -4 /* gui.Gwlp.WNDPROC */);
+        vnode._oldProc = oldProc;
+        gui.SetWindowProc(h, (hw, msg, wParam, lParam) => {
+            const cb = vnode.props?.onEvent;
+            if (cb)
+                cb({ hwnd: hw, msg, wParam, lParam });
+            return gui.CallWindowProc(oldProc, hw, msg, wParam, lParam);
+        });
+    }
+    if (props.placeholder !== undefined && SendMessageW_proc) {
+        ffi.ffiCall(SendMessageW_proc, [FFI_U64, FFI_S32, FFI_U32, FFI_PTR], [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], [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], [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], [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], [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], [hwnd, PBM_SETPOS, Number(props.value), 0], FFI_U64);
+    }
+}
+const wideCache = new Map();
+const MAX_WIDE_CACHE = 50;
+function strToWide(str) {
+    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, x, y, w, h) {
+    if (!MoveWindow_proc)
+        return;
+    ffi.ffiCall(MoveWindow_proc, [FFI_U64, FFI_S32, FFI_S32, FFI_S32, FFI_S32, FFI_U32], [hwnd, x, y, w, h, 1], FFI_U32);
+}
+export function destroyWindow(hwnd) {
+    if (!DestroyWindow_proc)
+        return false;
+    return !!ffi.ffiCall(DestroyWindow_proc, [FFI_U64], [hwnd], FFI_U32);
+}