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()))
