quickwin 1.0.0

package/lib/react-qw/components/ListView.js

@@ -0,0 +1,328 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useRef, useEffect } from 'react';
+import * as gui from 'gui';
+import * as ffi from 'ffi';
+import * as win from 'win';
+export function makeColorBlock(size, bgra) {
+    const n = size * size;
+    const buf = new ArrayBuffer(n * 4);
+    const b = new Uint8Array(buf);
+    for (let i = 0; i < n; i++) {
+        b[i * 4] = bgra & 0xFF;
+        b[i * 4 + 1] = (bgra >> 8) & 0xFF;
+        b[i * 4 + 2] = (bgra >> 16) & 0xFF;
+        b[i * 4 + 3] = 0xFF;
+    }
+    return buf;
+}
+function textToUtf16(s) {
+    const buf = new ArrayBuffer((s.length + 1) * 2);
+    const dv = new DataView(buf);
+    for (let i = 0; i < s.length; i++)
+        dv.setUint16(i * 2, s.charCodeAt(i), true);
+    return buf;
+}
+function readI32(ptr, offset) {
+    return ffi.readByte(ptr + offset) | (ffi.readByte(ptr + offset + 1) << 8) |
+        (ffi.readByte(ptr + offset + 2) << 16) | (ffi.readByte(ptr + offset + 3) << 24);
+}
+function readU32(ptr, offset) {
+    return ffi.readByte(ptr + offset) | (ffi.readByte(ptr + offset + 1) << 8) |
+        (ffi.readByte(ptr + offset + 2) << 16) | (ffi.readByte(ptr + offset + 3) << 24) >>> 0;
+}
+function readU64(ptr, offset) {
+    const lo = readU32(ptr, offset);
+    const hi = readU32(ptr, offset + 4);
+    return lo + hi * 0x100000000;
+}
+function writeU32(ptr, offset, v) {
+    ffi.writeByte(ptr + offset, v & 0xFF);
+    ffi.writeByte(ptr + offset + 1, (v >> 8) & 0xFF);
+    ffi.writeByte(ptr + offset + 2, (v >> 16) & 0xFF);
+    ffi.writeByte(ptr + offset + 3, (v >> 24) & 0xFF);
+}
+function bufPtr(buf) {
+    return ffi.bufferPtr(buf);
+}
+const LV_WS = 268435456 /* gui.WindowStyle.VISIBLE */ | 8388608 /* gui.WindowStyle.BORDER */ | 2097152 /* gui.WindowStyle.VSCROLL */ | 1048576 /* gui.WindowStyle.HSCROLL */
+    | 1 /* gui.ListViewStyle.REPORT */ | 4 /* gui.ListViewStyle.SINGLESEL */;
+// x64 结构体偏移（NMHDR 为 24 字节）
+const CD_STAGE = 24; // NMCUSTOMDRAW.dwDrawStage
+const CD_HDC = 32; // NMCUSTOMDRAW.hdc
+const CD_ITEM = 56; // NMCUSTOMDRAW.dwItemSpec（行索引）
+const CD_CLRTEXT = 80; // NMLVCUSTOMDRAW.clrText
+const CD_CLRTEXTBK = 84; // NMLVCUSTOMDRAW.clrTextBk
+const CD_SUBITEM = 88; // NMLVCUSTOMDRAW.iSubItem
+const NMIA_ITEM = 24; // NMITEMACTIVATE.iItem
+const NMIA_SUBITEM = 28; // NMITEMACTIVATE.iSubItem
+const NM_CODE = 16; // NMHDR.code
+const fontCache = new Map();
+let gdi32 = null;
+let createFontIndirectW = null;
+let selectObjectFn = null;
+let getObjectW = null;
+function ensureGdi() {
+    if (gdi32 !== null)
+        return;
+    gdi32 = win.LoadLibrary('gdi32.dll');
+    if (!gdi32)
+        return;
+    createFontIndirectW = win.GetProcAddress(gdi32, 'CreateFontIndirectW');
+    selectObjectFn = win.GetProcAddress(gdi32, 'SelectObject');
+    getObjectW = win.GetProcAddress(gdi32, 'GetObjectW');
+}
+let user32 = null;
+let loadCursorW = null;
+let setCursorFn = null;
+let screenToClient = null;
+function ensureUser32() {
+    if (user32 !== null)
+        return;
+    user32 = win.LoadLibrary('user32.dll');
+    if (!user32)
+        return;
+    loadCursorW = win.GetProcAddress(user32, 'LoadCursorW');
+    setCursorFn = win.GetProcAddress(user32, 'SetCursor');
+    screenToClient = win.GetProcAddress(user32, 'ScreenToClient');
+}
+function getCellFont(hwnd, style) {
+    const key = (style.bold ? 'b' : '') + (style.italic ? 'i' : '') + (style.underline ? 'u' : '');
+    if (key === '')
+        return null;
+    const cached = fontCache.get(key);
+    if (cached !== undefined)
+        return cached === 0 ? null : cached;
+    ensureGdi();
+    if (!createFontIndirectW || !getObjectW || !hwnd)
+        return null;
+    const lf = new ArrayBuffer(92);
+    const dv = new DataView(lf);
+    const cur = gui.SendMessage(hwnd, 49 /* gui.WmMsg.GETFONT */, 0, 0);
+    if (cur) {
+        const got = ffi.ffiCall(getObjectW, [ffi.FFI_TYPE_UINT64, ffi.FFI_TYPE_SINT32, ffi.FFI_TYPE_POINTER], [cur, 92, lf], ffi.FFI_TYPE_SINT32);
+        if (!got)
+            return null;
+    }
+    else {
+        dv.setInt32(0, -13, true);
+    }
+    if (style.bold)
+        dv.setInt32(16, 700 /* gui.FontWeight.BOLD */, true);
+    if (style.italic)
+        dv.setUint8(20, 1);
+    if (style.underline)
+        dv.setUint8(21, 1);
+    const h = ffi.ffiCall(createFontIndirectW, [ffi.FFI_TYPE_POINTER], [lf], ffi.FFI_TYPE_UINT64);
+    fontCache.set(key, h === 0 ? 0 : h);
+    return h === 0 ? null : h;
+}
+function handleCustomDraw(lParam, columns, data, hwnd) {
+    const stage = readU32(lParam, CD_STAGE);
+    if (stage === 1 /* gui.CustomDrawStage.PREPAINT */)
+        return 32 /* gui.CustomDrawFlag.NOTIFYITEMDRAW */;
+    if (stage === 65537 /* gui.CustomDrawStage.ITEMPREPAINT */)
+        return 32 /* gui.CustomDrawFlag.NOTIFYSUBITEMDRAW */;
+    if (stage === 196609 /* gui.CustomDrawStage.SUBITEMPREPAINT */) {
+        const colIndex = readI32(lParam, CD_SUBITEM);
+        const row = readI32(lParam, CD_ITEM);
+        const style = resolveCellStyle(columns, data, row, colIndex);
+        if (!style)
+            return 0 /* gui.CustomDrawFlag.DODEFAULT */;
+        if (style.color !== undefined)
+            writeU32(lParam, CD_CLRTEXT, style.color);
+        if (style.background !== undefined)
+            writeU32(lParam, CD_CLRTEXTBK, style.background);
+        const hfont = getCellFont(hwnd, style);
+        if (hfont && selectObjectFn) {
+            const hdc = readU64(lParam, CD_HDC);
+            if (hdc) {
+                ffi.ffiCall(selectObjectFn, [ffi.FFI_TYPE_UINT64, ffi.FFI_TYPE_UINT64], [hdc, hfont], ffi.FFI_TYPE_UINT64);
+                return 2 /* gui.CustomDrawFlag.NEWFONT */;
+            }
+        }
+    }
+    return 0 /* gui.CustomDrawFlag.DODEFAULT */;
+}
+function alignToFmt(align) {
+    if (align === 'center')
+        return 2 /* gui.LvColumnFormat.CENTER */;
+    if (align === 'right')
+        return 1 /* gui.LvColumnFormat.RIGHT */;
+    return 0 /* gui.LvColumnFormat.LEFT */;
+}
+function cellText(record, col, index) {
+    if (col.render)
+        return col.render(record, index);
+    if (col.dataIndex === undefined)
+        return '';
+    const v = record[col.dataIndex];
+    return v == null ? '' : String(v);
+}
+function resolveCellStyle(columns, data, row, colIndex) {
+    const col = columns[colIndex];
+    if (!col || !col.cellStyle)
+        return undefined;
+    const record = data[row];
+    if (record === undefined)
+        return undefined;
+    const style = typeof col.cellStyle === 'function' ? col.cellStyle(record, row) : col.cellStyle;
+    return style || undefined;
+}
+function makeLVItem(i, sub, text, image) {
+    const b = new ArrayBuffer(84);
+    const dv = new DataView(b);
+    dv.setInt32(4, i, true);
+    dv.setInt32(8, sub, true);
+    let mask = 1 /* LvItemFlag.TEXT */;
+    if (image !== undefined) {
+        mask |= 2 /* LvItemFlag.IMAGE */;
+        dv.setInt32(36, image, true);
+    }
+    dv.setUint32(0, mask, true);
+    const textBuf = textToUtf16(text);
+    dv.setBigUint64(24, BigInt(bufPtr(textBuf)), true);
+    b.__textBuf = textBuf;
+    return b;
+}
+const ListView = forwardRef(function ListViewInner({ columns, data, style, icons, iconSize, getIcon }, ref) {
+    const lvRef = useRef(null);
+    const iconListRef = useRef(0);
+    useEffect(() => {
+        const h = lvRef.current;
+        if (!h)
+            return;
+        const il = iconListRef.current;
+        iconListRef.current = 0;
+        if (il) {
+            gui.SendMessage(h, 4099 /* gui.LvMsg.SETIMAGELIST */, 1 /* gui.LvImageList.SMALL */, 0);
+            gui.ImageListDestroy(il);
+        }
+        if (!icons || icons.length === 0)
+            return;
+        const size = iconSize ?? 32;
+        const img = gui.ImageListCreate(size, size, 32 /* gui.ImageListFlag.COLOR32 */, icons.length, 1);
+        if (!img)
+            return;
+        for (const p of icons) {
+            const hbm = gui.CreateBitmapFromPixels(size, size, p);
+            if (hbm) {
+                gui.ImageListAdd(img, hbm);
+                gui.DeleteObject(hbm);
+            }
+        }
+        gui.SendMessage(h, 4099 /* gui.LvMsg.SETIMAGELIST */, 1 /* gui.LvImageList.SMALL */, img);
+        iconListRef.current = img;
+    }, [icons, iconSize]);
+    useEffect(() => {
+        const h = lvRef.current;
+        if (!h)
+            return;
+        // 从后往前删旧列
+        const hdr = gui.SendMessage(h, 4127 /* gui.LvMsg.GETHEADER */, 0, 0);
+        if (hdr) {
+            let n = gui.SendMessage(hdr, 4608 /* gui.HdmMsg.GETITEMCOUNT */, 0, 0);
+            for (let k = n - 1; k >= 0; k--)
+                gui.SendMessage(h, 4124 /* gui.LvMsg.DELETECOLUMN */, k, 0);
+        }
+        gui.SendMessage(h, 4150 /* gui.LvMsg.SETEXTENDEDLISTVIEWSTYLE */, 0, 32 /* gui.LvExStyle.FULLROWSELECT */ | 1 /* gui.LvExStyle.GRIDLINES */ | 65536 /* gui.LvExStyle.DOUBLEBUFFER */);
+        const n = columns.length;
+        for (let j = 0; j < n; j++) {
+            const titleBuf = textToUtf16(columns[j].name);
+            const lvc = new ArrayBuffer(52);
+            const dv = new DataView(lvc);
+            dv.setUint32(0, 4 /* LvColumnMask.TEXT */ | 2 /* LvColumnMask.WIDTH */ | 1 /* LvColumnMask.FORMAT */, true);
+            dv.setInt32(4, alignToFmt(columns[j].align), true);
+            dv.setInt32(8, columns[j].width ?? 100, true);
+            dv.setBigUint64(16, BigInt(bufPtr(titleBuf)), true);
+            dv.setInt32(28, j, true);
+            lvc.__titleBuf = titleBuf;
+            gui.SendMessage(h, 4193 /* gui.LvMsg.INSERTCOLUMNW */, j, bufPtr(lvc));
+        }
+    }, [columns]);
+    useEffect(() => {
+        const h = lvRef.current;
+        if (!h)
+            return;
+        gui.SendMessage(h, 4105 /* gui.LvMsg.DELETEALLITEMS */, 0, 0);
+        const nCols = columns.length;
+        for (let i = 0; i < data.length; i++) {
+            const record = data[i];
+            const img = getIcon ? getIcon(record, i) : undefined;
+            const itemBuf = makeLVItem(i, 0, cellText(record, columns[0], i), img);
+            gui.SendMessage(h, 4173 /* gui.LvMsg.INSERTITEMW */, 0, bufPtr(itemBuf));
+            for (let j = 1; j < nCols; j++) {
+                const subBuf = makeLVItem(i, j, cellText(record, columns[j], i));
+                gui.SendMessage(h, 4172 /* gui.LvMsg.SETITEMW */, 0, bufPtr(subBuf));
+            }
+        }
+        for (let j = 0; j < columns.length; j++) {
+            if (columns[j].width == null) {
+                gui.SendMessage(h, 4126 /* gui.LvMsg.SETCOLUMNWIDTH */, j, -2 /* gui.LvColumnWidthCmd.AUTOSIZE_USEHEADER */);
+            }
+        }
+    }, [data, columns, getIcon]);
+    return (_jsx("w", { type: "STATIC", ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 33554432 /* gui.WindowStyle.CLIPCHILDREN */, style: { ...style, flexDirection: 'column', alignItems: 'stretch' }, ref: ref, onEvent: (e) => {
+            if (e.msg === 78 /* gui.WmMsg.NOTIFY */) {
+                const code = readI32(e.lParam, NM_CODE);
+                if (code === -12 /* gui.LvNotifyCode.CUSTOMDRAW */) {
+                    return handleCustomDraw(e.lParam, columns, data, lvRef.current);
+                }
+                if (code === -100 /* gui.LvNotifyCode.ITEMCHANGING */) {
+                    const uNewState = readU32(e.lParam, 32);
+                    const uOldState = readU32(e.lParam, 36);
+                    if ((uNewState & 2 /* LvItemState.SELECTED */) !== (uOldState & 2 /* LvItemState.SELECTED */))
+                        return 1;
+                }
+                if (code === -2 /* gui.LvNotifyCode.CLICK */) {
+                    const iItem = readI32(e.lParam, NMIA_ITEM);
+                    const iSubItem = readI32(e.lParam, NMIA_SUBITEM);
+                    const col = columns[iSubItem];
+                    const record = data[iItem];
+                    if (col?.onCellClick && record !== undefined)
+                        col.onCellClick(record, iItem);
+                }
+            }
+            return;
+        }, children: _jsx("w", { type: "SysListView32", ws: LV_WS, style: { flexGrow: 1 }, ref: (h) => {
+                lvRef.current = h;
+            }, onEvent: (e) => {
+                if (e.msg !== 32 /* gui.WmMsg.SETCURSOR */)
+                    return;
+                if ((e.lParam & 0xFFFF) !== 1 /* gui.HitTest.CLIENT */)
+                    return;
+                const h = lvRef.current;
+                if (!h)
+                    return;
+                ensureUser32();
+                if (!loadCursorW || !setCursorFn || !screenToClient)
+                    return;
+                const sp = gui.GetCursorPos();
+                if (!sp)
+                    return;
+                const sbuf = new ArrayBuffer(8);
+                const sdv = new DataView(sbuf);
+                sdv.setInt32(0, sp[0], true);
+                sdv.setInt32(4, sp[1], true);
+                ffi.ffiCall(screenToClient, [ffi.FFI_TYPE_UINT64, ffi.FFI_TYPE_POINTER], [h, sbuf], ffi.FFI_TYPE_SINT32);
+                const lvhi = new ArrayBuffer(24);
+                const lvd = new DataView(lvhi);
+                lvd.setInt32(0, sdv.getInt32(0, true), true);
+                lvd.setInt32(4, sdv.getInt32(4, true), true);
+                lvd.setInt32(12, -1, true);
+                lvd.setInt32(16, -1, true);
+                const lvhiPtr = bufPtr(lvhi);
+                gui.SendMessage(h, 4153 /* gui.LvMsg.SUBITEMHITTEST */, 0, lvhiPtr);
+                const iItem = readI32(lvhiPtr, 12);
+                const iSubItem = readI32(lvhiPtr, 16);
+                const style = resolveCellStyle(columns, data, iItem, iSubItem);
+                if (!style || style.cursor === undefined)
+                    return;
+                const hc = ffi.ffiCall(loadCursorW, [ffi.FFI_TYPE_UINT64, ffi.FFI_TYPE_UINT64], [0, style.cursor], ffi.FFI_TYPE_UINT64);
+                if (hc) {
+                    ffi.ffiCall(setCursorFn, [ffi.FFI_TYPE_UINT64], [hc], ffi.FFI_TYPE_UINT64);
+                    return 1;
+                }
+                return;
+            } }) }));
+});
+export { ListView };

