eric: comparison src/eric7/QScintilla/Editor.py

-:e075c8fe07fd
+:df7edc29cbfb
 Qt,
 QTimer,
 pyqtSignal,
 pyqtSlot,
 )
-from PyQt6.QtGui import QActionGroup, QFont, QPainter, QPalette, QPixmap
+from PyQt6.QtGui import QAction, QActionGroup, QFont, QPainter, QPalette, QPixmap
 from PyQt6.QtPrintSupport import (
 QAbstractPrintDialog,
 QPrintDialog,
 QPrinter,
 QPrintPreviewDialog,
 mouseDoubleClick = pyqtSignal(QPoint, Qt.MouseButton)
 WarningCode = 1
 WarningPython = 2
 WarningStyle = 3
+WarningInfo = 4
+WarningError = 5
 # Autocompletion icon definitions
 ClassID = 1
 ClassProtectedID = 2
 ClassPrivateID = 3
 # bookmarks are just a list of handles to the
 # bookmark markers
 self.syntaxerrors = {}
 # key:   marker handle
 # value: list of (error message, error index)
-self.warnings = {}
+self._warnings = {}
 # key:   marker handle
 # value: list of (warning message, warning type)
 self.notcoveredMarkers = []  # just a list of marker handles
 self.showingNotcoveredMarkers = False
 Preferences.getEditor("MarkOccurrencesTimeout")
 )
 self.__markOccurrencesTimer.timeout.connect(self.__markOccurrences)
 self.__markedText = ""
 self.__searchIndicatorLines = []
+# set the autosave attributes
+self.__autosaveInterval = Preferences.getEditor("AutosaveIntervalSeconds")
+self.__autosaveManuallyDisabled = False
+# initialize the autosave timer
+self.__autosaveTimer = QTimer(self)
+self.__autosaveTimer.setObjectName("AutosaveTimer")
+self.__autosaveTimer.setSingleShot(True)
+self.__autosaveTimer.timeout.connect(self.__autosave)
 # initialize some spellchecking stuff
 self.spell = None
 self.lastLine = 0
 self.lastIndex = 0
 bnd = req.boundedTo(self.vm.size())
 if bnd.width() < req.width() or bnd.height() < req.height():
 self.resize(bnd)
-# set the autosave flag
-self.autosaveEnabled = Preferences.getEditor("AutosaveInterval") > 0
-self.autosaveManuallyDisabled = False
 # code coverage related attributes
 self.__coverageFile = ""
 self.__initContextMenu()
 self.__initContextMenuMargins()
 # it's a clone
 self.__languageChanged(editor.apiLanguage, propagate=False)
 self.__encodingChanged(editor.encoding, propagate=False)
 self.__spellLanguageChanged(editor.getSpellingLanguage(), propagate=False)
 # link the warnings to the original editor
-self.warnings = editor.warnings
+self._warnings = editor._warnings
 self.setAcceptDrops(True)
 # breakpoint handling
 self.breakpointModel = self.dbs.getBreakPointModel()
 self.menuActs["MonospacedFont"].setChecked(self.useMonospaced)
 self.menuActs["AutosaveEnable"] = self.menu.addAction(
 self.tr("Autosave enabled"), self.__autosaveEnable
 )
 self.menuActs["AutosaveEnable"].setCheckable(True)
-self.menuActs["AutosaveEnable"].setChecked(self.autosaveEnabled)
+self.menuActs["AutosaveEnable"].setChecked(self.__autosaveInterval > 0)
 self.menuActs["TypingAidsEnabled"] = self.menu.addAction(
 self.tr("Typing aids enabled"), self.__toggleTypingAids
 )
 self.menuActs["TypingAidsEnabled"].setCheckable(True)
 self.menuActs["TypingAidsEnabled"].setEnabled(self.completer is not None)
 self,
 self.tr("Export source"),
 self.tr("""No export format given. Aborting..."""),
 )
+@pyqtSlot()
 def __showContextMenuLanguages(self):
 """
 Private slot handling the aboutToShow signal of the languages context
 menu.
 """
 self.__docstringGenerator = None
 def __languageChanged(self, language, propagate=True):
 """
-Private slot handling a change of a connected editor's language.
+Private method handling a change of a connected editor's language.
 @param language language to be set (string)
 @param propagate flag indicating to propagate the change (boolean)
 """
 if language == "":
 if act:
 act.setChecked(False)
 else:
 self.supportedLanguages[self.apiLanguage][2].setChecked(True)
+@pyqtSlot()
 def projectLexerAssociationsChanged(self):
 """
 Public slot to handle changes of the project lexer associations.
 """
 self.setLanguage(self.fileName)
+@pyqtSlot()
 def __showContextMenuEncodings(self):
 """
 Private slot handling the aboutToShow signal of the encodings context
 menu.
 """
 Private method to check the selected encoding of the encodings submenu.
 """
 with contextlib.suppress(AttributeError, KeyError):
 (self.supportedEncodings[self.__normalizedEncoding()].setChecked(True))
+@pyqtSlot(str)
 def __encodingChanged(self, encoding, propagate=True):
 """
 Private slot to handle a change of the encoding.
-@param encoding changed encoding (string)
+@param encoding changed encoding
-@param propagate flag indicating to propagate the change (boolean)
+@type str
+@param propagate flag indicating to propagate the change
+@type bool
 """
 self.encoding = encoding
 self.__checkEncoding()
 if not self.inEncodingChanged and propagate:
 encoding.replace("-default", "")
 .replace("-guessed", "")
 .replace("-selected", "")
 )
+@pyqtSlot()
 def __showContextMenuEol(self):
 """
 Private slot handling the aboutToShow signal of the eol context menu.
 """
 self.showMenu.emit("Eol", self.eolMenu, self)
 Private method to check the selected eol type of the eol submenu.
 """
 with contextlib.suppress(AttributeError, TypeError):
 self.supportedEols[self.getLineSeparator()].setChecked(True)
+@pyqtSlot()
 def __eolChanged(self):
 """
 Private slot to handle a change of the eol mode.
 """
 self.__checkEol()
 self.inEolChanged = True
 eol = self.getLineSeparator()
 self.eolChanged.emit(eol)
 self.inEolChanged = False
+@pyqtSlot()
 def __showContextMenuSpellCheck(self):
 """
 Private slot handling the aboutToShow signal of the spell check
 context menu.
 """
 )
 self.menuActs["SpellCheckLanguages"].setEnabled(spellingAvailable)
 self.showMenu.emit("SpellCheck", self.spellCheckMenu, self)
+@pyqtSlot()
 def __showContextMenuSpellLanguages(self):
 """
 Private slot handling the aboutToShow signal of the spell check
 languages context menu.
 """
 """
 language = act.data()
 self.__setSpellingLanguage(language)
 self.spellLanguageChanged.emit(language)
+@pyqtSlot()
 def __checkSpellLanguage(self):
 """
 Private slot to check the selected spell check language action.
 """
 language = self.getSpellingLanguage()
 with contextlib.suppress(AttributeError, KeyError):
 self.supportedSpellLanguages[language].setChecked(True)
+@pyqtSlot(str)
 def __spellLanguageChanged(self, language, propagate=True):
 """
 Private slot to handle a change of the spell check language.
 @param language new spell check language
 self.spellLanguageChanged.emit(language)
 self.__inSpellLanguageChanged = False
 def __bindLexer(self, filename, pyname=""):
 """
-Private slot to set the correct lexer depending on language.
+Private method to set the correct lexer depending on language.
 @param filename filename used to determine the associated lexer
-language (string)
+language
-@param pyname name of the pygments lexer to use (string)
+@type str
+@param pyname name of the pygments lexer to use
+@type str
 """
 if self.lexer_ is not None and (
 self.lexer_.lexer() == "container" or self.lexer_.lexer() is None
 ):
 self.SCN_STYLENEEDED.disconnect(self.__styleNeeded)
 self.__setAnnotationStyles()
 self.lexer_.setDefaultColor(self.lexer_.color(0))
 self.lexer_.setDefaultPaper(self.lexer_.paper(0))
+@pyqtSlot(int)
 def __styleNeeded(self, position):
 """
 Private slot to handle the need for more styling.
-@param position end position, that needs styling (integer)
+@param position end position, that needs styling
+@type int
 """
 self.lexer_.styleText(self.getEndStyled(), position)
 def getLexer(self):
 """
 """
 return self.apiLanguage
 def __bindCompleter(self, filename):
 """
-Private slot to set the correct typing completer depending on language.
+Private method to set the correct typing completer depending on language.
 @param filename filename used to determine the associated typing
-completer language (string)
+completer language
+@type str
 """
 if self.completer is not None:
 self.completer.setEnabled(False)
 self.completer = None
 @return the completer object (CompleterBase)
 """
 return self.completer
+@pyqtSlot(bool)
 def __modificationChanged(self, m):
 """
 Private slot to handle the modificationChanged signal.
 It emits the signal modificationStatusChanged with parameters
 m and self.
 @param m modification status
+@type bool
 """
 if not m and bool(self.fileName) and pathlib.Path(self.fileName).exists():
 self.lastModified = pathlib.Path(self.fileName).stat().st_mtime
 self.modificationStatusChanged.emit(m, self)
 self.undoAvailable.emit(self.isUndoAvailable())
 self.redoAvailable.emit(self.isRedoAvailable())
+if not m:
+self.__autosaveTimer.stop()
+@pyqtSlot(int, int)
 def __cursorPositionChanged(self, line, index):
 """
 Private slot to handle the cursorPositionChanged signal.
 It emits the signal cursorChanged with parameters fileName,
 line and pos.
 @param line line number of the cursor
