eric: comparison eric6/QScintilla/Editor.py

-:fb0ef164f536
+:698ae46f40a4
 """
 import os
 import re
 import difflib
+import contextlib
+import editorconfig
 from PyQt5.QtCore import (
 pyqtSignal, pyqtSlot, Qt, QDir, QTimer, QModelIndex, QFileInfo,
 QCryptographicHash, QEvent, QDateTime, QPoint
 )
 import Preferences
 import Utilities
 from Utilities import MouseUtilities
 import UI.PixmapCache
-from ThirdParty.EditorConfig import editorconfig
 EditorAutoCompletionListID = 1
 TemplateCompletionListID = 2
 @type TaskViewer
 @param parent reference to the parent widget
 @type QWidget
 @exception OSError raised to indicate an issue accessing the file
 """
-super(Editor, self).__init__(parent)
+super().__init__(parent)
 self.setAttribute(Qt.WidgetAttribute.WA_KeyCompression)
 self.setUtf8(True)
 self.dbs = dbs
 self.taskViewer = tv
 elif self.filetype in ["Python", "Python3", "MicroPython"]:
 bindName = "dummy.py"
 if not bindName and line0.startswith("#!"):
 # #! marker detection
-if "python3" in line0:
+if (
-bindName = "dummy.py"
+"python3" in line0 or
-self.filetype = "Python3"
+"python" in line0 or
-elif "python" in line0:
+"pypy3" in line0 or
-bindName = "dummy.py"
+"pypy" in line0
-self.filetype = "Python3"
+):
-elif "pypy3" in line0:
-bindName = "dummy.py"
-self.filetype = "Python3"
-elif "pypy" in line0:
 bindName = "dummy.py"
 self.filetype = "Python3"
 elif ("/bash" in line0 or "/sh" in line0):
 bindName = "dummy.sh"
 elif "ruby" in line0:
 def __checkEncoding(self):
 """
 Private method to check the selected encoding of the encodings submenu.
 """
-try:
+with contextlib.suppress(AttributeError, KeyError):
 (self.supportedEncodings[self.__normalizedEncoding()]
 .setChecked(True))
-except (AttributeError, KeyError):
-pass
 def __encodingChanged(self, encoding, propagate=True):
 """
 Private slot to handle a change of the encoding.
 def __checkEol(self):
 """
 Private method to check the selected eol type of the eol submenu.
 """
-try:
+with contextlib.suppress(AttributeError, TypeError):
 self.supportedEols[self.getLineSeparator()].setChecked(True)
-except (AttributeError, TypeError):
-pass
 def __eolChanged(self):
 """
 Private slot to handle a change of the eol mode.
 """
 def __checkSpellLanguage(self):
 """
 Private slot to check the selected spell check language action.
 """
 language = self.getSpellingLanguage()
-try:
+with contextlib.suppress(AttributeError, KeyError):
 self.supportedSpellLanguages[language].setChecked(True)
-except (AttributeError, KeyError):
-pass
 def __spellLanguageChanged(self, language, propagate=True):
 """
 Private slot to handle a change of the spell check language.
 self.__setMarginsDisplay()
 if self.lexer_.lexer() == "container" or self.lexer_.lexer() is None:
 self.SCN_STYLENEEDED.connect(self.__styleNeeded)
 # get the font for style 0 and set it as the default font
-if pyname and pyname.startswith("Pygments|"):
+key = (
-key = 'Scintilla/Guessed/style0/font'
+'Scintilla/Guessed/style0/font'
-else:
+if pyname and pyname.startswith("Pygments|") else
-key = 'Scintilla/{0}/style0/font'.format(self.lexer_.language())
+'Scintilla/{0}/style0/font'.format(self.lexer_.language())
+)
 fdesc = Preferences.Prefs.settings.value(key)
 if fdesc is not None:
 font = QFont(fdesc[0], int(fdesc[1]))
 self.lexer_.setDefaultFont(font)
 self.lexer_.readSettings(Preferences.Prefs.settings, "Scintilla")
 # now set the lexer properties
 self.lexer_.initProperties()
 # initialize the lexer APIs settings
