mirror of
https://github.com/kuhyx/diet-guard.git
synced 2026-11-10 18:07:20 +01:00
213 lines
7.5 KiB
Python
213 lines
7.5 KiB
Python
"""Field widgets of the gate's "Log Meal" tab.
|
|
|
|
Split out of :mod:`._gatelock_ui` to keep every gate module under the repo's
|
|
250-line limit. This half builds the *input* widgets -- the description box,
|
|
the suggestion picker, the amount/unit row, and the macro section --
|
|
:mod:`._gatelock_layout` assembles them into the tab.
|
|
|
|
The palette and the leaf helpers stay in :mod:`._gatelock_ui`, which is the
|
|
single ``LockConfig()`` all gate modules read; deliberately not re-derived
|
|
here, since a separate copy is exactly what drifted before (see
|
|
``DESIGN_AUDIT_TODO.md``).
|
|
|
|
.. note::
|
|
This module imports ``tkinter`` and builds widgets, so it **must** appear in
|
|
``diet_guard.tests._gate_fixtures._GATE_TK_MODULES``. A module left out of
|
|
that set builds real Tk widgets under pytest against fake parents.
|
|
``test_gate_tk_modules_complete`` enforces this.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import tkinter as tk
|
|
from typing import TYPE_CHECKING
|
|
|
|
from diet_guard import _gatelock_glyphs as glyphs
|
|
from diet_guard import _gatelock_ui
|
|
from diet_guard._gatelock_spacing import SM, XS
|
|
from diet_guard._gatelock_typography import BODY, LABEL, SUBTITLE
|
|
from diet_guard._gatelock_ui import (
|
|
_ACCENT,
|
|
_COLORS,
|
|
_FIELD_BG,
|
|
_FONT,
|
|
BASIS_PREFIX_GRAMS,
|
|
BG,
|
|
FG,
|
|
SUGGESTION_ROWS,
|
|
UNIT_GRAMS,
|
|
UNIT_ITEMS,
|
|
_macro_cell,
|
|
_numeric_entry,
|
|
)
|
|
from diet_guard._gatelock_ui_types import _MacroEntries
|
|
|
|
if TYPE_CHECKING:
|
|
from collections.abc import Callable
|
|
|
|
from diet_guard._gatelock_ui_types import GateVars
|
|
|
|
__all__ = [
|
|
"build_amount_row",
|
|
"build_desc",
|
|
"build_macro_section",
|
|
"build_suggestion_box",
|
|
]
|
|
|
|
|
|
def build_desc(parent: tk.Frame) -> tk.Text:
|
|
"""Build and return the multi-line "what did you eat?" description box.
|
|
|
|
A multi-line ``Text`` (not an ``Entry``) so a long restaurant description
|
|
wraps onto a second line and stays fully visible, instead of scrolling off
|
|
the right edge where the end can no longer be read.
|
|
"""
|
|
tk.Label(parent, text=glyphs.FOOD, font=(_FONT, SUBTITLE), bg=BG, fg=FG).pack()
|
|
text = tk.Text(
|
|
parent,
|
|
font=(_FONT, BODY),
|
|
width=64,
|
|
height=2,
|
|
wrap="word",
|
|
bg=_FIELD_BG,
|
|
fg=FG,
|
|
insertbackground=FG,
|
|
# focus_kwargs() sets highlightcolor (the *focused* ring). This
|
|
# previously set only highlightbackground, which is the UNFOCUSED ring
|
|
# -- so the box outlined while unfocused and went black (invisible on
|
|
# bg) the moment it took focus, exactly inverting the affordance.
|
|
**_COLORS.focus_kwargs(),
|
|
)
|
|
text.pack(pady=(XS, XS))
|
|
# Through the module, not a by-value import: the keyboard test patches
|
|
# ``_gatelock_ui._escape_text_tab_trap``, and ``escape_tab_trap`` resolves
|
|
# it at call time so the patch still bites. Importing the name directly
|
|
# would bind a copy the patch can never reach -- a fail-open that disables
|
|
# the Tab-trap escape with a green suite.
|
|
_gatelock_ui.escape_tab_trap(text)
|
|
return text
|
|
|
|
|
|
def build_suggestion_box(parent: tk.Frame) -> tk.Listbox:
|
|
"""Build the food-bank / staple / OFF picker list and return it."""
|
|
box = tk.Listbox(
|
|
parent,
|
|
font=(_FONT, BODY),
|
|
width=52,
|
|
height=SUGGESTION_ROWS,
|
|
bg=_FIELD_BG,
|
|
fg=FG,
|
|
selectbackground=_ACCENT,
|
|
selectforeground=_COLORS.palette.on_fill,
|
|
activestyle="none",
|
|
# Was highlightthickness=0, which removed the focus ring entirely. The
|
|
# list *is* arrow-key navigable, so it was keyboard-usable with no
|
|
# visual indication of where focus was.
|
|
**_COLORS.focus_kwargs(),
|
|
)
|
|
box.pack(pady=(0, XS))
|
|
return box
|
|
|
|
|
|
def build_amount_row(
|
|
root: tk.Misc,
|
|
parent: tk.Frame,
|
|
vars_: GateVars,
|
|
on_unit_change: Callable[[str], None],
|
|
) -> tk.Entry:
|
|
"""Build the "how much did you eat?" amount + unit row; return the entry."""
|
|
tk.Label(parent, text=glyphs.AMOUNT, font=(_FONT, SUBTITLE), bg=BG, fg=FG).pack()
|
|
row = tk.Frame(parent, bg=BG)
|
|
row.pack(pady=(XS, XS))
|
|
amount_entry = _numeric_entry(root, row, width=10, variable=vars_.entries.amount)
|
|
amount_entry.pack(side="left", ipady=XS)
|
|
_build_unit_selector(row, vars_, on_unit_change)
|
|
return amount_entry
|
|
|
|
|
|
def _build_unit_selector(
|
|
row: tk.Frame,
|
|
vars_: GateVars,
|
|
on_unit_change: Callable[[str], None],
|
|
) -> None:
|
|
"""Build the grams/items selector as focusable radio buttons.
|
|
|
|
Deliberately **not** a ``tk.OptionMenu``, which this used to be, for two
|
|
independent reasons:
|
|
|
|
1. **It was unreachable by keyboard.** ``OptionMenu``'s underlying
|
|
``Menubutton`` defaults to ``takefocus=0``, so ``::tk::FocusOK`` rejects
|
|
it and it never appears in the tab ring (verified: the ring ran
|
|
Entry -> Text -> Listbox -> Button -> TNotebook and skipped it). Since
|
|
the unit rescales the entire entry, a pointerless user could not switch
|
|
between "250 grams" and "3 items" inside a lock they cannot leave
|
|
without logging a meal.
|
|
2. **A posted menu is unsafe on a lock surface.** A dropped-down Tk menu is
|
|
a separate override-redirect toplevel that steals the Tk grab, which
|
|
gatelock's recovery tick then kills within a second. That is the
|
|
documented 2026-07-26 failure where a frozen sport selector logged a walk
|
|
as table tennis, and it is why screen-locker statically bans
|
|
``OptionMenu`` on lock surfaces.
|
|
|
|
``tk.Radiobutton`` avoids both: it is in the tab ring by default and accepts
|
|
**both** ``Space`` and ``Return`` (unlike ``tk.Button``, which on X11 binds
|
|
only ``Space``), and it posts nothing.
|
|
"""
|
|
for unit in (UNIT_GRAMS, UNIT_ITEMS):
|
|
tk.Radiobutton(
|
|
row,
|
|
text=glyphs.ITEMS if unit == UNIT_ITEMS else glyphs.GRAMS,
|
|
value=unit,
|
|
variable=vars_.unit,
|
|
command=lambda u=unit: on_unit_change(u),
|
|
font=(_FONT, LABEL),
|
|
bg=BG,
|
|
fg=FG,
|
|
selectcolor=_FIELD_BG,
|
|
activebackground=BG,
|
|
activeforeground=_ACCENT,
|
|
**_COLORS.focus_kwargs(),
|
|
).pack(side="left", padx=(SM, 0))
|
|
|
|
|
|
def build_macro_section(
|
|
root: tk.Misc,
|
|
parent: tk.Frame,
|
|
vars_: GateVars,
|
|
) -> tuple[tk.Label, tk.Entry, _MacroEntries]:
|
|
"""Build the per-basis field and macro row.
|
|
|
|
Returns the basis-prefix label, the "per" entry, and the four macro entries,
|
|
for the caller to store in the widget bundle.
|
|
"""
|
|
basis = tk.Frame(parent, bg=BG)
|
|
basis.pack()
|
|
basis_prefix = tk.Label(
|
|
basis,
|
|
text=BASIS_PREFIX_GRAMS,
|
|
font=(_FONT, LABEL),
|
|
bg=BG,
|
|
fg=FG,
|
|
)
|
|
basis_prefix.pack(side="left")
|
|
per_entry = _numeric_entry(root, basis, width=5, variable=vars_.entries.per)
|
|
per_entry.pack(side="left", padx=XS, ipady=XS)
|
|
# Blank kcal still means "look it up"; the busy cue shows it happening.
|
|
tk.Label(basis, text="g", font=(_FONT, LABEL), bg=BG, fg=FG).pack(side="left")
|
|
|
|
row = tk.Frame(parent, bg=BG)
|
|
row.pack(pady=(XS, XS))
|
|
# Shape + colour per macro, the phone's MacroKind vocabulary.
|
|
colors = glyphs.MACRO_COLORS
|
|
macros = _MacroEntries(
|
|
kcal=_macro_cell(root, row, "kcal", vars_.entries.kcal),
|
|
protein=_macro_cell(
|
|
root, row, glyphs.PROTEIN, vars_.entries.protein, colors["protein"]
|
|
),
|
|
carbs=_macro_cell(
|
|
root, row, glyphs.CARBS, vars_.entries.carbs, colors["carbs"]
|
|
),
|
|
fat=_macro_cell(root, row, glyphs.FAT, vars_.entries.fat, colors["fat"]),
|
|
)
|
|
return basis_prefix, per_entry, macros
|