+@type int
 @param index position in line of the cursor
+@type int
 """
 self.cursorChanged.emit(self.fileName, line + 1, index)
 if Preferences.getEditor("MarkOccurrencesEnabled"):
-self.__markOccurrencesTimer.stop()
 self.__markOccurrencesTimer.start()
 if self.lastLine != line:
 self.cursorLineChanged.emit(line)
 self.__markerMap.update()
 self.lastLine = line
 self.lastIndex = index
+@pyqtSlot()
 def __modificationReadOnly(self):
 """
 Private slot to handle the modificationAttempted signal.
 """
 EricMessageBox.warning(
 @param foldPrev previous fold level (integer)
 @param token ???
 @param annotationLinesAdded number of added/deleted annotation lines
 (integer)
 """
-if (
+if mtype & (self.SC_MOD_INSERTTEXT | self.SC_MOD_DELETETEXT):
-mtype & (self.SC_MOD_INSERTTEXT | self.SC_MOD_DELETETEXT)
+# 1. set/reset the autosave timer
-and linesAdded != 0
+if self.__autosaveInterval > 0:
-and self.breaks
+self.__autosaveTimer.start(self.__autosaveInterval * 1000)
-):
-bps = []  # list of breakpoints
+# 2. move breakpoints if a line was inserted or deleted
-for handle, (ln, cond, temp, enabled, ignorecount) in self.breaks.items():
+if linesAdded != 0 and self.breaks:
-line = self.markerLine(handle) + 1
+bps = []  # list of breakpoints
-if ln != line:
+for handle, (
-bps.append((ln, line))
+ln,
-self.breaks[handle] = (line, cond, temp, enabled, ignorecount)
+cond,
-self.inLinesChanged = True
+temp,
-for ln, line in sorted(bps, reverse=linesAdded > 0):
+enabled,
-index1 = self.breakpointModel.getBreakPointIndex(self.fileName, ln)
+ignorecount,
-index2 = self.breakpointModel.index(index1.row(), 1)
+) in self.breaks.items():
-self.breakpointModel.setData(index2, line)
+line = self.markerLine(handle) + 1
-self.inLinesChanged = False
+if ln != line:
+bps.append((ln, line))
+self.breaks[handle] = (line, cond, temp, enabled, ignorecount)
+self.inLinesChanged = True
+for ln, line in sorted(bps, reverse=linesAdded > 0):
+index1 = self.breakpointModel.getBreakPointIndex(self.fileName, ln)
+index2 = self.breakpointModel.index(index1.row(), 1)
+self.breakpointModel.setData(index2, line)
+self.inLinesChanged = False
 def __restoreBreakpoints(self):
 """
 Private method to restore the breakpoints.
 """
-for handle in list(self.breaks.keys()):
+for handle in self.breaks:
 self.markerDeleteHandle(handle)
 self.__addBreakPoints(QModelIndex(), 0, self.breakpointModel.rowCount() - 1)
 self.__markerMap.update()
+@pyqtSlot(QModelIndex, int, int)
 def __deleteBreakPoints(self, parentIndex, start, end):
 """
 Private slot to delete breakpoints.
-@param parentIndex index of parent item (QModelIndex)
+@param parentIndex index of parent item
-@param start start row (integer)
+@type QModelIndex
-@param end end row (integer)
+@param start start row
+@type int
+@param end end row
+@type int
 """
 for row in range(start, end + 1):
 index = self.breakpointModel.index(row, 0, parentIndex)
 fn, lineno = self.breakpointModel.getBreakPointByIndex(index)[0:2]
 if fn == self.fileName:
 self.clearBreakpoint(lineno)
+@pyqtSlot(QModelIndex, QModelIndex)
 def __changeBreakPoints(self, startIndex, endIndex):
 """
 Private slot to set changed breakpoints.
 @param startIndex start index of the breakpoints being changed
-(QModelIndex)
+@type QModelIndex
 @param endIndex end index of the breakpoints being changed
-(QModelIndex)
+@type QModelIndex
 """
 if not self.inLinesChanged:
 self.__addBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
+@pyqtSlot(QModelIndex, QModelIndex)
 def __breakPointDataAboutToBeChanged(self, startIndex, endIndex):
 """
 Private slot to handle the dataAboutToBeChanged signal of the
 breakpoint model.
-@param startIndex start index of the rows to be changed (QModelIndex)
+@param startIndex start index of the rows to be changed
-@param endIndex end index of the rows to be changed (QModelIndex)
+@type QModelIndex
+@param endIndex end index of the rows to be changed
+@type QModelIndex
 """
 self.__deleteBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
