eric: comparison ViewManager/ViewManager.py

-:96232974dcdb
+:645c12de6b0c
 from __future__ import unicode_literals
 import os
-from PyQt4.QtCore import QSignalMapper, QTimer, QFileInfo, pyqtSignal, \
+from PyQt4.QtCore import pyqtSignal, QSignalMapper, QTimer, \
-QRegExp, QObject, Qt
+QFileInfo, QRegExp, QObject, Qt
 from PyQt4.QtGui import QColor, QKeySequence, QLineEdit, QToolBar, \
 QWidgetAction, QDialog, QApplication, QMenu, QPalette, QComboBox, QPixmap
 from PyQt4.Qsci import QsciScintilla
 from E5Gui.E5Application import e5App
 self.sbWritable = sbWritable
 self.sbEnc = sbEncoding
 self.sbLang = sbLanguage
 self.sbEol = sbEol
 self.sbZoom = sbZoom
-self.sbZoom.valueChanged.connect(self.__zoom)
+self.sbZoom.valueChanged.connect(self.__zoomTo)
 self.__setSbFile(zoom=0)
+self.sbLang.clicked.connect(self.__showLanguagesMenu)
+self.sbEol.clicked.connect(self.__showEolMenu)
+self.sbEnc.clicked.connect(self.__showEncodingsMenu)
+##################################################################
+## Below are menu handling methods for status bar labels
+##################################################################
+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)
+"""
+aw = self.activeWindow()
+if aw is not None:
+menu = aw.getMenu("Languages")
+if menu is not None:
+menu.exec_(pos)
+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)
+"""
+aw = self.activeWindow()
+if aw is not None:
+menu = aw.getMenu("Eol")
+if menu is not None:
+menu.exec_(pos)
+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)
+"""
+aw = self.activeWindow()
+if aw is not None:
+menu = aw.getMenu("Encodings")
+if menu is not None:
+menu.exec_(pos)
 ###########################################################################
 ## methods below need to be implemented by a subclass
 ###########################################################################
 self.newAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>New</b>"""
 """<p>An empty editor window will be created.</p>"""
 ))
-self.newAct.triggered[()].connect(self.newEditor)
+self.newAct.triggered.connect(self.newEditor)
 self.fileActions.append(self.newAct)
 self.openAct = E5Action(
 QApplication.translate('ViewManager', 'Open'),
 UI.PixmapCache.getIcon("open.png"),
 'ViewManager',
 """<b>Open a file</b>"""
 """<p>You will be asked for the name of a file to be opened"""
 """ in an editor window.</p>"""
 ))
-self.openAct.triggered[()].connect(self.openFiles)
+self.openAct.triggered.connect(self.__openFiles)
 self.fileActions.append(self.openAct)
 self.closeActGrp = createActionGroup(self)
 self.closeAct = E5Action(
 self.closeAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Close Window</b>"""
 """<p>Close the current window.</p>"""
 ))
-self.closeAct.triggered[()].connect(self.closeCurrentWindow)
+self.closeAct.triggered.connect(self.closeCurrentWindow)
 self.fileActions.append(self.closeAct)
 self.closeAllAct = E5Action(
 QApplication.translate('ViewManager', 'Close All'),
 QApplication.translate('ViewManager', 'Clos&e All'),
 self.closeAllAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Close All Windows</b>"""
 """<p>Close all editor windows.</p>"""
 ))
-self.closeAllAct.triggered[()].connect(self.closeAllWindows)
+self.closeAllAct.triggered.connect(self.closeAllWindows)
 self.fileActions.append(self.closeAllAct)
 self.closeActGrp.setEnabled(False)
 self.saveActGrp = createActionGroup(self)
 self.saveAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Save File</b>"""
 """<p>Save the contents of current editor window.</p>"""
 ))
-self.saveAct.triggered[()].connect(self.saveCurrentEditor)
+self.saveAct.triggered.connect(self.saveCurrentEditor)
 self.fileActions.append(self.saveAct)
 self.saveAsAct = E5Action(
 QApplication.translate('ViewManager', 'Save as'),
 UI.PixmapCache.getIcon("fileSaveAs.png"),
 'ViewManager',
 """<b>Save File as</b>"""
 """<p>Save the contents of current editor window to a new file."""
 """ The file can be entered in a file selection dialog.</p>"""
 ))
-self.saveAsAct.triggered[()].connect(self.saveAsCurrentEditor)
+self.saveAsAct.triggered.connect(self.saveAsCurrentEditor)
 self.fileActions.append(self.saveAsAct)
 self.saveAllAct = E5Action(
 QApplication.translate('ViewManager', 'Save all'),
 UI.PixmapCache.getIcon("fileSaveAll.png"),
 self.saveAllAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Save All Files</b>"""
 """<p>Save the contents of all editor windows.</p>"""
 ))
-self.saveAllAct.triggered[()].connect(self.saveAllEditors)
+self.saveAllAct.triggered.connect(self.saveAllEditors)
 self.fileActions.append(self.saveAllAct)
 self.saveActGrp.setEnabled(False)
 self.printAct = E5Action(
 self.printAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Print File</b>"""
 """<p>Print the contents of current editor window.</p>"""
 ))
-self.printAct.triggered[()].connect(self.printCurrentEditor)
+self.printAct.triggered.connect(self.printCurrentEditor)
 self.printAct.setEnabled(False)
 self.fileActions.append(self.printAct)
 self.printPreviewAct = E5Action(
 QApplication.translate('ViewManager', 'Print Preview'),
 self.printPreviewAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Print Preview</b>"""
 """<p>Print preview of the current editor window.</p>"""
 ))
-self.printPreviewAct.triggered[()].connect(
+self.printPreviewAct.triggered.connect(
 self.printPreviewCurrentEditor)
 self.printPreviewAct.setEnabled(False)
 self.fileActions.append(self.printPreviewAct)
 self.findFileNameAct = E5Action(
 self.findFileNameAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Search File</b>"""
 """<p>Search for a file.</p>"""
 ))
-self.findFileNameAct.triggered[()].connect(self.__findFileName)
+self.findFileNameAct.triggered.connect(self.__findFileName)
 self.fileActions.append(self.findFileNameAct)
 def initFileMenu(self):
 """
 Public method to create the File menu.
 self.undoAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Undo</b>"""
 """<p>Undo the last change done in the current editor.</p>"""
 ))
-self.undoAct.triggered[()].connect(self.__editUndo)
+self.undoAct.triggered.connect(self.__editUndo)
 self.editActions.append(self.undoAct)
 self.redoAct = E5Action(
 QApplication.translate('ViewManager', 'Redo'),
 UI.PixmapCache.getIcon("editRedo.png"),
 self.redoAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Redo</b>"""
 """<p>Redo the last change done in the current editor.</p>"""
 ))
-self.redoAct.triggered[()].connect(self.__editRedo)
+self.redoAct.triggered.connect(self.__editRedo)
 self.editActions.append(self.redoAct)
 self.revertAct = E5Action(
 QApplication.translate(
 'ViewManager', 'Revert to last saved state'),
 'ViewManager',
 """<b>Revert to last saved state</b>"""
 """<p>Undo all changes up to the last saved state"""
 """ of the current editor.</p>"""
 ))
-self.revertAct.triggered[()].connect(self.__editRevert)
+self.revertAct.triggered.connect(self.__editRevert)
 self.editActions.append(self.revertAct)
 self.copyActGrp = createActionGroup(self.editActGrp)
 self.cutAct = E5Action(
 'ViewManager',
 """<b>Cut</b>"""
 """<p>Cut the selected text of the current editor to the"""
 """ clipboard.</p>"""
 ))
-self.cutAct.triggered[()].connect(self.__editCut)
+self.cutAct.triggered.connect(self.__editCut)
 self.editActions.append(self.cutAct)
 self.copyAct = E5Action(
 QApplication.translate('ViewManager', 'Copy'),
 UI.PixmapCache.getIcon("editCopy.png"),
 'ViewManager',
 """<b>Copy</b>"""
 """<p>Copy the selected text of the current editor to the"""
 """ clipboard.</p>"""
 ))
-self.copyAct.triggered[()].connect(self.__editCopy)
+self.copyAct.triggered.connect(self.__editCopy)
 self.editActions.append(self.copyAct)
 self.pasteAct = E5Action(
 QApplication.translate('ViewManager', 'Paste'),
 UI.PixmapCache.getIcon("editPaste.png"),
 'ViewManager',
 """<b>Paste</b>"""
 """<p>Paste the last cut/copied text from the clipboard to"""
 """ the current editor.</p>"""
 ))
-self.pasteAct.triggered[()].connect(self.__editPaste)
+self.pasteAct.triggered.connect(self.__editPaste)
 self.editActions.append(self.pasteAct)
 self.deleteAct = E5Action(
 QApplication.translate('ViewManager', 'Clear'),
 UI.PixmapCache.getIcon("editDelete.png"),
 self.deleteAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Clear</b>"""
 """<p>Delete all text of the current editor.</p>"""
 ))
-self.deleteAct.triggered[()].connect(self.__editDelete)
+self.deleteAct.triggered.connect(self.__editDelete)
 self.editActions.append(self.deleteAct)
 self.joinAct = E5Action(
 QApplication.translate('ViewManager', 'Join Lines'),
 QApplication.translate('ViewManager', 'Join Lines'),
 self.joinAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Join Lines</b>"""
 """<p>Join the current and the next lines.</p>"""
 ))
-self.joinAct.triggered[()].connect(self.__editJoin)
+self.joinAct.triggered.connect(self.__editJoin)
 self.editActions.append(self.joinAct)
 self.indentAct = E5Action(
 QApplication.translate('ViewManager', 'Indent'),
 UI.PixmapCache.getIcon("editIndent.png"),
 'ViewManager',
 """<b>Indent</b>"""
 """<p>Indents the current line or the lines of the"""
 """ selection by one level.</p>"""
 ))
