# ============================================================
# vqt6 — Viper 的 Qt6 绑定包
#
# 公共 Pythonic API（基于 C 桥接层）
# 用户用法:
#   import vqt6
#   app = vqt6.QApplication([])
#   win = vqt6.QWidget()
#   win.setWindowTitle("Hello")
#   win.show()
#   app.exec()
# ============================================================

import t
import stdlib
from stdint import *
from vqt6._types import *
from vqt6._qtcore import *
from vqt6._qtwidgets import *
from vqt6._qtgui import *
from vqt6._qtnetwork import *


# ============================================================
# 高级 API 类（Pythonic 包装，不透明指针）
# ============================================================

# ============================================================
# 模块级 helper：QWidget 基础操作（各控件类复用）
# ============================================================
def _w_show(ptr: t.CPtr):
    vqt6_qwidget_show(ptr)


def _w_hide(ptr: t.CPtr):
    vqt6_qwidget_hide(ptr)


def _w_close(ptr: t.CPtr) -> int:
    return vqt6_qwidget_close(ptr)


def _w_set_geometry(ptr: t.CPtr, x: int, y: int, w: int, h: int):
    vqt6_qwidget_set_geometry(ptr, x, y, w, h)


def _w_resize(ptr: t.CPtr, w: int, h: int):
    vqt6_qwidget_resize(ptr, w, h)


def _w_move(ptr: t.CPtr, x: int, y: int):
    vqt6_qwidget_move(ptr, x, y)


def _w_set_enabled(ptr: t.CPtr, enabled: int):
    vqt6_qwidget_set_enabled(ptr, enabled)


def _w_set_visible(ptr: t.CPtr, visible: int):
    vqt6_qwidget_set_visible(ptr, visible)


def _w_is_visible(ptr: t.CPtr) -> int:
    return vqt6_qwidget_is_visible(ptr)


def _w_set_window_title(ptr: t.CPtr, title: str):
    qs: QtStringPtr = vqt6_qstring_create(title)
    vqt6_qwidget_set_window_title(ptr, qs)
    vqt6_qstring_free(qs)


def _w_set_tool_tip(ptr: t.CPtr, tip: str):
    qs: QtStringPtr = vqt6_qstring_create(tip)
    vqt6_qwidget_set_tool_tip(ptr, qs)
    vqt6_qstring_free(qs)


def _w_text_of(qstr: QtStringPtr) -> str:
    """QtStringPtr → Viper str（复制到 malloc 缓冲）"""
    buf: bytes = stdlib.malloc(1024)
    vqt6_qstring_to_utf8(qstr, buf, 1024)
    s: str = buf
    vqt6_qstring_free(qstr)
    return s


# ============================================================
# 树状控件统计助手（返回 int，规避跨模块 FFI 返回指针）
# 叶子勾选态: 0=未选 1=半选 2=选中
# ============================================================
def qtree_checked_count(tw: QtTreeWidgetPtr) -> int:
    """统计被勾选的叶子节点数"""
    n: int = 0
    gi: int = 0
    top_n: int = vqt6_qtreewidget_top_level_item_count(tw)
    while gi < top_n:
        g: QtTreeWidgetItemPtr = vqt6_qtreewidget_top_level_item(tw, gi)
        ci: int = 0
        cn: int = vqt6_qtreewidgetitem_child_count(g)
        while ci < cn:
            it: QtTreeWidgetItemPtr = vqt6_qtreewidgetitem_child(g, ci)
            if vqt6_qtreewidgetitem_check_state(it) == 2:
                n += 1
            ci += 1
        gi += 1
    return n


def qtree_checked_size(tw: QtTreeWidgetPtr) -> int:
    """统计被勾选叶子节点的磁盘占用合计(MB)"""
    mb: int = 0
    gi: int = 0
    top_n: int = vqt6_qtreewidget_top_level_item_count(tw)
    while gi < top_n:
        g: QtTreeWidgetItemPtr = vqt6_qtreewidget_top_level_item(tw, gi)
        ci: int = 0
        cn: int = vqt6_qtreewidgetitem_child_count(g)
        while ci < cn:
            it: QtTreeWidgetItemPtr = vqt6_qtreewidgetitem_child(g, ci)
            if vqt6_qtreewidgetitem_check_state(it) == 2:
                mb += vqt6_qtreewidgetitem_data_int(it)
            ci += 1
        gi += 1
    return mb


def qtree_click_toggle(tw: QtTreeWidgetPtr):
    """点击带子节点的当前行 → 展开/折叠"""
    cur: QtTreeWidgetItemPtr = vqt6_qtreewidget_current_item(tw)
    if cur is None:
        return
    if vqt6_qtreewidgetitem_child_count(cur) > 0:
        ex: int = vqt6_qtreewidgetitem_is_expanded(cur)
        vqt6_qtreewidgetitem_set_expanded(cur, 1 - ex)


@t.NoVTable
class QApplication:
    """QApplication 包装（不透明指针）"""
    _ptr: QtAppPtr

    def __init__(self, argv: list[str] | t.CPtr):
        # 把 argv 转换为 argc/argv 数组
        argc: t.CInt = 1
        # Viper 端 argv 是 c_char_p 指针数组
        # 这里仅传空 argv，避免 C ABI 复杂性
        argv_ptr: t.CPtr = t.CPtr(0)
        self._ptr = vqt6_qapplication_create(argc, argv_ptr)
        if self._ptr is None:
            raise RuntimeError("Failed to create QApplication")

    def exec(self) -> int:
        return vqt6_qapplication_exec(self._ptr)

    def quit(self):
        vqt6_qapplication_quit(self._ptr)

    def exit(self, code: int):
        vqt6_qapplication_exit(self._ptr, code)

    def process_events(self):
        vqt6_qapplication_process_events(self._ptr)

    def desktop_width(self) -> int:
        return vqt6_qapplication_desktop_width(self._ptr)

    def desktop_height(self) -> int:
        return vqt6_qapplication_desktop_height(self._ptr)


