eric: comparison src/eric7/ViewManager/ViewManager.py

-:c712d09cc839
+:f6881d10e995
 def setReferences(self, ui, dbs):
 """
 Public method to set some references needed later on.
 @param ui reference to the main user interface
+@type UserInterface
 @param dbs reference to the debug server object
+@type DebugServer
 """
 from eric7.QScintilla.SearchReplaceWidget import SearchReplaceSlidingWidget
 self.ui = ui
 self.dbs = dbs
 def searchReplaceWidget(self):
 """
 Public method to get a reference to the search widget.
-@return reference to the search widget (SearchReplaceSlidingWidget)
+@return reference to the search widget
+@rtype SearchReplaceSlidingWidget
 """
 return self.__searchReplaceWidget
 def __loadRecent(self):
 """
 def getMostRecent(self):
 """
 Public method to get the most recently opened file.
-@return path of the most recently opened file (string)
+@return path of the most recently opened file
+@rtype str
 """
 if len(self.recent):
 return self.recent[0]
 else:
 return None
 """
 Public method to transfer statusbar info from the user interface to
 viewmanager.
 @param sbLine reference to the line number part of the statusbar
-(QLabel)
+@type QLabel
 @param sbPos reference to the character position part of the statusbar
-(QLabel)
+@type QLabel
 @param sbWritable reference to the writability indicator part of
-the statusbar (QLabel)
+the statusbar
+@type QLabel
 @param sbEncoding reference to the encoding indicator part of the
-statusbar (QLabel)
+statusbar
+@type QLabel
 @param sbLanguage reference to the language indicator part of the
-statusbar (QLabel)
+statusbar
+@type QLabel
 @param sbEol reference to the eol indicator part of the statusbar
-(QLabel)
+@type QLabel
-@param sbZoom reference to the zoom widget (EricZoomWidget)
+@param sbZoom reference to the zoom widget
+@type EricZoomWidget
 """
 self.sbLine = sbLine
 self.sbPos = sbPos
 self.sbWritable = sbWritable
 self.sbEnc = sbEncoding
 def __showLanguagesMenu(self, pos):
 """
 Private slot to show the Languages menu of the current editor.
-@param pos position the menu should be shown at (QPoint)
+@param pos position the menu should be shown at
+@type QPoint
 """
 aw = self.activeWindow()
 if aw is not None:
 menu = aw.getMenu("Languages")
 if menu is not None:
 def __showEolMenu(self, pos):
 """
 Private slot to show the EOL menu of the current editor.
-@param pos position the menu should be shown at (QPoint)
+@param pos position the menu should be shown at
+@type QPoint
 """
 aw = self.activeWindow()
 if aw is not None:
 menu = aw.getMenu("Eol")
 if menu is not None:
 def __showEncodingsMenu(self, pos):
 """
 Private slot to show the Encodings menu of the current editor.
-@param pos position the menu should be shown at (QPoint)
+@param pos position the menu should be shown at
+@type QPoint
 """
 aw = self.activeWindow()
 if aw is not None:
 menu = aw.getMenu("Encodings")
 if menu is not None:
 def canCascade(self):
 """
 Public method to signal if cascading of managed windows is available.
 @return flag indicating cascading of windows is available
+@rtype bool
 @exception NotImplementedError Not implemented
 """
 raise NotImplementedError("Not implemented")
 return False
 def canTile(self):
 """
 Public method to signal if tiling of managed windows is available.
 @return flag indicating tiling of windows is available
+@rtype bool
 @exception NotImplementedError Not implemented
 """
 raise NotImplementedError("Not implemented")
 return False
 def activeWindow(self):
 """
 Public method to return the active (i.e. current) window.
 @return reference to the active editor
+@rtype Editor
 @exception NotImplementedError Not implemented
 """
 raise NotImplementedError("Not implemented")
 return None  # __IGNORE_WARNING_M831__
 def _removeView(self, win):
 """
 Protected method to remove a view (i.e. window).
 @param win editor window to be removed