-if self.project.isOpen() and self.project.isProjectFile(filename):
+projectType = (
-projectType = self.project.getProjectType()
+self.project.getProjectType()
-else:
+if self.project.isOpen() and self.project.isProjectFile(filename)
-projectType = ""
+else ""
+)
 api = self.vm.getAPIsManager().getAPIs(self.apiLanguage,
 projectType=projectType)
 if api is not None and not api.isEmpty():
 self.lexer_.setAPIs(api.getQsciAPIs())
 self.acAPI = True
 @return flag indicating a Javascript file (boolean)
 """
 if self.filetype == "JavaScript":
 return True
-if self.filetype == "":
+if (
-if (
+self.filetype == "" and
 self.fileName and
 os.path.splitext(self.fileName)[1] == ".js"
 ):
 self.filetype = "JavaScript"
 return True
 return False
 def highlightVisible(self):
 """
 @param annotationLinesAdded number of added/deleted annotation lines
 (integer)
 """
 if (
 mtype & (self.SC_MOD_INSERTTEXT | self.SC_MOD_DELETETEXT) and
-linesAdded != 0
+linesAdded != 0 and
+self.breaks
 ):
-if self.breaks:
+bps = []    # list of breakpoints
-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
-line = self.markerLine(handle) + 1
+if ln != line:
-if ln != line:
+bps.append((ln, line))
-bps.append((ln, line))
+self.breaks[handle] = (line, cond, temp, enabled,
-self.breaks[handle] = (line, cond, temp, enabled,
+ignorecount)
-ignorecount)
+self.inLinesChanged = True
-self.inLinesChanged = True
+for ln, line in sorted(bps, reverse=linesAdded > 0):
-for ln, line in sorted(bps, reverse=linesAdded > 0):
+index1 = self.breakpointModel.getBreakPointIndex(
-index1 = self.breakpointModel.getBreakPointIndex(
+self.fileName, ln)
-self.fileName, ln)
+index2 = self.breakpointModel.index(index1.row(), 1)
-index2 = self.breakpointModel.index(index1.row(), 1)
+self.breakpointModel.setData(index2, line)
-self.breakpointModel.setData(index2, line)
+self.inLinesChanged = False
-self.inLinesChanged = False
 def __restoreBreakpoints(self):
 """
 Private method to restore the breakpoints.
 """
 self.markerDeleteAll(self.taskmarker)
 self.taskViewer.clearFileTasks(self.fileName)
 self.__hasTaskMarkers = False
 # now search tasks and record them
-lineIndex = -1
+for lineIndex, line in enumerate(txtList):
-for line in txtList:
-lineIndex += 1
 shouldBreak = False
 if line.endswith("__NO-TASK__"):
 # ignore potential task marker
 continue
 permissions = os.stat(fn).st_mode
 perms_valid = True
 except OSError:
 # if there was an error, ignore it
 perms_valid = False
-try:
+with contextlib.suppress(OSError):
 os.remove(bfn)
-except OSError:
+with contextlib.suppress(OSError):
-# if there was an error, ignore it
-pass
-try:
 os.rename(fn, bfn)
-except OSError:
-# if there was an error, ignore it
-pass
 # now write text to the file fn
 try:
 editorConfigEncoding = self.__getEditorConfig(
 "DefaultEncoding", nodefault=True, config=config)
 if (
 self.fileName and
 self.project.startswithProjectPath(self.fileName)
 ):
 path = os.path.dirname(self.fileName)
-else:
+elif not self.fileName:
 path = self.project.getProjectPath()
 if not path and self.fileName:
 path = os.path.dirname(self.fileName)
 if not path:
 fn = self.__getSaveFileName(path)
 if not fn:
 return False
 res = self.writeFile(fn)
-if res:
+if (
+res and
+self.project.isOpen() and
+self.project.startswithProjectPath(fn)
+):
 # save to project, if a project is loaded
-if (
+self.project.appendFile(fn)
-self.project.isOpen() and
-self.project.startswithProjectPath(fn)
-):
-self.project.appendFile(fn)
 return res
 def saveFile(self, saveas=False, path=None):
 """
 if wc is None or not useWordChars:
 pattern = r"\b[\w_]+\b"
 else:
 wc = re.sub(r'\w', "", wc)
 pattern = r"\b[\w{0}]+\b".format(re.escape(wc))
