def __init__(self, registry=None, enable_vi_mode=Never(), enable_system_bindings=Never(), enable_search=Always(), enable_open_in_editor=Never(), enable_all=Always()): # Accept both Filters and booleans as input. enable_vi_mode = to_cli_filter(enable_vi_mode) enable_system_bindings = to_cli_filter(enable_system_bindings) enable_open_in_editor = to_cli_filter(enable_open_in_editor) enable_all = to_cli_filter(enable_all) # Create registry. assert registry is None or isinstance(registry, Registry) self.registry = registry or Registry() # Emacs mode filter is the opposite of Vi mode. enable_emacs_mode = ~enable_vi_mode # Vi state. (Object to keep track of in which Vi mode we are.) self.vi_state = ViState() # Load basic bindings. load_basic_bindings(self.registry, enable_all) load_basic_system_bindings(self.registry, enable_system_bindings & enable_all) # Load emacs bindings. load_emacs_bindings(self.registry, enable_emacs_mode & enable_all) load_emacs_open_in_editor_bindings( self.registry, enable_emacs_mode & enable_open_in_editor & enable_all) load_emacs_search_bindings( self.registry, enable_emacs_mode & enable_search & enable_all) load_emacs_system_bindings( self.registry, enable_emacs_mode & enable_system_bindings & enable_all) # Load Vi bindings. load_vi_bindings(self.registry, self.vi_state, enable_visual_key=~enable_open_in_editor, filter=enable_vi_mode & enable_all) load_vi_open_in_editor_bindings( self.registry, self.vi_state, enable_vi_mode & enable_open_in_editor & enable_all) load_vi_search_bindings(self.registry, self.vi_state, enable_vi_mode & enable_search & enable_all) load_vi_system_bindings( self.registry, self.vi_state, enable_vi_mode & enable_system_bindings & enable_all)
def __init__(self, registry=None, enable_vi_mode=Never(), enable_system_prompt=Never(), enable_search=Always(), enable_open_in_editor=Never()): assert registry is None or isinstance(registry, Registry) assert isinstance(enable_vi_mode, CLIFilter) assert isinstance(enable_system_prompt, CLIFilter) assert isinstance(enable_open_in_editor, CLIFilter) self.registry = registry or Registry() # Emacs mode filter is the opposite of Vi mode. enable_emacs_mode = ~enable_vi_mode # Vi state. (Object to keep track of in which Vi mode we are.) self.vi_state = ViState() # Load emacs bindings. load_emacs_bindings(self.registry, enable_emacs_mode) load_emacs_open_in_editor_bindings( self.registry, enable_emacs_mode & enable_open_in_editor) load_emacs_search_bindings(self.registry, enable_emacs_mode & enable_search) load_emacs_system_bindings(self.registry, enable_emacs_mode & enable_system_prompt) # Load Vi bindings. load_vi_bindings(self.registry, self.vi_state, enable_vi_mode) load_vi_open_in_editor_bindings(self.registry, self.vi_state, enable_vi_mode & enable_open_in_editor) load_vi_search_bindings(self.registry, self.vi_state, enable_vi_mode & enable_search) load_vi_system_bindings(self.registry, self.vi_state, enable_vi_mode & enable_system_prompt)
def __init__(self, registry=None, enable_vi_mode=False, enable_system_prompt=False, enable_search=True, enable_open_in_editor=False): self.registry = registry or Registry() # Flags. You can change these anytime. self.enable_vi_mode = enable_vi_mode self.enable_system_prompt = enable_system_prompt self.enable_search = enable_search self.enable_open_in_editor = enable_open_in_editor # Create set of filters to enable/disable sets of key bindings at # runtime. vi_mode_enabled = ViModeEnabled(self) emacs_mode_enabled = ~ vi_mode_enabled system_prompt_enabled = SystemPromptEnabled(self) search_enabled = SearchEnabled(self) open_in_editor_enabled = OpenInEditorEnabled(self) # Vi state. (Object to keep track of in which Vi mode we are.) self.vi_state = ViState() # Load all bindings in the registry with the correct filters. load_emacs_bindings(self.registry, emacs_mode_enabled) load_emacs_open_in_editor_bindings( self.registry, emacs_mode_enabled & open_in_editor_enabled) load_emacs_search_bindings( self.registry, emacs_mode_enabled & search_enabled) load_emacs_system_bindings( self.registry, emacs_mode_enabled & system_prompt_enabled) load_vi_bindings(self.registry, self.vi_state, vi_mode_enabled) load_vi_open_in_editor_bindings( self.registry, self.vi_state, vi_mode_enabled & open_in_editor_enabled) load_vi_search_bindings( self.registry, self.vi_state, vi_mode_enabled & search_enabled) load_vi_system_bindings( self.registry, self.vi_state, vi_mode_enabled & system_prompt_enabled)
def __init__(self): #: True when the prefix key (Ctrl-B) has been pressed. self.has_prefix = False #: Error/info message. self.message = None # Vi state. (Each client has its own state.) self.vi_state = ViState() # True when the command prompt is visible. self.command_mode = False # When a "confirm-before" command is running, # Show this text in the command bar. When confirmed, execute # confirm_command. self.confirm_text = None self.confirm_command = None # When a "command-prompt" command is running. self.prompt_text = None self.prompt_command = None
def __init__(self, layout=None, style=None, include_default_pygments_style=True, key_bindings=None, clipboard=None, full_screen=False, color_depth=None, mouse_support=False, enable_page_navigation_bindings=None, # Can be None, True or False. paste_mode=False, editing_mode=EditingMode.EMACS, erase_when_done=False, reverse_vi_search_direction=False, min_redraw_interval=None, max_render_postpone_time=0, on_reset=None, on_invalidate=None, before_render=None, after_render=None, # I/O. input=None, output=None): # If `enable_page_navigation_bindings` is not specified, enable it in # case of full screen applications only. This can be overridden by the user. if enable_page_navigation_bindings is None: enable_page_navigation_bindings = Condition(lambda: self.full_screen) paste_mode = to_filter(paste_mode) mouse_support = to_filter(mouse_support) reverse_vi_search_direction = to_filter(reverse_vi_search_direction) enable_page_navigation_bindings = to_filter(enable_page_navigation_bindings) include_default_pygments_style = to_filter(include_default_pygments_style) assert layout is None or isinstance(layout, Layout), 'Got layout: %r' % (layout, ) assert key_bindings is None or isinstance(key_bindings, KeyBindingsBase) assert clipboard is None or isinstance(clipboard, Clipboard) assert isinstance(full_screen, bool) assert (color_depth is None or callable(color_depth) or color_depth in ColorDepth._ALL), 'Got color_depth: %r' % (color_depth, ) assert isinstance(editing_mode, six.string_types) assert style is None or isinstance(style, BaseStyle) assert isinstance(erase_when_done, bool) assert min_redraw_interval is None or isinstance(min_redraw_interval, (float, int)) assert max_render_postpone_time is None or isinstance(max_render_postpone_time, (float, int)) assert on_reset is None or callable(on_reset) assert on_invalidate is None or callable(on_invalidate) assert before_render is None or callable(before_render) assert after_render is None or callable(after_render) assert output is None or isinstance(output, Output) assert input is None or isinstance(input, Input) self.style = style if layout is None: layout = create_dummy_layout() # Key bindings. self.key_bindings = key_bindings self._default_bindings = load_key_bindings() self._page_navigation_bindings = load_page_navigation_bindings() self.layout = layout self.clipboard = clipboard or InMemoryClipboard() self.full_screen = full_screen self._color_depth = color_depth self.mouse_support = mouse_support self.paste_mode = paste_mode self.editing_mode = editing_mode self.erase_when_done = erase_when_done self.reverse_vi_search_direction = reverse_vi_search_direction self.enable_page_navigation_bindings = enable_page_navigation_bindings self.min_redraw_interval = min_redraw_interval self.max_render_postpone_time = max_render_postpone_time # Events. self.on_invalidate = Event(self, on_invalidate) self.on_reset = Event(self, on_reset) self.before_render = Event(self, before_render) self.after_render = Event(self, after_render) # I/O. self.output = output or get_default_output() self.input = input or get_default_input() # List of 'extra' functions to execute before a Application.run. self.pre_run_callables = [] self._is_running = False self.future = None #: Quoted insert. This flag is set if we go into quoted insert mode. self.quoted_insert = False #: Vi state. (For Vi key bindings.) self.vi_state = ViState() self.emacs_state = EmacsState() #: When to flush the input (For flushing escape keys.) This is important #: on terminals that use vt100 input. We can't distinguish the escape #: key from for instance the left-arrow key, if we don't know what follows #: after "\x1b". This little timer will consider "\x1b" to be escape if #: nothing did follow in this time span. #: This seems to work like the `ttimeoutlen` option in Vim. self.ttimeoutlen = .5 # Seconds. #: Like Vim's `timeoutlen` option. This can be `None` or a float. For #: instance, suppose that we have a key binding AB and a second key #: binding A. If the uses presses A and then waits, we don't handle #: this binding yet (unless it was marked 'eager'), because we don't #: know what will follow. This timeout is the maximum amount of time #: that we wait until we call the handlers anyway. Pass `None` to #: disable this timeout. self.timeoutlen = 1.0 #: The `Renderer` instance. # Make sure that the same stdout is used, when a custom renderer has been passed. self._merged_style = self._create_merged_style(include_default_pygments_style) self.renderer = Renderer( self._merged_style, self.output, full_screen=full_screen, mouse_support=mouse_support, cpr_not_supported_callback=self.cpr_not_supported_callback) #: Render counter. This one is increased every time the UI is rendered. #: It can be used as a key for caching certain information during one #: rendering. self.render_counter = 0 # Invalidate flag. When 'True', a repaint has been scheduled. self._invalidated = False self._invalidate_events = [] # Collection of 'invalidate' Event objects. self._last_redraw_time = 0 # Unix timestamp of last redraw. Used when # `min_redraw_interval` is given. #: The `InputProcessor` instance. self.key_processor = KeyProcessor(_CombinedRegistry(self)) # If `run_in_terminal` was called. This will point to a `Future` what will be # set at the point when the previous run finishes. self._running_in_terminal = False self._running_in_terminal_f = None # Trigger initialize callback. self.reset()
def __init__( self, layout: Optional[Layout] = None, style: Optional[BaseStyle] = None, include_default_pygments_style: FilterOrBool = True, style_transformation: Optional[StyleTransformation] = None, key_bindings: Optional[KeyBindingsBase] = None, clipboard: Optional[Clipboard] = None, full_screen: bool = False, color_depth: Union[ColorDepth, Callable[[], Union[ColorDepth, None]], None] = None, mouse_support: FilterOrBool = False, enable_page_navigation_bindings: Optional[ FilterOrBool] = None, # Can be None, True or False. paste_mode: FilterOrBool = False, editing_mode: EditingMode = EditingMode.EMACS, erase_when_done: bool = False, reverse_vi_search_direction: FilterOrBool = False, min_redraw_interval: Union[float, int, None] = None, max_render_postpone_time: Union[float, int, None] = 0.01, refresh_interval: Optional[float] = None, on_reset: Optional[ApplicationEventHandler] = None, on_invalidate: Optional[ApplicationEventHandler] = None, before_render: Optional[ApplicationEventHandler] = None, after_render: Optional[ApplicationEventHandler] = None, # I/O. input: Optional[Input] = None, output: Optional[Output] = None, ): # If `enable_page_navigation_bindings` is not specified, enable it in # case of full screen applications only. This can be overridden by the user. if enable_page_navigation_bindings is None: enable_page_navigation_bindings = Condition( lambda: self.full_screen) paste_mode = to_filter(paste_mode) mouse_support = to_filter(mouse_support) reverse_vi_search_direction = to_filter(reverse_vi_search_direction) enable_page_navigation_bindings = to_filter( enable_page_navigation_bindings) include_default_pygments_style = to_filter( include_default_pygments_style) if layout is None: layout = create_dummy_layout() if style_transformation is None: style_transformation = DummyStyleTransformation() self.style = style self.style_transformation = style_transformation # Key bindings. self.key_bindings = key_bindings self._default_bindings = load_key_bindings() self._page_navigation_bindings = load_page_navigation_bindings() self.layout = layout self.clipboard = clipboard or InMemoryClipboard() self.full_screen: bool = full_screen self._color_depth = color_depth self.mouse_support = mouse_support self.paste_mode = paste_mode self.editing_mode = editing_mode self.erase_when_done = erase_when_done self.reverse_vi_search_direction = reverse_vi_search_direction self.enable_page_navigation_bindings = enable_page_navigation_bindings self.min_redraw_interval = min_redraw_interval self.max_render_postpone_time = max_render_postpone_time self.refresh_interval = refresh_interval # Events. self.on_invalidate = Event(self, on_invalidate) self.on_reset = Event(self, on_reset) self.before_render = Event(self, before_render) self.after_render = Event(self, after_render) # I/O. session = get_app_session() self.output = output or session.output self.input = input or session.input # List of 'extra' functions to execute before a Application.run. self.pre_run_callables: List[Callable[[], None]] = [] self._is_running = False self.future: Optional[Future[_AppResult]] = None self.loop: Optional[AbstractEventLoop] = None self.context: Optional[contextvars.Context] = None #: Quoted insert. This flag is set if we go into quoted insert mode. self.quoted_insert = False #: Vi state. (For Vi key bindings.) self.vi_state = ViState() self.emacs_state = EmacsState() #: When to flush the input (For flushing escape keys.) This is important #: on terminals that use vt100 input. We can't distinguish the escape #: key from for instance the left-arrow key, if we don't know what follows #: after "\x1b". This little timer will consider "\x1b" to be escape if #: nothing did follow in this time span. #: This seems to work like the `ttimeoutlen` option in Vim. self.ttimeoutlen = 0.5 # Seconds. #: Like Vim's `timeoutlen` option. This can be `None` or a float. For #: instance, suppose that we have a key binding AB and a second key #: binding A. If the uses presses A and then waits, we don't handle #: this binding yet (unless it was marked 'eager'), because we don't #: know what will follow. This timeout is the maximum amount of time #: that we wait until we call the handlers anyway. Pass `None` to #: disable this timeout. self.timeoutlen = 1.0 #: The `Renderer` instance. # Make sure that the same stdout is used, when a custom renderer has been passed. self._merged_style = self._create_merged_style( include_default_pygments_style) self.renderer = Renderer( self._merged_style, self.output, self.input, full_screen=full_screen, mouse_support=mouse_support, cpr_not_supported_callback=self.cpr_not_supported_callback, ) #: Render counter. This one is increased every time the UI is rendered. #: It can be used as a key for caching certain information during one #: rendering. self.render_counter = 0 # Invalidate flag. When 'True', a repaint has been scheduled. self._invalidated = False self._invalidate_events: List[Event[object]] = [ ] # Collection of 'invalidate' Event objects. self._last_redraw_time = 0.0 # Unix timestamp of last redraw. Used when # `min_redraw_interval` is given. #: The `InputProcessor` instance. self.key_processor = KeyProcessor(_CombinedRegistry(self)) # If `run_in_terminal` was called. This will point to a `Future` what will be # set at the point when the previous run finishes. self._running_in_terminal = False self._running_in_terminal_f: Optional[Future[None]] = None # Trigger initialize callback. self.reset()
def __init__(self, registry=None, enable_vi_mode=False, get_vi_state=None, get_search_state=None, enable_abort_and_exit_bindings=False, enable_system_bindings=False, enable_search=False, enable_open_in_editor=False, enable_extra_page_navigation=False, enable_auto_suggest_bindings=False, enable_all=True): assert registry is None or isinstance(registry, Registry) assert get_vi_state is None or callable(get_vi_state) assert get_search_state is None or callable(get_search_state) # Create registry. self.registry = registry or Registry() # Vi state. (Object to keep track of in which Vi mode we are.) if get_vi_state is None: vi_state = ViState( ) # Stateful. Should be defined outside the function below. def get_vi_state(cli): return vi_state self.get_vi_state = get_vi_state # Accept both Filters and booleans as input. enable_vi_mode = to_cli_filter(enable_vi_mode) enable_abort_and_exit_bindings = to_cli_filter( enable_abort_and_exit_bindings) enable_system_bindings = to_cli_filter(enable_system_bindings) enable_search = to_cli_filter(enable_search) enable_open_in_editor = to_cli_filter(enable_open_in_editor) enable_extra_page_navigation = to_cli_filter( enable_extra_page_navigation) enable_auto_suggest_bindings = to_cli_filter( enable_auto_suggest_bindings) enable_all = to_cli_filter(enable_all) # Emacs mode filter is the opposite of Vi mode. enable_emacs_mode = ~enable_vi_mode # Load basic bindings. load_basic_bindings(self.registry, enable_all) load_abort_and_exit_bindings( self.registry, enable_abort_and_exit_bindings & enable_all) load_basic_system_bindings(self.registry, enable_system_bindings & enable_all) # Load emacs bindings. load_emacs_bindings(self.registry, enable_emacs_mode & enable_all) load_emacs_open_in_editor_bindings( self.registry, enable_emacs_mode & enable_open_in_editor & enable_all) load_emacs_search_bindings(self.registry, filter=enable_emacs_mode & enable_search & enable_all, get_search_state=get_search_state) load_emacs_system_bindings( self.registry, enable_emacs_mode & enable_system_bindings & enable_all) load_extra_emacs_page_navigation_bindings( self.registry, enable_emacs_mode & enable_extra_page_navigation & enable_all) # Load Vi bindings. load_vi_bindings(self.registry, self.get_vi_state, enable_visual_key=~enable_open_in_editor, filter=enable_vi_mode & enable_all, get_search_state=get_search_state) load_vi_open_in_editor_bindings( self.registry, self.get_vi_state, enable_vi_mode & enable_open_in_editor & enable_all) load_vi_search_bindings(self.registry, self.get_vi_state, filter=enable_vi_mode & enable_search & enable_all, get_search_state=get_search_state) load_vi_system_bindings( self.registry, self.get_vi_state, enable_vi_mode & enable_system_bindings & enable_all) load_extra_vi_page_navigation_bindings( self.registry, enable_vi_mode & enable_extra_page_navigation & enable_all) # Suggestion bindings. # (This has to come at the end, because the Vi bindings also have an # implementation for the "right arrow", but we really want the # suggestion binding when a suggestion is available.) load_auto_suggestion_bindings( self.registry, enable_auto_suggest_bindings & enable_all)
def __init__( self, layout=None, style=None, key_bindings=None, clipboard=None, full_screen=False, mouse_support=False, enable_page_navigation_bindings=False, paste_mode=False, editing_mode=EditingMode.EMACS, erase_when_done=False, reverse_vi_search_direction=False, min_redraw_interval=None, max_render_postpone_time=0, on_reset=None, on_render=None, on_invalidate=None, # I/O. input=None, output=None): paste_mode = to_filter(paste_mode) mouse_support = to_filter(mouse_support) reverse_vi_search_direction = to_filter(reverse_vi_search_direction) enable_page_navigation_bindings = to_filter( enable_page_navigation_bindings) assert layout is None or isinstance(layout, Layout) assert key_bindings is None or isinstance(key_bindings, KeyBindingsBase) assert clipboard is None or isinstance(clipboard, Clipboard) assert isinstance(full_screen, bool) assert isinstance(editing_mode, six.string_types) assert style is None or isinstance(style, BaseStyle) assert isinstance(erase_when_done, bool) assert min_redraw_interval is None or isinstance( min_redraw_interval, (float, int)) assert max_render_postpone_time is None or isinstance( max_render_postpone_time, (float, int)) assert on_reset is None or callable(on_reset) assert on_render is None or callable(on_render) assert on_invalidate is None or callable(on_invalidate) assert output is None or isinstance(output, Output) assert input is None or isinstance(input, Input) self.style = style if layout is None: layout = create_dummy_layout() # Key bindings. self.key_bindings = key_bindings self._default_bindings = load_key_bindings() self._page_navigation_bindings = load_page_navigation_bindings() self.layout = layout self.clipboard = clipboard or InMemoryClipboard() self.full_screen = full_screen self.mouse_support = mouse_support self.paste_mode = paste_mode self.editing_mode = editing_mode self.erase_when_done = erase_when_done self.reverse_vi_search_direction = reverse_vi_search_direction self.enable_page_navigation_bindings = enable_page_navigation_bindings self.min_redraw_interval = min_redraw_interval self.max_render_postpone_time = max_render_postpone_time # Events. self.on_invalidate = Event(self, on_invalidate) self.on_render = Event(self, on_render) self.on_reset = Event(self, on_reset) # I/O. self.output = output or get_default_output() self.input = input or get_default_input() # List of 'extra' functions to execute before a Application.run. self.pre_run_callables = [] self._is_running = False self.future = None #: Quoted insert. This flag is set if we go into quoted insert mode. self.quoted_insert = False #: Vi state. (For Vi key bindings.) self.vi_state = ViState() #: When to flush the input (For flushing escape keys.) This is important #: on terminals that use vt100 input. We can't distinguish the escape #: key from for instance the left-arrow key, if we don't know what follows #: after "\x1b". This little timer will consider "\x1b" to be escape if #: nothing did follow in this time span. #: This seems to work like the `ttimeoutlen` option in Vim. self.input_timeout = .5 #: The `Renderer` instance. # Make sure that the same stdout is used, when a custom renderer has been passed. self._merged_style = merge_styles([ default_style(), DynamicStyle(lambda: self.style), ]) self.renderer = Renderer( self._merged_style, self.output, full_screen=full_screen, mouse_support=mouse_support, cpr_not_supported_callback=self.cpr_not_supported_callback) #: Render counter. This one is increased every time the UI is rendered. #: It can be used as a key for caching certain information during one #: rendering. self.render_counter = 0 # Invalidate flag. When 'True', a repaint has been scheduled. self._invalidated = False self._invalidate_events = [ ] # Collection of 'invalidate' Event objects. self._last_redraw_time = 0 # Unix timestamp of last redraw. Used when # `min_redraw_interval` is given. #: The `InputProcessor` instance. self.key_processor = KeyProcessor(_CombinedRegistry(self)) # If `run_in_terminal` was called. This will point to a `Future` what will be # set at the point whene the previous run finishes. self._running_in_terminal = False self._running_in_terminal_f = None # Trigger initialize callback. self.reset()