+@type EditorAssembly
 @exception NotImplementedError Not implemented
 """
 raise NotImplementedError("Not implemented")
 def _addView(self, win, fn=None, noName="", addNext=False, indexes=None):
 def _showView(self, win, fn=None):
 """
 Protected method to show a view (i.e. window).
 @param win editor assembly to be shown
+@type EditorAssembly
 @param fn filename of this editor
+@type str
 @exception NotImplementedError Not implemented
 """
 raise NotImplementedError("Not implemented")
 def showWindowMenu(self, windowMenu):
 """
 Public method to set up the viewmanager part of the Window menu.
 @param windowMenu reference to the window menu
+@type QMenu
 @exception NotImplementedError Not implemented
 """
 raise NotImplementedError("Not implemented")
 def _initWindowActions(self):
 def setEditorName(self, editor, newName):
 """
 Public method to change the displayed name of the editor.
 @param editor editor window to be changed
-@param newName new name to be shown (string)
+@type Editor
+@param newName new name to be shown
+@type str
 @exception NotImplementedError Not implemented
 """
 raise NotImplementedError("Not implemented")
 def _modificationStatusChanged(self, m, editor):
 """
 Protected slot to handle the modificationStatusChanged signal.
-@param m flag indicating the modification status (boolean)
+@param m flag indicating the modification status
+@type bool
 @param editor editor window changed
+@type Editor
 @exception NotImplementedError Not implemented
 """
 raise NotImplementedError("Not implemented")
 def mainWidget(self):
 def canSplit(self):
 """
 Public method to signal if splitting of the view is available.
-@return flag indicating splitting of the view is available.
+@return flag indicating splitting of the view is available
+@rtype bool
 """
 return False
 def addSplit(self):
 """
 def getSplitOrientation(self):
 """
 Public method to get the orientation of the split view.
-@return orientation of the split (Qt.Orientation.Horizontal or
+@return orientation of the split
-Qt.Orientation.Vertical)
+@rtype Qt.Orientation
 """
 return Qt.Orientation.Vertical
 def setSplitOrientation(self, orientation):
 """
 Public method used to set the orientation of the split view.
 @param orientation orientation of the split
-(Qt.Orientation.Horizontal or Qt.Orientation.Vertical)
+@type Qt.Orientation
 """
 pass
 def nextSplit(self):
 """
 def eventFilter(self, qobject, event):
 """
 Public method called to filter an event.
-@param qobject object, that generated the event (QObject)
+@param qobject object, that generated the event
-@param event the event, that was generated by object (QEvent)
+@type QObject
+@param event the event, that was generated by object
+@type QEvent
 @return flag indicating if event was filtered out
+@rtype bool
 """
 return False
 #####################################################################
 ## methods above need to be implemented by a subclass, that supports
 def initFileMenu(self):
 """
 Public method to create the File menu.
 @return the generated menu
+@rtype QMenu
 """
 menu = QMenu(QCoreApplication.translate("ViewManager", "&File"), self.ui)
 self.recentMenu = QMenu(
 QCoreApplication.translate("ViewManager", "Open &Recent Files"), menu
 )
 def initFileToolbar(self, toolbarManager):
 """
 Public method to create the File toolbar.
 @param toolbarManager reference to a toolbar manager object
-(EricToolBarManager)
+@type EricToolBarManager
 @return the generated toolbar
+@rtype QToolBar
 """
 tb = QToolBar(QCoreApplication.translate("ViewManager", "File"), self.ui)
 tb.setObjectName("FileToolbar")
 tb.setToolTip(QCoreApplication.translate("ViewManager", "File"))
 def __initContextMenuExporters(self):
 """
 Private method used to setup the Exporters sub menu.
