def _create_window_frame(self, editor_buffer):
"""
Create a Window for the buffer, with underneat a status bar.
"""
@Condition
def wrap_lines(cli):
return self.editor.wrap_lines
window = Window(
self._create_buffer_control(editor_buffer),
allow_scroll_beyond_bottom=Always(),
scroll_offsets=ScrollOffsets(
left=0, right=0,
top=Integer.from_callable(lambda: self.editor.scroll_offset),
bottom=Integer.from_callable(lambda: self.editor.scroll_offset)),
wrap_lines=wrap_lines,
left_margins=[ConditionalMargin(
margin=NumberredMargin(
display_tildes=True,
relative=Condition(lambda cli: self.editor.relative_number)),
filter=Condition(lambda cli: self.editor.show_line_numbers))],
cursorline=Condition(lambda cli: self.editor.cursorline),
cursorcolumn=Condition(lambda cli: self.editor.cursorcolumn),
get_colorcolumns=(
lambda cli: [ColorColumn(pos) for pos in self.editor.colorcolumn]))
return HSplit([
window,
VSplit([
WindowStatusBar(self.editor, editor_buffer),
WindowStatusBarRuler(self.editor, window, editor_buffer.buffer_name),
]),
])
def _create_window_frame(self, editor_buffer):
"""
Create a Window for the buffer, with underneat a status bar.
"""
window = Window(
self._create_buffer_control(editor_buffer),
allow_scroll_beyond_bottom=Always(),
scroll_offsets=PyvimScrollOffsets(self.editor),
left_margins=[
ConditionalMargin(
margin=NumberredMargin(
buffer_name=editor_buffer.buffer_name,
relative=Condition(
lambda cli: self.editor.relative_number)),
filter=Condition(
lambda cli: self.editor.show_line_numbers))
])
return HSplit([
window,
VSplit([
WindowStatusBar(self.editor, editor_buffer, self.manager),
WindowStatusBarRuler(self.editor, window,
editor_buffer.buffer_name),
]),
])
def main():
hy_repl = HyREPL()
eventloop = create_eventloop()
validator = HyValidator()
history = FileHistory(expanduser("~/.pthy_history"))
def src_is_multiline():
if app and app.buffer:
text = app.buffer.document.text
if '\n' in text:
return True
return False
app = create_default_application(
"λ: ",
validator=validator,
multiline=Condition(src_is_multiline),
lexer=HyLexer,
style=HyStyle,
history=history,
completer=HyCompleter(hy_repl),
display_completions_in_columns=True,
extra_input_processors=[
ConditionalProcessor(processor=HighlightMatchingBracketProcessor(),
filter=~IsDone())
])
# Somewhat ugly trick to add a margin to the multiline input
# without needing to define a custom layout
app.layout.children[0].children[
1].content.content.margin = ConditionalMargin(NumberredMargin(),
filter=IsMultiline())
cli = CommandLineInterface(application=app, eventloop=eventloop)
load_modified_bindings(app.key_bindings_registry)
hy_repl.cli = cli
try:
while True:
try:
code_obj = cli.run()
hy_repl.evaluate(code_obj.text)
except KeyboardInterrupt:
pass
except EOFError:
pass
finally:
eventloop.close()
def setup_layout(self):
"""docstring for setup_layout"""
if bool(egc.TEXT_EDITOR_ENABLE_LEFT_MARGIN) is True:
self._left_margin = NumberredMargin(display_tildes=True)
if bool(egc.TEXT_EDITOR_ENABLE_RIGHT_MARGIN) is True:
self._right_margin = ScrollbarMargin(display_arrows=True)
self._buffer_control = BufferControl(buffer_name=self._editor_buffer_name)
self._editor_aiml_code_window = Window(content=self._buffer_control, left_margins=[self._left_margin,])
self._vertical_line = FillControl('|', token=Token.Line)
self._window_separater = Window(width=D.exact(1), content=self._vertical_line)
self._aiml_list = TokenListControl(get_tokens=self.get_aiml_list)
self._editor_aiml_list_window = Window(content=self._aiml_list, right_margins=[self._right_margin,])
self._layout = VSplit([
self._editor_aiml_code_window,
self._window_separater,
self._editor_aiml_list_window,
])
def main():
manager = KeyBindingManager(enable_system_bindings=Always())
D = LayoutDimension
layout = HSplit([
VSplit([
Window(width=D(min=15, max=30, preferred=30),
content=FillControl('a', token=Token.A)),
Window(width=D.exact(1),
content=FillControl('|', token=Token.Line)),
Window(content=TokenListControl.static([(Token.HelloWorld,
lipsum)])),
Window(width=D.exact(1),
content=FillControl('|', token=Token.Line)),
Window(content=BufferControl(
lexer=PygmentsLexer(PythonLexer),
margin=NumberredMargin(),
input_processors=[
DefaultPrompt.from_message('python> '),
AfterInput.static(' <python', token=Token.AfterInput),
]), ),
Window(width=D.exact(1),
content=FillControl('|', token=Token.Line)),
HSplit([
Window(width=D(max=40),
height=D.exact(4),
content=FillControl('b', token=Token.B)),
Window(width=D(max=40),
content=FillControl('f', token=Token.F)),
Window(width=D.exact(30),
height=D.exact(2),
content=FillControl('c', token=Token.C)),
]),
#CompletionsMenu(),
]),
Window(height=D.exact(1), content=FillControl('-', token=Token.Line)),
Window(height=D.exact(3), content=FillControl('d', token=Token.D)),
SystemToolbar(),
ArgToolbar(),
CompletionsToolbar(),
SearchToolbar(),
])
layout = FloatContainer(content=layout,
floats=[
Float(xcursor=True,
ycursor=True,
content=VSplit([
Window(width=D.exact(5),
content=FillControl(
'f', token=Token.F)),
CompletionsMenu(),
])),
])
eventloop = create_eventloop()
application = Application(layout=layout,
style=TestStyle,
key_bindings_registry=manager.registry,
buffer=Buffer(is_multiline=Always(),
completer=TestCompleter()))
cli = CommandLineInterface(application=application, eventloop=eventloop)
cli.run()
eventloop.close()
def __init__(self, debugger):
self._filename = None
self.sources = {}
self.debugger = debugger
self.debugger.events.on_stop += self.on_stop
self.current_address_margin = CurrentAddressMargin()
kb = KeyBindings()
self.locals_processor = DisplayVariablesProcessor()
self.source_buffer = Buffer(multiline=True)
self.bar_buffer = Buffer(multiline=True)
self.register_buffer = Buffer(multiline=True)
self.logs_buffer = Buffer(multiline=True)
@kb.add(Keys.F10, eager=True)
def quit_(event):
event.app.exit()
@kb.add(Keys.F8)
def clear_breakpoint_(event):
if self.has_source():
filename, row = self.get_current_location()
self.debugger.clear_breakpoint(filename, row)
@kb.add(Keys.F7)
def set_breakpoint_(event):
if self.has_source():
filename, row = self.get_current_location()
self.debugger.set_breakpoint(filename, row)
@kb.add(Keys.F6)
def step_(event):
self.debugger.step()
@kb.add(Keys.F5)
def run_(event):
self.debugger.run()
@kb.add(Keys.F4)
def stop_(event):
self.debugger.stop()
@kb.add(Keys.PageUp)
def scroll_up_(event):
self.source_buffer.cursor_up(count=15)
@kb.add(Keys.PageDown)
def scroll_down_(event):
self.source_buffer.cursor_down(count=15)
src_lexer = PygmentsLexer(CLexer)
source_code_window = Window(
content=BufferControl(
buffer=self.source_buffer,
lexer=src_lexer,
input_processors=[self.locals_processor],
),
left_margins=[self.current_address_margin,
NumberredMargin()],
right_margins=[ScrollbarMargin(display_arrows=True)],
cursorline=True,
)
register_window = Window(
content=BufferControl(buffer=self.register_buffer), width=20)
title_text = "Welcome to the ppci debugger version {}".format(
ppci_version)
help_text = ("F4=stop F5=run F6=step F7=set breakpoint" +
" F8=clear breakpoint F10=exit")
# Application layout:
layout = HSplit([
Window(content=FormattedTextControl(text=title_text), height=1),
VSplit([
HSplit([
Frame(body=source_code_window),
Window(
content=BufferControl(buffer=self.logs_buffer),
height=2,
),
]),
Frame(body=register_window, title="registers"),
]),
Window(
content=FormattedTextControl(self.get_status_tokens),
height=1,
),
Window(content=FormattedTextControl(help_text), height=1),
])
style = style_from_pygments(get_style_by_name("vim"))
log_handler = MyHandler(self.logs_buffer)
fmt = logging.Formatter(fmt=logformat)
log_handler.setFormatter(fmt)
log_handler.setLevel(logging.DEBUG)
logging.getLogger().setLevel(logging.DEBUG)
logging.getLogger().addHandler(log_handler)
self.application = Application(layout=layout,
style=style,
key_bindings=kb,
full_screen=True)
def __init__(self):
pdb.Pdb.__init__(self)
# Cache for the grammar.
self._grammar_cache = None # (current_pdb_commands, grammar) tuple.
self.completer = None
self.validator = None
self.lexer = None
self._source_code_window = Window(BufferControl(
buffer_name='source_code',
lexer=PygmentsLexer(PythonLexer),
input_processors=[
HighlightSearchProcessor(preview_search=True),
HighlightSelectionProcessor(),
],
),
left_margins=[
SourceCodeMargin(self),
NumberredMargin(),
],
right_margins=[ScrollbarMargin()],
scroll_offsets=ScrollOffsets(
top=2, bottom=2),
height=LayoutDimension(preferred=10))
# Callstack window.
callstack = CallStack(weakref.ref(self))
self.callstack_focussed = False # When True, show cursor there, and allow navigation through it.
self.callstack_selected_frame = 0 # Top frame.
show_pdb_content_filter = ~IsDone() & Condition(
lambda cli: not self.python_input.show_exit_confirmation)
self.python_input = PythonInput(
get_locals=lambda: self.curframe.f_locals,
get_globals=lambda: self.curframe.f_globals,
_completer=DynamicCompleter(lambda: self.completer),
_validator=DynamicValidator(lambda: self.validator),
_accept_action=self._create_accept_action(),
_extra_buffers={'source_code': Buffer(read_only=True)},
_input_buffer_height=LayoutDimension(min=2, max=4),
_lexer=PdbLexer(),
_extra_buffer_processors=[
ConditionalProcessor(processor=CompletionHint(),
filter=~IsDone())
],
_extra_layout_body=ConditionalContainer(
HSplit([
VSplit([
HSplit([
SourceTitlebar(weakref.ref(self)),
FloatContainer(
content=self._source_code_window,
floats=[
Float(right=0,
bottom=0,
content=BreakPointInfoToolbar(
weakref.ref(self)))
]),
]),
HSplit([
Window(width=LayoutDimension.exact(1),
height=LayoutDimension.exact(1),
content=FillControl(
'\u252c', token=Token.Toolbar.Title)),
Window(width=LayoutDimension.exact(1),
content=FillControl('\u2502',
token=Token.Separator)),
]),
HSplit([
StackTitlebar(weakref.ref(self)),
Window(callstack,
scroll_offsets=ScrollOffsets(top=2,
bottom=2),
right_margins=[ScrollbarMargin()],
height=LayoutDimension(preferred=10)),
]),
]),
]),
filter=show_pdb_content_filter),
_extra_toolbars=[
ConditionalContainer(PdbShortcutsToolbar(weakref.ref(self)),
show_pdb_content_filter)
],
history_filename=os.path.expanduser('~/.ptpdb_history'),
)
# Override prompt style.
self.python_input.all_prompt_styles['pdb'] = PdbPromptStyle(
self._get_current_pdb_commands())
self.python_input.prompt_style = 'pdb'
# Override exit message.
self.python_input.exit_message = 'Do you want to quit BDB? This raises BdbQuit.'
# Set UI styles.
self.python_input.ui_styles = {
'ptpdb': get_ui_style(),
}
self.python_input.use_ui_colorscheme('ptpdb')
# Set autocompletion style. (Multi-column works nicer.)
self.python_input.completion_visualisation = CompletionVisualisation.MULTI_COLUMN
# Load additional key bindings.
load_custom_pdb_key_bindings(self,
self.python_input.key_bindings_registry)
self.cli = CommandLineInterface(
eventloop=create_eventloop(),
application=self.python_input.create_application())
def __init__(self):
self.command_parser = BrewPiCommandParser(self)
self.buffers = {
DEFAULT_BUFFER:
Buffer(completer=command_completer,
enable_history_search=True,
history=InMemoryHistory(),
accept_action=AcceptAction(self.command_parser.parse)),
'MESSAGES':
Buffer(),
'RESULT':
Buffer(),
'STATE':
Buffer(),
}
self.registry = load_key_bindings()
self.registry.add_binding(Keys.ControlC,
eager=True)(self._on_request_shutdown)
self.registry.add_binding(Keys.ControlQ,
eager=True)(self._on_request_shutdown)
self.layout = HSplit([
# One window that holds the BufferControl with the default buffer on the
# left.
VSplit([
HSplit([
Window(content=TokenListControl(get_tokens=lambda cli: [(
Token.Title, 'Command Result')]),
height=D.exact(1)),
Window(content=BufferControl(buffer_name='RESULT'),
wrap_lines=True,
left_margins=[ScrollbarMargin()]),
]),
Window(width=D.exact(1),
content=FillControl('|', token=Token.Line)),
HSplit([
Window(content=TokenListControl(get_tokens=lambda cli: [(
Token.Title, 'Raw Protocol Messages')]),
height=D.exact(1)),
Window(
content=BufferControl(buffer_name='MESSAGES',
lexer=PygmentsLexer(JsonLexer)),
wrap_lines=True,
left_margins=[NumberredMargin()],
right_margins=[ScrollbarMargin()])
])
]),
VSplit([
Window(content=TokenListControl(
get_tokens=self.get_prompt_tokens),
height=D.exact(1),
dont_extend_width=True),
Window(content=BufferControl(buffer_name=DEFAULT_BUFFER),
height=D.exact(1),
dont_extend_height=True),
]),
Window(content=BufferControl(buffer_name='STATE'),
height=D.exact(1),
dont_extend_height=True)
])
super().__init__(
layout=self.layout,
buffers=self.buffers,
key_bindings_registry=self.registry,
mouse_support=True,
style=style_from_pygments(
get_style_by_name('emacs'),
style_dict={
Token.Toolbar:
'#ffffff bg:#333333',
Token.Title:
'#ffffff bg:#000088',
# User input.
Token:
'#ff0066',
# Prompt.
Token.Name:
'#884444 italic',
Token.At:
'#00aa00',
Token.Colon:
'#00aa00',
Token.Pound:
'#00aa00',
Token.Host:
'#000088 bg:#aaaaff',
Token.Path:
'#884444 underline',
# Make a selection reverse/underlined.
# (Use Control-Space to select.)
Token.SelectedText:
'reverse underline',
}),
use_alternate_screen=True)
# BrewPi Stuff
self.controller_manager = BrewPiControllerManager()
self.msg_decoder = RawMessageDecoder()
self.controller = None