예제 #1
0
def main():
    """Since 1 braille chars can represent 2*4 points we have to scale the board accordingly"""
    width, height = drawille.getTerminalSize()
    width, height = int((width*2.0)-2), int((height*4.0)-4)
    game = GameOfLife(width=width, height=height)
    
    def fill_board_randomly(game):
        def set_cell_randomly():
            if randrange(10) > randrange(6, 10): return 1
            return 0

        for y in range(game.height):
            for x in range(game.width):
                game.board[y][x] = set_cell_randomly()
        
    fill_board_randomly(game)             
    
    def frame_coordinates(game):
        while True:
            game.evolve_board()
            s = []
            for y in range(game.height):
                for x in range(game.width):
                    if game.board[y][x] == 1: s.append((x, y))

            yield s
     
    s = drawille.Canvas()
    drawille.animate(s, frame_coordinates, 1./5, game)
예제 #2
0
def main(stdscr):
    stdscr.nodelay(1)
    curses.curs_set(0)

    termSize = getTerminalSize()
    argsSize = len(sys.argv)
    WIDTH = min((int(sys.argv[1]) if argsSize > 1 else 64), termSize[0] * 2)
    HEIGHT = min((int(sys.argv[2]) if argsSize > 2 else 64), termSize[1] * 4)
    FRAMES = 4
    display = Canvas()
    grid = getGrid(WIDTH, HEIGHT)

    addPentomino(grid, int(WIDTH / 2), int(HEIGHT / 2))
    drawGrid(display, grid, stdscr)
    time.sleep(1. / FRAMES)

    while True:
        grid = updateGrid(grid, WIDTH, HEIGHT)
        drawGrid(display, grid, stdscr)
        key = stdscr.getch()
        if key == ord('q'):
            break
        elif key == ord('s'):
            addPentomino(grid, int(WIDTH / 2), int(HEIGHT / 2))
        elif key == curses.KEY_UP:
            FRAMES += 1 if FRAMES < 60 else 0
        elif key == curses.KEY_DOWN:
            FRAMES -= 1 if FRAMES > 2 else 0
        time.sleep(1. / FRAMES)
예제 #3
0
    def while_waiting(self):
        '''
            called periodically when user is not pressing any key
        '''
        # if not self.update_thread:
        #     t = ThreadJob(self.update,self.stop_event,1)
        #     self.update_thread = t
        #     self.update_thread.start()
        self._logger.info('Updating GUI due to no keyboard interrupt')
        '''
            Earlier a thread job was being used to update the GUI
            in background but while_waiting is getting called after 10ms
            (keypress_timeout_default) so no more thread job is required
            Only issue is that when user is interacting constantly the GUI
            won't update
        '''
        terminal_width,terminal_height = drawille.getTerminalSize()
        self._logger.info("Equating terminal sizes, old {0}*{1} vs {2}*{3}".format(PREVIOUS_TERMINAL_WIDTH,
                                                                                   PREVIOUS_TERMINAL_HEIGHT,
                                                                                   terminal_width,
                                                                                   terminal_height
                                                                                   ))

        # In case the terminal size is changed, try resizing the terminal and redrawing ptop
        if terminal_width != PREVIOUS_TERMINAL_WIDTH or terminal_height != PREVIOUS_TERMINAL_HEIGHT:
            self._logger.info("Terminal Size changed, updating the GUI")
            self.window.erase()
            self.draw()
            self.update()
        # In case the terminal size is not changed, don't redraw the GUI, just update the contents
        else:
            self.update()