-@return reference to the generated menu (QMenu)
+@return reference to the generated menu
+@rtype QMenu
 """
 menu = QMenu(QCoreApplication.translate("ViewManager", "Export as"))
 supportedExporters = Exporters.getSupportedFormats()
 for exporter in sorted(supportedExporters):
 def initEditMenu(self):
 """
 Public method to create the Edit menu.
 @return the generated menu
+@rtype QMenu
 """
 autocompletionMenu = QMenu(
 QCoreApplication.translate("ViewManager", "Complete"), self.ui
 )
 autocompletionMenu.setTearOffEnabled(True)
 def initEditToolbar(self, toolbarManager):
 """
 Public method to create the Edit toolbar.
 @param toolbarManager reference to a toolbar manager object
-(EricToolBarManager)
+@type EricToolBarManager
 @return the generated toolbar
+@rtype QToolBar
 """
 tb = QToolBar(QCoreApplication.translate("ViewManager", "Edit"), self.ui)
 tb.setObjectName("EditToolbar")
 tb.setToolTip(QCoreApplication.translate("ViewManager", "Edit"))
 def initViewMenu(self):
 """
 Public method to create the View menu.
 @return the generated menu
+@rtype QMenu
 """
 menu = QMenu(QCoreApplication.translate("ViewManager", "&View"), self.ui)
 menu.setTearOffEnabled(True)
 menu.addActions(self.viewActGrp.actions())
 menu.addSeparator()
 def initViewToolbar(self, toolbarManager):
 """
 Public method to create the View toolbar.
 @param toolbarManager reference to a toolbar manager object
-(EricToolBarManager)
+@type EricToolBarManager
 @return the generated toolbar
+@rtype QToolBar
 """
 tb = QToolBar(QCoreApplication.translate("ViewManager", "View"), self.ui)
 tb.setObjectName("ViewToolbar")
 tb.setToolTip(QCoreApplication.translate("ViewManager", "View"))
 def initMacroMenu(self):
 """
 Public method to create the Macro menu.
 @return the generated menu
+@rtype QMenu
 """
 menu = QMenu(QCoreApplication.translate("ViewManager", "&Macros"), self.ui)
 menu.setTearOffEnabled(True)
 menu.addActions(self.macroActGrp.actions())
 def initBookmarkMenu(self):
 """
 Public method to create the Bookmark menu.
 @return the generated menu
+@rtype QMenu
 """
 menu = QMenu(QCoreApplication.translate("ViewManager", "&Bookmarks"), self.ui)
 self.bookmarksMenu = QMenu(
 QCoreApplication.translate("ViewManager", "&Bookmarks"), menu
 )
 def initBookmarkToolbar(self, toolbarManager):
 """
 Public method to create the Bookmark toolbar.
 @param toolbarManager reference to a toolbar manager object
-(EricToolBarManager)
+@type EricToolBarManager
 @return the generated toolbar
+@rtype QToolBar
 """
 tb = QToolBar(QCoreApplication.translate("ViewManager", "Bookmarks"), self.ui)
 tb.setObjectName("BookmarksToolbar")
 tb.setToolTip(QCoreApplication.translate("ViewManager", "Bookmarks"))
 def addToExtrasMenu(self, menu):
 """
 Public method to add some actions to the Extras menu.
-@param menu reference to the menu to add actions to (QMenu)
+@param menu reference to the menu to add actions to
+@type QMenu
 """
 self.__editSpellingMenu = QMenu(
 QCoreApplication.translate("ViewManager", "Edit Dictionary")
 )
 self.__editProjectPwlAct = self.__editSpellingMenu.addAction(
 def initSpellingToolbar(self, toolbarManager):
 """
 Public method to create the Spelling toolbar.
 @param toolbarManager reference to a toolbar manager object
-(EricToolBarManager)
+@type EricToolBarManager
 @return the generated toolbar
+@rtype QToolBar
 """
 tb = QToolBar(QCoreApplication.translate("ViewManager", "Spelling"), self.ui)
 tb.setObjectName("SpellingToolbar")
 tb.setToolTip(QCoreApplication.translate("ViewManager", "Spelling"))
 def openFiles(self, prog):
 """
 Public slot to open some files.
-@param prog name of file to be opened (string)
+@param prog name of file to be opened
+@type str
 """
 prog = os.path.abspath(prog)
 # Open up the new files.
 self.openSourceFile(prog)
 def closeCurrentWindow(self):
 """
 Public method to close the current window.
-@return flag indicating success (boolean)
+@return flag indicating success
+@rtype bool
 """
 aw = self.activeWindow()
 if aw is None:
 return False
 def closeEditorWindow(self, editor):
 """
 Public method to close an arbitrary source editor.
 @param editor editor to be closed
+@type Editor
 """
 if editor is None:
 return
 res = self.closeEditor(editor)
 def __connectEditor(self, editor):
 """
 Private method to establish all editor connections.
 @param editor reference to the editor object to be connected
+@type Editor
 """
 editor.modificationStatusChanged.connect(self._modificationStatusChanged)
 editor.cursorChanged.connect(
 lambda fn, line, pos: self.__cursorChanged(fn, line, pos, editor)
 )
 def cloneEditor(self, caller, filetype, fn):
 """
 Public method to clone an editor displaying the given document.
 @param caller reference to the editor calling this method
-@param filetype type of the source file (string)
+@type Editor
+@param filetype type of the source file
+@type str
 @param fn filename of this view
-@return reference to the new editor object (Editor.Editor) and the new
+@type str
-editor assembly object (EditorAssembly.EditorAssembly)
+@return reference to the new editor object and the new editor
+assembly object
+@rtype tuple of (Editor, EditorAssembly)
 """
 from eric7.QScintilla.EditorAssembly import EditorAssembly
 assembly = EditorAssembly(
 self.dbs,
 def addToRecentList(self, fn):
 """
 Public slot to add a filename to the list of recently opened files.
 @param fn name of the file to be added
+@type str
 """
 for recent in self.recent[:]:
 if FileSystemUtilities.samepath(fn, recent):
 self.recent.remove(recent)
 self.recent.insert(0, fn)
 def showDebugSource(self, fn, line):
 """
 Public method to open the given file and highlight the given line in
 it.
-@param fn filename of editor to update (string)
+@param fn filename of editor to update
-@param line line number to highlight (int)
+@type str
+@param line line number to highlight
+@type int
 """
 if not fn.startswith("<"):
 self.openSourceFile(fn, line)
 self.setFileLine(fn, line)
 def setFileLine(self, fn, line, error=False, syntaxError=False):
 """
 Public method to update the user interface when the current program
 or line changes.
-@param fn filename of editor to update (string)
+@param fn filename of editor to update
-@param line line number to highlight (int)
+@type str
-@param error flag indicating an error highlight (boolean)
+@param line line number to highlight
+@type int
+@param error flag indicating an error highlight
+@type bool
 @param syntaxError flag indicating a syntax error
+@type bool
 """
 try:
 newWin, self.currentEditor = self.getEditor(fn)
 except (OSError, UnicodeDecodeError):
 return
 zoom=None,
 ):
 """
 Private method to set the file info in the status bar.
-@param fn filename to display (string)
+@param fn filename to display
-@param line line number to display (int)
+@type str
-@param pos character position to display (int)
+@param line line number to display
-@param encoding encoding name to display (string)
+@type int
-@param language language to display (string)
+@param pos character position to display
-@param eol eol indicator to display (string)
+@type int
-@param zoom zoom value (integer)
+@param encoding encoding name to display
+@type str
+@param language language to display
+@type str
+@param eol eol indicator to display
+@type str
+@param zoom zoom value
+@type int
 """
 if not fn:
 fn = ""
 writ = "  "
 else:
 def __eolPixmap(self, eolIndicator):
 """
 Private method to get an EOL pixmap for an EOL string.
-@param eolIndicator eol indicator string (string)
+@param eolIndicator eol indicator string
-@return pixmap for the eol indicator (QPixmap)
+@type str
+@return pixmap for the eol indicator
+@rtype QPixmap
 """
 if eolIndicator == "LF":
 pixmap = EricPixmapCache.getPixmap("eolLinux")
 elif eolIndicator == "CR":
 pixmap = EricPixmapCache.getPixmap("eolMac")
 """
 Public method to switch off all highlights or the highlight of
 the current editor.
 @param current flag indicating only the current editor should be
-unhighlighted (boolean)
+unhighlighted
+@type bool
 """
 if current:
 if self.currentEditor is not None:
 self.currentEditor.highlight()
 else:
 def getOpenFilenames(self):
 """
 Public method returning a list of the filenames of all editors.
-@return list of all opened filenames (list of strings)
+@return list of all opened filenames
+@rtype list of str
 """
 filenames = []
 for editor in self.editors:
 fn = editor.getFileName()
 if fn is not None and fn not in filenames and os.path.exists(fn):
 def getOpenEditors(self):
 """
 Public method to get references to all open editors.
-@return list of references to all open editors (list of
+@return list of references to all open editors
-QScintilla.editor)
+@rtype list of Editor
 """
 return self.editors
 def getOpenEditorsCount(self):
 """
 Public method to get the number of open editors.
-@return number of open editors (integer)
+@return number of open editors
+@rtype int
 """
 return len(self.editors)
 def getOpenEditor(self, fn):
 """
 Public method to return a list of all editors displaying the given file.
 @param fn filename to look for
 @type str
 @return list of references to the editors displaying this file
+@rtype list of Editor
 """
 return [
 ed
 for ed in self.editors
 if FileSystemUtilities.samepath(fn, ed.getFileName())
 def getOpenEditorCount(self, fn):
 """
 Public method to return the count of editors displaying the given file.
 @param fn filename to look for
-@return count of editors displaying this file (integer)
+@type str
+@return count of editors displaying this file
+@rtype int
 """
 return len(self.getOpenEditorList(fn))
 def getOpenEditorsForSession(self):
 """
 def getActiveName(self):
 """
 Public method to retrieve the filename of the active window.
-@return filename of active window (string)
+@return filename of active window
+@rtype str
 """
 aw = self.activeWindow()
 if aw:
 return aw.getFileName()
 else:
 def saveEditor(self, fn):
 """
 Public method to save a named editor file.
-@param fn filename of editor to be saved (string)
+@param fn filename of editor to be saved
-@return flag indicating success (boolean)
+@type str
+@return flag indicating success
+@rtype bool
 """
 for editor in self.editors:
 if FileSystemUtilities.samepath(fn, editor.getFileName()):
 break
 else:
 def saveEditorEd(self, ed):
 """
 Public slot to save the contents of an editor.
 @param ed editor to be saved
-@return flag indicating success (boolean)
+@type Editor
+@return flag indicating success
+@rtype bool
 """
 if ed:
 if not ed.isModified():
 return True
 else:
 def saveAsEditorEd(self, ed):
 """
 Public slot to save the contents of an editor to a new file.
 @param ed editor to be saved
+@type Editor
 """
 if ed:
 ok = ed.saveFileAs()
 if ok:
 self.setEditorName(ed, ed.getFileName())
 """
 Public slot to save the contents of an editor to a new copy of
 the file.
 @param ed editor to be saved
+@type Editor
 """
 if ed:
 ed.saveFileCopy()
 def saveCopyCurrentEditor(self):
 def saveEditorsList(self, editors):
 """
 Public slot to save a list of editors.
 @param editors list of editors to be saved
+@type list of Editor
 """
 for editor in editors:
 ok = editor.saveFile()
 if ok:
 self.setEditorName(editor, editor.getFileName())
 def __exportMenuTriggered(self, act):
 """
 Private method to handle the selection of an export format.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 aw = self.activeWindow()
 if aw:
 exporterFormat = act.data()
 aw.exportFile(exporterFormat)
 def __openSourceFile(self, act):
 """
 Private method to open a file from the list of recently opened files.
-@param act reference to the action that triggered (QAction)
+@param act reference to the action that triggered
+@type QAction
 """
 file = act.data()
 if file:
 self.openSourceFile(file)
 def projectFileRenamed(self, oldfn, newfn):
 """
 Public slot to handle the projectFileRenamed signal.
-@param oldfn old filename of the file (string)
+@param oldfn old filename of the file
-@param newfn new filename of the file (string)
+@type str
+@param newfn new filename of the file
+@type str
 """
 editor = self.getOpenEditor(oldfn)
 if editor:
 editor.fileRenamed(newfn)
 """
 Public method to set a flag enabling the editors to perform focus in
 checks.
 @param enabled flag indicating focus in checks should be performed
-(boolean)
+@type bool
 """
 self.editorsCheckFocusIn = enabled
 def editorsCheckFocusInEnabled(self):
 """
 Public method returning the flag indicating editors should perform
 focus in checks.
-@return flag indicating focus in checks should be performed (boolean)
+@return flag indicating focus in checks should be performed
+@rtype bool
 """
 return self.editorsCheckFocusIn
 def __findLocation(self):
 """
 """
 Public method to determine the selection or the current word for the
 next find operation.
 @param getCurrentWord flag indicating to return the current word, if
-no selected text was found (boolean)
+no selected text was found
-@return selection or current word (string)
+@type bool
+@return selection or current word
+@rtype str
 """
 aw = self.activeWindow()
 if aw is None:
 return ""
 def getSRHistory(self, key):
 """
 Public method to get the search or replace history list.
 @param key list to return (must be 'search' or 'replace')
-@return the requested history list (list of strings)
+@type str
+@return the requested history list
+@rtype list of str
 """
 return self.srHistory[key]
 def showSearchWidget(self):
 """
 def __zoomTo(self, value):
 """
 Private slot to zoom to a given value.
-@param value zoom value to be set (integer)
+@param value zoom value to be set
+@type int
 """
 aw = (
 ericApp().getObject("Shell")
 if QApplication.focusWidget() == ericApp().getObject("Shell")
 else self.activeWindow()
 def __splitOrientation(self, checked):
 """
 Private method to handle the split orientation action.
-@param checked flag indicating the checked state of the action
+@param checked flag indicating the checked state of the action.
-(boolean). True means splitting horizontally.
+True means splitting horizontally.
+@type bool
 """
 if checked:
 self.setSplitOrientation(Qt.Orientation.Horizontal)
 self.splitViewAct.setIcon(EricPixmapCache.getIcon("splitHorizontal"))
 self.splitRemoveAct.setIcon(EricPixmapCache.getIcon("remsplitHorizontal"))
 def __previewEditor(self, checked):
 """
 Private slot to handle a change of the preview selection state.
-@param checked state of the action (boolean)
+@param checked state of the action
+@type bool
 """
 Preferences.setUI("ShowFilePreview", checked)
 self.previewStateChanged.emit(checked)
 def __astViewer(self, checked):
 """
 Private slot to handle a change of the AST Viewer selection state.
-@param checked state of the action (boolean)
+@param checked state of the action
+@type bool
 """
 self.astViewerStateChanged.emit(checked)
 def __disViewer(self, checked):
 """
 Private slot to handle a change of the DIS Viewer selection state.
-@param checked state of the action (boolean)
+@param checked state of the action
+@type bool
 """
 self.disViewerStateChanged.emit(checked)
 ##################################################################
 ## Below are the action methods for the macro menu
 def __bookmarkSelected(self, act):
 """
 Private method to handle the bookmark selected signal.