-self.indentAct.triggered[()].connect(self.__editIndent)
+self.indentAct.triggered.connect(self.__editIndent)
 self.editActions.append(self.indentAct)
 self.unindentAct = E5Action(
 QApplication.translate('ViewManager', 'Unindent'),
 UI.PixmapCache.getIcon("editUnindent.png"),
 'ViewManager',
 """<b>Unindent</b>"""
 """<p>Unindents the current line or the lines of the"""
 """ selection by one level.</p>"""
 ))
-self.unindentAct.triggered[()].connect(self.__editUnindent)
+self.unindentAct.triggered.connect(self.__editUnindent)
 self.editActions.append(self.unindentAct)
 self.smartIndentAct = E5Action(
 QApplication.translate('ViewManager', 'Smart indent'),
 UI.PixmapCache.getIcon("editSmartIndent.png"),
 'ViewManager',
 """<b>Smart indent</b>"""
 """<p>Indents the current line or the lines of the"""
 """ current selection smartly.</p>"""
 ))
-self.smartIndentAct.triggered[()].connect(self.__editSmartIndent)
+self.smartIndentAct.triggered.connect(self.__editSmartIndent)
 self.editActions.append(self.smartIndentAct)
 self.commentAct = E5Action(
 QApplication.translate('ViewManager', 'Comment'),
 UI.PixmapCache.getIcon("editComment.png"),
 'ViewManager',
 """<b>Comment</b>"""
 """<p>Comments the current line or the lines of the"""
 """ current selection.</p>"""
 ))
-self.commentAct.triggered[()].connect(self.__editComment)
+self.commentAct.triggered.connect(self.__editComment)
 self.editActions.append(self.commentAct)
 self.uncommentAct = E5Action(
 QApplication.translate('ViewManager', 'Uncomment'),
 UI.PixmapCache.getIcon("editUncomment.png"),
 'ViewManager',
 """<b>Uncomment</b>"""
 """<p>Uncomments the current line or the lines of the"""
 """ current selection.</p>"""
 ))
-self.uncommentAct.triggered[()].connect(self.__editUncomment)
+self.uncommentAct.triggered.connect(self.__editUncomment)
 self.editActions.append(self.uncommentAct)
 self.toggleCommentAct = E5Action(
 QApplication.translate('ViewManager', 'Toggle Comment'),
 UI.PixmapCache.getIcon("editToggleComment.png"),
 """<b>Toggle Comment</b>"""
 """<p>If the current line does not start with a block comment,"""
 """ the current line or selection is commented. If it is already"""
 """ commented, this comment block is uncommented. </p>"""
 ))
-self.toggleCommentAct.triggered[()].connect(self.__editToggleComment)
+self.toggleCommentAct.triggered.connect(self.__editToggleComment)
 self.editActions.append(self.toggleCommentAct)
 self.streamCommentAct = E5Action(
 QApplication.translate('ViewManager', 'Stream Comment'),
 QApplication.translate('ViewManager', 'Stream Comment'),
 'ViewManager',
 """<b>Stream Comment</b>"""
 """<p>Stream comments the current line or the current"""
 """ selection.</p>"""
 ))
-self.streamCommentAct.triggered[()].connect(self.__editStreamComment)
+self.streamCommentAct.triggered.connect(self.__editStreamComment)
 self.editActions.append(self.streamCommentAct)
 self.boxCommentAct = E5Action(
 QApplication.translate('ViewManager', 'Box Comment'),
 QApplication.translate('ViewManager', 'Box Comment'),
 'ViewManager',
 """<b>Box Comment</b>"""
 """<p>Box comments the current line or the lines of the"""
 """ current selection.</p>"""
 ))
-self.boxCommentAct.triggered[()].connect(self.__editBoxComment)
+self.boxCommentAct.triggered.connect(self.__editBoxComment)
 self.editActions.append(self.boxCommentAct)
 self.selectBraceAct = E5Action(
 QApplication.translate('ViewManager', 'Select to brace'),
 QApplication.translate('ViewManager', 'Select to &brace'),
 'ViewManager',
 """<b>Select to brace</b>"""
 """<p>Select text of the current editor to the matching"""
 """ brace.</p>"""
 ))
-self.selectBraceAct.triggered[()].connect(self.__editSelectBrace)
+self.selectBraceAct.triggered.connect(self.__editSelectBrace)
 self.editActions.append(self.selectBraceAct)
 self.selectAllAct = E5Action(
 QApplication.translate('ViewManager', 'Select all'),
 QApplication.translate('ViewManager', '&Select all'),
 self.selectAllAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Select All</b>"""
 """<p>Select all text of the current editor.</p>"""
 ))
-self.selectAllAct.triggered[()].connect(self.__editSelectAll)
+self.selectAllAct.triggered.connect(self.__editSelectAll)
 self.editActions.append(self.selectAllAct)
 self.deselectAllAct = E5Action(
 QApplication.translate('ViewManager', 'Deselect all'),
 QApplication.translate('ViewManager', '&Deselect all'),
 self.deselectAllAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Deselect All</b>"""
 """<p>Deselect all text of the current editor.</p>"""
 ))
-self.deselectAllAct.triggered[()].connect(self.__editDeselectAll)
+self.deselectAllAct.triggered.connect(self.__editDeselectAll)
 self.editActions.append(self.deselectAllAct)
 self.convertEOLAct = E5Action(
 QApplication.translate(
 'ViewManager', 'Convert Line End Characters'),
 'ViewManager',
 """<b>Convert Line End Characters</b>"""
 """<p>Convert the line end characters to the currently set"""
 """ type.</p>"""
 ))
-self.convertEOLAct.triggered[()].connect(self.__convertEOL)
+self.convertEOLAct.triggered.connect(self.__convertEOL)
 self.editActions.append(self.convertEOLAct)
 self.shortenEmptyAct = E5Action(
 QApplication.translate('ViewManager', 'Shorten empty lines'),
 QApplication.translate('ViewManager', 'Shorten empty lines'),
 'ViewManager',
 """<b>Shorten empty lines</b>"""
 """<p>Shorten lines consisting solely of whitespace"""
 """ characters.</p>"""
 ))
-self.shortenEmptyAct.triggered[()].connect(self.__shortenEmptyLines)
+self.shortenEmptyAct.triggered.connect(self.__shortenEmptyLines)
 self.editActions.append(self.shortenEmptyAct)
 self.autoCompleteAct = E5Action(
 QApplication.translate('ViewManager', 'Autocomplete'),
 QApplication.translate('ViewManager', '&Autocomplete'),
 'ViewManager',
 """<b>Autocomplete</b>"""
 """<p>Performs an autocompletion of the word containing"""
 """ the cursor.</p>"""
 ))
-self.autoCompleteAct.triggered[()].connect(self.__editAutoComplete)
+self.autoCompleteAct.triggered.connect(self.__editAutoComplete)
 self.editActions.append(self.autoCompleteAct)
 self.autoCompleteFromDocAct = E5Action(
 QApplication.translate(
 'ViewManager', 'Autocomplete from Document'),
 'ViewManager',
 """<b>Autocomplete from Document</b>"""
 """<p>Performs an autocompletion from document of the word"""
 """ containing the cursor.</p>"""
 ))
-self.autoCompleteFromDocAct.triggered[()].connect(
+self.autoCompleteFromDocAct.triggered.connect(
 self.__editAutoCompleteFromDoc)
 self.editActions.append(self.autoCompleteFromDocAct)
 self.autoCompleteFromAPIsAct = E5Action(
 QApplication.translate('ViewManager', 'Autocomplete from APIs'),
 'ViewManager',
 """<b>Autocomplete from APIs</b>"""
 """<p>Performs an autocompletion from APIs of the word"""
 """ containing the cursor.</p>"""
 ))
-self.autoCompleteFromAPIsAct.triggered[()].connect(
+self.autoCompleteFromAPIsAct.triggered.connect(
 self.__editAutoCompleteFromAPIs)
 self.editActions.append(self.autoCompleteFromAPIsAct)
 self.autoCompleteFromAllAct = E5Action(
 QApplication.translate(
 'ViewManager',
 """<b>Autocomplete from Document and APIs</b>"""
 """<p>Performs an autocompletion from document and APIs"""
 """ of the word containing the cursor.</p>"""
 ))
-self.autoCompleteFromAllAct.triggered[()].connect(
+self.autoCompleteFromAllAct.triggered.connect(
 self.__editAutoCompleteFromAll)
 self.editActions.append(self.autoCompleteFromAllAct)
 self.calltipsAct = E5Action(
 QApplication.translate('ViewManager', 'Calltip'),
 'ViewManager',
 """<b>Calltip</b>"""
 """<p>Show calltips based on the characters immediately to the"""
 """ left of the cursor.</p>"""
 ))
-self.calltipsAct.triggered[()].connect(self.__editShowCallTips)
+self.calltipsAct.triggered.connect(self.__editShowCallTips)
 self.editActions.append(self.calltipsAct)
 self.sortAct = E5Action(
 QApplication.translate('ViewManager', 'Sort'),
 QApplication.translate('ViewManager', 'Sort'),
 'ViewManager',
 """<b>Sort</b>"""
 """<p>Sort the lines spanned by a rectangular selection based on"""
 """ the selection ignoring leading and trailing whitespace.</p>"""
 ))
-self.sortAct.triggered[()].connect(self.__editSortSelectedLines)
+self.sortAct.triggered.connect(self.__editSortSelectedLines)
 self.editActions.append(self.sortAct)
 self.editActGrp.setEnabled(False)
 self.copyActGrp.setEnabled(False)
 self.editorActGrp, 'vm_edit_move_left_char')
 self.esm.setMapping(act, QsciScintilla.SCI_CHARLEFT)
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+B')))
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move right one character'),
 QApplication.translate('ViewManager', 'Move right one character'),
 self.editorActGrp, 'vm_edit_move_right_char')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+F')))
 self.esm.setMapping(act, QsciScintilla.SCI_CHARRIGHT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move up one line'),
 QApplication.translate('ViewManager', 'Move up one line'),
 self.editorActGrp, 'vm_edit_move_up_line')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+P')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEUP)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move down one line'),
 QApplication.translate('ViewManager', 'Move down one line'),
 self.editorActGrp, 'vm_edit_move_down_line')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+N')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEDOWN)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move left one word part'),
 QApplication.translate('ViewManager', 'Move left one word part'),
 self.editorActGrp, 'vm_edit_move_left_word_part')
 if not isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Left')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTLEFT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move right one word part'),
 QApplication.translate('ViewManager', 'Move right one word part'),
 self.editorActGrp, 'vm_edit_move_right_word_part')
 if not isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Right')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTRIGHT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move left one word'),
 QApplication.translate('ViewManager', 'Move left one word'),
 QApplication.translate('ViewManager', 'Alt+Left')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Left')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDLEFT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move right one word'),
 QApplication.translate('ViewManager', 'Move right one word'),
 self.editorActGrp, 'vm_edit_move_right_word')
 if not isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Right')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDRIGHT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 self.editorActGrp, 'vm_edit_move_first_visible_char')
 if not isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Home')))
 self.esm.setMapping(act, QsciScintilla.SCI_VCHOME)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Move to start of display line'),
 QApplication.translate('ViewManager', 'Ctrl+Left')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Home')))
 self.esm.setMapping(act, QsciScintilla.SCI_HOMEDISPLAY)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Move to end of document line'),
 QApplication.translate('ViewManager', 'Meta+E')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'End')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Scroll view down one line'),
 QApplication.translate('ViewManager', 'Scroll view down one line'),
 QKeySequence(QApplication.translate('ViewManager', 'Ctrl+Down')),
 0,
 self.editorActGrp, 'vm_edit_scroll_down_line')
 self.esm.setMapping(act, QsciScintilla.SCI_LINESCROLLDOWN)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Scroll view up one line'),
 QApplication.translate('ViewManager', 'Scroll view up one line'),
 QKeySequence(QApplication.translate('ViewManager', 'Ctrl+Up')), 0,
 self.editorActGrp, 'vm_edit_scroll_up_line')
 self.esm.setMapping(act, QsciScintilla.SCI_LINESCROLLUP)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move up one paragraph'),
 QApplication.translate('ViewManager', 'Move up one paragraph'),
 QKeySequence(QApplication.translate('ViewManager', 'Alt+Up')), 0,
 self.editorActGrp, 'vm_edit_move_up_para')
 self.esm.setMapping(act, QsciScintilla.SCI_PARAUP)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move down one paragraph'),
 QApplication.translate('ViewManager', 'Move down one paragraph'),
 QKeySequence(QApplication.translate('ViewManager', 'Alt+Down')), 0,
 self.editorActGrp, 'vm_edit_move_down_para')
 self.esm.setMapping(act, QsciScintilla.SCI_PARADOWN)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move up one page'),
 QApplication.translate('ViewManager', 'Move up one page'),
 QKeySequence(QApplication.translate('ViewManager', 'PgUp')), 0,
 self.editorActGrp, 'vm_edit_move_up_page')
 self.esm.setMapping(act, QsciScintilla.SCI_PAGEUP)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move down one page'),
 QApplication.translate('ViewManager', 'Move down one page'),
 self.editorActGrp, 'vm_edit_move_down_page')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+V')))
 self.esm.setMapping(act, QsciScintilla.SCI_PAGEDOWN)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move to start of document'),
 QApplication.translate('ViewManager', 'Move to start of document'),
 QApplication.translate('ViewManager', 'Ctrl+Up')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Home')))
 self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTSTART)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Move to end of document'),
 QApplication.translate('ViewManager', 'Move to end of document'),
 QApplication.translate('ViewManager', 'Ctrl+Down')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+End')))
 self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Indent one level'),
 QApplication.translate('ViewManager', 'Indent one level'),
 QKeySequence(QApplication.translate('ViewManager', 'Tab')), 0,
 self.editorActGrp, 'vm_edit_indent_one_level')
 self.esm.setMapping(act, QsciScintilla.SCI_TAB)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Unindent one level'),
 QApplication.translate('ViewManager', 'Unindent one level'),
 QKeySequence(QApplication.translate('ViewManager', 'Shift+Tab')),
 0,
 self.editorActGrp, 'vm_edit_unindent_one_level')
 self.esm.setMapping(act, QsciScintilla.SCI_BACKTAB)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection left one character'),
 self.editorActGrp, 'vm_edit_extend_selection_left_char')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Shift+B')))
 self.esm.setMapping(act, QsciScintilla.SCI_CHARLEFTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection right one character'),
 self.editorActGrp, 'vm_edit_extend_selection_right_char')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Shift+F')))
 self.esm.setMapping(act, QsciScintilla.SCI_CHARRIGHTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection up one line'),
 self.editorActGrp, 'vm_edit_extend_selection_up_line')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Shift+P')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEUPEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection down one line'),
 self.editorActGrp, 'vm_edit_extend_selection_down_line')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Shift+N')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEDOWNEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection left one word part'),
 self.editorActGrp, 'vm_edit_extend_selection_left_word_part')
 if not isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Shift+Left')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTLEFTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection right one word part'),
 self.editorActGrp, 'vm_edit_extend_selection_right_word_part')
 if not isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Shift+Right')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTRIGHTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection left one word'),
 QApplication.translate('ViewManager', 'Alt+Shift+Left')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Shift+Left')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDLEFTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection right one word'),
 QApplication.translate('ViewManager', 'Alt+Shift+Right')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Shift+Right')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDRIGHTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 self.editorActGrp, 'vm_edit_extend_selection_first_visible_char')
 if not isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Shift+Home')))
 self.esm.setMapping(act, QsciScintilla.SCI_VCHOMEEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection to end of document line'),
 QApplication.translate('ViewManager', 'Meta+Shift+E')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Shift+End')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEENDEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection up one paragraph'),
 QKeySequence(QApplication.translate(
 'ViewManager', 'Alt+Shift+Up')),
 0,
 self.editorActGrp, 'vm_edit_extend_selection_up_para')
 self.esm.setMapping(act, QsciScintilla.SCI_PARAUPEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection down one paragraph'),
 QKeySequence(QApplication.translate(
 'ViewManager', 'Alt+Shift+Down')),
 0,
 self.editorActGrp, 'vm_edit_extend_selection_down_para')
 self.esm.setMapping(act, QsciScintilla.SCI_PARADOWNEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection up one page'),
 'ViewManager', 'Extend selection up one page'),
 QKeySequence(QApplication.translate('ViewManager', 'Shift+PgUp')),
 0,
 self.editorActGrp, 'vm_edit_extend_selection_up_page')
 self.esm.setMapping(act, QsciScintilla.SCI_PAGEUPEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection down one page'),
 self.editorActGrp, 'vm_edit_extend_selection_down_page')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Shift+V')))
 self.esm.setMapping(act, QsciScintilla.SCI_PAGEDOWNEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection to start of document'),
 QApplication.translate('ViewManager', 'Ctrl+Shift+Up')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Shift+Home')))
 self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTSTARTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection to end of document'),
 QApplication.translate('ViewManager', 'Ctrl+Shift+Down')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Shift+End')))
 self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTENDEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Delete previous character'),
 QApplication.translate('ViewManager', 'Delete previous character'),
 QApplication.translate('ViewManager', 'Meta+H')))
 else:
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Shift+Backspace')))
 self.esm.setMapping(act, QsciScintilla.SCI_DELETEBACK)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 'ViewManager',
 'Delete previous character if not at start of line'),
 0, 0,
 self.editorActGrp, 'vm_edit_delet_previous_char_not_line_start')
 self.esm.setMapping(act, QsciScintilla.SCI_DELETEBACKNOTLINE)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Delete current character'),
 QApplication.translate('ViewManager', 'Delete current character'),
 self.editorActGrp, 'vm_edit_delete_current_char')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+D')))
 self.esm.setMapping(act, QsciScintilla.SCI_CLEAR)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Delete word to left'),
 QApplication.translate('ViewManager', 'Delete word to left'),
 QKeySequence(QApplication.translate(
 'ViewManager', 'Ctrl+Backspace')),
 0,
 self.editorActGrp, 'vm_edit_delete_word_left')
 self.esm.setMapping(act, QsciScintilla.SCI_DELWORDLEFT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Delete word to right'),
 QApplication.translate('ViewManager', 'Delete word to right'),
 QKeySequence(QApplication.translate('ViewManager', 'Ctrl+Del')), 0,
 self.editorActGrp, 'vm_edit_delete_word_right')
 self.esm.setMapping(act, QsciScintilla.SCI_DELWORDRIGHT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Delete line to left'),
 QApplication.translate('ViewManager', 'Delete line to left'),
 QKeySequence(QApplication.translate(
 'ViewManager', 'Ctrl+Shift+Backspace')),
 0,
 self.editorActGrp, 'vm_edit_delete_line_left')
 self.esm.setMapping(act, QsciScintilla.SCI_DELLINELEFT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Delete line to right'),
 QApplication.translate('ViewManager', 'Delete line to right'),
 QApplication.translate('ViewManager', 'Meta+K')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Shift+Del')))
 self.esm.setMapping(act, QsciScintilla.SCI_DELLINERIGHT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Insert new line'),
 QApplication.translate('ViewManager', 'Insert new line'),
 QKeySequence(QApplication.translate('ViewManager', 'Return')),
 QKeySequence(QApplication.translate('ViewManager', 'Enter')),
 self.editorActGrp, 'vm_edit_insert_line')
 self.esm.setMapping(act, QsciScintilla.SCI_NEWLINE)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Insert new line below current line'),
 'ViewManager', 'Insert new line below current line'),
 QKeySequence(QApplication.translate(
 'ViewManager', 'Shift+Return')),
 QKeySequence(QApplication.translate('ViewManager', 'Shift+Enter')),
 self.editorActGrp, 'vm_edit_insert_line_below')