-if self.caseSensitive():
+rx = (
-rx = re.compile(pattern)
+re.compile(pattern)
-else:
+if self.caseSensitive() else
-rx = re.compile(pattern, re.IGNORECASE)
+re.compile(pattern, re.IGNORECASE)
+)
 text = self.text(line)
 for match in rx.finditer(text):
 start, end = match.span()
 if start <= index <= end:
 pos = self.positionBefore(pos)
 ch = self.charAt(pos)
 # Don't go past the end of the previous line
-if ch == '\n' or ch == '\r':
+if ch in ('\n', '\r'):
 return "", pos
 return ch, pos
 def getSearchText(self, selectionOnly=False):
 line, index = self.getCursorPosition()
 self.beginUndoAction()
 if Preferences.getEditor("CommentColumn0"):
 self.insertAt(self.lexer_.commentStr(), line, 0)
 else:
-self.insertAt(self.lexer_.commentStr(), line,
+lineText = self.text(line)
-self.indentation(line))
+pos = len(lineText.replace(lineText.lstrip(" \t"), ""))
+self.insertAt(self.lexer_.commentStr(), line, pos)
 self.endUndoAction()
 def uncommentLine(self):
 """
 Public slot to uncomment the current line.
 # now remove the comment string
 self.beginUndoAction()
 if Preferences.getEditor("CommentColumn0"):
 self.setSelection(line, 0, line, len(commentStr))
 else:
-self.setSelection(line, self.indentation(line),
+lineText = self.text(line)
-line, self.indentation(line) + len(commentStr))
+pos = len(lineText.replace(lineText.lstrip(" \t"), ""))
+self.setSelection(line, pos, line, pos + len(commentStr))
 self.removeSelectedText()
 self.endUndoAction()
 def commentSelection(self):
 """
 commentStr = self.lexer_.commentStr()
 # get the selection boundaries
 lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
-if indexTo == 0:
+endLine = lineTo if indexTo else lineTo - 1
-endLine = lineTo - 1
-else:
-endLine = lineTo
 self.beginUndoAction()
 # iterate over the lines
 for line in range(lineFrom, endLine + 1):
 if Preferences.getEditor("CommentColumn0"):
 self.insertAt(commentStr, line, 0)
 else:
-self.insertAt(commentStr, line, self.indentation(line))
+lineText = self.text(line)
+pos = len(lineText.replace(lineText.lstrip(" \t"), ""))
+self.insertAt(commentStr, line, pos)
 # change the selection accordingly
 self.setSelection(lineFrom, 0, endLine + 1, 0)
 self.endUndoAction()
 commentStr = self.lexer_.commentStr()
 # get the selection boundaries
 lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
-if indexTo == 0:
+endLine = lineTo if indexTo else lineTo - 1
-endLine = lineTo - 1
-else:
-endLine = lineTo
 self.beginUndoAction()
 # iterate over the lines
 for line in range(lineFrom, endLine + 1):
 # check if line starts with our comment string (i.e. was commented
 continue
 if Preferences.getEditor("CommentColumn0"):
 self.setSelection(line, 0, line, len(commentStr))
 else:
-self.setSelection(line,
+lineText = self.text(line)
-self.indentation(line),
+pos = len(lineText.replace(lineText.lstrip(" \t"), ""))
-line,
+self.setSelection(line, pos, line, pos + len(commentStr))
-self.indentation(line) + len(commentStr))
 self.removeSelectedText()
 # adjust selection start
 if line == lineFrom:
 indexFrom -= len(commentStr)
 commentStr = self.lexer_.boxCommentStr()
 # get the selection boundaries
 lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
