eric: ViewManager/ViewManager.py@b8ab8eac9dde (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2011 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the viewmanager base class.
 """
 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
 from PyQt4.Qsci import QsciScintilla
 from E5Gui.E5Application import e5App
 from E5Gui import E5FileDialog, E5MessageBox
 from Globals import recentNameFiles
 import Preferences
 from .BookmarkedFilesDialog import BookmarkedFilesDialog
 from QScintilla.Editor import Editor
 from QScintilla.GotoDialog import GotoDialog
 from QScintilla.SearchReplaceWidget import SearchReplaceWidget
 from QScintilla.ZoomDialog import ZoomDialog
 from QScintilla.APIsManager import APIsManager
 from QScintilla.SpellChecker import SpellChecker
 import QScintilla.Lexers
 import QScintilla.Exporters
 from QScintilla.Shell import Shell
 from QScintilla.Terminal import Terminal
 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:
             QLineEdit.keyPressEvent(self, evt)  # pass it on
     def focusInEvent(self, evt):
         """
         Re-implemented to record the current editor widget.
         @param evt focus event (QFocusEvent)
         """
         self.gotFocus.emit()
         QLineEdit.focusInEvent(self, 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 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.
     """
     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)
     def __init__(self):
         """
         Constructor
         @param ui reference to the main user interface
         @param dbs reference to the debug server object
         """
         QObject.__init__(self)
         # 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
         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
         """
         self.ui = ui
         self.dbs = dbs
         self.searchDlg = SearchReplaceWidget(False, self, ui)
         self.replaceDlg = SearchReplaceWidget(True, self, ui)
         self.checkActions.connect(self.searchDlg.updateSelectionCheckBox)
         self.checkActions.connect(self.replaceDlg.updateSelectionCheckBox)
     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, sbFile, sbLine, sbPos, sbWritable, sbEncoding, sbLanguage, sbEol):
         """
         Public method to transfer statusbar info from the user interface to viewmanager.
         @param sbFile reference to the file part of the statusbar (E5SqueezeLabelPath)
         @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)
         """
         self.sbFile = sbFile
         self.sbLine = sbLine
         self.sbPos = sbPos
         self.sbWritable = sbWritable
         self.sbEnc = sbEncoding
         self.sbLang = sbLanguage
         self.sbEol = sbEol
         self.__setSbFile()
     ############################################################################
     ## methods below need to be implemented by a subclass
     ############################################################################
     def canCascade(self):
         """
         Public method to signal if cascading of managed windows is available.
         @return 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.
         @return 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.
         @return 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 window 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 window 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 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.
         """
         menu = QMenu(QApplication.translate('ViewManager', "Export as"))
         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', 'Cl&ear'),
                 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.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('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.editActions.append(self.selectBraceAct)
         self.selectAllAct = E5Action(QApplication.translate('ViewManager', 'Select all'),
                 QApplication.translate('ViewManager', '&Select all'),
                 QKeySequence(QApplication.translate('ViewManager',
                     "Ctrl+A", "Edit|Select all")),
 ,
                 self.editActGrp, 'vm_edit_select_all')
         self.selectAllAct.setStatusTip(QApplication.translate('ViewManager',
             'Select all text'))
         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.editActions.append(self.selectAllAct)
         self.deselectAllAct = E5Action(QApplication.translate('ViewManager',
                     'Deselect all'),
                 QApplication.translate('ViewManager', '&Deselect all'),
                 QKeySequence(QApplication.translate('ViewManager',
                     "Alt+Ctrl+A", "Edit|Deselect all")),
 ,
                 self.editActGrp, 'vm_edit_deselect_all')
         self.deselectAllAct.setStatusTip(QApplication.translate('ViewManager',
             'Deselect all text'))
         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.editActions.append(self.deselectAllAct)
         self.convertEOLAct = E5Action(QApplication.translate('ViewManager',
                     'Convert Line End Characters'),
                 QApplication.translate('ViewManager', 'Convert &Line End Characters'),
 , 0, self.editActGrp, 'vm_edit_convert_eol')
         self.convertEOLAct.setStatusTip(QApplication.translate('ViewManager',
             'Convert Line End Characters'))
         self.convertEOLAct.setWhatsThis(QApplication.translate('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.editActions.append(self.convertEOLAct)
         self.shortenEmptyAct = E5Action(QApplication.translate('ViewManager',
                     'Shorten empty lines'),
                 QApplication.translate('ViewManager', 'Shorten empty lines'),
 , 0, self.editActGrp, 'vm_edit_shorten_empty_lines')
         self.shortenEmptyAct.setStatusTip(QApplication.translate('ViewManager',
             'Shorten empty lines'))
         self.shortenEmptyAct.setWhatsThis(QApplication.translate('ViewManager',
             """<b>Shorten empty lines</b>"""
             """<p>Shorten lines consisting solely of whitespace characters.</p>"""
         ))
         self.shortenEmptyAct.triggered[()].connect(self.__shortenEmptyLines)
         self.editActions.append(self.shortenEmptyAct)
         self.autoCompleteAct = E5Action(QApplication.translate('ViewManager',
                     'Autocomplete'),
                 QApplication.translate('ViewManager', '&Autocomplete'),
                 QKeySequence(QApplication.translate('ViewManager',
                     "Ctrl+Space", "Edit|Autocomplete")),
 ,
                 self.editActGrp, 'vm_edit_autocomplete')
         self.autoCompleteAct.setStatusTip(QApplication.translate('ViewManager',
             'Autocomplete current word'))
         self.autoCompleteAct.setWhatsThis(QApplication.translate('ViewManager',
             """<b>Autocomplete</b>"""
             """<p>Performs an autocompletion of the word containing the cursor.</p>"""
         ))
         self.autoCompleteAct.triggered[()].connect(self.__editAutoComplete)
         self.editActions.append(self.autoCompleteAct)
         self.autoCompleteFromDocAct = E5Action(QApplication.translate('ViewManager',
                     'Autocomplete from Document'),
                 QApplication.translate('ViewManager', 'Autocomplete from Document'),
                 QKeySequence(QApplication.translate('ViewManager', "Ctrl+Shift+Space",
                              "Edit|Autocomplete from Document")),
 , self.editActGrp, 'vm_edit_autocomplete_from_document')
         self.autoCompleteFromDocAct.setStatusTip(QApplication.translate('ViewManager',
             'Autocomplete current word from Document'))
         self.autoCompleteFromDocAct.setWhatsThis(QApplication.translate('ViewManager',
             """<b>Autocomplete from Document</b>"""
             """<p>Performs an autocompletion from document of the word"""
             """ containing the cursor.</p>"""
         ))
         self.autoCompleteFromDocAct.triggered[()].connect(self.__editAutoCompleteFromDoc)
         self.editActions.append(self.autoCompleteFromDocAct)
         self.autoCompleteFromAPIsAct = E5Action(QApplication.translate('ViewManager',
                     'Autocomplete from APIs'),
                 QApplication.translate('ViewManager', 'Autocomplete from APIs'),
                 QKeySequence(QApplication.translate('ViewManager', "Ctrl+Alt+Space",
                              "Edit|Autocomplete from APIs")),
 , self.editActGrp, 'vm_edit_autocomplete_from_api')
         self.autoCompleteFromAPIsAct.setStatusTip(QApplication.translate('ViewManager',
             'Autocomplete current word from APIs'))
         self.autoCompleteFromAPIsAct.setWhatsThis(QApplication.translate('ViewManager',
             """<b>Autocomplete from APIs</b>"""
             """<p>Performs an autocompletion from APIs of the word containing"""
             """ the cursor.</p>"""
         ))
         self.autoCompleteFromAPIsAct.triggered[()].connect(self.__editAutoCompleteFromAPIs)
         self.editActions.append(self.autoCompleteFromAPIsAct)
         self.autoCompleteFromAllAct = E5Action(
                 QApplication.translate('ViewManager',
                     'Autocomplete from Document and APIs'),
                 QApplication.translate('ViewManager',
                     'Autocomplete from Document and APIs'),
                 QKeySequence(QApplication.translate('ViewManager', "Alt+Shift+Space",
                              "Edit|Autocomplete from Document and APIs")),
 , self.editActGrp, 'vm_edit_autocomplete_from_all')
         self.autoCompleteFromAllAct.setStatusTip(QApplication.translate('ViewManager',
             'Autocomplete current word from Document and APIs'))
         self.autoCompleteFromAllAct.setWhatsThis(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>"""
         ))
 




d28d558f7484
Continued porting signal/slot usage to the new API.

Detlev Offenbach <detl

Mercurial Repositories > eric / annotate

ViewManager/ViewManager.py@b8ab8eac9dde (annotated)

ViewManager/ViewManager.py