def run_scrimmage_ui(): use_asyncio_event_loop() app = Application( layout=layout, key_bindings=kb, full_screen=True, style=style, mouse_support=True, enable_page_navigation_bindings=True,) loop = asyncio.get_event_loop() loop.run_until_complete( app.run_async().to_asyncio_future())
context = Context() shade_menu = ShadeMenu(context) context.shade_menu = shade_menu scene_menu = SceneMenu(context) context.scene_menu = scene_menu test_menu = SideBar(context, [], None) menu_items = [ MenuItem( "file", children=[ MenuItem("shades", shade_menu.show), MenuItem("scenes", scene_menu.show), ], ) ] layout = get_layout(shade_menu, menu_items) app = Application( layout=layout, full_screen=True, key_bindings=kb, style=ui_style, ) loop.run_until_complete(app.run_async().to_asyncio_future())
class TUI(object): key_bindings = KeyBindings() def __init__(self): self.console = TextArea( scrollbar=True, focusable=False, line_numbers=False, lexer=PygmentsLexer(SerTermLexer), ) self.cmd_line = TextArea( multiline=False, prompt=HTML('<orange>>>> </orange>'), style='bg: cyan', accept_handler=self.cmd_line_accept_handler, history=FileHistory('.ser-term-hist'), auto_suggest=AutoSuggestFromHistory(), ) self.root = HSplit([ self.console, self.cmd_line, ]) self.menu = MenuContainer( self.root, menu_items=[ MenuItem(text='[F2] Open port', handler=self.key_uart_open), MenuItem(text='[F3] Close port', handler=self.key_uart_close), MenuItem( text='[F4] Baudrate', children=[ MenuItem( str(bd), handler=(lambda bd: lambda: self.baudrate_update( baudrate=int(bd)))(bd)) for bd in BAUDRATE ], ), MenuItem( text='[F5] End line', children=[ MenuItem('LF \\n', handler=lambda: self.end_line_update('\n')), MenuItem('CR \\r', handler=lambda: self.end_line_update('\r')), MenuItem('CRLF \\r\\n', handler=lambda: self.end_line_update('\r\n')), ], ), MenuItem(text='[F10] Quit', handler=self.key_application_quit), ], ) if args.end_line == 'LF': self.end_line = '\n' elif args.end_line == 'CR': self.end_line = '\r' else: self.end_line = '\r\n' self.end_line_update() self.baudrate_update() self.layout = Layout(self.menu) self.layout.focus(self.root) self.key_bindings.add('s-tab')(focus_previous) self.key_bindings.add('tab')(focus_next) self.app = Application( layout=self.layout, key_bindings=self.key_bindings, full_screen=True, mouse_support=True, ) @key_bindings.add('f10') @key_bindings.add('c-c') @key_bindings.add('c-d') @key_bindings.add('c-x') @key_bindings.add('c-q') @key_bindings.add('escape') def key_application_quit(self, event=None): get_app().exit() @key_bindings.add('f2') def key_uart_open(self, event=None): UART.run() @key_bindings.add('f3') def key_uart_close(self, event=None): UART.stop() @key_bindings.add('f4') def key_baudrate(self, event=None): tui.baudrate_update(shift=True) @key_bindings.add('f5') def key_end_line(self, event=None): tui.end_line_update(shift=True) def cmd_line_accept_handler(self, handler): line = ''.join(('Tx: ', handler.text)) console_append(self.console, line) UART.queue_tx.put_nowait(handler.text + self.end_line) def end_line_update(self, symbol=None, shift=None): if symbol: self.end_line = symbol if shift: if self.end_line == '\n': self.end_line = '\r' self.menu.menu_items[-2].text = '[F5] End line CR' elif self.end_line == '\r': self.end_line = '\r\n' self.menu.menu_items[-2].text = '[F5] End line CRLF' else: self.end_line = '\n' self.menu.menu_items[-2].text = '[F5] End line LF' if self.end_line == '\n': self.menu.menu_items[-2].text = '[F5] End line LF' elif self.end_line == '\r': self.menu.menu_items[-2].text = '[F5] End line CR' else: self.menu.menu_items[-2].text = '[F5] End line CRLF' def baudrate_update(self, baudrate=None, shift=None): if baudrate in BAUDRATE: UART.baudrate = baudrate UART.stop() UART.run() if shift: i = BAUDRATE.index(UART.baudrate) i = 0 if i + 1 >= len(BAUDRATE) else i + 1 UART.baudrate = BAUDRATE[i] UART.stop() UART.run() self.menu.menu_items[-3].text = '[F4] Baudrate ' + str(UART.baudrate) def run(self): prompt_toolkit.eventloop.use_asyncio_event_loop() asyncio.get_event_loop().run_until_complete( self.app.run_async().to_asyncio_future())
class UI(Client): def __init__(self, username: str, password: str): super().__init__(username, password, handle_data=DataFormat.ANSI) self.commands = [] self.output_buffer = Buffer_() self.cursor_pos = 0 self.chat_buffer = Buffer_() self.output = BufferControl(self.output_buffer, input_processors=[FormatText()], include_default_input_processors=True) self.chat = BufferControl(self.chat_buffer, input_processors=[FormatText()], include_default_input_processors=True) self.hide_ip = "--hide-ip" in sys.argv self.suggest = AutoSuggestFromLogs([ CommandSuggest(), ]) self.input = TextArea(height=1, prompt=" >> ", multiline=False, wrap_lines=False, accept_handler=self.accept, auto_suggest=self.suggest, dont_extend_width=True) self.host_ip = FormattedTextControl(ANSI("")) self.chat_float = Float(Frame(Window(self.chat, wrap_lines=True)), right=1, top=0, width=40, height=12, hide_when_covering_content=True) self.text = "" self.chat_text = "" def set_frame_size(fn): def inner(*args): size = self.app.output.get_size() self.chat_float.width = size.columns // 3 self.chat_float.height = size.rows // 2 return fn(*args) return inner self.out_window = Window(self.output, wrap_lines=True) kb = KeyBindings() @kb.add('c-c') @kb.add('c-q') def _(_): self.app.exit() self._loop = False self.run_again = False @kb.add('c-i', filter=has_focus(self.input)) def __(_): fut = self.suggest.get_suggestion_future(self.input.buffer, self.input.document) text = self.input.text def set_input(fut_2): res = fut_2.result() if res is not None: self.input.text = text + res.text self.input.document = Document(self.input.text, cursor_position=len( self.input.text)) fut.add_done_callback(set_input) @kb.add(Keys.ScrollUp) def sup(_): self.output_buffer.cursor_up(1) self.out_window._scroll_up() # pylint: disable=protected-access @kb.add(Keys.ScrollDown) def sdown(_): self.output_buffer.cursor_down(1) self.out_window._scroll_down() # pylint: disable=protected-access self.app = Application( layout=Layout( container=HSplit([ Frame( FloatContainer(self.out_window, floats=[self.chat_float])), Frame( VSplit([ self.input, Window(self.host_ip, align=WindowAlign.RIGHT, dont_extend_width=True) ])) ]), focused_element=self.input, ), full_screen=True, mouse_support=True, enable_page_navigation_bindings=True, key_bindings=merge_key_bindings([kb]), paste_mode=True, ) self.app._on_resize = set_frame_size(self.app._on_resize) # pylint: disable=protected-access self.run_again = True self.loop = get_event_loop() self._loop = False self.own_pass = "" self.own_ip = "" self.current_ip = "" # patch_stdout() @classmethod def create(cls) -> 'UI': user = prompt("Username: "******"Password: "******"{Fore.BLUE}[BROADCAST]{Fore.RESET} {converted_color_codes(e.msg)}" ) else: self.set_output(converted_color_codes(e.msg)) def event_error(self, e: ErrorEvent): self.err(e.error) @staticmethod def sanitize(arg: str) -> ANSI: return to_formatted_text(ANSI(arg)) def err(self, message: str): self.set_output( f"{Fore.RED}{converted_color_codes(message)}{Fore.RESET}") def set_chat_output(self, text: str): new_text = (self.chat_text + "\n" + text).strip() self.chat_buffer.set_text(new_text) self.chat_text = new_text.replace("\t", " ") def set_output(self, text: str): new_text = (self.text + "\n" + text).strip() self.output_buffer.set_text(new_text) self.text = new_text.replace("\t", " ") self.cursor_pos = len(self.text) def clear_chat(self): self.chat_buffer.set_text("") self.chat_text = "" def clear(self): self.output_buffer.set_text("") self.text = "" def accept(self, _): if self.input.text.strip(): self.set_output(f"\n>> {self.input.text}") self.commands.append(self.input.text) self.suggest.last_command(self.input.text) self.input.text = "" async def get_host_data(self): data = await self.command("pass see -l") self.own_pass = data.msg sys_info = await self.command('specs -l') self.current_ip = self.own_ip = re.search( r"(?P<ip>\d{1,3}(\.\d{1,3}){3,4})", sys_info.msg).group("ip") def launch(self): colorama.init() use_asyncio_event_loop() patch_stdout() while self.run_again: self.run_again = False self._loop = True self.loop.create_task(self.start()) try: self.loop.run_until_complete( self.app.run_async().to_asyncio_future()) except KeyboardInterrupt: if self.current_ip != self.own_ip: self.loop.run_until_complete(self.command("dc")) async def event_ready(self): o_text = self.output_buffer.text await self.get_host_data() text = (( f"{Fore.YELLOW}{self.own_ip} - {self.own_pass}{Fore.RESET} " if self.own_ip == self.current_ip else f"{Fore.YELLOW}{self.current_ip} / {self.own_ip} - {self.own_pass}{Fore.RESET} " ) if not self.hide_ip else "") self.host_ip.text = self.sanitize(text) self.clear() self.set_output(o_text) macros = MacroHolder() while self._loop: # TODO: Update these when they change macros.macros["self"] = self.own_ip macros.macros["pass"] = self.own_pass while not self.commands: await asyncio.sleep(0.1) try: line = self.commands.pop(0).strip() line = macros.parse(line) command, *args = line.split() if command == "chats": if len(args) == 1 and args[0] == "clear": self.clear_chat() else: await self.command(" ".join([command, *args])) elif command == "macro": if args and args[0] in ("add", "remove", "list"): sub = args.pop(0) if sub == "add": if len(args) >= 2: macros += args[0], " ".join(args[1:]) else: self.set_output( "Usage: macro add <name> <value>") elif sub == "remove": if args: macros -= args[0] else: self.set_output("Usage: macro remove <name>") else: self.set_output("Macros:") for key in sorted(list(macros)): self.set_output(f"${key} -> {macros[key]}") else: self.set_output("Usage: macro [add/remove/list] ...") elif command == "clear": self.clear() elif command == "quit": self._loop = False self.run_again = False self.stop() self.app.exit() else: await self.command(" ".join([command, *args])) except Exception as e: # pylint: disable=broad-except self.err(repr(e))
@kb.add('c-q') def exit_(event): global RunApp """ Pressing Ctrl-Q will exit the user interface. Setting a return value means: quit the event loop that drives the user interface and return this value from the `Application.run()` call. """ RunApp = False event.app.exit() async def print_serial(): while (RunApp): if (ser.inWaiting() > 0): input_str = ser.read(ser.inWaiting()).decode() clean_str = re.sub('\r', '', input_str) buffer2.insert_text(clean_str) else: await sleep(0.5) app = Application(key_bindings=kb, layout=layout, style=style, full_screen=True) use_asyncio_event_loop() get_event_loop().run_until_complete( gather(app.run_async().to_asyncio_future(), print_serial()))