ui/curses: add curses interface draft

pqcli/ui/curses/widgets/__init__.py

@@ -0,0 +1,6 @@
+from .base import WindowWrapper
+from .data_table import DataTable
+from .label import Label
+from .list_box import ListBox
+from .menu import Menu
+from .progress_bar import ProgressBar

pqcli/ui/curses/widgets/base.py

@@ -0,0 +1,41 @@
+import curses
+import typing as T
+
+
+class Widget:
+    def __del__(self) -> None:
+        self.stop()
+
+    def stop(self) -> None:
+        pass
+
+
+class WindowWrapper(Widget):
+    def __init__(
+        self, parent: T.Optional[T.Any], h: int, w: int, y: int, x: int
+    ) -> None:
+        self._parent = parent
+        self._win: T.Optional[T.Any]
+
+        if not parent:
+            self._win = None
+        else:
+            try:
+                self._win = parent.derwin(h, w, y, x)
+                self._win.refresh()
+            except curses.error:
+                self._win = None
+
+    def stop(self) -> None:
+        del self._win
+        self._win = None
+
+    def getbegyx(self) -> T.Tuple[int, int]:
+        if not self._win:
+            return (0, 0)
+        return self._win.getbegyx()
+
+    def getmaxyx(self) -> T.Tuple[int, int]:
+        if not self._win:
+            return (0, 0)
+        return self._win.getmaxyx()

pqcli/ui/curses/widgets/data_table.py

@@ -0,0 +1,71 @@
+import curses
+import enum
+import typing as T
+
+from .scrollable import Scrollable
+
+
+class DataTable(Scrollable):
+    def __init__(
+        self,
+        parent: T.Any,
+        h: int,
+        w: int,
+        y: int,
+        x: int,
+        align_right: bool = False,
+    ) -> None:
+        super().__init__(parent, h, w, y, x)
+
+        self._align_right = align_right
+        self._items: T.List[T.Tuple[str, str]]
+
+    def add(self, text: str, value: str) -> None:
+        self._items.append((text, value))
+        self.scroll_to_item(-1)
+
+    def set(self, text: str, value: str) -> None:
+        idx = self.get_idx(text)
+        if idx is None:
+            self.add(text, value)
+        else:
+            self._items[idx] = (self._items[idx][0], value)
+            self.scroll_to_item(idx)
+
+    def delete(self, text: str) -> None:
+        idx = self.get_idx(text)
+        if idx is not None:
+            del self._items[idx]
+            self.scroll_to_item(idx)
+
+    def get_idx(self, text: str) -> T.Optional[int]:
+        for idx, row in enumerate(self._items):
+            if row[0].strip() == text.strip():
+                return idx
+        return None
+
+    def _render_impl(self) -> None:
+        assert self._pad
+        h, w = self.getmaxyx()
+        if self._align_right:
+            for y, row in enumerate(self._items):
+                self._pad.move(y, 0)
+                self._pad.addnstr(row[0], min(len(row[0]), w))
+                col2_x = max(0, w - len(row[1]))
+                if col2_x < w:
+                    self._pad.move(y, col2_x)
+                    self._pad.addstr(row[1])
+        else:
+            col2_x = self._get_col_width(0)
+            for y, row in enumerate(self._items):
+                self._pad.addnstr(y, 0, row[0], min(len(row[0]), w))
+                if col2_x < w:
+                    self._pad.addnstr(
+                        y, col2_x, row[1], min(len(row[1]), w - col2_x)
+                    )
+
+        y, x = self.getbegyx()
+        self._pad.refresh(self._scroll_y, 0, y, x, y + h - 1, x + w - 1)
+
+    def _get_col_width(self, x: int) -> int:
+        return max([len(row[0]) for row in self._items] + [0])

pqcli/ui/curses/widgets/label.py

@@ -0,0 +1,10 @@
+from .base import WindowWrapper
+
+
+class Label(WindowWrapper):
+    def set_text(self, text: str) -> None:
+        if not self._win:
+            return
+        self._win.erase()
+        self._win.addnstr(text, min(len(text), self.getmaxyx()[1] - 1))
+        self._win.refresh()

pqcli/ui/curses/widgets/list_box.py

@@ -0,0 +1,40 @@
+import curses
+import enum
+import typing as T
+
+from .scrollable import Scrollable
+
+
+class ListBox(Scrollable):
+    _items: T.List[str]
+
+    def add(self, text: str) -> None:
+        self._items.append(text)
+        self.scroll_to_item(-1)
+
+    def set(self, idx: int, value: str) -> None:
+        if idx < 0:
+            idx %= len(self._items)
+        self._items[idx] = value
+
+    def get(self, idx: int) -> T.Optional[str]:
+        if not self._items:
+            return None
+        if idx < 0:
+            idx %= len(self._items)
+        try:
+            return self._items[idx]
+        except ValueError:
+            return None
+
+    def delete(self, idx: int, count: int = 1) -> None:
+        del self._items[idx : idx + count]
+
+    def _render_impl(self) -> None:
+        assert self._pad
+        h, w = self.getmaxyx()
+        for y, item in enumerate(self._items):
+            self._pad.addnstr(y, 0, item, min(len(item), w))
+
+        y, x = self.getbegyx()
+        self._pad.refresh(self._scroll_y, 0, y, x, y + h - 1, x + w - 1)

