visualdynamics 0.1.0a1__tar.gz → 0.1.0a2__tar.gz

{visualdynamics-0.1.0a1/src/visualdynamics.egg-info → visualdynamics-0.1.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visualdynamics
-Version: 0.1.0a1
+Version: 0.1.0a2
 Summary: Structural Dynamics Visualization: a units-aware structural dynamics analysis toolset
 Author-email: Brandon Zwink <bzwink@gmail.com>
 License-Expression: GPL-3.0-or-later

{visualdynamics-0.1.0a1 → visualdynamics-0.1.0a2}/src/visualdynamics/__init__.py

@@ -76,7 +76,7 @@ from .units import (
 #: alpha, said in the version itself so the dialog, the About text, the
 #: installers and latest.json all say the same thing, and the first
 #: non-alpha release is offered as an upgrade (Brandon, 2026-09-11)
-__version__ = '0.1.0a1'
+__version__ = '0.1.0a2'
 
 
 def launch_gui(*paths: str, in_process: bool | None = None) -> Any:

{visualdynamics-0.1.0a1 → visualdynamics-0.1.0a2}/src/visualdynamics/gui/__init__.py

@@ -92,6 +92,30 @@ def check_qt_binding() -> None:
         f'which then breaks sdynpy\'s own plotting in that process.')
 
 
+def theme_flag(argv: list[str]) -> tuple[list[str], str | None]:
+    """Take `--theme dark`, `--theme light` or `--theme=dark` out of
+    the arguments: the rest, and the theme named, or None."""
+    rest: list[str] = []
+    theme = None
+    skip = False
+    for i, arg in enumerate(argv):
+        if skip:
+            skip = False
+            continue
+        if arg.startswith('--theme='):
+            theme = arg.split('=', 1)[1]
+        elif arg == '--theme' and i + 1 < len(argv):
+            theme = argv[i + 1]
+            skip = True
+        else:
+            rest.append(arg)
+    if theme is not None:
+        theme = theme.strip().lower()
+        if theme not in ('dark', 'light'):
+            raise SystemExit(f"--theme takes dark or light, not {theme!r}")
+    return rest, theme
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     import os
 
@@ -108,6 +132,7 @@ def main(argv: Sequence[str] | None = None) -> int:
 
     check_qt_binding()      # before a window is built out of the mismatch
 
+    from ..theme import OVERRIDE as THEME_OVERRIDE
     from .main_window import MainWindow
 
     # let Ctrl-C in the launching terminal kill the GUI immediately instead
@@ -121,6 +146,12 @@ def main(argv: Sequence[str] | None = None) -> int:
     # its own and is not a file to import
     with_disclaimer = '--no-disclaimer' not in argv
     argv = [a for a in argv if a != '--no-disclaimer']
+    # --theme dark|light: said into the environment, which is the one
+    # place the theme module looks first, so the window and every
+    # later `apply_theme` agree (2026-09-14)
+    argv, theme = theme_flag(argv)
+    if theme is not None:
+        os.environ[THEME_OVERRIDE] = theme
     # what the machine calls this while it is running — and it must be
     # said *before* the QApplication exists. Cocoa's application menu
     # ('Hide …', 'Quit …') is built during construction, titled from

{visualdynamics-0.1.0a1 → visualdynamics-0.1.0a2}/src/visualdynamics/gui/main_window.py

@@ -134,7 +134,7 @@ from ..rotate import (
     rotate_frame,
     wrapped,
 )
-from ..theme import OVERLAY_ALPHA, system_scheme
+from ..theme import OVERLAY_ALPHA
 from ..theme import theme as resolve_theme
 from ..units import DEFAULT_SYSTEM, SYSTEMS, UnitSystem
 from ..viz.geometry import (
@@ -177,6 +177,13 @@ from .object_tables import (
     units_table_model,
 )
 from .panes import DataPane, ScenePane
+from .preferences import (
+    chosen_scheme,
+    refresh_palettes,
+    remember_appearance,
+    remembered_appearance,
+    wear_appearance,
+)
 from .project_tree import (
     PROJECT_ROW,
     ROLE_ACTIVE,
@@ -649,8 +656,12 @@ class MainWindow(QMainWindow):
         check_qt_binding()   # a mismatch is unreadable once it reaches a layout
         import pyqtgraph as pg
 
-        # follow the OS light/dark setting for the parts we draw ourselves
-        self.theme_name: str = system_scheme()
+        # the appearance chosen for this launch, remembered, or the
+        # platform's — in that order (gui/preferences.py) — worn by the
+        # whole application first, so the chrome and the drawn parts
+        # are built to the same scheme
+        wear_appearance()
+        self.theme_name: str = chosen_scheme()
         colors = resolve_theme(self.theme_name)
         pg.setConfigOption('background', colors['plot_background'])
         pg.setConfigOption('foreground', colors['plot_foreground'])
@@ -1343,6 +1354,25 @@ class MainWindow(QMainWindow):
         report_menu.addAction('&Empty',
                               lambda: self.generate_report('empty'))
         file_menu.addSeparator()
+        # light, dark, or the platform's choice, remembered between
+        # launches: a Linux desktop Qt could not read left a friend of
+        # Brandon's with a light window and no way to change it
+        # (2026-09-14). One menu, still — File stays the only one.
+        appearance = file_menu.addMenu('&Appearance')
+        group = QActionGroup(self)
+        group.setExclusive(True)
+        self.appearance_actions: dict[str, QAction] = {}
+        remembered = remembered_appearance()
+        for choice, label in (('system', '&System'), ('light', '&Light'),
+                              ('dark', '&Dark')):
+            action = appearance.addAction(label)
+            action.setCheckable(True)
+            action.setChecked(choice == remembered)
+            action.triggered.connect(
+                lambda _checked=False, choice=choice:
+                self.choose_appearance(choice))
+            group.addAction(action)
+            self.appearance_actions[choice] = action
         file_menu.addAction('Check for &Updates...', self.check_for_updates)
         # the About role: macOS moves it into the application menu,
         # where a Mac user looks for a version; Windows and Linux keep
@@ -2096,19 +2126,43 @@ class MainWindow(QMainWindow):
         self.dofs_combo_action.setVisible(bool(quantities))
 
     def _scheme_changed(self, _scheme) -> None:
-        """The platform switched light and dark: restate the theme."""
+        """The platform switched light and dark: restate the theme —
+        which follows it only while the appearance is System — and
+        make every widget re-read the palette, which they do not do
+        on their own (gui/preferences.py, `refresh_palettes`)."""
+        refresh_palettes()
         self.apply_theme()
 
+    def choose_appearance(self, choice: str) -> None:
+        """File → Appearance: remember the choice and wear it now.
+        'system' means follow the platform again."""
+        remember_appearance(choice)
+        for name, action in self.appearance_actions.items():
+            action.setChecked(name == choice)
+        # the application first — chrome, menus, native widgets — then
+        # the parts drawn here; Qt announces the switch through
+        # colorSchemeChanged too, which lands on apply_theme as well
+        wear_appearance(choice=choice)
+        self.apply_theme()
+        self._show_status(
+            'Following the system appearance' if choice == 'system'
+            else f'{choice.capitalize()} appearance, remembered')
+
     def apply_theme(self, name: str | None = None) -> None:
-        """Adopt a light/dark theme (default: whatever the OS is set to)."""
+        """Adopt a light/dark theme (default: the one chosen — this
+        launch's flag, the remembered appearance, or the OS)."""
         import pyqtgraph as pg
 
-        self.theme_name = name or system_scheme()
+        self.theme_name = name or chosen_scheme()
         colors = resolve_theme(self.theme_name)
         _keep_selection_vivid(self.table)
         pg.setConfigOption('foreground', colors['plot_foreground'])
         self.data_pane.apply_theme(self.theme_name, colors)
-        self.scene.apply_background()
+        # the scene's own theme name, not just its background: told
+        # only to repaint, it repainted in the theme it was built with,
+        # and a window opened light stayed white after Dark (Brandon's
+        # screenshot, 2026-09-14)
+        self.scene.apply_theme(self.theme_name)
         # the tree wears the scene's own ground — one theme for every
         # surface, black or white, never the platform's grey (Brandon,
         # 2026-08-23)

visualdynamics-0.1.0a2/src/visualdynamics/gui/preferences.py

@@ -0,0 +1,135 @@
+"""What the application remembers between launches: today, the
+appearance.
+
+One `QSettings` under one name, so a preference set on one launch is
+read on the next; the tests point the store at a temporary folder
+through `QSettings.setPath`, so nothing a test chooses reaches the
+user's own file.
+
+The appearance a window wears is decided in this order, and the order
+is the point: an explicit statement for this launch
+(`VISUALDYNAMICS_THEME`, which `--theme` sets) beats the remembered
+choice, and the remembered choice beats what the platform reports —
+`'system'` means follow the platform, which is the default and what
+`theme.system_scheme` answers.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+
+from PySide6.QtCore import QSettings
+
+from ..theme import OVERRIDE, THEMES, system_scheme
+
+#: the remembered choices, in menu order
+APPEARANCES = ('system', 'light', 'dark')
+KEY = 'appearance'
+
+
+#: a file to keep the preferences in instead of the platform's store —
+#: what the tests set, so nothing a test chooses reaches the user's own
+STORE = 'VISUALDYNAMICS_SETTINGS'
+
+
+def settings() -> QSettings:
+    """The application's own store: the platform's (a plist on macOS,
+    the registry on Windows, a file under ~/.config on Linux), or the
+    file `VISUALDYNAMICS_SETTINGS` names."""
+    path = os.environ.get(STORE)
+    if path:
+        return QSettings(path, QSettings.Format.IniFormat)
+    return QSettings('visualdynamics', 'Visual Dynamics')
+
+
+def remembered_appearance() -> str:
+    """'system', 'light' or 'dark' — 'system' when nothing was chosen
+    or the stored word is not one of ours."""
+    said = str(settings().value(KEY, 'system')).strip().lower()
+    return said if said in APPEARANCES else 'system'
+
+
+def remember_appearance(choice: str) -> None:
+    """Store the choice; 'system' clears it rather than storing a word
+    that means "nothing chosen"."""
+    if choice not in APPEARANCES:
+        raise ValueError(f'appearance is one of {APPEARANCES}, not {choice!r}')
+    store = settings()
+    if choice == 'system':
+        store.remove(KEY)
+    else:
+        store.setValue(KEY, choice)
+    store.sync()
+
+
+def chosen_scheme() -> str:
+    """The theme to wear now: this launch's statement, else the
+    remembered choice, else the platform's."""
+    said = os.environ.get(OVERRIDE, '').strip().lower()
+    if said in THEMES:
+        return said
+    remembered = remembered_appearance()
+    if remembered in THEMES:
+        return remembered
+    return system_scheme()
+
+
+def wear_appearance(app: Any = None, choice: str | None = None) -> None:
+    """Make the whole application wear the chosen appearance — the
+    window chrome, the menus, every native widget — not only the parts
+    this program draws itself.
+
+    Qt 6.8 gave `QStyleHints.setColorScheme`: Light or Dark forces the
+    application's appearance (on macOS, the NSApp appearance), Unknown
+    follows the platform again. Without it the first cut of the menu
+    changed the plots and the scene and left the chrome as the OS had
+    it, and Brandon chose Light and saw nothing change (2026-09-14).
+    The platform then reports the forced scheme, which is what
+    `theme.system_scheme` and the `colorSchemeChanged` slot read, so
+    every later repaint agrees. `choice` defaults to what
+    `chosen_scheme` would answer: this launch's statement, else the
+    remembered choice, else the platform's.
+    """
+    from PySide6.QtCore import Qt
+    from PySide6.QtWidgets import QApplication
+
+    app = app or QApplication.instance()
+    if app is None:
+        return
+    hints = app.styleHints()
+    if not hasattr(hints, 'setColorScheme'):
+        return                      # an older Qt: the drawn parts only
+    if choice is None:
+        said = os.environ.get(OVERRIDE, '').strip().lower()
+        choice = said if said in THEMES else remembered_appearance()
+    hints.setColorScheme({'light': Qt.ColorScheme.Light,
+                          'dark': Qt.ColorScheme.Dark}.get(
+                              choice, Qt.ColorScheme.Unknown))
+    refresh_palettes(app)
+
+
+def refresh_palettes(app: Any = None) -> None:
+    """Make every widget re-read the application palette.
+
+    On macOS with Qt 6.11 the application palette follows a colour
+    scheme change at once, but widgets already on screen keep the
+    palette they resolved before it — the status bar and the panes
+    stayed light after Brandon switched back to Dark (his screenshot,
+    2026-09-14), while a fresh window came up right. Setting an
+    *empty* palette on a widget makes it resolve from its parent and
+    the application again, and leaves `WA_SetPalette` clear, so the
+    widgets that own a palette on purpose (the tree and the tables,
+    coloured by the theme) are skipped and keep theirs.
+    """
+    from PySide6.QtCore import Qt
+    from PySide6.QtGui import QPalette
+    from PySide6.QtWidgets import QApplication, QWidget
+
+    app = app or QApplication.instance()
+    if app is None or not hasattr(app, 'topLevelWidgets'):
+        return
+    for top in app.topLevelWidgets():
+        for widget in (top, *top.findChildren(QWidget)):
+            if not widget.testAttribute(Qt.WidgetAttribute.WA_SetPalette):
+                widget.setPalette(QPalette())

{visualdynamics-0.1.0a1 → visualdynamics-0.1.0a2}/src/visualdynamics/theme.py

@@ -148,12 +148,23 @@ def colormap(values: Any) -> Any:
     return stops[low] * (1.0 - f) + stops[low + 1] * f
 
 
+#: an explicit answer beats every guess: `VISUALDYNAMICS_THEME=dark`
+#: (or light) in the environment, which the launcher's `--theme` sets
+OVERRIDE = 'VISUALDYNAMICS_THEME'
+
+
 def system_scheme(app: Any = None) -> str:
-    """'dark' or 'light' from the OS appearance, via Qt.
+    """'dark' or 'light': the environment's say, else the OS appearance
+    via Qt, else the desktop asked directly, else the palette.
 
     Falls back to the default theme when Qt or an application instance is
     unavailable (e.g. plain scripting use).
     """
+    import os
+
+    said = os.environ.get(OVERRIDE, '').strip().lower()
+    if said in THEMES:
+        return said
     try:
         from PySide6.QtCore import Qt
         from PySide6.QtWidgets import QApplication
@@ -167,6 +178,66 @@ def system_scheme(app: Any = None) -> str:
         return 'dark'
     if scheme == Qt.ColorScheme.Light:
         return 'light'
-    palette = app.palette()  # Qt could not tell: judge by palette lightness
+    # Qt could not tell. On Linux that is the usual case: Qt learns the
+    # scheme through a platform-theme plugin, and a packaged build
+    # shipped none until 2026-09-14 — a friend of Brandon's on a dark
+    # desktop got a light window. The desktop is asked directly before
+    # the palette is judged, since the palette is Qt's own light one
+    # whenever the plugin is missing.
+    asked = desktop_scheme()
+    if asked is not None:
+        return asked
+    palette = app.palette()  # judge by palette lightness
     return ('dark' if palette.color(palette.ColorRole.Window).lightness() < 128
             else 'light')
+
+
+def desktop_scheme(platform: str | None = None,
+                   run: Any = None, home: str | None = None) -> str | None:
+    """The Linux desktop's own answer, or None where there is none.
+
+    Three doors, in the order a modern desktop answers them: the XDG
+    settings portal's `color-scheme` (GNOME, KDE and the rest, over
+    D-Bus through `gdbus`, which ships with GLib), GNOME's
+    `gsettings` key of the same name, and KDE's `kdeglobals`. Each is
+    a subprocess or a file read with a short timeout, and any failure
+    is "no answer" — never an exception in the way of a window.
+    `platform`, `run` and `home` are for the tests.
+    """
+    import os
+    import subprocess
+    import sys
+
+    platform = platform or sys.platform
+    if not platform.startswith('linux'):
+        return None
+    run = run or (lambda cmd: subprocess.run(
+        cmd, capture_output=True, text=True, timeout=2, check=False).stdout)
+    for command, dark, light in (
+            (['gdbus', 'call', '--session',
+              '--dest', 'org.freedesktop.portal.Desktop',
+              '--object-path', '/org/freedesktop/portal/desktop',
+              '--method', 'org.freedesktop.portal.Settings.ReadOne',
+              'org.freedesktop.appearance', 'color-scheme'],
+             'uint32 1', 'uint32 2'),
+            (['gsettings', 'get', 'org.gnome.desktop.interface',
+              'color-scheme'],
+             'prefer-dark', 'prefer-light')):
+        try:
+            out = run(command) or ''
+        except Exception:  # noqa: BLE001, S112 — absent tool, timeout: no answer from this door
+            continue
+        if dark in out:
+            return 'dark'
+        if light in out:
+            return 'light'
+    try:
+        kdeglobals = os.path.join(home or os.path.expanduser('~'),
+                                  '.config', 'kdeglobals')
+        with open(kdeglobals, encoding='utf-8', errors='replace') as f:
+            for line in f:
+                if line.strip().lower().startswith('colorscheme='):
+                    return ('dark' if 'dark' in line.lower() else 'light')
+    except OSError:
+        pass
+    return None

{visualdynamics-0.1.0a1 → visualdynamics-0.1.0a2/src/visualdynamics.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visualdynamics
-Version: 0.1.0a1
+Version: 0.1.0a2
 Summary: Structural Dynamics Visualization: a units-aware structural dynamics analysis toolset
 Author-email: Brandon Zwink <bzwink@gmail.com>
 License-Expression: GPL-3.0-or-later

{visualdynamics-0.1.0a1 → visualdynamics-0.1.0a2}/src/visualdynamics.egg-info/SOURCES.txt

@@ -68,6 +68,7 @@ src/visualdynamics/gui/main_window.py
 src/visualdynamics/gui/object_tables.py
 src/visualdynamics/gui/octave_panel.py
 src/visualdynamics/gui/panes.py
+src/visualdynamics/gui/preferences.py
 src/visualdynamics/gui/project_tree.py
 src/visualdynamics/gui/record_grid.py
 src/visualdynamics/gui/report_editor.py