vp6 0.4.3__py3-none-any.whl

vp6/__init__.py

@@ -0,0 +1,37 @@
+"""VP6 - VB6-style GUI programming for Python.
+
+    from vp6 import *
+"""
+
+from .appearance import (vpSchemeDark, vpSchemeIDE, vpSchemeLight, vpSchemeProjectDefault,
+                         vpSchemeSystem)
+from .app import App, Beep, Clipboard, Debug, DoEvents, End, Screen
+from .colors import (RGB, QBColor, vpBlack, vpBlue, vpCyan, vpGreen, vpMagenta, vpRed,
+                     vpWhite, vpYellow)
+from .constants import *  # noqa: F403
+from .constants import __all__ as _constants_all
+from .controls import (Button, CheckBox, ColumnHeader, ComboBox, CommandButton, Control,
+                       ControlArray, Frame, HScrollBar, Image, ImageList, Label, Line, ListBox,
+                       ListImage, ListItem, ListView, Menu, Node, OptionButton,
+                       Panel, PictureBox, ProgressBar, Slider, Splitter, StatusBar, Tab,
+                       TabStrip, TextBox, Timer, Toolbar, TreeView, UpDown, VScrollBar)
+from .dialogs import InputBox, MsgBox
+from .form import Form, Forms, Load, Unload, run
+
+__version__ = "0.4.3"
+
+__all__ = [
+    "App", "Beep", "Clipboard", "Debug", "DoEvents", "End", "Screen",
+    "RGB", "QBColor", "vpBlack", "vpBlue", "vpCyan", "vpGreen", "vpMagenta", "vpRed",
+    "vpWhite", "vpYellow",
+    "Button", "CheckBox", "ColumnHeader", "ComboBox", "CommandButton", "Control", "ControlArray", "Frame", "HScrollBar",
+    "Image", "ImageList", "Label", "Line", "ListBox", "ListImage", "ListItem", "ListView",
+    "Menu", "Node",
+    "OptionButton", "PictureBox",
+    "Panel", "ProgressBar", "Slider", "Splitter", "StatusBar", "Tab", "TabStrip", "TextBox",
+    "Timer", "Toolbar", "TreeView", "UpDown", "VScrollBar",
+    "InputBox", "MsgBox",
+    "Form", "Forms", "Load", "Unload", "run",
+    "vpSchemeProjectDefault", "vpSchemeSystem", "vpSchemeLight", "vpSchemeDark", "vpSchemeIDE",
+    *_constants_all,
+]

vp6/_props.py

