eric: comparison src/eric7/UI/UserInterface.py

-:411df92e881f
+:3b34efa2857c
 # -*- coding: utf-8 -*-
-# Copyright (c) 2002 - 2023 Detlev Offenbach <detlev@die-offenbachs.de>
+# Copyright (c) 2002 - 2024 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the main user interface.
 """
 def __nWrite(self, n):
 """
 Private method used to write data.
 @param n max number of bytes to write
+@type int
 """
 if n:
 line = self.buffer[:n]
 if self.stderr:
 self.appendStderr.emit(line)
 def __bufferedWrite(self):
 """
 Private method returning number of characters to write.
 @return number of characters buffered or length of buffered line
-(integer)
+@rtype int
 """
 return self.buffer.rfind("\n") + 1
 def flush(self):
 """
 def write(self, s):
 """
 Public method used to write data.
 @param s data to be written (it must support the str-method)
+@type Any
 """
 self.buffer += str(s)
 self.__nWrite(self.__bufferedWrite())
 def __openOnStartup(self, startupType=None):
 """
 Private method to open the last file, project or multiproject.
-@param startupType type of startup requested (string, one of
+@param startupType type of startup requested (one of
 "Nothing", "File", "Project", "MultiProject" or "Session")
+@type str
 """
 startupTypeMapping = {
 "Nothing": 0,
 "File": 1,
 "Project": 2,
 def __createDockWindow(self, name):
 """
 Private method to create a dock window with common properties.
-@param name object name of the new dock window (string)
+@param name object name of the new dock window
-@return the generated dock window (QDockWindow)
+@type str
+@return the generated dock window
+@rtype QDockWindow
 """
 dock = QDockWidget()
 dock.setObjectName(name)
 dock.setFeatures(
 QDockWidget.DockWidgetFeature.DockWidgetClosable
 def __setupDockWindow(self, dock, where, widget, caption):
 """
 Private method to configure the dock window created with
 __createDockWindow().
-@param dock the dock window (QDockWindow)
+@param dock the dock window
-@param where dock area to be docked to (Qt.DockWidgetArea)
+@type QDockWindow
-@param widget widget to be shown in the dock window (QWidget)
+@param where dock area to be docked to
-@param caption caption of the dock window (string)
+@type Qt.DockWidgetArea
+@param widget widget to be shown in the dock window
+@type QWidget
+@param caption caption of the dock window
+@type str
 """
 if caption is None:
 caption = ""
 self.addDockWidget(where, dock)
 dock.setWidget(widget)
 def __setWindowCaption(self, editor=None, project=None):
 """
 Private method to set the caption of the Main Window.
-@param editor filename to be displayed (string)
+@param editor filename to be displayed
-@param project project name to be displayed (string)
+@type str
+@param project project name to be displayed
+@type str
 """
 if editor is not None and self.captionShowsFilename:
 self.capEditor = FileSystemUtilities.compactPath(
 editor, self.maxFilePathLen
 )
 def showEmailDialog(self, mode, attachFile=None, deleteAttachFile=False):
 """
 Public slot to show the email dialog in a given mode.
-@param mode mode of the email dialog (string, "bug" or "feature")
+@param mode mode of the email dialog ("bug" or "feature")
-@param attachFile name of a file to attach to the email (string)
+@type str
+@param attachFile name of a file to attach to the email
+@type str
 @param deleteAttachFile flag indicating to delete the attached file
-after it has been sent (boolean)
+after it has been sent
+@type bool
 """
 from .EmailDialog import EmailDialog
 if Preferences.getUser("UseSystemEmailClient"):
 self.__showSystemEmailClient(mode, attachFile, deleteAttachFile)
 def __showSystemEmailClient(self, mode, attachFile=None, deleteAttachFile=False):
 """
 Private slot to show the system email dialog.
-@param mode mode of the email dialog (string, "bug" or "feature")
+@param mode mode of the email dialog ("bug" or "feature")
+@type str
 @param attachFile name of a file to put into the body of the
-email (string)
+email
+@type str
 @param deleteAttachFile flag indicating to delete the file after
-it has been read (boolean)
+it has been read
+@type bool
 """
 address = FeatureAddress if mode == "feature" else BugAddress
 subject = "[eric] "
 if attachFile is not None:
 with open(attachFile, "r", encoding="utf-8") as f:
 def __hasErrorLog(self):
 """
 Private method to check, if an error log file exists.
-@return flag indicating the existence of an error log file (boolean)
+@return flag indicating the existence of an error log file
+@rtype bool
 """
 logFile = os.path.join(Globals.getConfigDir(), self.ErrorLogFileName)
 return os.path.exists(logFile)
 def __showErrorLog(self):
 def addEricActions(self, actions, actionType):
 """
 Public method to add actions to the list of actions.
-@param actions list of actions to be added (list of EricAction)
+@param actions list of actions to be added
+@type list of EricAction
 @param actionType string denoting the action set to add to.
 It must be one of "ui" or "wizards".
+@type str
 """
 if actionType == "ui":
 self.actions.extend(actions)
 elif actionType == "wizards":
 self.wizardsActions.extend(actions)
 def removeEricActions(self, actions, actionType="ui"):
 """
 Public method to remove actions from the list of actions.
-@param actions list of actions (list of EricAction)
+@param actions list of actions
+@type list of EricActio
 @param actionType string denoting the action set to remove from.
 It must be one of "ui" or "wizards".
+@type str
 """
 for act in actions:
 with contextlib.suppress(ValueError):
 if actionType == "ui":
 self.actions.remove(act)
 """
 Public method to get a list of all actions.
 @param actionType string denoting the action set to get.
 It must be one of "ui" or "wizards".
-@return list of all actions (list of EricAction)
+@type str
+@return list of all actions
+@rtype list of EricAction
 """
 if actionType == "ui":
 return self.actions[:]
 elif actionType == "wizards":
 return self.wizardsActions[:]
 def getMenuAction(self, menuName, actionName):
 """
 Public method to get a reference to an action of a menu.
-@param menuName name of the menu to search in (string)
+@param menuName name of the menu to search in
+@type str
 @param actionName object name of the action to search for
-(string)
+@type str
-@return reference to the menu action (QAction)
+@return reference to the menu action
+@rtype QAction
 """
 try:
 menu = self.__menus[menuName]
 except KeyError:
 return None
 def getMenuBarAction(self, menuName):
 """
 Public method to get a reference to an action of the main menu.
-@param menuName name of the menu to search in (string)
+@param menuName name of the menu to search in
-@return reference to the menu bar action (QAction)
+@type str
+@return reference to the menu bar action
+@rtype QAction
 """
 try:
 menu = self.__menus[menuName]
 except KeyError:
 return None
 def getMenu(self, name):
 """
 Public method to get a reference to a specific menu.
-@param name name of the menu (string)
+@param name name of the menu
-@return reference to the menu (QMenu)
+@type str
+@return reference to the menu
+@rtype QMenu
 """
 try:
 return self.__menus[name]
 except KeyError:
 return None
 def unregisterToolbar(self, name):
 """
 Public method to unregister a toolbar.
-@param name name of the toolbar (string).
+@param name name of the toolbar
+@type str
 """
 if name in self.__toolbars:
 del self.__toolbars[name]
 def getToolbar(self, name):
 """
 Public method to get a reference to a specific toolbar.
-@param name name of the toolbar (string)
+@param name name of the toolbar
-@return reference to the toolbar entry (tuple of string and QToolBar)
+@type str
+@return reference to the toolbar entry
+@rtype tuple of (str, QToolBar)
 """
 try:
 return self.__toolbars[name]
 except KeyError:
 return None
 def getLocale(self):
 """
 Public method to get the locale of the IDE.
-@return locale of the IDE (string or None)
+@return locale of the IDE
+@rtype str
 """
 return self.locale
 def __quit(self):
 """
 def __toolGroupSelected(self, act):
 """
 Private slot to set the current tool group.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 self.toolGroupsMenuTriggered = True
 idx = act.data()
 if idx is not None:
 self.currentToolGroup = idx
 def __populateToolbarsMenu(self, menu):
 """
 Private method to populate a toolbars menu.
-@param menu reference to the menu to be populated (QMenu)
+@param menu reference to the menu to be populated
+@type QMenu
 """
 menu.clear()
 for name, (text, tb, _category) in sorted(
 self.__toolbars.items(), key=lambda t: t[1][0]
 def createPopupMenu(self):
 """
 Public method to create the toolbars menu for Qt.
-@return toolbars menu (QMenu)
+@return toolbars menu
+@rtype QMenu
 """
 menu = QMenu(self)
 menu.triggered.connect(self.__TBPopupMenuTriggered)
 self.__populateToolbarsMenu(menu)
 def __TBMenuTriggered(self, act):
 """
 Private method to handle the toggle of a toolbar via the Window->
 Toolbars submenu.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 name = act.data()
 if name:
 if name == "__SHOW__":
 for _text, tb, _category in self.__toolbars.values():
 def __TBPopupMenuTriggered(self, act):
 """
 Private method to handle the toggle of a toolbar via the QMainWindow
 Toolbars popup menu.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 name = act.data()
 if name:
 if name == "__SHOW__":
 for _text, tb, _category in self.__toolbars.values():
 def __saveCurrentViewProfile(self, save):
 """
 Private slot to save the window geometries of the active profile.
 @param save flag indicating that the current profile should
-be saved (boolean)
+be saved
+@type bool
 """
 if self.currentProfile and save:
 # step 1: save the window geometries of the active profile
 if self.__layoutType in ["Toolboxes", "Sidebars"]:
 state = self.saveState()
 def __activateViewProfile(self, name, save=True):
 """
 Private slot to activate a view profile.
-@param name name of the profile to be activated (string)
+@param name name of the profile to be activated
+@type str
 @param save flag indicating that the current profile should
-be saved (boolean)
+be saved
+@type bool
 """
 if self.currentProfile != name or not save:
 # step 1: save the active profile
 self.__saveCurrentViewProfile(save)
 def __setEditProfile(self, save=True):
 """
 Private slot to activate the edit view profile.
 @param save flag indicating that the current profile should
-be saved (boolean)
+be saved
+@type bool
 """
 self.__activateViewProfile("edit", save)
 self.setEditProfileAct.setChecked(True)
 @pyqtSlot()
 def setDebugProfile(self, save=True):
 """
 Public slot to activate the debug view profile.
 @param save flag indicating that the current profile should
-be saved (boolean)
+be saved
+@type bool
 """
 self.viewmanager.searchReplaceWidget().hide()
 self.__activateViewProfile("debug", save)
 self.setDebugProfileAct.setChecked(True)
 def getViewProfile(self):
 """
 Public method to get the current view profile.
-@return the name of the current view profile (string)
+@return the name of the current view profile
+@rtype str
 """
 return self.currentProfile
 def getLayoutType(self):
 """
 def __toggleWindow(self, w):
 """
 Private method to toggle a workspace editor window.
 @param w reference to the workspace editor window
-@return flag indicating, if the window was shown (boolean)
+@type Editor
+@return flag indicating, if the window was shown
+@rtype bool
 """
 if w.isHidden():
 w.show()
 return True
 else:
 def __customViewer(self, home=None):
 """
 Private slot to start a custom viewer.
-@param home full pathname of a file to display (string)
+@param home full pathname of a file to display
+@type str
 """
 customViewer = Preferences.getHelp("CustomViewer")
 if not customViewer:
 EricMessageBox.information(
 self,
 def __chmViewer(self, home=None):
 """
 Private slot to start the win help viewer to show *.chm files.
-@param home full pathname of a file to display (string)
+@param home full pathname of a file to display
+@type str
 """
 if home:
 proc = QProcess()
 args = []
 args.append(home)
 @pyqtSlot(str)
 def __UIPreviewer(self, fn=None):
 """
 Private slot to start the UI Previewer executable.
-@param fn filename of the form to be previewed (string)
+@param fn filename of the form to be previewed
+@type str
 """
 proc = QProcess()
 viewer = os.path.join(getConfig("ericDir"), "eric7_uipreviewer.py")
 def __TRPreviewer(self, fileNames=None, ignore=False):
 """
 Private slot to start the Translation Previewer executable.
 @param fileNames filenames of forms and/or translations to be previewed
-(list of strings)
+@type list of str
 @param ignore flag indicating non existing files should be ignored
-(boolean)
+@type bool
 """
 proc = QProcess()
 viewer = os.path.join(getConfig("ericDir"), "eric7_trpreviewer.py")
 @pyqtSlot(str)
 def __showSvg(self, fn):
 """
 Private slot to show a SVG file in a dialog.
-@param fn filename of the file to show (string)
+@param fn filename of the file to show
+@type str
 """
 from eric7.Graphics.SvgDiagram import SvgDiagram
 dlg = SvgDiagram(fn, self)
 dlg.show()
 def __toolExecute(self, act):
 """
 Private slot to execute a particular tool.
-@param act reference to the action that was triggered (QAction)
+@param act reference to the action that was triggered
+@type QAction
 """
 if self.toolGroupsMenuTriggered:
 # ignore actions triggered from the select tool group submenu
 self.toolGroupsMenuTriggered = False
 return
 def __startToolProcess(self, tool):
 """
 Private slot to start an external tool process.
-@param tool list of tool entries
+@param tool dictionary of tool entries
+@type dict
 """
 proc = QProcess()
 procData = (None,)
 program = tool["executable"]
 args = []
 @pyqtSlot(int, QProcess.ExitStatus)
 def __toolFinished(self, exitCode, exitStatus):
 """
 Private slot to handle the finished signal of a tool process.
-@param exitCode exit code of the process (integer)
+@param exitCode exit code of the process
-@param exitStatus exit status of the process (QProcess.ExitStatus)
+@type int
+@param exitStatus exit status of the process
+@type QProcess.ExitStatus
 """
 exitedProcs = []
 # loop through all running tool processes
 for program, toolProc, toolProcData in self.toolProcs:
 def __webBrowser(self, home=""):
 """
 Private slot to start the eric web browser.
-@param home full pathname of a file to display (string)
+@param home full pathname of a file to display
+@type str
 """
 started = QDesktopServices.openUrl(QUrl(home))
 if not started:
 EricMessageBox.critical(
 self, self.tr("Open Browser"), self.tr("Could not start a web browser")
 @pyqtSlot(str)
 def showPreferences(self, pageName=None):
 """
 Public slot to set the preferences.
-@param pageName name of the configuration page to show (string)
+@param pageName name of the configuration page to show
+@type str
 """
 from eric7.Preferences.ConfigurationDialog import ConfigurationDialog
 if self.__configurationDialog is None:
 # only one invocation at a time is allowed
 """
 Private slot to handle the programChange signal.
 This primarily is here to set the currentProg variable.
-@param fn filename to be set as current prog (string)
+@param fn filename to be set as current prog
+@type str
 """
 # Delete the old program if there was one.
 if self.currentProg is not None:
 del self.currentProg
 def __editorOpened(self, fn):
 """
 Private slot to handle the editorOpened signal.
-@param fn filename of the opened editor (string)
+@param fn filename of the opened editor
+@type str
 """
 self.wizardsMenuAct.setEnabled(len(self.__menus["wizards"].actions()) > 0)
 if (
 fn
 def __checkActions(self, editor):
 """
 Private slot to check some actions for their enable/disable status.
 @param editor editor window
+@type Editor
 """
 fn = editor.getFileName() if editor else None
 if fn and Testing.isLanguageSupported(editor.getFileType()):
 self.testScriptAct.setEnabled(True)
 def appendToStdout(self, s):
 """
 Public slot to append text to the stdout log viewer tab.
-@param s output to be appended (string)
+@param s output to be appended
+@type str
 """
 self.appendStdout.emit(s)
 def appendToStderr(self, s):
 """
 Public slot to append text to the stderr log viewer tab.
-@param s output to be appended (string)
+@param s output to be appended
+@type str
 """
 self.appendStderr.emit(s)
 ##########################################################
 ## Below are slots needed by the plugin menu
 def __installPlugins(self, pluginFileNames=None):
 """
 Private slot to show a dialog to install a new plugin.
 @param pluginFileNames list of plugin files suggested for
-installation list of strings
+installation
+@type list of str
 """
 from eric7.PluginManager.PluginInstallDialog import PluginInstallDialog
 self.__pluginInstallDialog = PluginInstallDialog(
 self.pluginManager,
 def dragEnterEvent(self, event):
 """
 Protected method to handle the drag enter event.
-@param event the drag enter event (QDragEnterEvent)
+@param event the drag enter event
+@type QDragEnterEvent
 """
 self.inDragDrop = event.mimeData().hasUrls()
 if self.inDragDrop:
 event.acceptProposedAction()
 def dragMoveEvent(self, event):
 """
 Protected method to handle the drag move event.
-@param event the drag move event (QDragMoveEvent)
+@param event the drag move event
+@type QDragMoveEvent
 """
 if self.inDragDrop:
 event.acceptProposedAction()
 def dragLeaveEvent(self, event):
 """
 Protected method to handle the drag leave event.
-@param event the drag leave event (QDragLeaveEvent)
+@param event the drag leave event
+@type QDragLeaveEvent
 """
 if self.inDragDrop:
 self.inDragDrop = False
 def dropEvent(self, event):
 """
 Protected method to handle the drop event.
-@param event the drop event (QDropEvent)
+@param event the drop event
+@type QDropEvent
 """
 if event.mimeData().hasUrls():
 event.acceptProposedAction()
 for url in event.mimeData().urls():
 fname = url.toLocalFile()
 """
 Protected event handler for the close event.
 This event handler saves the preferences.
-@param event close event (QCloseEvent)
+@param event close event
+@type QCloseEvent
 """
 if self.__shutdown():
 event.accept()
 if not self.inCloseEvent:
 self.inCloseEvent = True
 def __sslErrors(self, reply, errors):
 """
 Private slot to handle SSL errors.
-@param reply reference to the reply object (QNetworkReply)
+@param reply reference to the reply object
-@param errors list of SSL errors (list of QSslError)
+@type QNetworkReply
+@param errors list of SSL errors
+@type list of QSslError
 """
 ignored = self.__sslErrorHandler.sslErrorsReply(reply, errors)[0]
 if ignored == EricSslErrorState.NOT_IGNORED:
 self.__downloadCancelled = True
 def versionIsNewer(self, required, snapshot=None):
 """
 Public method to check, if the eric version is good compared to
 the required version.
-@param required required version (string)
+@param required required version
-@param snapshot required snapshot version (string)
+@type str
-@return flag indicating, that the version is newer than the required
+@param snapshot required snapshot version
-one (boolean)
+@type str
+@return flag indicating, that the version is newer than the required one
+@rtype bool
 """
 if VersionOnly.startswith("@@"):
 # development version, always newer
 return True
 def __getFloatingGeometry(self, w):
 """
 Private method to get the geometry of a floating windows.
-@param w reference to the widget to be saved (QWidget)
+@param w reference to the widget to be saved
+@type QWidget
 @return list giving the widget's geometry and its visibility
+@rtype list of [int, int, int, int, bool]
 """
 s = w.size()
 p = w.pos()
 return [p.x(), p.y(), s.width(), s.height(), not w.isHidden()]
 def showEvent(self, evt):
 """
 Protected method to handle the show event.
-@param evt reference to the show event (QShowEvent)
+@param evt reference to the show event
+@type QShowEvent
 """
 if self.__startup:
 if Preferences.getGeometry("MainMaximized"):
 self.setWindowState(Qt.WindowState.WindowMaximized)
 self.__startup = False

Mercurial Repositories > eric / file comparison

comparison: src/eric7/UI/UserInterface.py

src/eric7/UI/UserInterface.py