console-window 2.0.0.8__tar.gz → 2.0.0.9__tar.gz

{console_window-2.0.0.8 → console_window-2.0.0.9}/CHANGELOG.md

@@ -6,6 +6,10 @@ This project follows [Semantic Versioning](https://semver.org/).
 ## [Unreleased]
 
 ### Added
+- `line_attr` on `add_fancy_header()`/`add_header_line()`: an attribute OR'd
+  into every span of the header (including plain spans and the raw line emitted
+  for `mode='Off'`), so a caller can dim a whole fancy header while keeping the
+  per-span bold/underline/reverse styling.
 - `suspend_curses()`/`resume_curses()` on `ConsoleWindow`: leave curses mode
   with `endwin()` while keeping the window (pads, content model, pick state)
   alive, then reattach a screen and repaint.  This is the supported way for an

{console_window-2.0.0.8 → console_window-2.0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: console-window
-Version: 2.0.0.8
+Version: 2.0.0.9
 Summary: A robust curses wrapper for creating Text User Interfaces (TUIs).
 Author-email: Joe Defen <joedef@duck.com>
 Requires-Python: >=3.10
@@ -122,7 +122,9 @@ demonstrates:
   sizes.
 * **`flash()`** — transient, non-destructive status messages.
 * **Token-based headers** — `HeaderLine` (`text`, `bracket_key`, `key`, `extend`)
-  rendered with `add_header_line()`, rather than string markup.
+  rendered with `add_header_line()`, rather than string markup. Both header
+  helpers accept `line_attr`, an attribute OR'd into every span, so a whole
+  header can be dimmed (`curses.A_DIM`) without losing its per-span styling.
 * **`Ctrl-C` as an application key** — `ctrl_c_terminates=False` and
   `keys={0x3, ord('q')}` on the quit action. This works only while no live
   window in the process has requested terminating Ctrl-C: once any window uses

{console_window-2.0.0.8 → console_window-2.0.0.9}/README.md

@@ -103,7 +103,9 @@ demonstrates:
   sizes.
 * **`flash()`** — transient, non-destructive status messages.
 * **Token-based headers** — `HeaderLine` (`text`, `bracket_key`, `key`, `extend`)
-  rendered with `add_header_line()`, rather than string markup.
+  rendered with `add_header_line()`, rather than string markup. Both header
+  helpers accept `line_attr`, an attribute OR'd into every span, so a whole
+  header can be dimmed (`curses.A_DIM`) without losing its per-span styling.
 * **`Ctrl-C` as an application key** — `ctrl_c_terminates=False` and
   `keys={0x3, ord('q')}` on the quit action. This works only while no live
   window in the process has requested terminating Ctrl-C: once any window uses

{console_window-2.0.0.8 → console_window-2.0.0.9}/console_window/__init__.py

@@ -1,6 +1,6 @@
 # Single source of truth for the package version: pyproject.toml declares
 # ``dynamic = ["version"]``, so flit reads this value instead of duplicating it.
-__version__ = "2.0.0.8"
+__version__ = "2.0.0.9"
 
 from .context import Context
 from .header import HeaderLine, Span

{console_window-2.0.0.8 → console_window-2.0.0.9}/console_window/window.py

@@ -985,7 +985,8 @@ class ConsoleWindow:
         self._add(self.body, text, attr, resume, context, is_body=True)
 
     def add_fancy_header(self, line: str | HeaderLine, mode: str = 'Underline',
-                         search_pattern_attr: int | None = None) -> None:
+                         search_pattern_attr: int | None = None,
+                         line_attr: int | None = None) -> None:
         """Add a header line with legacy ``[x]``/``KEY:``/``/pattern`` markup.
 
         String input is parsed unless ``mode='Off'``.  A :class:`HeaderLine`
@@ -993,44 +994,67 @@ class ConsoleWindow:
         treated as markup too: in every mode except ``'Off'`` they are removed,
         while the enclosed key keeps its ``KEY`` styling.  Use
         :meth:`add_header_line` when literal brackets are wanted.
+
+        *line_attr* is OR'd into the attribute of every span (and into the raw
+        line emitted for ``mode='Off'``), so a caller can, for example, dim a
+        whole header with ``line_attr=curses.A_DIM`` while keeping each span's
+        own bold/underline/reverse styling.
         """
         if isinstance(line, str):
             if mode == 'Off':
-                # Legacy: no markup processing, add the raw line unchanged.
-                self.add_header(line)
+                # Legacy: no markup processing, add the raw line unchanged
+                # (except for the caller's whole-line attribute).
+                self.add_header(line, attr=line_attr)
                 return
             spans = parse_fancy_header(line)
         else:
             spans = list(line)
             if mode != 'Off':
                 spans = strip_key_brackets(spans)
-        self._emit_header_spans(spans, mode, search_pattern_attr)
+        self._emit_header_spans(spans, mode, search_pattern_attr, line_attr)
 
     def add_header_line(self, header_line: HeaderLine | Iterable[Span],
                         mode: str = 'Underline',
-                        search_pattern_attr: int | None = None) -> None:
-        self._emit_header_spans(list(header_line), mode, search_pattern_attr)
+                        search_pattern_attr: int | None = None,
+                        line_attr: int | None = None) -> None:
+        """Render explicit header spans; see :meth:`add_fancy_header`.
+
+        *line_attr* is OR'd into every span's resolved attribute, including
+        plain spans, so the whole line can carry an extra style such as
+        ``curses.A_DIM``.
+        """
+        self._emit_header_spans(list(header_line), mode, search_pattern_attr,
+                                line_attr)
 
     @staticmethod
     def _resolve_header_attr(role: str, mode: str,
-                             search_pattern_attr: int | None) -> int | None:
+                             search_pattern_attr: int | None,
+                             line_attr: int | None = None) -> int | None:
         if mode == 'Off' or role == PLAIN:
-            return None
-        if role == LABEL:
-            return curses.A_BOLD
-        if role == SEARCH:
+            attr = None
+        elif role == LABEL:
+            attr = curses.A_BOLD
+        elif role == SEARCH:
             if search_pattern_attr is not None:
-                return search_pattern_attr
-            return curses.A_BOLD | curses.A_REVERSE
+                attr = search_pattern_attr
+            else:
+                attr = curses.A_BOLD | curses.A_REVERSE
         # KEY (and any unknown role) follows the mode's key styling.
-        if mode == 'Underline':
-            return curses.A_UNDERLINE | curses.A_BOLD
-        return curses.A_REVERSE
+        elif mode == 'Underline':
+            attr = curses.A_UNDERLINE | curses.A_BOLD
+        else:
+            attr = curses.A_REVERSE
+        if line_attr is not None:
+            attr = (attr or 0) | line_attr
+        return attr
 
     def _emit_header_spans(self, spans: Iterable[Span], mode: str,
-                           search_pattern_attr: int | None = None) -> None:
+                           search_pattern_attr: int | None = None,
+                           line_attr: int | None = None) -> None:
         result_sections = [
-            (span.text, self._resolve_header_attr(span.role, mode, search_pattern_attr))
+            (span.text,
+             self._resolve_header_attr(span.role, mode, search_pattern_attr,
+                                       line_attr))
             for span in spans
         ]
 

{console_window-2.0.0.8 → console_window-2.0.0.9}/tests/test_header.py

@@ -207,6 +207,48 @@ def test_add_fancy_header_headerline_preserves_explicit_roles():
         win.stop_curses()
 
 
+def test_add_fancy_header_line_attr_dims_every_run():
+    # line_attr is OR'd into each span's own style, so a dimmed legend keeps
+    # its underlined keys and its explicitly styled search field.
+    win = _make_window()
+    try:
+        win.add_fancy_header('[v]iew /pat', mode='Underline',
+                             search_pattern_attr=curses.A_BOLD,
+                             line_attr=curses.A_DIM)
+        assert win.head.texts[0] == 'view /pat'
+        attrs = [attr for attr, _count in win.head.text_attrs[0]]
+        assert all(attr & curses.A_DIM for attr in attrs)
+        assert KEY_ATTR | curses.A_DIM in attrs
+        assert curses.A_BOLD | curses.A_DIM in attrs
+    finally:
+        win.stop_curses()
+
+
+def test_add_fancy_header_line_attr_applies_in_off_mode():
+    # mode='Off' emits the raw string, but the whole-line attribute still
+    # applies (otherwise a caller could not dim it at all).
+    win = _make_window()
+    try:
+        win.add_fancy_header('[v]iew', mode='Off', line_attr=curses.A_DIM)
+        assert win.head.texts[0] == '[v]iew'
+        assert all(attr & curses.A_DIM
+                   for attr, _count in win.head.text_attrs[0])
+    finally:
+        win.stop_curses()
+
+
+def test_add_header_line_line_attr_dims_plain_spans():
+    win = _make_window()
+    try:
+        win.add_header_line(HeaderLine().text('plain').label('T'),
+                            mode='Underline', line_attr=curses.A_DIM)
+        attrs = [attr for attr, _count in win.head.text_attrs[0]]
+        assert curses.A_DIM in attrs             # the PLAIN run
+        assert curses.A_BOLD | curses.A_DIM in attrs  # the LABEL run
+    finally:
+        win.stop_curses()
+
+
 def test_string_reparse_drops_keys_the_legacy_grammar_cannot_spell():
     # str(line) is pure text, so the legacy scanner's two KEY rules ('[x]' and
     # 'UPPERCASE:') are all that survive a round trip.  'l:' and '?:' match
@@ -253,3 +295,15 @@ def test_token_and_string_paths_converge_for_legacy_spelled_keys():
 
 def test_resolve_header_attr_off_is_plain(role):
     assert ConsoleWindow._resolve_header_attr(role, 'Off', None) is None
+
+
+def test_resolve_header_attr_line_attr_combines_with_roles():
+    assert (ConsoleWindow._resolve_header_attr(
+                PLAIN, 'Underline', None, curses.A_DIM)
+            == curses.A_DIM)
+    assert (ConsoleWindow._resolve_header_attr(
+                KEY, 'Underline', None, curses.A_DIM)
+            == KEY_ATTR | curses.A_DIM)
+    assert (ConsoleWindow._resolve_header_attr(
+                SEARCH, 'Underline', curses.A_BOLD, curses.A_DIM)
+            == curses.A_BOLD | curses.A_DIM)