-if indexTo == 0:
+endLine = lineTo if indexTo else lineTo - 1
-endLine = lineTo - 1
-else:
-endLine = lineTo
 self.beginUndoAction()
 # iterate over the lines
 for line in range(lineFrom, endLine + 1):
 self.insertAt(commentStr['middle'], line, 0)
 if not self.hasSelectedText():
 return
 # get the selection
 lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
+endLine = lineTo if indexTo else lineTo - 1
-if indexTo == 0:
-endLine = lineTo - 1
-else:
-endLine = lineTo
 self.beginUndoAction()
 # iterate over the lines
 for line in range(lineFrom, endLine + 1):
 if indent:
 # set folding margin settings
 if Preferences.getEditor("FoldingMargin"):
 self.setMarginWidth(self.__foldMargin, 16)
 folding = Preferences.getEditor("FoldingStyle")
-try:
+with contextlib.suppress(AttributeError):
 folding = QsciScintilla.FoldStyle(folding)
-except AttributeError:
-pass
 self.setFolding(folding, self.__foldMargin)
 self.setFoldMarginColors(
 Preferences.getEditorColour("FoldmarginBackground"),
 Preferences.getEditorColour("FoldmarginBackground"))
 self.setFoldMarkersColors(
 self.setIndentationGuidesForegroundColor(
 Preferences.getEditorColour("IndentationGuidesForeground"))
 if Preferences.getEditor("ShowWhitespace"):
 self.setWhitespaceVisibility(
 QsciScintilla.WhitespaceVisibility.WsVisible)
-try:
+with contextlib.suppress(AttributeError):
 self.setWhitespaceForegroundColor(
 Preferences.getEditorColour("WhitespaceForeground"))
 self.setWhitespaceBackgroundColor(
 Preferences.getEditorColour("WhitespaceBackground"))
 self.setWhitespaceSize(
 Preferences.getEditor("WhitespaceSize"))
-except AttributeError:
-# QScintilla before 2.5 doesn't support this
-pass
 else:
 self.setWhitespaceVisibility(
 QsciScintilla.WhitespaceVisibility.WsInvisible)
 self.setEolVisibility(Preferences.getEditor("ShowEOL"))
 self.setAutoIndent(Preferences.getEditor("AutoIndentation"))
 self.highlightIndicator, QsciScintilla.INDIC_FULLBOX,
 Preferences.getEditorColour("HighlightMarker"))
 self.setCursorFlashTime(QApplication.cursorFlashTime())
-try:
+with contextlib.suppress(AttributeError):
 if Preferences.getEditor("AnnotationsEnabled"):
 self.setAnnotationDisplay(
 QsciScintilla.AnnotationDisplay.AnnotationBoxed)
 else:
 self.setAnnotationDisplay(
 QsciScintilla.AnnotationDisplay.AnnotationHidden)
-except AttributeError:
-pass
 self.__setAnnotationStyles()
 if Preferences.getEditor("OverrideEditAreaColours"):
 self.setColor(Preferences.getEditorColour("EditAreaForeground"))
 self.setPaper(Preferences.getEditorColour("EditAreaBackground"))
 Preferences.getEditorColour("CallTipsForeground"))
 self.setCallTipsHighlightColor(
 Preferences.getEditorColour("CallTipsHighlight"))
 self.setCallTipsVisible(Preferences.getEditor("CallTipsVisible"))
 calltipsStyle = Preferences.getEditor("CallTipsStyle")
-try:
+with contextlib.suppress(AttributeError):
 self.setCallTipsPosition(
 Preferences.getEditor("CallTipsPosition"))
