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

-:411df92e881f
+:3b34efa2857c
 # -*- coding: utf-8 -*-
-# Copyright (c) 2002 - 2023 Detlev Offenbach <detlev@die-offenbachs.de>
+# Copyright (c) 2002 - 2024 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the editor component of the eric IDE.
 """
 from eric7.EricGui.EricOverrideCursor import EricOverrideCursor
 from eric7.EricUtilities.EricCache import EricCache
 from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
 from eric7.Globals import recentNameBreakpointConditions
-from eric7.SystemUtilities import OSUtilities, PythonUtilities
+from eric7.SystemUtilities import FileSystemUtilities, OSUtilities, PythonUtilities
 from eric7.UI import PythonDisViewer
 from eric7.Utilities import MouseUtilities
 from . import Exporters, Lexers, TypingCompleters
 from .EditorMarkerMap import EditorMarkerMap
 lastEditPositionAvailable = pyqtSignal()
 refreshed = pyqtSignal()
 settingsRead = pyqtSignal()
 mouseDoubleClick = pyqtSignal(QPoint, Qt.MouseButton)
+# TODO: convert to an enum.Enum
 WarningCode = 1
 WarningPython = 2
 WarningStyle = 3
 WarningInfo = 4
 WarningError = 5
+# TODO: convert to an enum.IntEnum (also in Assistant plugin)
 # Autocompletion icon definitions
 ClassID = 1
 ClassProtectedID = 2
 ClassPrivateID = 3
 MethodID = 4
 if editor is None:
 if self.fileName:
 if not Utilities.MimeTypes.isTextFile(self.fileName):
 raise OSError()
-if self.isLocalFile() and pathlib.Path(self.fileName).exists():
+if (
+FileSystemUtilities.isPlainFileName(self.fileName)
+and pathlib.Path(self.fileName).exists()
+):
 fileSizeKB = pathlib.Path(self.fileName).stat().st_size // 1024
 if fileSizeKB > Preferences.getEditor("RejectFilesize"):
 EricMessageBox.warning(
 None,
 self.tr("Open File"),
 @param name name of the current file
 @type str
 """
 renamed = self.fileName != name
+oldFileName = self.fileName
 self.fileName = name
 if renamed:
 self.vm.setEditorName(self, self.fileName)
+self.vm.removeWatchedFilePath(oldFileName)
+self.vm.addWatchedFilePath(self.fileName)
 if self.fileName:
 self.__fileNameExtension = os.path.splitext(self.fileName)[1][1:].lower()
 else:
 self.__fileNameExtension = ""
-def isLocalFile(self):
-"""
-Public method to check, if the editor contains a local file.
-@return flag indicating a local file
-@rtype bool
-"""
-return not self.fileName.startswith(("device:", "remote:"))
-def isDeviceFile(self):
-"""
-Public method to check, if the editor contains a MCU device file.
-@return flag indicating a MCU device file
-@rtype bool
-"""
-return self.fileName.startswith("device:")
-def isRemoteFile(self):
-"""
-Public method to check, if the editor contains a remote file.
-@return flag indicating a remote file
-@rtype bool
-"""
-return self.fileName.startswith("remote:")
 def __registerImages(self):
 """
 Private method to register images for autocompletion lists.
 """
 def __bindName(self, line0):
 """
 Private method to generate a dummy filename for binding a lexer.
 @param line0 first line of text to use in the generation process
-(string)
+@type str
-@return dummy file name to be used for binding a lexer (string)
+@return dummy file name to be used for binding a lexer
+@rtype str
 """
 bindName = ""
 line0 = line0.lower()
 # check first line if it does not start with #!
 def getMenu(self, menuName):
 """
 Public method to get a reference to the main context menu or a submenu.
-@param menuName name of the menu (string)
+@param menuName name of the menu
-@return reference to the requested menu (QMenu) or None
+@type str
+@return reference to the requested menu or None
+@rtype QMenu
 """
 try:
 return self.__menus[menuName]
 except KeyError:
 return None
 def hasMiniMenu(self):
 """
 Public method to check the miniMenu flag.
-@return flag indicating a minimized context menu (boolean)
+@return flag indicating a minimized context menu
+@rtype bool
 """
 return self.miniMenu
 def __initContextMenu(self):
 """
 self.languagesActGrp.addAction(self.noLanguageAct)
 menu.addSeparator()
 self.supportedLanguages = {}
 supportedLanguages = Lexers.getSupportedLanguages()
-languages = sorted(supportedLanguages.keys())
+for language in sorted(supportedLanguages):
-for language in languages:
 if language != "Guessed":
 self.supportedLanguages[language] = supportedLanguages[language][:2]
 act = menu.addAction(
 EricPixmapCache.getIcon(supportedLanguages[language][2]),
 self.supportedLanguages[language][0],
 def exportFile(self, exporterFormat):
 """
 Public method to export the file.
-@param exporterFormat format the file should be exported into (string)
+@param exporterFormat format the file should be exported into
+@type str
 """
 if exporterFormat:
 exporter = Exporters.getExporter(exporterFormat, self)
 if exporter:
 exporter.exportSource()
 def __selectPygmentsLexer(self):
 """
 Private method to select a specific pygments lexer.
-@return name of the selected pygments lexer (string)
+@return name of the selected pygments lexer
+@rtype str
 """
 from pygments.lexers import get_all_lexers  # __IGNORE_WARNING_I102__
 lexerList = sorted(lex[0] for lex in get_all_lexers())
 try:
 def __languageMenuTriggered(self, act):
 """
 Private method to handle the selection of a lexer language.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 if act == self.noLanguageAct:
 self.__resetLanguage()
 elif act == self.pygmentsAct:
 self.setLanguage("dummy.pygments")
 def __languageChanged(self, language, propagate=True):
 """
 Private method handling a change of a connected editor's language.
-@param language language to be set (string)
+@param language language to be set
-@param propagate flag indicating to propagate the change (boolean)
+@type str
+@param propagate flag indicating to propagate the change
+@type bool
 """
 if language == "":
 self.__resetLanguage(propagate=propagate)
 elif language == "Guessed":
 self.setLanguage("dummy.pygments", propagate=propagate)
 def __resetLanguage(self, propagate=True):
 """
 Private method used to reset the language selection.
-@param propagate flag indicating to propagate the change (boolean)
+@param propagate flag indicating to propagate the change
+@type bool
 """
 if self.lexer_ is not None and (
 self.lexer_.lexer() == "container" or self.lexer_.lexer() is None
 ):
 with contextlib.suppress(TypeError):
 def setLanguage(self, filename, initTextDisplay=True, propagate=True, pyname=""):
 """
 Public method to set a lexer language.
 @param filename filename used to determine the associated lexer
-language (string)
+language
+@type str
 @param initTextDisplay flag indicating an initialization of the text
-display is required as well (boolean)
+display is required as well
-@param propagate flag indicating to propagate the change (boolean)
+@type bool
-@param pyname name of the pygments lexer to use (string)
+@param propagate flag indicating to propagate the change
+@type bool
+@param pyname name of the pygments lexer to use
+@type str
 """
 # clear all warning and syntax error markers
 self.clearSyntaxError()
 self.clearWarnings()
 def __encodingsMenuTriggered(self, act):
 """
 Private method to handle the selection of an encoding.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 encoding = act.data()
 self.setModified(True)
 self.__encodingChanged("{0}-selected".format(encoding))
 def __normalizedEncoding(self, encoding=""):
 """
 Private method to calculate the normalized encoding string.
-@param encoding encoding to be normalized (string)
+@param encoding encoding to be normalized
-@return normalized encoding (string)
+@type str
+@return normalized encoding
+@rtype str
 """
 if not encoding:
 encoding = self.encoding
 return (
 encoding.replace("-default", "")
 def __eolMenuTriggered(self, act):
 """
 Private method to handle the selection of an eol type.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 eol = act.data()
 self.setEolModeByEolString(eol)
 self.convertEols(self.eolMode())
 if not self.inEolChanged:
 self.inEolChanged = True
 eol = self.getLineSeparator()
 self.eolChanged.emit(eol)
 self.inEolChanged = False
+def convertEols(self, eolMode):
+"""
+Public method to convert the end-of-line marker.
+This variant of the method emits a signal to update the IDE after
+the original method was called.
+@param eolMode end-of-line mode
+@type QsciScintilla.EolMode
+"""
+super().convertEols(eolMode)
+self.__eolChanged()
 @pyqtSlot()
 def __showContextMenuSpellCheck(self):
 """
 Private slot handling the aboutToShow signal of the spell check
 def getLexer(self):
 """
 Public method to retrieve a reference to the lexer object.
-@return the lexer object (Lexer)
+@return the lexer object
+@rtype Lexer
 """
 return self.lexer_
 def getLanguage(self, normalized=True, forPygments=False):
 """
 Public method to retrieve the language of the editor.
 @param normalized flag indicating to normalize some Pygments
-lexer names (boolean)
+lexer names
+@type bool
 @param forPygments flag indicating to normalize some lexer
-names for Pygments (boolean)
+names for Pygments
-@return language of the editor (string)
+@type bool
+@return language of the editor
+@rtype str
 """
 if self.apiLanguage == "Guessed" or self.apiLanguage.startswith("Pygments|"):
 lang = self.lexer_.name()
 if normalized and lang in ("Python 2.x", "Python"):
 # adjust some Pygments lexer names
 def getCompleter(self):
 """
 Public method to retrieve a reference to the completer object.
