fide/fide.py

import pygame as pg
from pygame import Rect

from piece_table import PieceTable

import os
import json
import sys
import time
import copy
from dataclasses import dataclass
from typing import List, Optional

from code import InteractiveConsole, InteractiveInterpreter

@dataclass(slots=True)
class Cursor:
    width: float
    height: float
    line_num: int = 0
    col: int = 0
    want_col: int = 0

@dataclass(slots=True)
class Line:
    # Making this a PieceTable rather than a string is rather pointless right now
    # But it's easier to operate on rows for the time being
    piece: PieceTable
    length: int

@dataclass(slots=True)
class Buffer:
    lines: List[Line]
    cursor: Cursor
    filepath: Optional[str] = None

def cursor_pos(cursor: Cursor):
    return (cursor.line_num, cursor.col)

def cursor_draw(cursor: Cursor):
    rect = Rect(cursor.col * cursor.width, cursor.line_num * cursor.height, 3, cursor.height)
    pg.draw.rect(screen, "black", rect, width=2)

def line_create(text: str) -> Line:
    return Line(PieceTable(text), len(text))

def buffer_create(text: str, filepath: str, cursor: Cursor) -> Buffer:
    lines = []
    for line in text.split('\n'):
        lines.append(line_create(line))
    return Buffer(lines, cursor, filepath)

def buffer_line_current(buf: Buffer) -> Line:
    return buf.lines[buf.cursor.line_num]

def buffer_line_num(buf: Buffer) -> int:
    return buf.cursor.line_num

def buffer_total_lines(buf: Buffer) -> int:
    return len(buf.lines)

def buffer_line_len(buf: Buffer) -> int:
    return buffer_line_current(buf).length


# oswinx, oswiny = 1940,50
oswinx, oswiny = 20,50
os.environ['SDL_VIDEO_WINDOW_POS'] = "%d,%d" % (oswinx,oswiny)
os.environ['SDL_VIDEO_X11_WMCLASS'] = "pygame"
clock = pg.time.Clock()

pg.init()
pg.font.init()
text_renderer = pg.font.Font('JetBrainsMono-Regular.otf', 14)
screen = pg.display.set_mode((900, 900), pg.RESIZABLE)
pg.key.set_repeat(240, 10)

def load_file(path):
    with open(path, 'r', encoding='utf-8') as f:
        text = f.read()
        f.close()
        return text

@dataclass
class GlobalContext:
    text: str
    current_buffer: Buffer
    cursor: Cursor

# global ctx
global ctx
cursor = Cursor(width=8, height=20)
if len(sys.argv) <= 1:
    ctx = GlobalContext("", buffer_create("", cursor), cursor)
else:
    text = load_file(sys.argv[1])
    ctx  = GlobalContext(text, buffer_create(text, sys.argv[1], cursor), cursor)
from config import *
from editing import *
from keybindings import *
def main():
    running = True
    frame_count = 0
    cursor_flash = 0
    cursor_on = True
    line_height = 20
    cursor = ctx.cursor
    current_buffer = ctx.current_buffer
    console = InteractiveInterpreter(locals())
    console.runsource('from editing import *')
    # We are hardcoding precedence here
    while running:
        dt = clock.tick(120) / 1000.0
        screen.fill('white')
        frame_count += 1
        for event in pg.event.get():
            # print(pg.event.event_name(event.type))
            if event.type == pg.QUIT:
                running = False
            if event.type == pg.KEYDOWN:
                # print(pg.key.name(event.key))
                cursor_on = True
                cursor_flash = 0
                curr_line = buffer_line_current(current_buffer)
                kb_to_test = Keybinding(pg.key.name(event.key), event.mod)
                # print(kb_to_test, event.key, pg.key.name(event.key))
                passthrough = True
                for i in range(len(keymap_stack) - 1, -1, -1):
                    keymap = keymap_stack[i]
                    if kb_to_test in keymap.mapping:
                        keymap.mapping[kb_to_test]()
                        if not keymap.pinned:
                            keymap_stack.pop()
                        passthrough = False
                        break
                    else:
                        if keymap.pop_not_found:
                            keymap_stack.pop()
                        if not keymap.fallthrough:
                            passthrough = False
                            if len(kb_to_test.key) == 1:
                                print(f"{kb_to_test} not found")
                            break
                # No keybinding found so send the directly to the buffer
                # I think emacs instead binds every key to a function that sends the
                # letter, we can evaluate if that's better later on
                if passthrough and event.mod < 2 and event.unicode:
                    buffer_insert_char(event.unicode)
                # if event.key == pg.K_RETURN:
                #     src = buffer_line_current(current_buffer).piece.get_text()
                    # try:
                    #     eval(src[3:])
                    # except:
                    #     print('error evaluating line: ' + src[3:])
                #     console.runsource(src[3:])

        for i,curr_line in enumerate(current_buffer.lines):
            line_syntax = syntax_highlights.get_line(i)
            for grammar in line_syntax:
                if grammar.name == 'string':
                    color = 'green'
                else:
                    color = 'black'
                # Does this even make sense? Do we even need a piece
                # table anymore? Why can't we just use a parsed
                # grammar and iterate that and print out the text?

                # I think it makes sense to just grab the string from
                # the treesitter grammar What we need to do is iterate
                # over each child, keeping track of our position As we
                # iterate, we start at row 0, col 0, add any
                # whitespace needed so get the first token. If we were
                # to do it that way, then we have to generate the
                # whitespace and draw it as well.

                # The thing I'm not clear on is what is the best way
                # to identify a token, because we need to tell when to
                # actually write the thing out
                string = curr_line.piece.string_at(grammar.start, grammar.end - grammar.start)
                render = text_renderer.render(string, True, color)
                screen.blit(render, (0, i * line_height))

        if cursor_on and cursor_flash < 0.5:
            cursor_draw(cursor)
        elif cursor_on:
            cursor_on = False
            cursor_flash = 0
        elif not cursor_on and cursor_flash > 0.5:
            cursor_on = True
            cursor_flash = 0
        cursor_flash += dt

        pg.display.flip()

if __name__ == '__main__':
    main()