batuhan-basoglu/Vehicle-Anti-Theft-Face-Recognition-System
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Vehicle-Anti-Theft-Face-Rec.../venv/Lib/site-packages/prompt_toolkit/key_binding/bindings/vi.py

2222 lines
74 KiB
Python
Raw Normal View History

Uploaded Test files
2020-11-12 16:05:57 +00:00
# pylint: disable=function-redefined
import codecs
import string
from enum import Enum
from itertools import accumulate
from typing import Callable, Iterable, List, Optional, Tuple, TypeVar, Union, cast
from prompt_toolkit.application.current import get_app
from prompt_toolkit.buffer import Buffer, indent, reshape_text, unindent
from prompt_toolkit.clipboard import ClipboardData
from prompt_toolkit.document import Document
from prompt_toolkit.filters import (
Always,
Condition,
Filter,
has_arg,
is_read_only,
is_searching,
)
from prompt_toolkit.filters.app import (
in_paste_mode,
is_multiline,
vi_digraph_mode,
vi_insert_mode,
vi_insert_multiple_mode,
vi_mode,
vi_navigation_mode,
vi_recording_macro,
vi_replace_mode,
vi_replace_single_mode,
vi_search_direction_reversed,
vi_selection_mode,
vi_waiting_for_text_object_mode,
)
from prompt_toolkit.input.vt100_parser import Vt100Parser
from prompt_toolkit.key_binding.digraphs import DIGRAPHS
from prompt_toolkit.key_binding.key_processor import KeyPress, KeyPressEvent
from prompt_toolkit.key_binding.vi_state import CharacterFind, InputMode
from prompt_toolkit.keys import Keys
from prompt_toolkit.search import SearchDirection
from prompt_toolkit.selection import PasteMode, SelectionState, SelectionType
from ..key_bindings import ConditionalKeyBindings, KeyBindings, KeyBindingsBase
from .named_commands import get_by_name
__all__ = [
"load_vi_bindings",
"load_vi_search_bindings",
]
E = KeyPressEvent
ascii_lowercase = string.ascii_lowercase
vi_register_names = ascii_lowercase + "0123456789"
class TextObjectType(Enum):
EXCLUSIVE = "EXCLUSIVE"
INCLUSIVE = "INCLUSIVE"
LINEWISE = "LINEWISE"
BLOCK = "BLOCK"
class TextObject:
"""
Return struct for functions wrapped in ``text_object``.
Both `start` and `end` are relative to the current cursor position.
"""
def __init__(
self, start: int, end: int = 0, type: TextObjectType = TextObjectType.EXCLUSIVE
):
self.start = start
self.end = end
self.type = type
@property
def selection_type(self) -> SelectionType:
if self.type == TextObjectType.LINEWISE:
return SelectionType.LINES
if self.type == TextObjectType.BLOCK:
return SelectionType.BLOCK
else:
return SelectionType.CHARACTERS
def sorted(self) -> Tuple[int, int]:
"""
Return a (start, end) tuple where start <= end.
"""
if self.start < self.end:
return self.start, self.end
else:
return self.end, self.start
def operator_range(self, document: Document) -> Tuple[int, int]:
"""
Return a (start, end) tuple with start <= end that indicates the range
operators should operate on.
`buffer` is used to get start and end of line positions.
This should return something that can be used in a slice, so the `end`
position is *not* included.
"""
start, end = self.sorted()
doc = document
if (
self.type == TextObjectType.EXCLUSIVE
and doc.translate_index_to_position(end + doc.cursor_position)[1] == 0
):
# If the motion is exclusive and the end of motion is on the first
# column, the end position becomes end of previous line.
end -= 1
if self.type == TextObjectType.INCLUSIVE:
end += 1
if self.type == TextObjectType.LINEWISE:
# Select whole lines
row, col = doc.translate_index_to_position(start + doc.cursor_position)
start = doc.translate_row_col_to_index(row, 0) - doc.cursor_position
row, col = doc.translate_index_to_position(end + doc.cursor_position)
end = (
doc.translate_row_col_to_index(row, len(doc.lines[row]))
- doc.cursor_position
)
return start, end
def get_line_numbers(self, buffer: Buffer) -> Tuple[int, int]:
"""
Return a (start_line, end_line) pair.
"""
# Get absolute cursor positions from the text object.
from_, to = self.operator_range(buffer.document)
from_ += buffer.cursor_position
to += buffer.cursor_position
# Take the start of the lines.
from_, _ = buffer.document.translate_index_to_position(from_)
to, _ = buffer.document.translate_index_to_position(to)
return from_, to
def cut(self, buffer: Buffer) -> Tuple[Document, ClipboardData]:
"""
Turn text object into `ClipboardData` instance.
"""
from_, to = self.operator_range(buffer.document)
from_ += buffer.cursor_position
to += buffer.cursor_position
# For Vi mode, the SelectionState does include the upper position,
# while `self.operator_range` does not. So, go one to the left, unless
# we're in the line mode, then we don't want to risk going to the
# previous line, and missing one line in the selection.
if self.type != TextObjectType.LINEWISE:
to -= 1
document = Document(
buffer.text,
to,
SelectionState(original_cursor_position=from_, type=self.selection_type),
)
new_document, clipboard_data = document.cut_selection()
return new_document, clipboard_data
# Typevar for any text object function:
TextObjectFunction = Callable[[E], TextObject]
_TOF = TypeVar("_TOF", bound=TextObjectFunction)
def create_text_object_decorator(
key_bindings: KeyBindings,
) -> Callable[..., Callable[[_TOF], _TOF]]:
"""
Create a decorator that can be used to register Vi text object implementations.
"""
def text_object_decorator(
*keys: Union[Keys, str],
filter: Filter = Always(),
no_move_handler: bool = False,
no_selection_handler: bool = False,
eager: bool = False,
) -> Callable[[_TOF], _TOF]:
"""
Register a text object function.
Usage::
@text_object('w', filter=..., no_move_handler=False)
def handler(event):
# Return a text object for this key.
return TextObject(...)
:param no_move_handler: Disable the move handler in navigation mode.
(It's still active in selection mode.)
"""
def decorator(text_object_func: _TOF) -> _TOF:
@key_bindings.add(
*keys, filter=vi_waiting_for_text_object_mode & filter, eager=eager
)
def _apply_operator_to_text_object(event: E) -> None:
# Arguments are multiplied.
vi_state = event.app.vi_state
event._arg = str((vi_state.operator_arg or 1) * (event.arg or 1))
# Call the text object handler.
text_obj = text_object_func(event)
# Get the operator function.
# (Should never be None here, given the
# `vi_waiting_for_text_object_mode` filter state.)
operator_func = vi_state.operator_func
if text_obj is not None and operator_func is not None:
# Call the operator function with the text object.
operator_func(event, text_obj)
# Clear operator.
event.app.vi_state.operator_func = None
event.app.vi_state.operator_arg = None
# Register a move operation. (Doesn't need an operator.)
if not no_move_handler:
@key_bindings.add(
*keys,
filter=~vi_waiting_for_text_object_mode
& filter
& vi_navigation_mode,
eager=eager,
)
def _move_in_navigation_mode(event: E) -> None:
"""
Move handler for navigation mode.
"""
text_object = text_object_func(event)
event.current_buffer.cursor_position += text_object.start
# Register a move selection operation.
if not no_selection_handler:
@key_bindings.add(
*keys,
filter=~vi_waiting_for_text_object_mode
& filter
& vi_selection_mode,
eager=eager,
)
def _move_in_selection_mode(event: E) -> None:
"""
Move handler for selection mode.
"""
text_object = text_object_func(event)
buff = event.current_buffer
selection_state = buff.selection_state
if selection_state is None:
return # Should not happen, because of the `vi_selection_mode` filter.
# When the text object has both a start and end position, like 'i(' or 'iw',
# Turn this into a selection, otherwise the cursor.
if text_object.end:
# Take selection positions from text object.
start, end = text_object.operator_range(buff.document)
start += buff.cursor_position
end += buff.cursor_position
selection_state.original_cursor_position = start
buff.cursor_position = end
# Take selection type from text object.
if text_object.type == TextObjectType.LINEWISE:
selection_state.type = SelectionType.LINES
else:
selection_state.type = SelectionType.CHARACTERS
else:
event.current_buffer.cursor_position += text_object.start
# Make it possible to chain @text_object decorators.
return text_object_func
return decorator
return text_object_decorator
# Typevar for any operator function:
OperatorFunction = Callable[[E, TextObject], None]
_OF = TypeVar("_OF", bound=OperatorFunction)
def create_operator_decorator(
key_bindings: KeyBindings,
) -> Callable[..., Callable[[_OF], _OF]]:
"""
Create a decorator that can be used for registering Vi operators.
"""
def operator_decorator(
*keys: Union[Keys, str], filter: Filter = Always(), eager: bool = False
) -> Callable[[_OF], _OF]:
"""
Register a Vi operator.
Usage::
@operator('d', filter=...)
def handler(event, text_object):
# Do something with the text object here.
"""
def decorator(operator_func: _OF) -> _OF:
@key_bindings.add(
*keys,
filter=~vi_waiting_for_text_object_mode & filter & vi_navigation_mode,
eager=eager,
)
def _operator_in_navigation(event: E) -> None:
"""
Handle operator in navigation mode.
"""
# When this key binding is matched, only set the operator
# function in the ViState. We should execute it after a text
# object has been received.
event.app.vi_state.operator_func = operator_func
event.app.vi_state.operator_arg = event.arg
@key_bindings.add(
*keys,
filter=~vi_waiting_for_text_object_mode & filter & vi_selection_mode,
eager=eager,
)
def _operator_in_selection(event: E) -> None:
"""
Handle operator in selection mode.
"""
buff = event.current_buffer
selection_state = buff.selection_state
if selection_state is not None:
# Create text object from selection.
if selection_state.type == SelectionType.LINES:
text_obj_type = TextObjectType.LINEWISE
elif selection_state.type == SelectionType.BLOCK:
text_obj_type = TextObjectType.BLOCK
else:
text_obj_type = TextObjectType.INCLUSIVE
text_object = TextObject(
selection_state.original_cursor_position - buff.cursor_position,
type=text_obj_type,
)
# Execute operator.
operator_func(event, text_object)
# Quit selection mode.
buff.selection_state = None
return operator_func
return decorator
return operator_decorator
def load_vi_bindings() -> KeyBindingsBase:
"""
Vi extensions.
# Overview of Readline Vi commands:
# http://www.catonmat.net/download/bash-vi-editing-mode-cheat-sheet.pdf
"""
# Note: Some key bindings have the "~IsReadOnly()" filter added. This
# prevents the handler to be executed when the focus is on a
# read-only buffer.
# This is however only required for those that change the ViState to
# INSERT mode. The `Buffer` class itself throws the
# `EditReadOnlyBuffer` exception for any text operations which is
# handled correctly. There is no need to add "~IsReadOnly" to all key
# bindings that do text manipulation.
key_bindings = KeyBindings()
handle = key_bindings.add
# (Note: Always take the navigation bindings in read-only mode, even when
# ViState says different.)
TransformFunction = Tuple[Tuple[str, ...], Filter, Callable[[str], str]]
vi_transform_functions: List[TransformFunction] = [
# Rot 13 transformation
(
("g", "?"),
Always(),
lambda string: cast(str, codecs.encode(string, "rot_13")),
),
# To lowercase
(("g", "u"), Always(), lambda string: string.lower()),
# To uppercase.
(("g", "U"), Always(), lambda string: string.upper()),
# Swap case.
(("g", "~"), Always(), lambda string: string.swapcase()),
(
("~",),
Condition(lambda: get_app().vi_state.tilde_operator),
lambda string: string.swapcase(),
),
]
# Insert a character literally (quoted insert).
handle("c-v", filter=vi_insert_mode)(get_by_name("quoted-insert"))
@handle("escape")
def _back_to_navigation(event: E) -> None:
"""
Escape goes to vi navigation mode.
"""
buffer = event.current_buffer
vi_state = event.app.vi_state
if vi_state.input_mode in (InputMode.INSERT, InputMode.REPLACE):
buffer.cursor_position += buffer.document.get_cursor_left_position()
vi_state.input_mode = InputMode.NAVIGATION
if bool(buffer.selection_state):
buffer.exit_selection()
@handle("k", filter=vi_selection_mode)
def _up_in_selection(event: E) -> None:
"""
Arrow up in selection mode.
"""
event.current_buffer.cursor_up(count=event.arg)
@handle("j", filter=vi_selection_mode)
def _down_in_selection(event: E) -> None:
"""
Arrow down in selection mode.
"""
event.current_buffer.cursor_down(count=event.arg)
@handle("up", filter=vi_navigation_mode)
@handle("c-p", filter=vi_navigation_mode)
def _up_in_navigation(event: E) -> None:
"""
Arrow up and ControlP in navigation mode go up.
"""
event.current_buffer.auto_up(count=event.arg)
@handle("k", filter=vi_navigation_mode)
def _go_up(event: E) -> None:
"""
Go up, but if we enter a new history entry, move to the start of the
line.
"""
event.current_buffer.auto_up(
count=event.arg, go_to_start_of_line_if_history_changes=True
)
@handle("down", filter=vi_navigation_mode)
@handle("c-n", filter=vi_navigation_mode)
def _go_down(event: E) -> None:
"""
Arrow down and Control-N in navigation mode.
"""
event.current_buffer.auto_down(count=event.arg)
@handle("j", filter=vi_navigation_mode)
def _go_down2(event: E) -> None:
"""
Go down, but if we enter a new history entry, go to the start of the line.
"""
event.current_buffer.auto_down(
count=event.arg, go_to_start_of_line_if_history_changes=True
)
@handle("backspace", filter=vi_navigation_mode)
def _go_left(event: E) -> None:
"""
In navigation-mode, move cursor.
"""
event.current_buffer.cursor_position += (
event.current_buffer.document.get_cursor_left_position(count=event.arg)
)
@handle("c-n", filter=vi_insert_mode)
def _complete_next(event: E) -> None:
b = event.current_buffer
if b.complete_state:
b.complete_next()
else:
b.start_completion(select_first=True)
@handle("c-p", filter=vi_insert_mode)
def _complete_prev(event: E) -> None:
"""
Control-P: To previous completion.
"""
b = event.current_buffer
if b.complete_state:
b.complete_previous()
else:
b.start_completion(select_last=True)
@handle("c-g", filter=vi_insert_mode)
@handle("c-y", filter=vi_insert_mode)
def _accept_completion(event: E) -> None:
"""
Accept current completion.
"""
event.current_buffer.complete_state = None
@handle("c-e", filter=vi_insert_mode)
def _cancel_completion(event: E) -> None:
"""
Cancel completion. Go back to originally typed text.
"""
event.current_buffer.cancel_completion()
@Condition
def is_returnable() -> bool:
return get_app().current_buffer.is_returnable
# In navigation mode, pressing enter will always return the input.
handle("enter", filter=vi_navigation_mode & is_returnable)(
get_by_name("accept-line")
)
# In insert mode, also accept input when enter is pressed, and the buffer
# has been marked as single line.
handle("enter", filter=is_returnable & ~is_multiline)(get_by_name("accept-line"))
@handle("enter", filter=~is_returnable & vi_navigation_mode)
def _start_of_next_line(event: E) -> None:
"""
Go to the beginning of 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
)
# ** In navigation mode **
# List of navigation commands: http://hea-www.harvard.edu/~fine/Tech/vi.html
@handle("insert", filter=vi_navigation_mode)
def _insert_mode(event: E) -> None:
"""
Pressing the Insert key.
"""
event.app.vi_state.input_mode = InputMode.INSERT
@handle("insert", filter=vi_insert_mode)
def _navigation_mode(event: E) -> None:
"""
Pressing the Insert key.
"""
event.app.vi_state.input_mode = InputMode.NAVIGATION
@handle("a", filter=vi_navigation_mode & ~is_read_only)
# ~IsReadOnly, because we want to stay in navigation mode for
# read-only buffers.
def _a(event: E) -> None:
event.current_buffer.cursor_position += (
event.current_buffer.document.get_cursor_right_position()
)
event.app.vi_state.input_mode = InputMode.INSERT
@handle("A", filter=vi_navigation_mode & ~is_read_only)
def _A(event: E) -> None:
event.current_buffer.cursor_position += (
event.current_buffer.document.get_end_of_line_position()
)
event.app.vi_state.input_mode = InputMode.INSERT
@handle("C", filter=vi_navigation_mode & ~is_read_only)
def _change_until_end_of_line(event: E) -> None:
"""
Change to end of line.
Same as 'c$' (which is implemented elsewhere.)
"""
buffer = event.current_buffer
deleted = buffer.delete(count=buffer.document.get_end_of_line_position())
event.app.clipboard.set_text(deleted)
event.app.vi_state.input_mode = InputMode.INSERT
@handle("c", "c", filter=vi_navigation_mode & ~is_read_only)
@handle("S", filter=vi_navigation_mode & ~is_read_only)
def _change_current_line(event: E) -> None: # TODO: implement 'arg'
"""
Change current line
"""
buffer = event.current_buffer
# We copy the whole line.
data = ClipboardData(buffer.document.current_line, SelectionType.LINES)
event.app.clipboard.set_data(data)
# But we delete after the whitespace
buffer.cursor_position += buffer.document.get_start_of_line_position(
after_whitespace=True
)
buffer.delete(count=buffer.document.get_end_of_line_position())
event.app.vi_state.input_mode = InputMode.INSERT
@handle("D", filter=vi_navigation_mode)
def _delete_until_end_of_line(event: E) -> None:
"""
Delete from cursor position until the end of the line.
"""
buffer = event.current_buffer
deleted = buffer.delete(count=buffer.document.get_end_of_line_position())
event.app.clipboard.set_text(deleted)
@handle("d", "d", filter=vi_navigation_mode)
def _delete_line(event: E) -> None:
"""
Delete line. (Or the following 'n' lines.)
"""
buffer = event.current_buffer
# Split string in before/deleted/after text.
lines = buffer.document.lines
before = "\n".join(lines[: buffer.document.cursor_position_row])
deleted = "\n".join(
lines[
buffer.document.cursor_position_row : buffer.document.cursor_position_row
+ event.arg
]
)
after = "\n".join(lines[buffer.document.cursor_position_row + event.arg :])
# Set new text.
if before and after:
before = before + "\n"
# Set text and cursor position.
buffer.document = Document(
text=before + after,
# Cursor At the start of the first 'after' line, after the leading whitespace.
cursor_position=len(before) + len(after) - len(after.lstrip(" ")),
)
# Set clipboard data
event.app.clipboard.set_data(ClipboardData(deleted, SelectionType.LINES))
@handle("x", filter=vi_selection_mode)
def _cut(event: E) -> None:
"""
Cut selection.
('x' is not an operator.)
"""
clipboard_data = event.current_buffer.cut_selection()
event.app.clipboard.set_data(clipboard_data)
@handle("i", filter=vi_navigation_mode & ~is_read_only)
def _i(event: E) -> None:
event.app.vi_state.input_mode = InputMode.INSERT
@handle("I", filter=vi_navigation_mode & ~is_read_only)
def _I(event: E) -> None:
event.app.vi_state.input_mode = InputMode.INSERT
event.current_buffer.cursor_position += (
event.current_buffer.document.get_start_of_line_position(
after_whitespace=True
)
)
@Condition
def in_block_selection() -> bool:
buff = get_app().current_buffer
return bool(
buff.selection_state and buff.selection_state.type == SelectionType.BLOCK
)
@handle("I", filter=in_block_selection & ~is_read_only)
def insert_in_block_selection(event: E, after: bool = False) -> None:
"""
Insert in block selection mode.
"""
buff = event.current_buffer
# Store all cursor positions.
positions = []
if after:
def get_pos(from_to: Tuple[int, int]) -> int:
return from_to[1]
else:
def get_pos(from_to: Tuple[int, int]) -> int:
return from_to[0]
for i, from_to in enumerate(buff.document.selection_ranges()):
positions.append(get_pos(from_to))
if i == 0:
buff.cursor_position = get_pos(from_to)
buff.multiple_cursor_positions = positions
# Go to 'INSERT_MULTIPLE' mode.
event.app.vi_state.input_mode = InputMode.INSERT_MULTIPLE
buff.exit_selection()
@handle("A", filter=in_block_selection & ~is_read_only)
def _append_after_block(event: E) -> None:
insert_in_block_selection(event, after=True)
@handle("J", filter=vi_navigation_mode & ~is_read_only)
def _join(event: E) -> None:
"""
Join lines.
"""
for i in range(event.arg):
event.current_buffer.join_next_line()
@handle("g", "J", filter=vi_navigation_mode & ~is_read_only)
def _join_nospace(event: E) -> None:
"""
Join lines without space.
"""
for i in range(event.arg):
event.current_buffer.join_next_line(separator="")
@handle("J", filter=vi_selection_mode & ~is_read_only)
def _join_selection(event: E) -> None:
"""
Join selected lines.
"""
event.current_buffer.join_selected_lines()
@handle("g", "J", filter=vi_selection_mode & ~is_read_only)
def _join_selection_nospace(event: E) -> None:
"""
Join selected lines without space.
"""
event.current_buffer.join_selected_lines(separator="")
@handle("p", filter=vi_navigation_mode)
def _paste(event: E) -> None:
"""
Paste after
"""
event.current_buffer.paste_clipboard_data(
event.app.clipboard.get_data(),
count=event.arg,
paste_mode=PasteMode.VI_AFTER,
)
@handle("P", filter=vi_navigation_mode)
def _paste_before(event: E) -> None:
"""
Paste before
"""
event.current_buffer.paste_clipboard_data(
event.app.clipboard.get_data(),
count=event.arg,
paste_mode=PasteMode.VI_BEFORE,
)
@handle('"', Keys.Any, "p", filter=vi_navigation_mode)
def _paste_register(event: E) -> None:
"""
Paste from named register.
"""
c = event.key_sequence[1].data
if c in vi_register_names:
data = event.app.vi_state.named_registers.get(c)
if data:
event.current_buffer.paste_clipboard_data(
data, count=event.arg, paste_mode=PasteMode.VI_AFTER
)
@handle('"', Keys.Any, "P", filter=vi_navigation_mode)
def _paste_register_before(event: E) -> None:
"""
Paste (before) from named register.
"""
c = event.key_sequence[1].data
if c in vi_register_names:
data = event.app.vi_state.named_registers.get(c)
if data:
event.current_buffer.paste_clipboard_data(
data, count=event.arg, paste_mode=PasteMode.VI_BEFORE
)
@handle("r", filter=vi_navigation_mode)
def _replace(event: E) -> None:
"""
Go to 'replace-single'-mode.
"""
event.app.vi_state.input_mode = InputMode.REPLACE_SINGLE
@handle("R", filter=vi_navigation_mode)
def _replace_mode(event: E) -> None:
"""
Go to 'replace'-mode.
"""
event.app.vi_state.input_mode = InputMode.REPLACE
@handle("s", filter=vi_navigation_mode & ~is_read_only)
def _substitute(event: E) -> None:
"""
Substitute with new text
(Delete character(s) and go to insert mode.)
"""
text = event.current_buffer.delete(count=event.arg)
event.app.clipboard.set_text(text)
event.app.vi_state.input_mode = InputMode.INSERT
@handle("u", filter=vi_navigation_mode, save_before=(lambda e: False))
def _undo(event: E) -> None:
for i in range(event.arg):
event.current_buffer.undo()
@handle("V", filter=vi_navigation_mode)
def _visual_line(event: E) -> None:
"""
Start lines selection.
"""
event.current_buffer.start_selection(selection_type=SelectionType.LINES)
@handle("c-v", filter=vi_navigation_mode)
def _visual_block(event: E) -> None:
"""
Enter block selection mode.
"""
event.current_buffer.start_selection(selection_type=SelectionType.BLOCK)
@handle("V", filter=vi_selection_mode)
def _visual_line2(event: E) -> None:
"""
Exit line selection mode, or go from non line selection mode to line
selection mode.
"""
selection_state = event.current_buffer.selection_state
if selection_state is not None:
if selection_state.type != SelectionType.LINES:
selection_state.type = SelectionType.LINES
else:
event.current_buffer.exit_selection()
@handle("v", filter=vi_navigation_mode)
def _visual(event: E) -> None:
"""
Enter character selection mode.
"""
event.current_buffer.start_selection(selection_type=SelectionType.CHARACTERS)
@handle("v", filter=vi_selection_mode)
def _visual2(event: E) -> None:
"""
Exit character selection mode, or go from non-character-selection mode
to character selection mode.
"""
selection_state = event.current_buffer.selection_state
if selection_state is not None:
if selection_state.type != SelectionType.CHARACTERS:
selection_state.type = SelectionType.CHARACTERS
else:
event.current_buffer.exit_selection()
@handle("c-v", filter=vi_selection_mode)
def _visual_block2(event: E) -> None:
"""
Exit block selection mode, or go from non block selection mode to block
selection mode.
"""
selection_state = event.current_buffer.selection_state
if selection_state is not None:
if selection_state.type != SelectionType.BLOCK:
selection_state.type = SelectionType.BLOCK
else:
event.current_buffer.exit_selection()
@handle("a", "w", filter=vi_selection_mode)
@handle("a", "W", filter=vi_selection_mode)
def _visual_auto_word(event: E) -> None:
"""
Switch from visual linewise mode to visual characterwise mode.
"""
buffer = event.current_buffer
if (
buffer.selection_state
and buffer.selection_state.type == SelectionType.LINES
):
buffer.selection_state.type = SelectionType.CHARACTERS
@handle("x", filter=vi_navigation_mode)
def _delete(event: E) -> None:
"""
Delete character.
"""
buff = event.current_buffer
count = min(event.arg, len(buff.document.current_line_after_cursor))
if count:
text = event.current_buffer.delete(count=count)
event.app.clipboard.set_text(text)
@handle("X", filter=vi_navigation_mode)
def _delete_before_cursor(event: E) -> None:
buff = event.current_buffer
count = min(event.arg, len(buff.document.current_line_before_cursor))
if count:
text = event.current_buffer.delete_before_cursor(count=count)
event.app.clipboard.set_text(text)
@handle("y", "y", filter=vi_navigation_mode)
@handle("Y", filter=vi_navigation_mode)
def _yank_line(event: E) -> None:
"""
Yank the whole line.
"""
text = "\n".join(event.current_buffer.document.lines_from_current[: event.arg])
event.app.clipboard.set_data(ClipboardData(text, SelectionType.LINES))
@handle("+", filter=vi_navigation_mode)
def _next_line(event: E) -> None:
"""
Move to first non whitespace of next line
"""
buffer = event.current_buffer
buffer.cursor_position += buffer.document.get_cursor_down_position(
count=event.arg
)
buffer.cursor_position += buffer.document.get_start_of_line_position(
after_whitespace=True
)
@handle("-", filter=vi_navigation_mode)
def _prev_line(event: E) -> None:
"""
Move to first non whitespace of previous line
"""
buffer = event.current_buffer
buffer.cursor_position += buffer.document.get_cursor_up_position(
count=event.arg
)
buffer.cursor_position += buffer.document.get_start_of_line_position(
after_whitespace=True
)
@handle(">", ">", filter=vi_navigation_mode)
def _indent(event: E) -> None:
"""
Indent lines.
"""
buffer = event.current_buffer
current_row = buffer.document.cursor_position_row
indent(buffer, current_row, current_row + event.arg)
@handle("<", "<", filter=vi_navigation_mode)
def _unindent(event: E) -> None:
"""
Unindent lines.
"""
current_row = event.current_buffer.document.cursor_position_row
unindent(event.current_buffer, current_row, current_row + event.arg)
@handle("O", filter=vi_navigation_mode & ~is_read_only)
def _open_above(event: E) -> None:
"""
Open line above and enter insertion mode
"""
event.current_buffer.insert_line_above(copy_margin=not in_paste_mode())
event.app.vi_state.input_mode = InputMode.INSERT
@handle("o", filter=vi_navigation_mode & ~is_read_only)
def _open_below(event: E) -> None:
"""
Open line below and enter insertion mode
"""
event.current_buffer.insert_line_below(copy_margin=not in_paste_mode())
event.app.vi_state.input_mode = InputMode.INSERT
@handle("~", filter=vi_navigation_mode)
def _reverse_case(event: E) -> None:
"""
Reverse case of current character and move cursor forward.
"""
buffer = event.current_buffer
c = buffer.document.current_char
if c is not None and c != "\n":
buffer.insert_text(c.swapcase(), overwrite=True)
@handle("g", "u", "u", filter=vi_navigation_mode & ~is_read_only)
def _lowercase_line(event: E) -> None:
"""
Lowercase current line.
"""
buff = event.current_buffer
buff.transform_current_line(lambda s: s.lower())
@handle("g", "U", "U", filter=vi_navigation_mode & ~is_read_only)
def _uppercase_line(event: E) -> None:
"""
Uppercase current line.
"""
buff = event.current_buffer
buff.transform_current_line(lambda s: s.upper())
@handle("g", "~", "~", filter=vi_navigation_mode & ~is_read_only)
def _swapcase_line(event: E) -> None:
"""
Swap case of the current line.
"""
buff = event.current_buffer
buff.transform_current_line(lambda s: s.swapcase())
@handle("#", filter=vi_navigation_mode)
def _prev_occurence(event: E) -> None:
"""
Go to previous occurrence of this word.
"""
b = event.current_buffer
search_state = event.app.current_search_state
search_state.text = b.document.get_word_under_cursor()
search_state.direction = SearchDirection.BACKWARD
b.apply_search(search_state, count=event.arg, include_current_position=False)
@handle("*", filter=vi_navigation_mode)
def _next_occurance(event: E) -> None:
"""
Go to next occurrence of this word.
"""
b = event.current_buffer
search_state = event.app.current_search_state
search_state.text = b.document.get_word_under_cursor()
search_state.direction = SearchDirection.FORWARD
b.apply_search(search_state, count=event.arg, include_current_position=False)
@handle("(", filter=vi_navigation_mode)
def _begin_of_sentence(event: E) -> None:
# TODO: go to begin of sentence.
# XXX: should become text_object.
pass
@handle(")", filter=vi_navigation_mode)
def _end_of_sentence(event: E) -> None:
# TODO: go to end of sentence.
# XXX: should become text_object.
pass
operator = create_operator_decorator(key_bindings)
text_object = create_text_object_decorator(key_bindings)
@handle(Keys.Any, filter=vi_waiting_for_text_object_mode)
def _unknown_text_object(event: E) -> None:
"""
Unknown key binding while waiting for a text object.
"""
event.app.output.bell()
#
# *** Operators ***
#
def create_delete_and_change_operators(
delete_only: bool, with_register: bool = False
) -> None:
"""
Delete and change operators.
:param delete_only: Create an operator that deletes, but doesn't go to insert mode.
:param with_register: Copy the deleted text to this named register instead of the clipboard.
"""
handler_keys: Iterable[str]
if with_register:
handler_keys = ('"', Keys.Any, "cd"[delete_only])
else:
handler_keys = "cd"[delete_only]
@operator(*handler_keys, filter=~is_read_only)
def delete_or_change_operator(event: E, text_object: TextObject) -> None:
clipboard_data = None
buff = event.current_buffer
if text_object:
new_document, clipboard_data = text_object.cut(buff)
buff.document = new_document
# Set deleted/changed text to clipboard or named register.
if clipboard_data and clipboard_data.text:
if with_register:
reg_name = event.key_sequence[1].data
if reg_name in vi_register_names:
event.app.vi_state.named_registers[reg_name] = clipboard_data
else:
event.app.clipboard.set_data(clipboard_data)
# Only go back to insert mode in case of 'change'.
if not delete_only:
event.app.vi_state.input_mode = InputMode.INSERT
create_delete_and_change_operators(False, False)
create_delete_and_change_operators(False, True)
create_delete_and_change_operators(True, False)
create_delete_and_change_operators(True, True)
def create_transform_handler(
filter: Filter, transform_func: Callable[[str], str], *a: str
) -> None:
@operator(*a, filter=filter & ~is_read_only)
def _(event: E, text_object: TextObject) -> None:
"""
Apply transformation (uppercase, lowercase, rot13, swap case).
"""
buff = event.current_buffer
start, end = text_object.operator_range(buff.document)
if start < end:
# Transform.
buff.transform_region(
buff.cursor_position + start,
buff.cursor_position + end,
transform_func,
)
# Move cursor
buff.cursor_position += text_object.end or text_object.start
for k, f, func in vi_transform_functions:
create_transform_handler(f, func, *k)
@operator("y")
def _yank(event: E, text_object: TextObject) -> None:
"""
Yank operator. (Copy text.)
"""
_, clipboard_data = text_object.cut(event.current_buffer)
if clipboard_data.text:
event.app.clipboard.set_data(clipboard_data)
@operator('"', Keys.Any, "y")
def _yank_to_register(event: E, text_object: TextObject) -> None:
"""
Yank selection to named register.
"""
c = event.key_sequence[1].data
if c in vi_register_names:
_, clipboard_data = text_object.cut(event.current_buffer)
event.app.vi_state.named_registers[c] = clipboard_data
@operator(">")
def _indent_text_object(event: E, text_object: TextObject) -> None:
"""
Indent.
"""
buff = event.current_buffer
from_, to = text_object.get_line_numbers(buff)
indent(buff, from_, to + 1, count=event.arg)
@operator("<")
def _unindent_text_object(event: E, text_object: TextObject) -> None:
"""
Unindent.
"""
buff = event.current_buffer
from_, to = text_object.get_line_numbers(buff)
unindent(buff, from_, to + 1, count=event.arg)
@operator("g", "q")
def _reshape(event: E, text_object: TextObject) -> None:
"""
Reshape text.
"""
buff = event.current_buffer
from_, to = text_object.get_line_numbers(buff)
reshape_text(buff, from_, to)
#
# *** Text objects ***
#
@text_object("b")
def _b(event: E) -> TextObject:
"""
Move one word or token left.
"""
return TextObject(
event.current_buffer.document.find_start_of_previous_word(count=event.arg)
or 0
)
@text_object("B")
def _B(event: E) -> TextObject:
"""
Move one non-blank word left
"""
return TextObject(
event.current_buffer.document.find_start_of_previous_word(
count=event.arg, WORD=True
)
or 0
)
@text_object("$")
def _dollar(event: E) -> TextObject:
"""
'c$', 'd$' and '$': Delete/change/move until end of line.
"""
return TextObject(event.current_buffer.document.get_end_of_line_position())
@text_object("w")
def _word_forward(event: E) -> TextObject:
"""
'word' forward. 'cw', 'dw', 'w': Delete/change/move one word.
"""
return TextObject(
event.current_buffer.document.find_next_word_beginning(count=event.arg)
or event.current_buffer.document.get_end_of_document_position()
)
@text_object("W")
def _WORD_forward(event: E) -> TextObject:
"""
'WORD' forward. 'cW', 'dW', 'W': Delete/change/move one WORD.
"""
return TextObject(
event.current_buffer.document.find_next_word_beginning(
count=event.arg, WORD=True
)
or event.current_buffer.document.get_end_of_document_position()
)
@text_object("e")
def _end_of_word(event: E) -> TextObject:
"""
End of 'word': 'ce', 'de', 'e'
"""
end = event.current_buffer.document.find_next_word_ending(count=event.arg)
return TextObject(end - 1 if end else 0, type=TextObjectType.INCLUSIVE)
@text_object("E")
def _end_of_WORD(event: E) -> TextObject:
"""
End of 'WORD': 'cE', 'dE', 'E'
"""
end = event.current_buffer.document.find_next_word_ending(
count=event.arg, WORD=True
)
return TextObject(end - 1 if end else 0, type=TextObjectType.INCLUSIVE)
@text_object("i", "w", no_move_handler=True)
def _inner_word(event: E) -> TextObject:
"""
Inner 'word': ciw and diw
"""
start, end = event.current_buffer.document.find_boundaries_of_current_word()
return TextObject(start, end)
@text_object("a", "w", no_move_handler=True)
def _a_word(event: E) -> TextObject:
"""
A 'word': caw and daw
"""
start, end = event.current_buffer.document.find_boundaries_of_current_word(
include_trailing_whitespace=True
)
return TextObject(start, end)
@text_object("i", "W", no_move_handler=True)
def _inner_WORD(event: E) -> TextObject:
"""
Inner 'WORD': ciW and diW
"""
start, end = event.current_buffer.document.find_boundaries_of_current_word(
WORD=True
)
return TextObject(start, end)
@text_object("a", "W", no_move_handler=True)
def _a_WORD(event: E) -> TextObject:
"""
A 'WORD': caw and daw
"""
start, end = event.current_buffer.document.find_boundaries_of_current_word(
WORD=True, include_trailing_whitespace=True
)
return TextObject(start, end)
@text_object("a", "p", no_move_handler=True)
def _paragraph(event: E) -> TextObject:
"""
Auto paragraph.
"""
start = event.current_buffer.document.start_of_paragraph()
end = event.current_buffer.document.end_of_paragraph(count=event.arg)
return TextObject(start, end)
@text_object("^")
def _start_of_line(event: E) -> TextObject:
""" 'c^', 'd^' and '^': Soft start of line, after whitespace. """
return TextObject(
event.current_buffer.document.get_start_of_line_position(
after_whitespace=True
)
)
@text_object("0")
def _hard_start_of_line(event: E) -> TextObject:
"""
'c0', 'd0': Hard start of line, before whitespace.
(The move '0' key is implemented elsewhere, because a '0' could also change the `arg`.)
"""
return TextObject(
event.current_buffer.document.get_start_of_line_position(
after_whitespace=False
)
)
def create_ci_ca_handles(
ci_start: str, ci_end: str, inner: bool, key: Optional[str] = None
) -> None:
# TODO: 'dat', 'dit', (tags (like xml)
"""
Delete/Change string between this start and stop character. But keep these characters.
This implements all the ci", ci<, ci{, ci(, di", di<, ca", ca<, ... combinations.
"""
def handler(event: E) -> TextObject:
if ci_start == ci_end:
# Quotes
start = event.current_buffer.document.find_backwards(
ci_start, in_current_line=False
)
end = event.current_buffer.document.find(ci_end, in_current_line=False)
else:
# Brackets
start = event.current_buffer.document.find_enclosing_bracket_left(
ci_start, ci_end
)
end = event.current_buffer.document.find_enclosing_bracket_right(
ci_start, ci_end
)
if start is not None and end is not None:
offset = 0 if inner else 1
return TextObject(start + 1 - offset, end + offset)
else:
# Nothing found.
return TextObject(0)
if key is None:
text_object("ai"[inner], ci_start, no_move_handler=True)(handler)
text_object("ai"[inner], ci_end, no_move_handler=True)(handler)
else:
text_object("ai"[inner], key, no_move_handler=True)(handler)
for inner in (False, True):
for ci_start, ci_end in [
('"', '"'),
("'", "'"),
("`", "`"),
("[", "]"),
("<", ">"),
("{", "}"),
("(", ")"),
]:
create_ci_ca_handles(ci_start, ci_end, inner)
create_ci_ca_handles("(", ")", inner, "b") # 'dab', 'dib'
create_ci_ca_handles("{", "}", inner, "B") # 'daB', 'diB'
@text_object("{")
def _previous_section(event: E) -> TextObject:
"""
Move to previous blank-line separated section.
Implements '{', 'c{', 'd{', 'y{'
"""
index = event.current_buffer.document.start_of_paragraph(
count=event.arg, before=True
)
return TextObject(index)
@text_object("}")
def _next_section(event: E) -> TextObject:
"""
Move to next blank-line separated section.
Implements '}', 'c}', 'd}', 'y}'
"""
index = event.current_buffer.document.end_of_paragraph(
count=event.arg, after=True
)
return TextObject(index)
@text_object("f", Keys.Any)
def _next_occurence(event: E) -> TextObject:
"""
Go to next occurrence of character. Typing 'fx' will move the
cursor to the next occurrence of character. 'x'.
"""
event.app.vi_state.last_character_find = CharacterFind(event.data, False)
match = event.current_buffer.document.find(
event.data, in_current_line=True, count=event.arg
)
if match:
return TextObject(match, type=TextObjectType.INCLUSIVE)
else:
return TextObject(0)
@text_object("F", Keys.Any)
def _previous_occurance(event: E) -> TextObject:
"""
Go to previous occurrence of character. Typing 'Fx' will move the
cursor to the previous occurrence of character. 'x'.
"""
event.app.vi_state.last_character_find = CharacterFind(event.data, True)
return TextObject(
event.current_buffer.document.find_backwards(
event.data, in_current_line=True, count=event.arg
)
or 0
)
@text_object("t", Keys.Any)
def _t(event: E) -> TextObject:
"""
Move right to the next occurrence of c, then one char backward.
"""
event.app.vi_state.last_character_find = CharacterFind(event.data, False)
match = event.current_buffer.document.find(
event.data, in_current_line=True, count=event.arg
)
if match:
return TextObject(match - 1, type=TextObjectType.INCLUSIVE)
else:
return TextObject(0)
@text_object("T", Keys.Any)
def _T(event: E) -> TextObject:
"""
Move left to the previous occurrence of c, then one char forward.
"""
event.app.vi_state.last_character_find = CharacterFind(event.data, True)
match = event.current_buffer.document.find_backwards(
event.data, in_current_line=True, count=event.arg
)
return TextObject(match + 1 if match else 0)
def repeat(reverse: bool) -> None:
"""
Create ',' and ';' commands.
"""
@text_object("," if reverse else ";")
def _(event: E) -> TextObject:
"""
Repeat the last 'f'/'F'/'t'/'T' command.
"""
pos: Optional[int] = 0
vi_state = event.app.vi_state
type = TextObjectType.EXCLUSIVE
if vi_state.last_character_find:
char = vi_state.last_character_find.character
backwards = vi_state.last_character_find.backwards
if reverse:
backwards = not backwards
if backwards:
pos = event.current_buffer.document.find_backwards(
char, in_current_line=True, count=event.arg
)
else:
pos = event.current_buffer.document.find(
char, in_current_line=True, count=event.arg
)
type = TextObjectType.INCLUSIVE
if pos:
return TextObject(pos, type=type)
else:
return TextObject(0)
repeat(True)
repeat(False)
@text_object("h")
@text_object("left")
def _left(event: E) -> TextObject:
"""
Implements 'ch', 'dh', 'h': Cursor left.
"""
return TextObject(
event.current_buffer.document.get_cursor_left_position(count=event.arg)
)
@text_object("j", no_move_handler=True, no_selection_handler=True)
# Note: We also need `no_selection_handler`, because we in
# selection mode, we prefer the other 'j' binding that keeps
# `buffer.preferred_column`.
def _down(event: E) -> TextObject:
"""
Implements 'cj', 'dj', 'j', ... Cursor up.
"""
return TextObject(
event.current_buffer.document.get_cursor_down_position(count=event.arg),
type=TextObjectType.LINEWISE,
)
@text_object("k", no_move_handler=True, no_selection_handler=True)
def _up(event: E) -> TextObject:
"""
Implements 'ck', 'dk', 'k', ... Cursor up.
"""
return TextObject(
event.current_buffer.document.get_cursor_up_position(count=event.arg),
type=TextObjectType.LINEWISE,
)
@text_object("l")
@text_object(" ")
@text_object("right")
def _right(event: E) -> TextObject:
"""
Implements 'cl', 'dl', 'l', 'c ', 'd ', ' '. Cursor right.
"""
return TextObject(
event.current_buffer.document.get_cursor_right_position(count=event.arg)
)
@text_object("H")
def _top_of_screen(event: E) -> TextObject:
"""
Moves to the start of the visible region. (Below the scroll offset.)
Implements 'cH', 'dH', 'H'.
"""
w = event.app.layout.current_window
b = event.current_buffer
if w and w.render_info:
# When we find a Window that has BufferControl showing this window,
# move to the start of the visible area.
pos = (
b.document.translate_row_col_to_index(
w.render_info.first_visible_line(after_scroll_offset=True), 0
)
- b.cursor_position
)
else:
# Otherwise, move to the start of the input.
pos = -len(b.document.text_before_cursor)
return TextObject(pos, type=TextObjectType.LINEWISE)
@text_object("M")
def _middle_of_screen(event: E) -> TextObject:
"""
Moves cursor to the vertical center of the visible region.
Implements 'cM', 'dM', 'M'.
"""
w = event.app.layout.current_window
b = event.current_buffer
if w and w.render_info:
# When we find a Window that has BufferControl showing this window,
# move to the center of the visible area.
pos = (
b.document.translate_row_col_to_index(
w.render_info.center_visible_line(), 0
)
- b.cursor_position
)
else:
# Otherwise, move to the start of the input.
pos = -len(b.document.text_before_cursor)
return TextObject(pos, type=TextObjectType.LINEWISE)
@text_object("L")
def _end_of_screen(event: E) -> TextObject:
"""
Moves to the end of the visible region. (Above the scroll offset.)
"""
w = event.app.layout.current_window
b = event.current_buffer
if w and w.render_info:
# When we find a Window that has BufferControl showing this window,
# move to the end of the visible area.
pos = (
b.document.translate_row_col_to_index(
w.render_info.last_visible_line(before_scroll_offset=True), 0
)
- b.cursor_position
)
else:
# Otherwise, move to the end of the input.
pos = len(b.document.text_after_cursor)
return TextObject(pos, type=TextObjectType.LINEWISE)
@text_object("n", no_move_handler=True)
def _search_next(event: E) -> TextObject:
"""
Search next.
"""
buff = event.current_buffer
search_state = event.app.current_search_state
cursor_position = buff.get_search_position(
search_state, include_current_position=False, count=event.arg
)
return TextObject(cursor_position - buff.cursor_position)
@handle("n", filter=vi_navigation_mode)
def _search_next2(event: E) -> None:
"""
Search next in navigation mode. (This goes through the history.)
"""
search_state = event.app.current_search_state
event.current_buffer.apply_search(
search_state, include_current_position=False, count=event.arg
)
@text_object("N", no_move_handler=True)
def _search_previous(event: E) -> TextObject:
"""
Search previous.
"""
buff = event.current_buffer
search_state = event.app.current_search_state
cursor_position = buff.get_search_position(
~search_state, include_current_position=False, count=event.arg
)
return TextObject(cursor_position - buff.cursor_position)
@handle("N", filter=vi_navigation_mode)
def _search_previous2(event: E) -> None:
"""
Search previous in navigation mode. (This goes through the history.)
"""
search_state = event.app.current_search_state
event.current_buffer.apply_search(
~search_state, include_current_position=False, count=event.arg
)
@handle("z", "+", filter=vi_navigation_mode | vi_selection_mode)
@handle("z", "t", filter=vi_navigation_mode | vi_selection_mode)
@handle("z", "enter", filter=vi_navigation_mode | vi_selection_mode)
def _scroll_top(event: E) -> None:
"""
Scrolls the window to makes the current line the first line in the visible region.
"""
b = event.current_buffer
event.app.layout.current_window.vertical_scroll = b.document.cursor_position_row
@handle("z", "-", filter=vi_navigation_mode | vi_selection_mode)
@handle("z", "b", filter=vi_navigation_mode | vi_selection_mode)
def _scroll_bottom(event: E) -> None:
"""
Scrolls the window to makes the current line the last line in the visible region.
"""
# We can safely set the scroll offset to zero; the Window will make
# sure that it scrolls at least enough to make the cursor visible
# again.
event.app.layout.current_window.vertical_scroll = 0
@handle("z", "z", filter=vi_navigation_mode | vi_selection_mode)
def _scroll_center(event: E) -> None:
"""
Center Window vertically around cursor.
"""
w = event.app.layout.current_window
b = event.current_buffer
if w and w.render_info:
info = w.render_info
# Calculate the offset that we need in order to position the row
# containing the cursor in the center.
scroll_height = info.window_height // 2
y = max(0, b.document.cursor_position_row - 1)
height = 0
while y > 0:
line_height = info.get_height_for_line(y)
if height + line_height < scroll_height:
height += line_height
y -= 1
else:
break
w.vertical_scroll = y
@text_object("%")
def _goto_corresponding_bracket(event: E) -> TextObject:
"""
Implements 'c%', 'd%', '%, 'y%' (Move to corresponding bracket.)
If an 'arg' has been given, go this this % position in the file.
"""
buffer = event.current_buffer
if event._arg:
# If 'arg' has been given, the meaning of % is to go to the 'x%'
# row in the file.
if 0 < event.arg <= 100:
absolute_index = buffer.document.translate_row_col_to_index(
int((event.arg * buffer.document.line_count - 1) / 100), 0
)
return TextObject(
absolute_index - buffer.document.cursor_position,
type=TextObjectType.LINEWISE,
)
else:
return TextObject(0) # Do nothing.
else:
# Move to the corresponding opening/closing bracket (()'s, []'s and {}'s).
match = buffer.document.find_matching_bracket_position()
if match:
return TextObject(match, type=TextObjectType.INCLUSIVE)
else:
return TextObject(0)
@text_object("|")
def _to_column(event: E) -> TextObject:
"""
Move to the n-th column (you may specify the argument n by typing it on
number keys, for example, 20|).
"""
return TextObject(
event.current_buffer.document.get_column_cursor_position(event.arg - 1)
)
@text_object("g", "g")
def _goto_first_line(event: E) -> TextObject:
"""
Go to the start of the very first line.
Implements 'gg', 'cgg', 'ygg'
"""
d = event.current_buffer.document
if event._arg:
# Move to the given line.
return TextObject(
d.translate_row_col_to_index(event.arg - 1, 0) - d.cursor_position,
type=TextObjectType.LINEWISE,
)
else:
# Move to the top of the input.
return TextObject(
d.get_start_of_document_position(), type=TextObjectType.LINEWISE
)
@text_object("g", "_")
def _goto_last_line(event: E) -> TextObject:
"""
Go to last non-blank of line.
'g_', 'cg_', 'yg_', etc..
"""
return TextObject(
event.current_buffer.document.last_non_blank_of_current_line_position(),
type=TextObjectType.INCLUSIVE,
)
@text_object("g", "e")
def _ge(event: E) -> TextObject:
"""
Go to last character of previous word.
'ge', 'cge', 'yge', etc..
"""
prev_end = event.current_buffer.document.find_previous_word_ending(
count=event.arg
)
return TextObject(
prev_end - 1 if prev_end is not None else 0, type=TextObjectType.INCLUSIVE
)
@text_object("g", "E")
def _gE(event: E) -> TextObject:
"""
Go to last character of previous WORD.
'gE', 'cgE', 'ygE', etc..
"""
prev_end = event.current_buffer.document.find_previous_word_ending(
count=event.arg, WORD=True
)
return TextObject(
prev_end - 1 if prev_end is not None else 0, type=TextObjectType.INCLUSIVE
)
@text_object("g", "m")
def _gm(event: E) -> TextObject:
"""
Like g0, but half a screenwidth to the right. (Or as much as possible.)
"""
w = event.app.layout.current_window
buff = event.current_buffer
if w and w.render_info:
width = w.render_info.window_width
start = buff.document.get_start_of_line_position(after_whitespace=False)
start += int(min(width / 2, len(buff.document.current_line)))
return TextObject(start, type=TextObjectType.INCLUSIVE)
return TextObject(0)
@text_object("G")
def _last_line(event: E) -> TextObject:
"""
Go to the end of the document. (If no arg has been given.)
"""
buf = event.current_buffer
return TextObject(
buf.document.translate_row_col_to_index(buf.document.line_count - 1, 0)
- buf.cursor_position,
type=TextObjectType.LINEWISE,
)
#
# *** Other ***
#
@handle("G", filter=has_arg)
def _to_nth_history_line(event: E) -> None:
"""
If an argument is given, move to this line in the history. (for
example, 15G)
"""
event.current_buffer.go_to_history(event.arg - 1)
for n in "123456789":
@handle(
n,
filter=vi_navigation_mode
| vi_selection_mode
| vi_waiting_for_text_object_mode,
)
def _arg(event: E) -> None:
"""
Always handle numberics in navigation mode as arg.
"""
event.append_to_arg_count(event.data)
@handle(
"0",
filter=(
vi_navigation_mode | vi_selection_mode | vi_waiting_for_text_object_mode
)
& has_arg,
)
def _0_arg(event: E) -> None:
"""
Zero when an argument was already give.
"""
event.append_to_arg_count(event.data)
@handle(Keys.Any, filter=vi_replace_mode)
def _insert_text(event: E) -> None:
"""
Insert data at cursor position.
"""
event.current_buffer.insert_text(event.data, overwrite=True)
@handle(Keys.Any, filter=vi_replace_single_mode)
def _replace_single(event: E) -> None:
"""
Replace single character at cursor position.
"""
event.current_buffer.insert_text(event.data, overwrite=True)
event.current_buffer.cursor_position -= 1
event.app.vi_state.input_mode = InputMode.NAVIGATION
@handle(
Keys.Any,
filter=vi_insert_multiple_mode,
save_before=(lambda e: not e.is_repeat),
)
def _insert_text_multiple_cursors(event: E) -> None:
"""
Insert data at multiple cursor positions at once.
(Usually a result of pressing 'I' or 'A' in block-selection mode.)
"""
buff = event.current_buffer
original_text = buff.text
# Construct new text.
text = []
p = 0
for p2 in buff.multiple_cursor_positions:
text.append(original_text[p:p2])
text.append(event.data)
p = p2
text.append(original_text[p:])
# Shift all cursor positions.
new_cursor_positions = [
pos + i + 1 for i, pos in enumerate(buff.multiple_cursor_positions)
]
# Set result.
buff.text = "".join(text)
buff.multiple_cursor_positions = new_cursor_positions
buff.cursor_position += 1
@handle("backspace", filter=vi_insert_multiple_mode)
def _delete_before_multiple_cursors(event: E) -> None:
"""
Backspace, using multiple cursors.
"""
buff = event.current_buffer
original_text = buff.text
# Construct new text.
deleted_something = False
text = []
p = 0
for p2 in buff.multiple_cursor_positions:
if p2 > 0 and original_text[p2 - 1] != "\n": # Don't delete across lines.
text.append(original_text[p : p2 - 1])
deleted_something = True
else:
text.append(original_text[p:p2])
p = p2
text.append(original_text[p:])
if deleted_something:
# Shift all cursor positions.
lengths = [len(part) for part in text[:-1]]
new_cursor_positions = list(accumulate(lengths))
# Set result.
buff.text = "".join(text)
buff.multiple_cursor_positions = new_cursor_positions
buff.cursor_position -= 1
else:
event.app.output.bell()
@handle("delete", filter=vi_insert_multiple_mode)
def _delete_after_multiple_cursors(event):
"""
Delete, using multiple cursors.
"""
buff = event.current_buffer
original_text = buff.text
# Construct new text.
deleted_something = False
text = []
new_cursor_positions = []
p = 0
for p2 in buff.multiple_cursor_positions:
text.append(original_text[p:p2])
if p2 >= len(original_text) or original_text[p2] == "\n":
# Don't delete across lines.
p = p2
else:
p = p2 + 1
deleted_something = True
text.append(original_text[p:])
if deleted_something:
# Shift all cursor positions.
lengths = [len(part) for part in text[:-1]]
new_cursor_positions = list(accumulate(lengths))
# Set result.
buff.text = "".join(text)
buff.multiple_cursor_positions = new_cursor_positions
else:
event.app.output.bell()
@handle("left", filter=vi_insert_multiple_mode)
def _left_multiple(event: E) -> None:
"""
Move all cursors to the left.
(But keep all cursors on the same line.)
"""
buff = event.current_buffer
new_positions = []
for p in buff.multiple_cursor_positions:
if buff.document.translate_index_to_position(p)[1] > 0:
p -= 1
new_positions.append(p)
buff.multiple_cursor_positions = new_positions
if buff.document.cursor_position_col > 0:
buff.cursor_position -= 1
@handle("right", filter=vi_insert_multiple_mode)
def _right_multiple(event: E) -> None:
"""
Move all cursors to the right.
(But keep all cursors on the same line.)
"""
buff = event.current_buffer
new_positions = []
for p in buff.multiple_cursor_positions:
row, column = buff.document.translate_index_to_position(p)
if column < len(buff.document.lines[row]):
p += 1
new_positions.append(p)
buff.multiple_cursor_positions = new_positions
if not buff.document.is_cursor_at_the_end_of_line:
buff.cursor_position += 1
@handle("up", filter=vi_insert_multiple_mode)
@handle("down", filter=vi_insert_multiple_mode)
def _updown_multiple(event: E) -> None:
"""
Ignore all up/down key presses when in multiple cursor mode.
"""
@handle("c-x", "c-l", filter=vi_insert_mode)
def _complete_line(event: E) -> None:
"""
Pressing the ControlX - ControlL sequence in Vi mode does line
completion based on the other lines in the document and the history.
"""
event.current_buffer.start_history_lines_completion()
@handle("c-x", "c-f", filter=vi_insert_mode)
def _complete_filename(event: E) -> None:
"""
Complete file names.
"""
# TODO
pass
@handle("c-k", filter=vi_insert_mode | vi_replace_mode)
def _digraph(event: E) -> None:
"""
Go into digraph mode.
"""
event.app.vi_state.waiting_for_digraph = True
@Condition
def digraph_symbol_1_given() -> bool:
return get_app().vi_state.digraph_symbol1 is not None
@handle(Keys.Any, filter=vi_digraph_mode & ~digraph_symbol_1_given)
def _digraph1(event: E) -> None:
"""
First digraph symbol.
"""
event.app.vi_state.digraph_symbol1 = event.data
@handle(Keys.Any, filter=vi_digraph_mode & digraph_symbol_1_given)
def _create_digraph(event: E) -> None:
"""
Insert digraph.
"""
try:
# Lookup.
code: Tuple[str, str] = (
event.app.vi_state.digraph_symbol1 or "",
event.data,
)
if code not in DIGRAPHS:
code = code[::-1] # Try reversing.
symbol = DIGRAPHS[code]
except KeyError:
# Unknown digraph.
event.app.output.bell()
else:
# Insert digraph.
overwrite = event.app.vi_state.input_mode == InputMode.REPLACE
event.current_buffer.insert_text(chr(symbol), overwrite=overwrite)
event.app.vi_state.waiting_for_digraph = False
finally:
event.app.vi_state.waiting_for_digraph = False
event.app.vi_state.digraph_symbol1 = None
@handle("c-o", filter=vi_insert_mode | vi_replace_mode)
def _quick_normal_mode(event: E) -> None:
"""
Go into normal mode for one single action.
"""
event.app.vi_state.temporary_navigation_mode = True
@handle("q", Keys.Any, filter=vi_navigation_mode & ~vi_recording_macro)
def _start_macro(event: E) -> None:
"""
Start recording macro.
"""
c = event.key_sequence[1].data
if c in vi_register_names:
vi_state = event.app.vi_state
vi_state.recording_register = c
vi_state.current_recording = ""
@handle("q", filter=vi_navigation_mode & vi_recording_macro)
def _stop_macro(event: E) -> None:
"""
Stop recording macro.
"""
vi_state = event.app.vi_state
# Store and stop recording.
if vi_state.recording_register:
vi_state.named_registers[vi_state.recording_register] = ClipboardData(
vi_state.current_recording
)
vi_state.recording_register = None
vi_state.current_recording = ""
@handle("@", Keys.Any, filter=vi_navigation_mode, record_in_macro=False)
def _execute_macro(event: E) -> None:
"""
Execute macro.
Notice that we pass `record_in_macro=False`. This ensures that the `@x`
keys don't appear in the recording itself. This function inserts the
body of the called macro back into the KeyProcessor, so these keys will
be added later on to the macro of their handlers have
`record_in_macro=True`.
"""
# Retrieve macro.
c = event.key_sequence[1].data
try:
macro = event.app.vi_state.named_registers[c]
except KeyError:
return
# Expand macro (which is a string in the register), in individual keys.
# Use vt100 parser for this.
keys: List[KeyPress] = []
parser = Vt100Parser(keys.append)
parser.feed(macro.text)
parser.flush()
# Now feed keys back to the input processor.
for _ in range(event.arg):
event.app.key_processor.feed_multiple(keys, first=True)
return ConditionalKeyBindings(key_bindings, vi_mode)
def load_vi_search_bindings() -> KeyBindingsBase:
key_bindings = KeyBindings()
handle = key_bindings.add
from . import search
@Condition
def search_buffer_is_empty() -> bool:
" Returns True when the search buffer is empty. "
return get_app().current_buffer.text == ""
# Vi-style forward search.
handle(
"/",
filter=(vi_navigation_mode | vi_selection_mode) & ~vi_search_direction_reversed,
)(search.start_forward_incremental_search)
handle(
"?",
filter=(vi_navigation_mode | vi_selection_mode) & vi_search_direction_reversed,
)(search.start_forward_incremental_search)
handle("c-s")(search.start_forward_incremental_search)
# Vi-style backward search.
handle(
"?",
filter=(vi_navigation_mode | vi_selection_mode) & ~vi_search_direction_reversed,
)(search.start_reverse_incremental_search)
handle(
"/",
filter=(vi_navigation_mode | vi_selection_mode) & vi_search_direction_reversed,
)(search.start_reverse_incremental_search)
handle("c-r")(search.start_reverse_incremental_search)
# Apply the search. (At the / or ? prompt.)
handle("enter", filter=is_searching)(search.accept_search)
handle("c-r", filter=is_searching)(search.reverse_incremental_search)
handle("c-s", filter=is_searching)(search.forward_incremental_search)
handle("c-c")(search.abort_search)
handle("c-g")(search.abort_search)
handle("backspace", filter=search_buffer_is_empty)(search.abort_search)
# Handle escape. This should accept the search, just like readline.
# `abort_search` would be a meaningful alternative.
handle("escape")(search.accept_search)
return ConditionalKeyBindings(key_bindings, vi_mode)
Reference in a new issue Copy permalink