triplot 1.1.0__py3-none-any.whl

dscpanel/register.py

@@ -0,0 +1,284 @@
+"""Putting the program in the Start Menu, and taking it out again.
+
+Two rules:
+
+1. **It is opt-in and you run it yourself.** A program that quietly claims a
+   file type or writes a shortcut the first time it runs is a program people
+   learn to distrust. So nothing here happens at start-up; `triplot
+   register` does it and `triplot register --remove` undoes it.
+2. **It writes a manifest of everything it created.** Removal then takes away
+   exactly what was added, rather than guessing at paths a later version
+   might get wrong - and that manifest, together with
+   `branding.LEGACY_NAMES`, is the whole answer to "we will probably rename
+   this later": the new name knows what the old one installed and can clean
+   it up with `--clean-legacy`.
+
+Everything is per user. Nothing here needs administrator rights, nothing is
+written outside the user's own profile, and no registry key outside
+`HKCU\\Software\\Classes`.
+
+Aliases are the same machinery pointed at a name the user picks:
+`triplot alias tp` makes `tp` work in a terminal on any platform - a
+`.cmd` shim beside the installed command on Windows, a symlink in
+`~/.local/bin` elsewhere - and records it so `--remove` can take it away.
+"""
+
+import json
+import os
+import shutil
+import subprocess
+import sys
+
+from . import branding
+
+
+def _load():
+    try:
+        with open(branding.manifest_path(), "r", encoding="utf-8") as fh:
+            return json.load(fh)
+    except (OSError, ValueError):
+        return {"entries": []}
+
+
+def _save(manifest):
+    os.makedirs(branding.app_dir(), exist_ok=True)
+    with open(branding.manifest_path(), "w", encoding="utf-8") as fh:
+        json.dump(manifest, fh, indent=1)
+
+
+def _record(manifest, kind, path, name=""):
+    entry = {"kind": kind, "path": str(path), "name": name,
+             "app": branding.APP_NAME}
+    if entry not in manifest["entries"]:
+        manifest["entries"].append(entry)
+
+
+def launcher():
+    """The command a shortcut should run: the installed exe if there is one.
+
+    The windowed entry point is preferred, so no console window appears
+    behind the program. Falling back to `python -m dscpanel` keeps this
+    working from a source checkout that was never pip-installed.
+    """
+    for name in (branding.EXE_NAME_GUI, branding.EXE_NAME):
+        found = shutil.which(name)
+        if found:
+            return [found]
+    python = sys.executable
+    if sys.platform == "win32":
+        windowed = os.path.join(os.path.dirname(python), "pythonw.exe")
+        if os.path.isfile(windowed):
+            python = windowed
+    return [python, "-m", "dscpanel"]
+
+
+# --------------------------------------------------------------- Windows
+def _windows_start_menu():
+    base = os.environ.get("APPDATA") or os.path.expanduser("~")
+    return os.path.join(base, "Microsoft", "Windows", "Start Menu",
+                        "Programs")
+
+
+def _make_shortcut(link_path, command, description):
+    """Write a .lnk through PowerShell's WScript.Shell.
+
+    Via PowerShell rather than pywin32, so the program does not need a
+    dependency whose only job is to make one file.
+    """
+    target = command[0]
+    arguments = " ".join('"{}"'.format(a) for a in command[1:])
+    script = (
+        "$s = New-Object -ComObject WScript.Shell; "
+        "$l = $s.CreateShortcut('{link}'); "
+        "$l.TargetPath = '{target}'; "
+        "$l.Arguments = '{args}'; "
+        "$l.Description = '{desc}'; "
+        "$l.WorkingDirectory = '{cwd}'; "
+        "$l.Save()").format(
+            link=link_path.replace("'", "''"),
+            target=target.replace("'", "''"),
+            args=arguments.replace("'", "''"),
+            desc=description.replace("'", "''"),
+            cwd=os.path.expanduser("~").replace("'", "''"))
+    subprocess.run(["powershell", "-NoProfile", "-ExecutionPolicy", "Bypass",
+                    "-Command", script], check=True,
+                   stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
+    return link_path
+
+
+def _windows_scripts_dir():
+    """Where pip put the command, which is a directory already on PATH.
+
+    The fallback is the USER scripts directory rather than the interpreter's
+    own: a Python under `C:\\Program Files` has a Scripts folder that needs
+    administrator rights to write to, so an alias written there fails for
+    exactly the people who did not install Python themselves. The user
+    scheme is where `pip install --user` puts a command anyway.
+    """
+    found = shutil.which(branding.EXE_NAME) or shutil.which(
+        branding.EXE_NAME_GUI)
+    if found:
+        return os.path.dirname(found)
+    import sysconfig
+    try:
+        path = sysconfig.get_path("scripts", "nt_user")
+        if path:
+            return path
+    except (KeyError, ValueError):
+        pass
+    return os.path.join(os.path.dirname(sys.executable), "Scripts")
+
+
+# ----------------------------------------------------------------- POSIX
+def _desktop_entry_dir():
+    base = os.environ.get("XDG_DATA_HOME") or os.path.expanduser(
+        "~/.local/share")
+    return os.path.join(base, "applications")
+
+
+def _write_desktop_entry(path, command, name, description):
+    with open(path, "w", encoding="utf-8") as fh:
+        fh.write("[Desktop Entry]\n")
+        fh.write("Type=Application\n")
+        fh.write("Name={}\n".format(name))
+        fh.write("Comment={}\n".format(description))
+        fh.write("Exec={} %F\n".format(" ".join(command)))
+        fh.write("Terminal=false\n")
+        fh.write("Categories=Science;Education;\n")
+    return path
+
+
+# ------------------------------------------------------------------- API
+def register(desktop=False, dry_run=False):
+    """Make the program findable: Start Menu, or a .desktop entry."""
+    manifest = _load()
+    command = launcher()
+    made = []
+    if sys.platform == "win32":
+        link = os.path.join(_windows_start_menu(),
+                            branding.APP_NAME + ".lnk")
+        made.append(("start menu", link))
+        if desktop:
+            made.append(("desktop", os.path.join(
+                os.path.expanduser("~/Desktop"),
+                branding.APP_NAME + ".lnk")))
+        if not dry_run:
+            for kind, path in made:
+                os.makedirs(os.path.dirname(path), exist_ok=True)
+                _make_shortcut(path, command, branding.DESCRIPTION)
+                _record(manifest, kind, path, branding.APP_NAME)
+    else:
+        path = os.path.join(_desktop_entry_dir(),
+                            branding.EXE_NAME + ".desktop")
+        made.append(("desktop entry", path))
+        if not dry_run:
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            _write_desktop_entry(path, command, branding.APP_NAME,
+                                 branding.DESCRIPTION)
+            _record(manifest, "desktop entry", path, branding.APP_NAME)
+    if not dry_run:
+        _save(manifest)
+    return made
+
+
+def unregister(names=None, dry_run=False):
+    """Remove what was registered, for this name or for the ones given."""
+    manifest = _load()
+    wanted = set(names or [branding.APP_NAME])
+    removed, kept = [], []
+    for entry in manifest["entries"]:
+        if entry.get("app") not in wanted:
+            kept.append(entry)
+            continue
+        path = entry.get("path", "")
+        removed.append(path)
+        if not dry_run and os.path.exists(path):
+            try:
+                os.remove(path)
+            except OSError:
+                kept.append(entry)
+    if not dry_run:
+        manifest["entries"] = kept
+        _save(manifest)
+    return removed
+
+
+def clean_legacy(dry_run=False):
+    """Take away what the program's PREVIOUS names left behind.
+
+    This is the deregistration half of a rename. `branding.LEGACY_NAMES` is
+    the list a renamed release ships; everything here works from it, so the
+    old name never has to be remembered by hand.
+    """
+    names = [entry[0] for entry in branding.LEGACY_NAMES]
+    removed = unregister(names, dry_run=dry_run) if names else []
+    # Shortcuts made before the manifest existed, or by a version that could
+    # not write it, are looked for by name as well.
+    for app_name, exe_name, _prog_id in branding.LEGACY_NAMES:
+        guesses = []
+        if sys.platform == "win32":
+            guesses.append(os.path.join(_windows_start_menu(),
+                                        app_name + ".lnk"))
+            guesses.append(os.path.join(os.path.expanduser("~/Desktop"),
+                                        app_name + ".lnk"))
+            guesses.append(os.path.join(_windows_scripts_dir(),
+                                        exe_name + ".cmd"))
+        else:
+            guesses.append(os.path.join(_desktop_entry_dir(),
+                                        exe_name + ".desktop"))
+            guesses.append(os.path.expanduser("~/.local/bin/" + exe_name))
+        for path in guesses:
+            if os.path.exists(path):
+                removed.append(path)
+                if not dry_run:
+                    try:
+                        os.remove(path)
+                    except OSError:
+                        pass
+    return removed
+
+
+def alias(name, remove=False, dry_run=False):
+    """Make `name` start the program too, and remember that it was made."""
+    manifest = _load()
+    command = launcher()
+    if sys.platform == "win32":
+        path = os.path.join(_windows_scripts_dir(), name + ".cmd")
+        body = '@echo off\r\n"{}" %*\r\n'.format(" ".join(command))
+    else:
+        path = os.path.expanduser(os.path.join("~/.local/bin", name))
+        body = "#!/bin/sh\nexec {} \"$@\"\n".format(" ".join(command))
+    if remove:
+        if not dry_run and os.path.exists(path):
+            os.remove(path)
+        manifest["entries"] = [e for e in manifest["entries"]
+                               if e.get("path") != path]
+        if not dry_run:
+            _save(manifest)
+        return path
+    if not dry_run:
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w", encoding="utf-8", newline="") as fh:
+            fh.write(body)
+        if sys.platform != "win32":
+            os.chmod(path, 0o755)
+        _record(manifest, "alias", path, branding.APP_NAME)
+        _save(manifest)
+    return path
+
+
+def aliases():
+    """Every alias this program knows it made."""
+    return [e["path"] for e in _load()["entries"] if e.get("kind") == "alias"]
+
+
+def describe():
+    """What is registered right now, as lines for a terminal."""
+    manifest = _load()
+    if not manifest["entries"]:
+        return ["nothing registered (run: {} register)".format(
+            branding.EXE_NAME)]
+    return ["{:<14} {}{}".format(e.get("kind", "?"), e.get("path", "?"),
+                                 "" if os.path.exists(e.get("path", ""))
+                                 else "   (gone)")
+            for e in manifest["entries"]]

dscpanel/ui/appearance.py

@@ -0,0 +1,146 @@
+"""The rest of the window, in the plot's colours.
+
+The plot paints its own theme (`ui/plot.py`, `THEMES`). Everything else - the
+outliner, the menus, the status bar, every dialog - is Qt's, and it followed
+the system's light look while the plot beside it was dark. When the plot
+is dark, so should every window be.
+
+So the application palette follows the plot's theme: dark greys (Fusion
+style plus a Blender-ish palette) for `blender-default`, Fusion's own
+light palette for `light`, the Boombox skin for `boombox`. Fusion in every
+case, because a palette only fully applies under a style that draws with
+it, and switching styles between two themes would change the widgets'
+shapes as well as their colours.
+"""
+
+from PySide6.QtCore import Qt
+from PySide6.QtGui import QColor, QGuiApplication, QPalette
+from PySide6.QtWidgets import QApplication
+
+from . import plot as plot_module
+
+#: The theme the application palette was last set for, so a refresh that
+#: changes nothing does not repaint every widget in the program.
+_applied = None
+
+
+def dark_palette():
+    """The dark palette: Fusion's greys, Blender-ish."""
+    p = QPalette()
+    grey = QColor(53, 53, 53)
+    base = QColor(42, 42, 42)
+    text = QColor(220, 220, 220)
+    disabled = QColor(128, 128, 128)
+    p.setColor(QPalette.Window, grey)
+    p.setColor(QPalette.WindowText, text)
+    p.setColor(QPalette.Base, base)
+    p.setColor(QPalette.AlternateBase, QColor(58, 58, 58))
+    p.setColor(QPalette.ToolTipBase, QColor(42, 42, 42))
+    p.setColor(QPalette.ToolTipText, text)
+    p.setColor(QPalette.PlaceholderText, QColor(140, 140, 140))
+    p.setColor(QPalette.Text, text)
+    p.setColor(QPalette.Button, grey)
+    p.setColor(QPalette.ButtonText, text)
+    p.setColor(QPalette.BrightText, QColor(255, 120, 120))
+    p.setColor(QPalette.Link, QColor(110, 160, 220))
+    p.setColor(QPalette.Highlight, QColor(70, 105, 150))
+    p.setColor(QPalette.HighlightedText, QColor(240, 240, 240))
+    for role in (QPalette.WindowText, QPalette.Text, QPalette.ButtonText):
+        p.setColor(QPalette.Disabled, role, disabled)
+    p.setColor(QPalette.Disabled, QPalette.Highlight, QColor(80, 80, 80))
+    return p
+
+
+def light_palette():
+    """Fusion's classic light palette, written out.
+
+    Not `standardPalette()`: that follows the colour scheme in force at the
+    moment it is asked, so taken while the dark scheme was still set it
+    handed back a DARK palette and the "light" theme stayed dark."""
+    p = QPalette()
+    window = QColor(239, 239, 239)
+    text = QColor(20, 20, 20)
+    disabled = QColor(150, 150, 150)
+    p.setColor(QPalette.Window, window)
+    p.setColor(QPalette.WindowText, text)
+    p.setColor(QPalette.Base, QColor(255, 255, 255))
+    p.setColor(QPalette.AlternateBase, QColor(245, 245, 245))
+    p.setColor(QPalette.ToolTipBase, QColor(255, 255, 220))
+    p.setColor(QPalette.ToolTipText, text)
+    p.setColor(QPalette.PlaceholderText, QColor(120, 120, 120))
+    p.setColor(QPalette.Text, text)
+    p.setColor(QPalette.Button, window)
+    p.setColor(QPalette.ButtonText, text)
+    p.setColor(QPalette.BrightText, QColor(200, 30, 30))
+    p.setColor(QPalette.Link, QColor(30, 90, 180))
+    p.setColor(QPalette.Highlight, QColor(48, 140, 198))
+    p.setColor(QPalette.HighlightedText, QColor(255, 255, 255))
+    for role in (QPalette.WindowText, QPalette.Text, QPalette.ButtonText):
+        p.setColor(QPalette.Disabled, role, disabled)
+    return p
+
+
+def boombox_palette():
+    """The Boombox skin: brushed-metal greys, parchment text, the LCD
+    green."""
+    p = QPalette()
+    window = QColor("#232323")
+    text = QColor("#d6d6c2")
+    disabled = QColor("#6b7178")
+    p.setColor(QPalette.Window, window)
+    p.setColor(QPalette.WindowText, text)
+    p.setColor(QPalette.Base, QColor("#2a2d31"))
+    p.setColor(QPalette.AlternateBase, QColor("#2e3236"))
+    p.setColor(QPalette.ToolTipBase, QColor("#0c130c"))
+    p.setColor(QPalette.ToolTipText, QColor("#39ff7a"))
+    p.setColor(QPalette.PlaceholderText, QColor("#9a9a86"))
+    p.setColor(QPalette.Text, text)
+    p.setColor(QPalette.Button, QColor("#3a3f44"))
+    p.setColor(QPalette.ButtonText, text)
+    p.setColor(QPalette.BrightText, QColor("#ff5555"))
+    p.setColor(QPalette.Link, QColor("#39ff7a"))
+    p.setColor(QPalette.Highlight, QColor("#2f7d4a"))
+    p.setColor(QPalette.HighlightedText, QColor("#caffd9"))
+    p.setColor(QPalette.Mid, QColor("#15171a"))
+    for role in (QPalette.WindowText, QPalette.Text, QPalette.ButtonText):
+        p.setColor(QPalette.Disabled, role, disabled)
+    p.setColor(QPalette.Disabled, QPalette.Highlight, QColor("#3a3f44"))
+    return p
+
+
+#: The window's palette for each of the plot's themes.
+PALETTES = {plot_module.THEME_DARK: dark_palette,
+            plot_module.THEME_LIGHT: light_palette,
+            plot_module.THEME_BOOMBOX: boombox_palette}
+
+
+def apply(theme, app=None):
+    """Give the whole application the palette that goes with `theme`.
+
+    Returns True when anything changed. Also tells Qt which colour scheme is
+    in force where it can be told (Qt 6.8+), which is what darkens the
+    Windows title bar to match.
+    """
+    global _applied
+    app = app or QApplication.instance()
+    if app is None or theme == _applied:
+        return False
+    if app.style().name().lower() != "fusion":
+        app.setStyle("Fusion")
+    dark = theme != plot_module.THEME_LIGHT
+    # The scheme FIRST, the palette after it: a scheme change makes Qt
+    # re-derive colours, and the explicit palette has to be the last word.
+    hints = QGuiApplication.styleHints()
+    try:
+        hints.setColorScheme(Qt.ColorScheme.Dark if dark
+                             else Qt.ColorScheme.Light)
+    except AttributeError:
+        pass                       # an older Qt: the title bar stays as it is
+    app.setPalette(PALETTES.get(theme, dark_palette)())
+    _applied = theme
+    return True
+
+
+def applied():
+    """The theme the application is currently dressed in. For tests."""
+    return _applied