fix: Disable menu filtering on legacy Windows console

Calling terminal.get_cursor_pos() when using the legacy Windows Console
Host resulted in the program hanging waiting for a response on stdin to
an escape sequence that the terminal didn't respond to.

Enabling VT mode temporarily made it respond and provide a cursor
position, but either the return values differed from how a modern
terminal would report them or this interacted strangely with menu
rendering in some other way, as this resulted in parts of menus being
rendered to the wrong locations on any menu with a filter text field.

To work around this, we now simply detect whether VT mode is enabled,
and if it isn't, we disable the filter text field. This allows menus to
mostly work, just without the ability to search by typing.

Author: joelspadin

zmk/menu.py

@@ -133,11 +133,17 @@ def __init__(
             self._num_title_lines = 0
             self._last_title_line_len = 0
 
-        if self._get_display_count() == self._max_items_per_page:
-            self._top_row = 1
+        if terminal.cursor_control_supported():
+            if self._get_display_count() == self._max_items_per_page:
+                self._top_row = 1
+            else:
+                _, y = terminal.get_cursor_pos()
+                self._top_row = min(y, self.console.height - self._get_menu_height())
         else:
-            _, y = terminal.get_cursor_pos()
-            self._top_row = min(y, self.console.height - self._get_menu_height())
+            # If get_cursor_pos() is unsupported, then we can't move the cursor
+            # accurately between the end of the menu and the filter text. Disable
+            # the filter feature so the menu still mostly works.
+            self._filter_func = None
 
         self._apply_filter()
 
@@ -381,21 +387,24 @@ def _handle_input(self):
         return False
 
     def _handle_backspace(self):
-        if self._cursor_index == 0:
+        if not self.has_filter or self._cursor_index == 0:
             return
 
         self._filter_text = splice(self._filter_text, self._cursor_index - 1, count=1)
         self._cursor_index -= 1
         self._apply_filter()
 
     def _handle_delete(self):
-        if self._cursor_index == len(self._filter_text):
+        if not self.has_filter or self._cursor_index == len(self._filter_text):
             return
 
         self._filter_text = splice(self._filter_text, self._cursor_index, count=1)
         self._apply_filter()
 
     def _handle_text(self, key: bytes):
+        if not self.has_filter:
+            return
+
         text = key.decode()
         self._filter_text = splice(
             self._filter_text, self._cursor_index, insert_text=text

zmk/terminal.py

@@ -35,14 +35,7 @@
     _STD_INPUT_HANDLE = -10
     _STD_OUTPUT_HANDLE = -11
 
-    _ENABLE_PROCESSED_OUTPUT = 1
-    _ENABLE_WRAP_AT_EOL_OUTPUT = 2
     _ENABLE_VIRTUAL_TERMINAL_PROCESSING = 4
-    _VT_FLAGS = (
-        _ENABLE_PROCESSED_OUTPUT
-        | _ENABLE_WRAP_AT_EOL_OUTPUT
-        | _ENABLE_VIRTUAL_TERMINAL_PROCESSING
-    )
 
     _WINDOWS_SPECIAL_KEYS = {
         71: HOME,
@@ -76,25 +69,6 @@ def read_key() -> bytes:
 
         return key
 
-    @contextmanager
-    def enable_vt_mode() -> Generator[None, None, None]:
-        """
-        Context manager which enables virtual terminal processing.
-        """
-        kernel32 = windll.kernel32
-        stdout_handle = kernel32.GetStdHandle(_STD_OUTPUT_HANDLE)
-
-        old_stdout_mode = wintypes.DWORD()
-        kernel32.GetConsoleMode(stdout_handle, byref(old_stdout_mode))
-
-        new_stdout_mode = old_stdout_mode.value | _VT_FLAGS
-
-        try:
-            kernel32.SetConsoleMode(stdout_handle, new_stdout_mode)
-            yield
-        finally:
-            kernel32.SetConsoleMode(stdout_handle, old_stdout_mode)
-
     @contextmanager
     def disable_echo() -> Generator[None, None, None]:
         """
@@ -112,16 +86,22 @@ def disable_echo() -> Generator[None, None, None]:
         finally:
             kernel32.SetConsoleMode(stdin_handle, old_stdin_mode)
 
-except ImportError:
-    import termios
-
-    @contextmanager
-    def enable_vt_mode() -> Generator[None, None, None]:
+    def cursor_control_supported() -> bool:
         """
-        Context manager which enables virtual terminal processing.
+        Gets whether this terminal supports the virtual terminal escape sequence
+        for getting the cursor position.
         """
-        # Assume that Unix terminals support VT escape sequences by default.
-        yield
+        kernel32 = windll.kernel32
+        stdout_handle = kernel32.GetStdHandle(_STD_OUTPUT_HANDLE)
+
+        stdout_mode = wintypes.DWORD()
+        kernel32.GetConsoleMode(stdout_handle, byref(stdout_mode))
+
+        return bool(stdout_mode.value & _ENABLE_VIRTUAL_TERMINAL_PROCESSING)
+
+
+except ImportError:
+    import termios
 
     @contextmanager
     def disable_echo() -> Generator[None, None, None]:
@@ -147,10 +127,20 @@ def read_key() -> bytes:
         with disable_echo():
             return os.read(sys.stdin.fileno(), 4)
 
+    def cursor_control_supported() -> bool:
+        """
+        Gets whether this terminal supports the virtual terminal escape sequence
+        for getting the cursor position.
+        """
+        # Assume that Unix terminals support VT escape sequences by default.
+        return True
+
 
 def get_cursor_pos() -> tuple[int, int]:
     """
     Returns the cursor position as a tuple (x, y). Positions are 0-based.
+
+    This function may not work properly if cursor_control_supported() returns False.
     """
     with disable_echo():
         sys.stdout.write("\x1b[6n")