-except AttributeError:
-pass
 if Preferences.getEditor("CallTipsEnabled"):
 if calltipsStyle == QsciScintilla.CallTipsStyle.CallTipsNoContext:
 self.setCallTipsStyle(
 QsciScintilla.CallTipsStyle.CallTipsNoContext)
 """
 if self.lexer_ is None:
 return False
 wseps = self.lexer_.autoCompletionWordSeparators()
-for wsep in wseps:
+return any(wsep.endswith(ch) for wsep in wseps)
-if wsep.endswith(ch):
-return True
-return False
 def __autocompletionCancelled(self):
 """
 Private slot to handle the cancellation of an auto-completion list.
 """
 self.__acTimer.stop()
 self.__acContext = context
 self.__acTimer.start()
 else:
 self.__autoComplete(auto, context)
-elif not auto:
-self.autoCompleteQScintilla()
 elif (
-self.autoCompletionSource() !=
+not auto or
-QsciScintilla.AutoCompletionSource.AcsNone
+(self.autoCompletionSource() !=
+QsciScintilla.AutoCompletionSource.AcsNone)
 ):
 self.autoCompleteQScintilla()
 def __getAcText(self):
 """
 @rtype str
 """
 line, col = self.getCursorPosition()
 text = self.text(line)
 try:
-if self.__isStartChar(text[col - 1]):
+acText = (
-acText = self.getWordLeft(line, col - 1) + text[col - 1]
+self.getWordLeft(line, col - 1) + text[col - 1]
-else:
+if self.__isStartChar(text[col - 1]) else
-acText = self.getWordLeft(line, col)
+self.getWordLeft(line, col)
+)
 except IndexError:
 acText = ""
 return acText
 # Suppress empty completions
 if auto and self.__acText == '':
 return
-if self.__acCacheEnabled:
+completions = (
-completions = self.__acCache.get(self.__acText)
+self.__acCache.get(self.__acText)
-else:
+if self.__acCacheEnabled else
-completions = None
+None
+)
 if completions is not None:
 # show list with cached entries
 if self.isListActive():
 self.cancelList()
 Private method to show the completions list.
 @param completions completions to be shown
 @type list of str or set of str
 """
-if Preferences.getEditor("AutoCompletionReversedList"):
+acCompletions = (
-acCompletions = sorted(
+sorted(
 list(completions),
 key=self.__replaceLeadingUnderscores)
-else:
+if Preferences.getEditor("AutoCompletionReversedList") else
-acCompletions = sorted(list(completions))
+sorted(list(completions))
+)
 self.showUserList(EditorAutoCompletionListID, acCompletions)
 def __replaceLeadingUnderscores(self, txt):
 """
 Private method to replace the first two underlines for invers sorting.
 Public method to show calltips.
 """
 if bool(self.__ctHookFunctions):
 self.__callTip()
 else:
-super(Editor, self).callTip()
+super().callTip()
 def __callTip(self):
 """
 Private method to show call tips provided by a plugin.
 """
 self.SendScintilla(QsciScintilla.SCI_CALLTIPCANCEL)
 if not found:
 return
+callTips = []
 if self.__ctHookFunctions:
-callTips = []
 for key in self.__ctHookFunctions:
 callTips.extend(self.__ctHookFunctions[key](self, pos, commas))
 callTips = list(set(callTips))
 callTips.sort()
+else:
+# try QScintilla calltips
+super().callTip()
+return
 if len(callTips) == 0:
 if Preferences.getEditor("CallTipsScintillaOnFail"):
 # try QScintilla calltips
-super(Editor, self).callTip()
+super().callTip()
 return
 ctshift = 0
 for ct in callTips:
 shift = ct.index("(")
 if ctshift < shift:
 ctshift = shift
 cv = self.callTipsVisible()
-if cv > 0:
+ct = (
 # this is just a safe guard
-ct = self._encodeString("\n".join(callTips[:cv]))
+self._encodeString("\n".join(callTips[:cv]))
-else:
+if cv > 0 else
 # until here and unindent below
-ct = self._encodeString("\n".join(callTips))
+self._encodeString("\n".join(callTips))
+)
 self.SendScintilla(QsciScintilla.SCI_CALLTIPSHOW,
 self.__adjustedCallTipPosition(ctshift, pos), ct)
 if b'\n' in ct:
 return
 QsciScintilla.SCI_POSITIONFROMLINE,
 self.SendScintilla(QsciScintilla.SCI_LINEFROMPOSITION, ct))
 if ct - ctshift < ctmin:
 ct = ctmin
 else:
-ct = ct - ctshift
+ct -= ctshift
 return ct
 #################################################################
 ## Methods needed by the code documentation viewer
 #################################################################
 else:
 self.menuActs["Comment"].setEnabled(False)
 self.menuActs["Uncomment"].setEnabled(False)
 self.menuActs["StreamComment"].setEnabled(False)
 self.menuActs["BoxComment"].setEnabled(False)
+cline = self.getCursorPosition()[0]
+line = self.text(cline)
+self.menuActs["Docstring"].setEnabled(
+self.getDocstringGenerator().isFunctionStart(line))
 self.menuActs["TypingAidsEnabled"].setEnabled(
 self.completer is not None)
 self.menuActs["TypingAidsEnabled"].setChecked(
 self.completer is not None and self.completer.isEnabled())
 else:
 self.menuActs["NewSplit"].setIcon(
 UI.PixmapCache.getIcon("splitVertical"))
 self.menuActs["Tools"].setEnabled(not self.toolsMenu.isEmpty())
-cline = self.getCursorPosition()[0]
-line = self.text(cline)
-self.menuActs["Docstring"].setEnabled(
-self.getDocstringGenerator().isFunctionStart(line))
 self.showMenu.emit("Main", self.menu, self)
 def __showContextMenuAutocompletion(self):
 """
 Public slot to handle the 'Goto syntax error' context menu action.
 """
 seline = self.markerFindNext(0, 1 << self.syntaxerror)
 if seline >= 0:
 index = 0
-for handle in self.syntaxerrors.keys():
+for handle in self.syntaxerrors:
 if self.markerLine(handle) == seline:
 index = self.syntaxerrors[handle][0][1]
 self.setCursorPosition(seline, index)
 self.ensureLineVisible(seline)
 warningAnnotations = []
 errorAnnotations = []
 styleAnnotations = []
 # step 1: do warnings
-for handle in self.warnings.keys():
+for handle in self.warnings:
 if self.markerLine(handle) == line:
 for msg, warningType in self.warnings[handle]:
 if warningType == self.WarningStyle:
 styleAnnotations.append(
 self.tr("Style: {0}").format(msg))
 else:
 warningAnnotations.append(
 self.tr("Warning: {0}").format(msg))
 # step 2: do syntax errors
-for handle in self.syntaxerrors.keys():
+for handle in self.syntaxerrors:
 if self.markerLine(handle) == line:
 for msg, _ in self.syntaxerrors[handle]:
 errorAnnotations.append(
 self.tr("Error: {0}").format(msg))
 def undo(self):
 """
 Public method to undo the last recorded change.
 """
-super(Editor, self).undo()
+super().undo()
 self.undoAvailable.emit(self.isUndoAvailable())
 self.redoAvailable.emit(self.isRedoAvailable())
 def redo(self):
 """
 Public method to redo the last recorded change.
 """
-super(Editor, self).redo()
+super().redo()
 self.undoAvailable.emit(self.isUndoAvailable())
 self.redoAvailable.emit(self.isRedoAvailable())
 def close(self, alsoDelete=False):
 """
 self.__processSyntaxCheckError)
 if self.spell:
 self.spell.stopIncrementalCheck()
-try:
+with contextlib.suppress(TypeError):
 self.project.projectPropertiesChanged.disconnect(
 self.__projectPropertiesChanged)
-except TypeError:
-pass
 if self.fileName:
 self.taskViewer.clearFileTasks(self.fileName, True)
-super(Editor, self).close()
+super().close()
 def keyPressEvent(self, ev):
 """
 Protected method to handle the user input a key at a time.
 @param encString string to use to enclose the selection
 (one or two characters)
 @type str
 """
 startChar = encString[0]
-if len(encString) == 2:
+endChar = encString[1] if len(encString) == 2 else startChar
-endChar = encString[1]
-else:
-endChar = startChar
 sline, sindex, eline, eindex = self.getSelection()
 replaceText = startChar + self.selectedText() + endChar
 self.beginUndoAction()
 self.replaceSelectedText(replaceText)
 txt = ev.text()
 # See it is text to insert.
 if len(txt) and txt >= " ":
-if self.hasSelectedText():
+if (
-if txt in Editor.EncloseChars:
+self.hasSelectedText() and
-encloseSelectedText(Editor.EncloseChars[txt])
+txt in Editor.EncloseChars
-ev.accept()
+):
-return
+encloseSelectedText(Editor.EncloseChars[txt])
+ev.accept()
+return
-super(Editor, self).keyPressEvent(ev)
+super().keyPressEvent(ev)
 else:
 ev.ignore()
 def focusInEvent(self, event):
 """
 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)
