Using TermSize everywhere (larger commit.)

Author: jimdeekepler

scrolltext/cli.py

@@ -26,7 +26,7 @@ def main():
     try:
         cfg = init_utils(write_config)
         action = action or _str_to_action_type(cfg["main"]["action"])
-        action(write_config)
+        action(cfg)
     except KeyError as e:
         print("KeyError occured: " + str(e) + "\nProbalby check config?")
     except NameError as e:

scrolltext/cursestext.py

@@ -4,7 +4,7 @@
 from curses import wrapper, error
 import curses
 import logging
-from .utils import CharacterScroller, IS_WINDOWS, init_utils
+from .utils import CharacterScroller, IS_WINDOWS, TermSize
 
 
 QUIT_CHARACTERS = ["\x1B", "Q", "q"]
@@ -13,84 +13,130 @@
 log = logging.getLogger(__name__)
 
 
-def curses_scroller(win, write_config):
+def curses_scroller(win, cfg):
     """
     Curses-main: render a text in a side-scrolling manner, using curses.
 
     :param win: Internal curses based object
     :type win: curses._window
-    :param write_config: Write initial config
-    :type: bool
+    :param cfg: Config object
+    :type: configparser.ConfigParser
     """
-    winsize = win.getmaxyx()
-    log.debug("win dimensions: (columns, rows) (%d, %d)", winsize[1], winsize[0])
-
-    cfg = init_utils(write_config)
-    box = cfg["cursestext"].getboolean("box")
-    # try:
-    if box:
+    if cfg["cursestext"].getboolean("box"):
         win.box()
     if not IS_WINDOWS:
         curses.curs_set(0)  # Hide the cursor
 
+    term_size = TermSize(0, 0)
+    update_term_size(win, cfg["cursestext"].getboolean("box"), term_size)
     argv = {}
-    argv["term_rows"] = winsize[0] - (2 if box else 1)
-    argv["term_columns"] = winsize[1] - (2 if box else 0)
     argv["min_scroll_line"] = 3
-    scroller = CharacterScroller(cfg, **argv)
+    scroller = CharacterScroller(cfg, term_size, **argv)
+    draw_items(win, cfg["cursestext"].getboolean("box"),
+               argv["min_scroll_line"], scroller, term_size)
 
-    win.addstr(1, 10, "Scroll-Text")
-    add_quit_text(win, box, scroller.line, argv["term_rows"])
     win.timeout(100)
     try:
-        do_textloop(win, box, term_size, scroller, term_size.get_rows())
+        do_textloop(win, cfg, term_size, scroller, argv["min_scroll_line"])
     except KeyboardInterrupt:
         pass
 
 
-def do_textloop(win, box, scroller, visibile_height):
+def do_textloop(win, cfg, term_size, scroller, min_scroll_line):
     """
     This method loops over the scrolled text
     """
+    box = cfg["cursestext"].getboolean("box")
+    term_too_small_printed = False
     for text in scroller:
         win_text = text
-        if not box and scroller.line == visibile_height:
+        # hack: When writing to the last line we prevent adding an immediate newline and thus
+        #       moving the text upwards, by removing the last character of the visibile text.
+        if not box and scroller.line == term_size.get_rows():
             win_text = text[:-1]
-        win.addstr(scroller.line, (1 if box else 0), win_text)
-        win.redrawwin()
-        if check_quit(win):
+        if scroller.line >= min_scroll_line:
+            _addstr_wrapper(win, scroller.line, (1 if box else 0), win_text)
+            term_too_small_printed = False
+            win.redrawwin()
+        else:
+            if not term_too_small_printed:
+                log.debug("Terminal is too small  cols: %d  rows: %d",
+                          term_size.get_cols(), term_size.get_rows())
+            term_too_small_printed = True
+        character = get_char(win)
+        if character == curses.KEY_EXIT:
             return
+        if character == curses.KEY_RESIZE:
+            update_term_size(win, box, term_size)
+            draw_items(win, box, min_scroll_line, scroller, term_size)
 
 
-def add_quit_text(win, box, line, visibile_height):
+def add_quit_text(win, box, line, term_size):
     """
     Adds a hint message to win.
-    TODO: visibile_height, winsize, ...??
     """
-    if not box and line == visibile_height:
-        win.addstr(visibile_height - 2, 0, " You can quit with 'q' or 'Q'.")
+    if term_size.get_cols() < len(" You can quit with 'q' or 'Q'.") + 2:
+        return
+    if not box and line == term_size.get_rows():
+        _addstr_wrapper(win, term_size.get_rows() - 2, 0, " You can quit with 'q' or 'Q'.")
     else:
-        win.addstr(visibile_height, (2 if box else 0), " You can quit with 'q' or 'Q'.")
+        _addstr_wrapper(win, term_size.get_rows(),
+                        (2 if box else 0), " You can quit with 'q' or 'Q'.")
 
 
-def check_quit(win):
+def get_char(win):
     """
-    :returns: True, if a quit character is entered, False, otherwise.
-    :rtype: Boolean
+    :returns: curses.KEY_EXIT, if a quit character is entered, the current character, otherwise.
+    :rtype: int
     """
-    character = win.getch(4, 0)
+    log.debug("getch")
+    character = None
+    character = win.getch(0, 0)
     if character != -1:
         log.debug("got key (%d)  type %s", character, type(character))
     if character != -1 and (chr(character) in QUIT_CHARACTERS):
