eric: comparison QScintilla/Editor.py

-:84b65fb9e780
+:d133c7edd88a
 Constructor
 @param dbs reference to the debug server object
 @param fn name of the file to be opened (string). If it is None,
 a new (empty) editor is opened
-@param vm reference to the view manager object (ViewManager.ViewManager)
+@param vm reference to the view manager object
+(ViewManager.ViewManager)
 @param filetype type of the source file (string)
 @param editor reference to an Editor object, if this is a cloned view
 @param tv reference to the task viewer object
+@exception IOError raised to indicate an issue accessing the file
 """
 super().__init__()
 self.setAttribute(Qt.WA_DeleteOnClose)
 self.setAttribute(Qt.WA_KeyCompression)
 self.setUtf8(True)
 def addClone(self, editor):
 """
 Public method to add a clone to our list.
-@param clone reference to the cloned editor (Editor)
+@param editor reference to the cloned editor (Editor)
 """
 self.__clones.append(editor)
 editor.editorRenamed.connect(self.fileRenamed)
 editor.languageChanged.connect(self.languageChanged)
 def removeClone(self, editor):
 """
 Public method to remove a clone from our list.
-@param clone reference to the cloned editor (Editor)
+@param editor reference to the cloned editor (Editor)
 """
 if editor in self.__clones:
 editor.editorRenamed.disconnect(self.fileRenamed)
 editor.languageChanged.disconnect(self.languageChanged)
 editor.eolChanged.disconnect(self.__eolChanged)
 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)
+@param line0 first line of text to use in the generation process
+(string)
+@return dummy file name to be used for binding a lexer (string)
 """
 bindName = ""
 line0 = line0.lower()
 # check first line if it does not start with #!
 """
 return self.miniMenu
 def __initContextMenu(self):
 """
-Private method used to setup the context menu
+Private method used to setup the context menu.
 """
 self.miniMenu = Preferences.getEditor("MiniContextMenu")
 self.menuActs = {}
 self.menu = QMenu()
 self.spellingMenu.triggered.connect(self.__contextMenuSpellingTriggered)
 def __initContextMenuAutocompletion(self):
 """
 Private method used to setup the Checks context sub menu.
+@return reference to the generated menu (QMenu)
 """
 menu = QMenu(self.trUtf8('Autocomplete'))
 self.menuActs["acDynamic"] = \
 menu.addAction(self.trUtf8('dynamic'),
 return menu
 def __initContextMenuChecks(self):
 """
 Private method used to setup the Checks context sub menu.
+@return reference to the generated menu (QMenu)
 """
 menu = QMenu(self.trUtf8('Check'))
 menu.aboutToShow.connect(self.__showContextMenuChecks)
 return menu
 def __initContextMenuShow(self):
 """
 Private method used to setup the Show context sub menu.
+@return reference to the generated menu (QMenu)
 """
 menu = QMenu(self.trUtf8('Show'))
 menu.addAction(self.trUtf8('Code metrics...'), self.__showCodeMetrics)
 self.coverageMenuAct = \
 return menu
 def __initContextMenuGraphics(self):
 """
 Private method used to setup the diagrams context sub menu.
+@return reference to the generated menu (QMenu)
 """
 menu = QMenu(self.trUtf8('Diagrams'))
 menu.addAction(self.trUtf8('Class Diagram...'),
 self.__showClassDiagram)
 return menu
 def __initContextMenuLanguages(self):
 """
 Private method used to setup the Languages context sub menu.
+@return reference to the generated menu (QMenu)
 """
 menu = QMenu(self.trUtf8("Languages"))
 self.languagesActGrp = QActionGroup(self)
 self.noLanguageAct = menu.addAction(self.trUtf8("No Language"))
 return menu
 def __initContextMenuEncodings(self):
 """
 Private method used to setup the Encodings context sub menu.
+@return reference to the generated menu (QMenu)
 """
 self.supportedEncodings = {}
 menu = QMenu(self.trUtf8("Encodings"))
 return menu
 def __initContextMenuEol(self):
 """
 Private method to setup the eol context sub menu.
+@return reference to the generated menu (QMenu)
 """
 self.supportedEols = {}
 menu = QMenu(self.trUtf8("End-of-Line Type"))
 return menu
 def __initContextMenuExporters(self):
 """
 Private method used to setup the Exporters context sub menu.
+@return reference to the generated menu (QMenu)
 """
 menu = QMenu(self.trUtf8("Export as"))
 from . import Exporters
 supportedExporters = Exporters.getSupportedFormats()
 return menu
 def __initContextMenuMargins(self):
 """
-Private method used to setup the context menu for the margins
+Private method used to setup the context menu for the margins.
 """
 self.marginMenuActs = {}
 if self.__unifiedMargins:
 self.__initContextMenuUnifiedMargins()
 else:
 self.__initContextMenuSeparateMargins()
 def __initContextMenuSeparateMargins(self):
 """
-Private method used to setup the context menu for the separated margins
+Private method used to setup the context menu for the separated margins.
 """
 # bookmark margin
 self.bmMarginMenu = QMenu()
 self.bmMarginMenu.addAction(self.trUtf8('Toggle bookmark'),
 self.indicMarginMenu.aboutToShow.connect(self.__showContextMenuMargin)
 def __initContextMenuUnifiedMargins(self):
 """
