def _create_application(self):
"""
Create an `Application` instance.
"""
return Application(
input=self.input,
output=self.output,
layout=self.ptpython_layout.layout,
key_bindings=merge_key_bindings([
load_python_bindings(self),
load_auto_suggest_bindings(),
load_sidebar_bindings(self),
load_confirm_exit_bindings(self),
# Extra key bindings should not be active when the sidebar is visible.
ConditionalKeyBindings(
self.extra_key_bindings,
Condition(lambda: not self.show_sidebar))
]),
color_depth=lambda: self.color_depth,
paste_mode=Condition(lambda: self.paste_mode),
mouse_support=Condition(lambda: self.enable_mouse_support),
style=DynamicStyle(lambda: self._current_style),
style_transformation=self.style_transformation,
include_default_pygments_style=False,
reverse_vi_search_direction=True)
def _create_application(self, color_depth):
"""
Create an `Application` instance.
"""
return Application(
input=self.input,
output=self.output,
layout=create_layout(
self,
lexer=DynamicLexer(
lambda: self._lexer
if self.enable_syntax_highlighting else SimpleLexer()),
input_buffer_height=self._input_buffer_height,
extra_buffer_processors=self._extra_buffer_processors,
extra_body=self._extra_layout_body,
extra_toolbars=self._extra_toolbars),
key_bindings=merge_key_bindings([
load_python_bindings(self),
load_sidebar_bindings(self),
load_confirm_exit_bindings(self),
# Extra key bindings should not be active when the sidebar is visible.
ConditionalKeyBindings(
self.extra_key_bindings,
Condition(lambda: not self.show_sidebar))
]),
color_depth=color_depth,
paste_mode=Condition(lambda: self.paste_mode),
mouse_support=Condition(lambda: self.enable_mouse_support),
style=DynamicStyle(lambda: self._current_style),
include_default_pygments_style=False,
reverse_vi_search_direction=True)
def _create_application(self):
"""
Create an `Application` instance.
"""
return Application(
input=self.input,
output=self.output,
layout=self.ptpython_layout.layout,
key_bindings=merge_key_bindings([
load_python_bindings(self),
load_auto_suggest_bindings(),
load_sidebar_bindings(self),
load_confirm_exit_bindings(self),
ConditionalKeyBindings(
load_open_in_editor_bindings(),
Condition(lambda: self.enable_open_in_editor)),
# Extra key bindings should not be active when the sidebar is visible.
ConditionalKeyBindings(
self.extra_key_bindings,
Condition(lambda: not self.show_sidebar))
]),
color_depth=lambda: self.color_depth,
paste_mode=Condition(lambda: self.paste_mode),
mouse_support=Condition(lambda: self.enable_mouse_support),
style=DynamicStyle(lambda: self._current_style),
style_transformation=self.style_transformation,
include_default_pygments_style=False,
reverse_vi_search_direction=True)
def __init__(self):
collections = {
coll_id: Collection.load(coll_id)
for coll_id in Collection.registered_collections()
}
if collections:
active_collection = collections[list(collections.keys())[0]]
else:
active_collection = Collection.new(collection_id="temp_colleciton",
doc_types=list(
DOCTYPES.values()))
self.global_kb = return_global_keybindings(self)
# global state dict that objects (e.g. screens) register themselves to and can access.
self.state = {
"app": Application(full_screen=True),
"collections": collections,
"active_collection": active_collection,
"views": {},
}
# add screens; self.state must exist before adding but all objects share state ref.
self.state["views"]["search"] = SearchView(state=self.state)
self.state["views"]["collections"] = CollectionsView(state=self.state)
self.state["active_view"] = self.state["views"]["search"]
self.state["app"].layout = self.state["active_view"].layout
self.state["app"].key_bindings = merge_key_bindings(
[self.global_kb, self.state["active_view"].kb])
def key_bindings(self):
kb = KeyBindings()
@kb.add("c-c")
@kb.add("c-q")
def terminate(event):
event.app.exit(None)
return merge_key_bindings([self.container.key_bindings, kb])
def __init__(self,
options,
default_index=0,
header_filter=lambda x: x,
match_filter=lambda x: x):
self.info_window = InfoWindow()
self.help_window = HelpWindow()
self.message_toolbar = MessageToolbar(style="class:message_toolbar")
self.error_toolbar = MessageToolbar(style="class:error_toolbar")
self.status_line = MessageToolbar(style="class:status_line")
self.status_line_format = user._tui_status_line_format
self.options_list = OptionsList(
options,
default_index,
header_filter,
match_filter,
custom_filter=~has_focus(self.help_window))
self.options_list.search_buffer.on_text_changed += self.update
cmd, cmd_key_bindings = command_key_bindings(self)
self.command_line_prompt = CommandLinePrompt(commands=cmd)
key_bindings = merge_key_bindings(
[general_key_bindings(self), cmd_key_bindings])
_root_container = HSplit([
HSplit([
Window(content=BufferControl(
input_processors=[BeforeInput('> ')],
buffer=self.options_list.search_buffer)),
self.options_list,
self.info_window,
]),
self.help_window,
self.error_toolbar,
self.message_toolbar,
self.status_line,
self.command_line_prompt.window,
])
self.set_help_text()
self.layout = Layout(_root_container)
super(Picker, self).__init__(
input=None,
output=None,
editing_mode=EditingMode.EMACS
if user._tui_edit_mode == 'emacs' else EditingMode.VI,
layout=self.layout,
style=Style.from_dict(user_styles.get_user_styles()),
key_bindings=key_bindings,
include_default_pygments_style=False,
full_screen=True,
enable_page_navigation_bindings=True)
self.update()
def loop(cmd, history_file):
buf = create_buffer(cmd, history_file)
key_bindings = KeyBindings()
bind_keys(buf, key_bindings)
layout = create_layout(
buffer=buf,
multiline=True,
lexer=SqlLexer,
extra_input_processors=[
ConditionalProcessor(
processor=HighlightMatchingBracketProcessor(chars='[](){}'),
filter=HasFocus(DEFAULT_BUFFER) & ~IsDone())
],
get_bottom_toolbar_tokens=lambda: get_toolbar_tokens(cmd),
get_prompt_tokens=lambda: [('class:prompt', 'cr> ')])
output = get_default_output()
app = Application(layout=layout,
style=style_from_pygments_cls(CrateStyle),
key_bindings=merge_key_bindings(
[key_bindings,
load_open_in_editor_bindings()]),
editing_mode=_get_editing_mode(),
output=output)
cmd.get_num_columns = lambda: output.get_size().columns
while True:
try:
text = app.run()
if text:
cmd.process(text)
buf.reset()
except ProgrammingError as e:
if '401' in e.message:
username = cmd.username
password = cmd.password
cmd.username = input('Username: '******'Bye!')
return
def get_all_kb(self):
kb = KeyBindings()
@kb.add('c-c')
def exit_app(_):
self.quit_app()
@kb.add('q')
def exit_app(_):
self.quit_app()
extra_kb = self.get_kb() or KeyBindings()
return merge_key_bindings([kb, extra_kb])
def main():
style = Style([
('terminal focused', 'bg:#aaaaaa'),
('title', 'bg:#000044 #ffffff underline'),
])
term1 = Terminal()
text_area = TextArea(text='Press Control-W to switch focus.\n'
'Then you can edit this text area.\n'
'Press Control-X to exit')
kb = KeyBindings()
@kb.add('c-w')
def _(event):
switch_focus()
@kb.add('c-x', eager=True)
def _(event):
event.app.exit()
def switch_focus():
" Change focus when Control-W is pressed."
if application.layout.has_focus(term1):
application.layout.focus(text_area)
else:
application.layout.focus(term1)
application = Application(
layout=Layout(container=HSplit([
Window(height=1,
style='class:title',
content=FormattedTextControl(
' Press Control-W to switch focus.')),
VSplit([
term1,
Window(style='bg:#aaaaff', width=1),
text_area,
]),
]),
focused_element=term1),
style=style,
key_bindings=merge_key_bindings([
load_key_bindings(),
kb,
]),
full_screen=True,
mouse_support=True,
)
application.run()
def get_app(self):
bindings = KeyBindings()
@bindings.add(Keys.ControlC)
def _ctrl_c(event):
get_app().exit(exception=KeyboardInterrupt)
@bindings.add(Keys.Enter)
def _enter(event):
get_app().exit(result=self.get_answer())
return Application(layout=Layout(self.get_layout()),
key_bindings=merge_key_bindings(
[load_key_bindings(), bindings]),
style=get_theme_manager().get_current_style())
def mount(self, screen):
"""
Mount a screen into the view.
The screen must have a `main_container` attribute and,
optionally, a `bindings` attribute.
"""
if self._current_screen is not None:
self._current_screen.stop()
self._current_screen = screen
if screen.bindings is not None:
if screen.use_default_bindings:
merged_key_bindings = merge_key_bindings(
[self.bindings, screen.bindings])
self.application.key_bindings = merged_key_bindings
else:
self.application.key_bindings = screen.bindings
else:
# Screen does not define additional keybindings
self.application.key_bindings = self.bindings
self._render()
screen.on_mount(self.application)
def __init__(self, pymux):
self.pymux = pymux
def get_search_state():
" Return the currently active SearchState. (The one for the focused pane.) "
return pymux.arrangement.get_active_pane().search_state
self.custom_key_bindings = KeyBindings()
self.key_bindings = merge_key_bindings([
self._load_builtins(),
self.custom_key_bindings,
])
self._prefix = ('c-b', )
self._prefix_binding = None
# Load initial bindings.
self._load_prefix_binding()
# Custom user configured key bindings.
# { (needs_prefix, key) -> (command, handler) }
self.custom_bindings = {}
def __init__(self, pymux):
self.pymux = pymux
def get_search_state():
" Return the currently active SearchState. (The one for the focused pane.) "
return pymux.arrangement.get_active_pane().search_state
self.custom_key_bindings = KeyBindings()
self.key_bindings = merge_key_bindings([
self._load_builtins(),
self.custom_key_bindings,
])
self._prefix = ('c-b', )
self._prefix_binding = None
# Load initial bindings.
self._load_prefix_binding()
# Custom user configured key bindings.
# { (needs_prefix, key) -> (command, handler) }
self.custom_bindings = {}
def setup_app(gdb):
def codeview_line_prefix(line_number, wrap_count):
try:
if False: pass
elif line_number + 1 == get_app().my.gdb.lineno:
return [('class:text-area.pfx,selected', '>')]
elif get_app().my.gdb.sourcefile in get_app(
).my.gdb.breakpoints and line_number + 1 in get_app(
).my.gdb.breakpoints[get_app().my.gdb.sourcefile]:
return [('class:text-area.pfx.bp', 'o')]
except:
pass
return [('class:text-area.pfx', ' ')]
controls = {}
controls['header'] = Label(
text=u'',
style=u'class:header_label',
)
controls['codeview'] = TextArea(
text=u'',
read_only=True,
scrollbar=True,
line_numbers=True,
wrap_lines=True,
get_line_prefix=codeview_line_prefix,
lexer=PygmentsLexer(CLexer),
style=u'class:codeview',
focusable=True,
focus_on_click=True,
)
controls['gdbout'] = TextArea(
text=u'',
read_only=True,
scrollbar=True,
wrap_lines=True,
style=u'class:gdbout',
height=LayoutDimension(4, 16, preferred=8),
focusable=True,
focus_on_click=True,
)
controls['inferiorout'] = TextArea(
text=u'',
read_only=True,
scrollbar=True,
wrap_lines=False,
style=u'class:inferiorout',
height=LayoutDimension(1, 16, preferred=1),
focusable=True,
focus_on_click=True,
)
controls['locals'] = sidebar('locals', lambda: get_app().my.locals)
controls['exprs'] = sidebar('exprs', lambda: get_app().my.exprs)
controls['args'] = sidebar('args', lambda: get_app().my.args)
controls['input_label'] = Label(
text=u'(gdb) ',
style=u'class:input_label',
width=LayoutDimension.exact(6),
)
controls['input'] = Window(
content=BufferControl(
buffer=Buffer(
read_only=False,
multiline=False,
history=InMemoryHistory(),
),
focusable=True,
focus_on_click=True,
),
height=LayoutDimension.exact(1),
dont_extend_height=True,
style=u'class:input',
)
controls['vardetails'] = TextArea(
height=LayoutDimension(1, 4),
wrap_lines=True,
read_only=True,
style=u'class:vardetails',
)
def up_():
val = get_app().my.locals.get_value_by_index( \
get_app().my.controls['locals'].selected_option_index)
text = get_app().my.controls['vardetails'].text
if val is None and text != '':
get_app().my.controls['vardetails'].text = '<out of scope>'
elif text != '':
get_app().my.controls['vardetails'].text = val[1]
controls['vardetails'].update = up_
def need_vardetails():
return get_app().my.controls['vardetails'].text != ''
controls['sidebar'] = HSplit([
controls['exprs'],
controls['args'],
controls['locals'],
])
controls['sidebar']._remaining_space_window.style = 'class:sidebar'
controls['root_container'] = HSplit([
controls['header'],
ConditionalContainer(controls['vardetails'],
Condition(need_vardetails)),
VSplit([
HSplit([
controls['codeview'],
controls['inferiorout'],
controls['gdbout'],
VSplit([
controls['input_label'],
controls['input'],
]),
]),
controls['sidebar'],
]),
])
def do_exit():
get_app().exit(result=True)
def do_cont():
run_gdb_cmd(get_app(), 'c')
def do_step_into():
run_gdb_cmd(get_app(), 's')
def do_step_over():
run_gdb_cmd(get_app(), 'n')
def do_set_bp():
if get_app().my.focused_control == 'codeview':
c = get_app().my.controls['codeview']
line, col = c.document.translate_index_to_position(
c.document.cursor_position)
line += 1
run_gdb_cmd(get_app(),
'b %s:%d' % (get_app().my.gdb.sourcefile, line))
def do_toggle_prompt():
get_app().my.input_gdb = not get_app().my.input_gdb
get_app().my.controls['input_label'].text = '(gdb) ' if get_app(
).my.input_gdb else '>>> '
def do_toggle_mouse():
# we need to have the ability to turn mouse off to use the X11
# clipboard (selection needs to be handled by X11, not the app)
get_app().my.mouse_enabled = not get_app().my.mouse_enabled
controls['root_container'] = MenuContainer(
body=controls['root_container'],
menu_items=[
MenuItem('File',
children=[
MenuItem('Load config', handler=load_config),
MenuItem('Save config', handler=save_config),
MenuItem('-', disabled=True),
MenuItem('Exit', handler=do_exit),
]),
MenuItem('Debug',
children=[
MenuItem('Continue (F5)', handler=do_cont),
MenuItem('Step Into (F7)', handler=do_step_into),
MenuItem('Step Over (F8)', handler=do_step_over),
MenuItem('Set Breakpoint (CTRL-b)',
handler=do_set_bp),
]),
MenuItem('Extra',
children=[
MenuItem('Toggle python prompt (F1)',
handler=do_toggle_prompt),
MenuItem('Toggle mouse support (F2)',
handler=do_toggle_mouse),
]),
],
floats=[])
kb = KeyBindings()
@kb.add(u'escape', 'f')
def _focus_menu(event):
get_app().layout.focus(get_app().my.controls['root_container'].window)
@kb.add(u'c-q')
def exit_(event):
do_exit()
@kb.add(u'f1')
def eff_one_(event):
do_toggle_prompt()
@kb.add(u'enter')
def enter_(event):
def add_expr(name, expr):
get_app().my.exprs_dict[name] = expr
def del_expr(name):
if name in get_app().my.exprs_dict:
del get_app().my.exprs_dict[name]
if event.app.my.focused_control != 'input':
event.app.my.set_focus('input')
return
text = event.app.my.controls['input'].content.buffer.text
if len(text) and text[0] == ':':
# direct command
command, rest = text.split(' ', 1)
if command == ':expr':
command, rest = rest.split(' ', 1)
if command == 'add':
name, expr = rest.split(' ', 1)
add_expr(name, expr)
elif command == 'del':
del_expr(rest)
elif event.app.my.input_gdb:
cmd = text
if not len(cmd): cmd = event.app.my.last_gdb_cmd
else: event.app.my.last_gdb_cmd = cmd
run_gdb_cmd(event.app, cmd)
if text == 'q':
event.app.exit()
else:
try:
app.my.console.runsource(text)
except Exception as e:
import traceback
add_gdbview_text(event.app, traceback.format_exc())
event.app.my.controls['input'].content.buffer.reset(
append_to_history=True)
@kb.add(u'tab')
def enter_(event):
for i in xrange(len(event.app.my.focus_list)):
if event.app.my.focus_list[i] == event.app.my.focused_control:
next_focus = i + 1
if next_focus >= len(event.app.my.focus_list):
next_focus = 0
event.app.my.set_focus(event.app.my.focus_list[next_focus])
break
@kb.add(u'c-b')
def cb_(event):
do_set_bp()
@kb.add(u'f5')
def eff_five_(event):
do_cont()
@kb.add(u'f7')
def _(event):
do_step_into()
@kb.add(u'f8')
def _(event):
do_step_over()
@kb.add(u'f2')
def _(event):
do_toggle_mouse()
styledict = {
'gdbout': 'bg:#000000 #888888',
'inferiorout': 'bg:#330000 #888888',
'input': 'bg:#000000 #8888ff underline',
'input_label': 'bg:#000000 #8888ff underline',
'header_label': 'bg:#9999ff #000000 underline',
'vardetails': 'bg:#000000 #8888ff',
'text-area.pfx': 'bg:#aaaaaa #ff0000',
'text-area.pfx.selected': 'bg:#ff0000 #ffffff',
'sidebar': 'bg:#bbbbbb #000000',
'sidebar.title': 'bg:#668866 #ffffff',
'sidebar.title focused': 'bg:#000000 #ffffff bold',
'sidebar.label': 'bg:#bbbbbb #222222',
'sidebar.status': 'bg:#dddddd #000011',
'sidebar.labelodd': 'bg:#bbbb00 #222222',
'sidebar.statusodd': 'bg:#dddd00 #000011',
'sidebar.label selected': 'bg:#222222 #eeeeee',
'sidebar.status selected': 'bg:#444444 #ffffff bold',
'sidebar.status changed': 'bg:#dddddd #ff0000 bold',
'sidebar.statusodd changed': 'bg:#dddd00 #ff0000 bold',
}
pyg_style = style_from_pygments_cls(CodeviewStyle)
style = merge_styles([
Style.from_dict(styledict),
pyg_style,
])
@Condition
def _is_mouse_active():
return get_app().my.mouse_enabled
app = Application(
layout=Layout(
controls['root_container'],
focused_element=controls['input'],
),
style=style,
full_screen=True,
key_bindings=merge_key_bindings([
kb,
load_sidebar_bindings('locals'),
load_inputbar_bindings(),
]),
mouse_support=_is_mouse_active,
)
class My():
pass
app.my = My()
app.my.saved_config = {}
app.my.mouse_enabled = True
app.my.controls = controls
app.my.control_to_name_mapping = {}
for name in controls:
app.my.control_to_name_mapping[controls[name]] = name
if isinstance(controls[name], TextArea) or 'control' in vars(
controls[name]):
app.my.control_to_name_mapping[controls[name].control] = name
elif 'content' in vars(controls[name]):
app.my.control_to_name_mapping[controls[name].content] = name
app.my.locals = OrderedDict()
app.my.args = OrderedDict()
app.my.exprs = OrderedDict()
app.my.exprs_dict = dict()
app.my.gdb = gdb
app.my.last_gdb_cmd = ''
app.my.input_gdb = True
app.my.focus_list = [
'input', 'codeview', 'inferiorout', 'gdbout', 'args', 'locals', 'exprs'
]
app.my.focused_control = 'input'
def _set_focus(ctrl_or_name):
if isinstance(ctrl_or_name, six.text_type):
ctrl = get_app().my.controls[ctrl_or_name]
name = ctrl_or_name
else:
ctrl = ctrl_or_name
name = get_app().my.control_to_name_mapping[ctrl]
get_app().layout.focus(ctrl)
get_app().my.focused_control = name
app.my.set_focus = _set_focus
def _has_focus(ctrl_or_name):
ctrl = get_app().my.controls[ctrl_or_name] if isinstance(
ctrl_or_name, str) else ctrl_or_name
return get_app().layout.has_focus(ctrl)
app.my.has_focus = _has_focus
app_console_writefunc = lambda x: add_gdbview_text(get_app(), x)
app.my.console = py_console.Shell(locals=globals(),
writefunc=app_console_writefunc)
def my_mouse_handler(self, mouse_event):
# loosely based on prompt_toolkit/layout/controls.py:716
#if self.focus_on_click() and mouse_event.event_type == MouseEventType.MOUSE_DOWN:
if mouse_event.event_type == MouseEventType.MOUSE_DOWN:
get_app().my.set_focus(self)
processed_line = self._last_get_processed_line(
mouse_event.position.y)
xpos = processed_line.display_to_source(mouse_event.position.x)
index = self.buffer.document.translate_row_col_to_index(
mouse_event.position.y, xpos)
self.buffer.cursor_position = index
else:
return NotImplemented
for x in app.my.focus_list:
if isinstance(app.my.controls[x], Window) and isinstance(
app.my.controls[x].content, SidebarControl):
continue #don't override custom mouse handler
if isinstance(app.my.controls[x], TextArea):
app.my.controls[
x].control.mouse_handler = my_mouse_handler.__get__(
app.my.controls[x].control)
else:
app.my.controls[
x].content.mouse_handler = my_mouse_handler.__get__(
app.my.controls[x].content)
return app
def update_active_view(self, view):
self.state["app"].layout = view.layout
self.state["active_view"] = view
self.state["app"].key_bindings = merge_key_bindings(
[self.global_kb, view.kb])
view.reset_view()
def _create_application(self) -> Application:
self.sql_layout = sqlAppLayout(my_app=self)
kb = KeyBindings()
confirmation_visible = Condition(lambda: self.show_exit_confirmation)
@kb.add("c-q")
def _(event):
" Pressing Ctrl-Q or Ctrl-C will exit the user interface. "
self.show_exit_confirmation = True
@kb.add("y", filter=confirmation_visible)
@kb.add("Y", filter=confirmation_visible)
@kb.add("enter", filter=confirmation_visible)
@kb.add("c-q", filter=confirmation_visible)
def _(event):
"""
Really quit.
"""
event.app.exit(exception=ExitEX(), style="class:exiting")
@kb.add(Keys.Any, filter=confirmation_visible)
def _(event):
"""
Cancel exit.
"""
self.show_exit_confirmation = False
# Global key bindings.
@kb.add("tab",
filter=Condition(
lambda: self.show_preview or self.show_login_prompt))
def _(event):
event.app.layout.focus_next()
@kb.add("f4")
def _(event):
" Toggle between Emacs and Vi mode. "
self.vi_mode = not self.vi_mode
# apparently ctrls does this
@kb.add("c-t", filter=Condition(lambda: not self.show_preview))
def _(event):
"""
Show/hide sidebar.
"""
self.show_sidebar = not self.show_sidebar
if self.show_sidebar:
event.app.layout.focus("sidebarbuffer")
else:
event.app.layout.focus_previous()
sidebar_visible = Condition(lambda: self.show_sidebar and not self.show_expanding_object and not self.show_login_prompt and not self.show_preview) \
& ~has_focus("sidebarsearchbuffer")
@kb.add("up", filter=sidebar_visible)
@kb.add("c-p", filter=sidebar_visible)
@kb.add("k", filter=sidebar_visible)
def _(event):
" Go to previous option. "
obj = self._selected_object
self.select_previous()
inc = len(self.selected_object.name) + 1 # newline character
if obj is self.obj_list[0]:
idx = 0
cursor = 0
while obj is not self._selected_object:
if not obj.next_object:
raise IndexError
cursor += len(obj.name) + 1
idx += 1
obj = obj.next_object
self._selected_obj_idx = [idx, cursor]
else:
self._selected_obj_idx[0] -= 1
self._selected_obj_idx[1] -= inc
@kb.add("down", filter=sidebar_visible)
@kb.add("c-n", filter=sidebar_visible)
@kb.add("j", filter=sidebar_visible)
def _(event):
" Go to next option. "
inc = len(self.selected_object.name) + 1 # newline character
self.select_next()
if self.selected_object is self.obj_list[0]:
self._selected_obj_idx = [0, 0]
else:
self._selected_obj_idx[0] += 1
self._selected_obj_idx[1] += inc
@kb.add("enter", filter=sidebar_visible)
def _(event):
" If connection, connect. If table preview"
obj = self.selected_object
if type(obj).__name__ == "myDBConn" and not obj.conn.connected():
self.show_login_prompt = True
event.app.layout.focus(self.sql_layout.lprompt)
if type(obj).__name__ == "myDBConn" and obj.conn.connected():
# OG: some thread locking may be needed here
self._active_conn = obj.conn
elif obj.otype in ["table", "view", "function"]:
self.show_preview = True
self.show_sidebar = False
event.app.layout.focus(self.sql_layout.preview)
@kb.add("right", filter=sidebar_visible)
@kb.add("l", filter=sidebar_visible)
@kb.add(" ", filter=sidebar_visible)
def _(event):
" Select next value for current option. "
obj = self.selected_object
obj.expand()
if type(obj).__name__ == "myDBConn" and not obj.conn.connected():
self.show_login_prompt = True
event.app.layout.focus(self.sql_layout.lprompt)
@kb.add("left", filter=sidebar_visible)
@kb.add("h", filter=sidebar_visible)
def _(event):
" Select next value for current option. "
obj = self.selected_object
if type(obj).__name__ == "myDBConn" and obj.conn.connected(
) and obj.children is None:
self.show_disconnect_dialog = True
event.app.layout.focus(self.sql_layout.disconnect_dialog)
else:
obj.collapse()
auto_suggest_bindings = load_auto_suggest_bindings()
return Application(
layout=self.sql_layout.layout,
key_bindings=merge_key_bindings([kb, auto_suggest_bindings]),
enable_page_navigation_bindings=True,
style=style_factory(self.syntax_style, self.cli_style),
include_default_pygments_style=False,
mouse_support=self.mouse_support,
full_screen=False,
editing_mode=EditingMode.VI
if self.config["main"].as_bool("vi") else EditingMode.EMACS)
def _get_key_bindings(self):
kb = KeyBindings()
@kb.add('c-up')
def _(event):
self.console.enter_copy_mode()
@kb.add('c-x', 'a', eager=True)
def _(event):
self._hide_tui()
self.app.invalidate()
@kb.add('c-x', '1', eager=True)
def _(event):
self._hide_tui()
self.source.show = True
self.app.invalidate()
@kb.add('c-x', '2', eager=True)
def _(event):
self._hide_tui()
self.source.show = True
self.disassembly.show = True
@kb.add('c-x', 's', eager=True)
def _(event):
self.source.toggle_show()
self.app.invalidate()
@kb.add('c-x', 'd', eager=True)
def _(event):
self.disassembly.toggle_show()
self.app.invalidate()
@kb.add('c-x', 'c', eager=True)
def _(event):
self.callstack.toggle_show()
self.app.invalidate()
@kb.add('c-x', 'v', eager=True)
def _(event):
self.argsnlocals.toggle_show()
self.app.invalidate()
@kb.add('c-x', 'b', eager=True)
def _(event):
self.breakpoints.toggle_show()
self.app.invalidate()
@kb.add('c-x', 'r', eager=True)
def _(event):
self.registers.toggle_show()
self.app.invalidate()
@kb.add('c-x', 't', eager=True)
def _(event):
self.threads.toggle_show()
@kb.add('c-s', eager=True)
def _(event):
self._next_style()
@kb.add('c-l')
def _(event):
pass
@kb.add('c-x')
def _(event):
pass
@kb.add('s-right')
def _(event):
self.layout.focus_next()
@kb.add('s-left')
def _(event):
self.layout.focus_previous()
kb = merge_key_bindings([load_key_bindings(), kb])
return kb
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 interrogatio(questions, theme='default'):
"""
Prompts user for inputs as defined in the questions parameter and returns
a dictionary with the answers.
:param questions: a list of questions.
:type questions: list
:param theme: the name of the theme to use.
:type theme: string
:return: a dictionary with the answers.
:rtype: dict
:raise InvalidQuestionError: if there is an error in the question
definition.
:raise ThemeNotFoundError: if the specified theme does not exists.
Usage:
.. code-block:: python
from interrogatio import interrogatio
questions = [
{
'name': 'name',
'type': 'input',
'message': 'What is your name'
},
{
'name': 'favorite_pet',
'type': 'input',
'message': 'What is your favorite pet'
}
]
answers = interrogatio(questions, theme='purple')
"""
set_theme(theme)
answers = {}
validate_questions(questions)
for q in questions:
handler = get_instance(q)
handler.set_context(answers)
layout = handler.get_layout()
layout.align = HorizontalAlign.LEFT
bindings = [load_key_bindings()]
handler_bindings = handler.get_keybindings()
if handler_bindings: # pragma: no branch
bindings.append(handler_bindings)
app = Application(
layout=Layout(layout),
key_bindings=merge_key_bindings(bindings),
style=for_prompt(),
)
while True:
result = app.run()
if not result:
return
if handler.is_valid(answers):
answers.update(handler.get_answer())
break
else:
print_formatted_text(
FormattedText([('class:error', handler.errors[0])]),
style=for_prompt(),
)
return answers
# Add empty container if task list is empty
if not tasks:
right_window.children = [
Window(FormattedTextControl("-- No Tasks --"))
]
else:
right_window.children = tasks
focus_index_task = 0
tasks[focus_index_task].style = color_task
focus_folder = False
# Creating an `Application` instance
# ----------------------------------
application = Application(
layout=Layout(root_container),
key_bindings=merge_key_bindings([kb, kb_exit, kb_escape]),
mouse_support=False,
full_screen=False,
)
# Run the application
# -------------------
def run():
application.run()
if __name__ == "__main__":
run()
def __init__(self,
options: Sequence[Option],
default_index: int = 0,
header_filter: Callable[[Option], str] = str,
match_filter: Callable[[Option], str] = str):
self.info_window = InfoWindow()
self.help_window = HelpWindow()
self.message_toolbar = MessageToolbar(style="class:message_toolbar")
self.error_toolbar = MessageToolbar(style="class:error_toolbar")
self.status_line = MessageToolbar(style="class:status_line")
self.status_line_format = config.getstring('status_line_format',
section="tui")
self.options_list = OptionsList(
options,
default_index,
header_filter=header_filter,
match_filter=match_filter,
custom_filter=~has_focus(
self.help_window)) # type: OptionsList[Option]
self.options_list.search_buffer.on_text_changed += self.update
commands, commands_kb = get_commands(self)
self.command_line_prompt = CommandLinePrompt(commands=commands)
kb = merge_key_bindings([create_keybindings(self), commands_kb])
_root_container = HSplit([
HSplit([
Window(content=BufferControl(
input_processors=[BeforeInput('> ')],
buffer=self.options_list.search_buffer)),
self.options_list,
self.info_window,
]),
self.help_window,
self.error_toolbar,
self.message_toolbar,
self.status_line,
self.command_line_prompt.window,
])
help_text = "" # type: str
keys_info = get_keys_info()
for k in keys_info:
help_text += ("<ansired>{k[key]}</ansired>: {k[help]}\n".format(
k=keys_info[k]))
self.help_window.text = HTML(help_text)
self.layout = Layout(_root_container)
super(Picker, self).__init__(
input=None,
output=None,
editing_mode=EditingMode.EMACS if config.get(
'editmode', section='tui') == 'emacs' else EditingMode.VI,
layout=self.layout,
style=Style.from_dict({
'options_list.selected_margin':
config.get('options_list.selected_margin_style',
section='tui'),
'options_list.unselected_margin':
config.get('options_list.unselected_margin_style',
section='tui'),
'error_toolbar':
config.get('error_toolbar_style', section='tui'),
'message_toolbar':
config.get('message_toolbar_style', section='tui'),
'status_line':
config.get('status_line_style', section='tui'),
}),
key_bindings=kb,
include_default_pygments_style=False,
full_screen=True,
enable_page_navigation_bindings=True)
self.update()
],
height=1,
style="class:topbar",
)
root_container = FloatContainer(HSplit([
titlebar,
body,
]), floats=[])
application = Application(
layout=Layout(root_container, focused_element=sidebar),
key_bindings=merge_key_bindings([
kb,
ConditionalKeyBindings(
key_bindings=focus_bindings,
filter=Condition(lambda: not state.is_float_displaying),
),
ConditionalKeyBindings(
key_bindings=sidebar_bindings,
filter=Condition(lambda: state.focused_window == sidebar),
),
]),
mouse_support=True,
full_screen=True,
style=style,
refresh_interval=0.5,
)
def execute():
async def main():
update_text_window(0)