pqcli/ui/curses/widgets/menu.py

@@ -0,0 +1,79 @@
+import curses
+import typing as T
+
+from ..util import Choice
+from .base import Widget
+
+
+class Menu(Widget):
+    def __init__(
+        self,
+        header: str,
+        choices: T.List[Choice],
+        scr_height: int,
+        scr_width: int,
+    ) -> None:
+        self.header_lines = header.split("\n")
+        self.choices = choices
+        self.scr_width = scr_width
+        self.scr_height = scr_height
+
+        w = max(map(len, self.header_lines))
+        h = len(self.header_lines) + 1 + len(choices)
+        self._pad: T.Optional[T.Any] = curses.newpad(h, w)
+
+        for y, line in enumerate(self.header_lines):
+            self._pad.move(y, 0)
+            self._pad.addstr(line)
+
+        self.active_choice = 0
+
+    def stop(self) -> None:
+        del self._pad
+        self._pad = None
+
+    def getmaxyx(self) -> T.Tuple[int, int]:
+        if not self._pad:
+            return (0, 0)
+        return self._pad.getmaxyx()
+
+    def next(self) -> None:
+        self.active_choice = min(len(self.choices) - 1, self.active_choice + 1)
+
+    def prev(self) -> None:
+        self.active_choice = max(0, self.active_choice - 1)
+
+    def keypress(self, key: int) -> None:
+        for choice in self.choices:
+            if key in choice.keys:
+                choice.callback()
+                return
+
+        if key in set(map(ord, "jJ")) | {curses.KEY_DOWN}:
+            self.next()
+            return
+
+        if key in set(map(ord, "kK")) | {curses.KEY_UP}:
+            self.prev()
+            return
+
+    def render(self) -> None:
+        if not self._pad:
+            return
+
+        for y, choice in enumerate(self.choices):
+            self._pad.move(len(self.header_lines) + 1 + y, 0)
+            if y == self.active_choice:
+                self._pad.standout()
+            self._pad.addstr(choice.desc)
+            if y == self.active_choice:
+                self._pad.standend()
+
+        self._pad.refresh(
+            0,
+            0,
+            (self.scr_height - self._pad.getmaxyx()[0]) // 2,
+            (self.scr_width - self._pad.getmaxyx()[1]) // 2,
+            self.scr_height - 1,
+            self.scr_width - 1,
+        )

pqcli/ui/curses/widgets/progress_bar.py

@@ -0,0 +1,19 @@
+import curses
+
+from .base import WindowWrapper
+
+
+class ProgressBar(WindowWrapper):
+    def set_position(self, position: float, max_: float) -> None:
+        if not self._win:
+            return
+        self._win.erase()
+        text = f"{position / max_:.02%}"
+        x = max(0, (self.getmaxyx()[1] - len(text)) // 2)
+        self._win.addnstr(0, x, text, min(len(text), self.getmaxyx()[1] - 1))
+        x = int(position * self.getmaxyx()[1] // max_)
+        if x > 0:
+            self._win.chgat(0, 0, curses.A_REVERSE)
+            if x < self.getmaxyx()[1]:
+                self._win.chgat(0, x, curses.A_NORMAL)
+        self._win.refresh()

pqcli/ui/curses/widgets/scrollable.py

@@ -0,0 +1,52 @@
+import curses
+import typing as T
+
+from .base import WindowWrapper
+
+
+class Scrollable(WindowWrapper):
+    def __init__(self, *args: T.Any, **kwargs: T.Any) -> None:
+        super().__init__(*args, **kwargs)
+        self._scroll_y = 0
+        self._pad: T.Optional[T.Any] = curses.newpad(1, 1)
+        self._items: T.List[T.Any] = []
+
+    def clear(self) -> None:
+        self._items = []
+        self.scroll_to_item(0)
+
+    def scroll_to_item(self, y: int) -> None:
+        if not self._items or not self._win:
+            return
+        if y < 0:
+            y %= len(self._items)
+        while not (self._scroll_y <= y < self._scroll_y + self.getmaxyx()[0]):
+            self._scroll_y += 1 if self._scroll_y < y else -1
+
+    def stop(self) -> None:
+        super().stop()
+        del self._pad
+        self._pad = None
+
+    def __len__(self) -> int:
+        return len(self._items)
+
+    def render(self) -> None:
+        if not self._pad:
+            return
+
+        if self._items:
+            self._pad.resize(
+                max(1, len(self._items)), max(1, self.getmaxyx()[1] + 1)
+            )
+        else:
+            self._pad.resize(1, 1)
+
+        self._pad.erase()
+        try:
+            self._render_impl()
+        except curses.error:
+            pass
+
+    def _render_impl(self) -> None:
+        raise NotImplementedError("not implemented")