if p:
r.insert(p)
if last_is_completer:
- if not r.cmpltn_menu_vis:
- r.cmpltn_menu_vis = 1
+ if not r.cmpltn_menu_visible:
+ r.cmpltn_menu_visible = True
r.cmpltn_menu, r.cmpltn_menu_end = build_menu(
r.console, completions, r.cmpltn_menu_end,
r.use_brackets, r.sort_in_column)
commands.self_insert.do(self)
- if r.cmpltn_menu_vis:
+ if r.cmpltn_menu_visible:
stem = r.get_stem()
if len(stem) < 1:
r.cmpltn_reset()
### Instance variables
cmpltn_menu: list[str] = field(init=False)
- cmpltn_menu_vis: int = field(init=False)
+ cmpltn_menu_visible: bool = field(init=False)
cmpltn_menu_end: int = field(init=False)
cmpltn_menu_choices: list[str] = field(init=False)
if not isinstance(cmd, (complete, self_insert)):
self.cmpltn_reset()
- def calc_screen(self) -> list[str]:
- screen = super().calc_screen()
- if self.cmpltn_menu_vis:
+ def calc_complete_screen(self) -> list[str]:
+ screen = super().calc_complete_screen()
+ if self.cmpltn_menu_visible:
ly = self.lxy[1]
screen[ly:ly] = self.cmpltn_menu
self.screeninfo[ly:ly] = [(0, [])]*len(self.cmpltn_menu)
def cmpltn_reset(self) -> None:
self.cmpltn_menu = []
- self.cmpltn_menu_vis = 0
+ self.cmpltn_menu_visible = False
self.cmpltn_menu_end = 0
self.cmpltn_menu_choices = []
# types
Command = commands.Command
if False:
+ from typing import Callable
from .types import Callback, SimpleContextManager, KeySpec, CommandName
+ CalcScreen = Callable[[], list[str]]
def disp_str(buffer: str) -> tuple[str, list[int]]:
keymap: tuple[tuple[str, str], ...] = ()
input_trans: input.KeymapTranslator = field(init=False)
input_trans_stack: list[input.KeymapTranslator] = field(default_factory=list)
+ screen: list[str] = field(default_factory=list)
screeninfo: list[tuple[int, list[int]]] = field(init=False)
cxy: tuple[int, int] = field(init=False)
lxy: tuple[int, int] = field(init=False)
+ calc_screen: CalcScreen = field(init=False)
def __post_init__(self) -> None:
# Enable the use of `insert` without a `prepare` call - necessary to
self.input_trans = input.KeymapTranslator(
self.keymap, invalid_cls="invalid-key", character_cls="self-insert"
)
- self.screeninfo = [(0, [0])]
+ self.screeninfo = [(0, [])]
self.cxy = self.pos2xy()
self.lxy = (self.pos, 0)
+ self.calc_screen = self.calc_complete_screen
def collect_keymap(self) -> tuple[tuple[KeySpec, CommandName], ...]:
return default_keymap
- def calc_screen(self) -> list[str]:
+ def append_to_screen(self) -> list[str]:
+ new_screen = self.screen.copy() or ['']
+
+ new_character = self.buffer[-1]
+ new_character_len = wlen(new_character)
+
+ last_line_len = wlen(new_screen[-1])
+ if last_line_len + new_character_len >= self.console.width: # We need to wrap here
+ new_screen[-1] += '\\'
+ self.screeninfo[-1][1].append(1)
+ new_screen.append(self.buffer[-1])
+ self.screeninfo.append((0, [new_character_len]))
+ else:
+ new_screen[-1] += self.buffer[-1]
+ self.screeninfo[-1][1].append(new_character_len)
+ self.cxy = self.pos2xy()
+
+ # Reset the function that is used for completing the screen
+ self.calc_screen = self.calc_complete_screen
+ return new_screen
+
+ def calc_complete_screen(self) -> list[str]:
"""The purpose of this method is to translate changes in
self.buffer into changes in self.screen. Currently it rips
everything down and starts from scratch, which whilst not
def refresh(self) -> None:
"""Recalculate and refresh the screen."""
# this call sets up self.cxy, so call it first.
- screen = self.calc_screen()
- self.console.refresh(screen, self.cxy)
+ self.screen = self.calc_screen()
+ self.console.refresh(self.screen, self.cxy)
self.dirty = False
def do_cmd(self, cmd: tuple[str, list[str]]) -> None: