def __init__(self, show_position: bool = False) -> None: def get_formatted_text() -> StyleAndTextTuples: buff = get_app().current_buffer if buff.validation_error: row, column = buff.document.translate_index_to_position( buff.validation_error.cursor_position ) if show_position: text = "%s (line=%s column=%s)" % ( buff.validation_error.message, row + 1, column + 1, ) else: text = buff.validation_error.message return [("class:validation-toolbar", text)] else: return [] self.control = FormattedTextControl(get_formatted_text) self.container = ConditionalContainer( content=Window(self.control, height=1), filter=has_validation_error )
def __init__(self) -> None: self.text_control = FormattedTextControl(text=HTML('')) self.window = Window(content=self.text_control, always_hide_cursor=True, align=WindowAlign.LEFT) super(HelpWindow, self).__init__(content=self.window, filter=has_focus(self.window))
def python_sidebar_help(python_input): """ Create the `Layout` for the help text for the current item in the sidebar. """ token = "class: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_help_text(): return [(token, get_current_description())] return ConditionalContainer( content=Window(FormattedTextControl(get_help_text), style=token, height=Dimension(min=3)), filter=ShowSidebar(python_input) & Condition(lambda: python_input.show_sidebar_help) & ~is_done, )
def __init__(self, text: str, handler: Optional[Callable[[], None]] = None, width: int = 12) -> None: self.text = text self.handler = handler self.width = width self.control = FormattedTextControl( self._get_text_fragments, key_bindings=self._get_key_bindings(), focusable=True) def get_style() -> str: if get_app().layout.has_focus(self): return 'class:button.focused' else: return 'class:button' self.window = Window(self.control, align=WindowAlign.CENTER, height=1, width=width, style=get_style, dont_extend_width=True, dont_extend_height=True)
def __init__(self, text, handler=None, width=12): assert isinstance(text, six.text_type) assert handler is None or callable(handler) assert isinstance(width, int) self.text = text self.handler = handler self.width = width self.control = FormattedTextControl( self._get_text_fragments, key_bindings=self._get_key_bindings(), focusable=True) def get_style(): if get_app().layout.has_focus(self): return 'class:button.focused' else: return 'class:button' self.window = Window(self.control, align=WindowAlign.CENTER, height=1, width=width, style=get_style, dont_extend_width=True, dont_extend_height=True)
def updateScreen(self): """ Update the UI after a change """ # generate the tab bar self.tabbar = [] for veh in self.tabs: if veh.active: self.tabbar.append( ('class:tabbar.tab.active', ' {0} '.format(veh.name))) else: self.tabbar.append( ('class:tabbar.tab', ' {0} '.format(veh.name))) self.tabbar.append(('class:tabbar', ' ')) self.hscreen[0].content = FormattedTextControl( self.tabbar, style='class:tabbar') for veh in self.tabs: if veh.active: self.hscreen[2].content = BufferControl(buffer=veh.output, focusable=False) self.hscreen[4].content = BufferControl(buffer=veh.input, focusable=True, input_processors=[veh.prompt]) return
def __init__( self, text: AnyFormattedText, style: str = "", width: AnyDimension = None, dont_extend_height: bool = True, dont_extend_width: bool = False, align: Union[WindowAlign, Callable[[], WindowAlign]] = WindowAlign.LEFT, ) -> None: self.text = text def get_width() -> AnyDimension: if width is None: text_fragments = to_formatted_text(self.text) text = fragment_list_to_text(text_fragments) if text: longest_line = max(get_cwidth(line) for line in text.splitlines()) else: return D(preferred=0) return D(preferred=longest_line) else: return width self.formatted_text_control = FormattedTextControl(text=lambda: self.text) self.window = Window( content=self.formatted_text_control, width=get_width, height=D(min=1), style="class:label " + style, dont_extend_height=dont_extend_height, dont_extend_width=dont_extend_width, align=align, )
def __init__(self, title: str = "DLNest Output", routineTask=None, freq: int = 1, style: str = "class_analyzer_output"): super(AnalyzeOutput, self).__init__(title, routineTask, freq, style) self.infoText = FormattedTextControl( [("", " No analyze task is running ")], focusable=False, show_cursor=False) self.infoWindow = Window(content=self.infoText) self.infoLabel = Box( body=self.infoWindow, height=3, padding_top=1, padding_bottom=1, # padding_left=3, # padding_right=3, style="class:analyzer_info_label") self.window = Frame(HSplit([self.infoLabel, self.shower]), title=self.title, style=self.style, modal=True, key_bindings=self.kb)
def status_bar(my_app: "sqlApp") -> Container: """ Create the `Layout` for the status bar. """ TB = "class:status-toolbar" def get_text_fragments() -> StyleAndTextTuples: result: StyleAndTextTuples = [] append = result.append append((TB, " ")) result.extend(get_inputmode_fragments(my_app)) append((TB, " ")) result.extend(get_connection_fragments(my_app)) return result return ConditionalContainer( content=Window(content=FormattedTextControl(get_text_fragments), style=TB), filter=~is_done & renderer_height_is_known & Condition(lambda: not my_app.show_exit_confirmation), )
def create(self, sort_by=None, order=None): self.servers = servers.refresh(sort_by=sort_by, order=order) servers_output = VSplit([ self.servers, Window(width=1, char='│', style='class:line'), response_box.create(), ]) body = HSplit([ servers_output, Window(height=1, char='─', style='class:line'), summary_box() ]) title_bar = [ ('class:title', ' Freud {}'.format(__version__)), ('class:title', ' (Press [Ctrl-C] to quit. Press [Ctrl-F] for info.)'), ] self.container = HSplit([ search_toolbar, Window(height=1, content=FormattedTextControl(title_bar), align=WindowAlign.CENTER), Window(height=1, char='─', style='class:line'), body, ]) return self.container
def __init__(self, text: str, handler: Optional[Callable[[], None]] = None, width: int = None) -> None: self.text = text self.handler = handler self.width = width if width is None: self.width = max(12, len(text) + 2) self.control = FormattedTextControl( self._get_text_fragments, key_bindings=self._get_key_bindings(), focusable=True, ) def get_style() -> str: if get_app().layout.has_focus(self): return "class:button.focused" else: return "class:button" self.window = Window( self.control, align=WindowAlign.CENTER, height=1, width=Dimension(preferred=self.width, max=self.width), style=get_style, dont_extend_width=True, dont_extend_height=True, always_hide_cursor=True # Stops curser from showing when selected )
def create_application_details(yarn_watcher): """Create application details window.""" def get_text(width=DEFAULT_ROW_WIDTH): def _row(val, st=''): return [(st, Border.VERTICAL), (st, val.ljust(width - 2)[:width - 2]), (st, Border.VERTICAL), (st, '\n')] curr = yarn_watcher.current_application result = [] result.append(('', Border.TOP_LEFT)) result.append(('', Border.HORIZONTAL * (width - 2))) result.append(('', Border.TOP_RIGHT)) result.append(('', '\n')) result.extend(_row('Application ID: {}'.format(curr.app_id))) result.extend(_row('Name: {}'.format(curr.name))) result.extend(_row('Progress: {}%'.format(curr.progress))) result.extend( _row('Status: {}'.format(curr.status), 'class:status.{}'.format(curr.status).lower())) result.append(('', Border.BOTTOM_LEFT)) result.append(('', Border.HORIZONTAL * (width - 2))) result.append(('', Border.BOTTOM_RIGHT)) result.append(('', '\n')) return result control = FormattedTextControl(get_text, focusable=False) return Window(control, width=DEFAULT_ROW_WIDTH, style='class:details')
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 output_hook(self, msg: Dict[str, Any]): msg_type = msg["header"]["msg_type"] content = msg["content"] outputs = self.executing_cells[0].json["outputs"] if msg_type == "stream": if (not outputs) or (outputs[-1]["name"] != content["name"]): outputs.append({ "name": content["name"], "output_type": msg_type, "text": [] }) outputs[-1]["text"].append(content["text"]) elif msg_type in ("display_data", "execute_result"): outputs.append({ "data": { "text/plain": [content["data"].get("text/plain", "")] }, "execution_count": self.execution_count, "metadata": {}, "output_type": msg_type, }) elif msg_type == "error": outputs.append({ "ename": content["ename"], "evalue": content["evalue"], "output_type": "error", "traceback": content["traceback"], }) else: return text, height = get_output_text_and_height(outputs) self.executing_cells[0].output.content = FormattedTextControl( text=text) self.executing_cells[0].output.height = height self.app.invalidate()
def meta_enter_message(python_input: "PythonInput") -> Container: """ Create the `Layout` for the 'Meta+Enter` message. """ def get_text_fragments() -> StyleAndTextTuples: return [("class:accept-message", " [Meta+Enter] Execute ")] @Condition def extra_condition() -> bool: " Only show when... " b = python_input.default_buffer return ( python_input.show_meta_enter_message and ( not b.document.is_cursor_at_the_end or python_input.accept_input_on_enter is None ) and "\n" in b.text ) visible = ~is_done & has_focus(DEFAULT_BUFFER) & extra_condition return ConditionalContainer( content=Window(FormattedTextControl(get_text_fragments)), filter=visible )
def __init__( self, options: Sequence[Tuple[RadioListType, AnyFormattedText]]) -> None: self.options = options self.current_option: RadioListType = options[0][0] self._selected_index = 0 # Key bindings. kb = KeyBindings() kb.add("up")(self._handle_up) kb.add("down")(self._handle_down) kb.add("enter")(self._handle_enter) kb.add("c-d")(self._handle_exit) kb.add("c-a")(self._handle_home) kb.add("c-e")(self._handle_end) # Control and window. self.control = FormattedTextControl(self._get_text_fragments, key_bindings=kb, focusable=True) self.window = Window( content=self.control, style=self.container_style, right_margins=[ScrollbarMargin(display_arrows=True)], dont_extend_height=True, )
def __init__(self, text: AnyFormattedText, style: str = '', width: AnyDimension = None, dont_extend_height: bool = True, dont_extend_width: bool = False) -> None: self.text = text def get_width() -> AnyDimension: if width is None: text_fragments = to_formatted_text(self.text) text = fragment_list_to_text(text_fragments) if text: longest_line = max( get_cwidth(line) for line in text.splitlines()) else: return D(preferred=0) return D(preferred=longest_line) else: return width self.formatted_text_control = FormattedTextControl( text=lambda: self.text) self.window = Window(content=self.formatted_text_control, width=get_width, style='class:label ' + style, dont_extend_height=dont_extend_height, dont_extend_width=dont_extend_width)
def __init__(self, playback, save_location=None, *args, **kwargs): self.mainViewCondition = partial(self.mainView, self) self.mainViewCondition = Condition(self.mainViewCondition) self.disabled_bindings = False bindings = KeyBindings() self.init_bindings(bindings) super().__init__(full_screen=True, key_bindings=bindings, mouse_support=True, *args, **kwargs) self.displayingHelpScreen = ( False) # used to toggle between help screen on normal if save_location: self.save_location = save_location else: self.save_location = SAVE_LOCATION self.playback = playback self._savedLayout = Layout(Window()) self.command_cache = deque([], maxlen=5) ########################################## ### Setting up views ########################################## self.old_command_window = FormattedTextControl(text="Output goes here", focusable=True) self.new_command_window = FormattedTextControl(text="Output goes here", focusable=True) self.body = Frame( HSplit([ Frame(Window(self.old_command_window)), Frame(Window(self.new_command_window)), ])) self.toolbar = Window( FormattedTextControl(text=self.toolbar_text), height=Dimension(max=1, weight=10000), dont_extend_height=True, ) self.main_view = HSplit([self.body, self.toolbar], padding_char="-") self.layout = Layout(self.main_view)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.riitag_info = user.RiitagInfo() # placeholder self.menu_settings_button = Button( 'Settings', handler=lambda: self._set_state('Settings')) self.menu_exit_button = Button('Exit', handler=self.quit_app) self.menu_logout_button = Button('Logout', handler=self._logout) self.settings_back_button = Button( 'Back...', width=12, handler=lambda: self._set_state('Menu')) self.settings_reset_button = Button('Reset...', width=12, handler=self._reset_preferences) self.settings_pres_timeout_button = PreferenceButton( value=self.app.preferences.presence_timeout, increments=10, limits=(10, 120)) self.settings_check_interval_button = PreferenceButton( value=self.app.preferences.check_interval, increments=10, limits=(10, 60)) self.right_panel_state = 'Menu' self.menu_layout = Frame(Box(HSplit([ self.menu_settings_button, Label(''), self.menu_exit_button, self.menu_logout_button, ]), padding_left=3, padding_top=2), title='Menu') self.settings_layout = Frame(Box(HSplit([ Window(FormattedTextControl( HTML( 'This is where you can modify settings\nregarding the underlying presence\nwatcher.' )), wrap_lines=True, width=25), Label(''), VSplit([ Label('Presence Timeout (min.):'), self.settings_pres_timeout_button ], width=15), VSplit([ Label('Refresh Interval (sec.):'), self.settings_check_interval_button ], padding=3), Label(''), VSplit([self.settings_back_button, self.settings_reset_button], align=WindowAlign.CENTER) ]), padding_left=3, padding_top=2), title='Settings')
def __init__(self, values: Sequence[Tuple[_T, AnyFormattedText]]) -> None: assert len(values) > 0 self.values = values # current_values will be used in multiple_selection, # current_value will be used otherwise. self.current_values: List[_T] = [] self.current_value: _T = values[0][0] self._selected_index = 0 # Key bindings. kb = KeyBindings() @kb.add('up') def _(event: E) -> None: self._selected_index = max(0, self._selected_index - 1) @kb.add('down') def _(event: E) -> None: self._selected_index = min( len(self.values) - 1, self._selected_index + 1) @kb.add('pageup') def _(event: E) -> None: w = event.app.layout.current_window self._selected_index = max( 0, self._selected_index - len(w.render_info.displayed_lines)) @kb.add('pagedown') def _(event: E) -> None: w = event.app.layout.current_window self._selected_index = min( len(self.values) - 1, self._selected_index + len(w.render_info.displayed_lines)) @kb.add('enter') @kb.add(' ') def _(event: E) -> None: self._handle_enter() @kb.add(Keys.Any) def _(event: E) -> None: # We first check values after the selected value, then all values. for value in self.values[self._selected_index + 1:] + self.values: if value[1].startswith(event.data): self._selected_index = self.values.index(value) return # Control and window. self.control = FormattedTextControl(self._get_text_fragments, key_bindings=kb, focusable=True) self.window = Window(content=self.control, style=self.container_style, right_margins=[ ScrollbarMargin(display_arrows=True), ], dont_extend_height=True)
def _render_events(self, events): event_texts = [self._format_event(event) for event in events] event_max_width = max(len(event_text) for event_text in event_texts) return Window( FormattedTextControl("\n".join(event_texts)), width=min(event_max_width, 50), height=len(events), )
def do_inspect(self, _): self.right_buffer.text = "INSPECT:\n" + _.text # hide previous command buffer control self.command_area.children[0].content = DummyControl() self.status_area.content = FormattedTextControl( self.get_status_text('inspect file: ' + _.text)) app = get_app() app.layout.focus(self.left_buffer)
def __init__(self, message: str, filter: "FilterOrBool", **kwargs) -> None: self._message = message super().__init__( Window(FormattedTextControl(text=self._get_message), dont_extend_height=True, **kwargs), filter=filter, )
def __init__(self, text: AnyFormattedText, style: str = '', **kw) -> None: # Note: The style needs to be applied to the toolbar as a whole, not # just the `FormattedTextControl`. super().__init__( FormattedTextControl(text, **kw), style=style, dont_extend_height=True, height=Dimension(min=1))
def generate_layout(input_field: TextArea, output_field: TextArea, log_field: TextArea, search_field: SearchToolbar, timer: TextArea, process_monitor: TextArea, trade_monitor: TextArea): root_container = HSplit([ VSplit( [ Window(FormattedTextControl(get_version), style="class:title"), Window(FormattedTextControl(get_paper_trade_status), style="class:title"), Window(FormattedTextControl(get_active_strategy), style="class:title"), # Window(FormattedTextControl(get_active_markets), style="class:title"), # Window(FormattedTextControl(get_script_file), style="class:title"), Window(FormattedTextControl(get_strategy_file), 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, ]), ]), VSplit([ trade_monitor, process_monitor, timer, ], height=1), ]) return Layout(root_container, focused_element=input_field)
def get_status(self): if self.error_messages: return Window( FormattedTextControl( FormattedText([('class:error', self.error_messages)]), ), height=1, ) return Label('')
def __init__(self, style=""): self.message = None self.text_control = FormattedTextControl(text="") super(MessageToolbar, self).__init__(content=Window(style=style, content=self.text_control, height=1), filter=Condition(lambda: self.text))
def __init__(self, values): assert isinstance(values, list) assert len(values) > 0 assert all(isinstance(i, tuple) and len(i) == 2 for i in values) self.values = values self.current_value = values[0][0] self._selected_index = 0 # Key bindings. kb = KeyBindings() @kb.add('up') def _(event): self._selected_index = max(0, self._selected_index - 1) @kb.add('down') def _(event): self._selected_index = min( len(self.values) - 1, self._selected_index + 1) @kb.add('pageup') def _(event): w = event.app.layout.current_window self._selected_index = max( 0, self._selected_index - len(w.render_info.displayed_lines)) @kb.add('pagedown') def _(event): w = event.app.layout.current_window self._selected_index = min( len(self.values) - 1, self._selected_index + len(w.render_info.displayed_lines)) @kb.add('enter') @kb.add(' ') def _(event): self.current_value = self.values[self._selected_index][0] @kb.add(Keys.Any) def _(event): # We first check values after the selected value, then all values. for value in self.values[self._selected_index + 1:] + self.values: if value[1].startswith(event.data): self._selected_index = self.values.index(value) return # Control and window. self.control = FormattedTextControl(self._get_text_fragments, key_bindings=kb, focusable=True) self.window = Window(content=self.control, style='class:radio-list', right_margins=[ ScrollbarMargin(display_arrows=True), ], dont_extend_height=True)
def prompt(text: Union[str, FormattedText], title: str = '', actions: List[Action] = [], **kwargs: Any) -> None: """A simple and extensible prompt helper routine :param text: Text to be printed before the prompt, it can be formatted text :type text: str or FormattedText :param title: Title to be shown in a bottom bar :type title: str :param actions: A list of Actions as defined in `Action`. :type actions: [Action] :param kwargs: kwargs to prompt_toolkit application class """ assert (isinstance(actions, list)) assert (type(title) == str) kb = KeyBindings() for action in actions: kb.add(action.key)(action.action) print_formatted_text(FormattedText(text)) root_container = HSplit([ Window(wrap_lines=True, height=1, align=WindowAlign.LEFT, always_hide_cursor=True, style='bg:ansiblack fg:ansiwhite', content=FormattedTextControl( focusable=False, text=HTML(' '.join( "{a.name}<yellow>[{a.key}]</yellow>".format(a=a) for a in actions)))) ] + ([ Window(height=1, align=WindowAlign.LEFT, always_hide_cursor=True, style='bold fg:ansipurple bg:ansiwhite', content=FormattedTextControl(focusable=False, text=title)) ] if title else [])) app = Application(layout=Layout(root_container), key_bindings=kb, **kwargs) app.run()
def output_hook(self, msg: Dict[str, Any]): msg_id = msg["parent_header"]["msg_id"] execution_count = self.msg_id_2_execution_count[msg_id] msg_type = msg["header"]["msg_type"] content = msg["content"] outputs = self.executing_cells[execution_count].json["outputs"] if msg_type == "stream": if (not outputs) or (outputs[-1]["name"] != content["name"]): outputs.append({ "name": content["name"], "output_type": msg_type, "text": [] }) outputs[-1]["text"].append(content["text"]) elif msg_type in ("display_data", "execute_result"): outputs.append({ "data": { "text/plain": [content["data"].get("text/plain", "")] }, "execution_count": execution_count, "metadata": {}, "output_type": msg_type, }) text = rich_print(f"Out[{execution_count}]:", style="red", end="") self.executing_cells[ execution_count].output_prefix.content = FormattedTextControl( text=ANSI(text)) elif msg_type == "error": outputs.append({ "ename": content["ename"], "evalue": content["evalue"], "output_type": "error", "traceback": content["traceback"], }) else: return text, height = get_output_text_and_height(outputs) self.executing_cells[ execution_count].output.content = FormattedTextControl(text=text) height_keep = self.executing_cells[execution_count].output.height self.executing_cells[execution_count].output.height = height if self.app and height_keep != height: # height has changed self.focus(self.current_cell_idx, update_layout=True) self.app.invalidate()