diff --git a/CHANGELOG.md b/CHANGELOG.md index 655b08b..f1e92e7 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,28 @@ allowed to change behaviour, not just add to it. ## [Unreleased] +### Added + +- **The PicoCalc picks its console font, and MeshTerm hands the console back.** A *Console + font* row under Display on the Preferences page offers `6x12 (53x26)` — the font the + device boots in — and `6x8 (53x40)`, fourteen more rows of the same glyph inventory in a + shorter cell. Choosing one loads it there and then; the kernel raises SIGWINCH on a font + change, so the frame repaints at the new height without a relaunch. The 6×8 base has no + Cyrillic, so a node named in Cyrillic draws as boxes on it. + + A virtual terminal has one font for the whole console, so switching MeshTerm's switches + the shell's. It saves whatever font was loaded before the first paint and reloads it on + the way out — from the session's teardown and from an `atexit` hook, so quitting, an + unwind and a crash all leave the console as they found it. Off the handheld, off a real + VT, or with no `setfont`, none of it happens and the log says which. The row is drawn on + the PicoCalc only, while the value round-trips through `preferences.yaml` everywhere. + + The 6×8 font's build moved into `scripts/calculinux-console-font-6x8.sh`, on its own + because its base bitmap is the Linux kernel's `font_6x8` and therefore GPL-2.0 — marked + as such, with the licence beside it, and reading the donor, alias and keeper tables out + of the 6×12 script rather than keeping a second copy of them. Running the 6×12 script + still builds both. + ## [0.3.2] — 2026-09-11 ### Added diff --git a/NOTICE b/NOTICE index 35f437a..5fefb84 100644 --- a/NOTICE +++ b/NOTICE @@ -25,6 +25,14 @@ project and is not authorized to do so. -------------------------------------------------------------------------------- +Device script: scripts/calculinux-console-font-6x8.sh embeds the Linux kernel's +font_6x8 bitmap (lib/fonts/font_6x8.c) and is therefore licensed GPL-2.0-only, +as is the console font it builds; its terms are included beside it as +scripts/LICENSE.GPL-2.0 and are its only license -- the Apache License above +does not apply to it. Nothing GPL-2.0 reaches the MeshTerm package: that script +is excluded from the distribution, runs on the device, and produces a PSF data +file the Linux console driver loads, which MeshTerm neither links nor bundles. + Bundled font: meshterm/assets/fonts/CascadiaMonoPL.ttf is Cascadia Mono PL, Copyright (c) 2019 - Present, Microsoft Corporation, with Reserved Font Name Cascadia Code. It is redistributed here unmodified under the SIL Open Font diff --git a/docs/hardware.md b/docs/hardware.md index 0fc5428..2bf5f0e 100644 --- a/docs/hardware.md +++ b/docs/hardware.md @@ -102,11 +102,19 @@ font: the script and the inventory move in the same commit or the test fails. > **Licensing.** The installed 6×12 font is a **derivative of Terminus**, which is under the > SIL Open Font Licence 1.1 with "Terminus" as a Reserved Font Name — so the output is named > `meshterm`, which is exactly what the OFL requires of a renamed derivative, and it must not -> be called Terminus. Nothing Terminus itself is in this repo. The optional 6×8 candidate is +> be called Terminus. Nothing Terminus itself is in this repo. The 6×8 companion is > different: its base bitmap is the Linux kernel's `font_6x8`, which is **GPL-2.0**, embedded -> base64 in the script. That sits awkwardly beside an Apache-2.0 repo and a decision on it is -> pending; the 6×12 Terminus-derived font is the installed default, and the 6×8 build is an -> A/B candidate you flip to by hand. +> base64 in the script. So that material lives in one file of its own, +> [`calculinux-console-font-6x8.sh`](../scripts/calculinux-console-font-6x8.sh), marked +> `SPDX-License-Identifier: GPL-2.0-only` with the licence beside it as +> [`scripts/LICENSE.GPL-2.0`](../scripts/LICENSE.GPL-2.0) — and that is the end of the +> awkwardness. Nothing GPL-2.0 enters the Apache-2.0 program: the script is excluded from +> the Python distribution, it runs **on the device**, and what it produces is a PSF **data +> file the kernel's console driver loads** with `setfont`. MeshTerm never links it, never +> bundles it and never redistributes it; it names a path on the console's own filesystem. +> The two scripts share one copy of the donor, alias and keeper tables — the 6×8 one reads +> them out of the 6×12 one, between its `shared generator` marker lines — so a glyph added +> in one place lands in both fonts. --- @@ -192,12 +200,34 @@ glyph: sh calculinux-console-font.sh ``` -It builds both fonts, applies the 6×12 one live with `setfont` on `/dev/tty1`, and persists -it as `FONT=meshterm` in `/etc/vconsole.conf` so systemd loads it at boot. If `setfont` -fails it aborts *before* persisting, so you are never left with a font that only exists in -`vconsole.conf`. It prints the A/B commands as it finishes — `setfont -/usr/share/consolefonts/meshterm8.psf.gz` for 53×40, the same with `meshterm.psf.gz` for -53×26 — and whichever you prefer goes in `vconsole.conf` by hand. +It builds both fonts — the 6×8 one by handing off to +[`calculinux-console-font-6x8.sh`](../scripts/calculinux-console-font-6x8.sh) beside it, or +telling you it is missing; `SKIP_6X8=1` builds only the default — applies the 6×12 one live +with `setfont` on `/dev/tty1`, and persists it as `FONT=meshterm` in `/etc/vconsole.conf` so +systemd loads it at boot. If `setfont` fails it aborts *before* persisting, so you are never +left with a font that only exists in `vconsole.conf`. A 6×8 build that fails is a warning +and nothing more: the default is installed either way. + +**Choosing between them is a preference, not a command.** *Display → Console font* on the +Preferences page offers `6x12 (53x26)` and `6x8 (53x40)`, and it is drawn on the PicoCalc +only — it is a row about hardware no desktop has, though the value round-trips through +`preferences.yaml` on any machine. Picking one loads it immediately: the kernel raises +SIGWINCH on a font change, so the whole frame repaints at the new row count without a +relaunch. + +MeshTerm puts the font back when it exits. Before the first paint it saves the console's +current font with `setfont -O ~/.meshterm/console-font-before.psf` — whatever the *shell* +was in, not whatever we assume it was — and reloads that file on the way out, from the +session's own teardown and from an `atexit` hook, so ^Q and a crash both leave the console +as they found it. Then the file is deleted. No `sudo` anywhere: the VT is the process's +controlling terminal and belongs to the logged-in user. Every part of this is optional and +silent — off the PicoCalc, off a real VT (an ssh session is a pty, not a console), or with +no `setfont` on `PATH`, it does nothing and says so once in the log. A permanent choice +still goes in `vconsole.conf` by hand: `FONT=meshterm8` for 53×40, `FONT=meshterm` for 53×26. + +> **The 6×8 font has no Cyrillic.** Its base is CP437, where the 6×12 Terminus base is not, +> so a node named in Cyrillic draws as tofu boxes on it. That is a known and accepted cost +> of the fourteen extra rows, not a bug to report. The same script owns the sixteen colour slots. A **default run restores the stock kernel VT palette** and removes any previous remap: it disables and deletes the `meshterm-vtrgb` diff --git a/meshterm/cli.py b/meshterm/cli.py index 39079a0..8a1ac38 100644 --- a/meshterm/cli.py +++ b/meshterm/cli.py @@ -308,6 +308,17 @@ def main_callback( if _offer_a_console_that_can_draw_meshterm(console, prefs): return + from .services import consolefont as vt_console_font + + # The PicoCalc's whole console shares one font, so asking for the 6x8 build changes + # what the *shell* is drawn in too. Save the reader's font before the first paint + # and put it back on the way out — from the `finally` here, and from an `atexit` + # remember() arms, since ^Q and an unhandled error leave by other doors. This is + # the menu's boundary only: a scripted run prints into a console it was invited + # into and never touches its font. + saved_font = vt_console_font.remember() + vt_console_font.apply(prefs.get("console_font")) + # The interactive session is the one that holds the stores in memory and rewrites # them whole, so it is the one that claims the directory. One-shot subcommands are # brief and mostly read; blocking `meshterm contacts` because a menu is open in @@ -333,6 +344,8 @@ def main_callback( get_logger().exception("the interactive session raised an unhandled error") _report_log_location(console, settings.config_dir) raise + finally: + vt_console_font.restore(saved_font) def _offer_a_console_that_can_draw_meshterm(console: Console, prefs: Preferences) -> bool: diff --git a/meshterm/core/preferences.py b/meshterm/core/preferences.py index 49bac7f..a381345 100644 --- a/meshterm/core/preferences.py +++ b/meshterm/core/preferences.py @@ -91,6 +91,14 @@ class PrefSpec: relaunch: Whether the new value only takes hold next launch. Woven into the description rather than shown as its own mark — it is a caveat about one preference, not a status the reader scans a column for. + platforms: Which :class:`~meshterm.platforms.Platform` names the preference is + *offered* on, or ``None`` (the default) for all of them. A preference about + hardware only one flavour has — the PicoCalc's console font — would be a row + answering a question the desktop cannot ask, so the page leaves it out there. + Only the page: the key stays in the registry on every platform, so a file + written on the handheld still parses, keeps its value and saves back out on a + desktop rather than being silently dropped by a machine that merely cannot + act on it. """ key: str @@ -104,12 +112,24 @@ class PrefSpec: maximum: float | None = None unit: str = "" relaunch: bool = False + platforms: frozenset[str] | None = None @property def description(self) -> str: """The DESCRIPTION lane's text: the help, plus the relaunch caveat where it applies.""" return f"{self.help} (next launch)" if self.relaunch else self.help + def offered_on(self, platform: str) -> bool: + """Whether the editor draws a row for this preference on ``platform``. + + Args: + platform: A :attr:`~meshterm.platforms.Platform.name`. + + Returns: + ``True`` unless :attr:`platforms` names a set this platform is not in. + """ + return self.platforms is None or platform in self.platforms + #: The two languages the plain CLI can print a time in. Named for what the reader sees #: rather than for the mechanism: an *age* is how long ago, a *timestamp* is when. @@ -149,6 +169,16 @@ _CONSOLE_SETUP_CHOICES: dict[str, str] = { "off": "Leave it alone", } +#: The two console fonts ``scripts/calculinux-console-font.sh`` (and its 6x8 companion) +#: build for the PicoCalc's framebuffer panel. Each is named by its cell and by the screen +#: that cell buys, because choosing a font here is choosing how much fits — not a bitmap. +#: Plain ASCII ``x`` and not ``×``: the multiplication sign is not one of the 512 glyphs +#: the console font carries, so it would draw as a tofu box on the one platform this +#: preference is offered on. The value maps to a file in +#: :data:`meshterm.services.consolefont.FONT_FILES`, which is where a filename belongs — +#: a path on one device is not something a reader picks. +_CONSOLE_FONT_CHOICES: dict[str, str] = {"6x12": "6x12 (53x26)", "6x8": "6x8 (53x40)"} + #: What the log file keeps. The plain level names, which are what every other tool calls #: these — someone being talked through a problem is being told "set it to debug", not #: "set it to everything". @@ -365,6 +395,20 @@ PREFERENCES: tuple[PrefSpec, ...] = ( default="auto", choices=_CONSOLE_SETUP_CHOICES, ), + PrefSpec( + key="console_font", + label="Console font", + help="Bigger text, or more rows on the handheld's panel", + group="Display", + value_type="enum", + # The 6x12 Terminus derivative, because it is the font the device boots with and + # the one every screen's row budget is designed to (Platform.readable_rows is 26). + # The 6x8 build is the same glyph inventory in a shorter cell — fourteen more rows + # for anyone who would rather see more of a list than read it comfortably. + default="6x12", + choices=_CONSOLE_FONT_CHOICES, + platforms=frozenset({"picocalc"}), + ), # --- Diagnostics --------------------------------------------------------------- PrefSpec( key="log_level", @@ -402,13 +446,21 @@ def get_spec(key: str) -> PrefSpec: raise PreferenceError(f"unknown preference: {key!r}") from None -def by_group() -> list[tuple[str, list[PrefSpec]]]: +def by_group(platform: str | None = None) -> list[tuple[str, list[PrefSpec]]]: """Every preference grouped for display, in :data:`GROUPS` order. + Args: + platform: A :attr:`~meshterm.platforms.Platform.name` to draw the page for, which + drops the preferences that platform is not offered (see + :meth:`PrefSpec.offered_on`). ``None`` — the default, and what the file writer + uses — keeps every preference, so an override made on one flavour survives + being loaded and saved on another. + Returns: ``(group, specs)`` pairs; a group holding no preferences is omitted. """ - grouped = [(g, [s for s in PREFERENCES if s.group == g]) for g in GROUPS] + kept = [s for s in PREFERENCES if platform is None or s.offered_on(platform)] + grouped = [(g, [s for s in kept if s.group == g]) for g in GROUPS] return [(g, specs) for g, specs in grouped if specs] diff --git a/meshterm/services/consolefont.py b/meshterm/services/consolefont.py new file mode 100644 index 0000000..4d1c2b7 --- /dev/null +++ b/meshterm/services/consolefont.py @@ -0,0 +1,219 @@ +"""The PicoCalc's console font: remember what was there, switch, put it back. + +The handheld draws to a Linux virtual terminal, and a VT loads exactly one font for the +whole console — there is no per-application font the way a desktop terminal emulator has +one. So MeshTerm asking for its 6x8 build (53x40, fourteen more rows) means changing the +font the *shell* is using, and leaving it changed would be MeshTerm walking off with the +reader's console. Hence the shape of this module: **remember** the font the shell had, +**apply** the one the preference names, and **restore** on every way out. + +``setfont -O`` writes the current font out with its unicode table, and feeding that file +straight back to ``setfont`` reproduces it exactly — verified on the device. No ``sudo`` +is involved: the VT is the process's controlling terminal and is owned by the logged-in +user, which is the whole reason this can be a preference rather than a setup step. +``-C`` is deliberately never passed, so every call targets that controlling VT and not +whichever tty number happens to be first. + +Everything here is cosmetic and everything here fails quietly. A missing ``setfont``, a +read-only state directory, an ssh session that is not a VT at all, a non-zero exit — each +is one debug line and a no-op return, because a font is never a reason for the app not to +start. :func:`applies` is the single gate all three verbs ask first, so "this is not that +machine" is answered in one place. + +Distinct from :mod:`meshterm.core.consolefont`, which installs a *TrueType* face for the +classic Windows console. Same words, opposite platforms: that one is a Win32 font +resource, this one is a PSF bitmap the Linux kernel's console driver reads. +""" + +from __future__ import annotations + +import atexit +import os +import re +import shutil +import subprocess +from pathlib import Path + +from ..core.config import default_config_dir +from ..persistence.logging import get_logger +from ..platforms import get_platform + +#: Where ``scripts/calculinux-console-font.sh`` and its 6x8 companion install the fonts. +FONT_DIR = Path("/usr/share/consolefonts") + +#: One preference value -> the file the build script writes for it. This map lives beside +#: the code that runs ``setfont`` rather than in the preference registry: a reader picks a +#: cell size and a row count, not a path on a filesystem only one machine has. +FONT_FILES: dict[str, str] = {"6x12": "meshterm.psf.gz", "6x8": "meshterm8.psf.gz"} + +#: The preference this module acts on, named once so the caller and the registry agree. +PREFERENCE_KEY = "console_font" + +#: What :func:`remember` writes under the MeshTerm home. A plain ``.psf``: ``setfont -O`` +#: writes an uncompressed PSF, and the file is transient anyway (:func:`restore` deletes +#: it), so it is never gzipped and never versioned. +SAVED_NAME = "console-font-before.psf" + +#: A Linux virtual terminal, which is the only kind of console ``setfont`` can talk to. +#: ``/dev/pts/3`` (an ssh session or a terminal emulator on the same device) is not one, +#: and ``setfont`` against it would either fail or change a console nobody is looking at. +_VT_NAME = re.compile(r"^/dev/tty[0-9]+$") + +#: Seconds before a ``setfont`` call is given up on. It is a sub-millisecond ioctl in +#: practice; the timeout is here so a wedged binary cannot hold the app's startup. +_TIMEOUT_S = 5.0 + + +def _controlling_vt() -> str | None: + """The name of stdin's terminal when it is a Linux VT, else ``None``. + + ``os.ttyname`` does not exist on Windows and raises on a redirected stdin, which are + both simply "not a VT" as far as this module is concerned. + """ + try: + name = os.ttyname(0) + except (AttributeError, OSError, ValueError): + return None + return name if _VT_NAME.match(name) else None + + +def applies() -> bool: + """Whether switching the console font is a thing this session can do at all. + + Three conditions, each a different reason to leave the console alone: the PicoCalc is + the only platform whose fonts this module knows; stdin must be the Linux VT whose font + would change (an ssh session's pty has no font of its own); and ``setfont`` must + exist, which on the device means the ``kbd`` package the font build already needs. + + Returns: + ``True`` when all three hold. Otherwise ``False``, with one debug line naming + which one did not — the log is where a font that "did nothing" gets explained. + """ + platform = get_platform() + if platform.name != "picocalc": + get_logger().debug("console font: leaving it alone — platform is %s", platform.name) + return False + if _controlling_vt() is None: + get_logger().debug("console font: leaving it alone — stdin is not a Linux VT") + return False + if shutil.which("setfont") is None: + get_logger().debug("console font: leaving it alone — no setfont on PATH") + return False + return True + + +def remember() -> Path | None: + """Save the console's current font, and arm its restore. + + The saved file is the *shell's* font — whatever was loaded before MeshTerm started, + which is usually the 6x12 default but is whatever the reader last chose — so the + restore puts back what they had rather than what we assume they had. + + The restore is registered with :mod:`atexit` here as well as being run from the + session's ``finally``, because the ways out of a full-screen app are many (^Q, an + unhandled exception, the menu's own unwind) and a console left in the wrong font is + only noticed after the app is gone. Restoring twice is harmless: the first one deletes + the file and the second finds nothing to do. + + Returns: + The path the font was written to, to hand back to :func:`restore`, or ``None`` + when there was nothing to remember (see :func:`applies`) or the write failed. + """ + if not applies(): + return None + path = default_config_dir() / SAVED_NAME + try: + path.parent.mkdir(parents=True, exist_ok=True) + except OSError as exc: + get_logger().debug("console font: cannot make %s: %s", path.parent, exc) + return None + if not _setfont("-O", str(path)): + return None + atexit.register(restore, path) + return path + + +def apply(choice: str) -> bool: + """Load the font one preference value names. + + Args: + choice: A :data:`FONT_FILES` key — the ``console_font`` preference's value. + + Returns: + Whether ``setfont`` ran and succeeded. ``False`` is the ordinary answer on every + machine that is not the handheld, and never an error the caller has to handle. + """ + if not applies(): + return False + name = FONT_FILES.get(str(choice)) + if name is None: + get_logger().debug("console font: no file for %r; leaving the console alone", choice) + return False + # ``as_posix``: this is a path on the handheld's filesystem whatever machine the + # string is built on, and a developer's Windows box would otherwise spell it with + # backslashes on its way into a test. + return _setfont((FONT_DIR / name).as_posix()) + + +def restore(saved: Path | None) -> None: + """Put back the font :func:`remember` saved, then drop the file. + + Idempotent by construction — the file is deleted whether or not loading it worked, so + a second call (the ``atexit`` one, after the session's ``finally`` already ran) finds + nothing and does nothing. + + Args: + saved: What :func:`remember` returned. ``None`` means there was nothing to do. + """ + if saved is None: + return + try: + present = saved.is_file() + except OSError: # pragma: no cover - a stat that fails is a file we can't use + present = False + if present and shutil.which("setfont") is not None: + _setfont(str(saved)) + try: + saved.unlink(missing_ok=True) + except OSError as exc: # pragma: no cover - a file we wrote should be ours to remove + get_logger().debug("console font: cannot remove %s: %s", saved, exc) + + +def _setfont(*args: str) -> bool: + """Run ``setfont`` with ``args``, logging anything it has to say about failing. + + Never ``-C``: with no tty named, ``setfont`` acts on its controlling terminal, which + is the console the reader is actually looking at. + + Returns: + ``True`` only on a clean exit. + """ + argv = ["setfont", *args] + try: + done = subprocess.run( # noqa: S603 - a fixed binary name with our own arguments + argv, capture_output=True, text=True, timeout=_TIMEOUT_S, check=False + ) + except (OSError, subprocess.SubprocessError) as exc: + get_logger().debug("console font: %s failed: %s", " ".join(argv), exc) + return False + if done.returncode != 0: + get_logger().debug( + "console font: %s exited %d: %s", + " ".join(argv), + done.returncode, + (done.stderr or "").strip() or "(no output)", + ) + return False + return True + + +__all__ = [ + "FONT_DIR", + "FONT_FILES", + "PREFERENCE_KEY", + "SAVED_NAME", + "applies", + "apply", + "remember", + "restore", +] diff --git a/meshterm/tools/preferences.py b/meshterm/tools/preferences.py index 4afc5e5..304200f 100644 --- a/meshterm/tools/preferences.py +++ b/meshterm/tools/preferences.py @@ -82,6 +82,7 @@ class PreferencesTool(Tool): PreferenceError: If a key is unknown or a value fails its spec — reported cleanly by the CLI rather than as a traceback. """ + from ..services import consolefont from ..ui.preferences import preferences_table from ..ui.surface import TuiUi @@ -125,6 +126,13 @@ class PreferencesTool(Tool): if changes: prefs.save() + if not scripted and any(c["key"] == consolefont.PREFERENCE_KEY for c in applied): + # The one preference whose effect is outside the app: the console's font is + # the console's, so it takes hold now rather than next launch. The kernel + # sends SIGWINCH on a VT font change, so prompt_toolkit repaints the whole + # frame at the new row count by itself. Menu-only — a scripted run was typed + # into a console it does not own (see meshterm.services.consolefont). + consolefont.apply(prefs.get(consolefont.PREFERENCE_KEY)) if scripted and any(op[0] in ("set", "reset") for op in ops): blocks.append(_written(applied, prefs)) diff --git a/meshterm/ui/preferences.py b/meshterm/ui/preferences.py index 1d197c7..e12717b 100644 --- a/meshterm/ui/preferences.py +++ b/meshterm/ui/preferences.py @@ -43,6 +43,7 @@ from ..core.preferences import ( parse_value, range_hint, ) +from ..platforms import get_platform from .menus import ( confirm_discard, exit_rows, @@ -132,9 +133,20 @@ def _resettable(prefs: Preferences, pending: dict[str, Any]) -> list[str]: ] +def _page_groups() -> list[tuple[str, list[PrefSpec]]]: + """The groups this page draws — everything the *running* platform is offered. + + A preference gated to another flavour (the PicoCalc's console font, on a desktop) is a + row whose question this machine cannot answer, so it is not drawn. Its value is still + in the registry and still round-trips through the file, which is what keeps a + ``preferences.yaml`` written on the handheld from being quietly emptied by a desktop. + """ + return by_group(get_platform().name) + + def _all_specs() -> list[PrefSpec]: - """Every spec in page order (the grouping flattened).""" - return [spec for _, specs in by_group() for spec in specs] + """Every spec the page draws, in page order (the grouping flattened).""" + return [spec for _, specs in _page_groups() for spec in specs] #: Cell cap on *each side* of a VALUE lane's ``current → staged``. The lane is sized to @@ -174,7 +186,7 @@ def _menu_items(prefs: Preferences, pending: dict[str, Any]) -> tuple[str, list] value), description — under one pinned header, so the page reads as the editor it is. """ sections: list[tuple[str, list[tuple[str, Text, str, Any]]]] = [] - for group, specs in by_group(): + for group, specs in _page_groups(): sections.append( ( group, @@ -261,6 +273,10 @@ def preferences_table(prefs: Preferences, width: int = _DESCRIBE_FROM) -> Table: row to open and no reset row to infer the difference from — and it names each preference by its **key**, since that is what ``preferences set`` takes. + "Every" is meant literally, platform gates included (``by_group()`` with no argument): + a command line is regularly typed on one machine about a file that belongs to another, + and a key the listing hid is a key nobody would think to ``set``. + Args: prefs: The preferences to render. width: The console's width, which decides whether the DESCRIPTION lane is drawn. diff --git a/scripts/LICENSE.GPL-2.0 b/scripts/LICENSE.GPL-2.0 new file mode 100644 index 0000000..d511905 --- /dev/null +++ b/scripts/LICENSE.GPL-2.0 @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/scripts/README.md b/scripts/README.md index 4d46d3f..385db6d 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -13,7 +13,8 @@ been proven on one bench. Start there and pick your target; the table below is t | File | Runs on | What it does | | --- | --- | --- | | [`calculinux-setup.sh`](calculinux-setup.sh) | the Lyra (root) | One-time bring-up: python packages, the Wi-Fi boot-scan kick, a boot clock sync (there is no RTC), the deploy user, the checkout, the venv and `pip install -e .`, the login PATH, and the console font. Idempotent. | -| [`calculinux-console-font.sh`](calculinux-console-font.sh) | the Lyra (root) | Just the console font: builds, installs and persists the 512-glyph **meshterm** PSF (braille, node marks, rounded frame corners, the list cursor) and restores the stock 16-slot palette. Run it alone after a MeshTerm update. | +| [`calculinux-console-font.sh`](calculinux-console-font.sh) | the Lyra (root) | Just the console font: builds, installs and persists the 512-glyph **meshterm** PSF (braille, node marks, rounded frame corners, the list cursor) and restores the stock 16-slot palette. Calls the 6×8 build below when it sits alongside. Run it alone after a MeshTerm update. | +| [`calculinux-console-font-6x8.sh`](calculinux-console-font-6x8.sh) | the Lyra (root) | The shorter-cell companion font, **meshterm8** (6×8 → 53×40), for anyone who wants more rows than the 6×12 default gives. Its base bitmap is the kernel's `font_6x8`, so this one file and the PSF it builds are **GPL-2.0-only** ([`LICENSE.GPL-2.0`](LICENSE.GPL-2.0)); it reads the donor/alias/keeper tables out of the script above rather than keeping a second copy. Pick between the two fonts from MeshTerm's Preferences page. | | [`calculinux-wifi-set.sh`](calculinux-wifi-set.sh) | the Lyra (sudo) | Interactive Wi-Fi join: prompts for an SSID and passphrase, writes iwd's credentials, connects now. This is how a network *becomes* known to the boot kick. | | [`calculinux-radio-bridge.sh`](calculinux-radio-bridge.sh) | the Lyra (root) | **Unfinished, unsupported.** An early UART-to-TCP pump, superseded by `xiao-radio/lyra-setup.sh`; its header describes routing it does not contain. See the manual before reading it. | | [`meshterm-spi-bridge`](meshterm-spi-bridge) | the radio host (your user) | Runs a mesh node in software over an SPI-attached SX1262 (uConsole AIO, Waveshare HATs) and serves the companion protocol on `127.0.0.1:5000`. Setup menu, preflight, optional `systemd --user` service. **Written for `pymc_core` 1.0.x — see the manual's rename note before installing.** | diff --git a/scripts/calculinux-console-font-6x8.sh b/scripts/calculinux-console-font-6x8.sh new file mode 100644 index 0000000..7b81cf7 --- /dev/null +++ b/scripts/calculinux-console-font-6x8.sh @@ -0,0 +1,176 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0-only +# calculinux-console-font-6x8.sh -- build and install meshterm8.psf.gz, the 6x8 (53x40) +# console font for the PicoCalc panel. +# +# LICENCE -- READ THIS FIRST. The base bitmap embedded below is the Linux kernel's own +# font_6x8 (lib/fonts/font_6x8.c), which is GPL-2.0. This script is therefore GPL-2.0-only +# and so is the PSF it produces; the full licence text sits beside it as +# scripts/LICENSE.GPL-2.0. The rest of MeshTerm is Apache-2.0 and stays that way: the +# produced meshterm8.psf.gz is a DATA FILE the Linux kernel console reads with setfont, on +# the device, at run time. MeshTerm never links it, never bundles it, and never +# redistributes it -- it is built on the machine it runs on, from this script, and the +# Python package excludes scripts/ from its sdist entirely. Nothing GPL-2.0 enters the +# distributed program; MeshTerm merely names a file on the console's filesystem. +# +# WHERE THE SHARED PARTS LIVE. The donor, alias and keeper tables, the braille generator +# and the PSF2 writer are NOT duplicated here. They are read out of +# calculinux-console-font.sh (Apache-2.0), between its "shared generator (BEGIN)" and +# "(END)" marker lines, and exec'd -- so the two fonts can never drift, and a repo test +# that parses those tables has exactly one file to parse. That file must sit beside this +# one; point SHARED at it if it does not. +# +# WHAT IS ONLY HERE. The GPL-2.0 base bitmap, its CP437 unicode mapping, and the same 18 +# marks redrawn for the shorter cell (MARKS8). +# +# The 6x8 base has CP437 coverage, so unlike the Terminus base it has NO CYRILLIC: a node +# named in Cyrillic draws as tofu in this font. The keeper list drops the Cyrillic canary +# accordingly, and only pi is checked. +# +# Run as root on the Lyra, either on its own or through calculinux-console-font.sh, which +# calls it: +# +# sh calculinux-console-font-6x8.sh +# +# Idempotent. It installs the font and nothing else -- it never runs setfont, never touches +# /etc/vconsole.conf and never touches the palette. Choose the font live from MeshTerm's +# Preferences page (Display -> Console font), or by hand with +# `setfont /usr/share/consolefonts/meshterm8.psf.gz`. +set -eu + +FONT_NAME=meshterm +CONSOLEFONTS=/usr/share/consolefonts +OUT8="$CONSOLEFONTS/${FONT_NAME}8.psf.gz" +HERE=$(dirname "$0") +SHARED=${SHARED:-"$HERE/calculinux-console-font.sh"} # Apache-2.0; holds the shared tables + +# --- preflight: fail early with a plain reason, never half-apply ----------------------- +[ "$(id -u)" = 0 ] || { echo "error: run as root (writes $CONSOLEFONTS)" >&2; exit 1; } +command -v python3 >/dev/null 2>&1 || { echo "error: python3 not found" >&2; exit 1; } +[ -f "$SHARED" ] || { echo "error: shared generator not found: $SHARED" >&2; exit 1; } + +echo "building $OUT8 (6x8) ..." +SHARED="$SHARED" OUT8="$OUT8" python3 - <<'PYEOF' +import base64 +import os +import re + +# --- the shared generator, borrowed rather than copied --------------------------------- +# Everything between the two marker lines in calculinux-console-font.sh: the braille +# generator, art(), DONORS, ALIASES, KEEP_COMMON, BANDS8 and build(). One copy of those +# tables, in the Apache-2.0 file, both fonts built from it. +SHARED = os.environ["SHARED"] +_source = open(SHARED, encoding="utf-8").read() +_block = re.search( + r"^# --- shared generator \(BEGIN\).*?$(.*?)^# --- shared generator \(END\)", + _source, re.S | re.M) +if _block is None: + raise SystemExit( + "no 'shared generator' block in %s -- the two font scripts have drifted" % SHARED) +exec(compile(_block.group(1), SHARED, "exec"), globals()) + +OUT8 = os.environ["OUT8"] + +# The same 18 marks redrawn for the 6x8 cell (first-draft art; a later tweak round +# refines whichever font wins the A/B). +MARKS8 = { + 0x25CF: art([ # BLACK CIRCLE + "......", "..##..", ".####.", "######", "######", ".####.", "..##..", "......"]), + 0x25C9: art([ # FISHEYE + "......", "..##..", ".#..#.", "#.##.#", "#.##.#", ".#..#.", "..##..", "......"]), + 0x2605: art([ # BLACK STAR + "......", "..#...", "..#...", "######", ".####.", "..##..", ".#..#.", "......"]), + 0x2014: art([ # EM DASH + "......", "......", "......", "######", "######", "......", "......", "......"]), + 0x2713: art([ # CHECK MARK + "......", "......", ".....#", "....#.", "#..#..", ".##...", ".#....", "......"]), + 0x2717: art([ # BALLOT X + "......", "#...#.", ".#.#..", "..#...", ".#.#..", "#...#.", "......", "......"]), + 0x25B6: art([ # RIGHT-POINTING TRIANGLE + "#.....", "##....", "###...", "####..", "####..", "###...", "##....", "#....."]), + 0x276F: art([ # HEAVY RIGHT ANGLE QUOTE -- the list cursor + "##....", ".##...", "..##..", "...##.", "..##..", ".##...", "##....", "......"]), + 0x25B8: art([ # SMALL RIGHT-POINTING TRIANGLE -- reorder cursor + "......", "......", ".#....", ".##...", ".###..", ".##...", ".#....", "......"]), + 0x2026: art([ # HORIZONTAL ELLIPSIS + "......", "......", "......", "......", "......", "#.#.#.", "#.#.#.", "......"]), + 0x26A0: art([ # WARNING SIGN + "..##..", ".#..#.", "#.##.#", "#.##.#", "#....#", "#.##.#", "######", "......"]), + 0x232B: art([ # ERASE TO THE LEFT + "......", "..####", ".##.##", "#..#.#", ".##.##", "..####", "......", "......"]), + 0x21E7: art([ # UPWARDS WHITE ARROW -- shift + "..##..", ".#..#.", "#....#", "##..##", ".#..#.", ".#..#.", ".####.", "......"]), + 0x2699: art([ # GEAR + "......", "..##..", "######", "##..##", "##..##", "######", "..##..", "......"]), + 0x21BB: art([ # CLOCKWISE OPEN CIRCLE ARROW -- refresh + "....#.", ".#####", "#...#.", "#.....", "#.....", "#....#", ".####.", "......"]), + 0x25F7: art([ # CLOCK FACE + "......", ".####.", "#..#.#", "#..###", "#....#", "#....#", ".####.", "......"]), + 0x2316: art([ # POSITION INDICATOR -- crosshair + "..##..", "......", "#.##.#", "#.##.#", "......", "..##..", "......", "......"]), + 0x26BF: art([ # SQUARED KEY -- padlock + ".####.", ".#..#.", "######", "##..##", "##..##", "######", "######", "......"]), +} + +# --- the base bitmap: the Linux kernel's font_6x8 (GPL-2.0; see the header) ------------ +FONT8 = base64.b64decode(""" +AAAAAAAAAAB4hMyEzLR4AHj8tPy0zHgAACh8fDgQAAAAEDh8OBAAAAA4OGxsEDgAABA4fHwQOAAA +ADB4MAAAAPz8zITM/Pz8ADBIhEgwAAD8zLR4tMz8/DwUIHhERDgAOEREOBA4EAAYFBQQEHBgADwk +PCQkbGwAEFQ4bDhUEABAYHB4cGBAAAQMHDwcDAQAEDhUEFQ4EABISEhISABIADxUVDwUFBQAOEQw +KBQMRDgAAAAA+Pj4ABA4VBBUOBB8EDhUEBAQEAAQEBAQVDgQAAAQCHwIEAAAABAgfCAQAAAAAABA +QEB4AABIhPyESAAAABAQODh8fAAAfHw4OBAQAAAAAAAAAAAAEBAQEBAAEAAoKAAAAAAAAAAofCgo +fCgAEDhAMAhwIABkZAgQIExMADBIUCBUSDQAEBAAAAAAAAAIECAgIBAIACAQCAgIECAAEFQ4VBAA +AAAAEBB8EBAAAAAAAAAAMDAgAAAAfAAAAAAAAAAAABgYAAQICBAQICBAOERMVGREOAAQMFAQEBB8 +ADhEBAgQIHwAOEQEGAREOAAIGChIfAgIAHxAeAQERDgAGCBAeEREOAB8BAQIEBAQADhERDhERDgA +OEREPAQIMAAAABgYABgYAAAAMDAAMDAgBAgQIBAIBAAAAHwAfAAAACAQCAQIECAAOEQECBAAEAA4 +RFxUXEA4ABAoRER8REQAeCQkOCQkeAA4REBAQEQ4AHgkJCQkJHgAfEBAeEBAfAB8QEB4QEBAADhE +QFxERDgAREREfERERAA4EBAQEBA4ABwICAhISDAAREhQYFBIRABAQEBAQEB8AERsVFREREQARGRU +TERERAA4REREREQ4AHhERHhAQEAAOERERFRINAB4RER4UEhEADhEQDgERDgAfBAQEBAQEABERERE +REQ4AEREREREKBAAREREVFRsRABERCgQKEREAERERCgQEBAAfAQIECBAfAAYEBAQEBAYAEAgIBAQ +CAgEMBAQEBAQMAAQKEQAAAAAAAAAAAAAAAB8IBAIAAAAAAAAADgEPEQ8AEBAWGREZFgAAAA4REBE +OAAEBDRMREw0AAAAOER8QDwADBAQOBAQEAAANExETDQEOEBAeEREREQAEAAwEBAQOAAQADAQEBAQ +YEBASFBwSEQAMBAQEBAQOAAAAGhUVFRUAAAAWGREREQAAAA4REREOAAAAHhEZFhAQAAAPERMNAQE +AABYZEBAQAAAADxAOAR4ABAQOBAQEAwAAABERERMNAAAAERERCgQAAAAVFRUVCgAAABEKBAoRAAA +AERERDwEOAAAfAgQIHwACBAQIBAQCAAQEAAQEBAQACAQEAgQECAAAAAAIFQIAAAAABAoRER8AAA4 +REBEOBAgACgARERMNAAYADhEfEA8ABgAOAQ8RDwAKAA4BDxEPAAYADgEPEQ8ADwYOAQ8RDwAAAA4 +REBEOBAYADhEfEA8ACgAOER8QDwAGAA4RHxAPAAoADAQEBA4ABgAMBAQEDgAGAAwEBAQOABEEChE +fEREADBIOER8REQAEHxAeEBAfAAAAHgUfFA8ADxQUHhQUFwAGAA4REREOAAoADhEREQ4ABgAOERE +RDgAECgARERMNAAgEABEREw0ACgAREREPAQ4hDhEREREOACIREREREQ4ABA4VFBUOBAAMEhAcEBE +eABEKHwQfBAQAHBIcEhcSEQADBAQOBAQYAAYADgEPEQ8AAgQADAQEDgACBAAOEREOAAIEABEREw0 +ADRYAFhkREQAWERkVExERAA4BDxEPAB8ADhEREQ4AHwAEAAQIEBEOAAAAAB8QEAAAAAAAHwEBAAA +ICQoEChECBwgJCgQKFg8CBAAEBAQEBAAAAAkSJBIJAAAAJBIJEiQABBEEEQQRBBEqFSoVKhUqFTc +dNx03HTcdBAQEBAQEBAQEBAQ8BAQEBAQEPAQ8BAQECgoKOgoKCgoAAAA+CgoKCgAAPAQ8BAQECgo +6AjoKCgoKCgoKCgoKCgAAPgI6CgoKCgo6Aj4AAAAKCgo+AAAAAAQEPAQ8AAAAAAAAPAQEBAQEBAQ +HAAAAAAQEBD8AAAAAAAAAPwQEBAQEBAQHBAQEBAAAAD8AAAAABAQEPwQEBAQEBAcEBwQEBAoKCgs +KCgoKCgoLCA8AAAAAAA8ICwoKCgoKOwA/AAAAAAA/ADsKCgoKCgsICwoKCgAAPwA/AAAACgo7ADs +KCgoEBD8APwAAAAoKCj8AAAAAAAA/AD8EBAQAAAA/CgoKCgoKCg8AAAAABAQHBAcAAAAAAAcEBwQ +EBAAAAA8KCgoKCgoKPwoKCgoEBD8EPwQEBAQEBDwAAAAAAAAABwQEBAQ/Pz8/Pz8/PwAAAAA/Pz8 +/ODg4ODg4ODgHBwcHBwcHBz8/Pz8AAAAAAAANEhISDQAJERISEREWEB8RERAQEBAAAAAfCgoKCgA +fCQQCBAkfAAAADxISEgwAAAASEhISHRAAAB8EBAQDAAQOEREOBA4ADhERHxERDgAOEREREQobAAY +IBgkJCQYAAAAOFRUVDgAAAQ4VFQ4QAA8QEA4QEA8ADhEREREREQAAPwA/AD8AAAQEHwQEAB8ACAQ +CBAgADgACBAgEAgAOAAMEBAQEBAQEBAQEBAQEBBgABAAfAAQAAAAIFQIIFQIADBISDAAAAAAAAAQ +OBAAAAAAAAAQAAAAAAQICFBQICAAYFBQUAAAAABgECBwAAAAAAA4ODg4ODgAAAAAAAAAAAA= +""") +assert len(FONT8) == 2048 +glyphs8 = [FONT8[i * 8:(i + 1) * 8] for i in range(256)] +# CP437's graphics mapping: the control range 0x00-0x1F holds pictographs, 0x7F a house; +# the rest decodes through Python's cp437 codec. +CP437_LOW = [ + 0x0000, 0x263A, 0x263B, 0x2665, 0x2666, 0x2663, 0x2660, 0x2022, + 0x25D8, 0x25CB, 0x25D9, 0x2642, 0x2640, 0x266A, 0x266B, 0x263C, + 0x25BA, 0x25C4, 0x2195, 0x203C, 0x00B6, 0x00A7, 0x25AC, 0x21A8, + 0x2191, 0x2193, 0x2192, 0x2190, 0x221F, 0x2194, 0x25B2, 0x25BC, +] +entries8 = [] +for i in range(256): + if i < 0x20: + cp = CP437_LOW[i] + elif i == 0x7F: + cp = 0x2302 + else: + cp = ord(bytes([i]).decode("cp437")) + entries8.append(chr(cp).encode("utf-8") if cp else b"") +build(glyphs8, entries8, 8, 8, MARKS8, BANDS8, [0x03C0], OUT8) +PYEOF + +echo "done -- flip to it with 'setfont $OUT8' (53x40), or from MeshTerm's Preferences page." diff --git a/scripts/calculinux-console-font.sh b/scripts/calculinux-console-font.sh index 6906c10..da03538 100644 --- a/scripts/calculinux-console-font.sh +++ b/scripts/calculinux-console-font.sh @@ -1,4 +1,5 @@ #!/bin/sh +# SPDX-License-Identifier: Apache-2.0 # calculinux-console-font.sh -- build, install, and persist the "meshterm" console fonts # and the 16-slot palette. # @@ -7,17 +8,27 @@ # and every font Calculinux ships is a classic 256-glyph VGA font -- so out of the box the # panel cannot draw what MeshTerm's UI leans on hardest: braille charts (U+2800-U+28FF), # the node/status marks, the P3 compact-icon marks, rounded panel corners, or the list -# cursor. This script synthesizes TWO 512-glyph PSF2 fonts: +# cursor. This script synthesizes the 512-glyph PSF2 font MeshTerm runs in: # # * meshterm.psf.gz 6x12 (Terminus base) -> 53x26 -- the installed default -# * meshterm8.psf.gz 6x8 (kernel font_6x8) -> 53x40 -- the A/B candidate # # meshterm.psf.gz is a derivative of Terminus Font (OFL-1.1) and must not itself be called # "Terminus" -- the stock ter-u12n.psf.gz base keeps its own OFL-1.1 licence, distinct from # this repository's Apache-2.0. # -# Flip live with `setfont /usr/share/consolefonts/meshterm8.psf.gz` (and back with -# meshterm.psf.gz); persist the winner via FONT= in /etc/vconsole.conf. +# The taller-screen companion, meshterm8.psf.gz (6x8 -> 53x40), is built by +# calculinux-console-font-6x8.sh, which this script runs for you when it sits alongside +# (set SKIP_6X8=1 to build only the default). It lives in its own file because its base +# bitmap is the Linux kernel's font_6x8 and therefore GPL-2.0: keeping that material in one +# clearly marked file is the point of the split. The two scripts share ONE copy of the +# donor / alias / keeper tables and the whole generator -- the block between the +# "shared generator" markers below, which the 6x8 script extracts from this file and execs. +# Edit those tables here and both fonts move together. +# +# Both fonts install into /usr/share/consolefonts. Flip live with +# `setfont /usr/share/consolefonts/meshterm8.psf.gz` (and back with meshterm.psf.gz), or +# from MeshTerm's own Preferences page (Display -> Console font); persist a permanent +# choice via FONT= in /etc/vconsole.conf. # # Why 512 and not more: fbcon caps a font at 512 glyphs. Braille alone is 256 and the base # set is another 256 -- the budget is already full, so every extra mark is drawn into a @@ -27,11 +38,6 @@ # is verified after it. The rounded corners and the midline ellipsis cost no glyph: they # are aliased onto existing bitmaps. # -# The 6x8 base is the Linux kernel's own font_6x8 (lib/fonts/font_6x8.c, GPL-2.0), -# embedded below -- CP437 coverage, so unlike the Terminus base it has NO Cyrillic; -# its keeper list drops the Cyrillic canary accordingly. Note: this bitmap's GPL-2.0 -# licence differs from this repository's own (Apache-2.0); it is embedded as data. -# # Everything else is pure geometry, generated on-device; only the stock Terminus font and # python3 are required. Run as root on the Lyra (serial console is fine): # @@ -47,8 +53,10 @@ FONT_NAME=meshterm CONSOLEFONTS=/usr/share/consolefonts BASE="$CONSOLEFONTS/ter-u12n.psf.gz" # stock Terminus 6x12, 256 glyphs OUT="$CONSOLEFONTS/$FONT_NAME.psf.gz" # the 6x12 default -OUT8="$CONSOLEFONTS/${FONT_NAME}8.psf.gz" # the 6x8 A/B candidate +OUT8="$CONSOLEFONTS/${FONT_NAME}8.psf.gz" # the 6x8 companion, built by its own script VCONSOLE=/etc/vconsole.conf +HERE=$(dirname "$0") +BUILD8="$HERE/calculinux-console-font-6x8.sh" # GPL-2.0; see its header # --- preflight: fail early with a plain reason, never half-apply ----------------------- [ "$(id -u)" = 0 ] || { echo "error: run as root (writes $CONSOLEFONTS and $VCONSOLE)" >&2; exit 1; } @@ -56,16 +64,22 @@ command -v python3 >/dev/null 2>&1 || { echo "error: python3 not found" >&2; exi command -v setfont >/dev/null 2>&1 || { echo "error: setfont not found (install kbd tools)" >&2; exit 1; } [ -f "$BASE" ] || { echo "error: base font not found: $BASE" >&2; exit 1; } -# --- build both fonts ------------------------------------------------------------------ +# --- build the 6x12 font ----------------------------------------------------------------- # The generator is inlined (quoted heredoc, so the shell expands nothing) and reads its -# paths from the environment. It is the single source of truth for the synthesized glyphs. -echo "building $OUT (6x12) and $OUT8 (6x8) ..." -BASE="$BASE" OUT="$OUT" OUT8="$OUT8" python3 - <<'PYEOF' -import base64, os, struct, gzip +# paths from the environment. It is the single source of truth for the synthesized glyphs: +# the block between the "shared generator" markers is extracted and exec'd verbatim by +# calculinux-console-font-6x8.sh, so the donor, alias and keeper tables exist ONCE. +echo "building $OUT (6x12) ..." +BASE="$BASE" OUT="$OUT" python3 - <<'PYEOF' +import os + +# --- shared generator (BEGIN) --------------------------------------------------------- +# Read by calculinux-console-font-6x8.sh out of this very file, between these two markers. +# Keep it self-contained: no os.environ reads, nothing specific to one cell size, and no +# reference to anything defined after the (END) marker. +import gzip +import struct -BASE = os.environ["BASE"] -OUT = os.environ["OUT"] -OUT8 = os.environ["OUT8"] PSF2_MAGIC = 0x864AB572 # --- braille: 2-wide dot grid; the codepoint's low byte says which dots lit ------------ @@ -153,47 +167,6 @@ MARKS = { "##..##", "##..##", "######", "######", "......", "......"]), } -# The same 18 marks redrawn for the 6x8 cell (first-draft art; a later tweak round -# refines whichever font wins the A/B). -MARKS8 = { - 0x25CF: art([ # BLACK CIRCLE - "......", "..##..", ".####.", "######", "######", ".####.", "..##..", "......"]), - 0x25C9: art([ # FISHEYE - "......", "..##..", ".#..#.", "#.##.#", "#.##.#", ".#..#.", "..##..", "......"]), - 0x2605: art([ # BLACK STAR - "......", "..#...", "..#...", "######", ".####.", "..##..", ".#..#.", "......"]), - 0x2014: art([ # EM DASH - "......", "......", "......", "######", "######", "......", "......", "......"]), - 0x2713: art([ # CHECK MARK - "......", "......", ".....#", "....#.", "#..#..", ".##...", ".#....", "......"]), - 0x2717: art([ # BALLOT X - "......", "#...#.", ".#.#..", "..#...", ".#.#..", "#...#.", "......", "......"]), - 0x25B6: art([ # RIGHT-POINTING TRIANGLE - "#.....", "##....", "###...", "####..", "####..", "###...", "##....", "#....."]), - 0x276F: art([ # HEAVY RIGHT ANGLE QUOTE -- the list cursor - "##....", ".##...", "..##..", "...##.", "..##..", ".##...", "##....", "......"]), - 0x25B8: art([ # SMALL RIGHT-POINTING TRIANGLE -- reorder cursor - "......", "......", ".#....", ".##...", ".###..", ".##...", ".#....", "......"]), - 0x2026: art([ # HORIZONTAL ELLIPSIS - "......", "......", "......", "......", "......", "#.#.#.", "#.#.#.", "......"]), - 0x26A0: art([ # WARNING SIGN - "..##..", ".#..#.", "#.##.#", "#.##.#", "#....#", "#.##.#", "######", "......"]), - 0x232B: art([ # ERASE TO THE LEFT - "......", "..####", ".##.##", "#..#.#", ".##.##", "..####", "......", "......"]), - 0x21E7: art([ # UPWARDS WHITE ARROW -- shift - "..##..", ".#..#.", "#....#", "##..##", ".#..#.", ".#..#.", ".####.", "......"]), - 0x2699: art([ # GEAR - "......", "..##..", "######", "##..##", "##..##", "######", "..##..", "......"]), - 0x21BB: art([ # CLOCKWISE OPEN CIRCLE ARROW -- refresh - "....#.", ".#####", "#...#.", "#.....", "#.....", "#....#", ".####.", "......"]), - 0x25F7: art([ # CLOCK FACE - "......", ".####.", "#..#.#", "#..###", "#....#", "#....#", ".####.", "......"]), - 0x2316: art([ # POSITION INDICATOR -- crosshair - "..##..", "......", "#.##.#", "#.##.#", "......", "..##..", "......", "......"]), - 0x26BF: art([ # SQUARED KEY -- padlock - ".####.", ".#..#.", "######", "##..##", "##..##", "######", "######", "......"]), -} - # Donor codepoints whose glyph slots we may repurpose (glyphs MeshTerm never draws). # Order matters: MARKS consume donors front to back, one each. See the header comment # for the shared-slot trap; the tail donors double as MAP TARGETS in meshterm/ui/theme @@ -265,6 +238,11 @@ def build(glyphs, entries, charsize, height, marks, bands, keep_extra, out_path) % (out_path, height, len(marks), len(ALIASES))) +# --- shared generator (END) ----------------------------------------------------------- + +BASE = os.environ["BASE"] +OUT = os.environ["OUT"] + # --- 6x12: the Terminus base ----------------------------------------------------------- base = gzip.open(BASE, "rb").read() magic, ver, hsize, flags, length, charsize, h, w = struct.unpack("&2 +else + echo "note: $BUILD8 not found -- only $OUT was built (copy the whole scripts/ dir)" >&2 +fi + # --- apply live: setfont re-renders the whole console immediately ----------------------- TTY=/dev/tty1 [ -c "$TTY" ] || TTY=/dev/tty0 @@ -349,7 +282,10 @@ else echo "FONT=$FONT_NAME" >> "$VCONSOLE" fi echo "persisted FONT=$FONT_NAME in $VCONSOLE (loads on every boot)" -echo "A/B: 'setfont $OUT8' for 53x40, 'setfont $OUT' for 53x26; persist the winner in $VCONSOLE" +if [ -f "$OUT8" ]; then + echo "taller: 'setfont $OUT8' for 53x40, 'setfont $OUT' for 53x26 -- or let MeshTerm do" + echo "it (Preferences -> Display -> Console font); persist a permanent choice in $VCONSOLE" +fi # --- palette ----------------------------------------------------------------------------- # By design, the console keeps its STANDARD kernel palette -- black diff --git a/tests/test_preferences.py b/tests/test_preferences.py index ae608fc..e9d3d4e 100644 --- a/tests/test_preferences.py +++ b/tests/test_preferences.py @@ -33,6 +33,7 @@ from meshterm.core.preferences import ( ) from meshterm.core.watch_store import WatchStore from meshterm.persistence.repository import Repository +from meshterm.platforms import get_platform from meshterm.ui.preferences import _menu_items, edit_preferences, preferences_table from meshterm.ui.theme import active_theme from tests.conftest import plain as _plain @@ -257,11 +258,16 @@ def _rows(prefs: Preferences, pending: dict | None = None) -> tuple[str, list[st def test_the_page_groups_every_preference_under_its_own_heading() -> None: - """Each group is a section, and each of its preferences a row under it.""" + """Each group is a section, and each of its preferences a row under it. + + "Its preferences" is what this platform is offered: a spec gated to another flavour + (``PrefSpec.platforms``) has no row here, which is the gate's whole visible effect and + is pinned in ``tests/test_vt_console_font.py``. + """ _, items = _menu_items(Preferences(), {}) _, rows = _rows(Preferences()) values = [item.value for item in items if hasattr(item, "value")] - for group, specs in by_group(): + for group, specs in by_group(get_platform().name): assert any(f"── {group} ──" in row for row in rows), f"{group} has no heading" for spec in specs: assert spec.key in values, f"{spec.key} has no row" diff --git a/tests/test_vt_console_font.py b/tests/test_vt_console_font.py new file mode 100644 index 0000000..8b1b66a --- /dev/null +++ b/tests/test_vt_console_font.py @@ -0,0 +1,302 @@ +"""Tests for the PicoCalc's console-font switch: the gate, the three verbs, and the wiring. + +Nothing here runs ``setfont`` — the point of the module under test is that it shells out, +so what is pinned is *which command line* it builds and that it never builds one on a +machine it has no business touching. :func:`subprocess.run` is replaced by a recorder +throughout; a real call would be a test changing the developer's console. + +Three questions, in order: does :func:`~meshterm.services.consolefont.applies` say no +everywhere it should; do the verbs say the right thing to ``setfont`` and shrug off a +failure; and is the switch wired to the *menu* only, so a scripted command typed into +somebody else's terminal never repaints it. +""" + +from __future__ import annotations + +import io +import os +import subprocess +from pathlib import Path +from typing import Any + +import pytest +from rich.console import Console + +from meshterm.context import AppContext +from meshterm.core.admin_store import AdminStore +from meshterm.core.config import Settings +from meshterm.core.device_store import DeviceStore +from meshterm.core.preferences import Preferences, by_group, get_spec +from meshterm.persistence.repository import Repository +from meshterm.platforms import PICOCALC, REGULAR, set_platform +from meshterm.services import consolefont +from meshterm.tools.preferences import PreferencesTool +from meshterm.ui.theme import active_theme + +#: What a successful ``setfont`` looks like coming back from :func:`subprocess.run`. +_OK = subprocess.CompletedProcess(["setfont"], 0, "", "") + + +class _Recorder: + """Stands in for :func:`subprocess.run`, remembering every argv and answering to script.""" + + def __init__(self, answers: list[subprocess.CompletedProcess] | None = None) -> None: + self.calls: list[list[str]] = [] + self.answers = list(answers or []) + + def __call__(self, argv: list[str], **kwargs: Any) -> subprocess.CompletedProcess: + self.calls.append(list(argv)) + return self.answers.pop(0) if self.answers else _OK + + +@pytest.fixture +def device(monkeypatch: pytest.MonkeyPatch) -> _Recorder: + """Make the process look like MeshTerm running on the handheld's own VT.""" + set_platform(PICOCALC) + monkeypatch.setattr(os, "ttyname", lambda fd: "/dev/tty1", raising=False) + monkeypatch.setattr(consolefont.shutil, "which", lambda name: "/usr/bin/setfont") + recorder = _Recorder() + monkeypatch.setattr(consolefont.subprocess, "run", recorder) + return recorder + + +# -- the gate -------------------------------------------------------------------- + + +def test_the_switch_applies_on_the_handhelds_own_console(device: _Recorder) -> None: + """Picocalc, a Linux VT on stdin, and a setfont to run: all three, so it applies.""" + assert consolefont.applies() is True + + +def test_a_desktop_never_touches_a_console_font(device: _Recorder) -> None: + """The fonts are the PicoCalc's; no other platform has them or wants them.""" + set_platform(REGULAR) + assert consolefont.applies() is False + + +@pytest.mark.parametrize("tty", ["/dev/pts/3", "/dev/ttyS1", "/dev/console"]) +def test_anything_that_is_not_a_linux_vt_is_left_alone( + device: _Recorder, monkeypatch: pytest.MonkeyPatch, tty: str +) -> None: + """An ssh pty has no font of its own, and a serial line is not a console we own.""" + monkeypatch.setattr(os, "ttyname", lambda fd: tty, raising=False) + assert consolefont.applies() is False + + +def test_a_redirected_stdin_is_not_a_vt(device: _Recorder, monkeypatch: pytest.MonkeyPatch) -> None: + """``os.ttyname`` raising (a pipe, or Windows, which has no such call) means no.""" + + def _no_tty(fd: int) -> str: + raise OSError(25, "not a tty") + + monkeypatch.setattr(os, "ttyname", _no_tty, raising=False) + assert consolefont.applies() is False + + +def test_no_setfont_means_no_switching(device: _Recorder, monkeypatch: pytest.MonkeyPatch) -> None: + """The kbd tools are what the font build needs too; without them there is no verb.""" + monkeypatch.setattr(consolefont.shutil, "which", lambda name: None) + assert consolefont.applies() is False + + +def test_a_gated_out_machine_runs_nothing_at_all(device: _Recorder) -> None: + """Every verb asks the gate first, so a no is a no-op and not a stray subprocess.""" + set_platform(REGULAR) + assert consolefont.remember() is None + assert consolefont.apply("6x8") is False + assert device.calls == [] + + +# -- the three verbs ------------------------------------------------------------- + + +def test_remember_saves_the_font_the_shell_had(device: _Recorder) -> None: + """``setfont -O`` writes the current font, unicode table and all, under the app's home.""" + saved = consolefont.remember() + assert saved is not None + assert saved.name == consolefont.SAVED_NAME + assert device.calls == [["setfont", "-O", str(saved)]] + + +def test_apply_loads_the_file_the_preference_names(device: _Recorder) -> None: + """The value is a cell size; the path it maps to is this module's business, not a preference.""" + assert consolefont.apply("6x8") is True + assert device.calls == [["setfont", "/usr/share/consolefonts/meshterm8.psf.gz"]] + assert consolefont.apply("6x12") is True + assert device.calls[-1] == ["setfont", "/usr/share/consolefonts/meshterm.psf.gz"] + + +def test_no_call_ever_names_a_tty(device: _Recorder) -> None: + """Never ``-C``: setfont with no tty named acts on the console the reader is looking at.""" + consolefont.remember() + consolefont.apply("6x8") + assert not any("-C" in argv for argv in device.calls) + + +def test_a_value_with_no_font_behind_it_changes_nothing(device: _Recorder) -> None: + """A key from a hand-edited file that names no font is a no-op, not a crash.""" + assert consolefont.apply("8x16") is False + assert device.calls == [] + + +def test_restore_reloads_the_saved_font_and_drops_the_file( + device: _Recorder, tmp_path: Path +) -> None: + """The way out: put back exactly what was saved, then leave nothing behind.""" + saved = tmp_path / consolefont.SAVED_NAME + saved.write_bytes(b"PSF") + consolefont.restore(saved) + assert device.calls == [["setfont", str(saved)]] + assert not saved.exists() + + +def test_restoring_twice_is_harmless(device: _Recorder, tmp_path: Path) -> None: + """The session's ``finally`` and the atexit hook both fire; the second finds nothing.""" + saved = tmp_path / consolefont.SAVED_NAME + saved.write_bytes(b"PSF") + consolefont.restore(saved) + consolefont.restore(saved) + consolefont.restore(None) + assert device.calls == [["setfont", str(saved)]] + + +def test_a_setfont_that_fails_is_swallowed( + device: _Recorder, monkeypatch: pytest.MonkeyPatch +) -> None: + """A font is cosmetic: a non-zero exit is a log line, never an exception.""" + monkeypatch.setattr( + consolefont.subprocess, + "run", + _Recorder([subprocess.CompletedProcess(["setfont"], 1, "", "setfont: KDFONTOP: EINVAL")]), + ) + assert consolefont.apply("6x8") is False + + +def test_a_setfont_that_cannot_be_run_is_swallowed( + device: _Recorder, monkeypatch: pytest.MonkeyPatch +) -> None: + """Same for a binary that vanishes between the which() and the exec, and for a timeout.""" + + def _boom(argv: list[str], **kwargs: Any) -> Any: + raise OSError(2, "No such file or directory") + + monkeypatch.setattr(consolefont.subprocess, "run", _boom) + assert consolefont.apply("6x8") is False + assert consolefont.remember() is None + + +def test_a_failed_remember_leaves_nothing_to_restore( + device: _Recorder, monkeypatch: pytest.MonkeyPatch +) -> None: + """Nothing saved means nothing to put back — the caller's ``finally`` gets a None.""" + monkeypatch.setattr( + consolefont.subprocess, + "run", + _Recorder([subprocess.CompletedProcess(["setfont"], 1, "", "denied")]), + ) + assert consolefont.remember() is None + + +# -- the preference -------------------------------------------------------------- + + +def test_the_preference_is_offered_on_the_handheld_only() -> None: + """A row about hardware the desktop does not have is a question it cannot answer.""" + spec = get_spec("console_font") + assert spec.offered_on("picocalc") is True + assert spec.offered_on("regular") is False + # Everything else is offered everywhere; the gate is the exception, not the rule. + gated = {s.key for _, specs in by_group() for s in specs if s.platforms is not None} + assert gated == {"console_font"} + + +@pytest.mark.parametrize("platform", [REGULAR, PICOCALC]) +def test_the_preference_round_trips_on_every_platform(tmp_path: Path, platform: Any) -> None: + """A file written on the handheld loads, keeps its value, and saves back on a desktop.""" + set_platform(platform) + path = tmp_path / "preferences.yaml" + written = Preferences(path) + written.set("console_font", "6x8") + written.save() + + reread = Preferences.load(path) + assert reread.get("console_font") == "6x8" + # And saving again keeps it: the gate hides a row, it never drops a value. + reread.save() + assert "console_font" in path.read_text(encoding="utf-8") + assert Preferences.load(path).get("console_font") == "6x8" + + +def test_the_page_draws_the_row_on_the_handheld_and_not_on_the_desktop() -> None: + """The gate's one visible effect: a Display row that exists on one platform.""" + from meshterm.ui.preferences import _menu_items + + set_platform(PICOCALC) + _, items = _menu_items(Preferences(), {}) + assert "console_font" in [getattr(item, "value", None) for item in items] + + set_platform(REGULAR) + _, items = _menu_items(Preferences(), {}) + assert "console_font" not in [getattr(item, "value", None) for item in items] + + +def test_the_printed_table_still_names_every_preference() -> None: + """The CLI's listing is platform-blind on purpose: a hidden key is one nobody would set.""" + from meshterm.ui.preferences import preferences_table + + set_platform(REGULAR) + console = Console(width=120, file=io.StringIO(), theme=active_theme(), legacy_windows=False) + with console.capture() as capture: + console.print(preferences_table(Preferences(), 120)) + assert "console_font" in capture.get() + + +# -- the wiring ------------------------------------------------------------------ + + +@pytest.fixture +def ctx(tmp_path: Path) -> Any: + """A mock-backed context whose preferences live in a throwaway file.""" + settings = Settings(config_dir=tmp_path, db_path=tmp_path / "prefs.db") + context = AppContext( + console=Console(file=io.StringIO()), + settings=settings, + repo=Repository(settings.db_path), + device_store=DeviceStore(tmp_path / "devices.json"), + admin_store=AdminStore(tmp_path / "admin.json"), + mock=True, + ) + yield context + context.repo.close() + + +async def test_the_command_line_never_repaints_the_console( + device: _Recorder, ctx: AppContext +) -> None: + """`meshterm preferences set console_font 6x8` writes the file and touches nothing else. + + A scripted run was typed into a console MeshTerm was invited into and does not own — + and half the time it is an ssh session onto the handheld from somewhere else entirely. + """ + result = await PreferencesTool().run(ctx, {"ops": [("set", "console_font", "6x8")]}) + assert result.summary == {"changes": 1} + assert ctx.preferences.get("console_font") == "6x8" + assert device.calls == [] + + +async def test_the_page_switches_the_font_as_it_saves(device: _Recorder, ctx: AppContext) -> None: + """On the menu path the new font is loaded there and then, not next launch.""" + from meshterm.ui.surface import TuiUi + + ctx.ui = TuiUi(object()) # type: ignore[arg-type] + await PreferencesTool().run(ctx, {"ops": [("set", "console_font", "6x8")]}) + assert device.calls == [["setfont", "/usr/share/consolefonts/meshterm8.psf.gz"]] + + +async def test_another_preference_leaves_the_font_alone(device: _Recorder, ctx: AppContext) -> None: + """Only the one preference reaches outside the app; the rest just get written.""" + from meshterm.ui.surface import TuiUi + + ctx.ui = TuiUi(object()) # type: ignore[arg-type] + await PreferencesTool().run(ctx, {"ops": [("set", "history_days", "30")]}) + assert device.calls == []