def init_layout(self):
for i in range(len(self.top_screens)):
s = self.top_screens[i]
s.app = self
s.screen_idx = i
self.screen_sel_buttons.append(
Button(text="%s %s" % (s.shortcut.upper(), s.shortcut_label),
handler=s.screen_sel))
self.lbl_screen = Label(text=self.top_screens[0].title)
self.top_screen = DynamicContainer(self.get_top_screen_container)
btn_action = Button(text="F8 Action", handler=self.f_action)
btn_exit = Button(text="F10 Exit", handler=self.f_exit)
self.root_container = FloatContainer(
HSplit([
Box(
body=VSplit([self.lbl_screen], align="CENTER", padding=3),
style="class:button-bar",
height=1,
),
self.top_screen,
Box(
body=VSplit(self.screen_sel_buttons +
[btn_action, btn_exit],
align="CENTER",
padding=3),
style="class:button-bar",
height=1,
),
]), self.floats)
self.top_layout = Layout(self.root_container,
focused_element=self.screen_sel_buttons[0])
def get_root_container(self):
solution_containers = [
HSplit([
self._get_grid_container(grid),
Button(
"Select",
functools.partial(self.multi_screen.app.exit,
result=grid)),
]) for grid in self.solution_grids
]
challenge_grid_container = Box(
self._get_grid_container(self.challenge_grid))
return FloatContainer(
Box(
Frame(
HSplit(
[
challenge_grid_container,
VSplit(
solution_containers,
padding=2,
),
],
padding=1,
), ), ),
floats=[],
)
def get_root_container(self) -> FloatContainer:
header_row = self.table.format_table().splitlines()[0]
data_rows = self.table.format_table().splitlines()[1:]
row_buttons = [
SelectableLabel(row,
handler=functools.partial(self._handle_answer, i))
for i, row in enumerate(data_rows)
]
table_container = HSplit([
Label(FormattedText([("class:column-name", header_row)]), ),
HorizontalLine(),
*row_buttons,
])
rules_container = Box(
Label(
self.table.format_constraints(separator="\n\n"),
dont_extend_width=True,
), )
return FloatContainer(
Box(
Frame(
VSplit([
table_container,
VerticalLine(),
rules_container,
])), ),
floats=[],
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.riitag_info = user.RiitagInfo() # placeholder
self.menu_settings_button = Button(
'Settings', handler=lambda: self._set_state('Settings'))
self.menu_exit_button = Button('Exit', handler=self.quit_app)
self.menu_logout_button = Button('Logout', handler=self._logout)
self.settings_back_button = Button(
'Back...', width=12, handler=lambda: self._set_state('Menu'))
self.settings_reset_button = Button('Reset...',
width=12,
handler=self._reset_preferences)
self.settings_pres_timeout_button = PreferenceButton(
value=self.app.preferences.presence_timeout,
increments=10,
limits=(10, 120))
self.settings_check_interval_button = PreferenceButton(
value=self.app.preferences.check_interval,
increments=10,
limits=(10, 60))
self.right_panel_state = 'Menu'
self.menu_layout = Frame(Box(HSplit([
self.menu_settings_button,
Label(''),
self.menu_exit_button,
self.menu_logout_button,
]),
padding_left=3,
padding_top=2),
title='Menu')
self.settings_layout = Frame(Box(HSplit([
Window(FormattedTextControl(
HTML(
'This is where you can modify settings\nregarding the underlying presence\nwatcher.'
)),
wrap_lines=True,
width=25),
Label(''),
VSplit([
Label('Presence Timeout (min.):'),
self.settings_pres_timeout_button
],
width=15),
VSplit([
Label('Refresh Interval (sec.):'),
self.settings_check_interval_button
],
padding=3),
Label(''),
VSplit([self.settings_back_button, self.settings_reset_button],
align=WindowAlign.CENTER)
]),
padding_left=3,
padding_top=2),
title='Settings')
def progress_dialog(
title: AnyFormattedText = "",
text: AnyFormattedText = "",
run_callback: Callable[[Callable[[int], None], Callable[[str], None]], None] = (
lambda *a: None
),
style: Optional[BaseStyle] = None,
) -> Application[None]:
"""
:param run_callback: A function that receives as input a `set_percentage`
function and it does the work.
"""
loop = get_event_loop()
progressbar = ProgressBar()
text_area = TextArea(
focusable=False,
# Prefer this text area as big as possible, to avoid having a window
# that keeps resizing when we add text to it.
height=D(preferred=10 ** 10),
)
dialog = Dialog(
body=HSplit(
[
Box(Label(text=text)),
Box(text_area, padding=D.exact(1)),
progressbar,
]
),
title=title,
with_background=True,
)
app = _create_app(dialog, style)
def set_percentage(value: int) -> None:
progressbar.percentage = int(value)
app.invalidate()
def log_text(text: str) -> None:
loop.call_soon_threadsafe(text_area.buffer.insert_text, text)
app.invalidate()
# Run the callback in the executor. When done, set a return value for the
# UI, so that it quits.
def start() -> None:
try:
run_callback(set_percentage, log_text)
finally:
app.exit()
def pre_run() -> None:
run_in_executor_with_context(start)
app.pre_run_callables.append(pre_run)
return app
def progress_dialog(title='',
text='',
run_callback=None,
style=None,
async_=False):
"""
:param run_callback: A function that receives as input a `set_percentage`
function and it does the work.
"""
assert callable(run_callback)
progressbar = ProgressBar()
text_area = TextArea(
focusable=False,
# Prefer this text area as big as possible, to avoid having a window
# that keeps resizing when we add text to it.
height=D(preferred=10**10))
dialog = Dialog(body=HSplit([
Box(Label(text=text)),
Box(text_area, padding=D.exact(1)),
progressbar,
]),
title=title,
with_background=True)
app = _create_app(dialog, style)
def set_percentage(value):
progressbar.percentage = int(value)
app.invalidate()
def log_text(text):
text_area.buffer.insert_text(text)
app.invalidate()
# Run the callback in the executor. When done, set a return value for the
# UI, so that it quits.
def start():
try:
run_callback(set_percentage, log_text)
finally:
app.exit()
run_in_executor(start)
if async_:
return app.run_async()
else:
return app.run()
def get_root_container(self) -> FloatContainer:
buttons = [
*self._game_buttons.keys(),
HorizontalLine(),
Button("Quit", width=MENU_BUTTON_WIDTH, handler=self._exit),
]
menu_keybindings = _create_menu_keybindings(buttons)
game_buttons_container = Frame(
HSplit(
buttons,
width=Dimension(min=MENU_BUTTON_WIDTH, max=40),
height=Dimension(),
),
title="Games",
key_bindings=menu_keybindings,
)
game_description_container = Frame(
Box(
Label(
text=self._get_game_description,
dont_extend_height=False,
width=Dimension(min=40),
),
padding=0,
padding_left=1,
), )
return FloatContainer(VSplit([
game_buttons_container,
game_description_container,
]),
floats=[])
def __init__(self,
title: str = "DLNest Output",
routineTask=None,
freq: int = 1,
style: str = "class_analyzer_output"):
super(AnalyzeOutput, self).__init__(title, routineTask, freq, style)
self.infoText = FormattedTextControl(
[("", " No analyze task is running ")],
focusable=False,
show_cursor=False)
self.infoWindow = Window(content=self.infoText)
self.infoLabel = Box(
body=self.infoWindow,
height=3,
padding_top=1,
padding_bottom=1,
# padding_left=3,
# padding_right=3,
style="class:analyzer_info_label")
self.window = Frame(HSplit([self.infoLabel, self.shower]),
title=self.title,
style=self.style,
modal=True,
key_bindings=self.kb)
def MenuScreen(controller):
def on_start_click():
new_state = PlayingScreenState(username=controller.state.username,
choice_history=[root_branch],
choice_index=0,
start_time=time())
controller.set_state(new_state)
def on_help_click():
new_state = HelpScreenState(username=controller.state.username,
previous_state=controller.state)
controller.set_state(new_state)
buttons = [
Button('start', handler=on_start_click),
Button('help', handler=on_help_click),
Button('quit', handler=exit_current_app)
]
kb = create_vertical_button_list_kbs(buttons)
body = Box(
VSplit([
HSplit(children=buttons,
padding=Dimension(preferred=1, max=1),
key_bindings=kb)
]))
toolbar_content = Window(content=FormattedTextControl(
'Hello %s. I wish you the best of luck...' %
controller.state.username),
align=WindowAlign.CENTER,
height=1)
return ToolbarFrame(body, toolbar_content)
def process_steps(self):
if self.intro:
layout = Window(
FormattedTextControl(to_formatted_text(HTML(self.intro))),
wrap_lines=True,
)
self.steps.append(
{
'layout': layout,
'label': 'Introduction',
'handler': None,
}, )
for handler in self.handlers:
layout = handler.get_layout()
layout.align = HorizontalAlign.JUSTIFY
self.steps.append(
{
'layout': layout,
'label': handler.get_label(),
'handler': handler,
}, )
if self.summary:
layout = Box(
body=DynamicContainer(self.get_summary),
padding=D(preferred=1, max=1),
padding_bottom=1,
)
self.steps.append(
{
'layout': layout,
'label': 'Summary',
'handler': None,
}, )
def _box(self, body):
return Box(
body=body,
height=Dimension(min=1),
width=Dimension(min=1, weight=4),
padding=1,
)
def PlayingScreen(controller):
current_component = get_current_choice(controller)
component = current_component(controller)
body = component.render()
username = controller.state.username
choice_history = controller.state.choice_history
choice_index = controller.state.choice_index
def on_back_click():
new_state = PlayingScreenState(username=username,
choice_history=choice_history,
choice_index=choice_index - 1,
start_time=controller.state.start_time)
controller.set_state(new_state)
def on_help_click():
new_state = HelpScreenState(username=username,
previous_state=controller.state)
controller.set_state(new_state)
def on_menu_click():
new_state = MenuScreenState(username)
controller.set_state(new_state)
def on_next_click():
new_state = PlayingScreenState(username=username,
choice_history=choice_history,
choice_index=choice_index + 1,
start_time=controller.state.start_time)
controller.set_state(new_state)
buttons = [
Button('help', handler=on_help_click),
Button('menu', handler=on_menu_click),
Button('quit', handler=exit_current_app)
]
if choice_index > 0:
buttons.insert(0, Button('(back)', handler=on_back_click))
if choice_index < len(choice_history) - 1:
buttons.append(Button('(next)', handler=on_next_click))
kb = create_horizontal_button_list_kbs(buttons)
is_button_focused = reduce(lambda a, b: a | b, map(has_focus, buttons))
def reset_focus(_):
component.refocus()
kb.add('down', filter=is_button_focused)(reset_focus)
toolbar_content = Box(VSplit(children=buttons,
align=HorizontalAlign.CENTER,
key_bindings=kb),
height=1)
return ToolbarFrame(body, toolbar_content, put_on_top=True)
def get_questions_widgets(self):
question_widgets = [
Frame(body=Label(text=unicode(self.header))),
]
question_widgets += self.questions.get_widgets_list()
create_button = Button(u"Create", handler=self.accept_create)
exit_button = Button(u"Exit", handler=self.accept_exit)
question_widgets.append(Box(VSplit([create_button, exit_button])))
return question_widgets
def creationLayoutFactory(self):
root_container = Box(
Frame(
TextArea(
text="CREATION layout placeholder",
width=40,
height=10,
)), )
return Layout(container=root_container)
def editingLayoutFactory(self): #TODO
root_container = Box(
Frame(
TextArea(
text="EDITING layout placeholder",
width=40,
height=10,
)), )
return Layout(container=root_container)
def removingLayoutFactory(self): #TODO
root_container = Box(
Frame(
TextArea(
text="DELETE layout placeholder",
width=40,
height=10,
)), )
return Layout(container=root_container)
def render(self):
current_time = time()
time_played = current_time - self._controller.state.start_time
return Box(TextArea(
text=self._label.format(name=self._controller.state.username) +
'\n\nTime Played:\n' + format_time(time_played) + '\n',
read_only=True,
focusable=False,
scrollbar=True),
padding=1)
def _get_grid_container(pattern_grid: PatternGrid):
"""Get a container for a given pattern grid."""
return Frame(
Box(
Label(
text=pattern_grid.format_grid,
dont_extend_width=True,
),
padding_left=1,
padding_right=1,
), )
def get_layout(self):
game_labels = []
for game in self.riitag_info.games:
if not game:
continue
console_and_game_id = game.split('-')
if len(console_and_game_id) == 2:
console: str = console_and_game_id[0]
game_id: str = console_and_game_id[1]
label_text = f'<b>-</b> {game_id} ({console.title()})'
else:
label_text = f'<b>-</b> {console_and_game_id[0]}'
game_labels.append(Label(HTML(label_text)))
right_panel_layout = HSplit([])
if self.right_panel_state == 'Menu':
right_panel_layout = self.menu_layout
elif self.right_panel_state == 'Settings':
right_panel_layout = self.settings_layout
return HSplit([
Box(
Label(text='Use the arrow keys and enter to navigate.'),
height=3,
padding_left=2
),
VSplit([
Frame(
Box(
HSplit([
Label(HTML(f'<b>Name:</b> {self.riitag_info.name}')),
Label(HTML(f'<b>Games:</b> {len(game_labels)}')),
*game_labels
]), padding_left=3, padding_top=2
), title='RiiTag'),
right_panel_layout
])
])
def get_root_container(self) -> FloatContainer:
tree_lines = self.tree.format_tree(hide_values=True).splitlines()
self.node_inputs = [
TextArea(wrap_lines=False,
style="class:tree-node",
width=NODE_INPUT_WIDTH) for _ in self.tree.descendants
]
tree_labels = [
Label(line, dont_extend_width=True) for line in tree_lines
]
tree_input_container = Frame(
HSplit([
VSplit([label, button])
for label, button in zip(tree_labels, self.node_inputs)
]),
title="Tree",
)
buttons = [
Button("Done", handler=self.handle_input_confirm),
]
button_container = Box(VSplit(buttons, padding=4), padding_top=1)
tree_panel_container = Box(
HSplit([
tree_input_container,
button_container,
]))
table_container = Label(self.closure_table.format_table())
root_container = FloatContainer(
VSplit([tree_panel_container, table_container]),
floats=[],
)
return root_container
def _create_ui(self):
btn_start = Button("Start", handler=self.tomato.start)
btn_pause = Button("Pause", handler=self.tomato.pause)
btn_reset = Button("Reset", handler=self.tomato.reset)
btn_reset_all = Button("Reset All", handler=self.tomato.reset_all)
btn_exit = Button("Exit", handler=self._exit_clicked)
# All the widgets for the UI.
self.text_area = FormattedTextControl(focusable=False,
show_cursor=False)
text_window = Window(
content=self.text_area,
dont_extend_height=True,
height=11,
style="bg:#ffffff #000000",
)
root_container = Box(
HSplit([
Label(text="Press `Tab` to move the focus."),
HSplit([
VSplit(
[
btn_start,
btn_pause,
btn_reset,
btn_reset_all,
btn_exit,
],
padding=1,
style="bg:#cccccc",
),
text_window,
]),
]))
layout = Layout(container=root_container, focused_element=btn_start)
self._set_key_bindings()
# Styling.
style = Style([
("left-pane", "bg:#888800 #000000"),
("right-pane", "bg:#00aa00 #000000"),
("button", "#000000"),
("button-arrow", "#000000"),
("button focused", "bg:#ff0000"),
("red", "#ff0000"),
("green", "#00ff00"),
])
self.application = Application(layout=layout,
key_bindings=self.kb,
style=style,
full_screen=True)
def HelpScreen(controller):
body = Box(TextArea(help_text, focusable=False, scrollbar=True),
padding=0,
padding_left=1,
padding_right=1)
def on_back_click():
new_state = controller.state.previous_state
controller.set_state(new_state)
buttons = [
Button('back', handler=on_back_click),
Button('quit', handler=exit_current_app)
]
kb = create_horizontal_button_list_kbs(buttons)
toolbar_content = Box(VSplit(children=buttons,
align=HorizontalAlign.CENTER,
padding=Dimension(preferred=10, max=10),
key_bindings=kb),
height=1)
return ToolbarFrame(body, toolbar_content)
def create_app(listen_handler, home):
# components
logo = Label(text=LOGO)
text_area = TextArea(text=str(home), read_only=True, scrollbar=True)
listen_btn = Button('Listen', handler=listen_handler(text_area=text_area))
help_btn = Button('Help', handler=help_handler)
exit_btn = Button('Exit', handler=lambda: get_app().exit())
buttons = HSplit(children=[
Label(text=' MENU'),
Frame(listen_btn),
Frame(help_btn),
Frame(exit_btn)
],
style='bg:#00aa00 #000000')
# root container
root_container = FloatContainer(HSplit([
Box(body=VSplit([buttons, logo], padding=12),
padding=0,
style='bg:#888800 #000000'),
text_area,
]),
floats=[])
# key bindings
bindings = KeyBindings()
bindings.add('tab')(focus_next)
bindings.add('s-tab')(focus_previous)
@bindings.add('c-c')
@bindings.add('q')
def _(event):
event.app.exit()
# application
application = Application(layout=Layout(root_container,
focused_element=listen_btn),
key_bindings=bindings,
enable_page_navigation_bindings=True,
mouse_support=True,
full_screen=True)
return application
def render(self):
choices_len = len(self._choices)
buttons = [
Button('[%s] %s' % (i, label) if choices_len > 1 else label,
handler=self._create_handler(sub_component))
for ((label, sub_component),
i) in zip(self._choices, range(
1, choices_len +
1)) # this is still a loop even if it is inline..
]
self._first_button = buttons[0]
global global__default_target_focus
global__default_target_focus = self._first_button
kb = create_vertical_button_list_kbs(buttons)
is_first_selected = has_focus(buttons[0])
kb.add('up', filter=is_first_selected)(lambda e: focus_first_element())
return Box(
HSplit(
[
TextArea(
text=self._label.format(
name=self._controller.state.username) + '\n',
read_only=True,
focusable=False,
scrollbar=True,
# push buttons to bottom of screen
height=Dimension(preferred=100000, max=100000)),
HSplit([
VSplit(children=[button], align=HorizontalAlign.CENTER)
for button in buttons
],
padding=1,
key_bindings=kb)
],
padding=Dimension(preferred=2, max=2),
width=Dimension(),
align=VerticalAlign.TOP),
padding=1)
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 refresh(self, sort_by=None, order=None):
names = update_servers(sort_by=sort_by, order=order)
self.server_list = []
for name in names:
button_obj = ButtonManager(name)
button = CustomButton(name, handler=button_obj.click_handler)
self.server_list.append(button)
# If there are no servers
if not self.server_list:
from prompt_toolkit.layout.containers import Window
from prompt_toolkit.layout.controls import FormattedTextControl
window = Window(
FormattedTextControl(
'No Servers',
focusable=True,
show_cursor=False
)
)
self.server_list.append(window)
self.hsplit = HSplit(self.server_list)
boxes = Box(
width=SERVER_WIDTH,
padding_top=0,
padding_left=1,
body=self.hsplit
)
from freud.key_bindings import server_kb
self.content = HSplit([
boxes
], key_bindings=server_kb)
return self.content
def create_container(self):
container = HSplit([
Box(body=VSplit([self.input_window, self.cancel_button],
padding=1),
padding=1,
style="class:preview-input-field"),
Window(height=1, char="-", style="class:preview-divider-line"),
self.output_field,
self.search_field,
])
frame = Shadow(body=Frame(
title=lambda: "Preview: " + self.my_app.selected_object.name,
body=container,
style="class:dialog.body",
width=D(preferred=180, min=30),
modal=True))
return ConditionalContainer(content=frame,
filter=ShowPreview(self.my_app) & ~is_done)
def get_layout(self):
widget = self.get_widget()
vsplit_components = [widget]
if 'message' in self._question and self._question['message']:
vsplit_components.insert(
0,
Label(
self._question['message'],
dont_extend_width=True,
dont_extend_height=False,
style='class:selectone.question',
),
)
btn_all = Button('All', widget.select_all)
btn_none = Button('None', widget.select_none)
buttons = Box(
body=VSplit([btn_all, btn_none], padding=1),
height=D(min=1, max=3, preferred=3),
padding_left=0,
)
hsplit_components = [buttons, VSplit(vsplit_components, padding=1)]
if 'description' in self._question and self._question['description']:
hsplit_components.insert(
0,
Window(
FormattedTextControl(
FormattedText([(
'class:selectone.question',
self._question['description'],
)]), ),
wrap_lines=True,
height=D(min=1, max=5, preferred=3),
),
)
return HSplit(hsplit_components, padding=1)
def generate_layout(input_field: TextArea,
output_field: TextArea,
log_field: TextArea,
right_pane_toggle: Button,
log_field_button: Button,
search_field: SearchToolbar,
timer: TextArea,
process_monitor: TextArea,
trade_monitor: TextArea,
command_tabs: Dict[str, CommandTab],
):
components = {}
components["item_top_version"] = Window(FormattedTextControl(get_version), style="class:header")
components["item_top_active"] = Window(FormattedTextControl(get_active_strategy), style="class:header")
components["item_top_file"] = Window(FormattedTextControl(get_strategy_file), style="class:header")
components["item_top_gateway"] = Window(FormattedTextControl(get_gateway_status), style="class:header")
components["item_top_toggle"] = right_pane_toggle
components["pane_top"] = VSplit([components["item_top_version"],
components["item_top_active"],
components["item_top_file"],
components["item_top_gateway"],
components["item_top_toggle"]], height=1)
components["pane_bottom"] = VSplit([trade_monitor,
process_monitor,
timer], height=1)
output_pane = Box(body=output_field, padding=0, padding_left=2, style="class:output-field")
input_pane = Box(body=input_field, padding=0, padding_left=2, padding_top=1, style="class:input-field")
components["pane_left"] = HSplit([output_pane, input_pane], width=Dimension(weight=1))
if all(not t.is_selected for t in command_tabs.values()):
log_field_button.window.style = "class:tab_button.focused"
else:
log_field_button.window.style = "class:tab_button"
tab_buttons = [log_field_button]
for tab in sorted(command_tabs.values(), key=lambda x: x.tab_index):
if tab.button is not None:
if tab.is_selected:
tab.button.window.style = "class:tab_button.focused"
else:
tab.button.window.style = "class:tab_button"
tab.close_button.window.style = tab.button.window.style
tab_buttons.append(VSplit([tab.button, tab.close_button]))
pane_right_field = log_field
focused_right_field = [tab.output_field for tab in command_tabs.values() if tab.is_selected]
if focused_right_field:
pane_right_field = focused_right_field[0]
components["pane_right_top"] = VSplit(tab_buttons, height=1, style="class:log-field", padding_char=" ", padding=2)
components["pane_right"] = ConditionalContainer(
Box(body=HSplit([components["pane_right_top"], pane_right_field, search_field], width=Dimension(weight=1)),
padding=0, padding_left=2, style="class:log-field"),
filter=True
)
components["hint_menus"] = [Float(xcursor=True,
ycursor=True,
transparent=True,
content=CompletionsMenu(max_height=16,
scroll_offset=1))]
root_container = HSplit([
components["pane_top"],
VSplit(
[FloatContainer(components["pane_left"], components["hint_menus"]),
components["pane_right"]]),
components["pane_bottom"],
])
return Layout(root_container, focused_element=input_field), components
textfield,
], height=D()),
VSplit([
Frame(body=ProgressBar(),
title='Progress bar'),
Frame(title='Checkbox list',
body=HSplit([
checkbox1,
checkbox2,
])),
Frame(title='Radio list', body=radios),
], padding=1),
Box(
body=VSplit([
yes_button,
no_button,
], align='CENTER', padding=3),
style='class:button-bar',
height=3,
),
])
root_container = MenuContainer(body=root_container, menu_items=[
MenuItem('File', children=[
MenuItem('New'),
MenuItem('Open', children=[
MenuItem('From file...'),
MenuItem('From URL...'),
MenuItem('Something else..', children=[
MenuItem('A'),
MenuItem('B'),
MenuItem('C'),