-try:
+with contextlib.suppress(AttributeError):
 self.setCaretWidth(self.caretWidth)
-except AttributeError:
-pass
 self.__updateReadOnly(False)
 if (
 self.vm.editorsCheckFocusInEnabled() and
 not self.inReopenPrompt and self.fileName and
 QFileInfo(self.fileName).lastModified().toString() !=
 self.lastModified = QFileInfo(self.fileName).lastModified()
 self.inReopenPrompt = False
 self.setCursorFlashTime(QApplication.cursorFlashTime())
-super(Editor, self).focusInEvent(event)
+super().focusInEvent(event)
 def focusOutEvent(self, event):
 """
 Protected method called when the editor loses focus.
 @type QFocusEvent
 """
 self.vm.editorActGrp.setEnabled(False)
 self.setCaretWidth(0)
-super(Editor, self).focusOutEvent(event)
+super().focusOutEvent(event)
 def changeEvent(self, evt):
 """
 Protected method called to process an event.
 cap = self.fileName
 if self.isReadOnly():
 cap = self.tr("{0} (ro)").format(cap)
 self.setWindowTitle(cap)
-super(Editor, self).changeEvent(evt)
+super().changeEvent(evt)
 def mousePressEvent(self, event):
 """
 Protected method to handle the mouse press event.
 @param event the mouse press event
 @type QMouseEvent
 """
 self.vm.eventFilter(self, event)
-super(Editor, self).mousePressEvent(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(Editor, self).mouseDoubleClickEvent(evt)
+super().mouseDoubleClickEvent(evt)
 self.mouseDoubleClick.emit(evt.pos(), evt.buttons())
 def wheelEvent(self, evt):
 """
 elif delta > 0:
 self.gotoMethodClass(True)
 evt.accept()
 return
-super(Editor, self).wheelEvent(evt)
+super().wheelEvent(evt)
 def event(self, evt):
 """
 Public method handling events.
 """
 if evt.type() == QEvent.Type.Gesture:
 self.gestureEvent(evt)
 return True
-return super(Editor, self).event(evt)
+return super().event(evt)
 def gestureEvent(self, evt):
 """
 Protected method handling gesture events.
 Protected method handling resize events.
 @param evt reference to the resize event
 @type QResizeEvent
 """
-super(Editor, self).resizeEvent(evt)
+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
 """
-try:
+with contextlib.suppress(AttributeError):
 self.__markerMap.calculateGeometry()
-except AttributeError:
+return super().viewportEvent(evt)
-# ignore this - there seems to be a runtime issue when the editor
-# is created
-pass
-return super(Editor, self).viewportEvent(evt)
 def __updateReadOnly(self, bForce=True):
 """
 Private method to update the readOnly information for this editor.
 def clearStyles(self):
 """
 Public method to set the styles according the selected Qt style
 or the selected editor colours.
 """
-super(Editor, self).clearStyles()
+super().clearStyles()
 if Preferences.getEditor("OverrideEditAreaColours"):
 self.setColor(Preferences.getEditorColour("EditAreaForeground"))
 self.setPaper(Preferences.getEditorColour("EditAreaBackground"))
 #################################################################
 """
 self.inDragDrop = event.mimeData().hasUrls()
 if self.inDragDrop:
 event.acceptProposedAction()
 else:
-super(Editor, self).dragEnterEvent(event)
+super().dragEnterEvent(event)
 def dragMoveEvent(self, event):
 """
 Protected method to handle the drag move event.
 @param event the drag move event (QDragMoveEvent)
 """
 if self.inDragDrop:
 event.accept()
 else:
-super(Editor, self).dragMoveEvent(event)
+super().dragMoveEvent(event)
 def dragLeaveEvent(self, event):
 """
 Protected method to handle the drag leave event.
 """
 if self.inDragDrop:
 self.inDragDrop = False
 event.accept()
 else:
-super(Editor, self).dragLeaveEvent(event)
+super().dragLeaveEvent(event)
 def dropEvent(self, event):
 """
 Protected method to handle the drop event.
 self.tr("Drop Error"),
 self.tr("""<p><b>{0}</b> is not a file.</p>""")
 .format(fname))
 event.acceptProposedAction()
 else:
-super(Editor, self).dropEvent(event)
+super().dropEvent(event)
 self.inDragDrop = False
 #################################################################
 ## Support for Qt resources files
 matchingPairs = ['()', '[]', '{}', '<>', "''", '""']
 # __IGNORE_WARNING_M613__
 if text in matchingPairs:
 self.delete()
-super(Editor, self).editorCommand(cmd)
+super().editorCommand(cmd)
 def __applyTemplate(self, templateName, language):
 """
 Private method to apply a template by name.
 def projectClosed(self):
 """
 Public slot to handle the closing of a project.
 """
-try:
+with contextlib.suppress(TypeError):
 self.project.projectPropertiesChanged.disconnect(
 self.__projectPropertiesChanged)
-except TypeError:
-pass
 #######################################################################
 ## Spell checking related methods
 #######################################################################
 def setAutoSpellChecking(self):
 """
 Public method to set the automatic spell checking.
 """
 if Preferences.getEditor("AutoSpellCheckingEnabled"):
-try:
+with contextlib.suppress(TypeError):
 self.SCN_CHARADDED.connect(
 self.__spellCharAdded, Qt.ConnectionType.UniqueConnection)
-except TypeError:
-pass
 self.spell.checkDocumentIncrementally()
 else:
-try:
+with contextlib.suppress(TypeError):
 self.SCN_CHARADDED.disconnect(self.__spellCharAdded)
-except TypeError:
-pass
 self.clearAllIndicators(self.spellingIndicator)
 def isSpellCheckRegion(self, pos):
 """
 Public method to check, if the given position is within a region, that
 @return flag indicating pos is in a spell check region
 @rtype bool
 """
 if self.__spellCheckStringsOnly:
 if (
-self.__fileNameExtension in
+(self.__fileNameExtension in
-Preferences.getEditor("FullSpellCheckExtensions")
+Preferences.getEditor("FullSpellCheckExtensions")) or
-):
+(not self.__fileNameExtension and
-return True
+Preferences.getEditor("FullSpellCheckUnknown"))
-elif (
-not self.__fileNameExtension and
-Preferences.getEditor("FullSpellCheckUnknown")
 ):
 return True
 else:
 style = self.styleAt(pos)
 if self.lexer_ is not None:
 wordStart, wordEnd = self.getCurrentWordBoundaries()
 wordStartPos = self.positionFromLineIndex(line, wordStart)
 wordEndPos = self.positionFromLineIndex(line, wordEnd)
 regExp = re.compile(r"\b{0}\b".format(word))
-if forward:
+startPos = wordEndPos if forward else wordStartPos
-startPos = wordEndPos
-else:
-startPos = wordStartPos
 matches = [m for m in regExp.finditer(self.text())]
 if matches:
 if forward:
 matchesAfter = [m for m in matches if m.start() >= startPos]
 modifiers = evt.modifiers()
 button = evt.button()
 key = (int(modifiers), int(button))
 self.vm.eventFilter(self, evt)
-super(Editor, self).mouseReleaseEvent(evt)
+super().mouseReleaseEvent(evt)
 if (
 button != Qt.MouseButton.NoButton and
 Preferences.getEditor("MouseClickHandlersEnabled") and
 key in self.__mouseClickHandlers

Mercurial Repositories > eric / file comparison

comparison: eric6/QScintilla/Editor.py

eric6/QScintilla/Editor.py