def height_is_known(self):
"""
True when the height from the cursor until the bottom of the terminal
is known. (It's often nicer to draw bottom toolbars only if the height
is known, in order to avoid flickering when the CPR response arrives.)
"""
return self.use_alternate_screen or self._min_available_height > 0 or \
is_windows() # On Windows, we don't have to wait for a CPR.
def reset(self, _scroll=False, leave_alternate_screen=True):
# Reset position
self._cursor_pos = Point(x=0, y=0)
# Remember the last screen instance between renderers. This way,
# we can create a `diff` between two screens and only output the
# difference. It's also to remember the last height. (To show for
# instance a toolbar at the bottom position.)
self._last_screen = None
self._last_size = None
self._last_token = None
# When the style hash changes, we have to do a full redraw as well as
# clear the `_attrs_for_token` dictionary.
self._last_style_hash = None
self._attrs_for_token = None
# Default MouseHandlers. (Just empty.)
self.mouse_handlers = MouseHandlers()
# Remember the last title. Only set the title when it changes.
self._last_title = None
#: Space from the top of the layout, until the bottom of the terminal.
#: We don't know this until a `report_absolute_cursor_row` call.
self._min_available_height = 0
# In case of Windown, also make sure to scroll to the current cursor
# position. (Only when rendering the first time.)
if is_windows() and _scroll:
self.output.scroll_buffer_to_prompt()
# Quit alternate screen.
if self._in_alternate_screen and leave_alternate_screen:
self.output.quit_alternate_screen()
self._in_alternate_screen = False
# Disable mouse support.
if self._mouse_support_enabled:
self.output.disable_mouse_support()
self._mouse_support_enabled = False
# Disable bracketed paste.
if self._bracketed_paste_enabled:
self.output.disable_bracketed_paste()
self._bracketed_paste_enabled = False
# Flush output. `disable_mouse_support` needs to write to stdout.
self.output.flush()
def _(event):
"""
Handling of mouse events for Windows.
"""
assert is_windows() # This key binding should only exist for Windows.
# Parse data.
event_type, x, y = event.data.split(';')
x = int(x)
y = int(y)
# Make coordinates absolute to the visible part of the terminal.
screen_buffer_info = event.cli.renderer.output.get_win32_screen_buffer_info(
)
rows_above_cursor = screen_buffer_info.dwCursorPosition.Y - event.cli.renderer._cursor_pos.y
y -= rows_above_cursor
# Call the mouse event handler.
handler = event.cli.renderer.mouse_handlers.mouse_handlers[x, y]
handler(event.cli,
MouseEvent(position=Point(x=x, y=y), event_type=event_type))
def request_absolute_cursor_position(self):
"""
Get current cursor position.
For vt100: Do CPR request. (answer will arrive later.)
For win32: Do API call. (Answer comes immediately.)
"""
# Only do this request when the cursor is at the top row. (after a
# clear or reset). We will rely on that in `report_absolute_cursor_row`.
assert self._cursor_pos.y == 0
# For Win32, we have an API call to get the number of rows below the
# cursor.
if is_windows():
self._min_available_height = self.output.get_rows_below_cursor_position()
else:
if self.use_alternate_screen:
self._min_available_height = self.output.get_size().rows
else:
# Asks for a cursor position report (CPR).
self.waiting_for_cpr = True
self.output.ask_for_cpr()
def call_inputhook(self, input_is_ready_func):
"""
Call the inputhook. (Called by a prompt-toolkit eventloop.)
"""
self._input_is_ready = input_is_ready_func
# Start thread that activates this pipe when there is input to process.
def thread():
input_is_ready_func(wait=True)
os.write(self._w, b'x')
threading.Thread(target=thread).start()
# Call inputhook.
self.inputhook(self)
# Flush the read end of the pipe.
try:
# Before calling 'os.read', call select.select. This is required
# when the gevent monkey patch has been applied. 'os.read' is never
# monkey patched and won't be cooperative, so that would block all
# other select() calls otherwise.
# See: http://www.gevent.org/gevent.os.html
# Note: On Windows, this is apparently not an issue.
# However, if we would ever want to add a select call, it
# should use `windll.kernel32.WaitForMultipleObjects`,
# because `select.select` can't wait for a pipe on Windows.
if not is_windows():
select_fds([self._r], timeout=None)
os.read(self._r, 1024)
except OSError:
# This happens when the window resizes and a SIGWINCH was received.
# We get 'Error: [Errno 4] Interrupted system call'
# Just ignore.
pass
self._input_is_ready = None
# Help Window.
Token.Window.Border: '#0000bb',
Token.Window.Title: 'bg:#bbbbbb #000000',
Token.Window.TIItleV2: 'bg:#6688bb #000000 bold',
# Meta-enter message.
Token.AcceptMessage: 'bg:#ffff88 #444444',
# Exit confirmation.
Token.ExitConfirmation: 'bg:#884444 #ffffff',
}
# Some changes to get a bit more contrast on Windows consoles.
# (They only support 16 colors.)
if is_windows() and not is_conemu_ansi():
default_ui_style.update({
Token.Sidebar.Title:
'bg:#00ff00 #ffffff',
Token.ExitConfirmation:
'bg:#ff4444 #ffffff',
Token.Toolbar.Validation:
'bg:#ff4444 #ffffff',
Token.Menu.Completions.Completion:
'bg:#ffffff #000000',
Token.Menu.Completions.Completion.Current:
'bg:#aaaaaa #000000',
})
blue_ui_style = {}
blue_ui_style.update(default_ui_style)
def __init__(
self,
get_globals=None,
get_locals=None,
history_filename=None,
vi_mode=False,
# For internal use.
_completer=None,
_validator=None,
_lexer=None,
_extra_buffers=None,
_extra_buffer_processors=None,
_on_start=None,
_extra_layout_body=None,
_extra_toolbars=None,
_input_buffer_height=None,
_accept_action=AcceptAction.RETURN_DOCUMENT,
_on_exit=AbortAction.RAISE_EXCEPTION):
self.get_globals = get_globals or (lambda: {})
self.get_locals = get_locals or self.get_globals
self.show_parenthesis_automator = False
self._completer = _completer or PythonCompleter(
self.get_globals, self.get_locals)
self._validator = _validator or PythonValidator(
self.get_compiler_flags)
self.history = FileHistory(
history_filename) if history_filename else InMemoryHistory()
self._lexer = _lexer or PygmentsLexer(PythonLexer)
self._extra_buffers = _extra_buffers
self._accept_action = _accept_action
self._on_exit = _on_exit
self._on_start = _on_start
self._input_buffer_height = _input_buffer_height
self._extra_layout_body = _extra_layout_body or []
self._extra_toolbars = _extra_toolbars or []
self._extra_buffer_processors = _extra_buffer_processors or []
# Settings.
self.show_signature = False
self.show_docstring = False
self.show_realtime_input = False
self.show_vars = False
self.show_meta_enter_message = True
self.completion_visualisation = CompletionVisualisation.MULTI_COLUMN
self.completion_menu_scroll_offset = 1
self.show_line_numbers = False
self.show_status_bar = True
self.wrap_lines = True
self.complete_while_typing = True
self.vi_mode = vi_mode
self.paste_mode = False # When True, don't insert whitespace after newline.
self.confirm_exit = True # Ask for confirmation when Control-D is pressed.
self.accept_input_on_enter = 2 # Accept when pressing Enter 'n' times.
# 'None' means that meta-enter is always required.
self.enable_open_in_editor = True
self.enable_system_bindings = True
self.enable_input_validation = True
self.enable_auto_suggest = False
self.enable_mouse_support = False
self.enable_history_search = False # When True, like readline, going
# back in history will filter the
# history on the records starting
# with the current input.
self.highlight_matching_parenthesis = False
self.show_sidebar = False # Currently show the sidebar.
self.show_sidebar_help = True # When the sidebar is visible, also show the help text.
self.show_exit_confirmation = False # Currently show 'Do you really want to exit?'
self.terminal_title = None # The title to be displayed in the terminal. (None or string.)
self.exit_message = 'Do you really want to exit?'
self.insert_blank_line_after_output = True # (For the REPL.)
# Tokens to be shown at the prompt.
self.prompt_style = 'classic' # The currently active style.
self.all_prompt_styles={ # Styles selectable from the menu.
'ipython':IPythonPrompt(self),
'classic':ClassicPrompt(),
}
self.get_input_prompt_tokens=lambda cli: \
self.all_prompt_styles[self.prompt_style].in_tokens(cli)
self.get_output_prompt_tokens=lambda cli: \
self.all_prompt_styles[self.prompt_style].out_tokens(cli)
#: Load styles.
self.code_styles = get_all_code_styles()
self.ui_styles = get_all_ui_styles()
self._current_code_style_name = 'default'
self._current_ui_style_name = 'default'
if is_windows():
self._current_code_style_name = 'win32'
self._current_style = self._generate_style()
self.true_color = False
# Options to be configurable from the sidebar.
self.options = self._create_options()
self.selected_option_index = 0
#: Incremeting integer counting the current statement.
self.current_statement_index = 1
# Code signatures. (This is set asynchronously after a timeout.)
self.signatures = []
self.waa = True # RYAN BURGERT STUFF
self.sand_creature = 'dust ball'
# Create a Registry for the key bindings.
self.key_bindings_registry = MergedRegistry([
ConditionalRegistry(
registry=load_key_bindings_for_prompt(
enable_abort_and_exit_bindings=True,
enable_search=True,
enable_open_in_editor=Condition(
lambda cli: self.enable_open_in_editor),
enable_system_bindings=Condition(
lambda cli: self.enable_system_bindings),
enable_auto_suggest_bindings=Condition(
lambda cli: self.enable_auto_suggest)),
# Disable all default key bindings when the sidebar or the exit confirmation
# are shown.
filter=Condition(lambda cli: not (self.show_sidebar or self.
show_exit_confirmation))),
load_mouse_bindings(),
load_python_bindings(self),
load_sidebar_bindings(self),
load_confirm_exit_bindings(self),
])
# Boolean indicating whether we have a signatures thread running.
# (Never run more than one at the same time.)
self._get_signatures_thread_running = False