-@return the completer object (CompleterBase)
+@return the completer object
+@rtype CompleterBase
 """
 return self.completer
 @pyqtSlot(bool)
 def __modificationChanged(self, m):
 def setNoName(self, noName):
 """
 Public method to set the display string for an unnamed editor.
-@param noName display string for this unnamed editor (string)
+@param noName display string for this unnamed editor
+@type str
 """
 self.noName = noName
 def getNoName(self):
 """
 Public method to get the display string for an unnamed editor.
-@return display string for this unnamed editor (string)
+@return display string for this unnamed editor
+@rtype str
 """
 return self.noName
 def getFileName(self):
 """
 Public method to return the name of the file being displayed.
-@return filename of the displayed file (string)
+@return filename of the displayed file
+@rtype str
 """
 return self.fileName
 def getFileType(self):
 """
 Public method to return the type of the file being displayed.
-@return type of the displayed file (string)
+@return type of the displayed file
+@rtype str
 """
 return self.filetype
 def getFileTypeByFlag(self):
 """
 Public method to return the type of the file, if it was set by an
 eflag: marker.
 @return type of the displayed file, if set by an eflag: marker or an
-empty string (string)
+empty string
+@rtype str
 """
 if self.filetypeByFlag:
 return self.filetype
 else:
 return ""
 def determineFileType(self):
 """
 Public method to determine the file type using various tests.
-@return type of the displayed file or an empty string (string)
+@return type of the displayed file or an empty string
+@rtype str
 """
 ftype = self.filetype
 if not ftype:
 pyVer = self.__getPyVersion()
 if pyVer:
 def getEncoding(self):
 """
 Public method to return the current encoding.
-@return current encoding (string)
+@return current encoding
+@rtype str
 """
 return self.encoding
 def __getPyVersion(self):
 """
 Private method to return the Python main version or 0 if it's
 not a Python file at all.
-@return Python version or 0 if it's not a Python file (int)
+@return Python version or 0 if it's not a Python file
+@rtype int
 """
 return PythonUtilities.determinePythonVersion(self.fileName, self.text(0), self)
 def isPyFile(self):
 """
 Public method to return a flag indicating a Python (2 or 3) file.
-@return flag indicating a Python3 file (boolean)
+@return flag indicating a Python3 file
+@rtype bool
 """
 return self.__getPyVersion() == 3
 def isPy3File(self):
 """
 Public method to return a flag indicating a Python3 file.
-@return flag indicating a Python3 file (boolean)
+@return flag indicating a Python3 file
+@rtype bool
 """
 return self.__getPyVersion() == 3
 def isMicroPythonFile(self):
 """
 def isRubyFile(self):
 """
 Public method to return a flag indicating a Ruby file.
-@return flag indicating a Ruby file (boolean)
+@return flag indicating a Ruby file
+@rtype bool
 """
 if self.filetype == "Ruby":
 return True
 if self.filetype == "":
 def isJavascriptFile(self):
 """
 Public method to return a flag indicating a Javascript file.
-@return flag indicating a Javascript file (boolean)
+@return flag indicating a Javascript file
+@rtype bool
 """
 if self.filetype == "JavaScript":
 return True
 if (
 def highlight(self, line=None, error=False, syntaxError=False):  # noqa: U100
 """
 Public method to highlight [or de-highlight] a particular line.
-@param line line number to highlight (integer)
+@param line line number to highlight
+@type int
 @param error flag indicating whether the error highlight should be
-used (boolean)
+used
-@param syntaxError flag indicating a syntax error (boolean)
+@type bool
+@param syntaxError flag indicating a syntax error
+@type bool
 """
 if line is None:
 self.lastHighlight = None
 if self.lastErrorMarker is not None:
 self.markerDeleteHandle(self.lastErrorMarker)
 def getHighlightPosition(self):
 """
 Public method to return the position of the highlight bar.
-@return line number of the highlight bar (integer)
+@return line number of the highlight bar
+@rtype int
 """
 if self.lastHighlight is not None:
 return self.markerLine(self.lastHighlight)
 else:
 return 1
 annotationLinesAdded,  # noqa: U100
 ):
 """
 Private method to handle changes of the number of lines.
-@param pos start position of change (integer)
+@param pos start position of change
-@param mtype flags identifying the change (integer)
+@type int
-@param text text that is given to the Undo system (string)
+@param mtype flags identifying the change
-@param length length of the change (integer)
+@type int
-@param linesAdded number of added/deleted lines (integer)
+@param text text that is given to the Undo system
-@param line line number of a fold level or marker change (integer)
+@type str
-@param foldNow new fold level (integer)
+@param length length of the change
-@param foldPrev previous fold level (integer)
+@type int
+@param linesAdded number of added/deleted lines
+@type int
+@param line line number of a fold level or marker change
+@type int
+@param foldNow new fold level
+@type int
+@param foldPrev previous fold level
+@type int
 @param token ???
+@type int
 @param annotationLinesAdded number of added/deleted annotation lines
-(integer)
+@type int
 """
 if mtype & (self.SC_MOD_INSERTTEXT | self.SC_MOD_DELETETEXT):
 # 1. set/reset the autosave timer
 if self.__autosaveInterval > 0:
 self.__autosaveTimer.start(self.__autosaveInterval * 1000)
 Public method to clear a breakpoint.
 Note: This doesn't clear the breakpoint in the debugger,
 it just deletes it from the editor internal list of breakpoints.
-@param line line number of the breakpoint (integer)
+@param line line number of the breakpoint
+@type int
 """
 if self.inLinesChanged:
 return
 for handle in self.breaks:
 def newBreakpointWithProperties(self, line, properties):
 """
 Public method to set a new breakpoint and its properties.
-@param line line number of the breakpoint (integer)
+@param line line number of the breakpoint
-@param properties properties for the breakpoint (tuple)
+@type int
+@param properties properties for the breakpoint
 (condition, temporary flag, enabled flag, ignore count)
+@type tuple of (str, bool, bool, int)
 """
 if not properties[2]:
 marker = self.dbreakpoint
 elif properties[0]:
 marker = properties[1] and self.tcbreakpoint or self.cbreakpoint
 def __toggleBreakpoint(self, line, temporary=False):
 """
 Private method to toggle a breakpoint.
-@param line line number of the breakpoint (integer)
+@param line line number of the breakpoint
-@param temporary flag indicating a temporary breakpoint (boolean)
+@type int
+@param temporary flag indicating a temporary breakpoint
+@type bool
 """
 for handle in self.breaks:
 if self.markerLine(handle) == line - 1:
 # delete breakpoint or toggle it to the next state
 index = self.breakpointModel.getBreakPointIndex(self.fileName, line)
 def __addBreakPoint(self, line, temporary):
 """
 Private method to add a new breakpoint.
-@param line line number of the breakpoint (integer)
+@param line line number of the breakpoint
-@param temporary flag indicating a temporary breakpoint (boolean)
+@type int
+@param temporary flag indicating a temporary breakpoint
+@type bool
 """
 if self.fileName and self.isPyFile():
 linestarts = PythonDisViewer.linestarts(self.text())
 if line not in linestarts:
 if Preferences.getDebugger("IntelligentBreakpoints"):
 def __toggleBreakpointEnabled(self, line):
 """
 Private method to toggle a breakpoints enabled status.
-@param line line number of the breakpoint (integer)
+@param line line number of the breakpoint
+@type int
 """
 for handle in self.breaks:
 if self.markerLine(handle) == line - 1:
 index = self.breakpointModel.getBreakPointIndex(self.fileName, line)
 self.breakpointModel.setBreakPointEnabledByIndex(
 def curLineHasBreakpoint(self):
 """
 Public method to check for the presence of a breakpoint at the current
 line.
-@return flag indicating the presence of a breakpoint (boolean)
+@return flag indicating the presence of a breakpoint
+@rtype bool
 """
 line, _ = self.getCursorPosition()
 return self.markersAtLine(line) & self.breakpointMask != 0
 def getBreakpointLines(self):
 """
 Public method to get the lines containing a breakpoint.
-@return list of lines containing a breakpoint (list of integer)
+@return list of lines containing a breakpoint
+@rtype list of int
 """
 lines = []
 line = -1
 while True:
 line = self.markerFindNext(line + 1, self.breakpointMask)
 def hasBreakpoints(self):
 """
 Public method to check for the presence of breakpoints.
-@return flag indicating the presence of breakpoints (boolean)
+@return flag indicating the presence of breakpoints
+@rtype bool
 """
 return len(self.breaks) > 0
 @pyqtSlot()
 def __menuToggleTemporaryBreakpoint(self):
 def toggleBookmark(self, line):
 """
 Public method to toggle a bookmark.
-@param line line number of the bookmark (integer)
+@param line line number of the bookmark
+@type int
 """
 for handle in self.bookmarks:
 if self.markerLine(handle) == line - 1:
 self.bookmarks.remove(handle)
 self.markerDeleteHandle(handle)
 def getBookmarks(self):
 """
 Public method to retrieve the bookmarks.
 @return sorted list of all lines containing a bookmark
-(list of integer)
+@rtype list of int
 """
 bmlist = []
 for handle in self.bookmarks:
 bmlist.append(self.markerLine(handle) + 1)
 def getBookmarkLines(self):
 """
 Public method to get the lines containing a bookmark.