-        return True
-    return False
+        return curses.KEY_EXIT
+    return character
+
+
+def update_term_size(win, box, term_size):
+    """
+    Updates TermSize object.
+    """
+    winsize = win.getmaxyx()
+    log.debug("win dimensions: (columns, rows) (%d, %d)", winsize[1], winsize[0])
+    available_rows = winsize[0] - (2 if box else 1)
+    available_columns = winsize[1] - (2 if box else 0)
+    term_size.set_size(available_columns, available_rows)
+
+
+def draw_items(win, box, min_scroll_line, scroller, term_size):
+    """
+    Add strings to the curses window.
+    """
+    # clear the window contents
+    win.clear()
+
+    # and redraw screen
+    if scroller.line != 1 and term_size.get_cols() > len("Scroll-Text"):
+        _addstr_wrapper(win, 1, 10, "Scroll-Text")
+    if term_size.get_rows() > min_scroll_line:
+        add_quit_text(win, box, scroller.line, term_size)
+
+
+def _addstr_wrapper(win, row, column, text):
+    log.debug("addstr to line %d", row)
+    try:
+        win.addstr(row, column, text)
+    except:  # pylint: disable=W0702 (bare-except)
+        log.exception("Error in addstr")
 
 
-def work(write_config):
+def work(cfg):
     """Main usese curses.wrapper. See curses doc for details.
     """
     try:  # noqa: C901 ignoring 'TryExcept 42' is too complex - fix later
-        wrapper(curses_scroller, write_config)
+        wrapper(curses_scroller, cfg)
     except error as ex:
         log.exception(ex)
     finally:

scrolltext/linescroller.py

@@ -1,18 +1,20 @@
 """
 A simple side scrolling text application.
 """
+import logging
 import shutil
 from time import sleep
-from .utils import CLEAR, HOME, IS_WINDOWS, UP_ONE_ROW, CharacterScroller, init_utils
+from .utils import CLEAR, HOME, IS_WINDOWS, UP_ONE_ROW, CharacterScroller, TermSize
 
 if not IS_WINDOWS:
     from scrolltext.getchtimeout import GetchWithTimeout
 
 
-VISIBILE_TEXT_LENGTH = shutil.get_terminal_size()[0]
+last_term_rows = -1  # pylint: disable=C0103 (invalid-name)
+log = logging.getLogger(__name__)
 
 
-def linescroller(write_config):
+def linescroller(cfg):
     """
     Main entry point for linescroller.
     :param write_config: Write initial config
@@ -22,35 +24,43 @@ def linescroller(write_config):
     if not IS_WINDOWS:
         getch = GetchWithTimeout()
     try:
-        _linescroller(getch, write_config)
+        _linescroller(getch, cfg)
     except RuntimeError:
         pass
     finally:
         if not IS_WINDOWS:
             getch.cleanup()
 
 
-def _linescroller(getch, write_config):
+def _linescroller(getch, cfg):
     """
     Prints a text in a side-scrolling manner.
     """
-    cfg = init_utils(write_config)
+    term_size = TermSize(0, 0)
+    _update_term_size(term_size)
     argv = {}
-    argv["term_rows"] = shutil.get_terminal_size()[1]
-    argv["term_columns"] = shutil.get_terminal_size()[0] - (1 if IS_WINDOWS else 0)
     argv["min_scroll_line"] = 0
-    scroller = CharacterScroller(cfg, **argv)
+    scroller = CharacterScroller(cfg, term_size, **argv)
 
     print(f"{CLEAR}{HOME}", end="")
     if scroller.line > 0:
         _move_to_line(scroller.line)
+    cnt = 0
     for text in scroller:
-        win_text = text
+        if scroller.line < term_size.get_rows() - 1:
+            win_text = text
+        else:
+            win_text = text[:-1]
         print(win_text, end="\r")
         if IS_WINDOWS:
             sleep(.15)
         else:
             _check_input(getch)
+        cnt += 1
+        if _update_term_size(term_size):
+            print(f"{CLEAR}{HOME}", end="")
+            if scroller.line > 0:
+                _move_to_line(scroller.line)
     if IS_WINDOWS:
         print(f"{UP_ONE_ROW}", end="")
 
@@ -60,6 +70,8 @@ def _check_input(getch):
     Use getchtimeout to get a character. If "Q" or "q" is given, then it raises SystemExit
     """
     character = getch.getch(timeout=.1)
+    if isinstance(character, int) == int:
+        log.debug("Got key '%d'", character)
     if character is not None and character in ["\033", "\x1b", "", "\r", "", " ", "Q", "q"]:
         raise RuntimeError()
 
@@ -75,3 +87,16 @@ def _move_to_line(line):
     else:
         for _ in range(line):
             print("\033[1B", end="")
+
+
+def _update_term_size(term_size):
+    global last_term_rows  # pylint: disable=W0603 (global-statement)
+    available_rows = shutil.get_terminal_size()[1]
+    available_columns = shutil.get_terminal_size()[0] - (1 if IS_WINDOWS else 0)
+    term_size.set_size(available_columns, available_rows)
+    if last_term_rows == -1:
+        last_term_rows = term_size.get_rows()
+    if term_size.get_rows() != last_term_rows:
+        last_term_rows = term_size.get_rows()
+        return True
+    return False