+@pyqtSlot(QModelIndex, int, int)
 def __addBreakPoints(self, parentIndex, start, end):
 """
 Private slot to add breakpoints.
-@param parentIndex index of parent item (QModelIndex)
+@param parentIndex index of parent item
-@param start start row (integer)
+@type QModelIndex
-@param end end row (integer)
+@param start start row
+@type int
+@param end end row
+@type int
 """
 for row in range(start, end + 1):
 index = self.breakpointModel.index(row, 0, parentIndex)
 (
 fn,
 if self.inLinesChanged:
 return
 for handle in self.breaks:
 if self.markerLine(handle) == line - 1:
-break
+del self.breaks[handle]
-else:
+self.markerDeleteHandle(handle)
-# not found, simply ignore it
+self.__markerMap.update()
 return
-del self.breaks[handle]
-self.markerDeleteHandle(handle)
-self.__markerMap.update()
 def newBreakpointWithProperties(self, line, properties):
 """
 Public method to set a new breakpoint and its properties.
 @return flag indicating the presence of breakpoints (boolean)
 """
 return len(self.breaks) > 0
+@pyqtSlot()
 def __menuToggleTemporaryBreakpoint(self):
 """
 Private slot to handle the 'Toggle temporary breakpoint' context menu
 action.
 """
 self.line, index = self.getCursorPosition()
 self.line += 1
 self.__toggleBreakpoint(self.line, 1)
 self.line = -1
+@pyqtSlot()
 def menuToggleBreakpoint(self):
 """
 Public slot to handle the 'Toggle breakpoint' context menu action.
 """
 if self.line < 0:
 self.line, index = self.getCursorPosition()
 self.line += 1
 self.__toggleBreakpoint(self.line)
 self.line = -1
+@pyqtSlot()
 def __menuToggleBreakpointEnabled(self):
 """
 Private slot to handle the 'Enable/Disable breakpoint' context menu
 action.
 """
 self.line, index = self.getCursorPosition()
 self.line += 1
 self.__toggleBreakpointEnabled(self.line)
 self.line = -1
+@pyqtSlot()
 def menuEditBreakpoint(self, line=None):
 """
 Public slot to handle the 'Edit breakpoint' context menu action.
-@param line linenumber of the breakpoint to edit
+@param line line number of the breakpoint to edit
+@type int
 """
 from eric7.Debugger.EditBreakpointDialog import EditBreakpointDialog
 if line is not None:
 self.line = line - 1
 break
 self.line = -1
+@pyqtSlot()
 def menuNextBreakpoint(self):
 """
 Public slot to handle the 'Next breakpoint' context menu action.
 """
 line, index = self.getCursorPosition()
 bpline = self.markerFindNext(0, self.breakpointMask)
 if bpline >= 0:
 self.setCursorPosition(bpline, 0)
 self.ensureLineVisible(bpline)
+@pyqtSlot()
 def menuPreviousBreakpoint(self):
 """
 Public slot to handle the 'Previous breakpoint' context menu action.
 """
 line, index = self.getCursorPosition()
 bpline = self.markerFindPrevious(self.lines() - 1, self.breakpointMask)
 if bpline >= 0:
 self.setCursorPosition(bpline, 0)
 self.ensureLineVisible(bpline)
+@pyqtSlot()
 def __menuClearBreakpoints(self):
 """
 Private slot to handle the 'Clear all breakpoints' context menu action.
 """
 self.__clearBreakpoints(self.fileName)
 def __clearBreakpoints(self, fileName):
 """
-Private slot to clear all breakpoints.
+Private method to clear all breakpoints.
-@param fileName name of the file (string)
+@param fileName name of the file
+@type str
 """
 idxList = []
 for ln, _, _, _, _ in self.breaks.values():
 index = self.breakpointModel.getBreakPointIndex(fileName, ln)
 if index.isValid():
 @return flag indicating the presence of bookmarks (boolean)
 """
 return len(self.bookmarks) > 0
+@pyqtSlot()
 def menuToggleBookmark(self):
 """
 Public slot to handle the 'Toggle bookmark' context menu action.
 """
 if self.line < 0:
 self.line, index = self.getCursorPosition()
 self.line += 1
 self.toggleBookmark(self.line)
 self.line = -1
+@pyqtSlot()
 def nextBookmark(self):
 """
 Public slot to handle the 'Next bookmark' context menu action.
 """
 line, index = self.getCursorPosition()
 bmline = self.markerFindNext(0, 1 << self.bookmark)
 if bmline >= 0:
 self.setCursorPosition(bmline, 0)
 self.ensureLineVisible(bmline)
+@pyqtSlot()
 def previousBookmark(self):
 """
 Public slot to handle the 'Previous bookmark' context menu action.
 """
 line, index = self.getCursorPosition()
 bmline = self.markerFindPrevious(self.lines() - 1, 1 << self.bookmark)
 if bmline >= 0:
 self.setCursorPosition(bmline, 0)
 self.ensureLineVisible(bmline)
+@pyqtSlot()
 def clearBookmarks(self):
 """
 Public slot to handle the 'Clear all bookmarks' context menu action.
 """
 for handle in self.bookmarks:
 ###########################################################################
 ## Printing methods below
 ###########################################################################
+@pyqtSlot()
 def printFile(self):
 """
 Public slot to print the text.
 """
 from .Printer import Printer
 QApplication.processEvents()
 else:
 sb.showMessage(self.tr("Printing aborted"), 2000)
 QApplication.processEvents()
+@pyqtSlot()
 def printPreviewFile(self):
 """
 Public slot to show a print preview of the text.
 """
 from .Printer import Printer
 @return flag indicating the presence of task markers (boolean)
 """
 return self.__hasTaskMarkers
+@pyqtSlot()
 def nextTask(self):
 """
 Public slot to handle the 'Next task' context menu action.
 """
 line, index = self.getCursorPosition()
 taskline = self.markerFindNext(0, 1 << self.taskmarker)
 if taskline >= 0:
 self.setCursorPosition(taskline, 0)
 self.ensureLineVisible(taskline)
+@pyqtSlot()
 def previousTask(self):
 """
 Public slot to handle the 'Previous task' context menu action.
 """
 line, index = self.getCursorPosition()
 taskline = self.markerFindPrevious(self.lines() - 1, 1 << self.taskmarker)
 if taskline >= 0:
 self.setCursorPosition(taskline, 0)
 self.ensureLineVisible(taskline)
+@pyqtSlot()
 def extractTasks(self):
 """
 Public slot to extract all tasks.
 """
 from eric7.Tasks.Task import Task
 painter = QPainter(pixmap)
 painter.fillRect(size - 4, 0, 4, size, Preferences.getEditorColour(key))
 painter.end()
 return pixmap
+@pyqtSlot()
 def __initOnlineChangeTrace(self):
 """
 Private slot to initialize the online change trace.
 """
 self.__hasChangeMarkers = False
 self.__onlineChangeTraceTimer.timeout.connect(
 self.__onlineChangeTraceTimerTimeout
 )
 self.textChanged.connect(self.__resetOnlineChangeTraceTimer)
+@pyqtSlot()
 def __reinitOnlineChangeTrace(self):
 """
 Private slot to re-initialize the online change trace.
 """
 self.__oldText = self.text()
 """
 if Preferences.getEditor("OnlineChangeTrace"):
 self.__onlineChangeTraceTimer.stop()
 self.__onlineChangeTraceTimer.start()
+@pyqtSlot()
 def __onlineChangeTraceTimerTimeout(self):
 """
 Private slot to mark added and changed lines.
 """
 self.__deleteAllChangeMarkers()
 if self.__hasChangeMarkers:
 self.changeMarkersUpdated.emit(self)
 self.__markerMap.update()
+@pyqtSlot()
 def resetOnlineChangeTraceInfo(self):
 """
 Public slot to reset the online change trace info.
 """
 self.__lastSavedText = self.text()
 if self.__hasChangeMarkers:
 self.changeMarkersUpdated.emit(self)
 self.__markerMap.update()
+@pyqtSlot()
 def __deleteAllChangeMarkers(self):
 """
 Private slot to delete all change markers.
 """
 self.markerDeleteAll(self.__changeMarkerUnsaved)
 @return flag indicating the presence of change markers (boolean)
 """
 return self.__hasChangeMarkers
+@pyqtSlot()
 def nextChange(self):
 """
 Public slot to handle the 'Next change' context menu action.
 """
 line, index = self.getCursorPosition()
 changeline = self.markerFindNext(0, self.changeMarkersMask)
 if changeline >= 0:
 self.setCursorPosition(changeline, 0)
 self.ensureLineVisible(changeline)
+@pyqtSlot()
 def previousChange(self):
 """
 Public slot to handle the 'Previous change' context menu action.
 """
 line, index = self.getCursorPosition()
 break
 # Couldn't find the unmodified state
 def readFile(self, fn, createIt=False, encoding=""):
 """
-Public slot to read the text from a file.
+Public method to read the text from a file.
 @param fn filename to read from (string)
 @param createIt flag indicating the creation of a new file, if the
 given one doesn't exist (boolean)
 @param encoding encoding to be used to read the file (string)
 self.extractTasks()
 self.setModified(modified)
 self.lastModified = pathlib.Path(fn).stat().st_mtime
+@pyqtSlot()
 def __convertTabs(self):
 """
 Private slot to convert tabulators to spaces.
 """
 if (
 ok = self.findNextTarget()
 self.endUndoAction()
 def writeFile(self, fn, backup=True):
 """
-Public slot to write the text to a file.
+Public method to write the text to a file.
-@param fn filename to write to (string)
+@param fn filename to write to
-@param backup flag indicating to save a backup (boolean)
+@type str
-@return flag indicating success (boolean)
+@param backup flag indicating to save a backup
+@type bool
+@return flag indicating success
+@rtype bool
 """
 config = self.__loadEditorConfigObject(fn)
 eol = self.__getEditorConfig("EOLMode", nodefault=True, config=config)
 if eol is not None:
 else:
 fn = self.fileName
 self.__loadEditorConfig(fn)
 self.editorAboutToBeSaved.emit(self.fileName)
+if self.__autosaveTimer.isActive():
+self.__autosaveTimer.stop()
 if self.writeFile(fn):
 if saveas:
 self.__clearBreakpoints(self.fileName)
 self.setFileName(fn)
 self.setModified(False)
 )
 return False
 def saveFileAs(self, path=None):
 """
-Public slot to save a file with a new name.
+Public method to save a file with a new name.
-@param path directory to save the file in (string)
+@param path directory to save the file in
-@return tuple of two values (boolean, string) giving a success
+@type str
-indicator and the name of the saved file
+@return tuple containing a success indicator and the name of the saved file
+@rtype tuple of (bool, str)
 """
 return self.saveFile(True, path)
 def __saveDeviceFile(self, saveas=False):
 """
 return False
 def handleRenamed(self, fn):
 """
-Public slot to handle the editorRenamed signal.
+Public method to handle the editorRenamed signal.
 @param fn filename to be set for the editor (string).
 """
 self.__clearBreakpoints(fn)
 self.lastModified = pathlib.Path(fn).stat().st_mtime
 self.vm.setEditorName(self, self.fileName)
 self.__updateReadOnly(True)
+@pyqtSlot(str)
 def fileRenamed(self, fn):
 """
 Public slot to handle the editorRenamed signal.
-@param fn filename to be set for the editor (string).
+@param fn filename to be set for the editor
+@type str.
 """
 self.handleRenamed(fn)
 if not self.inFileRenamed:
 self.inFileRenamed = True
 self.editorRenamed.emit(self.fileName)
 ## Utility methods below
 ###########################################################################
 def ensureVisible(self, line, expand=False):
 """
-Public slot to ensure, that the specified line is visible.
+Public method to ensure, that the specified line is visible.
 @param line line number to make visible
 @type int
 @param expand flag indicating to expand all folds
 @type bool
 QsciScintilla.SC_FOLDACTION_EXPAND,
 )
 def ensureVisibleTop(self, line, expand=False):
 """
-Public slot to ensure, that the specified line is visible at the top
+Public method to ensure, that the specified line is visible at the top
 of the editor.
 @param line line number to make visible
 @type int
 @param expand flag indicating to expand all folds
 def __marginClicked(self, margin, line, modifiers):  # noqa: U100
 """
 Private slot to handle the marginClicked signal.
-@param margin id of the clicked margin (integer)
+@param margin id of the clicked margin
-@param line line number of the click (integer)
+@type int
-@param modifiers keyboard modifiers (Qt.KeyboardModifiers)
+@param line line number of the click
+@type int
+@param modifiers keyboard modifiers
+@type Qt.KeyboardModifiers
 """
 if margin == self.__bmMargin:
 self.toggleBookmark(line + 1)
 elif margin == self.__bpMargin:
 self.__toggleBreakpoint(line + 1)
 if self.markersAtLine(line) & (1 << self.syntaxerror):
 self.__showSyntaxError(line)
 elif self.markersAtLine(line) & (1 << self.warning):
 self.__showWarning(line)
+@pyqtSlot()
 def handleMonospacedEnable(self):
 """
 Public slot to handle the Use Monospaced Font context menu entry.
 """
 if self.menuActs["MonospacedFont"].isChecked():
 self.lexer_.readSubstyles(self)
 self.lexer_.initProperties()
 self.setMonospaced(False)
 self.__setMarginsDisplay()
-def getWordBoundaries(self, line, index, useWordChars=True):
+def getWordBoundaries(self, line, index, useWordChars=True, forCompletion=False):
 """
 Public method to get the word boundaries at a position.
-@param line number of line to look at (int)
+@param line number of line to look at
-@param index position to look at (int)
+@type int
+@param index position to look at
+@type int
 @param useWordChars flag indicating to use the wordCharacters
-method (boolean)
+method (defaults to True)
+@type bool (optional)
+@param forCompletion flag indicating a modification for completions (defaults
+to False)
+@type bool (optional)
 @return tuple with start and end indexes of the word at the position
-(integer, integer)
+@rtype tuple of (int, int)
 """
 wc = self.wordCharacters()
 if wc is None or not useWordChars:
 pattern = r"\b[\w_]+\b"
 else:
 wc = re.sub(r"\w", "", wc)
 pattern = r"\b[\w{0}]+\b".format(re.escape(wc))
+if forCompletion:
+pattern += "=?"
 rx = (
 re.compile(pattern)
 if self.caseSensitive()
 else re.compile(pattern, re.IGNORECASE)
 )
 if start <= index <= end:
 return (start, end)
 return (index, index)
-def getWord(self, line, index, direction=0, useWordChars=True):
+def getWord(self, line, index, direction=0, useWordChars=True, forCompletion=False):
 """
 Public method to get the word at a position.
-@param line number of line to look at (int)
+@param line number of line to look at
-@param index position to look at (int)
+@type int
+@param index position to look at
+@type int
 @param direction direction to look in (0 = whole word, 1 = left,
 2 = right)
+@type int
 @param useWordChars flag indicating to use the wordCharacters
-method (boolean)
+method (defaults to True)
-@return the word at that position (string)
+@type bool (optional)
-"""
+@param forCompletion flag indicating a modification for completions (defaults
-start, end = self.getWordBoundaries(line, index, useWordChars)
+to False)
+@type bool (optional)
+@return the word at that position
+@rtype str
+"""
+start, end = self.getWordBoundaries(
+line, index, useWordChars=useWordChars, forCompletion=forCompletion
+)
 if direction == 1:
 end = index
 elif direction == 2:
 start = index
 if end > start:
 if Preferences.getEditor("CommentColumn0"):
 return line.startswith(commentStr)
 else:
 return line.strip().startswith(commentStr)
+@pyqtSlot()
 def toggleCommentBlock(self):
 """
 Public slot to toggle the comment of a block.
 If the editor contains selected text and the start line is not commented, it
 # 3. uncomment the determined block and reset the cursor position
 self.setSelection(begline, 0, endline, self.lineLength(endline))
 self.uncommentLineOrSelection()
 self.setCursorPosition(line, index - len(commentStr))
+@pyqtSlot()
 def commentLine(self):
 """
 Public slot to comment the current line.
 """
 if self.lexer_ is None or not self.lexer_.canBlockComment():
 lineText = self.text(line)
 pos = len(lineText.replace(lineText.lstrip(" \t"), ""))
 self.insertAt(self.lexer_.commentStr(), line, pos)
 self.endUndoAction()
+@pyqtSlot()
 def uncommentLine(self):
 """
 Public slot to uncomment the current line.
 """
 if self.lexer_ is None or not self.lexer_.canBlockComment():
 pos = len(lineText.replace(lineText.lstrip(" \t"), ""))
 self.setSelection(line, pos, line, pos + len(commentStr))
 self.removeSelectedText()
 self.endUndoAction()
+@pyqtSlot()
 def commentSelection(self):
 """
 Public slot to comment the current selection.
 """
 if self.lexer_ is None or not self.lexer_.canBlockComment():
 # change the selection accordingly
 self.setSelection(lineFrom, 0, endLine + 1, 0)
 self.endUndoAction()
+@pyqtSlot()
 def uncommentSelection(self):
 """
 Public slot to uncomment the current selection.
 """
 if self.lexer_ is None or not self.lexer_.canBlockComment():
 # change the selection accordingly
 self.setSelection(lineFrom, indexFrom, lineTo, indexTo)
 self.endUndoAction()
+@pyqtSlot()
 def commentLineOrSelection(self):
 """
 Public slot to comment the current line or current selection.
 """
 if self.hasSelectedText():
 self.commentSelection()
 else:
 self.commentLine()
+@pyqtSlot()
 def uncommentLineOrSelection(self):
 """
 Public slot to uncomment the current line or current selection.
 """
 if self.hasSelectedText():
 self.uncommentSelection()
 else:
 self.uncommentLine()
+@pyqtSlot()
 def streamCommentLine(self):
 """
 Public slot to stream comment the current line.
 """
 if self.lexer_ is None or not self.lexer_.canStreamComment():
 self.beginUndoAction()
 self.insertAt(commentStr["end"], line, self.lineLength(line))
 self.insertAt(commentStr["start"], line, 0)
 self.endUndoAction()
+@pyqtSlot()
 def streamCommentSelection(self):
 """
 Public slot to comment the current selection.
 """
 if self.lexer_ is None or not self.lexer_.canStreamComment():
 if lineFrom == endLine:
 indexTo += len(commentStr["start"])
 self.setSelection(lineFrom, indexFrom, lineTo, indexTo)
 self.endUndoAction()
+@pyqtSlot()
 def streamCommentLineOrSelection(self):
 """
 Public slot to stream comment the current line or current selection.
 """
 if self.hasSelectedText():
 self.streamCommentSelection()
 else:
 self.streamCommentLine()
+@pyqtSlot()
 def boxCommentLine(self):
 """
 Public slot to box comment the current line.
 """
 if self.lexer_ is None or not self.lexer_.canBoxComment():
 self.insertAt(commentStr["middle"], line, 0)
 self.insertAt(eol, line, 0)
 self.insertAt(commentStr["start"], line, 0)
 self.endUndoAction()
+@pyqtSlot()
 def boxCommentSelection(self):
 """
 Public slot to box comment the current selection.
 """
 if self.lexer_ is None or not self.lexer_.canBoxComment():
 # change the selection accordingly
 self.setSelection(lineFrom, 0, endLine + 3, 0)
 self.endUndoAction()
+@pyqtSlot()
 def boxCommentLineOrSelection(self):
 """
 Public slot to box comment the current line or current selection.
 """
 if self.hasSelectedText():
 indexEnd = indexTo - self.indentationWidth()
 if indexEnd < 0:
 indexEnd = 0
 self.setSelection(lineFrom, indexStart, lineTo, indexEnd)
+@pyqtSlot()
 def indentLineOrSelection(self):
 """
 Public slot to indent the current line or current selection.
 """
 if self.hasSelectedText():
 self.__indentSelection(True)
 else:
 self.__indentLine(True)
+@pyqtSlot()
 def unindentLineOrSelection(self):
 """
 Public slot to unindent the current line or current selection.
 """
 if self.hasSelectedText():
 self.__indentSelection(False)
 else:
 self.__indentLine(False)
+@pyqtSlot()
 def smartIndentLineOrSelection(self):
 """
 Public slot to indent current line smartly.
 """
 if self.hasSelectedText():
 else:
 self.__indentLine(True)
 def gotoLine(self, line, pos=1, firstVisible=False, expand=False):
 """
-Public slot to jump to the beginning of a line.
+Public method to jump to the beginning of a line.
 @param line line number to go to
 @type int
 @param pos position in line to go to
 @type int
 if firstVisible:
 self.ensureVisibleTop(line, expand)
 else:
 self.ensureVisible(line, expand)
+@pyqtSlot()
 def __textChanged(self):
 """
 Private slot to handle a change of the editor text.
 This slot defers the handling to the next time the event loop
 is run in order to ensure, that cursor position has been updated
 by the underlying Scintilla editor.
 """
 QTimer.singleShot(0, self.__saveLastEditPosition)
+@pyqtSlot()
 def __saveLastEditPosition(self):
 """
 Private slot to record the last edit position.
 """
 self.__lastEditPosition = self.getCursorPosition()
 ###########################################################################
 ## Setup methods below
 ###########################################################################
+@pyqtSlot()
 def readSettings(self):
 """
 Public slot to read the settings into our lexer.
 """
 # read the lexer settings and reinit the properties
 # set the calltips function
 self.__setCallTips()
 # set the autosave flags
-self.autosaveEnabled = Preferences.getEditor("AutosaveInterval") > 0
+self.__autosaveInterval = Preferences.getEditor("AutosaveIntervalSeconds")
+if self.__autosaveInterval == 0:
+self.__autosaveTimer.stop()
+else:
+if self.isModified():
+self.__autosaveTimer.start(self.__autosaveInterval * 1000)
 if Preferences.getEditor("MiniContextMenu") != self.miniMenu:
 # regenerate context menu
 self.__initContextMenu()
 else:
 self.menuActs["AutoCompletionEnable"].setChecked(
 self.autoCompletionThreshold() != -1
 )
 self.menuActs["MonospacedFont"].setChecked(self.useMonospaced)
 self.menuActs["AutosaveEnable"].setChecked(
-self.autosaveEnabled and not self.autosaveManuallyDisabled
+self.__autosaveInterval > 0 and not self.__autosaveManuallyDisabled
 )
 # regenerate the margins context menu(s)
 self.__initContextMenuMargins()
 self.setMarginWidth(self.__foldMargin, 0)
 self.setFolding(
 QsciScintilla.FoldStyle.NoFoldStyle.value, self.__foldMargin
 )
+@pyqtSlot()
 def __resizeLinenoMargin(self):
 """
 Private slot to resize the line numbers margin.
 """
 linenoMargin = Preferences.getEditor("LinenoMargin")
 elif autoCompletionSource == QsciScintilla.AutoCompletionSource.AcsAPIs:
 self.setAutoCompletionSource(QsciScintilla.AutoCompletionSource.AcsAPIs)
 else:
 self.setAutoCompletionSource(QsciScintilla.AutoCompletionSource.AcsAll)
+@pyqtSlot()
 def __toggleAutoCompletionEnable(self):
 """
 Private slot to handle the Enable Autocompletion context menu entry.
 """
 if self.menuActs["AutoCompletionEnable"].isChecked():
 #################################################################
 ## Support for autocompletion hook methods
 #################################################################
+@pyqtSlot(int)
 def __charAdded(self, charNumber):
 """
 Private slot called to handle the user entering a character.
-@param charNumber value of the character entered (integer)
+@param charNumber value of the character entered
+@type int
 """
 char = chr(charNumber)
 # update code documentation viewer
 if char == "(" and Preferences.getDocuViewer("ShowInfoOnOpenParenthesis"):
 self.vm.showEditorInfo(self)
 return False
 wseps = self.lexer_.autoCompletionWordSeparators()
 return any(wsep.endswith(ch) for wsep in wseps)
+@pyqtSlot()
 def __autocompletionCancelled(self):
 """
 Private slot to handle the cancellation of an auto-completion list.
 """
 self.__acWatchdog.stop()
 """
 Private method to clear the auto-completions cache.
 """
 self.__acCache.clear()
+@pyqtSlot(int, str)
 def __completionListSelected(self, listId, txt):
 """
 Private slot to handle the selection from the completion list.
-@param listId the ID of the user list (should be 1 or 2) (integer)
+@param listId the ID of the user list (should be 1 or 2)
-@param txt the selected text (string)
+@type int
+@param txt the selected text
+@type str
 """
 # custom completions via plug-ins
 if listId == EditorAutoCompletionListID:
 lst = txt.split()
 if len(lst) > 1:
 self.selectCurrentWord()
 self.removeSelectedText()
 line, col = self.getCursorPosition()
 else:
 line, col = self.getCursorPosition()
-wLeft = self.getWordLeft(line, col)
+wLeft = self.getWord(line, col, 1, forCompletion=True)  # word left
 if not txt.startswith(wLeft):
 self.selectCurrentWord()
 self.removeSelectedText()
 line, col = self.getCursorPosition()
 elif wLeft:
 #################################################################
 ## Methods needed by the code documentation viewer
 #################################################################
+@pyqtSlot()
 def __showCodeInfo(self):
 """
 Private slot to handle the context menu action to show code info.
 """
 self.vm.showEditorInfo(self)
 elif self.__marginNumber(pos.x()) == self.__indicMargin:
 self.indicMarginMenu.popup(self.mapToGlobal(pos))
 elif self.__marginNumber(pos.x()) == self.__foldMargin:
 self.foldMarginMenu.popup(self.mapToGlobal(pos))
+@pyqtSlot()
 def __aboutToShowContextMenu(self):
 """
 Private slot handling the aboutToShow signal of the context menu.
 """
 self.menuActs["Reopen"].setEnabled(
 self.menuActs["Tools"].setEnabled(not self.toolsMenu.isEmpty())
 self.showMenu.emit("Main", self.menu, self)
+@pyqtSlot()
 def __showContextMenuAutocompletion(self):
 """
 Private slot called before the autocompletion menu is shown.
 """
 self.menuActs["acDynamic"].setEnabled(self.canProvideDynamicAutoCompletion())
 self.menuActs["acAPI"].setEnabled(self.acAPI)
 self.menuActs["acAPIDocument"].setEnabled(self.acAPI)
 self.showMenu.emit("Autocompletion", self.autocompletionMenu, self)
+@pyqtSlot()
 def __showContextMenuShow(self):
 """
 Private slot called before the show menu is shown.
 """
 prEnable = False
 )
 self.coverageHideAnnotationMenuAct.setEnabled(len(self.notcoveredMarkers) > 0)
 self.showMenu.emit("Show", self.menuShow, self)
+@pyqtSlot()
 def __showContextMenuGraphics(self):
 """
 Private slot handling the aboutToShow signal of the diagrams context
 menu.
 """
 else:
 self.applicationDiagramMenuAct.setEnabled(False)
 self.showMenu.emit("Graphics", self.graphicsMenu, self)
+@pyqtSlot(QMenu)
 def __showContextMenuMargin(self, menu):
 """
 Private slot handling the aboutToShow signal of the margins context
 menu.
 self.marginMenuActs["ExpandChildren"].setEnabled(isFoldHeader)
 self.marginMenuActs["CollapseChildren"].setEnabled(isFoldHeader)
 if menu is self.indicMarginMenu:
 hasSyntaxErrors = bool(self.syntaxerrors)
-hasWarnings = bool(self.warnings)
+hasWarnings = bool(self._warnings)
 hasNotCoveredMarkers = bool(self.notcoveredMarkers)
 self.marginMenuActs["GotoSyntaxError"].setEnabled(hasSyntaxErrors)
 self.marginMenuActs["ClearSyntaxError"].setEnabled(hasSyntaxErrors)
 if hasSyntaxErrors and self.markersAtLine(self.line) & (
 self.__hasChangeMarkers
 )
 self.showMenu.emit("Margin", menu, self)
+@pyqtSlot()
 def __showContextMenuChecks(self):
 """
 Private slot handling the aboutToShow signal of the checks context
 menu.
 """
 self.showMenu.emit("Checks", self.checksMenu, self)
+@pyqtSlot()
 def __showContextMenuTools(self):
 """
 Private slot handling the aboutToShow signal of the tools context
 menu.
 """
 self.showMenu.emit("Tools", self.toolsMenu, self)
+@pyqtSlot()
 def __showContextMenuFormatting(self):
 """
 Private slot handling the aboutToShow signal of the code formatting context
 menu.
 """
 encoding = act.data()
 self.readFile(self.fileName, encoding=encoding)
 self.__convertTabs()
 self.__checkEncoding()
+@pyqtSlot()
 def __contextSave(self):
 """
 Private slot handling the save context menu entry.
 """
 ok = self.saveFile()
 if ok:
 self.vm.setEditorName(self, self.fileName)
+@pyqtSlot()
 def __contextSaveAs(self):
 """
 Private slot handling the save as context menu entry.
 """
 ok = self.saveFileAs()
 if ok:
 self.vm.setEditorName(self, self.fileName)
+@pyqtSlot()
 def __contextSaveCopy(self):
 """
 Private slot handling the save copy context menu entry.
 """
 self.saveFileCopy()
+@pyqtSlot()
 def __contextClose(self):
 """
 Private slot handling the close context menu entry.
 """
 self.vm.closeEditor(self)
+@pyqtSlot()
 def __newView(self):
 """
 Private slot to create a new view to an open document.
 """
 self.vm.newEditorView(self.fileName, self, self.filetype)
+@pyqtSlot()
 def __newViewNewSplit(self):
 """
 Private slot to create a new view to an open document.
 """
 self.vm.addSplit()
 self.vm.newEditorView(self.fileName, self, self.filetype)
+@pyqtSlot()
 def __selectAll(self):
 """
 Private slot handling the select all context menu action.
 """
 self.selectAll(True)
+@pyqtSlot()
 def __deselectAll(self):
 """
 Private slot handling the deselect all context menu action.
 """
 self.selectAll(False)
+@pyqtSlot()
 def joinLines(self):
 """
 Public slot to join the current line with the next one.
 """
 curLine = self.getCursorPosition()[0]
 self.beginUndoAction()
 self.removeSelectedText()
 self.insertAt(" ", curLine, startIndex)
 self.endUndoAction()
+@pyqtSlot()
 def shortenEmptyLines(self):
 """
 Public slot to compress lines consisting solely of whitespace
 characters.
 """
 while ok:
 self.replaceTarget("")
 ok = self.findNextTarget()
 self.endUndoAction()
+@pyqtSlot()
 def __autosaveEnable(self):
 """
 Private slot handling the autosave enable context menu action.
 """
 if self.menuActs["AutosaveEnable"].isChecked():
-self.autosaveManuallyDisabled = False
+self.__autosaveManuallyDisabled = False
 else:
-self.autosaveManuallyDisabled = True
+self.__autosaveManuallyDisabled = True
-def shouldAutosave(self):
+def __shouldAutosave(self):
 """
-Public slot to check the autosave flags.
+Private method to check the autosave flags.
 @return flag indicating this editor should be saved (boolean)
 """
 return (
 bool(self.fileName)
-and not self.autosaveManuallyDisabled
+and not self.__autosaveManuallyDisabled
 and not self.isReadOnly()
-)
+and self.isModified()
+)
+def __autosave(self):
+"""
+Private slot to save the contents of the editor automatically.
+It is only saved by the autosave timer after an initial save (i.e. it already
+has a name).
+"""
+if self.__shouldAutosave():
+self.saveFile()
 def checkSyntax(self):
 """
 Public method to perform an automatic syntax check of the file.
 """
 fileType,
 self.fileName or "(Unnamed)",
 self.text(),
 )