-act.triggered[()].connect(self.__newLineBelow)
+act.triggered.connect(self.__newLineBelow)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Delete current line'),
 QApplication.translate('ViewManager', 'Delete current line'),
 QKeySequence(QApplication.translate(
 'ViewManager', 'Ctrl+Shift+L')),
 0,
 self.editorActGrp, 'vm_edit_delete_current_line')
 self.esm.setMapping(act, QsciScintilla.SCI_LINEDELETE)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Duplicate current line'),
 QApplication.translate('ViewManager', 'Duplicate current line'),
 QKeySequence(QApplication.translate('ViewManager', 'Ctrl+D')), 0,
 self.editorActGrp, 'vm_edit_duplicate_current_line')
 self.esm.setMapping(act, QsciScintilla.SCI_LINEDUPLICATE)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Swap current and previous lines'),
 QApplication.translate(
 'ViewManager', 'Swap current and previous lines'),
 QKeySequence(QApplication.translate('ViewManager', 'Ctrl+T')), 0,
 self.editorActGrp, 'vm_edit_swap_current_previous_line')
 self.esm.setMapping(act, QsciScintilla.SCI_LINETRANSPOSE)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Cut current line'),
 QApplication.translate('ViewManager', 'Cut current line'),
 QKeySequence(QApplication.translate('ViewManager', 'Alt+Shift+L')),
 0,
 self.editorActGrp, 'vm_edit_cut_current_line')
 self.esm.setMapping(act, QsciScintilla.SCI_LINECUT)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Copy current line'),
 QApplication.translate('ViewManager', 'Copy current line'),
 QKeySequence(QApplication.translate(
 'ViewManager', 'Ctrl+Shift+T')),
 0,
 self.editorActGrp, 'vm_edit_copy_current_line')
 self.esm.setMapping(act, QsciScintilla.SCI_LINECOPY)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Toggle insert/overtype'),
 QApplication.translate('ViewManager', 'Toggle insert/overtype'),
 QKeySequence(QApplication.translate('ViewManager', 'Ins')), 0,
 self.editorActGrp, 'vm_edit_toggle_insert_overtype')
 self.esm.setMapping(act, QsciScintilla.SCI_EDITTOGGLEOVERTYPE)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Move to end of display line'),
 QApplication.translate('ViewManager', 'Ctrl+Right')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+End')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEENDDISPLAY)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend selection to end of display line'),
 self.editorActGrp, 'vm_edit_extend_selection_end_displayed_line')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Shift+Right')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEENDDISPLAYEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Formfeed'),
 QApplication.translate('ViewManager', 'Formfeed'),
 0, 0,
 self.editorActGrp, 'vm_edit_formfeed')
 self.esm.setMapping(act, QsciScintilla.SCI_FORMFEED)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate('ViewManager', 'Escape'),
 QApplication.translate('ViewManager', 'Escape'),
 QKeySequence(QApplication.translate('ViewManager', 'Esc')), 0,
 self.editorActGrp, 'vm_edit_escape')
 self.esm.setMapping(act, QsciScintilla.SCI_CANCEL)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend rectangular selection down one line'),
 self.editorActGrp, 'vm_edit_extend_rect_selection_down_line')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Alt+Shift+N')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEDOWNRECTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Extend rectangular selection up one line'),
 self.editorActGrp, 'vm_edit_extend_rect_selection_up_line')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Alt+Shift+P')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEUPRECTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 self.editorActGrp, 'vm_edit_extend_rect_selection_left_char')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Alt+Shift+B')))
 self.esm.setMapping(act, QsciScintilla.SCI_CHARLEFTRECTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 self.editorActGrp, 'vm_edit_extend_rect_selection_right_char')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Alt+Shift+F')))
 self.esm.setMapping(act, QsciScintilla.SCI_CHARRIGHTRECTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 'vm_edit_extend_rect_selection_first_visible_char')
 if not isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Shift+Home')))
 self.esm.setMapping(act, QsciScintilla.SCI_VCHOMERECTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 QApplication.translate('ViewManager', 'Meta+Alt+Shift+E')))
 else:
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Shift+End')))
 self.esm.setMapping(act, QsciScintilla.SCI_LINEENDRECTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 QKeySequence(QApplication.translate(
 'ViewManager', 'Alt+Shift+PgUp')),
 0,
 self.editorActGrp, 'vm_edit_extend_rect_selection_up_page')
 self.esm.setMapping(act, QsciScintilla.SCI_PAGEUPRECTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 self.editorActGrp, 'vm_edit_extend_rect_selection_down_page')
 if isMacPlatform():
 act.setAlternateShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Alt+Shift+V')))
 self.esm.setMapping(act, QsciScintilla.SCI_PAGEDOWNRECTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Duplicate current selection'),
 QKeySequence(QApplication.translate(
 'ViewManager', 'Ctrl+Shift+D')),
 0,
 self.editorActGrp, 'vm_edit_duplicate_current_selection')
 self.esm.setMapping(act, QsciScintilla.SCI_SELECTIONDUPLICATE)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_SCROLLTOSTART"):
 act = E5Action(
 QApplication.translate(
 self.editorActGrp, 'vm_edit_scroll_start_text')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Home')))
 self.esm.setMapping(act, QsciScintilla.SCI_SCROLLTOSTART)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_SCROLLTOEND"):
 act = E5Action(
 QApplication.translate(
 self.editorActGrp, 'vm_edit_scroll_end_text')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'End')))
 self.esm.setMapping(act, QsciScintilla.SCI_SCROLLTOEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_VERTICALCENTRECARET"):
 act = E5Action(
 QApplication.translate(
 self.editorActGrp, 'vm_edit_scroll_vertically_center')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+L')))
 self.esm.setMapping(act, QsciScintilla.SCI_VERTICALCENTRECARET)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_WORDRIGHTEND"):
 act = E5Action(
 QApplication.translate(
 self.editorActGrp, 'vm_edit_move_end_next_word')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Right')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDRIGHTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_WORDRIGHTENDEXTEND"):
 act = E5Action(
 QApplication.translate(
 self.editorActGrp, 'vm_edit_select_end_next_word')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Shift+Right')))
 self.esm.setMapping(act, QsciScintilla.SCI_WORDRIGHTENDEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_WORDLEFTEND"):
 act = E5Action(
 QApplication.translate(
 QApplication.translate(
 'ViewManager', 'Move to end of previous word'),
 0, 0,
 self.editorActGrp, 'vm_edit_move_end_previous_word')
 self.esm.setMapping(act, QsciScintilla.SCI_WORDLEFTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_WORDLEFTENDEXTEND"):
 act = E5Action(
 QApplication.translate(
 QApplication.translate(
 'ViewManager', 'Extend selection to end of previous word'),
 0, 0,
 self.editorActGrp, 'vm_edit_select_end_previous_word')
 self.esm.setMapping(act, QsciScintilla.SCI_WORDLEFTENDEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_HOME"):
 act = E5Action(
 QApplication.translate(
 self.editorActGrp, 'vm_edit_move_start_document_line')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+A')))
 self.esm.setMapping(act, QsciScintilla.SCI_HOME)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_HOMEEXTEND"):
 act = E5Action(
 QApplication.translate(
 'vm_edit_extend_selection_start_document_line')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Shift+A')))
 self.esm.setMapping(act, QsciScintilla.SCI_HOME)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_HOMERECTEXTEND"):
 act = E5Action(
 QApplication.translate(
 self.editorActGrp, 'vm_edit_select_rect_start_line')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Meta+Alt+Shift+A')))
 self.esm.setMapping(act, QsciScintilla.SCI_HOMERECTEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_HOMEDISPLAYEXTEND"):
 act = E5Action(
 QApplication.translate(
 'vm_edit_extend_selection_start_display_line')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Ctrl+Shift+Left')))
 self.esm.setMapping(act, QsciScintilla.SCI_HOMEDISPLAYEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_HOMEWRAP"):
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 'Move to start of display or document line'),
 0, 0,
 self.editorActGrp, 'vm_edit_move_start_display_document_line')
 self.esm.setMapping(act, QsciScintilla.SCI_HOMEWRAP)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_HOMEWRAPEXTEND"):
 act = E5Action(
 QApplication.translate(
 'Extend selection to start of display or document line'),
 0, 0,
 self.editorActGrp,
 'vm_edit_extend_selection_start_display_document_line')
 self.esm.setMapping(act, QsciScintilla.SCI_HOMEWRAPEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_VCHOMEWRAP"):
 act = E5Action(
 QApplication.translate(
 ' line'),
 0, 0,
 self.editorActGrp,
 'vm_edit_move_first_visible_char_document_line')
 self.esm.setMapping(act, QsciScintilla.SCI_VCHOMEWRAP)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_VCHOMEWRAPEXTEND"):
 act = E5Action(
 QApplication.translate(
 ' display or document line'),
 0, 0,
 self.editorActGrp,
 'vm_edit_extend_selection_first_visible_char_document_line')
 self.esm.setMapping(act, QsciScintilla.SCI_VCHOMEWRAPEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_LINEENDWRAP"):
 act = E5Action(
 QApplication.translate(
 'ViewManager',
 'Move to end of display or document line'),
 0, 0,
 self.editorActGrp, 'vm_edit_end_start_display_document_line')
 self.esm.setMapping(act, QsciScintilla.SCI_LINEENDWRAP)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_LINEENDWRAPEXTEND"):
 act = E5Action(
 QApplication.translate(
 'Extend selection to end of display or document line'),
 0, 0,
 self.editorActGrp,
 'vm_edit_extend_selection_end_display_document_line')
 self.esm.setMapping(act, QsciScintilla.SCI_LINEENDWRAPEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_STUTTEREDPAGEUP"):
 act = E5Action(
 QApplication.translate(
 QApplication.translate(
 'ViewManager', 'Stuttered move up one page'),
 0, 0,
 self.editorActGrp, 'vm_edit_stuttered_move_up_page')
 self.esm.setMapping(act, QsciScintilla.SCI_STUTTEREDPAGEUP)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_STUTTEREDPAGEUPEXTEND"):
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Stuttered extend selection up one page'),
 0, 0,
 self.editorActGrp,
 'vm_edit_stuttered_extend_selection_up_page')
 self.esm.setMapping(act, QsciScintilla.SCI_STUTTEREDPAGEUPEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_STUTTEREDPAGEDOWN"):
 act = E5Action(
 QApplication.translate(
 QApplication.translate(
 'ViewManager', 'Stuttered move down one page'),
 0, 0,
 self.editorActGrp, 'vm_edit_stuttered_move_down_page')
 self.esm.setMapping(act, QsciScintilla.SCI_STUTTEREDPAGEDOWN)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_STUTTEREDPAGEDOWNEXTEND"):
 act = E5Action(
 QApplication.translate(
 'ViewManager', 'Stuttered extend selection down one page'),
 0, 0,
 self.editorActGrp,
 'vm_edit_stuttered_extend_selection_down_page')
 self.esm.setMapping(act, QsciScintilla.SCI_STUTTEREDPAGEDOWNEXTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_DELWORDRIGHTEND"):
 act = E5Action(
 QApplication.translate(
 self.editorActGrp, 'vm_edit_delete_right_end_next_word')
 if isMacPlatform():
 act.setShortcut(QKeySequence(
 QApplication.translate('ViewManager', 'Alt+Del')))
 self.esm.setMapping(act, QsciScintilla.SCI_DELWORDRIGHTEND)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_MOVESELECTEDLINESUP"):
 act = E5Action(
 QApplication.translate(
 QApplication.translate(
 'ViewManager', 'Move selected lines up one line'),
 0, 0,
 self.editorActGrp, 'vm_edit_move_selection_up_one_line')
 self.esm.setMapping(act, QsciScintilla.SCI_MOVESELECTEDLINESUP)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 if hasattr(QsciScintilla, "SCI_MOVESELECTEDLINESDOWN"):
 act = E5Action(
 QApplication.translate(
 QApplication.translate(
 'ViewManager', 'Move selected lines down one line'),
 0, 0,
 self.editorActGrp, 'vm_edit_move_selection_down_one_line')
 self.esm.setMapping(act, QsciScintilla.SCI_MOVESELECTEDLINESDOWN)
-act.triggered[()].connect(self.esm.map)
+act.triggered.connect(self.esm.map)
 self.editActions.append(act)
 self.editorActGrp.setEnabled(False)
 self.editLowerCaseAct = E5Action(
 'ViewManager', 'Convert selection to lower case'),
 QKeySequence(QApplication.translate('ViewManager', 'Alt+Shift+U')),
 0,
 self.editActGrp, 'vm_edit_convert_selection_lower')
 self.esm.setMapping(self.editLowerCaseAct, QsciScintilla.SCI_LOWERCASE)
-self.editLowerCaseAct.triggered[()].connect(self.esm.map)
+self.editLowerCaseAct.triggered.connect(self.esm.map)
 self.editActions.append(self.editLowerCaseAct)
 self.editUpperCaseAct = E5Action(
 QApplication.translate(
 'ViewManager', 'Convert selection to upper case'),
 QKeySequence(QApplication.translate(
 'ViewManager', 'Ctrl+Shift+U')),
 0,
 self.editActGrp, 'vm_edit_convert_selection_upper')
 self.esm.setMapping(self.editUpperCaseAct, QsciScintilla.SCI_UPPERCASE)
-self.editUpperCaseAct.triggered[()].connect(self.esm.map)
+self.editUpperCaseAct.triggered.connect(self.esm.map)
 self.editActions.append(self.editUpperCaseAct)
 def initEditMenu(self):
 """
 Public method to create the Edit menu.
 """<b>Search</b>"""
 """<p>Search for some text in the current editor. A"""
 """ dialog is shown to enter the searchtext and options"""
 """ for the search.</p>"""
 ))
-self.searchAct.triggered[()].connect(self.__search)
+self.searchAct.triggered.connect(self.__search)
 self.searchActions.append(self.searchAct)
 self.searchNextAct = E5Action(
 QApplication.translate(
 'ViewManager', 'Search next'),
 """<b>Search next</b>"""
 """<p>Search the next occurrence of some text in the current"""
 """ editor. The previously entered searchtext and options are"""
 """ reused.</p>"""
 ))
-self.searchNextAct.triggered[()].connect(self.__searchWidget.findNext)
+self.searchNextAct.triggered.connect(self.__searchWidget.findNext)
 self.searchActions.append(self.searchNextAct)
 self.searchPrevAct = E5Action(
 QApplication.translate('ViewManager', 'Search previous'),
 UI.PixmapCache.getIcon("findPrev.png"),
 """<b>Search previous</b>"""
 """<p>Search the previous occurrence of some text in the current"""
 """ editor. The previously entered searchtext and options are"""
 """ reused.</p>"""
 ))
-self.searchPrevAct.triggered[()].connect(self.__searchWidget.findPrev)
+self.searchPrevAct.triggered.connect(self.__searchWidget.findPrev)
 self.searchActions.append(self.searchPrevAct)
 self.searchClearMarkersAct = E5Action(
 QApplication.translate('ViewManager', 'Clear search markers'),
 UI.PixmapCache.getIcon("findClear.png"),
 self.searchClearMarkersAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Clear search markers</b>"""
 """<p>Clear all displayed search markers.</p>"""
 ))
-self.searchClearMarkersAct.triggered[()].connect(
+self.searchClearMarkersAct.triggered.connect(
 self.__searchClearMarkers)
 self.searchActions.append(self.searchClearMarkersAct)
 self.searchNextWordAct = E5Action(
 QApplication.translate(
 'ViewManager',
 """<b>Search current word forward</b>"""
 """<p>Search the next occurrence of the current word of the"""
 """ current editor.</p>"""
 ))
-self.searchNextWordAct.triggered[()].connect(self.__findNextWord)
+self.searchNextWordAct.triggered.connect(self.__findNextWord)
 self.searchActions.append(self.searchNextWordAct)
 self.searchPrevWordAct = E5Action(
 QApplication.translate(
 'ViewManager', 'Search current word backward'),
 'ViewManager',
 """<b>Search current word backward</b>"""
 """<p>Search the previous occurrence of the current word of the"""
 """ current editor.</p>"""
 ))
-self.searchPrevWordAct.triggered[()].connect(self.__findPrevWord)
+self.searchPrevWordAct.triggered.connect(self.__findPrevWord)
 self.searchActions.append(self.searchPrevWordAct)
 self.replaceAct = E5Action(
 QApplication.translate('ViewManager', 'Replace'),
 QApplication.translate('ViewManager', '&Replace...'),
 """<b>Replace</b>"""
 """<p>Search for some text in the current editor and replace it."""
 """ A dialog is shown to enter the searchtext, the replacement"""
 """ text and options for the search and replace.</p>"""
 ))
-self.replaceAct.triggered[()].connect(self.__replace)
+self.replaceAct.triggered.connect(self.__replace)
 self.searchActions.append(self.replaceAct)
 self.quickSearchAct = E5Action(
 QApplication.translate('ViewManager', 'Quicksearch'),
 UI.PixmapCache.getIcon("quickFindNext.png"),
 """<p>This activates the quicksearch function of the IDE by"""
 """ giving focus to the quicksearch entry field. If this field"""
 """ is already active and contains text, it searches for the"""
 """ next occurrence of this text.</p>"""
 ))
-self.quickSearchAct.triggered[()].connect(self.__quickSearch)
+self.quickSearchAct.triggered.connect(self.__quickSearch)
 self.searchActions.append(self.quickSearchAct)
 self.quickSearchBackAct = E5Action(
 QApplication.translate('ViewManager', 'Quicksearch backwards'),
 UI.PixmapCache.getIcon("quickFindPrev.png"),
 'ViewManager',
 """<b>Quicksearch backwards</b>"""
 """<p>This searches the previous occurrence of the quicksearch"""
 """ text.</p>"""
 ))
-self.quickSearchBackAct.triggered[()].connect(self.__quickSearchPrev)
+self.quickSearchBackAct.triggered.connect(self.__quickSearchPrev)
 self.searchActions.append(self.quickSearchBackAct)
 self.quickSearchExtendAct = E5Action(
 QApplication.translate('ViewManager', 'Quicksearch extend'),
 UI.PixmapCache.getIcon("quickFindExtend.png"),
 'ViewManager',
 """<b>Quicksearch extend</b>"""
 """<p>This extends the quicksearch text to the end of the word"""
 """ currently found.</p>"""
 ))
-self.quickSearchExtendAct.triggered[()].connect(
+self.quickSearchExtendAct.triggered.connect(
 self.__quickSearchExtend)
 self.searchActions.append(self.quickSearchExtendAct)
 self.gotoAct = E5Action(
 QApplication.translate('ViewManager', 'Goto Line'),
 'ViewManager',
 """<b>Goto Line</b>"""
 """<p>Go to a specific line of text in the current editor."""
 """ A dialog is shown to enter the linenumber.</p>"""
 ))
-self.gotoAct.triggered[()].connect(self.__goto)
+self.gotoAct.triggered.connect(self.__goto)
 self.searchActions.append(self.gotoAct)
 self.gotoBraceAct = E5Action(
 QApplication.translate('ViewManager', 'Goto Brace'),
 UI.PixmapCache.getIcon("gotoBrace.png"),
 self.gotoBraceAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Goto Brace</b>"""
 """<p>Go to the matching brace in the current editor.</p>"""
 ))
-self.gotoBraceAct.triggered[()].connect(self.__gotoBrace)
+self.gotoBraceAct.triggered.connect(self.__gotoBrace)
 self.searchActions.append(self.gotoBraceAct)
 self.gotoLastEditAct = E5Action(
 QApplication.translate('ViewManager', 'Goto Last Edit Location'),
 UI.PixmapCache.getIcon("gotoLastEditPosition.png"),
 'ViewManager',
 """<b>Goto Last Edit Location</b>"""
 """<p>Go to the location of the last edit in the current"""
 """ editor.</p>"""
 ))
-self.gotoLastEditAct.triggered[()].connect(self.__gotoLastEditPosition)
+self.gotoLastEditAct.triggered.connect(self.__gotoLastEditPosition)
 self.searchActions.append(self.gotoLastEditAct)
 self.gotoPreviousDefAct = E5Action(
 QApplication.translate(
 'ViewManager', 'Goto Previous Method or Class'),
 'ViewManager',
 """<b>Goto Previous Method or Class</b>"""
 """<p>Goes to the line of the previous method or class"""
 """ definition and highlights the name.</p>"""
 ))
-self.gotoPreviousDefAct.triggered[()].connect(
+self.gotoPreviousDefAct.triggered.connect(
 self.__gotoPreviousMethodClass)
 self.searchActions.append(self.gotoPreviousDefAct)
 self.gotoNextDefAct = E5Action(
 QApplication.translate('ViewManager', 'Goto Next Method or Class'),
 'ViewManager',
 """<b>Goto Next Method or Class</b>"""
 """<p>Goes to the line of the next method or class definition"""
 """ and highlights the name.</p>"""
 ))
-self.gotoNextDefAct.triggered[()].connect(self.__gotoNextMethodClass)
+self.gotoNextDefAct.triggered.connect(self.__gotoNextMethodClass)
 self.searchActions.append(self.gotoNextDefAct)
 self.searchActGrp.setEnabled(False)
 self.searchFilesAct = E5Action(
 """<b>Search in Files</b>"""
 """<p>Search for some text in the files of a directory tree"""
 """ or the project. A dialog is shown to enter the searchtext"""
 """ and options for the search and to display the result.</p>"""
 ))
-self.searchFilesAct.triggered[()].connect(self.__searchFiles)
+self.searchFilesAct.triggered.connect(self.__searchFiles)
 self.searchActions.append(self.searchFilesAct)
 self.replaceFilesAct = E5Action(
 QApplication.translate('ViewManager', 'Replace in Files'),
 QApplication.translate('ViewManager', 'Replace in F&iles...'),
 """<p>Search for some text in the files of a directory tree"""
 """ or the project and replace it. A dialog is shown to enter"""
 """ the searchtext, the replacement text and options for the"""
 """ search and to display the result.</p>"""
 ))
-self.replaceFilesAct.triggered[()].connect(self.__replaceFiles)
+self.replaceFilesAct.triggered.connect(self.__replaceFiles)
 self.searchActions.append(self.replaceFilesAct)
 self.searchOpenFilesAct = E5Action(
 QApplication.translate('ViewManager', 'Search in Open Files'),
 UI.PixmapCache.getIcon("documentFind.png"),
 """<b>Search in Open Files</b>"""
 """<p>Search for some text in the currently opened files."""
 """ A dialog is shown to enter the searchtext"""
 """ and options for the search and to display the result.</p>"""
 ))
-self.searchOpenFilesAct.triggered[()].connect(self.__searchOpenFiles)
+self.searchOpenFilesAct.triggered.connect(self.__searchOpenFiles)
 self.searchActions.append(self.searchOpenFilesAct)
 self.replaceOpenFilesAct = E5Action(
 QApplication.translate('ViewManager', 'Replace in Open Files'),
 QApplication.translate('ViewManager', 'Replace in Open Files...'),
 """<p>Search for some text in the currently opened files"""
 """ and replace it. A dialog is shown to enter"""
 """ the searchtext, the replacement text and options for the"""
 """ search and to display the result.</p>"""
 ))
-self.replaceOpenFilesAct.triggered[()].connect(self.__replaceOpenFiles)
+self.replaceOpenFilesAct.triggered.connect(self.__replaceOpenFiles)
 self.searchActions.append(self.replaceOpenFilesAct)
 def initSearchToolbars(self, toolbarManager):
 """
 Public method to create the Search toolbars.
 self.quickFindtextCombo._editor.gotFocus.connect(
 self.__quickSearchFocusIn)
 self.quickFindtextAction = QWidgetAction(self)
 self.quickFindtextAction.setDefaultWidget(self.quickFindtextCombo)
 self.quickFindtextAction.setObjectName("vm_quickfindtext_action")
-self.quickFindtextAction.setText(self.trUtf8("Quicksearch Textedit"))
+self.quickFindtextAction.setText(self.tr("Quicksearch Textedit"))
 qtb.addAction(self.quickFindtextAction)
 qtb.addAction(self.quickSearchAct)
 qtb.addAction(self.quickSearchBackAct)
 qtb.addAction(self.quickSearchExtendAct)
 self.quickFindtextCombo.setEnabled(False)
 self.zoomInAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Zoom in</b>"""
 """<p>Zoom in on the text. This makes the text bigger.</p>"""
 ))
-self.zoomInAct.triggered[()].connect(self.__zoomIn)
+self.zoomInAct.triggered.connect(self.__zoomIn)
 self.viewActions.append(self.zoomInAct)
 self.zoomOutAct = E5Action(
 QApplication.translate('ViewManager', 'Zoom out'),
 UI.PixmapCache.getIcon("zoomOut.png"),
 self.zoomOutAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Zoom out</b>"""
 """<p>Zoom out on the text. This makes the text smaller.</p>"""
 ))
-self.zoomOutAct.triggered[()].connect(self.__zoomOut)
+self.zoomOutAct.triggered.connect(self.__zoomOut)
 self.viewActions.append(self.zoomOutAct)
 self.zoomResetAct = E5Action(
 QApplication.translate('ViewManager', 'Zoom reset'),
 UI.PixmapCache.getIcon("zoomReset.png"),
 'ViewManager',
 """<b>Zoom reset</b>"""
 """<p>Reset the zoom of the text. """
 """This sets the zoom factor to 100%.</p>"""
 ))
-self.zoomResetAct.triggered[()].connect(self.__zoomReset)
+self.zoomResetAct.triggered.connect(self.__zoomReset)
 self.viewActions.append(self.zoomResetAct)
 self.zoomToAct = E5Action(
 QApplication.translate('ViewManager', 'Zoom'),
 UI.PixmapCache.getIcon("zoomTo.png"),
 'ViewManager',
 """<b>Zoom</b>"""
 """<p>Zoom the text. This opens a dialog where the"""
 """ desired size can be entered.</p>"""
 ))
-self.zoomToAct.triggered[()].connect(self.__zoom)
+self.zoomToAct.triggered.connect(self.__zoom)
 self.viewActions.append(self.zoomToAct)
 self.toggleAllAct = E5Action(
 QApplication.translate('ViewManager', 'Toggle all folds'),
 QApplication.translate('ViewManager', 'Toggle &all folds'),
 self.toggleAllAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Toggle all folds</b>"""
 """<p>Toggle all folds of the current editor.</p>"""
 ))
-self.toggleAllAct.triggered[()].connect(self.__toggleAll)
+self.toggleAllAct.triggered.connect(self.__toggleAll)
 self.viewActions.append(self.toggleAllAct)
 self.toggleAllChildrenAct = E5Action(
 QApplication.translate(
 'ViewManager', 'Toggle all folds (including children)'),
 'ViewManager',
 """<b>Toggle all folds (including children)</b>"""
 """<p>Toggle all folds of the current editor including"""
 """ all children.</p>"""
 ))
-self.toggleAllChildrenAct.triggered[()].connect(
+self.toggleAllChildrenAct.triggered.connect(
 self.__toggleAllChildren)
 self.viewActions.append(self.toggleAllChildrenAct)
 self.toggleCurrentAct = E5Action(
 QApplication.translate('ViewManager', 'Toggle current fold'),
 'ViewManager',
 """<b>Toggle current fold</b>"""
 """<p>Toggle the folds of the current line of the current"""
 """ editor.</p>"""
 ))
-self.toggleCurrentAct.triggered[()].connect(self.__toggleCurrent)
+self.toggleCurrentAct.triggered.connect(self.__toggleCurrent)
 self.viewActions.append(self.toggleCurrentAct)
 self.unhighlightAct = E5Action(
 QApplication.translate('ViewManager', 'Remove all highlights'),
 UI.PixmapCache.getIcon("unhighlight.png"),
 self.unhighlightAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Remove all highlights</b>"""
 """<p>Remove the highlights of all editors.</p>"""
 ))
-self.unhighlightAct.triggered[()].connect(self.unhighlight)
+self.unhighlightAct.triggered.connect(self.__unhighlight)
 self.viewActions.append(self.unhighlightAct)
 self.newDocumentViewAct = E5Action(
 QApplication.translate('ViewManager', 'New Document View'),
 UI.PixmapCache.getIcon("documentNewView.png"),
 """<b>New Document View</b>"""
 """<p>Opens a new view of the current document. Both views show"""
 """ the same document. However, the cursors may be positioned"""
 """ independently.</p>"""
 ))
-self.newDocumentViewAct.triggered[()].connect(self.__newDocumentView)
+self.newDocumentViewAct.triggered.connect(self.__newDocumentView)
 self.viewActions.append(self.newDocumentViewAct)
 self.newDocumentSplitViewAct = E5Action(
 QApplication.translate(
 'ViewManager', 'New Document View (with new split)'),
 """<b>New Document View</b>"""
 """<p>Opens a new view of the current document in a new split."""
 """ Both views show the same document. However, the cursors may"""
 """ be positioned independently.</p>"""
 ))
-self.newDocumentSplitViewAct.triggered[()].connect(
+self.newDocumentSplitViewAct.triggered.connect(
 self.__newDocumentSplitView)
 self.viewActions.append(self.newDocumentSplitViewAct)
 self.splitViewAct = E5Action(
 QApplication.translate('ViewManager', 'Split view'),
 self.splitViewAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Split view</b>"""
 """<p>Add a split to the view.</p>"""
 ))
-self.splitViewAct.triggered[()].connect(self.__splitView)
+self.splitViewAct.triggered.connect(self.__splitView)
 self.viewActions.append(self.splitViewAct)
 self.splitOrientationAct = E5Action(
 QApplication.translate('ViewManager', 'Arrange horizontally'),
 QApplication.translate('ViewManager', 'Arrange &horizontally'),
 self.splitRemoveAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Remove split</b>"""
 """<p>Remove the current split.</p>"""
 ))
-self.splitRemoveAct.triggered[()].connect(self.removeSplit)
+self.splitRemoveAct.triggered.connect(self.removeSplit)
 self.viewActions.append(self.splitRemoveAct)
 self.nextSplitAct = E5Action(
 QApplication.translate('ViewManager', 'Next split'),
 QApplication.translate('ViewManager', '&Next split'),
 self.nextSplitAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Next split</b>"""
 """<p>Move to the next split.</p>"""
 ))
-self.nextSplitAct.triggered[()].connect(self.nextSplit)
+self.nextSplitAct.triggered.connect(self.nextSplit)
 self.viewActions.append(self.nextSplitAct)
 self.prevSplitAct = E5Action(
 QApplication.translate('ViewManager', 'Previous split'),
 QApplication.translate('ViewManager', '&Previous split'),
 self.prevSplitAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Previous split</b>"""
 """<p>Move to the previous split.</p>"""
 ))
-self.prevSplitAct.triggered[()].connect(self.prevSplit)
+self.prevSplitAct.triggered.connect(self.prevSplit)
 self.viewActions.append(self.prevSplitAct)
 self.previewAct = E5Action(
 QApplication.translate('ViewManager', 'Preview'),
 UI.PixmapCache.getIcon("previewer.png"),
 self.macroStartRecAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Start Macro Recording</b>"""
 """<p>Start recording editor commands into a new macro.</p>"""
 ))
-self.macroStartRecAct.triggered[()].connect(self.__macroStartRecording)
+self.macroStartRecAct.triggered.connect(self.__macroStartRecording)
 self.macroActions.append(self.macroStartRecAct)
 self.macroStopRecAct = E5Action(
 QApplication.translate('ViewManager', 'Stop Macro Recording'),
 QApplication.translate('ViewManager', 'Sto&p Macro Recording'),
 self.macroStopRecAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Stop Macro Recording</b>"""
 """<p>Stop recording editor commands into a new macro.</p>"""
 ))
-self.macroStopRecAct.triggered[()].connect(self.__macroStopRecording)
+self.macroStopRecAct.triggered.connect(self.__macroStopRecording)
 self.macroActions.append(self.macroStopRecAct)
 self.macroRunAct = E5Action(
 QApplication.translate('ViewManager', 'Run Macro'),
 QApplication.translate('ViewManager', '&Run Macro'),
 self.macroRunAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Run Macro</b>"""
 """<p>Run a previously recorded editor macro.</p>"""
 ))
-self.macroRunAct.triggered[()].connect(self.__macroRun)
+self.macroRunAct.triggered.connect(self.__macroRun)
 self.macroActions.append(self.macroRunAct)
 self.macroDeleteAct = E5Action(
 QApplication.translate('ViewManager', 'Delete Macro'),
 QApplication.translate('ViewManager', '&Delete Macro'),
 self.macroDeleteAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Delete Macro</b>"""
 """<p>Delete a previously recorded editor macro.</p>"""
 ))
-self.macroDeleteAct.triggered[()].connect(self.__macroDelete)
+self.macroDeleteAct.triggered.connect(self.__macroDelete)
 self.macroActions.append(self.macroDeleteAct)
 self.macroLoadAct = E5Action(
 QApplication.translate('ViewManager', 'Load Macro'),
 QApplication.translate('ViewManager', '&Load Macro'),
 self.macroLoadAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Load Macro</b>"""
 """<p>Load an editor macro from a file.</p>"""
 ))
-self.macroLoadAct.triggered[()].connect(self.__macroLoad)
+self.macroLoadAct.triggered.connect(self.__macroLoad)
 self.macroActions.append(self.macroLoadAct)
 self.macroSaveAct = E5Action(
 QApplication.translate('ViewManager', 'Save Macro'),
 QApplication.translate('ViewManager', '&Save Macro'),
 self.macroSaveAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Save Macro</b>"""
 """<p>Save a previously recorded editor macro to a file.</p>"""
 ))
-self.macroSaveAct.triggered[()].connect(self.__macroSave)
+self.macroSaveAct.triggered.connect(self.__macroSave)
 self.macroActions.append(self.macroSaveAct)
 self.macroActGrp.setEnabled(False)
 def initMacroMenu(self):
 'ViewManager',
 """<b>Toggle Bookmark</b>"""
 """<p>Toggle a bookmark at the current line of the current"""
 """ editor.</p>"""
 ))
-self.bookmarkToggleAct.triggered[()].connect(self.__toggleBookmark)
+self.bookmarkToggleAct.triggered.connect(self.__toggleBookmark)
 self.bookmarkActions.append(self.bookmarkToggleAct)
 self.bookmarkNextAct = E5Action(
 QApplication.translate('ViewManager', 'Next Bookmark'),
 UI.PixmapCache.getIcon("bookmarkNext.png"),
 self.bookmarkNextAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Next Bookmark</b>"""
 """<p>Go to next bookmark of the current editor.</p>"""
 ))
-self.bookmarkNextAct.triggered[()].connect(self.__nextBookmark)
+self.bookmarkNextAct.triggered.connect(self.__nextBookmark)
 self.bookmarkActions.append(self.bookmarkNextAct)
 self.bookmarkPreviousAct = E5Action(
 QApplication.translate('ViewManager', 'Previous Bookmark'),
 UI.PixmapCache.getIcon("bookmarkPrevious.png"),
 self.bookmarkPreviousAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Previous Bookmark</b>"""
 """<p>Go to previous bookmark of the current editor.</p>"""
 ))
-self.bookmarkPreviousAct.triggered[()].connect(self.__previousBookmark)
+self.bookmarkPreviousAct.triggered.connect(self.__previousBookmark)
 self.bookmarkActions.append(self.bookmarkPreviousAct)
 self.bookmarkClearAct = E5Action(
 QApplication.translate('ViewManager', 'Clear Bookmarks'),
 QApplication.translate('ViewManager', '&Clear Bookmarks'),
 self.bookmarkClearAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Clear Bookmarks</b>"""
 """<p>Clear bookmarks of all editors.</p>"""
 ))
-self.bookmarkClearAct.triggered[()].connect(self.__clearAllBookmarks)
+self.bookmarkClearAct.triggered.connect(self.__clearAllBookmarks)
 self.bookmarkActions.append(self.bookmarkClearAct)
 self.syntaxErrorGotoAct = E5Action(
 QApplication.translate('ViewManager', 'Goto Syntax Error'),
 UI.PixmapCache.getIcon("syntaxErrorGoto.png"),
 self.syntaxErrorGotoAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Goto Syntax Error</b>"""
 """<p>Go to next syntax error of the current editor.</p>"""
 ))
-self.syntaxErrorGotoAct.triggered[()].connect(self.__gotoSyntaxError)
+self.syntaxErrorGotoAct.triggered.connect(self.__gotoSyntaxError)
 self.bookmarkActions.append(self.syntaxErrorGotoAct)
 self.syntaxErrorClearAct = E5Action(
 QApplication.translate('ViewManager', 'Clear Syntax Errors'),
 QApplication.translate('ViewManager', 'Clear &Syntax Errors'),
 self.syntaxErrorClearAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Clear Syntax Errors</b>"""
 """<p>Clear syntax errors of all editors.</p>"""
 ))
-self.syntaxErrorClearAct.triggered[()].connect(
+self.syntaxErrorClearAct.triggered.connect(
 self.__clearAllSyntaxErrors)
 self.bookmarkActions.append(self.syntaxErrorClearAct)
 self.warningsNextAct = E5Action(
 QApplication.translate('ViewManager', 'Next warning message'),
 'ViewManager', 'Next warning message'))
 self.warningsNextAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Next warning message</b>"""
 """<p>Go to next line of the current editor"""
-""" having a py3flakes warning.</p>"""
+""" having a pyflakes warning.</p>"""
 ))