@@ -0,0 +1,108 @@
+"""Declarative VB-style properties.
+
+Every form/control class lists its designable properties as ``PropSpec``
+entries. For each one a Python property is generated that:
+
+* normalizes the assigned value (``kind``),
+* stores it in ``self._values``,
+* calls ``self._apply_<Name>(value)`` so the class can update the Qt widget.
+
+A class can define ``_read_<Name>()`` when the live value comes from the
+widget (e.g. the text the user typed into a TextBox).
+
+The same metadata drives the IDE: the property grid, the designer region
+serializer and default-value elision.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from . import colors
+
+
+@dataclass(frozen=True)
+class PropSpec:
+    name: str
+    # str, text, int, bool, enum, color, font, file, shortcut; list and outline (lines
+    # of text); panels, tabs, images, buttons, columns and listitems (lines of
+    # text that are a collection at run time: StatusBar.Panels, TabStrip.Tabs, ...)
+    kind: str = "str"
+    default: object = None
+    choices: tuple = ()  # enum: ((value, "label"), ...)
+    always: bool = False  # always written to the designer region
+    description: str = ""
+
+
+def P(name, kind="str", default=None, choices=(), always=False, description=""):
+    return PropSpec(name, kind, default, tuple(choices), always, description)
+
+
+def enum_choices(*labels: str) -> tuple:
+    """enum_choices("None", "Fixed Single") -> ((0, "0 - None"), (1, "1 - Fixed Single"))"""
+    return tuple((i, f"{i} - {label}") for i, label in enumerate(labels))
+
+
+def normalize(kind: str, value):
+    if value is None:
+        return None
+    if kind in ("str", "text", "file", "font", "shortcut"):
+        return str(value)
+    if kind in ("int", "enum"):
+        return int(value)
+    if kind == "bool":
+        return bool(value)
+    if kind == "color":
+        return colors.normalize(value)
+    if kind in ("list", "outline", "panels", "tabs", "images", "buttons", "columns",
+                "listitems"):
+        if isinstance(value, str):
+            value = value.splitlines()
+        return [str(v) for v in value]
+    return value
+
+
+def _make_property(name: str) -> property:
+    def fget(self):
+        reader = getattr(self, "_read_" + name, None)
+        if reader is not None:
+            return reader()
+        return self._values.get(name, self._specs[name].default)
+
+    def fset(self, value):
+        self._set_prop(name, value)
+
+    return property(fget, fset, doc=f"VB property {name}")
+
+
+class PropertyHost:
+    Properties: tuple[PropSpec, ...] = ()
+    _specs: dict[str, PropSpec] = {}
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+        cls._specs = {spec.name: spec for spec in cls.Properties}
+        for spec in cls.Properties:
+            if not isinstance(getattr(cls, spec.name, None), property):
+                setattr(cls, spec.name, _make_property(spec.name))
+
+    def _init_values(self, props: dict) -> None:
+        """Apply defaults, then the given property values, in spec order."""
+        unknown = set(props) - set(self._specs)
+        if unknown:
+            raise AttributeError(
+                f"{type(self).__name__} has no properties: {', '.join(sorted(unknown))}")
+        for spec in self.Properties:
+            self._set_prop(spec.name, props.get(spec.name, spec.default))
+
+    def _set_prop(self, name: str, value) -> None:
+        spec = self._specs[name]
+        value = normalize(spec.kind, value)
+        self._values[name] = value
+        applier = getattr(self, "_apply_" + name, None)
+        if applier is not None:
+            applier(value)
+
+    @classmethod
+    def properties(cls) -> tuple[PropSpec, ...]:
+        return cls.Properties

vp6/app.py

@@ -0,0 +1,300 @@
+"""Application level services: the Qt application, App/Screen/Clipboard
+objects, DoEvents, End and the VB style run-time error handling."""
+
+from __future__ import annotations
+
+import inspect
+import os
+import signal
+import socket
+import sys
+import threading
+import traceback
+
+from PySide6.QtCore import QEventLoop, QObject, QSocketNotifier, QTimer
+from PySide6.QtGui import QGuiApplication, QIcon
+from PySide6.QtWidgets import QApplication, QDialog, QMessageBox
+
+_interrupt_handler = None  # installed by ensure_app() for VP6 programs
+
+
+def ensure_app() -> QApplication:
+    """Return the QApplication, creating it on first use. A VP6 program
+    creates it here, so this is also where Ctrl+C gets wired to closing the
+    program's forms, and where it gets the VP6 icon (until the project's own
+    icon replaces it, see set_program_icon). (The IDE and the tests create
+    their own QApplication and keep their own Ctrl+C behavior.)"""
+    global _interrupt_handler
+    app = QApplication.instance()
+    if app is None:
+        app = QApplication(sys.argv[:1])
+        _interrupt_handler = install_interrupt_handler(close_all_windows)
+        app.setWindowIcon(vp6_icon())
+    return app
+
+
+# --- icons -----------------------------------------------------------------------------------
+
+# The VP6 icon (project.VP6_ICON_FILES, several sizes): the IDE's icon, and
+# every program's until its project names its own
+
+
+def icon_from(paths) -> QIcon:
+    """An icon from image files (the sizes of one picture); missing files are
+    skipped, so the icon may be null."""
+    icon = QIcon()
+    for path in paths:
+        if os.path.isfile(path):
+            icon.addFile(path)
+    return icon
+
+
+def vp6_icon() -> QIcon:
+    from .project import VP6_ICON_FILES
+
+    return icon_from(VP6_ICON_FILES)
+
+
+def set_program_icon(paths) -> bool:
+    """Make these image files the program's icon (its windows, and the Dock or
+    taskbar). Returns False, keeping the icon it had, if none can be read."""
+    app = ensure_app()  # first: Qt can't read images before there is an application
+    icon = icon_from(paths)
+    if icon.isNull():
+        return False
+    app.setWindowIcon(icon)
+    return True
+
+
+# --- Ctrl+C -----------------------------------------------------------------------------
+
+class InterruptHandler(QObject):
+    """Makes Ctrl+C (SIGINT) in the terminal run ``action`` in a Qt program.
+
+    Python runs signal handlers only when it gets control back, and Qt's
+    event loop can stay in C++ indefinitely, so SIGINT would be ignored. The
+    signal module writes to a socket on every signal (``set_wakeup_fd``); a
+    socket notifier on it returns control to Python, which then runs the
+    handler. Before ``action``, any open modal window (a MsgBox, a dialog, a
+    form shown with vpModal) is closed, since it would block. A repeated
+    Ctrl+C while ``action`` is still running (e.g. a Form_Unload asking
+    "Close?") is ignored."""
+
+    def __init__(self, action, parent=None):
+        super().__init__(parent)
+        self._action = action
+        self._busy = False
+        self._receive, self._send = socket.socketpair()
+        for sock in (self._receive, self._send):
+            sock.setblocking(False)
+        signal.set_wakeup_fd(self._send.fileno())
+        signal.signal(signal.SIGINT, self._on_interrupt)
+        self._notifier = QSocketNotifier(self._receive.fileno(), QSocketNotifier.Read, self)
+        self._notifier.activated.connect(self._drain)
+
+    def _drain(self, *_):
+        try:
+            self._receive.recv(64)
+        except OSError:
+            pass
+        # Back in Python: the pending SIGINT handler runs now
+
+    def _on_interrupt(self, signum, frame):
+        QTimer.singleShot(0, self, self._run)
+
+    def _run(self):
+        if self._busy:
+            return
+        modal = QApplication.activeModalWidget()
+        if modal is not None:
+            # Close it, then continue once its event loop has returned
+            modal.reject() if isinstance(modal, QDialog) else modal.close()
+            QTimer.singleShot(0, self, self._run)
+            return
+        self._busy = True
+        try:
+            self._action()
+        finally:
+            self._busy = False
+
+
+def install_interrupt_handler(action, parent=None) -> InterruptHandler | None:
+    """Run ``action`` on Ctrl+C. Returns None where signals can't be handled
+    (not the main thread)."""
+    if threading.current_thread() is not threading.main_thread():
+        return None
+    try:
+        return InterruptHandler(action, parent)
+    except (ValueError, OSError):
+        return None
+
+
+def close_all_windows() -> None:
+    """Ctrl+C in a VP6 program: close its windows like their close buttons
+    would, so each Form_Unload runs (and may cancel). When the last one
+    closes, the program ends."""
+    app = QApplication.instance()
+    windows = [w for w in app.topLevelWidgets() if w.isVisible()]
+    if not windows:
+        app.quit()  # an event loop without windows: just stop it
+        return
+    for window in windows:
+        window.close()
+
+
+def DoEvents() -> None:
+    """Process pending GUI events, like VB6's DoEvents."""
+    app = QApplication.instance()
+    if app is not None:
+        app.processEvents(QEventLoop.AllEvents)
+
+
+def Beep() -> None:
+    ensure_app()
+    QApplication.beep()
+
+
+def End() -> None:
+    """Terminate the program immediately, like VB6's End statement: no form
+    gets Form_Unload (closing the windows would run it, so they aren't
+    closed; the process just ends)."""
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(0)
+
+
+class _App:
+    """The VB ``App`` object."""
+
+    Title = ""
+
+    @property
+    def Path(self) -> str:
+        main = sys.modules.get("__main__")
+        path = getattr(main, "__file__", None)
+        return os.path.dirname(os.path.abspath(path)) if path else os.getcwd()
+
+    @property
+    def EXEName(self) -> str:
+        return self.Title or os.path.splitext(os.path.basename(sys.argv[0] or "app"))[0]
+
+
+class _Screen:
+    """The VB ``Screen`` object (sizes in pixels)."""
+
+    @property
+    def Width(self) -> int:
+        ensure_app()
+        return QGuiApplication.primaryScreen().size().width()
+
+    @property
+    def Height(self) -> int:
+        ensure_app()
+        return QGuiApplication.primaryScreen().size().height()
+
+    @property
+    def ActiveForm(self):
+        widget = QApplication.activeWindow()
+        return getattr(widget, "_vp_form", None)
+
+
+class _Clipboard:
+    """The VB ``Clipboard`` object."""
+
+    def GetText(self) -> str:
+        ensure_app()
+        return QGuiApplication.clipboard().text()
+
+    def SetText(self, text: str) -> None:
+        ensure_app()
+        QGuiApplication.clipboard().setText(str(text))
+
+    def Clear(self) -> None:
+        ensure_app()
+        QGuiApplication.clipboard().clear()
+
+
+class _Debug:
+    """``Debug.Print`` writes to the IDE's Immediate window (stdout)."""
+
+    @staticmethod
+    def Print(*values) -> None:
+        print(*values, flush=True)
+
+
+App = _App()
+Screen = _Screen()
+Clipboard = _Clipboard()
+Debug = _Debug()
+
+
+# --- event handler invocation -------------------------------------------------
+
+_arity_cache: dict = {}
+
+
+def _positional_capacity(func) -> int | None:
+    """How many positional arguments ``func`` (a bound method) accepts;
+    None means unlimited."""
+    key = getattr(func, "__func__", func)
+    if key in _arity_cache:
+        return _arity_cache[key]
+    try:
+        params = inspect.signature(func).parameters.values()
+    except (TypeError, ValueError):
+        result = None
+    else:
+        if any(p.kind == p.VAR_POSITIONAL for p in params):
+            result = None
+        else:
+            result = sum(1 for p in params
+                         if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD))
+    _arity_cache[key] = result
+    return result
+
+
+def call_handler(handler, *args):
+    """Call an event handler, passing only as many arguments as it declares.
+
+    ``def Command1_MouseDown(self, Button, Shift, X, Y)`` and
+    ``def Command1_MouseDown(self)`` both work. Exceptions are reported as VB
+    style run-time errors instead of silently vanishing inside Qt.
+    """
+    capacity = _positional_capacity(handler)
+    if capacity is not None:
+        args = args[:capacity]
+    try:
+        return handler(*args)
+    except SystemExit:
+        raise
+    except Exception as exc:  # noqa: BLE001 - this is the top-level error trap
+        report_runtime_error(exc)
+        return None
+
+
+def report_runtime_error(exc: BaseException) -> None:
+    traceback.print_exception(exc, file=sys.stderr)
+    sys.stderr.flush()
+    if os.environ.get("VP6_NO_ERROR_DIALOG"):
+        return
+    box = QMessageBox()
+    box.setIcon(QMessageBox.Critical)
+    box.setWindowTitle(App.EXEName or "VP6")
+    box.setText(f"Run-time error:\n\n{type(exc).__name__}: {exc}")
+    box.setDetailedText("".join(traceback.format_exception(exc)))
+    end_button = box.addButton("End", QMessageBox.DestructiveRole)
+    box.addButton("Continue", QMessageBox.AcceptRole)
+    box.exec()
+    if box.clickedButton() is end_button:
+        End()
+
+
+def run_event_loop() -> int:
+    """Run the GUI event loop while any window is open."""
+    app = QApplication.instance()
+    if app is None or not any(w.isVisible() for w in app.topLevelWidgets()):
+        return 0
+    return app.exec()
+
+
+__all__ = ["App", "Screen", "Clipboard", "Debug", "DoEvents", "Beep", "End"]