-@param act reference to the action that triggered (QAction)
+@param act reference to the action that triggered
+@type QAction
 """
 bmList = act.data()
 filename = bmList[0]
 line = bmList[1]
 self.openSourceFile(filename, line)
 Private slot to handle the bookmarkToggled signal.
 It checks some bookmark actions and reemits the signal.
 @param editor editor that sent the signal
+@type Editor
 """
 if editor.hasBookmarks():
 self.bookmarkNextAct.setEnabled(True)
 self.bookmarkPreviousAct.setEnabled(True)
 self.bookmarkClearAct.setEnabled(True)
 Protected slot to handle the syntaxerrorToggled signal.
 It checks some syntax error actions and reemits the signal.
 @param editor editor that sent the signal
+@type Editor
 """
 if editor.hasSyntaxErrors():
 self.syntaxErrorGotoAct.setEnabled(True)
 self.syntaxErrorClearAct.setEnabled(True)
 else:
 def __coverageMarkersShown(self, shown):
 """
 Private slot to handle the coverageMarkersShown signal.
 @param shown flag indicating whether the markers were shown or cleared
+@type bool
 """
 if shown:
 self.notcoveredNextAct.setEnabled(True)
 self.notcoveredPreviousAct.setEnabled(True)
 else:
 def __taskMarkersUpdated(self, editor):
 """
 Private slot to handle the taskMarkersUpdated signal.
 @param editor editor that sent the signal
+@type Editor
 """
 if editor.hasTaskMarkers():
 self.taskNextAct.setEnabled(True)
 self.taskPreviousAct.setEnabled(True)
 else:
 def __changeMarkersUpdated(self, editor):
 """
 Private slot to handle the changeMarkersUpdated signal.
 @param editor editor that sent the signal
+@type Editor
 """
 if editor.hasChangeMarkers():
 self.changeNextAct.setEnabled(True)
 self.changePreviousAct.setEnabled(True)
 else:
 def __editSpellingDictionary(self, dictionaryFile):
 """
 Private slot to edit the given spelling dictionary.
-@param dictionaryFile file name of the dictionary to edit (string)
+@param dictionaryFile file name of the dictionary to edit
+@type str
 """
 if os.path.exists(dictionaryFile):
 try:
 with open(dictionaryFile, "r", encoding="utf-8") as f:
 data = f.read()
 """
 Protected slot to check some actions for their enable/disable status
 and set the statusbar info.
 @param editor editor window
+@type Editor
 @param setSb flag indicating an update of the status bar is wanted
-(boolean)
+@type bool
 """
 if editor is not None:
 self.saveAct.setEnabled(
 editor.isModified()
 and not FileSystemUtilities.isRemoteFileName(editor.getFileName())
 Private slot to handle the breakpointToggled signal.
 It simply reemits the signal.
 @param editor editor that sent the signal
+@type Editor
 """
 self.breakpointToggled.emit(editor)
 def getActions(self, actionSetType):
 """
 Public method to get a list of all actions.
 @param actionSetType string denoting the action set to get.
 It must be one of "edit", "file", "search", "view", "window",
 "macro", "bookmark" or "spelling".
-@return list of all actions (list of EricAction)
+@type str
+@return list of all actions
+@rtype list of EricAction
 """
 try:
 return self.__actions[actionSetType][:]
 except KeyError:
 return []
 def __editorCommand(self, cmd):
 """
 Private method to send an editor command to the active window.
 @param cmd the scintilla command to be sent
+@type int
 """
 focusWidget = QApplication.focusWidget()
 if focusWidget == ericApp().getObject("Shell"):
 ericApp().getObject("Shell").editorCommand(cmd)
 else:
 using the following search order, until a match is found:<br />
 1: Directory of currently active editor<br />
 2: Directory of currently active Project<br />
 3: CWD
