def get_root_container(self) -> FloatContainer:
validator = CoordinateValidator(self.maze_grid)
maze_grid_container = Label(text=self.maze_grid.format_grid, )
coordinates_input_container = Window(
BufferControl(
buffer=Buffer(
validator=validator,
validate_while_typing=False,
multiline=False,
accept_handler=self._accept_handler,
),
input_processors=[
BeforeInput("Enter coordinates (x, y): "),
],
), )
validation_toolbar = ConditionalContainer(
ValidationToolbar(),
filter=~is_done,
)
return FloatContainer(
HSplit([
maze_grid_container,
HorizontalLine(),
coordinates_input_container,
validation_toolbar,
]),
floats=[],
)
def __init__(self, buffer, **kwargs):
self.buffer = buffer
self.before_input_text = kwargs.get("before_input_text", "➜ ")
self.title = kwargs.get("title", "COMMAND SHELL")
self._buffer = buffer
self._buffer_control = BufferControl(
buffer=self.buffer,
input_processors=[BeforeInput(text=self.before_input_text)],
focus_on_click=True,
)
self.window = Frame(
title=self.title,
key_bindings=self.kbindings(),
body=FloatContainer(
content=Window(self._buffer_control),
key_bindings=None,
floats=[
Float(
xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=5, scroll_offset=1),
)
],
),
height=3,
)
def __init__(self, buffer, title):
self._title = title
self._buffer = buffer
self.buffer_control = BufferControl(
buffer=self._buffer,
lexer=PygmentsLexer(MarkdownLexer),
)
self.window = Frame(
body=Window(
content=self.buffer_control,
right_margins=[ScrollbarMargin(display_arrows=True)],
scroll_offsets=ScrollOffsets(top=2, bottom=2),
),
title=self._title,
)
def _body_windows(self, formatted_columns):
rows = list(itertools.zip_longest(*formatted_columns, fillvalue=""))
if rows:
rows_string = [self._sep.join(row) for row in rows]
table_body = "\n".join(rows_string)
document = Document(table_body, 0)
_buffer = Buffer(document=document, read_only=True)
self._body_control = BufferControl(_buffer)
body_windows = [
Window(
self._body_control,
right_margins=[ScrollbarMargin(display_arrows=True)],
)
]
else:
body_windows = []
return body_windows
def pager(self, html, end="\n"):
"""
Construct pager using prompt_toolkit
"""
my_buffer = Buffer()
my_window = Window(
BufferControl(
buffer=my_buffer,
focusable=True,
preview_search=True,
input_processors=[FormatText()],
))
my_buffer.text = html
my_buffer.read_only = to_filter(True)
root_container = HSplit([
my_window,
])
bindings = KeyBindings()
@bindings.add("c-c")
@bindings.add("q")
def _(event):
"Quit."
event.app.exit()
application = Application(
layout=Layout(
root_container,
focused_element=my_window,
),
key_bindings=bindings,
enable_page_navigation_bindings=True,
mouse_support=True,
full_screen=True,
)
application.run()
super().msg(html=html, end=end)
def __init__(self, buffer):
self.buffer_control = BufferControl(
buffer=buffer,
focusable=True,
key_bindings=self._get_key_bindings(),
focus_on_click=True,
)
self.window = Window(
content=self.buffer_control,
right_margins=[ScrollbarMargin(display_arrows=True)],
)
self.window = Frame(body=Box(
self.window,
padding_left=2,
padding_right=2,
padding_top=0,
padding_bottom=0,
))
def create_cmd_bar(self):
ctx = self.ctx
def get_cmd_prefix():
has_focus = ctx.app.layout.current_buffer is ctx.cmd_buffer
cls = style.COMMAND_FOCUSED
if has_focus:
text = f"<{cls}>> </{cls}>"
else:
text = "> "
return HTML(text)
return Window(
BufferControl(
ctx.cmd_buffer,
focus_on_click=True,
input_processors=[BeforeInput(get_cmd_prefix)],
key_bindings=cmd_kb,
lexer=PygmentsLexer(CommandLexer),
),
height=1,
)
def __init__(self, path):
self.edit = False
self.lock = False
self.model = model.Model(path)
self.style = style_from_dict({
Token.CursorLine: 'reverse',
})
self.wrapping = Condition(lambda cli: self.model.wrap)
self.editing = Condition(lambda cli: self.edit)
self.locked = Condition(lambda clie: self.lock)
self.main = Window(content=MyControl(self.model),
cursorline=~self.locked,
wrap_lines=self.wrapping)
self.status = Window(height=LayoutDimension.exact(1),
content=TokenListControl(
get_tokens=self.get_status_tokens,
align_right=False))
self.command = Window(
height=LayoutDimension.exact(1),
content=BufferControl(buffer_name=DEFAULT_BUFFER),
allow_scroll_beyond_bottom=True)
self.layout = HSplit([self.main, self.status, self.command])
bindings = self.load_bindings()
self.application = Application(
layout=self.layout,
style=self.style,
use_alternate_screen=True,
buffer=Buffer(is_multiline=False,
read_only=Condition(lambda: not self.edit)),
key_bindings_registry=bindings)
def textbox(buffer, title, lexer=None):
def get_style():
ctx = context.get()
if ctx.app.layout.current_buffer is buffer:
cls = style.TEXTBOX_FOCUSED
else:
cls = style.TEXTBOX
return f"class:{cls}"
return HSplit([
FormattedTextToolbar(
text=title,
style=get_style,
),
Window(
cursorline=True,
content=BufferControl(
buffer=buffer,
focus_on_click=True,
lexer=lexer,
),
ignore_content_width=True,
),
])
def homeLayoutFactory(self):
content = self.studio.content
statusBar = Frame(
Window(BufferControl(buffer=content.getBuffer("statusBar"),
focusable=False),
height=D(min=1, max=1, preferred=1),
align=WindowAlign.CENTER))
savedModelsBox = Box(HSplit([
Label(text="Saved Models: ", style="class:blue class:underlined"),
Window(
BufferControl(buffer=content.getBuffer("savedModels"),
focusable=False))
]),
padding=0)
modelDefinitionsBox = Box(HSplit([
Label(text="Model Definitions: ",
style="class:blue class:underlined"),
Window(
BufferControl(buffer=content.getBuffer("modelDefinitions"),
focusable=False))
]),
padding=0)
rightSidebar = Frame(
HSplit([savedModelsBox,
HorizontalLine(), modelDefinitionsBox]))
createModelButton = Button("[C] Create Model ",
handler=self.studio.layouts.swapper(
Layouts.CREATE))
loadModelButton = Button("[L] Load Saved Model ",
handler=self.studio.layouts.swapper(
Layouts.LOAD))
importModelButton = Button("[I] Import Model From Definition ",
handler=self.studio.layouts.swapper(
Layouts.IMPORT))
editModelButton = Button("[E] Edit Model ",
handler=self.studio.layouts.swapper(
Layouts.EDIT))
deleteModelButton = Button("[D] Delete Model ",
handler=self.studio.layouts.swapper(
Layouts.DELETE))
quitButton = Button("[Q] Quit ",
handler=self.studio.exit)
editModelButton = ConditionalContainer(
editModelButton, filter=self.studio.controller.modelExistsFilter())
leftSidebar = HSplit([
createModelButton,
loadModelButton,
importModelButton,
editModelButton,
deleteModelButton,
quitButton,
])
creditBar = Label(
text="Created by Samuel Ellertson - github.com/SamuelEllertson",
style="class:blue")
body = VSplit([Frame(Sizeable(leftSidebar)), Sizeable(rightSidebar)])
root = HSplit([statusBar, body, creditBar])
return Layout(container=root, focused_element=createModelButton)
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 = ""
def apply_transformation(self, input_):
fragments = to_formatted_text(
ANSI(fragment_list_to_text(input_.fragments)))
return Transformation(fragments)
# layout.
search_field = SearchToolbar() # for reverse search.
output_field = Buffer()
channels_window = RadioList(utils.get_channels())
general_ch = utils.config['channels']['general']
channels_window.current_value = general_ch
channels_frame = Frame(channels_window, title="channels", width=23)
output_window = Frame(Window(BufferControl(buffer=output_field,
focusable=False,
input_processors=[FormatText()]),
wrap_lines=True),
title="#general")
input_field = TextArea(
height=1,
prompt='> ',
multiline=False,
wrap_lines=False,
search_field=search_field,
)
command_window_frame = Frame(input_field, title=cmd_area_text)
upper_container = VSplit([channels_frame, output_window])
container = HSplit([
upper_container,