+@pyqtSlot(str, str)
 def __processSyntaxCheckError(self, fn, msg):
 """
 Private slot to report an error message of a syntax check.
 @param fn filename of the file
 self.toggleWarning(0, 0, True, msg)
 self.updateVerticalScrollBar()
+@pyqtSlot(str, dict)
 def __processSyntaxCheckResult(self, fn, problems):
 """
 Private slot to report the resulting messages of a syntax check.
-@param fn filename of the checked file (str)
+@param fn filename of the checked file
+@type str
 @param problems dictionary with the keys 'error' and 'warnings' which
 hold a list containing details about the error/ warnings
 (file name, line number, column, codestring (only at syntax
-errors), the message) (dict)
+errors), the message)
+@type dict
 """
 # Check if it's the requested file, otherwise ignore signal
 if fn != self.fileName and (bool(self.fileName) or fn != "(Unnamed)"):
 return
 error = problems.get("error")
 if error:
 _fn, lineno, col, code, msg = error
 self.toggleSyntaxError(lineno, col, True, msg)
-warnings = problems.get("py_warnings", [])
+for _fn, lineno, col, _code, msg in problems.get("py_warnings", []):
-for _fn, lineno, col, _code, msg in warnings:
 self.toggleWarning(lineno, col, True, msg, warningType=Editor.WarningPython)
-warnings = problems.get("warnings", [])
+for _fn, lineno, col, _code, msg in problems.get("warnings", []):
-for _fn, lineno, col, _code, msg in warnings:
 self.toggleWarning(lineno, col, True, msg, warningType=Editor.WarningCode)
 self.updateVerticalScrollBar()
+@pyqtSlot()
 def __initOnlineSyntaxCheck(self):
 """
 Private slot to initialize the online syntax check.
 """
 self.__onlineSyntaxCheckTimer = QTimer(self)
 @return flag indicating the presence of coverage markers (boolean)
 """
 return len(self.notcoveredMarkers) > 0