-self.warningsNextAct.triggered[()].connect(self.__nextWarning)
+self.warningsNextAct.triggered.connect(self.__nextWarning)
 self.bookmarkActions.append(self.warningsNextAct)
 self.warningsPreviousAct = E5Action(
 QApplication.translate('ViewManager', 'Previous warning message'),
 UI.PixmapCache.getIcon("warningPrev.png"),
 'ViewManager', 'Previous warning message'))
 self.warningsPreviousAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Previous warning message</b>"""
 """<p>Go to previous line of the current editor"""
-""" having a py3flakes warning.</p>"""
+""" having a pyflakes warning.</p>"""
 ))
-self.warningsPreviousAct.triggered[()].connect(self.__previousWarning)
+self.warningsPreviousAct.triggered.connect(self.__previousWarning)
 self.bookmarkActions.append(self.warningsPreviousAct)
 self.warningsClearAct = E5Action(
 QApplication.translate('ViewManager', 'Clear Warning Messages'),
 QApplication.translate('ViewManager', 'Clear &Warning Messages'),
 self.warningsClearAct.setStatusTip(QApplication.translate(
 'ViewManager', 'Clear Warning Messages'))
 self.warningsClearAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Clear Warning Messages</b>"""
-"""<p>Clear py3flakes warning messages of all editors.</p>"""
+"""<p>Clear pyflakes warning messages of all editors.</p>"""
 ))
