urwid frontend: handle long-running commands and lengthy output better.

Marien Zwart · Marien Zwart · commit ad51de23a2a8 · 2011-10-11T22:36:15.000+02:00
Redrawing the screen is relatively slow, so rate-limiting it greatly
speeds up inputs that result in a lot of output quickly.

Also, scrolling to the bottom while waiting for a command to run out
of output makes it more obvious we did not get stuck.

Both issues reported by tos9 over irc.
diff --git a/bpython/urwid.py b/bpython/urwid.py
@@ -37,6 +37,7 @@
 
 import sys
 import os
+import time
 import locale
 import signal
 from types import ModuleType
@@ -438,9 +439,15 @@ def notify(self, s, n=10):
 
 class URWIDRepl(repl.Repl):
 
+    _time_between_redraws = .05 # seconds
+
     def __init__(self, event_loop, palette, interpreter, config):
         repl.Repl.__init__(self, interpreter, config)
 
+        self._redraw_handle = None
+        self._redraw_pending = False
+        self._redraw_time = 0
+
         self.listbox = BPythonListBox(urwid.SimpleListWalker([]))
 
         # String is straight from bpython.cli
@@ -485,6 +492,13 @@ def echo(self, orig_s):
                 self.current_output = urwid.Text(('output', s))
                 if self.edit is None:
                     self.listbox.body.append(self.current_output)
+                    # Focus the widget we just added to force the
+                    # listbox to scroll. This causes output to scroll
+                    # if the user runs a blocking call that prints
+                    # more than a screenful, instead of staying
+                    # scrolled to the previous input line and then
+                    # jumping to the bottom when done.
+                    self.listbox.set_focus(len(self.listbox.body) - 1)
                 else:
                     self.listbox.body.insert(-1, self.current_output)
                     # The edit widget should be focused and *stay* focused.
@@ -496,9 +510,37 @@ def echo(self, orig_s):
                     ('output', self.current_output.text + s))
         if orig_s.endswith('\n'):
             self.current_output = None
-        # TODO: maybe do the redraw after a short delay
-        # (for performance)
-        self.main_loop.draw_screen()
+
+        # If we hit this repeatedly in a loop the redraw is rather
+        # slow (testcase: pprint(__builtins__). So if we have recently
+        # drawn the screen already schedule a call in the future.
+        #
+        # Unfortunately we may hit this function repeatedly through a
+        # blocking call triggered by the user, in which case our
+        # timeout will not run timely as we do not return to urwid's
+        # eventloop. So we manually check if our timeout has long
+        # since expired, and redraw synchronously if it has.
+        if self._redraw_handle is None:
+            self.main_loop.draw_screen()
+
+            def maybe_redraw(loop, self):
+                if self._redraw_pending:
+                    loop.draw_screen()
+                    self._redraw_pending = False
+
+                self._redraw_handle = None
+
+            self._redraw_handle = self.main_loop.set_alarm_in(
+                self._time_between_redraws, maybe_redraw, self)
+            self._redraw_time = time.time()
+        else:
+            self._redraw_pending = True
+            now = time.time()
+            if now - self._redraw_time > 2 * self._time_between_redraws:
+                # The timeout is well past expired, assume we're
+                # blocked and redraw synchronously.
+                self.main_loop.draw_screen()
+                self._redraw_time = now
 
     def current_line(self):
         """Return the current line (the one the cursor is in)."""