+@pyqtSlot()
 def nextUncovered(self):
 """
 Public slot to handle the 'Next uncovered' context menu action.
 """
 line, index = self.getCursorPosition()
 ucline = self.markerFindNext(0, 1 << self.notcovered)
 if ucline >= 0:
 self.setCursorPosition(ucline, 0)
 self.ensureLineVisible(ucline)
+@pyqtSlot()
 def previousUncovered(self):
 """
 Public slot to handle the 'Previous uncovered' context menu action.
 """
 line, index = self.getCursorPosition()
 ###########################################################################
 ## Syntax error handling methods below
 ###########################################################################
-def toggleSyntaxError(self, line, index, error, msg="", show=False):
+def toggleSyntaxError(self, line, index, setError, msg="", show=False):
 """
 Public method to toggle a syntax error indicator.
-@param line line number of the syntax error (integer)
+@param line line number of the syntax error
-@param index index number of the syntax error (integer)
+@type int
-@param error flag indicating if the error marker should be
+@param index index number of the syntax error
-set or deleted (boolean)
+@type int
-@param msg error message (string)
+@param setError flag indicating if the error marker should be
+set or deleted
+@type bool
+@param msg error message
+@type str
 @param show flag indicating to set the cursor to the error position
-(boolean)
+@type bool
 """
 if line == 0:
 line = 1
 # hack to show a syntax error marker, if line is reported to be 0