-self.warningsClearAct.triggered[()].connect(self.__clearAllWarnings)
+self.warningsClearAct.triggered.connect(self.__clearAllWarnings)
 self.bookmarkActions.append(self.warningsClearAct)
 self.notcoveredNextAct = E5Action(
 QApplication.translate('ViewManager', 'Next uncovered line'),
 UI.PixmapCache.getIcon("notcoveredNext.png"),
 'ViewManager',
 """<b>Next uncovered line</b>"""
 """<p>Go to next line of the current editor marked as not"""
 """ covered.</p>"""
 ))
-self.notcoveredNextAct.triggered[()].connect(self.__nextUncovered)
+self.notcoveredNextAct.triggered.connect(self.__nextUncovered)
 self.bookmarkActions.append(self.notcoveredNextAct)
 self.notcoveredPreviousAct = E5Action(
 QApplication.translate('ViewManager', 'Previous uncovered line'),
 UI.PixmapCache.getIcon("notcoveredPrev.png"),
 'ViewManager',
 """<b>Previous uncovered line</b>"""
 """<p>Go to previous line of the current editor marked"""
 """ as not covered.</p>"""
 ))
-self.notcoveredPreviousAct.triggered[()].connect(
+self.notcoveredPreviousAct.triggered.connect(
 self.__previousUncovered)
 self.bookmarkActions.append(self.notcoveredPreviousAct)
 self.taskNextAct = E5Action(
 QApplication.translate('ViewManager', 'Next Task'),
 self.taskNextAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Next Task</b>"""
 """<p>Go to next line of the current editor having a task.</p>"""
 ))
-self.taskNextAct.triggered[()].connect(self.__nextTask)
+self.taskNextAct.triggered.connect(self.__nextTask)
 self.bookmarkActions.append(self.taskNextAct)
 self.taskPreviousAct = E5Action(
 QApplication.translate('ViewManager', 'Previous Task'),
 UI.PixmapCache.getIcon("taskPrev.png"),
 'ViewManager',
 """<b>Previous Task</b>"""
 """<p>Go to previous line of the current editor having a"""
 """ task.</p>"""
 ))
-self.taskPreviousAct.triggered[()].connect(self.__previousTask)
+self.taskPreviousAct.triggered.connect(self.__previousTask)
 self.bookmarkActions.append(self.taskPreviousAct)
 self.changeNextAct = E5Action(
 QApplication.translate('ViewManager', 'Next Change'),
 UI.PixmapCache.getIcon("changeNext.png"),
 'ViewManager',
 """<b>Next Change</b>"""
 """<p>Go to next line of the current editor having a change"""
 """ marker.</p>"""
 ))
-self.changeNextAct.triggered[()].connect(self.__nextChange)
+self.changeNextAct.triggered.connect(self.__nextChange)
 self.bookmarkActions.append(self.changeNextAct)
 self.changePreviousAct = E5Action(
 QApplication.translate('ViewManager', 'Previous Change'),
 UI.PixmapCache.getIcon("changePrev.png"),
 'ViewManager',
 """<b>Previous Change</b>"""
 """<p>Go to previous line of the current editor having"""
 """ a change marker.</p>"""
 ))
-self.changePreviousAct.triggered[()].connect(self.__previousChange)
+self.changePreviousAct.triggered.connect(self.__previousChange)
 self.bookmarkActions.append(self.changePreviousAct)
 self.bookmarkActGrp.setEnabled(False)
 def initBookmarkMenu(self):
 self.spellCheckAct.setWhatsThis(QApplication.translate(
 'ViewManager',
 """<b>Check spelling</b>"""
 """<p>Perform a spell check of the current editor.</p>"""
 ))
-self.spellCheckAct.triggered[()].connect(self.__spellCheck)
+self.spellCheckAct.triggered.connect(self.__spellCheck)
 self.spellingActions.append(self.spellCheckAct)
 self.autoSpellCheckAct = E5Action(
 QApplication.translate('ViewManager', 'Automatic spell checking'),
 UI.PixmapCache.getIcon("autospellchecking.png"),
 """<p>Activate or deactivate the automatic spell checking"""
 """ function of all editors.</p>"""
 ))
 self.autoSpellCheckAct.setChecked(
 Preferences.getEditor("AutoSpellCheckingEnabled"))
-self.autoSpellCheckAct.triggered[()].connect(
+self.autoSpellCheckAct.triggered.connect(
 self.__setAutoSpellChecking)
 self.spellingActions.append(self.autoSpellCheckAct)
 self.__enableSpellingActions()
 ##################################################################
 ## Methods and slots that deal with file and window handling
 ##################################################################
-def openFiles(self, prog=None):
+def __openFiles(self):
+"""
+Private slot to open some files.
+"""
+# set the cwd of the dialog based on the following search criteria:
+#     1: Directory of currently active editor
+#     2: Directory of currently active project
+#     3: CWD
+import QScintilla.Lexers
+filter = self._getOpenFileFilter()
+progs = E5FileDialog.getOpenFileNamesAndFilter(
+self.ui,
+QApplication.translate('ViewManager', "Open files"),
+self._getOpenStartDir(),
+QScintilla.Lexers.getOpenFileFiltersList(True, True),
+filter)[0]
+for prog in progs:
+self.openFiles(prog)
+def openFiles(self, prog):
 """
 Public slot to open some files.
 @param prog name of file to be opened (string)
 """
-# Get the file name if one wasn't specified.
+prog = Utilities.normabspath(prog)
-if prog is None:
+# Open up the new files.
-# set the cwd of the dialog based on the following search criteria:
+self.openSourceFile(prog)
-#     1: Directory of currently active editor
-#     2: Directory of currently active project
-#     3: CWD
-import QScintilla.Lexers
-filter = self._getOpenFileFilter()
-progs = E5FileDialog.getOpenFileNamesAndFilter(
-self.ui,
-QApplication.translate('ViewManager', "Open files"),
-self._getOpenStartDir(),
-QScintilla.Lexers.getOpenFileFiltersList(True, True),
-filter)[0]
-else:
-progs = [prog]
-for prog in progs:
-prog = Utilities.normabspath(prog)
-# Open up the new files.
-self.openSourceFile(prog)
 def checkDirty(self, editor, autosave=False):
 """
 Public method to check dirty status and open a message window.
 pixmap = UI.PixmapCache.getPixmap("eolWindows.png")
 else:
 pixmap = QPixmap()
 return pixmap
+def __unhighlight(self):
+"""
+Privat slot to switch of all highlights.
+"""
+self.unhighlight()
 def unhighlight(self, current=False):
 """
-Public method to switch off all highlights.
+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)
 """
 if current:
 @return list of all opened filenames (list of strings)
 """
 filenames = []
 for editor in self.editors:
 fn = editor.getFileName()
-if fn is not None and fn not in filenames:
+if fn is not None and fn not in filenames and os.path.exists(fn):
+# only return names of existing files
 filenames.append(fn)
 return filenames
 def getEditor(self, fn, filetype=""):
 aw = self.activeWindow()
 if aw:
 aw.zoomTo(0)
 self.sbZoom.setValue(aw.getZoom())
-def __zoom(self, value=None):
+def __zoom(self):
 """
 Private method to handle the zoom action.
-@keyparam value zoom value to be set (integer)
 """
 if QApplication.focusWidget() == e5App().getObject("Shell"):
 aw = e5App().getObject("Shell")
 else:
 aw = self.activeWindow()
 if aw:
-if value is None:
+from QScintilla.ZoomDialog import ZoomDialog
-from QScintilla.ZoomDialog import ZoomDialog
+dlg = ZoomDialog(aw.getZoom(), self.ui, None, True)
-dlg = ZoomDialog(aw.getZoom(), self.ui, None, True)
+if dlg.exec_() == QDialog.Accepted:
-if dlg.exec_() == QDialog.Accepted:
+value = dlg.getZoomSize()
-value = dlg.getZoomSize()
+self.__zoomTo(value)
-if value is not None:
-aw.zoomTo(value)
+def __zoomTo(self, value):
-self.sbZoom.setValue(aw.getZoom())
+"""
+Private slot to zoom to a given value.
+@param value zoom value to be set (integer)
+"""
+if QApplication.focusWidget() == e5App().getObject("Shell"):
+aw = e5App().getObject("Shell")
+else:
+aw = self.activeWindow()
+if aw:
+aw.zoomTo(value)
+self.sbZoom.setValue(aw.getZoom())
 def zoomValueChanged(self, value):
 """
 Public slot to handle changes of the zoom value.
 if editor.canAutoCompleteFromAPIs():
 self.autoCompleteFromAPIsAct.setEnabled(True)
 else:
 self.autoCompleteFromAPIsAct.setEnabled(False)
-if editor.getPyVersion() or editor.isRubyFile():
+if editor.isPyFile() or editor.isRubyFile():
 self.gotoPreviousDefAct.setEnabled(True)
 self.gotoNextDefAct.setEnabled(True)
 else:
 self.gotoPreviousDefAct.setEnabled(False)
 self.gotoNextDefAct.setEnabled(False)

Mercurial Repositories > eric / file comparison

comparison: ViewManager/ViewManager.py

ViewManager/ViewManager.py