tui.py

#!/usr/bin/env python3
import os
import sys
import termios
import tty


class TUI:
    def __init__(self, hd44780, memory):
        self.hd = hd44780
        self.mem = memory
        self.running = False

    def clear(self):
        os.system('cls' if os.name == 'nt' else 'clear')

    def get_display_lines(self):
        lines = []
        for i in range(4):
            addr = self.hd._DDRAM_LINE_ADDR[i]
            start = self.hd._REG_DDRAM_START + addr
            line_bytes = self.hd._mem[start:start + 20]
            lines.append(''.join(chr(b) if 32 <= b < 127 else ' ' for b in line_bytes))
        return lines

    def get_cursor_position(self):
        ac = self.hd._mem[self.hd._REG_BF_AC] & self.hd._MASK_AC
        for line_num, line_addr in enumerate(self.hd._DDRAM_LINE_ADDR):
            if line_addr <= ac < line_addr + 20:
                return (line_num, ac - line_addr)
        return (0, 0)

    def is_display_on(self):
        return bool(self.hd._mem[self.hd._REG_DISPLAY_CTRL] & self.hd._BIT_D)

    def is_cursor_on(self):
        return bool(self.hd._mem[self.hd._REG_DISPLAY_CTRL] & self.hd._BIT_C)

    def is_blink_on(self):
        return bool(self.hd._mem[self.hd._REG_DISPLAY_CTRL] & self.hd._BIT_B)

    def get_backlight(self):
        r = self.mem.registers[self.mem.I2C_LCD_BL]
        g = self.mem.registers[self.mem.I2C_LCD_BL_G]
        b = self.mem.registers[self.mem.I2C_LCD_BL_B]
        return (r, g, b)

    def get_encoder_value(self):
        lo = self.mem.registers[self.mem.I2C_ROTARY_VAL]
        hi = self.mem.registers[self.mem.I2C_ROTARY_VAL + 1]
        val = (hi << 8) | lo
        if val >= 0x8000:
            val -= 0x10000
        return val

    def get_button_states(self):
        state = self.mem.registers[self.mem.I2C_SW_MOM_ADD]
        return [(state >> i) & 1 for i in range(6)]

    def adjust_brightness(self, delta: int):
        for reg in (self.mem.I2C_LCD_BL, self.mem.I2C_LCD_BL_G, self.mem.I2C_LCD_BL_B):
            self.mem.registers[reg] = max(0, min(100, self.mem.registers[reg] + delta))

    def toggle_button(self, button: int):
        bit = 1 << (button - 1)
        self.mem.registers[self.mem.I2C_SW_MOM_ADD] ^= bit
        self.mem.registers[self.mem.I2C_SW_INT_ADD] |= bit

    def render(self):
        self.clear()

        lcd_lines  = self.get_display_lines()
        cursor_pos = self.get_cursor_position()
        display_on = self.is_display_on()
        cursor_on  = self.is_cursor_on()
        blink_on   = self.is_blink_on()
        r, g, b    = self.get_backlight()
        ac         = self.hd._mem[self.hd._REG_BF_AC] & self.hd._MASK_AC
        encoder    = self.get_encoder_value()
        buttons    = self.get_button_states()

        G  = "\033[32m"    # green (border)
        HI = "\033[92m"    # bright green (LCD active)
        DM = "\033[90m"    # gray (dim / off)
        MG = "\033[35m"    # magenta (blink indicator)
        RV = "\033[7m"     # reverse video (cursor char)
        BD = "\033[41;1m"  # red bg + bold (pressed button)
        X  = "\033[0m"     # reset

        W = 30
        lines = []

        # Header
        lines.append(f"{G}╔{'═'*W}╗{X}")
        lines.append(f"{G}║{X}{'SMLCD EMULATOR':^{W}}{G}║{X}")
        lines.append(f"{G}╠{'═'*W}╣{X}")

        # LCD display
        lines.append(f"{G}║{X} {DM}LCD DISPLAY{X}{' '*18}{G}║{X}")

        tc = HI if display_on else DM
        for ln, line in enumerate(lcd_lines):
            text = line.ljust(20)[:20]
            if cursor_on and display_on and ln == cursor_pos[0]:
                col = cursor_pos[1]
                rendered = f"{tc}{text[:col]}{RV}{text[col]}{X}{tc}{text[col+1:]}{X}"
            else:
                rendered = f"{tc}{text}{X}"
            lines.append(f"{G}║{X}     {rendered}     {G}║{X}")

        lines.append(f"{G}╠{'═'*W}╣{X}")

        # Status — fixed 3-char width for ON/OFF fields keeps row width constant
        d_val = f"{HI}ON {X}" if display_on else f"{DM}OFF{X}"
        if not cursor_on:
            c_val = f"{DM}OFF{X}"
        elif blink_on:
            c_val = f"{MG}BLK{X}"
        else:
            c_val = f"{HI}ON {X}"

        lines.append(f"{G}║{X} Disp:{d_val} Cursor:{c_val}  AC:0x{ac:02X} {G}║{X}")
        lines.append(f"{G}║{X} Backlight R:{r:3} G:{g:3} B:{b:3}  {G}║{X}")
        lines.append(f"{G}║{X} Line:{cursor_pos[0]+1} Col:{cursor_pos[1]:02}  Encoder:{encoder:5} {G}║{X}")

        lines.append(f"{G}╠{'═'*W}╣{X}")

        # Buttons — red bg + bold when pressed
        btn_strs = []
        for i in range(6):
            if buttons[i]:
                btn_strs.append(f"{BD}[{i+1}]{X}")
            else:
                btn_strs.append(f"{DM} {i+1} {X}")
        lines.append(f"{G}║{X} {' '.join(btn_strs)}      {G}║{X}")

        lines.append(f"{G}╠{'═'*W}╣{X}")

        # Footer
        lines.append(f"{G}║{X}{DM} 1-4:line  <->  c:clr  q:quit {X}{G}║{X}")
        lines.append(f"{G}║{X}{DM} +/-:BL  !@#$%^:btn toggle    {X}{G}║{X}")
        lines.append(f"{G}╚{'═'*W}╝{X}")

        print("\n".join(lines))

    def write_char(self, char):
        self.mem.registers[self.mem.I2C_LCD_DATA] = ord(char)
        self.mem.write_data(self.mem.I2C_LCD_CMD, self.mem.LCD_DATA_WR)

    def set_line(self, line_num):
        if 0 <= line_num <= 3:
            self.hd.execute_instructions(
                self.hd._INST_SET_DDRAM | self.hd._DDRAM_LINE_ADDR[line_num]
            )

    def move_cursor_left(self):
        ac = self.hd._mem[self.hd._REG_BF_AC] & self.hd._MASK_AC
        if ac > 0:
            ac -= 1
            self.hd._mem[self.hd._REG_BF_AC] = (
                self.hd._mem[self.hd._REG_BF_AC] & self.hd._MASK_BF
            ) | ac

    def move_cursor_right(self):
        ac = self.hd._mem[self.hd._REG_BF_AC] & self.hd._MASK_AC
        ac += 1
        self.hd._mem[self.hd._REG_BF_AC] = (
            self.hd._mem[self.hd._REG_BF_AC] & self.hd._MASK_BF
        ) | (ac & self.hd._MASK_AC)

    def clear_display(self):
        self.hd.execute_instructions(self.hd._INST_CLEAR)

    def _read_key(self):
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(fd)
            ch = sys.stdin.read(1)
            if ch == '\x1b':
                ch2 = sys.stdin.read(1)
                ch3 = sys.stdin.read(1)
                if ch2 == '[':
                    if ch3 == 'D':
                        return 'LEFT'
                    elif ch3 == 'C':
                        return 'RIGHT'
                return None
            return ch
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)

    def handle_key(self, key):
        if key is None:
            return True
        if key == 'q' or key == '\x03':
            return False
        if key == 'c':
            self.clear_display()
        elif key in '1234':
            self.set_line(int(key) - 1)
        elif key == 'LEFT':
            self.move_cursor_left()
        elif key == 'RIGHT':
            self.move_cursor_right()
        elif key == '+':
            self.adjust_brightness(10)
        elif key == '-':
            self.adjust_brightness(-10)
        elif key in '!@#$%^':
            self.toggle_button('!@#$%^'.index(key) + 1)
        elif key == '\x7f' or key == '\x08':
            self.move_cursor_left()
            self.write_char(' ')
            self.move_cursor_left()
        elif len(key) == 1 and 32 <= ord(key) < 127:
            self.write_char(key)
        return True

    def run(self, refresh_rate=0.1):
        self.running = True
        try:
            while self.running:
                self.render()
                key = self._read_key()
                if not self.handle_key(key):
                    break
        except KeyboardInterrupt:
            pass
        finally:
            self.running = False
            self.clear()
            print("SMLCD Emulator stopped.")


def demo():
    from smlcd_shim import SMlcd

    lcd = SMlcd()
    lcd.cmd(0x0F)  # display on, cursor on, blink on

    lcd.text_write_at(1, 1, "== SMLCD Emulator ==")
    lcd.text_write_at(2, 1, "   Hello, World!    ")
    lcd.text_write_at(3, 1, "  Type to write...  ")
    lcd.text_write_at(4, 1, "  q=quit  c=clear   ")

    lcd.bl_rgb(50, 200, 50)
    lcd.inject_encoder(300)

    tui = TUI(lcd.hd, lcd.mem)
    tui.run()


if __name__ == "__main__":
    demo()