How to make a Window's contents scrollable, auto-width, and not centered?

[jeffwright13]

I've defined a basic TUI with a Window object that holds ANSI-encoded test result data (several pages long). I have it rendering in the Window object, but it doesn't match what would actually be seen on the command line when pytest is run:

vs what I see:

The main things I see that don't meet my expectations are: (1) text should be left-justified, not centered; (2) line width should match that of the terminal in which it was run (is there an auto-width or wrap feature?); (3) since my text is longer than the screen height, I'd like to make it scrollable with a tab/slider on the right.

Code (yes, very hack-y, I admit!):

from __future__ import annotations
from pytest_tui.utils import Results
from pytermgui.parser import MarkupLanguage as ML
from pytermgui.pretty import print
import pytermgui as ptg

test_results = Results()


def _get_short_test_summary_results() -> str:
    return test_results.Sections["LAST_LINE"].content.replace("=", "").replace("\n", "")


def _get_test_session_start_results() -> str:
    return test_results.Sections["TEST_SESSION_STARTS"].content


def _configure_widgets() -> None:
    ptg.boxes.SINGLE.set_chars_of(ptg.Window)


def _define_layout() -> ptg.Layout:
    layout = ptg.Layout()

    layout.add_slot("HeaderSlot", height=3)
    layout.add_slot("QuitterSlot", width=0.12)
    layout.add_break()

    layout.add_slot("TabSummarySlot", height=3, width=0.11)
    layout.add_slot("TabPassesSlot", height=3, width=0.11)
    layout.add_slot("TabFailuresSlot", height=3, width=0.11)
    layout.add_slot("TabSkippedSlot", height=3, width=0.11)
    layout.add_slot("TabXfailsSlot", height=3, width=0.11)
    layout.add_slot("TabXpassesSlot", height=3, width=0.11)
    layout.add_slot("TabWarningsSlot", height=3, width=0.11)
    layout.add_slot("TabErrorsSlot", height=3, width=0.11)
    layout.add_slot("TabFullOutputSlot", height=3, width=0.11)
    layout.add_break()

    layout.add_slot("BodySlot")
    layout.add_break()

    return layout


def main(argv: list[str] | None = None) -> None:
    _configure_widgets()
    short_test_summary_results = _get_short_test_summary_results()
    test_session_start_results = _get_test_session_start_results()

    with ptg.WindowManager() as manager:
        manager.layout = _define_layout()

        header = ptg.Window(
            ML().get_markup(short_test_summary_results),
            box="SINGLE",
            is_persistent=True,
        )
        quitter = ptg.Window(
            ptg.Button("Quit (q)", lambda *_: manager.stop()),
            box="SINGLE",
            is_persistent=True,
        )
        manager.bind("q", lambda *_: manager.stop())
        manager.add(header)
        manager.add(quitter)

        tab_summary = ptg.Window(
            ptg.Button("Summary (s)", lambda *_: None),
            box="SINGLE",
        )
        manager.bind("s", lambda *_: None)
        manager.add(tab_summary)

        tab_passes = ptg.Window(
            ptg.Button("Passes (p)", lambda *_: None),
            box="SINGLE",
        )
        manager.bind("p", lambda *_: None)
        manager.add(tab_passes)

        tab_failures = ptg.Window(
            ptg.Button("Failures (f)", lambda *_: None),
            box="SINGLE",
        )
        manager.bind("f", lambda *_: None)
        manager.add(tab_failures)

        tab_skipped = ptg.Window(
            ptg.Button("Skipped (s)", lambda *_: None),
            box="SINGLE",
        )
        manager.bind("s", lambda *_: None)
        manager.add(tab_skipped)

        tab_xfails = ptg.Window(
            ptg.Button("Xfails (x)", lambda *_: None),
            box="SINGLE",
        )
        manager.bind("x", lambda *_: None)
        manager.add(tab_xfails)

        tab_xpasses = ptg.Window(
            ptg.Button("Xpasses (q)", lambda *_: None),
            box="SINGLE",
        )
        manager.bind("q", lambda *_: None)
        manager.add(tab_xpasses)

        tab_warnings = ptg.Window(
            ptg.Button("Warnings (q)", lambda *_: None),
            box="SINGLE",
        )
        manager.bind("w", lambda *_: None)
        manager.add(tab_warnings)

        tab_errors = ptg.Window(
            ptg.Button("Errors (e)", lambda *_: None),
            box="SINGLE",
        )
        manager.bind("e", lambda *_: None)
        manager.add(tab_errors)

        tab_allout = ptg.Window(
            ptg.Button("All Output (a)", lambda *_: None),
            box="SINGLE",
        )
        manager.bind("a", lambda *_: None)
        manager.add(tab_allout)

        body = ptg.Window(
            ML().get_markup(test_session_start_results),
            # k,
            box="SINGLE",
        )
        manager.add(body)


if __name__ == "__main__":
    main()

[bczsalba]

Sadly, the scrollbar part is not available at the moment, but it's on it's way. Other than that, what you want is somewhat displayed in the scrolling sandbox file. Some of the code is a bit behind on the API, so just look at these.

I have a feeling you might run into some performance issues with this sadly. As I said in the issue above, the current scrolling behaviour is kind of not very smart, so it does a lot of extra rendering.

One small gain to performance you can have would be to split all the lines into their own labels, like so:

...

body = ptg.Window(
    *[
         ptg.Label(line, parent_align=0)
         for line in ptg.tim.get_markup(test_session_start_results).splitlines()
      ]
    overflow=ptg.Overflow.SCROLL,
)

...

Here, parent_align does the centering part you are after. Another thing you could do, though one that I'm not sure would work for your project, is to split the results into multiple smaller parts, and have them be within scrollable containers themselves. This in general would probably lead to better performance and possibly even a better user experience, but again I'm not sure what your goals are.