curses-utils2 0.3.2__tar.gz → 0.4.0__tar.gz

{curses_utils2-0.3.2 → curses_utils2-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: curses-utils2
-Version: 0.3.2
+Version: 0.4.0
 Summary: A curses utils
 Project-URL: homepage, https://github.com/shamilbi/curses-utils2
 Author-email: Shamil Bikineyev <shamilbi@gmail.com>

curses_utils2-0.4.0/curses_utils2/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.4.0'

curses_utils2-0.4.0/curses_utils2/list1_v2.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+import curses
+from typing import Protocol
+
+from .proto import WinProto
+from .win import win_addstr
+
+
+class ListProto(Protocol):
+    def get_record_str(self, i: int) -> str:
+        pass
+
+    def records_len(self) -> int:
+        pass
+
+    def refresh_win_deps(self):
+        pass
+
+
+class ListV2(WinProto):
+    '''
+    A projection of an array of records r0...rX to a window lines of string s0...sY
+    where si = get_record_str(j) = rj -> str, s(i+1) = get_record_str(j+1), j < records_len()
+    and changing cursor (i) leads to call refresh_win_deps()
+    '''
+
+    def __init__(
+        self,
+        proto: ListProto,
+        current_color: int = curses.A_BOLD,
+    ):
+        self.proto = proto
+        self.current_color = current_color
+
+        self.cur = 0  # cursor y
+        self.idx = 0  # source index
+
+        self.win: curses.window | None = None
+
+    def set_win(self, win: curses.window | None):
+        self.win = win
+        if win:
+            win.keypad(True)
+
+    def refresh(self):
+        if not self.win:
+            self.proto.refresh_win_deps()
+            return
+        self.win.erase()
+        len_ = self.proto.records_len()
+        if len_:
+            rows, _ = self.win.getmaxyx()
+            if not self.idx < len_:  # deleted
+                self.idx = len_ - 1
+            if not self.cur < rows:  # new win < old win
+                self.cur = rows - 1
+            if (rows - self.cur) > (di := len_ - self.idx):
+                # gap at bottom
+                self.cur = rows - di
+            self.cur = min(self.cur, self.idx)
+            for i in range(rows):
+                idx = self.idx - self.cur + i
+                if not idx < len_:
+                    break
+                s = self.proto.get_record_str(idx)
+                if i == self.cur:
+                    win_addstr(self.win, i, 0, s, attr=self.current_color)
+                else:
+                    win_addstr(self.win, i, 0, s)
+            self.win.move(self.cur, 0)
+        self.win.refresh()
+        self.proto.refresh_win_deps()
+
+    def scroll_top(self):
+        self.idx = self.cur = 0
+        self.refresh()
+
+    def scroll_bottom(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_:
+            return
+        rows, _ = self.win.getmaxyx()
+        self.cur = min(rows - 1, len_ - 1)
+        self.idx = len_ - 1
+        self.refresh()
+
+    def scroll_down(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_ or not self.idx + 1 < len_:
+            return
+        rows, _ = self.win.getmaxyx()
+        prev_s = self.proto.get_record_str(self.idx)
+        next_s = self.proto.get_record_str(self.idx + 1)
+        win_addstr(self.win, self.cur, 0, prev_s)
+        if self.cur + 1 < rows:
+            self.cur += 1
+        else:
+            self.win.move(0, 0)
+            self.win.deleteln()
+            self.cur = rows - 1
+        win_addstr(self.win, self.cur, 0, next_s, attr=self.current_color)
+        self.idx += 1
+        self.win.refresh()
+        self.proto.refresh_win_deps()
+
+    def scroll_up(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_ or self.idx - 1 < 0:
+            return
+        prev_s = self.proto.get_record_str(self.idx)
+        next_s = self.proto.get_record_str(self.idx - 1)
+        win_addstr(self.win, self.cur, 0, prev_s)
+        if self.cur > 0:
+            self.cur -= 1
+        else:
+            self.win.move(0, 0)
+            self.win.insdelln(1)
+        win_addstr(self.win, self.cur, 0, next_s, attr=self.current_color)
+        self.idx -= 1
+        self.win.refresh()
+        self.proto.refresh_win_deps()
+
+    def scroll_page_down(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_:
+            return
+        rows, _ = self.win.getmaxyx()
+        idx = self.idx + rows
+        if idx < len_:
+            self.idx = idx
+            self.refresh()
+        else:
+            idx = len_ - 1
+            delta = idx - self.idx
+            if not delta:
+                self.scroll_bottom()
+            elif self.cur + delta < rows:
+                self.cur += delta
+                self.idx = idx
+                self.refresh()
+            else:
+                self.scroll_bottom()
+
+    def scroll_page_up(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_:
+            return
+        rows, _ = self.win.getmaxyx()
+        idx = self.idx - rows
+        if not idx < 0:
+            self.idx = idx
+            self.refresh()
+        else:
+            self.scroll_top()
+
+    def handle_input(self, ch: int) -> bool:
+        char = chr(ch)
+        if char.upper() == 'J' or ch == curses.KEY_DOWN:  # Down or J
+            self.scroll_down()
+        elif char.upper() == 'K' or ch == curses.KEY_UP:  # Up or K
+            self.scroll_up()
+        elif char == 'g' or ch == curses.KEY_HOME:  # Move to top
+            self.scroll_top()
+        elif char == 'G' or ch == curses.KEY_END:  # Move to last item
+            self.scroll_bottom()
+        elif ch == curses.KEY_NPAGE:  # Page down
+            self.scroll_page_down()
+        elif ch == curses.KEY_PPAGE:  # Page up
+            self.scroll_page_up()
+        else:
+            return False
+        return True

curses_utils2-0.4.0/curses_utils2/list1m_v2.py

@@ -0,0 +1,56 @@
+import curses
+
+from .list1_v2 import ListProto, ListV2
+
+
+class List1mProto(ListProto):
+    def record_move_up(self, i: int) -> bool:  # type: ignore[empty-body]
+        pass
+
+    def record_move_down(self, i: int) -> bool:  # type: ignore[empty-body]
+        pass
+
+
+class List1mV2(ListV2):
+    'List + move_up(), move_down()'
+
+    def __init__(
+        self,
+        proto: List1mProto,
+        current_color: int = curses.A_BOLD,
+    ):
+        super().__init__(proto, current_color)
+        self.proto: List1mProto = proto
+
+    def move_up(self, i: int):
+        if not self.proto.record_move_up(i):
+            return
+        if self.idx > 0:
+            self.idx -= 1
+        if self.cur > 0:
+            self.cur -= 1
+        self.refresh()
+
+    def move_down(self, i: int):
+        if not self.win:
+            return
+        if not self.proto.record_move_down(i):
+            return
+        len_ = self.proto.records_len()
+        rows, _ = self.win.getmaxyx()
+        if self.idx < len_ - 1:
+            self.idx += 1
+        if self.cur < rows - 1:
+            self.cur += 1
+        self.refresh()
+
+    def handle_input(self, ch: int) -> bool:
+        if super().handle_input(ch):
+            return True
+        if ch == curses.KEY_SR:  # Shift-Up
+            self.move_up(self.idx)
+        elif ch == curses.KEY_SF:  # Shift-Down
+            self.move_down(self.idx)
+        else:
+            return False
+        return True

curses_utils2-0.4.0/curses_utils2/list3_v2.py

@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import curses
+from collections.abc import Generator
+from typing import Protocol
+
+from .proto import WinProto
+from .win import win_addstr
+
+
+class ListProto3(Protocol):
+    def get_record_str(self, i: int) -> Generator[str]:
+        'yields <height> lines'
+
+    def records_len(self) -> int:
+        pass
+
+    def refresh_win_deps(self):
+        pass
+
+
+class List3v2(WinProto):
+    'List + every record projects to <height> window lines'
+
+    def __init__(
+        self,
+        proto: ListProto3,
+        height: int = 1,
+        current_color: int = curses.A_BOLD,
+    ):
+        self.height = height
+        self.proto = proto
+        self.current_color = current_color
+
+        self.cur = 0  # cursor y, = 0..(maxy // height), real cursor = cur * height
+        self.idx = 0  # source index
+
+        self.win: curses.window | None = None
+
+    def set_win(self, win: curses.window | None):
+        self.win = win
+        if win:
+            win.keypad(True)
+
+    def addstr(self, i: int, g: Generator[str], attr: int = 0):
+        if not self.win:
+            return
+        i2 = i * self.height
+        j = -1
+        for j, s in enumerate(g):
+            if j >= self.height:
+                break
+            if not j:
+                # first line
+                win_addstr(self.win, i2 + j, 0, s, attr=attr | curses.A_BOLD)
+            else:
+                # rest of lines
+                win_addstr(self.win, i2 + j, 0, s, attr=attr | curses.A_DIM)
+        if j < self.height - 1:
+            # print rest lines
+            from_ = j + 1
+            for j in range(from_, self.height):
+                win_addstr(self.win, i2 + j, 0, '', attr=attr)
+
+    def refresh(self):
+        if not self.win:
+            self.proto.refresh_win_deps()
+            return
+        self.win.erase()
+        len_ = self.proto.records_len()
+        if len_:
+            rows, _ = self.win.getmaxyx()
+            rows //= self.height
+            if not self.idx < len_:  # deleted
+                self.idx = len_ - 1
+            if not self.cur < rows:  # new win < old win
+                self.cur = rows - 1
+            if (rows - self.cur) > (di := len_ - self.idx):
+                # gap at bottom
+                self.cur = rows - di
+            self.cur = min(self.cur, self.idx)
+            for i in range(rows):
+                idx = self.idx - self.cur + i
+                if not idx < len_:
+                    break
+                s = self.proto.get_record_str(idx)
+                if i == self.cur:
+                    self.addstr(i, s, attr=self.current_color)
+                else:
+                    self.addstr(i, s)
+            self.win.move(self.cur * self.height, 0)
+        self.win.refresh()
+        self.proto.refresh_win_deps()
+
+    def scroll_top(self):
+        self.idx = self.cur = 0
+        self.refresh()
+
+    def scroll_bottom(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_:
+            return
+        rows, _ = self.win.getmaxyx()
+        rows //= self.height
+        self.cur = min(rows - 1, len_ - 1)
+        self.idx = len_ - 1
+        self.refresh()
+
+    def scroll_down(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_ or not self.idx + 1 < len_:
+            return
+        rows, _ = self.win.getmaxyx()
+        rows //= self.height
+        prev_s = self.proto.get_record_str(self.idx)
+        next_s = self.proto.get_record_str(self.idx + 1)
+        self.addstr(self.cur, prev_s)
+        if self.cur + 1 < rows:
+            self.cur += 1
+        else:
+            self.win.move(0, 0)
+            self.win.deleteln()
+            self.win.deleteln()
+            self.cur = rows - 1
+        self.addstr(self.cur, next_s, attr=self.current_color)
+        self.idx += 1
+        self.win.refresh()
+        self.proto.refresh_win_deps()
+
+    def scroll_up(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_ or self.idx - 1 < 0:
+            return
+        prev_s = self.proto.get_record_str(self.idx)
+        next_s = self.proto.get_record_str(self.idx - 1)
+        self.addstr(self.cur, prev_s)
+        if self.cur > 0:
+            self.cur -= 1
+        else:
+            self.win.move(0, 0)
+            self.win.insdelln(self.height)
+        self.addstr(self.cur, next_s, attr=self.current_color)
+        self.idx -= 1
+        self.win.refresh()
+        self.proto.refresh_win_deps()
+
+    def scroll_page_down(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_:
+            return
+        rows, _ = self.win.getmaxyx()
+        rows //= self.height
+        idx = self.idx + rows
+        if idx < len_:
+            self.idx = idx
+            self.refresh()
+        else:
+            idx = len_ - 1
+            delta = idx - self.idx
+            if not delta:
+                self.scroll_bottom()
+            elif self.cur + delta < rows:
+                self.cur += delta
+                self.idx = idx
+                self.refresh()
+            else:
+                self.scroll_bottom()
+
+    def scroll_page_up(self):
+        if not self.win:
+            return
+        len_ = self.proto.records_len()
+        if not len_:
+            return
+        rows, _ = self.win.getmaxyx()
+        rows //= self.height
+        idx = self.idx - rows
+        if idx >= 0:
+            self.idx = idx
+            self.refresh()
+        else:
+            self.scroll_top()
+
+    def handle_input(self, ch: int) -> bool:
+        char = chr(ch)
+        if char.upper() == 'J' or ch == curses.KEY_DOWN:  # Down or J
+            self.scroll_down()
+        elif char.upper() == 'K' or ch == curses.KEY_UP:  # Up or K
+            self.scroll_up()
+        elif char == 'g' or ch == curses.KEY_HOME:  # Move to top
+            self.scroll_top()
+        elif char == 'G' or ch == curses.KEY_END:  # Move to last item
+            self.scroll_bottom()
+        elif ch == curses.KEY_NPAGE:  # Page down
+            self.scroll_page_down()
+        elif ch == curses.KEY_PPAGE:  # Page up
+            self.scroll_page_up()
+        else:
+            return False
+        return True

curses_utils2-0.4.0/curses_utils2/proto.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import curses
+from typing import Protocol
+
+
+class WinProto(Protocol):
+    def set_win(self, win: curses.window | None):
+        pass
+
+    def refresh(self):
+        pass

curses_utils2-0.4.0/curses_utils2/winbox.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+import curses
+
+from .proto import WinProto
+from .win import win_addstr
+
+
+class WinBox:
+    '''
+    win (box) + internal win (body)
+
+    '''
+
+    def __init__(self, body: WinProto, offy: int = 0, offx: int = 0):
+        'offy: y offset, offx: x offset'
+        self.body = body
+        self.offy, self.offx = offy, offx
+
+    def set_win(self, win: curses.window | None):
+        # pylint: disable=attribute-defined-outside-init
+        self.win = win
+
+        if not win:
+            self.body.set_win(None)
+            return
+
+        # body win
+        rows, cols = win.getmaxyx()
+        rows2 = rows - 2 - self.offy  # 2 - border
+        cols2 = cols - 2 - 2 * self.offx  # 2 - border
+        if rows2 < 0 or cols < 2:
+            self.win = None
+            self.body.set_win(None)
+            return
+        if rows2 < 1 or cols2 < 1:
+            self.body.set_win(None)
+            return
+        win2 = win.derwin(
+            rows2,
+            cols2,
+            1 + self.offy,  # 1 - border
+            1 + self.offx,  # 1 - border
+        )
+        self.body.set_win(win2)
+
+    def refresh(self, header: str = ''):
+        if not self.win:
+            return
+
+        self.win.erase()
+        if header:
+            # put header above body
+            win_addstr(self.win, 1, 1 + self.offx, header, border=1 + self.offx)
+        self.win.box()
+        self.win.refresh()
+
+        self.body.refresh()

curses_utils2-0.3.2/curses_utils2/__init__.py

@@ -1 +0,0 @@
-__version__ = '0.3.2'