def init_prompt_toolkit_cli(self):
if ('IPY_TEST_SIMPLE_PROMPT' in os.environ) or not sys.stdin.isatty():
# Fall back to plain non-interactive output for tests.
# This is very limited, and only accepts a single line.
def prompt():
return cast_unicode_py2(
input('In [%d]: ' % self.execution_count))
self.prompt_for_code = prompt
return
kbmanager = KeyBindingManager.for_prompt(enable_vi_mode=self.vi_mode)
insert_mode = ViStateFilter(kbmanager.get_vi_state, InputMode.INSERT)
# Ctrl+J == Enter, seemingly
@kbmanager.registry.add_binding(Keys.ControlJ,
filter=(HasFocus(DEFAULT_BUFFER)
& ~HasSelection()
& insert_mode))
def _(event):
b = event.current_buffer
d = b.document
if not (d.on_last_line or d.cursor_position_row >=
d.line_count - d.empty_line_count_at_the_end()):
b.newline()
return
status, indent = self.input_splitter.check_complete(d.text)
if (status != 'incomplete') and b.accept_action.is_returnable:
b.accept_action.validate_and_handle(event.cli, b)
else:
b.insert_text('\n' + (' ' * (indent or 0)))
@kbmanager.registry.add_binding(Keys.ControlC)
def _(event):
event.current_buffer.reset()
@Condition
def cursor_in_leading_ws(cli):
before = cli.application.buffer.document.current_line_before_cursor
return (not before) or before.isspace()
# Ctrl+I == Tab
@kbmanager.registry.add_binding(Keys.ControlI,
filter=(HasFocus(DEFAULT_BUFFER)
& ~HasSelection()
& insert_mode
& cursor_in_leading_ws))
def _(event):
event.current_buffer.insert_text(' ' * 4)
# Pre-populate history from IPython's history database
history = InMemoryHistory()
last_cell = u""
for _, _, cell in self.history_manager.get_tail(
self.history_load_length, include_latest=True):
# Ignore blank lines and consecutive duplicates
cell = cell.rstrip()
if cell and (cell != last_cell):
history.append(cell)
style_overrides = {
Token.Prompt: '#009900',
Token.PromptNum: '#00ff00 bold',
}
if self.highlighting_style:
style_cls = get_style_by_name(self.highlighting_style)
else:
style_cls = get_style_by_name('default')
# The default theme needs to be visible on both a dark background
# and a light background, because we can't tell what the terminal
# looks like. These tweaks to the default theme help with that.
style_overrides.update({
Token.Number: '#007700',
Token.Operator: 'noinherit',
Token.String: '#BB6622',
Token.Name.Function: '#2080D0',
Token.Name.Class: 'bold #2080D0',
Token.Name.Namespace: 'bold #2080D0',
})
style_overrides.update(self.highlighting_style_overrides)
style = PygmentsStyle.from_defaults(pygments_style_cls=style_cls,
style_dict=style_overrides)
app = create_prompt_application(
multiline=True,
lexer=PygmentsLexer(Python3Lexer if PY3 else PythonLexer),
get_prompt_tokens=self.get_prompt_tokens,
get_continuation_tokens=self.get_continuation_tokens,
key_bindings_registry=kbmanager.registry,
history=history,
completer=IPythonPTCompleter(self.Completer),
enable_history_search=True,
style=style,
mouse_support=self.mouse_support,
)
self.pt_cli = CommandLineInterface(app,
eventloop=create_eventloop(
self.inputhook))
def create_key_bindings(editor):
"""
Create custom key bindings.
This starts with the key bindings, defined by `prompt-toolkit`, but adds
the ones which are specific for the editor.
"""
# Create new Key binding manager.
manager = KeyBindingManager(enable_vi_mode=Always(),
enable_search=True,
enable_extra_page_navigation=Always(),
enable_system_bindings=Always())
# Filters.
vi_buffer_focussed = Condition(
lambda cli: cli.current_buffer_name.startswith('buffer-'))
in_insert_mode = (ViStateFilter(manager.get_vi_state, InputMode.INSERT)
& vi_buffer_focussed)
in_navigation_mode = (ViStateFilter(
manager.get_vi_state, InputMode.NAVIGATION) & vi_buffer_focussed)
# Decorator.
handle = create_handle_decorator(manager.registry)
@handle(Keys.ControlT)
def _(event):
"""
Override default behaviour of prompt-toolkit.
(Control-T will swap the last two characters before the cursor, because
that's what readline does.)
"""
pass
@handle(Keys.ControlT, filter=in_insert_mode)
def indent_line(event):
"""
Indent current line.
"""
b = event.cli.current_buffer
# Move to start of line.
pos = b.document.get_start_of_line_position(after_whitespace=True)
b.cursor_position += pos
# Insert tab.
if editor.expand_tab:
b.insert_text(' ')
else:
b.insert_text('\t')
# Restore cursor.
b.cursor_position -= pos
@handle(Keys.ControlR,
filter=in_navigation_mode,
save_before=(lambda e: False))
def redo(event):
"""
Redo.
"""
event.cli.current_buffer.redo()
@handle(':', filter=in_navigation_mode)
def enter_command_mode(event):
"""
Entering command mode.
"""
editor.enter_command_mode()
@handle(Keys.Tab,
filter=ViStateFilter(manager.get_vi_state, InputMode.INSERT)
& ~HasFocus(COMMAND_BUFFER) & WhitespaceBeforeCursorOnLine())
def autocomplete_or_indent(event):
"""
When the 'tab' key is pressed with only whitespace character before the
cursor, do autocompletion. Otherwise, insert indentation.
"""
b = event.cli.current_buffer
if editor.expand_tab:
b.insert_text(' ')
else:
b.insert_text('\t')
@handle(Keys.Escape, filter=HasFocus(COMMAND_BUFFER))
@handle(Keys.ControlC, filter=HasFocus(COMMAND_BUFFER))
@handle(Keys.Backspace,
filter=HasFocus(COMMAND_BUFFER)
& Condition(lambda cli: cli.buffers[COMMAND_BUFFER].text == ''))
def leave_command_mode(event):
"""
Leaving command mode.
"""
editor.leave_command_mode()
@handle(Keys.ControlW, Keys.ControlW, filter=in_navigation_mode)
def focus_next_window(event):
editor.window_arrangement.cycle_focus()
editor.sync_with_prompt_toolkit()
@handle(Keys.ControlW, 'n', filter=in_navigation_mode)
def horizontal_split(event):
"""
Split horizontally.
"""
editor.window_arrangement.hsplit(None)
editor.sync_with_prompt_toolkit()
@handle(Keys.ControlW, 'v', filter=in_navigation_mode)
def vertical_split(event):
"""
Split vertically.
"""
editor.window_arrangement.vsplit(None)
editor.sync_with_prompt_toolkit()
@handle('g', 't', filter=in_navigation_mode)
def focus_next_tab(event):
editor.window_arrangement.go_to_next_tab()
editor.sync_with_prompt_toolkit()
@handle('g', 'T', filter=in_navigation_mode)
def focus_previous_tab(event):
editor.window_arrangement.go_to_previous_tab()
editor.sync_with_prompt_toolkit()
@handle(Keys.ControlJ, filter=in_navigation_mode)
def goto_line_beginning(event):
""" Enter in navigation mode should move to the start of the next line. """
b = event.current_buffer
b.cursor_down(count=event.arg)
b.cursor_position += b.document.get_start_of_line_position(
after_whitespace=True)
@handle(Keys.F1)
def show_help(event):
editor.show_help()
return manager
def load_python_bindings(key_bindings_manager, settings, add_buffer,
close_current_buffer):
"""
Custom key bindings.
"""
handle = key_bindings_manager.registry.add_binding
has_selection = HasSelection()
vi_navigation_mode = ViStateFilter(key_bindings_manager.vi_state, InputMode.NAVIGATION) & \
~ HasSelection()
@handle(Keys.F2)
def _(event):
"""
Show/hide sidebar.
"""
settings.show_sidebar = not settings.show_sidebar
@handle(Keys.F3)
def _(event):
"""
Shange completion style.
"""
# Toggle between combinations.
settings.show_completions_toolbar, settings.show_completions_menu = {
(False, False): (False, True),
(False, True): (True, False),
(True, False): (False, False),
}[settings.show_completions_toolbar, settings.show_completions_menu]
@handle(Keys.F4)
def _(event):
"""
Toggle between Vi and Emacs mode.
"""
key_bindings_manager.enable_vi_mode = not key_bindings_manager.enable_vi_mode
@handle(Keys.F6)
def _(event):
"""
Enable/Disable paste mode.
"""
settings.paste_mode = not settings.paste_mode
@handle(Keys.F7)
def _(event):
"""
Enable/Disable multiline mode.
"""
settings.currently_multiline = not settings.currently_multiline
@handle(Keys.F8)
def _(event):
"""
Show/hide signature.
"""
settings.show_signature = not settings.show_signature
@handle(Keys.F9)
def _(event):
"""
Show/hide docstring window.
"""
settings.show_docstring = not settings.show_docstring
@handle(Keys.F10)
def _(event):
"""
Show/hide line numbers
"""
settings.show_line_numbers = not settings.show_line_numbers
@handle(Keys.F5)
def _(event):
"""
Show all buffers
"""
settings.show_all_buffers = not settings.show_all_buffers
@handle('g', 't', filter=vi_navigation_mode)
@handle(Keys.ControlRight)
def _(event):
"""
Focus next tab.
"""
focus_next_buffer(event.cli)
@handle('g', 'T', filter=vi_navigation_mode)
@handle(Keys.ControlLeft)
def _(event):
"""
Focus previous tab.
"""
focus_previous_buffer(event.cli)
# @handle(Keys.F5, filter=filters.HasFocus('default') & ~has_selection) # XXX: use current tab
# def _(event):
# """
# Merge the previous entry from the history on top.
# """
# buffer = event.cli.buffers['default']
#
# buffer.text = buffer._working_lines[buffer.working_index - 1] + '\n' + buffer.text
# buffer._working_lines = buffer._working_lines[:buffer.working_index - 1] + buffer._working_lines[buffer.working_index:]
# buffer.working_index -= 1
@handle(Keys.ControlT, filter=IsPythonBufferFocussed() & ~has_selection)
def _(event):
"""
Create a new Python buffer.
"""
add_buffer()
@handle(Keys.ControlD, filter=IsPythonBufferFocussed())
def _(event):
"""
Close Python buffer.
"""
close_current_buffer()
@handle(Keys.Tab, filter=~has_selection)
def _(event):
"""
When the 'tab' key is pressed with only whitespace character before the
cursor, do autocompletion. Otherwise, insert indentation.
"""
buffer = event.cli.current_buffer
current_char = buffer.document.current_line_before_cursor
if not current_char or current_char.isspace():
buffer.insert_text(' ')
else:
buffer.complete_next()
@handle(Keys.ControlJ,
filter=~has_selection
& ~(ViModeEnabled(key_bindings_manager) & ViStateFilter(
key_bindings_manager.vi_state, InputMode.NAVIGATION))
& IsPythonBufferFocussed() & IsMultiline())
def _(event):
"""
Auto indent after newline/Enter.
(When not in Vi navigaton mode, and when multiline is enabled.)
"""
buffer = event.current_buffer
if settings.paste_mode:
buffer.insert_text('\n')
else:
auto_newline(buffer)
def load_python_bindings(key_bindings_manager, python_input):
"""
Custom key bindings.
"""
sidebar_visible = Condition(lambda cli: python_input.show_sidebar)
handle = key_bindings_manager.registry.add_binding
has_selection = HasSelection()
vi_mode_enabled = Condition(lambda cli: python_input.vi_mode)
@handle(Keys.ControlL)
def _(event):
"""
Clear whole screen and render again -- also when the sidebar is visible.
"""
event.cli.renderer.clear()
@handle(Keys.F2)
def _(event):
"""
Show/hide sidebar.
"""
python_input.show_sidebar = not python_input.show_sidebar
@handle(Keys.F3)
def _(event):
"""
Select from the history.
"""
python_input.key_bindings_manager.get_vi_state(
event.cli).input_mode = InputMode.NAVIGATION
def done(result):
if result is not None:
event.cli.buffers[DEFAULT_BUFFER].document = result
python_input.key_bindings_manager.get_vi_state(
event.cli).input_mode = InputMode.INSERT
event.cli.run_sub_application(
create_history_application(
python_input, event.cli.buffers[DEFAULT_BUFFER].document),
done)
@handle(Keys.F4)
def _(event):
"""
Toggle between Vi and Emacs mode.
"""
python_input.vi_mode = not python_input.vi_mode
@handle(Keys.F6)
def _(event):
"""
Enable/Disable paste mode.
"""
python_input.paste_mode = not python_input.paste_mode
@handle(Keys.Tab,
filter=~sidebar_visible & ~has_selection
& TabShouldInsertWhitespaceFilter())
def _(event):
"""
When tab should insert whitespace, do that instead of completion.
"""
event.cli.current_buffer.insert_text(' ')
@handle(Keys.ControlJ,
filter=~sidebar_visible & ~has_selection
& ~(vi_mode_enabled & ViStateFilter(
key_bindings_manager.get_vi_state, InputMode.NAVIGATION))
& HasFocus(DEFAULT_BUFFER) & IsMultiline())
def _(event):
"""
Behaviour of the Enter key.
Auto indent after newline/Enter.
(When not in Vi navigaton mode, and when multiline is enabled.)
"""
b = event.current_buffer
empty_lines_required = python_input.accept_input_on_enter or 10000
def at_the_end(b):
""" we consider the cursor at the end when there is no text after
the cursor, or only whitespace. """
text = b.document.text_after_cursor
return text == '' or (text.isspace() and not '\n' in text)
if python_input.paste_mode:
# In paste mode, always insert text.
b.insert_text('\n')
elif at_the_end(b) and b.document.text.replace(' ', '').endswith(
'\n' * (empty_lines_required - 1)):
if b.validate():
# When the cursor is at the end, and we have an empty line:
# drop the empty lines, but return the value.
b.document = Document(text=b.text.rstrip(),
cursor_position=len(b.text.rstrip()))
b.accept_action.validate_and_handle(event.cli, b)
else:
auto_newline(b)
@handle(
Keys.ControlD,
filter=~sidebar_visible
& Condition(lambda cli:
# Only when the `confirm_exit` flag is set.
python_input.confirm_exit and
# And the current buffer is empty.
cli.current_buffer_name == DEFAULT_BUFFER and not cli.
current_buffer.text))
def _(event):
"""
Override Control-D exit, to ask for confirmation.
"""
python_input.show_exit_confirmation = True
def init_prompt_toolkit_cli(self):
if ('IPY_TEST_SIMPLE_PROMPT' in os.environ) or not sys.stdin.isatty():
# Fall back to plain non-interactive output for tests.
# This is very limited, and only accepts a single line.
def prompt():
return cast_unicode_py2(input('In [%d]: ' % self.execution_count))
self.prompt_for_code = prompt
return
kbmanager = KeyBindingManager.for_prompt(enable_vi_mode=self.vi_mode)
insert_mode = ViStateFilter(kbmanager.get_vi_state, InputMode.INSERT)
# Ctrl+J == Enter, seemingly
@kbmanager.registry.add_binding(Keys.ControlJ,
filter=(HasFocus(DEFAULT_BUFFER)
& ~HasSelection()
& insert_mode
))
def _(event):
b = event.current_buffer
d = b.document
if not (d.on_last_line or d.cursor_position_row >= d.line_count
- d.empty_line_count_at_the_end()):
b.newline()
return
status, indent = self.input_splitter.check_complete(d.text)
if (status != 'incomplete') and b.accept_action.is_returnable:
b.accept_action.validate_and_handle(event.cli, b)
else:
b.insert_text('\n' + (' ' * (indent or 0)))
@kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(DEFAULT_BUFFER))
def _(event):
event.current_buffer.reset()
@kbmanager.registry.add_binding(Keys.ControlC, filter=HasFocus(SEARCH_BUFFER))
def _(event):
if event.current_buffer.document.text:
event.current_buffer.reset()
else:
event.cli.push_focus(DEFAULT_BUFFER)
supports_suspend = Condition(lambda cli: hasattr(signal, 'SIGTSTP'))
@kbmanager.registry.add_binding(Keys.ControlZ, filter=supports_suspend)
def _(event):
event.cli.suspend_to_background()
@Condition
def cursor_in_leading_ws(cli):
before = cli.application.buffer.document.current_line_before_cursor
return (not before) or before.isspace()
# Ctrl+I == Tab
@kbmanager.registry.add_binding(Keys.ControlI,
filter=(HasFocus(DEFAULT_BUFFER)
& ~HasSelection()
& insert_mode
& cursor_in_leading_ws
))
def _(event):
event.current_buffer.insert_text(' ' * 4)
# Pre-populate history from IPython's history database
history = InMemoryHistory()
last_cell = u""
for _, _, cell in self.history_manager.get_tail(self.history_load_length,
include_latest=True):
# Ignore blank lines and consecutive duplicates
cell = cell.rstrip()
if cell and (cell != last_cell):
history.append(cell)
self._style = self._make_style_from_name(self.highlighting_style)
style = DynamicStyle(lambda: self._style)
self._app = create_prompt_application(
key_bindings_registry=kbmanager.registry,
history=history,
completer=IPythonPTCompleter(self.Completer),
enable_history_search=True,
style=style,
mouse_support=self.mouse_support,
**self._layout_options()
)
self.pt_cli = CommandLineInterface(self._app,
eventloop=create_eventloop(self.inputhook))
def create_key_bindings(editor):
"""
Create custom key bindings.
This starts with the key bindings, defined by `prompt-toolkit`, but adds
the ones which are specific for the editor.
"""
# Create new Key binding manager.
manager = KeyBindingManager(enable_vi_mode=True, enable_system_prompt=True)
manager.vi_state.input_mode = InputMode.NAVIGATION
# Filters.
vi_buffer_focussed = Condition(
lambda cli: cli.current_buffer_name.startswith('buffer-'))
in_insert_mode = (ViStateFilter(manager.vi_state, InputMode.INSERT)
& vi_buffer_focussed)
in_navigation_mode = (ViStateFilter(manager.vi_state, InputMode.NAVIGATION)
& vi_buffer_focussed)
# Decorator.
handle = create_handle_decorator(manager.registry)
@handle(Keys.ControlF)
def _(event):
"""
Scroll window down.
"""
w = find_window_for_buffer_name(event.cli.layout,
event.cli.current_buffer_name)
b = event.cli.current_buffer
if w and w.render_info:
new_document_line = min(
b.document.line_count - 1, b.document.cursor_position_row +
int(w.render_info.rendered_height / 2))
b.cursor_position = b.document.translate_row_col_to_index(
new_document_line, 0)
w.vertical_scroll = w.render_info.input_line_to_screen_line(
new_document_line)
@handle(Keys.ControlT, filter=in_insert_mode)
def _(event):
"""
Indent current line.
"""
b = event.cli.current_buffer
# Move to start of line.
pos = b.document.get_start_of_line_position(after_whitespace=True)
b.cursor_position += pos
# Insert tab.
if editor.expand_tab:
b.insert_text(' ')
else:
b.insert_text('\t')
# Restore cursor.
b.cursor_position -= pos
@handle(Keys.ControlU)
def _(event):
"""
Scroll window up.
"""
w = find_window_for_buffer_name(event.cli.layout,
event.cli.current_buffer_name)
b = event.cli.current_buffer
if w and w.render_info:
new_document_line = max(
0, b.document.cursor_position_row -
int(w.render_info.rendered_height / 2))
b.cursor_position = b.document.translate_row_col_to_index(
new_document_line, 0)
w.vertical_scroll = w.render_info.input_line_to_screen_line(
new_document_line)
@handle(Keys.ControlR, filter=in_navigation_mode, save_before=False)
def _(event):
"""
Redo.
"""
event.cli.current_buffer.redo()
@handle(':', filter=in_navigation_mode)
def enter_command_mode(event):
"""
Entering command mode.
"""
editor.enter_command_mode()
@handle(Keys.Tab,
filter=ViStateFilter(manager.vi_state, InputMode.INSERT)
& ~HasFocus(COMMAND_BUFFER) & WhitespaceBeforeCursorOnLine())
def _(event):
"""
When the 'tab' key is pressed with only whitespace character before the
cursor, do autocompletion. Otherwise, insert indentation.
"""
b = event.cli.current_buffer
if editor.expand_tab:
b.insert_text(' ')
else:
b.insert_text('\t')
@handle(Keys.Escape, filter=HasFocus(COMMAND_BUFFER))
@handle(Keys.ControlC, filter=HasFocus(COMMAND_BUFFER))
@handle(Keys.Backspace,
filter=HasFocus(COMMAND_BUFFER)
& Condition(lambda cli: cli.buffers[COMMAND_BUFFER].text == ''))
def leave_command_mode(event):
"""
Leaving command mode.
"""
editor.leave_command_mode()
@handle(Keys.ControlW, Keys.ControlW, filter=in_navigation_mode)
def focus_next_window(event):
editor.window_arrangement.cycle_focus()
editor.sync_with_prompt_toolkit()
@handle('g', 't', filter=in_navigation_mode)
def focus_next_tab(event):
editor.window_arrangement.go_to_next_tab()
editor.sync_with_prompt_toolkit()
@handle('g', 'T', filter=in_navigation_mode)
def focus_previous_tab(event):
editor.window_arrangement.go_to_previous_tab()
editor.sync_with_prompt_toolkit()
@handle(Keys.ControlJ, filter=in_navigation_mode)
def _(event):
""" Enter in navigation mode should move to the start of the next line. """
b = event.current_buffer
b.cursor_down(count=event.arg)
b.cursor_position += b.document.get_start_of_line_position(
after_whitespace=True)
@handle(Keys.F1)
def show_help(event):
editor.show_help()
return manager
def load_python_bindings(key_bindings_manager, settings):
"""
Custom key bindings.
"""
handle = key_bindings_manager.registry.add_binding
has_selection = HasSelection()
@handle(Keys.F2)
def _(event):
"""
Show/hide sidebar.
"""
settings.show_sidebar = not settings.show_sidebar
@handle(Keys.F3)
def _(event):
"""
Shange completion style.
"""
# Toggle between combinations.
settings.show_completions_toolbar, settings.show_completions_menu = {
(False, False): (False, True),
(False, True): (True, False),
(True, False): (False, False),
}[settings.show_completions_toolbar, settings.show_completions_menu]
@handle(Keys.F4)
def _(event):
"""
Toggle between Vi and Emacs mode.
"""
key_bindings_manager.enable_vi_mode = not key_bindings_manager.enable_vi_mode
@handle(Keys.F5)
def _(event):
"""
Enable/Disable complete while typing.
"""
settings.complete_while_typing = not settings.complete_while_typing
@handle(Keys.F6)
def _(event):
"""
Enable/Disable paste mode.
"""
settings.paste_mode = not settings.paste_mode
@handle(Keys.F8)
def _(event):
"""
Show/hide signature.
"""
settings.show_signature = not settings.show_signature
@handle(Keys.F9)
def _(event):
"""
Show/hide docstring window.
"""
settings.show_docstring = not settings.show_docstring
@handle(Keys.F10)
def _(event):
"""
Show/hide line numbers
"""
settings.show_line_numbers = not settings.show_line_numbers
@handle(Keys.Tab,
filter=~has_selection & TabShouldInsertWhitespaceFilter())
def _(event):
"""
When tab should insert whitespace, do that instead of completion.
"""
event.cli.current_buffer.insert_text(' ')
@handle(Keys.ControlJ,
filter=~has_selection
& ~(ViModeEnabled(key_bindings_manager) & ViStateFilter(
key_bindings_manager.vi_state, InputMode.NAVIGATION))
& HasFocus('default') & IsMultiline())
def _(event):
"""
Behaviour of the Enter key.
Auto indent after newline/Enter.
(When not in Vi navigaton mode, and when multiline is enabled.)
"""
b = event.current_buffer
def at_the_end(b):
""" we consider the cursor at the end when there is no text after
the cursor, or only whitespace. """
text = b.document.text_after_cursor
return text == '' or (text.isspace() and not '\n' in text)
if settings.paste_mode:
# In paste mode, always insert text.
b.insert_text('\n')
elif at_the_end(b) and b.document.text.replace(' ', '').endswith('\n'):
if b.validate():
# When the cursor is at the end, and we have an empty line:
# drop the empty lines, but return the value.
b.document = Document(text=b.text.rstrip(),
cursor_position=len(b.text.rstrip()))
b.append_to_history()
event.cli.set_return_value(b.document)
else:
auto_newline(b)
def edit_file(filename):
manager = KeyBindingManager(enable_vi_mode=True, enable_system_prompt=True)
manager.vi_state.input_mode = InputMode.NAVIGATION
layout = HSplit([
Header(),
Window(content=BufferControl(show_line_numbers=AlwaysOn(),
lexer=get_lexer_for_filename(
filename).__class__)),
VimToolbar(filename, manager),
VimInputBar(),
SystemToolbar(),
SearchToolbar(),
])
with codecs.open(filename, 'r', 'utf-8') as f:
text = f.read()
@manager.registry.add_binding(':',
filter=ViStateFilter(manager.vi_state,
InputMode.NAVIGATION))
def enter_command_mode(event):
"""
Entering command mode.
"""
event.cli.focus_stack.push('vim-input')
manager.vi_state.input_mode = InputMode.INSERT
@manager.registry.add_binding(Keys.Escape, filter=HasFocus('vim-input'))
@manager.registry.add_binding(Keys.ControlC, filter=HasFocus('vim-input'))
@manager.registry.add_binding(
Keys.Backspace,
filter=HasFocus('vim-input')
& Condition(lambda cli: cli.buffers['vim-input'].text == ''))
def leave_command_mode(event):
"""
Leaving command mode.
"""
event.cli.focus_stack.pop()
manager.vi_state.input_mode = InputMode.NAVIGATION
event.cli.buffers['vim-input'].document = Document()
@manager.registry.add_binding(Keys.ControlJ, filter=HasFocus('vim-input'))
def process_command(event):
"""
Handling of commands.
"""
text = event.current_buffer.text
def save():
with codecs.open(filename, 'w', 'utf-8') as f:
f.write(event.cli.buffers['default'].text)
def leave_command_mode():
event.cli.focus_stack.pop()
manager.vi_state.input_mode = InputMode.NAVIGATION
event.cli.buffers['vim-input'].document = Document()
if text == 'w':
save()
leave_command_mode()
elif text in ('wq', 'wqa'):
save()
event.cli.set_return_value('')
elif text in ('q', 'qa', 'q!', 'qa!'):
event.cli.set_return_value('')
else:
leave_command_mode()
# TODO: validation of other commands.
cli = CommandLineInterface(
layout=layout,
renderer=Renderer(use_alternate_screen=True),
key_bindings_registry=manager.registry,
buffers={
'default':
Buffer(returnable=AlwaysOff(),
is_multiline=True,
initial_document=Document(text, 0)),
'vim-input':
Buffer(returnable=AlwaysOff()),
},
style=VimStyle,
)
# Run interface.
cli.read_input()