예제 #4
0
def goldenratio2drawille(goldenratio, n, s, angle):
    def square(size):
        for i in range(4):
            t.forward(size)
            t.right(goldenratio.angle)

    # Taken from python turtle library
    def circle(radius, extent=None, steps=None):
        fullCircle = 360
        if extent is None:
            extent = fullCircle
        if steps is None:
            frac = abs(extent) / fullCircle
            steps = 1+int(min(11+abs(radius) / 6.0, 59.0)*frac)
        w = 1.0 * extent / steps
        w2 = 0.5 * w
        l = 2.0 * radius * sin(w2*pi/180.0)
        if radius < 0:
            l, w, w2 = -l, -w, -w2
        t.right(w2)
        for i in range(steps):
            t.forward(l)
            t.right(w)
        t.left(w2)

    t = Turtle()
    size = getTerminalSize()[0] + s
    t.rotation = goldenratio.angle + angle

    for i in range(n):
        square(size)
        t.forward(size)
        t.right(goldenratio.angle)
        t.forward(size)
        size /= goldenratio.phi

    t.up()
    t.move(0, 0)
    t.down()
    size = getTerminalSize()[0] + s
    t.rotation = goldenratio.angle + angle

    for i in range(n):
        circle(size, 90)
        size /= goldenratio.phi

    return t.frame()
예제 #5
0
def __main__(stdsrc, argv=None):
    if argv == None:
        argv = sys.argv

    # Initialize putmatrix
    matrix = None
    if len(argv) > 1:
        # load specified file
        f = open( argv[1], 'r' )
        matrix = [ [ bool(int(val)) for val in  line.split(',')] for line in f ]
    else:
        matrix = [[True for i in range(20)] for j in range(20)]

    # Get terminal size
    term_x, term_y = getTerminalSize()

    # Set rows and columns
    columns = (term_x-1)*2
    rows = (term_y-1)*4

    g = GameOfLife(rows,columns)

    g.draw()

    c_x = 0
    c_y = 0
    stdscr.move(c_y,c_x)

    while True:

        g.tick()

        # Draw to curses
        g.draw()
        stdscr.move(c_y,c_x)

        stdscr.refresh()

        # Catch user input
        inp = stdscr.getch()
        if inp != curses.ERR:
            # Down
            if inp == 258:
                c_y = min(c_y + 1, term_y-1)
            # Up
            if inp == 259:
                c_y = max(c_y - 1, 0)
            # Left
            if inp == 260:
                c_x = max(c_x - 1, 0)
            # Right
            if inp == 261:
                c_x = min(c_x + 1, term_x-1)
            # Put
            if inp == ord(" "):
                g.put(matrix, c_x*2, c_y*4)
            # Quit
            if inp == 27:
                break
예제 #6
0
def complexset2drawille(complexset, n):
    can = Canvas()
    w, h = getTerminalSize()
    w *= 2
    h *= 4

    for row in range(h):
        for col in range(w):
            if complexset.plot(col, row, w, h, n) >= complexset.MAX_ITER:
                can.set(col, row)
    return can.frame()
예제 #7
0
def getDrawing():
    global currentfractal, drawing, iteration, size, angle
    fractal = fractals[currentfractal]
    if isinstance(fractal, Mandelbrot) or isinstance(fractal, Julia):
        drawing = complexset2drawille(fractal, iteration)
    elif isinstance(fractal, Goldenratio):
        drawing = goldenratio2drawille(fractal, iteration, size, angle)
    else:
        drawing = lsystem2drawille(fractal, iteration, size, angle)
    # Restrict viewport because curses can't handle UTF outside viewport
    termSize = getTerminalSize()
    drawing = '\n'.join(map(lambda x: x[:termSize[0] - 1], drawing.split('\n')[:termSize[1] - 1]))
