eric: comparison eric6/QScintilla/Editor.py

-:babe80d84a3e
+:7eb04391adf7
 #
 """
 Module implementing the editor component of the eric6 IDE.
 """
-from __future__ import unicode_literals
-try:
-str = unicode
-chr = unichr
-except NameError:
-pass
 import os
 import re
 import difflib
-from PyQt5.QtCore import QDir, QTimer, QModelIndex, QFileInfo, pyqtSignal, \
+from PyQt5.QtCore import (
-pyqtSlot, QCryptographicHash, QEvent, QDateTime, QRegExp, Qt, QPoint
+QDir, QTimer, QModelIndex, QFileInfo, pyqtSignal, pyqtSlot,
+QCryptographicHash, QEvent, QDateTime, QRegExp, Qt, QPoint
+)
 from PyQt5.QtGui import QCursor, QPalette, QFont, QPixmap, QPainter
-from PyQt5.QtWidgets import QLineEdit, QActionGroup, QDialog, QInputDialog, \
+from PyQt5.QtWidgets import (
-QApplication, QMenu
+QLineEdit, QActionGroup, QDialog, QInputDialog, QApplication, QMenu
+)
 from PyQt5.QtPrintSupport import QPrinter, QPrintDialog, QAbstractPrintDialog
 from PyQt5.Qsci import QsciScintilla, QsciMacro, QsciStyledText
 from E5Gui.E5Application import e5App
 from E5Gui import E5FileDialog, E5MessageBox
 from .EditorMarkerMap import EditorMarkerMap
 import Preferences
 import Utilities
 from Utilities import MouseUtilities
-from Globals import qVersionTuple
 import UI.PixmapCache
 from ThirdParty.EditorConfig import editorconfig
 self.currentline = self.markerDefine(
 UI.PixmapCache.getPixmap("currentLineMarker.png"))
 self.errorline = self.markerDefine(
 UI.PixmapCache.getPixmap("errorLineMarker.png"))
-self.breakpointMask = (1 << self.breakpoint) | \
+self.breakpointMask = (
-(1 << self.cbreakpoint) | \
+(1 << self.breakpoint) |
-(1 << self.tbreakpoint) | \
+(1 << self.cbreakpoint) |
-(1 << self.tcbreakpoint) | \
+(1 << self.tbreakpoint) |
-(1 << self.dbreakpoint)
+(1 << self.tcbreakpoint) |
+(1 << self.dbreakpoint)
-self.changeMarkersMask = (1 << self.__changeMarkerSaved) | \
+)
-(1 << self.__changeMarkerUnsaved)
+self.changeMarkersMask = (
+(1 << self.__changeMarkerSaved) |
+(1 << self.__changeMarkerUnsaved)
+)
 self.__markerMap = EditorMarkerMap(self)
 # configure the margins
 self.__setMarginsDisplay()
 self.syntaxCheckService = None
 self.isResourcesFile = False
 if editor is None:
 if self.fileName:
-if (QFileInfo(self.fileName).size() // 1024) > \
+if (
-Preferences.getEditor("WarnFilesize"):
+(QFileInfo(self.fileName).size() // 1024) >
+Preferences.getEditor("WarnFilesize")
+):
 res = E5MessageBox.yesNo(
 self,
 self.tr("Open File"),
 self.tr("""<p>The size of the file <b>{0}</b>"""
 """ is <b>{1} KB</b>."""
 self.__bindLexer(self.fileName)
 self.__bindCompleter(self.fileName)
 self.checkSyntax()
 self.isResourcesFile = self.fileName.endswith(".qrc")
+self.__convertTabs()
 self.recolor()
 else:
 # clone the given editor
 self.setDocument(editor.document())
 self.breaks = editor.breaks
 self.textChanged.connect(self.__textChanged)
 # initialize the online change trace timer
 self.__initOnlineChangeTrace()
-if self.fileName and \
+if (
-self.project.isOpen() and \
+self.fileName and
-self.project.isProjectSource(self.fileName):
+self.project.isOpen() and
+self.project.isProjectSource(self.fileName)
+):
 self.project.projectPropertiesChanged.connect(
 self.__projectPropertiesChanged)
 self.grabGesture(Qt.PinchGesture)
 self.supportedLanguages = {}
 supportedLanguages = Lexers.getSupportedLanguages()
 languages = sorted(list(supportedLanguages.keys()))
 for language in languages:
 if language != "Guessed":
-self.supportedLanguages[language] = \
+self.supportedLanguages[language] = (
 supportedLanguages[language][:2]
+)
 act = menu.addAction(
 UI.PixmapCache.getIcon(supportedLanguages[language][2]),
 self.supportedLanguages[language][0])
 act.setCheckable(True)
 act.setData(language)
 self.marginMenuActs["EnableBreakpoint"] = self.bpMarginMenu.addAction(
 self.tr('Enable breakpoint'),
 self.__menuToggleBreakpointEnabled)
 self.marginMenuActs["NextBreakpoint"] = self.bpMarginMenu.addAction(
 self.tr('Next breakpoint'), self.menuNextBreakpoint)
-self.marginMenuActs["PreviousBreakpoint"] = \
+self.marginMenuActs["PreviousBreakpoint"] = (
 self.bpMarginMenu.addAction(
 self.tr('Previous breakpoint'),
 self.menuPreviousBreakpoint)
+)
 self.marginMenuActs["ClearBreakpoint"] = self.bpMarginMenu.addAction(
 self.tr('Clear all breakpoints'), self.__menuClearBreakpoints)
 self.bpMarginMenu.aboutToShow.connect(
 lambda: self.__showContextMenuMargin(self.bpMarginMenu))
 # fold margin
 self.foldMarginMenu = QMenu()
-self.marginMenuActs["ToggleAllFolds"] = \
+self.marginMenuActs["ToggleAllFolds"] = (
 self.foldMarginMenu.addAction(
 self.tr("Toggle all folds"),
 self.foldAll)
-self.marginMenuActs["ToggleAllFoldsAndChildren"] = \
+)
+self.marginMenuActs["ToggleAllFoldsAndChildren"] = (
 self.foldMarginMenu.addAction(
 self.tr("Toggle all folds (including children)"),
 lambda: self.foldAll(True))
-self.marginMenuActs["ToggleCurrentFold"] = \
+)
+self.marginMenuActs["ToggleCurrentFold"] = (
 self.foldMarginMenu.addAction(
 self.tr("Toggle current fold"),
 self.toggleCurrentFold)
+)
 self.foldMarginMenu.addSeparator()
-self.marginMenuActs["ExpandChildren"] = \
+self.marginMenuActs["ExpandChildren"] = (
 self.foldMarginMenu.addAction(
 self.tr("Expand (including children)"),
 self.__contextMenuExpandFoldWithChildren)
-self.marginMenuActs["CollapseChildren"] = \
+)
+self.marginMenuActs["CollapseChildren"] = (
 self.foldMarginMenu.addAction(
 self.tr("Collapse (including children)"),
 self.__contextMenuCollapseFoldWithChildren)
+)
 self.foldMarginMenu.addSeparator()
-self.marginMenuActs["ClearAllFolds"] = \
+self.marginMenuActs["ClearAllFolds"] = (
 self.foldMarginMenu.addAction(
 self.tr("Clear all folds"),
 self.clearFolds)
+)
 self.foldMarginMenu.aboutToShow.connect(
 lambda: self.__showContextMenuMargin(self.foldMarginMenu))
 # indicator margin
 self.indicMarginMenu = QMenu()
-self.marginMenuActs["GotoSyntaxError"] = \
+self.marginMenuActs["GotoSyntaxError"] = (
 self.indicMarginMenu.addAction(
 self.tr('Goto syntax error'), self.gotoSyntaxError)
-self.marginMenuActs["ShowSyntaxError"] = \
+)
+self.marginMenuActs["ShowSyntaxError"] = (
 self.indicMarginMenu.addAction(
 self.tr('Show syntax error message'),
 self.__showSyntaxError)
-self.marginMenuActs["ClearSyntaxError"] = \
+)
+self.marginMenuActs["ClearSyntaxError"] = (
 self.indicMarginMenu.addAction(
 self.tr('Clear syntax error'), self.clearSyntaxError)
+)
 self.indicMarginMenu.addSeparator()
-self.marginMenuActs["NextWarningMarker"] = \
+self.marginMenuActs["NextWarningMarker"] = (
 self.indicMarginMenu.addAction(
 self.tr("Next warning"), self.nextWarning)
-self.marginMenuActs["PreviousWarningMarker"] = \
+)
+self.marginMenuActs["PreviousWarningMarker"] = (
 self.indicMarginMenu.addAction(
 self.tr("Previous warning"), self.previousWarning)
-self.marginMenuActs["ShowWarning"] = \
+)
+self.marginMenuActs["ShowWarning"] = (
 self.indicMarginMenu.addAction(
 self.tr('Show warning message'), self.__showWarning)
-self.marginMenuActs["ClearWarnings"] = \
+)
+self.marginMenuActs["ClearWarnings"] = (
 self.indicMarginMenu.addAction(
 self.tr('Clear warnings'), self.clearWarnings)
+)
 self.indicMarginMenu.addSeparator()
-self.marginMenuActs["NextCoverageMarker"] = \
+self.marginMenuActs["NextCoverageMarker"] = (
 self.indicMarginMenu.addAction(
 self.tr('Next uncovered line'), self.nextUncovered)
-self.marginMenuActs["PreviousCoverageMarker"] = \
+)
+self.marginMenuActs["PreviousCoverageMarker"] = (
 self.indicMarginMenu.addAction(
 self.tr('Previous uncovered line'), self.previousUncovered)
+)
 self.indicMarginMenu.addSeparator()
-self.marginMenuActs["NextTaskMarker"] = \
+self.marginMenuActs["NextTaskMarker"] = (
 self.indicMarginMenu.addAction(
 self.tr('Next task'), self.nextTask)
-self.marginMenuActs["PreviousTaskMarker"] = \
+)
+self.marginMenuActs["PreviousTaskMarker"] = (
 self.indicMarginMenu.addAction(
 self.tr('Previous task'), self.previousTask)
+)
 self.indicMarginMenu.addSeparator()
-self.marginMenuActs["NextChangeMarker"] = \
+self.marginMenuActs["NextChangeMarker"] = (
 self.indicMarginMenu.addAction(
 self.tr('Next change'), self.nextChange)
-self.marginMenuActs["PreviousChangeMarker"] = \
+)
+self.marginMenuActs["PreviousChangeMarker"] = (
 self.indicMarginMenu.addAction(
 self.tr('Previous change'), self.previousChange)
-self.marginMenuActs["ClearChangeMarkers"] = \
+)
+self.marginMenuActs["ClearChangeMarkers"] = (
 self.indicMarginMenu.addAction(
 self.tr('Clear changes'), self.__reinitOnlineChangeTrace)
+)
 self.indicMarginMenu.aboutToShow.connect(
 lambda: self.__showContextMenuMargin(self.indicMarginMenu))
 def __exportMenuTriggered(self, act):
 """
 Private method used to reset the language selection.
 @keyparam propagate flag indicating to propagate the change (boolean)
 """
-if self.lexer_ is not None and \
+if (
-(self.lexer_.lexer() == "container" or self.lexer_.lexer() is None):
+self.lexer_ is not None and
+(self.lexer_.lexer() == "container" or
+self.lexer_.lexer() is None)
+):
 self.SCN_STYLENEEDED.disconnect(self.__styleNeeded)
 self.apiLanguage = ""
 self.lexer_ = None
 self.__lexerReset = True
 def __checkEncoding(self):
 """
 Private method to check the selected encoding of the encodings submenu.
 """
 try:
-self.supportedEncodings[self.__normalizedEncoding()]\
+(self.supportedEncodings[self.__normalizedEncoding()]
-.setChecked(True)
+.setChecked(True))
 except (AttributeError, KeyError):
 pass
 def __encodingChanged(self, encoding, propagate=True):
 """
 @param encoding encoding to be normalized (string)
 @return normalized encoding (string)
 """
 if not encoding:
 encoding = self.encoding
-return encoding.replace("-default", "")\
+return (
-.replace("-guessed", "")\
+encoding
-.replace("-selected", "")
+.replace("-default", "")
+.replace("-guessed", "")
+.replace("-selected", "")
+)
 def __showContextMenuEol(self):
 """
 Private slot handling the aboutToShow signal of the eol context menu.
 """
 @param filename filename used to determine the associated lexer
 language (string)
 @keyparam pyname name of the pygments lexer to use (string)
 """
-if self.lexer_ is not None and \
+if (
-(self.lexer_.lexer() == "container" or self.lexer_.lexer() is None):
+self.lexer_ is not None and
+(self.lexer_.lexer() == "container" or
+self.lexer_.lexer() is None)
+):
 self.SCN_STYLENEEDED.disconnect(self.__styleNeeded)
 language = ""
 if not self.filetype:
 if filename:
 basename = os.path.basename(filename)
-if self.project.isOpen() and \
+if (
-self.project.isProjectFile(filename):
+self.project.isOpen() and
+self.project.isProjectFile(filename)
+):
 language = self.project.getEditorLexerAssoc(basename)
 if not language:
 language = Preferences.getEditorLexerAssoc(basename)
 if not language:
 bindName = self.__bindName(self.text(0))
 lexer names (boolean)
 @keyparam forPygments flag indicating to normalize some lexer
 names for Pygments (boolean)
 @return language of the editor (string)
 """
-if self.apiLanguage == "Guessed" or \
+if (
-self.apiLanguage.startswith("Pygments|"):
+self.apiLanguage == "Guessed" or
+self.apiLanguage.startswith("Pygments|")
+):
 lang = self.lexer_.name()
 if normalized:
 # adjust some Pygments lexer names
 if lang == "Python":
 lang = "Python2"
 if self.filetype == "Ruby":
 return True
 if self.filetype == "":
 line0 = self.text(0)
-if line0.startswith("#!") and \
+if (
-"ruby" in line0:
+line0.startswith("#!") and
+"ruby" in line0
+):
 self.filetype = "Ruby"
 return True
-if bool(self.fileName) and \
+if (
-os.path.splitext(self.fileName)[1] in \
+bool(self.fileName) and
-self.dbs.getExtensions('Ruby'):
+os.path.splitext(self.fileName)[1] in
+self.dbs.getExtensions('Ruby')
+):
 self.filetype = "Ruby"
 return True
 return False
 """
 if self.filetype == "JavaScript":
 return True
 if self.filetype == "":
-if self.fileName and \
+if (
-os.path.splitext(self.fileName)[1] == ".js":
+self.fileName and
+os.path.splitext(self.fileName)[1] == ".js"
+):
 self.filetype = "JavaScript"
 return True
 return False
 @param foldPrev previous fold level (integer)
 @param token ???
 @param annotationLinesAdded number of added/deleted annotation lines
 (integer)
 """
-if mtype & (self.SC_MOD_INSERTTEXT | self.SC_MOD_DELETETEXT) and \
+if (
-linesAdded != 0:
+mtype & (self.SC_MOD_INSERTTEXT | self.SC_MOD_DELETETEXT) and
+linesAdded != 0
+):
 if self.breaks:
 bps = []    # list of breakpoints
-for handle, (ln, cond, temp, enabled, ignorecount) in \
+for handle, (ln, cond, temp, enabled, ignorecount) in (
-self.breaks.items():
+self.breaks.items()
+):
 line = self.markerLine(handle) + 1
 if ln != line:
 bps.append((ln, line))
 self.breaks[handle] = (line, cond, temp, enabled,
 ignorecount)
 @param start start row (integer)
 @param end end row (integer)
 """
 for row in range(start, end + 1):
 index = self.breakpointModel.index(row, 0, parentIndex)
-fn, line, cond, temp, enabled, ignorecount = \
+fn, line, cond, temp, enabled, ignorecount = (
 self.breakpointModel.getBreakPointByIndex(index)[:6]
+)
 if fn == self.fileName:
 self.newBreakpointWithProperties(
 line, (cond, temp, enabled, ignorecount))
 def clearBreakpoint(self, line):
 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)
-if Preferences.getDebugger("ThreeStateBreakPoints") and \
+if (
-not self.breakpointModel.isBreakPointTemporaryByIndex(
+Preferences.getDebugger("ThreeStateBreakPoints") and
-index):
+not self.breakpointModel.isBreakPointTemporaryByIndex(
+index)
+):
 self.breakpointModel.deleteBreakPointByIndex(index)
 self.__addBreakPoint(line, True)
 else:
 self.breakpointModel.deleteBreakPointByIndex(index)
 self.breakpointToggled.emit(self)
 QApplication.restoreOverrideCursor()
 raise
 modified = False
-if (not self.__getEditorConfig("TabForIndentation")) and \
+self.setText(txt)
-Preferences.getEditor("ConvertTabsOnLoad") and \
-not (self.lexer_ and
+# get eric specific flags
-self.lexer_.alwaysKeepTabs()):
+self.__processFlags()
+# perform automatic EOL conversion
+if (
+self.__getEditorConfig("EOLMode", nodefault=True) or
+Preferences.getEditor("AutomaticEOLConversion")
+):
+self.convertEols(self.eolMode())
+else:
+fileEol = self.detectEolString(txt)
+self.setEolModeByEolString(fileEol)
+self.extractTasks()
+QApplication.restoreOverrideCursor()
+self.setModified(modified)
+self.lastModified = QFileInfo(self.fileName).lastModified()
+def __convertTabs(self):
+"""
+Private slot to convert tabulators to spaces.
+"""
+if (
+(not self.__getEditorConfig("TabForIndentation")) and
+Preferences.getEditor("ConvertTabsOnLoad") and
+not (self.lexer_ and
+self.lexer_.alwaysKeepTabs())
+):
+txt = self.text()
 txtExpanded = txt.expandtabs(self.__getEditorConfig("TabWidth"))
 if txtExpanded != txt:
-modified = True
+self.beginUndoAction
-txt = txtExpanded
+self.setText(txt)
+self.endUndoAction()
-self.setText(txt)
+self.setModified(True)
-# get eric specific flags
-self.__processFlags()
-# perform automatic EOL conversion
-if self.__getEditorConfig("EOLMode", nodefault=True) or \
-Preferences.getEditor("AutomaticEOLConversion"):
-self.convertEols(self.eolMode())
-else:
-fileEol = self.detectEolString(txt)
-self.setEolModeByEolString(fileEol)
-self.extractTasks()
-QApplication.restoreOverrideCursor()
-self.setModified(modified)
-self.lastModified = QFileInfo(self.fileName).lastModified()
 def __removeTrailingWhitespace(self):
 """
 Private method to remove trailing whitespace.
 """
 searchRE = r"[ \t]+$"    # whitespace at the end of a line
 @param path directory to save the file in (string)
 @return file name (string)
 """
 # save to project, if a project is loaded
 if self.project.isOpen():
-if self.fileName and \
+if (
-self.project.startswithProjectPath(self.fileName):
+self.fileName and
+self.project.startswithProjectPath(self.fileName)
+):
 path = os.path.dirname(self.fileName)
 else:
 path = self.project.getProjectPath()
 if not path and self.fileName:
 path = os.path.dirname(self.fileName)
 if not path:
-path = Preferences.getMultiProject("Workspace") or \
+path = (
+Preferences.getMultiProject("Workspace") or
 Utilities.getHomeDir()
+)
 from . import Lexers
 if self.fileName:
 filterPattern = "(*{0})".format(
 os.path.splitext(self.fileName)[1])
 return False
 res = self.writeFile(fn)
 if res:
 # save to project, if a project is loaded
-if self.project.isOpen() and \
+if (
-self.project.startswithProjectPath(fn):
+self.project.isOpen() and
+self.project.startswithProjectPath(fn)
+):
 self.project.appendFile(fn)
 return res
 def saveFile(self, saveas=False, path=None):
 return False
 newName = fn
 # save to project, if a project is loaded
-if self.project.isOpen() and \
+if (
-self.project.startswithProjectPath(fn):
+self.project.isOpen() and
+self.project.startswithProjectPath(fn)
+):
 editorConfigEol = self.__getEditorConfig(
 "EOLMode", nodefault=True,
 config=self.__loadEditorConfigObject(fn))
 if editorConfigEol is not None:
 self.setEolMode(editorConfigEol)
 self.isResourcesFile = self.fileName.endswith(".qrc")
 self.__initContextMenu()
 self.editorRenamed.emit(self.fileName)
 # save to project, if a project is loaded
-if self.project.isOpen() and \
+if (
-self.project.startswithProjectPath(fn):
+self.project.isOpen() and
+self.project.startswithProjectPath(fn)
+):
 self.project.appendFile(fn)
 self.addedToProject()
 self.setLanguage(self.fileName)
 commentStr = self.lexer_.commentStr()
 line, index = self.getCursorPosition()
 # check if line starts with our comment string (i.e. was commented
 # by our comment...() slots
-if self.hasSelectedText() and \
+if (
-self.__isCommentedLine(self.text(self.getSelection()[0]),
+self.hasSelectedText() and
-commentStr):
+self.__isCommentedLine(self.text(self.getSelection()[0]),
+commentStr)
+):
 self.uncommentLineOrSelection()
 elif not self.__isCommentedLine(self.text(line), commentStr):
 # it doesn't, so comment the line or selection
 self.commentLineOrSelection()
 else:
 # determine the start of the comment block
 begline = line
-while begline > 0 and \
+while (
-self.__isCommentedLine(self.text(begline - 1), commentStr):
+begline > 0 and
+self.__isCommentedLine(self.text(begline - 1), commentStr)
+):
 begline -= 1
 # determine the end of the comment block
 endline = line
 lines = self.lines()
-while endline < lines and \
+while (
-self.__isCommentedLine(self.text(endline + 1), commentStr):
+endline < lines and
+self.__isCommentedLine(self.text(endline + 1), commentStr)
+):
 endline += 1
 self.setSelection(begline, 0, endline, self.lineLength(endline))
 self.uncommentLineOrSelection()
 marginBmMask = (1 << self.bookmark)
 self.setMarginWidth(self.__bmMargin, 16)
 self.setMarginSensitivity(self.__bmMargin, True)
 self.setMarginMarkerMask(self.__bmMargin, marginBmMask)
-marginBpMask = (1 << self.breakpoint) | \
+marginBpMask = (
-(1 << self.cbreakpoint) | \
+(1 << self.breakpoint) |
-(1 << self.tbreakpoint) | \
+(1 << self.cbreakpoint) |
-(1 << self.tcbreakpoint) | \
+(1 << self.tbreakpoint) |
-(1 << self.dbreakpoint)
+(1 << self.tcbreakpoint) |
+(1 << self.dbreakpoint)
+)
 self.setMarginWidth(self.__bpMargin, 16)
 self.setMarginSensitivity(self.__bpMargin, True)
 self.setMarginMarkerMask(self.__bpMargin, marginBpMask)
-marginIndicMask = (1 << self.syntaxerror) | \
+marginIndicMask = (
-(1 << self.notcovered) | \
+(1 << self.syntaxerror) |
-(1 << self.taskmarker) | \
+(1 << self.notcovered) |
-(1 << self.warning) | \
+(1 << self.taskmarker) |
-(1 << self.__changeMarkerUnsaved) | \
+(1 << self.warning) |
-(1 << self.__changeMarkerSaved) | \
+(1 << self.__changeMarkerUnsaved) |
-(1 << self.currentline) | \
+(1 << self.__changeMarkerSaved) |
-(1 << self.errorline)
+(1 << self.currentline) |
+(1 << self.errorline)
+)
 self.setMarginWidth(self.__indicMargin, 16)
 self.setMarginSensitivity(self.__indicMargin, True)
 self.setMarginMarkerMask(self.__indicMargin, marginIndicMask)
 # set linenumber margin settings
 self.searchIndicator = QsciScintilla.INDIC_CONTAINER
 self.indicatorDefine(
 self.searchIndicator, QsciScintilla.INDIC_BOX,
 Preferences.getEditorColour("SearchMarkers"))
-if not Preferences.getEditor("SearchMarkersEnabled") and \
+if (
-not Preferences.getEditor("QuickSearchMarkersEnabled") and \
+not Preferences.getEditor("SearchMarkersEnabled") and
-not Preferences.getEditor("MarkOccurrencesEnabled"):
+not Preferences.getEditor("QuickSearchMarkersEnabled") and
+not Preferences.getEditor("MarkOccurrencesEnabled")
+):
 self.clearAllIndicators(self.searchIndicator)
 self.spellingIndicator = QsciScintilla.INDIC_CONTAINER + 1
 self.indicatorDefine(
 self.spellingIndicator, QsciScintilla.INDIC_SQUIGGLE,
 def __setEolMode(self):
 """
 Private method to configure the eol mode of the editor.
 """
-if self.fileName and \
+if (
-self.project.isOpen() and \
+self.fileName and
-self.project.isProjectFile(self.fileName):
+self.project.isOpen() and
+self.project.isProjectFile(self.fileName)
+):
 eolMode = self.__getEditorConfig("EOLMode", nodefault=True)
 if eolMode is None:
 eolStr = self.project.getEolString()
 self.setEolModeByEolString(eolStr)
 else:
 pass
 if Preferences.getEditor("CallTipsEnabled"):
 if calltipsStyle == QsciScintilla.CallTipsNoContext:
 self.setCallTipsStyle(QsciScintilla.CallTipsNoContext)
-elif calltipsStyle == \
+elif (
-QsciScintilla.CallTipsNoAutoCompletionContext:
+calltipsStyle == QsciScintilla.CallTipsNoAutoCompletionContext
+):
 self.setCallTipsStyle(
 QsciScintilla.CallTipsNoAutoCompletionContext)
 else:
 self.setCallTipsStyle(QsciScintilla.CallTipsContext)
 else:
 @param enable flag indicating the desired autocompletion status
 (boolean)
 """
 if enable:
-autoCompletionSource = \
+autoCompletionSource = Preferences.getEditor(
-Preferences.getEditor("AutoCompletionSource")
+"AutoCompletionSource")
 if autoCompletionSource == QsciScintilla.AcsDocument:
 self.setAutoCompletionSource(QsciScintilla.AcsDocument)
 elif autoCompletionSource == QsciScintilla.AcsAPIs:
 self.setAutoCompletionSource(QsciScintilla.AcsAPIs)
 else:
 @param charNumber value of the character entered (integer)
 """
 char = chr(charNumber)
 # update code documentation viewer
-if char == "(" and \
+if (
-Preferences.getDocuViewer("ShowInfoOnOpenParenthesis"):
+char == "(" and
+Preferences.getDocuViewer("ShowInfoOnOpenParenthesis")
+):
 self.vm.showEditorInfo(self)
 if self.isListActive():
 if self.__isStartChar(char):
 self.cancelList()
 elif char == '(':
 self.cancelList()
 else:
 self.__acTimer.stop()
-if self.callTipsStyle() != QsciScintilla.CallTipsNone and \
+if (
-self.lexer_ is not None and chr(charNumber) in '()':
+self.callTipsStyle() != QsciScintilla.CallTipsNone and
+self.lexer_ is not None and chr(charNumber) in '()'
+):
 self.callTip()
 if not self.isCallTipActive():
 char = chr(charNumber)
 if self.__isStartChar(char):
 and function(editor, bool, str) returning nothing in case async
 is True
 @param asynchroneous flag indicating an asynchroneous function
 @type bool
 """
-if key in self.__completionListHookFunctions or \
+if (
-key in self.__completionListAsyncHookFunctions:
+key in self.__completionListHookFunctions or
+key in self.__completionListAsyncHookFunctions
+):
 # it was already registered
 E5MessageBox.warning(
 self,
 self.tr("Auto-Completion Provider"),
 self.tr("""The completion list provider '{0}' was already"""
 return
 if self.isListActive():
 self.cancelList()
-if self.__completionListHookFunctions or \
+if (
-self.__completionListAsyncHookFunctions:
+self.__completionListHookFunctions or
+self.__completionListAsyncHookFunctions
+):
 # Avoid delayed auto-completion after cursor repositioning
 self.__acText = self.__getAcText()
 if auto and Preferences.getEditor("AutoCompletionTimeout"):
 self.__acTimer.stop()
 self.__acContext = context
 len(self.__completionListHookFunctions)
 ):
 self.__acWatchdog.stop()
 # Autocomplete with QScintilla if no results present
-if Preferences.getEditor("AutoCompletionScintillaOnFail") and \
+if (
-not self.__acCompletions:
+Preferences.getEditor("AutoCompletionScintillaOnFail") and
+not self.__acCompletions
+):
 self.autoCompleteQScintilla()
 return
 # ... or completions are not empty
 if not bool(completions):
 @param evt the context menu event (QContextMenuEvent)
 """
 evt.accept()
 if self.__marginNumber(evt.x()) == -1:
 self.spellingMenuPos = self.positionFromPoint(evt.pos())
-if self.spellingMenuPos >= 0 and \
+if (
-self.spell is not None and \
+self.spellingMenuPos >= 0 and
-self.hasIndicator(self.spellingIndicator, self.spellingMenuPos):
+self.spell is not None and
+self.hasIndicator(self.spellingIndicator,
+self.spellingMenuPos)
+):
 self.spellingMenu.popup(evt.globalPos())
 else:
 self.menu.popup(evt.globalPos())
 else:
 self.line = self.lineAt(evt.pos())
 if not self.isResourcesFile:
 if self.fileName and self.isPyFile():
 self.menuActs["Show"].setEnabled(True)
 else:
 self.menuActs["Show"].setEnabled(False)
-if self.fileName and \
+if (
-(self.isPyFile() or self.isRubyFile()):
+self.fileName and
+(self.isPyFile() or self.isRubyFile())
+):
 self.menuActs["Diagrams"].setEnabled(True)
 else:
 self.menuActs["Diagrams"].setEnabled(False)
 if not self.miniMenu:
 if self.lexer_ is not None:
 """
 prEnable = False
 coEnable = False
 # first check if the file belongs to a project
-if self.project.isOpen() and \
+if (
-self.project.isProjectSource(self.fileName):
+self.project.isOpen() and
+self.project.isProjectSource(self.fileName)
+):
 fn = self.project.getMainScript(True)
 if fn is not None:
 tfn = Utilities.getTestFileName(fn)
 basename = os.path.splitext(fn)[0]
 tbasename = os.path.splitext(tfn)[0]
-prEnable = prEnable or \
+prEnable = (
-os.path.isfile("{0}.profile".format(basename)) or \
+prEnable or
+os.path.isfile("{0}.profile".format(basename)) or
 os.path.isfile("{0}.profile".format(tbasename))
+)
 coEnable = (
-coEnable or
+(coEnable or
 os.path.isfile("{0}.coverage".format(basename)) or
-os.path.isfile("{0}.coverage".format(tbasename))) and \
+os.path.isfile("{0}.coverage".format(tbasename))) and
 (self.project.isPy3Project() or
 self.project.isPy2Project())
+)
 # now check ourselves
 fn = self.getFileName()
 if fn is not None:
 tfn = Utilities.getTestFileName(fn)
 basename = os.path.splitext(fn)[0]
 tbasename = os.path.splitext(tfn)[0]
-prEnable = prEnable or \
+prEnable = (
-os.path.isfile("{0}.profile".format(basename)) or \
+prEnable or
+os.path.isfile("{0}.profile".format(basename)) or
 os.path.isfile("{0}.profile".format(tbasename))
+)
 coEnable = (
-coEnable or
+(coEnable or
 os.path.isfile("{0}.coverage".format(basename)) or
-os.path.isfile("{0}.coverage".format(tbasename))) and \
+os.path.isfile("{0}.coverage".format(tbasename))) and
 self.isPyFile()
+)
 # now check for syntax errors
 if self.hasSyntaxErrors():
 coEnable = False
 def __showContextMenuGraphics(self):
 """
 Private slot handling the aboutToShow signal of the diagrams context
 menu.
 """
-if self.project.isOpen() and \
+if (
-self.project.isProjectSource(self.fileName):
+self.project.isOpen() and
+self.project.isProjectSource(self.fileName)
+):
 self.applicationDiagramMenuAct.setEnabled(True)
 else:
 self.applicationDiagramMenuAct.setEnabled(False)
 self.showMenu.emit("Graphics", self.graphicsMenu, self)
 hasWarnings = bool(self.warnings)
 hasNotCoveredMarkers = bool(self.notcoveredMarkers)
 self.marginMenuActs["GotoSyntaxError"].setEnabled(hasSyntaxErrors)
 self.marginMenuActs["ClearSyntaxError"].setEnabled(hasSyntaxErrors)
-if hasSyntaxErrors and \
+if (
-self.markersAtLine(self.line) & (1 << self.syntaxerror):
+hasSyntaxErrors and
+self.markersAtLine(self.line) & (1 << self.syntaxerror)
+):
 self.marginMenuActs["ShowSyntaxError"].setEnabled(True)
 else:
 self.marginMenuActs["ShowSyntaxError"].setEnabled(False)
 self.marginMenuActs["NextWarningMarker"].setEnabled(hasWarnings)
 self.marginMenuActs["PreviousWarningMarker"].setEnabled(
 hasWarnings)
 self.marginMenuActs["ClearWarnings"].setEnabled(hasWarnings)
-if hasWarnings and \
+if (
-self.markersAtLine(self.line) & (1 << self.warning):
+hasWarnings and
+self.markersAtLine(self.line) & (1 << self.warning)
+):
 self.marginMenuActs["ShowWarning"].setEnabled(True)
 else:
 self.marginMenuActs["ShowWarning"].setEnabled(False)
 self.marginMenuActs["NextCoverageMarker"].setEnabled(
 @param act reference to the action that was triggered (QAction)
 """
 encoding = act.data()
 self.readFile(self.fileName, encoding=encoding)
+self.__convertTabs()
 self.__checkEncoding()
 def __contextSave(self):
 """
 Private slot handling the save context menu entry.
 line0Text = self.text(curLine)
 line1Text = self.text(curLine + 1)
 if line1Text in ["", "\r", "\n", "\r\n"]:
 return
-if line0Text.rstrip("\r\n\\ \t").endswith(("'", '"')) and \
+if (
-line1Text.lstrip().startswith(("'", '"')):
+line0Text.rstrip("\r\n\\ \t").endswith(("'", '"')) and
+line1Text.lstrip().startswith(("'", '"'))
+):
 # merging multi line strings
 startChars = "\r\n\\ \t'\""
 endChars = " \t'\""
 else:
 startChars = "\r\n\\ \t"
 """
 Public slot to check the autosave flags.
 @return flag indicating this editor should be saved (boolean)
 """
-return bool(self.fileName) and \
+return (
-not self.autosaveManuallyDisabled and \
+bool(self.fileName) and
+not self.autosaveManuallyDisabled and
 not self.isReadOnly()
+)
 def checkSyntax(self):
 """
 Public method to perform an automatic syntax check of the file.
 """
 fileType = self.filetype
 if fileType == "MicroPython":
 # adjustment for MicroPython
 fileType = "Python3"
-if self.syntaxCheckService is None or \
+if (
-fileType not in self.syntaxCheckService.getLanguages():
+self.syntaxCheckService is None or
+fileType not in self.syntaxCheckService.getLanguages()
+):
 return
 if Preferences.getEditor("AutoCheckSyntax"):
 if Preferences.getEditor("OnlineSyntaxCheck"):
 self.__onlineSyntaxCheckTimer.stop()
 """
 files = []
 # first check if the file belongs to a project and there is
 # a project coverage file
-if self.project.isOpen() and \
+if (
-self.project.isProjectSource(self.fileName):
+self.project.isOpen() and
+self.project.isProjectSource(self.fileName)
+):
 fn = self.project.getMainScript(True)
 if fn is not None:
 tfn = Utilities.getTestFileName(fn)
 basename = os.path.splitext(fn)[0]
 tbasename = os.path.splitext(tfn)[0]
 """
 files = []
 # first check if the file belongs to a project and there is
 # a project profile file
-if self.project.isOpen() and \
+if (
-self.project.isProjectSource(self.fileName):
+self.project.isOpen() and
+self.project.isProjectSource(self.fileName)
+):
 fn = self.project.getMainScript(True)
 if fn is not None:
 tfn = Utilities.getTestFileName(fn)
 basename = os.path.splitext(fn)[0]
 tbasename = os.path.splitext(tfn)[0]
 handle = self.markerAdd(line - 1, self.syntaxerror)
 self.syntaxerrors[handle] = [(msg, index)]
 self.syntaxerrorToggled.emit(self)
 else:
 for handle in list(self.syntaxerrors.keys()):
-if self.markerLine(handle) == line - 1 and \
+if (
-(msg, index) not in self.syntaxerrors[handle]:
+self.markerLine(handle) == line - 1 and
+(msg, index) not in self.syntaxerrors[handle]
+):
 self.syntaxerrors[handle].append((msg, index))
 if show:
 self.setCursorPosition(line - 1, index)
 self.ensureLineVisible(line - 1)
 else:
 handle = self.markerAdd(line - 1, self.warning)
 self.warnings[handle] = [warn]
 self.syntaxerrorToggled.emit(self)
 else:
 for handle in list(self.warnings.keys()):
-if self.markerLine(handle) == line - 1 and \
+if (
-warn not in self.warnings[handle]:
+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()):
 if self.markerLine(handle) == line - 1:
 del self.warnings[handle]
 def __setAnnotationStyles(self):
 """
 Private slot to define the style used by inline annotations.
 """
 if hasattr(QsciScintilla, "annotate"):
-self.annotationWarningStyle = \
+self.annotationWarningStyle = (
 QsciScintilla.STYLE_LASTPREDEFINED + 1
+)
 self.SendScintilla(
 QsciScintilla.SCI_STYLESETFORE,
 self.annotationWarningStyle,
 Preferences.getEditorColour("AnnotationsWarningForeground"))
 self.SendScintilla(
 """
 Private method to refresh the annotations.
 """
 if hasattr(QsciScintilla, "annotate"):
 self.clearAnnotations()
-for handle in list(self.warnings.keys()) + \
+for handle in (
-list(self.syntaxerrors.keys()):
+list(self.warnings.keys()) +
+list(self.syntaxerrors.keys())
+):
 line = self.markerLine(handle)
 self.__setAnnotation(line)
 #################################################################
 ## Fold handling methods
 try:
 self.setCaretWidth(self.caretWidth)
 except AttributeError:
 pass
 self.__updateReadOnly(False)
-if self.vm.editorsCheckFocusInEnabled() and \
+if (
-not self.inReopenPrompt and self.fileName and \
+self.vm.editorsCheckFocusInEnabled() and
-QFileInfo(self.fileName).lastModified().toString() != \
+not self.inReopenPrompt and self.fileName and
-self.lastModified.toString():
+QFileInfo(self.fileName).lastModified().toString() !=
+self.lastModified.toString()
+):
 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"""
-""" was opened in eric6. Reread it?</p>""")\
+""" was opened in eric6. Reread it?</p>"""
-.format(self.fileName)
+).format(self.fileName)
 yesDefault = True
 if self.isModified():
 msg += self.tr(
 """<br><b>Warning:</b> You will lose"""
 """ your changes upon reopening it.""")
 other modes. This is to make the editor windows work nicer
 with the QWorkspace.
 @param evt the event, that was generated (QEvent)
 """
-if evt.type() == QEvent.WindowStateChange and \
+if (
-bool(self.fileName):
+evt.type() == QEvent.WindowStateChange and
+bool(self.fileName)
+):
 if self.windowState() == Qt.WindowStates(Qt.WindowMinimized):
 cap = os.path.basename(self.fileName)
 else:
 cap = self.fileName
 if self.isReadOnly():
 """
 Protected method to handle wheel events.
 @param evt reference to the wheel event (QWheelEvent)
 """
-if qVersionTuple() >= (5, 0, 0):
+delta = evt.angleDelta().y()
-delta = evt.angleDelta().y()
-else:
-delta = evt.delta()
 if evt.modifiers() & Qt.ControlModifier:
 if delta < 0:
 self.zoomOut()
 elif delta > 0:
 self.zoomIn()
 signal if there was an attribute change.
 """
 if self.fileName == "":
 return
-readOnly = not QFileInfo(self.fileName).isWritable() or \
+readOnly = (
+not QFileInfo(self.fileName).isWritable() or
 self.isReadOnly()
+)
 if not bForce and (readOnly == self.isReadOnly()):
 return
 cap = self.fileName
 if readOnly:
 self.readFile(self.fileName)
 except IOError:
 # do not prompt for this change again...
 self.lastModified = QDateTime.currentDateTime()
 self.setModified(False)
+self.__convertTabs()
 # re-initialize the online change tracer
 self.__reinitOnlineChangeTrace()
 # reset cursor position
 """
 from Graphics.UMLDialog import UMLDialog
 if not self.checkDirty():
 return
-package = os.path.isdir(self.fileName) and \
+package = (
+os.path.isdir(self.fileName) and
 self.fileName or os.path.dirname(self.fileName)
+)
 res = E5MessageBox.yesNo(
 self,
 self.tr("Package Diagram"),
 self.tr("""Include class attributes?"""),
 yesDefault=True)
 """
 from Graphics.UMLDialog import UMLDialog
 if not self.checkDirty():
 return
-package = os.path.isdir(self.fileName) and self.fileName \
+package = (
-or os.path.dirname(self.fileName)
+os.path.isdir(self.fileName) and
+self.fileName or os.path.dirname(self.fileName)
+)
 res = E5MessageBox.yesNo(
 self,
 self.tr("Imports Diagram"),
 self.tr("""Include imports from external modules?"""))
 self.importsDiagram = UMLDialog(
 def projectOpened(self):
 """
 Public slot to handle the opening of a project.
 """
-if self.fileName and \
+if (
-self.project.isProjectSource(self.fileName):
+self.fileName and
+self.project.isProjectSource(self.fileName)
+):
 self.project.projectPropertiesChanged.connect(
 self.__projectPropertiesChanged)
 self.setSpellingForProject()
 def projectClosed(self):
 def setSpellingForProject(self):
 """
 Public method to set the spell checking options for files belonging
 to the current project.
 """
-if self.fileName and \
+if (
-self.project.isOpen() and \
+self.fileName and
-self.project.isProjectSource(self.fileName):
+self.project.isOpen() and
+self.project.isProjectSource(self.fileName)
+):
 pwl, pel = self.project.getProjectDictionaries()
 self.__setSpellingLanguage(self.project.getProjectSpellLanguage(),
 pwl=pwl, pel=pel)
 def setAutoSpellChecking(self):
 @return flag indicating pos is in a spell check region (boolean)
 """
 if self.__spellCheckStringsOnly:
 style = self.styleAt(pos)
 if self.lexer_ is not None:
-return self.lexer_.isCommentStyle(style) or \
+return (
+self.lexer_.isCommentStyle(style) or
 self.lexer_.isStringStyle(style)
+)
 return True
 @pyqtSlot(int)
 def __spellCharAdded(self, charNumber):
 """
 @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)
 """
-return bool(self.fileName) and \
+return (
-self.project.isOpen() and \
+(bool(self.fileName) and
-self.project.isProjectFile(self.fileName), \
+self.project.isOpen() and
-self.__isShared, self.__inSharedEdit, self.__inRemoteSharedEdit
+self.project.isProjectFile(self.fileName)),
+self.__isShared,
+self.__inSharedEdit,
+self.__inRemoteSharedEdit
+)
 def shareConnected(self, connected):
 """
 Public slot to handle a change of the connected state.
 Public slot to handle received editor commands.
 @param command command string (string)
 """
 if self.__isShared:
-if self.__isSyncing and \
+if (
-not command.startswith(Editor.SyncToken + Editor.Separator):
+self.__isSyncing and
+not command.startswith(Editor.SyncToken + Editor.Separator)
+):
 self.__receivedWhileSyncing.append(command)
 else:
 self.__dispatchCommand(command)
 def __dispatchCommand(self, command):
 from .SortOptionsDialog import SortOptionsDialog
 dlg = SortOptionsDialog()
 if dlg.exec_() == QDialog.Accepted:
 ascending, alnum, caseSensitive = dlg.getData()
-origStartLine, origStartIndex, origEndLine, origEndIndex = \
+origStartLine, origStartIndex, origEndLine, origEndIndex = (
 self.getRectangularSelection()
+)
 # convert to upper-left to lower-right
 startLine = min(origStartLine, origEndLine)
 startIndex = min(origStartIndex, origEndIndex)
 endLine = max(origStartLine, origEndLine)
 endIndex = max(origStartIndex, origEndIndex)
 key = (int(modifiers), int(button))
 self.vm.eventFilter(self, evt)
 super(Editor, self).mouseReleaseEvent(evt)
-if button != Qt.NoButton and \
+if (
-Preferences.getEditor("MouseClickHandlersEnabled") and \
+button != Qt.NoButton and
-key in self.__mouseClickHandlers:
+Preferences.getEditor("MouseClickHandlersEnabled") and
+key in self.__mouseClickHandlers
+):
 evt.accept()
 self.__mouseClickHandlers[key][1](self)
 def setMouseClickHandler(self, name, modifiers, button, function):
 """
 if not config:
 if nodefault:
 return None
 else:
-return Preferences.getEditor(option)
+value = self.__getOverrideValue(option)
+if value is None:
+# no override
+value = Preferences.getEditor(option)
+return value
 try:
 if option == "EOLMode":
 value = config["end_of_line"]
 if value == "lf":
 except KeyError:
 value = None
 if value is None and not nodefault:
 # use Preferences in case of error
-value = Preferences.getEditor(option)
+value = self.__getOverrideValue(option)
+if value is None:
+# no override
+value = Preferences.getEditor(option)
 return value
 def getEditorConfig(self, option):
 """
 @return value of requested setting
 @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
+"""
+if option in ("TabWidth", "IndentWidth"):
+overrides = Preferences.getEditor("TabIndentOverride")
+if self.filetype in overrides:
+if option == "TabWidth":
+return overrides[self.filetype][0]
+elif option == "IndentWidth":
+return overrides[self.filetype][1]
+return None
 def mouseDoubleClickEvent(self, evt):
 """
 Protected method to handle mouse double click events.
 @param evt reference to the mouse event

Mercurial Repositories > eric / file comparison

comparison: eric6/QScintilla/Editor.py

eric6/QScintilla/Editor.py