If enabled, Python source code will be analyzed " "using pyflakes, lines containing errors or " "warnings will be highlighted.
" "Note: add analysis:ignore in " "a comment to ignore code analysis " "warnings.
")) pyflakes_box.setEnabled(is_pyflakes) if not is_pyflakes: pyflakes_box.setToolTip(_("Code analysis requires pyflakes %s+") % codeanalysis.PYFLAKES_REQVER) pep8_box = newcb(_("Real-time code style analysis"), 'code_analysis/pep8', default=False, tip=_("If enabled, Python source code will be analyzed " "using pycodestyle, lines that are not following PEP8 " "style guide will be highlighted.
" "Note: add analysis:ignore in " "a comment to ignore style analysis " "warnings.
")) pep8_box.setEnabled(is_pep8) todolist_box = newcb(_("Code annotations (TODO, FIXME, XXX, HINT, TIP," " @todo, HACK, BUG, OPTIMIZE, !!!, ???)"), 'todo_list', default=True) realtime_radio = self.create_radiobutton( _("Perform analysis when " "saving file and every"), 'realtime_analysis', True) saveonly_radio = self.create_radiobutton( _("Perform analysis only " "when saving file"), 'onsave_analysis') af_spin = self.create_spinbox("", _(" ms"), 'realtime_analysis/timeout', min_=100, max_=1000000, step=100) af_layout = QHBoxLayout() af_layout.addWidget(realtime_radio) af_layout.addWidget(af_spin) run_layout = QVBoxLayout() run_layout.addWidget(saveall_box) run_group.setLayout(run_layout) run_selection_layout = QVBoxLayout() run_selection_layout.addWidget(focus_box) run_selection_group.setLayout(run_selection_layout) introspection_layout = QVBoxLayout() if rope_is_installed: introspection_layout.addWidget(calltips_box) introspection_layout.addWidget(completion_box) introspection_layout.addWidget(case_comp_box) introspection_layout.addWidget(comp_enter_box) introspection_layout.addWidget(gotodef_box) else: introspection_layout.addWidget(rope_label) introspection_group.setLayout(introspection_layout) analysis_layout = QVBoxLayout() analysis_layout.addWidget(pyflakes_box) analysis_pep_layout = QHBoxLayout() analysis_pep_layout.addWidget(pep8_box) analysis_pep_layout.addWidget(pep8_label) analysis_layout.addLayout(analysis_pep_layout) analysis_layout.addWidget(todolist_box) analysis_layout.addLayout(af_layout) analysis_layout.addWidget(saveonly_radio) analysis_group.setLayout(analysis_layout) sourcecode_layout = QVBoxLayout() sourcecode_layout.addWidget(closepar_box) sourcecode_layout.addWidget(autounindent_box) sourcecode_layout.addWidget(add_colons_box) sourcecode_layout.addWidget(close_quotes_box) indent_tab_layout = QHBoxLayout() indent_tab_grid_layout = QGridLayout() indent_tab_grid_layout.addWidget(indent_chars_box.label, 0, 0) indent_tab_grid_layout.addWidget(indent_chars_box.combobox, 0, 1) indent_tab_grid_layout.addWidget(tabwidth_spin.plabel, 1, 0) indent_tab_grid_layout.addWidget(tabwidth_spin.spinbox, 1, 1) indent_tab_grid_layout.addWidget(tabwidth_spin.slabel, 1, 2) indent_tab_layout.addLayout(indent_tab_grid_layout) indent_tab_layout.addStretch(1) sourcecode_layout.addLayout(indent_tab_layout) sourcecode_layout.addWidget(tab_mode_box) sourcecode_layout.addWidget(ibackspace_box) sourcecode_layout.addWidget(removetrail_box) sourcecode_group.setLayout(sourcecode_layout) eol_group = QGroupBox(_("End-of-line characters")) eol_label = QLabel(_("When opening a text file containing " "mixed end-of-line characters (this may " "raise syntax errors in the consoles " "on Windows platforms), Spyder may fix the " "file automatically.")) eol_label.setWordWrap(True) check_eol_box = newcb(_("Fix automatically and show warning " "message box"), 'check_eol_chars', default=True) eol_layout = QVBoxLayout() eol_layout.addWidget(eol_label) eol_layout.addWidget(check_eol_box) eol_group.setLayout(eol_layout) tabs = QTabWidget() tabs.addTab(self.create_tab(interface_group, display_group), _("Display")) tabs.addTab(self.create_tab(introspection_group, analysis_group), _("Code Introspection/Analysis")) tabs.addTab(self.create_tab(template_btn, run_group, run_selection_group, sourcecode_group, eol_group), _("Advanced settings")) vlayout = QVBoxLayout() vlayout.addWidget(tabs) self.setLayout(vlayout) class Editor(SpyderPluginWidget): """ Multi-file Editor widget """ CONF_SECTION = 'editor' CONFIGWIDGET_CLASS = EditorConfigPage TEMPFILE_PATH = get_conf_path('temp.py') TEMPLATE_PATH = get_conf_path('template.py') DISABLE_ACTIONS_WHEN_HIDDEN = False # SpyderPluginWidget class attribute # Signals run_in_current_ipyclient = Signal(str, str, str, bool, bool, bool, bool) exec_in_extconsole = Signal(str, bool) redirect_stdio = Signal(bool) open_dir = Signal(str) breakpoints_saved = Signal() run_in_current_extconsole = Signal(str, str, str, bool, bool) open_file_update = Signal(str) def __init__(self, parent, ignore_last_opened_files=False): if PYQT5: SpyderPluginWidget.__init__(self, parent, main=parent) else: SpyderPluginWidget.__init__(self, parent) self.__set_eol_chars = True # Creating template if it doesn't already exist if not osp.isfile(self.TEMPLATE_PATH): if os.name == "nt": shebang = [] else: shebang = ['#!/usr/bin/env python' + ('2' if PY2 else '3')] header = shebang + [ '# -*- coding: utf-8 -*-', '"""', 'Created on %(date)s', '', '@author: %(username)s', '"""', ''] try: encoding.write(os.linesep.join(header), self.TEMPLATE_PATH, 'utf-8') except EnvironmentError: pass self.projects = None self.outlineexplorer = None self.help = None self.file_dependent_actions = [] self.pythonfile_dependent_actions = [] self.dock_toolbar_actions = None self.edit_menu_actions = None #XXX: find another way to notify Spyder self.stack_menu_actions = None self.__first_open_files_setup = True self.editorstacks = [] self.last_focus_editorstack = {} self.editorwindows = [] self.editorwindows_to_be_created = [] self.toolbar_list = None self.menu_list = None # Initialize plugin self.initialize_plugin() # Configuration dialog size self.dialog_size = None statusbar = self.main.statusBar() self.readwrite_status = ReadWriteStatus(self, statusbar) self.eol_status = EOLStatus(self, statusbar) self.encoding_status = EncodingStatus(self, statusbar) self.cursorpos_status = CursorPositionStatus(self, statusbar) layout = QVBoxLayout() self.dock_toolbar = QToolBar(self) add_actions(self.dock_toolbar, self.dock_toolbar_actions) layout.addWidget(self.dock_toolbar) self.last_edit_cursor_pos = None self.cursor_pos_history = [] self.cursor_pos_index = None self.__ignore_cursor_position = True # Don't start IntrospectionManager when running tests because # it consumes a lot of memory if (running_under_pytest() and not os.environ.get('SPY_TEST_USE_INTROSPECTION')): try: from unittest.mock import Mock except ImportError: from mock import Mock # Python 2 self.introspector = Mock() else: self.introspector = IntrospectionManager( extra_path=self.main.get_spyder_pythonpath()) # Setup new windows: self.main.all_actions_defined.connect(self.setup_other_windows) # Change module completions when PYTHONPATH changes self.main.sig_pythonpath_changed.connect(self.set_path) # Find widget self.find_widget = FindReplace(self, enable_replace=True) self.find_widget.hide() self.find_widget.visibility_changed.connect( lambda vs: self.rehighlight_cells()) self.register_widget_shortcuts(self.find_widget) # Tabbed editor widget + Find/Replace widget editor_widgets = QWidget(self) editor_layout = QVBoxLayout() editor_layout.setContentsMargins(0, 0, 0, 0) editor_widgets.setLayout(editor_layout) self.editorsplitter = EditorSplitter(self, self, self.stack_menu_actions, first=True) editor_layout.addWidget(self.editorsplitter) editor_layout.addWidget(self.find_widget) # Splitter: editor widgets (see above) + outline explorer self.splitter = QSplitter(self) self.splitter.setContentsMargins(0, 0, 0, 0) self.splitter.addWidget(editor_widgets) self.splitter.setStretchFactor(0, 5) self.splitter.setStretchFactor(1, 1) layout.addWidget(self.splitter) self.setLayout(layout) self.setFocusPolicy(Qt.ClickFocus) # Editor's splitter state state = self.get_option('splitter_state', None) if state is not None: self.splitter.restoreState( QByteArray().fromHex( str(state).encode('utf-8')) ) self.recent_files = self.get_option('recent_files', []) self.untitled_num = 0 # Parameters of last file execution: self.__last_ic_exec = None # internal console self.__last_ec_exec = None # external console # File types and filters used by the Open dialog self.edit_filetypes = None self.edit_filters = None self.__ignore_cursor_position = False current_editor = self.get_current_editor() if current_editor is not None: filename = self.get_current_filename() position = current_editor.get_position('cursor') self.add_cursor_position_to_history(filename, position) self.update_cursorpos_actions() self.set_path() def set_projects(self, projects): self.projects = projects @Slot() def show_hide_projects(self): if self.projects is not None: dw = self.projects.dockwidget if dw.isVisible(): dw.hide() else: dw.show() dw.raise_() self.switch_to_plugin() def set_outlineexplorer(self, outlineexplorer): self.outlineexplorer = outlineexplorer for editorstack in self.editorstacks: editorstack.set_outlineexplorer(self.outlineexplorer) self.editorstacks[0].initialize_outlineexplorer() self.outlineexplorer.edit_goto.connect( lambda filenames, goto, word: self.load(filenames=filenames, goto=goto, word=word, editorwindow=self)) self.outlineexplorer.edit.connect( lambda filenames: self.load(filenames=filenames, editorwindow=self)) def set_help(self, help_plugin): self.help = help_plugin for editorstack in self.editorstacks: editorstack.set_help(self.help) #------ Private API -------------------------------------------------------- def restore_scrollbar_position(self): """Restoring scrollbar position after main window is visible""" # Widget is now visible, we may center cursor on top level editor: try: self.get_current_editor().centerCursor() except AttributeError: pass #------ SpyderPluginWidget API --------------------------------------------- def get_plugin_title(self): """Return widget title""" title = _('Editor') if self.dockwidget: filename = self.get_current_filename() if self.dockwidget.dock_tabbar: if filename and self.dockwidget.dock_tabbar.count() < 2: title += ' - ' + to_text_string(filename) else: title += ' - ' + to_text_string(filename) return title def get_plugin_icon(self): """Return widget icon.""" return ima.icon('edit') def get_focus_widget(self): """ Return the widget to give focus to. This happens when plugin's dockwidget is raised on top-level. """ return self.get_current_editor() def visibility_changed(self, enable): """DockWidget visibility has changed""" SpyderPluginWidget.visibility_changed(self, enable) if self.dockwidget.isWindow(): self.dock_toolbar.show() else: self.dock_toolbar.hide() if enable: self.refresh_plugin() self.update_plugin_title.emit() def refresh_plugin(self): """Refresh editor plugin""" editorstack = self.get_current_editorstack() editorstack.refresh() self.refresh_save_all_action() def closing_plugin(self, cancelable=False): """Perform actions before parent main window is closed""" state = self.splitter.saveState() self.set_option('splitter_state', qbytearray_to_str(state)) filenames = [] editorstack = self.editorstacks[0] active_project_path = None if self.projects is not None: active_project_path = self.projects.get_active_project_path() if not active_project_path: self.set_open_filenames() else: self.projects.set_project_filenames( [finfo.filename for finfo in editorstack.data]) self.set_option('layout_settings', self.editorsplitter.get_layout_settings()) self.set_option('windows_layout_settings', [win.get_layout_settings() for win in self.editorwindows]) # self.set_option('filenames', filenames) self.set_option('recent_files', self.recent_files) try: if not editorstack.save_if_changed(cancelable) and cancelable: return False else: for win in self.editorwindows[:]: win.close() return True except IndexError: return True def get_plugin_actions(self): """Return a list of actions related to plugin""" # ---- File menu and toolbar ---- self.new_action = create_action( self, _("&New file..."), icon=ima.icon('filenew'), tip=_("New file"), triggered=self.new, context=Qt.WidgetShortcut ) self.register_shortcut(self.new_action, context="Editor", name="New file", add_sc_to_tip=True) self.open_last_closed_action = create_action( self, _("O&pen last closed"), tip=_("Open last closed"), triggered=self.open_last_closed ) self.register_shortcut(self.open_last_closed_action, context="Editor", name="Open last closed") self.open_action = create_action(self, _("&Open..."), icon=ima.icon('fileopen'), tip=_("Open file"), triggered=self.load, context=Qt.WidgetShortcut) self.register_shortcut(self.open_action, context="Editor", name="Open file", add_sc_to_tip=True) self.revert_action = create_action(self, _("&Revert"), icon=ima.icon('revert'), tip=_("Revert file from disk"), triggered=self.revert) self.save_action = create_action(self, _("&Save"), icon=ima.icon('filesave'), tip=_("Save file"), triggered=self.save, context=Qt.WidgetShortcut) self.register_shortcut(self.save_action, context="Editor", name="Save file", add_sc_to_tip=True) self.save_all_action = create_action(self, _("Sav&e all"), icon=ima.icon('save_all'), tip=_("Save all files"), triggered=self.save_all, context=Qt.WidgetShortcut) self.register_shortcut(self.save_all_action, context="Editor", name="Save all", add_sc_to_tip=True) save_as_action = create_action(self, _("Save &as..."), None, ima.icon('filesaveas'), tip=_("Save current file as..."), triggered=self.save_as, context=Qt.WidgetShortcut) self.register_shortcut(save_as_action, "Editor", "Save As") save_copy_as_action = create_action(self, _("Save copy as..."), None, ima.icon('filesaveas'), _("Save copy of current file as..."), triggered=self.save_copy_as) print_preview_action = create_action(self, _("Print preview..."), tip=_("Print preview..."), triggered=self.print_preview) self.print_action = create_action(self, _("&Print..."), icon=ima.icon('print'), tip=_("Print current file..."), triggered=self.print_file) # Shortcut for close_action is defined in widgets/editor.py self.close_action = create_action(self, _("&Close"), icon=ima.icon('fileclose'), tip=_("Close current file"), triggered=self.close_file) self.close_all_action = create_action(self, _("C&lose all"), icon=ima.icon('filecloseall'), tip=_("Close all opened files"), triggered=self.close_all_files, context=Qt.WidgetShortcut) self.register_shortcut(self.close_all_action, context="Editor", name="Close all") # ---- Find menu and toolbar ---- _text = _("&Find text") find_action = create_action(self, _text, icon=ima.icon('find'), tip=_text, triggered=self.find, context=Qt.WidgetShortcut) self.register_shortcut(find_action, context="_", name="Find text", add_sc_to_tip=True) find_next_action = create_action(self, _("Find &next"), icon=ima.icon('findnext'), triggered=self.find_next, context=Qt.WidgetShortcut) self.register_shortcut(find_next_action, context="_", name="Find next") find_previous_action = create_action(self, _("Find &previous"), icon=ima.icon('findprevious'), triggered=self.find_previous, context=Qt.WidgetShortcut) self.register_shortcut(find_previous_action, context="_", name="Find previous") _text = _("&Replace text") replace_action = create_action(self, _text, icon=ima.icon('replace'), tip=_text, triggered=self.replace, context=Qt.WidgetShortcut) self.register_shortcut(replace_action, context="_", name="Replace text") # ---- Debug menu and toolbar ---- set_clear_breakpoint_action = create_action(self, _("Set/Clear breakpoint"), icon=ima.icon('breakpoint_big'), triggered=self.set_or_clear_breakpoint, context=Qt.WidgetShortcut) self.register_shortcut(set_clear_breakpoint_action, context="Editor", name="Breakpoint") set_cond_breakpoint_action = create_action(self, _("Set/Edit conditional breakpoint"), icon=ima.icon('breakpoint_cond_big'), triggered=self.set_or_edit_conditional_breakpoint, context=Qt.WidgetShortcut) self.register_shortcut(set_cond_breakpoint_action, context="Editor", name="Conditional breakpoint") clear_all_breakpoints_action = create_action(self, _('Clear breakpoints in all files'), triggered=self.clear_all_breakpoints) self.winpdb_action = create_action(self, _("Debug with winpdb"), triggered=self.run_winpdb) self.winpdb_action.setEnabled(WINPDB_PATH is not None and PY2) # --- Debug toolbar --- debug_action = create_action(self, _("&Debug"), icon=ima.icon('debug'), tip=_("Debug file"), triggered=self.debug_file) self.register_shortcut(debug_action, context="_", name="Debug", add_sc_to_tip=True) debug_next_action = create_action(self, _("Step"), icon=ima.icon('arrow-step-over'), tip=_("Run current line"), triggered=lambda: self.debug_command("next")) self.register_shortcut(debug_next_action, "_", "Debug Step Over", add_sc_to_tip=True) debug_continue_action = create_action(self, _("Continue"), icon=ima.icon('arrow-continue'), tip=_("Continue execution until next breakpoint"), triggered=lambda: self.debug_command("continue")) self.register_shortcut(debug_continue_action, "_", "Debug Continue", add_sc_to_tip=True) debug_step_action = create_action(self, _("Step Into"), icon=ima.icon('arrow-step-in'), tip=_("Step into function or method of current line"), triggered=lambda: self.debug_command("step")) self.register_shortcut(debug_step_action, "_", "Debug Step Into", add_sc_to_tip=True) debug_return_action = create_action(self, _("Step Return"), icon=ima.icon('arrow-step-out'), tip=_("Run until current function or method returns"), triggered=lambda: self.debug_command("return")) self.register_shortcut(debug_return_action, "_", "Debug Step Return", add_sc_to_tip=True) debug_exit_action = create_action(self, _("Stop"), icon=ima.icon('stop_debug'), tip=_("Stop debugging"), triggered=lambda: self.debug_command("exit")) self.register_shortcut(debug_exit_action, "_", "Debug Exit", add_sc_to_tip=True) # --- Run toolbar --- run_action = create_action(self, _("&Run"), icon=ima.icon('run'), tip=_("Run file"), triggered=self.run_file) self.register_shortcut(run_action, context="_", name="Run", add_sc_to_tip=True) configure_action = create_action(self, _("&Configuration per file..."), icon=ima.icon('run_settings'), tip=_("Run settings"), menurole=QAction.NoRole, triggered=self.edit_run_configurations) self.register_shortcut(configure_action, context="_", name="Configure", add_sc_to_tip=True) re_run_action = create_action(self, _("Re-run &last script"), icon=ima.icon('run_again'), tip=_("Run again last file"), triggered=self.re_run_file) self.register_shortcut(re_run_action, context="_", name="Re-run last script", add_sc_to_tip=True) run_selected_action = create_action(self, _("Run &selection or " "current line"), icon=ima.icon('run_selection'), tip=_("Run selection or " "current line"), triggered=self.run_selection, context=Qt.WidgetShortcut) self.register_shortcut(run_selected_action, context="Editor", name="Run selection", add_sc_to_tip=True) run_cell_action = create_action(self, _("Run cell"), icon=ima.icon('run_cell'), shortcut=QKeySequence(RUN_CELL_SHORTCUT), tip=_("Run current cell (Ctrl+Enter)\n" "[Use #%% to create cells]"), triggered=self.run_cell, context=Qt.WidgetShortcut) run_cell_advance_action = create_action(self, _("Run cell and advance"), icon=ima.icon('run_cell_advance'), shortcut=QKeySequence(RUN_CELL_AND_ADVANCE_SHORTCUT), tip=_("Run current cell and go to the next one " "(Shift+Enter)"), triggered=self.run_cell_and_advance, context=Qt.WidgetShortcut) re_run_last_cell_action = create_action(self, _("Re-run last cell"), tip=_("Re run last cell "), triggered=self.re_run_last_cell, context=Qt.WidgetShortcut) self.register_shortcut(re_run_last_cell_action, context="Editor", name='re-run last cell', add_sc_to_tip=True) # --- Source code Toolbar --- self.todo_list_action = create_action(self, _("Show todo list"), icon=ima.icon('todo_list'), tip=_("Show comments list (TODO/FIXME/XXX/HINT/TIP/@todo/" "HACK/BUG/OPTIMIZE/!!!/???)"), triggered=self.go_to_next_todo) self.todo_menu = QMenu(self) self.todo_list_action.setMenu(self.todo_menu) self.todo_menu.aboutToShow.connect(self.update_todo_menu) self.warning_list_action = create_action(self, _("Show warning/error list"), icon=ima.icon('wng_list'), tip=_("Show code analysis warnings/errors"), triggered=self.go_to_next_warning) self.warning_menu = QMenu(self) self.warning_list_action.setMenu(self.warning_menu) self.warning_menu.aboutToShow.connect(self.update_warning_menu) self.previous_warning_action = create_action(self, _("Previous warning/error"), icon=ima.icon('prev_wng'), tip=_("Go to previous code analysis warning/error"), triggered=self.go_to_previous_warning) self.next_warning_action = create_action(self, _("Next warning/error"), icon=ima.icon('next_wng'), tip=_("Go to next code analysis warning/error"), triggered=self.go_to_next_warning) self.previous_edit_cursor_action = create_action(self, _("Last edit location"), icon=ima.icon('last_edit_location'), tip=_("Go to last edit location"), triggered=self.go_to_last_edit_location, context=Qt.WidgetShortcut) self.register_shortcut(self.previous_edit_cursor_action, context="Editor", name="Last edit location", add_sc_to_tip=True) self.previous_cursor_action = create_action(self, _("Previous cursor position"), icon=ima.icon('prev_cursor'), tip=_("Go to previous cursor position"), triggered=self.go_to_previous_cursor_position, context=Qt.WidgetShortcut) self.register_shortcut(self.previous_cursor_action, context="Editor", name="Previous cursor position", add_sc_to_tip=True) self.next_cursor_action = create_action(self, _("Next cursor position"), icon=ima.icon('next_cursor'), tip=_("Go to next cursor position"), triggered=self.go_to_next_cursor_position, context=Qt.WidgetShortcut) self.register_shortcut(self.next_cursor_action, context="Editor", name="Next cursor position", add_sc_to_tip=True) # --- Edit Toolbar --- self.toggle_comment_action = create_action(self, _("Comment")+"/"+_("Uncomment"), icon=ima.icon('comment'), tip=_("Comment current line or selection"), triggered=self.toggle_comment, context=Qt.WidgetShortcut) self.register_shortcut(self.toggle_comment_action, context="Editor", name="Toggle comment") blockcomment_action = create_action(self, _("Add &block comment"), tip=_("Add block comment around " "current line or selection"), triggered=self.blockcomment, context=Qt.WidgetShortcut) self.register_shortcut(blockcomment_action, context="Editor", name="Blockcomment") unblockcomment_action = create_action(self, _("R&emove block comment"), tip = _("Remove comment block around " "current line or selection"), triggered=self.unblockcomment, context=Qt.WidgetShortcut) self.register_shortcut(unblockcomment_action, context="Editor", name="Unblockcomment") # ---------------------------------------------------------------------- # The following action shortcuts are hard-coded in CodeEditor # keyPressEvent handler (the shortcut is here only to inform user): # (context=Qt.WidgetShortcut -> disable shortcut for other widgets) self.indent_action = create_action(self, _("Indent"), "Tab", icon=ima.icon('indent'), tip=_("Indent current line or selection"), triggered=self.indent, context=Qt.WidgetShortcut) self.unindent_action = create_action(self, _("Unindent"), "Shift+Tab", icon=ima.icon('unindent'), tip=_("Unindent current line or selection"), triggered=self.unindent, context=Qt.WidgetShortcut) self.text_uppercase_action = create_action(self, _("Toggle Uppercase"), tip=_("Change to uppercase current line or selection"), triggered=self.text_uppercase, context=Qt.WidgetShortcut) self.register_shortcut(self.text_uppercase_action, context="Editor", name="transform to uppercase") self.text_lowercase_action = create_action(self, _("Toggle Lowercase"), tip=_("Change to lowercase current line or selection"), triggered=self.text_lowercase, context=Qt.WidgetShortcut) self.register_shortcut(self.text_lowercase_action, context="Editor", name="transform to lowercase") # ---------------------------------------------------------------------- self.win_eol_action = create_action(self, _("Carriage return and line feed (Windows)"), toggled=lambda checked: self.toggle_eol_chars('nt', checked)) self.linux_eol_action = create_action(self, _("Line feed (UNIX)"), toggled=lambda checked: self.toggle_eol_chars('posix', checked)) self.mac_eol_action = create_action(self, _("Carriage return (Mac)"), toggled=lambda checked: self.toggle_eol_chars('mac', checked)) eol_action_group = QActionGroup(self) eol_actions = (self.win_eol_action, self.linux_eol_action, self.mac_eol_action) add_actions(eol_action_group, eol_actions) eol_menu = QMenu(_("Convert end-of-line characters"), self) add_actions(eol_menu, eol_actions) trailingspaces_action = create_action(self, _("Remove trailing spaces"), triggered=self.remove_trailing_spaces) self.showblanks_action = create_action(self, _("Show blank spaces"), toggled=self.toggle_show_blanks) fixindentation_action = create_action(self, _("Fix indentation"), tip=_("Replace tab characters by space characters"), triggered=self.fix_indentation) gotoline_action = create_action(self, _("Go to line..."), icon=ima.icon('gotoline'), triggered=self.go_to_line, context=Qt.WidgetShortcut) self.register_shortcut(gotoline_action, context="Editor", name="Go to line") workdir_action = create_action(self, _("Set console working directory"), icon=ima.icon('DirOpenIcon'), tip=_("Set current console (and file explorer) working " "directory to current script directory"), triggered=self.__set_workdir) self.max_recent_action = create_action(self, _("Maximum number of recent files..."), triggered=self.change_max_recent_files) self.clear_recent_action = create_action(self, _("Clear this list"), tip=_("Clear recent files list"), triggered=self.clear_recent_files) # ---- File menu/toolbar construction ---- self.recent_file_menu = QMenu(_("Open &recent"), self) self.recent_file_menu.aboutToShow.connect(self.update_recent_file_menu) file_menu_actions = [self.new_action, MENU_SEPARATOR, self.open_action, self.open_last_closed_action, self.recent_file_menu, MENU_SEPARATOR, MENU_SEPARATOR, self.save_action, self.save_all_action, save_as_action, save_copy_as_action, self.revert_action, MENU_SEPARATOR, print_preview_action, self.print_action, MENU_SEPARATOR, self.close_action, self.close_all_action, MENU_SEPARATOR] self.main.file_menu_actions += file_menu_actions file_toolbar_actions = ([self.new_action, self.open_action, self.save_action, self.save_all_action] + self.main.file_toolbar_actions) self.main.file_toolbar_actions = file_toolbar_actions # ---- Find menu/toolbar construction ---- self.main.search_menu_actions = [find_action, find_next_action, find_previous_action, replace_action] self.main.search_toolbar_actions = [find_action, find_next_action, replace_action] # ---- Edit menu/toolbar construction ---- self.edit_menu_actions = [self.toggle_comment_action, blockcomment_action, unblockcomment_action, self.indent_action, self.unindent_action, self.text_uppercase_action, self.text_lowercase_action] self.main.edit_menu_actions += [MENU_SEPARATOR] + self.edit_menu_actions edit_toolbar_actions = [self.toggle_comment_action, self.unindent_action, self.indent_action] self.main.edit_toolbar_actions += edit_toolbar_actions # ---- Search menu/toolbar construction ---- self.main.search_menu_actions += [gotoline_action] self.main.search_toolbar_actions += [gotoline_action] # ---- Run menu/toolbar construction ---- run_menu_actions = [run_action, run_cell_action, run_cell_advance_action, re_run_last_cell_action, MENU_SEPARATOR, run_selected_action, re_run_action, configure_action, MENU_SEPARATOR] self.main.run_menu_actions += run_menu_actions run_toolbar_actions = [run_action, run_cell_action, run_cell_advance_action, run_selected_action, re_run_action] self.main.run_toolbar_actions += run_toolbar_actions # ---- Debug menu/toolbar construction ---- # NOTE: 'list_breakpoints' is used by the breakpoints # plugin to add its "List breakpoints" action to this # menu debug_menu_actions = [debug_action, debug_next_action, debug_step_action, debug_return_action, debug_continue_action, debug_exit_action, MENU_SEPARATOR, set_clear_breakpoint_action, set_cond_breakpoint_action, clear_all_breakpoints_action, 'list_breakpoints', MENU_SEPARATOR, self.winpdb_action] self.main.debug_menu_actions += debug_menu_actions debug_toolbar_actions = [debug_action, debug_next_action, debug_step_action, debug_return_action, debug_continue_action, debug_exit_action] self.main.debug_toolbar_actions += debug_toolbar_actions # ---- Source menu/toolbar construction ---- source_menu_actions = [eol_menu, self.showblanks_action, trailingspaces_action, fixindentation_action, MENU_SEPARATOR, self.todo_list_action, self.warning_list_action, self.previous_warning_action, self.next_warning_action, MENU_SEPARATOR, self.previous_edit_cursor_action, self.previous_cursor_action, self.next_cursor_action] self.main.source_menu_actions += source_menu_actions source_toolbar_actions = [self.todo_list_action, self.warning_list_action, self.previous_warning_action, self.next_warning_action, MENU_SEPARATOR, self.previous_edit_cursor_action, self.previous_cursor_action, self.next_cursor_action] self.main.source_toolbar_actions += source_toolbar_actions # ---- Dock widget and file dependent actions ---- self.dock_toolbar_actions = (file_toolbar_actions + [MENU_SEPARATOR] + source_toolbar_actions + [MENU_SEPARATOR] + run_toolbar_actions + [MENU_SEPARATOR] + debug_toolbar_actions + [MENU_SEPARATOR] + edit_toolbar_actions) self.pythonfile_dependent_actions = [run_action, configure_action, set_clear_breakpoint_action, set_cond_breakpoint_action, debug_action, run_selected_action, run_cell_action, run_cell_advance_action, re_run_last_cell_action, blockcomment_action, unblockcomment_action, self.winpdb_action] self.cythonfile_compatible_actions = [run_action, configure_action] self.file_dependent_actions = self.pythonfile_dependent_actions + \ [self.save_action, save_as_action, save_copy_as_action, print_preview_action, self.print_action, self.save_all_action, gotoline_action, workdir_action, self.close_action, self.close_all_action, self.toggle_comment_action, self.revert_action, self.indent_action, self.unindent_action] self.stack_menu_actions = [gotoline_action, workdir_action] return self.file_dependent_actions def register_plugin(self): """Register plugin in Spyder's main window""" self.main.restore_scrollbar_position.connect( self.restore_scrollbar_position) self.main.console.edit_goto.connect(self.load) self.exec_in_extconsole.connect(self.main.execute_in_external_console) self.redirect_stdio.connect(self.main.redirect_internalshell_stdio) self.open_dir.connect(self.main.workingdirectory.chdir) self.set_help(self.main.help) if self.main.outlineexplorer is not None: self.set_outlineexplorer(self.main.outlineexplorer) editorstack = self.get_current_editorstack() if not editorstack.data: self.__load_temp_file() self.main.add_dockwidget(self) self.main.add_to_fileswitcher(self, editorstack.tabs, editorstack.data, ima.icon('TextFileIcon')) def update_font(self): """Update font from Preferences""" font = self.get_plugin_font() color_scheme = self.get_color_scheme() for editorstack in self.editorstacks: editorstack.set_default_font(font, color_scheme) completion_size = CONF.get('main', 'completion/size') for finfo in editorstack.data: comp_widget = finfo.editor.completion_widget comp_widget.setup_appearance(completion_size, font) #------ Focus tabwidget def __get_focus_editorstack(self): fwidget = QApplication.focusWidget() if isinstance(fwidget, EditorStack): return fwidget else: for editorstack in self.editorstacks: if editorstack.isAncestorOf(fwidget): return editorstack def set_last_focus_editorstack(self, editorwindow, editorstack): self.last_focus_editorstack[editorwindow] = editorstack self.last_focus_editorstack[None] = editorstack # very last editorstack def get_last_focus_editorstack(self, editorwindow=None): return self.last_focus_editorstack[editorwindow] def remove_last_focus_editorstack(self, editorstack): for editorwindow, widget in list(self.last_focus_editorstack.items()): if widget is editorstack: self.last_focus_editorstack[editorwindow] = None def save_focus_editorstack(self): editorstack = self.__get_focus_editorstack() if editorstack is not None: for win in [self]+self.editorwindows: if win.isAncestorOf(editorstack): self.set_last_focus_editorstack(win, editorstack) # ------ Handling editorstacks def register_editorstack(self, editorstack): self.editorstacks.append(editorstack) self.register_widget_shortcuts(editorstack) if len(self.editorstacks) > 1 and self.main is not None: # The first editostack is registered automatically with Spyder's # main window through the `register_plugin` method. Only additional # editors added by splitting need to be registered. # See Issue #5057. self.main.fileswitcher.sig_goto_file.connect( editorstack.set_stack_index) if self.isAncestorOf(editorstack): # editorstack is a child of the Editor plugin self.set_last_focus_editorstack(self, editorstack) editorstack.set_closable( len(self.editorstacks) > 1 ) if self.outlineexplorer is not None: editorstack.set_outlineexplorer(self.outlineexplorer) editorstack.set_find_widget(self.find_widget) editorstack.reset_statusbar.connect(self.readwrite_status.hide) editorstack.reset_statusbar.connect(self.encoding_status.hide) editorstack.reset_statusbar.connect(self.cursorpos_status.hide) editorstack.readonly_changed.connect( self.readwrite_status.readonly_changed) editorstack.encoding_changed.connect( self.encoding_status.encoding_changed) editorstack.sig_editor_cursor_position_changed.connect( self.cursorpos_status.cursor_position_changed) editorstack.sig_refresh_eol_chars.connect(self.eol_status.eol_changed) editorstack.set_help(self.help) editorstack.set_io_actions(self.new_action, self.open_action, self.save_action, self.revert_action) editorstack.set_tempfile_path(self.TEMPFILE_PATH) editorstack.set_introspector(self.introspector) settings = ( ('set_pyflakes_enabled', 'code_analysis/pyflakes'), ('set_pep8_enabled', 'code_analysis/pep8'), ('set_todolist_enabled', 'todo_list'), ('set_realtime_analysis_enabled', 'realtime_analysis'), ('set_realtime_analysis_timeout', 'realtime_analysis/timeout'), ('set_blanks_enabled', 'blank_spaces'), ('set_linenumbers_enabled', 'line_numbers'), ('set_edgeline_enabled', 'edge_line'), ('set_edgeline_column', 'edge_line_column'), ('set_codecompletion_auto_enabled', 'codecompletion/auto'), ('set_codecompletion_case_enabled', 'codecompletion/case_sensitive'), ('set_codecompletion_enter_enabled', 'codecompletion/enter_key'), ('set_calltips_enabled', 'calltips'), ('set_go_to_definition_enabled', 'go_to_definition'), ('set_focus_to_editor', 'focus_to_editor'), ('set_close_parentheses_enabled', 'close_parentheses'), ('set_close_quotes_enabled', 'close_quotes'), ('set_add_colons_enabled', 'add_colons'), ('set_auto_unindent_enabled', 'auto_unindent'), ('set_indent_chars', 'indent_chars'), ('set_tab_stop_width_spaces', 'tab_stop_width_spaces'), ('set_wrap_enabled', 'wrap'), ('set_tabmode_enabled', 'tab_always_indent'), ('set_intelligent_backspace_enabled', 'intelligent_backspace'), ('set_highlight_current_line_enabled', 'highlight_current_line'), ('set_highlight_current_cell_enabled', 'highlight_current_cell'), ('set_occurrence_highlighting_enabled', 'occurrence_highlighting'), ('set_occurrence_highlighting_timeout', 'occurrence_highlighting/timeout'), ('set_checkeolchars_enabled', 'check_eol_chars'), ('set_tabbar_visible', 'show_tab_bar'), ('set_always_remove_trailing_spaces', 'always_remove_trailing_spaces'), ) for method, setting in settings: getattr(editorstack, method)(self.get_option(setting)) editorstack.set_help_enabled(CONF.get('help', 'connect/editor')) color_scheme = self.get_color_scheme() editorstack.set_default_font(self.get_plugin_font(), color_scheme) editorstack.starting_long_process.connect(self.starting_long_process) editorstack.ending_long_process.connect(self.ending_long_process) # Redirect signals editorstack.redirect_stdio.connect( lambda state: self.redirect_stdio.emit(state)) editorstack.exec_in_extconsole.connect( lambda text, option: self.exec_in_extconsole.emit(text, option)) editorstack.update_plugin_title.connect( lambda: self.update_plugin_title.emit()) editorstack.editor_focus_changed.connect(self.save_focus_editorstack) editorstack.editor_focus_changed.connect(self.set_editorstack_for_introspection) editorstack.editor_focus_changed.connect(self.main.plugin_focus_changed) editorstack.zoom_in.connect(lambda: self.zoom(1)) editorstack.zoom_out.connect(lambda: self.zoom(-1)) editorstack.zoom_reset.connect(lambda: self.zoom(0)) editorstack.sig_new_file.connect(lambda s: self.new(text=s)) editorstack.sig_new_file[()].connect(self.new) editorstack.sig_close_file.connect(self.close_file_in_all_editorstacks) editorstack.file_saved.connect(self.file_saved_in_editorstack) editorstack.file_renamed_in_data.connect( self.file_renamed_in_data_in_editorstack) editorstack.create_new_window.connect(self.create_new_window) editorstack.opened_files_list_changed.connect( self.opened_files_list_changed) editorstack.analysis_results_changed.connect( self.analysis_results_changed) editorstack.todo_results_changed.connect(self.todo_results_changed) editorstack.update_code_analysis_actions.connect( self.update_code_analysis_actions) editorstack.update_code_analysis_actions.connect( self.update_todo_actions) editorstack.refresh_file_dependent_actions.connect( self.refresh_file_dependent_actions) editorstack.refresh_save_all_action.connect(self.refresh_save_all_action) editorstack.sig_refresh_eol_chars.connect(self.refresh_eol_chars) editorstack.save_breakpoints.connect(self.save_breakpoints) editorstack.text_changed_at.connect(self.text_changed_at) editorstack.current_file_changed.connect(self.current_file_changed) editorstack.plugin_load.connect(self.load) editorstack.plugin_load[()].connect(self.load) editorstack.edit_goto.connect(self.load) editorstack.sig_save_as.connect(self.save_as) editorstack.sig_prev_edit_pos.connect(self.go_to_last_edit_location) editorstack.sig_prev_cursor.connect(self.go_to_previous_cursor_position) editorstack.sig_next_cursor.connect(self.go_to_next_cursor_position) def unregister_editorstack(self, editorstack): """Removing editorstack only if it's not the last remaining""" self.remove_last_focus_editorstack(editorstack) if len(self.editorstacks) > 1: index = self.editorstacks.index(editorstack) self.editorstacks.pop(index) return True else: # editorstack was not removed! return False def clone_editorstack(self, editorstack): editorstack.clone_from(self.editorstacks[0]) for finfo in editorstack.data: self.register_widget_shortcuts(finfo.editor) @Slot(str, str) def close_file_in_all_editorstacks(self, editorstack_id_str, filename): for editorstack in self.editorstacks: if str(id(editorstack)) != editorstack_id_str: editorstack.blockSignals(True) index = editorstack.get_index_from_filename(filename) editorstack.close_file(index, force=True) editorstack.blockSignals(False) @Slot(str, str, str) def file_saved_in_editorstack(self, editorstack_id_str, original_filename, filename): """A file was saved in editorstack, this notifies others""" for editorstack in self.editorstacks: if str(id(editorstack)) != editorstack_id_str: editorstack.file_saved_in_other_editorstack(original_filename, filename) @Slot(str, str, str) def file_renamed_in_data_in_editorstack(self, editorstack_id_str, original_filename, filename): """A file was renamed in data in editorstack, this notifies others""" for editorstack in self.editorstacks: if str(id(editorstack)) != editorstack_id_str: editorstack.rename_in_data(original_filename, filename) def set_editorstack_for_introspection(self): """ Set the current editorstack to be used by the IntrospectionManager instance """ editorstack = self.__get_focus_editorstack() if editorstack is not None: self.introspector.set_editor_widget(editorstack) # Disconnect active signals try: self.introspector.sig_send_to_help.disconnect() self.introspector.sig_edit_goto.disconnect() except TypeError: pass # Reconnect signals again self.introspector.sig_send_to_help.connect(editorstack.send_to_help) self.introspector.sig_edit_goto.connect( lambda fname, lineno, name: editorstack.edit_goto.emit(fname, lineno, name)) #------ Handling editor windows def setup_other_windows(self): """Setup toolbars and menus for 'New window' instances""" self.toolbar_list = ((_("File toolbar"), "file_toolbar", self.main.file_toolbar_actions), (_("Search toolbar"), "search_toolbar", self.main.search_menu_actions), (_("Source toolbar"), "source_toolbar", self.main.source_toolbar_actions), (_("Run toolbar"), "run_toolbar", self.main.run_toolbar_actions), (_("Debug toolbar"), "debug_toolbar", self.main.debug_toolbar_actions), (_("Edit toolbar"), "edit_toolbar", self.main.edit_toolbar_actions)) self.menu_list = ((_("&File"), self.main.file_menu_actions), (_("&Edit"), self.main.edit_menu_actions), (_("&Search"), self.main.search_menu_actions), (_("Sour&ce"), self.main.source_menu_actions), (_("&Run"), self.main.run_menu_actions), (_("&Tools"), self.main.tools_menu_actions), (_("&View"), []), (_("&Help"), self.main.help_menu_actions)) # Create pending new windows: for layout_settings in self.editorwindows_to_be_created: win = self.create_new_window() win.set_layout_settings(layout_settings) def create_new_window(self): oe_options = self.outlineexplorer.get_options() window = EditorMainWindow(self, self.stack_menu_actions, self.toolbar_list, self.menu_list, show_fullpath=oe_options['show_fullpath'], show_all_files=oe_options['show_all_files'], show_comments=oe_options['show_comments']) window.add_toolbars_to_menu("&View", window.get_toolbars()) window.load_toolbars() window.resize(self.size()) window.show() self.register_editorwindow(window) window.destroyed.connect(lambda: self.unregister_editorwindow(window)) return window def register_editorwindow(self, window): self.editorwindows.append(window) def unregister_editorwindow(self, window): self.editorwindows.pop(self.editorwindows.index(window)) #------ Accessors def get_filenames(self): return [finfo.filename for finfo in self.editorstacks[0].data] def get_filename_index(self, filename): return self.editorstacks[0].has_filename(filename) def get_current_editorstack(self, editorwindow=None): if self.editorstacks is not None: if len(self.editorstacks) == 1: editorstack = self.editorstacks[0] else: editorstack = self.__get_focus_editorstack() if editorstack is None or editorwindow is not None: editorstack = self.get_last_focus_editorstack(editorwindow) if editorstack is None: editorstack = self.editorstacks[0] return editorstack def get_current_editor(self): editorstack = self.get_current_editorstack() if editorstack is not None: return editorstack.get_current_editor() def get_current_finfo(self): editorstack = self.get_current_editorstack() if editorstack is not None: return editorstack.get_current_finfo() def get_current_filename(self): editorstack = self.get_current_editorstack() if editorstack is not None: return editorstack.get_current_filename() def is_file_opened(self, filename=None): return self.editorstacks[0].is_file_opened(filename) def set_current_filename(self, filename, editorwindow=None): """Set focus to *filename* if this file has been opened Return the editor instance associated to *filename*""" editorstack = self.get_current_editorstack(editorwindow) return editorstack.set_current_filename(filename) def set_path(self): for finfo in self.editorstacks[0].data: finfo.path = self.main.get_spyder_pythonpath() if self.introspector: self.introspector.change_extra_path( self.main.get_spyder_pythonpath()) #------ FileSwitcher API def get_current_tab_manager(self): """Get the widget with the TabWidget attribute.""" return self.get_current_editorstack() #------ Refresh methods def refresh_file_dependent_actions(self): """Enable/disable file dependent actions (only if dockwidget is visible)""" if self.dockwidget and self.dockwidget.isVisible(): enable = self.get_current_editor() is not None for action in self.file_dependent_actions: action.setEnabled(enable) def refresh_save_all_action(self): """Enable 'Save All' if there are files to be saved""" editorstack = self.get_current_editorstack() if editorstack: state = any(finfo.editor.document().isModified() or finfo.newly_created for finfo in editorstack.data) self.save_all_action.setEnabled(state) def update_warning_menu(self): """Update warning list menu""" editorstack = self.get_current_editorstack() check_results = editorstack.get_analysis_results() self.warning_menu.clear() filename = self.get_current_filename() for message, line_number in check_results: error = 'syntax' in message text = message[:1].upper() + message[1:] icon = ima.icon('error') if error else ima.icon('warning') slot = lambda _checked, _l=line_number: self.load(filename, goto=_l) action = create_action(self, text=text, icon=icon, triggered=slot) self.warning_menu.addAction(action) def analysis_results_changed(self): """ Synchronize analysis results between editorstacks Refresh analysis navigation buttons """ editorstack = self.get_current_editorstack() results = editorstack.get_analysis_results() index = editorstack.get_stack_index() if index != -1: filename = editorstack.data[index].filename for other_editorstack in self.editorstacks: if other_editorstack is not editorstack: other_editorstack.set_analysis_results(filename, results) self.update_code_analysis_actions() def update_todo_menu(self): """Update todo list menu""" editorstack = self.get_current_editorstack() results = editorstack.get_todo_results() self.todo_menu.clear() filename = self.get_current_filename() for text, line0 in results: icon = ima.icon('todo') slot = lambda _checked, _l=line0: self.load(filename, goto=_l) action = create_action(self, text=text, icon=icon, triggered=slot) self.todo_menu.addAction(action) self.update_todo_actions() def todo_results_changed(self): """ Synchronize todo results between editorstacks Refresh todo list navigation buttons """ editorstack = self.get_current_editorstack() results = editorstack.get_todo_results() index = editorstack.get_stack_index() if index != -1: filename = editorstack.data[index].filename for other_editorstack in self.editorstacks: if other_editorstack is not editorstack: other_editorstack.set_todo_results(filename, results) self.update_todo_actions() def refresh_eol_chars(self, os_name): os_name = to_text_string(os_name) self.__set_eol_chars = False if os_name == 'nt': self.win_eol_action.setChecked(True) elif os_name == 'posix': self.linux_eol_action.setChecked(True) else: self.mac_eol_action.setChecked(True) self.__set_eol_chars = True #------ Slots def opened_files_list_changed(self): """ Opened files list has changed: --> open/close file action --> modification ('*' added to title) --> current edited file has changed """ # Refresh Python file dependent actions: editor = self.get_current_editor() if editor: python_enable = editor.is_python() cython_enable = python_enable or ( programs.is_module_installed('Cython') and editor.is_cython()) for action in self.pythonfile_dependent_actions: if action in self.cythonfile_compatible_actions: enable = cython_enable else: enable = python_enable if action is self.winpdb_action: action.setEnabled(enable and WINPDB_PATH is not None) else: action.setEnabled(enable) self.open_file_update.emit(self.get_current_filename()) def update_code_analysis_actions(self): editorstack = self.get_current_editorstack() results = editorstack.get_analysis_results() # Update code analysis buttons state = (self.get_option('code_analysis/pyflakes') \ or self.get_option('code_analysis/pep8')) \ and results is not None and len(results) for action in (self.warning_list_action, self.previous_warning_action, self.next_warning_action): action.setEnabled(state) def update_todo_actions(self): editorstack = self.get_current_editorstack() results = editorstack.get_todo_results() state = self.get_option('todo_list') \ and results is not None and len(results) self.todo_list_action.setEnabled(state) def rehighlight_cells(self): """Rehighlight cells of current editor""" editor = self.get_current_editor() editor.rehighlight_cells() QApplication.processEvents() #------ Breakpoints def save_breakpoints(self, filename, breakpoints): filename = to_text_string(filename) breakpoints = to_text_string(breakpoints) filename = osp.normpath(osp.abspath(filename)) if breakpoints: breakpoints = eval(breakpoints) else: breakpoints = [] save_breakpoints(filename, breakpoints) self.breakpoints_saved.emit() #------ File I/O def __load_temp_file(self): """Load temporary file from a text file in user home directory""" if not osp.isfile(self.TEMPFILE_PATH): # Creating temporary file default = ['# -*- coding: utf-8 -*-', '"""', _("Spyder Editor"), '', _("This is a temporary script file."), '"""', '', ''] text = os.linesep.join([encoding.to_unicode(qstr) for qstr in default]) try: encoding.write(to_text_string(text), self.TEMPFILE_PATH, 'utf-8') except EnvironmentError: self.new() return self.load(self.TEMPFILE_PATH) @Slot() def __set_workdir(self): """Set current script directory as working directory""" fname = self.get_current_filename() if fname is not None: directory = osp.dirname(osp.abspath(fname)) self.open_dir.emit(directory) def __add_recent_file(self, fname): """Add to recent file list""" if fname is None: return if fname in self.recent_files: self.recent_files.remove(fname) self.recent_files.insert(0, fname) if len(self.recent_files) > self.get_option('max_recent_files'): self.recent_files.pop(-1) def _clone_file_everywhere(self, finfo): """Clone file (*src_editor* widget) in all editorstacks Cloning from the first editorstack in which every single new editor is created (when loading or creating a new file)""" for editorstack in self.editorstacks[1:]: editor = editorstack.clone_editor_from(finfo, set_current=False) self.register_widget_shortcuts(editor) @Slot() @Slot(str) def new(self, fname=None, editorstack=None, text=None): """ Create a new file - Untitled fname=None --> fname will be 'untitledXX.py' but do not create file fname=