-@return list of lines containing a bookmark (list of integer)
+@return list of lines containing a bookmark
+@rtype list of int
 """
 lines = []
 line = -1
 while True:
 line = self.markerFindNext(line + 1, 1 << self.bookmark)
 def hasBookmarks(self):
 """
 Public method to check for the presence of bookmarks.
-@return flag indicating the presence of bookmarks (boolean)
+@return flag indicating the presence of bookmarks
+@rtype bool
 """
 return len(self.bookmarks) > 0
 @pyqtSlot()
 def menuToggleBookmark(self):
 def __printPreview(self, printer):
 """
 Private slot to generate a print preview.
 @param printer reference to the printer object
-(QScintilla.Printer.Printer)
+@type QScintilla.Printer.Printer
 """
 printer.printRange(self)
 ###########################################################################
 ## Task handling methods below
 def getTaskLines(self):
 """
 Public method to get the lines containing a task.
-@return list of lines containing a task (list of integer)
+@return list of lines containing a task
+@rtype list of int
 """
 lines = []
 line = -1
 while True:
 line = self.markerFindNext(line + 1, 1 << self.taskmarker)
 def hasTaskMarkers(self):
 """
 Public method to determine, if this editor contains any task markers.
-@return flag indicating the presence of task markers (boolean)
+@return flag indicating the presence of task markers
+@rtype bool
 """
 return self.__hasTaskMarkers
 @pyqtSlot()
 def nextTask(self):
 def __createChangeMarkerPixmap(self, key, size=16):
 """
 Private method to create a pixmap for the change markers.
-@param key key of the color to use (string)
+@param key key of the color to use
-@param size size of the pixmap (integer)
+@type str
-@return create pixmap (QPixmap)
+@param size size of the pixmap
+@type int
+@return create pixmap
+@rtype QPixmap
 """
 pixmap = QPixmap(size, size)
 pixmap.fill(Qt.GlobalColor.transparent)
 painter = QPainter(pixmap)
 painter.fillRect(size - 4, 0, 4, size, Preferences.getEditorColour(key))
 def getChangeLines(self):
 """
 Public method to get the lines containing a change.
-@return list of lines containing a change (list of integer)
+@return list of lines containing a change
+@rtype list of int
 """
 lines = []
 line = -1
 while True:
 line = self.markerFindNext(line + 1, self.changeMarkersMask)
 def hasChangeMarkers(self):
 """
 Public method to determine, if this editor contains any change markers.
-@return flag indicating the presence of change markers (boolean)
+@return flag indicating the presence of change markers
+@rtype bool
 """
 return self.__hasChangeMarkers
 @pyqtSlot()
 def nextChange(self):
 def __processFlags(self):
 """
 Private method to extract flags and process them.
-@return list of change flags (list of string)
+@return list of change flags
+@rtype list of str
 """
 txt = self.text()
 flags = Utilities.extractFlags(txt)
 changedFlags = []
 def checkDirty(self):
 """
 Public method to check dirty status and open a message window.
-@return flag indicating successful reset of the dirty flag (boolean)
+@return flag indicating successful reset of the dirty flag
+@rtype bool
 """
 if self.isModified():
 fn = self.fileName
 if fn is None:
 fn = self.noName
 res = EricMessageBox.okToClearData(
 self,
 self.tr("File Modified"),
 self.tr("<p>The file <b>{0}</b> has unsaved changes.</p>").format(fn),
-self.saveFile if not self.isRemoteFile() else None,
+self.saveFile
+if not FileSystemUtilities.isRemoteFileName(self.fileName)
+else None,
 )
 if res:
 self.vm.setEditorName(self, self.fileName)
 return res
 self.redo()
 else:
 break
 # Couldn't find the unmodified state
-def readFile(self, fn, createIt=False, encoding=""):
+def readFile(self, fn, createIt=False, encoding="", noempty=False):
 """
 Public method to read the text from a file.
-@param fn filename to read from (string)
+@param fn filename to read from
+@type str
 @param createIt flag indicating the creation of a new file, if the
-given one doesn't exist (boolean)
+given one doesn't exist (defaults to False)
-@param encoding encoding to be used to read the file (string)
+@type bool (optional)
+@param encoding encoding to be used to read the file (defaults to "")
 (Note: this parameter overrides encoding detection)
+@type str (optional)
+@param noempty flag indicating to not set an empty text (defaults to False)
+@type bool (optional)
 """
 self.__loadEditorConfig(fileName=fn)
 try:
 with EricOverrideCursor():
 "<p>Reason: {1}</p>"
 ).format(fn, str(why)),
 )
 raise
+if noempty and not bool(txt):
+return
 with EricOverrideCursor():
-modified = False
 self.setText(txt)
+self.setModified(False)
 # get eric specific flags
 self.__processFlags()
 # perform automatic EOL conversion
 ) or Preferences.getEditor("AutomaticEOLConversion"):
 self.convertEols(self.eolMode())
 else:
 fileEol = self.detectEolString(txt)
 self.setEolModeByEolString(fileEol)
+self.__eolChanged()
 self.extractTasks()
-self.setModified(modified)
 self.lastModified = pathlib.Path(fn).stat().st_mtime
 @pyqtSlot()
 def __convertTabs(self):
 """
 def __getSaveFileName(self, path=None):
 """
 Private method to get the name of the file to be saved.
-@param path directory to save the file in (string)
+@param path directory to save the file in
-@return file name (string)
+@type str
+@return file name
+@rtype str
 """
 # save to project, if a project is loaded
 if self.project.isOpen():
 if self.fileName and self.project.startswithProjectPath(self.fileName):
 path = os.path.dirname(self.fileName)
 def saveFileCopy(self, path=None):
 """
 Public method to save a copy of the file.
-@param path directory to save the file in (string)
+@param path directory to save the file in
-@return flag indicating success (boolean)
+@type str
+@return flag indicating success
+@rtype bool
 """
 fn = self.__getSaveFileName(path)
 if not fn:
 return False
 def saveFile(self, saveas=False, path=None):
 """
 Public method to save the text to a file.
-@param saveas flag indicating a 'save as' action (boolean)
+@param saveas flag indicating a 'save as' action
-@param path directory to save the file in (string)
+@type bool
-@return flag indicating success (boolean)
+@param path directory to save the file in
-"""
+@type str
-if not saveas and (not self.isModified() or self.isRemoteFile()):
+@return flag indicating success
+@rtype bool
+"""
+if not saveas and (
+not self.isModified() or FileSystemUtilities.isRemoteFileName(self.fileName)
+):
 # do nothing if text wasn't changed or is a remote file
 return False
-if self.isDeviceFile():
+if FileSystemUtilities.isDeviceFileName(self.fileName):
 return self.__saveDeviceFile(saveas=saveas)
 newName = None
 if saveas or self.fileName == "":
 saveas = True
 # Convert the file name to device path separators ('/') and ensure,
 # intermediate directories exist (creating them if necessary)
 fn = fn.replace("\\", "/")
 if "/" in fn:
 dn = fn.rsplit("/", 1)[0]
-filemanager.makedirs(dn.replace("device:", ""))
+filemanager.makedirs(FileSystemUtilities.plainFileName(dn))
-success = filemanager.writeFile(fn.replace("device:", ""), self.text())
+success = filemanager.writeFile(
+FileSystemUtilities.plainFileName(fn), self.text()
+)
 if success:
 self.setFileName(fn)
 self.setModified(False)
 self.resetOnlineChangeTraceInfo()
 return success
 def handleRenamed(self, fn):
 """
 Public method 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.__clearBreakpoints(fn)
 self.setFileName(fn)
 self.setWindowTitle(self.fileName)
 def getWordLeft(self, line, index):
 """
 Public method to get the word to the left of 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
-@return the word to the left of that position (string)
+@param index position to look at
+@type int
+@return the word to the left of that position
+@rtype str
 """
 return self.getWord(line, index, 1)
 def getWordRight(self, line, index):
 """
 Public method to get the word to the right of 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
-@return the word to the right of that position (string)
+@param index position to look at
+@type int
+@return the word to the right of that position
+@rtype str
 """
 return self.getWord(line, index, 2)
 def getCurrentWord(self):
 """
 Public method to get the word at the current position.
-@return the word at that current position (string)
+@return the word at that current position
+@rtype str
 """
 line, index = self.getCursorPosition()
 return self.getWord(line, index)
 def getCurrentWordBoundaries(self):
 """
 Public method to get the word boundaries at the current position.
 @return tuple with start and end indexes of the current word
-(integer, integer)
+@rtype tuple of (int, int)
 """
 line, index = self.getCursorPosition()
 return self.getWordBoundaries(line, index)
 def selectWord(self, line, index):
 """
 Public method to select 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
 """
 start, end = self.getWordBoundaries(line, index)
 self.setSelection(line, start, line, end)
 def selectCurrentWord(self):
 def __getCharacter(self, pos):
 """
 Private method to get the character to the left of the current position
 in the current line.
-@param pos position to get character at (integer)
+@param pos position to get character at
-@return requested character or "", if there are no more (string) and
+@type int
-the next position (i.e. pos - 1)
+@return requested character or "", if there are no more and the next position
+(i.e. pos - 1)
+@rtype tuple of (str, int)
 """
 if pos <= 0:
 return "", pos
 pos = self.positionBefore(pos)
 """
 Public method to determine the selection or the current word for the
 next search operation.
 @param selectionOnly flag indicating that only selected text should be
-returned (boolean)
+returned
-@return selection or current word (string)
+@type bool
+@return selection or current word
+@rtype str
 """
 if self.hasSelectedText():
 text = self.selectedText()
 if "\r" in text or "\n" in text:
 # the selection contains at least a newline, it is
 def setSearchIndicator(self, startPos, indicLength):
 """
 Public method to set a search indicator for the given range.
-@param startPos start position of the indicator (integer)
+@param startPos start position of the indicator
-@param indicLength length of the indicator (integer)
+@type int
+@param indicLength length of the indicator
+@type int
 """
 self.setIndicatorRange(self.searchIndicator, startPos, indicLength)
 line = self.lineIndexFromPosition(startPos)[0]
 if line not in self.__searchIndicatorLines:
 self.__searchIndicatorLines.append(line)
 def getSearchIndicatorLines(self):
 """
 Public method to get the lines containing a search indicator.
-@return list of lines containing a search indicator (list of integer)
+@return list of lines containing a search indicator
+@rtype list of int
 """
 return self.__searchIndicatorLines[:]
 def updateMarkerMap(self):
 """
 def __isCommentedLine(self, line, commentStr):
 """
 Private method to check, if the given line is a comment line as
 produced by the configured comment rules.
