quickwin 1.2.1 → 1.3.0

package/lib/ffi-struct.ts

@@ -0,0 +1,239 @@
+import * as os from 'os'
+import { normKind, type Norm } from './ffi-bind.js'
+
+// 声明式结构体定义：struct({ field: 'i32', p: 'ptr', ws: 'wstr[32]', child: SubStruct })
+// layout 采用 MSVC 对齐语义：
+//   i8/u8→1   i16/u16→2   i32/u32/f32→4   i64/u64/f64→8   ptr→arch 宽(4/8)
+//   struct 对齐 = 最大字段对齐，总尺寸末尾补齐
+// 字段类型：
+//   标量 kind（含 ffi-bind 的 C typedef 别名：int/DWORD/LPARAM/HANDLE...）
+//   定长数组 'u16[8]' / 'i32[4]' / 'wstr[32]'（wstr 读 string、写 string，自动截断+补 0）
+//   嵌套 struct：字段值直接传子 struct 定义对象
+
+type FieldKind = 'u8' | 'i8' | 'u16' | 'i16' | 'u32' | 'i32' | 'u64' | 'i64' | 'f32' | 'f64' | 'ptr' | 'wstr'
+
+const PTR = os.arch === 'x64' ? 8 : 4
+
+// kind → [align, size]
+const AS: Record<FieldKind, [number, number]> = {
+    u8: [1, 1], i8: [1, 1],
+    u16: [2, 2], i16: [2, 2],
+    u32: [4, 4], i32: [4, 4],
+    u64: [8, 8], i64: [8, 8],
+    f32: [4, 4], f64: [8, 8],
+    ptr: [PTR, PTR],
+    wstr: [2, 2], // 仅定长数组元素用（wchar）
+}
+
+type KnownScalar = 'u8' | 'i8' | 'u16' | 'i16' | 'u32' | 'i32' | 'u64' | 'i64' | 'f32' | 'f64' | 'ptr'
+
+type ValOf<S extends string> = S extends `${infer B}[${number}]`
+    ? (B extends 'wstr' ? string : Norm<B> extends KnownScalar ? number[] : never)
+    : S extends KnownScalar ? number
+    : Norm<S> extends KnownScalar ? number : never
+
+export type StructShape<T extends Record<string, unknown> = Record<string, unknown>> = {
+    readonly __fields: T
+    readonly size: number
+    readonly structAlign: number
+}
+
+type ShapeOf<T extends Record<string, unknown>> = {
+    [K in keyof T]: T[K] extends string ? ValOf<T[K]> : T[K] extends StructShape ? ShapeOf<T[K]['__fields']> : never
+}
+
+export type StructDef<F extends Record<string, string | StructShape>> = StructShape<F> & {
+    read(buf: ArrayBuffer, offset?: number): ShapeOf<F>
+    write(v: ShapeOf<F>, buf?: ArrayBuffer, offset?: number): ArrayBuffer
+    offsetOf(name: keyof F): number
+}
+
+type Field = {
+    name: string
+    base: FieldKind
+    count: number
+    offset: number
+    child?: StructShape
+}
+
+function alignUp(v: number, a: number): number {
+    return (v + a - 1) & ~(a - 1)
+}
+
+function parseField(f: string): { base: FieldKind; count: number } {
+    const arr = /^(.+)\[(\d+)\]$/.exec(f)
+    if (arr) {
+        const b = normKind(arr[1]!)
+        if (b === 'void') throw new Error(`ffi-struct: "void" cannot be an array base`)
+        return { base: b as FieldKind, count: Number(arr[2]) }
+    }
+    const b = normKind(f)
+    if (b === 'void' || b === 'wstr') throw new Error(`ffi-struct: invalid scalar field type "${f}"`)
+    return { base: b as FieldKind, count: 1 }
+}
+
+function layout<F extends Record<string, string | StructShape>>(def: F): { fields: Field[]; size: number; structAlign: number } {
+    const fields: Field[] = []
+    let cursor = 0
+    let maxAlign = 1
+    for (const key of Object.keys(def) as (keyof F)[]) {
+        const v = def[key]
+        let a: number
+        let w: number
+        if (typeof v === 'string') {
+            const { base, count } = parseField(v)
+            const [align, elem] = AS[base]
+            a = align
+            w = count >= 1 ? elem * count : elem
+            fields.push({ name: key as string, base, count, offset: 0 })
+        } else {
+            const child = v as StructShape
+            a = child.structAlign
+            w = child.size
+            fields.push({ name: key as string, base: 'u8', count: 0, offset: 0, child })
+        }
+        const off = alignUp(cursor, a)
+        const f = fields[fields.length - 1]!
+        f.offset = off
+        cursor = off + w
+        if (a > maxAlign) maxAlign = a
+    }
+    return { fields, size: alignUp(cursor, maxAlign), structAlign: maxAlign }
+}
+
+const _layoutCache = new WeakMap<object, { fields: Field[]; size: number; structAlign: number }>()
+
+function buildLayout<F extends Record<string, string | StructShape>>(def: F): { fields: Field[]; size: number; structAlign: number } {
+    let hit = _layoutCache.get(def)
+    if (hit) return hit
+    hit = layout(def)
+    _layoutCache.set(def, hit)
+    return hit
+}
+
+function readScalar(dv: DataView, off: number, k: FieldKind): number {
+    switch (k) {
+        case 'u8': return dv.getUint8(off)
+        case 'i8': return dv.getInt8(off)
+        case 'u16': return dv.getUint16(off, true)
+        case 'i16': return dv.getInt16(off, true)
+        case 'u32': return dv.getUint32(off, true)
+        case 'i32': return dv.getInt32(off, true)
+        case 'u64': return Number(dv.getBigUint64(off, true))
+        case 'i64': return Number(dv.getBigInt64(off, true))
+        case 'f32': return dv.getFloat32(off, true)
+        case 'f64': return dv.getFloat64(off, true)
+        case 'ptr': return readPtr(dv, off)
+        case 'wstr': return dv.getUint16(off, true)
+    }
+}
+
+function readPtr(dv: DataView, off: number): number {
+    if (PTR === 8) return Number(dv.getBigUint64(off, true))
+    return dv.getUint32(off, true)
+}
+
+function writeScalar(dv: DataView, off: number, k: FieldKind, val: number): void {
+    switch (k) {
+        case 'u8': dv.setUint8(off, val); break
+        case 'i8': dv.setInt8(off, val); break
+        case 'u16': dv.setUint16(off, val, true); break
+        case 'i16': dv.setInt16(off, val, true); break
+        case 'u32': dv.setUint32(off, val >>> 0, true); break
+        case 'i32': dv.setInt32(off, val | 0, true); break
+        case 'u64': dv.setBigUint64(off, BigInt(Math.trunc(val)), true); break
+        case 'i64': dv.setBigInt64(off, BigInt(Math.trunc(val)), true); break
+        case 'f32': dv.setFloat32(off, val, true); break
+        case 'f64': dv.setFloat64(off, val, true); break
+        case 'ptr': writePtr(dv, off, val); break
+        case 'wstr': dv.setUint16(off, val, true); break
+    }
+}
+
+function writePtr(dv: DataView, off: number, val: number): void {
+    if (PTR === 8) dv.setBigUint64(off, BigInt(Math.trunc(val)), true)
+    else dv.setUint32(off, val >>> 0, true)
+}
+
+function readField(dv: DataView, base: number, f: Field): unknown {
+    const off = base + f.offset
+    if (f.child) return readInto(f.child, dv.buffer as ArrayBuffer, off)
+    if (f.count > 1) {
+        if (f.base === 'wstr') {
+            const arr = new Uint16Array(dv.buffer, dv.byteOffset + off, f.count)
+            let end = 0
+            while (end < arr.length && arr[end] !== 0) end++
+            let s = ''
+            for (let i = 0; i < end; i++) s += String.fromCharCode(arr[i]!)
+            return s
+        }
+        const out: number[] = []
+        const step = AS[f.base]![1]
+        for (let i = 0; i < f.count; i++) out.push(readScalar(dv, off + i * step, f.base))
+        return out
+    }
+    return readScalar(dv, off, f.base)
+}
+
+function writeField(dv: DataView, base: number, f: Field, v: unknown): void {
+    const off = base + f.offset
+    if (f.child) { writeInto(f.child, v as Record<string, unknown>, dv.buffer as ArrayBuffer, off); return }
+    if (f.count > 1) {
+        if (f.base === 'wstr') {
+            const s = String(v ?? '')
+            const arr = new Uint16Array(dv.buffer, dv.byteOffset + off, f.count)
+            for (let i = 0; i < arr.length; i++) arr[i] = 0
+            const n = Math.min(s.length, f.count - 1)
+            for (let i = 0; i < n; i++) arr[i] = s.charCodeAt(i)
+            return
+        }
+        const step = AS[f.base]![1]
+        const list = (v ?? []) as number[]
+        for (let i = 0; i < f.count; i++) writeScalar(dv, off + i * step, f.base, list[i] ?? 0)
+        return
+    }
+    writeScalar(dv, off, f.base, Number(v))
+}
+
+function doSize<F extends Record<string, string | StructShape>>(def: F): number {
+    return buildLayout(def).size
+}
+
+function readInto<S>(child: StructShape, buf: ArrayBuffer, offset: number): S {
+    const r = child as unknown as { read(b: ArrayBuffer, o: number): S }
+    return r.read(buf, offset)
+}
+
+function doRead<F extends Record<string, string | StructShape>>(_def: F, fields: Field[], buf: ArrayBuffer, offset: number): ShapeOf<F> {
+    const out: Record<string, unknown> = {}
+    const dv = new DataView(buf)
+    for (const f of fields) out[f.name] = readField(dv, offset, f)
+    return out as ShapeOf<F>
+}
+
+function doWrite<F extends Record<string, string | StructShape>>(def: F, fields: Field[], v: ShapeOf<F>, buf?: ArrayBuffer, offset = 0): ArrayBuffer {
+    buf = buf ?? new ArrayBuffer(doSize(def))
+    const dv = new DataView(buf)
+    for (const f of fields) writeField(dv, offset, f, (v as Record<string, unknown>)[f.name])
+    return buf
+}
+
+function writeInto<W>(child: StructShape, v: Record<string, unknown>, buf: ArrayBuffer, offset: number): void {
+    const w = child as unknown as { write(i: W, b: ArrayBuffer, o: number): unknown }
+    w.write(v as W, buf, offset)
+}
+
+export function struct<const F extends Record<string, string | StructShape>>(def: F): StructDef<F> {
+    const { fields, size, structAlign } = buildLayout(def)
+    return {
+        __fields: def,
+        size,
+        structAlign,
+        read: (buf: ArrayBuffer, offset = 0) => doRead(def, fields, buf, offset),
+        write: (v, buf?: ArrayBuffer, offset = 0) => doWrite(def, fields, v, buf, offset),
+        offsetOf: (name: keyof F) => {
+            for (const f of fields) if (f.name === name) return f.offset
+            throw new Error(`ffi-struct: no field "${String(name)}"`)
+        },
+    }
+}

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

