eric: comparison UI/UserInterface.py

-:f7a6d271bb40
+:071afe8be2a1
 import os
 import sys
 import logging
-from PyQt4.QtCore import QTimer, QFile, QFileInfo, pyqtSignal, \
+from PyQt4.QtCore import pyqtSlot, QTimer, QFile, QFileInfo, pyqtSignal, \
 PYQT_VERSION_STR, QDate, QIODevice, qVersion, QProcess, QSize, QUrl, \
 QObject, Qt
 from PyQt4.QtGui import QSizePolicy, QWidget, QKeySequence, QDesktopServices, \
 QWhatsThis, QToolBar, QDialog, QSplitter, QApplication, QMenu, \
 QVBoxLayout, QDockWidget, QAction, QLabel
 """<b>Quit the IDE</b>"""
 """<p>This quits the IDE. Any unsaved changes may be saved"""
 """ first. Any Python program being debugged will be stopped"""
 """ and the preferences will be written to disc.</p>"""
 ))
-self.exitAct.triggered[()].connect(self.__quit)
+self.exitAct.triggered.connect(self.__quit)
 self.exitAct.setMenuRole(QAction.QuitRole)
 self.actions.append(self.exitAct)
 self.newWindowAct = E5Action(
 self.tr('New Window'),
 'Open a new eric5 instance'))
 self.newWindowAct.setWhatsThis(self.tr(
 """<b>New Window</b>"""
 """<p>This opens a new instance of the eric5 IDE.</p>"""
 ))
-self.newWindowAct.triggered[()].connect(self.__newWindow)
+self.newWindowAct.triggered.connect(self.__newWindow)
 self.actions.append(self.newWindowAct)
 self.newWindowAct.setEnabled(
 not Preferences.getUI("SingleApplicationMode"))
 self.viewProfileActGrp = createActionGroup(self, "viewprofiles", True)
 """<b>Edit Profile</b>"""
 """<p>Activate the "Edit View Profile". Windows being shown,"""
 """ if this profile is active, may be configured with the"""
 """ "View Profile Configuration" dialog.</p>"""
 ))
-self.setEditProfileAct.triggered[()].connect(self.__setEditProfile)
+self.setEditProfileAct.triggered.connect(self.__setEditProfile)
 self.actions.append(self.setEditProfileAct)
 self.setDebugProfileAct = E5Action(
 self.tr('Debug Profile'),
 UI.PixmapCache.getIcon("viewProfileDebug.png"),
 """<b>Debug Profile</b>"""
 """<p>Activate the "Debug View Profile". Windows being shown,"""
 """ if this profile is active, may be configured with the"""
 """ "View Profile Configuration" dialog.</p>"""
 ))
