def _draw_number(screen, x_offset, number, token=Token.Clock, default_token=Token): " Write number at position. " for y, row in enumerate(_numbers[number]): screen_row = screen.data_buffer[y] for x, n in enumerate(row): t = token if n == '#' else default_token screen_row[x + x_offset] = Char(' ', t)
def create_tutorial_layout(lex): """ layout for example tutorial """ lexer, _, _ = get_lexers(lex, None, None) layout_full = HSplit([ FloatContainer( Window(BufferControl(input_processors=input_processors, lexer=lexer, preview_search=Always()), get_height=get_height), [ Float(xcursor=True, ycursor=True, content=CompletionsMenu( max_height=MAX_COMPLETION, scroll_offset=1, extra_filter=(HasFocus(DEFAULT_BUFFER)))) ]), ConditionalContainer(HSplit([ get_hline(), get_param(lexer), get_hline(), Window(content=BufferControl(buffer_name='example_line', lexer=lexer), ), Window(TokenListControl(get_tutorial_tokens, default_char=Char(' ', Token.Toolbar)), height=D.exact(1)), ]), filter=~IsDone() & RendererHeightIsKnown()) ]) return layout_full
def python_sidebar_help(python_input): """ Create the `Layout` for the help text for the current item in the sidebar. """ token = Token.Sidebar.HelpText def get_current_description(): """ Return the description of the selected option. """ i = 0 for category in python_input.options: for option in category.options: if i == python_input.selected_option_index: return option.description i += 1 return '' def get_tokens(cli): return [(token, get_current_description())] return ConditionalContainer( content=Window(TokenListControl(get_tokens, Char(token=token)), height=LayoutDimension(min=3)), filter=ShowSidebar(python_input) & Condition(lambda cli: python_input.show_sidebar_help) & ~IsDone())
def show_sidebar_button_info(python_input): """ Create `Layout` for the information in the right-bottom corner. (The right part of the status bar.) """ @if_mousedown def toggle_sidebar(cli, mouse_event): " Click handler for the menu. " python_input.show_sidebar = not python_input.show_sidebar token = Token.Toolbar.Status version = sys.version_info tokens = [ (token.Key, '[F2]', toggle_sidebar), (token, ' Menu', toggle_sidebar), (token, ' - '), (token.PythonVersion, '%s %i.%i.%i' % (platform.python_implementation(), version[0], version[1], version[2])), (token, ' '), ] width = token_list_width(tokens) def get_tokens(cli): # Python version return tokens return ConditionalContainer( content=Window( TokenListControl(get_tokens, default_char=Char(token=token)), height=LayoutDimension.exact(1), width=LayoutDimension.exact(width)), filter=~IsDone() & RendererHeightIsKnown() & Condition(lambda cli: python_input.show_status_bar and not python_input.show_exit_confirmation))
def status_bar(python_input, *items): return StatusToolbar( items, default_char=Char(token=StatusToken), filter=~IsDone() & RendererHeightIsKnown() & Condition(lambda cli: python_input.show_bliss_bar and python_input. bliss_bar.items and not python_input.show_exit_confirmation))
def __init__(self, editor, buffer_window, buffer_name): def get_scroll_text(): info = buffer_window.render_info if info: if info.full_height_visible: return 'All' elif info.top_visible: return 'Top' elif info.bottom_visible: return 'Bot' else: percentage = info.vertical_scroll_percentage return '%2i%%' % percentage return '' def get_tokens(cli): main_document = cli.buffers[buffer_name].document return [ (Token.Toolbar.Status.CursorPosition, '(%i,%i)' % (main_document.cursor_position_row + 1, main_document.cursor_position_col + 1)), (Token.Toolbar.Status, ' - '), (Token.Toolbar.Status.Percentage, get_scroll_text()), (Token.Toolbar.Status, ' '), ] super(WindowStatusBarRuler, self).__init__( Window( TokenListControl(get_tokens, default_char=Char(' ', Token.Toolbar.Status), align_right=True), height=LayoutDimension.exact(1), ), filter=Condition(lambda cli: editor.show_ruler))
def create_popup_window(title, body): """ Return the layout for a pop-up window. It consists of a title bar showing the `title` text, and a body layout. The window is surrounded by borders. """ assert isinstance(title, six.text_type) assert isinstance(body, Container) return HSplit([ VSplit([ Window(width=D.exact(1), height=D.exact(1), content=FillControl(BORDER.TOP_LEFT, token=Token.Window.Border)), TokenListToolbar( get_tokens=lambda cli: [(Token.Window.Title, ' %s ' % title)], align_center=True, default_char=Char(BORDER.HORIZONTAL, Token.Window.Border)), Window(width=D.exact(1), height=D.exact(1), content=FillControl(BORDER.TOP_RIGHT, token=Token.Window.Border)), ]), VSplit([ Window(width=D.exact(1), content=FillControl(BORDER.VERTICAL, token=Token.Window.Border)), body, Window(width=D.exact(1), content=FillControl(BORDER.VERTICAL, token=Token.Window.Border)), ]), VSplit([ Window(width=D.exact(1), height=D.exact(1), content=FillControl(BORDER.BOTTOM_LEFT, token=Token.Window.Border)), Window(height=D.exact(1), content=FillControl(BORDER.HORIZONTAL, token=Token.Window.Border)), Window(width=D.exact(1), height=D.exact(1), content=FillControl(BORDER.BOTTOM_RIGHT, token=Token.Window.Border)), ]), ])
def __init__(self, editor, editor_buffer): def get_tokens(cli): insert_mode = cli.vi_state.input_mode in (InputMode.INSERT, InputMode.INSERT_MULTIPLE) replace_mode = cli.vi_state.input_mode == InputMode.REPLACE sel = cli.buffers[editor_buffer.buffer_name].selection_state visual_line = sel is not None and sel.type == SelectionType.LINES visual_block = sel is not None and sel.type == SelectionType.BLOCK visual_char = sel is not None and sel.type == SelectionType.CHARACTERS def mode(): if cli.current_buffer_name == editor_buffer.buffer_name: if insert_mode: if editor.paste_mode: return ' -- INSERT (paste)--' else: return ' -- INSERT --' elif replace_mode: return ' -- REPLACE --' elif visual_block: return ' -- VISUAL BLOCK --' elif visual_line: return ' -- VISUAL LINE --' elif visual_char: return ' -- VISUAL --' return ' ' return [ (Token.Toolbar.Status, ' '), (Token.Toolbar.Status, editor_buffer.location or ''), (Token.Toolbar.Status, ' [New File]' if editor_buffer.is_new else ''), (Token.Toolbar.Status, '*' if editor_buffer.has_unsaved_changes else ''), (Token.Toolbar.Status, ' '), (Token.Toolbar.Status, mode()), ] super(WindowStatusBar, self).__init__(get_tokens, default_char=Char(' ', Token.Toolbar.Status))
def _reset_screen(self): """ Reset the Screen content. (also called when switching from/to alternate buffer. """ self.pt_screen = Screen(default_char=Char( ' ', '')) # TODO: maybe stop using this Screen class. self.pt_screen.cursor_position = CursorPosition(0, 0) self.pt_screen.show_cursor = True self.data_buffer = self.pt_screen.data_buffer self.pt_cursor_position = self.pt_screen.cursor_position self.wrapped_lines = [] # List of line indexes that were wrapped. self._attrs = Attrs(color=None, bgcolor=None, bold=False, underline=False, italic=False, blink=False, reverse=False, hidden=False) self._style_str = '' self.margins = None self.max_y = 0 # Max 'y' position to which is written.
def python_sidebar_navigation(python_input): """ Create the `Layout` showing the navigation information for the sidebar. """ def get_tokens(cli): tokens = [] T = Token.Sidebar # Show navigation info. tokens.extend([ (T.Separator, ' ' * 43 + '\n'), (T, ' '), (T.Key, '[Arrows]'), (T, ' '), (T.Key.Description, 'Navigate'), (T, ' '), (T.Key, '[Enter]'), (T, ' '), (T.Key.Description, 'Hide menu'), ]) return tokens return ConditionalContainer(content=Window( TokenListControl(get_tokens, Char(token=Token.Sidebar)), width=LayoutDimension.exact(43), height=LayoutDimension.exact(2)), filter=ShowSidebar(python_input) & ~IsDone())
def __init__(self, pager): def get_tokens(cli): return pager.titlebar_tokens super(Titlebar, self).__init__( get_tokens, default_char=Char(' ', Token.Titlebar), filter=Condition(lambda cli: pager.display_titlebar))
def _draw_number(screen, x_offset, y_offset, number, style='class:clock', transparent=False): " Write number at position. " fg = Char(' ', 'class:clock') bg = Char(' ', '') for y, row in enumerate(_numbers[number]): screen_row = screen.data_buffer[y + y_offset] for x, n in enumerate(row): if n == '#': screen_row[x + x_offset] = fg elif not transparent: screen_row[x + x_offset] = bg
def python_sidebar(python_input): """ Create the `Layout` for the sidebar with the configurable options. """ def get_tokens(cli): tokens = [] T = Token.Sidebar def append_category(category): tokens.extend([ (T, ' '), (T.Title, ' %-36s' % category.title), (T, '\n'), ]) def append(selected, label, status): token = T.Selected if selected else T tokens.append((T, ' >' if selected else ' ')) tokens.append((token.Label, '%-24s' % label)) tokens.append((token.Status, ' ')) tokens.append((token.Status, '%s' % status)) if selected: tokens.append((Token.SetCursorPosition, '')) tokens.append((token.Status, ' ' * (14 - len(status)))) tokens.append((T, '<' if selected else '')) tokens.append((T, '\n')) i = 0 for category in python_input.options: append_category(category) for option in category.options: append(i == python_input.selected_option_index, option.title, '%s' % option.get_current_value()) i += 1 tokens.pop() # Remove last newline. return tokens class Control(TokenListControl): def move_cursor_down(self, cli): python_input.selected_option_index += 1 def move_cursor_up(self, cli): python_input.selected_option_index -= 1 return ConditionalContainer( content=Window( Control(get_tokens, Char(token=Token.Sidebar), has_focus=ShowSidebar(python_input) & ~IsDone()), width=LayoutDimension.exact(43), height=LayoutDimension(min=3), scroll_offsets=ScrollOffsets(top=1, bottom=1)), filter=ShowSidebar(python_input) & ~IsDone())
def status_bar(key_bindings_manager, python_input): """ Create the `Layout` for the status bar. """ TB = Token.Toolbar.Status @if_mousedown def toggle_paste_mode(cli, mouse_event): python_input.paste_mode = not python_input.paste_mode @if_mousedown def enter_history(cli, mouse_event): python_input.enter_history(cli) def get_tokens(cli): python_buffer = cli.buffers[DEFAULT_BUFFER] result = [] append = result.append append((TB, ' ')) result.extend(get_inputmode_tokens(cli, python_input)) append((TB, ' ')) # Position in history. append((TB, '%i/%i ' % (python_buffer.working_index + 1, len(python_buffer._working_lines)))) # Shortcuts. if not python_input.vi_mode and cli.current_buffer_name == SEARCH_BUFFER: append((TB, '[Ctrl-G] Cancel search [Enter] Go to this position.')) elif bool(cli.current_buffer.selection_state ) and not python_input.vi_mode: # Emacs cut/copy keys. append( (TB, '[Ctrl-W] Cut [Meta-W] Copy [Ctrl-Y] Paste [Ctrl-G] Cancel')) else: result.extend([ (TB.Key, '[F3]', enter_history), (TB, ' History ', enter_history), (TB.Key, '[F6]', toggle_paste_mode), (TB, ' ', toggle_paste_mode), ]) if python_input.paste_mode: append((TB.PasteModeOn, 'Paste mode (on)', toggle_paste_mode)) else: append((TB, 'Paste mode', toggle_paste_mode)) return result return TokenListToolbar( get_tokens, default_char=Char(token=TB), filter=~IsDone() & RendererHeightIsKnown() & Condition(lambda cli: python_input.show_status_bar and not python_input.show_exit_confirmation))
def chars_are_equal(new_char, old_char): """ Test whether two `Char` instances are equal if printed. """ if grayed: new_char = Char(new_char.char, token=Token.Aborted) # We ignore z-index, that does not matter if things get painted. return new_char.char == old_char.char and new_char.token == old_char.token
def __init__(self): def get_tokens(cli): return [ (Token.Header, " Experimental Pure Python Vim editor. Type ':q' to quit." ), ] super(Header, self).__init__(get_tokens, default_char=Char(' ', Token.Header))
def write_to_screen(self, cli, screen, mouse_handlers, write_position): """ Write window to screen. This renders the user control, the margins and copies everything over to the absolute position at the given screen. """ # Set size of the screen. self.process.set_size(write_position.width, write_position.height) vertical_scroll = self.process.screen.line_offset # Render UserControl. temp_screen = self.process.screen.pt_screen # Write body to screen. self._copy_body(cli, temp_screen, screen, write_position, vertical_scroll, write_position.width) # Set mouse handlers. def mouse_handler(cli, mouse_event): """ Wrapper around the mouse_handler of the `UIControl` that turns absolute coordinates into relative coordinates. """ position = mouse_event.position # Call the mouse handler of the UIControl first. self._mouse_handler( cli, MouseEvent(position=Point(x=position.x - write_position.xpos, y=position.y - write_position.ypos + vertical_scroll), event_type=mouse_event.event_type)) mouse_handlers.set_mouse_handler_for_range( x_min=write_position.xpos, x_max=write_position.xpos + write_position.width, y_min=write_position.ypos, y_max=write_position.ypos + write_position.height, handler=mouse_handler) # If reverse video is enabled for the whole screen. if self.process.screen.has_reverse_video: data_buffer = screen.data_buffer for y in range(write_position.ypos, write_position.ypos + write_position.height): row = data_buffer[y] for x in range(write_position.xpos, write_position.xpos + write_position.width): char = row[x] token = list(char.token or DEFAULT_TOKEN) # The token looks like ('C', *attrs). Replace the value of the reverse flag. if token and token[0] == 'C': token[-1] = not token[-1] # Invert reverse value. row[x] = Char(char.char, tuple(token))
def draw(self, char): pt_screen = self.pt_screen # Translating a given character. if self.charset: char = char.translate(self.g1_charset) else: char = char.translate(self.g0_charset) # Calculate character width. (We use the prompt_toolkit function which # has built-in caching.) char_width = get_cwidth(char) # If this was the last column in a line and auto wrap mode is # enabled, move the cursor to the beginning of the next line, # otherwise replace characters already displayed with newly # entered. if pt_screen.cursor_position.x >= self.columns: if mo.DECAWM in self.mode: self.carriage_return() self.linefeed() else: pt_screen.cursor_position.x -= char_width # If Insert mode is set, new characters move old characters to # the right, otherwise terminal is in Replace mode and new # characters replace old characters at cursor position. if mo.IRM in self.mode: self.insert_characters(char_width) token = ('C', ) + self._attrs row = pt_screen.data_buffer[pt_screen.cursor_position.y] row[pt_screen.cursor_position.x] = Char(char, token) if char_width > 1: row[pt_screen.cursor_position.x + 1] = Char(' ', token) # .. note:: We can't use :meth:`cursor_forward()`, because that # way, we'll never know when to linefeed. pt_screen.cursor_position.x += char_width self.max_y = max(self.max_y, pt_screen.cursor_position.y)
def create_screen(self, cli, width, height): screen = Screen(initial_width=width) for y in range(self.HEIGHT): for x in range(self.WIDTH): screen.data_buffer[y][x] = Char(' ', Token) # Display time. now = datetime.datetime.now() _draw_number(screen, 0, now.hour // 10) _draw_number(screen, 6, now.hour % 10) _draw_number(screen, 16, now.minute // 10) _draw_number(screen, 23, now.minute % 10) # Add a colon screen.data_buffer[1][13] = Char(' ', Token.Clock) screen.data_buffer[3][13] = Char(' ', Token.Clock) screen.width = self.WIDTH screen.height = self.HEIGHT return screen
def create_default_layout(message='', lexer=None, is_password=False, reserve_space_for_menu=False, get_bottom_toolbar_tokens=None): """ Generate default layout. """ assert get_bottom_toolbar_tokens is None or callable(get_bottom_toolbar_tokens) # Create processors list. input_processors = [HighlightSearchProcessor(), HighlightSelectionProcessor()] if is_password: input_processors.extend([PasswordProcessor(), DefaultPrompt(message)]) else: input_processors.append(DefaultPrompt(message)) # Create bottom toolbar. if get_bottom_toolbar_tokens: toolbars = [Window(TokenListControl(get_bottom_toolbar_tokens, default_char=Char(' ', Token.Toolbar)), height=LayoutDimension.exact(1), filter=~IsDone())] else: toolbars = [] def get_height(cli): # If there is an autocompletion menu to be shown, make sure that our # layout has at least a minimal height in order to display it. if reserve_space_for_menu and not cli.is_done: return LayoutDimension(min=8) else: return LayoutDimension() # Create and return Layout instance. return HSplit([ FloatContainer( Window( BufferControl( input_processors=input_processors, lexer=lexer, # Enable preview_search, we want to have immediate feedback # in reverse-i-search mode. preview_search=Always()), get_height=get_height, ), [ Float(xcursor=True, ycursor=True, content=CompletionsMenu(max_height=16, extra_filter=HasFocus(DEFAULT_BUFFER))) ] ), ValidationToolbar(), SystemToolbar(), ] + toolbars)
def __init__(self, tosh): self._tosh = tosh self._tabs = [ToshTab(tosh)] self._active_tab = 0 layout = [ Window(TokenListControl( self._get_tabs_tokens, default_char=Char(' ', Token.Tabs), ), height=D(max=1)), self._tabs[0].layout ] super().__init__(layout)
def erase_in_display(self, type_of=0, private=False): """Erases display in a specific way. :param int type_of: defines the way the line should be erased in: * ``0`` -- Erases from cursor to end of screen, including cursor position. * ``1`` -- Erases from beginning of screen to cursor, including cursor position. * ``2`` -- Erases complete display. All lines are erased and changed to single-width. Cursor does not move. * ``3`` -- Erase saved lines. (Xterm) Clears the history. :param bool private: when ``True`` character attributes aren left unchanged **not implemented**. """ line_offset = self.line_offset pt_cursor_position = self.pt_cursor_position try: max_line = max(self.pt_screen.data_buffer) except ValueError: # max() called on empty sequence. Screen is empty. Nothing to erase. return if type_of == 3: # Clear data buffer. for y in list(self.data_buffer): self.data_buffer.pop(y, None) # Reset line_offset. pt_cursor_position.y = 0 self.max_y = 0 else: try: interval = ( # a) erase from cursor to the end of the display, including # the cursor, range(pt_cursor_position.y + 1, max_line + 1), # b) erase from the beginning of the display to the cursor, # including it, range(line_offset, pt_cursor_position.y), # c) erase the whole display. range(line_offset, max_line + 1))[type_of] except IndexError: return data_buffer = self.data_buffer for line in interval: data_buffer[line] = defaultdict(lambda: Char(' ')) # In case of 0 or 1 we have to erase the line with the cursor. if type_of in [0, 1]: self.erase_in_line(type_of)
def create_default_layout(message='', lexer=None, is_password=False, reserve_space_for_menu=False, get_bottom_toolbar_tokens=None): """ Generate default layout. """ assert get_bottom_toolbar_tokens is None or callable(get_bottom_toolbar_tokens) # Create processors list. if is_password: input_processors = [PasswordProcessor(), DefaultPrompt(message)] else: input_processors = [DefaultPrompt(message)] # Create bottom toolbar. if get_bottom_toolbar_tokens: toolbars = [Window(TokenListControl(get_bottom_toolbar_tokens, default_char=Char(' ', Token.Toolbar)), height=LayoutDimension.exact(1), filter=~IsDone())] else: toolbars = [] def get_height(cli): # If there is an autocompletion menu to be shown, make sure that our # layout has at least a minimal height in order to display it. if reserve_space_for_menu and not cli.is_done: return LayoutDimension(min=8) else: return LayoutDimension() # Create and return Layout instance. return HSplit([ FloatContainer( Window( BufferControl( input_processors=input_processors, lexer=lexer), get_height=get_height, ), [ Float(xcursor=True, ycursor=True, content=CompletionsMenu(max_height=16, extra_filter=HasFocus('default'))) ] ), ValidationToolbar(), SystemToolbar(), ] + toolbars)
def __init__(self, key_bindings_manager, settings, token=Token.Toolbar.Status): def get_tokens(cli): _, python_buffer = current_python_buffer(cli, settings) if not python_buffer: return [] TB = token result = [] append = result.append append((TB, ' ')) result.extend(get_inputmode_tokens(TB, key_bindings_manager, cli)) append((TB, ' ')) # Position in history. append((TB, '%i/%i ' % (python_buffer.working_index + 1, len(python_buffer._working_lines)))) # Shortcuts. if not key_bindings_manager.enable_vi_mode and cli.focus_stack.current == 'search': append((TB, '[Ctrl-G] Cancel search [Enter] Go to this position.')) elif bool(cli.current_buffer.selection_state ) and not key_bindings_manager.enable_vi_mode: # Emacs cut/copy keys. append(( TB, '[Ctrl-W] Cut [Meta-W] Copy [Ctrl-Y] Paste [Ctrl-G] Cancel' )) else: append((TB, ' ')) if settings.paste_mode: append((TB.On, '[F6] Paste mode (on) ')) else: append((TB.Off, '[F6] Paste mode (off) ')) if python_buffer.is_multiline: append((TB, ' [Meta+Enter] Execute')) return result super(PythonToolbar, self).__init__(get_tokens, default_char=Char(token=token), filter=~IsDone() & RendererHeightIsKnown())
def __init__(self, settings, key_bindings_manager): def get_tokens(cli): tokens = [] TB = Token.Sidebar if key_bindings_manager.enable_vi_mode: mode = 'vi' else: mode = 'emacs' if settings.show_completions_toolbar: completion_style = 'toolbar' elif settings.show_completions_menu: completion_style = 'pop-up' else: completion_style = 'off' def append(shortcut, label, status): tokens.append((TB.Shortcut, ' [%s] ' % shortcut)) tokens.append((TB.Label, '%-18s' % label)) if status: tokens.append((TB.Status, '%9s\n' % status)) else: tokens.append((TB.Label, '\n')) append('Ctrl-T', 'New tab', '') append('Ctrl-D', 'Close tab', '') append('Ctrl-Left/Right', 'Focus tab', '') append('F3', 'Completion menu', '(%s)' % completion_style) append('F4', 'Input mode', '(%s)' % mode) append('F5', 'Show all tabs', '(on)' if settings.show_all_buffers else '(off)') # append('F5', 'Merge from history', '') append('F6', 'Paste mode', '(on)' if settings.paste_mode else '(off)') append('F7', 'Multiline', '(always)' if settings.currently_multiline else '(auto)') append('F8', 'Show signature', '(on)' if settings.show_signature else '(off)') append('F9', 'Show docstring', '(on)' if settings.show_docstring else '(off)') append('F10', 'Show line numbers', '(on)' if settings.show_line_numbers else '(off)') return tokens super(PythonSidebarControl, self).__init__(get_tokens, Char(token=Token.Sidebar))
def __init__(self, pdb_ref): token = Token.Toolbar.Title def get_tokens(cli): pdb = pdb_ref() return [ (token, '\u2500\u2500'), (token.Text, ' '), (token.Text, pdb.curframe.f_code.co_filename or 'None'), (token.Text, ' : %s ' % pdb.curframe.f_lineno), ] super(SourceTitlebar, self).__init__(get_tokens, default_char=Char(token=token, char='\u2500'))
def __init__(self, pymux): token = Token.ConfirmationToolbar def get_tokens(cli): client_state = pymux.get_client_state(cli) return [ (token.Question, ' '), (token.Question, format_pymux_string( pymux, cli, client_state.confirm_text or '')), (token.Question, ' '), (token.YesNo, ' y/n'), (Token.SetCursorPosition, ''), (token.YesNo, ' '), ] super(ConfirmationToolbar, self).__init__(get_tokens, default_char=Char(' ', token))
def __init__(self, pymux, arrangement_pane): assert isinstance(arrangement_pane, arrangement.Pane) def focussed(cli): return pymux.arrangement.get_active_pane(cli) == arrangement_pane def get_before_input(cli): if not arrangement_pane.is_searching: text = '' elif arrangement_pane.search_state.direction == IncrementalSearchDirection.BACKWARD: text = 'Search up: ' else: text = 'Search down: ' if focussed(cli): return [(Token.Search.Focussed, text)] else: return [(Token.Search, text)] def get_after_input(cli): if focussed(cli): return [(Token.Search.Focussed, ' ')] else: return [] class SearchLexer(Lexer): " Color for the search string. " def lex_document(self, cli, document): def get_line(lineno): text = document.lines[lineno] if focussed(cli): return [(Token.Search.Focussed.Text, text)] else: return [(Token.Search.Text, text)] return get_line super(SearchWindow, self).__init__(content=BufferControl( buffer_name='search-%i' % arrangement_pane.pane_id, input_processors=[ BeforeInput(get_before_input), AfterInput(get_after_input) ], lexer=SearchLexer(), default_char=Char(token=Token)), dont_extend_height=True)
def _reset_screen(self): """ Reset the Screen content. (also called when switching from/to alternate buffer. """ self.pt_screen = Screen(default_char=Char(' ', DEFAULT_TOKEN)) self.pt_screen.cursor_position = CursorPosition(0, 0) self.pt_screen.show_cursor = True self.data_buffer = self.pt_screen.data_buffer self.pt_cursor_position = self.pt_screen.cursor_position self._attrs = Attrs(color=None, bgcolor=None, bold=False, underline=False, italic=False, blink=False, reverse=False) self.margins = None self.max_y = 0 # Max 'y' position to which is written.
def __init__(self, opt_ns, srv_c, inst_xml): manager = KeyBindingManager() # Start with the `KeyBindingManager`. self.srv_text = ServiceOutput(opt_ns, srv_c, inst_xml) layout = HSplit( [ # One window that holds the BufferControl with the default buffer on the # left. Window( height=D.exact(1), content=TokenListControl( self.get_title_line, default_char=Char(" ", token=Token.String.ICSW.Header) ) ), Window( height=D.exact(1), content=FillControl('-', token=Token.Line) ), # Display the text 'Hello world' on the right. Window( content=TokenListControl( self.get_icsw_output, ) ), ] ) self._updating = False @manager.registry.add_binding(Keys.ControlC, eager=True) @manager.registry.add_binding("q", eager=True) def _handler_data(event): event.cli.set_return_value(0) our_style = style_from_dict(logging_tools.get_icsw_prompt_styles()) application = Application( layout=layout, use_alternate_screen=True, style=our_style, on_input_timeout=self.input_timeout, key_bindings_registry=manager.registry, ) event_loop = create_eventloop() self.application = application self.event_loop = event_loop