-@param line text of the line to check (string)
+@param line text of the line to check
-@param commentStr comment string to check against (string)
+@type str
-@return flag indicating a commented line (boolean)
+@param commentStr comment string to check against
+@type str
+@return flag indicating a commented line
+@rtype bool
 """
 if Preferences.getEditor("CommentColumn0"):
 return line.startswith(commentStr)
 else:
 return line.strip().startswith(commentStr)
 @pyqtSlot()
-def toggleCommentBlock(self):
+def toggleComment(self):
 """
-Public slot to toggle the comment of a block.
+Public slot to toggle a block or stream comment.
+If the lexer supports a block comment, that is used for toggling the
+comment. Otherwise a stream comment is used if that is supported. If
+none of these are supported, the request is ignored silently.
+"""
+if self.lexer_ is not None:
+if self.lexer_.canBlockComment():
+self.__toggleBlockComment()
+elif self.lexer_.canStreamComment():
+self.__toggleStreamComment()
+@pyqtSlot()
+def __toggleBlockComment(self):
+"""
+Private slot to toggle the comment of a block.
 If the editor contains selected text and the start line is not commented, it
 will be commented. Otherwise the selection will be un-commented. In case there
 is no selected text and the current line is not commented, it will be commented.
 If is commented, the comment block will be removed.
 self.setSelection(begline, 0, endline, self.lineLength(endline))
 self.uncommentLineOrSelection()
 self.setCursorPosition(line, index - len(commentStr))
 @pyqtSlot()
-def commentLine(self):
+def __commentLine(self):
 """
-Public slot to comment the current line.
+Private slot to comment the current line.
 """
 if self.lexer_ is None or not self.lexer_.canBlockComment():
 return
 line, index = self.getCursorPosition()
 pos = len(lineText.replace(lineText.lstrip(" \t"), ""))
 self.insertAt(self.lexer_.commentStr(), line, pos)
 self.endUndoAction()
 @pyqtSlot()
-def uncommentLine(self):
+def __uncommentLine(self):
 """
-Public slot to uncomment the current line.
+Private slot to uncomment the current line.
 """
 if self.lexer_ is None or not self.lexer_.canBlockComment():
 return
 commentStr = self.lexer_.commentStr()
 self.setSelection(line, pos, line, pos + len(commentStr))
 self.removeSelectedText()
 self.endUndoAction()
 @pyqtSlot()
-def commentSelection(self):
+def __commentSelection(self):
 """
-Public slot to comment the current selection.
+Private slot to comment the current selection.
 """
 if self.lexer_ is None or not self.lexer_.canBlockComment():
 return
 if not self.hasSelectedText():
 # change the selection accordingly
 self.setSelection(lineFrom, 0, endLine + 1, 0)
 self.endUndoAction()
 @pyqtSlot()
-def uncommentSelection(self):
+def __uncommentSelection(self):
 """
-Public slot to uncomment the current selection.
+Private slot to uncomment the current selection.
 """
 if self.lexer_ is None or not self.lexer_.canBlockComment():
 return
 if not self.hasSelectedText():
 @pyqtSlot()
 def commentLineOrSelection(self):
 """
 Public slot to comment the current line or current selection.
-"""
-if self.hasSelectedText():
+If the lexer supports a block comment, that is used for commenting.
-self.commentSelection()
+Otherwise a stream comment is used if that is supported. If none of
-else:
+these are supported, the request is ignored silently.
-self.commentLine()
+"""
+if self.lexer_ is not None:
+if self.lexer_.canBlockComment():
+if self.hasSelectedText():
+self.__commentSelection()
+else:
+self.__commentLine()
+elif self.lexer_.canStreamComment():
+# delegate to the stream comment method
+self.streamCommentLineOrSelection()
 @pyqtSlot()
 def uncommentLineOrSelection(self):
 """
 Public slot to uncomment the current line or current selection.
-"""
-if self.hasSelectedText():
+If the lexer supports a block comment, that is used for uncommenting.
-self.uncommentSelection()
+Otherwise a stream comment is used if that is supported. If none of
-else:
+these are supported, the request is ignored silently.
-self.uncommentLine()
+"""
+if self.lexer_ is not None:
-@pyqtSlot()
+if self.lexer_.canBlockComment():
-def streamCommentLine(self):
+if self.hasSelectedText():
-"""
+self.__uncommentSelection()
-Public slot to stream comment the current line.
+else:
+self.__uncommentLine()
+elif self.lexer_.canStreamComment():
+# delegate to the stream uncomment method
+self.streamUncommentLineOrSelection()
+def __isStreamCommentedLine(self, line, streamCommentStr):
+"""
+Private method to check, if the line is commented by a stream comment.
+@param line text of the line to check
+@type str
+@param streamCommentStr dictionary containing the stream comment start and
+end strings
+@type dict
+@return flag indicating a stream commented line
+@rtype bool
+"""
+line = line.strip()
+return line.startswith(streamCommentStr["start"]) and line.endswith(
+streamCommentStr["end"]
+)
+@pyqtSlot()
+def __toggleStreamComment(self):
+"""
+Private slot to toggle the comment of a block.
+If the editor contains selected text and the start line is not commented, it
+will be commented. Otherwise the selection will be un-commented. In case there
+is no selected text and the current line is not commented, it will be commented.
+If is commented, the comment block will be removed.
 """
 if self.lexer_ is None or not self.lexer_.canStreamComment():
 return
-commentStr = self.lexer_.streamCommentStr()
+streamCommentStr = self.lexer_.streamCommentStr()
 line, index = self.getCursorPosition()
-self.beginUndoAction()
+if self.hasSelectedText():
-self.insertAt(commentStr["end"], line, self.lineLength(line))
+# Check if the selection starts with a stream comment string.
-self.insertAt(commentStr["start"], line, 0)
+if self.text(self.getSelection()[0]).startswith(streamCommentStr["start"]):
-self.endUndoAction()
+self.streamUncommentLineOrSelection()
+else:
-@pyqtSlot()
+self.streamCommentLineOrSelection()
-def streamCommentSelection(self):
+elif self.__isStreamCommentedLine(self.text(line), streamCommentStr):
-"""
+# It is a stream commented line.
-Public slot to comment the current selection.
+self.streamUncommentLineOrSelection()
+elif self.text(line).lstrip(" \t").startswith(streamCommentStr["start"]):
+# The cursor is at the first line of a stream comment.
+pos = len(self.text(line).replace(self.text(line).lstrip(" \t"), ""))
+endline = line
+lines = self.lines()
+while endline < lines and not self.text(endline).rstrip().endswith(
+streamCommentStr["end"]
+):
+endline += 1
+# Uncomment the determined block and reset the cursor position
+self.setSelection(line, pos, endline, self.lineLength(endline))
+self.uncommentLineOrSelection()
+self.setCursorPosition(line, index - len(streamCommentStr["start"]))
+elif self.text(line).rstrip().endswith(streamCommentStr["end"]):
+# The cursor is at the last line of a stream comment.
+begline = line
+while begline > 0 and not self.text(begline).lstrip(" \t").startswith(
+streamCommentStr["start"]
+):
+begline -= 1
+pos = len(self.text(begline).replace(self.text(begline).lstrip(" \t"), ""))
+# Uncomment the determined block and reset the cursor position
+self.setSelection(begline, pos, line, self.lineLength(line))
+self.uncommentLineOrSelection()
+self.setCursorPosition(
+line, min(index, self.lineLength(line) - len(self.getLineSeparator()))
+)
+else:
+# No selected text and the current line does not start with a stream comment
+# string, so comment the line.
+self.streamCommentLineOrSelection()
+@pyqtSlot()
+def __streamCommentLine(self):
+"""
+Private slot to stream comment the current line.
 """
 if self.lexer_ is None or not self.lexer_.canStreamComment():
 return
+streamCommentStr = self.lexer_.streamCommentStr()
+line, index = self.getCursorPosition()
+self.beginUndoAction()
+self.insertAt(
+streamCommentStr["end"],
+line,
+self.lineLength(line) - len(self.getLineSeparator()),
+)
+self.insertAt(streamCommentStr["start"], line, 0)
+self.endUndoAction()
+@pyqtSlot()
+def __streamCommentSelection(self):
+"""
+Private slot to comment the current selection.
+"""
+if self.lexer_ is None or not self.lexer_.canStreamComment():
+return
 if not self.hasSelectedText():
 return