package/lib/react-qw/components/PathPicker.js

@@ -0,0 +1,136 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, useState, useRef } from 'react';
+import * as ffi from 'ffi';
+import * as win from 'win';
+const FFI_PTR = ffi.FFI_TYPE_POINTER;
+const FFI_U32 = ffi.FFI_TYPE_UINT32;
+let _GetOpenFileNameW = 0;
+let _SHBrowseForFolderW = 0;
+let _SHGetPathFromIDListW = 0;
+let _CoTaskMemFree = 0;
+function ensureDlls() {
+    if (_GetOpenFileNameW)
+        return true;
+    const comdlg32 = win.LoadLibrary('comdlg32.dll');
+    const shell32 = win.LoadLibrary('shell32.dll');
+    const ole32 = win.LoadLibrary('ole32.dll');
+    if (!comdlg32 || !shell32 || !ole32)
+        return false;
+    const load = (lib, name) => win.GetProcAddress(lib, name) || 0;
+    _GetOpenFileNameW = load(comdlg32, 'GetOpenFileNameW');
+    _SHBrowseForFolderW = load(shell32, 'SHBrowseForFolderW');
+    _SHGetPathFromIDListW = load(shell32, 'SHGetPathFromIDListW');
+    _CoTaskMemFree = load(ole32, 'CoTaskMemFree');
+    return !!_GetOpenFileNameW && !!_SHBrowseForFolderW && !!_SHGetPathFromIDListW && !!_CoTaskMemFree;
+}
+function strToWide(s) {
+    return new TextEncoder('utf-16le').encode(s + '\0').buffer;
+}
+const _decoder = new TextDecoder('utf-16le');
+function wideToStr(buf, offset = 0) {
+    const str = _decoder.decode(new Uint8Array(buf, offset));
+    const nullIdx = str.indexOf('\0');
+    return nullIdx >= 0 ? str.substring(0, nullIdx) : str;
+}
+function setPtr(dv, off, ptr) {
+    dv.setUint32(off, ptr & 0xFFFFFFFF, true);
+    dv.setUint32(off + 4, Math.floor(ptr / 0x100000000), true);
+}
+function openFileDialog(owner, filter, title, multiple) {
+    if (!ensureDlls())
+        return null;
+    const structBuf = new ArrayBuffer(152);
+    const sv = new DataView(structBuf);
+    const fileBuf = new ArrayBuffer(260 * 2);
+    const filterWide = strToWide(filter);
+    const titleWide = title ? strToWide(title) : null;
+    sv.setUint32(0, 152, true);
+    setPtr(sv, 8, owner);
+    setPtr(sv, 24, ffi.bufferPtr(filterWide));
+    setPtr(sv, 48, ffi.bufferPtr(fileBuf));
+    sv.setUint32(56, 260, true);
+    let flags = 0x1000 | 0x0800 | 0x0008;
+    if (multiple)
+        flags |= 0x0200;
+    flags |= 0x80000;
+    sv.setUint32(96, flags, true);
+    if (titleWide)
+        setPtr(sv, 88, ffi.bufferPtr(titleWide));
+    const ret = ffi.ffiCall(_GetOpenFileNameW, [FFI_PTR], [structBuf], FFI_U32);
+    if (!ret)
+        return null;
+    if (!multiple) {
+        return wideToStr(fileBuf);
+    }
+    const dir = wideToStr(fileBuf);
+    let pos = (dir.length + 1) * 2;
+    const files = [];
+    while (pos < fileBuf.byteLength) {
+        const f = wideToStr(fileBuf, pos);
+        if (f.length === 0)
+            break;
+        files.push(dir + '\\' + f);
+        pos += (f.length + 1) * 2;
+    }
+    if (files.length === 0)
+        return [dir];
+    return files;
+}
+function openFolderDialog(owner, title) {
+    if (!ensureDlls())
+        return null;
+    const structBuf = new ArrayBuffer(64);
+    const sv = new DataView(structBuf);
+    const titleWide = title ? strToWide(title) : null;
+    setPtr(sv, 0, owner);
+    if (titleWide)
+        setPtr(sv, 24, ffi.bufferPtr(titleWide));
+    sv.setUint32(32, 0x00000041, true);
+    const pidl = ffi.ffiCall(_SHBrowseForFolderW, [FFI_PTR], [structBuf], FFI_PTR);
+    if (!pidl)
+        return null;
+    const pathBuf = new ArrayBuffer(260 * 2);
+    const ok = ffi.ffiCall(_SHGetPathFromIDListW, [ffi.FFI_TYPE_UINT64, FFI_PTR], [pidl, pathBuf], FFI_U32);
+    ffi.ffiCall(_CoTaskMemFree, [ffi.FFI_TYPE_UINT64], [pidl], ffi.FFI_TYPE_VOID);
+    return ok ? wideToStr(pathBuf) : null;
+}
+export const PathPicker = forwardRef((props, ref) => {
+    const { type = 'file', filter = 'All Files\0*.*\0\0', title, disabled, style } = props;
+    const multiple = props.multiple === true;
+    const controlledValue = props.value;
+    const defaultValue = props.defaultValue;
+    const onChange = props.onChange;
+    const [internalValue, setInternalValue] = useState(defaultValue ?? (multiple ? [] : ''));
+    const isControlled = controlledValue !== undefined;
+    const displayValue = isControlled ? controlledValue : internalValue;
+    const containerRef = useRef(null);
+    const displayText = Array.isArray(displayValue) ? displayValue.join('\n') : (displayValue ?? '');
+    const handleBrowse = () => {
+        const owner = containerRef.current;
+        if (!owner)
+            return;
+        let result;
+        if (type === 'folder') {
+            const r = openFolderDialog(owner, title);
+            result = r !== null ? (multiple ? [r] : r) : null;
+        }
+        else {
+            result = openFileDialog(owner, filter, title, multiple);
+        }
+        if (result === null)
+            return;
+        if (!isControlled)
+            setInternalValue(result);
+        onChange?.(result);
+    };
+    return (_jsxs("w", { type: "STATIC", ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 33554432 /* gui.WindowStyle.CLIPCHILDREN */, style: { ...style, flexDirection: 'row', alignItems: 'stretch' }, ref: (h) => {
+            containerRef.current = h;
+            if (typeof ref === 'function')
+                ref(h);
+            else if (ref)
+                ref.current = h;
+        }, children: [_jsx("w", { type: "EDIT", text: displayText, ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 8388608 /* gui.WindowStyle.BORDER */ | 2048 /* gui.EditStyle.READONLY */ | 128 /* gui.EditStyle.AUTOHSCROLL */, style: { flexGrow: 1 } }), _jsx("w", { type: "BUTTON", text: "...", ws: 268435456 /* gui.WindowStyle.VISIBLE */, style: { width: 70 }, disabled: disabled, onEvent: (e) => {
+                    if (e.msg === 514 /* gui.WmMsg.LBUTTONUP */)
+                        handleBrowse();
+                } })] }));
+});