예제 #8
0
파일: sw.py 프로젝트: zemiret/termglyph
def main(stdscr):
    curses.init_pair(1, curses.COLOR_YELLOW, curses.COLOR_BLACK)
    title = 'welcome-component.js'

    text = 'abc kanapecki what what the heck is this kurdebele lemme go slower'
    w, h = drawille.getTerminalSize() 

    stdscr.clear()

    # Title
    draw_title(stdscr, title, w, h)

    # Text 
    word_images = convert_text_to_bitmaps(text)
    # TODO: This... does not throw an error but does not really work
    word_images = combine_bitmaps(word_images, w)

    frames = map(lambda im: termglyph.get_frame(im, color=False), word_images)
    framelines = []
    for frame in frames:
        x, y = get_frame_starting_cords(frame, w, h)
        frame = fill_frame_to_x(x, frame)

        framelines.append(FrameLine(frame, y, w, h))

    if len(framelines) == 0:
        return

    frame_window = [framelines[0]] 
    frame_index = 1

    while not len(frame_window) == 0:
        stdscr.clear()
        draw_and_advance_frames(stdscr, frame_window)

        if frame_window[0].is_out():
            frame_window.pop(0)

        if len(frame_window) > 0 and\
           frame_window[-1].can_push_next() and frame_index < len(framelines):

            frame_window.append(framelines[frame_index])
            frame_index += 1


        stdscr.refresh()
        # stdscr.getkey()
        time.sleep(SWIPE_RATE)