-commentStr = self.lexer_.streamCommentStr()
+streamCommentStr = self.lexer_.streamCommentStr()
 # get the selection boundaries
 lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
 if indexTo == 0:
 endLine = lineTo - 1
-endIndex = self.lineLength(endLine)
+endIndex = self.lineLength(endLine) - len(self.getLineSeparator())
 else:
 endLine = lineTo
 endIndex = indexTo
 self.beginUndoAction()
-self.insertAt(commentStr["end"], endLine, endIndex)
+self.insertAt(streamCommentStr["end"], endLine, endIndex)
-self.insertAt(commentStr["start"], lineFrom, indexFrom)
+self.insertAt(streamCommentStr["start"], lineFrom, indexFrom)
 # change the selection accordingly
 if indexTo > 0:
-indexTo += len(commentStr["end"])
+indexTo += len(streamCommentStr["end"])
 if lineFrom == endLine:
-indexTo += len(commentStr["start"])
+indexTo += len(streamCommentStr["start"])
 self.setSelection(lineFrom, indexFrom, lineTo, indexTo)
 self.endUndoAction()
 @pyqtSlot()
+def __streamUncommentLine(self):
+"""
+Private slot to stream uncomment the current line.
+"""
+if self.lexer_ is None or not self.lexer_.canStreamComment():
+return
+streamCommentStr = self.lexer_.streamCommentStr()
+line, index = self.getCursorPosition()
+# check if line starts and ends with the stream comment strings
+if not self.__isStreamCommentedLine(self.text(line), streamCommentStr):
+return
+self.beginUndoAction()
+# 1. remove comment end string
+self.setSelection(
+line,
+self.lineLength(line)
+- len(self.getLineSeparator())
+- len(streamCommentStr["end"]),
+line,
+self.lineLength(line) - len(self.getLineSeparator()),
+)
+self.removeSelectedText()
+# 2. remove comment start string
+lineText = self.text(line)
+pos = len(lineText.replace(lineText.lstrip(" \t"), ""))
+self.setSelection(line, pos, line, pos + len(streamCommentStr["start"]))
+self.removeSelectedText()
+self.endUndoAction()
+@pyqtSlot()
+def __streamUncommentSelection(self):
+"""
+Private slot to stream uncomment the current selection.
+"""
+if self.lexer_ is None or not self.lexer_.canStreamComment():
+return
+if not self.hasSelectedText():
+return
+streamCommentStr = self.lexer_.streamCommentStr()
+# get the selection boundaries
+lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
+if indexTo == 0:
+endLine = lineTo - 1
+endIndex = self.lineLength(endLine) - len(self.getLineSeparator())
+else:
+endLine = lineTo
+endIndex = indexTo
+self.beginUndoAction()
+self.setSelection(lineFrom, indexFrom, endLine, endIndex)
+selTxt = self.selectedText()
+if selTxt.endswith(streamCommentStr["end"]):
+self.setSelection(
+endLine, endIndex - len(streamCommentStr["end"]), endLine, endIndex
+)
+self.removeSelectedText()
+# modify selection end accordingly
+if indexTo > 0:
+indexTo -= len(streamCommentStr["end"])
+if selTxt.startswith(streamCommentStr["start"]):
+self.setSelection(
+lineFrom,
+indexFrom,
+lineFrom,
+indexFrom + len(streamCommentStr["start"]),
+)
+self.removeSelectedText()
+# modify selection end accordingly
+if lineFrom == lineTo and indexTo > 0:
+indexTo -= len(streamCommentStr["start"])
+self.endUndoAction()
+# now set the new selection
+self.setSelection(lineFrom, indexFrom, lineTo, indexTo)
+@pyqtSlot()
 def streamCommentLineOrSelection(self):
 """
 Public slot to stream comment the current line or current selection.
 """
 if self.hasSelectedText():
-self.streamCommentSelection()
+self.__streamCommentSelection()
 else:
-self.streamCommentLine()
+self.__streamCommentLine()
 @pyqtSlot()
-def boxCommentLine(self):
+def streamUncommentLineOrSelection(self):
 """
-Public slot to box comment the current line.
+Public slot to stream uncomment the current line or current selection.
+"""
+if self.hasSelectedText():
+self.__streamUncommentSelection()
+else:
+self.__streamUncommentLine()
+@pyqtSlot()
+def __boxCommentLine(self):
+"""
+Private slot to box comment the current line.
 """
 if self.lexer_ is None or not self.lexer_.canBoxComment():
 return
-commentStr = self.lexer_.boxCommentStr()
+boxCommentStr = self.lexer_.boxCommentStr()
 line, index = self.getCursorPosition()
 eol = self.getLineSeparator()
 self.beginUndoAction()
 self.insertAt(eol, line, self.lineLength(line))
-self.insertAt(commentStr["end"], line + 1, 0)
+self.insertAt(boxCommentStr["end"], line + 1, 0)
-self.insertAt(commentStr["middle"], line, 0)
+self.insertAt(boxCommentStr["middle"], line, 0)
 self.insertAt(eol, line, 0)
-self.insertAt(commentStr["start"], line, 0)
+self.insertAt(boxCommentStr["start"], line, 0)
 self.endUndoAction()
 @pyqtSlot()
-def boxCommentSelection(self):
+def __boxCommentSelection(self):
 """
-Public slot to box comment the current selection.
+Private slot to box comment the current selection.
 """
 if self.lexer_ is None or not self.lexer_.canBoxComment():
 return
 if not self.hasSelectedText():
 return
-commentStr = self.lexer_.boxCommentStr()
+boxCommentStr = self.lexer_.boxCommentStr()
 # get the selection boundaries
 lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
 endLine = lineTo if indexTo else lineTo - 1
 self.beginUndoAction()
 # iterate over the lines
 for line in range(lineFrom, endLine + 1):
-self.insertAt(commentStr["middle"], line, 0)
+self.insertAt(boxCommentStr["middle"], line, 0)
 # now do the comments before and after the selection
 eol = self.getLineSeparator()
 self.insertAt(eol, endLine, self.lineLength(endLine))
-self.insertAt(commentStr["end"], endLine + 1, 0)
+self.insertAt(boxCommentStr["end"], endLine + 1, 0)
 self.insertAt(eol, lineFrom, 0)
-self.insertAt(commentStr["start"], lineFrom, 0)
+self.insertAt(boxCommentStr["start"], lineFrom, 0)
 # change the selection accordingly
 self.setSelection(lineFrom, 0, endLine + 3, 0)
 self.endUndoAction()
 def boxCommentLineOrSelection(self):
 """
 Public slot to box comment the current line or current selection.
 """
 if self.hasSelectedText():
-self.boxCommentSelection()
+self.__boxCommentSelection()
 else:
-self.boxCommentLine()
+self.__boxCommentLine()
 ###########################################################################
 ## Indentation handling methods below
 ###########################################################################
 def __indentLine(self, indent=True):
 """
 Private method to indent or unindent the current line.
-@param indent flag indicating an indent operation (boolean)
+@param indent flag indicating an indent operation
 <br />If the flag is true, an indent operation is performed.
 Otherwise the current line is unindented.
+@type bool
 """
 line, index = self.getCursorPosition()
 self.beginUndoAction()
 if indent:
 self.indent(line)
 def __indentSelection(self, indent=True):
 """
 Private method to indent or unindent the current selection.
-@param indent flag indicating an indent operation (boolean)
+@param indent flag indicating an indent operation
 <br />If the flag is true, an indent operation is performed.
 Otherwise the current line is unindented.
+@type bool
 """
 if not self.hasSelectedText():
 return
 # get the selection
 def isLastEditPositionAvailable(self):
 """
 Public method to check, if a last edit position is available.
-@return flag indicating availability (boolean)
+@return flag indicating availability
+@rtype bool
 """
 return self.__lastEditPosition is not None
 def gotoLastEditPosition(self):
 """
 def gotoMethodClass(self, goUp=False):
 """
 Public method to go to the next Python method or class definition.
-@param goUp flag indicating the move direction (boolean)
+@param goUp flag indicating the move direction
+@type bool
 """
 if self.isPyFile() or self.isRubyFile():
 lineNo = self.getCursorPosition()[0]
 line = self.text(lineNo)
 if line.strip().startswith(("class ", "def ", "module ")):
 def canAutoCompleteFromAPIs(self):
 """
 Public method to check for API availablity.