package/lib/react-qw/components/ProgressBar.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useEffect, useRef } from 'react';
+import * as gui from 'gui';
+export const ProgressBar = forwardRef(({ value = 0, max = 100, style, smooth }, ref) => {
+    const pbRef = useRef(null);
+    const ws = 268435456 /* gui.WindowStyle.VISIBLE */ | 8388608 /* gui.WindowStyle.BORDER */
+        | (smooth ? 1 /* gui.ProgressStyle.SMOOTH */ : 0);
+    useEffect(() => {
+        const h = pbRef.current;
+        if (!h)
+            return;
+        gui.SendMessage(h, 1030 /* gui.ProgressMsg.SETRANGE32 */, 0, max);
+        gui.SendMessage(h, 1026 /* gui.ProgressMsg.SETPOS */, Math.min(value, max), 0);
+    }, [value, max]);
+    return (_jsx("w", { type: "msctls_progress32", ws: ws, style: style, ref: (h) => {
+            pbRef.current = h;
+            if (typeof ref === 'function')
+                ref(h);
+            else if (ref)
+                ref.current = h;
+        } }));
+});

package/lib/react-qw/components/RadioButton.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useState, useEffect, useRef } from 'react';
+import * as gui from 'gui';
+export const RadioButton = forwardRef(({ checked: controlledChecked, defaultChecked = false, onChange, label, style, disabled }, ref) => {
+    const [internalChecked, setInternalChecked] = useState(defaultChecked);
+    const isControlled = controlledChecked !== undefined;
+    const displayChecked = isControlled ? controlledChecked : internalChecked;
+    const rbRef = useRef(null);
+    useEffect(() => {
+        const h = rbRef.current;
+        if (!h)
+            return;
+        gui.SendMessage(h, 241 /* gui.ButtonMsg.SETCHECK */, displayChecked ? 1 /* gui.ButtonCheckState.CHECKED */ : 0 /* gui.ButtonCheckState.UNCHECKED */, 0);
+    }, [displayChecked]);
+    return (_jsx("w", { type: "BUTTON", text: label ?? '', ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 9 /* gui.ButtonStyle.AUTORADIOBUTTON */, style: style, disabled: disabled, ref: (h) => {
+            rbRef.current = h;
+            if (typeof ref === 'function')
+                ref(h);
+            else if (ref)
+                ref.current = h;
+        }, onEvent: (e) => {
+            if (e.msg === 514 /* gui.WmMsg.LBUTTONUP */) {
+                const newChecked = gui.SendMessage(e.hwnd, 240 /* gui.ButtonMsg.GETCHECK */, 0, 0) !== 0;
+                if (newChecked !== displayChecked) {
+                    if (!isControlled)
+                        setInternalChecked(newChecked);
+                    onChange?.(newChecked);
+                }
+            }
+        } }));
+});

