boacon 0.0.1__py3-none-any.whl

boacon/__init__.py

@@ -0,0 +1,360 @@
+from .c_BCChar import *
+from .c_BCCoord import *
+from .c_BCError import *
+from .c_BCPane import *
+from .c_BCPostDrawArgs import *
+from .c_BCSetChrFunc import *
+from .c_BCSignal import *
+from .c_BCSignalEmitter import *
+from .c_BCState import *
+from .c_BCStr import *
+from .g_attr import *
+from .g_key import *
+from .p_BCConsolePane import *
+
+import curses as _curses
+import numpy as _np
+import numpy.typing as _npt
+
+#region const
+
+_C_BORDERCHARS = [\
+    0xFF, 0x50, 0x50, 0x50, 0x51, 0x54, 0x5A, 0x50, 0x51, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x5D, 0x50, 0x69, 0x50, 0x51, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x5A, 0x50, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x51, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x69, 0x50, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x57, 0x66, 0x50, 0x50, 0x51, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x63, 0x66, 0x69, 0x50, 0x51, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x6C, 0x66, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x6C, 0x66, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x54, 0x66, 0x50, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x51, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x6C, 0x66, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x60, 0x66, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x51, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x6C, 0x66, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x66, 0x66, 0x50, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x6C, 0x66, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x6C, 0x66, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,\
+    0x6C, 0x66, 0x69, 0x50, 0x60, 0x54, 0x5A, 0x50, 0x63, 0x57, 0x5D, 0x50, 0x51, 0x51, 0x51, 0xA1,]
+
+#endregion
+
+#region variables
+
+_f_state = BCState.NORUN
+_f_win:None|_curses.window = None
+_f_win_ok = False
+_f_win_w = 0
+_f_win_h = 0
+_f_color = False
+_f_panes:None|list[BCPane] = None
+_f_bgbuffer:None|_npt.NDArray[_np.bool_] = None
+
+_f_border = False
+
+_s_on_init_emitter = BCSignalEmitter[()]()
+_s_on_init = BCSignal(_s_on_init_emitter)
+_s_on_final_emitter = BCSignalEmitter[()]()
+_s_on_final = BCSignal(_s_on_final_emitter)
+
+_s_postdraw_emitter:None|BCSignalEmitter[BCPostDrawArgs] = None
+_s_postdraw:None|BCSignal[BCPostDrawArgs] = None
+
+#endregion
+
+#region helper
+
+def _m_verify_run():
+    global _f_state
+    if _f_state == BCState.RUN: return
+    raise BCError("boacon system is not currently running.")
+
+def _m_setcursor(visible:bool):
+    global _f_win, _f_win_ok
+    assert _f_win is not None
+    # Try to hide normally
+    if not _f_win_ok:
+        try: _curses.curs_set(1 if visible else 0)
+        except _curses.error: _f_win_ok = True
+    # Try to hide alternatively
+    if _f_win_ok: # Do NOT change to else or elif
+        try: _f_win.leaveok(not visible)
+        except _curses.error: pass
+
+def _m_cursesattr_color(attr:int):
+    cattr = _curses.A_STANDOUT if attr_emp(attr) else _curses.A_NORMAL
+    return cattr | _curses.color_pair(0b111 ^ attr_color(attr))
+
+def _m_cursesattr_nocolor(attr:int):
+    return _curses.A_STANDOUT if attr_emp(attr) else _curses.A_NORMAL
+
+def _m_setchr_color(x:int, y:int, char:BCChar):
+    global _f_win, _f_bgbuffer, _f_win_w
+    assert _f_win is not None
+    assert _f_bgbuffer is not None
+    attr = _m_cursesattr_color(char.attr)
+    try:
+        _f_win.addch(y, x, chr(char.ord), attr)
+        _f_bgbuffer[y * _f_win_w + x] = True
+    except: pass
+
+def _m_setchr_nocolor(x:int, y:int, char:BCChar):
+    global _f_win, _f_bgbuffer, _f_win_w
+    assert _f_win is not None
+    assert _f_bgbuffer is not None
+    attr = _m_cursesattr_nocolor(char.attr)
+    try:
+        _f_win.addch(y, x, chr(char.ord), attr)
+        _f_bgbuffer[y * _f_win_w + x] = True
+    except: pass
+
+def _m_borderchar(x:int, y:int):
+    global _f_win_w, _f_win_h, _f_bgbuffer
+    assert _f_bgbuffer is not None
+    # Examine neighbors
+    index = y * _f_win_w + x
+    index_t = index - _f_win_w
+    index_b = index + _f_win_w
+    notedge_t = y > 0
+    notedge_b = (y + 1) < _f_win_h
+    notedge_l = x > 0
+    notedge_r = (x + 1) < _f_win_w
+    if notedge_t:
+        neighbor_t = _f_bgbuffer[index_t]
+        neighbor_tl = notedge_l and _f_bgbuffer[index_t - 1]
+        neighbor_tr = notedge_r and _f_bgbuffer[index_t + 1]
+    else:
+        neighbor_t = False
+        neighbor_tl = False
+        neighbor_tr = False
+    if notedge_b:
+        neighbor_b = _f_bgbuffer[index_b]
+        neighbor_bl = notedge_l and _f_bgbuffer[index_b - 1]
+        neighbor_br = notedge_r and _f_bgbuffer[index_b + 1]
+    else:
+        neighbor_b = False
+        neighbor_bl = False
+        neighbor_br = False
+    neighbor_l = notedge_l and _f_bgbuffer[index - 1]
+    neighbor_r = notedge_r and _f_bgbuffer[index + 1]
+    # Determine character
+    index = 0
+    if neighbor_t: index |= 0b00000001
+    if neighbor_b: index |= 0b00000010
+    if neighbor_l: index |= 0b00000100
+    if neighbor_r: index |= 0b00001000
+    if neighbor_tl: index |= 0b00010000
+    if neighbor_tr: index |= 0b00100000
+    if neighbor_bl: index |= 0b01000000
+    if neighbor_br: index |= 0b10000000
+    raw = _C_BORDERCHARS[index]
+    return ' ' if (raw == 0xFF) else chr(0x2500 | raw)
+
+#endregion
+
+#region init/final
+
+def init():
+    global _f_state
+    if _f_state != BCState.NORUN: return
+    _f_state = BCState.INIT
+    # Global vars
+    global _f_win, _f_win_w, _f_win_h, _f_color, _f_panes
+    global _f_border
+    # Initialize window
+    _f_win = _curses.initscr()
+    _f_win.keypad(True)
+    _f_win.nodelay(True)
+    _f_win_w = 0
+    _f_win_h = 0
+    # Initialize curses
+    _curses.noecho()
+    _curses.cbreak()
+    _m_setcursor(False)
+    # Initialize color
+    _curses.start_color()
+    if _curses.has_colors() and _curses.COLOR_PAIRS >= 8:
+        _curses.use_default_colors()
+        _curses.init_pair(0b001, _curses.COLOR_CYAN, -1)
+        _curses.init_pair(0b010, _curses.COLOR_MAGENTA, -1)
+        _curses.init_pair(0b011, _curses.COLOR_BLUE, -1)
+        _curses.init_pair(0b100, _curses.COLOR_YELLOW, -1)
+        _curses.init_pair(0b101, _curses.COLOR_GREEN, -1)
+        _curses.init_pair(0b110, _curses.COLOR_RED, -1)
+        _curses.init_pair(0b111, _curses.COLOR_BLACK, -1)
+        _f_color = True
+    else:
+        _f_color = False
+    # Initialize panes
+    _f_panes = []
+    # Initialize border
+    _f_border = True
+    # Initialize signals
+    global _s_postdraw, _s_postdraw_emitter
+    _s_postdraw_emitter = BCSignalEmitter[BCPostDrawArgs]()
+    _s_postdraw = BCSignal[BCPostDrawArgs](_s_postdraw_emitter)
+    # Success!!!
+    _f_state = BCState.RUN
+    _s_on_init_emitter.emit(())
+
+def final():
+    global _f_state
+    if _f_state != BCState.RUN: return
+    _s_on_final_emitter.emit(())
+    _f_state = BCState.FINAL
+    # Global vars
+    global _f_win, _panes
+    assert _f_win is not None
+    # Finalize curses
+    _curses.nocbreak()
+    _curses.echo()
+    _curses.endwin()
+    # Finalize window
+    _m_setcursor(True)
+    _f_win.nodelay(False)
+    _f_win.keypad(False)
+    # Success!!!
+    _f_state = BCState.NORUN
+
+#endregion
+
+#region "properties"
+
+def state():
+    """
+    State of the boacon system
+    """
+    global _f_state
+    return _f_state
+
+def panes():
+    """
+    Panes that are being displayed
+    
+    :raise BCError:
+        boacon system is not currently running
+    """
+    _m_verify_run()
+    global _f_panes
+    assert _f_panes is not None
+    return _f_panes
+
+def on_init():
+    """
+    Emitted after the boacon system is initialized
+    """
+    global _s_on_init
+    return _s_on_init
+
+def on_final():
+    """
+    Emitted before the boacon system is finalized
+    """
+    global _s_on_final
+    return _s_on_final
+
+def postdraw():
+    """
+    Emitted after drawing the panes and right before the screen is refreshed
+    
+    :raise BCError:
+        boacon system is not currently running
+    """
+    _m_verify_run()
+    global _s_postdraw
+    assert _s_postdraw is not None
+    return _s_postdraw
+
+#endregion
+
+#region functions
+
+def refresh():
+    """
+    Refreshes the screen
+    
+    :raise BCError:
+        boacon system is not currently running
+    """
+    _m_verify_run()
+    global _f_win, _f_win_w, _f_win_h, _f_color, _f_panes, _f_bgbuffer
+    global _f_border
+    assert _f_win is not None
+    assert _f_panes is not None
+    global _s_postdraw_emitter
+    assert _s_postdraw_emitter is not None
+    # Determine functions
+    _func_cursesattr = _m_cursesattr_color if _f_color else _m_cursesattr_nocolor
+    _func_setchr = _m_setchr_color if _f_color else _m_setchr_nocolor
+    # Update size
+    _new_h, _new_w = _f_win.getmaxyx()
+    if _f_win_w != _new_w or _f_win_h != _new_h:
+        _f_win_w = _new_w
+        _f_win_h = _new_h
+        _f_bgbuffer = _np.zeros(_f_win_w * _f_win_h, dtype = bool)
+        resized = True
+    else:
+        assert _f_bgbuffer is not None
+        resized = False
+    # Resolve pane dimensions
+    redrawbg = resized
+    for _pane in _f_panes:
+        if _pane._m_resolve(resized, _f_win_w, _f_win_h):
+            redrawbg = True
+    if redrawbg:
+        _f_bgbuffer.fill(False)
+    # Update panes
+    for _pane in _f_panes:
+        _pane._m_refresh(redrawbg, _func_setchr)
+    # Draw background
+    if redrawbg:
+        for _y in range(_f_win_h):
+            for _x in range(_f_win_w):
+                _i = _y * _f_win_w + _x
+                if _f_bgbuffer[_i]: continue
+                # Determine character
+                _chr = _m_borderchar(_x, _y) if _f_border else ' '
+                # Set character
+                try: _f_win.addch(_y, _x, _chr)
+                except: pass
+    # Post draw
+    _s_postdraw_emitter.emit((BCPostDrawArgs(_f_win, _func_cursesattr, _func_setchr),))
+    # Success!!!
+    _f_win.refresh()
+    
+def getch():
+    """
+    Gets a character code from the keyboard
+    
+    :return:
+        Character code (or -1 if no character is pressed)
+    :raise BCError:
+        boacon system is not currently running
+    """
+    _m_verify_run()
+    global _f_win
+    assert _f_win is not None
+    return _f_win.getch()
+
+def get_border():
+    """
+    Gets whether or not pane borders are enabled
+    
+    :raise BCError:
+        boacon system is not currently running
+    """
+    _m_verify_run()
+    global _f_border
+    return _f_border
+
+def set_border(value:bool):
+    """
+    Sets whether or not pane borders are enabled
+    
+    :raise BCError:
+        boacon system is not currently running
+    """
+    _m_verify_run()
+    global _f_border
+    _f_border = value
+
+#endregion