vp6/appearance.py

@@ -0,0 +1,248 @@
+"""Light / dark color schemes for forms.
+
+``Form.ColorScheme`` is one of:
+
+* ``vpSchemeProjectDefault`` (0) - use the project's scheme (the default),
+* ``vpSchemeSystem`` (1) - native look, follows the OS appearance live,
+* ``vpSchemeLight`` (2) / ``vpSchemeDark`` (3) - forced light or dark,
+* ``vpSchemeIDE`` (4) - follow the VP6 IDE's appearance: live in the
+  designer; when run from the IDE, the IDE's appearance at launch (passed in
+  the ``VP6_IDE_SCHEME`` environment variable); otherwise System.
+
+Native styles (notably macOS) ignore widget palettes, so forced schemes use
+Qt's Fusion style with a fixed light or dark palette on the form, its
+controls and the message boxes shown over it.
+
+The project scheme is set by the runner from the ``.vp6p`` file. When a
+form runs on its own (``python Form1.py``) it is read from a ``.vp6p`` next
+to the form's file, if there is one.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+import sys
+
+import shiboken6
+from PySide6.QtGui import QColor, QGuiApplication, QPalette
+from PySide6.QtWidgets import QStyle, QStyleFactory, QWidget
+
+vpSchemeProjectDefault = 0
+vpSchemeSystem = 1
+vpSchemeLight = 2
+vpSchemeDark = 3
+vpSchemeIDE = 4
+
+PROJECT_SCHEMES = {"system": vpSchemeSystem, "light": vpSchemeLight, "dark": vpSchemeDark,
+                   "ide": vpSchemeIDE}
+SCHEME_NAMES = {v: k for k, v in PROJECT_SCHEMES.items()}
+IDE_SCHEME_ENV = "VP6_IDE_SCHEME"
+
+# Set by the IDE (inside the IDE process): returns System, Light or Dark
+ide_scheme_provider = None
+
+# Set by the project runner; None = look for a .vp6p next to the form
+project_scheme: int | None = None
+_found_schemes: dict[str, int] = {}
+_fusion = None  # see fusion_style
+_fusion_address = None
+
+
+def scheme_from_name(name: str | None) -> int:
+    return PROJECT_SCHEMES.get((name or "system").lower(), vpSchemeSystem)
+
+
+def ide_scheme() -> int:
+    """What vpSchemeIDE currently means: System, Light or Dark."""
+    if ide_scheme_provider is not None:
+        return ide_scheme_provider()
+    scheme = PROJECT_SCHEMES.get(os.environ.get(IDE_SCHEME_ENV, "").lower(), vpSchemeSystem)
+    return scheme if scheme != vpSchemeIDE else vpSchemeSystem
+
+
+def resolve(scheme: int) -> int:
+    """Turn any scheme except Project Default into System, Light or Dark."""
+    if scheme == vpSchemeIDE:
+        scheme = ide_scheme()
+    return scheme if scheme in (vpSchemeLight, vpSchemeDark) else vpSchemeSystem
+
+
+def project_scheme_for(directory: str) -> int:
+    """The project scheme for a form in ``directory``."""
+    if project_scheme is not None:
+        return project_scheme
+    if directory not in _found_schemes:
+        scheme = vpSchemeSystem
+        from .project import Project
+
+        for path in sorted(glob.glob(os.path.join(directory, "*.vp6p"))):
+            try:
+                scheme = scheme_from_name(Project.load(path).color_scheme)
+                break
+            except (OSError, ValueError):
+                continue
+        _found_schemes[directory] = scheme
+    return _found_schemes[directory]
+
+
+def _qt_scheme_is_dark() -> bool:
+    from PySide6.QtCore import Qt
+
+    scheme = QGuiApplication.styleHints().colorScheme()
+    if scheme == Qt.ColorScheme.Dark:
+        return True
+    if scheme == Qt.ColorScheme.Light:
+        return False
+    return QGuiApplication.palette().color(QPalette.Window).lightness() < 128
+
+
+# The IDE can force the whole application light or dark. Qt then reports the
+# forced scheme, so the real OS appearance is queried from the OS instead.
+_override_active = False
+_os_dark_before_override = False
+_os_query_cache: tuple[float, bool] | None = None
+
+
+def set_app_override(active: bool) -> None:
+    """Called by the IDE before it forces (or stops forcing) the app scheme."""
+    global _override_active, _os_dark_before_override, _os_query_cache
+    if active and not _override_active:
+        _os_dark_before_override = _qt_scheme_is_dark()
+    _override_active = active
+    _os_query_cache = None
+
+
+def app_override_active() -> bool:
+    return _override_active
+
+
+def _query_os_dark() -> bool:
+    global _os_query_cache
+    import time
+
+    now = time.monotonic()
+    if _os_query_cache and now - _os_query_cache[0] < 2:
+        return _os_query_cache[1]
+    dark = _os_dark_before_override
+    try:
+        if sys.platform == "darwin":
+            import subprocess
+
+            result = subprocess.run(["defaults", "read", "-g", "AppleInterfaceStyle"],
+                                    capture_output=True, text=True, timeout=1)
+            dark = result.stdout.strip().lower() == "dark"
+        elif sys.platform == "win32":
+            import winreg
+
+            key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows"
+                                 r"\CurrentVersion\Themes\Personalize")
+            dark = winreg.QueryValueEx(key, "AppsUseLightTheme")[0] == 0
+    except Exception:  # noqa: BLE001 - fall back to the last known appearance
+        pass
+    _os_query_cache = (now, dark)
+    return dark
+
+
+def system_is_dark() -> bool:
+    """Whether the operating system appearance is dark."""
+    return _query_os_dark() if _override_active else _qt_scheme_is_dark()
+
+
+def is_dark(scheme: int) -> bool:
+    """Whether a resolved scheme (System/Light/Dark) renders dark right now."""
+    return scheme == vpSchemeDark or (scheme == vpSchemeSystem and system_is_dark())
+
+
+def fusion_style():
+    """One shared Fusion style, a child of the application so it outlives
+    every widget using it. Don't keep what this returns: call it again.
+
+    PySide treats a style as belonging to the widgets it is set on, and when
+    such a widget is destroyed (e.g. a Toolbar's buttons being rebuilt) it
+    invalidates the style's Python wrapper, although the C++ style lives on
+    and other widgets still use it. So the style is remembered by its C++
+    address, and a fresh wrapper is found among the application's children
+    when the old one was invalidated."""
+    global _fusion, _fusion_address
+    if _fusion is not None and shiboken6.isValid(_fusion):
+        return _fusion
+    app = QGuiApplication.instance()
+    if _fusion_address is not None:
+        for child in app.children():  # the same style: a new wrapper
+            if isinstance(child, QStyle) and shiboken6.getCppPointer(child)[0] == \
+                    _fusion_address:
+                _fusion = child
+                return _fusion
+    _fusion = QStyleFactory.create("Fusion")
+    _fusion.setParent(app)
+    _fusion_address = shiboken6.getCppPointer(_fusion)[0]
+    return _fusion
+
+
+def _palette(colors: dict, disabled: dict) -> QPalette:
+    palette = QPalette()
+    for role, color in colors.items():
+        palette.setColor(role, QColor(color))
+    for role, color in disabled.items():
+        palette.setColor(QPalette.Disabled, role, QColor(color))
+    return palette
+
+
+def scheme_palette(dark: bool) -> QPalette:
+    """A complete palette for a forced light or dark scheme."""
+    if dark:
+        return _palette({
+            QPalette.Window: "#353535", QPalette.WindowText: "#f0f0f0",
+            QPalette.Base: "#252525", QPalette.AlternateBase: "#303030",
+            QPalette.Text: "#f0f0f0", QPalette.Button: "#3c3c3c",
+            QPalette.ButtonText: "#f0f0f0", QPalette.BrightText: "#ff5555",
+            QPalette.Light: "#505050", QPalette.Midlight: "#454545", QPalette.Mid: "#2a2a2a",
+            QPalette.Dark: "#1e1e1e", QPalette.Shadow: "#141414",
+            QPalette.Highlight: "#2a82da", QPalette.HighlightedText: "#ffffff",
+            QPalette.Link: "#5aa9f0", QPalette.LinkVisited: "#b48ef0",
+            QPalette.ToolTipBase: "#454545", QPalette.ToolTipText: "#f0f0f0",
+            QPalette.PlaceholderText: "#8a8a8a",
+        }, {QPalette.WindowText: "#7f7f7f", QPalette.Text: "#7f7f7f",
+            QPalette.ButtonText: "#7f7f7f", QPalette.Base: "#2d2d2d"})
+    return _palette({
+        QPalette.Window: "#efefef", QPalette.WindowText: "#000000",
+        QPalette.Base: "#ffffff", QPalette.AlternateBase: "#f7f7f7",
+        QPalette.Text: "#000000", QPalette.Button: "#efefef",
+        QPalette.ButtonText: "#000000", QPalette.BrightText: "#ffffff",
+        QPalette.Light: "#ffffff", QPalette.Midlight: "#cacaca", QPalette.Mid: "#b8b8b8",
+        QPalette.Dark: "#9f9f9f", QPalette.Shadow: "#767676",
+        QPalette.Highlight: "#308cc6", QPalette.HighlightedText: "#ffffff",
+        QPalette.Link: "#0000ff", QPalette.LinkVisited: "#ff00ff",
+        QPalette.ToolTipBase: "#ffffdc", QPalette.ToolTipText: "#000000",
+        QPalette.PlaceholderText: "#7f7f7f",
+    }, {QPalette.WindowText: "#bebebe", QPalette.Text: "#bebebe",
+        QPalette.ButtonText: "#bebebe", QPalette.Base: "#efefef"})
+
+
+def style_tree(widget: QWidget, style) -> None:
+    """Apply ``style`` (None = the application style) to a widget and all its
+    descendants; Qt doesn't propagate styles to children."""
+    from PySide6.QtCore import Qt
+
+    for w in [widget, *widget.findChildren(QWidget)]:
+        if style is None:
+            if w.testAttribute(Qt.WA_SetStyle):
+                w.setStyle(None)
+        else:
+            w.setStyle(style)
+
+
+def match_dialog(dialog: QWidget, parent: QWidget | None) -> None:
+    """Give a message box the color scheme of the form it is shown over."""
+    form = getattr(parent.window(), "_vp_form", None) if parent is not None else None
+    if form is None:
+        return
+    scheme = form._effective_scheme()
+    if scheme in (vpSchemeLight, vpSchemeDark):
+        dialog.setPalette(scheme_palette(scheme == vpSchemeDark))
+        style_tree(dialog, fusion_style())
+
+
+__all__ = ["vpSchemeProjectDefault", "vpSchemeSystem", "vpSchemeLight", "vpSchemeDark",
+           "vpSchemeIDE"]