def edit_multiline(default_text=""): kb = KeyBindings() @kb.add('c-q') @kb.add('escape', 'enter') def exit_(event): """ Pressing Ctrl-Q, Alt+Enter or Esc + Enter will exit the editor. """ event.app.exit(textf.text) @kb.add('c-c') def do_copy(event): data = textf.buffer.copy_selection() get_app().clipboard.set_data(data) @kb.add('c-x', eager=True) def do_cut(event): data = textf.buffer.cut_selection() get_app().clipboard.set_data(data) @kb.add('c-z') def do_undo(event): textf.buffer.undo() @kb.add('c-y') def do_redo(event): textf.buffer.redo() @kb.add('c-a') def do_select_all(event): textf.buffer.cursor_position = 0 textf.buffer.start_selection() textf.buffer.cursor_position = len(textf.buffer.text) update_stored_pos(None) @kb.add('c-v') def do_paste(event): textf.buffer.paste_clipboard_data(get_app().clipboard.get_data()) @kb.add('left') def kb_left(event): textf.buffer.selection_state = None if textf.buffer.cursor_position != 0 and textf.text[ textf.buffer.cursor_position - 1] == '\n': textf.buffer.cursor_up() textf.buffer.cursor_right(len(textf.text)) else: textf.buffer.cursor_left() update_stored_pos(None) @kb.add('right') def kb_right(event): textf.buffer.selection_state = None if textf.buffer.cursor_position < len(textf.text) and textf.text[ textf.buffer.cursor_position] == '\n': textf.buffer.cursor_down() textf.buffer.cursor_left(len(textf.text)) else: textf.buffer.cursor_right() update_stored_pos(None) @kb.add('home') def kb_home(event): textf.buffer.selection_state = None width = getTermWidth() doc = textf.document if textf.buffer.cursor_position == doc._line_start_indexes[ cursor_row()] + int(cursor_col() / width) * width: textf.buffer.cursor_position = doc._line_start_indexes[ cursor_row()] else: textf.buffer.cursor_position = doc._line_start_indexes[ cursor_row()] + int(cursor_col() / width) * width update_stored_pos(None) @kb.add('end') def kb_end(event): textf.buffer.selection_state = None width = getTermWidth() doc = textf.document row = cursor_row() if textf.buffer.cursor_position == doc._line_start_indexes[row] + ( int(cursor_col() / width) + 1) * width - 1: textf.buffer.cursor_position = doc._line_start_indexes[row] + len( doc.current_line) else: textf.buffer.cursor_position = min( doc._line_start_indexes[row] + (int(cursor_col() / width) + 1) * width - 1, doc._line_start_indexes[row] + len(doc.current_line)) update_stored_pos(None) @kb.add('up') def kb_up(event): textf.freezestore = True width = getTermWidth() doc = textf.document textf.buffer.selection_state = None col = cursor_col() row = cursor_row() if width > 9000: # A failsafe in case the terminal size is incorrectly detected textf.buffer.cursor_up() return if col >= width: # Move one row up staying on the same line textf.buffer.cursor_position = doc._line_start_indexes[row] + int( col / width - 1) * width + textf.stored_cursor_pos elif row >= 1: # Moving up to a different line prevlinelen = len(doc.lines[row - 1]) textf.buffer.cursor_position = min( doc._line_start_indexes[row] - 1, doc._line_start_indexes[row - 1] + int(prevlinelen / width) * width + textf.stored_cursor_pos) else: # Cursor is on the first row of first line textf.buffer.cursor_position = 0 textf.freezestore = False update_stored_pos(None) @kb.add('down') def kb_down(event): textf.freezestore = True width = getTermWidth() doc = textf.document textf.buffer.selection_state = None col = cursor_col() row = cursor_row() nextlinelen = len(doc.lines[row + 1]) if row < len(doc.lines) - 1 else -1 if width > 9000: # A failsafe in case the terminal size is incorrectly detected textf.buffer.cursor_down() return if col <= len(doc.current_line ) - width: # Move one row down staying on the same line textf.buffer.cursor_position = doc._line_start_indexes[row] + int( col / width + 1) * width + textf.stored_cursor_pos elif nextlinelen < 0: # Move to the very end textf.buffer.cursor_position = len(textf.text) textf.freezestore = False update_stored_pos(None) # Move to the end of the same line the cursor is on elif col != len(doc.lines[row]) and textf.stored_cursor_pos >= len( doc.lines[row]) - int(len(doc.lines[row]) / width) * width: textf.buffer.cursor_position = doc._line_start_indexes[row + 1] - 1 else: # Move to a different line textf.buffer.cursor_position = min( doc._line_start_indexes[row + 1] + nextlinelen, doc._line_start_indexes[row + 1] + textf.stored_cursor_pos) textf = TextArea() bottom_bar_text = FormattedTextControl( text= '\nCurrently editing. Press Ctrl+Q, Alt+Enter or Esc + Enter to exit.') bottom_bar = Window(content=bottom_bar_text) root_container = HSplit([ textf, bottom_bar, ]) layout = Layout(root_container) app = Application(key_bindings=kb, layout=layout, enable_page_navigation_bindings=True, full_screen=False) textf.freezestore = False textf.text = default_text textf.buffer.cursor_position = len(textf.buffer.text) # Find the row the cursor is at # My own function, in fear of race conditions def cursor_row(): i = 0 while i < len( textf.document._line_start_indexes ) and textf.buffer.cursor_position >= textf.document._line_start_indexes[ i]: i += 1 return i - 1 # Find the column the cursor is at # There is a built-in function, but I think there's some kind of a race condition if it's used def cursor_col(): i = textf.buffer.cursor_position - 1 while i >= 0 and textf.text[i] != '\n': i -= 1 return textf.buffer.cursor_position - i - 1 def update_stored_pos(event): if not event: textf.freezestore = False if textf.freezestore: textf.freezestore = False return width = getTermWidth() col = cursor_col() textf.stored_cursor_pos = col - int(col / width) * width textf.buffer.on_cursor_position_changed += update_stored_pos update_stored_pos(None) text = app.run() clear_lines(1) return text
@kb.add("c-a") def select_all(event=None): code.buffer.cursor_position = 0 code.buffer.start_selection() code.buffer.cursor_position = len(code.buffer.text) def insert_time_and_date(): code.buffer.insert_text(datetime.now().isoformat()) search_toolbar = SearchToolbar() code = TextArea( scrollbar=True, wrap_lines=False, focus_on_click=True, line_numbers=True, search_field=search_toolbar, ) code.window.right_margins[0].up_arrow_symbol = "↑" # type: ignore code.window.right_margins[0].down_arrow_symbol = "↓" # type: ignore class CodeFrame: """A custom frame for the quick python code container to match desired styling""" def __init__( self, body: AnyContainer, title: AnyFormattedText = "", style: str = "", width: AnyDimension = None,
def __init__(self, ctui=None, input_field=None, output_field=None, statusbar=None, root_container=None): self.ctui = ctui self._completer = CommandCompleter(ctui.commands) self._history = FileHistory("{}/.{}_history".format( Path.home(), self.ctui.name)) self._input_field = TextArea(height=1, prompt=self.ctui.prompt, style='class:input_field', completer=self.completer, history=self.history) self._header_field = Window(height=1, char='-', style='class:line') self._output_field = TextArea(text='', style='class:output_field', wrap_lines=self.ctui.wrap_lines, scrollbar=True) self._statusbar = Window(content=FormattedTextControl( self.statusbar_text), height=1, style='class:statusbar') self._body = FloatContainer(HSplit([ self.input_field, self.header_field, self.output_field, self.statusbar ]), floats=[ Float(xcursor=True, ycursor=True, content=CompletionsMenu( max_height=16, scroll_offset=1)) ]) self._root_container = MenuContainer( body=self.body, menu_items=[ MenuItem( 'Session ', children=[ MenuItem('Connect'), MenuItem('Disconnect'), # MenuItem('Save'), # MenuItem('Save as...'), # MenuItem('-', disabled=True), MenuItem('Exit'), ]), MenuItem('Edit ', children=[ MenuItem('Copy'), MenuItem('Paste'), ]), MenuItem('Help ', children=[ MenuItem('Help', handler=show_help), MenuItem('About'), ]), ], floats=[ Float(xcursor=True, ycursor=True, content=CompletionsMenu(max_height=16, scroll_offset=1)), ])
Pressing Ctrl-Q will exit the user interface. Setting a return value means: quit the event loop that drives the user interface and return this value from the `Application.run()` call. """ event.app.exit() # Now we add an event handler that captures change events to the buffer on the # left. If the text changes over there, we'll update the buffer on the right. right_buffer = Buffer() # Output buffer. input_field = TextArea(height=1, prompt='>>> ', style='class:input-field', multiline=False, wrap_lines=False) # Attach accept handler to the input field. We do this by assigning the # handler to the `TextArea` that we created earlier. it is also possible to # pass it to the constructor of `TextArea`. # NOTE: It's better to assign an `accept_handler`, rather then adding a # custom ENTER key binding. This will automatically reset the input # field and add the strings to the history. def accept(buff): # Evaluate "calculator" expression. try: output = '\n\nIn: {}\nOut: {}'.format( input_field.text,
class FormatText(Processor): def apply_transformation(self, ti): try: fragments = to_formatted_text( HTML(fragment_list_to_text(ti.fragments))) return Transformation(fragments) except Exception: return Transformation(ti.fragments) # todo: make textbuffer fixed length (for example: len = max(10000)) _output_window = TextArea( complete_while_typing=False, scrollbar=True, focus_on_click=True, line_numbers=True, input_processors=[FormatText()], ) output = _output_window.buffer kb = KeyBindings() @kb.add("c-q") def _(event): event.app.exit() _current_menu = None
def accept_yes(): get_app().exit(result=True) def accept_no(): get_app().exit(result=False) def do_exit(): get_app().exit(result=False) yes_button = Button(text='Yes', handler=accept_yes) no_button = Button(text='No', handler=accept_no) textfield = TextArea() checkbox1 = Checkbox(text='Checkbox') checkbox2 = Checkbox(text='Checkbox') radios = RadioList(values=[ ('Red', 'red'), ('Green', 'green'), ('Blue', 'blue'), ('Orange', 'orange'), ('Yellow', 'yellow'), ('Purple', 'Purple'), ('Brown', 'Brown'), ]) animal_completer = WordCompleter([ 'alligator',
def __init__(self, first_game, engine): self.completer = CustomCompleter(['start']) self.elements = { 'board': Window(FormattedTextControl( ANSI(show_board(chess.STARTING_BOARD_FEN))), width=35, height=13), 'input': TextArea(height=1, prompt='>>> ', style='class:input-field', width=80, completer=self.completer), 'p1': Window(FormattedTextControl(ANSI('Games')), width=31, height=13, wrap_lines=True), 'p2': Window(FormattedTextControl(ANSI('Legal Moves')), width=31, height=13, wrap_lines=True), } self.frames = {} self.frames['board'] = Float(Frame(self.elements['board'], style='bg:#2e2e2e #ffffff'), top=10) self.frames['input'] = Float(Frame(self.elements['input'], style='bg:#2e2e2e #ffffff'), top=30) self.frames['p1'] = Float(Frame(self.elements['p1'], style='bg:#1e1e1e #ffffff'), top=10, left=10) self.frames['p2'] = Float(Frame(self.elements['p2'], style='bg:#1e1e1e #ffffff'), top=10, right=10) self.body = FloatContainer(content=Window(FormattedTextControl('')), floats=[v for k, v in self.frames.items()]) self.kb = KeyBindings() self.app = Application(layout=Layout( self.body, focused_element=self.elements['input']), key_bindings=self.kb, full_screen=True) self.set_kb() self.game = first_game self.board = first_game.board() self.moves = list(first_game.main_line()) self.engine = engine self.state = 'init' self.now = 0 self.N = len(self.moves) self.chain = [] self.selected = None self.quit = False
#!/usr/bin/env python """ A simple example of a a text area displaying "Hello World!". """ from prompt_toolkit.application import Application from prompt_toolkit.key_binding import KeyBindings from prompt_toolkit.layout import Layout from prompt_toolkit.widgets import Box, Frame, TextArea # Layout for displaying hello world. # (The frame creates the border, the box takes care of the margin/padding.) root_container = Box( Frame( TextArea( text="Hello world!\nPress control-c to quit.", width=40, height=10, )), ) layout = Layout(container=root_container) # Key bindings. kb = KeyBindings() @kb.add("c-c") def _(event): " Quit when control-c is pressed. " event.app.exit() # Build a main application object.
def button3_clicked(): text_area.text = 'Button 3 clicked' def exit_clicked(): get_app().exit() # All the widgets for the UI. button1 = Button('Button 1', handler=button1_clicked) button2 = Button('Button 2', handler=button2_clicked) button3 = Button('Button 3', handler=button3_clicked) button4 = Button('Exit', handler=exit_clicked) text_area = TextArea(focusable=True) # Combine all the widgets in a UI. # The `Box` object ensures that padding will be inserted around the containing # widget. It adapts automatically, unless an explicit `padding` amount is given. root_container = Box( HSplit([ Label(text='Press `Tab` to move the focus.'), VSplit([ Box(body=HSplit([button1, button2, button3, button4], padding=1), padding=1, style='class:left-pane'), Box(body=Frame(text_area), padding=1, style='class:right-pane'), ]), ]), )
def button_handler(): global info info = False layout.focus(input_field) dialog = Dialog(title="Info", body=Label(text="...", dont_extend_height=True), buttons=[ Button(text="OK", handler=button_handler), ]) search_field = SearchToolbar() input_field = TextArea(height=1, prompt='/', style='class:input-field', multiline=False, wrap_lines=False, search_field=search_field) input_field.accept_handler = filterTable table = Window(content=FormattedTextControl( text=getFormattedTable(selected, filteredList), get_cursor_position=GetCursorPosition())) root_container = HSplit([ table, ConditionalContainer(content=input_field, filter=isSearching), ConditionalContainer(content=dialog, filter=showInfo) ]) layout = Layout(container=root_container)
for cmd in cmds: t3 = cmd.rstrip().partition('(') x = t3[0] args = t3[2].rstrip(')').partition(',') if x in ("stream", "change"): dest = capture1 if args[0] == "2": dest = capture2 _print(dest, ('\ninput[' + args[0] + '] = ' + args[2] + '\n')) elif len(cmd) > 0: myprint('^^' + cmd + '\n') elif len(text) > 0: myprint(text + '\n') capture1 = TextArea(style='class:capture-field', height=2) capture2 = TextArea(style='class:capture-field', height=2) captures = VSplit([capture1, capture2]) output_field = TextArea(style='class:output-field', text=druid_intro) statusbar = Window(height=1, char='/', style='class:line', content=FormattedTextControl(text='druid////'), align=WindowAlign.RIGHT) input_field = TextArea(height=1, prompt='> ', multiline=False, wrap_lines=False, style='class:input-field') container = HSplit([captures, output_field, statusbar, input_field])
commandWindowFrame.title = title #listens cursor changes in pods list def podListCursorChanged(buffer): #when position changes, save cursor position to state state.cursor_line = buffer.document.cursor_position_row if args.no_dynamic_title == False: setCommandWindowTitle() #pods window podListArea = TextArea(text="", multiline=True, wrap_lines=False, scrollbar=enableScrollbar, lexer=lexer.ResourceWindowLexer(), read_only=True) #add listener to cursor position changed podListArea.buffer.on_cursor_position_changed = Event(podListArea.buffer, podListCursorChanged) podListArea.buffer.name = WindowName.resource podListArea.window.cursorline = to_filter(True) podListAreaFrame = Frame(podListArea, title="Pods", width=podListWindowSize) left_container = HSplit([ upper_left_container, #HorizontalLine(), #Window(height=1, char='-'), podListAreaFrame
from __future__ import unicode_literals import prompt_toolkit from prompt_toolkit.application import Application from prompt_toolkit.eventloop import use_asyncio_event_loop from prompt_toolkit.key_binding import KeyBindings from prompt_toolkit.layout import Layout, VSplit, HSplit from prompt_toolkit.widgets import Box, Button, Frame, TextArea import asyncio import time lineCount = 6 debugAxis = 2 debugSleep = 0.2 bytesSentText = TextArea(text="") bytesReceivedText = TextArea(text="") def handleHome(): # time.sleep(debugSleep) sendHome(debugAxis) def goAway(): goAway(debugAxis) def debugAxisX(): debugAxisX() def debugAxisY():
"dim": "#444", "bold": "bold", "sidebar.label": "#aaa", "sidebar.label selected": "#fff bold", "sidebar.label seldim": "bg:#444 #fff bold", "sidebar.modified": "bg:orange white bold", "status": "reverse", "topbar": "bg:#fff bg:blue", "notification": "#000", }) # Text editor text_window = TextArea( text=state.current_text, scrollbar=True, line_numbers=True, multiline=True, width=Dimension(min=24), focus_on_click=True, ) def save_current_note(): """ Save the current note """ text = text_window.document.text or "" if not state.current_note: return if state.current_note.get("_INSERT_FLAG"): note_id = db.insert( (state.current_note["title"], text, state.current_note["ts"]))
#!/usr/bin/env python """ Example usage of 'print_container', a tool to print any layout in a non-interactive way. """ from prompt_toolkit.shortcuts import print_container from prompt_toolkit.widgets import Frame, TextArea print_container( Frame( TextArea(text="Hello world!\n"), title="Stage: parse", ) )
def main(): # The layout. search_field = SearchToolbar() # For reverse search. output_field = TextArea(style='class:output-field', text=help_text) input_field = TextArea( height=1, prompt='>>> ', style='class:input-field', multiline=False, wrap_lines=False, search_field=search_field) container = HSplit([ output_field, Window(height=1, char='-', style='class:line'), input_field, search_field, ]) # Attach accept handler to the input field. We do this by assigning the # handler to the `TextArea` that we created earlier. it is also possible to # pass it to the constructor of `TextArea`. # NOTE: It's better to assign an `accept_handler`, rather then adding a # custom ENTER key binding. This will automatically reset the input # field and add the strings to the history. def accept(buff): # Evaluate "calculator" expression. try: output = '\n\nIn: {}\nOut: {}'.format( input_field.text, eval(input_field.text)) # Don't do 'eval' in real code! except BaseException as e: output = '\n\n{}'.format(e) new_text = output_field.text + output # Add text to output buffer. output_field.buffer.document = Document( text=new_text, cursor_position=len(new_text)) input_field.accept_handler = accept # The key bindings. kb = KeyBindings() @kb.add('c-c') @kb.add('c-q') def _(event): " Pressing Ctrl-Q or Ctrl-C will exit the user interface. " event.app.exit() # Style. style = Style([ ('output-field', 'bg:#000044 #ffffff'), ('input-field', 'bg:#000000 #ffffff'), ('line', '#004400'), ]) # Run application. application = Application( layout=Layout(container, focused_element=input_field), key_bindings=kb, style=style, mouse_support=True, full_screen=True) application.run()
def __init__(self, config, out_queue, state=TaskState()): self.config = config tui_config = config['tui'] self.tui_config = tui_config self.out_queue = out_queue def commandHandler(buffer): #check incoming command cmdString = buffer.text #executeCommand(cmdString) pass def commandPrompt(line_number, wrap_count): return "command> " ######################################################################## kb = KeyBindings() @kb.add('c-d') def exit_(event): """ Pressing Esc will exit the user interface. Setting a return value means: quit the event loop that drives the user interface and return this value from the `CommandLineInterface.run()` call. """ event.app.exit() @kb.add('tab') def tab_(event): focus_next(event) @kb.add('s-tab') def stab_(event): focus_previous(event) @kb.add('s-right') def next_tab(event): state.next_tab() event.app.invalidate() @kb.add('s-left') def next_tab(event): state.prev_tab() event.app.invalidate() orders_kb = KeyBindings() @orders_kb.add('f5') def _(event): #command = ('refresh', something...) #self.out_queue.put_nowait(command) pass ######################################################################## outputArea = TextArea( text="", multiline=True, wrap_lines=False, #lexer=lexer.OutputAreaLexer(), #scrollbar=enableScrollbar, style='class:output-field', read_only=True) content_container = Frame(outputArea, title="Output") log_container = Frame( Window( BufferControl( buffer=Buffer(name='logger_buffer', read_only=True), input_processors=[FormatTextHTML()], ), right_margins=[ScrollbarMargin(display_arrows=True) ], # low-level scrollbar ), title='Log', height=8, ) command_container = TextArea(text="", multiline=False, accept_handler=commandHandler, get_line_prefix=commandPrompt) commandWindowFrame = Frame( command_container, title= "TuiTerminal (Ctrl-D to exit, Tab to switch focus and refresh UI, 'help' for help)", height=4) root_container = HSplit( [content_container, log_container, commandWindowFrame]) layout = Layout(root_container, focused_element=command_container) style = Style.from_dict({ 'output-field': 'bg:#101010', 'frame.border': 'SteelBlue', 'frame.label': 'PowderBlue', }) application = Application( layout=layout, key_bindings=kb, style=style, full_screen=tui_config.getboolean('full_screen'), mouse_support=tui_config.getboolean('mouse_support'), #after_render=after_render, ) self.application = application
#buffer to store the user input left_buffer = Buffer(accept_handler=runCommand, multiline=False, completer=mainCompleter(), history=FileHistory('history.txt'), complete_while_typing=True) #input window, storing the user input buffer left_window = Window(BufferControl(buffer=left_buffer)) #one of two regions used to store system ouput responseOutput = TextArea( text="FTP Communication Responses(and commands)", scrollbar=True, line_numbers=True, ) #region to display the system outputs systemOutput = TextArea( text="System Output", scrollbar=True, line_numbers=True, ) #function to append new text to the responce ouput text area def printResponceOutput(text): currentText = responseOutput.document.text newText = currentText + "\n" + text
def _get_answer_widget(self): return TextArea(multiline=False)
def progress_log_dialog( title: AnyFormattedText = "", text: AnyFormattedText = "", wait_text: str = "Wait", quit_text: str = "Quit", status_text: AnyFormattedText = "", run_callback: Callable[[ Callable[[int], None], Callable[[str], None], Callable[ [str], None], Callable[[dict], None], Callable[[], bool] ], None] = (lambda *a: None), style: Optional[BaseStyle] = None, ) -> Application[None]: """ :param run_callback: A function that receives as input a `set_percentage` function and it does the work. """ loop = get_event_loop() def wait_handler() -> None: pass def quit_handler() -> None: app = get_app() if not app.exited: app.exited = True app.exit(result=app.result) wait_button = Button(text=wait_text, handler=wait_handler) quit_button = Button(text=quit_text, handler=quit_handler) progressbar = ProgressBar() text_area = TextArea( focusable=False, # Prefer this text area as big as possible, to avoid having a window # that keeps resizing when we add text to it. height=D(preferred=10**10), width=D(preferred=10**10)) status = Label(text=status_text) dialog = Dialog( title=title, body=HSplit([ Box(Label(text=text)), Box(text_area, padding=D.exact(1)), Box(status, padding=D.exact(1)), progressbar, ]), buttons=[wait_button, quit_button], with_background=True, ) app = _create_app(dialog, style) app.result = None app.exited = False def set_percentage(value: int) -> None: progressbar.percentage = int(value) app.invalidate() def log_text(text: str) -> None: loop.call_soon_threadsafe(text_area.buffer.insert_text, text) app.invalidate() def change_status(text: str) -> None: status.formatted_text_control.text = text app.invalidate() def set_result(new_result: dict) -> None: app.result = new_result def get_exited() -> bool: return app.exited # Run the callback in the executor. When done, set a return value for the # UI, so that it quits. def start() -> None: result = None try: result = run_callback(set_percentage, log_text, change_status, set_result, get_exited) finally: if not app.exited: app.exited = True app.exit(result=result) def pre_run() -> None: run_in_executor_with_context(start) app.pre_run_callables.append(pre_run) return app
def main(role, addr, target, name, cert, ns, domain): cert_file, key_file = cssc(getcwd(), cert, cert.replace("pem", "key")) hash_str = self_hash(path=join(getcwd(), "atomic_p2p")) dashboard_text = "==================== Dashboard ====================\n" peer_text = "==================== Peer ====================\n" device_text = "==================== Device ====================\n" #dashboard_field = FormattedTextControl(ANSI(dashboard_text)) dashboard_field = TextArea(text=dashboard_text) #peer_field = FormattedTextControl(ANSI(peer_text)) peer_field = TextArea(text=peer_text) device_field = TextArea(text=device_text) input_field = TextArea(height=1, prompt=" > ", style="class:input-field") addr = addr.split(":") service = { "peer": None, "monitor": None, "device": None } service["peer"] = Peer(host=addr, name=name, role=role, cert=(cert_file, key_file), _hash=hash_str, ns=ns, output_field=[dashboard_field, peer_field]) service["monitor"] = service["peer"].monitor service["device"] = Device(peer=service["peer"], output_field=[dashboard_field, device_field]) service["peer"].start() service["device"].start() if target is not None: service["peer"]._on_command(["join", target]) elif domain is not None: if ns is None: service["peer"]._on_command(["join", domain]) else: service["peer"]._on_command(["join", domain, ns]) else: # printText("\x1b[1;33;40myou are first peer.\x1b[0m", output=[dashboard_field, peer_field]) printText("you are first peer.", output=[dashboard_field, peer_field]) left_split = HSplit([ #Window(height=10, content=peer_field), peer_field, Window(height=1, char="-", style="class:line"), #Window(dashboard_field), dashboard_field, Window(height=1, char="-", style="class:line"), input_field ]) right_split = HSplit([ device_field ]) container = VSplit([left_split, right_split]) kb = KeyBindings() @kb.add("c-q") def _(event): for each in service: service[each].stop() event.app.exit() @kb.add("c-c") def _(event): input_field.text = "" @kb.add("enter") def _(event): cmd = input_field.text.split(" ") service_key = cmd[0].lower() if service_key in service: service[service_key]._on_command(cmd[1:]) elif service_key == "help": helptips = "peer help - See peer's help\n"\ "monitor help - See monitor's help\n"\ "device help - See defice's help\n"\ "exit/stop - exit the whole program.\n" printText(helptips, output=dashboard_field) elif service_key == "exit" or service_key == "stop": for each in service: service[each].stop() event.app.exit() else: printText("command error , input 'help' to check the function.", output=dashboard_field) input_field.text = "" prompt_style = Style([ ("input_field", "bg:#000000 #ffffff"), ("line", "#004400") ]) application = Application( layout=Layout(container, focused_element=input_field), key_bindings=kb, style=prompt_style, full_screen=True ) application.run()
def _(event): """ Create new task/folder """ global waiting_for_confirmation global prompt_window waiting_for_confirmation = True # Check if we are creating new task or folder if focus_folder: # We are creating a new folder input_field = TextArea( height=1, prompt="New folder: ", style="class:input-field", multiline=False, wrap_lines=False, ) # Get new folder name def get_name(buff): global waiting_for_confirmation global prompt_window global left_window user_input = input_field.text if user_input: # Create new folder auth.create_folder(user_input) # Refresh folders load_folders() # Return to normal state waiting_for_confirmation = False prompt_window = Window() else: # We are creating a new task input_field = TextArea( height=1, prompt="New task: ", style="class:input-field", multiline=False, wrap_lines=False, ) # Get new task name def get_name(buff): global waiting_for_confirmation global prompt_window user_input = input_field.text if user_input: # Create new task auth.create_task(user_input, folder2id[focus_index_folder]) # Refresh tasks load_tasks() # Return to normal state waiting_for_confirmation = False prompt_window = Window() input_field.accept_handler = get_name prompt_window = input_field event.app.layout.focus(input_field)
def preview_element(my_app: "sqlApp"): help_text = """ Press Enter in the input box to page through the table. Alternatively, enter a filtering SQL statement and then press Enter to page through the results. """ formatter = TabularOutputFormatter() input_buffer = Buffer(name="previewbuffer", tempfile_suffix=".sql", multiline=False) input_control = BufferControl(buffer=input_buffer, include_default_input_processors=False, preview_search=False) input_window = Window(input_control, ) search_buffer = Buffer(name="previewsearchbuffer") search_field = SearchToolbar(search_buffer) output_field = TextArea( style="class:preview-output-field", text=help_text, height=D(preferred=50), search_field=search_field, wrap_lines=False, focusable=True, read_only=True, preview_search=True, input_processors=[ ConditionalProcessor( processor=HighlightIncrementalSearchProcessor(), filter=has_focus("previewsearchbuffer") | has_focus(search_field.control), ), HighlightSelectionProcessor(), ]) def refresh_results(window_height) -> bool: sql_conn = my_app.selected_object.conn if sql_conn.execution_status == executionStatus.FAIL: # Let's display the error message to the user output = sql_conn.execution_err else: crsr = sql_conn.cursor if crsr.description: cols = [col.name for col in crsr.description] else: cols = [] if len(cols): sql_conn.status = connStatus.FETCHING res = sql_conn.async_fetchmany(size=window_height - 4) output = formatter.format_output(res, cols, format_name="psql") output = "\n".join(output) else: sql_conn.status = connStatus.IDLE output = "No rows returned\n" # Add text to output buffer. output_field.buffer.set_document( Document(text=output, cursor_position=0), True) return True def accept(buff: Buffer) -> bool: obj = my_app.selected_object sql_conn = obj.conn catalog = None schema = None # TODO: Verify connected if obj.parent is not None: if type(obj.parent).__name__ == "myDBSchema": schema = obj.parent.name elif type(obj.parent).__name__ == "myDBCatalog": catalog = obj.parent.name if obj.parent.parent is not None: if type(obj.parent.parent).__name__ == "myDBCatalog": catalog = obj.parent.parent.name if catalog: catalog = (sql_conn.quotechar + "%s" + sql_conn.quotechar) % catalog if schema: schema = (sql_conn.quotechar + "%s" + sql_conn.quotechar) % schema name = (sql_conn.quotechar + "%s" + sql_conn.quotechar) % obj.name identifier = ".".join(list(filter(None, [catalog, schema, obj.name]))) query = sql_conn.preview_query(table=identifier, filter_query=buff.text, limit=my_app.preview_limit_rows) func = partial( refresh_results, window_height=output_field.window.render_info.window_height) # If status is IDLE, this is the first time we are executing. if sql_conn.query != query or sql_conn.status == connStatus.IDLE: # Exit the app to execute the query my_app.application.exit(result=["preview", query]) my_app.application.pre_run_callables.append(func) else: # No need to exit let's just go and fetch func() return True # Keep filter text input_buffer.accept_handler = accept def cancel_handler() -> None: sql_conn = my_app.selected_object.conn sql_conn.close_cursor() sql_conn.status = connStatus.IDLE input_buffer.text = "" output_field.buffer.set_document( Document(text=help_text, cursor_position=0), True) my_app.show_preview = False my_app.show_sidebar = True my_app.application.layout.focus(input_buffer) my_app.application.layout.focus("sidebarbuffer") return None cancel_button = Button(text="Done", handler=cancel_handler) container = HSplit([ Box(body=VSplit([input_window, cancel_button], padding=1), padding=1, style="class:preview-input-field"), Window(height=1, char="-", style="class:preview-divider-line"), output_field, search_field, ]) frame = Shadow(body=Frame(title="Table Preview", body=container, style="class:dialog.body", width=D(preferred=180, min=30), modal=True)) return ConditionalContainer(content=frame, filter=ShowPreview(my_app) & ~is_done)
) # Global key bindings kb = KeyBindings() top_bar = Window( height=1, content=FormattedTextControl(get_topbar_text), align=WindowAlign.CENTER, style="class:topbar", ) text_window = TextArea( text="", multiline=True, wrap_lines=True, focusable=True, scrollbar=True, line_numbers=True, ) title_bar = Window( FormattedTextControl(get_statusbar_upper_text), align=WindowAlign.CENTER, style="class:notification", height=1, ) status_bar = VSplit( [ Window( FormattedTextControl( HTML( 'Press <style bg="blue"><b>F2</b></style> or <style bg="blue"><b>Ctrl-R</b></style> to set a title'
def login_prompt(my_app: "sqlApp"): def ok_handler() -> None: my_app.application.layout.focus(uidTextfield) obj = my_app.selected_object try: obj.conn.connect(username=uidTextfield.text, password=pwdTextfield.text) # Query the type of back-end and instantiate an appropriate class dbms = obj.conn.get_info(SQLGetInfo.SQL_DBMS_NAME) # Now clone object cls = connWrappers[dbms] if dbms in connWrappers.keys( ) else sqlConnection newConn = cls(dsn=obj.conn.dsn, conn=obj.conn.conn, username=obj.conn.username, password=obj.conn.password) obj.conn.close() newConn.connect() obj.conn = newConn my_app.active_conn = obj.conn # OG some thread locking may be needed here obj.expand() except ConnectError as e: msgLabel.text = "Connect failed" else: msgLabel.text = "" my_app.show_login_prompt = False my_app.show_sidebar = True my_app.application.layout.focus("sidebarbuffer") uidTextfield.text = "" pwdTextfield.text = "" def cancel_handler() -> None: msgLabel.text = "" my_app.application.layout.focus(uidTextfield) my_app.show_login_prompt = False my_app.show_sidebar = True my_app.application.layout.focus("sidebarbuffer") def accept(buf: Buffer) -> bool: my_app.application.layout.focus(ok_button) return True ok_button = Button(text="OK", handler=ok_handler) cancel_button = Button(text="Cancel", handler=cancel_handler) pwdTextfield = TextArea(multiline=False, password=True, accept_handler=accept) uidTextfield = TextArea(multiline=False, password=False, accept_handler=accept) msgLabel = Label(text="", dont_extend_height=True, style="class:frame.label") msgLabel.window.align = WindowAlign.CENTER dialog = Dialog( title="Server Credentials", body=HSplit( [ Label(text="Username ", dont_extend_height=True), uidTextfield, Label(text="Password", dont_extend_height=True), pwdTextfield, msgLabel ], padding=D(preferred=1, max=1), ), width=D(min=10, preferred=50), buttons=[ok_button, cancel_button], with_background=False) return ConditionalContainer(content=dialog, filter=ShowLoginPrompt(my_app) & ~is_done)
('No', False), ('Maybe...', None), ], ).run() emails = { "1": Window(content=FormattedTextControl(text='1 Hello world'), height=1), "2": Window(content=FormattedTextControl(text='2 Hello world'), height=1), "3": Window(content=FormattedTextControl(text='3 Hello world'), height=1), } revs = Box( Frame(TextArea( text='Hello world', width=40, height=1, )), ) email_list = [v for k, v in emails.items()] def create_input(name, label, default=''): return HSplit([ # Window(height=1, char='-'), VSplit([ Window(content=FormattedTextControl(text=label), height=1, width=wcswidth(label)+1), Window(content=BufferControl(buffer=Buffer(name=name)), height=1), ]), Window(height=1, char='-'),
def get_caller_identity(): client = boto3.client("sts") caller_identity = client.get_caller_identity() return "User ID: {}\nAccount: {}\nCaller ARN: {}".format( caller_identity["UserId"], caller_identity["Account"], caller_identity["Arn"], ) def do_exit(): get_app().exit(result=False) console_area = Frame(body=TextArea()) service_radio = RadioList(values=[ ("ec2", "ec2"), ("s3", "s3"), ("vpc", "vpc"), ("route53", "route53"), ("ecr", "ecr"), ("blah", "blah"), ], ) service_selection_frame = service_radio root_container = HSplit([ Window(FormattedTextControl("AWS > "), height=1, style="reverse"), service_selection_frame, console_area, Frame( title="Caller Identity",
def get_statusbar_text(): return " Press Ctrl-C to open menu. " def get_statusbar_right_text(): return " {}:{} ".format( text_field.document.cursor_position_row + 1, text_field.document.cursor_position_col + 1, ) search_toolbar = SearchToolbar() text_field = TextArea( lexer=DynamicLexer(lambda: PygmentsLexer.from_filename( ApplicationState.current_path or ".txt", sync_from_start=False)), scrollbar=True, line_numbers=True, search_field=search_toolbar, ) class TextInputDialog: def __init__(self, title="", label_text="", completer=None): self.future = Future() def accept_text(buf): get_app().layout.focus(ok_button) buf.complete_state = None return True def accept():
text_area.document.cursor_position_col + 1)), ('class:status', ' - Press '), ('class:status.key', 'Ctrl-C'), ('class:status', ' to exit, '), ('class:status.key', '/'), ('class:status', ' for searching.'), ] search_field = SearchToolbar( text_if_not_searching=[('class:not-searching', "Press '/' to start searching.")]) text_area = TextArea(text=text, read_only=True, scrollbar=True, line_numbers=True, search_field=search_field, lexer=PygmentsLexer(PythonLexer)) root_container = HSplit([ # The top toolbar. Window(content=FormattedTextControl(get_statusbar_text), height=D.exact(1), style='class:status'), # The main content. text_area, search_field, ]) # Key bindings.
def main(): # The layout. search_field = SearchToolbar() # For reverse search. output_field = TextArea(style='class:output-field', text=help_text) input_field = TextArea( height=1, prompt='>>> ', style='class:input-field', multiline=False, wrap_lines=False, search_field=search_field) container = HSplit([ output_field, Window(height=1, char='-', style='class:line'), input_field, search_field, ]) # Attach accept handler to the input field. We do this by assigning the # handler to the `TextArea` that we created earlier. it is also possible to # pass it to the constructor of `TextArea`. # NOTE: It's better to assign an `accept_handler`, rather then adding a # custom ENTER key binding. This will automatically reset the input # field and add the strings to the history. def accept(buff): # Evaluate "calculator" expression. try: output = '\n\nIn: {}\nOut: {}'.format( input_field.text, eval(input_field.text)) # Don't do 'eval' in real code! except BaseException as e: output = '\n\n{}'.format(e) new_text = output_field.text + output # Add text to output buffer. output_field.buffer.document = Document( text=new_text, cursor_position=len(new_text)) input_field.accept_handler = accept # The key bindings. kb = KeyBindings() @kb.add('c-c') @kb.add('c-q') def _(event): " Pressing Ctrl-Q or Ctrl-C will exit the user interface. " event.app.exit() # Style. style = Style([ ('output-field', 'bg:#000044 #ffffff'), ('input-field', 'bg:#000000 #ffffff'), ('line', '#004400'), ]) # Run application. application = Application( layout=Layout(container, focused_element=input_field), key_bindings=kb, style=style, mouse_support=True, full_screen=True) application.run()
for cmd in cmds: t3 = cmd.rstrip().partition('(') x = t3[0] args = t3[2].rstrip(')').partition(',') if x == "stream" or x == "change": dest = capture1 if args[0] == "2": dest = capture2 _print(dest, ('\ninput[' + args[0] + '] = ' + args[2] + '\n')) elif len(cmd) > 0: myprint(cmd + '\n') elif len(text) > 0: myprint(text + '\n') capture1 = TextArea(style='class:capture-field', height=2) capture2 = TextArea(style='class:capture-field', height=2) output_field = TextArea(style='class:output-field', text=druid_intro) 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,