-self.setDebugProfileAct.triggered[()].connect(self.setDebugProfile)
+self.setDebugProfileAct.triggered.connect(self.setDebugProfile)
 self.actions.append(self.setDebugProfileAct)
 self.pbActivateAct = E5Action(
 self.tr('Project-Viewer'),
 self.tr('&Project-Viewer'),
 self.pbActivateAct.setWhatsThis(self.tr(
 """<b>Activate Project-Viewer</b>"""
 """<p>This switches the input focus to the Project-Viewer"""
 """ window.</p>"""
 ))
-self.pbActivateAct.triggered[()].connect(self.__activateProjectBrowser)
+self.pbActivateAct.triggered.connect(self.__activateProjectBrowser)
 self.actions.append(self.pbActivateAct)
 self.addAction(self.pbActivateAct)
 self.mpbActivateAct = E5Action(
 self.tr('Multiproject-Viewer'),
 self.mpbActivateAct.setWhatsThis(self.tr(
 """<b>Activate Multiproject-Viewer</b>"""
 """<p>This switches the input focus to the Multiproject-Viewer"""
 """ window.</p>"""
 ))
-self.mpbActivateAct.triggered[()].connect(
+self.mpbActivateAct.triggered.connect(
 self.__activateMultiProjectBrowser)
 self.actions.append(self.mpbActivateAct)
 self.addAction(self.mpbActivateAct)
 self.debugViewerActivateAct = E5Action(
 self.debugViewerActivateAct.setWhatsThis(self.tr(
 """<b>Activate Debug-Viewer</b>"""
 """<p>This switches the input focus to the Debug-Viewer"""
 """ window.</p>"""
 ))
-self.debugViewerActivateAct.triggered[()].connect(
+self.debugViewerActivateAct.triggered.connect(
 self.__activateDebugViewer)
 self.actions.append(self.debugViewerActivateAct)
 self.addAction(self.debugViewerActivateAct)
 self.shellActivateAct = E5Action(
 "Switch the input focus to the Shell window."))
 self.shellActivateAct.setWhatsThis(self.tr(
 """<b>Activate Shell</b>"""
 """<p>This switches the input focus to the Shell window.</p>"""
 ))
-self.shellActivateAct.triggered[()].connect(self.__activateShell)
+self.shellActivateAct.triggered.connect(self.__activateShell)
 self.actions.append(self.shellActivateAct)
 self.addAction(self.shellActivateAct)
 self.browserActivateAct = E5Action(
 self.tr('File-Browser'),
 self.browserActivateAct.setWhatsThis(self.tr(
 """<b>Activate File-Browser</b>"""
 """<p>This switches the input focus to the File-Browser"""
 """ window.</p>"""
 ))
-self.browserActivateAct.triggered[()].connect(self.__activateBrowser)
+self.browserActivateAct.triggered.connect(self.__activateBrowser)
 self.actions.append(self.browserActivateAct)
 self.addAction(self.browserActivateAct)
 self.logViewerActivateAct = E5Action(
 self.tr('Log-Viewer'),
 self.logViewerActivateAct.setWhatsThis(self.tr(
 """<b>Activate Log-Viewer</b>"""
 """<p>This switches the input focus to the Log-Viewer"""
 """ window.</p>"""
 ))
-self.logViewerActivateAct.triggered[()].connect(
+self.logViewerActivateAct.triggered.connect(
 self.__activateLogViewer)
 self.actions.append(self.logViewerActivateAct)
 self.addAction(self.logViewerActivateAct)
 self.taskViewerActivateAct = E5Action(
 self.taskViewerActivateAct.setWhatsThis(self.tr(
 """<b>Activate Task-Viewer</b>"""
 """<p>This switches the input focus to the Task-Viewer"""
 """ window.</p>"""
 ))
-self.taskViewerActivateAct.triggered[()].connect(
+self.taskViewerActivateAct.triggered.connect(
 self.__activateTaskViewer)
 self.actions.append(self.taskViewerActivateAct)
 self.addAction(self.taskViewerActivateAct)
 self.templateViewerActivateAct = E5Action(
 self.templateViewerActivateAct.setWhatsThis(self.tr(
 """<b>Activate Template-Viewer</b>"""
 """<p>This switches the input focus to the Template-Viewer"""
 """ window.</p>"""
 ))
-self.templateViewerActivateAct.triggered[()].connect(
+self.templateViewerActivateAct.triggered.connect(
 self.__activateTemplateViewer)
 self.actions.append(self.templateViewerActivateAct)
 self.addAction(self.templateViewerActivateAct)
 self.ltAct = E5Action(
 self.ltAct.setWhatsThis(self.tr(
 """<b>Toggle the Left Toolbox window</b>"""
 """<p>If the Left Toolbox window is hidden then display it."""
 """ If it is displayed then close it.</p>"""
 ))
-self.ltAct.triggered[()].connect(self.__toggleLeftToolbox)
+self.ltAct.triggered.connect(self.__toggleLeftToolbox)
 self.actions.append(self.ltAct)
 self.rtAct = E5Action(
 self.tr('Right Toolbox'),
 self.tr('&Right Toolbox'),
 self.rtAct.setWhatsThis(self.tr(
 """<b>Toggle the Right Toolbox window</b>"""
 """<p>If the Right Toolbox window is hidden then display it."""
 """ If it is displayed then close it.</p>"""
 ))
-self.rtAct.triggered[()].connect(self.__toggleRightToolbox)
+self.rtAct.triggered.connect(self.__toggleRightToolbox)
 self.actions.append(self.rtAct)
 self.htAct = E5Action(
 self.tr('Horizontal Toolbox'),
 self.tr('&Horizontal Toolbox'), 0, 0, self,
 self.htAct.setWhatsThis(self.tr(
 """<b>Toggle the Horizontal Toolbox window</b>"""
 """<p>If the Horizontal Toolbox window is hidden then display"""
 """ it. If it is displayed then close it.</p>"""
 ))
-self.htAct.triggered[()].connect(self.__toggleHorizontalToolbox)
+self.htAct.triggered.connect(self.__toggleHorizontalToolbox)
 self.actions.append(self.htAct)
 self.lsbAct = E5Action(
 self.tr('Left Sidebar'),
 self.tr('&Left Sidebar'),
 self.lsbAct.setWhatsThis(self.tr(
 """<b>Toggle the left sidebar window</b>"""
 """<p>If the left sidebar window is hidden then display it."""
 """ If it is displayed then close it.</p>"""
 ))
-self.lsbAct.triggered[()].connect(self.__toggleLeftSidebar)
+self.lsbAct.triggered.connect(self.__toggleLeftSidebar)
 self.actions.append(self.lsbAct)
 self.rsbAct = E5Action(
 self.tr('Right Sidebar'),
 self.tr('&Right Sidebar'),
 self.rsbAct.setWhatsThis(self.tr(
 """<b>Toggle the right sidebar window</b>"""
 """<p>If the right sidebar window is hidden then display it."""
 """ If it is displayed then close it.</p>"""
 ))
-self.rsbAct.triggered[()].connect(self.__toggleRightSidebar)
+self.rsbAct.triggered.connect(self.__toggleRightSidebar)
 self.actions.append(self.rsbAct)
 self.bsbAct = E5Action(
 self.tr('Bottom Sidebar'),
 self.tr('&Bottom Sidebar'), 0, 0, self,
 self.bsbAct.setWhatsThis(self.tr(
 """<b>Toggle the bottom sidebar window</b>"""
 """<p>If the bottom sidebar window is hidden then display it."""
 """ If it is displayed then close it.</p>"""
 ))
-self.bsbAct.triggered[()].connect(self.__toggleBottomSidebar)
+self.bsbAct.triggered.connect(self.__toggleBottomSidebar)
 self.actions.append(self.bsbAct)
 self.cooperationViewerActivateAct = E5Action(
 self.tr('Cooperation-Viewer'),
 self.tr('Co&operation-Viewer'),
 self.cooperationViewerActivateAct.setWhatsThis(self.tr(
 """<b>Activate Cooperation-Viewer</b>"""
 """<p>This switches the input focus to the Cooperation-Viewer"""
 """ window.</p>"""
 ))
-self.cooperationViewerActivateAct.triggered[()].connect(
+self.cooperationViewerActivateAct.triggered.connect(
 self.activateCooperationViewer)
 self.actions.append(self.cooperationViewerActivateAct)
 self.addAction(self.cooperationViewerActivateAct)
 self.ircActivateAct = E5Action(
 "Switch the input focus to the IRC window."))
 self.ircActivateAct.setWhatsThis(self.tr(
 """<b>Activate IRC</b>"""
 """<p>This switches the input focus to the IRC window.</p>"""
 ))
-self.ircActivateAct.triggered[()].connect(
+self.ircActivateAct.triggered.connect(
 self.__activateIRC)
 self.actions.append(self.ircActivateAct)
 self.addAction(self.ircActivateAct)
 self.symbolsViewerActivateAct = E5Action(
 self.symbolsViewerActivateAct.setWhatsThis(self.tr(
 """<b>Activate Symbols-Viewer</b>"""
 """<p>This switches the input focus to the Symbols-Viewer"""
 """ window.</p>"""
 ))
-self.symbolsViewerActivateAct.triggered[()].connect(
+self.symbolsViewerActivateAct.triggered.connect(
 self.__activateSymbolsViewer)
 self.actions.append(self.symbolsViewerActivateAct)
 self.addAction(self.symbolsViewerActivateAct)
 self.numbersViewerActivateAct = E5Action(
 self.numbersViewerActivateAct.setWhatsThis(self.tr(
 """<b>Activate Numbers-Viewer</b>"""
 """<p>This switches the input focus to the Numbers-Viewer"""
 """ window.</p>"""
 ))
-self.numbersViewerActivateAct.triggered[()].connect(
+self.numbersViewerActivateAct.triggered.connect(
 self.__activateNumbersViewer)
 self.actions.append(self.numbersViewerActivateAct)
 self.addAction(self.numbersViewerActivateAct)
 self.whatsThisAct = E5Action(
 """ a question mark, and you can click on the interface elements"""
 """ to get a short description of what they do and how to use"""
 """ them. In dialogs, this feature can be accessed using the"""
 """ context help button in the titlebar.</p>"""
 ))
-self.whatsThisAct.triggered[()].connect(self.__whatsThis)
+self.whatsThisAct.triggered.connect(self.__whatsThis)
 self.actions.append(self.whatsThisAct)
 self.helpviewerAct = E5Action(
 self.tr('Helpviewer'),
 UI.PixmapCache.getIcon("help.png"),
 """ the capability to navigate to links, set bookmarks, print"""
 """ the displayed help and some more features. You may use it to"""
 """ browse the internet as well</p><p>If called with a word"""
 """ selected, this word is search in the Qt help collection.</p>"""
 ))
-self.helpviewerAct.triggered[()].connect(self.__helpViewer)
+self.helpviewerAct.triggered.connect(self.__helpViewer)
 self.actions.append(self.helpviewerAct)
 self.__initQtDocActions()
 self.__initPythonDocActions()
 self.__initEricDocAction()
 'Display version information'))
 self.versionAct.setWhatsThis(self.tr(
 """<b>Show Versions</b>"""
 """<p>Display version information.</p>"""
 ))
-self.versionAct.triggered[()].connect(self.__showVersions)
+self.versionAct.triggered.connect(self.__showVersions)
 self.actions.append(self.versionAct)
 self.checkUpdateAct = E5Action(
 self.tr('Check for Updates'),
 self.tr('Check for &Updates...'), 0, 0, self, 'check_updates')
 self.checkUpdateAct.setStatusTip(self.tr('Check for Updates'))
 self.checkUpdateAct.setWhatsThis(self.tr(
 """<b>Check for Updates...</b>"""
 """<p>Checks the internet for updates of eric5.</p>"""
 ))
-self.checkUpdateAct.triggered[()].connect(self.performVersionCheck)
+self.checkUpdateAct.triggered.connect(self.performVersionCheck)
 self.actions.append(self.checkUpdateAct)
 self.showVersionsAct = E5Action(
 self.tr('Show downloadable versions'),
 self.tr('Show &downloadable versions...'),
 self.showVersionsAct.setWhatsThis(self.tr(
 """<b>Show downloadable versions...</b>"""
 """<p>Shows the eric5 versions available for download """
 """from the internet.</p>"""
 ))
-self.showVersionsAct.triggered[()].connect(
+self.showVersionsAct.triggered.connect(
 self.showAvailableVersionsInfo)
 self.actions.append(self.showVersionsAct)
 self.showErrorLogAct = E5Action(
 self.tr('Show Error Log'),
 self.showErrorLogAct.setStatusTip(self.tr('Show Error Log'))
 self.showErrorLogAct.setWhatsThis(self.tr(
 """<b>Show Error Log...</b>"""
 """<p>Opens a dialog showing the most recent error log.</p>"""
 ))
-self.showErrorLogAct.triggered[()].connect(self.__showErrorLog)
+self.showErrorLogAct.triggered.connect(self.__showErrorLog)
 self.actions.append(self.showErrorLogAct)
 self.reportBugAct = E5Action(
 self.tr('Report Bug'),
 self.tr('Report &Bug...'),
 self.reportBugAct.setStatusTip(self.tr('Report a bug'))
 self.reportBugAct.setWhatsThis(self.tr(
 """<b>Report Bug...</b>"""
 """<p>Opens a dialog to report a bug.</p>"""
 ))
-self.reportBugAct.triggered[()].connect(self.__reportBug)
+self.reportBugAct.triggered.connect(self.__reportBug)
 self.actions.append(self.reportBugAct)
 self.requestFeatureAct = E5Action(
 self.tr('Request Feature'),
 self.tr('Request &Feature...'),
 'Send a feature request'))
 self.requestFeatureAct.setWhatsThis(self.tr(
 """<b>Request Feature...</b>"""
 """<p>Opens a dialog to send a feature request.</p>"""
 ))
-self.requestFeatureAct.triggered[()].connect(self.__requestFeature)
+self.requestFeatureAct.triggered.connect(self.__requestFeature)
 self.actions.append(self.requestFeatureAct)
 self.utActGrp = createActionGroup(self)
 self.utDialogAct = E5Action(
 self.utDialogAct.setWhatsThis(self.tr(
 """<b>Unittest</b>"""
 """<p>Perform unit tests. The dialog gives you the"""
 """ ability to select and run a unittest suite.</p>"""
 ))
-self.utDialogAct.triggered[()].connect(self.__unittest)
+self.utDialogAct.triggered.connect(self.__unittest)
 self.actions.append(self.utDialogAct)
 self.utRestartAct = E5Action(
 self.tr('Unittest Restart'),
 UI.PixmapCache.getIcon("unittestRestart.png"),
 self.utRestartAct.setStatusTip(self.tr('Restart last unittest'))
 self.utRestartAct.setWhatsThis(self.tr(
 """<b>Restart Unittest</b>"""
 """<p>Restart the unittest performed last.</p>"""
 ))
-self.utRestartAct.triggered[()].connect(self.__unittestRestart)
+self.utRestartAct.triggered.connect(self.__unittestRestart)
 self.utRestartAct.setEnabled(False)
 self.actions.append(self.utRestartAct)
 self.utRerunFailedAct = E5Action(
 self.tr('Unittest Rerun Failed'),
 self.utRerunFailedAct.setWhatsThis(self.tr(
 """<b>Rerun Failed Tests</b>"""
 """<p>Rerun all tests that failed during the last unittest"""
 """ run.</p>"""
 ))
-self.utRerunFailedAct.triggered[()].connect(self.__unittestRerunFailed)
+self.utRerunFailedAct.triggered.connect(self.__unittestRerunFailed)
 self.utRerunFailedAct.setEnabled(False)
 self.actions.append(self.utRerunFailedAct)
 self.utScriptAct = E5Action(
 self.tr('Unittest Script'),
 'Run unittest with current script'))
 self.utScriptAct.setWhatsThis(self.tr(
 """<b>Unittest Script</b>"""
 """<p>Run unittest with current script.</p>"""
 ))
-self.utScriptAct.triggered[()].connect(self.__unittestScript)
+self.utScriptAct.triggered.connect(self.__unittestScript)
 self.utScriptAct.setEnabled(False)
 self.actions.append(self.utScriptAct)
 self.utProjectAct = E5Action(
 self.tr('Unittest Project'),
 'Run unittest with current project'))
 self.utProjectAct.setWhatsThis(self.tr(
 """<b>Unittest Project</b>"""
 """<p>Run unittest with current project.</p>"""
 ))
-self.utProjectAct.triggered[()].connect(self.__unittestProject)
+self.utProjectAct.triggered.connect(self.__unittestProject)
 self.utProjectAct.setEnabled(False)
 self.actions.append(self.utProjectAct)
 # check for Qt4/Qt5 designer and linguist
 if Utilities.isWindowsPlatform():
 self.designer4Act.setStatusTip(self.tr('Start Qt-Designer'))
 self.designer4Act.setWhatsThis(self.tr(
 """<b>Qt-Designer</b>"""
 """<p>Start Qt-Designer.</p>"""
 ))
-self.designer4Act.triggered[()].connect(self.__designer4)
+self.designer4Act.triggered.connect(self.__designer4)
 self.actions.append(self.designer4Act)
 else:
 self.designer4Act = None
 if Utilities.isWindowsPlatform():
 self.linguist4Act.setStatusTip(self.tr('Start Qt-Linguist'))
 self.linguist4Act.setWhatsThis(self.tr(
 """<b>Qt-Linguist</b>"""
 """<p>Start Qt-Linguist.</p>"""
 ))
-self.linguist4Act.triggered[()].connect(self.__linguist4)
+self.linguist4Act.triggered.connect(self.__linguist4)
 self.actions.append(self.linguist4Act)
 else:
 self.linguist4Act = None
 self.uipreviewerAct = E5Action(
 self.uipreviewerAct.setStatusTip(self.tr('Start the UI Previewer'))
 self.uipreviewerAct.setWhatsThis(self.tr(
 """<b>UI Previewer</b>"""
 """<p>Start the UI Previewer.</p>"""
 ))
-self.uipreviewerAct.triggered[()].connect(self.__UIPreviewer)
+self.uipreviewerAct.triggered.connect(self.__UIPreviewer)
 self.actions.append(self.uipreviewerAct)
 self.trpreviewerAct = E5Action(
 self.tr('Translations Previewer'),
 UI.PixmapCache.getIcon("trPreviewer.png"),
 'Start the Translations Previewer'))
 self.trpreviewerAct.setWhatsThis(self.tr(
 """<b>Translations Previewer</b>"""
 """<p>Start the Translations Previewer.</p>"""
 ))
-self.trpreviewerAct.triggered[()].connect(self.__TRPreviewer)
+self.trpreviewerAct.triggered.connect(self.__TRPreviewer)
 self.actions.append(self.trpreviewerAct)
 self.diffAct = E5Action(
 self.tr('Compare Files'),
 UI.PixmapCache.getIcon("diffFiles.png"),
 self.diffAct.setStatusTip(self.tr('Compare two files'))
 self.diffAct.setWhatsThis(self.tr(
 """<b>Compare Files</b>"""
 """<p>Open a dialog to compare two files.</p>"""
 ))
-self.diffAct.triggered[()].connect(self.__compareFiles)
+self.diffAct.triggered.connect(self.__compareFiles)
 self.actions.append(self.diffAct)
 self.compareAct = E5Action(
 self.tr('Compare Files side by side'),
 UI.PixmapCache.getIcon("compareFiles.png"),
 self.compareAct.setWhatsThis(self.tr(
 """<b>Compare Files side by side</b>"""
 """<p>Open a dialog to compare two files and show the result"""
 """ side by side.</p>"""
 ))
-self.compareAct.triggered[()].connect(self.__compareFilesSbs)
+self.compareAct.triggered.connect(self.__compareFilesSbs)
 self.actions.append(self.compareAct)
 self.sqlBrowserAct = E5Action(
 self.tr('SQL Browser'),
 UI.PixmapCache.getIcon("sqlBrowser.png"),
 self.sqlBrowserAct.setStatusTip(self.tr('Browse a SQL database'))
 self.sqlBrowserAct.setWhatsThis(self.tr(
 """<b>SQL Browser</b>"""
 """<p>Browse a SQL database.</p>"""
 ))
-self.sqlBrowserAct.triggered[()].connect(self.__sqlBrowser)
+self.sqlBrowserAct.triggered.connect(self.__sqlBrowser)
 self.actions.append(self.sqlBrowserAct)
 self.miniEditorAct = E5Action(
 self.tr('Mini Editor'),
 UI.PixmapCache.getIcon("editor.png"),
 self.miniEditorAct.setStatusTip(self.tr('Mini Editor'))
 self.miniEditorAct.setWhatsThis(self.tr(
 """<b>Mini Editor</b>"""
 """<p>Open a dialog with a simplified editor.</p>"""
 ))
-self.miniEditorAct.triggered[()].connect(self.__openMiniEditor)
+self.miniEditorAct.triggered.connect(self.__openMiniEditor)
 self.actions.append(self.miniEditorAct)
 self.webBrowserAct = E5Action(
 self.tr('eric5 Web Browser'),
 UI.PixmapCache.getIcon("ericWeb.png"),
 'Start the eric5 Web Browser'))
 self.webBrowserAct.setWhatsThis(self.tr(
 """<b>eric5 Web Browser</b>"""
 """<p>Browse the Internet with the eric5 Web Browser.</p>"""
 ))
-self.webBrowserAct.triggered[()].connect(self.__startWebBrowser)
+self.webBrowserAct.triggered.connect(self.__startWebBrowser)
 self.actions.append(self.webBrowserAct)
 self.iconEditorAct = E5Action(
 self.tr('Icon Editor'),
 UI.PixmapCache.getIcon("iconEditor.png"),
 'Start the eric5 Icon Editor'))
 self.iconEditorAct.setWhatsThis(self.tr(
 """<b>Icon Editor</b>"""
 """<p>Starts the eric5 Icon Editor for editing simple icons.</p>"""
 ))
-self.iconEditorAct.triggered[()].connect(self.__editPixmap)
+self.iconEditorAct.triggered.connect(self.__editPixmap)
 self.actions.append(self.iconEditorAct)
 self.snapshotAct = E5Action(
 self.tr('Snapshot'),
 UI.PixmapCache.getIcon("ericSnap.png"),
 self.snapshotAct.setWhatsThis(self.tr(
 """<b>Snapshot</b>"""
 """<p>This opens a dialog to take snapshots of a screen"""
 """ region.</p>"""
 ))
-self.snapshotAct.triggered[()].connect(self.__snapshot)
+self.snapshotAct.triggered.connect(self.__snapshot)
 self.actions.append(self.snapshotAct)
 self.prefAct = E5Action(
 self.tr('Preferences'),
 UI.PixmapCache.getIcon("configure.png"),
 self.prefAct.setWhatsThis(self.tr(
 """<b>Preferences</b>"""
 """<p>Set the configuration items of the application"""
 """ with your prefered values.</p>"""
 ))
-self.prefAct.triggered[()].connect(self.showPreferences)
+self.prefAct.triggered.connect(self.showPreferences)
 self.prefAct.setMenuRole(QAction.PreferencesRole)
 self.actions.append(self.prefAct)
 self.prefExportAct = E5Action(
 self.tr('Export Preferences'),
 'Export the current configuration'))
 self.prefExportAct.setWhatsThis(self.tr(
 """<b>Export Preferences</b>"""
 """<p>Export the current configuration to a file.</p>"""
 ))
-self.prefExportAct.triggered[()].connect(self.__exportPreferences)
+self.prefExportAct.triggered.connect(self.__exportPreferences)
 self.actions.append(self.prefExportAct)
 self.prefImportAct = E5Action(
 self.tr('Import Preferences'),
 UI.PixmapCache.getIcon("configureImport.png"),
 'Import a previously exported configuration'))
 self.prefImportAct.setWhatsThis(self.tr(
 """<b>Import Preferences</b>"""
 """<p>Import a previously exported configuration.</p>"""
 ))
-self.prefImportAct.triggered[()].connect(self.__importPreferences)
+self.prefImportAct.triggered.connect(self.__importPreferences)
 self.actions.append(self.prefImportAct)
 self.reloadAPIsAct = E5Action(
 self.tr('Reload APIs'),
 self.tr('Reload &APIs'),
 'Reload the API information'))
 self.reloadAPIsAct.setWhatsThis(self.tr(
 """<b>Reload APIs</b>"""
 """<p>Reload the API information.</p>"""
 ))
-self.reloadAPIsAct.triggered[()].connect(self.__reloadAPIs)
+self.reloadAPIsAct.triggered.connect(self.__reloadAPIs)
 self.actions.append(self.reloadAPIsAct)
 self.showExternalToolsAct = E5Action(
 self.tr('Show external tools'),
 UI.PixmapCache.getIcon("showPrograms.png"),
 self.showExternalToolsAct.setWhatsThis(self.tr(
 """<b>Show external tools</b>"""
 """<p>Opens a dialog to show the path and versions of all"""
 """ extenal tools used by eric5.</p>"""
 ))
-self.showExternalToolsAct.triggered[()].connect(
+self.showExternalToolsAct.triggered.connect(
 self.__showExternalTools)
 self.actions.append(self.showExternalToolsAct)
 self.configViewProfilesAct = E5Action(
 self.tr('View Profiles'),
 """<b>View Profiles</b>"""
 """<p>Configure the view profiles. With this dialog you may"""
 """ set the visibility of the various windows for the"""
 """ predetermined view profiles.</p>"""
 ))
-self.configViewProfilesAct.triggered[()].connect(
+self.configViewProfilesAct.triggered.connect(
 self.__configViewProfiles)
 self.actions.append(self.configViewProfilesAct)
 self.configToolBarsAct = E5Action(
 self.tr('Toolbars'),
 """<b>Toolbars</b>"""
 """<p>Configure the toolbars. With this dialog you may"""
 """ change the actions shown on the various toolbars and"""
 """ define your own toolbars.</p>"""
 ))
-self.configToolBarsAct.triggered[()].connect(self.__configToolBars)
+self.configToolBarsAct.triggered.connect(self.__configToolBars)
 self.actions.append(self.configToolBarsAct)
 self.shortcutsAct = E5Action(
 self.tr('Keyboard Shortcuts'),
 UI.PixmapCache.getIcon("configureShortcuts.png"),
 self.shortcutsAct.setWhatsThis(self.tr(
 """<b>Keyboard Shortcuts</b>"""
 """<p>Set the keyboard shortcuts of the application"""
 """ with your prefered values.</p>"""
 ))
-self.shortcutsAct.triggered[()].connect(self.__configShortcuts)
+self.shortcutsAct.triggered.connect(self.__configShortcuts)
 self.actions.append(self.shortcutsAct)
 self.exportShortcutsAct = E5Action(
 self.tr('Export Keyboard Shortcuts'),
 UI.PixmapCache.getIcon("exportShortcuts.png"),
 'Export the keyboard shortcuts'))
 self.exportShortcutsAct.setWhatsThis(self.tr(
 """<b>Export Keyboard Shortcuts</b>"""
 """<p>Export the keyboard shortcuts of the application.</p>"""
 ))
-self.exportShortcutsAct.triggered[()].connect(self.__exportShortcuts)
+self.exportShortcutsAct.triggered.connect(self.__exportShortcuts)
 self.actions.append(self.exportShortcutsAct)
 self.importShortcutsAct = E5Action(
 self.tr('Import Keyboard Shortcuts'),
 UI.PixmapCache.getIcon("importShortcuts.png"),
 'Import the keyboard shortcuts'))
 self.importShortcutsAct.setWhatsThis(self.tr(
 """<b>Import Keyboard Shortcuts</b>"""
 """<p>Import the keyboard shortcuts of the application.</p>"""
 ))
-self.importShortcutsAct.triggered[()].connect(self.__importShortcuts)
+self.importShortcutsAct.triggered.connect(self.__importShortcuts)
 self.actions.append(self.importShortcutsAct)
 if SSL_AVAILABLE:
 self.certificatesAct = E5Action(
 self.tr('Manage SSL Certificates'),
 self.certificatesAct.setWhatsThis(self.tr(
 """<b>Manage SSL Certificates...</b>"""
 """<p>Opens a dialog to manage the saved SSL certificates."""
 """</p>"""
 ))
-self.certificatesAct.triggered[()].connect(
+self.certificatesAct.triggered.connect(
 self.__showCertificatesDialog)
 self.actions.append(self.certificatesAct)
 self.editMessageFilterAct = E5Action(
 self.tr('Edit Message Filters'),
 """<b>Edit Message Filters</b>"""
 """<p>Opens a dialog to edit the message filters used to"""
 """ suppress unwanted messages been shown in an error"""
 """ window.</p>"""
 ))
-self.editMessageFilterAct.triggered[()].connect(
+self.editMessageFilterAct.triggered.connect(
 E5ErrorMessage.editMessageFilters)
 self.actions.append(self.editMessageFilterAct)
 self.viewmanagerActivateAct = E5Action(
 self.tr('Activate current editor'),
 self.tr('Activate current editor'),
 QKeySequence(self.tr("Alt+Shift+E")),
 0, self, 'viewmanager_activate', 1)
-self.viewmanagerActivateAct.triggered[()].connect(
+self.viewmanagerActivateAct.triggered.connect(
 self.__activateViewmanager)
 self.actions.append(self.viewmanagerActivateAct)
 self.addAction(self.viewmanagerActivateAct)
 self.nextTabAct = E5Action(
 self.tr('Show next'),
 self.tr('Show next'),
 QKeySequence(self.tr('Ctrl+Alt+Tab')), 0,
 self, 'view_next_tab')
-self.nextTabAct.triggered[()].connect(self.__showNext)
+self.nextTabAct.triggered.connect(self.__showNext)
 self.actions.append(self.nextTabAct)
 self.addAction(self.nextTabAct)
 self.prevTabAct = E5Action(
 self.tr('Show previous'),
 self.tr('Show previous'),
 QKeySequence(self.tr('Shift+Ctrl+Alt+Tab')), 0,
 self, 'view_previous_tab')
-self.prevTabAct.triggered[()].connect(self.__showPrevious)
+self.prevTabAct.triggered.connect(self.__showPrevious)
 self.actions.append(self.prevTabAct)
 self.addAction(self.prevTabAct)
 self.switchTabAct = E5Action(
 self.tr('Switch between tabs'),
 self.tr('Switch between tabs'),
 QKeySequence(self.tr('Ctrl+1')), 0,
 self, 'switch_tabs')
-self.switchTabAct.triggered[()].connect(self.__switchTab)
+self.switchTabAct.triggered.connect(self.__switchTab)
 self.actions.append(self.switchTabAct)
 self.addAction(self.switchTabAct)
 self.pluginInfoAct = E5Action(
 self.tr('Plugin Infos'),
 self.pluginInfoAct.setWhatsThis(self.tr(
 """<b>Plugin Infos...</b>"""
 """<p>This opens a dialog, that show some information about"""
 """ loaded plugins.</p>"""
 ))
-self.pluginInfoAct.triggered[()].connect(self.__showPluginInfo)
+self.pluginInfoAct.triggered.connect(self.__showPluginInfo)
 self.actions.append(self.pluginInfoAct)
 self.pluginInstallAct = E5Action(
 self.tr('Install Plugins'),
 UI.PixmapCache.getIcon("pluginInstall.png"),
 self.pluginInstallAct.setStatusTip(self.tr('Install Plugins'))
 self.pluginInstallAct.setWhatsThis(self.tr(
 """<b>Install Plugins...</b>"""
 """<p>This opens a dialog to install or update plugins.</p>"""
 ))
-self.pluginInstallAct.triggered[()].connect(self.__installPlugins)
+self.pluginInstallAct.triggered.connect(self.__installPlugins)
 self.actions.append(self.pluginInstallAct)
 self.pluginDeinstallAct = E5Action(
 self.tr('Uninstall Plugin'),
 UI.PixmapCache.getIcon("pluginUninstall.png"),
 self.pluginDeinstallAct.setStatusTip(self.tr('Uninstall Plugin'))
 self.pluginDeinstallAct.setWhatsThis(self.tr(
 """<b>Uninstall Plugin...</b>"""
 """<p>This opens a dialog to uninstall a plugin.</p>"""
 ))
-self.pluginDeinstallAct.triggered[()].connect(self.__deinstallPlugin)
+self.pluginDeinstallAct.triggered.connect(self.__deinstallPlugin)
 self.actions.append(self.pluginDeinstallAct)
 self.pluginRepoAct = E5Action(
 self.tr('Plugin Repository'),
 UI.PixmapCache.getIcon("pluginRepository.png"),
 self.pluginRepoAct.setWhatsThis(self.tr(
 """<b>Plugin Repository...</b>"""
 """<p>This opens a dialog, that shows a list of plugins """
 """available on the Internet.</p>"""
 ))
-self.pluginRepoAct.triggered[()].connect(self.showPluginsAvailable)
+self.pluginRepoAct.triggered.connect(self.showPluginsAvailable)
 self.actions.append(self.pluginRepoAct)
 # initialize viewmanager actions
 self.viewmanager.initActions()
 """<b>Qt4 Documentation</b>"""
 """<p>Display the Qt4 Documentation. Dependent upon your"""
 """ settings, this will either show the help in Eric's internal"""
 """ help viewer, or execute a web browser or Qt Assistant. </p>"""
 ))
-self.qt4DocAct.triggered[()].connect(self.__showQt4Doc)
+self.qt4DocAct.triggered.connect(self.__showQt4Doc)
 self.actions.append(self.qt4DocAct)
 self.qt5DocAct = E5Action(
 self.tr('Qt5 Documentation'),
 self.tr('Qt&5 Documentation'),
 """<b>Qt5 Documentation</b>"""
 """<p>Display the Qt5 Documentation. Dependent upon your"""
 """ settings, this will either show the help in Eric's internal"""
 """ help viewer, or execute a web browser or Qt Assistant. </p>"""
 ))
-self.qt5DocAct.triggered[()].connect(self.__showQt5Doc)
+self.qt5DocAct.triggered.connect(self.__showQt5Doc)
 self.actions.append(self.qt5DocAct)
 self.pyqt4DocAct = E5Action(
 self.tr('PyQt4 Documentation'),
 self.tr('PyQt&4 Documentation'),
 """<b>PyQt4 Documentation</b>"""
 """<p>Display the PyQt4 Documentation. Dependent upon your"""
 """ settings, this will either show the help in Eric's internal"""
 """ help viewer, or execute a web browser or Qt Assistant. </p>"""
 ))
-self.pyqt4DocAct.triggered[()].connect(self.__showPyQt4Doc)
+self.pyqt4DocAct.triggered.connect(self.__showPyQt4Doc)
 self.actions.append(self.pyqt4DocAct)
 try:
 import PyQt5        # __IGNORE_WARNING__
 self.pyqt5DocAct = E5Action(
 """<p>Display the PyQt5 Documentation. Dependent upon your"""
 """ settings, this will either show the help in Eric's"""
 """ internal help viewer, or execute a web browser or"""
 """ Qt Assistant. </p>"""
 ))
-self.pyqt5DocAct.triggered[()].connect(self.__showPyQt5Doc)
+self.pyqt5DocAct.triggered.connect(self.__showPyQt5Doc)
 self.actions.append(self.pyqt5DocAct)
 except ImportError:
 self.pyqt5DocAct = None
 def __initPythonDocActions(self):
 """ documentation is assumed to be the doc directory underneath"""
 """ the location of the Python 3 executable on Windows and"""
 """ <i>/usr/share/doc/packages/python/html</i> on Unix. Set"""
 """ PYTHON3DOCDIR in your environment to override this.</p>"""
 ))
-self.pythonDocAct.triggered[()].connect(self.__showPythonDoc)
+self.pythonDocAct.triggered.connect(self.__showPythonDoc)
 self.actions.append(self.pythonDocAct)
 self.python2DocAct = E5Action(
 self.tr('Python 2 Documentation'),
 self.tr('Python &2 Documentation'),
 """ Windows and"""
 """ <i>/usr/share/doc/packages/python/html/python-docs-html</i>"""
 """ on Unix. Set PYTHON2DOCDIR in your environment to override"""
 """ this. </p>"""
 ))
-self.python2DocAct.triggered[()].connect(self.__showPython2Doc)
+self.python2DocAct.triggered.connect(self.__showPython2Doc)
 self.actions.append(self.python2DocAct)
 def __initEricDocAction(self):
 """
 Private slot to initialize the action to show the eric5 documentation.
 """<b>Eric API Documentation</b>"""
 """<p>Display the Eric API documentation. The location for the"""
 """ documentation is the Documentation/Source subdirectory of"""
 """ the eric5 installation directory.</p>"""
 ))
-self.ericDocAct.triggered[()].connect(self.__showEricDoc)
+self.ericDocAct.triggered.connect(self.__showEricDoc)
 self.actions.append(self.ericDocAct)
 def __initPySideDocAction(self):
 """
 Private slot to initialize the action to show the PySide documentation.
 """<p>Display the PySide Documentation. Dependent upon your"""
 """ settings, this will either show the help in Eric's"""
 """ internal help viewer, or execute a web browser or"""
 """ Qt Assistant. </p>"""
 ))
-self.pysideDocAct.triggered[()].connect(self.__showPySideDoc)
+self.pysideDocAct.triggered.connect(self.__showPySideDoc)
 self.actions.append(self.pysideDocAct)
 else:
 self.pysideDocAct = None
 def __initMenus(self):
 if tool['menutext'] != '--':
 act = QAction(UI.PixmapCache.getIcon(tool['icon']),
 tool['menutext'], self)
 act.setObjectName("{0}@@{1}".format(toolGroup[0],
 tool['menutext']))
-act.triggered[()].connect(self.__toolActionTriggered)
+act.triggered.connect(self.__toolActionTriggered)
 self.toolGroupActions[act.objectName()] = act
 self.toolbarManager.addAction(act, category)
 def __updateExternalToolsActions(self):
 # step 3: remove all actions not configured any more
 for key in groupActionKeys:
 if key not in ckeys:
 self.toolbarManager.removeAction(self.toolGroupActions[key])
-self.toolGroupActions[key].triggered[()].disconnect(
+self.toolGroupActions[key].triggered.disconnect(
 self.__toolActionTriggered)
 del self.toolGroupActions[key]
 # step 4: add all newly configured tools
 category = self.tr("External Tools/{0}").format(toolGroup[0])
 key = "{0}@@{1}".format(toolGroup[0], tool['menutext'])
 if key not in groupActionKeys:
 act = QAction(UI.PixmapCache.getIcon(tool['icon']),
 tool['menutext'], self)
 act.setObjectName(key)
-act.triggered[()].connect(self.__toolActionTriggered)
+act.triggered.connect(self.__toolActionTriggered)
 self.toolGroupActions[key] = act
 self.toolbarManager.addAction(act, category)
 def __showFileMenu(self):
 self.bottomSidebar.setCurrentWidget(self.__currentBottomWidget)
 self.__currentRightWidget = None
 self.__currentBottomWidget = None
 self.__activateViewmanager()
+@pyqtSlot()
 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)
 """
 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
 Private slot for displaying the unittest dialog.
 """
 self.__createUnitTestDialog()
 self.unittestDialog.show()
 self.unittestDialog.raise_()
+@pyqtSlot()
+@pyqtSlot(str)
 def __unittestScript(self, prog=None):
 """
 Private slot for displaying the unittest dialog and run the current
 script.
 self.tr('Process Generation Error'),
 self.tr(
 '<p>Could not start Qt-Linguist.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(linguist))
+@pyqtSlot()
+@pyqtSlot(str)
 def __linguist4(self, fn=None):
 """
 Private slot to start the Qt-Linguist 4 executable.
 @param fn filename of the translation file to be opened
 self.tr(
 '<p>Could not start the help viewer.<br>'
 'Ensure that it is available as <b>hh</b>.</p>'
 ))
+@pyqtSlot()
+@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)
 self.tr(
 '<p>Could not start UI Previewer.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(viewer))
+@pyqtSlot()
+@pyqtSlot(str)
+@pyqtSlot(str, bool)
 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
 self.tr(
 '<p>Could not start SQL Browser.<br>'
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(browser))
+@pyqtSlot()
+@pyqtSlot(str)
 def __editPixmap(self, fn=""):
 """
 Private slot to show a pixmap in a dialog.
 @param fn filename of the file to show (string)
 """
 from IconEditor.IconEditorWindow import IconEditorWindow
 dlg = IconEditorWindow(fn, self, fromEric=True, project=self.project)
 dlg.show()
+@pyqtSlot()
+@pyqtSlot(str)
 def __showPixmap(self, fn):
 """
 Private slot to show a pixmap in a dialog.
 @param fn filename of the file to show (string)
 from Graphics.PixmapDiagram import PixmapDiagram
 dlg = PixmapDiagram(fn, self)
 if dlg.getStatus():
 dlg.show()
+@pyqtSlot()
+@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)
 if self.helpWindow is None:
 self.launchHelpViewer("", useSingle=True)
 self.helpWindow.raise_()
 return self.helpWindow
+@pyqtSlot()
+@pyqtSlot(str)
 def showPreferences(self, pageName=None):
 """
 Public slot to set the preferences.
 @param pageName name of the configuration page to show (string)
 """
 from PluginManager.PluginInfoDialog import PluginInfoDialog
 self.__pluginInfoDialog = PluginInfoDialog(self.pluginManager, self)
 self.__pluginInfoDialog.show()
+@pyqtSlot()
 def __installPlugins(self, pluginFileNames=[]):
 """
 Private slot to show a dialog to install a new plugin.
 @param pluginFileNames list of plugin files suggested for
 """
 Public method to show the eric5 versions available for download.
 """
 self.performVersionCheck(manual=True, showVersions=True)
+@pyqtSlot()
 def performVersionCheck(self, manual=True, alternative=0,
 showVersions=False):
 """
 Public method to check the internet for an eric5 update.
 self.__versionCheckProgress.setValue(alternative)
 request = QNetworkRequest(url)
 request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
 QNetworkRequest.AlwaysNetwork)
 reply = self.__networkManager.get(request)
-reply.finished[()].connect(self.__versionsDownloadDone)
+reply.finished.connect(self.__versionsDownloadDone)
 self.__replies.append(reply)
 def __versionsDownloadDone(self):
 """
 Private method called, after the versions file has been downloaded

Mercurial Repositories > eric / file comparison

comparison: UI/UserInterface.py

UI/UserInterface.py