eric: comparison ViewManager/ViewManager.py

--1:000000000000
+:de9c2efb9d02
+# -*- coding: utf-8 -*-
+# Copyright (c) 2002 - 2009 Detlev Offenbach <detlev@die-offenbachs.de>
+#
+"""
+Module implementing the viewmanager base class.
+"""
+import os
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+from PyQt4.Qsci import QsciScintilla
+from E4Gui.E4Application import e4App
+from Globals import recentNameFiles
+import Preferences
+from BookmarkedFilesDialog import BookmarkedFilesDialog
+from QScintilla.QsciScintillaCompat import QSCINTILLA_VERSION
+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
+import Utilities
+import UI.PixmapCache
+import UI.Config
+from E4Gui.E4Action import E4Action, 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
+"""
+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.emit(SIGNAL("returnPressed()"))
+elif cmd == QsciScintilla.SCI_CANCEL:
+self.emit(SIGNAL("escPressed()"))
+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.emit(SIGNAL("escPressed()"))
+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.emit(SIGNAL("gotFocus()"))
+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(string) emitted after an editor window was opened
+@signal editorOpenedEd(editor) emitted after an editor window was opened
+@signal editorClosed(string) emitted just before an editor window gets closed
+@signal editorClosedEd(editor) emitted just before an editor window gets closed
+@signal editorSaved(string) 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.
+"""
+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.isValid():
+self.bookmarked = bs.toStringList()
+# initialize the autosave timer
+self.autosaveInterval = Preferences.getEditor("AutosaveInterval")
+self.autosaveTimer = QTimer(self)
+self.autosaveTimer.setObjectName("AutosaveTimer")
+self.autosaveTimer.setSingleShot(True)
+self.connect(self.autosaveTimer, SIGNAL('timeout()'), self.__autosave)
+# initialize the APIs manager
+self.apisManager = APIsManager(parent = self)
+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.connect(self, SIGNAL("checkActions"),
+self.searchDlg.updateSelectionCheckBox)
+self.connect(self, SIGNAL("checkActions"),
+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.isValid():
+for f in rs.toStringList():
+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, QVariant(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 (E4SqueezeLabelPath)
+@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._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 = E4Action(QApplication.translate('ViewManager', 'New'),
+UI.PixmapCache.getIcon("new.png"),
+QApplication.translate('ViewManager', '&New'),
+QKeySequence(QApplication.translate('ViewManager', "Ctrl+N", "File|New")),
+0, 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.connect(self.newAct, SIGNAL('triggered()'), self.newEditor)
+self.fileActions.append(self.newAct)
+self.openAct = E4Action(QApplication.translate('ViewManager', 'Open'),
+UI.PixmapCache.getIcon("open.png"),
+QApplication.translate('ViewManager', '&Open...'),
+QKeySequence(\
+QApplication.translate('ViewManager', "Ctrl+O", "File|Open")),
+0, 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.connect(self.openAct, SIGNAL('triggered()'), self.openFiles)
+self.fileActions.append(self.openAct)
+self.closeActGrp = createActionGroup(self)
+self.closeAct = E4Action(QApplication.translate('ViewManager', 'Close'),
+UI.PixmapCache.getIcon("close.png"),
+QApplication.translate('ViewManager', '&Close'),
+QKeySequence(\
+QApplication.translate('ViewManager', "Ctrl+W", "File|Close")),
+0, 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.connect(self.closeAct, SIGNAL('triggered()'), self.closeCurrentWindow)
+self.fileActions.append(self.closeAct)
+self.closeAllAct = E4Action(QApplication.translate('ViewManager', 'Close All'),
+QApplication.translate('ViewManager', 'Clos&e All'),
+0, 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.connect(self.closeAllAct, SIGNAL('triggered()'), self.closeAllWindows)
+self.fileActions.append(self.closeAllAct)
+self.closeActGrp.setEnabled(False)
+self.saveActGrp = createActionGroup(self)
+self.saveAct = E4Action(QApplication.translate('ViewManager', 'Save'),
+UI.PixmapCache.getIcon("fileSave.png"),
+QApplication.translate('ViewManager', '&Save'),
+QKeySequence(\
+QApplication.translate('ViewManager', "Ctrl+S", "File|Save")),
+0, 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.connect(self.saveAct, SIGNAL('triggered()'), self.saveCurrentEditor)
+self.fileActions.append(self.saveAct)
+self.saveAsAct = E4Action(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")),
+0, 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.connect(self.saveAsAct, SIGNAL('triggered()'), self.saveAsCurrentEditor)
+self.fileActions.append(self.saveAsAct)
+self.saveAllAct = E4Action(QApplication.translate('ViewManager', 'Save all'),
+UI.PixmapCache.getIcon("fileSaveAll.png"),
+QApplication.translate('ViewManager', 'Save a&ll...'),
+0, 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.connect(self.saveAllAct, SIGNAL('triggered()'), self.saveAllEditors)
+self.fileActions.append(self.saveAllAct)
+self.saveActGrp.setEnabled(False)
+self.saveToProjectAct = E4Action(QApplication.translate('ViewManager',
+'Save to Project'),
+UI.PixmapCache.getIcon("fileSaveProject.png"),
+QApplication.translate('ViewManager', 'Save to Pro&ject'),
+0, 0,self, 'vm_file_save_to_project')
+self.saveToProjectAct.setStatusTip(QApplication.translate('ViewManager',
+'Save the current file to the current project'))
+self.saveToProjectAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Save to Project</b>"""
+"""<p>Save the contents of the current editor window to the"""
+""" current project. After the file has been saved, it is"""
+""" automatically added to the current project.</p>"""
+))
+self.connect(self.saveToProjectAct, SIGNAL('triggered()'),
+self.saveCurrentEditorToProject)
+self.saveToProjectAct.setEnabled(False)
+self.fileActions.append(self.saveToProjectAct)
+self.printAct = E4Action(QApplication.translate('ViewManager', 'Print'),
+UI.PixmapCache.getIcon("print.png"),
+QApplication.translate('ViewManager', '&Print'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+P", "File|Print")),
+0, 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.connect(self.printAct, SIGNAL('triggered()'), self.printCurrentEditor)
+self.printAct.setEnabled(False)
+self.fileActions.append(self.printAct)
+self.printPreviewAct = \
+E4Action(QApplication.translate('ViewManager', 'Print Preview'),
+UI.PixmapCache.getIcon("printPreview.png"),
+QApplication.translate('ViewManager', 'Print Preview'),
+0, 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.connect(self.printPreviewAct, SIGNAL('triggered()'),
+self.printPreviewCurrentEditor)
+self.printPreviewAct.setEnabled(False)
+self.fileActions.append(self.printPreviewAct)
+self.findFileNameAct = E4Action(QApplication.translate('ViewManager',
+'Search File'),
+QApplication.translate('ViewManager', 'Search &File...'),
+QKeySequence(QApplication.translate('ViewManager',
+"Alt+Ctrl+F", "File|Search File")),
+0, 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.connect(self.findFileNameAct, SIGNAL('triggered()'), 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)
+menu.addAction(self.saveToProjectAct)
+self.exportersMenuAct = menu.addMenu(self.exportersMenu)
+menu.addSeparator()
+menu.addAction(self.printPreviewAct)
+menu.addAction(self.printAct)
+self.connect(self.recentMenu, SIGNAL('aboutToShow()'),
+self.__showRecentMenu)
+self.connect(self.recentMenu, SIGNAL('triggered(QAction *)'),
+self.__openSourceFile)
+self.connect(self.bookmarkedMenu, SIGNAL('aboutToShow()'),
+self.__showBookmarkedMenu)
+self.connect(self.bookmarkedMenu, SIGNAL('triggered(QAction *)'),
+self.__openSourceFile)
+self.connect(menu, SIGNAL('aboutToShow()'), 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 (E4ToolBarManager)
+@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)
+tb.addAction(self.saveToProjectAct)
+tb.addSeparator()
+tb.addAction(self.printPreviewAct)
+tb.addAction(self.printAct)
+toolbarManager.addToolBar(tb, 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 = supportedExporters.keys()
+exporters.sort()
+for exporter in exporters:
+act = menu.addAction(supportedExporters[exporter])
+act.setData(QVariant(exporter))
+self.connect(menu, SIGNAL('triggered(QAction *)'), 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 = E4Action(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.connect(self.undoAct, SIGNAL('triggered()'), self.__editUndo)
+self.editActions.append(self.undoAct)
+self.redoAct = E4Action(QApplication.translate('ViewManager', 'Redo'),
+UI.PixmapCache.getIcon("editRedo.png"),
+QApplication.translate('ViewManager', '&Redo'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+Shift+Z", "Edit|Redo")),
+0, 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.connect(self.redoAct, SIGNAL('triggered()'), self.__editRedo)
+self.editActions.append(self.redoAct)
+self.revertAct = E4Action(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")),
+0,
+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.connect(self.revertAct, SIGNAL('triggered()'), self.__editRevert)
+self.editActions.append(self.revertAct)
+self.copyActGrp = createActionGroup(self.editActGrp)
+self.cutAct = E4Action(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.connect(self.cutAct, SIGNAL('triggered()'), self.__editCut)
+self.editActions.append(self.cutAct)
+self.copyAct = E4Action(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.connect(self.copyAct, SIGNAL('triggered()'), self.__editCopy)
+self.editActions.append(self.copyAct)
+self.pasteAct = E4Action(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.connect(self.pasteAct, SIGNAL('triggered()'), self.__editPaste)
+self.editActions.append(self.pasteAct)
+self.deleteAct = E4Action(QApplication.translate('ViewManager', 'Clear'),
+UI.PixmapCache.getIcon("editDelete.png"),
+QApplication.translate('ViewManager', 'Cl&ear'),
+QKeySequence(QApplication.translate('ViewManager',
+"Alt+Shift+C", "Edit|Clear")),
+0,
+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.connect(self.deleteAct, SIGNAL('triggered()'), self.__editDelete)
+self.editActions.append(self.deleteAct)
+self.indentAct = E4Action(QApplication.translate('ViewManager', 'Indent'),
+UI.PixmapCache.getIcon("editIndent.png"),
+QApplication.translate('ViewManager', '&Indent'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+I", "Edit|Indent")),
+0,
+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.connect(self.indentAct, SIGNAL('triggered()'), self.__editIndent)
+self.editActions.append(self.indentAct)
+self.unindentAct = E4Action(QApplication.translate('ViewManager', 'Unindent'),
+UI.PixmapCache.getIcon("editUnindent.png"),
+QApplication.translate('ViewManager', 'U&nindent'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+Shift+I", "Edit|Unindent")),
+0,
+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.connect(self.unindentAct, SIGNAL('triggered()'), self.__editUnindent)
+self.editActions.append(self.unindentAct)
+self.smartIndentAct = E4Action(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")),
+0,
+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.connect(self.smartIndentAct, SIGNAL('triggered()'), self.__editSmartIndent)
+self.editActions.append(self.smartIndentAct)
+self.commentAct = E4Action(QApplication.translate('ViewManager', 'Comment'),
+UI.PixmapCache.getIcon("editComment.png"),
+QApplication.translate('ViewManager', 'C&omment'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+M", "Edit|Comment")),
+0,
+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.connect(self.commentAct, SIGNAL('triggered()'), self.__editComment)
+self.editActions.append(self.commentAct)
+self.uncommentAct = E4Action(QApplication.translate('ViewManager', 'Uncomment'),
+UI.PixmapCache.getIcon("editUncomment.png"),
+QApplication.translate('ViewManager', 'Unco&mment'),
+QKeySequence(QApplication.translate('ViewManager',
+"Alt+Ctrl+M", "Edit|Uncomment")),
+0,
+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.connect(self.uncommentAct, SIGNAL('triggered()'), self.__editUncomment)
+self.editActions.append(self.uncommentAct)
+self.streamCommentAct = E4Action(QApplication.translate('ViewManager',
+'Stream Comment'),
+QApplication.translate('ViewManager', 'Stream Comment'),
+0, 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.connect(self.streamCommentAct, SIGNAL('triggered()'),
+self.__editStreamComment)
+self.editActions.append(self.streamCommentAct)
+self.boxCommentAct = E4Action(QApplication.translate('ViewManager',
+'Box Comment'),
+QApplication.translate('ViewManager', 'Box Comment'),
+0, 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.connect(self.boxCommentAct, SIGNAL('triggered()'), self.__editBoxComment)
+self.editActions.append(self.boxCommentAct)
+self.selectBraceAct = E4Action(QApplication.translate('ViewManager',
+'Select to brace'),
+QApplication.translate('ViewManager', 'Select to &brace'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+E", "Edit|Select to brace")),
+0,
+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.connect(self.selectBraceAct, SIGNAL('triggered()'), self.__editSelectBrace)
+self.editActions.append(self.selectBraceAct)
+self.selectAllAct = E4Action(QApplication.translate('ViewManager', 'Select all'),
+QApplication.translate('ViewManager', '&Select all'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+A", "Edit|Select all")),
+0,
+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.connect(self.selectAllAct, SIGNAL('triggered()'), self.__editSelectAll)
+self.editActions.append(self.selectAllAct)
+self.deselectAllAct = E4Action(QApplication.translate('ViewManager',
+'Deselect all'),
+QApplication.translate('ViewManager', '&Deselect all'),
+QKeySequence(QApplication.translate('ViewManager',
+"Alt+Ctrl+A", "Edit|Deselect all")),
+0,
+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.connect(self.deselectAllAct, SIGNAL('triggered()'), self.__editDeselectAll)
+self.editActions.append(self.deselectAllAct)
+self.convertEOLAct = E4Action(QApplication.translate('ViewManager',
+'Convert Line End Characters'),
+QApplication.translate('ViewManager', 'Convert &Line End Characters'),
+0, 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.connect(self.convertEOLAct, SIGNAL('triggered()'), self.__convertEOL)
+self.editActions.append(self.convertEOLAct)
+self.shortenEmptyAct = E4Action(QApplication.translate('ViewManager',
+'Shorten empty lines'),
+QApplication.translate('ViewManager', 'Shorten empty lines'),
+0, 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.connect(self.shortenEmptyAct, SIGNAL('triggered()'),
+self.__shortenEmptyLines)
+self.editActions.append(self.shortenEmptyAct)
+self.autoCompleteAct = E4Action(QApplication.translate('ViewManager',
+'Autocomplete'),
+QApplication.translate('ViewManager', '&Autocomplete'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+Space", "Edit|Autocomplete")),
+0,
+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.connect(self.autoCompleteAct, SIGNAL('triggered()'), self.__editAutoComplete)
+self.editActions.append(self.autoCompleteAct)
+self.autoCompleteFromDocAct = E4Action(QApplication.translate('ViewManager',
+'Autocomplete from Document'),
+QApplication.translate('ViewManager', 'Autocomplete from Document'),
+QKeySequence(QApplication.translate('ViewManager', "Ctrl+Shift+Space",
+"Edit|Autocomplete from Document")),
+0, 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.connect(self.autoCompleteFromDocAct, SIGNAL('triggered()'),
+self.__editAutoCompleteFromDoc)
+self.editActions.append(self.autoCompleteFromDocAct)
+self.autoCompleteFromAPIsAct = E4Action(QApplication.translate('ViewManager',
+'Autocomplete from APIs'),
+QApplication.translate('ViewManager', 'Autocomplete from APIs'),
+QKeySequence(QApplication.translate('ViewManager', "Ctrl+Alt+Space",
+"Edit|Autocomplete from APIs")),
+0, 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.connect(self.autoCompleteFromAPIsAct, SIGNAL('triggered()'),
+self.__editAutoCompleteFromAPIs)
+self.editActions.append(self.autoCompleteFromAPIsAct)
+self.autoCompleteFromAllAct = E4Action(\
+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")),
+0, 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>"""
+))
+self.connect(self.autoCompleteFromAllAct, SIGNAL('triggered()'),
+self.__editAutoCompleteFromAll)
+self.editActions.append(self.autoCompleteFromAllAct)
+self.calltipsAct = E4Action(QApplication.translate('ViewManager',
+'Calltip'),
+QApplication.translate('ViewManager', '&Calltip'),
+QKeySequence(QApplication.translate('ViewManager',
+"Alt+Space", "Edit|Calltip")),
+0,
+self.editActGrp, 'vm_edit_calltip')
+self.calltipsAct.setStatusTip(QApplication.translate('ViewManager',
+'Show Calltips'))
+self.calltipsAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Calltip</b>"""
+"""<p>Show calltips based on the characters immediately to the"""
+""" left of the cursor.</p>"""
+))
+self.connect(self.calltipsAct, SIGNAL('triggered()'), self.__editShowCallTips)
+self.editActions.append(self.calltipsAct)
+self.editActGrp.setEnabled(False)
+self.copyActGrp.setEnabled(False)
+####################################################################
+## Below follow the actions for qscintilla standard commands.
+####################################################################
+self.esm = QSignalMapper(self)
+self.connect(self.esm, SIGNAL('mapped(int)'), self.__editorCommand)
+self.editorActGrp = createActionGroup(self.editActGrp)
+act = E4Action(QApplication.translate('ViewManager', 'Move left one character'),
+QApplication.translate('ViewManager', 'Move left one character'),
+QKeySequence(QApplication.translate('ViewManager', 'Left')), 0,
+self.editorActGrp, 'vm_edit_move_left_char')
+self.esm.setMapping(act, QsciScintilla.SCI_CHARLEFT)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move right one character'),
+QApplication.translate('ViewManager', 'Move right one character'),
+QKeySequence(QApplication.translate('ViewManager', 'Right')), 0,
+self.editorActGrp, 'vm_edit_move_right_char')
+self.esm.setMapping(act, QsciScintilla.SCI_CHARRIGHT)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move up one line'),
+QApplication.translate('ViewManager', 'Move up one line'),
+QKeySequence(QApplication.translate('ViewManager', 'Up')), 0,
+self.editorActGrp, 'vm_edit_move_up_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEUP)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move down one line'),
+QApplication.translate('ViewManager', 'Move down one line'),
+QKeySequence(QApplication.translate('ViewManager', 'Down')), 0,
+self.editorActGrp, 'vm_edit_move_down_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEDOWN)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move left one word part'),
+QApplication.translate('ViewManager', 'Move left one word part'),
+QKeySequence(QApplication.translate('ViewManager', 'Alt+Left')), 0,
+self.editorActGrp, 'vm_edit_move_left_word_part')
+self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTLEFT)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move right one word part'),
+QApplication.translate('ViewManager', 'Move right one word part'),
+QKeySequence(QApplication.translate('ViewManager', 'Alt+Right')), 0,
+self.editorActGrp, 'vm_edit_move_right_word_part')
+self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTRIGHT)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move left one word'),
+QApplication.translate('ViewManager', 'Move left one word'),
+QKeySequence(QApplication.translate('ViewManager', 'Ctrl+Left')), 0,
+self.editorActGrp, 'vm_edit_move_left_word')
+self.esm.setMapping(act, QsciScintilla.SCI_WORDLEFT)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move right one word'),
+QApplication.translate('ViewManager', 'Move right one word'),
+QKeySequence(QApplication.translate('ViewManager', 'Ctrl+Right')),
+0,
+self.editorActGrp, 'vm_edit_move_right_word')
+self.esm.setMapping(act, QsciScintilla.SCI_WORDRIGHT)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Move to first visible character in line'),
+QApplication.translate('ViewManager',
+'Move to first visible character in line'),
+QKeySequence(QApplication.translate('ViewManager', 'Home')), 0,
+self.editorActGrp, 'vm_edit_move_first_visible_char')
+self.esm.setMapping(act, QsciScintilla.SCI_VCHOME)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Move to start of displayed line'),
+QApplication.translate('ViewManager',
+'Move to start of displayed line'),
+QKeySequence(QApplication.translate('ViewManager', 'Alt+Home')), 0,
+self.editorActGrp, 'vm_edit_move_start_line')
+self.esm.setMapping(act, QsciScintilla.SCI_HOMEDISPLAY)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move to end of line'),
+QApplication.translate('ViewManager', 'Move to end of line'),
+QKeySequence(QApplication.translate('ViewManager', 'End')), 0,
+self.editorActGrp, 'vm_edit_move_end_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move down one page'),
+QApplication.translate('ViewManager', 'Move down one page'),
+QKeySequence(QApplication.translate('ViewManager', 'PgDown')), 0,
+self.editorActGrp, 'vm_edit_move_down_page')
+self.esm.setMapping(act, QsciScintilla.SCI_PAGEDOWN)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move to start of text'),
+QApplication.translate('ViewManager', 'Move to start of text'),
+QKeySequence(QApplication.translate('ViewManager', 'Ctrl+Home')), 0,
+self.editorActGrp, 'vm_edit_move_start_text')
+self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTSTART)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Move to end of text'),
+QApplication.translate('ViewManager', 'Move to end of text'),
+QKeySequence(QApplication.translate('ViewManager', 'Ctrl+End')), 0,
+self.editorActGrp, 'vm_edit_move_end_text')
+self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection left one character'),
+QApplication.translate('ViewManager',
+'Extend selection left one character'),
+QKeySequence(QApplication.translate('ViewManager', 'Shift+Left')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_left_char')
+self.esm.setMapping(act, QsciScintilla.SCI_CHARLEFTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection right one character'),
+QApplication.translate('ViewManager',
+'Extend selection right one character'),
+QKeySequence(QApplication.translate('ViewManager', 'Shift+Right')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_right_char')
+self.esm.setMapping(act, QsciScintilla.SCI_CHARRIGHTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection up one line'),
+QApplication.translate('ViewManager',
+'Extend selection up one line'),
+QKeySequence(QApplication.translate('ViewManager', 'Shift+Up')), 0,
+self.editorActGrp, 'vm_edit_extend_selection_up_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEUPEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection down one line'),
+QApplication.translate('ViewManager',
+'Extend selection down one line'),
+QKeySequence(QApplication.translate('ViewManager', 'Shift+Down')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_down_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEDOWNEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection left one word part'),
+QApplication.translate('ViewManager',
+'Extend selection left one word part'),
+QKeySequence(QApplication.translate('ViewManager',
+'Alt+Shift+Left')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_left_word_part')
+self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTLEFTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection right one word part'),
+QApplication.translate('ViewManager',
+'Extend selection right one word part'),
+QKeySequence(QApplication.translate('ViewManager',
+'Alt+Shift+Right')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_right_word_part')
+self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTRIGHTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection left one word'),
+QApplication.translate('ViewManager',
+'Extend selection left one word'),
+QKeySequence(QApplication.translate('ViewManager',
+'Ctrl+Shift+Left')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_left_word')
+self.esm.setMapping(act, QsciScintilla.SCI_WORDLEFTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection right one word'),
+QApplication.translate('ViewManager',
+'Extend selection right one word'),
+QKeySequence(QApplication.translate('ViewManager',
+'Ctrl+Shift+Right')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_right_word')
+self.esm.setMapping(act, QsciScintilla.SCI_WORDRIGHTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection to first visible character in line'),
+QApplication.translate('ViewManager',
+'Extend selection to first visible character in line'),
+QKeySequence(QApplication.translate('ViewManager', 'Shift+Home')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_first_visible_char')
+self.esm.setMapping(act, QsciScintilla.SCI_VCHOMEEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection to start of line'),
+QApplication.translate('ViewManager',
+'Extend selection to start of line'),
+QKeySequence(QApplication.translate('ViewManager',
+'Alt+Shift+Home')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_start_line')
+self.esm.setMapping(act, QsciScintilla.SCI_HOMEDISPLAYEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection to end of line'),
+QApplication.translate('ViewManager',
+'Extend selection to end of line'),
+QKeySequence(QApplication.translate('ViewManager', 'Shift+End')), 0,
+self.editorActGrp, 'vm_edit_extend_selection_end_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEENDEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection up one paragraph'),
+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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection down one paragraph'),
+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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection up one page'),
+QApplication.translate('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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection down one page'),
+QApplication.translate('ViewManager',
+'Extend selection down one page'),
+QKeySequence(QApplication.translate('ViewManager', 'Shift+PgDown')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_down_page')
+self.esm.setMapping(act, QsciScintilla.SCI_PAGEDOWNEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection to start of text'),
+QApplication.translate('ViewManager',
+'Extend selection to start of text'),
+QKeySequence(QApplication.translate('ViewManager',
+'Ctrl+Shift+Home')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_start_text')
+self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTSTARTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection to end of text'),
+QApplication.translate('ViewManager',
+'Extend selection to end of text'),
+QKeySequence(QApplication.translate('ViewManager',
+'Ctrl+Shift+End')),
+0,
+self.editorActGrp, 'vm_edit_extend_selection_end_text')
+self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTENDEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Delete previous character'),
+QApplication.translate('ViewManager', 'Delete previous character'),
+QKeySequence(QApplication.translate('ViewManager', 'Backspace')),
+QKeySequence(QApplication.translate('ViewManager',
+'Shift+Backspace')),
+self.editorActGrp, 'vm_edit_delete_previous_char')
+self.esm.setMapping(act, QsciScintilla.SCI_DELETEBACK)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Delete previous character if not at line start'),
+QApplication.translate('ViewManager',
+'Delete previous character if not at line start'),
+0, 0,
+self.editorActGrp, 'vm_edit_delet_previous_char_not_line_start')
+self.esm.setMapping(act, QsciScintilla.SCI_DELETEBACKNOTLINE)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Delete current character'),
+QApplication.translate('ViewManager', 'Delete current character'),
+QKeySequence(QApplication.translate('ViewManager', 'Del')), 0,
+self.editorActGrp, 'vm_edit_delete_current_char')
+self.esm.setMapping(act, QsciScintilla.SCI_CLEAR)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Delete line to right'),
+QApplication.translate('ViewManager', 'Delete line to right'),
+QKeySequence(QApplication.translate('ViewManager',
+'Ctrl+Shift+Del')),
+0,
+self.editorActGrp, 'vm_edit_delete_line_right')
+self.esm.setMapping(act, QsciScintilla.SCI_DELLINERIGHT)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Insert new line below current line'),
+QApplication.translate('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')
+self.connect(act, SIGNAL('triggered()'), self.__newLineBelow)
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Delete current line'),
+QApplication.translate('ViewManager', 'Delete current line'),
+QKeySequence(QApplication.translate('ViewManager', 'Ctrl+U')),
+QKeySequence(QApplication.translate('ViewManager', 'Ctrl+Shift+L')),
+self.editorActGrp, 'vm_edit_delete_current_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEDELETE)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Convert selection to lower case'),
+QApplication.translate('ViewManager',
+'Convert selection to lower case'),
+QKeySequence(QApplication.translate('ViewManager', 'Alt+Shift+U')),
+0,
+self.editorActGrp, 'vm_edit_convert_selection_lower')
+self.esm.setMapping(act, QsciScintilla.SCI_LOWERCASE)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Convert selection to upper case'),
+QApplication.translate('ViewManager',
+'Convert selection to upper case'),
+QKeySequence(QApplication.translate('ViewManager', 'Ctrl+Shift+U')),
+0,
+self.editorActGrp, 'vm_edit_convert_selection_upper')
+self.esm.setMapping(act, QsciScintilla.SCI_UPPERCASE)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Move to end of displayed line'),
+QApplication.translate('ViewManager',
+'Move to end of displayed line'),
+QKeySequence(QApplication.translate('ViewManager', 'Alt+End')), 0,
+self.editorActGrp, 'vm_edit_move_end_displayed_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEENDDISPLAY)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend selection to end of displayed line'),
+QApplication.translate('ViewManager',
+'Extend selection to end of displayed line'),
+0, 0,
+self.editorActGrp, 'vm_edit_extend_selection_end_displayed_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEENDDISPLAYEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager', 'Formfeed'),
+QApplication.translate('ViewManager', 'Formfeed'),
+0, 0,
+self.editorActGrp, 'vm_edit_formfeed')
+self.esm.setMapping(act, QsciScintilla.SCI_FORMFEED)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend rectangular selection down one line'),
+QApplication.translate('ViewManager',
+'Extend rectangular selection down one line'),
+QKeySequence(QApplication.translate('ViewManager',
+'Alt+Ctrl+Down')),
+0,
+self.editorActGrp, 'vm_edit_extend_rect_selection_down_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEDOWNRECTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend rectangular selection up one line'),
+QApplication.translate('ViewManager',
+'Extend rectangular selection up one line'),
+QKeySequence(QApplication.translate('ViewManager', 'Alt+Ctrl+Up')),
+0,
+self.editorActGrp, 'vm_edit_extend_rect_selection_up_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEUPRECTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend rectangular selection left one character'),
+QApplication.translate('ViewManager',
+'Extend rectangular selection left one character'),
+QKeySequence(QApplication.translate('ViewManager',
+'Alt+Ctrl+Left')),
+0,
+self.editorActGrp, 'vm_edit_extend_rect_selection_left_char')
+self.esm.setMapping(act, QsciScintilla.SCI_CHARLEFTRECTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend rectangular selection right one character'),
+QApplication.translate('ViewManager',
+'Extend rectangular selection right one character'),
+QKeySequence(QApplication.translate('ViewManager',
+'Alt+Ctrl+Right')),
+0,
+self.editorActGrp, 'vm_edit_extend_rect_selection_right_char')
+self.esm.setMapping(act, QsciScintilla.SCI_CHARRIGHTRECTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend rectangular selection to first'
+' visible character in line'),
+QApplication.translate('ViewManager',
+'Extend rectangular selection to first'
+' visible character in line'),
+QKeySequence(QApplication.translate('ViewManager',
+'Alt+Ctrl+Home')),
+0,
+self.editorActGrp,
+'vm_edit_extend_rect_selection_first_visible_char')
+self.esm.setMapping(act, QsciScintilla.SCI_VCHOMERECTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend rectangular selection to end of line'),
+QApplication.translate('ViewManager',
+'Extend rectangular selection to end of line'),
+QKeySequence(QApplication.translate('ViewManager', 'Alt+Ctrl+End')),
+0,
+self.editorActGrp, 'vm_edit_extend_rect_selection_end_line')
+self.esm.setMapping(act, QsciScintilla.SCI_LINEENDRECTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend rectangular selection up one page'),
+QApplication.translate('ViewManager',
+'Extend rectangular selection up one page'),
+QKeySequence(QApplication.translate('ViewManager',
+'Alt+Ctrl+PgUp')),
+0,
+self.editorActGrp, 'vm_edit_extend_rect_selection_up_page')
+self.esm.setMapping(act, QsciScintilla.SCI_PAGEUPRECTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Extend rectangular selection down one page'),
+QApplication.translate('ViewManager',
+'Extend rectangular selection down one page'),
+QKeySequence(QApplication.translate('ViewManager',
+'Alt+Ctrl+PgDown')),
+0,
+self.editorActGrp, 'vm_edit_extend_rect_selection_down_page')
+self.esm.setMapping(act, QsciScintilla.SCI_PAGEDOWNRECTEXTEND)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+act = E4Action(QApplication.translate('ViewManager',
+'Duplicate current selection'),
+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)
+self.connect(act, SIGNAL('triggered()'), self.esm, SLOT('map()'))
+self.editActions.append(act)
+self.editorActGrp.setEnabled(False)
+def initEditMenu(self):
+"""
+Public method to create the Edit menu
+@return the generated menu
+"""
+autocompletionMenu = \
+QMenu(QApplication.translate('ViewManager', '&Autocomplete'), self.ui)
+autocompletionMenu.setTearOffEnabled(True)
+autocompletionMenu.addAction(self.autoCompleteAct)
+autocompletionMenu.addAction(self.autoCompleteFromDocAct)
+autocompletionMenu.addAction(self.autoCompleteFromAPIsAct)
+autocompletionMenu.addAction(self.autoCompleteFromAllAct)
+autocompletionMenu.addSeparator()
+autocompletionMenu.addAction(self.calltipsAct)
+searchMenu = \
+QMenu(QApplication.translate('ViewManager', '&Search'), self.ui)
+searchMenu.setTearOffEnabled(True)
+searchMenu.addAction(self.quickSearchAct)
+searchMenu.addAction(self.quickSearchBackAct)
+searchMenu.addAction(self.searchAct)
+searchMenu.addAction(self.searchNextAct)
+searchMenu.addAction(self.searchPrevAct)
+searchMenu.addAction(self.replaceAct)
+searchMenu.addSeparator()
+searchMenu.addAction(self.searchClearMarkersAct)
+searchMenu.addSeparator()
+searchMenu.addAction(self.searchFilesAct)
+searchMenu.addAction(self.replaceFilesAct)
+menu = QMenu(QApplication.translate('ViewManager', '&Edit'), self.ui)
+menu.setTearOffEnabled(True)
+menu.addAction(self.undoAct)
+menu.addAction(self.redoAct)
+menu.addAction(self.revertAct)
+menu.addSeparator()
+menu.addAction(self.cutAct)
+menu.addAction(self.copyAct)
+menu.addAction(self.pasteAct)
+menu.addAction(self.deleteAct)
+menu.addSeparator()
+menu.addAction(self.indentAct)
+menu.addAction(self.unindentAct)
+menu.addAction(self.smartIndentAct)
+menu.addSeparator()
+menu.addAction(self.commentAct)
+menu.addAction(self.uncommentAct)
+menu.addAction(self.streamCommentAct)
+menu.addAction(self.boxCommentAct)
+menu.addSeparator()
+menu.addMenu(autocompletionMenu)
+menu.addSeparator()
+menu.addMenu(searchMenu)
+menu.addSeparator()
+menu.addAction(self.gotoAct)
+menu.addAction(self.gotoBraceAct)
+menu.addSeparator()
+menu.addAction(self.selectBraceAct)
+menu.addAction(self.selectAllAct)
+menu.addAction(self.deselectAllAct)
+menu.addSeparator()
+menu.addAction(self.shortenEmptyAct)
+menu.addAction(self.convertEOLAct)
+return menu
+def initEditToolbar(self, toolbarManager):
+"""
+Public method to create the Edit toolbar
+@param toolbarManager reference to a toolbar manager object (E4ToolBarManager)
+@return the generated toolbar
+"""
+tb = QToolBar(QApplication.translate('ViewManager', 'Edit'), self.ui)
+tb.setIconSize(UI.Config.ToolBarIconSize)
+tb.setObjectName("EditToolbar")
+tb.setToolTip(QApplication.translate('ViewManager', 'Edit'))
+tb.addAction(self.undoAct)
+tb.addAction(self.redoAct)
+tb.addSeparator()
+tb.addAction(self.cutAct)
+tb.addAction(self.copyAct)
+tb.addAction(self.pasteAct)
+tb.addAction(self.deleteAct)
+tb.addSeparator()
+tb.addAction(self.indentAct)
+tb.addAction(self.unindentAct)
+tb.addSeparator()
+tb.addAction(self.commentAct)
+tb.addAction(self.uncommentAct)
+toolbarManager.addToolBar(tb, tb.windowTitle())
+toolbarManager.addAction(self.smartIndentAct, tb.windowTitle())
+return tb
+##################################################################
+## Initialize the search related actions and the search toolbar
+##################################################################
+def __initSearchActions(self):
+"""
+Private method defining the user interface actions for the search commands.
+"""
+self.searchActGrp = createActionGroup(self)
+self.searchAct = E4Action(QApplication.translate('ViewManager', 'Search'),
+UI.PixmapCache.getIcon("find.png"),
+QApplication.translate('ViewManager', '&Search...'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+F", "Search|Search")),
+0,
+self.searchActGrp, 'vm_search')
+self.searchAct.setStatusTip(QApplication.translate('ViewManager',
+'Search for a text'))
+self.searchAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<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.connect(self.searchAct, SIGNAL('triggered()'), self.__search)
+self.searchActions.append(self.searchAct)
+self.searchNextAct = E4Action(QApplication.translate('ViewManager',
+'Search next'),
+UI.PixmapCache.getIcon("findNext.png"),
+QApplication.translate('ViewManager', 'Search &next'),
+QKeySequence(QApplication.translate('ViewManager',
+"F3", "Search|Search next")),
+0,
+self.searchActGrp, 'vm_search_next')
+self.searchNextAct.setStatusTip(QApplication.translate('ViewManager',
+'Search next occurrence of text'))
+self.searchNextAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<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.connect(self.searchNextAct, SIGNAL('triggered()'), self.searchDlg.findNext)
+self.searchActions.append(self.searchNextAct)
+self.searchPrevAct = E4Action(QApplication.translate('ViewManager',
+'Search previous'),
+UI.PixmapCache.getIcon("findPrev.png"),
+QApplication.translate('ViewManager', 'Search &previous'),
+QKeySequence(QApplication.translate('ViewManager',
+"Shift+F3", "Search|Search previous")),
+0,
+self.searchActGrp, 'vm_search_previous')
+self.searchPrevAct.setStatusTip(QApplication.translate('ViewManager',
+'Search previous occurrence of text'))
+self.searchPrevAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<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.connect(self.searchPrevAct, SIGNAL('triggered()'), self.searchDlg.findPrev)
+self.searchActions.append(self.searchPrevAct)
+self.searchClearMarkersAct = E4Action(QApplication.translate('ViewManager',
+'Clear search markers'),
+UI.PixmapCache.getIcon("findClear.png"),
+QApplication.translate('ViewManager', 'Clear search markers'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+3", "Search|Clear search markers")),
+0,
+self.searchActGrp, 'vm_clear_search_markers')
+self.searchClearMarkersAct.setStatusTip(QApplication.translate('ViewManager',
+'Clear all displayed search markers'))
+self.searchClearMarkersAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Clear search markers</b>"""
+"""<p>Clear all displayed search markers.</p>"""
+))
+self.connect(self.searchClearMarkersAct, SIGNAL('triggered()'),
+self.__searchClearMarkers)
+self.searchActions.append(self.searchClearMarkersAct)
+self.replaceAct = E4Action(QApplication.translate('ViewManager', 'Replace'),
+QApplication.translate('ViewManager', '&Replace...'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+R", "Search|Replace")),
+0,
+self.searchActGrp, 'vm_search_replace')
+self.replaceAct.setStatusTip(QApplication.translate('ViewManager',
+'Replace some text'))
+self.replaceAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<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.connect(self.replaceAct, SIGNAL('triggered()'), self.__replace)
+self.searchActions.append(self.replaceAct)
+self.quickSearchAct = E4Action(QApplication.translate('ViewManager',
+'Quicksearch'),
+UI.PixmapCache.getIcon("quickFindNext.png"),
+QApplication.translate('ViewManager', '&Quicksearch'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+Shift+K", "Search|Quicksearch")),
+0,
+self.searchActGrp, 'vm_quicksearch')
+self.quickSearchAct.setStatusTip(QApplication.translate('ViewManager',
+'Perform a quicksearch'))
+self.quickSearchAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Quicksearch</b>"""
+"""<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.connect(self.quickSearchAct, SIGNAL('triggered()'), self.__quickSearch)
+self.searchActions.append(self.quickSearchAct)
+self.quickSearchBackAct = E4Action(QApplication.translate('ViewManager',
+'Quicksearch backwards'),
+UI.PixmapCache.getIcon("quickFindPrev.png"),
+QApplication.translate('ViewManager', 'Quicksearch &backwards'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+Shift+J", "Search|Quicksearch backwards")),
+0, self.searchActGrp, 'vm_quicksearch_backwards')
+self.quickSearchBackAct.setStatusTip(QApplication.translate('ViewManager',
+'Perform a quicksearch backwards'))
+self.quickSearchBackAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Quicksearch backwards</b>"""
+"""<p>This searches the previous occurrence of the quicksearch text.</p>"""
+))
+self.connect(self.quickSearchBackAct, SIGNAL('triggered()'),
+self.__quickSearchPrev)
+self.searchActions.append(self.quickSearchBackAct)
+self.quickSearchExtendAct = E4Action(QApplication.translate('ViewManager',
+'Quicksearch extend'),
+UI.PixmapCache.getIcon("quickFindExtend.png"),
+QApplication.translate('ViewManager', 'Quicksearch e&xtend'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+Shift+H", "Search|Quicksearch extend")),
+0,
+self.searchActGrp, 'vm_quicksearch_extend')
+self.quickSearchExtendAct.setStatusTip(QApplication.translate('ViewManager', \
+'Extend the quicksearch to the end of the current word'))
+self.quickSearchExtendAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Quicksearch extend</b>"""
+"""<p>This extends the quicksearch text to the end of the word"""
+""" currently found.</p>"""
+))
+self.connect(self.quickSearchExtendAct, SIGNAL('triggered()'),
+self.__quickSearchExtend)
+self.searchActions.append(self.quickSearchExtendAct)
+self.gotoAct = E4Action(QApplication.translate('ViewManager', 'Goto Line'),
+UI.PixmapCache.getIcon("goto.png"),
+QApplication.translate('ViewManager', '&Goto Line...'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+G", "Search|Goto Line")),
+0,
+self.searchActGrp, 'vm_search_goto_line')
+self.gotoAct.setStatusTip(QApplication.translate('ViewManager', 'Goto Line'))
+self.gotoAct.setWhatsThis(QApplication.translate('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.connect(self.gotoAct, SIGNAL('triggered()'), self.__goto)
+self.searchActions.append(self.gotoAct)
+self.gotoBraceAct = E4Action(QApplication.translate('ViewManager', 'Goto Brace'),
+UI.PixmapCache.getIcon("gotoBrace.png"),
+QApplication.translate('ViewManager', 'Goto &Brace'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+L", "Search|Goto Brace")),
+0,
+self.searchActGrp, 'vm_search_goto_brace')
+self.gotoBraceAct.setStatusTip(QApplication.translate('ViewManager',
+'Goto Brace'))
+self.gotoBraceAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Goto Brace</b>"""
+"""<p>Go to the matching brace in the current editor.</p>"""
+))
+self.connect(self.gotoBraceAct, SIGNAL('triggered()'), self.__gotoBrace)
+self.searchActions.append(self.gotoBraceAct)
+self.searchActGrp.setEnabled(False)
+self.searchFilesAct = E4Action(QApplication.translate('ViewManager',
+'Search in Files'),
+UI.PixmapCache.getIcon("projectFind.png"),
+QApplication.translate('ViewManager', 'Search in &Files...'),
+QKeySequence(QApplication.translate('ViewManager',
+"Shift+Ctrl+F", "Search|Search Files")),
+0,
+self, 'vm_search_in_files')
+self.searchFilesAct.setStatusTip(QApplication.translate('ViewManager',
+'Search for a text in files'))
+self.searchFilesAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<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.connect(self.searchFilesAct, SIGNAL('triggered()'), self.__searchFiles)
+self.searchActions.append(self.searchFilesAct)
+self.replaceFilesAct = E4Action(QApplication.translate('ViewManager',
+'Replace in Files'),
+QApplication.translate('ViewManager', 'Replace in F&iles...'),
+QKeySequence(QApplication.translate('ViewManager',
+"Shift+Ctrl+R", "Search|Replace in Files")),
+0,
+self, 'vm_replace_in_files')
+self.replaceFilesAct.setStatusTip(QApplication.translate('ViewManager',
+'Search for a text in files and replace it'))
+self.replaceFilesAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Replace in Files</b>"""
+"""<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.connect(self.replaceFilesAct, SIGNAL('triggered()'), self.__replaceFiles)
+self.searchActions.append(self.replaceFilesAct)
+def initSearchToolbars(self, toolbarManager):
+"""
+Public method to create the Search toolbars
+@param toolbarManager reference to a toolbar manager object (E4ToolBarManager)
+@return a tuple of the generated toolbar (search, quicksearch)
+"""
+qtb = QToolBar(QApplication.translate('ViewManager', 'Quicksearch'), self.ui)
+qtb.setIconSize(UI.Config.ToolBarIconSize)
+qtb.setObjectName("QuicksearchToolbar")
+qtb.setToolTip(QApplication.translate('ViewManager', 'Quicksearch'))
+self.quickFindLineEdit = QuickSearchLineEdit(self)
+self.quickFindtextCombo = QComboBox(self)
+self.quickFindtextCombo.setEditable(True)
+self.quickFindtextCombo.setLineEdit(self.quickFindLineEdit)
+self.quickFindtextCombo.setDuplicatesEnabled(False)
+self.quickFindtextCombo.setInsertPolicy(QComboBox.InsertAtTop)
+self.quickFindtextCombo.lastActive = None
+self.quickFindtextCombo.lastCursorPos = None
+self.quickFindtextCombo.leForegroundColor = \
+self.quickFindtextCombo.lineEdit().palette().color(QPalette.Text)
+self.quickFindtextCombo.leBackgroundColor = \
+self.quickFindtextCombo.lineEdit().palette().color(QPalette.Base)
+self.quickFindtextCombo.lastSearchText = ""
+self.quickFindtextCombo._editor = self.quickFindtextCombo.lineEdit()
+# this allows us not to jump across searched text
+# just because of autocompletion enabled
+self.quickFindtextCombo.setAutoCompletion(False)
+self.quickFindtextCombo.setMinimumWidth(250)
+self.quickFindtextCombo.addItem("")
+self.quickFindtextCombo.setWhatsThis(QApplication.translate('ViewManager',
+"""<p>Enter the searchtext directly into this field."""
+""" The search will be performed case insensitive."""
+""" The quicksearch function is activated upon activation"""
+""" of the quicksearch next action (default key Ctrl+Shift+K),"""
+""" if this entry field does not have the input focus."""
+""" Otherwise it searches for the next occurrence of the"""
+""" text entered. The quicksearch backwards action"""
+""" (default key Ctrl+Shift+J) searches backward."""
+""" Activating the 'quicksearch extend' action"""
+""" (default key Ctrl+Shift+H) extends the current"""
+""" searchtext to the end of the currently found word."""
+""" The quicksearch can be ended by pressing the Return key"""
+""" while the quicksearch entry has the the input focus.</p>"""
+))
+self.connect(self.quickFindtextCombo._editor, SIGNAL('returnPressed()'),
+self.__quickSearchEnter)
+self.connect(self.quickFindtextCombo._editor,
+SIGNAL('textChanged(const QString&)'), self.__quickSearchText)
+self.connect(self.quickFindtextCombo._editor, SIGNAL('escPressed()'),
+self.__quickSearchEscape)
+self.connect(self.quickFindtextCombo._editor, SIGNAL('gotFocus()'),
+self.__quickSearchFocusIn)
+self.quickFindtextAction = QWidgetAction(self)
+self.quickFindtextAction.setDefaultWidget(self.quickFindtextCombo)
+self.quickFindtextAction.setObjectName("vm_quickfindtext_action")
+self.quickFindtextAction.setText(self.trUtf8("Quicksearch Textedit"))
+qtb.addAction(self.quickFindtextAction)
+qtb.addAction(self.quickSearchAct)
+qtb.addAction(self.quickSearchBackAct)
+qtb.addAction(self.quickSearchExtendAct)
+self.quickFindtextCombo.setEnabled(False)
+tb = QToolBar(QApplication.translate('ViewManager', 'Search'), self.ui)
+tb.setIconSize(UI.Config.ToolBarIconSize)
+tb.setObjectName("SearchToolbar")
+tb.setToolTip(QApplication.translate('ViewManager', 'Search'))
+tb.addAction(self.searchAct)
+tb.addAction(self.searchNextAct)
+tb.addAction(self.searchPrevAct)
+tb.addSeparator()
+tb.addAction(self.searchClearMarkersAct)
+tb.addSeparator()
+tb.addAction(self.searchFilesAct)
+tb.setAllowedAreas(Qt.ToolBarAreas(Qt.TopToolBarArea | Qt.BottomToolBarArea))
+toolbarManager.addToolBar(qtb, qtb.windowTitle())
+toolbarManager.addToolBar(tb, tb.windowTitle())
+toolbarManager.addAction(self.gotoAct, tb.windowTitle())
+toolbarManager.addAction(self.gotoBraceAct, tb.windowTitle())
+return tb, qtb
+##################################################################
+## Initialize the view related actions, view menu and toolbar
+##################################################################
+def __initViewActions(self):
+"""
+Private method defining the user interface actions for the view commands.
+"""
+self.viewActGrp = createActionGroup(self)
+self.viewFoldActGrp = createActionGroup(self)
+self.zoomInAct = E4Action(QApplication.translate('ViewManager', 'Zoom in'),
+UI.PixmapCache.getIcon("zoomIn.png"),
+QApplication.translate('ViewManager', 'Zoom &in'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl++", "View|Zoom in")),
+0,
+self.viewActGrp, 'vm_view_zoom_in')
+self.zoomInAct.setStatusTip(QApplication.translate('ViewManager',
+'Zoom in on the text'))
+self.zoomInAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Zoom in</b>"""
+"""<p>Zoom in on the text. This makes the text bigger.</p>"""
+))
+self.connect(self.zoomInAct, SIGNAL('triggered()'), self.__zoomIn)
+self.viewActions.append(self.zoomInAct)
+self.zoomOutAct = E4Action(QApplication.translate('ViewManager', 'Zoom out'),
+UI.PixmapCache.getIcon("zoomOut.png"),
+QApplication.translate('ViewManager', 'Zoom &out'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+-", "View|Zoom out")),
+0,
+self.viewActGrp, 'vm_view_zoom_out')
+self.zoomOutAct.setStatusTip(QApplication.translate('ViewManager',
+'Zoom out on the text'))
+self.zoomOutAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Zoom out</b>"""
+"""<p>Zoom out on the text. This makes the text smaller.</p>"""
+))
+self.connect(self.zoomOutAct, SIGNAL('triggered()'), self.__zoomOut)
+self.viewActions.append(self.zoomOutAct)
+self.zoomToAct = E4Action(QApplication.translate('ViewManager', 'Zoom'),
+UI.PixmapCache.getIcon("zoomTo.png"),
+QApplication.translate('ViewManager', '&Zoom'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+#", "View|Zoom")),
+0,
+self.viewActGrp, 'vm_view_zoom')
+self.zoomToAct.setStatusTip(QApplication.translate('ViewManager',
+'Zoom the text'))
+self.zoomToAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Zoom</b>"""
+"""<p>Zoom the text. This opens a dialog where the"""
+""" desired size can be entered.</p>"""
+))
+self.connect(self.zoomToAct, SIGNAL('triggered()'), self.__zoom)
+self.viewActions.append(self.zoomToAct)
+self.toggleAllAct = E4Action(QApplication.translate('ViewManager',
+'Toggle all folds'),
+QApplication.translate('ViewManager', 'Toggle &all folds'),
+0, 0, self.viewFoldActGrp, 'vm_view_toggle_all_folds')
+self.toggleAllAct.setStatusTip(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.connect(self.toggleAllAct, SIGNAL('triggered()'), self.__toggleAll)
+self.viewActions.append(self.toggleAllAct)
+self.toggleAllChildrenAct = \
+E4Action(QApplication.translate('ViewManager',
+'Toggle all folds (including children)'),
+QApplication.translate('ViewManager',
+'Toggle all &folds (including children)'),
+0, 0, self.viewFoldActGrp, 'vm_view_toggle_all_folds_children')
+self.toggleAllChildrenAct.setStatusTip(QApplication.translate('ViewManager',
+'Toggle all folds (including children)'))
+self.toggleAllChildrenAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Toggle all folds (including children)</b>"""
+"""<p>Toggle all folds of the current editor including"""
+""" all children.</p>"""
+))
+self.connect(self.toggleAllChildrenAct, SIGNAL('triggered()'),
+self.__toggleAllChildren)
+self.viewActions.append(self.toggleAllChildrenAct)
+self.toggleCurrentAct = E4Action(QApplication.translate('ViewManager',
+'Toggle current fold'),
+QApplication.translate('ViewManager', 'Toggle &current fold'),
+0, 0, self.viewFoldActGrp, 'vm_view_toggle_current_fold')
+self.toggleCurrentAct.setStatusTip(QApplication.translate('ViewManager',
+'Toggle current fold'))
+self.toggleCurrentAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Toggle current fold</b>"""
+"""<p>Toggle the folds of the current line of the current editor.</p>"""
+))
+self.connect(self.toggleCurrentAct, SIGNAL('triggered()'), self.__toggleCurrent)
+self.viewActions.append(self.toggleCurrentAct)
+self.unhighlightAct = E4Action(QApplication.translate('ViewManager',
+'Remove all highlights'),
+UI.PixmapCache.getIcon("unhighlight.png"),
+QApplication.translate('ViewManager',
+'Remove all highlights'),
+0, 0, self, 'vm_view_unhighlight')
+self.unhighlightAct.setStatusTip(QApplication.translate('ViewManager',
+'Remove all highlights'))
+self.unhighlightAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Remove all highlights</b>"""
+"""<p>Remove the highlights of all editors.</p>"""
+))
+self.connect(self.unhighlightAct, SIGNAL('triggered()'), self.unhighlight)
+self.viewActions.append(self.unhighlightAct)
+self.splitViewAct = E4Action(QApplication.translate('ViewManager', 'Split view'),
+UI.PixmapCache.getIcon("splitVertical.png"),
+QApplication.translate('ViewManager', '&Split view'),
+0, 0, self, 'vm_view_split_view')
+self.splitViewAct.setStatusTip(QApplication.translate('ViewManager',
+'Add a split to the view'))
+self.splitViewAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Split view</b>"""
+"""<p>Add a split to the view.</p>"""
+))
+self.connect(self.splitViewAct, SIGNAL('triggered()'), self.__splitView)
+self.viewActions.append(self.splitViewAct)
+self.splitOrientationAct = E4Action(QApplication.translate('ViewManager',
+'Arrange horizontally'),
+QApplication.translate('ViewManager',
+'Arrange &horizontally'),
+0, 0, self, 'vm_view_arrange_horizontally', True)
+self.splitOrientationAct.setStatusTip(QApplication.translate('ViewManager',
+'Arrange the splitted views horizontally'))
+self.splitOrientationAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Arrange horizontally</b>"""
+"""<p>Arrange the splitted views horizontally.</p>"""
+))
+self.splitOrientationAct.setChecked(False)
+self.connect(self.splitOrientationAct, SIGNAL('toggled(bool)'),
+self.__splitOrientation)
+self.viewActions.append(self.splitOrientationAct)
+self.splitRemoveAct = E4Action(QApplication.translate('ViewManager',
+'Remove split'),
+UI.PixmapCache.getIcon("remsplitVertical.png"),
+QApplication.translate('ViewManager', '&Remove split'),
+0, 0, self, 'vm_view_remove_split')
+self.splitRemoveAct.setStatusTip(QApplication.translate('ViewManager',
+'Remove the current split'))
+self.splitRemoveAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Remove split</b>"""
+"""<p>Remove the current split.</p>"""
+))
+self.connect(self.splitRemoveAct, SIGNAL('triggered()'), self.removeSplit)
+self.viewActions.append(self.splitRemoveAct)
+self.nextSplitAct = E4Action(QApplication.translate('ViewManager', 'Next split'),
+QApplication.translate('ViewManager', '&Next split'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+Alt+N", "View|Next split")),
+0,
+self, 'vm_next_split')
+self.nextSplitAct.setStatusTip(QApplication.translate('ViewManager',
+'Move to the next split'))
+self.nextSplitAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Next split</b>"""
+"""<p>Move to the next split.</p>"""
+))
+self.connect(self.nextSplitAct, SIGNAL('triggered()'), self.nextSplit)
+self.viewActions.append(self.nextSplitAct)
+self.prevSplitAct = E4Action(QApplication.translate('ViewManager',
+'Previous split'),
+QApplication.translate('ViewManager', '&Previous split'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+Alt+P", "View|Previous split")),
+0, self, 'vm_previous_split')
+self.prevSplitAct.setStatusTip(QApplication.translate('ViewManager',
+'Move to the previous split'))
+self.prevSplitAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Previous split</b>"""
+"""<p>Move to the previous split.</p>"""
+))
+self.connect(self.prevSplitAct, SIGNAL('triggered()'), self.prevSplit)
+self.viewActions.append(self.prevSplitAct)
+self.viewActGrp.setEnabled(False)
+self.viewFoldActGrp.setEnabled(False)
+self.unhighlightAct.setEnabled(False)
+self.splitViewAct.setEnabled(False)
+self.splitOrientationAct.setEnabled(False)
+self.splitRemoveAct.setEnabled(False)
+self.nextSplitAct.setEnabled(False)
+self.prevSplitAct.setEnabled(False)
+def initViewMenu(self):
+"""
+Public method to create the View menu
+@return the generated menu
+"""
+menu = QMenu(QApplication.translate('ViewManager', '&View'), self.ui)
+menu.setTearOffEnabled(True)
+menu.addActions(self.viewActGrp.actions())
+menu.addSeparator()
+menu.addActions(self.viewFoldActGrp.actions())
+menu.addSeparator()
+menu.addAction(self.unhighlightAct)
+if self.canSplit():
+menu.addSeparator()
+menu.addAction(self.splitViewAct)
+menu.addAction(self.splitOrientationAct)
+menu.addAction(self.splitRemoveAct)
+menu.addAction(self.nextSplitAct)
+menu.addAction(self.prevSplitAct)
+return menu
+def initViewToolbar(self, toolbarManager):
+"""
+Public method to create the View toolbar
+@param toolbarManager reference to a toolbar manager object (E4ToolBarManager)
+@return the generated toolbar
+"""
+tb = QToolBar(QApplication.translate('ViewManager', 'View'), self.ui)
+tb.setIconSize(UI.Config.ToolBarIconSize)
+tb.setObjectName("ViewToolbar")
+tb.setToolTip(QApplication.translate('ViewManager', 'View'))
+tb.addActions(self.viewActGrp.actions())
+toolbarManager.addToolBar(tb, tb.windowTitle())
+toolbarManager.addAction(self.unhighlightAct, tb.windowTitle())
+toolbarManager.addAction(self.splitViewAct, tb.windowTitle())
+toolbarManager.addAction(self.splitRemoveAct, tb.windowTitle())
+return tb
+##################################################################
+## Initialize the macro related actions and macro menu
+##################################################################
+def __initMacroActions(self):
+"""
+Private method defining the user interface actions for the macro commands.
+"""
+self.macroActGrp = createActionGroup(self)
+self.macroStartRecAct = E4Action(QApplication.translate('ViewManager',
+'Start Macro Recording'),
+QApplication.translate('ViewManager',
+'S&tart Macro Recording'),
+0, 0, self.macroActGrp, 'vm_macro_start_recording')
+self.macroStartRecAct.setStatusTip(QApplication.translate('ViewManager',
+'Start Macro Recording'))
+self.macroStartRecAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Start Macro Recording</b>"""
+"""<p>Start recording editor commands into a new macro.</p>"""
+))
+self.connect(self.macroStartRecAct, SIGNAL('triggered()'),
+self.__macroStartRecording)
+self.macroActions.append(self.macroStartRecAct)
+self.macroStopRecAct = E4Action(QApplication.translate('ViewManager',
+'Stop Macro Recording'),
+QApplication.translate('ViewManager',
+'Sto&p Macro Recording'),
+0, 0, self.macroActGrp, 'vm_macro_stop_recording')
+self.macroStopRecAct.setStatusTip(QApplication.translate('ViewManager',
+'Stop Macro Recording'))
+self.macroStopRecAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Stop Macro Recording</b>"""
+"""<p>Stop recording editor commands into a new macro.</p>"""
+))
+self.connect(self.macroStopRecAct, SIGNAL('triggered()'),
+self.__macroStopRecording)
+self.macroActions.append(self.macroStopRecAct)
+self.macroRunAct = E4Action(QApplication.translate('ViewManager', 'Run Macro'),
+QApplication.translate('ViewManager', '&Run Macro'),
+0, 0, self.macroActGrp, 'vm_macro_run')
+self.macroRunAct.setStatusTip(QApplication.translate('ViewManager', 'Run Macro'))
+self.macroRunAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Run Macro</b>"""
+"""<p>Run a previously recorded editor macro.</p>"""
+))
+self.connect(self.macroRunAct, SIGNAL('triggered()'), self.__macroRun)
+self.macroActions.append(self.macroRunAct)
+self.macroDeleteAct = E4Action(QApplication.translate('ViewManager',
+'Delete Macro'),
+QApplication.translate('ViewManager', '&Delete Macro'),
+0, 0, self.macroActGrp, 'vm_macro_delete')
+self.macroDeleteAct.setStatusTip(QApplication.translate('ViewManager',
+'Delete Macro'))
+self.macroDeleteAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Delete Macro</b>"""
+"""<p>Delete a previously recorded editor macro.</p>"""
+))
+self.connect(self.macroDeleteAct, SIGNAL('triggered()'), self.__macroDelete)
+self.macroActions.append(self.macroDeleteAct)
+self.macroLoadAct = E4Action(QApplication.translate('ViewManager', 'Load Macro'),
+QApplication.translate('ViewManager', '&Load Macro'),
+0, 0, self.macroActGrp, 'vm_macro_load')
+self.macroLoadAct.setStatusTip(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.connect(self.macroLoadAct, SIGNAL('triggered()'), self.__macroLoad)
+self.macroActions.append(self.macroLoadAct)
+self.macroSaveAct = E4Action(QApplication.translate('ViewManager', 'Save Macro'),
+QApplication.translate('ViewManager', '&Save Macro'),
+0, 0, self.macroActGrp, 'vm_macro_save')
+self.macroSaveAct.setStatusTip(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.connect(self.macroSaveAct, SIGNAL('triggered()'), self.__macroSave)
+self.macroActions.append(self.macroSaveAct)
+self.macroActGrp.setEnabled(False)
+def initMacroMenu(self):
+"""
+Public method to create the Macro menu
+@return the generated menu
+"""
+menu = QMenu(QApplication.translate('ViewManager', "&Macros"), self.ui)
+menu.setTearOffEnabled(True)
+menu.addActions(self.macroActGrp.actions())
+return menu
+#####################################################################
+## Initialize the bookmark related actions, bookmark menu and toolbar
+#####################################################################
+def __initBookmarkActions(self):
+"""
+Private method defining the user interface actions for the bookmarks commands.
+"""
+self.bookmarkActGrp = createActionGroup(self)
+self.bookmarkToggleAct = E4Action(QApplication.translate('ViewManager',
+'Toggle Bookmark'),
+UI.PixmapCache.getIcon("bookmarkToggle.png"),
+QApplication.translate('ViewManager', '&Toggle Bookmark'),
+QKeySequence(QApplication.translate('ViewManager',
+"Alt+Ctrl+T", "Bookmark|Toggle")), 0,
+self.bookmarkActGrp, 'vm_bookmark_toggle')
+self.bookmarkToggleAct.setStatusTip(QApplication.translate('ViewManager',
+'Toggle Bookmark'))
+self.bookmarkToggleAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Toggle Bookmark</b>"""
+"""<p>Toggle a bookmark at the current line of the current editor.</p>"""
+))
+self.connect(self.bookmarkToggleAct, SIGNAL('triggered()'), self.__toggleBookmark)
+self.bookmarkActions.append(self.bookmarkToggleAct)
+self.bookmarkNextAct = E4Action(QApplication.translate('ViewManager',
+'Next Bookmark'),
+UI.PixmapCache.getIcon("bookmarkNext.png"),
+QApplication.translate('ViewManager', '&Next Bookmark'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+PgDown", "Bookmark|Next")), 0,
+self.bookmarkActGrp, 'vm_bookmark_next')
+self.bookmarkNextAct.setStatusTip(QApplication.translate('ViewManager',
+'Next Bookmark'))
+self.bookmarkNextAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Next Bookmark</b>"""
+"""<p>Go to next bookmark of the current editor.</p>"""
+))
+self.connect(self.bookmarkNextAct, SIGNAL('triggered()'), self.__nextBookmark)
+self.bookmarkActions.append(self.bookmarkNextAct)
+self.bookmarkPreviousAct = E4Action(QApplication.translate('ViewManager',
+'Previous Bookmark'),
+UI.PixmapCache.getIcon("bookmarkPrevious.png"),
+QApplication.translate('ViewManager', '&Previous Bookmark'),
+QKeySequence(QApplication.translate('ViewManager',
+"Ctrl+PgUp", "Bookmark|Previous")),
+0, self.bookmarkActGrp, 'vm_bookmark_previous')
+self.bookmarkPreviousAct.setStatusTip(QApplication.translate('ViewManager',
+'Previous Bookmark'))
+self.bookmarkPreviousAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Previous Bookmark</b>"""
+"""<p>Go to previous bookmark of the current editor.</p>"""
+))
+self.connect(self.bookmarkPreviousAct, SIGNAL('triggered()'),
+self.__previousBookmark)
+self.bookmarkActions.append(self.bookmarkPreviousAct)
+self.bookmarkClearAct = E4Action(QApplication.translate('ViewManager',
+'Clear Bookmarks'),
+QApplication.translate('ViewManager', '&Clear Bookmarks'),
+QKeySequence(QApplication.translate('ViewManager',
+"Alt+Ctrl+C", "Bookmark|Clear")),
+0,
+self.bookmarkActGrp, 'vm_bookmark_clear')
+self.bookmarkClearAct.setStatusTip(QApplication.translate('ViewManager',
+'Clear Bookmarks'))
+self.bookmarkClearAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Clear Bookmarks</b>"""
+"""<p>Clear bookmarks of all editors.</p>"""
+))
+self.connect(self.bookmarkClearAct, SIGNAL('triggered()'),
+self.__clearAllBookmarks)
+self.bookmarkActions.append(self.bookmarkClearAct)
+self.syntaxErrorGotoAct = E4Action(QApplication.translate('ViewManager',
+'Goto Syntax Error'),
+UI.PixmapCache.getIcon("syntaxErrorGoto.png"),
+QApplication.translate('ViewManager', '&Goto Syntax Error'),
+0, 0,
+self.bookmarkActGrp, 'vm_syntaxerror_goto')
+self.syntaxErrorGotoAct.setStatusTip(QApplication.translate('ViewManager',
+'Goto Syntax Error'))
+self.syntaxErrorGotoAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Goto Syntax Error</b>"""
+"""<p>Go to next syntax error of the current editor.</p>"""
+))
+self.connect(self.syntaxErrorGotoAct, SIGNAL('triggered()'), self.__gotoSyntaxError)
+self.bookmarkActions.append(self.syntaxErrorGotoAct)
+self.syntaxErrorClearAct = E4Action(QApplication.translate('ViewManager',
+'Clear Syntax Errors'),
+QApplication.translate('ViewManager', 'Clear &Syntax Errors'),
+0, 0,
+self.bookmarkActGrp, 'vm_syntaxerror_clear')
+self.syntaxErrorClearAct.setStatusTip(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.connect(self.syntaxErrorClearAct, SIGNAL('triggered()'),
+self.__clearAllSyntaxErrors)
+self.bookmarkActions.append(self.syntaxErrorClearAct)
+self.notcoveredNextAct = E4Action(QApplication.translate('ViewManager',
+'Next uncovered line'),
+UI.PixmapCache.getIcon("notcoveredNext.png"),
+QApplication.translate('ViewManager', '&Next uncovered line'),
+0, 0,
+self.bookmarkActGrp, 'vm_uncovered_next')
+self.notcoveredNextAct.setStatusTip(QApplication.translate('ViewManager',
+'Next uncovered line'))
+self.notcoveredNextAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Next uncovered line</b>"""
+"""<p>Go to next line of the current editor marked as not covered.</p>"""
+))
+self.connect(self.notcoveredNextAct, SIGNAL('triggered()'), self.__nextUncovered)
+self.bookmarkActions.append(self.notcoveredNextAct)
+self.notcoveredPreviousAct = E4Action(QApplication.translate('ViewManager',
+'Previous uncovered line'),
+UI.PixmapCache.getIcon("notcoveredPrev.png"),
+QApplication.translate('ViewManager',
+'&Previous uncovered line'),
+0, 0,
+self.bookmarkActGrp, 'vm_uncovered_previous')
+self.notcoveredPreviousAct.setStatusTip(QApplication.translate('ViewManager',
+'Previous uncovered line'))
+self.notcoveredPreviousAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Previous uncovered line</b>"""
+"""<p>Go to previous line of the current editor marked"""
+""" as not covered.</p>"""
+))
+self.connect(self.notcoveredPreviousAct, SIGNAL('triggered()'),
+self.__previousUncovered)
+self.bookmarkActions.append(self.notcoveredPreviousAct)
+self.taskNextAct = E4Action(QApplication.translate('ViewManager',
+'Next Task'),
+UI.PixmapCache.getIcon("taskNext.png"),
+QApplication.translate('ViewManager', '&Next Task'),
+0, 0,
+self.bookmarkActGrp, 'vm_task_next')
+self.taskNextAct.setStatusTip(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.connect(self.taskNextAct, SIGNAL('triggered()'), self.__nextTask)
+self.bookmarkActions.append(self.taskNextAct)
+self.taskPreviousAct = E4Action(QApplication.translate('ViewManager',
+'Previous Task'),
+UI.PixmapCache.getIcon("taskPrev.png"),
+QApplication.translate('ViewManager',
+'&Previous Task'),
+0, 0,
+self.bookmarkActGrp, 'vm_task_previous')
+self.taskPreviousAct.setStatusTip(QApplication.translate('ViewManager',
+'Previous Task'))
+self.taskPreviousAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Previous Task</b>"""
+"""<p>Go to previous line of the current editor having a task.</p>"""
+))
+self.connect(self.taskPreviousAct, SIGNAL('triggered()'), self.__previousTask)
+self.bookmarkActions.append(self.taskPreviousAct)
+self.bookmarkActGrp.setEnabled(False)
+def initBookmarkMenu(self):
+"""
+Public method to create the Bookmark menu
+@return the generated menu
+"""
+menu = QMenu(QApplication.translate('ViewManager', '&Bookmarks'), self.ui)
+self.bookmarksMenu = QMenu(QApplication.translate('ViewManager', '&Bookmarks'),
+menu)
+menu.setTearOffEnabled(True)
+menu.addAction(self.bookmarkToggleAct)
+menu.addAction(self.bookmarkNextAct)
+menu.addAction(self.bookmarkPreviousAct)
+menu.addAction(self.bookmarkClearAct)
+menu.addSeparator()
+self.menuBookmarksAct = menu.addMenu(self.bookmarksMenu)
+menu.addSeparator()
+menu.addAction(self.syntaxErrorGotoAct)
+menu.addAction(self.syntaxErrorClearAct)
+menu.addSeparator()
+menu.addAction(self.notcoveredNextAct)
+menu.addAction(self.notcoveredPreviousAct)
+menu.addSeparator()
+menu.addAction(self.taskNextAct)
+menu.addAction(self.taskPreviousAct)
+self.connect(self.bookmarksMenu, SIGNAL('aboutToShow()'),
+self.__showBookmarksMenu)
+self.connect(self.bookmarksMenu, SIGNAL('triggered(QAction *)'),
+self.__bookmarkSelected)
+self.connect(menu, SIGNAL('aboutToShow()'), self.__showBookmarkMenu)
+return menu
+def initBookmarkToolbar(self, toolbarManager):
+"""
+Public method to create the Bookmark toolbar
+@param toolbarManager reference to a toolbar manager object (E4ToolBarManager)
+@return the generated toolbar
+"""
+tb = QToolBar(QApplication.translate('ViewManager', 'Bookmarks'), self.ui)
+tb.setIconSize(UI.Config.ToolBarIconSize)
+tb.setObjectName("BookmarksToolbar")
+tb.setToolTip(QApplication.translate('ViewManager', 'Bookmarks'))
+tb.addAction(self.bookmarkToggleAct)
+tb.addAction(self.bookmarkNextAct)
+tb.addAction(self.bookmarkPreviousAct)
+tb.addSeparator()
+tb.addAction(self.syntaxErrorGotoAct)
+tb.addSeparator()
+tb.addAction(self.taskNextAct)
+tb.addAction(self.taskPreviousAct)
+toolbarManager.addToolBar(tb, tb.windowTitle())
+toolbarManager.addAction(self.notcoveredNextAct, tb.windowTitle())
+toolbarManager.addAction(self.notcoveredPreviousAct, tb.windowTitle())
+return tb
+##################################################################
+## Initialize the spell checking related actions
+##################################################################
+def __initSpellingActions(self):
+"""
+Private method to initialize the spell checking actions.
+"""
+self.spellingActGrp = createActionGroup(self)
+self.spellCheckAct = E4Action(QApplication.translate('ViewManager',
+'Spell check'),
+UI.PixmapCache.getIcon("spellchecking.png"),
+QApplication.translate('ViewManager',
+'&Spell Check...'),
+QKeySequence(QApplication.translate('ViewManager',
+"Shift+F7", "Spelling|Spell Check")),
+0,
+self.spellingActGrp, 'vm_spelling_spellcheck')
+self.spellCheckAct.setStatusTip(QApplication.translate('ViewManager',
+'Perform spell check of current editor'))
+self.spellCheckAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Spell check</b>"""
+"""<p>Perform a spell check of the current editor.</p>"""
+))
+self.connect(self.spellCheckAct, SIGNAL('triggered()'), self.__spellCheck)
+self.spellingActions.append(self.spellCheckAct)
+self.autoSpellCheckAct = E4Action(QApplication.translate('ViewManager',
+'Automatic spell checking'),
+UI.PixmapCache.getIcon("autospellchecking.png"),
+QApplication.translate('ViewManager',
+'&Automatic spell checking'),
+0, 0,
+self.spellingActGrp, 'vm_spelling_autospellcheck')
+self.autoSpellCheckAct.setStatusTip(QApplication.translate('ViewManager',
+'(De-)Activate automatic spell checking'))
+self.autoSpellCheckAct.setWhatsThis(QApplication.translate('ViewManager',
+"""<b>Automatic spell checking</b>"""
+"""<p>Activate or deactivate the automatic spell checking function of"""
+""" all editors.</p>"""
+))
+self.autoSpellCheckAct.setCheckable(True)
+self.autoSpellCheckAct.setChecked(
+Preferences.getEditor("AutoSpellCheckingEnabled"))
+self.connect(self.autoSpellCheckAct, SIGNAL('triggered()'),
+self.__setAutoSpellChecking)
+self.spellingActions.append(self.autoSpellCheckAct)
+self.__enableSpellingActions()
+def __enableSpellingActions(self):
+"""
+Private method to set the enabled state of the spelling actions.
+"""
+spellingAvailable = SpellChecker.isAvailable()
+self.spellCheckAct.setEnabled(len(self.editors) != 0 and spellingAvailable)
+self.autoSpellCheckAct.setEnabled(spellingAvailable)
+def addToExtrasMenu(self, menu):
+"""
+Public method to add some actions to the extras menu.
+"""
+menu.addAction(self.spellCheckAct)
+menu.addAction(self.autoSpellCheckAct)
+menu.addSeparator()
+def initSpellingToolbar(self, toolbarManager):
+"""
+Public method to create the Spelling toolbar
+@param toolbarManager reference to a toolbar manager object (E4ToolBarManager)
+@return the generated toolbar
+"""
+tb = QToolBar(QApplication.translate('ViewManager', 'Spelling'), self.ui)
+tb.setIconSize(UI.Config.ToolBarIconSize)
+tb.setObjectName("SpellingToolbar")
+tb.setToolTip(QApplication.translate('ViewManager', 'Spelling'))
+tb.addAction(self.spellCheckAct)
+tb.addAction(self.autoSpellCheckAct)
+toolbarManager.addToolBar(tb, tb.windowTitle())
+return tb
+##################################################################
+## Methods and slots that deal with file and window handling
+##################################################################
+def openFiles(self, prog = None):
+"""
+Public slot to open some files.
+@param prog name of file to be opened (string)
+"""
+# Get the file name if one wasn't specified.
+if prog is None:
+# 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
+filter = self._getOpenFileFilter()
+progs = QFileDialog.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.
+@param editor editor window to check
+@param autosave flag indicating that the file should be saved
+automatically (boolean)
+@return flag indicating successful reset of the dirty flag (boolean)
+"""
+if editor.isModified():
+fn = editor.getFileName()
+# ignore the dirty status, if there is more than one open editor
+# for the same file
+if fn and self.getOpenEditorCount(fn) > 1:
+return True
+if fn is None:
+fn = editor.getNoName()
+autosave = False
+if autosave:
+res = QMessageBox.Save
+else:
+res = QMessageBox.warning(self.ui,
+QApplication.translate('ViewManager', "File Modified"),
+QApplication.translate('ViewManager',
+"""<p>The file <b>{0}</b> has unsaved changes.</p>""")
+.format(fn),
+QMessageBox.StandardButtons(\
+QMessageBox.Abort | \
+QMessageBox.Discard | \
+QMessageBox.Save),
+QMessageBox.Save)
+if res == QMessageBox.Save:
+ok, newName = editor.saveFile()
+if ok:
+self.setEditorName(editor, newName)
+return ok
+elif res == QMessageBox.Abort or res == QMessageBox.Cancel:
+return False
+return True
+def checkAllDirty(self):
+"""
+Public method to check the dirty status of all editors.
+@return flag indicating successful reset of all dirty flags (boolean)
+"""
+for editor in self.editors:
+if not self.checkDirty(editor):
+return False
+return True
+def closeEditor(self, editor):
+"""
+Public method to close an editor window.
+@param editor editor window to be closed
+@return flag indicating success (boolean)
+"""
+# save file if necessary
+if not self.checkDirty(editor):
+return False
+# get the filename of the editor for later use
+fn = editor.getFileName()
+# remove the window
+self._removeView(editor)
+self.editors.remove(editor)
+# send a signal, if it was the last editor for this filename
+if fn and self.getOpenEditor(fn) is None:
+self.emit(SIGNAL('editorClosed'), fn)
+self.emit(SIGNAL('editorClosedEd'), editor)
+# send a signal, if it was the very last editor
+if not len(self.editors):
+self.__lastEditorClosed()
+self.emit(SIGNAL('lastEditorClosed'))
+return True
+def closeCurrentWindow(self):
+"""
+Public method to close the current window.
+@return flag indicating success (boolean)
+"""
+aw = self.activeWindow()
+if aw is None:
+return False
+res = self.closeEditor(aw)
+if res and aw == self.currentEditor:
+self.currentEditor = None
+return res
+def closeAllWindows(self):
+"""
+Private method to close all editor windows via file menu.
+"""
+savedEditors = self.editors[:]
+for editor in savedEditors:
+self.closeEditor(editor)
+def closeWindow(self, fn):
+"""
+Public method to close an arbitrary source editor.
+@param fn filename of editor to be closed
+@return flag indicating success (boolean)
+"""
+for editor in self.editors:
+if Utilities.samepath(fn, editor.getFileName()):
+break
+else:
+return True
+res = self.closeEditor(editor)
+if res and editor == self.currentEditor:
+self.currentEditor = None
+return res
+def closeEditorWindow(self, editor):
+"""
+Public method to close an arbitrary source editor.
+@param editor editor to be closed
+"""
+if editor is None:
+return
+res = self.closeEditor(editor)
+if res and editor == self.currentEditor:
+self.currentEditor = None
+def exit(self):
+"""
+Public method to handle the debugged program terminating.
+"""
+if self.currentEditor is not None:
+self.currentEditor.highlight()
+self.currentEditor = None
+self.__setSbFile()
+def openSourceFile(self, fn, lineno = None, filetype = "", selection = None):
+"""
+Public slot to display a file in an editor.
+@param fn name of file to be opened
+@param lineno line number to place the cursor at
+@param filetype type of the source file (string)
+@param selection tuple (start, end) of an area to be selected
+"""
+try:
+newWin, editor = self.getEditor(fn, filetype = filetype)
+except IOError:
+return
+if newWin:
+self._modificationStatusChanged(editor.isModified(), editor)
+self._checkActions(editor)
+if lineno is not None and lineno >= 0:
+editor.ensureVisibleTop(lineno)
+editor.gotoLine(lineno)
+if selection is not None:
+editor.setSelection(lineno - 1, selection[0], lineno - 1, selection[1])
+# insert filename into list of recently opened files
+self.addToRecentList(fn)
+def __connectEditor(self, editor):
+"""
+Private method to establish all editor connections.
+@param editor reference to the editor object to be connected
+"""
+self.connect(editor, SIGNAL('modificationStatusChanged'),
+self._modificationStatusChanged)
+self.connect(editor, SIGNAL('cursorChanged'), self.__cursorChanged)
+self.connect(editor, SIGNAL('editorSaved'), self.__editorSaved)
+self.connect(editor, SIGNAL('breakpointToggled'), self.__breakpointToggled)
+self.connect(editor, SIGNAL('bookmarkToggled'), self.__bookmarkToggled)
+self.connect(editor, SIGNAL('syntaxerrorToggled'), self._syntaxErrorToggled)
+self.connect(editor, SIGNAL('coverageMarkersShown'),
+self.__coverageMarkersShown)
+self.connect(editor, SIGNAL('autoCompletionAPIsAvailable'),
+self.__editorAutoCompletionAPIsAvailable)
+self.connect(editor, SIGNAL('undoAvailable'), self.undoAct.setEnabled)
+self.connect(editor, SIGNAL('redoAvailable'), self.redoAct.setEnabled)
+self.connect(editor, SIGNAL('taskMarkersUpdated'), self.__taskMarkersUpdated)
+self.connect(editor, SIGNAL('languageChanged'), self.__editorConfigChanged)
+self.connect(editor, SIGNAL('eolChanged'), self.__editorConfigChanged)
+self.connect(editor, SIGNAL('encodingChanged'), self.__editorConfigChanged)
+self.connect(editor, SIGNAL("selectionChanged()"),
+self.searchDlg.selectionChanged)
+self.connect(editor, SIGNAL("selectionChanged()"),
+self.replaceDlg.selectionChanged)
+def newEditorView(self, fn, caller, filetype = ""):
+"""
+Public method to create a new editor displaying the given document.
+@param fn filename of this view
+@param caller reference to the editor calling this method
+@param filetype type of the source file (string)
+"""
+editor = self.cloneEditor(caller, filetype, fn)
+self._addView(editor, fn, caller.getNoName())
+self._modificationStatusChanged(editor.isModified(), editor)
+self._checkActions(editor)
+def cloneEditor(self, caller, filetype, fn):
+"""
+Public method to clone an editor displaying the given document.
+@param caller reference to the editor calling this method
+@param filetype type of the source file (string)
+@param fn filename of this view
+@return reference to the new editor object (Editor.Editor)
+"""
+editor = Editor(self.dbs, fn, self, filetype = filetype, editor = caller,
+tv = e4App().getObject("TaskViewer"))
+self.editors.append(editor)
+self.__connectEditor(editor)
+self.__editorOpened()
+self.emit(SIGNAL('editorOpened'), fn)
+self.emit(SIGNAL('editorOpenedEd'), editor)
+return editor
+def addToRecentList(self, fn):
+"""
+Public slot to add a filename to the list of recently opened files.
+@param fn name of the file to be added
+"""
+if fn in self.recent:
+self.recent.remove(fn)
+self.recent.insert(0, fn)
+maxRecent = Preferences.getUI("RecentNumber")
+if len(self.recent) > maxRecent:
+self.recent = self.recent[:maxRecent]
+self.__saveRecent()
+def showDebugSource(self, fn, line):
+"""
+Public method to open the given file and highlight the given line in it.
+@param fn filename of editor to update (string)
+@param line line number to highlight (int)
+"""
+self.openSourceFile(fn, line)
+self.setFileLine(fn, line)
+def setFileLine(self, fn, line, error = False, syntaxError = False):
+"""
+Public method to update the user interface when the current program
+or line changes.
+@param fn filename of editor to update (string)
+@param line line number to highlight (int)
+@param error flag indicating an error highlight (boolean)
+@param syntaxError flag indicating a syntax error
+"""
+try:
+newWin, self.currentEditor = self.getEditor(fn)
+except IOError:
+return
+enc = self.currentEditor.getEncoding()
+lang = self.currentEditor.getLanguage()
+eol = self.currentEditor.getEolIndicator()
+self.__setSbFile(fn, line, encoding = enc, language = lang, eol = eol)
+# Change the highlighted line.
+self.currentEditor.highlight(line, error, syntaxError)
+self.currentEditor.highlightVisible()
+self._checkActions(self.currentEditor, False)
+def __setSbFile(self, fn = None, line = None, pos = None,
+encoding = None, language = None, eol = None):
+"""
+Private method to set the file info in the status bar.
+@param fn filename to display (string)
+@param line line number to display (int)
+@param pos character position to display (int)
+@param encoding encoding name to display (string)
+@param language language to display (string)
+@param eol eol indicator to display (string)
+"""
+if fn is None:
+fn = ''
+writ = '   '
+else:
+if QFileInfo(fn).isWritable():
+writ = ' rw'
+else:
+writ = ' ro'
+self.sbWritable.setText(writ)
+self.sbFile.setTextPath(QApplication.translate('ViewManager', 'File: {0}'), fn)
+if line is None:
+line = ''
+self.sbLine.setText(QApplication.translate('ViewManager', 'Line: {0:5}')
+.format(line))
+if pos is None:
+pos = ''
+self.sbPos.setText(QApplication.translate('ViewManager', 'Pos: {0:5}')
+.format(pos))
+if encoding is None:
+encoding = ''
+self.sbEnc.setText(encoding)
+if language is None:
+language = ''
+self.sbLang.setText(language)
+if eol is None:
+eol = ''
+self.sbEol.setText(eol)
+def unhighlight(self, current = False):
+"""
+Public method to switch off all highlights.
+@param current flag indicating only the current editor should be unhighlighted
+(boolean)
+"""
+if current:
+if self.currentEditor is not None:
+self.currentEditor.highlight()
+else:
+for editor in self.editors:
+editor.highlight()
+def getOpenFilenames(self):
+"""
+Public method returning a list of the filenames of all editors.
+@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:
+filenames.append(fn)
+return filenames
+def getEditor(self, fn, filetype = ""):
+"""
+Public method to return the editor displaying the given file.
+If there is no editor with the given file, a new editor window is
+created.
+@param fn filename to look for
+@param filetype type of the source file (string)
+@return tuple of two values giving a flag indicating a new window creation and
+a reference to the editor displaying this file
+"""
+newWin = False
+editor = self.activeWindow()
+if editor is None or not Utilities.samepath(fn, editor.getFileName()):
+for editor in self.editors:
+if Utilities.samepath(fn, editor.getFileName()):
+break
+else:
+editor = Editor(self.dbs, fn, self, filetype = filetype,
+tv = e4App().getObject("TaskViewer"))
+self.editors.append(editor)
+self.__connectEditor(editor)
+self.__editorOpened()
+self.emit(SIGNAL('editorOpened'), fn)
+self.emit(SIGNAL('editorOpenedEd'), editor)
+newWin = True
+if newWin:
+self._addView(editor, fn)
+else:
+self._showView(editor, fn)
+return (newWin, editor)
+def getOpenEditors(self):
+"""
+Public method to get references to all open editors.
+@return list of references to all open editors (list of QScintilla.editor)
+"""
+return self.editors
+def getOpenEditorsCount(self):
+"""
+Public method to get the number of open editors.
+@return number of open editors (integer)
+"""
+return len(self.editors)
+def getOpenEditor(self, fn):
+"""
+Public method to return the editor displaying the given file.
+@param fn filename to look for
+@return a reference to the editor displaying this file or None, if
+no editor was found
+"""
+for editor in self.editors:
+if Utilities.samepath(fn, editor.getFileName()):
+return editor
+return None
+def getOpenEditorCount(self, fn):
+"""
+Public method to return the count of editors displaying the given file.
+@param fn filename to look for
+@return count of editors displaying this file (integer)
+"""
+count = 0
+for editor in self.editors:
+if Utilities.samepath(fn, editor.getFileName()):
+count += 1
+return count
+def getActiveName(self):
+"""
+Public method to retrieve the filename of the active window.
+@return filename of active window (string)
+"""
+aw = self.activeWindow()
+if aw:
+return aw.getFileName()
+else:
+return None
+def saveEditor(self, fn):
+"""
+Public method to save a named editor file.
+@param fn filename of editor to be saved (string)
+@return flag indicating success (boolean)
+"""
+for editor in self.editors:
+if Utilities.samepath(fn, editor.getFileName()):
+break
+else:
+return True
+if not editor.isModified():
+return True
+else:
+ok = editor.saveFile()[0]
+return ok
+def saveEditorEd(self, ed):
+"""
+Public slot to save the contents of an editor.
+@param ed editor to be saved
+@return flag indicating success (boolean)
+"""
+if ed:
+if not ed.isModified():
+return True
+else:
+ok, newName = ed.saveFile()
+if ok:
+self.setEditorName(ed, newName)
+return ok
+else:
+return False
+def saveCurrentEditor(self):
+"""
+Public slot to save the contents of the current editor.
+"""
+aw = self.activeWindow()
+self.saveEditorEd(aw)
+def saveAsEditorEd(self, ed):
+"""
+Public slot to save the contents of an editor to a new file.
+@param ed editor to be saved
+"""
+if ed:
+ok, newName = ed.saveFileAs()
+if ok:
+self.setEditorName(ed, newName)
+else:
+return
+def saveAsCurrentEditor(self):
+"""
+Public slot to save the contents of the current editor to a new file.
+"""
+aw = self.activeWindow()
+self.saveAsEditorEd(aw)
+def saveEditorsList(self, editors):
+"""
+Public slot to save a list of editors.
+@param editors list of editors to be saved
+"""
+for editor in editors:
+ok, newName = editor.saveFile()
+if ok:
+self.setEditorName(editor, newName)
+def saveAllEditors(self):
+"""
+Public slot to save the contents of all editors.
+"""
+for editor in self.editors:
+ok, newName = editor.saveFile()
+if ok:
+self.setEditorName(editor, newName)
+# restart autosave timer
+if self.autosaveInterval > 0:
+self.autosaveTimer.start(self.autosaveInterval * 60000)
+def saveEditorToProjectEd(self, ed):
+"""
+Public slot to save the contents of an editor to the current project.
+@param ed editor to be saved
+"""
+pro = e4App().getObject("Project")
+path = pro.ppath
+if ed:
+ok, newName = ed.saveFileAs(path)
+if ok:
+self.setEditorName(ed, newName)
+pro.appendFile(newName)
+ed.addedToProject()
+else:
+return
+def saveCurrentEditorToProject(self):
+"""
+Public slot to save the contents of the current editor to the current project.
+"""
+aw = self.activeWindow()
+self.saveEditorToProjectEd(aw)
+def __exportMenuTriggered(self, act):
+"""
+Private method to handle the selection of an export format.
+@param act reference to the action that was triggered (QAction)
+"""
+aw = self.activeWindow()
+if aw:
+exporterFormat = act.data().toString()
+aw.exportFile(exporterFormat)
+def newEditor(self):
+"""
+Public slot to generate a new empty editor.
+"""
+editor = Editor(self.dbs, None, self, tv = e4App().getObject("TaskViewer"))
+self.editors.append(editor)
+self.__connectEditor(editor)
+self._addView(editor, None)
+self.__editorOpened()
+self._checkActions(editor)
+self.emit(SIGNAL('editorOpened'), "")
+self.emit(SIGNAL('editorOpenedEd'), editor)
+def printEditor(self, editor):
+"""
+Public slot to print an editor.
+@param editor editor to be printed
+"""
+if editor:
+editor.printFile()
+else:
+return
+def printCurrentEditor(self):
+"""
+Public slot to print the contents of the current editor.
+"""
+aw = self.activeWindow()
+self.printEditor(aw)
+def printPreviewCurrentEditor(self):
+"""
+Public slot to show a print preview of the current editor.
+"""
+aw = self.activeWindow()
+if aw:
+aw.printPreviewFile()
+def __showFileMenu(self):
+"""
+Private method to set up the file menu.
+"""
+self.menuRecentAct.setEnabled(len(self.recent) > 0)
+def __showRecentMenu(self):
+"""
+Private method to set up recent files menu.
+"""
+self.__loadRecent()
+self.recentMenu.clear()
+idx = 1
+for rs in self.recent:
+if idx < 10:
+formatStr = '&%d. %s'
+else:
+formatStr = '%d. %s'
+act = self.recentMenu.addAction(\
+formatStr % (idx,
+Utilities.compactPath(rs, self.ui.maxMenuFilePathLen)))
+act.setData(QVariant(rs))
+act.setEnabled(QFileInfo(rs).exists())
+idx += 1
+self.recentMenu.addSeparator()
+self.recentMenu.addAction(\
+QApplication.translate('ViewManager', '&Clear'), self.__clearRecent)
+def __openSourceFile(self, act):
+"""
+Private method to open a file from the list of rencently opened files.
+@param act reference to the action that triggered (QAction)
+"""
+file = act.data().toString()
+if file:
+self.openSourceFile(file)
+def __clearRecent(self):
+"""
+Private method to clear the recent files menu.
+"""
+self.recent = []
+def __showBookmarkedMenu(self):
+"""
+Private method to set up bookmarked files menu.
+"""
+self.bookmarkedMenu.clear()
+for rp in self.bookmarked:
+act = self.bookmarkedMenu.addAction(\
+Utilities.compactPath(rp, self.ui.maxMenuFilePathLen))
+act.setData(QVariant(rp))
+act.setEnabled(QFileInfo(rp).exists())
+if len(self.bookmarked):
+self.bookmarkedMenu.addSeparator()
+self.bookmarkedMenu.addAction(\
+QApplication.translate('ViewManager', '&Add'), self.__addBookmarked)
+self.bookmarkedMenu.addAction(\
+QApplication.translate('ViewManager', '&Edit...'), self.__editBookmarked)
+self.bookmarkedMenu.addAction(\
+QApplication.translate('ViewManager', '&Clear'), self.__clearBookmarked)
+def __addBookmarked(self):
+"""
+Private method to add the current file to the list of bookmarked files.
+"""
+an = self.getActiveName()
+if an is not None and an not in self.bookmarked:
+self.bookmarked.append(an)
+def __editBookmarked(self):
+"""
+Private method to edit the list of bookmarked files.
+"""
+dlg = BookmarkedFilesDialog(self.bookmarked, self.ui)
+if dlg.exec_() == QDialog.Accepted:
+self.bookmarked = dlg.getBookmarkedFiles()
+def __clearBookmarked(self):
+"""
+Private method to clear the bookmarked files menu.
+"""
+self.bookmarked = []
+def newProject(self):
+"""
+Public slot to handle the NewProject signal.
+"""
+self.saveToProjectAct.setEnabled(True)
+def projectOpened(self):
+"""
+Public slot to handle the projectOpened signal.
+"""
+self.saveToProjectAct.setEnabled(True)
+for editor in self.editors:
+editor.setSpellingForProject()
+def projectClosed(self):
+"""
+Public slot to handle the projectClosed signal.
+"""
+self.saveToProjectAct.setEnabled(False)
+def projectFileRenamed(self, oldfn, newfn):
+"""
+Public slot to handle the projectFileRenamed signal.
+@param oldfn old filename of the file (string)
+@param newfn new filename of the file (string)
+"""
+editor = self.getOpenEditor(oldfn)
+if editor:
+editor.fileRenamed(newfn)
+def projectLexerAssociationsChanged(self):
+"""
+Public slot to handle changes of the project lexer associations.
+"""
+for editor in self.editors:
+editor.projectLexerAssociationsChanged()
+def enableEditorsCheckFocusIn(self, enabled):
+"""
+Public method to set a flag enabling the editors to perform focus in checks.
+@param enabled flag indicating focus in checks should be performed (boolean)
+"""
+self.editorsCheckFocusIn = enabled
+def editorsCheckFocusInEnabled(self):
+"""
+Public method returning the flag indicating editors should perform
+focus in checks.
+@return flag indicating focus in checks should be performed (boolean)
+"""
+return self.editorsCheckFocusIn
+def __findFileName(self):
+"""
+Private method to handle the search for file action.
+"""
+self.ui.findFileNameDialog.show()
+self.ui.findFileNameDialog.raise_()
+self.ui.findFileNameDialog.activateWindow()
+##################################################################
+## Below are the action methods for the edit menu
+##################################################################
+def __editUndo(self):
+"""
+Private method to handle the undo action.
+"""
+self.activeWindow().undo()
+def __editRedo(self):
+"""
+Private method to handle the redo action.
+"""
+self.activeWindow().redo()
+def __editRevert(self):
+"""
+Private method to handle the revert action.
+"""
+self.activeWindow().revertToUnmodified()
+def __editCut(self):
+"""
+Private method to handle the cut action.
+"""
+if QApplication.focusWidget() == e4App().getObject("Shell"):
+e4App().getObject("Shell").cut()
+elif QApplication.focusWidget() == e4App().getObject("Terminal"):
+e4App().getObject("Terminal").cut()
+else:
+self.activeWindow().cut()
+def __editCopy(self):
+"""
+Private method to handle the copy action.
+"""
+if QApplication.focusWidget() == e4App().getObject("Shell"):
+e4App().getObject("Shell").copy()
+elif QApplication.focusWidget() == e4App().getObject("Terminal"):
+e4App().getObject("Terminal").copy()
+else:
+self.activeWindow().copy()
+def __editPaste(self):
+"""
+Private method to handle the paste action.
+"""
+if QApplication.focusWidget() == e4App().getObject("Shell"):
+e4App().getObject("Shell").paste()
+elif QApplication.focusWidget() == e4App().getObject("Terminal"):
+e4App().getObject("Terminal").paste()
+else:
+self.activeWindow().paste()
+def __editDelete(self):
+"""
+Private method to handle the delete action.
+"""
+if QApplication.focusWidget() == e4App().getObject("Shell"):
+e4App().getObject("Shell").clear()
+elif QApplication.focusWidget() == e4App().getObject("Terminal"):
+e4App().getObject("Terminal").clear()
+else:
+self.activeWindow().clear()
+def __editIndent(self):
+"""
+Private method to handle the indent action.
+"""
+self.activeWindow().indentLineOrSelection()
+def __editUnindent(self):
+"""
+Private method to handle the unindent action.
+"""
+self.activeWindow().unindentLineOrSelection()
+def __editSmartIndent(self):
+"""
+Private method to handle the smart indent action
+"""
+self.activeWindow().smartIndentLineOrSelection()
+def __editComment(self):
+"""
+Private method to handle the comment action.
+"""
+self.activeWindow().commentLineOrSelection()
+def __editUncomment(self):
+"""
+Private method to handle the uncomment action.
+"""
+self.activeWindow().uncommentLineOrSelection()
+def __editStreamComment(self):
+"""
+Private method to handle the stream comment action.
+"""
+self.activeWindow().streamCommentLineOrSelection()
+def __editBoxComment(self):
+"""
+Private method to handle the box comment action.
+"""
+self.activeWindow().boxCommentLineOrSelection()
+def __editSelectBrace(self):
+"""
+Private method to handle the select to brace action.
+"""
+self.activeWindow().selectToMatchingBrace()
+def __editSelectAll(self):
+"""
+Private method to handle the select all action.
+"""
+self.activeWindow().selectAll(True)
+def __editDeselectAll(self):
+"""
+Private method to handle the select all action.
+"""
+self.activeWindow().selectAll(False)
+def __convertEOL(self):
+"""
+Private method to handle the convert line end characters action.
+"""
+aw = self.activeWindow()
+aw.convertEols(aw.eolMode())
+def __shortenEmptyLines(self):
+"""
+Private method to handle the shorten empty lines action.
+"""
+self.activeWindow().shortenEmptyLines()
+def __editAutoComplete(self):
+"""
+Private method to handle the autocomplete action.
+"""
+self.activeWindow().autoComplete()
+def __editAutoCompleteFromDoc(self):
+"""
+Private method to handle the autocomplete from document action.
+"""
+self.activeWindow().autoCompleteFromDocument()
+def __editAutoCompleteFromAPIs(self):
+"""
+Private method to handle the autocomplete from APIs action.
+"""
+self.activeWindow().autoCompleteFromAPIs()
+def __editAutoCompleteFromAll(self):
+"""
+Private method to handle the autocomplete from All action.
+"""
+self.activeWindow().autoCompleteFromAll()
+def __editorAutoCompletionAPIsAvailable(self, available):
+"""
+Private method to handle the availability of API autocompletion signal.
+"""
+self.autoCompleteFromAPIsAct.setEnabled(available)
+def __editShowCallTips(self):
+"""
+Private method to handle the calltips action.
+"""
+self.activeWindow().callTip()
+##################################################################
+## Below are the action and utility methods for the search menu
+##################################################################
+def textForFind(self, getCurrentWord = True):
+"""
+Public method to determine the selection or the current word for the next
+find operation.
+@param getCurrentWord flag indicating to return the current word, if no selected
+text was found (boolean)
+@return selection or current word (string)
+"""
+aw = self.activeWindow()
+if aw is None:
+return ""
+return aw.getSearchText(not getCurrentWord)
+def getSRHistory(self, key):
+"""
+Public method to get the search or replace history list.
+@param key list to return (must be 'search' or 'replace')
+@return the requested history list (list of strings)
+"""
+return self.srHistory[key]
+def __quickSearch(self):
+"""
+Private slot to handle the incremental quick search.
+"""
+# first we have to check if quick search is active
+# and try to activate it if not
+if not self.quickFindtextCombo.lineEdit().hasFocus():
+aw = self.activeWindow()
+self.quickFindtextCombo.lastActive = aw
+if aw:
+self.quickFindtextCombo.lastCursorPos = aw.getCursorPosition()
+else:
+self.quickFindtextCombo.lastCursorPos = None
+tff = self.textForFind(False)
+if tff:
+self.quickFindtextCombo.lineEdit().setText(tff)
+self.quickFindtextCombo.lineEdit().setFocus()
+self.quickFindtextCombo.lineEdit().selectAll()
+else:
+self.__quickSearchInEditor(True, False)
+def __quickSearchFocusIn(self):
+"""
+Private method to handle a focus in signal of the quicksearch lineedit.
+"""
+self.quickFindtextCombo.lastActive = self.activeWindow()
+def __quickSearchEnter(self):
+"""
+Private slot to handle the incremental quick search return pressed
+(jump back to text)
+"""
+if self.quickFindtextCombo.lastActive:
+self.quickFindtextCombo.lastActive.setFocus()
+def __quickSearchEscape(self):
+"""
+Private slot to handle the incremental quick search escape pressed
+(jump back to text)
+"""
+if self.quickFindtextCombo.lastActive:
+self.quickFindtextCombo.lastActive.setFocus()
+aw = self.activeWindow()
+if aw and self.quickFindtextCombo.lastCursorPos:
+aw.setCursorPosition(self.quickFindtextCombo.lastCursorPos[0],
+self.quickFindtextCombo.lastCursorPos[1])
+def __quickSearchText(self):
+"""
+Private slot to handle the textChanged signal of the quicksearch edit.
+"""
+self.__quickSearchInEditor(False, False)
+def __quickSearchPrev(self):
+"""
+Private slot to handle the quickFindPrev toolbutton action.
+"""
+self.__quickSearchInEditor(True, True)
+def __quickSearchMarkOccurrences(self, txt):
+"""
+Private method to mark all occurrences of the search text.
+@param txt text to search for (string)
+"""
+aw = self.activeWindow()
+lineFrom = 0
+indexFrom = 0
+lineTo = -1
+indexTo = -1
+aw.clearSearchIndicators()
+ok = aw.findFirstTarget(txt, False, False, False,
+lineFrom, indexFrom, lineTo, indexTo)
+while ok:
+tgtPos, tgtLen = aw.getFoundTarget()
+try:
+aw.setSearchIndicator(tgtPos, tgtLen)
+except AttributeError:
+self.viewmanager.setSearchIndicator(tgtPos, tgtLen)
+ok = aw.findNextTarget()
+def __quickSearchInEditor(self, again, back):
+"""
+Private slot to perform a quick search.
+@param again flag indicating a repeat of the last search (boolean)
+@param back flag indicating a backwards search operation (boolean)
+"""
+aw = self.activeWindow()
+if not aw:
+return
+text = self.quickFindtextCombo.lineEdit().text()
+if not text:
+text = self.quickFindtextCombo.lastSearchText
+if not text:
+if Preferences.getEditor("QuickSearchMarkersEnabled"):
+aw.clearSearchIndicators()
+return
+else:
+self.quickFindtextCombo.lastSearchText = text
+if Preferences.getEditor("QuickSearchMarkersEnabled"):
+self.__quickSearchMarkOccurrences(text)
+lineFrom, indexFrom, lineTo, indexTo = aw.getSelection()
+cline, cindex = aw.getCursorPosition ()
+if again:
+if back:
+if indexFrom != 0:
+index = indexFrom - 1
+line = lineFrom
+elif lineFrom == 0:
+return
+else:
+line = lineFrom - 1
+index = aw.lineLength(line)
+ok = aw.findFirst(text, False, False, False, True, False, line, index)
+else:
+ok = aw.findFirst(text, False, False, False, True, not back,
+cline, cindex)
+else:
+ok = aw.findFirst(text, False, False, False, True, not back,
+lineFrom, indexFrom)
+if not ok:
+palette = self.quickFindtextCombo.lineEdit().palette()
+palette.setColor(QPalette.Base, QColor("red"))
+palette.setColor(QPalette.Text, QColor("white"))
+self.quickFindtextCombo.lineEdit().setPalette(palette)
+else:
+palette = self.quickFindtextCombo.lineEdit().palette()
+palette.setColor(QPalette.Base,
+self.quickFindtextCombo.palette().color(QPalette.Base))
+palette.setColor(QPalette.Text,
+self.quickFindtextCombo.palette().color(QPalette.Text))
+self.quickFindtextCombo.lineEdit().setPalette(palette)
+def __quickSearchExtend(self):
+"""
+Private method to handle the quicksearch extend action.
+"""
+aw = self.activeWindow()
+if aw is None:
+return
+txt = self.quickFindtextCombo.lineEdit().text()
+if not txt:
+return
+line, index = aw.getCursorPosition()
+text = aw.text(line)
+re = QRegExp('[^\w_]')
+end = re.indexIn(text, index)
+if end > index:
+ext = text[index:end + 1]
+txt += ext
+self.quickFindtextCombo.lineEdit().setText(txt)
+def __search(self):
+"""
+Private method to handle the search action.
+"""
+self.replaceDlg.close()
+self.searchDlg.show(self.textForFind())
+def __replace(self):
+"""
+Private method to handle the replace action.
+"""
+self.searchDlg.close()
+self.replaceDlg.show(self.textForFind())
+def __searchClearMarkers(self):
+"""
+Private method to clear the search markers of the active window.
+"""
+self.activeWindow().clearSearchIndicators()
+def __goto(self):
+"""
+Private method to handle the goto action.
+"""
+aw = self.activeWindow()
+dlg = GotoDialog(aw.lines(), self.ui, None, True)
+if dlg.exec_() == QDialog.Accepted:
+aw.gotoLine(dlg.getLinenumber())
+def __gotoBrace(self):
+"""
+Private method to handle the goto brace action.
+"""
+self.activeWindow().moveToMatchingBrace()
+def __searchFiles(self):
+"""
+Private method to handle the search in files action.
+"""
+self.ui.findFilesDialog.show(self.textForFind())
+self.ui.findFilesDialog.raise_()
+self.ui.findFilesDialog.activateWindow()
+def __replaceFiles(self):
+"""
+Private method to handle the replace in files action.
+"""
+self.ui.replaceFilesDialog.show(self.textForFind())
+self.ui.replaceFilesDialog.raise_()
+self.ui.replaceFilesDialog.activateWindow()
+##################################################################
+## Below are the action methods for the view menu
+##################################################################
+def __zoomIn(self):
+"""
+Private method to handle the zoom in action.
+"""
+if QApplication.focusWidget() == e4App().getObject("Shell"):
+e4App().getObject("Shell").zoomIn()
+elif QApplication.focusWidget() == e4App().getObject("Terminal"):
+e4App().getObject("Terminal").zoomIn()
+else:
+aw = self.activeWindow()
+if aw:
+aw.zoomIn()
+def __zoomOut(self):
+"""
+Private method to handle the zoom out action.
+"""
+if QApplication.focusWidget() == e4App().getObject("Shell"):
+e4App().getObject("Shell").zoomOut()
+elif QApplication.focusWidget() == e4App().getObject("Terminal"):
+e4App().getObject("Terminal").zoomOut()
+else:
+aw = self.activeWindow()
+if aw:
+aw.zoomOut()
+def __zoom(self):
+"""
+Private method to handle the zoom action.
+"""
+if QApplication.focusWidget() == e4App().getObject("Shell"):
+aw = e4App().getObject("Shell")
+elif QApplication.focusWidget() == e4App().getObject("Terminal"):
+aw = e4App().getObject("Terminal")
+else:
+aw = self.activeWindow()
+if aw:
+dlg = ZoomDialog(aw.getZoom(), self.ui, None, True)
+if dlg.exec_() == QDialog.Accepted:
+aw.zoomTo(dlg.getZoomSize())
+def __toggleAll(self):
+"""
+Private method to handle the toggle all folds action.
+"""
+aw = self.activeWindow()
+if aw:
+aw.foldAll()
+def __toggleAllChildren(self):
+"""
+Private method to handle the toggle all folds (including children) action.
+"""
+aw = self.activeWindow()
+if aw:
+aw.foldAll(True)
+def __toggleCurrent(self):
+"""
+Private method to handle the toggle current fold action.
+"""
+aw = self.activeWindow()
+if aw:
+line, index = aw.getCursorPosition()
+aw.foldLine(line)
+def __splitView(self):
+"""
+Private method to handle the split view action.
+"""
+self.addSplit()
+def __splitOrientation(self, checked):
+"""
+Private method to handle the split orientation action.
+"""
+if checked:
+self.setSplitOrientation(Qt.Horizontal)
+self.splitViewAct.setIcon(\
+UI.PixmapCache.getIcon("splitHorizontal.png"))
+self.splitRemoveAct.setIcon(\
+UI.PixmapCache.getIcon("remsplitHorizontal.png"))
+else:
+self.setSplitOrientation(Qt.Vertical)
+self.splitViewAct.setIcon(\
+UI.PixmapCache.getIcon("splitVertical.png"))
+self.splitRemoveAct.setIcon(\
+UI.PixmapCache.getIcon("remsplitVertical.png"))
+##################################################################
+## Below are the action methods for the macro menu
+##################################################################
+def __macroStartRecording(self):
+"""
+Private method to handle the start macro recording action.
+"""
+self.activeWindow().macroRecordingStart()
+def __macroStopRecording(self):
+"""
+Private method to handle the stop macro recording action.
+"""
+self.activeWindow().macroRecordingStop()
+def __macroRun(self):
+"""
+Private method to handle the run macro action.
+"""
+self.activeWindow().macroRun()
+def __macroDelete(self):
+"""
+Private method to handle the delete macro action.
+"""
+self.activeWindow().macroDelete()
+def __macroLoad(self):
+"""
+Private method to handle the load macro action.
+"""
+self.activeWindow().macroLoad()
+def __macroSave(self):
+"""
+Private method to handle the save macro action.
+"""
+self.activeWindow().macroSave()
+##################################################################
+## Below are the action methods for the bookmarks menu
+##################################################################
+def __toggleBookmark(self):
+"""
+Private method to handle the toggle bookmark action.
+"""
+self.activeWindow().menuToggleBookmark()
+def __nextBookmark(self):
+"""
+Private method to handle the next bookmark action.
+"""
+self.activeWindow().nextBookmark()
+def __previousBookmark(self):
+"""
+Private method to handle the previous bookmark action.
+"""
+self.activeWindow().previousBookmark()
+def __clearAllBookmarks(self):
+"""
+Private method to handle the clear all bookmarks action.
+"""
+for editor in self.editors:
+editor.clearBookmarks()
+self.bookmarkNextAct.setEnabled(False)
+self.bookmarkPreviousAct.setEnabled(False)
+self.bookmarkClearAct.setEnabled(False)
+def __showBookmarkMenu(self):
+"""
+Private method to set up the bookmark menu.
+"""
+bookmarksFound = 0
+filenames = self.getOpenFilenames()
+for filename in filenames:
+editor = self.getOpenEditor(filename)
+bookmarksFound = len(editor.getBookmarks()) > 0
+if bookmarksFound:
+self.menuBookmarksAct.setEnabled(True)
+return
+self.menuBookmarksAct.setEnabled(False)
+def __showBookmarksMenu(self):
+"""
+Private method to handle the show bookmarks menu signal.
+"""
+self.bookmarksMenu.clear()
+filenames = self.getOpenFilenames()
+for filename in sorted(filenames):
+editor = self.getOpenEditor(filename)
+for bookmark in editor.getBookmarks():
+bmSuffix = " : %d" % bookmark
+act = self.bookmarksMenu.addAction(
+"%s%s" % (
+Utilities.compactPath(
+filename,
+self.ui.maxMenuFilePathLen - len(bmSuffix)),
+bmSuffix))
+act.setData(QVariant([QVariant(filename), QVariant(bookmark)]))
+def __bookmarkSelected(self, act):
+"""
+Private method to handle the bookmark selected signal.
+@param act reference to the action that triggered (QAction)
+"""
+try:
+qvList = act.data().toPyObject()
+filename = qvList[0]
+line = qvList[1]
+except AttributeError:
+qvList = act.data().toList()
+filename = qvList[0].toString()
+line = qvList[1].toInt()[0]
+self.openSourceFile(filename, line)
+def __bookmarkToggled(self, editor):
+"""
+Private slot to handle the bookmarkToggled signal.
+It checks some bookmark actions and reemits the signal.
+@param editor editor that sent the signal
+"""
+if editor.hasBookmarks():
+self.bookmarkNextAct.setEnabled(True)
+self.bookmarkPreviousAct.setEnabled(True)
+self.bookmarkClearAct.setEnabled(True)
+else:
+self.bookmarkNextAct.setEnabled(False)
+self.bookmarkPreviousAct.setEnabled(False)
+self.bookmarkClearAct.setEnabled(False)
+self.emit(SIGNAL('bookmarkToggled'), editor)
+def __gotoSyntaxError(self):
+"""
+Private method to handle the goto syntax error action.
+"""
+self.activeWindow().gotoSyntaxError()
+def __clearAllSyntaxErrors(self):
+"""
+Private method to handle the clear all syntax errors action.
+"""
+for editor in self.editors:
+editor.clearSyntaxError()
+def _syntaxErrorToggled(self, editor):
+"""
+Protected slot to handle the syntaxerrorToggled signal.
+It checks some syntax error actions and reemits the signal.
+@param editor editor that sent the signal
+"""
+if editor.hasSyntaxErrors():
+self.syntaxErrorGotoAct.setEnabled(True)
+self.syntaxErrorClearAct.setEnabled(True)
+else:
+self.syntaxErrorGotoAct.setEnabled(False)
+self.syntaxErrorClearAct.setEnabled(False)
+self.emit(SIGNAL('syntaxerrorToggled'), editor)
+def __nextUncovered(self):
+"""
+Private method to handle the next uncovered action.
+"""
+self.activeWindow().nextUncovered()
+def __previousUncovered(self):
+"""
+Private method to handle the previous uncovered action.
+"""
+self.activeWindow().previousUncovered()
+def __coverageMarkersShown(self, shown):
+"""
+Private slot to handle the coverageMarkersShown signal.
+@param shown flag indicating whether the markers were shown or cleared
+"""
+if shown:
+self.notcoveredNextAct.setEnabled(True)
+self.notcoveredPreviousAct.setEnabled(True)
+else:
+self.notcoveredNextAct.setEnabled(False)
+self.notcoveredPreviousAct.setEnabled(False)
+def __taskMarkersUpdated(self, editor):
+"""
+Protected slot to handle the syntaxerrorToggled signal.
+It checks some syntax error actions and reemits the signal.
+@param editor editor that sent the signal
+"""
+if editor.hasTaskMarkers():
+self.taskNextAct.setEnabled(True)
+self.taskPreviousAct.setEnabled(True)
+else:
+self.taskNextAct.setEnabled(False)
+self.taskPreviousAct.setEnabled(False)
+def __nextTask(self):
+"""
+Private method to handle the next task action.
+"""
+self.activeWindow().nextTask()
+def __previousTask(self):
+"""
+Private method to handle the previous task action.
+"""
+self.activeWindow().previousTask()
+##################################################################
+## Below are the action methods for the spell checking functions
+##################################################################
+def __setAutoSpellChecking(self):
+"""
+Private slot to set the automatic spell checking of all editors.
+"""
+enabled = self.autoSpellCheckAct.isChecked()
+Preferences.setEditor("AutoSpellCheckingEnabled", int(enabled))
+for editor in self.editors:
+editor.setAutoSpellChecking()
+def __spellCheck(self):
+"""
+Private slot to perform a spell check of the current editor.
+"""
+aw = self.activeWindow()
+if aw:
+aw.checkSpelling()
+##################################################################
+## Below are general utility methods
+##################################################################
+def handleResetUI(self):
+"""
+Public slot to handle the resetUI signal.
+"""
+editor = self.activeWindow()
+if editor is None:
+self.__setSbFile()
+else:
+line, pos = editor.getCursorPosition()
+enc = editor.getEncoding()
+lang = editor.getLanguage()
+eol = editor.getEolIndicator()
+self.__setSbFile(editor.getFileName(), line + 1, pos, enc, lang, eol)
+def closeViewManager(self):
+"""
+Public method to shutdown the viewmanager.
+If it cannot close all editor windows, it aborts the shutdown process.
+@return flag indicating success (boolean)
+"""
+self.closeAllWindows()
+# save the list of recently opened projects
+self.__saveRecent()
+# save the list of recently opened projects
+Preferences.Prefs.settings.setValue('Bookmarked/Sources',
+QVariant(self.bookmarked))
+if len(self.editors):
+return False
+else:
+return True
+def __lastEditorClosed(self):
+"""
+Private slot to handle the lastEditorClosed signal.
+"""
+self.closeActGrp.setEnabled(False)
+self.saveActGrp.setEnabled(False)
+self.exportersMenuAct.setEnabled(False)
+self.printAct.setEnabled(False)
+if self.printPreviewAct:
+self.printPreviewAct.setEnabled(False)
+self.editActGrp.setEnabled(False)
+self.searchActGrp.setEnabled(False)
+self.quickFindtextCombo.setEnabled(False)
+self.viewActGrp.setEnabled(False)
+self.viewFoldActGrp.setEnabled(False)
+self.unhighlightAct.setEnabled(False)
+self.splitViewAct.setEnabled(False)
+self.splitOrientationAct.setEnabled(False)
+self.macroActGrp.setEnabled(False)
+self.bookmarkActGrp.setEnabled(False)
+self.__enableSpellingActions()
+self.__setSbFile()
+# remove all split views, if this is supported
+if self.canSplit():
+while self.removeSplit(): pass
+# stop the autosave timer
+if self.autosaveTimer.isActive():
+self.autosaveTimer.stop()
+def __editorOpened(self):
+"""
+Private slot to handle the editorOpened signal.
+"""
+self.closeActGrp.setEnabled(True)
+self.saveActGrp.setEnabled(True)
+self.exportersMenuAct.setEnabled(True)
+self.printAct.setEnabled(True)
+if self.printPreviewAct:
+self.printPreviewAct.setEnabled(True)
+self.editActGrp.setEnabled(True)
+self.searchActGrp.setEnabled(True)
+self.quickFindtextCombo.setEnabled(True)
+self.viewActGrp.setEnabled(True)
+self.viewFoldActGrp.setEnabled(True)
+self.unhighlightAct.setEnabled(True)
+if self.canSplit():
+self.splitViewAct.setEnabled(True)
+self.splitOrientationAct.setEnabled(True)
+self.macroActGrp.setEnabled(True)
+self.bookmarkActGrp.setEnabled(True)
+self.__enableSpellingActions()
+# activate the autosave timer
+if not self.autosaveTimer.isActive() and \
+self.autosaveInterval > 0:
+self.autosaveTimer.start(self.autosaveInterval * 60000)
+def __autosave(self):
+"""
+Private slot to save the contents of all editors automatically.
+Only named editors will be saved by the autosave timer.
+"""
+for editor in self.editors:
+if editor.shouldAutosave():
+ok, newName = editor.saveFile()
+if ok:
+self.setEditorName(editor, newName)
+# restart autosave timer
+if self.autosaveInterval > 0:
+self.autosaveTimer.start(self.autosaveInterval * 60000)
+def _checkActions(self, editor, setSb = True):
+"""
+Protected slot to check some actions for their enable/disable status
+and set the statusbar info.
+@param editor editor window
+@param setSb flag indicating an update of the status bar is wanted (boolean)
+"""
+if editor is not None:
+self.saveAct.setEnabled(editor.isModified())
+self.revertAct.setEnabled(editor.isModified())
+self.undoAct.setEnabled(editor.isUndoAvailable())
+self.redoAct.setEnabled(editor.isRedoAvailable())
+lex = editor.getLexer()
+if lex is not None:
+self.commentAct.setEnabled(lex.canBlockComment())
+self.uncommentAct.setEnabled(lex.canBlockComment())
+self.streamCommentAct.setEnabled(lex.canStreamComment())
+self.boxCommentAct.setEnabled(lex.canBoxComment())
+else:
+self.commentAct.setEnabled(False)
+self.uncommentAct.setEnabled(False)
+self.streamCommentAct.setEnabled(False)
+self.boxCommentAct.setEnabled(False)
+if editor.hasBookmarks():
+self.bookmarkNextAct.setEnabled(True)
+self.bookmarkPreviousAct.setEnabled(True)
+self.bookmarkClearAct.setEnabled(True)
+else:
+self.bookmarkNextAct.setEnabled(False)
+self.bookmarkPreviousAct.setEnabled(False)
+self.bookmarkClearAct.setEnabled(False)
+if editor.hasSyntaxErrors():
+self.syntaxErrorGotoAct.setEnabled(True)
+self.syntaxErrorClearAct.setEnabled(True)
+else:
+self.syntaxErrorGotoAct.setEnabled(False)
+self.syntaxErrorClearAct.setEnabled(False)
+if editor.hasCoverageMarkers():
+self.notcoveredNextAct.setEnabled(True)
+self.notcoveredPreviousAct.setEnabled(True)
+else:
+self.notcoveredNextAct.setEnabled(False)
+self.notcoveredPreviousAct.setEnabled(False)
+if editor.hasTaskMarkers():
+self.taskNextAct.setEnabled(True)
+self.taskPreviousAct.setEnabled(True)
+else:
+self.taskNextAct.setEnabled(False)
+self.taskPreviousAct.setEnabled(False)
+if editor.canAutoCompleteFromAPIs():
+self.autoCompleteFromAPIsAct.setEnabled(True)
+else:
+self.autoCompleteFromAPIsAct.setEnabled(False)
+if setSb:
+line, pos = editor.getCursorPosition()
+enc = editor.getEncoding()
+lang = editor.getLanguage()
+eol = editor.getEolIndicator()
+self.__setSbFile(editor.getFileName(), line + 1, pos, enc, lang, eol)
+self.emit(SIGNAL('checkActions'), editor)
+def preferencesChanged(self):
+"""
+Public slot to handle the preferencesChanged signal.
+This method performs the following actions
+<ul>
+<li>reread the colours for the syntax highlighting</li>
+<li>reloads the already created API objetcs</li>
+<li>starts or stops the autosave timer</li>
+<li><b>Note</b>: changes in viewmanager type are activated
+on an application restart.</li>
+</ul>
+"""
+# reload the APIs
+self.apisManager.reloadAPIs()
+# reload editor settings
+for editor in self.editors:
+editor.readSettings()
+# reload the autosave timer setting
+self.autosaveInterval = Preferences.getEditor("AutosaveInterval")
+if len(self.editors):
+if self.autosaveTimer.isActive() and \
+self.autosaveInterval == 0:
+self.autosaveTimer.stop()
+elif not self.autosaveTimer.isActive() and \
+self.autosaveInterval > 0:
+self.autosaveTimer.start(self.autosaveInterval * 60000)
+self.__enableSpellingActions()
+def __editorSaved(self, fn):
+"""
+Private slot to handle the editorSaved signal.
+It simply reemits the signal.
+@param fn filename of the saved editor
+"""
+self.emit(SIGNAL('editorSaved'), fn)
+def __cursorChanged(self, fn, line, pos):
+"""
+Private slot to handle the cursorChanged signal.
+It emits the signal cursorChanged with parameter editor.
+@param fn filename (string)
+@param line line number of the cursor (int)
+@param pos position in line of the cursor (int)
+"""
+editor = self.getOpenEditor(fn)
+if editor is None:
+editor = self.sender()
+if editor is not None:
+enc = editor.getEncoding()
+lang = editor.getLanguage()
+eol = editor.getEolIndicator()
+else:
+enc = None
+lang = None
+eol = None
+self.__setSbFile(fn, line, pos, enc, lang, eol)
+self.emit(SIGNAL('cursorChanged'), editor)
+def __breakpointToggled(self, editor):
+"""
+Private slot to handle the breakpointToggled signal.
+It simply reemits the signal.
+@param editor editor that sent the signal
+"""
+self.emit(SIGNAL('breakpointToggled'), editor)
+def getActions(self, type):
+"""
+Public method to get a list of all actions.
+@param type string denoting the action set to get.
+It must be one of "edit", "file", "search",
+"view", "window", "macro" or "bookmark"
+@return list of all actions (list of E4Action)
+"""
+try:
+exec 'actionList = self.%sActions[:]' % type
+except AttributeError:
+actionList = []
+return actionList
+def __editorCommand(self, cmd):
+"""
+Private method to send an editor command to the active window.
+@param cmd the scintilla command to be sent
+"""
+focusWidget = QApplication.focusWidget()
+if focusWidget == e4App().getObject("Shell"):
+e4App().getObject("Shell").editorCommand(cmd)
+elif focusWidget == e4App().getObject("Terminal"):
+e4App().getObject("Terminal").editorCommand(cmd)
+elif focusWidget == self.quickFindtextCombo:
+self.quickFindtextCombo._editor.editorCommand(cmd)
+else:
+aw = self.activeWindow()
+if aw:
+aw.editorCommand(cmd)
+def __newLineBelow(self):
+"""
+Private method to insert a new line below the current one even if
+cursor is not at the end of the line.
+"""
+focusWidget = QApplication.focusWidget()
+if focusWidget == e4App().getObject("Shell") or \
+focusWidget == e4App().getObject("Terminal") or \
+focusWidget == self.quickFindtextCombo:
+return
+else:
+aw = self.activeWindow()
+if aw:
+aw.newLineBelow()
+def __editorConfigChanged(self):
+"""
+Private method to handle changes of an editors configuration (e.g. language).
+"""
+editor = self.sender()
+fn = editor.getFileName()
+line, pos = editor.getCursorPosition()
+enc = editor.getEncoding()
+lang = editor.getLanguage()
+eol = editor.getEolIndicator()
+self.__setSbFile(fn, line + 1, pos, encoding = enc, language = lang, eol = eol)
+##################################################################
+## Below are protected utility methods
+##################################################################
+def _getOpenStartDir(self):
+"""
+Protected method to return the starting directory for a file open dialog.
+The appropriate starting directory is calculated
+using the following search order, until a match is found:<br />
+1: Directory of currently active editor<br />
+2: Directory of currently active Project<br />
+3: CWD
+@return name of directory to start (string)
+"""
+# if we have an active source, return its path
+if self.activeWindow() is not None and \
+self.activeWindow().getFileName():
+return os.path.dirname(self.activeWindow().getFileName())
+# check, if there is an active project and return its path
+elif e4App().getObject("Project").isOpen():
+return e4App().getObject("Project").ppath
+else:
+# None will cause open dialog to start with cwd
+return ""
+def _getOpenFileFilter(self):
+"""
+Protected method to return the active filename filter for a file open dialog.
+The appropriate filename filter is determined by file extension of
+the currently active editor.
+@return name of the filename filter (string) or None
+"""
+if self.activeWindow() is not None and \
+self.activeWindow().getFileName():
+ext = os.path.splitext(self.activeWindow().getFileName())[1]
+rx = QRegExp(".*\*\.%s[ )].*" % ext[1:])
+filters = QScintilla.Lexers.getOpenFileFiltersList()
+index = -1
+for i in range(len(filters)):
+if rx.exactMatch(filters[i]):
+index = i
+break
+if index == -1:
+return Preferences.getEditor("DefaultOpenFilter")
+else:
+return filters[index]
+else:
+return Preferences.getEditor("DefaultOpenFilter")
+##################################################################
+## Below are API handling methods
+##################################################################
+def getAPIsManager(self):
+"""
+Public method to get a reference to the APIs manager.
+@return the APIs manager object (eric4.QScintilla.APIsManager)
+"""
+return self.apisManager

Mercurial Repositories > eric / file comparison

comparison: ViewManager/ViewManager.py

ViewManager/ViewManager.py