-@return flag indicating autocompletion from APIs is available (boolean)
+@return flag indicating autocompletion from APIs is available
+@rtype bool
 """
 return self.acAPI
 def autoCompleteQScintilla(self):
 """
 def setAutoCompletionEnabled(self, enable):
 """
 Public method to enable/disable autocompletion.
 @param enable flag indicating the desired autocompletion status
-(boolean)
+@type bool
 """
 if enable:
 autoCompletionSource = Preferences.getEditor("AutoCompletionSource")
 if autoCompletionSource == QsciScintilla.AutoCompletionSource.AcsDocument:
 self.setAutoCompletionSource(
 def __isStartChar(self, ch):
 """
 Private method to check, if a character is an autocompletion start
 character.
-@param ch character to be checked (one character string)
+@param ch character to be checked
-@return flag indicating the result (boolean)
+@type str
+@return flag indicating the result
+@rtype bool
 """
 if self.lexer_ is None:
 return False
 wseps = self.lexer_.autoCompletionWordSeparators()
 def autoComplete(self, auto=False, context=True):
 """
 Public method to start auto-completion.
 @param auto flag indicating a call from the __charAdded method
-(boolean)
+@type bool
-@param context flag indicating to complete a context (boolean)
+@param context flag indicating to complete a context
+@type bool
 """
 if auto and not Preferences.getEditor("AutoCompletionEnabled"):
 # auto-completion is disabled
 return
 def __autoComplete(self, auto=True, context=None):
 """
 Private method to start auto-completion via plug-ins.
 @param auto flag indicating a call from the __charAdded method
-(boolean)
+@type bool
 @param context flag indicating to complete a context
 @type bool or None
 """
 self.__acCompletions.clear()
 self.__acCompletionsFinished = 0
 def canProvideDynamicAutoCompletion(self):
 """
 Public method to test the dynamic auto-completion availability.
 @return flag indicating the availability of dynamic auto-completion
-(boolean)
+@rtype bool
 """
 return (
 self.acAPI
 or bool(self.__completionListHookFunctions)
 or bool(self.__completionListAsyncHookFunctions)
 def canProvideCallTipps(self):
 """
 Public method to test the calltips availability.
-@return flag indicating the availability of calltips (boolean)
+@return flag indicating the availability of calltips
+@rtype bool
 """
 return self.acAPI or bool(self.__ctHookFunctions)
 def callTip(self):
 """
 def __adjustedCallTipPosition(self, ctshift, pos):
 """
 Private method to calculate an adjusted position for showing calltips.
-@param ctshift amount the calltip shall be shifted (integer)
+@param ctshift amount the calltip shall be shifted
-@param pos position into the text (integer)
+@type int
-@return new position for the calltip (integer)
+@param pos position into the text
+@type int
+@return new position for the calltip
+@rtype int
 """
 ct = pos
 if ctshift:
 ctmin = self.SendScintilla(
 QsciScintilla.SCI_POSITIONFROMLINE,
 def __marginNumber(self, xPos):
 """
 Private method to calculate the margin number based on a x position.
-@param xPos x position (integer)
+@param xPos x position
+@type int
 @return margin number (integer, -1 for no margin)
+@rtype int
 """
 width = 0
 for margin in range(5):
 width += self.marginWidth(margin)
 if xPos <= width:
 def __reopenWithEncodingMenuTriggered(self, act):
 """
 Private method to handle the rereading of the file with a selected
 encoding.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 encoding = act.data()
 self.readFile(self.fileName, encoding=encoding)
 self.__convertTabs()
 self.__checkEncoding()
 def __shouldAutosave(self):
 """
 Private method to check the autosave flags.
-@return flag indicating this editor should be saved (boolean)
+@return flag indicating this editor should be saved
+@rtype bool
 """
 return (
 bool(self.fileName)
 and not self.__autosaveManuallyDisabled
 and not self.isReadOnly()
 def getCoverageLines(self):
 """
 Public method to get the lines containing a coverage marker.
-@return list of lines containing a coverage marker (list of integer)
+@return list of lines containing a coverage marker
+@rtype list of int
 """
 lines = []
 line = -1
 while True:
 line = self.markerFindNext(line + 1, 1 << self.notcovered)
 def hasCoverageMarkers(self):
 """
 Public method to test, if there are coverage markers.
-@return flag indicating the presence of coverage markers (boolean)
+@return flag indicating the presence of coverage markers
+@rtype bool
 """
 return len(self.notcoveredMarkers) > 0
 @pyqtSlot()
 def nextUncovered(self):
 self.syntaxerrors[handle].append((msg, index))
 if show:
 self.setCursorPosition(line - 1, index)
 self.ensureLineVisible(line - 1)
 else:
-for handle in list(self.syntaxerrors.keys()):
+for handle in list(self.syntaxerrors):
 if self.markerLine(handle) == line - 1:
 del self.syntaxerrors[handle]
 self.markerDeleteHandle(handle)
 self.syntaxerrorToggled.emit(self)
 def getSyntaxErrorLines(self):
 """
 Public method to get the lines containing a syntax error.
-@return list of lines containing a syntax error (list of integer)
+@return list of lines containing a syntax error
+@rtype list of int
 """
 lines = []
 line = -1
 while True:
 line = self.markerFindNext(line + 1, 1 << self.syntaxerror)
 def hasSyntaxErrors(self):
 """
 Public method to check for the presence of syntax errors.
-@return flag indicating the presence of syntax errors (boolean)
+@return flag indicating the presence of syntax errors
+@rtype bool
 """
 return len(self.syntaxerrors) > 0
 @pyqtSlot()
 def gotoSyntaxError(self):
 @pyqtSlot()
 def clearSyntaxError(self):
 """
 Public slot to handle the 'Clear all syntax error' context menu action.
 """
-for handle in list(self.syntaxerrors.keys()):
+for handle in list(self.syntaxerrors):
 line = self.markerLine(handle) + 1
 self.toggleSyntaxError(line, 0, False)
 self.syntaxerrors.clear()
 self.syntaxerrorToggled.emit(self)
 self.markerLine(handle) == line - 1
 and warn not in self._warnings[handle]
 ):
 self._warnings[handle].append(warn)
 else:
-for handle in list(self._warnings.keys()):
+for handle in list(self._warnings):
 if self.markerLine(handle) == line - 1:
 del self._warnings[handle]
 self.markerDeleteHandle(handle)
 self.syntaxerrorToggled.emit(self)
 # signal is also used for warnings
 def getWarningLines(self):
 """
 Public method to get the lines containing a warning.
-@return list of lines containing a warning (list of integer)
+@return list of lines containing a warning
+@rtype list of int
 """
 lines = []
 line = -1
 while True:
 line = self.markerFindNext(line + 1, 1 << self.warning)
 def hasWarnings(self):
 """
 Public method to check for the presence of warnings.
-@return flag indicating the presence of warnings (boolean)
+@return flag indicating the presence of warnings
+@rtype bool
 """
 return len(self._warnings) > 0
 @pyqtSlot()
 def nextWarning(self):
 """
 Private method to clear warnings of a specific kind.
 @param warningKind kind of warning to clear (Editor.WarningCode,
 Editor.WarningPython, Editor.WarningStyle)
-"""
+@type int
-for handle in list(self._warnings.keys()):
+"""
+for handle in list(self._warnings):
 issues = []
 for msg, warningType in self._warnings[handle]:
 if warningType == warningKind:
 continue
 def __setAnnotation(self, line):
 """
 Private method to set the annotations for the given line.
-@param line number of the line that needs annotation (integer)
+@param line number of the line that needs annotation
+@type int
 """
 if hasattr(QsciScintilla, "annotate"):
 warningAnnotations = []
 errorAnnotations = []
 styleAnnotations = []
 def __getMacroName(self):
 """
 Private method to select a macro name from the list of macros.
 @return Tuple of macro name and a flag, indicating, if the user
-pressed ok or canceled the operation. (string, boolean)
+pressed ok or canceled the operation.
+@rtype tuple of (str, bool)
 """
 qs = []
 for s in self.macros:
 qs.append(s)
 qs.sort()
 This overwritten method redirects the action to our
 ViewManager.closeEditor, which in turn calls our closeIt
 method.
-@return flag indicating a successful close of the editor (boolean)
+@return flag indicating a successful close of the editor
+@rtype bool
 """
 return self.vm.closeEditor(self)
 def closeIt(self):
 """
 @param event the event object
 @type QFocusEvent
 """
 self.recolor()
 self.vm.editActGrp.setEnabled(True)
 self.vm.editorActGrp.setEnabled(True)
 self.vm.copyActGrp.setEnabled(True)
 self.vm.viewActGrp.setEnabled(True)
 self.vm.searchActGrp.setEnabled(True)
 with contextlib.suppress(AttributeError):
 self.setCaretWidth(self.caretWidth)
 self.__updateReadOnly(False)
+self.setCursorFlashTime(QApplication.cursorFlashTime())
+super().focusInEvent(event)
+def focusOutEvent(self, event):
+"""
+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()
+super().focusOutEvent(event)
+def changeEvent(self, evt):
+"""
+Protected method called to process an event.
+This implements special handling for the events showMaximized,
+showMinimized and showNormal. The windows caption is shortened
+for the minimized mode and reset to the full filename for the
+other modes. This is to make the editor windows work nicer
+with the QWorkspace.
+@param evt the event, that was generated
+@type QEvent
+"""
+if evt.type() == QEvent.Type.WindowStateChange and bool(self.fileName):
+cap = (
+os.path.basename(self.fileName)
+if self.windowState() == Qt.WindowState.WindowMinimized
+else self.fileName
+)
+if self.checkReadOnly():
+cap = self.tr("{0} (ro)").format(cap)
+self.setWindowTitle(cap)
+super().changeEvent(evt)
+def mousePressEvent(self, event):
+"""
+Protected method to handle the mouse press event.
+@param event the mouse press event
+@type QMouseEvent
+"""
+if event.button() == Qt.MouseButton.XButton1:
+self.undo()
+event.accept()
+elif event.button() == Qt.MouseButton.XButton2:
+self.redo()
+event.accept()
+elif event.button() == Qt.MouseButton.LeftButton and bool(
+event.modifiers()
+& (Qt.KeyboardModifier.MetaModifier | Qt.KeyboardModifier.AltModifier)
+):
+line, index = self.lineIndexFromPoint(event.position().toPoint())
+self.addCursor(line, index)
+event.accept()
+else:
+self.vm.eventFilter(self, event)
+super().mousePressEvent(event)
+def mouseDoubleClickEvent(self, evt):
+"""
+Protected method to handle mouse double click events.
+@param evt reference to the mouse event
+@type QMouseEvent
+"""
+super().mouseDoubleClickEvent(evt)
+# accept all double click events even if not handled by QScintilla
+evt.accept()
+self.mouseDoubleClick.emit(evt.position().toPoint(), evt.buttons())
+def wheelEvent(self, evt):
+"""
+Protected method to handle wheel events.
+@param evt reference to the wheel event
+@type QWheelEvent
+"""
+delta = evt.angleDelta().y()
+if evt.modifiers() & Qt.KeyboardModifier.ControlModifier:
+if delta < 0:
+self.zoomOut()
+elif delta > 0:
+self.zoomIn()
+evt.accept()
+return
+if evt.modifiers() & Qt.KeyboardModifier.ShiftModifier:
+if delta < 0:
+self.gotoMethodClass(False)
+elif delta > 0:
+self.gotoMethodClass(True)
+evt.accept()
+return
+super().wheelEvent(evt)
+def event(self, evt):
+"""
+Public method handling events.
+@param evt reference to the event
+@type QEvent
+@return flag indicating, if the event was handled
+@rtype bool
+"""
+if evt.type() == QEvent.Type.Gesture:
+self.gestureEvent(evt)
+return True
+return super().event(evt)
+def gestureEvent(self, evt):
+"""
+Protected method handling gesture events.
+@param evt reference to the gesture event
+@type QGestureEvent
+"""
+pinch = evt.gesture(Qt.GestureType.PinchGesture)
+if pinch:
+if pinch.state() == Qt.GestureState.GestureStarted:
+zoom = (self.getZoom() + 10) / 10.0
+pinch.setTotalScaleFactor(zoom)
+elif pinch.state() == Qt.GestureState.GestureUpdated:
+zoom = int(pinch.totalScaleFactor() * 10) - 10
+if zoom <= -9:
+zoom = -9
+pinch.setTotalScaleFactor(0.1)
+elif zoom >= 20:
+zoom = 20
+pinch.setTotalScaleFactor(3.0)
+self.zoomTo(zoom)
+evt.accept()
+def resizeEvent(self, evt):
+"""
+Protected method handling resize events.
+@param evt reference to the resize event
+@type QResizeEvent
+"""
+super().resizeEvent(evt)
+self.__markerMap.calculateGeometry()
+def viewportEvent(self, evt):
+"""
+Protected method handling event of the viewport.
+@param evt reference to the event
+@type QEvent
+@return flag indiating that the event was handled
+@rtype bool
+"""
+with contextlib.suppress(AttributeError):
+self.__markerMap.calculateGeometry()
+return super().viewportEvent(evt)
+def __updateReadOnly(self, bForce=True):
+"""
+Private method to update the readOnly information for this editor.
+If bForce is True, then updates everything regardless if
+the attributes have actually changed, such as during
+initialization time.  A signal is emitted after the
+caption change.
+@param bForce True to force change, False to only update and emit
+signal if there was an attribute change.
+@type bool
+"""
+if self.fileName == "" or not FileSystemUtilities.isPlainFileName(
+self.fileName
+):
+return
+readOnly = self.checkReadOnly()
+if not bForce and (readOnly == self.isReadOnly()):
+return
+cap = self.fileName
+if readOnly:
+cap = self.tr("{0} (ro)".format(cap))
+self.setReadOnly(readOnly)
+self.setWindowTitle(cap)
+self.captionChanged.emit(cap, self)
+def checkReadOnly(self):
+"""
+Public method to check the 'read only' state.
+@return flag indicate a 'read only' state
+@rtype bool
+"""
+return (
+FileSystemUtilities.isPlainFileName(self.fileName)
+and not os.access(self.fileName, os.W_OK)
+) or self.isReadOnly()
+@pyqtSlot()
+def checkRereadFile(self):
+"""
+Public slot to check, if the file needs to be re-read, and refresh it if
+needed.
+"""
 if (
-self.vm.editorsCheckFocusInEnabled()
+self.fileName
-and not self.inReopenPrompt
-and self.fileName
 and pathlib.Path(self.fileName).exists()
 and pathlib.Path(self.fileName).stat().st_mtime != self.lastModified
 ):
-self.inReopenPrompt = True
 if Preferences.getEditor("AutoReopen") and not self.isModified():
 self.refresh()
 else:
 msg = self.tr(
 """<p>The file <b>{0}</b> has been changed while it"""
 if res:
 self.refresh()
 else:
 # do not prompt for this change again...
 self.lastModified = pathlib.Path(self.fileName).stat().st_mtime
-self.inReopenPrompt = False
+@pyqtSlot()
-self.setCursorFlashTime(QApplication.cursorFlashTime())
+def recordModificationTime(self):
+"""
-super().focusInEvent(event)
+Public slot to record the modification time of our file.
+"""
-def focusOutEvent(self, event):
+if self.fileName and pathlib.Path(self.fileName).exists():
-"""
+self.lastModified = pathlib.Path(self.fileName).stat().st_mtime
-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()
-super().focusOutEvent(event)
-def changeEvent(self, evt):
-"""
-Protected method called to process an event.
-This implements special handling for the events showMaximized,
-showMinimized and showNormal. The windows caption is shortened
-for the minimized mode and reset to the full filename for the
-other modes. This is to make the editor windows work nicer
-with the QWorkspace.
-@param evt the event, that was generated
-@type QEvent
-"""
-if evt.type() == QEvent.Type.WindowStateChange and bool(self.fileName):
-cap = (
-os.path.basename(self.fileName)
-if self.windowState() == Qt.WindowState.WindowMinimized
-else self.fileName
-)
-if self.checkReadOnly():
-cap = self.tr("{0} (ro)").format(cap)
-self.setWindowTitle(cap)
-super().changeEvent(evt)
-def mousePressEvent(self, event):
-"""
-Protected method to handle the mouse press event.
-@param event the mouse press event
-@type QMouseEvent
-"""
-if event.button() == Qt.MouseButton.XButton1:
-self.undo()
-event.accept()
-elif event.button() == Qt.MouseButton.XButton2:
-self.redo()
-event.accept()
-elif event.button() == Qt.MouseButton.LeftButton and bool(
-event.modifiers()
-& (Qt.KeyboardModifier.MetaModifier | Qt.KeyboardModifier.AltModifier)
-):
-line, index = self.lineIndexFromPoint(event.position().toPoint())
-self.addCursor(line, index)
-event.accept()
-else:
-self.vm.eventFilter(self, event)
-super().mousePressEvent(event)
-def mouseDoubleClickEvent(self, evt):
-"""
-Protected method to handle mouse double click events.
-@param evt reference to the mouse event
-@type QMouseEvent
-"""
-super().mouseDoubleClickEvent(evt)
-# accept all double click events even if not handled by QScintilla
-evt.accept()
-self.mouseDoubleClick.emit(evt.position().toPoint(), evt.buttons())
-def wheelEvent(self, evt):
-"""
-Protected method to handle wheel events.
-@param evt reference to the wheel event
-@type QWheelEvent
-"""
-delta = evt.angleDelta().y()
-if evt.modifiers() & Qt.KeyboardModifier.ControlModifier:
-if delta < 0:
-self.zoomOut()
-elif delta > 0:
-self.zoomIn()
-evt.accept()
-return
-if evt.modifiers() & Qt.KeyboardModifier.ShiftModifier:
-if delta < 0:
-self.gotoMethodClass(False)
-elif delta > 0:
-self.gotoMethodClass(True)
-evt.accept()
-return
-super().wheelEvent(evt)
-def event(self, evt):
-"""
-Public method handling events.
-@param evt reference to the event
-@type QEvent
-@return flag indicating, if the event was handled
-@rtype bool
-"""
-if evt.type() == QEvent.Type.Gesture:
-self.gestureEvent(evt)
-return True
-return super().event(evt)
-def gestureEvent(self, evt):
-"""
-Protected method handling gesture events.
-@param evt reference to the gesture event
-@type QGestureEvent
-"""
-pinch = evt.gesture(Qt.GestureType.PinchGesture)
-if pinch:
-if pinch.state() == Qt.GestureState.GestureStarted:
-zoom = (self.getZoom() + 10) / 10.0
-pinch.setTotalScaleFactor(zoom)
-elif pinch.state() == Qt.GestureState.GestureUpdated:
-zoom = int(pinch.totalScaleFactor() * 10) - 10
-if zoom <= -9:
-zoom = -9
-pinch.setTotalScaleFactor(0.1)
-elif zoom >= 20:
-zoom = 20
-pinch.setTotalScaleFactor(3.0)
-self.zoomTo(zoom)
-evt.accept()
-def resizeEvent(self, evt):
-"""
-Protected method handling resize events.
-@param evt reference to the resize event
-@type QResizeEvent
-"""
-super().resizeEvent(evt)
-self.__markerMap.calculateGeometry()
-def viewportEvent(self, evt):
-"""
-Protected method handling event of the viewport.
-@param evt reference to the event
-@type QEvent
-@return flag indiating that the event was handled
-@rtype bool
-"""
-with contextlib.suppress(AttributeError):
-self.__markerMap.calculateGeometry()
-return super().viewportEvent(evt)
-def __updateReadOnly(self, bForce=True):
-"""
-Private method to update the readOnly information for this editor.
-If bForce is True, then updates everything regardless if
-the attributes have actually changed, such as during
-initialization time.  A signal is emitted after the
-caption change.
-@param bForce True to force change, False to only update and emit
-signal if there was an attribute change.
-"""
-if self.fileName == "" or not self.isLocalFile():
-return
-readOnly = self.checkReadOnly()
-if not bForce and (readOnly == self.isReadOnly()):
-return
-cap = self.fileName
-if readOnly:
-cap = self.tr("{0} (ro)".format(cap))
-self.setReadOnly(readOnly)
-self.setWindowTitle(cap)
-self.captionChanged.emit(cap, self)
-def checkReadOnly(self):
-"""
-Public method to check the 'read only' state.
-@return flag indicate a 'read only' state
-@rtype bool
-"""
-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.
 self.close()
 return
 # reread the file
 try:
-self.readFile(self.fileName)
+self.readFile(self.fileName, noempty=True)
 except OSError:
 # do not prompt for this change again...
 self.lastModified = QDateTime.currentDateTime()
 self.setModified(False)
 self.__convertTabs()
 def setMonospaced(self, on):
 """
 Public method to set/reset a monospaced font.
-@param on flag to indicate usage of a monospace font (boolean)
+@param on flag to indicate usage of a monospace font
+@type bool
 """
 if on:
 if not self.lexer_:
 f = Preferences.getEditorOtherFonts("MonospacedFont")
 self.monospacedStyles(f)
 def dragEnterEvent(self, event):
 """
 Protected method to handle the drag enter event.
-@param event the drag enter event (QDragEnterEvent)
+@param event the drag enter event
+@type QDragEnterEvent
 """
 self.inDragDrop = event.mimeData().hasUrls()
 if self.inDragDrop:
 event.acceptProposedAction()
 else:
 def dragMoveEvent(self, event):
 """
 Protected method to handle the drag move event.
-@param event the drag move event (QDragMoveEvent)
+@param event the drag move event
+@type QDragMoveEvent
 """
 if self.inDragDrop:
 event.accept()
 else:
 super().dragMoveEvent(event)
 def dragLeaveEvent(self, event):
 """
 Protected method to handle the drag leave event.
-@param event the drag leave event (QDragLeaveEvent)
+@param event the drag leave event
+@type QDragLeaveEvent
 """
 if self.inDragDrop:
 self.inDragDrop = False
 event.accept()
 else:
 def dropEvent(self, event):
 """
 Protected method to handle the drop event.
-@param event the drop event (QDropEvent)
+@param event the drop event
+@type QDropEvent
 """
 if event.mimeData().hasUrls():
 for url in event.mimeData().urls():
 fname = url.toLocalFile()
 if fname:
 def __initContextMenuResources(self):
 """
 Private method used to setup the Resources context sub menu.
-@return reference to the generated menu (QMenu)
+@return reference to the generated menu
+@rtype QMenu
 """
 menu = QMenu(self.tr("Resources"))
 menu.addAction(self.tr("Add file..."), self.__addFileResource)
 menu.addAction(self.tr("Add files..."), self.__addFileResources)
 def editorCommand(self, cmd):
 """
 Public method to perform a simple editor command.
 @param cmd the scintilla command to be performed
+@type int
 """
 if cmd == QsciScintilla.SCI_TAB:
 try:
 templateViewer = ericApp().getObject("TemplateViewer")
 except KeyError:
 def __applyTemplate(self, templateName, language):
 """
 Private method to apply a template by name.
-@param templateName name of the template to apply (string)
+@param templateName name of the template to apply
+@type str
 @param language name of the language (group) to get the template
-from (string)
+from
+@type str
 """
 try:
 templateViewer = ericApp().getObject("TemplateViewer")
 except KeyError:
 # template viewer is not active
 def __setSpellingLanguage(self, language, pwl="", pel=""):
 """
 Private method to set the spell checking language.
-@param language spell checking language to be set (string)
+@param language spell checking language to be set
-@param pwl name of the personal/project word list (string)
+@type str
-@param pel name of the personal/project exclude list (string)
+@param pwl name of the personal/project word list
+@type str
+@param pel name of the personal/project exclude list
+@type str
 """
 if self.spell and self.spell.getLanguage() != language:
 self.spell.setLanguage(language, pwl=pwl, pel=pel)
 self.spell.checkDocumentIncrementally()
 Public method to get some share status info.
 @return tuple indicating, if the editor is sharable, the sharing
 status, if it is inside a locally initiated shared edit session
 and if it is inside a remotely initiated shared edit session
-(boolean, boolean, boolean, boolean)
+@rtype tuple of (bool, bool, bool, bool)
 """
 return (
 (
 bool(self.fileName)
 and self.project.isOpen()
 def shareConnected(self, connected):
 """
 Public method to handle a change of the connected state.
-@param connected flag indicating the connected state (boolean)
+@param connected flag indicating the connected state
+@type bool
 """
 if not connected:
 self.__inRemoteSharedEdit = False
 self.setReadOnly(False)
 self.__updateReadOnly()
 def shareEditor(self, share):
 """
 Public method to set the shared status of the editor.
-@param share flag indicating the share status (boolean)
+@param share flag indicating the share status
+@type bool
 """
 self.__isShared = share
 if not share:
 self.shareConnected(False)
 def cancelSharedEdit(self, send=True):
 """
 Public method to cancel a shared edit session for the editor.
-@param send flag indicating to send the CancelEdit command (boolean)
+@param send flag indicating to send the CancelEdit command
+@type bool
 """
 self.__inSharedEdit = False
 self.__savedText = ""
 if send:
 self.__send(Editor.CancelEditToken)
 def __send(self, token, args=None):
 """
 Private method to send an editor command to remote editors.
-@param token command token (string)
+@param token command token
-@param args arguments for the command (string)
+@type str
+@param args arguments for the command
+@type str
 """
 if self.vm.isConnected():
 msg = ""
 if token in (
 Editor.StartEditToken,
 def __dispatchCommand(self, command):
 """
 Private method to dispatch received commands.
-@param command command to be processed (string)
+@param command command to be processed
+@type str
 """
 token, argsString = command.split(Editor.Separator, 1)
 if token == Editor.StartEditToken:
 self.__processStartEditCommand(argsString)
 elif token == Editor.CancelEditToken:
 def __calculateChanges(self, old, new):
 """
 Private method to determine change commands to convert old text into
 new text.
-@param old old text (string)
+@param old old text
-@param new new text (string)
+@type str
-@return commands to change old into new (string)
+@param new new text
+@type str
+@return commands to change old into new
+@rtype str
 """
 oldL = old.splitlines()
 newL = new.splitlines()
 matcher = difflib.SequenceMatcher(None, oldL, newL)
 def __searchCurrentWord(self, forward=True):
 """
 Private slot to search the next occurrence of the current word.
-@param forward flag indicating the search direction (boolean)
+@param forward flag indicating the search direction
+@type bool
 """
 self.hideFindIndicator()
 line, index = self.getCursorPosition()
 word = self.getCurrentWord()
 wordStart, wordEnd = self.getCurrentWordBoundaries()
 # step 3: sort the lines
 eol = self.getLineSeparator()
 lastWithEol = True
 newLines = []
-for txt in sorted(selText.keys(), key=keyFun, reverse=reverse):
+for txt in sorted(selText, key=keyFun, reverse=reverse):
 for line in selText[txt]:
 txt = txtLines[line]
 if not txt.endswith(eol):
 lastWithEol = False
 txt += eol
 a plug-in.
 @param name name of the plug-in
 @type str
 """
-for key in list(self.__mouseClickHandlers.keys()):
+for key in list(self.__mouseClickHandlers):
 if self.__mouseClickHandlers[key][0] == name:
 del self.__mouseClickHandlers[key]
 def gotoReferenceHandler(self, referencesList):
 """
 @return EditorConfig dictionary
 @rtype dict
 """
 editorConfig = {}
-if fileName and self.isLocalFile():
+if fileName and FileSystemUtilities.isPlainFileName(self.fileName):
 try:
 editorConfig = editorconfig.get_properties(fileName)
 except editorconfig.EditorConfigError:
 EricMessageBox.warning(
 self,
 @type bool
 @param config reference to an EditorConfig object or None
 @type dict
 @return value of requested setting or None if nothing was found and
 nodefault parameter was True
-@rtype any
+@rtype Any
 """
 if config is None:
 config = self.__editorConfig
 if not config:
 Public method to get the requested option via EditorConfig.
 @param option Preferences option key
 @type str
 @return value of requested setting
-@rtype any
+@rtype Any
 """
 return self.__getEditorConfig(option)
 def __getOverrideValue(self, option):
 """
 Private method to get an override value for the current file type.
 @param option Preferences option key
 @type str
 @return override value; None in case nothing is defined
-@rtype any
+@rtype Any
 """
 if option in ("TabWidth", "IndentWidth"):
 overrides = Preferences.getEditor("TabIndentOverride")
 language = self.filetype or self.apiLanguage
 if language in overrides:

Mercurial Repositories > eric / file comparison

comparison: src/eric7/QScintilla/Editor.py

src/eric7/QScintilla/Editor.py