-if error:
+line = min(line, self.lines())
+# Limit the line number to the ones we really have to ensure proper display
+# of the error annotation.
+if setError:
 # set a new syntax error marker
 markers = self.markersAtLine(line - 1)
 index += self.indentation(line - 1)
 if not (markers & (1 << self.syntaxerror)):
 handle = self.markerAdd(line - 1, self.syntaxerror)
 self.syntaxerrors[handle] = [(msg, index)]
 self.syntaxerrorToggled.emit(self)
 else:
-for handle in list(self.syntaxerrors.keys()):
+for handle in self.syntaxerrors:
 if (
 self.markerLine(handle) == line - 1
 and (msg, index) not in self.syntaxerrors[handle]
 ):
 self.syntaxerrors[handle].append((msg, index))
 self.markerDeleteHandle(handle)
 self.syntaxerrorToggled.emit(self)
 self.__setAnnotation(line - 1)
 self.__markerMap.update()
-def getSyntaxErrors(self):
-"""
-Public method to retrieve the syntax error markers.
-@return sorted list of all lines containing a syntax error
-(list of integer)
-"""
-selist = []
-for handle in list(self.syntaxerrors.keys()):
-selist.append(self.markerLine(handle) + 1)
-selist.sort()
-return selist
 def getSyntaxErrorLines(self):
 """
 Public method to get the lines containing a syntax error.
 @return flag indicating the presence of syntax errors (boolean)
 """
 return len(self.syntaxerrors) > 0
+@pyqtSlot()
 def gotoSyntaxError(self):
 """
 Public slot to handle the 'Goto syntax error' context menu action.
 """
 seline = self.markerFindNext(0, 1 << self.syntaxerror)
 if self.markerLine(handle) == seline:
 index = self.syntaxerrors[handle][0][1]
 self.setCursorPosition(seline, index)
 self.ensureLineVisible(seline)
+@pyqtSlot()
 def clearSyntaxError(self):
 """
 Public slot to handle the 'Clear all syntax error' context menu action.
 """
 for handle in list(self.syntaxerrors.keys()):
 self.toggleSyntaxError(line, 0, False)
 self.syntaxerrors.clear()
 self.syntaxerrorToggled.emit(self)
+@pyqtSlot()
 def __showSyntaxError(self, line=-1):
 """
 Private slot to handle the 'Show syntax error message'
 context menu action.
-@param line line number to show the syntax error for (integer)
+@param line line number to show the syntax error for
+@type int
 """
 if line == -1:
 line = self.line
-for handle in list(self.syntaxerrors.keys()):
+for handle in self.syntaxerrors:
 if self.markerLine(handle) == line:
 errors = [e[0] for e in self.syntaxerrors[handle]]
 EricMessageBox.critical(
 self, self.tr("Syntax Error"), "\n".join(errors)
 )
 ###########################################################################
 ## Warning handling methods below
 ###########################################################################
 def toggleWarning(
-self, line, col, warning, msg="", warningType=WarningCode  # noqa: U100
+self, line, col, setWarning, msg="", warningType=WarningCode  # noqa: U100
 ):
 """
 Public method to toggle a warning indicator.
 Note: This method is used to set pyflakes and code style warnings.
 @param line line number of the warning
+@type int
 @param col column of the warning
-@param warning flag indicating if the warning marker should be
+@type int
-set or deleted (boolean)
+@param setWarning flag indicating if the warning marker should be
-@param msg warning message (string)
+set or deleted
-@param warningType type of warning message (integer)
+@type bool
+@param msg warning message
+@type str
+@param warningType type of warning message
+@type int
 """
 if line == 0:
 line = 1
 # hack to show a warning marker, if line is reported to be 0
-if warning:
+line = min(line, self.lines())
+# Limit the line number to the ones we really have to ensure proper display
+# of the warning annotation.
+if setWarning:
 # set/amend a new warning marker
 warn = (msg, warningType)
 markers = self.markersAtLine(line - 1)
 if not (markers & (1 << self.warning)):
 handle = self.markerAdd(line - 1, self.warning)
-self.warnings[handle] = [warn]
+self._warnings[handle] = [warn]
 self.syntaxerrorToggled.emit(self)
+# signal is also used for warnings
 else:
-for handle in list(self.warnings.keys()):
+for handle in self._warnings:
 if (
 self.markerLine(handle) == line - 1
-and warn not in self.warnings[handle]
+and warn not in self._warnings[handle]
 ):
-self.warnings[handle].append(warn)
+self._warnings[handle].append(warn)
 else:
-for handle in list(self.warnings.keys()):
+for handle in list(self._warnings.keys()):
 if self.markerLine(handle) == line - 1:
-del self.warnings[handle]
+del self._warnings[handle]
 self.markerDeleteHandle(handle)
 self.syntaxerrorToggled.emit(self)
+# signal is also used for warnings
 self.__setAnnotation(line - 1)
 self.__markerMap.update()
-def getWarnings(self):
-"""
-Public method to retrieve the warning markers.
-@return sorted list of all lines containing a warning
-(list of integer)
-"""
-fwlist = []
-for handle in list(self.warnings.keys()):
-fwlist.append(self.markerLine(handle) + 1)
-fwlist.sort()
-return fwlist
 def getWarningLines(self):
 """
 Public method to get the lines containing a warning.
 """
 Public method to check for the presence of warnings.
 @return flag indicating the presence of warnings (boolean)
 """
-return len(self.warnings) > 0
+return len(self._warnings) > 0
+@pyqtSlot()
 def nextWarning(self):
 """
 Public slot to handle the 'Next warning' context menu action.
 """
 line, index = self.getCursorPosition()
 fwline = self.markerFindNext(0, 1 << self.warning)
 if fwline >= 0:
 self.setCursorPosition(fwline, 0)
 self.ensureLineVisible(fwline)
+@pyqtSlot()
 def previousWarning(self):
 """
 Public slot to handle the 'Previous warning' context menu action.
 """
 line, index = self.getCursorPosition()
 fwline = self.markerFindPrevious(self.lines() - 1, 1 << self.warning)
 if fwline >= 0:
 self.setCursorPosition(fwline, 0)
 self.ensureLineVisible(fwline)
+@pyqtSlot()
 def clearFlakesWarnings(self):
 """
 Public slot to clear all pyflakes warnings.
 """
 self.__clearTypedWarning(Editor.WarningCode)
 self.__clearTypedWarning(Editor.WarningPython)
+@pyqtSlot()
 def clearStyleWarnings(self):
 """
 Public slot to clear all style warnings.
 """
 self.__clearTypedWarning(Editor.WarningStyle)
+@pyqtSlot()
+def clearInfoWarnings(self):
+"""
+Public slot to clear all info warnings.
+"""
+self.__clearTypedWarning(Editor.WarningInfo)
+@pyqtSlot()
+def clearErrorWarnings(self):
+"""
+Public slot to clear all error warnings.
+"""
+self.__clearTypedWarning(Editor.WarningError)
+@pyqtSlot()
+def clearCodeWarnings(self):
+"""
+Public slot to clear all code warnings.
+"""
+self.__clearTypedWarning(Editor.WarningCode)
 def __clearTypedWarning(self, warningKind):
 """
 Private method to clear warnings of a specific kind.
 @param warningKind kind of warning to clear (Editor.WarningCode,
 Editor.WarningPython, Editor.WarningStyle)
 """
-for handle in list(self.warnings.keys()):
+for handle in list(self._warnings.keys()):
-warnings = []
+issues = []
-for msg, warningType in self.warnings[handle]:
+for msg, warningType in self._warnings[handle]:
 if warningType == warningKind:
 continue
-warnings.append((msg, warningType))
+issues.append((msg, warningType))
-if warnings:
+if issues:
-self.warnings[handle] = warnings
+self._warnings[handle] = issues
 self.__setAnnotation(self.markerLine(handle))
 else:
-del self.warnings[handle]
+del self._warnings[handle]
 self.__setAnnotation(self.markerLine(handle))
 self.markerDeleteHandle(handle)
 self.syntaxerrorToggled.emit(self)
 self.__markerMap.update()
+@pyqtSlot()
 def clearWarnings(self):
 """
 Public slot to clear all warnings.
 """
-for handle in self.warnings:
+for handle in self._warnings:
-self.warnings[handle] = []
+self._warnings[handle] = []
 self.__setAnnotation(self.markerLine(handle))
 self.markerDeleteHandle(handle)
-self.warnings.clear()
+self._warnings.clear()
 self.syntaxerrorToggled.emit(self)
 self.__markerMap.update()
+@pyqtSlot()
 def __showWarning(self, line=-1):
 """
 Private slot to handle the 'Show warning' context menu action.