-@return name of directory to start (string)
+@return name of directory to start
+@rtype str
 """
 # if we have an active source, return its path
 if self.activeWindow() is not None and self.activeWindow().getFileName():
 return os.path.dirname(self.activeWindow().getFileName())
 dialog.
 The appropriate filename filter is determined by file extension of
 the currently active editor.
-@return name of the filename filter (string) or None
+@return name of the filename filter
+@rtype str
 """
 if self.activeWindow() is not None and self.activeWindow().getFileName():
 ext = os.path.splitext(self.activeWindow().getFileName())[1]
 rx = re.compile(r".*\*\.{0}[ )].*".format(ext[1:]))
 filters = Lexers.getOpenFileFiltersList()
 def getAPIsManager(self):
 """
 Public method to get a reference to the APIs manager.
-@return the APIs manager object (eric7.QScintilla.APIsManager)
+@return the APIs manager object
+@rtype QScintilla.APIsManager
 """
 return self.apisManager
 #######################################################################
 ## Cooperation related methods
 def setCooperationClient(self, client):
 """
 Public method to set a reference to the cooperation client.
-@param client reference to the cooperation client (CooperationClient)
+@param client reference to the cooperation client
+@type CooperationClient
 """
 self.__cooperationClient = client
 def isConnected(self):
 """
 Public method to check the connection status of the IDE.
-@return flag indicating the connection status (boolean)
+@return flag indicating the connection status
+@rtype bool
 """
 return self.__cooperationClient.hasConnections()
 def send(self, fileName, message):
 """
 Public method to send an editor command to remote editors.
-@param fileName file name of the editor (string)
+@param fileName file name of the editor
-@param message command message to be sent (string)
+@type str
+@param message command message to be sent
+@type str
 """
 project = ericApp().getObject("Project")
 if project.isProjectFile(fileName):
 self.__cooperationClient.sendEditorCommand(
 project.getHash(), project.getRelativeUniversalPath(fileName), message
 def receive(self, projectHash, fileName, command):
 """
 Public slot to handle received editor commands.
-@param projectHash hash of the project (string)
+@param projectHash hash of the project
-@param fileName project relative file name of the editor (string)
+@type str
-@param command command string (string)
+@param fileName project relative file name of the editor
+@type str
+@param command command string
+@type str
 """
 project = ericApp().getObject("Project")
 if projectHash == project.getHash():
 fn = project.getAbsoluteUniversalPath(fileName)
 editor = self.getOpenEditor(fn)
 def shareConnected(self, connected):
 """
 Public slot 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
 """
 for editor in self.getOpenEditors():
 editor.shareConnected(connected)
 def shareEditor(self, share):
 """
 Public slot to set the shared status of the current editor.
-@param share flag indicating the share status (boolean)
+@param share flag indicating the share status
+@type bool
 """
 aw = self.activeWindow()
 if aw is not None:
 fn = aw.getFileName()
 if fn and ericApp().getObject("Project").isProjectFile(fn):
 def insertSymbol(self, txt):
 """
 Public slot to insert a symbol text into the active window.
-@param txt text to be inserted (string)
+@param txt text to be inserted
+@type str
 """
 if self.__lastFocusWidget == ericApp().getObject("Shell"):
 ericApp().getObject("Shell").insert(txt)
 else:
 aw = self.activeWindow()
 def insertNumber(self, txt):
 """
 Public slot to insert a number text into the active window.
-@param txt text to be inserted (string)
+@param txt text to be inserted
+@type str
 """
 if self.__lastFocusWidget == ericApp().getObject("Shell"):
 aw = ericApp().getObject("Shell")
 if aw.hasSelectedText():
 aw.removeSelectedText()
 def getNumber(self):
 """
 Public method to get a number from the active window.
-@return selected text of the active window (string)
+@return selected text of the active window
+@rtype str
 """
 txt = ""
 if self.__lastFocusWidget == ericApp().getObject("Shell"):
 aw = ericApp().getObject("Shell")
 if aw.hasSelectedText():

Mercurial Repositories > eric / file comparison

comparison: src/eric7/ViewManager/ViewManager.py

src/eric7/ViewManager/ViewManager.py