def python_sidebar_navigation(python_input):
"""
Create the `Layout` showing the navigation information for the sidebar.
"""
def get_tokens(cli):
tokens = []
T = Token.Sidebar
# Show navigation info.
tokens.extend([
(T.Separator, ' ' * 43 + '\n'),
(T, ' '),
(T.Key, '[Arrows]'),
(T, ' '),
(T.Key.Description, 'Navigate'),
(T, ' '),
(T.Key, '[Enter]'),
(T, ' '),
(T.Key.Description, 'Hide menu'),
])
return tokens
return ConditionalContainer(content=Window(
TokenListControl(get_tokens, Char(token=Token.Sidebar)),
width=LayoutDimension.exact(43),
height=LayoutDimension.exact(2)),
filter=ShowSidebar(python_input) & ~IsDone())
def python_sidebar_navigation(python_input):
"""
Create the `Layout` showing the navigation information for the sidebar.
"""
def get_tokens(cli):
tokens = []
T = Token.Sidebar
# Show navigation info.
tokens.extend([
(T.Separator, ' ' * 43 + '\n'),
(T, ' '),
(T.Key, '[Arrows]'),
(T, ' '),
(T.Key.Description, 'Navigate'),
(T, ' '),
(T.Key, '[Enter]'),
(T, ' '),
(T.Key.Description, 'Hide menu'),
])
return tokens
return ConditionalContainer(
content=Window(
TokenListControl(get_tokens, Char(token=Token.Sidebar)),
width=LayoutDimension.exact(43),
height=LayoutDimension.exact(2)),
filter=ShowSidebar(python_input) & ~IsDone())
def get_dimensions(cli):
"""
Return a list of LayoutDimension instances for this split.
These dimensions will take the weight from the
arrangement.VSplit/HSplit instances.
"""
average_weight = get_average_weight()
# Make sure that weight is distributed
result = []
for i, item in enumerate(split):
result.append(D(weight=split.weights.get(item) or average_weight))
# Add dimension for the vertical border.
last_item = i == len(split) - 1
if is_vsplit and not last_item:
result.append(D.exact(1))
elif is_hsplit and not last_item:
if pymux.enable_pane_status:
result.append(D.exact(0))
else:
result.append(D.exact(1))
return result
def show_sidebar_button_info(python_input):
"""
Create `Layout` for the information in the right-bottom corner.
(The right part of the status bar.)
"""
@if_mousedown
def toggle_sidebar(cli, mouse_event):
" Click handler for the menu. "
python_input.show_sidebar = not python_input.show_sidebar
token = Token.Toolbar.Status
version = sys.version_info
tokens = [
(token.Key, '[F2]', toggle_sidebar),
(token, ' Menu', toggle_sidebar),
(token, ' - '),
(token.PythonVersion, '%s %i.%i.%i' % (platform.python_implementation(),
version[0], version[1], version[2])),
(token, ' '),
]
width = token_list_width(tokens)
def get_tokens(cli):
# Python version
return tokens
return ConditionalContainer(
content=Window(
TokenListControl(get_tokens, default_char=Char(token=token)),
height=LayoutDimension.exact(1),
width=LayoutDimension.exact(width)),
filter=~IsDone() & RendererHeightIsKnown() &
Condition(lambda cli: python_input.show_status_bar and
not python_input.show_exit_confirmation))
def __init__(self, python_input):
def get_tokens(cli):
tokens = []
T = Token.Sidebar
# Show navigation info.
tokens.extend([
(T.Separator , ' ' * 43 + '\n'),
(T, ' '),
(T.Key, '[Arrows]'),
(T, ' '),
(T.Key.Description, 'Navigate'),
(T, ' '),
(T.Key, '[Enter]'),
(T, ' '),
(T.Key.Description, 'Hide menu'),
])
return tokens
super(PythonSidebarNavigation, self).__init__(
TokenListControl(get_tokens, Char(token=Token.Sidebar)),
width=LayoutDimension.exact(43),
height=LayoutDimension.exact(2),
filter=ShowSidebar(python_input) & ~IsDone())
def __init__(self,
message="openstack> ",
menu_height=12,
multiwindow=False):
toolbar = Toolbar()
main_layout = create_prompt_layout(
message=message,
lexer=OSLexer,
get_bottom_toolbar_tokens=toolbar.handler,
reserve_space_for_menu=menu_height)
if multiwindow:
self.mlayout = VSplit([
main_layout,
Window(width=D.exact(1),
content=FillControl('|', token=Token.Line)),
Window(width=D.exact(70),
wrap_lines=True,
content=BufferControl(buffer_name='HELP')),
])
if multiwindow:
self.layout = self.mlayout
else:
self.layout = main_layout
def show_sidebar_button_info(python_input):
"""
Create `Layout` for the information in the right-bottom corner.
(The right part of the status bar.)
"""
@if_mousedown
def toggle_sidebar(cli, mouse_event):
" Click handler for the menu. "
python_input.show_sidebar = not python_input.show_sidebar
token = Token.Toolbar.Status
version = sys.version_info
tokens = [
(token.Key, '[F2]', toggle_sidebar),
(token, ' Menu', toggle_sidebar),
(token, ' - '),
(token.PythonVersion, '%s %i.%i.%i' % (platform.python_implementation(),
version[0], version[1], version[2])),
(token, ' '),
]
width = token_list_width(tokens)
def get_tokens(cli):
# Python version
return tokens
return ConditionalContainer(
content=Window(
TokenListControl(get_tokens, default_char=Char(token=token)),
height=LayoutDimension.exact(1),
width=LayoutDimension.exact(width)),
filter=~IsDone() & RendererHeightIsKnown() &
Condition(lambda cli: python_input.show_status_bar and
not python_input.show_exit_confirmation))
def get_height(cli):
# If there is an autocompletion menu to be shown, make sure that our
# layout has at least a minimal height in order to display it.
if reserve_space_for_menu and not cli.is_done:
return LayoutDimension(min=reserve_space_for_menu)
else:
return LayoutDimension()
def __init__(self, editor, buffer_window, buffer_name):
def get_scroll_text():
info = buffer_window.render_info
if info:
if info.full_height_visible:
return 'All'
elif info.top_visible:
return 'Top'
elif info.bottom_visible:
return 'Bot'
else:
percentage = info.vertical_scroll_percentage
return '%2i%%' % percentage
return ''
def get_tokens(cli):
main_document = cli.buffers[buffer_name].document
return [
(Token.Toolbar.CursorPosition, '(%i,%i)' % (main_document.cursor_position_row + 1,
main_document.cursor_position_col + 1)),
(Token.Toolbar, ' - '),
(Token.Toolbar.Percentage, get_scroll_text()),
(Token.Toolbar, ' '),
]
super(WindowStatusBarRuler, self).__init__(
Window(
TokenListControl(get_tokens, default_char=Char(' ', Token.Toolbar), align_right=True),
height=LayoutDimension.exact(1),
width=LayoutDimension.exact(15)),
filter=Condition(lambda cli: editor.show_ruler))
def __init__(self, editor, buffer_window, buffer_name):
def get_scroll_text():
info = buffer_window.render_info
if info:
if info.full_height_visible:
return 'All'
elif info.top_visible:
return 'Top'
elif info.bottom_visible:
return 'Bot'
else:
percentage = info.vertical_scroll_percentage
return '%2i%%' % percentage
return ''
def get_tokens(cli):
main_document = cli.buffers[buffer_name].document
return [
(Token.Toolbar.CursorPosition, '(%i,%i)' % (main_document.cursor_position_row + 1,
main_document.cursor_position_col + 1)),
(Token.Toolbar, ' - '),
(Token.Toolbar.Percentage, get_scroll_text()),
(Token.Toolbar, ' '),
]
super(WindowStatusBarRuler, self).__init__(
TokenListControl(get_tokens, default_char=Char(' ', Token.Toolbar), align_right=True),
height=LayoutDimension.exact(1),
width=LayoutDimension.exact(15),
filter=Condition(lambda cli: editor.show_ruler))
def get_dimensions(cli):
"""
Return a list of LayoutDimension instances for this split.
These dimensions will take the weight from the
arrangement.VSplit/HSplit instances.
"""
average_weight = get_average_weight()
# Make sure that weight is distributed
result = []
for i, item in enumerate(split):
result.append(D(weight=split.weights.get(item) or average_weight))
# Add dimension for the vertical border.
last_item = i == len(split) - 1
if is_vsplit and not last_item:
result.append(D.exact(1))
elif is_hsplit and not last_item:
if pymux.enable_pane_status:
result.append(D.exact(0))
else:
result.append(D.exact(1))
return result
def __init__(self, python_input):
token = Token.Toolbar.Status
version = sys.version_info
tokens = [
(token, ' [F2] Options'),
(token, ' - '),
(token.PythonVersion, '%s %i.%i.%i' % (platform.python_implementation(),
version[0], version[1], version[2])),
(token, ' '),
]
width = token_list_width(tokens)
def get_tokens(cli):
# Python version
return tokens
super(ShowSidebarButtonInfo, self).__init__(
content=Window(
TokenListControl(get_tokens, default_char=Char(token=token)),
height=LayoutDimension.exact(1),
width=LayoutDimension.exact(width)),
filter=~IsDone() & RendererHeightIsKnown() &
Condition(lambda cli: python_input.show_status_bar and
not python_input.show_exit_confirmation))
def comp_height(cli):
# If there is an autocompletion menu to be shown, make sure that o
# layout has at least a minimal height in order to display it.
if not cli.is_done:
return LayoutDimension(min=size)
else:
return LayoutDimension()
def get_anyhline(config):
""" if there is a line between descriptions and example """
if config.BOOLEAN_STATES[config.config.get('Layout', 'command_description')] or\
config.BOOLEAN_STATES[config.config.get('Layout', 'param_description')]:
return Window(width=LayoutDimension.exact(1),
height=LayoutDimension.exact(1),
content=FillControl('-', token=Token.Line))
return get_empty()
def python_sidebar(python_input):
"""
Create the `Layout` for the sidebar with the configurable options.
"""
def get_tokens(cli):
tokens = []
T = Token.Sidebar
def append_category(category):
tokens.extend([
(T, ' '),
(T.Title, ' %-36s' % category.title),
(T, '\n'),
])
def append(selected, label, status):
token = T.Selected if selected else T
tokens.append((T, ' >' if selected else ' '))
tokens.append((token.Label, '%-24s' % label))
tokens.append((token.Status, ' '))
tokens.append((token.Status, '%s' % status))
if selected:
tokens.append((Token.SetCursorPosition, ''))
tokens.append((token.Status, ' ' * (14 - len(status))))
tokens.append((T, '<' if selected else ''))
tokens.append((T, '\n'))
i = 0
for category in python_input.options:
append_category(category)
for option in category.options:
append(i == python_input.selected_option_index,
option.title, '%s' % option.get_current_value())
i += 1
tokens.pop() # Remove last newline.
return tokens
class Control(TokenListControl):
def move_cursor_down(self, cli):
python_input.selected_option_index += 1
def move_cursor_up(self, cli):
python_input.selected_option_index -= 1
return ConditionalContainer(
content=Window(
Control(get_tokens, Char(token=Token.Sidebar),
has_focus=ShowSidebar(python_input) & ~IsDone()),
width=LayoutDimension.exact(43),
height=LayoutDimension(min=3),
scroll_offsets=ScrollOffsets(top=1, bottom=1)),
filter=ShowSidebar(python_input) & ~IsDone())
def get_anyhline(config):
""" if there is a line between descriptions and example """
if config.BOOLEAN_STATES[config.config.get('Layout', 'command_description')] or\
config.BOOLEAN_STATES[config.config.get('Layout', 'param_description')]:
return Window(
width=LayoutDimension.exact(1),
height=LayoutDimension.exact(1),
content=FillControl('-', token=Token.Line))
return get_empty()
def vertical_line():
" Draw a vertical line between windows. (In case of a vsplit) "
char = '│'
content.append(HSplit([
Window(
width=D.exact(1), height=D.exact(1),
content=FillControl(char, token=Token.TitleBar.Line)),
Window(width=D.exact(1),
content=FillControl(char, token=Token.Line))
]))
def _gen_layout(self):
stat_windows = []
for stat_group in statinfo.groups:
for stat in stat_group:
stat_windows.append(make_stat_window(stat))
stat_windows.append(vpad(1))
stat_windows.append(
Window(content=BufferControl(buffer_name='REROLLS_STAT_BUFFER'),
**stat_args))
stat_windows.append(vpad(1))
@Condition
def scroll_cond(cli):
if self.info_window.render_info is None:
return True
try:
l = self.buffers['INFO_BUFFER'].document.line_count
return self.info_window.render_info.window_height < l
except:
return True
self.info_window = Window(
content=BufferControl(buffer_name='INFO_BUFFER'),
dont_extend_width=True,
wrap_lines=True,
always_hide_cursor=True,
right_margins=[
ConditionalMargin(ScrollbarMargin(display_arrows=True),
scroll_cond)
])
return HSplit([
hpad(1),
VSplit([
vpad(1),
HSplit(stat_windows),
vpad(2), # idk why there's an extra space on the stats
self.info_window,
vpad(1)
]),
hpad(1),
Window(content=BufferControl(buffer_name='MSG_BUFFER'),
height=D.exact(3),
wrap_lines=True),
Window(content=BufferControl(buffer_name=DEFAULT_BUFFER),
height=D.exact(1),
always_hide_cursor=True)
])
def vertical_line():
" Draw a vertical line between windows. (In case of a vsplit) "
char = '│'
content.append(HSplit([
ConditionalContainer(
content=Window(
width=D.exact(1), height=D.exact(1),
content=FillControl(char, token=Token.TitleBar.Line)),
filter=Condition(lambda cli: pymux.enable_pane_status),
),
Window(width=D.exact(1),
content=FillControl(char, token=Token.Line))
]))
def get_height(cli):
# If there is an autocompletion menu to be shown, make sure that our
# layout has at least a minimal height in order to display it.
if reserve_space_for_menu and not cli.is_done:
buff = cli.current_buffer
# Reserve the space, either when there are completions, or when
# `complete_while_typing` is true and we expect completions very
# soon.
if buff.complete_while_typing() or buff.complete_state is not None:
return LayoutDimension(min=reserve_space_for_menu)
return LayoutDimension()
def vertical_line():
" Draw a vertical line between windows. (In case of a vsplit) "
char = '│'
content.append(
HSplit([
ConditionalContainer(
content=Window(width=D.exact(1),
height=D.exact(1),
content=FillControl(
char, token=Token.TitleBar.Line)),
filter=Condition(lambda cli: pymux.enable_pane_status),
),
Window(width=D.exact(1),
content=FillControl(char, token=Token.Line))
]))
def signature_toolbar(python_input):
"""
Return the `Layout` for the signature.
"""
def get_tokens(cli):
result = []
append = result.append
Signature = Token.Toolbar.Signature
if python_input.signatures:
sig = python_input.signatures[0] # Always take the first one.
append((Signature, ' '))
try:
append((Signature, sig.full_name))
except IndexError:
# Workaround for #37: https://github.com/jonathanslenders/python-prompt-toolkit/issues/37
# See also: https://github.com/davidhalter/jedi/issues/490
return []
append((Signature.Operator, '('))
for i, p in enumerate(sig.params):
# Workaround for #47: 'p' is None when we hit the '*' in the signature.
# and sig has no 'index' attribute.
# See: https://github.com/jonathanslenders/ptpython/issues/47
# https://github.com/davidhalter/jedi/issues/598
description = (p.description if p else '*') #or '*'
sig_index = getattr(sig, 'index', 0)
if i == sig_index:
# Note: we use `_Param.description` instead of
# `_Param.name`, that way we also get the '*' before args.
append((Signature.CurrentName, str(description)))
else:
append((Signature, str(description)))
append((Signature.Operator, ', '))
if sig.params:
# Pop last comma
result.pop()
append((Signature.Operator, ')'))
append((Signature, ' '))
return result
return ConditionalContainer(
content=Window(
TokenListControl(get_tokens),
height=LayoutDimension.exact(1)),
filter=
# Show only when there is a signature
HasSignature(python_input) &
# And there are no completions to be shown. (would cover signature pop-up.)
~(HasCompletions() & (show_completions_menu(python_input) |
show_multi_column_completions_menu(python_input)))
# Signature needs to be shown.
& ShowSignature(python_input) &
# Not done yet.
~IsDone())
def signature_toolbar(python_input):
"""
Return the `Layout` for the signature.
"""
def get_tokens(cli):
result = []
append = result.append
Signature = Token.Toolbar.Signature
if python_input.signatures:
sig = python_input.signatures[0] # Always take the first one.
append((Signature, ' '))
try:
append((Signature, sig.full_name))
except IndexError:
# Workaround for #37: https://github.com/jonathanslenders/python-prompt-toolkit/issues/37
# See also: https://github.com/davidhalter/jedi/issues/490
return []
append((Signature.Operator, '('))
for i, p in enumerate(sig.params):
# Workaround for #47: 'p' is None when we hit the '*' in the signature.
# and sig has no 'index' attribute.
# See: https://github.com/jonathanslenders/ptpython/issues/47
# https://github.com/davidhalter/jedi/issues/598
description = (p.description if p else '*') #or '*'
sig_index = getattr(sig, 'index', 0)
if i == sig_index:
# Note: we use `_Param.description` instead of
# `_Param.name`, that way we also get the '*' before args.
append((Signature.CurrentName, str(description)))
else:
append((Signature, str(description)))
append((Signature.Operator, ', '))
if sig.params:
# Pop last comma
result.pop()
append((Signature.Operator, ')'))
append((Signature, ' '))
return result
return ConditionalContainer(
content=Window(
TokenListControl(get_tokens),
height=LayoutDimension.exact(1)),
filter=
# Show only when there is a signature
HasSignature(python_input) &
# And there are no completions to be shown. (would cover signature pop-up.)
~(HasCompletions() & (show_completions_menu(python_input) |
show_multi_column_completions_menu(python_input)))
# Signature needs to be shown.
& ShowSignature(python_input) &
# Not done yet.
~IsDone())
def _get_height_dimension(self) -> LayoutDimension:
"""Retrieve the height dimension dynamically.
Returns:
:class:`prompt_toolkit.layout.Dimension` instance.
"""
return LayoutDimension(preferred=self._get_height() + 1)
def create_tutorial_layout(lex):
""" layout for example tutorial """
lexer, _, _ = get_lexers(lex, None, None)
layout_full = HSplit([
FloatContainer(
Window(BufferControl(input_processors=input_processors,
lexer=lexer,
preview_search=Always()),
get_height=get_height), [
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=MAX_COMPLETION,
scroll_offset=1,
extra_filter=(HasFocus(DEFAULT_BUFFER))))
]),
ConditionalContainer(HSplit([
get_hline(),
get_param(lexer),
get_hline(),
Window(content=BufferControl(buffer_name='example_line',
lexer=lexer), ),
Window(TokenListControl(get_tutorial_tokens,
default_char=Char(' ', Token.Toolbar)),
height=D.exact(1)),
]),
filter=~IsDone() & RendererHeightIsKnown())
])
return layout_full
def __init__(self, python_input):
def get_tokens(cli):
tokens = []
T = Token.Sidebar
tokens.extend([
(T, ' '),
(T.Title, 'Options'),
(T, '\n'),
])
def append(selected, label, status):
token = T.Selected if selected else T
tokens.append((T, ' >' if selected else ' '))
tokens.append((token.Label, '%-24s' % label))
tokens.append((token.Status, ' %-14s' % status))
tokens.append((T, '<' if selected else ''))
tokens.append((T, '\n'))
for i, option in enumerate(python_input.options):
append(i == python_input.selected_option,
option.description, '%s' % option.get_current_value())
tokens.pop() # Remove last newline.
return tokens
super(PythonSidebar, self).__init__(
TokenListControl(get_tokens, Char(token=Token.Sidebar)),
width=LayoutDimension.exact(43),
filter=ShowSidebar(python_input) & ~IsDone())
def python_sidebar_help(python_input):
"""
Create the `Layout` for the help text for the current item in the sidebar.
"""
token = Token.Sidebar.HelpText
def get_current_description():
"""
Return the description of the selected option.
"""
i = 0
for category in python_input.options:
for option in category.options:
if i == python_input.selected_option_index:
return option.description
i += 1
return ''
def get_tokens(cli):
return [(token, get_current_description())]
return ConditionalContainer(
content=Window(TokenListControl(get_tokens, Char(token=token)),
height=LayoutDimension(min=3)),
filter=ShowSidebar(python_input)
& Condition(lambda cli: python_input.show_sidebar_help) & ~IsDone())
def horizontal_line():
char = '─'
content.append(
ConditionalContainer(
content=Window(height=D.exact(1),
content=FillControl(char, token=Token.Line)),
filter=Condition(lambda cli: not pymux.enable_pane_status)), )
def __init__(self):
super(CommandLine, self).__init__(BufferControl(
buffer_name=COMMAND_BUFFER,
input_processors=[BeforeInput.static(':')],
lexer=create_command_lexer()),
height=LayoutDimension.exact(1),
filter=HasFocus(COMMAND_BUFFER))
def create_default_layout(message='', lexer=None, is_password=False,
reserve_space_for_menu=False, get_bottom_toolbar_tokens=None,
extra_input_processors=None):
"""
Generate default layout.
"""
assert get_bottom_toolbar_tokens is None or callable(get_bottom_toolbar_tokens)
# Create processors list.
# (DefaultPrompt should always be at the end.)
input_processors = [HighlightSearchProcessor(preview_search=Always()),
HighlightSelectionProcessor()]
if extra_input_processors:
input_processors.extend(extra_input_processors)
if is_password:
input_processors.extend([PasswordProcessor(), DefaultPrompt(message)])
else:
input_processors.append(DefaultPrompt(message))
# Create bottom toolbar.
if get_bottom_toolbar_tokens:
toolbars = [Window(TokenListControl(get_bottom_toolbar_tokens,
default_char=Char(' ', Token.Toolbar)),
height=LayoutDimension.exact(1),
filter=~IsDone())]
else:
toolbars = []
def get_height(cli):
# If there is an autocompletion menu to be shown, make sure that our
# layout has at least a minimal height in order to display it.
if reserve_space_for_menu and not cli.is_done:
return LayoutDimension(min=8)
else:
return LayoutDimension()
# Create and return Layout instance.
return HSplit([
FloatContainer(
Window(
BufferControl(
input_processors=input_processors,
lexer=lexer,
# Enable preview_search, we want to have immediate feedback
# in reverse-i-search mode.
preview_search=Always()),
get_height=get_height,
),
[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16,
extra_filter=HasFocus(DEFAULT_BUFFER)))
]
),
ValidationToolbar(),
SystemToolbar(),
] + toolbars)
def horizontal_line():
char = '─'
content.append(
ConditionalContainer(
content=Window(height=D.exact(1),
content=FillControl(char, token=Token.Line)),
filter=Condition(lambda cli: not pymux.enable_pane_status)),
)
def __init__(self):
super(CommandLine, self).__init__(
BufferControl(
buffer_name=COMMAND_BUFFER,
input_processors=[BeforeInput.static(':')],
lexer=create_command_lexer()),
height=LayoutDimension.exact(1),
filter=HasFocus(COMMAND_BUFFER))
def __init__(self, opt_ns, srv_c, inst_xml):
manager = KeyBindingManager() # Start with the `KeyBindingManager`.
self.srv_text = ServiceOutput(opt_ns, srv_c, inst_xml)
layout = HSplit(
[
# One window that holds the BufferControl with the default buffer on the
# left.
Window(
height=D.exact(1),
content=TokenListControl(
self.get_title_line,
default_char=Char(" ", token=Token.String.ICSW.Header)
)
),
Window(
height=D.exact(1),
content=FillControl('-', token=Token.Line)
),
# Display the text 'Hello world' on the right.
Window(
content=TokenListControl(
self.get_icsw_output,
)
),
]
)
self._updating = False
@manager.registry.add_binding(Keys.ControlC, eager=True)
@manager.registry.add_binding("q", eager=True)
def _handler_data(event):
event.cli.set_return_value(0)
our_style = style_from_dict(logging_tools.get_icsw_prompt_styles())
application = Application(
layout=layout,
use_alternate_screen=True,
style=our_style,
on_input_timeout=self.input_timeout,
key_bindings_registry=manager.registry,
)
event_loop = create_eventloop()
self.application = application
self.event_loop = event_loop
def __init__(self):
super(CommandPrompt, self).__init__(
BufferControl(
buffer_name=COMMAND_BUFFER,
input_processors=[BeforeInput.static(self.PROMPT)],
),
height=D.exact(1)
)
def python_sidebar(python_input):
"""
Create the `Layout` for the sidebar with the configurable options.
"""
def get_tokens(cli):
tokens = []
T = Token.Sidebar
def append_category(category):
tokens.extend([
(T, ' '),
(T.Title, ' %-36s' % category.title),
(T, '\n'),
])
def append(selected, label, status):
token = T.Selected if selected else T
tokens.append((T, ' >' if selected else ' '))
tokens.append((token.Label, '%-24s' % label))
tokens.append((token.Status, ' '))
tokens.append((token.Status, '%s' % status))
if selected:
tokens.append((Token.SetCursorPosition, ''))
tokens.append((token.Status, ' ' * (14 - len(status))))
tokens.append((T, '<' if selected else ''))
tokens.append((T, '\n'))
i = 0
for category in python_input.options:
append_category(category)
for option in category.options:
append(i == python_input.selected_option_index,
option.title, '%s' % option.get_current_value())
i += 1
tokens.pop() # Remove last newline.
return tokens
class Control(TokenListControl):
def move_cursor_down(self, cli):
python_input.selected_option_index += 1
def move_cursor_up(self, cli):
python_input.selected_option_index -= 1
return ConditionalContainer(
content=Window(
Control(get_tokens, Char(token=Token.Sidebar),
has_focus=ShowSidebar(python_input) & ~IsDone()),
width=LayoutDimension.exact(43),
height=LayoutDimension(min=3),
scroll_offsets=ScrollOffsets(top=1, bottom=1)),
filter=ShowSidebar(python_input) & ~IsDone())
def _get_layout(self):
token_list_window = Window(height=LD.exact(1),
content=TokenListControl(
self._get_prompt_tokens))
conditional_window = ConditionalContainer(Window(
self.controller,
width=LD.exact(43),
height=LD.exact(len(self.choices)),
scroll_offsets=ScrollOffsets(top=1, bottom=1)),
filter=~IsDone())
if self.prompt_msg:
return HSplit([token_list_window, conditional_window])
else:
return HSplit([conditional_window])
def create_default_layout(message='', lexer=None, is_password=False,
reserve_space_for_menu=False, get_bottom_toolbar_tokens=None):
"""
Generate default layout.
"""
assert get_bottom_toolbar_tokens is None or callable(get_bottom_toolbar_tokens)
# Create processors list.
input_processors = [HighlightSearchProcessor(), HighlightSelectionProcessor()]
if is_password:
input_processors.extend([PasswordProcessor(), DefaultPrompt(message)])
else:
input_processors.append(DefaultPrompt(message))
# Create bottom toolbar.
if get_bottom_toolbar_tokens:
toolbars = [Window(TokenListControl(get_bottom_toolbar_tokens,
default_char=Char(' ', Token.Toolbar)),
height=LayoutDimension.exact(1),
filter=~IsDone())]
else:
toolbars = []
def get_height(cli):
# If there is an autocompletion menu to be shown, make sure that our
# layout has at least a minimal height in order to display it.
if reserve_space_for_menu and not cli.is_done:
return LayoutDimension(min=8)
else:
return LayoutDimension()
# Create and return Layout instance.
return HSplit([
FloatContainer(
Window(
BufferControl(
input_processors=input_processors,
lexer=lexer,
# Enable preview_search, we want to have immediate feedback
# in reverse-i-search mode.
preview_search=Always()),
get_height=get_height,
),
[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16,
extra_filter=HasFocus(DEFAULT_BUFFER)))
]
),
ValidationToolbar(),
SystemToolbar(),
] + toolbars)
def __init__(self, app):
self.layout = HSplit([
# main window
MainWindow(app),
TabSelectWindow(app),
# horizontal split
Window(height=D.exact(1),
content=FillControl('\u2500', token=Token.Line)),
# command prompt
CommandPrompt(),
])
def __init__(self):
token = Token.Toolbar.Status
version = sys.version_info
tokens = [
(token, ' [F2] Sidebar'),
(token, ' - '),
(token.PythonVersion, '%s %i.%i.%i' % (platform.python_implementation(),
version[0], version[1], version[2])),
(token, ' '),
]
width = token_list_width(tokens)
def get_tokens(cli):
# Python version
return tokens
super(ShowSidebarButtonInfo, self).__init__(
TokenListControl(get_tokens, default_char=Char(token=token)),
filter=~IsDone() & RendererHeightIsKnown(),
height=LayoutDimension.exact(1),
width=LayoutDimension.exact(width))
def __init__(self, settings):
super(SignatureToolbar, self).__init__(
SignatureControl(settings),
height=LayoutDimension.exact(1),
filter=
# Show only when there is a signature
HasSignature(settings) &
# And there are no completions to be shown. (would cover signature pop-up.)
(~HasCompletions() | ~ShowCompletionsMenu(settings))
# Signature needs to be shown.
& ShowSignature(settings) &
# Not done yet.
~IsDone())
def __init__(self, settings):
super(SignatureToolbar, self).__init__(
SignatureControl(settings),
height=LayoutDimension.exact(1),
filter=
# Show only when there is a signature
HasSignature(settings) &
# And there are no completions to be shown. (would cover signature pop-up.)
(~HasCompletions() | ~ShowCompletionsMenu(settings))
# Signature needs to be shown.
& ShowSignature(settings) &
# Not done yet.
~IsDone())
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 create_default_layout(message='', lexer=None, is_password=False,
reserve_space_for_menu=False, get_bottom_toolbar_tokens=None):
"""
Generate default layout.
"""
assert get_bottom_toolbar_tokens is None or callable(get_bottom_toolbar_tokens)
# Create processors list.
if is_password:
input_processors = [PasswordProcessor(), DefaultPrompt(message)]
else:
input_processors = [DefaultPrompt(message)]
# Create bottom toolbar.
if get_bottom_toolbar_tokens:
toolbars = [Window(TokenListControl(get_bottom_toolbar_tokens,
default_char=Char(' ', Token.Toolbar)),
height=LayoutDimension.exact(1),
filter=~IsDone())]
else:
toolbars = []
def get_height(cli):
# If there is an autocompletion menu to be shown, make sure that our
# layout has at least a minimal height in order to display it.
if reserve_space_for_menu and not cli.is_done:
return LayoutDimension(min=8)
else:
return LayoutDimension()
# Create and return Layout instance.
return HSplit([
FloatContainer(
Window(
BufferControl(
input_processors=input_processors,
lexer=lexer),
get_height=get_height,
),
[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(max_height=16,
extra_filter=HasFocus('default')))
]
),
ValidationToolbar(),
SystemToolbar(),
] + toolbars)
def _get_width_dimension(self) -> LayoutDimension:
"""Retrieve the width dimension dynamically.
Returns:
:class:`prompt_toolkit.layout.Dimension` instance.
"""
width, _ = get_dimension(offset=self._dimension_offset +
(self._padding * 2))
if self._vertical_mode():
if self._id == Pane.left:
width = math.ceil((width - (self._padding * 2)) / 2)
elif self._id == Pane.right:
width = math.floor((width - (self._padding * 2)) / 2)
self._width = width
return LayoutDimension(preferred=width)
def __init__(self,
message: "AnyFormattedText",
filter: "FilterOrBool",
wrap_lines: bool = True,
show_cursor: bool = True,
**kwargs) -> None:
super().__init__(
content=Window(
height=LayoutDimension.exact(1) if not wrap_lines else None,
content=FormattedTextControl(message, show_cursor=show_cursor),
wrap_lines=wrap_lines,
dont_extend_height=True,
**kwargs),
filter=filter,
)
def __init__(self, python_input):
def get_tokens(cli):
tokens = []
T = Token.Sidebar
def append_category(category):
tokens.extend([
(T, ' '),
(T.Title, ' %-36s' % category.title),
(T, '\n'),
])
def append(selected, label, status):
token = T.Selected if selected else T
tokens.append((T, ' >' if selected else ' '))
tokens.append((token.Label, '%-24s' % label))
tokens.append((token.Status, ' '))
tokens.append((token.Status, '%s' % status))
if selected:
tokens.append((Token.SetCursorPosition, ''))
tokens.append((token.Status, ' ' * (14 - len(status))))
tokens.append((T, '<' if selected else ''))
tokens.append((T, '\n'))
i = 0
for category in python_input.options:
append_category(category)
for option in category.options:
append(i == python_input.selected_option_index,
option.title, '%s' % option.get_current_value())
i += 1
tokens.pop() # Remove last newline.
return tokens
super(PythonSidebar, self).__init__(
content=Window(
TokenListControl(get_tokens, Char(token=Token.Sidebar),
has_focus=ShowSidebar(python_input) & ~IsDone()),
width=LayoutDimension.exact(43),
height=LayoutDimension(min=3),
scroll_offset=1),
filter=ShowSidebar(python_input) & ~IsDone())
def __init__(self, python_input):
def get_tokens(cli):
result = []
append = result.append
Signature = Token.Toolbar.Signature
if python_input.signatures:
sig = python_input.signatures[0] # Always take the first one.
append((Signature, ' '))
try:
append((Signature, sig.full_name))
except IndexError:
# Workaround for #37: https://github.com/jonathanslenders/python-prompt-toolkit/issues/37
# See also: https://github.com/davidhalter/jedi/issues/490
return []
append((Signature.Operator, '('))
for i, p in enumerate(sig.params):
if i == sig.index:
# Note: we use `_Param.description` instead of
# `_Param.name`, that way we also get the '*' before args.
append((Signature.CurrentName, str(p.description)))
else:
append((Signature, str(p.description)))
append((Signature.Operator, ', '))
if sig.params:
# Pop last comma
result.pop()
append((Signature.Operator, ')'))
append((Signature, ' '))
return result
super(SignatureToolbar, self).__init__(
TokenListControl(get_tokens),
height=LayoutDimension.exact(1),
filter=
# Show only when there is a signature
HasSignature(python_input) &
# And there are no completions to be shown. (would cover signature pop-up.)
(~HasCompletions() | ~ShowCompletionsMenu(python_input))
# Signature needs to be shown.
& ShowSignature(python_input) &
# Not done yet.
~IsDone())
def _factory():
return [
window_class(
control,
height=LayoutDimension(max=page_size),
dont_extend_height=True,
wrap_lines=True,
),
ConditionalContainer(
Window(
TokenListControl(_get_default_pager_tokens),
dont_extend_height=True,
wrap_lines=True,
),
filter=NeedsScrollTip(page_size) & ~IsDone(),
),
]
def setup_layout(self):
"""docstring for setup_layout"""
if bool(egc.TEXT_EDITOR_ENABLE_LEFT_MARGIN) is True:
self._left_margin = NumberredMargin(display_tildes=True)
if bool(egc.TEXT_EDITOR_ENABLE_RIGHT_MARGIN) is True:
self._right_margin = ScrollbarMargin(display_arrows=True)
self._buffer_control = BufferControl(buffer_name=self._editor_buffer_name)
self._editor_aiml_code_window = Window(content=self._buffer_control, left_margins=[self._left_margin,])
self._vertical_line = FillControl('|', token=Token.Line)
self._window_separater = Window(width=D.exact(1), content=self._vertical_line)
self._aiml_list = TokenListControl(get_tokens=self.get_aiml_list)
self._editor_aiml_list_window = Window(content=self._aiml_list, right_margins=[self._right_margin,])
self._layout = VSplit([
self._editor_aiml_code_window,
self._window_separater,
self._editor_aiml_list_window,
])
def get_dimensions(cli):
"""
Return a list of LayoutDimension instances for this split.
These dimensions will take the weight from the
arrangement.VSplit/HSplit instances.
"""
average_weight = get_average_weight()
# Make sure that weight is distributed
result = []
for i, item in enumerate(split):
result.append(D(weight=split.weights.get(item) or average_weight))
# Add dimension for the vertical border.
if is_vsplit and i != len(split) - 1:
result.append(D.exact(1))
return result
def create_layout_from_node(node):
if isinstance(node, window_arrangement.Window):
# Create frame for Window, or reuse it, if we had one already.
key = (node, node.editor_buffer)
frame = existing_frames.get(key)
if frame is None:
frame = self._create_window_frame(node.editor_buffer)
self._frames[key] = frame
return frame
elif isinstance(node, window_arrangement.VSplit):
children = []
for n in node:
children.append(create_layout_from_node(n))
children.append(Window(width=LayoutDimension.exact(1),
content=FillControl('\u2502', token=Token.FrameBorder)))
children.pop()
return VSplit(children)
if isinstance(node, window_arrangement.HSplit):
return HSplit([create_layout_from_node(n) for n in node])
def create_tutorial_layout(lex):
""" layout for example tutorial """
lexer, _, _ = get_lexers(lex, None, None)
layout_full = HSplit([
FloatContainer(
Window(
BufferControl(
input_processors=input_processors,
lexer=lexer,
preview_search=Always()),
get_height=get_height),
[
Float(xcursor=True,
ycursor=True,
content=CompletionsMenu(
max_height=MAX_COMPLETION,
scroll_offset=1,
extra_filter=(HasFocus(DEFAULT_BUFFER))))]),
ConditionalContainer(
HSplit([
get_hline(),
get_param(lexer),
get_hline(),
Window(
content=BufferControl(
buffer_name='example_line',
lexer=lexer
),
),
Window(
TokenListControl(
get_tutorial_tokens,
default_char=Char(' ', Token.Toolbar)),
height=D.exact(1)),
]),
filter=~IsDone() & RendererHeightIsKnown()
)
])
return layout_full
def __init__(self, editor):
super(TabsToolbar, self).__init__(
Window(TabsControl(editor), height=LayoutDimension.exact(1)),
filter=Condition(lambda cli: len(editor.window_arrangement.tab_pages) > 1))
# larger than what was available to the window.
# So, for this example, we create a layout that shows the content of the
# default buffer on the left, shows a line in the middle and another buffer
# (called 'RESULT') on the right.
layout = VSplit([
# One window that holds the BufferControl with the default buffer on the
# left.
Window(content=BufferControl(buffer_name=DEFAULT_BUFFER)),
# A vertical line in the middle. We explicitely specify the width, to make
# sure that the layout engine will not try to divide the whole width by
# three for all these windows. The `FillControl` will simply fill the whole
# window by repeating this character.
Window(width=D.exact(1),
content=FillControl('|', token=Token.Line)),
# Display the Result buffer on the right.
Window(content=BufferControl(buffer_name='RESULT')),
])
# As a demonstration. Let's add a title bar to the top, displaying "Hello world".
# somewhere, because usually the default key bindings include searching. (Press
# Ctrl-R.) It would be really annoying if the search key bindings are handled,
# but the user doesn't see any feedback. We will add the search toolbar to the
# bottom by using an HSplit.
def get_titlebar_tokens(cli):
return [
def get_hline():
""" gets a horiztonal line """
return Window(
width=D.exact(1),
height=D.exact(1),
content=FillControl('-', token=Token.Line))
def get_vline():
""" gets a vertical line """
return Window(
width=D.exact(1),
height=D.exact(1),
content=FillControl('*', token=Token.Line))
def create_layout(python_input, history_mapping):
"""
Create and return a `Container` instance for the history
application.
"""
processors = [
HighlightSearchProcessor(preview_search=True),
HighlightSelectionProcessor()]
help_window = create_popup_window(
title='History Help',
body=Window(
content=BufferControl(
buffer_name=HELP_BUFFER,
default_char=Char(token=Token),
lexer=PygmentsLexer(RstLexer),
input_processors=processors),
right_margins=[ScrollbarMargin()],
scroll_offsets=ScrollOffsets(top=2, bottom=2)))
return HSplit([
# Top title bar.
TokenListToolbar(
get_tokens=_get_top_toolbar_tokens,
align_center=True,
default_char=Char(' ', Token.Toolbar.Status)),
FloatContainer(
content=VSplit([
# Left side: history.
Window(
content=BufferControl(
buffer_name=HISTORY_BUFFER,
lexer=PygmentsLexer(PythonLexer),
input_processors=processors),
wrap_lines=False,
left_margins=[HistoryMargin(history_mapping)],
scroll_offsets=ScrollOffsets(top=2, bottom=2)),
# Separator.
Window(width=D.exact(1),
content=FillControl(BORDER.LIGHT_VERTICAL, token=Token.Separator)),
# Right side: result.
Window(
content=BufferControl(
buffer_name=DEFAULT_BUFFER,
input_processors=processors + [GrayExistingText(history_mapping)],
lexer=PygmentsLexer(PythonLexer)),
wrap_lines=False,
left_margins=[ResultMargin(history_mapping)],
scroll_offsets=ScrollOffsets(top=2, bottom=2)),
]),
floats=[
# Help text as a float.
Float(width=60, top=3, bottom=2,
content=ConditionalContainer(
# (We use InFocusStack, because it's possible to search
# through the help text as well, and at that point the search
# buffer has the focus.)
content=help_window, filter=InFocusStack(HELP_BUFFER))),
]
),
# Bottom toolbars.
ArgToolbar(),
SearchToolbar(),
TokenListToolbar(
get_tokens=partial(_get_bottom_toolbar_tokens, python_input=python_input),
default_char=Char(' ', Token.Toolbar.Status)),
])
def create_popup_window(title, body):
"""
Return the layout for a pop-up window. It consists of a title bar showing
the `title` text, and a body layout. The window is surrounded by borders.
"""
assert isinstance(title, six.text_type)
assert isinstance(body, Container)
return HSplit([
VSplit([
Window(width=D.exact(1), height=D.exact(1),
content=FillControl(BORDER.TOP_LEFT, token=Token.Window.Border)),
TokenListToolbar(
get_tokens=lambda cli: [(Token.Window.Title, ' %s ' % title)],
align_center=True,
default_char=Char(BORDER.HORIZONTAL, Token.Window.Border)),
Window(width=D.exact(1), height=D.exact(1),
content=FillControl(BORDER.TOP_RIGHT, token=Token.Window.Border)),
]),
VSplit([
Window(width=D.exact(1),
content=FillControl(BORDER.VERTICAL, token=Token.Window.Border)),
body,
Window(width=D.exact(1),
content=FillControl(BORDER.VERTICAL, token=Token.Window.Border)),
]),
VSplit([
Window(width=D.exact(1), height=D.exact(1),
content=FillControl(BORDER.BOTTOM_LEFT, token=Token.Window.Border)),
Window(height=D.exact(1),
content=FillControl(BORDER.HORIZONTAL, token=Token.Window.Border)),
Window(width=D.exact(1), height=D.exact(1),
content=FillControl(BORDER.BOTTOM_RIGHT, token=Token.Window.Border)),
]),
])
