def update_layout(self): if self.overview: self.layout = Layout( HSplit([ self.header, VSplit([ HSplit(self.server_windows), HSplit([ self.overview, Window(FormattedTextControl( text="[Ins ][Home][PgUp]\n[Del ][End ][PgDn]"), style="class:overview", height=2, align=WindowAlign.CENTER, dont_extend_height=True), ]), ]), self.footer, ]), ) else: self.layout = Layout( HSplit([ self.header, VSplit([ HSplit(self.server_windows), ]), self.footer, ]), )
def _get_windows(root_container): root_container = root_container.create() layout = Layout(root_container) all_windows = layout.find_all_windows() windows = [] for window in all_windows: windows.append(window) return windows
def toggle_convo_list(): global chat_area if chat_area: app.layout = Layout(root) app.layout.focus(convos) chat_area = False change_cursor(1) else: app.layout = Layout(chat_container) app.layout.focus(input_buf) chat_area = True change_cursor(vi_mode_to_cursor(get_input_mode))
def on_resize(self): cols, rows = os.get_terminal_size(0) focused_element = self.layout.current_window if cols >= 2 * rows: # fat self.app.layout = Layout(self.container_fat, focused_element=focused_element) else: # tall self.app.layout = Layout(self.container_tall, focused_element=focused_element) self.app.renderer.erase(leave_alternate_screen=False) self.app._request_absolute_cursor_position() self.app._redraw()
def __init__( self, state, ): self.state = state self.kb = KeyBindings() # layout components self.header_bar = FormattedTextControl(focusable=False, ) self.input_buffer = Buffer(multiline=False, ) self.input_buffer.on_text_changed += self.update_results self.results_control = SelectableList(text="") self.preview_bar = FormattedTextControl(focusable=False, ) self.preview_buffer = BufferControl( input_processors=[TabsProcessor(tabstop=4, char1="", char2="")], focusable=False, ) self.status_bar = FormattedTextControl() self.layout = Layout( HSplit([ Window(self.header_bar, height=1, style="reverse"), Window( BufferControl(self.input_buffer), height=1, ), Window(self.results_control, height=Dimension(**RESULTS_DIMENSION_DICT)), Window(self.preview_bar, height=1, style="reverse"), Window( self.preview_buffer, wrap_lines=True, height=Dimension(**PREVIEW_DIMENSION_DICT), ), Window(self.status_bar, height=1, style="reverse"), ]), ) self.reset_view() @self.kb.add("up") def _(event): self.results_control.index -= 1 self.update_preview() @self.kb.add("down") def _(event): self.results_control.index += 1 self.update_preview() @self.kb.add("enter") def _(event): self.select_collection() self.reset_view()
def __init__(self, manager: mp.Manager, shared_state: dict, rpc_channel: mp.Queue): self.manager = manager self.shared_state = shared_state self.rpc_channel = rpc_channel self.fileman = Filemanager(self) self.fileman_visible = True self.toolbar = Toolbar(self) self.views = OrderedDict() # type: Dict[str, SimpleView] self.app = Application( full_screen=True, mouse_support=True, color_depth=ColorDepth.DEPTH_24_BIT, clipboard=InMemoryClipboard(), enable_page_navigation_bindings=False, # key_bindings=get_filemanager_kb() layout=Layout( container=HSplit([ DynamicContainer(self._get_children), DynamicContainer(lambda: self.toolbar) ]), # focused_element=(self.current_view or self.fileman).input_field, ), )
def __init__(self, inpipe): self.inpipe = inpipe self.tempfile = tempfile.NamedTemporaryFile(mode="w", delete=True) self.initialize_nodes() root = VSplit( [ # Input buffer and status line HSplit( [ self.first_line, Window( content=BufferControl( buffer=self.input_buffer, # This lexer is disabled for now because # I don't want to mess with colourschemes # lexer=PygmentsLexer(PythonLexer), ) ), self.error_output, ], width=Dimension(), ), Window(width=1, char="|"), # Output display area Window(ignore_content_width=True, content=self.output, wrap_lines=True), ], width=Dimension(), ) layout = Layout(root) self.app = Application(layout=layout, key_bindings=kb, full_screen=True)
def main(self): session = PromptSession(message="> ", enable_history_search=True, auto_suggest=AutoCompleter(), history=FileHistory(HISTORY_FILE)) app = session.app textarea = TextArea(text=WELCOME_MSG, read_only=False, scrollbar=True) app.layout.container.height = 1 mainlayout = HSplit([textarea, app.layout.container]) app.layout = Layout(mainlayout, app.layout.current_control) # monkey patch fullscreen mode app.full_screen = True app.renderer.full_screen = True def accept(buf): if buf.text == "exit": app.exit(result="") else: newtext = self.cmd_parser.parse(buf.text) textarea.text = textarea.text + "\n" + newtext textarea.buffer.cursor_position = len(textarea.text) buf.reset(append_to_history=True) session.default_buffer.accept_handler = accept try: app.run() except (KeyboardInterrupt, EOFError): # ctrl+c or ctrl+d pass
def show_help(self): self.help_mode = True self.help_text = rich_print(md) self.help_window = Window(content=FormattedTextControl( text=ANSI(self.help_text))) self.app.layout = Layout(self.help_window) self.help_line = 0
def init_layout(self): for i in range(len(self.top_screens)): s = self.top_screens[i] s.app = self s.screen_idx = i self.screen_sel_buttons.append( Button(text="%s %s" % (s.shortcut.upper(), s.shortcut_label), handler=s.screen_sel)) self.lbl_screen = Label(text=self.top_screens[0].title) self.top_screen = DynamicContainer(self.get_top_screen_container) btn_action = Button(text="F8 Action", handler=self.f_action) btn_exit = Button(text="F10 Exit", handler=self.f_exit) self.root_container = FloatContainer( HSplit([ Box( body=VSplit([self.lbl_screen], align="CENTER", padding=3), style="class:button-bar", height=1, ), self.top_screen, Box( body=VSplit(self.screen_sel_buttons + [btn_action, btn_exit], align="CENTER", padding=3), style="class:button-bar", height=1, ), ]), self.floats) self.top_layout = Layout(self.root_container, focused_element=self.screen_sel_buttons[0])
async def main(): ''' Main stuff ''' application = Application( layout=Layout(container), key_bindings=bindings, mouse_support=False, full_screen=True, style=Style.from_dict({ #'dialog': 'bg:#cdbbb3', #'button': 'bg:#bf99a4', 'checkbox': '#a4a24f', #'dialog.body': 'bg:#a9cfd0', 'select-checked': 'fg:#000000 bg:#b0e2ff bold', 'select-selected': 'fg:#000000 bg:#b0e0e6 bold', #'dialog shadow': 'bg:#c98982', 'frame.label': '#884444 bold', #'dialog.body label': '#fd8bb6', 'info': 'fg:#27408b bold', }) ) #background_task_tune = asyncio.create_task(tune(application)) background_task_update_spots = asyncio.create_task( update_spots(application)) try: await application.run_async() finally: background_task_update_spots.cancel()
def editor_window(self): """configure the editor window and returns a application class""" self.buffer_1 = Buffer() # need the text in another method self.text = self.open_file() f_ext = pathlib.PurePath(self.file_abs_path).suffix # set container(s) self.buffer_1.text = self.text style_n = style_from_pygments_cls(get_style_by_name("friendly")) container = Window( BufferControl(buffer=self.buffer_1, lexer=syntax_highlight(f_ext))) # create layout layout_editor = Layout(container) # make an instance from keybinds method key_bind = self.key_binds("") # define application that will be started app = Application(layout=layout_editor, key_bindings=key_bind, full_screen=True, style=style_n) return app
def generate_layout(input_field: TextArea, output_field: TextArea, log_field: TextArea): root_container = VSplit([ FloatContainer( HSplit([ output_field, Window(height=1, char='-', style='class:line'), input_field, TextArea( height=1, text= f'Version: {version} [Ctrl + C] QUIT Hold down "fn" for selecting and copying text', style='class:label'), ]), [ # Completion menus. Float(xcursor=True, ycursor=True, transparent=True, content=CompletionsMenu(max_height=16, scroll_offset=1)), ]), Window(width=1, char='|', style='class:line'), log_field, ]) return Layout(root_container, focused_element=input_field)
def generate_layout(input_field: TextArea, output_field: TextArea, log_field: TextArea, search_field: SearchToolbar): root_container = HSplit([ VSplit([ Window(FormattedTextControl(get_version), style="class:title"), Window(FormattedTextControl(get_paper_trade_status), style="class:title"), Window(FormattedTextControl(get_title_bar_right_text), align=WindowAlign.RIGHT, style="class:title"), ], height=1), VSplit([ FloatContainer( HSplit([ output_field, Window(height=1, char='-', style='class:primary'), input_field, ]), [ # Completion menus. Float(xcursor=True, ycursor=True, transparent=True, content=CompletionsMenu(max_height=16, scroll_offset=1)), ]), Window(width=1, char='|', style='class:primary'), HSplit([ log_field, search_field, ]), ]), ]) return Layout(root_container, focused_element=input_field)
def application(): root_container = VSplit([ # One window that holds the BufferControl with the default buffer on # the left. input_field, # A vertical line in the middle. We explicitly specify the width, to # make sure that the layout engine will not try to divide the whole # width by three for all these windows. The window will simply fill its # content by repeating this character. Window(width=1, char='|'), # Display the text 'Hello world' on the right. Window(content=BufferControl(buffer=right_buffer)), ]) layout = Layout(root_container) # TODO : different layout if input/output not a terminal... application = Application( key_bindings=kb, layout=layout, full_screen=True, ) return application
def _create_layout(self): has_before_fragments, get_prompt_text_1, get_prompt_text_2 = \ _split_multiline_prompt(self._get_prompt) default_buffer = self.default_buffer default_buffer_control = BufferControl( buffer=default_buffer, search_buffer_control=None, input_processors=[], include_default_input_processors=False) prompt_window = Window(FormattedTextControl(get_prompt_text_1), dont_extend_height=True) default_buffer_window = Window( default_buffer_control, dont_extend_height=True, get_line_prefix=partial(self._get_line_prefix, get_prompt_text_2=get_prompt_text_2)) divider = Window(char='_', height=1, style='fg:gray bg:black') search_window = Window(content=SearchControl(), style='') bottom_toolbar = ConditionalContainer( Window(FormattedTextControl(lambda: self.bottom_toolbar), dont_extend_height=True, height=Dimension(min=1)), filter=~is_done & renderer_height_is_known & Condition(lambda: self.bottom_toolbar is not None)) layout = HSplit([ prompt_window, default_buffer_window, divider, search_window, bottom_toolbar ]) return Layout(layout, default_buffer_window)
def make_app(path_to_checklist, new_session): session = ChecklistSession(path_to_checklist, new_session) checklist = session.load() def status_bar_text(): items = checklist.items() return "{name} : {checked}/{total} done | 'q': quit | 'z': undo | '?' help | <up>/<down> moves | <space> toggles".format( name=checklist.name, checked=len([i for i in items if i.checked]), total=len(items)) checklist_window = Window(ChecklistControl(checklist, session), left_margins=[NumberedMargin()], right_margins=[ ScrollbarMargin(display_arrows=True), ]) status_bar_window = Window(content=FormattedTextControl(status_bar_text), height=1, style='reverse') root_container = FloatContainer( content=HSplit([ checklist_window, status_bar_window, ]), floats=[], ) if session.duplicates: root_container.floats.append( Float(content=DuplicatesWarningDialog(session.duplicates))) return Application(layout=Layout(root_container), full_screen=True, key_bindings=build_key_bindings())
def create_layout(self): inout_cells = list( itertools.chain.from_iterable([( VSplit([cell.input_prefix, cell.input]), VSplit([cell.output_prefix, ONE_COL, cell.output]), ) for cell in self.cells])) root_container = ScrollablePane(HSplit(inout_cells)) self.layout = Layout(root_container)
def build_app(args, original_text): input_field = Buffer() output_field = FormattedTextControl(original_text) message_field = FormattedTextControl('Enter regexp below:') input_window = Window(BufferControl(buffer=input_field), height=1) message_window = Window(message_field, height=1) output_window = Window(output_field) body = HSplit([ output_window, Window(height=1, char="-", style="class:line"), message_window, Window(height=1, char="-", style="class:line"), input_window, Window(height=1, char="-", style="class:line"), ]) title_window = Window( height=1, content=FormattedTextControl("Press [Ctrl-C] to quit."), align=WindowAlign.CENTER, ) root_container = HSplit( [title_window, Window(height=1, char="-", style="class:line"), body]) highlight = get_highlighting_function(args) kb = KeyBindings() @kb.add("c-c", eager=True) def _(event): event.app.exit() def handle_keypress(_): if len(input_field.text) == 0: output_field.text = original_text return try: output_field.text = highlight(input_field.text, original_text) message_field.text = 'Enter regexp below:' except re.error as e: output_field.text = original_text message_field.text = HTML('<red>Error: {}</red>'.format(e.msg)) input_field.on_text_changed += handle_keypress application = Application( layout=Layout(root_container, focused_element=input_window), key_bindings=kb, mouse_support=False, full_screen=True, ) return application
def run(self): self.app = Application( layout=Layout(self.container), key_bindings=get_key_bindings(), mouse_support=True, full_screen=True, ) self.app.run()
async def shell(): global crow input_field = TextArea(height=1, prompt='> ', style='class:input-field', multiline=False, wrap_lines=False) captures = VSplit([capture1, capture2]) container = HSplit([ captures, output_field, Window(height=1, char='/', style='class:line', content=FormattedTextControl(text='druid////'), align=WindowAlign.RIGHT), input_field ]) def cwrite(xs): global crow try: crow.write(xs) except: crowreconnect() def accept(buff): try: myprint('\n> ' + input_field.text + '\n') druidparser(cwrite, input_field.text) except ValueError as err: print(err) get_app().exit() input_field.accept_handler = accept kb = KeyBindings() @kb.add('c-c', eager=True) @kb.add('c-q', eager=True) def _(event): event.app.exit() style = Style([ ('capture-field', '#747369'), ('output-field', '#d3d0c8'), ('input-field', '#f2f0ec'), ('line', '#747369'), ]) application = Application( layout=Layout(container, focused_element=input_field), key_bindings=kb, style=style, mouse_support=True, full_screen=True, ) result = await application.run_async()
def __init__(self, options, default_index=0, header_filter=lambda x: x, match_filter=lambda x: x): self.info_window = InfoWindow() self.help_window = HelpWindow() self.message_toolbar = MessageToolbar(style="class:message_toolbar") self.error_toolbar = MessageToolbar(style="class:error_toolbar") self.status_line = MessageToolbar(style="class:status_line") self.status_line_format = user._tui_status_line_format self.options_list = OptionsList( options, default_index, header_filter, match_filter, custom_filter=~has_focus(self.help_window)) self.options_list.search_buffer.on_text_changed += self.update cmd, cmd_key_bindings = command_key_bindings(self) self.command_line_prompt = CommandLinePrompt(commands=cmd) key_bindings = merge_key_bindings( [general_key_bindings(self), cmd_key_bindings]) _root_container = HSplit([ HSplit([ Window(content=BufferControl( input_processors=[BeforeInput('> ')], buffer=self.options_list.search_buffer)), self.options_list, self.info_window, ]), self.help_window, self.error_toolbar, self.message_toolbar, self.status_line, self.command_line_prompt.window, ]) self.set_help_text() self.layout = Layout(_root_container) super(Picker, self).__init__( input=None, output=None, editing_mode=EditingMode.EMACS if user._tui_edit_mode == 'emacs' else EditingMode.VI, layout=self.layout, style=Style.from_dict(user_styles.get_user_styles()), key_bindings=key_bindings, include_default_pygments_style=False, full_screen=True, enable_page_navigation_bindings=True) self.update()
def update_layout(self): if self.overview_visible: self.layout = Layout( VSplit([ HSplit(self.server_windows + [self.help_bar]), HSplit([ self.overview_window, Window(FormattedTextControl(text="[Ins ][Home][PgUp]\n[Del ][End ][PgDn]"), style="bg:#202020 fg:ansigray", height=2, align=WindowAlign.CENTER, dont_extend_height=True), ]), ]), ) else: self.layout = Layout( VSplit([ HSplit(self.server_windows + [self.help_bar]), ]), )
def run(self): app = Application( layout=Layout(self.container, focused_element=self.container.input_area), key_bindings=self.key_bindings, style=self.styles, mouse_support=False, full_screen=True, ) return app.run()
def build_cluster_status(): ctx = context() build_cluster_status_command() # building pods container bad_pod_text_control = FormattedTextControl( text=lambda: CONTENT_VENDERER['pod_text']) bad_pod_win = Win(content=bad_pod_text_control) bad_pod_title = ctx.obj['watch_bad_pod_title'] bad_pod_container = HSplit([ Win( height=1, content=Title(bad_pod_title), ), bad_pod_win, ]) # building nodes container bad_node_text_control = FormattedTextControl( text=lambda: CONTENT_VENDERER['node_text']) bad_node_window = Win(content=bad_node_text_control) bad_node_container = HSplit([ Win( height=1, content=Title('bad nodes'), ), bad_node_window, ]) parts = [bad_pod_container, bad_node_container] global_urls = ctx.obj.get('global_urls') if global_urls: ingress_text_control = FormattedTextControl( text=lambda: CONTENT_VENDERER['ingress_text']) ingress_window = Win(content=ingress_text_control, height=lambda: tell_screen_height(0.4)) ingress_container = HSplit([ Win(height=1, content=Title('bad url requests')), ingress_window, ]) parts.append(ingress_container) # building root container root_container = HSplit(parts) kb = KeyBindings() @kb.add('c-c', eager=True) @kb.add('c-q', eager=True) def _(event): event.app.exit() app = Application( key_bindings=kb, layout=Layout(root_container), full_screen=True, ) app.create_background_task(refresh_admin_content()) return app
def create_application(self): self.application = Application( layout=Layout(self.root_container), key_bindings=self.kb, # Let's add mouse support! mouse_support=True, # Using an alternate screen buffer means as much as: "run full screen". # It switches the terminal to an alternate screen. full_screen=True)
def __init__(self, *args, **kwargs): console = kwargs.get('console') if console is None: raise Exception("No root console passed to the application") #console.__class__ = type("ConsoleTextArea", (TextArea, console.__class__), {}) #console.scrollbar = True root_container = HSplit([ console, ]) kwargs['layout'] = Layout(root_container, focused_element=console) super(FrameworkApp, self).__init__(*args, **kwargs)
def buildcontainers(): body_container = HSplit([ top_right_win, Window(height=1, char='-', style='class:line'), bottom_right_win ]) root_container = VSplit([ left_win, Window(width=1, char='|', style="class:line"), body_container ]) initiallayout = Layout(root_container, focused_element=left_win) return initiallayout
def __init__(self, loop, txClbk, vehListClk, vehObjClk, cmdProcessClk, prntr, settingsDir, isGUI, wxAppPersistMgr): BaseModule.__init__(self, loop, txClbk, vehListClk, vehObjClk, cmdProcessClk, prntr, settingsDir, isGUI, wxAppPersistMgr) self.tabs = [] # all the vehicles, one in each tab # commands self.shortName = "terminal" self.tabbar = [] self.style_extensions = { # Tabs 'tabbar': 'noinherit', 'tabbar.tab': '', 'tabbar.tab.active': 'bold noinherit reverse', } self.current_style = Style.from_dict(self.style_extensions) # make the screen self.hscreen = [] self.hscreen.append( Window(height=1, content=FormattedTextControl(self.tabbar, style='class:tabbar'), align=WindowAlign.LEFT)) self.hscreen.append(Window(height=1, char='-', style='class:line')) self.hscreen.append(Window(content=None, wrap_lines=True)) self.hscreen.append(Window(height=1, char='-', style='class:line')) self.hscreen.append(Window(height=1, content=None)) self.root_container = HSplit(self.hscreen) self.layout = Layout(self.root_container) self.application = Application(layout=self.layout, key_bindings=KB, full_screen=True, style=self.current_style) # event linkages self.application.nextTab = self.nextTab # initial layout self.tabbar.append(('class:tabbar.tab', ' {0} '.format("tmp"))) self.tabbar.append(('class:tabbar', ' ')) self.hscreen[0].content = FormattedTextControl(self.tabbar, style='class:tabbar') self.hscreen[2].content = BufferControl(focusable=False) self.hscreen[4].content = BufferControl(focusable=True) asyncio.ensure_future(self.runUI())
def main(): app = Application(layout=Layout(root_container.create(), focused_element=servers.content), key_bindings=kb, editing_mode=EditingMode.VI, style=style, mouse_support=True, full_screen=True, after_render=on_startup) asyncio.get_event_loop().run_until_complete( app.run_async().to_asyncio_future())