@@ -2,13 +2,17 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef, useRef, useEffect, useState } from 'react';
 import * as gui from 'gui';
 import * as ffi from 'ffi';
-function readI16(ptr, offset) {
-    return ffi.readByte(ptr + offset) | (ffi.readByte(ptr + offset + 1) << 8);
-}
-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);
-}
+import { struct } from '../../ffi-struct.js';
+import { NMHDR, nmCode, readI32At, readU16At } from '../nmhdr.js';
+const SYSTEMTIME = struct({
+    wYear: 'u16', wMonth: 'u16', wDayOfWeek: 'u16', wDay: 'u16',
+    wHour: 'u16', wMinute: 'u16', wSecond: 'u16', wMilliseconds: 'u16',
+});
+const NMDATETIMECHANGE = struct({
+    hdr: NMHDR,
+    dwFlags: 'u32',
+    st: SYSTEMTIME,
+});
 function bufPtr(buf) {
     return ffi.bufferPtr(buf);
 }
@@ -69,21 +73,23 @@ const DateTimePicker = forwardRef(function DateTimePicker({ value, onChange, def
     }, []);
     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, 16);
+                const code = nmCode(e.lParam);
                 if (code === -759 /* gui.DtNotifyCode.DATETIMECHANGE */) {
-                    const dwFlags = readI32(e.lParam, 24);
+                    // NMDATETIMECHANGE: NMHDR + DWORD dwFlags + SYSTEMTIME st
+                    const st = NMDATETIMECHANGE.offsetOf('st');
+                    const dwFlags = readI32At(e.lParam, NMDATETIMECHANGE.offsetOf('dwFlags'));
                     if (dwFlags === 1 /* gui.DtFlag.GDT_NONE */) {
                         if (!isControlled)
                             setInternalDate(null);
                         onChangeRef.current?.(null);
                     }
                     else {
-                        const year = readI16(e.lParam, 28);
-                        const month = readI16(e.lParam, 30);
-                        const day = readI16(e.lParam, 34);
-                        const hour = readI16(e.lParam, 36);
-                        const min = readI16(e.lParam, 38);
-                        const sec = readI16(e.lParam, 40);
+                        const year = readU16At(e.lParam, st + 0);
+                        const month = readU16At(e.lParam, st + 2);
+                        const day = readU16At(e.lParam, st + 6);
+                        const hour = readU16At(e.lParam, st + 8);
+                        const min = readU16At(e.lParam, st + 10);
+                        const sec = readU16At(e.lParam, st + 12);
                         const d = new Date(year, month - 1, day, hour, min, sec);
                         if (!isControlled)
                             setInternalDate(d);

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

@@ -2,10 +2,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef, useRef, useEffect } from 'react';
 import * as gui from 'gui';
 import * as ffi from 'ffi';
-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);
-}
+import { nmCode, NMHDR_SIZE } from '../nmhdr.js';
 function readUtf16(ptr, offset, maxWords) {
     const chars = [];
     for (let i = 0; i < maxWords; i++) {
@@ -32,9 +29,10 @@ const Link = forwardRef(function Link({ href, children, onClick, style }, ref) {
     }, [linkText]);
     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, 16);
+                const code = nmCode(e.lParam);
                 if (code === -2 /* gui.SysLinkNotifyCode.CLICK */ || code === -4 /* gui.SysLinkNotifyCode.RETURN */) {
-                    const url = readUtf16(e.lParam, 136, 2048);
+                    // NMLINK: NMHDR(12/20) + LITEM{ mask,iLink,state,stateMask (16B) + szID[48] (96B) } → szUrl
+                    const url = readUtf16(e.lParam, NMHDR_SIZE + 112, 2048);
                     onClickRef.current?.(url);
                 }
             }

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

