2115 lines
69 KiB
Plaintext
2115 lines
69 KiB
Plaintext
# ============================================================
|
|
# vqt6 - Viper's Qt6 binding package
|
|
#
|
|
# Public Pythonic API (built on the C bridge layer)
|
|
# Usage:
|
|
# 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 *
|
|
|
|
|
|
# ============================================================
|
|
# High-level API classes (Pythonic wrappers over opaque pointers)
|
|
#
|
|
# Every wrapper defines __new__ to heap-allocate its shell via stdlib.malloc
|
|
# ({ _ptr }, 8 bytes) so _ptr stays valid across frames and modules.
|
|
# ============================================================
|
|
|
|
# ============================================================
|
|
# Module-level helpers: base QWidget operations (shared by widget classes)
|
|
# ============================================================
|
|
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 (copied into a malloc buffer)."""
|
|
buf: bytes = stdlib.malloc(1024)
|
|
vqt6_qstring_to_utf8(qstr, buf, 1024)
|
|
s: str = buf
|
|
vqt6_qstring_free(qstr)
|
|
return s
|
|
|
|
|
|
# ============================================================
|
|
# Tree widget statistics helpers (return int to avoid cross-module FFI ptr returns)
|
|
# Leaf check state: 0=unchecked 1=partial 2=checked
|
|
# ============================================================
|
|
def qtree_checked_count(tw: QtTreeWidgetPtr) -> int:
|
|
"""Count checked leaf nodes."""
|
|
n: int = 0
|
|
top_n: int = vqt6_qtreewidget_top_level_item_count(tw)
|
|
for gi in range(int(top_n)):
|
|
g: QtTreeWidgetItemPtr = vqt6_qtreewidget_top_level_item(tw, gi)
|
|
cn: int = vqt6_qtreewidgetitem_child_count(g)
|
|
for ci in range(int(cn)):
|
|
it: QtTreeWidgetItemPtr = vqt6_qtreewidgetitem_child(g, ci)
|
|
if vqt6_qtreewidgetitem_check_state(it) == 2:
|
|
n += 1
|
|
return n
|
|
|
|
|
|
def qtree_checked_size(tw: QtTreeWidgetPtr) -> int:
|
|
"""Sum disk usage (MB) of checked leaf nodes."""
|
|
mb: int = 0
|
|
top_n: int = vqt6_qtreewidget_top_level_item_count(tw)
|
|
for gi in range(int(top_n)):
|
|
g: QtTreeWidgetItemPtr = vqt6_qtreewidget_top_level_item(tw, gi)
|
|
cn: int = vqt6_qtreewidgetitem_child_count(g)
|
|
for ci in range(int(cn)):
|
|
it: QtTreeWidgetItemPtr = vqt6_qtreewidgetitem_child(g, ci)
|
|
if vqt6_qtreewidgetitem_check_state(it) == 2:
|
|
mb += vqt6_qtreewidgetitem_data_int(it)
|
|
return mb
|
|
|
|
|
|
def qtree_click_toggle(tw: QtTreeWidgetPtr):
|
|
"""Toggle expansion of the current row when it has children."""
|
|
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)
|
|
|
|
|
|
novirtual class QApplication:
|
|
"""QApplication wrapper (opaque pointer)."""
|
|
_ptr: QtAppPtr
|
|
|
|
def __new__(self, argv: list[str]*) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
def __init__(self, argv: list[str]*):
|
|
# Convert argv into an argc/argv array.
|
|
argc: int = 1
|
|
# Viper argv is a c_char_p pointer array; an empty argv avoids C ABI complexity.
|
|
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)
|
|
|
|
def set_font_family(self, family: str):
|
|
"""Set the application-wide font family (global).
|
|
|
|
Must be called before creating any widget; it also reaches Qt Charts text
|
|
(titles/legend/axis labels) that stylesheets cannot.
|
|
"""
|
|
vqt6_qapplication_set_font_family_utf8(self._ptr, family)
|
|
|
|
|
|
novirtual class QWidget:
|
|
"""QWidget wrapper."""
|
|
_ptr: QtWidgetPtr
|
|
|
|
def __new__(self, parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
|
|
novirtual class QLabel:
|
|
"""QLabel wrapper."""
|
|
_ptr: QtLabelPtr
|
|
|
|
def __new__(self, text: str = "", parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
|
|
novirtual class QPushButton:
|
|
"""QPushButton wrapper."""
|
|
_ptr: QtPushButtonPtr
|
|
|
|
def __new__(self, text: str = "", parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
# Callbacks: cb is a Viper module-level function 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)
|
|
|
|
|
|
# ============================================================
|
|
# Menus: QAction / QMenu / QMenuBar / QStatusBar
|
|
#
|
|
# Defined before QMainWindow so return annotations need no forward reference;
|
|
# menuBar/statusBar return raw pointers since wrapper-value returns don't cross modules.
|
|
# ============================================================
|
|
novirtual class QAction:
|
|
"""QAction wrapper."""
|
|
_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)
|
|
|
|
|
|
novirtual class QMenu:
|
|
"""QMenu wrapper."""
|
|
_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)
|
|
|
|
|
|
novirtual class QMenuBar:
|
|
"""QMenuBar wrapper."""
|
|
_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)
|
|
|
|
|
|
novirtual class QStatusBar:
|
|
"""QStatusBar wrapper."""
|
|
_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)
|
|
|
|
|
|
# ============================================================
|
|
# Window: QMainWindow (defined after the QMenuBar / QStatusBar it depends on).
|
|
# ============================================================
|
|
novirtual class QMainWindow:
|
|
"""QMainWindow wrapper."""
|
|
_ptr: QtMainWindowPtr
|
|
|
|
def __new__(self, parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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) -> QtMenuBarPtr:
|
|
"""Return the window's own menu bar as a raw pointer (no wrapper created)."""
|
|
return vqt6_qmainwindow_menu_bar(self._ptr)
|
|
|
|
def setMenuBar(self, mb: t.CPtr):
|
|
vqt6_qmainwindow_set_menu_bar(self._ptr, mb)
|
|
|
|
def statusBar(self) -> QtStatusBarPtr:
|
|
"""Return the window's own status bar as a raw pointer (no wrapper created)."""
|
|
return vqt6_qmainwindow_status_bar(self._ptr)
|
|
|
|
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 setStyleSheet(self, qss: str):
|
|
vqt6_qwidget_set_stylesheet_utf8(self._ptr, qss)
|
|
|
|
def setEnabled(self, enabled: int):
|
|
_w_set_enabled(self._ptr, enabled)
|
|
|
|
def setToolTip(self, tip: str):
|
|
_w_set_tool_tip(self._ptr, tip)
|
|
|
|
|
|
novirtual class QDialog:
|
|
"""QDialog wrapper."""
|
|
_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)
|
|
|
|
|
|
# ============================================================
|
|
# Input widgets: QLineEdit / QCheckBox / QRadioButton
|
|
# ============================================================
|
|
novirtual class QLineEdit:
|
|
"""QLineEdit wrapper."""
|
|
_ptr: QtLineEditPtr
|
|
|
|
def __new__(self, text: str = "", parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
|
|
novirtual class QCheckBox:
|
|
"""QCheckBox wrapper."""
|
|
_ptr: QtCheckBoxPtr
|
|
|
|
def __new__(self, text: str = "", parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
|
|
novirtual class QRadioButton:
|
|
"""QRadioButton wrapper."""
|
|
_ptr: QtRadioButtonPtr
|
|
|
|
def __new__(self, text: str = "", parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
|
|
# ============================================================
|
|
# Selection widgets: QComboBox / QSlider / QSpinBox / QProgressBar
|
|
# ============================================================
|
|
novirtual class QComboBox:
|
|
"""QComboBox wrapper."""
|
|
_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)
|
|
|
|
|
|
novirtual class QSlider:
|
|
"""QSlider wrapper."""
|
|
_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)
|
|
|
|
|
|
novirtual class QSpinBox:
|
|
"""QSpinBox wrapper."""
|
|
_ptr: QtSpinBoxPtr
|
|
|
|
def __new__(self, parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
|
|
novirtual class QProgressBar:
|
|
"""QProgressBar wrapper."""
|
|
_ptr: QtProgressBarPtr
|
|
|
|
def __new__(self, parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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 setStyleSheet(self, qss: str):
|
|
vqt6_qwidget_set_stylesheet_utf8(self._ptr, qss)
|
|
|
|
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)
|
|
|
|
|
|
# ============================================================
|
|
# Text: QTextEdit / QPlainTextEdit
|
|
# ============================================================
|
|
novirtual class QTextEdit:
|
|
"""QTextEdit wrapper."""
|
|
_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)
|
|
|
|
|
|
novirtual class QPlainTextEdit:
|
|
"""QPlainTextEdit wrapper."""
|
|
_ptr: QtPlainTextEditPtr
|
|
|
|
def __new__(self, parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
|
|
# ============================================================
|
|
# Lists: QListWidget / QTabWidget / QStackedWidget
|
|
# ============================================================
|
|
novirtual class QListWidget:
|
|
"""QListWidget wrapper."""
|
|
_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 addBubble(self, text: str, qss: str, right_align: int = 0,
|
|
max_bubble_w: int = 420, hpad: int = 28, vpad: int = 16):
|
|
"""Append a chat bubble (WeChat/QQ style, right=self / left=peer).
|
|
|
|
qss: bubble QLabel style; right_align: 1=right(self)/0=left; max_bubble_w:
|
|
max width; hpad/vpad: horizontal/vertical QSS padding totals for sizing.
|
|
"""
|
|
tqs: QtStringPtr = vqt6_qstring_create(text)
|
|
qqs: QtStringPtr = vqt6_qstring_create(qss)
|
|
vqt6_qlistwidget_add_bubble(self._ptr, tqs, qqs, right_align, max_bubble_w, hpad, vpad)
|
|
vqt6_qstring_free(qqs)
|
|
vqt6_qstring_free(tqs)
|
|
|
|
def replaceLastBubble(self, text: str, qss: str, right_align: int = 0,
|
|
max_bubble_w: int = 420, hpad: int = 28, vpad: int = 16):
|
|
"""Remove the last bubble and rebuild it from new text (for streaming; params as addBubble)."""
|
|
tqs: QtStringPtr = vqt6_qstring_create(text)
|
|
qqs: QtStringPtr = vqt6_qstring_create(qss)
|
|
vqt6_qlistwidget_replace_last_bubble(self._ptr, tqs, qqs, right_align,
|
|
max_bubble_w, hpad, vpad)
|
|
vqt6_qstring_free(qqs)
|
|
vqt6_qstring_free(tqs)
|
|
|
|
def scrollToBottom(self):
|
|
vqt6_qlistwidget_scroll_to_bottom(self._ptr)
|
|
|
|
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)
|
|
|
|
|
|
novirtual class QTreeWidgetItem:
|
|
"""QTreeWidgetItem wrapper (tree node; check state 0=unchecked 2=checked)."""
|
|
_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):
|
|
"""Store disk usage (MB) in the node's UserRole (for statistics)."""
|
|
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)
|
|
|
|
|
|
novirtual class QTreeWidget:
|
|
"""QTreeWidget wrapper."""
|
|
_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)
|
|
|
|
|
|
novirtual class QTabWidget:
|
|
"""QTabWidget wrapper."""
|
|
_ptr: QtTabWidgetPtr
|
|
|
|
def __new__(self, parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
|
|
novirtual class QStackedWidget:
|
|
"""QStackedWidget wrapper."""
|
|
_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)
|
|
|
|
|
|
# ============================================================
|
|
# Layouts: QHBoxLayout / QVBoxLayout / QGridLayout
|
|
# ============================================================
|
|
novirtual class QHBoxLayout:
|
|
"""QHBoxLayout wrapper (pass the widget's ._ptr to addWidget)."""
|
|
_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)
|
|
|
|
|
|
novirtual class QVBoxLayout:
|
|
"""QVBoxLayout wrapper (pass the widget's ._ptr to addWidget)."""
|
|
_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)
|
|
|
|
|
|
novirtual class QGridLayout:
|
|
"""QGridLayout wrapper (pass the widget's ._ptr to addWidget)."""
|
|
_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)
|
|
|
|
|
|
# ============================================================
|
|
# Dialogs: QMessageBox / QFileDialog (static methods)
|
|
# ============================================================
|
|
novirtual class QMessageBox:
|
|
"""QMessageBox static dialog wrapper."""
|
|
_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)
|
|
|
|
|
|
novirtual class QFileDialog:
|
|
"""QFileDialog static dialog wrapper."""
|
|
_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)
|
|
|
|
|
|
# ============================================================
|
|
# Timer: QTimer
|
|
# ============================================================
|
|
novirtual class QTimer:
|
|
"""QTimer wrapper."""
|
|
_ptr: QtTimerPtr
|
|
|
|
def __new__(self) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
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)
|
|
|
|
|
|
# ============================================================
|
|
# Drawing basics: QColor / QFont
|
|
# ============================================================
|
|
novirtual class QColor:
|
|
"""QColor wrapper."""
|
|
_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)
|
|
|
|
|
|
novirtual class QFont:
|
|
"""QFont wrapper."""
|
|
_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)
|
|
|
|
|
|
# ============================================================
|
|
# Clipboard (copying links, etc.)
|
|
# ============================================================
|
|
def clipboard_set_text(text: str):
|
|
"""Write text to the system clipboard."""
|
|
vqt6_clipboard_set_text_utf8(text)
|
|
|
|
|
|
def clipboard_text() -> str:
|
|
"""Read text from the system clipboard."""
|
|
buf: bytes = stdlib.malloc(4096)
|
|
vqt6_clipboard_text_utf8(buf, 4096)
|
|
s: str = buf
|
|
stdlib.free(buf)
|
|
return s
|
|
|
|
|
|
# ============================================================
|
|
# Custom-painted widgets: Canvas / Graph3D / ChartView
|
|
# ============================================================
|
|
novirtual class Canvas:
|
|
"""Freehand drawing board / 28x28 grayscale display widget.
|
|
|
|
Left-drag draws; toMnist28 preprocesses the ink (bounding box scaled to
|
|
20x20, centroid-centered) into a 28x28 grayscale byte array.
|
|
"""
|
|
_ptr: QtCanvasPtr
|
|
|
|
def __new__(self, parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
def __init__(self, parent: "QWidget | None" = None):
|
|
if parent is not None and parent._ptr is not None:
|
|
self._ptr = vqt6_canvas_create_with_parent(parent._ptr)
|
|
else:
|
|
self._ptr = vqt6_canvas_create()
|
|
if self._ptr is None:
|
|
raise RuntimeError("Failed to create Canvas")
|
|
|
|
def clear(self):
|
|
vqt6_canvas_clear(self._ptr)
|
|
|
|
def hasInk(self) -> int:
|
|
return vqt6_canvas_has_ink(self._ptr)
|
|
|
|
def setMode(self, mode: int):
|
|
"""0 = freehand drawing, 1 = image display."""
|
|
vqt6_canvas_set_mode(self._ptr, mode)
|
|
|
|
def mode(self) -> int:
|
|
return vqt6_canvas_mode(self._ptr)
|
|
|
|
def setPen(self, r: int, g: int, b: int, width_norm: double):
|
|
vqt6_canvas_set_pen(self._ptr, r, g, b, width_norm)
|
|
|
|
def setGrid(self, on: int):
|
|
vqt6_canvas_set_grid(self._ptr, on)
|
|
|
|
def setScanLine(self, y_norm: int):
|
|
"""Scan line position 0..1000; <0 disables it."""
|
|
vqt6_canvas_set_scan_line(self._ptr, y_norm)
|
|
|
|
def setBackground(self, r: int, g: int, b: int):
|
|
vqt6_canvas_set_bg(self._ptr, r, g, b)
|
|
|
|
def toMnist28(self, out: bytes) -> int:
|
|
"""Ink -> 28x28 grayscale (written to out); returns 0 if there is no ink."""
|
|
return vqt6_canvas_to_mnist28(self._ptr, out)
|
|
|
|
def setImage28(self, inp: bytes):
|
|
"""Show a 28x28 grayscale image (switches to image display mode)."""
|
|
vqt6_canvas_set_image28(self._ptr, inp)
|
|
|
|
def changed(self, cb: bytes, data: bytes = 0):
|
|
"""Ink-finished (mouse release) callback: cb(slot_id: int, data: t.CPtr)."""
|
|
vqt6_canvas_connect_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)
|
|
|
|
def setStyleSheet(self, qss: str):
|
|
vqt6_qwidget_set_stylesheet_utf8(self._ptr, qss)
|
|
|
|
|
|
novirtual class Graph3D:
|
|
"""Software 3D neural-network structure view.
|
|
|
|
Layers run along Z (input farthest); each layer is a near-square grid and
|
|
adjacent layers are fully connected. Drag to rotate, wheel to zoom.
|
|
"""
|
|
_ptr: QtGraph3DPtr
|
|
|
|
def __new__(self, parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
def __init__(self, parent: "QWidget | None" = None):
|
|
if parent is not None and parent._ptr is not None:
|
|
self._ptr = vqt6_graph3d_create_with_parent(parent._ptr)
|
|
else:
|
|
self._ptr = vqt6_graph3d_create()
|
|
if self._ptr is None:
|
|
raise RuntimeError("Failed to create Graph3D")
|
|
|
|
def setup(self, layer_sizes: int*, n_layers: int):
|
|
"""layer_sizes: int array pointer (node count per layer, input -> output)."""
|
|
vqt6_graph3d_setup(self._ptr, layer_sizes, n_layers)
|
|
|
|
def clear(self):
|
|
vqt6_graph3d_clear(self._ptr)
|
|
|
|
def nodeCount(self) -> int:
|
|
return vqt6_graph3d_node_count(self._ptr)
|
|
|
|
def edgeCount(self) -> int:
|
|
return vqt6_graph3d_edge_count(self._ptr)
|
|
|
|
def setLayerAlpha(self, layer: int, alpha: double):
|
|
"""Per-layer brightness: 0..1."""
|
|
vqt6_graph3d_set_layer_alpha(self._ptr, layer, alpha)
|
|
|
|
def setAllLayerAlpha(self, alpha: double):
|
|
vqt6_graph3d_set_all_layer_alpha(self._ptr, alpha)
|
|
|
|
def setValues(self, values: double*, n: int):
|
|
"""Per-node activation (0..1), affecting brightness and radius."""
|
|
vqt6_graph3d_set_values(self._ptr, values, n)
|
|
|
|
def setEdgeWeights(self, w: double*, n: int):
|
|
"""Edge weights (in inter-layer order); affect color/alpha and are culled by |w|."""
|
|
vqt6_graph3d_set_edge_weights(self._ptr, w, n)
|
|
|
|
def setEdgeThreshold(self, tval: double):
|
|
vqt6_graph3d_set_edge_threshold(self._ptr, tval)
|
|
|
|
def setEdgeBudget(self, max_edges: int):
|
|
vqt6_graph3d_set_edge_budget(self._ptr, max_edges)
|
|
|
|
def setView(self, yaw_deg: double, pitch_deg: double, dist: double):
|
|
vqt6_graph3d_set_view(self._ptr, yaw_deg, pitch_deg, dist)
|
|
|
|
def setNodeScale(self, s: double):
|
|
vqt6_graph3d_set_node_scale(self._ptr, s)
|
|
|
|
def setBackground(self, r: int, g: int, b: int):
|
|
vqt6_graph3d_set_bg(self._ptr, r, g, b)
|
|
|
|
def resetView(self):
|
|
vqt6_graph3d_reset_view(self._ptr)
|
|
|
|
def view(self, yaw_deg: double*, pitch_deg: double*,
|
|
dist: double*):
|
|
vqt6_graph3d_get_view(self._ptr, yaw_deg, pitch_deg, dist)
|
|
|
|
def viewChanged(self, cb: bytes, data: bytes = 0):
|
|
vqt6_graph3d_connect_view_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)
|
|
|
|
|
|
novirtual class ChartView:
|
|
"""Qt Charts line-chart widget (optional right Y axis).
|
|
|
|
Typical usage:
|
|
cv = ChartView()
|
|
loss = cv.addLine("loss", 255, 107, 107, 0)
|
|
acc = cv.addLine("acc", 77, 171, 247, 1)
|
|
cv.append(loss, step, loss_value)
|
|
cv.autoscale()
|
|
"""
|
|
_ptr: QtChartViewPtr
|
|
|
|
def __new__(self, parent: "QWidget | None" = None) -> t.CPtr:
|
|
return stdlib.malloc(8) # heap-allocated shell, see note at top of file
|
|
|
|
def __init__(self, parent: "QWidget | None" = None):
|
|
if parent is not None and parent._ptr is not None:
|
|
self._ptr = vqt6_chartview_create_with_parent(parent._ptr)
|
|
else:
|
|
self._ptr = vqt6_chartview_create()
|
|
if self._ptr is None:
|
|
raise RuntimeError("Failed to create ChartView")
|
|
|
|
def addLine(self, name: str, r: int, g: int, b: int, right_axis: int = 0) -> QtChartSeriesPtr:
|
|
return vqt6_chartview_add_line(self._ptr, name, r, g, b, right_axis)
|
|
|
|
def append(self, series: QtChartSeriesPtr, x: double, y: double):
|
|
vqt6_chartview_append(self._ptr, series, x, y)
|
|
|
|
def clearSeries(self, series: QtChartSeriesPtr):
|
|
vqt6_chartview_clear_series(self._ptr, series)
|
|
|
|
def clearAll(self):
|
|
vqt6_chartview_clear_all(self._ptr)
|
|
|
|
def autoscale(self):
|
|
vqt6_chartview_autoscale(self._ptr)
|
|
|
|
def setTitle(self, title: str):
|
|
vqt6_chartview_set_title(self._ptr, title)
|
|
|
|
def setLegendVisible(self, visible: int):
|
|
vqt6_chartview_set_legend_visible(self._ptr, visible)
|
|
|
|
def setBackground(self, r: int, g: int, b: int):
|
|
vqt6_chartview_set_background(self._ptr, r, g, b)
|
|
|
|
def setMaxPoints(self, max_points: int):
|
|
"""Sliding window: drop a series' oldest points past max_points (<=0 = no limit)."""
|
|
vqt6_chartview_set_max_points(self._ptr, max_points)
|
|
|
|
def openZoom(self, title: str):
|
|
"""Open (or reuse) a large window for the current curves; closing only hides it."""
|
|
vqt6_chartview_open_zoom(self._ptr, title)
|
|
|
|
def syncZoom(self):
|
|
"""Sync current curves and axis ranges to the large window (no-op if not open)."""
|
|
vqt6_chartview_sync_zoom(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)
|
|
|
|
|
|
# ============================================================
|
|
# Module exports
|
|
# ============================================================
|
|
__all__ = [
|
|
# High-level classes
|
|
"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",
|
|
# Custom-painted widgets
|
|
"Canvas", "Graph3D", "ChartView",
|
|
"clipboard_set_text", "clipboard_text",
|
|
# Types
|
|
"QtObjectPtr", "QtStringPtr", "QtByteArrayPtr", "QtWidgetPtr", "QtAppPtr",
|
|
"QtLabelPtr", "QtPushButtonPtr",
|
|
"QtTreeWidgetPtr", "QtTreeWidgetItemPtr",
|
|
"QtColorPtr", "QtFontPtr", "QtPixmapPtr", "QtImagePtr", "QtPainterPtr",
|
|
"QtMenuBarPtr", "QtMenuPtr", "QtActionPtr", "QtStatusBarPtr",
|
|
"QtCanvasPtr", "QtGraph3DPtr", "QtChartViewPtr", "QtChartSeriesPtr",
|
|
"QtTcpSocketPtr", "QtHostAddressPtr", "QtNetworkRequestPtr", "QtNetworkReplyPtr",
|
|
# Constants
|
|
"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",
|
|
]
|