-Private method used to setup the context menu for the unified margins
+Private method used to setup the context menu for the unified margins.
 """
 self.marginMenu = QMenu()
 self.marginMenu.addAction(self.trUtf8('Toggle bookmark'),
 self.menuToggleBookmark)
 def __encodingChanged(self, encoding, propagate=True):
 """
 Private slot to handle a change of the encoding.
+@param encoding changed encoding (string)
 @keyparam propagate flag indicating to propagate the change (boolean)
 """
 self.encoding = encoding
 self.__checkEncoding()
 lineno = self.markerLine(self.lastHighlight)
 self.ensureVisible(lineno + 1)
 def highlight(self, line=None, error=False, syntaxError=False):
 """
-Public method to highlight (or de-highlight) a particular line.
+Public method to highlight [or de-highlight] a particular line.
 @param line line number to highlight (integer)
-@param error flag indicating whether the error highlight should be used (boolean)
+@param error flag indicating whether the error highlight should be
+used (boolean)
 @param syntaxError flag indicating a syntax error (boolean)
 """
 if line is None:
 self.lastHighlight = None
 if self.lastErrorMarker is not None:
 def __changeBreakPoints(self, startIndex, endIndex):
 """
 Private slot to set changed breakpoints.
-@param indexes indexes of changed breakpoints.
+@param startIndex start index of the breakpoints being changed
+(QModelIndex)
+@param endIndex end index of the breakpoints being changed
+(QModelIndex)
 """
 if not self.inLinesChanged:
 self.__addBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
 def __breakPointDataAboutToBeChanged(self, startIndex, endIndex):
 """
-Private slot to handle the dataAboutToBeChanged signal of the breakpoint model.
+Private slot to handle the dataAboutToBeChanged signal of the
+breakpoint model.
 @param startIndex start index of the rows to be changed (QModelIndex)
 @param endIndex end index of the rows to be changed (QModelIndex)
 """
 self.__deleteBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
 self.__clearBreakpoints(self.fileName)
 def __clearBreakpoints(self, fileName):
 """
 Private slot to clear all breakpoints.
+@param fileName name of the file (string)
 """
 idxList = []
 for handle, (ln, _, _, _, _) in list(self.breaks.items()):
 index = self.breakpointModel.getBreakPointIndex(fileName, ln)
 if index.isValid():
 indexEnd = 0
 self.setSelection(lineFrom, indexStart, lineTo, indexEnd)
 def indentLineOrSelection(self):
 """
-Public slot to indent the current line or current selection
+Public slot to indent the current line or current selection.
 """
 if self.hasSelectedText():
 self.__indentSelection(True)
 else:
 self.__indentLine(True)
 self.ensureVisible(self.__lastEditPosition[0])
 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)
 """
 if self.isPy3File() or self.isPy2File() or self.isRubyFile():
 lineNo = self.getCursorPosition()[0]
 line = self.text(lineNo)
 if line.strip().startswith(("class ", "def ", "module ")):
 self.showingNotcoveredMarkers = False
 def hasCoverageMarkers(self):
 """
 Public method to test, if there are coverage markers.
+@return flag indicating the presence of coverage markers (boolean)
 """
 return len(self.notcoveredMarkers) > 0
 def nextUncovered(self):
 """
 This overwritten method redirects the action to our
 ViewManager.closeEditor, which in turn calls our closeIt
 method.
 @param alsoDelete ignored
+@return flag indicating a successful close of the editor (boolean)
 """
 return self.vm.closeEditor(self)
 def closeIt(self):
 """
 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 (QEvent)
-@return flag indicating if the event could be processed (bool)
 """
 if evt.type() == QEvent.WindowStateChange and \
 self.fileName is not None:
 if self.windowState() == Qt.WindowStates(Qt.WindowMinimized):
 cap = os.path.basename(self.fileName)
 #################################################################
 def __initContextMenuResources(self):
 """
 Private method used to setup the Resources context sub menu.
+@return reference to the generated menu (QMenu)
 """
 menu = QMenu(self.trUtf8('Resources'))
 menu.addAction(self.trUtf8('Add file...'),
 self.__addFileResource)
 elif token == Editor.SyncToken:
 self.__processSyncCommand(argsString)
 def __processStartEditCommand(self, argsString):
 """
-Private slot to process a remote StartEdit command
+Private slot to process a remote StartEdit command.
 @param argsString string containing the command parameters (string)
 """
 if not self.__inSharedEdit and not self.__inRemoteSharedEdit:
 self.__inRemoteSharedEdit = True
 return "\n".join(commands) + "\n"
 def __processEndEditCommand(self, argsString):
 """
-Private slot to process a remote EndEdit command
+Private slot to process a remote EndEdit command.
 @param argsString string containing the command parameters (string)
 """
 commands = argsString.splitlines()
 sep = self.getLineSeparator()
 self.setCursorPosition(*cur)
 def __processRequestSyncCommand(self, argsString):
 """
-Private slot to process a remote RequestSync command
+Private slot to process a remote RequestSync command.
 @param argsString string containing the command parameters (string)
 """
 if self.__inSharedEdit:
 hash = str(
 if hash == argsString:
 self.__send(Editor.SyncToken, self.__savedText)
 def __processSyncCommand(self, argsString):
 """
-Private slot to process a remote Sync command
+Private slot to process a remote Sync command.
 @param argsString string containing the command parameters (string)
 """
 if self.__isSyncing:
 cur = self.getCursorPosition()

Mercurial Repositories > eric / file comparison

comparison: QScintilla/Editor.py

QScintilla/Editor.py