-@param line line number to show the warning for (integer)
+@param line line number to show the warning for
+@type int
 """
 if line == -1:
 line = self.line
-for handle in list(self.warnings.keys()):
+for handle in self._warnings:
 if self.markerLine(handle) == line:
 EricMessageBox.warning(
 self,
 self.tr("Warning"),
-"\n".join([w[0] for w in self.warnings[handle]]),
+"\n".join([w[0] for w in self._warnings[handle]]),
 )
 break
 else:
 EricMessageBox.warning(
 self, self.tr("Warning"), self.tr("No warning messages available.")
 ###########################################################################
 ## Annotation handling methods below
 ###########################################################################
+@pyqtSlot()
 def __setAnnotationStyles(self):
 """
 Private slot to define the style used by inline annotations.
 """
 if hasattr(QsciScintilla, "annotate"):
 QsciScintilla.SCI_STYLESETBACK,
 self.annotationStyleStyle,
 Preferences.getEditorColour("AnnotationsStyleBackground"),
 )
+self.annotationInfoStyle = self.annotationStyleStyle + 1
+self.SendScintilla(
+QsciScintilla.SCI_STYLESETFORE,
+self.annotationInfoStyle,
+Preferences.getEditorColour("AnnotationsInfoForeground"),
+)
+self.SendScintilla(
+QsciScintilla.SCI_STYLESETBACK,
+self.annotationInfoStyle,
+Preferences.getEditorColour("AnnotationsInfoBackground"),
+)
 def __setAnnotation(self, line):
 """
 Private method to set the annotations for the given line.
 @param line number of the line that needs annotation (integer)
 """
 if hasattr(QsciScintilla, "annotate"):
 warningAnnotations = []
 errorAnnotations = []
 styleAnnotations = []
+infoAnnotations = []
 # step 1: do warnings
-for handle in self.warnings:
+for handle in self._warnings:
 if self.markerLine(handle) == line:
-for msg, warningType in self.warnings[handle]:
+for msg, warningType in self._warnings[handle]:
-if warningType == Editor.WarningStyle:
+if warningType == Editor.WarningInfo:
+infoAnnotations.append(self.tr("Info: {0}").format(msg))
+elif warningType == Editor.WarningError:
+errorAnnotations.append(self.tr("Error: {0}").format(msg))
+elif warningType == Editor.WarningStyle:
 styleAnnotations.append(self.tr("Style: {0}").format(msg))
 elif warningType == Editor.WarningPython:
 warningAnnotations.append(msg)
 else:
 warningAnnotations.append(
 for handle in self.syntaxerrors:
 if self.markerLine(handle) == line:
 for msg, _ in self.syntaxerrors[handle]:
 errorAnnotations.append(self.tr("Error: {0}").format(msg))
+# step 3: assemble the annotation
 annotations = []
+if infoAnnotations:
+annotationInfoTxt = "\n".join(infoAnnotations)
+if styleAnnotations or warningAnnotations or errorAnnotations:
+annotationInfoTxt += "\n"
+annotations.append(
+QsciStyledText(annotationInfoTxt, self.annotationInfoStyle)
+)
 if styleAnnotations:
 annotationStyleTxt = "\n".join(styleAnnotations)
 if warningAnnotations or errorAnnotations:
 annotationStyleTxt += "\n"
 annotations.append(
 """
 Private method to refresh the annotations.
 """
 if hasattr(QsciScintilla, "annotate"):
 self.clearAnnotations()
-for handle in list(self.warnings.keys()) + list(self.syntaxerrors.keys()):
+for handle in self._warnings:
+line = self.markerLine(handle)
+self.__setAnnotation(line)
+for handle in self.syntaxerrors:
 line = self.markerLine(handle)
 self.__setAnnotation(line)
 #################################################################
 ## Fold handling methods
 #################################################################
+@pyqtSlot()
 def toggleCurrentFold(self):
 """
 Public slot to toggle the fold containing the current line.
 """
 line, index = self.getCursorPosition()
 self.foldLine(line)
 def expandFoldWithChildren(self, line=-1):
 """
-Public slot to expand the current fold including its children.
+Public method to expand the current fold including its children.
 @param line number of line to be expanded
 @type int
 """
 if line == -1:
 QsciScintilla.SCI_FOLDCHILDREN, line, QsciScintilla.SC_FOLDACTION_EXPAND
 )
 def collapseFoldWithChildren(self, line=-1):
 """
-Public slot to collapse the current fold including its children.
+Public method to collapse the current fold including its children.
 @param line number of line to be expanded
 @type int
 """
 if line == -1:
 self.SendScintilla(
 QsciScintilla.SCI_FOLDCHILDREN, line, QsciScintilla.SC_FOLDACTION_CONTRACT
 )
+@pyqtSlot()
 def __contextMenuExpandFoldWithChildren(self):
 """
 Private slot to handle the context menu expand with children action.
 """
 self.expandFoldWithChildren(self.line)
+@pyqtSlot()
 def __contextMenuCollapseFoldWithChildren(self):
 """
 Private slot to handle the context menu collapse with children action.
 """
 self.collapseFoldWithChildren(self.line)
 @return Tuple of macro name and a flag, indicating, if the user
 pressed ok or canceled the operation. (string, boolean)
 """
 qs = []
-for s in list(self.macros.keys()):
+for s in self.macros:
 qs.append(s)
 qs.sort()
 return QInputDialog.getItem(
 self, self.tr("Macro Name"), self.tr("Select a macro name:"), qs, 0, False
 )
 Protected method called when the editor loses focus.
 @param event the event object
 @type QFocusEvent
 """
+if Preferences.getEditor("AutosaveOnFocusLost") and self.__shouldAutosave():
+self.saveFile()
 self.vm.editorActGrp.setEnabled(False)
 self.setCaretWidth(0)
 self.cancelCallTips()
 """
 return (
 self.isLocalFile() and not os.access(self.fileName, os.W_OK)
 ) or self.isReadOnly()
+@pyqtSlot()
 def refresh(self):
 """
 Public slot to refresh the editor contents.
 """
 # save cursor position
 # clear flakes warning markers
 self.clearWarnings()
 # clear breakpoint markers
-for handle in list(self.breaks.keys()):
+for handle in self.breaks:
 self.markerDeleteHandle(handle)
 self.breaks.clear()
 if not os.path.exists(self.fileName):
 # close the file, if it was deleted in the background
 menu.aboutToShow.connect(self.__showContextMenuResources)
 return menu
+@pyqtSlot()
 def __showContextMenuResources(self):
 """
 Private slot handling the aboutToShow signal of the resources context
 menu.
 """
 self.applicationDiagram = UMLDialog(
 UMLDialogType.APPLICATION_DIAGRAM, self.project, self, noModules=not res
 )
 self.applicationDiagram.show()
+@pyqtSlot()
 def __loadDiagram(self):
 """
 Private slot to load a diagram from file.
 """
 from eric7.Graphics.UMLDialog import UMLDialog, UMLDialogType
 #######################################################################
 ## Typing aids related methods below
 #######################################################################
+@pyqtSlot()
 def __toggleTypingAids(self):
 """
 Private slot to toggle the typing aids.
 """
 if self.menuActs["TypingAidsEnabled"].isChecked():
 #######################################################################
 ## Project related methods
 #######################################################################
+@pyqtSlot()
 def __projectPropertiesChanged(self):
 """
 Private slot to handle changes of the project properties.
 """
 if self.spell:
 self.project.getProjectSpellLanguage(), pwl=pwl, pel=pel
 )
 self.project.projectPropertiesChanged.connect(self.__projectPropertiesChanged)
+@pyqtSlot()
 def projectOpened(self):
 """
 Public slot to handle the opening of a project.
 """
 if self.fileName and self.project.isProjectCategory(self.fileName, "SOURCES"):
 self.project.projectPropertiesChanged.connect(
 self.__projectPropertiesChanged
 )
 self.setSpellingForProject()
+@pyqtSlot()
 def projectClosed(self):
 """
 Public slot to handle the closing of a project.
 """
 with contextlib.suppress(TypeError):
 return ""
 def __setSpellingLanguage(self, language, pwl="", pel=""):
 """
-Private slot to set the spell checking language.
+Private method to set the spell checking language.
 @param language spell checking language to be set (string)
 @param pwl name of the personal/project word list (string)
 @param pel name of the personal/project exclude list (string)
 """
 @pyqtSlot(int)
 def __spellCharAdded(self, charNumber):
 """
 Private slot called to handle the user entering a character.
-@param charNumber value of the character entered (integer)
+@param charNumber value of the character entered
+@type int
 """
 if self.spell:
 if not chr(charNumber).isalnum():
 self.spell.checkWord(self.positionBefore(self.currentPosition()), True)
 elif self.hasIndicator(self.spellingIndicator, self.currentPosition()):
 self.spell.checkWord(self.currentPosition())