@t.NoVTable
class QWidget:
    """QWidget 包装"""
    _ptr: QtWidgetPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qwidget_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qwidget_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QWidget")

    def show(self):
        vqt6_qwidget_show(self._ptr)

    def hide(self):
        vqt6_qwidget_hide(self._ptr)

    def close(self) -> int:
        return vqt6_qwidget_close(self._ptr)

    def setWindowTitle(self, title: str):
        title_qs: QtStringPtr = vqt6_qstring_create(title)
        vqt6_qwidget_set_window_title(self._ptr, title_qs)
        vqt6_qstring_free(title_qs)

    def windowTitle(self) -> str:
        result: QtStringPtr = vqt6_qwidget_window_title(self._ptr)
        buf: bytes = stdlib.malloc(1024)
        vqt6_qstring_to_utf8(result, buf, 1024)
        s: str = buf
        vqt6_qstring_free(result)
        return s

    def resize(self, w: int, h: int):
        vqt6_qwidget_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        vqt6_qwidget_move(self._ptr, x, y)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        vqt6_qwidget_set_geometry(self._ptr, x, y, w, h)

    def setEnabled(self, enabled: int):
        vqt6_qwidget_set_enabled(self._ptr, enabled)

    def setVisible(self, visible: int):
        vqt6_qwidget_set_visible(self._ptr, visible)

    def isVisible(self) -> int:
        return vqt6_qwidget_is_visible(self._ptr)

    def setToolTip(self, tip: str):
        tip_qs: QtStringPtr = vqt6_qstring_create(tip)
        vqt6_qwidget_set_tool_tip(self._ptr, tip_qs)
        vqt6_qstring_free(tip_qs)

    def setStyleSheet(self, qss: str):
        vqt6_qwidget_set_stylesheet_utf8(self._ptr, qss)


@t.NoVTable
class QLabel:
    """QLabel 包装"""
    _ptr: QtLabelPtr

    def __init__(self, text: str = "", parent: "QWidget | None" = None):
        text_qs: QtStringPtr = vqt6_qstring_create(text)
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qlabel_create_with_text_parent(text_qs, parent._ptr)
        elif text_qs is not None:
            self._ptr = vqt6_qlabel_create_with_text(text_qs)
        else:
            self._ptr = vqt6_qlabel_create()
        vqt6_qstring_free(text_qs)
        if self._ptr is None:
            raise RuntimeError("Failed to create QLabel")

    def setText(self, text: str):
        text_qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qlabel_set_text(self._ptr, text_qs)
        vqt6_qstring_free(text_qs)

    def text(self) -> str:
        result: QtStringPtr = vqt6_qlabel_text(self._ptr)
        buf: bytes = stdlib.malloc(1024)
        vqt6_qstring_to_utf8(result, buf, 1024)
        s: str = buf
        vqt6_qstring_free(result)
        return s

    def setAlignment(self, alignment: int):
        vqt6_qlabel_set_alignment(self._ptr, alignment)

    def setStyleSheet(self, qss: str):
        vqt6_qwidget_set_stylesheet_utf8(self._ptr, qss)


@t.NoVTable
class QPushButton:
    """QPushButton 包装"""
    _ptr: QtPushButtonPtr

    def __init__(self, text: str = "", parent: "QWidget | None" = None):
        text_qs: QtStringPtr = vqt6_qstring_create(text)
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qpushbutton_create_with_text_parent(text_qs, parent._ptr)
        elif text_qs is not None:
            self._ptr = vqt6_qpushbutton_create_with_text(text_qs)
        else:
            self._ptr = vqt6_qpushbutton_create()
        vqt6_qstring_free(text_qs)
        if self._ptr is None:
            raise RuntimeError("Failed to create QPushButton")

    def setText(self, text: str):
        text_qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qpushbutton_set_text(self._ptr, text_qs)
        vqt6_qstring_free(text_qs)

    def text(self) -> str:
        result: QtStringPtr = vqt6_qpushbutton_text(self._ptr)
        buf: bytes = stdlib.malloc(1024)
        vqt6_qstring_to_utf8(result, buf, 1024)
        s: str = buf
        vqt6_qstring_free(result)
        return s

    def click(self):
        vqt6_qpushbutton_click(self._ptr)

    def setEnabled(self, enabled: int):
        vqt6_qwidget_set_enabled(self._ptr, enabled)

    def setCheckable(self, checkable: int):
        vqt6_qpushbutton_set_checkable(self._ptr, checkable)

    def isCheckable(self) -> int:
        return vqt6_qpushbutton_is_checkable(self._ptr)

    def setChecked(self, checked: int):
        vqt6_qpushbutton_set_checked(self._ptr, checked)

    def isChecked(self) -> int:
        return vqt6_qpushbutton_is_checked(self._ptr)

    def setFlat(self, flat: int):
        vqt6_qpushbutton_set_flat(self._ptr, flat)

    # 回调（cb 传 Viper 模块级函数，签名 def cb(slot_id: int, data: t.CPtr)）
    def clicked(self, cb: bytes, data: bytes = 0):
        vqt6_qpushbutton_connect_clicked(self._ptr, cb, data)

    def toggled(self, cb: bytes, data: bytes = 0):
        vqt6_qpushbutton_connect_toggled(self._ptr, cb, data)


# ============================================================
# 窗口：QMainWindow / QDialog
# ============================================================
@t.NoVTable
class QMainWindow:
    """QMainWindow 包装"""
    _ptr: QtMainWindowPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qmainwindow_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qmainwindow_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QMainWindow")

    def setCentralWidget(self, w: t.CPtr):
        vqt6_qmainwindow_set_central_widget(self._ptr, w)

    def menuBar(self) -> "QMenuBar":
        mb_ptr: QtMenuBarPtr = vqt6_qmainwindow_menu_bar(self._ptr)
        mb = QMenuBar()
        mb._ptr = mb_ptr
        return mb

    def setMenuBar(self, mb: t.CPtr):
        vqt6_qmainwindow_set_menu_bar(self._ptr, mb)

    def statusBar(self) -> "QStatusBar":
        sb_ptr: QtStatusBarPtr = vqt6_qmainwindow_status_bar(self._ptr)
        sb = QStatusBar()
        sb._ptr = sb_ptr
        return sb

    def addToolBar(self, tb: t.CPtr):
        vqt6_qmainwindow_add_tool_bar(self._ptr, tb)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def close(self) -> int:
        return _w_close(self._ptr)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def setWindowTitle(self, title: str):
        _w_set_window_title(self._ptr, title)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)

    def setToolTip(self, tip: str):
        _w_set_tool_tip(self._ptr, tip)


