eric: ViewManager/ViewManager.py@55030c09e142 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2013 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the viewmanager base class.
 """
 from __future__ import unicode_literals    # __IGNORE_WARNING__
 import os
 from PyQt4.QtCore import QSignalMapper, QTimer, QFileInfo, pyqtSignal, \
     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
 from E5Gui import E5FileDialog, E5MessageBox
 from Globals import recentNameFiles, isMacPlatform
 import Preferences
 from QScintilla.Editor import Editor
 import Utilities
 import UI.PixmapCache
 import UI.Config
 from E5Gui.E5Action import E5Action, createActionGroup
 class QuickSearchLineEdit(QLineEdit):
     """
     Class implementing a line edit that reacts to newline and cancel commands.
     @signal escPressed() emitted after the cancel command was activated
     @signal returnPressed() emitted after a newline command was activated
     @signal gotFocus() emitted when the focus is changed to this widget
     """
     escPressed = pyqtSignal()
     gotFocus = pyqtSignal()
     def editorCommand(self, cmd):
         """
         Public method to perform an editor command.
         @param cmd the scintilla command to be performed
         """
         if cmd == QsciScintilla.SCI_NEWLINE:
             cb = self.parent()
             hasEntry = cb.findText(self.text()) != -1
             if not hasEntry:
                 if cb.insertPolicy() == QComboBox.InsertAtTop:
                     cb.insertItem(0, self.text())
                 else:
                     cb.addItem(self.text())
             self.returnPressed.emit()
         elif cmd == QsciScintilla.SCI_CANCEL:
             self.escPressed.emit()
     def keyPressEvent(self, evt):
         """
         Re-implemented to handle the press of the ESC key.
         @param evt key event (QKeyPressEvent)
         """
         if evt.key() == Qt.Key_Escape:
             self.escPressed.emit()
         else:
             super(QuickSearchLineEdit, self).keyPressEvent(evt)  # pass it on
     def focusInEvent(self, evt):
         """
         Re-implemented to record the current editor widget.
         @param evt focus event (QFocusEvent)
         """
         self.gotFocus.emit()
         super(QuickSearchLineEdit, self).focusInEvent(evt)   # pass it on
 class ViewManager(QObject):
     """
     Base class inherited by all specific viewmanager classes.
     It defines the interface to be implemented by specific
     viewmanager classes and all common methods.
     @signal changeCaption(str) emitted if a change of the caption is necessary
     @signal editorChanged(str) emitted when the current editor has changed
     @signal editorChangedEd(Editor) emitted when the current editor has changed
     @signal lastEditorClosed() emitted after the last editor window was closed
     @signal editorOpened(str) emitted after an editor window was opened
     @signal editorOpenedEd(Editor) emitted after an editor window was opened
     @signal editorClosed(str) emitted just before an editor window gets closed
     @signal editorClosedEd(Editor) emitted just before an editor window gets
         closed
     @signal editorSaved(str) emitted after an editor window was saved
     @signal checkActions(Editor) emitted when some actions should be checked
         for their status
     @signal cursorChanged(Editor) emitted after the cursor position of the
         active window has changed
     @signal breakpointToggled(Editor) emitted when a breakpoint is toggled
     @signal bookmarkToggled(Editor) emitted when a bookmark is toggled
     @signal syntaxerrorToggled(Editor) emitted when a syntax error is toggled
     @signal previewStateChanged(bool) emitted to signal a change in the
         preview state
     @signal editorLanguageChanged(Editor) emitted to signal a change of an
         editor's language
     @signal editorTextChanged(Editor) emitted to signal a change of an
         editor's text
     @signal editorLineChanged(str,int) emitted to signal a change of an
         editor's current line (line is given one based)
     """
     changeCaption = pyqtSignal(str)
     editorChanged = pyqtSignal(str)
     editorChangedEd = pyqtSignal(Editor)
     lastEditorClosed = pyqtSignal()
     editorOpened = pyqtSignal(str)
     editorOpenedEd = pyqtSignal(Editor)
     editorClosed = pyqtSignal(str)
     editorClosedEd = pyqtSignal(Editor)
     editorSaved = pyqtSignal(str)
     checkActions = pyqtSignal(Editor)
     cursorChanged = pyqtSignal(Editor)
     breakpointToggled = pyqtSignal(Editor)
     bookmarkToggled = pyqtSignal(Editor)
     syntaxerrorToggled = pyqtSignal(Editor)
     previewStateChanged = pyqtSignal(bool)
     editorLanguageChanged = pyqtSignal(Editor)
     editorTextChanged = pyqtSignal(Editor)
     editorLineChanged = pyqtSignal(str, int)
     def __init__(self):
         """
         Constructor
         """
         super(ViewManager, self).__init__()
         # initialize the instance variables
         self.editors = []
         self.currentEditor = None
         self.untitledCount = 0
         self.srHistory = {
             "search": [],
             "replace": []
         }
         self.editorsCheckFocusIn = True
         self.recent = []
         self.__loadRecent()
         self.bookmarked = []
         bs = Preferences.Prefs.settings.value("Bookmarked/Sources")
         if bs is not None:
             self.bookmarked = bs
         # initialize the autosave timer
         self.autosaveInterval = Preferences.getEditor("AutosaveInterval")
         self.autosaveTimer = QTimer(self)
         self.autosaveTimer.setObjectName("AutosaveTimer")
         self.autosaveTimer.setSingleShot(True)
         self.autosaveTimer.timeout.connect(self.__autosave)
         # initialize the APIs manager
         from QScintilla.APIsManager import APIsManager
         self.apisManager = APIsManager(parent=self)
         self.__cooperationClient = None
         self.__lastFocusWidget = None
     def setReferences(self, ui, dbs):
         """
         Public method to set some references needed later on.
         @param ui reference to the main user interface
         @param dbs reference to the debug server object
         """
         from QScintilla.SearchReplaceWidget import SearchReplaceSlidingWidget
         self.ui = ui
         self.dbs = dbs
         self.__searchWidget = SearchReplaceSlidingWidget(False, self, ui)
         self.__replaceWidget = SearchReplaceSlidingWidget(True, self, ui)
         self.checkActions.connect(self.__searchWidget.updateSelectionCheckBox)
         self.checkActions.connect(self.__replaceWidget.updateSelectionCheckBox)
     def searchWidget(self):
         """
         Public method to get a reference to the search widget.
         @return reference to the search widget (SearchReplaceSlidingWidget)
         """
         return self.__searchWidget
     def replaceWidget(self):
         """
         Public method to get a reference to the replace widget.
         @return reference to the replace widget (SearchReplaceSlidingWidget)
         """
         return self.__replaceWidget
     def __loadRecent(self):
         """
         Private method to load the recently opened filenames.
         """
         self.recent = []
         Preferences.Prefs.rsettings.sync()
         rs = Preferences.Prefs.rsettings.value(recentNameFiles)
         if rs is not None:
             for f in Preferences.toList(rs):
                 if QFileInfo(f).exists():
                     self.recent.append(f)
     def __saveRecent(self):
         """
         Private method to save the list of recently opened filenames.
         """
         Preferences.Prefs.rsettings.setValue(recentNameFiles, self.recent)
         Preferences.Prefs.rsettings.sync()
     def getMostRecent(self):
         """
         Public method to get the most recently opened file.
         @return path of the most recently opened file (string)
         """
         if len(self.recent):
             return self.recent[0]
         else:
             return None
     def setSbInfo(self, sbLine, sbPos, sbWritable, sbEncoding, sbLanguage,
                   sbEol, sbZoom):
         """
         Public method to transfer statusbar info from the user interface to
         viewmanager.
         @param sbLine reference to the line number part of the statusbar
             (QLabel)
         @param sbPos reference to the character position part of the statusbar
             (QLabel)
         @param sbWritable reference to the writability indicator part of
             the statusbar (QLabel)
         @param sbEncoding reference to the encoding indicator part of the
             statusbar (QLabel)
         @param sbLanguage reference to the language indicator part of the
             statusbar (QLabel)
         @param sbEol reference to the eol indicator part of the statusbar
             (QLabel)
         @param sbZoom reference to the zoom widget (E5ZoomWidget)
         """
         self.sbLine = sbLine
         self.sbPos = sbPos
         self.sbWritable = sbWritable
         self.sbEnc = sbEncoding
         self.sbLang = sbLanguage
         self.sbEol = sbEol
         self.sbZoom = sbZoom
         self.sbZoom.valueChanged.connect(self.__zoom)
         self.__setSbFile(zoom=0)
     ###########################################################################
     ## methods below need to be implemented by a subclass
     ###########################################################################
     def canCascade(self):
         """
         Public method to signal if cascading of managed windows is available.
         @ireturn flag indicating cascading of windows is available
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def canTile(self):
         """
         Public method to signal if tiling of managed windows is available.
         @ireturn flag indicating tiling of windows is available
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def tile(self):
         """
         Public method to tile the managed windows.
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def cascade(self):
         """
         Public method to cascade the managed windows.
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def activeWindow(self):
         """
         Public method to return the active (i.e. current) window.
         @ireturn reference to the active editor
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def _removeAllViews(self):
         """
         Protected method to remove all views (i.e. windows).
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def _removeView(self, win):
         """
         Protected method to remove a view (i.e. window).
         @param win editor window to be removed
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def _addView(self, win, fn=None, noName=""):
         """
         Protected method to add a view (i.e. window).
         @param win editor assembly to be added
         @param fn filename of this editor
         @param noName name to be used for an unnamed editor (string)
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def _showView(self, win, fn=None):
         """
         Protected method to show a view (i.e. window).
         @param win editor assembly to be shown
         @param fn filename of this editor
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def showWindowMenu(self, windowMenu):
         """
         Public method to set up the viewmanager part of the Window menu.
         @param windowMenu reference to the window menu
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def _initWindowActions(self):
         """
         Protected method to define the user interface actions for window
         handling.
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def setEditorName(self, editor, newName):
         """
         Public method to change the displayed name of the editor.
         @param editor editor window to be changed
         @param newName new name to be shown (string)
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     def _modificationStatusChanged(self, m, editor):
         """
         Protected slot to handle the modificationStatusChanged signal.
         @param m flag indicating the modification status (boolean)
         @param editor editor window changed
         @exception RuntimeError Not implemented
         """
         raise RuntimeError('Not implemented')
     #####################################################################
     ## methods above need to be implemented by a subclass
     #####################################################################
     def canSplit(self):
         """
         Public method to signal if splitting of the view is available.
         @return flag indicating splitting of the view is available.
         """
         return False
     def addSplit(self):
         """
         Public method used to split the current view.
         """
         pass
     def removeSplit(self):
         """
         Public method used to remove the current split view.
         @return Flag indicating successful deletion
         """
         return False
     def getSplitOrientation(self):
         """
         Public method to get the orientation of the split view.
         @return orientation of the split (Qt.Horizontal or Qt.Vertical)
         """
         return Qt.Vertical
     def setSplitOrientation(self, orientation):
         """
         Public method used to set the orientation of the split view.
         @param orientation orientation of the split
             (Qt.Horizontal or Qt.Vertical)
         """
         pass
     def nextSplit(self):
         """
         Public slot used to move to the next split.
         """
         pass
     def prevSplit(self):
         """
         Public slot used to move to the previous split.
         """
         pass
     def eventFilter(self, object, event):
         """
         Public method called to filter an event.
         @param object object, that generated the event (QObject)
         @param event the event, that was generated by object (QEvent)
         @return flag indicating if event was filtered out
         """
         return False
     #####################################################################
     ## methods above need to be implemented by a subclass, that supports
     ## splitting of the viewmanager area.
     #####################################################################
     def initActions(self):
         """
         Public method defining the user interface actions.
         """
         # list containing all edit actions
         self.editActions = []
         # list containing all file actions
         self.fileActions = []
         # list containing all search actions
         self.searchActions = []
         # list containing all view actions
         self.viewActions = []
         # list containing all window actions
         self.windowActions = []
         # list containing all macro actions
         self.macroActions = []
         # list containing all bookmark actions
         self.bookmarkActions = []
         # list containing all spell checking actions
         self.spellingActions = []
         self.__actions = {
             "bookmark": self.bookmarkActions,
             "edit": self.editActions,
             "file": self.fileActions,
             "macro": self.macroActions,
             "search": self.searchActions,
             "spelling": self.spellingActions,
             "view": self.viewActions,
             "window": self.windowActions,
         }
         self._initWindowActions()
         self.__initFileActions()
         self.__initEditActions()
         self.__initSearchActions()
         self.__initViewActions()
         self.__initMacroActions()
         self.__initBookmarkActions()
         self.__initSpellingActions()
     ##################################################################
     ## Initialize the file related actions, file menu and toolbar
     ##################################################################
     def __initFileActions(self):
         """
         Private method defining the user interface actions for file handling.
         """
         self.newAct = E5Action(
             QApplication.translate('ViewManager', 'New'),
             UI.PixmapCache.getIcon("new.png"),
             QApplication.translate('ViewManager', '&New'),
             QKeySequence(
                 QApplication.translate('ViewManager', "Ctrl+N", "File|New")),
 , self, 'vm_file_new')
         self.newAct.setStatusTip(
             QApplication.translate(
                 'ViewManager', 'Open an empty editor window'))
         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.fileActions.append(self.newAct)
         self.openAct = E5Action(
             QApplication.translate('ViewManager', 'Open'),
             UI.PixmapCache.getIcon("open.png"),
             QApplication.translate('ViewManager', '&Open...'),
             QKeySequence(
                 QApplication.translate('ViewManager', "Ctrl+O", "File|Open")),
 , self, 'vm_file_open')
         self.openAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Open a file'))
         self.openAct.setWhatsThis(QApplication.translate(
             '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.fileActions.append(self.openAct)
         self.closeActGrp = createActionGroup(self)
         self.closeAct = E5Action(
             QApplication.translate('ViewManager', 'Close'),
             UI.PixmapCache.getIcon("close.png"),
             QApplication.translate('ViewManager', '&Close'),
             QKeySequence(
                 QApplication.translate('ViewManager', "Ctrl+W", "File|Close")),
 , self.closeActGrp, 'vm_file_close')
         self.closeAct.setStatusTip(
             QApplication.translate('ViewManager', 'Close the current window'))
         self.closeAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<b>Close Window</b>"""
             """<p>Close the current window.</p>"""
         ))
         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'),
 , 0, self.closeActGrp, 'vm_file_close_all')
         self.closeAllAct.setStatusTip(
             QApplication.translate('ViewManager', 'Close all editor windows'))
         self.closeAllAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<b>Close All Windows</b>"""
             """<p>Close all editor windows.</p>"""
         ))
         self.closeAllAct.triggered[()].connect(self.closeAllWindows)
         self.fileActions.append(self.closeAllAct)
         self.closeActGrp.setEnabled(False)
         self.saveActGrp = createActionGroup(self)
         self.saveAct = E5Action(
             QApplication.translate('ViewManager', 'Save'),
             UI.PixmapCache.getIcon("fileSave.png"),
             QApplication.translate('ViewManager', '&Save'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+S", "File|Save")),
 , self.saveActGrp, 'vm_file_save')
         self.saveAct.setStatusTip(
             QApplication.translate('ViewManager', 'Save the current file'))
         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.fileActions.append(self.saveAct)
         self.saveAsAct = E5Action(
             QApplication.translate('ViewManager', 'Save as'),
             UI.PixmapCache.getIcon("fileSaveAs.png"),
             QApplication.translate('ViewManager', 'Save &as...'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Shift+Ctrl+S", "File|Save As")),
 , self.saveActGrp, 'vm_file_save_as')
         self.saveAsAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Save the current file to a new one'))
         self.saveAsAct.setWhatsThis(QApplication.translate(
             '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.fileActions.append(self.saveAsAct)
         self.saveAllAct = E5Action(
             QApplication.translate('ViewManager', 'Save all'),
             UI.PixmapCache.getIcon("fileSaveAll.png"),
             QApplication.translate('ViewManager', 'Save a&ll'),
 , 0, self.saveActGrp, 'vm_file_save_all')
         self.saveAllAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Save all files'))
         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.fileActions.append(self.saveAllAct)
         self.saveActGrp.setEnabled(False)
         self.printAct = E5Action(
             QApplication.translate('ViewManager', 'Print'),
             UI.PixmapCache.getIcon("print.png"),
             QApplication.translate('ViewManager', '&Print'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+P", "File|Print")),
 , self, 'vm_file_print')
         self.printAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Print the current file'))
         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.setEnabled(False)
         self.fileActions.append(self.printAct)
         self.printPreviewAct = E5Action(
             QApplication.translate('ViewManager', 'Print Preview'),
             UI.PixmapCache.getIcon("printPreview.png"),
             QApplication.translate('ViewManager', 'Print Preview'),
 , 0, self, 'vm_file_print_preview')
         self.printPreviewAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Print preview of the current file'))
         self.printPreviewAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<b>Print Preview</b>"""
             """<p>Print preview of the current editor window.</p>"""
         ))
         self.printPreviewAct.triggered[()].connect(
             self.printPreviewCurrentEditor)
         self.printPreviewAct.setEnabled(False)
         self.fileActions.append(self.printPreviewAct)
         self.findFileNameAct = E5Action(
             QApplication.translate('ViewManager', 'Search File'),
             QApplication.translate('ViewManager', 'Search &File...'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Alt+Ctrl+F", "File|Search File")),
 , self, 'vm_file_search_file')
         self.findFileNameAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Search for a file'))
         self.findFileNameAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<b>Search File</b>"""
             """<p>Search for a file.</p>"""
         ))
         self.findFileNameAct.triggered[()].connect(self.__findFileName)
         self.fileActions.append(self.findFileNameAct)
     def initFileMenu(self):
         """
         Public method to create the File menu.
         @return the generated menu
         """
         menu = QMenu(QApplication.translate('ViewManager', '&File'), self.ui)
         self.recentMenu = QMenu(
             QApplication.translate('ViewManager', 'Open &Recent Files'),
             menu)
         self.bookmarkedMenu = QMenu(
             QApplication.translate('ViewManager', 'Open &Bookmarked Files'),
             menu)
         self.exportersMenu = self.__initContextMenuExporters()
         menu.setTearOffEnabled(True)
         menu.addAction(self.newAct)
         menu.addAction(self.openAct)
         self.menuRecentAct = menu.addMenu(self.recentMenu)
         menu.addMenu(self.bookmarkedMenu)
         menu.addSeparator()
         menu.addAction(self.closeAct)
         menu.addAction(self.closeAllAct)
         menu.addSeparator()
         menu.addAction(self.findFileNameAct)
         menu.addSeparator()
         menu.addAction(self.saveAct)
         menu.addAction(self.saveAsAct)
         menu.addAction(self.saveAllAct)
         self.exportersMenuAct = menu.addMenu(self.exportersMenu)
         menu.addSeparator()
         menu.addAction(self.printPreviewAct)
         menu.addAction(self.printAct)
         self.recentMenu.aboutToShow.connect(self.__showRecentMenu)
         self.recentMenu.triggered.connect(self.__openSourceFile)
         self.bookmarkedMenu.aboutToShow.connect(self.__showBookmarkedMenu)
         self.bookmarkedMenu.triggered.connect(self.__openSourceFile)
         menu.aboutToShow.connect(self.__showFileMenu)
         self.exportersMenuAct.setEnabled(False)
         return menu
     def initFileToolbar(self, toolbarManager):
         """
         Public method to create the File toolbar.
         @param toolbarManager reference to a toolbar manager object
             (E5ToolBarManager)
         @return the generated toolbar
         """
         tb = QToolBar(QApplication.translate('ViewManager', 'File'), self.ui)
         tb.setIconSize(UI.Config.ToolBarIconSize)
         tb.setObjectName("FileToolbar")
         tb.setToolTip(QApplication.translate('ViewManager', 'File'))
         tb.addAction(self.newAct)
         tb.addAction(self.openAct)
         tb.addAction(self.closeAct)
         tb.addSeparator()
         tb.addAction(self.saveAct)
         tb.addAction(self.saveAsAct)
         tb.addAction(self.saveAllAct)
         toolbarManager.addToolBar(tb, tb.windowTitle())
         toolbarManager.addAction(self.printPreviewAct, tb.windowTitle())
         toolbarManager.addAction(self.printAct, tb.windowTitle())
         return tb
     def __initContextMenuExporters(self):
         """
         Private method used to setup the Exporters sub menu.
         @return reference to the generated menu (QMenu)
         """
         menu = QMenu(QApplication.translate('ViewManager', "Export as"))
         import QScintilla.Exporters
         supportedExporters = QScintilla.Exporters.getSupportedFormats()
         exporters = sorted(list(supportedExporters.keys()))
         for exporter in exporters:
             act = menu.addAction(supportedExporters[exporter])
             act.setData(exporter)
         menu.triggered.connect(self.__exportMenuTriggered)
         return menu
     ##################################################################
     ## Initialize the edit related actions, edit menu and toolbar
     ##################################################################
     def __initEditActions(self):
         """
         Private method defining the user interface actions for the edit
             commands.
         """
         self.editActGrp = createActionGroup(self)
         self.undoAct = E5Action(
             QApplication.translate('ViewManager', 'Undo'),
             UI.PixmapCache.getIcon("editUndo.png"),
             QApplication.translate('ViewManager', '&Undo'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+Z", "Edit|Undo")),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Alt+Backspace", "Edit|Undo")),
             self.editActGrp, 'vm_edit_undo')
         self.undoAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Undo the last change'))
         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.editActions.append(self.undoAct)
         self.redoAct = E5Action(
             QApplication.translate('ViewManager', 'Redo'),
             UI.PixmapCache.getIcon("editRedo.png"),
             QApplication.translate('ViewManager', '&Redo'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+Shift+Z", "Edit|Redo")),
 ,
             self.editActGrp, 'vm_edit_redo')
         self.redoAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Redo the last change'))
         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.editActions.append(self.redoAct)
         self.revertAct = E5Action(
             QApplication.translate(
                 'ViewManager', 'Revert to last saved state'),
             QApplication.translate(
                 'ViewManager', 'Re&vert to last saved state'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+Y", "Edit|Revert")),
 ,
             self.editActGrp, 'vm_edit_revert')
         self.revertAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Revert to last saved state'))
         self.revertAct.setWhatsThis(QApplication.translate(
             '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.editActions.append(self.revertAct)
         self.copyActGrp = createActionGroup(self.editActGrp)
         self.cutAct = E5Action(
             QApplication.translate('ViewManager', 'Cut'),
             UI.PixmapCache.getIcon("editCut.png"),
             QApplication.translate('ViewManager', 'Cu&t'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+X", "Edit|Cut")),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Shift+Del", "Edit|Cut")),
             self.copyActGrp, 'vm_edit_cut')
         self.cutAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Cut the selection'))
         self.cutAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<b>Cut</b>"""
             """<p>Cut the selected text of the current editor to the"""
             """ clipboard.</p>"""
         ))
         self.cutAct.triggered[()].connect(self.__editCut)
         self.editActions.append(self.cutAct)
         self.copyAct = E5Action(
             QApplication.translate('ViewManager', 'Copy'),
             UI.PixmapCache.getIcon("editCopy.png"),
             QApplication.translate('ViewManager', '&Copy'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+C", "Edit|Copy")),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+Ins", "Edit|Copy")),
             self.copyActGrp, 'vm_edit_copy')
         self.copyAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Copy the selection'))
         self.copyAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<b>Copy</b>"""
             """<p>Copy the selected text of the current editor to the"""
             """ clipboard.</p>"""
         ))
         self.copyAct.triggered[()].connect(self.__editCopy)
         self.editActions.append(self.copyAct)
         self.pasteAct = E5Action(
             QApplication.translate('ViewManager', 'Paste'),
             UI.PixmapCache.getIcon("editPaste.png"),
             QApplication.translate('ViewManager', '&Paste'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+V", "Edit|Paste")),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Shift+Ins", "Edit|Paste")),
             self.copyActGrp, 'vm_edit_paste')
         self.pasteAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Paste the last cut/copied text'))
         self.pasteAct.setWhatsThis(QApplication.translate(
             '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.editActions.append(self.pasteAct)
         self.deleteAct = E5Action(
             QApplication.translate('ViewManager', 'Clear'),
             UI.PixmapCache.getIcon("editDelete.png"),
             QApplication.translate('ViewManager', 'Clear'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Alt+Shift+C", "Edit|Clear")),
 ,
             self.copyActGrp, 'vm_edit_clear')
         self.deleteAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Clear all text'))
         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.editActions.append(self.deleteAct)
         self.joinAct = E5Action(
             QApplication.translate('ViewManager', 'Join Lines'),
             QApplication.translate('ViewManager', 'Join Lines'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+J", "Edit|Join Lines")),
 ,
             self.copyActGrp, 'vm_edit_join_lines')
         self.joinAct.setStatusTip(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.editActions.append(self.joinAct)
         self.indentAct = E5Action(
             QApplication.translate('ViewManager', 'Indent'),
             UI.PixmapCache.getIcon("editIndent.png"),
             QApplication.translate('ViewManager', '&Indent'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+I", "Edit|Indent")),
 ,
             self.editActGrp, 'vm_edit_indent')
         self.indentAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Indent line'))
         self.indentAct.setWhatsThis(QApplication.translate(
             '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.editActions.append(self.indentAct)
         self.unindentAct = E5Action(
             QApplication.translate('ViewManager', 'Unindent'),
             UI.PixmapCache.getIcon("editUnindent.png"),
             QApplication.translate('ViewManager', 'U&nindent'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+Shift+I", "Edit|Unindent")),
 ,
             self.editActGrp, 'vm_edit_unindent')
         self.unindentAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Unindent line'))
         self.unindentAct.setWhatsThis(QApplication.translate(
             '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.editActions.append(self.unindentAct)
         self.smartIndentAct = E5Action(
             QApplication.translate('ViewManager', 'Smart indent'),
             UI.PixmapCache.getIcon("editSmartIndent.png"),
             QApplication.translate('ViewManager', 'Smart indent'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+Alt+I", "Edit|Smart indent")),
 ,
             self.editActGrp, 'vm_edit_smart_indent')
         self.smartIndentAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Smart indent Line or Selection'))
         self.smartIndentAct.setWhatsThis(QApplication.translate(
             '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.editActions.append(self.smartIndentAct)
         self.commentAct = E5Action(
             QApplication.translate('ViewManager', 'Comment'),
             UI.PixmapCache.getIcon("editComment.png"),
             QApplication.translate('ViewManager', 'C&omment'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+M", "Edit|Comment")),
 ,
             self.editActGrp, 'vm_edit_comment')
         self.commentAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Comment Line or Selection'))
         self.commentAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<b>Comment</b>"""
             """<p>Comments the current line or the lines of the"""
             """ current selection.</p>"""
         ))
         self.commentAct.triggered[()].connect(self.__editComment)
         self.editActions.append(self.commentAct)
         self.uncommentAct = E5Action(
             QApplication.translate('ViewManager', 'Uncomment'),
             UI.PixmapCache.getIcon("editUncomment.png"),
             QApplication.translate('ViewManager', 'Unco&mment'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Alt+Ctrl+M", "Edit|Uncomment")),
 ,
             self.editActGrp, 'vm_edit_uncomment')
         self.uncommentAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Uncomment Line or Selection'))
         self.uncommentAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<b>Uncomment</b>"""
             """<p>Uncomments the current line or the lines of the"""
             """ current selection.</p>"""
         ))
         self.uncommentAct.triggered[()].connect(self.__editUncomment)
         self.editActions.append(self.uncommentAct)
         self.toggleCommentAct = E5Action(
             QApplication.translate('ViewManager', 'Toggle Comment'),
             UI.PixmapCache.getIcon("editToggleComment.png"),
             QApplication.translate('ViewManager', 'Toggle Comment'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+Shift+M", "Edit|Toggle Comment")),
 ,
             self.editActGrp, 'vm_edit_toggle_comment')
         self.toggleCommentAct.setStatusTip(QApplication.translate(
             'ViewManager',
             'Toggle the comment of the current line, selection or'
             ' comment block'))
         self.toggleCommentAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<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.editActions.append(self.toggleCommentAct)
         self.streamCommentAct = E5Action(
             QApplication.translate('ViewManager', 'Stream Comment'),
             QApplication.translate('ViewManager', 'Stream Comment'),
 , 0,
             self.editActGrp, 'vm_edit_stream_comment')
         self.streamCommentAct.setStatusTip(QApplication.translate(
             'ViewManager',
             'Stream Comment Line or Selection'))
         self.streamCommentAct.setWhatsThis(QApplication.translate(
             'ViewManager',
             """<b>Stream Comment</b>"""
             """<p>Stream comments the current line or the current"""
             """ selection.</p>"""
         ))
         self.streamCommentAct.triggered[()].connect(self.__editStreamComment)
         self.editActions.append(self.streamCommentAct)
         self.boxCommentAct = E5Action(
             QApplication.translate('ViewManager', 'Box Comment'),
             QApplication.translate('ViewManager', 'Box Comment'),
 , 0,
             self.editActGrp, 'vm_edit_box_comment')
         self.boxCommentAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Box Comment Line or Selection'))
         self.boxCommentAct.setWhatsThis(QApplication.translate(
             '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.editActions.append(self.boxCommentAct)
         self.selectBraceAct = E5Action(
             QApplication.translate('ViewManager', 'Select to brace'),
             QApplication.translate('ViewManager', 'Select to &brace'),
             QKeySequence(QApplication.translate(
                 'ViewManager', "Ctrl+E", "Edit|Select to brace")),
 ,
             self.editActGrp, 'vm_edit_select_to_brace')
         self.selectBraceAct.setStatusTip(QApplication.translate(
             'ViewManager', 'Select text to the matching brace'))
         self.selectBraceAct.setWhatsThis(QApplication.translate

Mercurial Repositories > eric / annotate

ViewManager/ViewManager.py@55030c09e142 (annotated)

ViewManager/ViewManager.py