From a3c14925bc6f25b3e47cee01dfb32ff5d557c5ad Mon Sep 17 00:00:00 2001 From: Tristan Simas Date: Wed, 18 Nov 2026 05:21:52 -0500 Subject: [PATCH] qt views: the composer is built just after the history first paints Opening a second channel at a phone's speed held the loop for one long stall, and 335 ms of the 491 ms (probed) was ConversationView's constructor: 170 ms of it the composer (channel_prompt: ComposerEditor, place_input_box, focus_changed, paint_colours). Rows are measured in the relayouts after it. QtConversation.reserve_composer is the one owner for every view kind: - the composer's place in the layout holds a ComposerPlaceholder, as tall as that view kind's composer last asked to be (composer_heights, its sizeHint), else an estimate from its parts (the editor's line and padding over the info bar's line); - the composer is built just after the history viewport's first Paint (an event filter, then a zero timer), replacing the placeholder in place; - a tap or focus on the placeholder builds it at once and hands it the focus, so typing never waits; a view never shown (a restored background tab) builds none until it is; - what the composer is told before it exists goes through on_composer: now once it is built, else at the mount, the latest of each kind (label, status, commands, hold, receipt, mention candidates), so nothing piles up while a view is hidden; - close_core_events forgets a composer not built yet. ConversationView and the thread views (QtThreadView, so mailbox and ACP) reserve it the same way; the thread view's one-tick QTimer mount goes, and so does its own copy of the "Composer mount failed" handling. The question under the composer keeps its place. On Android the composer stays out of the first frame's EGL setup, as before. Measured placeholder vs built height (Pixel 8a profile): 60 px / 60 px for the channel, DM and mailbox views. tools/qt_drive.py (tools only): FRAME_TIME_OPEN also times the composer's mount, the delegate's new_document / final_document and the history's fragment_height / block_row, and prints each composer's placeholder height beside its built one. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01RnH6dT7wdh7i4tjJZQdFu3 --- src/toad/qt/acp_tab.py | 3 +- src/toad/qt/conversation.py | 116 ++++++++++++++++++++++++++++++--- src/toad/qt/submission_view.py | 3 +- src/toad/qt/thread_view.py | 25 +++---- src/toad/qt/window.py | 17 ++--- tools/qt_drive.py | 16 +++++ tools/qt_inherit_ratchet.py | 3 + 7 files changed, 146 insertions(+), 37 deletions(-) diff --git a/src/toad/qt/acp_tab.py b/src/toad/qt/acp_tab.py index 7597dabd5..7fba8db09 100644 --- a/src/toad/qt/acp_tab.py +++ b/src/toad/qt/acp_tab.py @@ -142,8 +142,7 @@ def show_agent_info(self, text: str) -> None: """The identity line and composer name the agent, as Textual's info bar does.""" self.identity_line.setText(f"ACP session #{self._session_pk} · {text}") self._composer_label = text - if self.composer is not None: - self.composer.labelled(text) + self.on_composer("label", lambda composer: composer.labelled(text)) @property def agent_title(self) -> str: diff --git a/src/toad/qt/conversation.py b/src/toad/qt/conversation.py index 45d7ba377..ad6d017a0 100644 --- a/src/toad/qt/conversation.py +++ b/src/toad/qt/conversation.py @@ -13,6 +13,7 @@ import asyncio import inspect +from collections.abc import Callable import shiboken6 from textual.content import Content @@ -23,14 +24,15 @@ from agent_comms.registry.thread_presentation import NoThreadPresentation, ThreadPresentation from agent_comms.ui_model.message_category import all_categories from metaclass_registry.mro_dispatch import MroDispatch -from PySide6.QtCore import QTimer -from PySide6.QtWidgets import QWidget +from PySide6.QtCore import QEvent, QObject, Qt, QTimer +from PySide6.QtWidgets import QBoxLayout, QWidget from pyqt_reactive.protocols.widget_adapters import PyQtWidgetMeta from toad.agent_binding import AgentConnection, NoAgentConnection from toad.agent_turn_events import AgentTurnEvents from toad.answer import Ask from toad.qt.agent_surface import QtSurfaceBinding, subscribe_agent +from toad.qt.metrics import UiGap from toad.client.agent_bound import ObservedAgentBinding from toad.client.bus_submission import TypedText from toad.client.category_selection import CategorySelection @@ -67,6 +69,24 @@ from toad.workspace_frame import WorkspaceFrame +class ComposerPlaceholder(QWidget): + """A view's composer until it is built (`QtConversation.reserve_composer`): as tall as + that kind's composer last was, so nothing moves when it arrives. A tap or the focus on + it builds the composer at once and hands it the focus.""" + + def __init__(self, view: QtConversation, height: int) -> None: + super().__init__() + self.view = view + self.setFixedHeight(height) + self.setFocusPolicy(Qt.FocusPolicy.StrongFocus) + + def mousePressEvent(self, event) -> None: # type: ignore[override] + self.view.mount_composer(focus=True) + + def focusInEvent(self, event) -> None: # type: ignore[override] + self.view.mount_composer(focus=True) + + class QtConversation( AgentTurnEvents, QtViewSettings, @@ -104,7 +124,12 @@ class QtConversation( _unpublished_presentation: ThreadPresentation = NoThreadPresentation() """An observed presentation whose transcript refresh waits for this view to be shown.""" composer: Composer | None = None - """Textual's prompt; a thread view mounts it one Qt tick after construction.""" + """Textual's prompt, built just after the view's history first paints + (`reserve_composer`); None until then.""" + composer_heights: dict[type, int] = {} + """Each view kind's composer height when it was last built: the placeholder's height, so + nothing moves when the composer arrives. Shared by every view of the kind.""" + _composer_reserved: tuple | None = None activity: tuple[QWidget, ...] """The rows under the transcript that observe Core, each closed with the view.""" @@ -124,6 +149,9 @@ def _setup_conversation(self, app) -> None: self.feedback = QtFlash(app, app.renderer) self.agent_activity = QtObservedSweep(self.working, renderer=app.renderer) self.submissions = ConversationSubmissions(self) + # What the composer is told before it is built, the latest of each kind, told at + # its mount (`on_composer`). + self._composer_applies: dict[str, Callable[[Composer], None]] = {} # Every conversation answers the workspace's `ViewAction` keys, as Textual's # `WorkspaceFrame` does for whichever conversation it shows: each member whose # declared capability this view has binds through the shared family loop, so @@ -137,11 +165,83 @@ def back_to_bottom_windows(self) -> tuple[JumpsToLatest, ...]: (`JumpsHistory`): `BackToBottomAction.apply(self)` jumps it to its latest row.""" return (self.messages,) if self.messages.can_jump_to_latest else () + # ---- The composer: built once the view's history has painted ---- + + def reserve_composer(self, layout: QBoxLayout, build: Callable[[], Composer], + mounted: Callable[[Composer], None]) -> None: + """The composer's place in `layout`, held by a placeholder as tall as this kind's + composer last was. The composer is built just after the history first paints, so + opening a view draws its history without waiting for the composer (a channel's took + 170 ms of a 491 ms open at a phone's speed), and a view never shown (a restored tab + in the background) builds none until it is. On Qt-for-Android this also keeps + ``QPlainTextEdit`` out of the first frame's EGL setup, which it deadlocks against + (``QtAndroidAccessibility``). `mounted` places what goes with it.""" + placeholder = ComposerPlaceholder(self, self.composer_heights.get(type(self), self.estimated_composer_height())) + layout.addWidget(placeholder) + self._composer_reserved = (layout, placeholder, build, mounted) + self.messages.viewport().installEventFilter(self) + + def estimated_composer_height(self) -> int: + """Before any composer of this kind was built: its editor (one line and the padding + `Composer.fit_height` gives it) over its info bar (a line and its margin).""" + line = self.fontMetrics().lineSpacing() + return (line + 24) + (line + UiGap.tight) + + def eventFilter(self, watched: QObject, event: QEvent) -> bool: # type: ignore[override] + if (event.type() == QEvent.Type.Paint and self._composer_reserved is not None + and watched is self.messages.viewport()): + watched.removeEventFilter(self) + QTimer.singleShot(0, self.mount_composer) + return super().eventFilter(watched, event) + + def mount_composer(self, focus: bool = False) -> None: + """Build the reserved composer in its placeholder's place, then tell it what it was + told meanwhile. Touching the placeholder mounts it at once, with the focus, so + typing never waits. A failed mount is loud: a silently missing composer is how the + mailbox view first shipped.""" + reserved, self._composer_reserved = self._composer_reserved, None + if reserved is None or not shiboken6.isValid(self): + return + layout, placeholder, build, mounted = reserved + self.messages.viewport().removeEventFilter(self) + try: + composer = build() + except Exception as error: + self.app.show_error(error, "Composer mount failed") + return + layout.replaceWidget(placeholder, composer) + placeholder.deleteLater() + self.composer = composer + mounted(composer) + applies, self._composer_applies = self._composer_applies, {} + for apply in applies.values(): + apply(composer) + if focus: + composer.editor.setFocus() + QTimer.singleShot(0, partial(self.remember_composer_height, composer)) + + def remember_composer_height(self, composer: Composer) -> None: + """The height the composer asks for, not the room it was given: a view whose + transcript is not laid out yet lets it stretch.""" + if shiboken6.isValid(composer): + self.composer_heights[type(self)] = composer.sizeHint().height() + + def on_composer(self, kind: str, apply: Callable[[Composer], None]) -> None: + """Tell the composer something: now once it is built, else at its mount, where only + the latest of each `kind` is told (a label, a status, the mention candidates).""" + if self.composer is not None: + apply(self.composer) + else: + self._composer_applies[kind] = apply + def close_core_events(self) -> None: """The view's subscriptions end, the rows under the transcript stop observing, and a command read in flight is dropped: it would hand its catalog to a deleted composer. Reads are exclusive across views, so the one running may be another - tab's; that composer asks again on its next keystroke (`Composer.refresh_offers`).""" + tab's; that composer asks again on its next keystroke (`Composer.refresh_offers`). + A composer not built yet never will be.""" + self._composer_reserved = None + self._composer_applies.clear() super().close_core_events() for row in self.activity: row.close_activity() @@ -172,9 +272,8 @@ def thread_status(self, status) -> None: self.sync_status() def sync_status(self) -> None: - """The info bar shows `ComposerStatus.composed_status()` once the composer exists.""" - if self.composer is not None: - self.composer.show_status(self.composed_status()) + """The info bar shows `ComposerStatus.composed_status()`, once the composer exists.""" + self.on_composer("status", lambda composer: composer.show_status(self.composed_status())) def present_thread_status(self) -> None: """A native agent reports its configuration through ACP (Textual's @@ -239,8 +338,7 @@ def update_slash_commands(self) -> None: async def read_commands(self) -> None: catalog = await self.read_command_catalog() - if self.composer is not None: - self.composer.set_commands(catalog.commands) + self.on_composer("commands", lambda composer: composer.set_commands(catalog.commands)) async def read_command_catalog(self) -> CommandCatalog: """Textual's `Conversation.read_command_catalog`: the bound agent's advertised diff --git a/src/toad/qt/submission_view.py b/src/toad/qt/submission_view.py index a8fed6ff1..d39a2522e 100644 --- a/src/toad/qt/submission_view.py +++ b/src/toad/qt/submission_view.py @@ -24,8 +24,7 @@ def delivery_unknown(self, description: str, body: str) -> None: async def refresh_composer(self, read_only: bool) -> None: """Hold the composer with the destination's read-only reason, or release it.""" self.composer_block = MessageDestination.read_only_reason if read_only else "" - if self.composer is not None: - self.composer.hold(self.composer_block) + self.on_composer("hold", lambda composer: composer.hold(self.composer_block)) def draws_user_message(self, reference) -> bool: return self.message_history.draws(reference) diff --git a/src/toad/qt/thread_view.py b/src/toad/qt/thread_view.py index 5a4c8baad..86adc2814 100644 --- a/src/toad/qt/thread_view.py +++ b/src/toad/qt/thread_view.py @@ -14,6 +14,8 @@ from typing import TYPE_CHECKING from agent_comms.messaging.channel_targets import CommandTarget +from functools import partial + from PySide6.QtCore import QTimer from PySide6.QtWidgets import QVBoxLayout, QWidget from pyqt_reactive.protocols.widget_adapters import PyQtWidgetMeta @@ -141,10 +143,8 @@ def _setup_prompt_stack(self, app: "QtToadApp", layout: QVBoxLayout, incarnation """Mount, under the transcript, the rows Textual's `Conversation.compose` yields after its window, in its order: flash, sweep, session status, goal bar, prompt. - The composer mounts one Qt event-loop tick later: on Qt-for-Android, mounting - ``QPlainTextEdit`` during ``__init__`` races ``QtAndroidAccessibility`` with the - first-paint EGL setup and deadlocks the window. Its slot is reserved here so it - lands in order.""" + The composer is built once the transcript has painted (`reserve_composer`); its + slot is reserved here so it lands in order, with the question under it.""" self.thread_activity = QtSessionDetails(self, app.renderer) self.goal_bar = None if incarnation is None else QtGoalBar(app, app.renderer, incarnation) self.activity = tuple(row for row in (self.thread_activity, self.goal_bar) if row is not None) @@ -154,22 +154,15 @@ def _setup_prompt_stack(self, app: "QtToadApp", layout: QVBoxLayout, incarnation layout.addWidget(row) layout.addLayout(self._composer_slot) self.refresh_thread_status() - QTimer.singleShot(0, lambda: self._mount_composer(app)) - - def _mount_composer(self, app: "QtToadApp") -> None: - """Deferred composer mount; see `_setup_prompt_stack`. A failed mount is loud: - a silently-missing composer is how the mailbox view first shipped.""" - try: - self.composer = self.composer_class()(self, app.renderer) - except Exception as error: - app.show_error(error, "Composer mount failed") - return - self._composer_slot.addWidget(self.composer) + self.reserve_composer(self._composer_slot, lambda: self.composer_class()(self, app.renderer), + partial(self._composer_mounted, app)) + + def _composer_mounted(self, app: "QtToadApp", composer: Composer) -> None: # Under the composer, as on a channel: the question an agent asks (a permission, a # confirmation), hidden until asked. self.question = QtQuestion(app, self) self._composer_slot.addWidget(self.question) - self.composer.labelled(self.composer_label) + composer.labelled(self.composer_label) self.sync_status() async def command_target_context(self) -> TargetContext: diff --git a/src/toad/qt/window.py b/src/toad/qt/window.py index ee8ab44d4..092f0dc5b 100644 --- a/src/toad/qt/window.py +++ b/src/toad/qt/window.py @@ -1262,8 +1262,6 @@ def __init__(self, app: QtToadApp, entry: QtHistorySessionEntry) -> None: # Textual's `CommsChatView.compose`: the flash under the window, the sweep painting # `working()` (an idle turn, the peer's observed row, or the first page loading), # the prompt (its info bar carries the thread status), then who is here. - self.composer = self.conversation.prompt(self) - self.composer.labelled(label) self.activity = tuple(self.conversation.compose_activity(self)) # The inline consent prompt ("did you mean it?", edit/clear confirmations) — hidden # until the conversation asks, mounted below the composer so the picks sit where @@ -1275,7 +1273,8 @@ def __init__(self, app: QtToadApp, entry: QtHistorySessionEntry) -> None: layout.addWidget(self.messages, 1) layout.addWidget(self.feedback) layout.addWidget(self.agent_activity) - layout.addWidget(self.composer) + self.reserve_composer(layout, lambda: self.conversation.prompt(self), + lambda composer: composer.labelled(label)) layout.addWidget(self.question) # Under the prompt, not over it: who is here is reference (Textual's # `CommsChatView.compose` yields the kind's activity after the prompt). @@ -1306,7 +1305,8 @@ async def wait_content_ready(self) -> None: def close_core_events(self) -> None: """The shared close (its history lets go of the wire), then the receipt stops following.""" super().close_core_events() - self.composer.receipt.stop() + if self.composer is not None: + self.composer.receipt.stop() async def retire_presentation(self) -> None: """The history lets go of its page reader; its rows go with the widgets.""" @@ -1336,13 +1336,14 @@ async def _refresh_source(self) -> None: finally: self.content_ready.set() self.submissions.settle() - self.composer.receipt.follow(str(source.root), next(( + followed = (str(source.root), next(( references for fragment in reversed(history.fragments) if (references := fragment.sent_references)), ()), history.pages[-1].prepared.page.source.selection.notification_identity) + self.on_composer("receipt", lambda composer: composer.receipt.follow(*followed)) self.refresh_thread_status() self.sync_working() label = self.conversation.label(source.references()) - self.composer.labelled(label) + self.on_composer("label", lambda composer: composer.labelled(label)) read_only = await asyncio.to_thread(self.conversation.read_only, source.core) await self.refresh_composer(read_only) self.thread_status = await self.conversation.status_text(source, read_only=read_only) @@ -1377,8 +1378,8 @@ def compose_peer_activity(self, peer: ThreadIncarnation) -> Iterator[QtGoalBar | async def update_channel_mentions(self, source: ReferencedCore) -> None: answer = await self.app.coordination_access.current_sidebar() - self.composer.set_mention_candidates( - await self.app.preparation.run_thread(self.conversation.mention_candidates, answer)) + candidates = await self.app.preparation.run_thread(self.conversation.mention_candidates, answer) + self.on_composer("mentions", lambda composer: composer.set_mention_candidates(candidates)) # Commands the composer offers after a / diff --git a/tools/qt_drive.py b/tools/qt_drive.py index 6ed049e11..1641aaba5 100644 --- a/tools/qt_drive.py +++ b/tools/qt_drive.py @@ -2154,6 +2154,22 @@ def wrapper(*args, **kwargs): timed_open(delegate, name, f"rows.{name}") for name in ("rows_changed", "show_pages"): timed_open(qt_history.QtHistoryWindow, name, f"window.{name}") + for name in ("new_document", "final_document"): + if name in delegate.__dict__: + timed_open(delegate, name, f"rows.{name}") + for name in ("fragment_height", "block_row"): + timed_open(qt_history.HistoryRowDelegate, name, f"history.{name}") + # The composer's mount after the first paint, and whether its placeholder held its height. + from toad.qt.conversation import QtConversation + timed_open(QtConversation, "mount_composer", "open.composer_mount") + remember = QtConversation.remember_composer_height + + def compared(view, composer) -> None: + placeholder = view.composer_heights.get(type(view), view.estimated_composer_height()) + print(f" composer {type(view).__name__}: placeholder {placeholder}px, built {composer.sizeHint().height()}px (given {composer.height()}px)", + flush=True) + remember(view, composer) + QtConversation.remember_composer_height = compared self.timings = timings def write_timings(self, probe) -> None: diff --git a/tools/qt_inherit_ratchet.py b/tools/qt_inherit_ratchet.py index 7e5cfcb26..d7613970e 100644 --- a/tools/qt_inherit_ratchet.py +++ b/tools/qt_inherit_ratchet.py @@ -98,6 +98,9 @@ } QT_ONLY = { + 'toad.qt.conversation.ComposerPlaceholder': "a Qt composer's place held before it is built: Qt builds a view's widgets in " + "its constructor, so a composer built there holds the view's first frame (and on Android races the first frame's EGL " + "setup); Textual composes a screen's widgets and mounts them after its first frame, so it has no placeholder to hold", 'toad.qt.widget_animation.WidgetAnimation': "a clock target's life bound to its Qt widget's C++ lifetime (destroyed signal, shiboken validity); a Textual widget is a Python object the clock can always ask", 'toad.qt.history.ArrivalFade': "a burst's rows painted at the ARRIVAL cascade's frame as QPainter opacity; Textual paints the same frame into its strips (TranscriptHistory.arrivals_began), and both read the cascade from toad.frame_presentation", 'toad.qt.action_shortcuts.BoundAction': "a live QShortcut and the action it answers: Qt fires neither of two shortcuts sharing a key (activatedAmbiguously), so ActionKeys keeps each to apply the declared binding order; Textual walks its binding chain itself",