The PicoCalc's console font is a preference, and the shell gets its own back

A Linux VT loads one font for the whole console, so asking for the 6x8 build
(53x40, fourteen rows more) changes what the shell is drawn in too. The new
console_font preference (6x12 default, 6x8 the alternative, offered on the
PicoCalc only, round-tripping through preferences.yaml on every platform)
therefore comes with services/consolefont.py: remember the font the shell had
with `setfont -O`, apply the one the preference names, and restore it on every
way out -- the menu's finally and an atexit hook, since ^Q and an unhandled
error leave by other doors. Verified on the device that setfont -O captures
the current font with its unicode table and that feeding it back reproduces it
exactly, with no sudo, because the VT is the process's own controlling
terminal. Only the interactive menu switches; a scripted run never touches the
console it was invited into. Changing the preference on its page applies live.

Shipping both fonts needed the licence untangled: the 6x8 base is the Linux
kernel's font_6x8 bitmap, GPL-2.0, so its build moves into
calculinux-console-font-6x8.sh under that licence with the GPLv2 text beside it
in scripts/LICENSE.GPL-2.0. The shared generator stays in the 6x12 script
between BEGIN/END markers and the 6x8 script executes that block, so the marks,
donors and aliases the font contract pins exist in one place. The produced PSF
is a data file the kernel console reads; MeshTerm never links or bundles it, and
NOTICE and the hardware manual say so. PrefSpec gains a platforms gate for the
page; the labels use an ASCII x because U+00D7 is not in the console font.
The 6x8 base has no Cyrillic; the manual says so and the owner accepts it.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
Jean-Pierre MartineauandClaude Fable 5.1 committed 2026-09-12 23:52:54 -04:00
1 parent ffd2649a35
commit 3b67c6813e
14 files changed
+1265 -137

No files matched your search

+22
View File
@@ -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
+8
View File
@@ -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
+40 -10
View File
@@ -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`
+13
View File
@@ -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:
+54 -2
View File
@@ -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]
+219
View File
@@ -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",
]
+8
View File
@@ -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))
+19 -3
View File
@@ -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.
+339
View File
@@ -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.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
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.
<signature of Ty Coon>, 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.
+2 -1
View File
@@ -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.** |
+176
View File
@@ -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("""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=
""")
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."
+55 -119
View File
@@ -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("<IIIIIIII", base[:32])
@@ -275,67 +253,22 @@ entries12 = base[32 + 256 * charsize:].split(b"\xff")[:256]
# Cyrillic pe + pi: the shared-slot canaries (donating pi once erased pe).
build(glyphs12, entries12, 12, 12, MARKS, BANDS12, [0x043F, 0x03C0], OUT)
# --- 6x8: the kernel's font_6x8 (CP437 coverage -- no Cyrillic) ------------------------
FONT8 = base64.b64decode("""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=
""")
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
# --- the 6x8 companion, out of its own (GPL-2.0) file -----------------------------------
# Kept separate because its base bitmap is the kernel's font_6x8 and the produced PSF is
# therefore GPL-2.0 -- see scripts/calculinux-console-font-6x8.sh and scripts/LICENSE.GPL-2.0.
# It re-uses the shared generator block above rather than carrying a second copy of the
# donor/alias/keeper tables, so a run here still produces both fonts, as it always did.
# A failure there is not a failure here: the 6x12 default is the font the device boots in.
if [ "${SKIP_6X8:-0}" = 1 ]; then
echo "skipping $OUT8 (SKIP_6X8=1)"
elif [ -f "$BUILD8" ]; then
sh "$BUILD8" || echo "warning: the 6x8 build failed; $OUT is installed either way" >&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
+8 -2
View File
@@ -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"
+302
View File
@@ -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 == []