package/lib/react-qw/components/ScrollView.js

@@ -0,0 +1,139 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef, useLayoutEffect, useRef } from 'react';
+import * as gui from 'gui';
+import { forceFlexLayout } from '../reconciler.js';
+export const ScrollView = forwardRef(({ children, style, contentWidth, contentHeight }, ref) => {
+    const svRef = useRef(null);
+    const contentRef = useRef(null);
+    const scrollXRef = useRef(0);
+    const scrollYRef = useRef(0);
+    // Win32 比例滚动条约定：
+    //   min   = 0
+    //   max   = contentSize - 1（内容最后像素行号）
+    //   page  = viewportSize（可见行数）
+    //   nPos  = 0 … max - page + 1（即 0 … contentSize - viewportSize）
+    function updateScroll(sv, content) {
+        const svRect = gui.GetClientRect(sv);
+        if (!svRect)
+            return;
+        const svW = svRect.right - svRect.left;
+        const svH = svRect.bottom - svRect.top;
+        const scale = gui.GetScaleFactor();
+        const natW = Math.round((contentWidth ?? (svW / scale)) * scale);
+        const natH = Math.round((contentHeight ?? (svH / scale)) * scale);
+        scrollXRef.current = Math.max(0, Math.min(scrollXRef.current, natW - svW));
+        scrollYRef.current = Math.max(0, Math.min(scrollYRef.current, natH - svH));
+        gui.SetWindowPos(content, 0 /* gui.SetWindowPosHwnd.TOP */, -scrollXRef.current, -scrollYRef.current, natW, natH, 4 /* gui.SetWindowPosFlag.SWP_NOZORDER */);
+        forceFlexLayout(content);
+        if (natW > svW) {
+            gui.SetScrollInfo(sv, 0 /* gui.ScrollBar.HORZ */, { min: 0, max: natW - 1, page: svW, pos: scrollXRef.current }, true);
+            gui.ShowScrollBar(sv, 0 /* gui.ScrollBar.HORZ */, true);
+        }
+        else {
+            scrollXRef.current = 0;
+            gui.ShowScrollBar(sv, 0 /* gui.ScrollBar.HORZ */, false);
+        }
+        if (natH > svH) {
+            gui.SetScrollInfo(sv, 1 /* gui.ScrollBar.VERT */, { min: 0, max: natH - 1, page: svH, pos: scrollYRef.current }, true);
+            gui.ShowScrollBar(sv, 1 /* gui.ScrollBar.VERT */, true);
+        }
+        else {
+            scrollYRef.current = 0;
+            gui.ShowScrollBar(sv, 1 /* gui.ScrollBar.VERT */, false);
+        }
+    }
+    useLayoutEffect(() => {
+        const sv = svRef.current;
+        const content = contentRef.current;
+        if (!sv || !content)
+            return;
+        updateScroll(sv, content);
+    }, [contentWidth, contentHeight]);
+    function setScrollPos(sv, content, bar, newPos) {
+        if (bar === 1 /* gui.ScrollBar.VERT */) {
+            scrollYRef.current = newPos;
+        }
+        else {
+            scrollXRef.current = newPos;
+        }
+        gui.SetWindowPos(content, 0 /* gui.SetWindowPosHwnd.TOP */, -scrollXRef.current, -scrollYRef.current, 0, 0, 1 /* gui.SetWindowPosFlag.SWP_NOSIZE */ | 4 /* gui.SetWindowPosFlag.SWP_NOZORDER */);
+        gui.SetScrollInfo(sv, bar, { pos: newPos }, true);
+    }
+    function handleScroll(e, bar) {
+        const sv = svRef.current;
+        const content = contentRef.current;
+        if (!sv || !content)
+            return;
+        const info = gui.GetScrollInfo(sv, bar);
+        const maxPos = info.max - info.page + 1;
+        const code = e.wParam & 0xFFFF;
+        const ref_ = bar === 1 /* gui.ScrollBar.VERT */ ? scrollYRef : scrollXRef;
+        let newPos = ref_.current;
+        if (code === 5 /* gui.ScrollCmd.THUMBTRACK */) {
+            newPos = Math.max(0, Math.min(maxPos, (e.wParam >> 16) & 0xFFFF));
+        }
+        else if (code === 0 /* gui.ScrollCmd.LINEUP */)
+            newPos -= 20;
+        else if (code === 1 /* gui.ScrollCmd.LINEDOWN */)
+            newPos += 20;
+        else if (code === 2 /* gui.ScrollCmd.PAGEUP */)
+            newPos -= info.page;
+        else if (code === 3 /* gui.ScrollCmd.PAGEDOWN */)
+            newPos += info.page;
+        else
+            return;
+        newPos = Math.max(0, Math.min(maxPos, newPos));
+        if (newPos !== ref_.current)
+            setScrollPos(sv, content, bar, newPos);
+    }
+    function handleMouseWheel(e) {
+        const sv = svRef.current;
+        const content = contentRef.current;
+        if (!sv || !content)
+            return;
+        const wheel = e.wParam >> 16;
+        const dy = -Math.round(wheel * 40 / 120);
+        const isHorz = (e.wParam & 4 /* gui.MouseKeyFlag.MK_SHIFT */) !== 0;
+        if (isHorz && contentWidth === undefined)
+            return;
+        if (!isHorz && contentHeight === undefined)
+            return;
+        const bar = isHorz ? 0 /* gui.ScrollBar.HORZ */ : 1 /* gui.ScrollBar.VERT */;
+        const info = gui.GetScrollInfo(sv, bar);
+        const maxPos = info.max - info.page + 1;
+        const ref_ = isHorz ? scrollXRef : scrollYRef;
+        let newPos = ref_.current + dy;
+        newPos = Math.max(0, Math.min(maxPos, newPos));
+        if (newPos !== ref_.current)
+            setScrollPos(sv, content, bar, newPos);
+    }
+    return (_jsx("w", { type: "STATIC", ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 33554432 /* gui.WindowStyle.CLIPCHILDREN */ |
+            (contentWidth !== undefined ? 1048576 /* gui.WindowStyle.HSCROLL */ : 0) |
+            (contentHeight !== undefined ? 2097152 /* gui.WindowStyle.VSCROLL */ : 0), style: style, ref: (h) => {
+            svRef.current = h;
+            if (typeof ref === 'function')
+                ref(h);
+            else if (ref)
+                ref.current = h;
+        }, onEvent: {
+            fn: (e) => {
+                if (e.msg === 132 /* gui.WmMsg.NCHITTEST */ ||
+                    e.msg === 161 /* gui.WmMsg.NCLBUTTONDOWN */) {
+                    return gui.DefWindowProc(e.hwnd, e.msg, e.wParam, e.lParam);
+                }
+                if (e.msg === 277 /* gui.WmMsg.VSCROLL */) {
+                    handleScroll(e, 1 /* gui.ScrollBar.VERT */);
+                    return 0;
+                }
+                if (e.msg === 276 /* gui.WmMsg.HSCROLL */) {
+                    handleScroll(e, 0 /* gui.ScrollBar.HORZ */);
+                    return 0;
+                }
+                if (e.msg === 522 /* gui.WmMsg.MOUSEWHEEL */) {
+                    handleMouseWheel(e);
+                    return 0;
+                }
+                return e.callOldWndProc();
+            }
+        }, children: _jsx("w", { type: "STATIC", ws: 268435456 /* gui.WindowStyle.VISIBLE */ | 33554432 /* gui.WindowStyle.CLIPCHILDREN */, style: { flexDirection: 'column', alignItems: 'flex-start' }, ref: (h) => { contentRef.current = h; }, children: children }) }));
+});