@t.NoVTable
class QDialog:
    """QDialog 包装"""
    _ptr: QtDialogPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qdialog_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qdialog_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QDialog")

    def exec(self) -> int:
        return vqt6_qdialog_exec(self._ptr)

    def accept(self):
        vqt6_qdialog_accept(self._ptr)

    def reject(self):
        vqt6_qdialog_reject(self._ptr)

    def setModal(self, modal: int):
        vqt6_qdialog_set_modal(self._ptr, modal)

    def isModal(self) -> int:
        return vqt6_qdialog_is_modal(self._ptr)

    def setResult(self, result: int):
        vqt6_qdialog_set_result(self._ptr, result)

    def result(self) -> int:
        return vqt6_qdialog_result(self._ptr)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def close(self) -> int:
        return _w_close(self._ptr)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def setWindowTitle(self, title: str):
        _w_set_window_title(self._ptr, title)


# ============================================================
# 输入控件：QLineEdit / QCheckBox / QRadioButton
# ============================================================
@t.NoVTable
class QLineEdit:
    """QLineEdit 包装"""
    _ptr: QtLineEditPtr

    def __init__(self, text: str = "", parent: "QWidget | None" = None):
        qs: QtStringPtr = vqt6_qstring_create(text)
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qlineedit_create_with_text_parent(qs, parent._ptr)
        else:
            self._ptr = vqt6_qlineedit_create_with_text(qs)
        vqt6_qstring_free(qs)
        if self._ptr is None:
            raise RuntimeError("Failed to create QLineEdit")

    def setText(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qlineedit_set_text(self._ptr, qs)
        vqt6_qstring_free(qs)

    def text(self) -> str:
        return _w_text_of(vqt6_qlineedit_text(self._ptr))

    def setPlaceholderText(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qlineedit_set_placeholder_text(self._ptr, qs)
        vqt6_qstring_free(qs)

    def setReadOnly(self, ro: int):
        vqt6_qlineedit_set_read_only(self._ptr, ro)

    def isReadOnly(self) -> int:
        return vqt6_qlineedit_is_read_only(self._ptr)

    def setMaxLength(self, max_len: int):
        vqt6_qlineedit_set_max_length(self._ptr, max_len)

    def selectAll(self):
        vqt6_qlineedit_select_all(self._ptr)

    def clear(self):
        vqt6_qlineedit_clear(self._ptr)

    def textChanged(self, cb: bytes, data: bytes = 0):
        vqt6_qlineedit_connect_text_changed(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


@t.NoVTable
class QCheckBox:
    """QCheckBox 包装"""
    _ptr: QtCheckBoxPtr

    def __init__(self, text: str = "", parent: "QWidget | None" = None):
        qs: QtStringPtr = vqt6_qstring_create(text)
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qcheckbox_create_with_text_parent(qs, parent._ptr)
        else:
            self._ptr = vqt6_qcheckbox_create_with_text(qs)
        vqt6_qstring_free(qs)
        if self._ptr is None:
            raise RuntimeError("Failed to create QCheckBox")

    def setText(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qcheckbox_set_text(self._ptr, qs)
        vqt6_qstring_free(qs)

    def text(self) -> str:
        return _w_text_of(vqt6_qcheckbox_text(self._ptr))

    def setChecked(self, checked: int):
        vqt6_qcheckbox_set_checked(self._ptr, checked)

    def isChecked(self) -> int:
        return vqt6_qcheckbox_is_checked(self._ptr)

    def setTristate(self, tristate: int):
        vqt6_qcheckbox_set_tristate(self._ptr, tristate)

    def isTristate(self) -> int:
        return vqt6_qcheckbox_is_tristate(self._ptr)

    def toggled(self, cb: bytes, data: bytes = 0):
        vqt6_qcheckbox_connect_toggled(self._ptr, cb, data)

    def stateChanged(self, cb: bytes, data: bytes = 0):
        vqt6_qcheckbox_connect_state_changed(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


@t.NoVTable
class QRadioButton:
    """QRadioButton 包装"""
    _ptr: QtRadioButtonPtr

    def __init__(self, text: str = "", parent: "QWidget | None" = None):
        qs: QtStringPtr = vqt6_qstring_create(text)
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qradiobutton_create_with_text_parent(qs, parent._ptr)
        else:
            self._ptr = vqt6_qradiobutton_create_with_text(qs)
        vqt6_qstring_free(qs)
        if self._ptr is None:
            raise RuntimeError("Failed to create QRadioButton")

    def setText(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qradiobutton_set_text(self._ptr, qs)
        vqt6_qstring_free(qs)

    def text(self) -> str:
        return _w_text_of(vqt6_qradiobutton_text(self._ptr))

    def setChecked(self, checked: int):
        vqt6_qradiobutton_set_checked(self._ptr, checked)

    def isChecked(self) -> int:
        return vqt6_qradiobutton_is_checked(self._ptr)

    def toggled(self, cb: bytes, data: bytes = 0):
        vqt6_qradiobutton_connect_toggled(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


# ============================================================
# 选择控件：QComboBox / QSlider / QSpinBox / QProgressBar
# ============================================================
@t.NoVTable
class QComboBox:
    """QComboBox 包装"""
    _ptr: QtComboBoxPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qcombobox_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qcombobox_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QComboBox")

    def addItem(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qcombobox_add_item(self._ptr, qs)
        vqt6_qstring_free(qs)

    def insertItem(self, index: int, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qcombobox_insert_item(self._ptr, index, qs)
        vqt6_qstring_free(qs)

    def removeItem(self, index: int):
        vqt6_qcombobox_remove_item(self._ptr, index)

    def clear(self):
        vqt6_qcombobox_clear(self._ptr)

    def count(self) -> int:
        return vqt6_qcombobox_count(self._ptr)

    def currentIndex(self) -> int:
        return vqt6_qcombobox_current_index(self._ptr)

    def setCurrentIndex(self, index: int):
        vqt6_qcombobox_set_current_index(self._ptr, index)

    def currentText(self) -> str:
        return _w_text_of(vqt6_qcombobox_current_text(self._ptr))

    def itemText(self, index: int) -> str:
        return _w_text_of(vqt6_qcombobox_item_text(self._ptr, index))

    def setEditable(self, editable: int):
        vqt6_qcombobox_set_editable(self._ptr, editable)

    def isEditable(self) -> int:
        return vqt6_qcombobox_is_editable(self._ptr)

    def currentIndexChanged(self, cb: bytes, data: bytes = 0):
        vqt6_qcombobox_connect_current_index_changed(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


@t.NoVTable
class QSlider:
    """QSlider 包装"""
    _ptr: QtSliderPtr

    def __init__(self, orientation: int = QT_HORIZONTAL, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qslider_create_with_orientation_parent(orientation, parent._ptr)
        else:
            self._ptr = vqt6_qslider_create_with_orientation(orientation)
        if self._ptr is None:
            raise RuntimeError("Failed to create QSlider")

    def setValue(self, value: int):
        vqt6_qslider_set_value(self._ptr, value)

    def value(self) -> int:
        return vqt6_qslider_value(self._ptr)

    def setMinimum(self, min_val: int):
        vqt6_qslider_set_minimum(self._ptr, min_val)

    def setMaximum(self, max_val: int):
        vqt6_qslider_set_maximum(self._ptr, max_val)

    def setRange(self, min_val: int, max_val: int):
        vqt6_qslider_set_range(self._ptr, min_val, max_val)

    def setOrientation(self, orientation: int):
        vqt6_qslider_set_orientation(self._ptr, orientation)

    def orientation(self) -> int:
        return vqt6_qslider_orientation(self._ptr)

    def valueChanged(self, cb: bytes, data: bytes = 0):
        vqt6_qslider_connect_value_changed(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


@t.NoVTable
class QSpinBox:
    """QSpinBox 包装"""
    _ptr: QtSpinBoxPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qspinbox_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qspinbox_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QSpinBox")

    def value(self) -> int:
        return vqt6_qspinbox_value(self._ptr)

    def setValue(self, value: int):
        vqt6_qspinbox_set_value(self._ptr, value)

    def setMinimum(self, min_val: int):
        vqt6_qspinbox_set_minimum(self._ptr, min_val)

    def setMaximum(self, max_val: int):
        vqt6_qspinbox_set_maximum(self._ptr, max_val)

    def setRange(self, min_val: int, max_val: int):
        vqt6_qspinbox_set_range(self._ptr, min_val, max_val)

    def minimum(self) -> int:
        return vqt6_qspinbox_minimum(self._ptr)

    def maximum(self) -> int:
        return vqt6_qspinbox_maximum(self._ptr)

    def setPrefix(self, prefix: str):
        qs: QtStringPtr = vqt6_qstring_create(prefix)
        vqt6_qspinbox_set_prefix(self._ptr, qs)
        vqt6_qstring_free(qs)

    def setSuffix(self, suffix: str):
        qs: QtStringPtr = vqt6_qstring_create(suffix)
        vqt6_qspinbox_set_suffix(self._ptr, qs)
        vqt6_qstring_free(qs)

    def valueChanged(self, cb: bytes, data: bytes = 0):
        vqt6_qspinbox_connect_value_changed(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


@t.NoVTable
class QProgressBar:
    """QProgressBar 包装"""
    _ptr: QtProgressBarPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qprogressbar_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qprogressbar_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QProgressBar")

    def setValue(self, value: int):
        vqt6_qprogressbar_set_value(self._ptr, value)

    def value(self) -> int:
        return vqt6_qprogressbar_value(self._ptr)

    def setRange(self, min_val: int, max_val: int):
        vqt6_qprogressbar_set_range(self._ptr, min_val, max_val)

    def setMinimum(self, min_val: int):
        vqt6_qprogressbar_set_minimum(self._ptr, min_val)

    def setMaximum(self, max_val: int):
        vqt6_qprogressbar_set_maximum(self._ptr, max_val)

    def setFormat(self, format_str: str):
        qs: QtStringPtr = vqt6_qstring_create(format_str)
        vqt6_qprogressbar_set_format(self._ptr, qs)
        vqt6_qstring_free(qs)

    def setTextVisible(self, visible: int):
        vqt6_qprogressbar_set_text_visible(self._ptr, visible)

    def valueChanged(self, cb: bytes, data: bytes = 0):
        vqt6_qprogressbar_connect_value_changed(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


# ============================================================
# 文本：QTextEdit / QPlainTextEdit
# ============================================================
@t.NoVTable
class QTextEdit:
    """QTextEdit 包装"""
    _ptr: QtTextEditPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qtextedit_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qtextedit_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QTextEdit")

    def setPlainText(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qtextedit_set_plain_text(self._ptr, qs)
        vqt6_qstring_free(qs)

    def toPlainText(self) -> str:
        return _w_text_of(vqt6_qtextedit_to_plain_text(self._ptr))

    def setHtml(self, html: str):
        qs: QtStringPtr = vqt6_qstring_create(html)
        vqt6_qtextedit_set_html(self._ptr, qs)
        vqt6_qstring_free(qs)

    def append(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qtextedit_append(self._ptr, qs)
        vqt6_qstring_free(qs)

    def clear(self):
        vqt6_qtextedit_clear(self._ptr)

    def setReadOnly(self, ro: int):
        vqt6_qtextedit_set_read_only(self._ptr, ro)

    def isReadOnly(self) -> int:
        return vqt6_qtextedit_is_read_only(self._ptr)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


@t.NoVTable
class QPlainTextEdit:
    """QPlainTextEdit 包装"""
    _ptr: QtPlainTextEditPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qplaintextedit_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qplaintextedit_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QPlainTextEdit")

    def setPlainText(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qplaintextedit_set_plain_text(self._ptr, qs)
        vqt6_qstring_free(qs)

    def toPlainText(self) -> str:
        return _w_text_of(vqt6_qplaintextedit_to_plain_text(self._ptr))

    def append(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qplaintextedit_append(self._ptr, qs)
        vqt6_qstring_free(qs)

    def clear(self):
        vqt6_qplaintextedit_clear(self._ptr)

    def setReadOnly(self, ro: int):
        vqt6_qplaintextedit_set_read_only(self._ptr, ro)

    def lineCount(self) -> int:
        return vqt6_qplaintextedit_line_count(self._ptr)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


# ============================================================
# 列表：QListWidget / QTabWidget / QStackedWidget
# ============================================================
@t.NoVTable
class QListWidget:
    """QListWidget 包装"""
    _ptr: QtListWidgetPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qlistwidget_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qlistwidget_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QListWidget")

    def addItem(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qlistwidget_add_item(self._ptr, qs)
        vqt6_qstring_free(qs)

    def insertItem(self, row: int, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qlistwidget_insert_item(self._ptr, row, qs)
        vqt6_qstring_free(qs)

    def clear(self):
        vqt6_qlistwidget_clear(self._ptr)

    def count(self) -> int:
        return vqt6_qlistwidget_count(self._ptr)

    def currentRow(self) -> int:
        return vqt6_qlistwidget_current_row(self._ptr)

    def setCurrentRow(self, row: int):
        vqt6_qlistwidget_set_current_row(self._ptr, row)

    def currentItemText(self) -> str:
        return _w_text_of(vqt6_qlistwidget_current_item_text(self._ptr))

    def itemText(self, row: int) -> str:
        return _w_text_of(vqt6_qlistwidget_item_text(self._ptr, row))

    def setItemText(self, row: int, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qlistwidget_set_item_text(self._ptr, row, qs)
        vqt6_qstring_free(qs)

    def currentRowChanged(self, cb: bytes, data: bytes = 0):
        vqt6_qlistwidget_connect_current_row_changed(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


@t.NoVTable
class QTreeWidgetItem:
    """QTreeWidgetItem 包装（树节点，勾选态 0=未选 2=选中）"""
    _ptr: QtTreeWidgetItemPtr

    def __init__(self, text: str = ""):
        qs: QtStringPtr = vqt6_qstring_create(text)
        self._ptr = vqt6_qtreewidgetitem_create(qs)
        vqt6_qstring_free(qs)
        if self._ptr is None:
            raise RuntimeError("Failed to create QTreeWidgetItem")

    def setText(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qtreewidgetitem_set_text(self._ptr, qs)
        vqt6_qstring_free(qs)

    def text(self) -> str:
        return _w_text_of(vqt6_qtreewidgetitem_text(self._ptr))

    def addChild(self, child: "QTreeWidgetItem"):
        vqt6_qtreewidgetitem_add_child(self._ptr, child._ptr)

    def childCount(self) -> int:
        return vqt6_qtreewidgetitem_child_count(self._ptr)

    def child(self, index: int) -> "QTreeWidgetItem":
        it = QTreeWidgetItem()
        it._ptr = vqt6_qtreewidgetitem_child(self._ptr, index)
        return it

    def setCheckable(self, checkable: int):
        vqt6_qtreewidgetitem_set_checkable(self._ptr, checkable)

    def setChecked(self, checked: int):
        if checked != 0:
            vqt6_qtreewidgetitem_set_check_state(self._ptr, 2)
        else:
            vqt6_qtreewidgetitem_set_check_state(self._ptr, 0)

    def isChecked(self) -> int:
        return vqt6_qtreewidgetitem_check_state(self._ptr)

    def setSize(self, mb: int):
        """把磁盘占用(MB)存到节点 UserRole（统计用）"""
        vqt6_qtreewidgetitem_set_data_int(self._ptr, mb)

    def setExpanded(self, expanded: int):
        vqt6_qtreewidgetitem_set_expanded(self._ptr, expanded)

    def isExpanded(self) -> int:
        return vqt6_qtreewidgetitem_is_expanded(self._ptr)


@t.NoVTable
class QTreeWidget:
    """QTreeWidget 包装"""
    _ptr: QtTreeWidgetPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qtreewidget_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qtreewidget_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QTreeWidget")

    def addTopLevelItem(self, item: "QTreeWidgetItem"):
        vqt6_qtreewidget_add_top_level_item(self._ptr, item._ptr)

    def insertTopLevelItem(self, index: int, item: "QTreeWidgetItem"):
        vqt6_qtreewidget_insert_top_level_item(self._ptr, index, item._ptr)

    def topLevelItemCount(self) -> int:
        return vqt6_qtreewidget_top_level_item_count(self._ptr)

    def topLevelItem(self, index: int) -> "QTreeWidgetItem":
        it = QTreeWidgetItem()
        it._ptr = vqt6_qtreewidget_top_level_item(self._ptr, index)
        return it

    def currentItem(self) -> "QTreeWidgetItem":
        it = QTreeWidgetItem()
        it._ptr = vqt6_qtreewidget_current_item(self._ptr)
        return it

    def expandAll(self):
        vqt6_qtreewidget_expand_all(self._ptr)

    def collapseAll(self):
        vqt6_qtreewidget_collapse_all(self._ptr)

    def setHeaderHidden(self, hidden: int):
        vqt6_qtreewidget_set_header_hidden(self._ptr, hidden)

    def setColumnCount(self, count: int):
        vqt6_qtreewidget_set_column_count(self._ptr, count)

    def setItemExpanded(self, item: "QTreeWidgetItem", expanded: int):
        vqt6_qtreewidget_set_item_expanded(self._ptr, item._ptr, expanded)

    def itemChanged(self, cb: bytes, data: bytes = 0):
        vqt6_qtreewidget_connect_item_changed(self._ptr, cb, data)

    def itemClicked(self, cb: bytes, data: bytes = 0):
        vqt6_qtreewidget_connect_item_clicked(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


@t.NoVTable
class QTabWidget:
    """QTabWidget 包装"""
    _ptr: QtTabWidgetPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qtabwidget_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qtabwidget_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QTabWidget")

    def addTab(self, w: t.CPtr, label: str) -> int:
        qs: QtStringPtr = vqt6_qstring_create(label)
        idx: int = vqt6_qtabwidget_add_tab(self._ptr, w, qs)
        vqt6_qstring_free(qs)
        return idx

    def removeTab(self, index: int):
        vqt6_qtabwidget_remove_tab(self._ptr, index)

    def count(self) -> int:
        return vqt6_qtabwidget_count(self._ptr)

    def currentIndex(self) -> int:
        return vqt6_qtabwidget_current_index(self._ptr)

    def setCurrentIndex(self, index: int):
        vqt6_qtabwidget_set_current_index(self._ptr, index)

    def tabText(self, index: int) -> str:
        return _w_text_of(vqt6_qtabwidget_tab_text(self._ptr, index))

    def setTabText(self, index: int, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qtabwidget_set_tab_text(self._ptr, index, qs)
        vqt6_qstring_free(qs)

    def currentChanged(self, cb: bytes, data: bytes = 0):
        vqt6_qtabwidget_connect_current_changed(self._ptr, cb, data)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


@t.NoVTable
class QStackedWidget:
    """QStackedWidget 包装"""
    _ptr: QtStackedWidgetPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qstackedwidget_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qstackedwidget_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QStackedWidget")

    def addWidget(self, w: t.CPtr) -> int:
        return vqt6_qstackedwidget_add_widget(self._ptr, w)

    def removeWidget(self, w: t.CPtr):
        vqt6_qstackedwidget_remove_widget(self._ptr, w)

    def count(self) -> int:
        return vqt6_qstackedwidget_count(self._ptr)

    def currentIndex(self) -> int:
        return vqt6_qstackedwidget_current_index(self._ptr)

    def setCurrentIndex(self, index: int):
        vqt6_qstackedwidget_set_current_index(self._ptr, index)

    def currentWidget(self) -> t.CPtr:
        return vqt6_qstackedwidget_current_widget(self._ptr)

    def show(self):
        _w_show(self._ptr)

    def hide(self):
        _w_hide(self._ptr)

    def setGeometry(self, x: int, y: int, w: int, h: int):
        _w_set_geometry(self._ptr, x, y, w, h)

    def resize(self, w: int, h: int):
        _w_resize(self._ptr, w, h)

    def move(self, x: int, y: int):
        _w_move(self._ptr, x, y)

    def setEnabled(self, enabled: int):
        _w_set_enabled(self._ptr, enabled)


# ============================================================
# 布局：QHBoxLayout / QVBoxLayout / QGridLayout
# ============================================================
@t.NoVTable
class QHBoxLayout:
    """QHBoxLayout 包装（addWidget 传控件 ._ptr）"""
    _ptr: QtBoxLayoutPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qhboxlayout_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qhboxlayout_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QHBoxLayout")

    def addWidget(self, widget: t.CPtr):
        vqt6_qlayout_add_widget(self._ptr, widget)

    def removeWidget(self, widget: t.CPtr):
        vqt6_qlayout_remove_widget(self._ptr, widget)

    def addLayout(self, child: t.CPtr):
        vqt6_qhboxlayout_add_layout(self._ptr, child)

    def addStretch(self, stretch: int):
        vqt6_qhboxlayout_add_stretch(self._ptr, stretch)

    def addSpacing(self, size: int):
        vqt6_qhboxlayout_add_spacing(self._ptr, size)

    def setSpacing(self, spacing: int):
        vqt6_qlayout_set_spacing(self._ptr, spacing)

    def setContentsMargins(self, left: int, top: int, right: int, bottom: int):
        vqt6_qlayout_set_contents_margins(self._ptr, left, top, right, bottom)


@t.NoVTable
class QVBoxLayout:
    """QVBoxLayout 包装（addWidget 传控件 ._ptr）"""
    _ptr: QtBoxLayoutPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qvboxlayout_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qvboxlayout_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QVBoxLayout")

    def addWidget(self, widget: t.CPtr):
        vqt6_qlayout_add_widget(self._ptr, widget)

    def removeWidget(self, widget: t.CPtr):
        vqt6_qlayout_remove_widget(self._ptr, widget)

    def addLayout(self, child: t.CPtr):
        vqt6_qvboxlayout_add_layout(self._ptr, child)

    def addStretch(self, stretch: int):
        vqt6_qvboxlayout_add_stretch(self._ptr, stretch)

    def addSpacing(self, size: int):
        vqt6_qvboxlayout_add_spacing(self._ptr, size)

    def setSpacing(self, spacing: int):
        vqt6_qlayout_set_spacing(self._ptr, spacing)

    def setContentsMargins(self, left: int, top: int, right: int, bottom: int):
        vqt6_qlayout_set_contents_margins(self._ptr, left, top, right, bottom)


@t.NoVTable
class QGridLayout:
    """QGridLayout 包装（addWidget 传控件 ._ptr）"""
    _ptr: QtGridLayoutPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qgridlayout_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qgridlayout_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QGridLayout")

    def addWidget(self, widget: t.CPtr, row: int, col: int):
        vqt6_qgridlayout_add_widget(self._ptr, widget, row, col)

    def addWidgetWithSpan(self, widget: t.CPtr, row: int, col: int, row_span: int, col_span: int):
        vqt6_qgridlayout_add_widget_with_span(self._ptr, widget, row, col, row_span, col_span)

    def setSpacing(self, spacing: int):
        vqt6_qlayout_set_spacing(self._ptr, spacing)

    def setContentsMargins(self, left: int, top: int, right: int, bottom: int):
        vqt6_qlayout_set_contents_margins(self._ptr, left, top, right, bottom)


# ============================================================
# 对话框：QMessageBox / QFileDialog（静态方法）
# ============================================================
@t.NoVTable
class QMessageBox:
    """QMessageBox 静态对话框"""
    _ptr: QtMessageBoxPtr

    @staticmethod
    def information(parent: "QWidget | None", title: str, text: str, buttons: int = QT_OK) -> int:
        qs_title: QtStringPtr = vqt6_qstring_create(title)
        qs_text: QtStringPtr = vqt6_qstring_create(text)
        parent_ptr: t.CPtr = None
        if parent is not None and parent._ptr is not None:
            parent_ptr = parent._ptr
        r: int = vqt6_qmessagebox_information(parent_ptr, qs_title, qs_text, buttons)
        vqt6_qstring_free(qs_title)
        vqt6_qstring_free(qs_text)
        return r

    @staticmethod
    def warning(parent: "QWidget | None", title: str, text: str, buttons: int = QT_OK) -> int:
        qs_title: QtStringPtr = vqt6_qstring_create(title)
        qs_text: QtStringPtr = vqt6_qstring_create(text)
        parent_ptr: t.CPtr = None
        if parent is not None and parent._ptr is not None:
            parent_ptr = parent._ptr
        r: int = vqt6_qmessagebox_warning(parent_ptr, qs_title, qs_text, buttons)
        vqt6_qstring_free(qs_title)
        vqt6_qstring_free(qs_text)
        return r

    @staticmethod
    def critical(parent: "QWidget | None", title: str, text: str, buttons: int = QT_OK) -> int:
        qs_title: QtStringPtr = vqt6_qstring_create(title)
        qs_text: QtStringPtr = vqt6_qstring_create(text)
        parent_ptr: t.CPtr = None
        if parent is not None and parent._ptr is not None:
            parent_ptr = parent._ptr
        r: int = vqt6_qmessagebox_critical(parent_ptr, qs_title, qs_text, buttons)
        vqt6_qstring_free(qs_title)
        vqt6_qstring_free(qs_text)
        return r

    @staticmethod
    def question(parent: "QWidget | None", title: str, text: str, buttons: int = QT_OK | QT_CANCEL) -> int:
        qs_title: QtStringPtr = vqt6_qstring_create(title)
        qs_text: QtStringPtr = vqt6_qstring_create(text)
        parent_ptr: t.CPtr = None
        if parent is not None and parent._ptr is not None:
            parent_ptr = parent._ptr
        r: int = vqt6_qmessagebox_question(parent_ptr, qs_title, qs_text, buttons)
        vqt6_qstring_free(qs_title)
        vqt6_qstring_free(qs_text)
        return r

    @staticmethod
    def about(parent: "QWidget | None", title: str, text: str):
        qs_title: QtStringPtr = vqt6_qstring_create(title)
        qs_text: QtStringPtr = vqt6_qstring_create(text)
        parent_ptr: t.CPtr = None
        if parent is not None and parent._ptr is not None:
            parent_ptr = parent._ptr
        vqt6_qmessagebox_about(parent_ptr, qs_title, qs_text)
        vqt6_qstring_free(qs_title)
        vqt6_qstring_free(qs_text)


@t.NoVTable
class QFileDialog:
    """QFileDialog 静态对话框"""
    _ptr: QtFileDialogPtr

    @staticmethod
    def getOpenFileName(parent: "QWidget | None", caption: str, directory: str, filter_str: str = "") -> str:
        qs_caption: QtStringPtr = vqt6_qstring_create(caption)
        qs_dir: QtStringPtr = vqt6_qstring_create(directory)
        qs_filter: QtStringPtr = vqt6_qstring_create(filter_str)
        parent_ptr: t.CPtr = None
        if parent is not None and parent._ptr is not None:
            parent_ptr = parent._ptr
        result: QtStringPtr = vqt6_qfiledialog_get_open_file_name(parent_ptr, qs_caption, qs_dir, qs_filter)
        vqt6_qstring_free(qs_caption)
        vqt6_qstring_free(qs_dir)
        vqt6_qstring_free(qs_filter)
        return _w_text_of(result)

    @staticmethod
    def getSaveFileName(parent: "QWidget | None", caption: str, directory: str, filter_str: str = "") -> str:
        qs_caption: QtStringPtr = vqt6_qstring_create(caption)
        qs_dir: QtStringPtr = vqt6_qstring_create(directory)
        qs_filter: QtStringPtr = vqt6_qstring_create(filter_str)
        parent_ptr: t.CPtr = None
        if parent is not None and parent._ptr is not None:
            parent_ptr = parent._ptr
        result: QtStringPtr = vqt6_qfiledialog_get_save_file_name(parent_ptr, qs_caption, qs_dir, qs_filter)
        vqt6_qstring_free(qs_caption)
        vqt6_qstring_free(qs_dir)
        vqt6_qstring_free(qs_filter)
        return _w_text_of(result)

    @staticmethod
    def getExistingDirectory(parent: "QWidget | None", caption: str, directory: str) -> str:
        qs_caption: QtStringPtr = vqt6_qstring_create(caption)
        qs_dir: QtStringPtr = vqt6_qstring_create(directory)
        parent_ptr: t.CPtr = None
        if parent is not None and parent._ptr is not None:
            parent_ptr = parent._ptr
        result: QtStringPtr = vqt6_qfiledialog_get_existing_directory(parent_ptr, qs_caption, qs_dir)
        vqt6_qstring_free(qs_caption)
        vqt6_qstring_free(qs_dir)
        return _w_text_of(result)


# ============================================================
# 定时器：QTimer
# ============================================================
@t.NoVTable
class QTimer:
    """QTimer 包装"""
    _ptr: QtTimerPtr

    def __init__(self):
        self._ptr = vqt6_qtimer_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QTimer")

    def start(self, interval_ms: int):
        vqt6_qtimer_start(self._ptr, interval_ms)

    def stop(self):
        vqt6_qtimer_stop(self._ptr)

    def setInterval(self, interval_ms: int):
        vqt6_qtimer_set_interval(self._ptr, interval_ms)

    def interval(self) -> int:
        return vqt6_qtimer_interval(self._ptr)

    def setSingleShot(self, single_shot: int):
        vqt6_qtimer_set_single_shot(self._ptr, single_shot)

    def isActive(self) -> int:
        return vqt6_qtimer_is_active(self._ptr)

    def timeout(self, cb: bytes, data: bytes = 0):
        vqt6_qtimer_connect_timeout(self._ptr, cb, data)


# ============================================================
# 菜单：QMenuBar / QMenu / QAction / QStatusBar
# ============================================================
@t.NoVTable
class QMenuBar:
    """QMenuBar 包装"""
    _ptr: QtMenuBarPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qmenubar_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qmenubar_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QMenuBar")

    def addMenu(self, title: str) -> "QMenu":
        qs: QtStringPtr = vqt6_qstring_create(title)
        mp: QtMenuPtr = vqt6_qmenubar_add_menu(self._ptr, qs)
        vqt6_qstring_free(qs)
        m = QMenu()
        m._ptr = mp
        return m

    def addAction(self, action: t.CPtr):
        vqt6_qmenubar_add_action(self._ptr, action)

    def clear(self):
        vqt6_qmenubar_clear(self._ptr)


@t.NoVTable
class QMenu:
    """QMenu 包装"""
    _ptr: QtMenuPtr

    def __init__(self, title: str = ""):
        if title != "":
            qs: QtStringPtr = vqt6_qstring_create(title)
            self._ptr = vqt6_qmenu_create_with_title(qs)
            vqt6_qstring_free(qs)
        else:
            self._ptr = vqt6_qmenu_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QMenu")

    def addAction(self, action: t.CPtr):
        vqt6_qmenu_add_action(self._ptr, action)

    def addActionWithText(self, text: str) -> "QAction":
        qs: QtStringPtr = vqt6_qstring_create(text)
        ap: QtActionPtr = vqt6_qmenu_add_action_with_text(self._ptr, qs)
        vqt6_qstring_free(qs)
        a = QAction()
        a._ptr = ap
        return a

    def addMenu(self, title: str) -> "QMenu":
        qs: QtStringPtr = vqt6_qstring_create(title)
        mp: QtMenuPtr = vqt6_qmenu_add_menu(self._ptr, qs)
        vqt6_qstring_free(qs)
        m = QMenu()
        m._ptr = mp
        return m

    def addSeparator(self):
        vqt6_qmenu_add_separator(self._ptr)

    def setTitle(self, title: str):
        qs: QtStringPtr = vqt6_qstring_create(title)
        vqt6_qmenu_set_title(self._ptr, qs)
        vqt6_qstring_free(qs)

    def clear(self):
        vqt6_qmenu_clear(self._ptr)


@t.NoVTable
class QAction:
    """QAction 包装"""
    _ptr: QtActionPtr

    def __init__(self, text: str = ""):
        if text != "":
            qs: QtStringPtr = vqt6_qstring_create(text)
            self._ptr = vqt6_qaction_create_with_text(qs)
            vqt6_qstring_free(qs)
        else:
            self._ptr = vqt6_qaction_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QAction")

    def setText(self, text: str):
        qs: QtStringPtr = vqt6_qstring_create(text)
        vqt6_qaction_set_text(self._ptr, qs)
        vqt6_qstring_free(qs)

    def text(self) -> str:
        return _w_text_of(vqt6_qaction_text(self._ptr))

    def setShortcut(self, key_seq: str):
        qs: QtStringPtr = vqt6_qstring_create(key_seq)
        vqt6_qaction_set_shortcut(self._ptr, qs)
        vqt6_qstring_free(qs)

    def setCheckable(self, checkable: int):
        vqt6_qaction_set_checkable(self._ptr, checkable)

    def isCheckable(self) -> int:
        return vqt6_qaction_is_checkable(self._ptr)

    def setChecked(self, checked: int):
        vqt6_qaction_set_checked(self._ptr, checked)

    def isChecked(self) -> int:
        return vqt6_qaction_is_checked(self._ptr)

    def setEnabled(self, enabled: int):
        vqt6_qaction_set_enabled(self._ptr, enabled)

    def isEnabled(self) -> int:
        return vqt6_qaction_is_enabled(self._ptr)

    def trigger(self):
        vqt6_qaction_trigger(self._ptr)

    def triggered(self, cb: bytes, data: bytes = 0):
        vqt6_qaction_connect_triggered(self._ptr, cb, data)


@t.NoVTable
class QStatusBar:
    """QStatusBar 包装"""
    _ptr: QtStatusBarPtr

    def __init__(self, parent: "QWidget | None" = None):
        if parent is not None and parent._ptr is not None:
            self._ptr = vqt6_qstatusbar_create_with_parent(parent._ptr)
        else:
            self._ptr = vqt6_qstatusbar_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QStatusBar")

    def showMessage(self, message: str, timeout_ms: int = 0):
        qs: QtStringPtr = vqt6_qstring_create(message)
        vqt6_qstatusbar_show_message(self._ptr, qs, timeout_ms)
        vqt6_qstring_free(qs)

    def clearMessage(self):
        vqt6_qstatusbar_clear_message(self._ptr)

    def currentMessage(self) -> str:
        return _w_text_of(vqt6_qstatusbar_current_message(self._ptr))

    def addWidget(self, w: t.CPtr, stretch: int = 0):
        vqt6_qstatusbar_add_widget(self._ptr, w, stretch)


# ============================================================
# 绘图基础：QColor / QFont
# ============================================================
@t.NoVTable
class QColor:
    """QColor 包装"""
    _ptr: QtColorPtr

    def __init__(self, r: int, g: int, b: int, a: int = 255):
        self._ptr = vqt6_qcolor_create_rgba(r, g, b, a)
        if self._ptr is None:
            raise RuntimeError("Failed to create QColor")

    def red(self) -> int:
        return vqt6_qcolor_red(self._ptr)

    def green(self) -> int:
        return vqt6_qcolor_green(self._ptr)

    def blue(self) -> int:
        return vqt6_qcolor_blue(self._ptr)

    def alpha(self) -> int:
        return vqt6_qcolor_alpha(self._ptr)


@t.NoVTable
class QFont:
    """QFont 包装"""
    _ptr: QtFontPtr

    def __init__(self, family: str = "", point_size: int = 0):
        if family != "":
            qs: QtStringPtr = vqt6_qstring_create(family)
            if point_size > 0:
                self._ptr = vqt6_qfont_create_with_family_size(qs, point_size)
            else:
                self._ptr = vqt6_qfont_create_with_family(qs)
            vqt6_qstring_free(qs)
        else:
            self._ptr = vqt6_qfont_create()
        if self._ptr is None:
            raise RuntimeError("Failed to create QFont")

    def setPointSize(self, size: int):
        vqt6_qfont_set_point_size(self._ptr, size)

    def setPixelSize(self, size: int):
        vqt6_qfont_set_pixel_size(self._ptr, size)

    def setBold(self, bold: int):
        vqt6_qfont_set_bold(self._ptr, bold)

    def setItalic(self, italic: int):
        vqt6_qfont_set_italic(self._ptr, italic)

    def setUnderline(self, underline: int):
        vqt6_qfont_set_underline(self._ptr, underline)


# ============================================================
# 模块导出
# ============================================================
__all__ = [
    # 高层类
    "QApplication", "QWidget", "QLabel", "QPushButton",
    "QMainWindow", "QDialog",
    "QLineEdit", "QCheckBox", "QRadioButton",
    "QComboBox", "QSlider", "QSpinBox", "QProgressBar",
    "QTextEdit", "QPlainTextEdit", "QListWidget",
    "QTreeWidget", "QTreeWidgetItem",
    "QTabWidget", "QStackedWidget",
    "QHBoxLayout", "QVBoxLayout", "QGridLayout",
    "QMessageBox", "QFileDialog", "QTimer",
    "QMenuBar", "QMenu", "QAction", "QStatusBar",
    "QColor", "QFont",
    # 类型
    "QtObjectPtr", "QtStringPtr", "QtByteArrayPtr", "QtWidgetPtr", "QtAppPtr",
    "QtLabelPtr", "QtPushButtonPtr",
    "QtTreeWidgetPtr", "QtTreeWidgetItemPtr",
    "QtColorPtr", "QtFontPtr", "QtPixmapPtr", "QtImagePtr", "QtPainterPtr",
    "QtTcpSocketPtr", "QtHostAddressPtr", "QtNetworkRequestPtr", "QtNetworkReplyPtr",
    # 常量
    "QT_KEY_ESCAPE", "QT_KEY_RETURN", "QT_KEY_A", "QT_KEY_Z",
    "QT_LEFT_BUTTON", "QT_RIGHT_BUTTON", "QT_MID_BUTTON",
    "QT_HORIZONTAL", "QT_VERTICAL",
    "QT_ALIGN_LEFT", "QT_ALIGN_CENTER", "QT_ALIGN_RIGHT",
    "QT_PORT_HTTP", "QT_PORT_HTTPS", "QT_PORT_FTP",
    "QT_OK", "QT_CANCEL", "QT_YES", "QT_NO", "QT_CLOSE",
]