Blender's GPU Accelerated UI, Decoupled from it's original codebase. Supports Rust, Python, JS, React, C & C++. Twice as good as GPUI
"""BUI with Qt syntax — Qt's widget API on the C kit.
Every QWidget is a kit node; QBoxLayout / QGridLayout / QFormLayout run on
the kit's C geometry managers, ``paintEvent`` + QPainter record into a kit
canvas, and top-level windows are native (Win32, X11, Cocoa) or Tk
(:mod:`bui.host`).
Signals, timers and animations are plain Python (as in PySide's Python
layer)::
from bui.qtsyntax import QApplication, QWidget, QPushButton, QVBoxLayout
app = QApplication([])
w = QWidget()
layout = QVBoxLayout(w)
button = QPushButton("Click me")
button.clicked.connect(lambda: print("clicked"))
layout.addWidget(button)
w.show()
app.exec()
SPDX-License-Identifier: GPL-2.0-or-later
"""
from __future__ import annotations
import os
import time
from typing import Callable, List, Optional
import buipy
from bui import _realtk, filebrowser, host
from bui.components.core import (EV_ACTIVATE, EV_CHANGE, EV_CLICK, EV_DOUBLE, EV_ENTER, # noqa: F401
EV_KEY, EV_LEAVE, EV_MOTION, EV_PRESS, EV_RELEASE,
EV_RENAME, EV_SUBMIT, EV_TOGGLE, EV_WHEEL)
from bui.components.menus import MenuItem
from bui.tksyntax import PhotoImage, color as _tk_color
PACK, GRID, PLACE = 1, 2, 3
N, S, W, E = 1, 2, 4, 8
# ==========================================================================
# Namespace and value types
class Qt:
AlignLeft, AlignRight, AlignHCenter, AlignJustify = 0x1, 0x2, 0x4, 0x8
AlignTop, AlignBottom, AlignVCenter = 0x20, 0x40, 0x80
AlignCenter = AlignHCenter | AlignVCenter
Horizontal, Vertical = 1, 2
Unchecked, PartiallyChecked, Checked = 0, 1, 2
NoPen, NoBrush = "nopen", "nobrush"
LeftButton, RightButton, MiddleButton = 1, 2, 4
NoModifier, ShiftModifier, ControlModifier, AltModifier = 0, 0x02000000, 0x04000000, \
0x08000000
Key_Return, Key_Enter, Key_Escape, Key_Tab, Key_Backspace, Key_Delete = \
0x01000004, 0x01000005, 0x01000000, 0x01000001, 0x01000003, 0x01000007
Key_Left, Key_Up, Key_Right, Key_Down, Key_Home, Key_End = \
0x01000012, 0x01000013, 0x01000014, 0x01000015, 0x01000010, 0x01000011
Key_Space = 0x20
WA_DeleteOnClose = 55
ScrollBarAlwaysOff, ScrollBarAsNeeded = 1, 0
ItemIsEditable, ItemIsSelectable, ItemIsEnabled = 2, 1, 32
DisplayRole, UserRole = 0, 256
white, black, red, green, blue, gray = "#ffffff", "#000000", "#ff0000", "#00ff00", \
"#0000ff", "#808080"
for _c in "ABCDEFGHIJKLMNOPQRSTUVWXYZ":
setattr(Qt, "Key_" + _c, ord(_c))
for _d in range(10):
setattr(Qt, "Key_%d" % _d, ord(str(_d)))
_KEYSYM_TO_QT = {"Return": Qt.Key_Return, "KP_Enter": Qt.Key_Enter, "Escape": Qt.Key_Escape,
"Tab": Qt.Key_Tab, "BackSpace": Qt.Key_Backspace, "Delete": Qt.Key_Delete,
"Left": Qt.Key_Left, "Up": Qt.Key_Up, "Right": Qt.Key_Right,
"Down": Qt.Key_Down, "Home": Qt.Key_Home, "End": Qt.Key_End,
"space": Qt.Key_Space}
class Signal:
"""Qt signal: ``clicked = Signal()`` on a class, then
``obj.clicked.connect(fn)`` / ``.emit(...)``."""
def __init__(self, *types, name=None):
self._types = types
self._name = None
def __set_name__(self, owner, name):
self._name = "_sig_" + name
def __get__(self, obj, owner=None):
if obj is None:
return self
bound = obj.__dict__.get(self._name)
if bound is None:
bound = BoundSignal(self._types)
obj.__dict__[self._name] = bound
return bound
Signal_ = pyqtSignal = Signal
class BoundSignal:
def __init__(self, types=()):
self._slots: List[Callable] = []
self._types = types
def connect(self, slot):
self._slots.append(slot)
return slot
def disconnect(self, slot=None):
if slot is None:
self._slots.clear()
elif slot in self._slots:
self._slots.remove(slot)
def emit(self, *args):
for slot in list(self._slots):
try:
slot(*args)
except TypeError:
# Qt drops extra signal arguments a slot does not take
if args:
slot(*args[:max(0, _arity(slot))])
else:
raise
def _arity(fn) -> int:
import inspect
try:
return len([p for p in inspect.signature(fn).parameters.values()
if p.default is p.empty and p.kind in (p.POSITIONAL_ONLY,
p.POSITIONAL_OR_KEYWORD)])
except (TypeError, ValueError):
return 0
class QColor:
def __init__(self, *args):
if len(args) == 1 and isinstance(args[0], QColor):
self._rgba = args[0]._rgba
elif len(args) == 1:
c = _tk_color(args[0]) or (0, 0, 0, 1)
self._rgba = tuple(c)
elif len(args) >= 3:
a = args[3] if len(args) > 3 else 255
self._rgba = (args[0] / 255.0, args[1] / 255.0, args[2] / 255.0, a / 255.0)
else:
self._rgba = (0.0, 0.0, 0.0, 1.0)
@staticmethod
def fromRgb(r, g, b, a=255): # noqa: N802
return QColor(r, g, b, a)
def red(self):
return round(self._rgba[0] * 255)
def green(self):
return round(self._rgba[1] * 255)
def blue(self):
return round(self._rgba[2] * 255)
def alpha(self):
return round(self._rgba[3] * 255)
def setAlpha(self, a): # noqa: N802
self._rgba = self._rgba[:3] + (a / 255.0,)
def name(self):
return "#%02x%02x%02x" % (self.red(), self.green(), self.blue())
def lighter(self, f=150):
k = f / 100.0
return QColor(*(min(255, round(c * 255 * k)) for c in self._rgba[:3]), self.alpha())
def darker(self, f=200):
k = 100.0 / f
return QColor(*(round(c * 255 * k) for c in self._rgba[:3]), self.alpha())
def rgba(self):
return self._rgba
def _rgba(c):
if c is None or c in (Qt.NoPen, Qt.NoBrush):
return None
if isinstance(c, QColor):
return c._rgba
if isinstance(c, (QPen, QBrush)):
return _rgba(c._color)
return QColor(c)._rgba
class QPen:
def __init__(self, color=None, width=1, *args):
self._color = color if color is not None else QColor("#000000")
self._width = width
def setWidth(self, w): # noqa: N802
self._width = w
def setColor(self, c): # noqa: N802
self._color = c
def color(self):
return QColor(self._color) if not isinstance(self._color, QColor) else self._color
class QBrush:
def __init__(self, color=None, *args):
self._color = color
def color(self):
return QColor(self._color) if not isinstance(self._color, QColor) else self._color
class QFont:
Bold, Normal = 75, 50
def __init__(self, family="", size=-1, weight=-1, italic=False):
self._family, self._size, self._bold = family, size, weight >= 75
def setPointSize(self, s): # noqa: N802
self._size = s
def pointSize(self): # noqa: N802
return self._size
def setPixelSize(self, s): # noqa: N802
self._size = s * 0.75
def setBold(self, b): # noqa: N802
self._bold = bool(b)
def bold(self):
return self._bold
def setFamily(self, f): # noqa: N802
self._family = f
class QPoint:
def __init__(self, x=0, y=0):
self._x, self._y = int(x), int(y)
def x(self):
return self._x
def y(self):
return self._y
QPointF = QPoint
class QSize:
def __init__(self, w=0, h=0):
self._w, self._h = int(w), int(h)
def width(self):
return self._w
def height(self):
return self._h
class QRect:
def __init__(self, x=0, y=0, w=0, h=0):
self._x, self._y, self._w, self._h = int(x), int(y), int(w), int(h)
def x(self):
return self._x
def y(self):
return self._y
def width(self):
return self._w
def height(self):
return self._h
left, top = x, y
def right(self):
return self._x + self._w - 1
def bottom(self):
return self._y + self._h - 1
def center(self):
return QPoint(self._x + self._w // 2, self._y + self._h // 2)
def contains(self, p, y=None):
px, py = (p.x(), p.y()) if y is None else (p, y)
return self._x <= px < self._x + self._w and self._y <= py < self._y + self._h
def adjusted(self, dx1, dy1, dx2, dy2):
return QRect(self._x + dx1, self._y + dy1, self._w - dx1 + dx2, self._h - dy1 + dy2)
QRectF = QRect
class QPixmap:
"""Image backed by RGBA pixels (shared with tksyntax.PhotoImage)."""
def __init__(self, *args):
if args and isinstance(args[0], str):
self._img = PhotoImage(file=args[0])
elif len(args) >= 2:
self._img = PhotoImage(width=int(args[0]), height=int(args[1]))
elif args and isinstance(args[0], QSize):
self._img = PhotoImage(width=args[0].width(), height=args[0].height())
else:
self._img = PhotoImage(width=0, height=0)
def width(self):
return self._img.width()
def height(self):
return self._img.height()
def isNull(self): # noqa: N802
return self._img.width() == 0
def fill(self, c=None):
rgba = bytes(round(v * 255) for v in (_rgba(c) or (1, 1, 1, 1)))
self._img._px = bytearray(rgba * (self._img.width() * self._img.height()))
def load(self, path):
self._img = PhotoImage(file=path)
return True
QImage = QPixmap
class QIcon:
def __init__(self, *args):
self.name = args[0] if args else ""
# ==========================================================================
# Events
class QEvent:
def __init__(self, kind=0):
self._type, self._accepted = kind, True
def type(self):
return self._type
def accept(self):
self._accepted = True
def ignore(self):
self._accepted = False
def isAccepted(self): # noqa: N802
return self._accepted
class QCloseEvent(QEvent):
pass
class QPaintEvent(QEvent):
def __init__(self, rect):
super().__init__()
self._rect = rect
def rect(self):
return self._rect
class QMouseEvent(QEvent):
def __init__(self, x, y, button=Qt.LeftButton, modifiers=0):
super().__init__()
self._x, self._y, self._button, self._mods = int(x), int(y), button, modifiers
def pos(self):
return QPoint(self._x, self._y)
position = pos
def x(self):
return self._x
def y(self):
return self._y
def button(self):
return self._button
def modifiers(self):
return self._mods
class QKeyEvent(QEvent):
def __init__(self, key, text="", modifiers=0):
super().__init__()
self._key, self._text, self._mods = key, text, modifiers
def key(self):
return self._key
def text(self):
return self._text
def modifiers(self):
return self._mods
class QWheelEvent(QEvent):
def __init__(self, delta):
super().__init__()
self._delta = delta
def angleDelta(self): # noqa: N802
return QPoint(0, self._delta)
def _mods_qt(bits):
return ((Qt.ShiftModifier if bits & 1 else 0) | (Qt.ControlModifier if bits & 2 else 0)
| (Qt.AltModifier if bits & 4 else 0))
# ==========================================================================
# QApplication, timers
class QApplication:
_instance: Optional["QApplication"] = None
def __init__(self, argv=None):
QApplication._instance = self
self._windows: list = []
@staticmethod
def instance():
return QApplication._instance
def exec(self) -> int:
for w in list(_pending_show):
w._open()
_pending_show.clear()
_timers.flush()
host.run()
return 0
exec_ = exec
def quit(self) -> None:
host.quit()
exit = quit
@staticmethod
def processEvents(): # noqa: N802
_timers.flush()
host.update()
def setStyle(self, *a): # noqa: N802
pass
setStyleSheet = setApplicationName = setStyle
QCoreApplication = QApplication
class _TimerService:
"""Timers run on a top-level window's clock; until one exists they wait."""
def __init__(self):
self.queue = []
def window(self):
for w in host._windows:
if w.is_open:
return w
return None
def after(self, ms, fn):
win = self.window()
if win is None:
self.queue.append((ms, fn))
return ("q", fn)
return ("w", win, win.after(int(ms), fn))
def cancel(self, token):
if token is None:
return
if token[0] == "q":
self.queue = [(m, f) for m, f in self.queue if f is not token[1]]
else:
try:
token[1].after_cancel(token[2])
except Exception:
pass
def flush(self):
win = self.window()
if win is None:
return
queue, self.queue = self.queue, []
for ms, fn in queue:
win.after(int(ms), fn)
_timers = _TimerService()
class QTimer:
timeout = Signal()
def __init__(self, parent=None):
self._interval, self._single, self._token = 0, False, None
@staticmethod
def singleShot(ms, fn): # noqa: N802
_timers.after(ms, fn)
def setInterval(self, ms): # noqa: N802
self._interval = int(ms)
def interval(self):
return self._interval
def setSingleShot(self, b): # noqa: N802
self._single = bool(b)
def isActive(self): # noqa: N802
return self._token is not None
def start(self, ms=None):
if ms is not None:
self._interval = int(ms)
self.stop()
self._token = _timers.after(self._interval, self._fire)
def stop(self):
_timers.cancel(self._token)
self._token = None
def _fire(self):
self._token = None
if not self._single:
self._token = _timers.after(max(1, self._interval), self._fire)
self.timeout.emit()
class QEasingCurve:
Linear, InOutQuad, OutCubic, InQuad, OutQuad = range(5)
def __init__(self, kind=0):
self._kind = kind
def valueForProgress(self, t): # noqa: N802
k = self._kind
if k == QEasingCurve.InOutQuad:
return 2 * t * t if t < 0.5 else 1 - (-2 * t + 2) ** 2 / 2
if k == QEasingCurve.OutCubic:
return 1 - (1 - t) ** 3
if k == QEasingCurve.InQuad:
return t * t
if k == QEasingCurve.OutQuad:
return 1 - (1 - t) ** 2
return t
class QPropertyAnimation:
finished = Signal()
valueChanged = Signal(object)
def __init__(self, target=None, prop=b"", parent=None):
self._target = target
self._prop = prop.decode() if isinstance(prop, bytes) else prop
self._start = self._end = 0
self._duration = 250
self._easing = QEasingCurve()
self._running = False
self._timer = QTimer()
self._timer.setInterval(8) # 120 Hz
self._timer.timeout.connect(self._tick)
def setTargetObject(self, o): # noqa: N802
self._target = o
def setPropertyName(self, name): # noqa: N802
self._prop = name.decode() if isinstance(name, bytes) else name
def setStartValue(self, v): # noqa: N802
self._start = v
def setEndValue(self, v): # noqa: N802
self._end = v
def setDuration(self, ms): # noqa: N802
self._duration = max(1, int(ms))
def setEasingCurve(self, e): # noqa: N802
self._easing = e if isinstance(e, QEasingCurve) else QEasingCurve(e)
def start(self):
self._t0 = time.perf_counter()
self._running = True
self._apply(self._start)
self._timer.start()
def stop(self):
self._running = False
self._timer.stop()
def state(self):
return 2 if self._running else 0
def _apply(self, v):
setter = getattr(self._target, "set" + self._prop[:1].upper() + self._prop[1:], None)
if callable(setter):
setter(v)
else:
setattr(self._target, self._prop, v)
self.valueChanged.emit(v)
def _tick(self):
t = min(1.0, (time.perf_counter() - self._t0) * 1000 / self._duration)
k = self._easing.valueForProgress(t)
if isinstance(self._start, (int, float)):
v = self._start + (self._end - self._start) * k
if isinstance(self._start, int) and isinstance(self._end, int):
v = round(v)
else:
v = self._end if t >= 1 else self._start
self._apply(v)
if t >= 1.0:
self.stop()
self.finished.emit()
# ==========================================================================
# QWidget
_pending_show: list = []
def _kids(node):
return buipy.KitNode.children.__get__(node)
_EVENT_METHODS = ("mousePressEvent", "mouseReleaseEvent", "mouseMoveEvent",
"mouseDoubleClickEvent", "keyPressEvent", "wheelEvent", "enterEvent",
"leaveEvent")
class QWidget(buipy.KitNode):
KIND = "frame"
def __init__(self, parent=None, *args, **kw):
cls = type(self)
custom_paint = cls.paintEvent is not QWidget.paintEvent
super().__init__("canvas" if custom_paint and self.KIND == "frame" else self.KIND)
self._custom_paint = custom_paint
self._layout = None
self._title = ""
self._size = None
self._window = None
self._ctx = None
self._policy = None
self._menubar = None
self._painted_size = None
if custom_paint:
self.set("bg", (0, 0, 0, 0))
if any(getattr(cls, m) is not getattr(QWidget, m) for m in _EVENT_METHODS):
self.set("events", True)
self._setup()
if parent is not None:
self.setParent(parent)
def _setup(self):
pass
@property
def _parent_widget(self):
p = buipy.KitNode.parent.__get__(self)
while p is not None and not isinstance(p, QWidget):
p = buipy.KitNode.parent.__get__(p)
return p
@property
def _r(self):
return buipy.KitNode.rect.__get__(self)
# -- tree ----------------------------------------------------------------------
def setParent(self, parent): # noqa: N802
if self.parent is not None:
self.parent.remove(self)
if parent is not None:
target = parent._content_node()
target.add(self)
if target.type == "frame" and self.geom_get("manager") == 0:
self.geom(PLACE, reset_place=1, x=0, y=0) # free child: placed at (0, 0)
def _content_node(self):
return self
def parentWidget(self): # noqa: N802
return self._parent_widget
def children(self):
return [c for c in _kids(self) if isinstance(c, QWidget)]
def setLayout(self, layout): # noqa: N802
if self._layout is not None:
self.remove(self._layout)
self._layout = layout
layout._owner = self
if layout._margins is None: # top-level layouts get Qt's default margin
layout.set("padding", round(0.45 * buipy.kit_unit()))
self._content_node().add(layout)
layout.geom(PACK, fill=3, expand=1)
def layout(self):
return self._layout
# -- geometry --------------------------------------------------------------------
def resize(self, w, h=None):
if h is None:
w, h = w.width(), w.height()
self._size = (int(w), int(h))
if self._window is not None:
self._window.set_size(*self._size)
elif self.geom_get("manager") == PLACE:
self.geom(PLACE, width=int(w), height=int(h))
else:
self.geom(int(self.geom_get("manager")), reqwidth=int(w), reqheight=int(h))
def move(self, x, y=None):
if y is None:
x, y = x.x(), x.y()
if self.geom_get("manager") in (0, PLACE):
self.geom(PLACE, x=int(x), y=int(y))
def setGeometry(self, x, y=None, w=None, h=None): # noqa: N802
if isinstance(x, QRect):
x, y, w, h = x.x(), x.y(), x.width(), x.height()
self.geom(PLACE, x=int(x), y=int(y), width=int(w), height=int(h))
self._size = (int(w), int(h))
def setFixedSize(self, w, h=None): # noqa: N802
if h is None:
w, h = w.width(), w.height()
self.geom(int(self.geom_get("manager")), reqwidth=int(w), reqheight=int(h))
self._size = (int(w), int(h))
self._fixed(0)
self._fixed(1)
def setFixedWidth(self, w): # noqa: N802
self.geom(int(self.geom_get("manager")), reqwidth=int(w))
self._fixed(0)
def setFixedHeight(self, h): # noqa: N802
self.geom(int(self.geom_get("manager")), reqheight=int(h))
self._fixed(1)
def _fixed(self, axis):
p = list(self._policy or (None, None))
p[axis] = QSizePolicy.Fixed
self._policy = tuple(p)
lay = self._parent_layout()
if isinstance(lay, QBoxLayout):
lay._policies()
def setMinimumWidth(self, w): # noqa: N802
self.geom(int(self.geom_get("manager")), reqwidth=int(w))
def setMinimumHeight(self, h): # noqa: N802
self.geom(int(self.geom_get("manager")), reqheight=int(h))
def setMinimumSize(self, w, h=None): # noqa: N802
pass
setMaximumSize = setMaximumWidth = setMaximumHeight = setMinimumSize
def width(self):
if self._window is not None:
return self._window.size[0]
return self._r[2] or (self._size or self.natural())[0]
def height(self):
if self._window is not None:
return self._window.size[1]
return self._r[3] or (self._size or self.natural())[1]
def x(self):
return self._r[0]
def y(self):
return self._r[1]
def pos(self):
return QPoint(self._r[0], self._r[1])
def size(self):
return QSize(self.width(), self.height())
def geometry(self):
return QRect(*self._r)
def rect(self): # noqa: F811 - Qt API (QWidget.rect())
return QRect(0, 0, self.width(), self.height())
def sizeHint(self): # noqa: N802
return QSize(*self.natural())
def absolutePos(self): # noqa: N802 - tools/tests
r = self._r
return r[0], r[1]
def setSizePolicy(self, h, v=None): # noqa: N802
self._policy = (h._h, h._v) if isinstance(h, QSizePolicy) else (h, v)
if isinstance(self._parent_layout(), QBoxLayout):
self._parent_layout()._policies()
def _parent_layout(self):
p = self.parent
return p if isinstance(p, QLayout) else None
# -- state ------------------------------------------------------------------------
def setEnabled(self, b): # noqa: N802
self.set("enabled", bool(b))
def isEnabled(self): # noqa: N802
return bool(self.get("enabled"))
def setVisible(self, b): # noqa: N802
if self._parent_widget is None and self._layout is not None or self._window:
self.show() if b else self.hide()
return
self.set("visible", bool(b))
def isVisible(self): # noqa: N802
return bool(self.get("visible"))
def hide(self):
if self._window is not None:
self._window.close()
self._window = None
else:
self.set("visible", False)
def setToolTip(self, text): # noqa: N802
self.set("description", str(text))
def setStyleSheet(self, css): # noqa: N802
for decl in str(css).split(";"):
k, _, v = decl.partition(":")
k, v = k.strip().lower(), v.strip()
if k == "color":
c = _tk_color(v)
if c:
try:
self.set("text_color", c)
except KeyError:
pass
elif k in ("background", "background-color"):
c = _tk_color(v)
if c and self.type in ("frame", "canvas"):
self.set("bg", c)
elif k == "font-weight" and "bold" in v:
try:
self.set("bold", True)
except KeyError:
pass
def setFont(self, font): # noqa: N802
if isinstance(font, QFont) and font.bold():
try:
self.set("bold", True)
except KeyError:
pass
def setObjectName(self, name): # noqa: N802
self._object_name = name
def objectName(self): # noqa: N802
return getattr(self, "_object_name", "")
def setAttribute(self, *a): # noqa: N802
pass
setWindowIcon = setWindowFlags = setFocusPolicy = setContentsMargins = setAttribute
installEventFilter = setMouseTracking = setAutoFillBackground = setAttribute
def setFocus(self, *a): # noqa: N802
pass
def setCursor(self, *a): # noqa: N802
pass
# -- window -------------------------------------------------------------------------
def setWindowTitle(self, title): # noqa: N802
self._title = str(title)
if self._window is not None:
self._window.title(self._title)
def windowTitle(self): # noqa: N802
return self._title
def show(self):
if self._parent_widget is not None:
self.set("visible", True)
return
if QApplication._instance is None or getattr(QApplication, "_running", False) \
or host._windows:
self._open()
else:
_pending_show.append(self)
self._open()
def _open(self):
if self._window is not None:
return
self._ctx = buipy.KitContext(self)
if self._menubar is not None:
self._ctx.set_header(self._menubar._node)
size = self._size or tuple(max(a, b) for a, b in zip(self.natural(), (200, 100)))
self._window = host.Window(self._ctx, self._title or "BUI", size)
self._window.on_close = self._close_requested
self._window.show()
_timers.flush()
_schedule_paint()
def _close_requested(self):
ev = QCloseEvent()
self.closeEvent(ev)
if ev.isAccepted():
self._window = None
return True
return False
def close(self):
if self._window is not None:
w, self._window = self._window, None
w.close()
return True
def isWindow(self): # noqa: N802
return self._parent_widget is None
def window(self):
w = self
while w._parent_widget is not None:
w = w._parent_widget
return w
def _host_window(self):
return self.window()._window
def setMenuBar(self, menubar): # noqa: N802
self._menubar = menubar
if self._ctx is not None:
self._ctx.set_header(menubar._node)
# -- painting --------------------------------------------------------------------
def paintEvent(self, event): # noqa: N802
pass
def update(self, *args):
if self._custom_paint:
self._repaint()
else:
self.invalidate()
repaint = update
def _repaint(self):
w, h = self._r[2], self._r[3]
if w <= 0 or h <= 0:
return
self._painted_size = (w, h)
self.canvas_delete(-1)
self._paint_id = 0
self.paintEvent(QPaintEvent(QRect(0, 0, w, h)))
def closeEvent(self, event): # noqa: N802
event.accept()
# -- input overrides ----------------------------------------------------------------
def mousePressEvent(self, e): # noqa: N802
pass
def mouseReleaseEvent(self, e): # noqa: N802
pass
def mouseMoveEvent(self, e): # noqa: N802
pass
def mouseDoubleClickEvent(self, e): # noqa: N802
pass
def keyPressEvent(self, e): # noqa: N802
pass
def wheelEvent(self, e): # noqa: N802
pass
def enterEvent(self, e): # noqa: N802
pass
def leaveEvent(self, e): # noqa: N802
pass
def _on_event(self, kind, ref, a, b):
if kind == EV_PRESS:
self.mousePressEvent(QMouseEvent(a, b))
elif kind == EV_RELEASE:
self.mouseReleaseEvent(QMouseEvent(a, b))
elif kind == EV_MOTION:
self.mouseMoveEvent(QMouseEvent(a, b))
elif kind == EV_DOUBLE:
self.mouseDoubleClickEvent(QMouseEvent(a, b))
elif kind == EV_ENTER:
self.enterEvent(QEvent())
elif kind == EV_LEAVE:
self.leaveEvent(QEvent())
elif kind == EV_WHEEL:
self.wheelEvent(QWheelEvent(int(a) * 120))
elif kind == EV_KEY:
text, _, keysym = (ref or "").partition("\t")
key = _KEYSYM_TO_QT.get(keysym, ord(keysym.upper()) if len(keysym) == 1 else 0)
self.keyPressEvent(QKeyEvent(key, text, _mods_qt(int(a))))
else:
self._event(kind, ref, a, b)
def _event(self, kind, ref, a, b):
pass
def _schedule_paint():
"""Custom-painted widgets paint once their size is known (after layout)."""
_timers.after(0, _paint_pending)
def _paint_pending():
for w in list(host._windows):
w.render_now()
for w in _custom_widgets():
if w._painted_size != (w._r[2], w._r[3]):
w._repaint()
def _custom_widgets():
import gc
return [o for o in gc.get_objects() if isinstance(o, QWidget) and o._custom_paint]
class QMainWindow(QWidget):
def _setup(self):
self._central = None
self._status = None
def setCentralWidget(self, w): # noqa: N802
if self._central is not None:
self.remove(self._central)
self._central = w
self.add(w)
w.geom(PACK, fill=3, expand=1)
def centralWidget(self): # noqa: N802
return self._central
def menuBar(self): # noqa: N802
if self._menubar is None:
self.setMenuBar(QMenuBar())
return self._menubar
def statusBar(self): # noqa: N802
if self._status is None:
self._status = QStatusBar()
self.add(self._status)
self._status.geom(PACK, side=1, fill=1)
return self._status
class QDialog(QWidget):
accepted = Signal()
rejected = Signal()
def exec(self):
self.show()
while self._window is not None and self._window.is_open:
host.update()
time.sleep(0.004)
return getattr(self, "_result", 0)
exec_ = exec
def accept(self):
self._result = 1
self.accepted.emit()
self.close()
def reject(self):
self._result = 0
self.rejected.emit()
self.close()
class QFrame(QWidget):
NoFrame, Box, Panel, StyledPanel, HLine, VLine = range(6)
def setFrameShape(self, *a): # noqa: N802
pass
setFrameShadow = setLineWidth = setFrameShape
# ==========================================================================
# Layouts
class QLayout(buipy.KitNode):
def __init__(self, parent=None):
super().__init__("frame")
self._owner = None
self._items = []
self._spacing = round(0.3 * buipy.kit_unit())
self._margins = None
if isinstance(parent, QWidget):
parent.setLayout(self)
def setSpacing(self, s): # noqa: N802
self._spacing = int(s)
self._relayout()
def spacing(self):
return self._spacing
def setContentsMargins(self, left, top=None, right=None, bottom=None): # noqa: N802
if isinstance(left, QMargins):
left = left._v
self._margins = int(left)
self.set("padding", int(left))
def count(self):
return len(self._items)
def itemAt(self, i): # noqa: N802
return _LayoutItem(self._items[i][0]) if 0 <= i < len(self._items) else None
def _relayout(self):
pass
def _adopt(self, w):
if isinstance(w, QWidget):
if w.parent is not None:
w.parent.remove(w)
self.add(w)
class _LayoutItem:
def __init__(self, w):
self._w = w
def widget(self):
return self._w if isinstance(self._w, QWidget) else None
def layout(self):
return self._w if isinstance(self._w, QLayout) else None
# Size policies (Qt defaults): which widgets take extra space.
_H_EXPANDING = ("text", "slider", "progress", "dropdown", "textarea", "list", "tree", "tabs",
"canvas", "scroll", "number")
_V_EXPANDING = ("textarea", "list", "tree", "tabs", "canvas", "scroll")
def _expands(node, horizontal):
if isinstance(node, QLayout):
return any(_expands(c, horizontal) for c, _ in node._items)
if isinstance(node, QWidget) and node._policy is not None and node._policy[0 if horizontal else 1] is not None:
p = node._policy[0 if horizontal else 1]
return p in (QSizePolicy.Expanding, QSizePolicy.MinimumExpanding)
kinds = _H_EXPANDING if horizontal else _V_EXPANDING
if isinstance(node, QWidget) and node._layout is not None:
return _expands(node._layout, horizontal)
return getattr(node, "type", "") in kinds or (
isinstance(node, QWidget) and node._custom_paint and not horizontal)
class QMargins:
def __init__(self, left=0, top=0, right=0, bottom=0):
self._v = left
class QSizePolicy:
Fixed, Minimum, Maximum, Preferred, Expanding, MinimumExpanding, Ignored = range(7)
def __init__(self, h=3, v=3):
self._h, self._v = h, v
class QBoxLayout(QLayout):
LeftToRight, RightToLeft, TopToBottom, BottomToTop = range(4)
_vertical = True
def addWidget(self, w, stretch=0, alignment=0): # noqa: N802
self._adopt(w)
self._items.append((w, stretch))
self._policies()
def addLayout(self, layout, stretch=0): # noqa: N802
layout._owner = self._owner
self.add(layout)
self._items.append((layout, stretch))
self._policies()
def insertWidget(self, index, w, stretch=0, alignment=0): # noqa: N802
self._adopt(w)
self._items.insert(index, (w, stretch))
self._reorder()
self._policies()
def addStretch(self, stretch=1): # noqa: N802
spacer = buipy.KitNode("frame")
self.add(spacer)
self._items.append((spacer, max(1, stretch)))
self._policies()
def addSpacing(self, size): # noqa: N802
spacer = buipy.KitNode("frame")
spacer.geom(0, **({"reqheight": int(size)} if self._vertical else
{"reqwidth": int(size)}))
self.add(spacer)
self._items.append((spacer, 0))
self._policies()
def removeWidget(self, w): # noqa: N802
self._items = [(i, s) for i, s in self._items if i is not w]
self.remove(w)
self._policies()
def setStretch(self, index, stretch): # noqa: N802
w, _ = self._items[index]
self._items[index] = (w, stretch)
self._policies()
def _reorder(self):
for i, (w, _) in enumerate(self._items):
buipy.KitNode.add(self, w, i)
def _relayout(self):
self._policies()
def _policies(self):
"""Qt box semantics on Tk's packer: items stack along the axis; extra
space goes to stretch factors, else to expanding widgets, else (for
horizontal boxes) is shared by all."""
v = self._vertical
any_stretch = any(s > 0 for _, s in self._items)
expanders = [w for w, s in self._items if (s > 0 if any_stretch else _expands(w, not v))]
if not v and not expanders:
expanders = [w for w, _ in self._items]
for k, (w, s) in enumerate(self._items):
gap = self._spacing if k else 0
w.geom(PACK, side=0 if v else 2, fill=1 if v else 2,
expand=1 if w in expanders else 0,
pady0=gap if v else 0, padx0=0 if v else gap)
if (v and _expands(w, True)) or not v:
w.geom(PACK, fill=3)
if v and w in expanders:
w.geom(PACK, fill=3)
class QVBoxLayout(QBoxLayout):
_vertical = True
class QHBoxLayout(QBoxLayout):
_vertical = False
class QGridLayout(QLayout):
def addWidget(self, w, row=0, column=0, rowspan=1, columnspan=1, alignment=0): # noqa: N802
self._adopt(w)
self._place(w, row, column, rowspan, columnspan, alignment)
def addLayout(self, layout, row=0, column=0, rowspan=1, columnspan=1, alignment=0): # noqa: N802
layout._owner = self._owner
self.add(layout)
self._place(layout, row, column, rowspan, columnspan, alignment)
def _place(self, w, row, column, rowspan, columnspan, alignment):
self._items.append((w, (row, column)))
sticky = W | E | ((N | S) if _expands(w, False) else 0)
if alignment & Qt.AlignLeft:
sticky &= ~E
if alignment & Qt.AlignRight:
sticky &= ~W
g = self._spacing # Qt spacing goes between cells, not around the edges
w.geom(GRID, row=row, column=column, rowspan=rowspan, columnspan=columnspan,
sticky=sticky, padx0=g if column else 0, pady0=g if row else 0)
if _expands(w, True):
self.grid_weight(1, column + columnspan - 1, 1.0)
if _expands(w, False):
self.grid_weight(0, row + rowspan - 1, 1.0)
def setColumnStretch(self, column, stretch): # noqa: N802
self.grid_weight(1, int(column), float(stretch))
def setRowStretch(self, row, stretch): # noqa: N802
self.grid_weight(0, int(row), float(stretch))
def setHorizontalSpacing(self, s): # noqa: N802
self._spacing = int(s)
setVerticalSpacing = setHorizontalSpacing
def rowCount(self): # noqa: N802
return 1 + max((r for _, (r, c) in self._items), default=-1)
def columnCount(self): # noqa: N802
return 1 + max((c for _, (r, c) in self._items), default=-1)
class QFormLayout(QGridLayout):
def addRow(self, label, field=None): # noqa: N802
row = self.rowCount()
if field is None:
self.addWidget(label, row, 0, 1, 2)
return
if isinstance(label, str):
label = QLabel(label)
label.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.addWidget(label, row, 0)
if isinstance(field, QLayout):
self.addLayout(field, row, 1)
else:
self.addWidget(field, row, 1)
self.setColumnStretch(1, 1)
class QStackedLayout(QLayout):
def addWidget(self, w): # noqa: N802
self._adopt(w)
self._items.append((w, 0))
w.geom(PACK, fill=3, expand=1)
self.setCurrentIndex(getattr(self, "_current", 0))
return len(self._items) - 1
def setCurrentIndex(self, i): # noqa: N802
self._current = i
for k, (w, _) in enumerate(self._items):
w.set("visible", k == i)
def currentIndex(self): # noqa: N802
return getattr(self, "_current", 0)
# ==========================================================================
# Widgets
class QLabel(QWidget):
KIND = "label"
def __init__(self, text="", parent=None, **kw):
super().__init__(parent)
self.set("text", str(text))
def setText(self, t): # noqa: N802
self.set("text", str(t))
def text(self):
return self.get_str("text")
def setAlignment(self, a): # noqa: N802
if isinstance(a, str):
a = {"center": Qt.AlignCenter, "right": Qt.AlignRight}.get(a, Qt.AlignLeft)
self.set("text_align", "right" if a & Qt.AlignRight else
("center" if a & Qt.AlignHCenter else "left"))
def setPixmap(self, pm): # noqa: N802
self.set_image(pm.width(), pm.height(), pm._img.rgba())
def setWordWrap(self, b): # noqa: N802
pass
setTextFormat = setOpenExternalLinks = setWordWrap
class QAbstractButton(QWidget):
clicked = Signal(bool)
pressed = Signal()
released = Signal()
toggled = Signal(bool)
def setText(self, t): # noqa: N802
self.set("text", str(t))
def text(self):
return self.get_str("text")
def setIcon(self, icon): # noqa: N802
name = getattr(icon, "name", "")
if name:
self.set("icon", name)
def click(self):
self._event(EV_CLICK, None, 0, 0)
def animateClick(self, *a): # noqa: N802
self.click()
def setShortcut(self, *a): # noqa: N802
pass
class QPushButton(QAbstractButton):
KIND = "button"
def __init__(self, text="", parent=None, **kw):
if isinstance(text, QWidget):
text, parent = "", text
super().__init__(parent)
self.set("text", str(text))
def _event(self, kind, ref, a, b):
if kind == EV_CLICK:
self.clicked.emit(False)
def setDefault(self, b): # noqa: N802
pass
setAutoDefault = setFlat = setDefault
QToolButton = QPushButton
class QCheckBox(QAbstractButton):
KIND = "checkbox"
stateChanged = Signal(int)
checkStateChanged = Signal(int)
def __init__(self, text="", parent=None):
super().__init__(parent)
self.set("label", str(text))
def setText(self, t): # noqa: N802
self.set("label", str(t))
def text(self):
return self.get_str("label")
def isChecked(self): # noqa: N802
return self.get("value") != 0
def setChecked(self, b): # noqa: N802
self.set("set_value", 1.0 if b else 0.0)
def checkState(self): # noqa: N802
return Qt.Checked if self.isChecked() else Qt.Unchecked
def setCheckState(self, s): # noqa: N802
self.setChecked(s == Qt.Checked or s is True)
def toggle(self):
self.setChecked(not self.isChecked())
def click(self):
self.toggle()
def _event(self, kind, ref, a, b):
if kind == EV_CHANGE:
on = self.isChecked()
self.toggled.emit(on)
self.stateChanged.emit(Qt.Checked if on else Qt.Unchecked)
self.checkStateChanged.emit(Qt.Checked if on else Qt.Unchecked)
self.clicked.emit(on)
class QRadioButton(QAbstractButton):
KIND = "radio"
def __init__(self, text="", parent=None):
super().__init__(parent)
self.set("label", str(text))
self._group = None
def setText(self, t): # noqa: N802
self.set("label", str(t))
def text(self):
return self.get_str("label")
def isChecked(self): # noqa: N802
return self.get("value") != 0
def setChecked(self, b): # noqa: N802
if bool(b) != self.isChecked():
self.set("set_value", 1.0 if b else 0.0)
def click(self):
self.setChecked(True)
def _siblings(self):
if self._group is not None:
return [r for r in self._group._buttons if r is not self]
container = self.parent
if container is None:
return []
return [c for c in _kids(container) if isinstance(c, QRadioButton) and c is not self]
def _event(self, kind, ref, a, b):
if kind == EV_CHANGE:
on = self.isChecked()
if on: # Qt auto-exclusive: siblings turn off
for r in self._siblings():
if r.isChecked():
r.set("set_value", 0.0)
self.toggled.emit(on)
if on:
self.clicked.emit(True)
class QButtonGroup:
buttonClicked = Signal(object)
idClicked = Signal(int)
def __init__(self, parent=None):
self._buttons = []
def addButton(self, b, id=-1): # noqa: N802, A002
self._buttons.append(b)
b._group = self
b.clicked.connect(lambda *a, b=b: (self.buttonClicked.emit(b),
self.idClicked.emit(self._buttons.index(b))))
def buttons(self):
return list(self._buttons)
def checkedButton(self): # noqa: N802
for b in self._buttons:
if b.isChecked():
return b
return None
class QLineEdit(QWidget):
KIND = "text"
textChanged = Signal(str)
textEdited = Signal(str)
returnPressed = Signal()
editingFinished = Signal()
def __init__(self, text="", parent=None):
if isinstance(text, QWidget):
text, parent = "", text
super().__init__(parent)
self.set("live", True)
self.set("events", True)
self.set("value", str(text))
def text(self):
return self.get_str("value")
def setText(self, t): # noqa: N802
self.set("set_value", str(t))
def clear(self):
self.setText("")
def setPlaceholderText(self, t): # noqa: N802
self.set("placeholder", str(t))
def setReadOnly(self, b): # noqa: N802
self.set("enabled", not b)
def setEchoMode(self, m): # noqa: N802
pass
setMaxLength = setValidator = setClearButtonEnabled = setAlignment = setEchoMode
def keyPressEvent(self, e): # noqa: N802
pass
def _on_event(self, kind, ref, a, b):
if kind == EV_CHANGE:
self.textChanged.emit(self.text())
self.textEdited.emit(self.text())
elif kind == EV_SUBMIT:
self.returnPressed.emit()
self.editingFinished.emit()
elif kind == EV_KEY:
QWidget._on_event(self, kind, ref, a, b)
class QTextEdit(QWidget):
KIND = "textarea"
textChanged = Signal()
def __init__(self, text="", parent=None):
if isinstance(text, QWidget):
text, parent = "", text
super().__init__(parent)
self.set("value", str(text))
def toPlainText(self): # noqa: N802
return self.get_str("value")
def setPlainText(self, t): # noqa: N802
self.set("value", str(t))
self.textChanged.emit()
setText = setHtml = setPlainText
def append(self, t):
cur = self.toPlainText()
self.setPlainText(cur + ("\n" if cur else "") + str(t))
def insertPlainText(self, t): # noqa: N802
caret = self.ta_caret()
self.ta_insert(caret, str(t))
self.textChanged.emit()
def clear(self):
self.setPlainText("")
def setReadOnly(self, b): # noqa: N802
self.set("enabled", not b)
def setPlaceholderText(self, t): # noqa: N802
pass
setLineWrapMode = setWordWrapMode = setPlaceholderText
def _event(self, kind, ref, a, b):
if kind == EV_CHANGE:
self.textChanged.emit()
QPlainTextEdit = QTextEdit
class QAbstractSlider(QWidget):
valueChanged = Signal(int)
sliderMoved = Signal(int)
sliderReleased = Signal()
rangeChanged = Signal(int, int)
def _setup(self):
self.set("integer", True)
self.set("precision", 0)
self.set("min", 0.0)
self.set("max", 99.0)
self.set("step", 1.0)
def setRange(self, lo, hi): # noqa: N802
self.set("min", float(lo))
self.set("max", float(hi))
self.rangeChanged.emit(int(lo), int(hi))
def setMinimum(self, v): # noqa: N802
self.set("min", float(v))
def setMaximum(self, v): # noqa: N802
self.set("max", float(v))
def minimum(self):
return int(self.get("min"))
def maximum(self):
return int(self.get("max"))
def value(self):
return int(round(self.get("value")))
def setValue(self, v): # noqa: N802
self.set("set_value", float(v))
def setSingleStep(self, s): # noqa: N802
self.set("step", float(s))
def setPageStep(self, s): # noqa: N802
pass
setTickPosition = setTickInterval = setTracking = setPageStep
def _event(self, kind, ref, a, b):
if kind == EV_CHANGE:
self.valueChanged.emit(self.value())
self.sliderMoved.emit(self.value())
class QSlider(QAbstractSlider):
KIND = "slider"
def __init__(self, orientation=Qt.Horizontal, parent=None):
if isinstance(orientation, QWidget):
orientation, parent = Qt.Horizontal, orientation
super().__init__(parent)
def setOrientation(self, o): # noqa: N802
pass
class QDial(QSlider):
pass
class QSpinBox(QAbstractSlider):
KIND = "number"
def __init__(self, parent=None):
super().__init__(parent)
self._prefix = ""
def setSuffix(self, s): # noqa: N802
self.set("suffix", str(s))
def setPrefix(self, p): # noqa: N802
self.set("label", str(p).rstrip(": "))
def stepUp(self): # noqa: N802
self.setValue(self.value() + int(self.get("step")))
def stepDown(self): # noqa: N802
self.setValue(self.value() - int(self.get("step")))
def text(self):
return str(self.value())
class QDoubleSpinBox(QSpinBox):
valueChanged = Signal(float)
def _setup(self):
super()._setup()
self.set("integer", False)
self.set("precision", 2)
self.set("step", 0.1)
def value(self):
return self.get("value")
def setDecimals(self, d): # noqa: N802
self.set("precision", int(d))
def _event(self, kind, ref, a, b):
if kind == EV_CHANGE:
self.valueChanged.emit(self.value())
class QProgressBar(QWidget):
KIND = "progress"
valueChanged = Signal(int)
def _setup(self):
self._min, self._max, self._value = 0, 100, 0
self._format = "%p%"
self._text_visible = True
self._update()
def setRange(self, lo, hi): # noqa: N802
self._min, self._max = lo, hi
self._update()
def setMinimum(self, v): # noqa: N802
self._min = v
self._update()
def setMaximum(self, v): # noqa: N802
self._max = v
self._update()
def setValue(self, v): # noqa: N802
self._value = int(v)
self._update()
self.valueChanged.emit(self._value)
def value(self):
return self._value
def minimum(self):
return self._min
def maximum(self):
return self._max
def setFormat(self, f): # noqa: N802
self._format = f
self._update()
def setTextVisible(self, b): # noqa: N802
self._text_visible = bool(b)
self._update()
def reset(self):
self.setValue(self._min)
def _update(self):
span = (self._max - self._min) or 1
frac = max(0.0, min(1.0, (self._value - self._min) / span))
self.set("factor", frac)
pct = int(round(frac * 100))
text = self._format.replace("%p", str(pct)).replace("%v", str(self._value)) \
.replace("%m", str(self._max))
self.set("text", text if self._text_visible else "")
class QComboBox(QWidget):
KIND = "dropdown"
currentIndexChanged = Signal(int)
currentTextChanged = Signal(str)
activated = Signal(int)
def _setup(self):
self._items = []
self._data = []
def addItem(self, text, data=None): # noqa: N802
if isinstance(text, QIcon):
text, data = data, None
self._items.append(str(text))
self._data.append(data)
self.set("items", self._items)
def addItems(self, texts): # noqa: N802
for t in texts:
self.addItem(t)
def insertItem(self, index, text, data=None): # noqa: N802
self._items.insert(index, str(text))
self._data.insert(index, data)
self.set("items", self._items)
def removeItem(self, index): # noqa: N802
del self._items[index]
del self._data[index]
self.set("items", self._items)
def clear(self):
self._items, self._data = [], []
self.set("items", [])
def count(self):
return len(self._items)
def itemText(self, i): # noqa: N802
return self._items[i]
def itemData(self, i, role=None): # noqa: N802
return self._data[i]
def currentIndex(self): # noqa: N802
return int(self.get("value")) if self._items else -1
def setCurrentIndex(self, i): # noqa: N802
self.set("set_value", float(i))
def currentText(self): # noqa: N802
i = self.currentIndex()
return self._items[i] if 0 <= i < len(self._items) else ""
def setCurrentText(self, t): # noqa: N802
if t in self._items:
self.setCurrentIndex(self._items.index(t))
def currentData(self, role=None): # noqa: N802
i = self.currentIndex()
return self._data[i] if 0 <= i < len(self._data) else None
def findText(self, t): # noqa: N802
return self._items.index(t) if t in self._items else -1
def setEditable(self, b): # noqa: N802
pass
def _event(self, kind, ref, a, b):
if kind == EV_CHANGE:
i = self.currentIndex()
self.currentIndexChanged.emit(i)
self.currentTextChanged.emit(self.currentText())
self.activated.emit(i)
class QListWidgetItem:
def __init__(self, text="", parent=None):
self._text = str(text)
self._data = {}
if isinstance(parent, QListWidget):
parent.addItem(self)
def text(self):
return self._text
def setText(self, t): # noqa: N802
self._text = str(t)
lw = getattr(self, "_list", None)
if lw is not None:
lw._push()
def setData(self, role, value): # noqa: N802
self._data[role] = value
def data(self, role):
return self._data.get(role)
def setFlags(self, f): # noqa: N802
pass
def setIcon(self, *a): # noqa: N802
pass
class QListWidget(QWidget):
KIND = "list"
currentRowChanged = Signal(int)
currentItemChanged = Signal(object, object)
itemClicked = Signal(object)
itemDoubleClicked = Signal(object)
itemSelectionChanged = Signal()
def _setup(self):
self._items: List[QListWidgetItem] = []
self.set("rows", 6)
self.set("events", True)
def _push(self):
self.set("items", [i.text() for i in self._items])
def addItem(self, item): # noqa: N802
if not isinstance(item, QListWidgetItem):
item = QListWidgetItem(item)
item._list = self
self._items.append(item)
self._push()
def addItems(self, texts): # noqa: N802
for t in texts:
self.addItem(t)
def insertItem(self, row, item): # noqa: N802
if not isinstance(item, QListWidgetItem):
item = QListWidgetItem(item)
item._list = self
self._items.insert(row, item)
self._push()
def takeItem(self, row): # noqa: N802
it = self._items.pop(row)
self._push()
return it
def clear(self):
self._items = []
self._push()
def count(self):
return len(self._items)
def item(self, row):
return self._items[row] if 0 <= row < len(self._items) else None
def currentRow(self): # noqa: N802
return int(self.get("value")) if self._items else -1
def setCurrentRow(self, row): # noqa: N802
self.set("set_value", float(row))
def currentItem(self): # noqa: N802
return self.item(self.currentRow())
def row(self, item):
return self._items.index(item)
def selectedItems(self): # noqa: N802
it = self.currentItem()
return [it] if it else []
def _on_event(self, kind, ref, a, b):
if kind == EV_CHANGE:
self.currentRowChanged.emit(self.currentRow())
self.currentItemChanged.emit(self.currentItem(), None)
self.itemSelectionChanged.emit()
elif kind == EV_PRESS:
if self.currentItem() is not None:
self.itemClicked.emit(self.currentItem())
elif kind == EV_DOUBLE:
if self.currentItem() is not None:
self.itemDoubleClicked.emit(self.currentItem())
elif kind == EV_RENAME:
self._items[int(a)]._text = self.strs("items")[int(a)]
class QTreeWidgetItem:
def __init__(self, parent_or_texts=None, texts=None):
texts_ = texts if texts is not None else (
parent_or_texts if isinstance(parent_or_texts, (list, tuple)) else [])
texts_ = [str(t) for t in texts_]
self._node = buipy.KitTreeItem(texts_[0] if texts_ else "")
self._node._qitem = self
self._texts = texts_
self._children: list = []
self._parent = None
self._node.set_values(texts_[1:])
if isinstance(parent_or_texts, QTreeWidgetItem):
parent_or_texts.addChild(self)
elif isinstance(parent_or_texts, QTreeWidget):
parent_or_texts.addTopLevelItem(self)
def text(self, col):
return self._texts[col] if col < len(self._texts) else ""
def setText(self, col, text): # noqa: N802
while len(self._texts) <= col:
self._texts.append("")
self._texts[col] = str(text)
self._node.label = self._texts[0]
self._node.set_values(self._texts[1:])
def addChild(self, child): # noqa: N802
child._parent = self
self._children.append(child)
self._node.add(child._node)
def child(self, i):
return self._children[i]
def childCount(self): # noqa: N802
return len(self._children)
def parent(self):
return self._parent
def setExpanded(self, b): # noqa: N802
self._node.set("expanded", 1.0 if b else 0.0)
def isExpanded(self): # noqa: N802
return bool(self._node.get("expanded"))
def setBackground(self, *a): # noqa: N802
pass
setForeground = setFlags = setIcon = setData = setBackground
class QTreeWidget(QWidget):
KIND = "tree"
itemClicked = Signal(object, int)
itemDoubleClicked = Signal(object, int)
currentItemChanged = Signal(object, object)
itemSelectionChanged = Signal()
def _setup(self):
self._top: List[QTreeWidgetItem] = []
self._headers = []
self.set("rows", 8)
self.set("events", True)
def setHeaderLabels(self, labels): # noqa: N802
self._headers = [str(l) for l in labels]
self.set("headers", self._headers)
def setColumnCount(self, n): # noqa: N802
pass
def setHeaderHidden(self, b): # noqa: N802
if b:
self.set("headers", [])
def addTopLevelItem(self, item): # noqa: N802
self._top.append(item)
self.set_tree_roots([i._node for i in self._top])
return item
def addTopLevelItems(self, items): # noqa: N802
for i in items:
self.addTopLevelItem(i)
def topLevelItem(self, i): # noqa: N802
return self._top[i]
def topLevelItemCount(self): # noqa: N802
return len(self._top)
def clear(self):
self._top = []
self.set_tree_roots([])
def currentItem(self): # noqa: N802
n = self.tree_selected()
return getattr(n, "_qitem", None) if n is not None else None
def setCurrentItem(self, item): # noqa: N802
self.tree_select(item._node if item is not None else None)
def expandAll(self): # noqa: N802
def walk(items):
for it in items:
it.setExpanded(True)
walk(it._children)
walk(self._top)
self.invalidate()
def collapseAll(self): # noqa: N802
def walk(items):
for it in items:
it.setExpanded(False)
walk(it._children)
walk(self._top)
self.invalidate()
def selectedItems(self): # noqa: N802
it = self.currentItem()
return [it] if it else []
def _on_event(self, kind, ref, a, b):
if kind == EV_CHANGE:
self.currentItemChanged.emit(self.currentItem(), None)
self.itemSelectionChanged.emit()
elif kind == EV_PRESS and self.currentItem() is not None:
self.itemClicked.emit(self.currentItem(), 0)
elif kind == EV_DOUBLE and self.currentItem() is not None:
self.itemDoubleClicked.emit(self.currentItem(), 0)
class QTableWidgetItem:
def __init__(self, text=""):
self._text = str(text)
def text(self):
return self._text
def setText(self, t): # noqa: N802
self._text = str(t)
def setFlags(self, *a): # noqa: N802
pass
setData = setBackground = setForeground = setTextAlignment = setFlags
class QTableWidget(QWidget):
"""A flat table: one tree row per table row, columns from the headers."""
KIND = "tree"
cellClicked = Signal(int, int)
cellDoubleClicked = Signal(int, int)
currentCellChanged = Signal(int, int, int, int)
itemSelectionChanged = Signal()
def __init__(self, rows=0, columns=0, parent=None):
if isinstance(rows, QWidget):
rows, columns, parent = 0, 0, rows
super().__init__(parent)
self._rows, self._cols = int(rows), int(columns)
self._cells = {}
self._headers = [str(c + 1) for c in range(self._cols)]
self._row_nodes = []
self.set("rows", 8)
self.set("events", True)
self._rebuild()
def _rebuild(self):
self.set("headers", self._headers[:self._cols] or [""])
self._row_nodes = []
for r in range(self._rows):
texts = [self._cells[(r, c)].text() if (r, c) in self._cells else ""
for c in range(max(1, self._cols))]
node = buipy.KitTreeItem(texts[0])
node.set_values(texts[1:])
node._row = r
self._row_nodes.append(node)
self.set_tree_roots(self._row_nodes)
def setRowCount(self, n): # noqa: N802
self._rows = int(n)
self._rebuild()
def setColumnCount(self, n): # noqa: N802
self._cols = int(n)
while len(self._headers) < self._cols:
self._headers.append(str(len(self._headers) + 1))
self._rebuild()
def rowCount(self): # noqa: N802
return self._rows
def columnCount(self): # noqa: N802
return self._cols
def setHorizontalHeaderLabels(self, labels): # noqa: N802
self._headers = [str(l) for l in labels]
self._rebuild()
def setItem(self, row, col, item): # noqa: N802
self._cells[(row, col)] = item
node = self._row_nodes[row]
texts = [self._cells[(row, c)].text() if (row, c) in self._cells else ""
for c in range(max(1, self._cols))]
node.label = texts[0]
node.set_values(texts[1:])
self.invalidate()
def item(self, row, col):
return self._cells.get((row, col))
def currentRow(self): # noqa: N802
n = self.tree_selected()
return getattr(n, "_row", -1) if n is not None else -1
def currentColumn(self): # noqa: N802
return 0
def setCurrentCell(self, row, col): # noqa: N802
if 0 <= row < len(self._row_nodes):
self.tree_select(self._row_nodes[row])
def clear(self):
self._cells = {}
self._rebuild()
def _on_event(self, kind, ref, a, b):
if kind == EV_CHANGE:
self.itemSelectionChanged.emit()
self.currentCellChanged.emit(self.currentRow(), 0, -1, -1)
elif kind == EV_PRESS and self.currentRow() >= 0:
self.cellClicked.emit(self.currentRow(), 0)
elif kind == EV_DOUBLE and self.currentRow() >= 0:
self.cellDoubleClicked.emit(self.currentRow(), 0)
class QTabWidget(QWidget):
KIND = "tabs"
currentChanged = Signal(int)
def _setup(self):
self._pages, self._titles = [], []
def addTab(self, w, title): # noqa: N802
if w.parent is not None:
w.parent.remove(w)
self.add(w)
self._pages.append(w)
self._titles.append(str(title))
self.set("items", self._titles)
return len(self._pages) - 1
def currentIndex(self): # noqa: N802
return int(self.get("current"))
def setCurrentIndex(self, i): # noqa: N802
self.set("current", float(i))
self.currentChanged.emit(int(i))
def count(self):
return len(self._pages)
def widget(self, i):
return self._pages[i]
def tabText(self, i): # noqa: N802
return self._titles[i]
def setTabText(self, i, t): # noqa: N802
self._titles[i] = str(t)
self.set("items", self._titles)
def _event(self, kind, ref, a, b):
if kind == EV_CHANGE:
self.currentChanged.emit(int(a))
class QGroupBox(QWidget):
"""Drawn as a Blender panel (header + body)."""
def __init__(self, title="", parent=None):
if isinstance(title, QWidget):
title, parent = "", title
super().__init__(parent)
self.set("text", str(title))
self.set("padding", round(0.3 * buipy.kit_unit()))
def setTitle(self, t): # noqa: N802
self.set("text", str(t))
def title(self):
return self.get_str("text")
class QScrollArea(QWidget):
KIND = "scroll"
def _setup(self):
self.set("rows", 10)
def setWidget(self, w): # noqa: N802
for c in _kids(self):
self.remove(c)
self.add(w)
def setWidgetResizable(self, b): # noqa: N802
pass
setHorizontalScrollBarPolicy = setVerticalScrollBarPolicy = setWidgetResizable
class QStatusBar(QWidget):
KIND = "label"
def showMessage(self, text, timeout=0): # noqa: N802
self.set("text", str(text))
if timeout:
_timers.after(timeout, self.clearMessage)
def clearMessage(self): # noqa: N802
self.set("text", "")
def currentMessage(self): # noqa: N802
return self.get_str("text")
# ==========================================================================
# Menus & actions
class QAction:
triggered = Signal(bool)
toggled = Signal(bool)
def __init__(self, text="", parent=None, triggered=None):
if isinstance(text, QIcon):
text = parent if isinstance(parent, str) else ""
self._text = str(text)
self._shortcut = ""
self._checkable = False
self._checked = False
self._enabled = True
if triggered is not None:
self.triggered.connect(triggered)
def text(self):
return self._text
def setText(self, t): # noqa: N802
self._text = str(t)
def setShortcut(self, s): # noqa: N802
self._shortcut = str(s)
def shortcut(self):
return self._shortcut
def setCheckable(self, b): # noqa: N802
self._checkable = bool(b)
def isCheckable(self): # noqa: N802
return self._checkable
def setChecked(self, b): # noqa: N802
self._checked = bool(b)
self.toggled.emit(self._checked)
def isChecked(self): # noqa: N802
return self._checked
def setEnabled(self, b): # noqa: N802
self._enabled = bool(b)
def isEnabled(self): # noqa: N802
return self._enabled
def trigger(self):
if self._checkable:
self.setChecked(not self._checked)
self.triggered.emit(self._checked)
def setStatusTip(self, *a): # noqa: N802
pass
setToolTip = setIcon = setStatusTip
def _item(self):
return MenuItem(self._text, self.trigger, shortcut=self._shortcut.replace("+", " ")
if self._shortcut else None,
checked=self._checked if self._checkable else None,
enabled=self._enabled)
class QMenu:
aboutToShow = Signal()
triggered = Signal(object)
def __init__(self, title="", parent=None):
if isinstance(title, QWidget):
title, parent = "", title
self._title = str(title)
self._actions = []
self._parent = parent
def title(self):
return self._title
def addAction(self, action, slot=None, shortcut=None): # noqa: N802
if not isinstance(action, QAction):
action = QAction(action)
if slot is not None:
action.triggered.connect(lambda *a: slot())
if shortcut:
action.setShortcut(shortcut)
self._actions.append(action)
self._changed()
return action
def addMenu(self, menu): # noqa: N802
if not isinstance(menu, QMenu):
menu = QMenu(menu)
menu._owner_menu = self
self._actions.append(menu)
self._changed()
return menu
def addSeparator(self): # noqa: N802
self._actions.append("-")
self._changed()
def actions(self):
return [a for a in self._actions if isinstance(a, QAction)]
def clear(self):
self._actions = []
self._changed()
def _items(self):
out = []
for a in self._actions:
if a == "-":
out.append("-")
elif isinstance(a, QMenu):
out.append(MenuItem(a._title, submenu=a._items()))
else:
out.append(a._item())
return out
def _changed(self):
bar = getattr(self, "_bar", None) or getattr(getattr(self, "_owner_menu", None),
"_bar", None)
if bar is not None:
bar._rebuild()
def exec(self, pos=None):
self.popup(pos)
exec_ = exec
def popup(self, pos=None):
win = self._window_widget()
if win is None or win._ctx is None:
return
at = (pos.x(), pos.y()) if pos is not None else None
self.aboutToShow.emit()
win._ctx.open_menu(None, self._items(), None, at)
def _window_widget(self):
p = self._parent
while p is not None and isinstance(p, QWidget) and p._parent_widget is not None:
p = p._parent_widget
if p is None:
for w in _custom_or_top():
return w
return p
def _custom_or_top():
import gc
return [o for o in gc.get_objects() if isinstance(o, QWidget) and o._window is not None]
class QMenuBar:
def __init__(self, parent=None):
self._menus: List[QMenu] = []
self._node = buipy.KitNode("menubar")
def addMenu(self, menu): # noqa: N802
if not isinstance(menu, QMenu):
menu = QMenu(menu)
menu._bar = self
self._menus.append(menu)
self._rebuild()
return menu
def addAction(self, action): # noqa: N802
return action
def _rebuild(self):
for c in self._node.children:
self._node.remove(c)
for m in self._menus:
b = buipy.KitNode("menubutton")
b.set("text", m._title)
b.set_menu(m._items())
self._node.add(b)
def absolutePos(self): # noqa: N802
r = self._node.rect
return r[0], r[1]
# ==========================================================================
# QPainter (records into the widget's kit canvas)
class QPainter:
Antialiasing = TextAntialiasing = SmoothPixmapTransform = 1
def __init__(self, device=None):
self._dev = None
self._pen = QPen(QColor("#000000"), 1)
self._brush = None
self._font = QFont()
self._opacity = 1.0
self._dx = self._dy = 0.0
self._stack = []
if device is not None:
self.begin(device)
def begin(self, device):
self._dev = device
return True
def end(self):
self._dev = None
return True
def isActive(self): # noqa: N802
return self._dev is not None
def setRenderHint(self, *a): # noqa: N802
pass
setRenderHints = setRenderHint
def save(self):
self._stack.append((self._pen, self._brush, self._font, self._opacity, self._dx,
self._dy))
def restore(self):
if self._stack:
(self._pen, self._brush, self._font, self._opacity, self._dx,
self._dy) = self._stack.pop()
def translate(self, dx, dy=None):
if dy is None:
dx, dy = dx.x(), dx.y()
self._dx += dx
self._dy += dy
def setPen(self, p): # noqa: N802
if p is None or p == Qt.NoPen:
self._pen = None
elif isinstance(p, QPen):
self._pen = p
else:
self._pen = QPen(p, 1)
def setBrush(self, b): # noqa: N802
if b is None or b == Qt.NoBrush:
self._brush = None
else:
self._brush = b if isinstance(b, QBrush) else QBrush(b)
def setFont(self, f): # noqa: N802
self._font = f
def setOpacity(self, o): # noqa: N802
self._opacity = float(o)
def _c(self, c):
rgba = _rgba(c)
if rgba is None:
return None
return rgba[:3] + (rgba[3] * self._opacity,)
def _add(self, kind, coords, fill=None, outline=None, width=1.0, text=None, **kw):
dev = self._dev
if dev is None:
return
dev._paint_id = getattr(dev, "_paint_id", 0) + 1
xy = [v + (self._dx if i % 2 == 0 else self._dy) for i, v in enumerate(coords)]
dev.canvas_set(dev._paint_id, kind, xy, fill=fill, outline=outline, width=width,
text=text, **kw)
def _pen_rgba(self):
return self._c(self._pen._color) if self._pen is not None else None
def _pen_w(self):
return float(self._pen._width or 1) if self._pen is not None else 1.0
def _brush_rgba(self):
return self._c(self._brush._color) if self._brush is not None else None
@staticmethod
def _rect_args(args):
if len(args) == 1 and isinstance(args[0], QRect):
r = args[0]
return r.x(), r.y(), r.width(), r.height()
return args[:4]
def fillRect(self, *args): # noqa: N802
if isinstance(args[0], QRect):
x, y, w, h = self._rect_args(args[:1])
c = args[1]
else:
x, y, w, h, c = args[:5]
self._add(0, [x, y, x + w, y + h], fill=self._c(c.color() if isinstance(c, QBrush)
else c))
def drawRect(self, *args): # noqa: N802
x, y, w, h = self._rect_args(args)
self._add(0, [x, y, x + w, y + h], fill=self._brush_rgba(), outline=self._pen_rgba(),
width=self._pen_w())
def drawRoundedRect(self, *args): # noqa: N802
if isinstance(args[0], QRect):
x, y, w, h = self._rect_args(args[:1])
rx = args[1]
else:
x, y, w, h, rx = args[:5]
self._add(7, [x, y, x + w, y + h], fill=self._brush_rgba(), outline=self._pen_rgba(),
width=self._pen_w(), radius=float(rx))
def drawEllipse(self, *args): # noqa: N802
if len(args) == 3 and isinstance(args[0], QPoint):
c, rx, ry = args
x, y, w, h = c.x() - rx, c.y() - ry, 2 * rx, 2 * ry
else:
x, y, w, h = self._rect_args(args)
self._add(1, [x, y, x + w, y + h], fill=self._brush_rgba(), outline=self._pen_rgba(),
width=self._pen_w())
def drawLine(self, *args): # noqa: N802
if len(args) == 2:
p1, p2 = args
args = (p1.x(), p1.y(), p2.x(), p2.y())
x1, y1, x2, y2 = args
self._add(2, [x1, y1, x2, y2], outline=self._pen_rgba(), width=self._pen_w())
def drawPolyline(self, points): # noqa: N802
flat = []
for p in points:
flat += [p.x(), p.y()] if isinstance(p, QPoint) else list(p)
self._add(2, flat, outline=self._pen_rgba(), width=self._pen_w())
def drawPolygon(self, points, *a): # noqa: N802
flat = []
for p in points:
flat += [p.x(), p.y()] if isinstance(p, QPoint) else list(p)
self._add(3, flat, fill=self._brush_rgba(), outline=self._pen_rgba(),
width=self._pen_w())
def drawPoint(self, x, y=None): # noqa: N802
if y is None:
x, y = x.x(), x.y()
self._add(0, [x, y, x + 1, y + 1], fill=self._pen_rgba())
def _arc(self, kind_fill, args):
if isinstance(args[0], QRect):
x, y, w, h = self._rect_args(args[:1])
start, span = args[1], args[2]
else:
x, y, w, h, start, span = args[:6]
self._add(5, [x, y, x + w, y + h], fill=self._brush_rgba() if kind_fill else None,
outline=self._pen_rgba(), width=self._pen_w(), start=start / 16.0,
extent=span / 16.0)
def drawArc(self, *args): # noqa: N802
self._arc(False, args)
def drawPie(self, *args): # noqa: N802
self._arc(True, args)
def drawText(self, *args): # noqa: N802
size = float(self._font._size) * 1.33 if self._font._size and self._font._size > 0 \
else 0.0
if isinstance(args[0], QRect):
r, flags, text = args[0], args[1], args[2]
ax = (r.x() + r.width() / 2 if flags & Qt.AlignHCenter else
(r.x() + r.width() if flags & Qt.AlignRight else r.x()))
ay = (r.y() if flags & Qt.AlignTop else
(r.y() + r.height() if flags & Qt.AlignBottom else r.y() + r.height() / 2))
anchor = (0 if flags & Qt.AlignHCenter else (E if flags & Qt.AlignRight else W)) | \
(N if flags & Qt.AlignTop else (S if flags & Qt.AlignBottom else 0))
self._add(4, [ax, ay], fill=self._pen_rgba(), text=str(text), size=size,
anchor=anchor)
else:
if isinstance(args[0], QPoint):
x, y, text = args[0].x(), args[0].y(), args[1]
else:
x, y, text = args[:3]
# Qt draws text at its baseline: anchor south-west on the baseline
self._add(4, [x, y], fill=self._pen_rgba(), text=str(text), size=size,
anchor=S | W)
def drawPixmap(self, *args): # noqa: N802
if isinstance(args[0], QPoint):
x, y, pm = args[0].x(), args[0].y(), args[1]
else:
x, y, pm = args[0], args[1], args[2]
img = pm._img
self._add(6, [x, y], image=(img.width(), img.height(), img.rgba()), anchor=N | W)
drawImage = drawPixmap
# ==========================================================================
# Dialog stubs (no blocking native dialogs)
class QMessageBox:
Ok, Cancel, Yes, No = 0x400, 0x400000, 0x4000, 0x10000
@staticmethod
def information(parent, title, text, *a, **kw):
return QMessageBox.Ok
warning = critical = about = information
@staticmethod
def question(parent, title, text, *a, **kw):
return QMessageBox.Yes
class QFileDialog:
@staticmethod
def _blender(kind, caption, directory, filter, multiple=False): # noqa: A002
"""Blender's file browser (bui.filebrowser); None when BUI_FILEDIALOG=native."""
if not filebrowser.enabled():
return None
initialdir, initialfile = (directory, None) if not directory or os.path.isdir(
directory) else os.path.split(directory)
result = filebrowser.ask(kind, title=caption or None, initialdir=initialdir or None,
initialfile=initialfile, multiple=multiple,
filters=filebrowser.qt_filters(filter))
if result is None:
return [] if multiple else ""
return result
@staticmethod
def getOpenFileNames(parent=None, caption="", directory="", filter="", *a): # noqa: N802,A002
paths = QFileDialog._blender("open", caption, directory, filter, multiple=True)
return (paths or [], "")
@staticmethod
def getOpenFileName(parent=None, caption="", directory="", filter="", *a): # noqa: N802,A002
path = QFileDialog._blender("open", caption, directory, filter)
if path is not None:
return path, ""
try:
filedialog = _realtk.module("tkinter.filedialog")
return filedialog.askopenfilename(title=caption), ""
except Exception:
return "", ""
@staticmethod
def getSaveFileName(parent=None, caption="", directory="", filter="", *a): # noqa: N802,A002
path = QFileDialog._blender("save", caption, directory, filter)
if path is not None:
return path, ""
try:
filedialog = _realtk.module("tkinter.filedialog")
return filedialog.asksaveasfilename(title=caption), ""
except Exception:
return "", ""
@staticmethod
def getExistingDirectory(parent=None, caption="", directory="", *a): # noqa: N802
path = QFileDialog._blender("directory", caption, directory, "")
if path is not None:
return path
try:
filedialog = _realtk.module("tkinter.filedialog")
return filedialog.askdirectory(title=caption)
except Exception:
return ""
QStackedWidget = QWidget