def __init__(self,
app=None,
show=True,
height=Dimension(preferred=60),
width=Dimension(preferred=1)): #80?
self.app = app
self.show = show
self.basename = None
self.filename = None
self.current_line = -1
self.handle_source_change = False
self.lexer = None
self.buffer = Buffer(document=Document(),
multiline=True) # TODO: Intelligent readonly lambda
self.control = BufferControl(self.buffer,
focusable=True,
lexer=DynamicLexer(lambda: self.lexer),
focus_on_click=True)
self.window = Window(content=self.control,
height=height,
width=width,
wrap_lines=False,
left_margins=[NumberedMargin()],
scroll_offsets = ScrollOffsets(top=5, bottom=40),
get_line_prefix=self._get_line_prefix)
self.info = InfoLine(text='', width=240)
self.container = ConditionalContainer(
content=HSplit([self.info.get_ui(),
self.window]),
filter=Condition(lambda: self.show))
def _box(self, body):
return Box(
body=body,
height=Dimension(min=1),
width=Dimension(min=1, weight=4),
padding=1,
)
def __init__(self):
self.lira = LiraApp()
self.lira.setup()
self.content = ContentArea(self)
self.status = StatusBar(self)
self.menu = SidebarMenu(self)
self.menu.reset(BooksList(self))
self.container = HSplit(
[
VSplit(
[
self.menu,
self.content,
],
padding=Dimension.exact(1),
padding_char="│",
padding_style=theme["separator"],
),
self.status,
],
padding=Dimension.exact(1),
padding_char="─",
padding_style=theme["separator"],
)
self.app = Application(
layout=Layout(self.container),
key_bindings=self.get_key_bindings(),
mouse_support=True,
full_screen=True,
style=style,
after_render=self._ready,
)
def __init__(self, tui):
self.tui = tui
self.lira = self.tui.lira
self.container = List(
title=self._get_title(),
elements=self._get_elements(),
get_bullet=self._get_bullet,
allow_select=self.allow_select,
width=Dimension(min=1),
height=Dimension(min=1),
)
def __init__(
self,
state,
):
self.state = state
self.kb = KeyBindings()
# layout components
self.header_bar = FormattedTextControl(focusable=False, )
self.input_buffer = Buffer(multiline=False, )
self.input_buffer.on_text_changed += self.update_results
self.results_control = SelectableList(text="")
self.preview_bar = FormattedTextControl(focusable=False, )
self.preview_buffer = BufferControl(
input_processors=[TabsProcessor(tabstop=4, char1="", char2="")],
focusable=False,
)
self.status_bar = FormattedTextControl()
self.layout = Layout(
HSplit([
Window(self.header_bar, height=1, style="reverse"),
Window(
BufferControl(self.input_buffer),
height=1,
),
Window(self.results_control,
height=Dimension(**RESULTS_DIMENSION_DICT)),
Window(self.preview_bar, height=1, style="reverse"),
Window(
self.preview_buffer,
wrap_lines=True,
height=Dimension(**PREVIEW_DIMENSION_DICT),
),
Window(self.status_bar, height=1, style="reverse"),
]), )
self.reset_view()
@self.kb.add("up")
def _(event):
self.results_control.index -= 1
self.update_preview()
@self.kb.add("down")
def _(event):
self.results_control.index += 1
self.update_preview()
@self.kb.add("enter")
def _(event):
self.select_collection()
self.reset_view()
def main():
# Create a big layout of many text areas, then wrap them in a `ScrollablePane`.
root_container = Frame(
ScrollablePane(
HSplit([
Frame(TextArea(text=f"label-{i}"), width=Dimension())
for i in range(20)
]))
# ScrollablePane(HSplit([TextArea(text=f"label-{i}") for i in range(20)]))
)
layout = Layout(container=root_container)
# Key bindings.
kb = KeyBindings()
@kb.add("c-c")
def exit(event) -> None:
get_app().exit()
kb.add("tab")(focus_next)
kb.add("s-tab")(focus_previous)
# Create and run application.
application = Application(layout=layout, key_bindings=kb, full_screen=True)
application.run()
def preferred_width(self, max_available_width: int) -> Dimension:
_min = 40
preferred = 80
if max_available_width / 2 >= 80:
preferred = max_available_width / 2
return Dimension(min=_min, preferred=preferred)
def __init__(self, app=None, show=False, height=Dimension(preferred=5)):
self.lexer = ThreadsLexer()
scroll_offsets = ScrollOffsets(top=5, bottom=5)
super(ThreadsWindow, self).__init__(app=app,
show=show,
title='[ Threads ]',
scroll_offsets=scroll_offsets)
def get_user_comment(self):
"""Modifies the display to add an area to enter a comment for a command
Creates a BufferControl in a Frame and replaces the toolbar with the Frame
#bug: the new toolbar is unable to get focus right away; it requires the user to click
in the area
"""
self._savedLayout = self.layout
self.disabled_bindings = True
commentControl = BufferControl(
Buffer(accept_handler=self._set_user_comment), focus_on_click=True)
user_in_area = Frame(
Window(
commentControl,
height=Dimension(max=1, weight=10000),
dont_extend_height=True,
),
title="Enter Comment (alt-Enter to submit)",
)
self.toolbar = user_in_area
self.main_view = HSplit([self.body, self.toolbar], padding_char="-")
self.layout = Layout(self.main_view, focused_element=user_in_area.body)
self.layout.focus(user_in_area.body)
self.invalidate()
def __init__(self,
app=None,
show=False,
title='[ A Window ]',
show_divider=lambda:True,
get_lexer=lambda: None,
height=Dimension(preferred=1),
wrap_lines=False,
scroll_offsets=ScrollOffsets()):
self.app = app
self.show = show
self.buffer = Buffer(document=Document(),
multiline=True)
self.control = BufferControl(buffer=self.buffer,
focusable=True,
lexer=self.lexer,
focus_on_click=True)
self.window = PromptWindow(content=self.control,
height=height,
wrap_lines=wrap_lines,
scroll_offsets=scroll_offsets)
self.divider = Divider(self, show=show_divider)
self.info = InfoLine(title, width=240)
self.container = ConditionalContainer(
content=VSplit([
self.divider.get_ui(),
HSplit([self.info.get_ui(), self.window])]),
filter=Condition(lambda: self.show))
def __init__(self, app=None, show=False, height=Dimension(preferred=20)):
self.frame = None
self.lexer = CallstackLexer()
scroll_offsets = ScrollOffsets(top=5, bottom=5)
super(CallstackWindow, self).__init__(app=app,
show=show,
title='[ Callstack ]',
scroll_offsets=scroll_offsets)
def __init__(self, tui):
super().__init__(tui)
self.list = DynamicContainer(self.get_container)
self.back_button = ConditionalContainer(
Button("Back", handler=self.pop),
filter=Condition(lambda: len(self.pages) > 1),
)
self.exit_button = Button("Exit", handler=exit_app)
self.container = HSplit(
[
self.list,
self.back_button,
self.exit_button,
],
height=Dimension(min=1),
width=Dimension(min=1),
key_bindings=self.get_key_bindings(),
)
def _get_status_area(self, status=""):
return TextArea(
text=status,
height=Dimension.exact(1),
prompt=">>> ",
multiline=False,
wrap_lines=False,
focusable=False,
read_only=True,
)
def __init__(self, app=None, show=False, height=Dimension(preferred=5)):
self.lexer = BreakpointsLexer()
self.breakpoints = {}
self.changed = {}
self.database = {}
self.hits = {}
scroll_offsets = ScrollOffsets(top=2, bottom=2)
super(BreakpointsWindow, self).__init__(app=app,
show=show,
title='[ Breakpoints ]',
scroll_offsets=scroll_offsets)
def __init__(self, lexer_name='yaml'):
self.buf = Buffer()
self.buf.text = ''
self.lexer = PygmentsLexer(find_lexer_class_by_name(lexer_name))
self.window = HSplit([
HorizontalLine(),
Window(content=BufferControl(buffer=self.buf, lexer=self.lexer))
],
height=Dimension(min=5, max=20, weight=1))
super(InfoWindow, self).__init__(content=self.window,
filter=has_focus(self))
def get_layout(entry_point, top_menu_items):
set_current_sidebar(entry_point)
menu = DynamicContainer(get_current_sidebar)
# windows that are focused by pressing tab keys.
main_focus = [menu, _output_window]
following = get_following(main_focus)
def next_main_window(event):
next_idx = following(1)
event.app.layout.focus(main_focus[next_idx])
def previous_main_window(event):
next_idx = following(-1)
event.app.layout.focus(main_focus[next_idx])
key_binding = KeyBindings()
kb.add("tab")(next_main_window)
kb.add("s-tab")(previous_main_window)
root_container = HSplit([
VSplit(
[menu, Window(width=1, char="|"), _output_window],
height=Dimension(),
),
Window(
content=status_bar,
width=Dimension(),
height=1,
style="class:status_bar",
),
])
if top_menu_items:
root_container = MenuContainer(body=root_container,
menu_items=top_menu_items)
main_focus.append(root_container.window)
layout = Layout(root_container, focused_element=entry_point)
return layout
def __init__(self,
app,
height=Dimension(preferred=20),
width=Dimension(preferred=20),
callback=None):
self.app = app
gdb = self._get_gdb_path()
self._create_pipes()
self._update_pythonpath()
gdbw_dir = self._get_gdbw_dir()
source_cmd = 'source %s/gdbwhelper.py' % (gdbw_dir)
gdb_run_cmd = [gdb, '-iex', source_cmd] + argv[1:]
self.console = Terminal(gdb_run_cmd,
done_callback=self._done,
height=height,
width=width)
self.info = InfoLine(text='', width=240)
self.window = HSplit([self.info.get_ui(), self.console])
self.update_info()
self.in_pipe.begin_reading(callback)
def __init__(self,
app=None,
show=False,
height=Dimension(preferred=22),
width=Dimension(preferred=25)):
self.app = app
self.show = show
self.cursor_line = 0
self.lexer = DisassemblyLexer(self)
self.buffer = Buffer(document=Document(),
multiline=True)
self.control = BufferControl(buffer=self.buffer,
focusable=True,
lexer=self.lexer,
focus_on_click=True)
self.window = Window(content=self.control,
height=height,
wrap_lines=False,
scroll_offsets = ScrollOffsets(top=0))
self.info = InfoLine('[Disassembly]', width=240)
self.container = ConditionalContainer(
content=HSplit([self.info.get_ui(), self.window]),
filter=Condition(lambda: self.show))
def __init__(self,
app=None,
show=False,
title='[Line Items]',
show_divider=lambda: True,
height=Dimension(preferred=1)):
self.lexer = LineItemsLexer(self)
self.lines = []
self.changed = []
super(LineItemsWindow, self).__init__(app=app,
show=show,
title=title,
show_divider=show_divider,
height=height)
def __init__(self, playback, save_location=None, *args, **kwargs):
self.mainViewCondition = partial(self.mainView, self)
self.mainViewCondition = Condition(self.mainViewCondition)
self.disabled_bindings = False
bindings = KeyBindings()
self.init_bindings(bindings)
super().__init__(full_screen=True,
key_bindings=bindings,
mouse_support=True,
*args,
**kwargs)
self.displayingHelpScreen = (
False) # used to toggle between help screen on normal
if save_location:
self.save_location = save_location
else:
self.save_location = SAVE_LOCATION
self.playback = playback
self._savedLayout = Layout(Window())
self.command_cache = deque([], maxlen=5)
##########################################
### Setting up views
##########################################
self.old_command_window = FormattedTextControl(text="Output goes here",
focusable=True)
self.new_command_window = FormattedTextControl(text="Output goes here",
focusable=True)
self.body = Frame(
HSplit([
Frame(Window(self.old_command_window)),
Frame(Window(self.new_command_window)),
]))
self.toolbar = Window(
FormattedTextControl(text=self.toolbar_text),
height=Dimension(max=1, weight=10000),
dont_extend_height=True,
)
self.main_view = HSplit([self.body, self.toolbar], padding_char="-")
self.layout = Layout(self.main_view)
def __init__(self, app=None, show=False, height=Dimension(preferred=20)):
self.frame = None
self.app = app
self.show = show
self.args = LineItemsWindow(app=app,
show=show,
title='[ Arguments ]',
show_divider=self._show_divider)
self.locals = LineItemsWindow(app=app,
show=show,
title='[ Locals ]',
show_divider=self._show_divider)
self.container = ConditionalContainer(
content=HSplit([self.args.get_ui(),
self.locals.get_ui()]),
filter=Condition(lambda: self.show))
def get_buffer_window(buffer,
height=20,
lexer_name="",
style="fg:black bg:ansiwhite"):
"""Generate a editable text window for pager in terminal
:param buffer: Buffer object storing the text
:type buffer: str
:param lexer_name: If the editable text should be highlighted with
some kind of grammar, examples are ``yaml``, ``python`` ...
:type lexer_name: str
:param height: Max height of the text area
:type height: int
:param style: Color setting of backgorund and foreground
:type style: str
:return: Container with window information
:rtype : prompt_toolkit.layout.containers.Window
"""
import prompt_toolkit.layout.containers
import prompt_toolkit.layout.controls
from prompt_toolkit.layout import Dimension
from prompt_toolkit.lexers import PygmentsLexer
from pygments.lexers import find_lexer_class_by_name
return prompt_toolkit.layout.containers.Window(
height=None if not height else Dimension(min=0, max=height),
width=None,
style=style,
always_hide_cursor=False,
content=prompt_toolkit.layout.controls.BufferControl(
buffer=buffer,
lexer=PygmentsLexer(find_lexer_class_by_name(lexer_name))))
def __init__(self):
# styling
style = Style.from_dict({
'completion-menu.completion': 'bg:#008888 #ffffff',
'completion-menu.completion.current': 'bg:#00aaaa #000000',
'scrollbar.background': 'bg:#88aaaa',
'scrollbar.button': 'bg:#222222',
'input-field': '#004400',
'buffer': '#ff0066',
})
# create input fields
self.source_field = make_text_area('[Source folder]: ')
self.target_field = make_text_area('[Target folder]: ')
self.dry_field = make_text_area('[{:13}]: '.format("Dry? (y/n)"))
# get completers
initialize_database()
con = db_connect()
self.source_field.completer = FuzzyCompleter(
WordCompleter(get_source_paths(con), ignore_case=True))
self.target_field.completer = FuzzyCompleter(
WordCompleter(get_target_paths(con), ignore_case=True))
self.dry_field.completer = WordCompleter(
['Yes', 'No', 'True', 'False', 'yes', 'no'], ignore_case=True)
# bottom toolbar
def bottom_toolbar_call():
s1 = '<b><style bg="ansired">C-H</style></b>: history mode.'
s2 = '<b><style bg="ansired">C-C/C-Q</style></b>: exit app.'
s3 = '<b><style bg="ansired">C-O</style></b>: ordered paths.'
s4 = '<b><style bg="ansired">C-R</style></b>: reverse paths.'
return HTML(" ".join([s1, s2, s3, s4]))
self.bottom_toolbar = ConditionalContainer(
Window(FormattedTextControl(lambda: bottom_toolbar_call,
style='class:bottom-toolbar.text'),
style='class:bottom-toolbar',
dont_extend_height=True,
height=Dimension(min=1)),
filter=(~is_done & renderer_height_is_known
& Condition(lambda: bottom_toolbar_call is not None)))
# create app body
self.body = FloatContainer(content=HSplit(children=[
self.source_field, self.target_field, self.dry_field,
self.bottom_toolbar
],
height=8),
floats=[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=12,
scroll_offset=1))
])
# define internal logic
def execute_command(buff):
"""Send command to subprocess dealing with dry argument recursively"""
dry = False if buff.text.lower() in ['n', 'no', 'false'] else True
dry_flag = 'DRY' if dry else 'NOT DRY'
dry_string = 'n' if dry else ''
command = "rsync -avucP{} {} {}".format(dry_string,
self.source_field.text,
self.target_field.text)
def run_script():
subprocess.call(command, shell=True)
def print_info():
print_formatted_text(
HTML('<ansired>{} </ansired>'.format(dry_flag)))
print_formatted_text(
HTML('<ansired>{} </ansired>'.format(
'You entered: {}'.format(command))))
print_formatted_text(
HTML('<ansired>{} </ansired>'.format('Running...')))
run_in_terminal(print_info)
if dry:
run_in_terminal(run_script)
return
else:
con = db_connect()
create_rsync_record(con, self.source_field.text,
self.target_field.text)
run_in_terminal(run_script)
app = get_app()
app.exit()
return
self.dry_field.buffer.accept_handler = execute_command
# Key bindings
self.kb = KeyBindings()
@self.kb.add('c-q')
@self.kb.add('c-c')
def _(event):
" Quit application. "
event.app.exit()
#kb.add('enter')(focus_next)
self.kb.add('tab')(focus_next)
self.kb.add('s-tab')(focus_previous)
# The `Application`
self.app = Application(
layout=Layout(self.body),
#style=style,
key_bindings=self.kb,
full_screen=False,
mouse_support=True)
def __init__(self, item, w_min=None, w_max=None, w_pre=None, w_weight=None, h_min=None, h_max=None, h_pre=None, h_weight=None):
super().__init__()
self.item = to_container(item)
self.width = Dimension(min=w_min, max=w_max, preferred=w_pre, weight=w_weight)
self.height = Dimension(min=h_min, max=h_max, preferred=h_pre, weight=h_weight)
def __init__(self, app=None, show=False, height=Dimension(preferred=22)):
super(RegistersWindow, self).__init__(app=app,
show=show,
height=height,
title='[ Registers ]',
show_divider=self._show_divider)
def _get_default_buffer_control_height(self) -> Dimension:
dim = super()._get_default_buffer_control_height()
# When there's no complete this line, don't reverse space for the autocompletion menu
if not self.has_complete_this_line and self.default_buffer.complete_state is None:
dim = Dimension()
return dim
style="class:file-viewer",
ignore_content_height=True,
cursorline=True,
dont_extend_height=True,
left_margins=[NumberedMargin()],
scroll_offsets=ScrollOffsets(top=10, bottom=10))
output_buffer = Buffer(document=Document(output, 0))
output_buffer_control = BufferControl(
buffer=output_buffer, input_processors=[AddStyleToDiff("bg:#222222")])
output_window = Window(content=output_buffer_control,
style="class:file-viewer",
ignore_content_height=True,
cursorline=True,
dont_extend_height=True,
height=Dimension(weight=1),
left_margins=[NumberedMargin()],
scroll_offsets=ScrollOffsets(top=10, bottom=10))
hotkeys = {
'<': 'pick left line',
'>': 'pick right line',
'C-up': None,
'C-down': 'go to output',
'C-q': 'quit',
'C-s': 'accept changes',
}
# The output titlebar: a vertical line in the middle.
output_titlebar = Window(content=FormattedTextControl(text=''),
height=1,
def text_area(title, text, lexer_name="", height=10, full_screen=False):
"""
Small implementation of an editor/pager for small pieces of text.
:param title: Title of the text_area
:type title: str
:param text: Editable text
:type text: str
:param lexer_name: If the editable text should be highlighted with
some kind of grammar, examples are ``yaml``, ``python`` ...
:type lexer_name: str
:param height: Max height of the text area
:type height: int
:param full_screen: Wether or not the text area should be full screen.
:type full_screen: bool
"""
from prompt_toolkit import Application
from prompt_toolkit.enums import EditingMode
from prompt_toolkit.buffer import Buffer
from prompt_toolkit.layout.containers import HSplit, Window, WindowAlign
from prompt_toolkit.layout.controls import (BufferControl,
FormattedTextControl)
from prompt_toolkit.layout.layout import Layout
from prompt_toolkit.layout import Dimension
from prompt_toolkit.key_binding import KeyBindings
from prompt_toolkit.lexers import PygmentsLexer
from pygments.lexers import find_lexer_class_by_name
assert (type(title) == str)
assert (type(text) == str)
assert (type(lexer_name) == str)
assert (type(height) == int)
assert (type(full_screen) == bool)
kb = KeyBindings()
buffer1 = Buffer()
buffer1.text = text
@kb.add('c-q')
def exit_(event):
event.app.exit(0)
@kb.add('c-s')
def save_(event):
event.app.return_text = buffer1.text
class App(Application):
return_text = None
text_height = Dimension(min=0, max=height) if height is not None else None
pygment_lexer = find_lexer_class_by_name(lexer_name)
lexer = PygmentsLexer(pygment_lexer)
text_window = Window(height=text_height,
content=BufferControl(buffer=buffer1, lexer=lexer))
root_container = HSplit([
Window(char='-',
align=WindowAlign.CENTER,
height=1,
content=FormattedTextControl(text=[('fg:ansiblack bg:ansiwhite',
title)]),
always_hide_cursor=True),
text_window,
Window(height=1,
width=None,
align=WindowAlign.CENTER,
char='-',
content=FormattedTextControl(
text=[('fg:ansiblack bg:ansiwhite',
"Quit [Ctrl-q] Save [Ctrl-s]")])),
])
layout = Layout(root_container)
layout.focus(text_window)
app = App(editing_mode=(EditingMode.EMACS if papis.config.get(
'editmode', section='tui') == 'emacs' else EditingMode.VI),
layout=layout,
key_bindings=kb,
full_screen=full_screen)
app.run()
return app.return_text
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
def fit_to_height(self):
d = self.buffer.document
l = len(d.lines)
self.window.height = Dimension(preferred=l)