boacon/c_BCChar.py

@@ -0,0 +1,140 @@
+all = ['BCChar']
+
+from .g_attr import\
+    ATTR_NORMAL as _ATTR_NORMAL
+
+class BCChar:
+    """
+    Represents a text character
+    """
+
+    #region init
+
+    def __init__(self, ord:int, attr:int = _ATTR_NORMAL):
+        """
+        Initializer for BBChar
+        
+        :param ord:
+            Ordinal code
+        :param attr:
+            Text attribute
+        """
+        self.__ord = ord
+        self.__attr = attr
+
+    #endregion
+
+    #region operators
+
+    def __repr__(self):
+        return f"BCChar({self.__ord}, attr = {self.__attr})"
+    
+    def __str__(self):
+        return chr(self.__ord)
+    
+    def __eq__(self, other:object):
+        equ = self.__equ(other)
+        if equ is None: return NotImplemented
+        return equ
+    
+    def __ne__(self, other:object):
+        equ = self.__equ(other)
+        if equ is None: return NotImplemented
+        return not equ
+    
+    def __lt__(self, other:object):
+        cmp = self.__cmp(other)
+        if cmp is None: return NotImplemented
+        return cmp < 0
+    
+    def __le__(self, other:object):
+        cmp = self.__cmp(other)
+        if cmp is None: return NotImplemented
+        return cmp <= 0
+    
+    def __gt__(self, other:object):
+        cmp = self.__cmp(other)
+        if cmp is None: return NotImplemented
+        return cmp > 0
+    
+    def __ge__(self, other:object):
+        cmp = self.__cmp(other)
+        if cmp is None: return NotImplemented
+        return cmp >= 0
+    
+    def __hash__(self):
+        return self.__ord
+
+    #endregion
+
+    #region properties
+
+    @property
+    def ord(self):
+        """
+        Ordinal code
+        """
+        return self.__ord
+    
+    @property
+    def attr(self):
+        """
+        Text attribute
+        """
+        return self.__attr
+
+    #endregion
+
+    #region helper methods
+
+    def __equ(self, other: object):
+        if isinstance(other, BCChar):
+            return self.__ord == other.__ord and self.__attr == other.__attr
+        if isinstance(other, str):
+            return len(other) == 1 and self.__ord == ord(other)
+        return None
+
+    def __cmp(self, other: object) -> None|int:
+        if isinstance(other, BCChar):
+            if self.__ord != other.__ord: return self.__ord - other.__ord
+            return self.__attr - other.__attr
+        if isinstance(other, str):
+            if len(other) != 1: return None
+            return self.__ord - ord(other)
+        return None
+    
+    #endregion
+
+    #region methods
+
+    def equ(self, other:object):
+        """
+        Checks if the character is equal to another character
+        
+        :param other:
+            Other character
+        :return:
+            Whether or not the two characters are equal
+        """
+        equ = self.__equ(other)
+        if equ is None: return False
+        return equ
+    
+    def cmp(self, other:object):
+        """
+        Compares the character to another character
+        
+        :param other:
+            Other character
+        :return:
+            lt 0: Current character precedes other character\n
+            eq 0: Current character is equal to the other character\n
+            gt 0: Current character follows other character
+        :raise TypeError:
+            Cannot compare with other type
+        """
+        cmp = self.__cmp(other)
+        if cmp is None: raise TypeError(f"Cannot compare BCChar with {type(other)}.")
+        return cmp
+
+    #endregion