@@ -3,6 +3,8 @@ import { forwardRef, useRef, useEffect } from 'react';
 import * as gui from 'gui';
 import * as ffi from 'ffi';
 import * as win from 'win';
+import { struct } from '../../ffi-struct.js';
+import { NMHDR, PTR_SIZE, nmCode } from '../nmhdr.js';
 export function makeColorBlock(size, bgra) {
     const n = size * size;
     const buf = new ArrayBuffer(n * 4);
@@ -46,16 +48,46 @@ function bufPtr(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
+// ListView 通知结构（嵌套 NMHDR 以复现 MSVC 尾 padding 传染，offsetOf 保证 ia32/x64 均正确）。
+const NMCUSTOMDRAW = struct({
+    hdr: NMHDR,
+    dwDrawStage: 'u32', hdc: 'ptr', rc: 'i32[4]',
+    dwItemSpec: 'ptr', uItemState: 'u32', lItemlParam: 'ptr',
+});
+const NMLVCUSTOMDRAW = struct({
+    hdr: NMHDR,
+    dwDrawStage: 'u32', hdc: 'ptr', rc: 'i32[4]',
+    dwItemSpec: 'ptr', uItemState: 'u32', lItemlParam: 'ptr',
+    clrText: 'u32', clrTextBk: 'u32', iSubItem: 'i32', dwItemType: 'u32',
+});
+// NMLISTVIEW / NMITEMACTIVATE 前缀字段布局一致（iItem..uChanged）
+const NMLISTVIEW = struct({
+    hdr: NMHDR,
+    iItem: 'i32', iSubItem: 'i32', uNewState: 'u32', uOldState: 'u32', uChanged: 'u32',
+    ptAction: 'i32[2]', lParam: 'ptr',
+});
+const CD_STAGE = NMCUSTOMDRAW.offsetOf('dwDrawStage');
+const CD_HDC = NMCUSTOMDRAW.offsetOf('hdc');
+const CD_ITEM = NMCUSTOMDRAW.offsetOf('dwItemSpec');
+const CD_CLRTEXT = NMLVCUSTOMDRAW.offsetOf('clrText');
+const CD_CLRTEXTBK = NMLVCUSTOMDRAW.offsetOf('clrTextBk');
+const CD_SUBITEM = NMLVCUSTOMDRAW.offsetOf('iSubItem');
+const NMIA_ITEM = NMLISTVIEW.offsetOf('iItem');
+const NMIA_SUBITEM = NMLISTVIEW.offsetOf('iSubItem');
+const NMLV_UNEW = NMLISTVIEW.offsetOf('uNewState');
+const NMLV_UOLD = NMLISTVIEW.offsetOf('uOldState');
+const LVITEMW = struct({
+    mask: 'u32', iItem: 'i32', iSubItem: 'i32',
+    state: 'u32', stateMask: 'u32',
+    pszText: 'ptr', cchTextMax: 'i32', iImage: 'i32', lParam: 'ptr',
+    iIndent: 'i32', iGroupId: 'i32', cColumns: 'u32',
+    puColumns: 'ptr', piColFmt: 'ptr', iGroup: 'i32',
+});
+const LVCOLUMNW = struct({
+    mask: 'u32', fmt: 'i32', cx: 'i32',
+    pszText: 'ptr', cchTextMax: 'i32', iSubItem: 'i32', iImage: 'i32', iOrder: 'i32',
+    cxMin: 'i32', cxDefault: 'i32', cxIdeal: 'i32',
+});
 const fontCache = new Map();
 let gdi32 = null;
 let createFontIndirectW = null;
@@ -99,7 +131,7 @@ function getCellFont(hwnd, style) {
     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);
+        const got = ffi.ffiCall(getObjectW, [ffi.FFI_TYPE_POINTER, ffi.FFI_TYPE_SINT32, ffi.FFI_TYPE_POINTER], [cur, 92, lf], ffi.FFI_TYPE_SINT32);
         if (!got)
             return null;
     }
@@ -112,9 +144,9 @@ function getCellFont(hwnd, style) {
         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;
+    const h = ffi.ffiCall(createFontIndirectW, [ffi.FFI_TYPE_POINTER], [lf], ffi.FFI_TYPE_POINTER);
+    fontCache.set(key, h ? h : 0);
+    return h ? h : null;
 }
 function handleCustomDraw(lParam, columns, data, hwnd) {
     const stage = readU32(lParam, CD_STAGE);
@@ -134,9 +166,9 @@ function handleCustomDraw(lParam, columns, data, hwnd) {
             writeU32(lParam, CD_CLRTEXTBK, style.background);
         const hfont = getCellFont(hwnd, style);
         if (hfont && selectObjectFn) {
-            const hdc = readU64(lParam, CD_HDC);
+            const hdc = PTR_SIZE === 8 ? readU64(lParam, CD_HDC) : readU32(lParam, CD_HDC);
             if (hdc) {
-                ffi.ffiCall(selectObjectFn, [ffi.FFI_TYPE_UINT64, ffi.FFI_TYPE_UINT64], [hdc, hfont], ffi.FFI_TYPE_UINT64);
+                ffi.ffiCall(selectObjectFn, [ffi.FFI_TYPE_POINTER, ffi.FFI_TYPE_POINTER], [hdc, hfont], ffi.FFI_TYPE_POINTER);
                 return 2 /* gui.CustomDrawFlag.NEWFONT */;
             }
         }
@@ -169,18 +201,24 @@ function resolveCellStyle(columns, data, row, colIndex) {
     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);
+    const b = LVITEMW.write({
+        mask: 1 /* LvItemFlag.TEXT */ | (image !== undefined ? 2 /* LvItemFlag.IMAGE */ : 0),
+        iItem: i,
+        iSubItem: sub,
+        state: 0,
+        stateMask: 0,
+        pszText: bufPtr(textBuf),
+        cchTextMax: 0,
+        iImage: image ?? 0,
+        lParam: 0,
+        iIndent: 0,
+        iGroupId: 0,
+        cColumns: 0,
+        puColumns: 0,
+        piColFmt: 0,
+        iGroup: 0,
+    });
     b.__textBuf = textBuf;
     return b;
 }
@@ -228,13 +266,19 @@ const ListView = forwardRef(function ListViewInner({ columns, data, style, icons
         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);
+            const lvc = LVCOLUMNW.write({
+                mask: 4 /* LvColumnMask.TEXT */ | 2 /* LvColumnMask.WIDTH */ | 1 /* LvColumnMask.FORMAT */,
+                fmt: alignToFmt(columns[j].align),
+                cx: columns[j].width ?? 100,
+                pszText: bufPtr(titleBuf),
+                cchTextMax: 0,
+                iSubItem: j,
+                iImage: 0,
+                iOrder: 0,
+                cxMin: 0,
+                cxDefault: 0,
+                cxIdeal: 0,
+            });
             lvc.__titleBuf = titleBuf;
             gui.SendMessage(h, 4193 /* gui.LvMsg.INSERTCOLUMNW */, j, bufPtr(lvc));
         }
@@ -263,13 +307,13 @@ const ListView = forwardRef(function ListViewInner({ columns, data, style, icons
     }, [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);
+                const code = nmCode(e.lParam);
                 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);
+                    const uNewState = readU32(e.lParam, NMLV_UNEW);
+                    const uOldState = readU32(e.lParam, NMLV_UOLD);
                     if ((uNewState & 2 /* LvItemState.SELECTED */) !== (uOldState & 2 /* LvItemState.SELECTED */))
                         return 1;
                 }
@@ -303,7 +347,7 @@ const ListView = forwardRef(function ListViewInner({ columns, data, style, icons
                 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);
+                ffi.ffiCall(screenToClient, [ffi.FFI_TYPE_POINTER, 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);
@@ -317,9 +361,9 @@ const ListView = forwardRef(function ListViewInner({ columns, data, style, icons
                 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);
+                const hc = ffi.ffiCall(loadCursorW, [ffi.FFI_TYPE_POINTER, ffi.FFI_TYPE_POINTER], [0, style.cursor], ffi.FFI_TYPE_POINTER);
                 if (hc) {
-                    ffi.ffiCall(setCursorFn, [ffi.FFI_TYPE_UINT64], [hc], ffi.FFI_TYPE_UINT64);
+                    ffi.ffiCall(setCursorFn, [ffi.FFI_TYPE_POINTER], [hc], ffi.FFI_TYPE_POINTER);
                     return 1;
                 }
                 return;

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

@@ -2,6 +2,7 @@ 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';
+import { OPENFILENAMEW, BROWSEINFOW } from '../../win-common-structs.js';
 const FFI_PTR = ffi.FFI_TYPE_POINTER;
 const FFI_U32 = ffi.FFI_TYPE_UINT32;
 let _GetOpenFileNameW = 0;
@@ -32,31 +33,42 @@ function wideToStr(buf, offset = 0) {
     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);
+    const ofn = OPENFILENAMEW.write({
+        lStructSize: OPENFILENAMEW.size,
+        hwndOwner: owner,
+        hInstance: 0,
+        lpstrFilter: ffi.bufferPtr(filterWide),
+        lpstrCustomFilter: 0,
+        nMaxCustFilter: 0,
+        nFilterIndex: 0,
+        lpstrFile: ffi.bufferPtr(fileBuf),
+        nMaxFile: 260,
+        lpstrFileTitle: 0,
+        nMaxFileTitle: 0,
+        lpstrInitialDir: 0,
+        lpstrTitle: titleWide ? ffi.bufferPtr(titleWide) : 0,
+        Flags: flags,
+        nFileOffset: 0,
+        nFileExtension: 0,
+        lpstrDefExt: 0,
+        lCustData: 0,
+        lpfnHook: 0,
+        lpTemplateName: 0,
+        pvReserved: 0,
+        dwReserved: 0,
+        FlagsEx: 0,
+    });
+    const ret = ffi.ffiCall(_GetOpenFileNameW, [FFI_PTR], [ofn], FFI_U32);
     if (!ret)
         return null;
     if (!multiple) {
@@ -79,19 +91,23 @@ function openFileDialog(owner, filter, title, multiple) {
 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);
+    const bi = BROWSEINFOW.write({
+        hwndOwner: owner,
+        pidlRoot: 0,
+        pszDisplayName: 0,
+        lpszTitle: titleWide ? ffi.bufferPtr(titleWide) : 0,
+        ulFlags: 0x00000041,
+        lpfn: 0,
+        lParam: 0,
+        iImage: 0,
+    });
+    const pidl = ffi.ffiCall(_SHBrowseForFolderW, [FFI_PTR], [bi], 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);
+    const ok = ffi.ffiCall(_SHGetPathFromIDListW, [ffi.FFI_TYPE_POINTER, FFI_PTR], [pidl, pathBuf], FFI_U32);
+    ffi.ffiCall(_CoTaskMemFree, [ffi.FFI_TYPE_POINTER], [pidl], ffi.FFI_TYPE_VOID);
     return ok ? wideToStr(pathBuf) : null;
 }
 export const PathPicker = forwardRef((props, ref) => {