+@pyqtSlot()
 def checkSpelling(self):
 """
 Public slot to perform an interactive spell check of the document.
 """
 from .SpellCheckingDialog import SpellCheckingDialog
 dlg.exec()
 self.setCursorPosition(cline, cindex)
 if Preferences.getEditor("AutoSpellCheckingEnabled"):
 self.spell.checkDocumentIncrementally()
+@pyqtSlot()
 def __checkSpellingSelection(self):
 """
 Private slot to spell check the current selection.
 """
 from .SpellCheckingDialog import SpellCheckingDialog
 startPos = self.positionFromLineIndex(sline, sindex)
 endPos = self.positionFromLineIndex(eline, eindex)
 dlg = SpellCheckingDialog(self.spell, startPos, endPos, self)
 dlg.exec()
+@pyqtSlot()
 def __checkSpellingWord(self):
 """
 Private slot to check the word below the spelling context menu.
 """
 from .SpellCheckingDialog import SpellCheckingDialog
 wordStartPos = self.positionFromLineIndex(line, wordStart)
 wordEndPos = self.positionFromLineIndex(line, wordEnd)
 dlg = SpellCheckingDialog(self.spell, wordStartPos, wordEndPos, self)
 dlg.exec()
+@pyqtSlot()
 def __showContextMenuSpelling(self):
 """
 Private slot to set up the spelling menu before it is shown.
 """
 self.spellingMenu.clear()
 )
 self.spellingMenu.addAction(self.tr("Ignore All"), self.__ignoreSpellingAlways)
 self.showMenu.emit("Spelling", self.spellingMenu, self)
+@pyqtSlot(QAction)
 def __contextMenuSpellingTriggered(self, action):
 """
 Private slot to handle the selection of a suggestion of the spelling
 context menu.
-@param action reference to the action that was selected (QAction)
+@param action reference to the action that was selected
+@type QAction
 """
 if action in self.spellingSuggActs:
 replacement = action.text()
 line, index = self.lineIndexFromPosition(self.spellingMenuPos)
 wordStart, wordEnd = self.getWordBoundaries(line, index)
 self.beginUndoAction()
 self.removeSelectedText()
 self.insert(replacement)
 self.endUndoAction()
+@pyqtSlot()
 def __addToSpellingDictionary(self):
 """
 Private slot to add the word below the spelling context menu to the
 dictionary.
 """
 wordStart, wordEnd = self.getWordBoundaries(line, index)
 self.clearIndicator(self.spellingIndicator, line, wordStart, line, wordEnd)
 if Preferences.getEditor("AutoSpellCheckingEnabled"):
 self.spell.checkDocumentIncrementally()
+@pyqtSlot()
 def __removeFromSpellingDictionary(self):
 """
 Private slot to remove the word below the context menu to the
 dictionary.
 """
 self.__inRemoteSharedEdit,
 )
 def shareConnected(self, connected):
 """
-Public slot to handle a change of the connected state.
+Public method to handle a change of the connected state.
 @param connected flag indicating the connected state (boolean)
 """
 if not connected:
 self.__inRemoteSharedEdit = False
 self.__isSyncing = False
 self.__receivedWhileSyncing = []
 def shareEditor(self, share):
 """
-Public slot to set the shared status of the editor.
+Public method to set the shared status of the editor.
 @param share flag indicating the share status (boolean)
 """
 self.__isShared = share
 if not share:
 self.shareConnected(False)
+@pyqtSlot()
 def startSharedEdit(self):
 """
 Public slot to start a shared edit session for the editor.
 """
 self.__inSharedEdit = True
 ).toHex(),
 encoding="utf-8",
 )
 self.__send(Editor.StartEditToken, hashStr)
+@pyqtSlot()
 def sendSharedEdit(self):
 """
 Public slot to end a shared edit session for the editor and
 send the changes.
 """
 self.__inSharedEdit = False
 self.__savedText = ""
 def cancelSharedEdit(self, send=True):
 """
-Public slot to cancel a shared edit session for the editor.
+Public method to cancel a shared edit session for the editor.
 @param send flag indicating to send the CancelEdit command (boolean)
 """
 self.__inSharedEdit = False
 self.__savedText = ""
 elif token == Editor.CancelEditToken:
 msg = "{0}{1}c".format(token, Editor.Separator)
 self.vm.send(self.fileName, msg)
+@pyqtSlot(str)
 def receive(self, command):
 """
 Public slot to handle received editor commands.
-@param command command string (string)
+@param command command string
+@type str
 """
 if self.__isShared:
 if self.__isSyncing and not command.startswith(
 Editor.SyncToken + Editor.Separator
 ):
 elif token == Editor.RequestSyncToken:
 self.__processRequestSyncCommand(argsString)
 elif token == Editor.SyncToken:
 self.__processSyncCommand(argsString)
+@pyqtSlot(str)
 def __processStartEditCommand(self, argsString):
 """
 Private slot to process a remote StartEdit command.
-@param argsString string containing the command parameters (string)
+@param argsString string containing the command parameters
+@type str
 """
 if not self.__inSharedEdit and not self.__inRemoteSharedEdit:
 self.__inRemoteSharedEdit = True
 self.setReadOnly(True)
 self.__updateReadOnly()
 commands.append(formatStr.format("r", j1, i2 - i1, j2 - j1))
 commands.extend(newL[j1:j2])
 return "\n".join(commands) + "\n"
+@pyqtSlot(str)
 def __processEndEditCommand(self, argsString):
 """
 Private slot to process a remote EndEdit command.
-@param argsString string containing the command parameters (string)
+@param argsString string containing the command parameters
+@type str
 """
 commands = argsString.splitlines()
 sep = self.getLineSeparator()
 cur = self.getCursorPosition()
 self.__updateReadOnly()
 self.__inRemoteSharedEdit = False
 self.setCursorPosition(*cur)
+@pyqtSlot(str)
 def __processRequestSyncCommand(self, argsString):
 """
 Private slot to process a remote RequestSync command.
-@param argsString string containing the command parameters (string)
+@param argsString string containing the command parameters
+@type str
 """
 if self.__inSharedEdit:
 hashStr = str(
 QCryptographicHash.hash(
 Utilities.encode(self.__savedText, self.encoding)[0],
 )
 if hashStr == argsString:
 self.__send(Editor.SyncToken, self.__savedText)
+@pyqtSlot(str)
 def __processSyncCommand(self, argsString):
 """
 Private slot to process a remote Sync command.
-@param argsString string containing the command parameters (string)
+@param argsString string containing the command parameters
+@type str
 """
 if self.__isSyncing:
 cur = self.getCursorPosition()
 self.setReadOnly(False)
 #######################################################################
 ## Special search related methods
 #######################################################################
+@pyqtSlot()
 def searchCurrentWordForward(self):
 """
 Public slot to search the current word forward.
 """
 self.__searchCurrentWord(forward=True)
+@pyqtSlot()
 def searchCurrentWordBackward(self):
 """
 Public slot to search the current word backward.
 """
 self.__searchCurrentWord(forward=False)
 #######################################################################
 ## Sort related methods
 #######################################################################
+@pyqtSlot()
 def sortLines(self):
 """
 Public slot to sort the lines spanned by a rectangular selection.
 """
 from .SortOptionsDialog import SortOptionsDialog
 a plug-in.
 @param name name of the plug-in
 @type str
 """
-keys = []
+for key in list(self.__mouseClickHandlers.keys()):
-for key in self.__mouseClickHandlers:
 if self.__mouseClickHandlers[key][0] == name:
-keys.append(key)
+del self.__mouseClickHandlers[key]
-for key in keys:
-del self.__mouseClickHandlers[key]
 def gotoReferenceHandler(self, referencesList):
 """
 Public method to handle a list of references to perform a goto.
 #######################################################################
 ## Methods implementing a Shell interface
 #######################################################################
+@pyqtSlot()
 def __executeSelection(self):
 """
 Private slot to execute the selected text in the shell window.
 """
 txt = self.selectedText()
 300, lambda: self.__popupDocstringMenu(lineText2Cursor, cursorPosition)
 )
 def __popupDocstringMenu(self, lastLineText, lastCursorPosition):
 """
-Private slot to pop up a menu asking the user, if a docstring should be
+Private method to pop up a menu asking the user, if a docstring should be
 inserted.
 @param lastLineText line contents when the delay timer was started
 @type str
 @param lastCursorPosition position of the cursor when the delay timer
 was started (line and index)
 @type tuple of (int, int)
 """
+from .DocstringGenerator.BaseDocstringGenerator import DocstringMenuForEnterOnly
 cursorPosition = self.getCursorPosition()
 if lastCursorPosition != cursorPosition:
 return
 if self.text(cursorPosition[0])[: cursorPosition[1]] != lastLineText:
 return
 generator = self.getDocstringGenerator()
 if generator.hasFunctionDefinition(cursorPosition):
-from .DocstringGenerator.BaseDocstringGenerator import (  # __IGNORE_WARNING__
-DocstringMenuForEnterOnly,
-)
 docstringMenu = DocstringMenuForEnterOnly(self)
 act = docstringMenu.addAction(
 EricPixmapCache.getIcon("fileText"),
 self.tr("Generate Docstring"),
 lambda: generator.insertDocstring(cursorPosition, fromStart=False),
 else:
 self.__cancelMouseHoverHelp()
 else:
 self.__cancelMouseHoverHelp()
+@pyqtSlot()
 def __cancelMouseHoverHelp(self):
 """
 Private slot cancelling the display of mouse hover help.
 """
 if self.__showingMouseHoverHelp:

Mercurial Repositories > eric / file comparison

comparison: src/eric7/QScintilla/Editor.py

src/eric7/QScintilla/Editor.py