boacon/c_BCCoord.py

@@ -0,0 +1,185 @@
+all = ['BCCoord']
+
+class BCCoord:
+    """
+    Represents coordinates for a single axis
+    """
+
+    #region init
+
+    def __init__(self, dis0:None|int = None, dis1:None|int = None, len:None|int = None):
+        """
+        Initializer for BCCoord
+        
+        :param dis0:
+            For X-axis: Distance from the left edge of console to left edge of pane\n
+            For Y-axis: Distance from the top edge of console to top edge of pane
+        :param dis1:
+            For X-axis: Distance from the right edge of console to right edge of pane\n
+            For Y-axis: Distance from the bottom edge of console to bottom edge of pane
+        :param len:
+            For X-axis: Width of pane\n
+            For Y-axis: Height of pane
+        """
+        self.__dis0 = dis0
+        self.__dis1 = dis1
+        self.__len = len
+        self.__first = True
+        self.__prev_dis0:None|int = None
+        self.__prev_dis1:None|int = None
+        self.__prev_len:None|int = None
+        self.__pnt0:int = 0
+        self.__pnt1:int = 0
+        self.__pntlen:int = 0
+        self.__clip0:int = 0
+        self.__clip1:int = 0
+        self.__cliplen:int = 0
+        self.__clipoff:int = 0
+
+    #endregion
+
+    #region properties
+
+    @property
+    def dis0(self):
+        """
+        For X-axis: Distance from the left edge of console to left edge of pane\n
+        For Y-axis: Distance from the top edge of console to top edge of pane
+        """
+        return self.__dis0
+
+    @property
+    def dis1(self):
+        """
+        For X-axis: Distance from the right edge of console to right edge of pane\n
+        For Y-axis: Distance from the bottom edge of console to bottom edge of pane
+        """
+        return self.__dis1
+
+    @property
+    def len(self):
+        """
+        For X-axis: Width of pane\n
+        For Y-axis: Height of pane
+        """
+        return self.__len
+
+    @property
+    def pnt0(self):
+        """
+        For X-axis: X-coordinate of left edge\n
+        For Y-axis: Y-coordinate of top edge
+        """
+        return self.__pnt0
+    
+    @property
+    def pnt1(self):
+        """
+        For X-axis: X-coordinate of right edge\n
+        For Y-axis: Y-coordinate of bottom edge
+        """
+        return self.__pnt1
+    
+    @property
+    def pntlen(self):
+        """
+        Distance between pnt0 and pnt1\n
+        For X-axis: Resolved width\n
+        For Y-axis: Resolved height
+        """
+        return self.__pntlen
+
+    @property
+    def clip0(self):
+        """
+        For X-axis: X-coordinate of left clip\n
+        For Y-axis: Y-coordinate of top clip
+        """
+        return self.__clip0
+    
+    @property
+    def clip1(self):
+        """
+        For X-axis: X-coordinate of right clip\n
+        For Y-axis: Y-coordinate of bottom clip
+        """
+        return self.__clip1
+    
+    @property
+    def cliplen(self):
+        """
+        Distance between clip0 and clip1\n
+        For X-axis: Clip width\n
+        For Y-axis: Clip height
+        """
+        return self.__cliplen
+
+    @property
+    def clipoff(self):
+        """
+        This is the offset from pnt0 to clip0
+        """
+        return self.__clipoff
+
+    @dis0.setter
+    def dis0(self, value:None|int): self.__dis0 = value
+
+    @dis1.setter
+    def dis1(self, value:None|int): self.__dis1 = value
+
+    @len.setter
+    def len(self, value:None|int): self.__len = value
+
+    #endregion
+    
+    #region helper methods
+
+    def _m_resolve(self, force:bool, containlen:int):
+        """
+        Also accessed by TPPane
+        """
+        if not (force or self.__first or\
+                self.__prev_dis0 != self.__dis0 or\
+                self.__prev_dis1 != self.__dis1 or\
+                self.__prev_len != self.__len):
+            return False
+        # Update previous
+        self.__first = False
+        self.__prev_dis0 = self.__dis0
+        self.__prev_dis1 = self.__dis1
+        self.__prev_len = self.__len
+        # Resolve
+        pnt0 = self.dis0
+        pnt1 = None if (self.dis1 is None) else (containlen - self.dis1)
+        pntlen = self.len
+        if pnt0 is not None:
+            if pnt1 is not None:
+                pntlen = pnt1 - pnt0
+            elif pntlen is not None:
+                pnt1 = pnt0 + pntlen
+            else:
+                pnt1 = pnt0
+                pntlen = 0
+        elif pnt1 is not None:
+            if pntlen is not None:
+                pnt0 = pnt1 - pntlen
+            else:
+                pnt0 = pnt1
+                pntlen = 0
+        elif pntlen is not None:
+            pnt0 = 0
+            pnt1 = pntlen
+        else:
+            pnt0 = 0
+            pnt1 = 0
+            pntlen = 0
+        self.__pnt0 = pnt0
+        self.__pnt1 = pnt1
+        self.__pntlen = pntlen
+        self.__clip0 = max(0, min(containlen, self.__pnt0))
+        self.__clip1 = max(0, min(containlen, self.__pnt1))
+        self.__cliplen = self.__clip1 - self.__clip0
+        self.__clipoff = self.__clip0 - self.pnt0
+        return True
+
+    #endregion

boacon/c_BCCursesAttrFunc.py

@@ -0,0 +1,14 @@
+all = ['BCCursesAttrFunc']
+
+from typing import\
+    Callable as _Callable
+
+type BCCursesAttrFunc = _Callable[[int], int]
+"""
+Function for computing a curses character attribute
+
+:param 0:
+    boacon character attribute
+:return:
+    curses character attribute
+"""

boacon/c_BCError.py

@@ -0,0 +1,7 @@
+all = ['BCError']
+
+class BCError(Exception):
+    """
+    Raised when a boacon-related error occurs
+    """
+    pass