예제 #9
0
def resize_to_fit(im):
    term_w, term_h = drawille.getTerminalSize()
    term_w *= drawille.X_SIZE_RATIO
    term_h *= drawille.Y_SIZE_RATIO
    im_width, im_height = im.size

    w_ratio = im_width / term_w
    h_ratio = im_height / term_h

    ratio = w_ratio if w_ratio > h_ratio else h_ratio
    if ratio > 1:
        new_width = int(im_width // ratio)
        new_height = int(im_height // ratio)

        im = im.resize((new_width, new_height))

    return im
예제 #10
0
    def create(self):
        # Draws a form with a widget for states, log messages, and connection status
        column_height = drawille.getTerminalSize()[::-1][0]

        self.states_widget = self.add(npyscreen.BoxTitle,
                                      name="Internal States ({} received)",
                                      max_height=column_height // 3,
                                      editable=True)

        self.messages_widget = self.add(
            npyscreen.BoxTitle,
            name="Log Messages",
            max_height=column_height // 3,
            editable=True,
        )

        self.connection_text = self.add_widget(npyscreen.TitleText,
                                               name=f"Connection Status: ",
                                               editable=False)
예제 #11
0
    exit()

if __name__ == '__main__':
    if len(argv) < 2:
        url = 'http://xkcd.com/'
    elif argv[1] in ['-h', '--help']:
        usage()
    elif argv[1].startswith('http'):
        url = argv[1]
    else:
        url = 'http://xkcd.com/%s/' % argv[1]
    c = urllib2.urlopen(url).read()
    img_url = re.findall('http:\/\/imgs.xkcd.com\/comics\/.*\.png', c)[0]
    i = Image.open(StringIO(urllib2.urlopen(img_url).read())).convert('L')
    w, h = i.size
    tw, th = getTerminalSize()
    tw *= 2
    th *= 2
    if tw < w:
        ratio = tw / float(w)
        w = tw
        h = int(h * ratio)
        i = i.resize((w, h), Image.ANTIALIAS)
    can = Canvas()
    x = y = 0

    try:
         i_converted = i.tobytes()
    except AttributeError:
         i_converted = i.tostring()
예제 #12
0
#!/usr/bin/env python
from time import sleep
import ui
import curses
import drawille
import locale
import math
import sys

locale.setlocale(locale.LC_ALL,"")

stdscr = curses.initscr()
stdscr.refresh()

size = drawille.getTerminalSize()
width = (size[0]-1) * ui.HORIZONTAL_PIXELS_PER_CHAR
height = (size[1]-1) * ui.VERTICAL_PIXELS_PER_CHAR


amplitude = ui.Control("amp", 1, 0, 2)
frequency = ui.Control("freq", 1.0, 0.1, 8)
phase = ui.Control("phase", 0.0, -1, 1)
resolution = ui.Control("res", 5, 1, 10)
speed = ui.Control("speed", 1, -2, 2)

time = 0

controls = [
    amplitude,
    frequency,
    phase,
예제 #13
0
    def while_waiting(self):
        # Saves current terminal size to determine whether or not a redraw
        # of the TUI is necessary
        curr_width, curr_height = drawille.getTerminalSize()

        # Serialized data to be received from manticore server
        serialized = None

        try:

            # Attempts to (re)connect to manticore server
            if not self._connected:
                self._mcore_socket = socket.socket(socket.AF_INET,
                                                   socket.SOCK_STREAM)
                self._logger.info("Connected to manticore server")
                self._mcore_socket.connect(("127.0.0.1", 1337))
                self._connected = True
                self._socket_list = [self._mcore_socket]

            # Uses Python select module with timeout 0 to determine whether or not sockets have any data
            # To be read from or written to to prevent client send/recv operations from blocking.
            read_sockets, write_sockets, error_sockets = select.select(
                self._socket_list, self._socket_list, [], 0)

            # If there are sockets available for reading, deserialize data
            if len(read_sockets):
                serialized = self._mcore_socket.recv(1024)
                self._logger.info("Received serialized of length {}".format(
                    len(serialized)))

            # If there are sockets available for writing, send an ACK to server
            if len(write_sockets):
                self._mcore_socket.send(b"Received states")

            # Protobuf can't directly determine the type of data being received, so we use the following workaround
            # We first try to deserialize data as a StateList object and check its .states attribute
            # Since in practice a StateList must contain at least one state, we know that if len(.states) is 0
            # Then the deserialized message can't be a StateList.  We then try deserializing into a MessageList object
            # and check its .messages attribute.  If len(.messages) is empty, then we conclude that the data sent
            # was corrupted or incorrectly serialized.
            try:
                m = StateList()
                m.ParseFromString(serialized)

                if len(m.states) > 0:
                    self.all_states += format_states(m)
                    self._logger.info("Deserialized StateList")

                else:
                    m = MessageList()
                    m.ParseFromString(serialized)
                    self.all_messages += format_messages(m)
                    self._logger.info("Deserialized LogMessage")

                    if len(m.messages) == 0:
                        raise TypeError

            except DecodeError:
                self._logger.info(
                    "Unable to deserialize message, malformed response")

        # Detect server disconnect
        except socket.error:
            self._connected = False

        # Handle any other exceptions
        except:
            pass

        self.MainForm.connection_text.value = f"{'Connected' if self._connected else 'Not connected'}"

        if curr_width != self.prev_width or curr_height != self.prev_height:
            self._logger.info('Size changed')
            self.MainForm.erase()
            self.draw()
            self.MainForm.DISPLAY()

        # Updates the list of states and messages to be displayed
        # Normally appending to the list of values during while_waiting() would work but we have to
        # Consider the scenario where the user resizes the terminal, in which case
        # .erase() is called and all widgets lose their previous values upon being redrawn.
        # So we maintain a separate list of all currently received states and messages (all_states, all_messages)
        # and reassign Each widget's list of states / messages instead.

        self.MainForm.states_widget.entry_widget.values = self.all_states
        self.MainForm.messages_widget.entry_widget.values = self.all_messages

        self.MainForm.states_widget.name = f"Internal States ({len(self.MainForm.states_widget.values)} received)"
        self.MainForm.messages_widget.name = f"Log Messages ({len(self.MainForm.messages_widget.values)} received)"

        self.MainForm.states_widget.display()
        self.MainForm.messages_widget.display()
        self.MainForm.connection_text.display()
예제 #14
0
 def draw(self):
     # Draws the main TUI form with all sub-widgets and allows for user interaction
     self.MainForm = ManticoreMain(parentApp=self, name="Manticore TUI")
     self.prev_width, self.prev_height = drawille.getTerminalSize()
     self.MainForm.edit()