| 1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677 |
- """Enter arriving inside a fast input burst: pasted newline or scripted submit.
- Paste without bracketed paste (tmux ``paste-buffer`` without ``-p``) and IME/voice dictation
- deliver every newline as its own Enter key right behind the text, so an Enter within
- ``RAPID_INPUT_ENTER_WINDOW_S`` of the last buffer change is a line break, not a submit (#10994).
- A script typing ``text`` + Enter in ONE write (``tmux send-keys 'text' Enter``, a PTY write of
- ``text\\r``) looks identical up to that Enter, except nothing follows it and no other Enter came
- before it. So an Enter with more keys of the same read still queued stays a newline, and so does
- the last Enter of a burst that already held one (the tail of a multi-line paste: input never went
- quiet for ``BURST_END_QUIET_S`` since that earlier Enter, however long the paste ran). The lone Enter
- that ends a burst inserts a provisional newline and submits once input has stayed quiet for
- ``BURST_END_QUIET_S``; any input in that window (the next chunk of a paste split across reads)
- keeps the newline.
- """
- from __future__ import annotations
- from time import monotonic
- RAPID_INPUT_ENTER_WINDOW_S = 0.05
- # Long enough for the next read of a paste split across reads (slow SSH links), short enough
- # that a scripted submit still feels immediate. Humans never reach this path: their Enter comes
- # more than RAPID_INPUT_ENTER_WINDOW_S after the last keystroke.
- BURST_END_QUIET_S = 0.25
- def note_text_change(cli) -> float:
- """Record a buffer change; input arriving inside the quiet window keeps a paste burst alive.
- So does input arriving while an Enter is held, however late a stalled loop reads it: it makes
- that Enter a pasted newline, so the paste's own trailing Enter stays one too.
- """
- now = monotonic()
- held = getattr(cli, "_tui_held_enter", None) is not None
- if held or now - getattr(cli, "_tui_paste_burst_at", float("-inf")) < BURST_END_QUIET_S:
- cli._tui_paste_burst_at = now
- cli._tui_held_enter = None
- return now
- def handle_burst_enter(cli, event, buf) -> bool:
- """Handle an Enter that arrived mid-burst; False when it is an ordinary (human) Enter.
- ``cli._tui_submit_buffer(event, buf)`` is called later when this Enter turns out to end the
- burst.
- """
- now = monotonic()
- if now - getattr(cli, "_tui_last_text_change", 0.0) >= RAPID_INPUT_ENTER_WINDOW_S:
- return False
- pasted_newline_before = now - getattr(cli, "_tui_paste_burst_at", float("-inf")) < BURST_END_QUIET_S
- cli._tui_paste_burst_at = now
- before = buf.document # the newline lands at the cursor, not necessarily at the end
- buf.insert_text("\n")
- app = event.app
- key_processor = getattr(app, "key_processor", None)
- loop = getattr(app, "loop", None)
- if key_processor is None or loop is None or key_processor.input_queue or pasted_newline_before:
- return True # inside (or the tail of) a multi-line paste
- with_newline = buf.document
- changed_at = getattr(cli, "_tui_last_text_change", 0.0)
- held = cli._tui_held_enter = object()
- def _settle() -> None:
- if cli._tui_held_enter is held:
- cli._tui_held_enter = None
- if not app.is_running or buf.document != with_newline or cli._tui_last_text_change != changed_at:
- return # more input arrived (or the buffer was edited): the newline stays
- buf.document = before
- cli._tui_submit_buffer(event, buf)
- app.invalidate()
- # Decide only after one more selector pass has run its reader callbacks: a loop stalled past
- # the window can reach this timer with the next chunk still unread (a signal handler that
- # interrupts the selector past its deadline returns no events). asyncio runs a call_soon
- # queued now ahead of the next pass's readers; the second hop runs after them.
- loop.call_later(BURST_END_QUIET_S, loop.call_soon, loop.call_soon, _settle)
- return True
|