# -*- coding: utf-8 -*- """ Adds debugging commands and features. """ import ast import os.path import tkinter as tk import tokenize from logging import getLogger from tkinter import ttk from tkinter.messagebox import showinfo from typing import List, Union # @UnusedImport from _tkinter import TclError from thonny import ( ast_utils, editors, get_runner, get_workbench, memory, misc_utils, running, ui_utils, ) from thonny.codeview import CodeView, SyntaxText, get_syntax_options_for_tag from thonny.common import DebuggerCommand, InlineCommand from thonny.languages import tr from thonny.memory import VariablesFrame from thonny.misc_utils import running_on_mac_os, running_on_rpi, shorten_repr from thonny.tktextext import TextFrame from thonny.ui_utils import CommonDialog, get_hyperlink_cursor, get_tk_version_info, select_sequence logger = getLogger(__name__) _current_debugger = None RESUME_COMMAND_CAPTION = "" # Init later when gettext is loaded class Debugger: def __init__(self): self._last_progress_message = None self._last_brought_out_frame_id = None self._editor_context_menu = None def check_issue_command(self, command, **kwargs): cmd = DebuggerCommand(command, **kwargs) self._last_debugger_command = cmd if get_runner().is_waiting_debugger_command(): logger.debug("_check_issue_debugger_command: %s", cmd) # tell MainCPythonBackend the state we are seeing cmd.setdefault( frame_id=self._last_progress_message.stack[-1].id, breakpoints=self.get_effective_breakpoints(command), state=self._last_progress_message.stack[-1].event, focus=self._last_progress_message.stack[-1].focus, allow_stepping_into_libraries=get_workbench().get_option( "debugger.allow_stepping_into_libraries" ), ) if command == "run_to_cursor": # cursor position was added as another breakpoint cmd.name = "resume" get_runner().send_command(cmd) if command == "resume": self.clear_last_frame() else: logger.debug("Bad state for sending debugger command " + str(command)) def get_run_to_cursor_breakpoint(self): return None def get_effective_breakpoints(self, command): result = editors.get_current_breakpoints() if command == "run_to_cursor": bp = self.get_run_to_cursor_breakpoint() if bp is not None: filename, lineno = bp result.setdefault(filename, set()) result[filename].add(lineno) return result def command_enabled(self, command): if not get_runner().is_waiting_debugger_command(): return False if command == "run_to_cursor": return self.get_run_to_cursor_breakpoint() is not None elif command == "step_back": return ( self._last_progress_message and self._last_progress_message["tracer_class"] == "NiceTracer" ) else: return True def handle_debugger_progress(self, msg): self._last_brought_out_frame_id = None def handle_debugger_return(self, msg): pass def close(self) -> None: self._last_brought_out_frame_id = None if get_workbench().get_option("debugger.automatic_stack_view"): get_workbench().hide_view("StackView") def clear_last_frame(self): pass def get_frame_by_id(self, frame_id): for frame_info in self._last_progress_message.stack: if frame_info.id == frame_id: return frame_info raise ValueError("Could not find frame %d" % frame_id) def bring_out_frame(self, frame_id, force=False): # called by StackView raise NotImplementedError() def get_editor_context_menu(self): def create_edit_command_handler(virtual_event_sequence): def handler(event=None): widget = get_workbench().focus_get() if widget: return widget.event_generate(virtual_event_sequence) return None return handler if self._editor_context_menu is None: menu = tk.Menu(get_workbench()) menu.add( "command", label=tr("Run to cursor"), command=lambda: self.check_issue_command("run_to_cursor"), ) menu.add("separator") menu.add("command", label="Copy", command=create_edit_command_handler("<>")) menu.add( "command", label=tr("Select all"), command=create_edit_command_handler("<>"), ) self._editor_context_menu = menu return self._editor_context_menu class SingleWindowDebugger(Debugger): def __init__(self): super().__init__() self._last_frame_visualizer = None # Make sure StackView is created get_workbench().get_view("StackView") def get_run_to_cursor_breakpoint(self): editor = get_workbench().get_editor_notebook().get_current_editor() if editor: filename = editor.get_filename() selection = editor.get_code_view().get_selected_range() lineno = selection.lineno if filename and lineno: return filename, lineno return None def handle_debugger_progress(self, msg): super().handle_debugger_progress(msg) self._last_progress_message = msg self.bring_out_frame(self._last_progress_message.stack[-1].id, force=True) if get_workbench().get_option("debugger.automatic_stack_view"): if len(msg.stack) > 1: get_workbench().show_view("StackView") get_workbench().get_view("ExceptionView").set_exception( msg["exception_info"]["lines_with_frame_info"] ) def close(self): super().close() if self._last_frame_visualizer is not None: self._last_frame_visualizer.close() self._last_frame_visualizer = None def clear_last_frame(self): if self._last_frame_visualizer is not None: self._last_frame_visualizer.clear() def bring_out_frame(self, frame_id, force=False): if not force and frame_id == self._last_brought_out_frame_id: return self._last_brought_out_frame_id = frame_id frame_info = self.get_frame_by_id(frame_id) if ( self._last_frame_visualizer is not None and self._last_frame_visualizer._frame_id != frame_info.id ): self._last_frame_visualizer.close() self._last_frame_visualizer = None if self._last_frame_visualizer is None: self._last_frame_visualizer = EditorVisualizer(frame_info) self._last_frame_visualizer._update_this_frame(self._last_progress_message, frame_info) # show variables var_view = get_workbench().get_view("VariablesView") if frame_info.code_name == "": var_view.show_globals(frame_info.globals, frame_info.module_name) else: var_view.show_frame_variables( frame_info.locals, frame_info.globals, frame_info.freevars, frame_info.module_name if frame_info.code_name == "" else frame_info.code_name, ) def handle_debugger_return(self, msg): if ( self._last_frame_visualizer is not None and self._last_frame_visualizer.get_frame_id() == msg.get("frame_id") ): self._last_frame_visualizer.close() class StackedWindowsDebugger(Debugger): def __init__(self): super().__init__() self._main_frame_visualizer = None def get_run_to_cursor_breakpoint(self): visualizer = self._get_topmost_selected_visualizer() if visualizer: assert isinstance(visualizer._text_frame, CodeView) code_view = visualizer._text_frame selection = code_view.get_selected_range() target_lineno = visualizer._firstlineno - 1 + selection.lineno return visualizer._filename, target_lineno else: return None def handle_debugger_progress(self, msg): super().handle_debugger_progress(msg) self._last_progress_message = msg main_frame_id = msg.stack[0].id # clear obsolete main frame visualizer if ( self._main_frame_visualizer and self._main_frame_visualizer.get_frame_id() != main_frame_id ): self._main_frame_visualizer.close() self._main_frame_visualizer = None if not self._main_frame_visualizer: self._main_frame_visualizer = EditorVisualizer(msg.stack[0]) self._main_frame_visualizer.update_this_and_next_frames(msg) self.bring_out_frame(msg.stack[-1].id, force=True) get_workbench().get_view("ExceptionView").set_exception( msg["exception_info"]["lines_with_frame_info"] ) def close(self): super().close() if self._main_frame_visualizer is not None: self._main_frame_visualizer.close() self._main_frame_visualizer = None def clear_last_frame(self): visualizer = self._get_topmost_visualizer() if visualizer is not None: visualizer.clear() def _get_topmost_visualizer(self): visualizer = self._main_frame_visualizer if visualizer is None: return None while visualizer._next_frame_visualizer is not None: visualizer = visualizer._next_frame_visualizer return visualizer def _get_topmost_selected_visualizer(self): visualizer = self._get_topmost_visualizer() if visualizer is None: return None topmost_text_widget = visualizer._text focused_widget = get_workbench().focus_get() if focused_widget is None: return None elif focused_widget == topmost_text_widget: return visualizer else: return None def bring_out_frame(self, frame_id, force=False): if not force and frame_id == self._last_brought_out_frame_id: return self._last_brought_out_frame_id = frame_id self._main_frame_visualizer.bring_out_frame(frame_id) # show variables var_view = get_workbench().get_view("VariablesView") frame_info = self.get_frame_by_id(frame_id) var_view.show_globals(frame_info.globals, frame_info.module_name) def handle_debugger_return(self, msg): if self._main_frame_visualizer is None: return self._main_frame_visualizer.close(msg["frame_id"]) if msg["frame_id"] == self._main_frame_visualizer.get_frame_id(): self._main_frame_visualizer = None class FrameVisualizer: """ Is responsible for stepping through statements and updating corresponding UI in Editor-s, FunctionCallDialog-s, ModuleDialog-s """ def __init__(self, text_frame, frame_info): self._text_frame = text_frame self._text = text_frame.text self._frame_info = frame_info self._frame_id = frame_info.id self._filename = frame_info.filename self._firstlineno = None if running_on_mac_os() and get_tk_version_info() < (8, 6, 11): # Older Tk versions had glitch with placement of the expression box # (closed box was not cleaned up) self._expression_box = ToplevelExpressionBox(text_frame) else: # since 8.6.11 Tk on macOS has glitch with ToplevelExpressionBox # (bad z-index) self._expression_box = PlacedExpressionBox(text_frame) self._note_box = ui_utils.NoteBox(text_frame.winfo_toplevel()) self._next_frame_visualizer = None self._prev_frame_visualizer = None self._text.set_read_only(True) self._line_debug = frame_info.current_statement is None self._reconfigure_tags() def _translate_lineno(self, lineno): return lineno - self._firstlineno + 1 def _reconfigure_tags(self): for tag in ["active_focus", "exception_focus"]: conf = get_syntax_options_for_tag(tag).copy() if self._line_debug: # meaning data comes from line-debug conf["borderwidth"] = 0 self._text.tag_configure(tag, **conf) def close(self, frame_id=None): if self._next_frame_visualizer: self._next_frame_visualizer.close(frame_id) if frame_id is None or self._next_frame_visualizer.get_frame_id() == frame_id: self._next_frame_visualizer = None if frame_id is None or frame_id == self._frame_id: self._text.set_read_only(False) self.clear() # self._expression_box.destroy() def clear(self): self.remove_focus_tags() self.hide_expression_box() self.close_note() def get_frame_id(self): return self._frame_id def update_this_and_next_frames(self, msg): """Must not be used on obsolete frame""" # debug("State: %s, focus: %s", msg.state, msg.focus) frame_info, next_frame_info = self._find_this_and_next_frame(msg.stack) self._update_this_frame(msg, frame_info) # clear obsolete next frame visualizer if self._next_frame_visualizer and ( not next_frame_info or self._next_frame_visualizer.get_frame_id() != next_frame_info.id ): self._next_frame_visualizer.close() self._next_frame_visualizer = None if next_frame_info and not self._next_frame_visualizer: self._next_frame_visualizer = self._create_next_frame_visualizer(next_frame_info) self._next_frame_visualizer._prev_frame_visualizer = self if self._next_frame_visualizer: self._next_frame_visualizer.update_this_and_next_frames(msg) def remove_focus_tags(self): for name in [ "exception_focus", "active_focus", "completed_focus", "suspended_focus", "sel", ]: self._text.tag_remove(name, "0.0", "end") def hide_expression_box(self): if self._expression_box is not None: self._expression_box.clear_debug_view() def _update_this_frame(self, msg, frame_info): self._frame_info = frame_info self.remove_focus_tags() if frame_info.event == "line": if ( frame_info.id in msg["exception_info"]["affected_frame_ids"] and msg["exception_info"]["is_fresh"] ): self._tag_range(frame_info.focus, "exception_focus") else: self._tag_range(frame_info.focus, "active_focus") else: if "statement" in frame_info.event: if msg["exception_info"]["msg"] is not None and msg["exception_info"]["is_fresh"]: stmt_tag = "exception_focus" elif frame_info.event.startswith("before"): stmt_tag = "active_focus" else: stmt_tag = "completed_focus" else: assert "expression" in frame_info.event stmt_tag = "suspended_focus" if frame_info.current_statement is not None: self._tag_range(frame_info.current_statement, stmt_tag) else: logger.warning("Missing current_statement: %s", frame_info) self._expression_box.update_expression(msg, frame_info) if ( frame_info.id in msg["exception_info"]["affected_frame_ids"] and msg["exception_info"]["is_fresh"] ): self._show_exception(msg["exception_info"]["lines_with_frame_info"], frame_info) else: self.close_note() def _show_exception(self, lines, frame_info): last_line_text = lines[-1][0] self.show_note( last_line_text.strip() + " ", ("...", lambda _: get_workbench().show_view("ExceptionView")), focus=frame_info.focus, ) def _find_this_and_next_frame(self, stack): for i in range(len(stack)): if stack[i].id == self._frame_id: if i == len(stack) - 1: # last frame return stack[i], None else: return stack[i], stack[i + 1] raise AssertionError("Frame doesn't exist anymore") def _tag_range(self, text_range, tag): # For most statements I want to highlight block of whole lines # but for pseudo-statements (like header in for-loop) I want to highlight only the indicated range self._text.tag_raise(tag) line_prefix = self._text.get( "%d.0" % self._translate_lineno(text_range.lineno), "%d.%d" % (self._translate_lineno(text_range.lineno), text_range.col_offset), ) if line_prefix.strip(): # pseudo-statement first_line = self._translate_lineno(text_range.lineno) last_line = self._translate_lineno(text_range.end_lineno) self._text.tag_add( tag, "%d.%d" % (first_line, text_range.col_offset), "%d.%d" % (last_line, text_range.end_col_offset), ) else: # normal statement first_line, first_col, last_line = self._get_text_range_block(text_range) for lineno in range(first_line, last_line + 1): self._text.tag_add(tag, "%d.%d" % (lineno, first_col), "%d.0" % (lineno + 1)) self._text.update_idletasks() self._text.see("%d.0" % (last_line)) self._text.see("%d.0" % (first_line)) if last_line - first_line < 3: # if it's safe to assume that whole code fits into screen # then scroll it down a bit so that expression view doesn't hide behind # lower edge of the editor self._text.update_idletasks() self._text.see("%d.0" % (first_line + 3)) def _get_text_range_block(self, text_range): first_line = text_range.lineno - self._firstlineno + 1 last_line = ( text_range.end_lineno - self._firstlineno + (1 if text_range.end_col_offset > 0 else 0) ) first_line_content = self._text.get("%d.0" % first_line, "%d.end" % first_line) if first_line_content.strip().startswith("elif "): first_col = first_line_content.find("elif ") else: first_col = text_range.col_offset return (first_line, first_col, last_line) def _create_next_frame_visualizer(self, next_frame_info): if next_frame_info.code_name == "": return ModuleLoadDialog(self._text, next_frame_info) else: dialog = FunctionCallDialog(self._text.master, next_frame_info) if self._expression_box.winfo_ismapped(): dialog.title(self._expression_box.get_focused_text()) else: dialog.title(tr("Function call at %s") % hex(self._frame_id)) return dialog def bring_out_frame(self, frame_id): if self._frame_id == frame_id: self.bring_out_this_frame() elif self._next_frame_visualizer is not None: self._next_frame_visualizer.bring_out_frame(frame_id) def bring_out_this_frame(self): pass def show_note(self, *content_items: Union[str, List], target=None, focus=None) -> None: if target is None: target = self._text self._note_box.show_note(*content_items, target=target, focus=focus) def close_note(self): self._note_box.close() class EditorVisualizer(FrameVisualizer): """ Takes care of stepping in the editor (main module in case of StackedWindowsDebugger) """ def __init__(self, frame_info): self.editor = ( get_workbench().get_editor_notebook().show_file(frame_info.filename, set_focus=False) ) FrameVisualizer.__init__(self, self.editor.get_code_view(), frame_info) self._firstlineno = 1 def _update_this_frame(self, msg, frame_info): FrameVisualizer._update_this_frame(self, msg, frame_info) if msg.in_present: self._decorate_editor_title("") else: self._decorate_editor_title(" <<< REPLAYING >>> ") def _decorate_editor_title(self, suffix): self.editor.master.update_editor_title(self.editor, self.editor.get_title() + suffix) def bring_out_this_frame(self): get_workbench().focus_set() def clear(self): super().clear() self._decorate_editor_title("") class BaseExpressionBox: def __init__(self, codeview, text): self.text = text self._codeview = codeview self._last_focus = None self._last_root_expression = None self.text.tag_configure("value", get_syntax_options_for_tag("value")) self.text.tag_configure("before", get_syntax_options_for_tag("active_focus")) self.text.tag_configure("after", get_syntax_options_for_tag("completed_focus")) self.text.tag_configure("exception", get_syntax_options_for_tag("exception_focus")) self.text.tag_raise("exception", "before") self.text.tag_raise("exception", "after") def get_text_options(self): opts = dict( height=1, width=1, relief=tk.RAISED, background="#DCEDF2", borderwidth=1, highlightthickness=0, padx=7, pady=7, wrap=tk.NONE, font="EditorFont", ) opts.update(get_syntax_options_for_tag("expression_box")) return opts def update_expression(self, msg, frame_info): focus = frame_info.focus event = frame_info.event if frame_info.current_root_expression is not None: if self._last_root_expression != frame_info.current_root_expression: # can happen, eg. when focus jumps from the last expr in while body # to while test expression self.clear_debug_view() with tokenize.open(frame_info.filename) as fp: whole_source = fp.read() lines = whole_source.splitlines() if len(lines) < frame_info.current_root_expression.end_lineno: # it must be on a synthetical line which is not actually present in the editor self.clear_debug_view() return self._load_expression( whole_source, frame_info.filename, frame_info.current_root_expression ) for subrange, value in frame_info.current_evaluations: self._replace(subrange, value) if "expression" in event: # Event may be also after_statement_again self._highlight_range( focus, event, ( frame_info.id in msg["exception_info"]["affected_frame_ids"] and msg["exception_info"]["is_fresh"] ), ) self._last_focus = focus self._update_position(frame_info.current_root_expression) self._update_size() else: # hide and clear on non-expression events self.clear_debug_view() self._last_root_expression = frame_info.current_root_expression def get_focused_text(self): if self._last_focus: start_mark = self._get_mark_name(self._last_focus.lineno, self._last_focus.col_offset) end_mark = self._get_mark_name( self._last_focus.end_lineno, self._last_focus.end_col_offset ) return self.text.get(start_mark, end_mark) else: return "" def clear_debug_view(self): self._main_range = None self._last_focus = None self._clear_expression() def _clear_expression(self): for tag in self.text.tag_names(): self.text.tag_remove(tag, "1.0", "end") self.text.mark_unset(*self.text.mark_names()) self.text.delete("1.0", "end") def _replace(self, focus, value): start_mark = self._get_mark_name(focus.lineno, focus.col_offset) end_mark = self._get_mark_name(focus.end_lineno, focus.end_col_offset) self.text.delete(start_mark, end_mark) id_str = memory.format_object_id(value.id) if get_workbench().in_heap_mode(): value_str = id_str else: value_str = shorten_repr(value.repr, 100) object_tag = "object_" + str(value.id) self.text.insert(start_mark, value_str, ("value", object_tag)) if misc_utils.running_on_mac_os(): sequence = "" else: sequence = "" self.text.tag_bind( object_tag, sequence, lambda _: get_workbench().event_generate("ObjectSelect", object_id=value.id), ) def _load_expression(self, whole_source: str, filename, text_range): assert isinstance(whole_source, str) root = ast_utils.parse_source(whole_source, filename) main_node = ast_utils.find_expression(root, text_range) source = ast_utils.extract_text_range(whole_source, text_range) logger.debug("EV.load_exp: %s", (text_range, main_node, source)) self._clear_expression() self.text.insert("1.0", source) # create node marks def _create_index(lineno, col_offset): local_lineno = lineno - main_node.lineno + 1 if lineno == main_node.lineno: local_col_offset = col_offset - main_node.col_offset else: local_col_offset = col_offset return str(local_lineno) + "." + str(local_col_offset) for node in ast.walk(main_node): if "lineno" in node._attributes and hasattr(node, "end_lineno"): index1 = _create_index(node.lineno, node.col_offset) index2 = _create_index(node.end_lineno, node.end_col_offset) start_mark = self._get_mark_name(node.lineno, node.col_offset) if not start_mark in self.text.mark_names(): self.text.mark_set(start_mark, index1) # print("Creating mark", start_mark, index1) self.text.mark_gravity(start_mark, tk.LEFT) end_mark = self._get_mark_name(node.end_lineno, node.end_col_offset) if not end_mark in self.text.mark_names(): self.text.mark_set(end_mark, index2) # print("Creating mark", end_mark, index2) self.text.mark_gravity(end_mark, tk.RIGHT) def _get_mark_name(self, lineno, col_offset): return str(lineno) + "_" + str(col_offset) def _get_tag_name(self, node_or_text_range): return ( str(node_or_text_range.lineno) + "_" + str(node_or_text_range.col_offset) + "_" + str(node_or_text_range.end_lineno) + "_" + str(node_or_text_range.end_col_offset) ) def _highlight_range(self, text_range, state, has_exception): logger.debug("EV._highlight_range: %s", text_range) self.text.tag_remove("after", "1.0", "end") self.text.tag_remove("before", "1.0", "end") self.text.tag_remove("exception", "1.0", "end") if state.startswith("after"): tag = "after" elif state.startswith("before"): tag = "before" else: return start_index = self._get_mark_name(text_range.lineno, text_range.col_offset) end_index = self._get_mark_name(text_range.end_lineno, text_range.end_col_offset) self.text.tag_add(tag, start_index, end_index) if has_exception: self.text.tag_add("exception", start_index, end_index) def _update_position(self, text_range): self._codeview.update_idletasks() text_line_number = text_range.lineno - self._codeview._first_line_number + 1 bbox = self._codeview.text.bbox(str(text_line_number) + "." + str(text_range.col_offset)) if isinstance(bbox, tuple): x = bbox[0] - self._codeview.text.cget("padx") + 6 y = bbox[1] - self._codeview.text.cget("pady") - 6 else: x = 30 y = 30 self._set_position_make_visible(x, y) def _update_size(self): content = self.text.get("1.0", tk.END) lines = content.splitlines() self.text["height"] = len(lines) self.text["width"] = max(map(len, lines)) def _set_position_make_visible(self, rel_x, rel_y): raise NotImplementedError() class PlacedExpressionBox(BaseExpressionBox, tk.Text): def __init__(self, codeview): tk.Text.__init__(self, codeview.winfo_toplevel(), self.get_text_options()) BaseExpressionBox.__init__(self, codeview, self) def clear_debug_view(self): if self.winfo_ismapped(): self.place_forget() super().clear_debug_view() def _set_position_make_visible(self, rel_x, rel_y): x = rel_x y = rel_y widget = self._codeview.text while widget != self.master: x += widget.winfo_x() y += widget.winfo_y() widget = widget.master if not self.winfo_ismapped(): self.place(x=x, y=y, anchor=tk.NW) self.update() class ToplevelExpressionBox(BaseExpressionBox, tk.Toplevel): def __init__(self, codeview): tk.Toplevel.__init__(self, codeview.winfo_toplevel()) text = tk.Text(self, **self.get_text_options()) BaseExpressionBox.__init__(self, codeview, text) self.text.grid() if running_on_mac_os(): try: # NB! Must be the first thing to do after creation # https://wiki.tcl-lang.org/page/MacWindowStyle self.tk.call( "::tk::unsupported::MacWindowStyle", "style", self._w, "help", "noActivates" ) except TclError: pass else: raise RuntimeError("Should be used only on Mac") self.resizable(False, False) if get_tk_version_info() >= (8, 6, 10) and running_on_mac_os(): # self.wm_overrideredirect(1) # Tkinter wrapper can give error in 3.9.2 self.tk.call("wm", "overrideredirect", self._w, 1) self.wm_transient(codeview.winfo_toplevel()) self.lift() def clear_debug_view(self): if self.winfo_ismapped(): self.withdraw() super().clear_debug_view() def _set_position_make_visible(self, rel_x, rel_y): """ widget = self._codeview.text while widget is not None: x += widget.winfo_x() y += widget.winfo_y() widget = widget.master """ x = rel_x + self._codeview.text.winfo_rootx() y = rel_y + self._codeview.text.winfo_rooty() if not self.winfo_ismapped(): self.update() self.deiconify() self.geometry("+%d+%d" % (x, y)) def get_text_options(self): opts = super().get_text_options() opts["relief"] = "flat" opts["borderwidth"] = 0 return opts class DialogVisualizer(CommonDialog, FrameVisualizer): def __init__(self, master, frame_info): CommonDialog.__init__(self, master) self.transient(master) if misc_utils.running_on_windows(): self.wm_attributes("-toolwindow", 1) # TODO: take size from prefs editor_notebook = get_workbench().get_editor_notebook() if master.winfo_toplevel() == get_workbench(): position_reference = editor_notebook else: # align to previous frame position_reference = master.winfo_toplevel() self.geometry( "{}x{}+{}+{}".format( editor_notebook.winfo_width(), editor_notebook.winfo_height() - 20, position_reference.winfo_rootx(), position_reference.winfo_rooty(), ) ) self.protocol("WM_DELETE_WINDOW", self._on_close) self.bind("", self._on_focus, True) self._init_layout_widgets(master, frame_info) FrameVisualizer.__init__(self, self._text_frame, frame_info) self._firstlineno = frame_info.firstlineno self._load_code(frame_info) self._text_frame.text.focus() self.wm_deiconify() self.update() def _init_layout_widgets(self, master, frame_info): self.main_frame = ttk.Frame( self ) # just a background behind padding of main_pw, without this OS X leaves white border self.main_frame.grid(sticky=tk.NSEW) self.rowconfigure(0, weight=1) self.columnconfigure(0, weight=1) self.main_pw = ui_utils.AutomaticPanedWindow(self.main_frame, orient=tk.VERTICAL) self.main_pw.grid(sticky=tk.NSEW, padx=10, pady=10) self.main_frame.rowconfigure(0, weight=1) self.main_frame.columnconfigure(0, weight=1) self._code_book = ttk.Notebook(self.main_pw) self._text_frame = CodeView( self._code_book, first_line_number=frame_info.firstlineno, font="EditorFont" ) self._code_book.add(self._text_frame, text=tr("Source code")) self.main_pw.add(self._code_book, minsize=200) self._code_book.preferred_size_in_pw = 400 def _load_code(self, frame_info): self._text_frame.set_content(frame_info.source) def _update_this_frame(self, msg, frame_info): FrameVisualizer._update_this_frame(self, msg, frame_info) def bring_out_this_frame(self): self.focus_set() # no effect when clicking on stack view var_view = get_workbench().get_view("VariablesView") var_view.show_globals(self._frame_info.globals, self._frame_info.module_name) def _on_focus(self, event): # TODO: bring out main frame when main window gets focus self.bring_out_this_frame() def _on_close(self): showinfo( tr("Can't close yet"), tr('Use "Stop" command if you want to cancel debugging'), master=self, ) def close(self, frame_id=None): super().close() if frame_id is None or frame_id == self._frame_id: self.destroy() class FunctionCallDialog(DialogVisualizer): def __init__(self, master, frame_info): DialogVisualizer.__init__(self, master, frame_info) def _init_layout_widgets(self, master, frame_info): DialogVisualizer._init_layout_widgets(self, master, frame_info) self._locals_book = ttk.Notebook(self.main_pw) self._locals_frame = VariablesFrame(self._locals_book) self._locals_book.preferred_size_in_pw = 200 self._locals_book.add(self._locals_frame, text=tr("Local variables")) self.main_pw.add(self._locals_book, minsize=100) def _load_code(self, frame_info): DialogVisualizer._load_code(self, frame_info) function_label = frame_info.code_name # change tab label self._code_book.tab(self._text_frame, text=function_label) def _update_this_frame(self, msg, frame_info): DialogVisualizer._update_this_frame(self, msg, frame_info) self._locals_frame.update_variables(frame_info.locals) class ModuleLoadDialog(DialogVisualizer): def __init__(self, text_frame, frame_info): DialogVisualizer.__init__(self, text_frame, frame_info) class StackView(ui_utils.TreeFrame): def __init__(self, master): super().__init__( master, ("function", "location", "id"), displaycolumns=("function", "location") ) # self.tree.configure(show="tree") self.tree.column("#0", width=0, anchor=tk.W, stretch=False) self.tree.column("function", width=120, anchor=tk.W, stretch=False) self.tree.column("location", width=450, anchor=tk.W, stretch=True) self.tree.heading("function", text=tr("Function"), anchor=tk.W) self.tree.heading("location", text=tr("Location"), anchor=tk.W) get_workbench().bind("DebuggerResponse", self._update_stack, True) get_workbench().bind("ToplevelResponse", lambda e=None: self._clear_tree(), True) get_workbench().bind("debugger_return_response", self._handle_debugger_return, True) def _update_stack(self, msg): self._clear_tree() node_id = None for frame in msg.stack: lineno = frame.focus.lineno node_id = self.tree.insert("", "end") self.tree.set(node_id, "function", frame.code_name) self.tree.set( node_id, "location", "%s, line %s" % (os.path.basename(frame.filename), lineno) ) self.tree.set(node_id, "id", frame.id) # select last frame if node_id is not None: self.tree.see(node_id) self.tree.selection_add(node_id) self.tree.focus(node_id) def _handle_debugger_return(self, msg): delete = False for iid in self.tree.get_children(): if self.tree.set(iid, "id") == msg["frame_id"]: # start deleting from this frame delete = True if delete: self.tree.delete(iid) def on_select(self, event): iid = self.tree.focus() if iid != "": # assuming id is in the last column frame_id = self.tree.item(iid)["values"][-1] if _current_debugger is not None: _current_debugger.bring_out_frame(frame_id) class ExceptionView(TextFrame): def __init__(self, master): super().__init__( master, borderwidth=0, relief="solid", undo=False, read_only=True, font="TkDefaultFont", text_class=SyntaxText, foreground=get_syntax_options_for_tag("stderr")["foreground"], highlightthickness=0, padx=5, pady=5, wrap="char", horizontal_scrollbar=False, ) self.text.tag_configure("hyperlink", **get_syntax_options_for_tag("hyperlink")) self.text.tag_bind("hyperlink", "", self._hyperlink_enter) self.text.tag_bind("hyperlink", "", self._hyperlink_leave) get_workbench().bind("ToplevelResponse", self._on_toplevel_response, True) self._prev_exception = None self._show_description() def _show_description(self): self.text.configure(foreground=get_syntax_options_for_tag("TEXT")["foreground"]) self.text.direct_insert( "end", tr("If last command raised an exception then this view will show the stacktrace."), ) def set_exception(self, exception_lines_with_frame_info): if exception_lines_with_frame_info == self._prev_exception: return self.text.direct_delete("1.0", "end") if exception_lines_with_frame_info is None: self._show_description() return self.text.configure(foreground=get_syntax_options_for_tag("stderr")["foreground"]) for line, frame_id, filename, lineno in exception_lines_with_frame_info: if frame_id is not None: frame_tag = "frame_%d" % frame_id def handle_frame_click(event, frame_id=frame_id, filename=filename, lineno=lineno): get_runner().send_command(InlineCommand("get_frame_info", frame_id=frame_id)) if os.path.exists(filename): get_workbench().get_editor_notebook().show_file( filename, lineno, set_focus=False ) self.text.tag_bind(frame_tag, "<1>", handle_frame_click, True) start = max(line.find("File"), 0) end = line.replace("\r", "").find("\n") if end < 10: end = len(line) self.text.direct_insert("end", line[:start]) self.text.direct_insert("end", line[start:end], ("hyperlink", frame_tag)) self.text.direct_insert("end", line[end:]) else: self.text.direct_insert("end", line) self._prev_exception = exception_lines_with_frame_info def _on_toplevel_response(self, msg): if "user_exception" in msg: self.set_exception(msg["user_exception"]["items"]) else: self.set_exception(None) def _hyperlink_enter(self, event): self.text.config(cursor=get_hyperlink_cursor()) def _hyperlink_leave(self, event): self.text.config(cursor="") def _debugger_command_enabled(command): if _current_debugger is None: return False else: return _current_debugger.command_enabled(command) def _issue_debugger_command(command): if _current_debugger is None: raise AssertionError("Trying to send debugger command without debugger") else: return _current_debugger.check_issue_command(command) def _start_debug_enabled(): return ( _current_debugger is None and get_workbench().get_editor_notebook().get_current_editor() is not None and get_runner().get_backend_proxy() and get_runner().get_backend_proxy().can_debug() ) def _request_debug(command_name): # Don't assume Debug command gets issued after this # This may just call the %cd command # or the user may deny saving current editor if get_workbench().in_simple_mode(): get_workbench().show_view("VariablesView") get_runner().execute_current(command_name) def _debug_accepted(event): # Called when proxy accepted the debug command global _current_debugger cmd = event.command if cmd.get("name") in ["Debug", "FastDebug"]: assert _current_debugger is None if get_workbench().get_option("debugger.frames_in_separate_windows"): _current_debugger = StackedWindowsDebugger() else: _current_debugger = SingleWindowDebugger() def _handle_debugger_progress(msg): global _current_debugger assert _current_debugger is not None _current_debugger.handle_debugger_progress(msg) _update_run_or_resume_button() def _handle_toplevel_response(msg): global _current_debugger if _current_debugger is not None: _current_debugger.close() _current_debugger = None _update_run_or_resume_button() def _handle_debugger_return(msg): global _current_debugger assert _current_debugger is not None _current_debugger.handle_debugger_return(msg) def _run_or_resume(): state = get_runner().get_state() if state == "waiting_debugger_command": _issue_debugger_command("resume") elif state == "waiting_toplevel_command": get_runner().cmd_run_current_script() def _run_or_resume_enabled(): return get_runner().cmd_run_current_script_enabled() or _debugger_command_enabled("resume") def _update_run_or_resume_button(): if not get_workbench().in_simple_mode(): return state = get_runner().get_state() if state == "waiting_debugger_command": caption = RESUME_COMMAND_CAPTION image = get_workbench().get_image("resume") elif state == "waiting_toplevel_command": caption = running.RUN_COMMAND_CAPTION image = get_workbench().get_image("run-current-script") else: return button = get_workbench().get_toolbar_button("runresume") button.configure(text=caption, image=image) def get_current_debugger(): return _current_debugger def run_preferred_debug_command(): preferred_debugger = get_workbench().get_option("debugger.preferred_debugger").lower() if preferred_debugger == "faster": return _request_debug("FastDebug") elif preferred_debugger == "birdseye": from thonny.plugins.birdseye_frontend import debug_with_birdseye return debug_with_birdseye() else: return _request_debug("Debug") def load_plugin() -> None: global RESUME_COMMAND_CAPTION RESUME_COMMAND_CAPTION = tr("Resume") if get_workbench().in_simple_mode(): get_workbench().set_default("debugger.frames_in_separate_windows", False) else: get_workbench().set_default("debugger.frames_in_separate_windows", True) get_workbench().set_default("debugger.automatic_stack_view", True) get_workbench().set_default( "debugger.preferred_debugger", "faster" if running_on_rpi() else "nicer" ) get_workbench().set_default("debugger.allow_stepping_into_libraries", False) get_workbench().add_command( "runresume", "run", tr("Run / resume"), _run_or_resume, caption=running.RUN_COMMAND_CAPTION, tester=_run_or_resume_enabled, default_sequence=None, group=10, image="run-current-script", include_in_menu=False, include_in_toolbar=get_workbench().in_simple_mode(), alternative_caption=RESUME_COMMAND_CAPTION, ) get_workbench().add_command( "debug_preferred", "run", tr("Debug current script"), run_preferred_debug_command, caption=tr("Debug"), tester=_start_debug_enabled, group=10, image="debug-current-script", include_in_menu=False, include_in_toolbar=True, ) get_workbench().add_command( "debug_nicer", "run", tr("Debug current script (nicer)"), lambda: _request_debug("Debug"), caption="Debug (nicer)", tester=_start_debug_enabled, default_sequence="", group=10, # image="debug-current-script", ) get_workbench().add_command( "debug_faster", "run", tr("Debug current script (faster)"), lambda: _request_debug("FastDebug"), caption="Debug (faster)", tester=_start_debug_enabled, default_sequence="", group=10, ) get_workbench().add_command( "step_over", "run", tr("Step over"), lambda: _issue_debugger_command("step_over"), caption=tr("Over"), tester=lambda: _debugger_command_enabled("step_over"), default_sequence="", group=30, image="step-over", include_in_toolbar=True, ) get_workbench().add_command( "step_into", "run", tr("Step into"), lambda: _issue_debugger_command("step_into"), caption=tr("Into"), tester=lambda: _debugger_command_enabled("step_into"), default_sequence="", group=30, image="step-into", include_in_toolbar=True, ) get_workbench().add_command( "step_out", "run", tr("Step out"), lambda: _issue_debugger_command("step_out"), caption=tr("Out"), tester=lambda: _debugger_command_enabled("step_out"), group=30, image="step-out", include_in_toolbar=True, ) get_workbench().add_command( "resume", "run", RESUME_COMMAND_CAPTION, lambda: _issue_debugger_command("resume"), caption=RESUME_COMMAND_CAPTION, tester=lambda: _debugger_command_enabled("resume"), default_sequence="", group=30, image="resume", include_in_toolbar=not get_workbench().in_simple_mode(), ) get_workbench().add_command( "run_to_cursor", "run", tr("Run to cursor"), lambda: _issue_debugger_command("run_to_cursor"), tester=lambda: _debugger_command_enabled("run_to_cursor"), default_sequence=select_sequence("", ""), group=30, image="run-to-cursor", include_in_toolbar=False, ) get_workbench().add_command( "step_back", "run", tr("Step back"), lambda: _issue_debugger_command("step_back"), caption=tr("Back"), tester=lambda: _debugger_command_enabled("step_back"), default_sequence=select_sequence("", ""), group=30, ) get_workbench().add_view(StackView, tr("Stack"), "se") get_workbench().add_view(ExceptionView, tr("Exception"), "s") get_workbench().bind("DebuggerResponse", _handle_debugger_progress, True) get_workbench().bind("ToplevelResponse", _handle_toplevel_response, True) get_workbench().bind("debugger_return_response", _handle_debugger_return, True) get_workbench().bind("CommandAccepted", _debug_accepted, True)