eric: QScintilla/MiniEditor.py@5ecba04d31f2 (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2007 - 2018 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing a minimalistic editor for simple editing tasks.
 """
 from __future__ import unicode_literals
 import os
 import re
 from PyQt5.QtCore import QSignalMapper, QPoint, QTimer, QFileInfo, \
     pyqtSignal, QSize, QRegExp, Qt, QCoreApplication
 from PyQt5.QtGui import QCursor, QKeySequence, QPalette, QFont
 from PyQt5.QtWidgets import QWidget, QWhatsThis, QActionGroup, QDialog, \
     QInputDialog, QApplication, QMenu, QVBoxLayout, QLabel
 from PyQt5.QtPrintSupport import QPrinter, QPrintDialog, QAbstractPrintDialog
 from PyQt5.Qsci import QsciScintilla
 from E5Gui.E5Action import E5Action, createActionGroup
 from E5Gui import E5MessageBox, E5FileDialog
 from E5Gui.E5MainWindow import E5MainWindow
 from .QsciScintillaCompat import QsciScintillaCompat
 import UI.PixmapCache
 import UI.Config
 from Globals import isMacPlatform
 import Utilities
 import Preferences
 from ThirdParty.EditorConfig import editorconfig
 class MiniScintilla(QsciScintillaCompat):
     """
     Class implementing a QsciScintillaCompat subclass for handling focus
     events.
     """
     def __init__(self, parent=None):
         """
         Constructor
         @param parent parent widget (QWidget)
         """
         super(MiniScintilla, self).__init__(parent)
         self.mw = parent
     def getFileName(self):
         """
         Public method to return the name of the file being displayed.
         @return filename of the displayed file (string)
         """
         return self.mw.getFileName()
     def focusInEvent(self, event):
         """
         Protected method called when the editor receives focus.
         This method checks for modifications of the current file and
         rereads it upon request. The cursor is placed at the current position
         assuming, that it is in the vicinity of the old position after the
         reread.
         @param event the event object (QFocusEvent)
         """
         self.mw.editorActGrp.setEnabled(True)
         try:
             self.setCaretWidth(self.mw.caretWidth)
         except AttributeError:
             pass
         self.setCursorFlashTime(QApplication.cursorFlashTime())
         super(MiniScintilla, self).focusInEvent(event)
     def focusOutEvent(self, event):
         """
         Protected method called when the editor loses focus.
         @param event the event object (QFocusEvent)
         """
         self.mw.editorActGrp.setEnabled(False)
         self.setCaretWidth(0)
         super(MiniScintilla, self).focusOutEvent(event)
     def removeTrailingWhitespace(self):
         """
         Public method to remove trailing whitespace.
         """
         searchRE = r"[ \t]+$"    # whitespace at the end of a line
         ok = self.findFirstTarget(searchRE, True, False, False, 0, 0)
         self.beginUndoAction()
         while ok:
             self.replaceTarget("")
             ok = self.findNextTarget()
         self.endUndoAction()
 class MiniEditor(E5MainWindow):
     """
     Class implementing a minimalistic editor for simple editing tasks.
     @signal editorSaved() emitted after the file has been saved
     """
     editorSaved = pyqtSignal()
     def __init__(self, filename="", filetype="", parent=None, name=None):
         """
         Constructor
         @param filename name of the file to open (string)
         @param filetype type of the source file (string)
         @param parent reference to the parent widget (QWidget)
         @param name object name of the window (string)
         """
         super(MiniEditor, self).__init__(parent)
         if name is not None:
             self.setObjectName(name)
         self.setWindowIcon(UI.PixmapCache.getIcon("editor.png"))
         self.setStyle(Preferences.getUI("Style"),
                       Preferences.getUI("StyleSheet"))
         self.__textEdit = MiniScintilla(self)
         self.__textEdit.clearSearchIndicators = self.clearSearchIndicators
         self.__textEdit.setSearchIndicator = self.setSearchIndicator
         self.__textEdit.setUtf8(True)
         self.srHistory = {
             "search": [],
             "replace": []
         }
         from .SearchReplaceWidget import SearchReplaceWidget
         self.__searchWidget = SearchReplaceWidget(False, self, self)
         self.__replaceWidget = SearchReplaceWidget(True, self, self)
         centralWidget = QWidget()
         layout = QVBoxLayout()
         layout.setContentsMargins(1, 1, 1, 1)
         layout.addWidget(self.__textEdit)
         layout.addWidget(self.__searchWidget)
         layout.addWidget(self.__replaceWidget)
         centralWidget.setLayout(layout)
         self.setCentralWidget(centralWidget)
         self.__searchWidget.hide()
         self.__replaceWidget.hide()
         self.lexer_ = None
         self.apiLanguage = ""
         self.filetype = ""
         self.__curFile = filename
         self.__loadEditorConfig(filename)
         self.__createActions()
         self.__createMenus()
         self.__createToolBars()
         self.__createStatusBar()
         self.__setTextDisplay()
         self.__setMargins()
         self.__setEolMode()
         self.__readSettings()
         # clear QScintilla defined keyboard commands
         # we do our own handling through the view manager
         self.__textEdit.clearAlternateKeys()
         self.__textEdit.clearKeys()
         # initialise the mark occurrences timer
         self.__markOccurrencesTimer = QTimer(self)
         self.__markOccurrencesTimer.setSingleShot(True)
         self.__markOccurrencesTimer.setInterval(
             Preferences.getEditor("MarkOccurrencesTimeout"))
         self.__markOccurrencesTimer.timeout.connect(self.__markOccurrences)
         self.__markedText = ""
         self.__textEdit.textChanged.connect(self.__documentWasModified)
         self.__textEdit.modificationChanged.connect(self.__modificationChanged)
         self.__textEdit.cursorPositionChanged.connect(
             self.__cursorPositionChanged)
         self.__textEdit.linesChanged.connect(self.__resizeLinenoMargin)
         self.__textEdit.setContextMenuPolicy(Qt.CustomContextMenu)
         self.__textEdit.customContextMenuRequested.connect(
             self.__contextMenuRequested)
         self.__textEdit.selectionChanged.connect(
             lambda: self.__searchWidget.selectionChanged(self.__textEdit))
         self.__textEdit.selectionChanged.connect(
             lambda: self.__replaceWidget.selectionChanged(self.__textEdit))
         if filename:
             self.__loadFile(filename, filetype)
         else:
             self.__setCurrentFile("")
             self.encoding = self.__getEditorConfig("DefaultEncoding")
         self.__checkActions()
     def closeEvent(self, event):
         """
         Protected method to handle the close event.
         @param event close event (QCloseEvent)
         """
         if self.__maybeSave():
             self.__writeSettings()
             event.accept()
         else:
             event.ignore()
     def __newFile(self):
         """
         Private slot to create a new file.
         """
         if self.__maybeSave():
             self.__textEdit.clear()
             self.__setCurrentFile("")
         self.__checkActions()
     def __open(self):
         """
         Private slot to open a file.
         """
         if self.__maybeSave():
             fileName = E5FileDialog.getOpenFileName(self)
             if fileName:
                 self.__loadFile(fileName)
         self.__checkActions()
     def __save(self):
         """
         Private slot to save a file.
         @return flag indicating success (boolean)
         """
         if not self.__curFile:
             return self.__saveAs()
         else:
             return self.__saveFile(self.__curFile)
     def __saveAs(self):
         """
         Private slot to save a file with a new name.
         @return flag indicating success (boolean)
         """
         fileName = E5FileDialog.getSaveFileName(self)
         if not fileName:
             return False
         return self.__saveFile(fileName)
     def __saveCopy(self):
         """
         Private slot to save a copy of the file with a new name.
         """
         fileName = E5FileDialog.getSaveFileName(self)
         if not fileName:
             return
         self.__writeFile(fileName)
     def __about(self):
         """
         Private slot to show a little About message.
         """
         E5MessageBox.about(
             self,
             self.tr("About eric6 Mini Editor"),
             self.tr(
                 "The eric6 Mini Editor is an editor component"
                 " based on QScintilla. It may be used for simple"
                 " editing tasks, that don't need the power of"
                 " a full blown editor."))
     def __aboutQt(self):
         """
         Private slot to handle the About Qt dialog.
         """
         E5MessageBox.aboutQt(self, "eric6 Mini Editor")
     def __whatsThis(self):
         """
         Private slot called in to enter Whats This mode.
         """
         QWhatsThis.enterWhatsThisMode()
     def __documentWasModified(self):
         """
         Private slot to handle a change in the documents modification status.
         """
         self.setWindowModified(self.__textEdit.isModified())
     def __checkActions(self, setSb=True):
         """
         Private slot to check some actions for their enable/disable status
         and set the statusbar info.
         @param setSb flag indicating an update of the status bar is wanted
             (boolean)
         """
         self.saveAct.setEnabled(self.__textEdit.isModified())
         self.undoAct.setEnabled(self.__textEdit.isUndoAvailable())
         self.redoAct.setEnabled(self.__textEdit.isRedoAvailable())
         if setSb:
             line, pos = self.__textEdit.getCursorPosition()
             self.__setSbFile(line + 1, pos)
     def __setSbFile(self, line=None, pos=None):
         """
         Private method to set the file info in the status bar.
         @param line line number to display (int)
         @param pos character position to display (int)
         """
         if not self.__curFile:
             writ = '   '
         else:
             if QFileInfo(self.__curFile).isWritable():
                 writ = ' rw'
             else:
                 writ = ' ro'
         self.sbWritable.setText(writ)
         if line is None:
             line = ''
         self.sbLine.setText(self.tr('Line: {0:5}').format(line))
         if pos is None:
             pos = ''
         self.sbPos.setText(self.tr('Pos: {0:5}').format(pos))
     def __readShortcut(self, act, category):
         """
         Private function to read a single keyboard shortcut from the settings.
         @param act reference to the action object (E5Action)
         @param category category the action belongs to (string)
         """
         if act.objectName():
             accel = Preferences.Prefs.settings.value(
                 "Shortcuts/{0}/{1}/Accel".format(category, act.objectName()))
             if accel is not None:
                 act.setShortcut(QKeySequence(accel))
             accel = Preferences.Prefs.settings.value(
                 "Shortcuts/{0}/{1}/AltAccel".format(
                     category, act.objectName()))
             if accel is not None:
                 act.setAlternateShortcut(QKeySequence(accel), removeEmpty=True)
     def __createActions(self):
         """
         Private method to create the actions.
         """
         self.fileActions = []
         self.editActions = []
         self.helpActions = []
         self.searchActions = []
         self.__createFileActions()
         self.__createEditActions()
         self.__createHelpActions()
         self.__createSearchActions()
         # read the keyboard shortcuts and make them identical to the main
         # eric6 shortcuts
         for act in self.helpActions:
             self.__readShortcut(act, "General")
         for act in self.editActions:
             self.__readShortcut(act, "Edit")
         for act in self.fileActions:
             self.__readShortcut(act, "File")
         for act in self.searchActions:
             self.__readShortcut(act, "Search")
     def __createFileActions(self):
         """
         Private method to create the File actions.
         """
         self.newAct = E5Action(
             self.tr('New'),
             UI.PixmapCache.getIcon("new.png"),
             self.tr('&New'),
             QKeySequence(self.tr("Ctrl+N", "File|New")),
 , self, 'vm_file_new')
         self.newAct.setStatusTip(self.tr('Open an empty editor window'))
         self.newAct.setWhatsThis(self.tr(
             """<b>New</b>"""
             """<p>An empty editor window will be created.</p>"""
         ))
         self.newAct.triggered.connect(self.__newFile)
         self.fileActions.append(self.newAct)
         self.openAct = E5Action(
             self.tr('Open'),
             UI.PixmapCache.getIcon("open.png"),
             self.tr('&Open...'),
             QKeySequence(self.tr("Ctrl+O", "File|Open")),
 , self, 'vm_file_open')
         self.openAct.setStatusTip(self.tr('Open a file'))
         self.openAct.setWhatsThis(self.tr(
             """<b>Open a file</b>"""
             """<p>You will be asked for the name of a file to be opened.</p>"""
         ))
         self.openAct.triggered.connect(self.__open)
         self.fileActions.append(self.openAct)
         self.saveAct = E5Action(
             self.tr('Save'),
             UI.PixmapCache.getIcon("fileSave.png"),
             self.tr('&Save'),
             QKeySequence(self.tr("Ctrl+S", "File|Save")),
 , self, 'vm_file_save')
         self.saveAct.setStatusTip(self.tr('Save the current file'))
         self.saveAct.setWhatsThis(self.tr(
             """<b>Save File</b>"""
             """<p>Save the contents of current editor window.</p>"""
         ))
         self.saveAct.triggered.connect(self.__save)
         self.fileActions.append(self.saveAct)
         self.saveAsAct = E5Action(
             self.tr('Save as'),
             UI.PixmapCache.getIcon("fileSaveAs.png"),
             self.tr('Save &as...'),
             QKeySequence(self.tr("Shift+Ctrl+S", "File|Save As")),
 , self, 'vm_file_save_as')
         self.saveAsAct.setStatusTip(self.tr(
             'Save the current file to a new one'))
         self.saveAsAct.setWhatsThis(self.tr(
             """<b>Save File as</b>"""
             """<p>Save the contents of current editor window to a new file."""
             """ The file can be entered in a file selection dialog.</p>"""
         ))
         self.saveAsAct.triggered.connect(self.__saveAs)
         self.fileActions.append(self.saveAsAct)
         self.saveCopyAct = E5Action(
             self.tr('Save Copy'),
             UI.PixmapCache.getIcon("fileSaveCopy.png"),
             self.tr('Save &Copy...'),
 , 0, self, 'vm_file_save_copy')
         self.saveCopyAct.setStatusTip(self.tr(
             'Save a copy of the current file'))
         self.saveCopyAct.setWhatsThis(self.tr(
             """<b>Save Copy</b>"""
             """<p>Save a copy of the contents of current editor window."""
             """ The file can be entered in a file selection dialog.</p>"""
         ))
         self.saveCopyAct.triggered.connect(self.__saveCopy)
         self.fileActions.append(self.saveCopyAct)
         self.closeAct = E5Action(
             self.tr('Close'),
             UI.PixmapCache.getIcon("close.png"),
             self.tr('&Close'),
             QKeySequence(self.tr("Ctrl+W", "File|Close")),
 , self, 'vm_file_close')
         self.closeAct.setStatusTip(self.tr('Close the editor window'))
         self.closeAct.setWhatsThis(self.tr(
             """<b>Close Window</b>"""
             """<p>Close the current window.</p>"""
         ))
         self.closeAct.triggered.connect(self.close)
         self.fileActions.append(self.closeAct)
         self.printAct = E5Action(
             self.tr('Print'),
             UI.PixmapCache.getIcon("print.png"),
             self.tr('&Print'),
             QKeySequence(self.tr("Ctrl+P", "File|Print")),
 , self, 'vm_file_print')
         self.printAct.setStatusTip(self.tr('Print the current file'))
         self.printAct.setWhatsThis(self.tr(
             """<b>Print File</b>"""
             """<p>Print the contents of the current file.</p>"""
         ))
         self.printAct.triggered.connect(self.__printFile)
         self.fileActions.append(self.printAct)
         self.printPreviewAct = E5Action(
             self.tr('Print Preview'),
             UI.PixmapCache.getIcon("printPreview.png"),
             QCoreApplication.translate('ViewManager', 'Print Preview'),
 , 0, self, 'vm_file_print_preview')
         self.printPreviewAct.setStatusTip(self.tr(
             'Print preview of the current file'))
         self.printPreviewAct.setWhatsThis(self.tr(
             """<b>Print Preview</b>"""
             """<p>Print preview of the current file.</p>"""
         ))
         self.printPreviewAct.triggered.connect(self.__printPreviewFile)
         self.fileActions.append(self.printPreviewAct)
     def __createEditActions(self):
         """
         Private method to create the Edit actions.
         """
         self.undoAct = E5Action(
             self.tr('Undo'),
             UI.PixmapCache.getIcon("editUndo.png"),
             self.tr('&Undo'),
             QKeySequence(self.tr("Ctrl+Z", "Edit|Undo")),
             QKeySequence(self.tr("Alt+Backspace", "Edit|Undo")),
             self, 'vm_edit_undo')
         self.undoAct.setStatusTip(self.tr('Undo the last change'))
         self.undoAct.setWhatsThis(self.tr(
             """<b>Undo</b>"""
             """<p>Undo the last change done in the current editor.</p>"""
         ))
         self.undoAct.triggered.connect(self.__undo)
         self.editActions.append(self.undoAct)
         self.redoAct = E5Action(
             self.tr('Redo'),
             UI.PixmapCache.getIcon("editRedo.png"),
             self.tr('&Redo'),
             QKeySequence(self.tr("Ctrl+Shift+Z", "Edit|Redo")),
 , self, 'vm_edit_redo')
         self.redoAct.setStatusTip(self.tr('Redo the last change'))
         self.redoAct.setWhatsThis(self.tr(
             """<b>Redo</b>"""
             """<p>Redo the last change done in the current editor.</p>"""
         ))
         self.redoAct.triggered.connect(self.__redo)
         self.editActions.append(self.redoAct)
         self.cutAct = E5Action(
             self.tr('Cut'),
             UI.PixmapCache.getIcon("editCut.png"),
             self.tr('Cu&t'),
             QKeySequence(self.tr("Ctrl+X", "Edit|Cut")),
             QKeySequence(self.tr("Shift+Del", "Edit|Cut")),
             self, 'vm_edit_cut')
         self.cutAct.setStatusTip(self.tr('Cut the selection'))
         self.cutAct.setWhatsThis(self.tr(
             """<b>Cut</b>"""
             """<p>Cut the selected text of the current editor to the"""
             """ clipboard.</p>"""
         ))
         self.cutAct.triggered.connect(self.__textEdit.cut)
         self.editActions.append(self.cutAct)
         self.copyAct = E5Action(
             self.tr('Copy'),
             UI.PixmapCache.getIcon("editCopy.png"),
             self.tr('&Copy'),
             QKeySequence(self.tr("Ctrl+C", "Edit|Copy")),
             QKeySequence(self.tr("Ctrl+Ins", "Edit|Copy")),
             self, 'vm_edit_copy')
         self.copyAct.setStatusTip(self.tr('Copy the selection'))
         self.copyAct.setWhatsThis(self.tr(
             """<b>Copy</b>"""
             """<p>Copy the selected text of the current editor to the"""
             """ clipboard.</p>"""
         ))
         self.copyAct.triggered.connect(self.__textEdit.copy)
         self.editActions.append(self.copyAct)
         self.pasteAct = E5Action(
             self.tr('Paste'),
             UI.PixmapCache.getIcon("editPaste.png"),
             self.tr('&Paste'),
             QKeySequence(self.tr("Ctrl+V", "Edit|Paste")),
             QKeySequence(self.tr("Shift+Ins", "Edit|Paste")),
             self, 'vm_edit_paste')
         self.pasteAct.setStatusTip(self.tr(
             'Paste the last cut/copied text'))
         self.pasteAct.setWhatsThis(self.tr(
             """<b>Paste</b>"""
             """<p>Paste the last cut/copied text from the clipboard to"""
             """ the current editor.</p>"""
         ))
         self.pasteAct.triggered.connect(self.__textEdit.paste)
         self.editActions.append(self.pasteAct)
         self.deleteAct = E5Action(
             self.tr('Clear'),
             UI.PixmapCache.getIcon("editDelete.png"),
             self.tr('Cl&ear'),
             QKeySequence(self.tr("Alt+Shift+C", "Edit|Clear")),
 ,
             self, 'vm_edit_clear')
         self.deleteAct.setStatusTip(self.tr('Clear all text'))
         self.deleteAct.setWhatsThis(self.tr(
             """<b>Clear</b>"""
             """<p>Delete all text of the current editor.</p>"""
         ))
         self.deleteAct.triggered.connect(self.__textEdit.clear)
         self.editActions.append(self.deleteAct)
         self.cutAct.setEnabled(False)
         self.copyAct.setEnabled(False)
         self.__textEdit.copyAvailable.connect(self.cutAct.setEnabled)
         self.__textEdit.copyAvailable.connect(self.copyAct.setEnabled)
         ####################################################################
         ## Below follow the actions for QScintilla standard commands.
         ####################################################################
         self.esm = QSignalMapper(self)
         self.esm.mapped[int].connect(self.__textEdit.editorCommand)
         self.editorActGrp = createActionGroup(self)
         act = E5Action(
             QCoreApplication.translate('ViewManager',
                                        'Move left one character'),
             QCoreApplication.translate('ViewManager',
                                        'Move left one character'),
             QKeySequence(QCoreApplication.translate('ViewManager', 'Left')), 0,
             self.editorActGrp, 'vm_edit_move_left_char')
         self.esm.setMapping(act, QsciScintilla.SCI_CHARLEFT)
         if isMacPlatform():
             act.setAlternateShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+B')))
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager',
                                        'Move right one character'),
             QCoreApplication.translate('ViewManager',
                                        'Move right one character'),
             QKeySequence(QCoreApplication.translate('ViewManager', 'Right')),
 , self.editorActGrp, 'vm_edit_move_right_char')
         if isMacPlatform():
             act.setAlternateShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+F')))
         self.esm.setMapping(act, QsciScintilla.SCI_CHARRIGHT)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager', 'Move up one line'),
             QCoreApplication.translate('ViewManager', 'Move up one line'),
             QKeySequence(QCoreApplication.translate('ViewManager', 'Up')), 0,
             self.editorActGrp, 'vm_edit_move_up_line')
         if isMacPlatform():
             act.setAlternateShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+P')))
         self.esm.setMapping(act, QsciScintilla.SCI_LINEUP)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager', 'Move down one line'),
             QCoreApplication.translate('ViewManager', 'Move down one line'),
             QKeySequence(QCoreApplication.translate('ViewManager', 'Down')), 0,
             self.editorActGrp, 'vm_edit_move_down_line')
         if isMacPlatform():
             act.setAlternateShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+N')))
         self.esm.setMapping(act, QsciScintilla.SCI_LINEDOWN)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager',
                                        'Move left one word part'),
             QCoreApplication.translate('ViewManager',
                                        'Move left one word part'),
 , 0,
             self.editorActGrp, 'vm_edit_move_left_word_part')
         if not isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Alt+Left')))
         self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTLEFT)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager',
                                        'Move right one word part'),
             QCoreApplication.translate('ViewManager',
                                        'Move right one word part'),
 , 0,
             self.editorActGrp, 'vm_edit_move_right_word_part')
         if not isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Alt+Right')))
         self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTRIGHT)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager', 'Move left one word'),
             QCoreApplication.translate('ViewManager', 'Move left one word'),
 , 0,
             self.editorActGrp, 'vm_edit_move_left_word')
         if isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Alt+Left')))
         else:
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Ctrl+Left')))
         self.esm.setMapping(act, QsciScintilla.SCI_WORDLEFT)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager', 'Move right one word'),
             QCoreApplication.translate('ViewManager', 'Move right one word'),
 , 0,
             self.editorActGrp, 'vm_edit_move_right_word')
         if isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Alt+Right')))
         else:
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Ctrl+Right')))
         self.esm.setMapping(act, QsciScintilla.SCI_WORDRIGHT)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager',
                 'Move to first visible character in document line'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Move to first visible character in document line'),
 , 0,
             self.editorActGrp, 'vm_edit_move_first_visible_char')
         if not isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Home')))
         self.esm.setMapping(act, QsciScintilla.SCI_VCHOME)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager',
                 'Move to start of display line'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Move to start of display line'),
 , 0,
             self.editorActGrp, 'vm_edit_move_start_line')
         if isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Ctrl+Left')))
         else:
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Alt+Home')))
         self.esm.setMapping(act, QsciScintilla.SCI_HOMEDISPLAY)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager',
                 'Move to end of document line'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Move to end of document line'),
 , 0,
             self.editorActGrp, 'vm_edit_move_end_line')
         if isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+E')))
         else:
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'End')))
         self.esm.setMapping(act, QsciScintilla.SCI_LINEEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager',
                                        'Scroll view down one line'),
             QCoreApplication.translate('ViewManager',
                                        'Scroll view down one line'),
             QKeySequence(QCoreApplication.translate('ViewManager',
                                                     'Ctrl+Down')),
 , self.editorActGrp, 'vm_edit_scroll_down_line')
         self.esm.setMapping(act, QsciScintilla.SCI_LINESCROLLDOWN)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager',
                                        'Scroll view up one line'),
             QCoreApplication.translate('ViewManager',
                                        'Scroll view up one line'),
             QKeySequence(QCoreApplication.translate('ViewManager', 'Ctrl+Up')),
 , self.editorActGrp, 'vm_edit_scroll_up_line')
         self.esm.setMapping(act, QsciScintilla.SCI_LINESCROLLUP)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager', 'Move up one paragraph'),
             QCoreApplication.translate('ViewManager', 'Move up one paragraph'),
             QKeySequence(QCoreApplication.translate('ViewManager', 'Alt+Up')),
 , self.editorActGrp, 'vm_edit_move_up_para')
         self.esm.setMapping(act, QsciScintilla.SCI_PARAUP)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager',
                                        'Move down one paragraph'),
             QCoreApplication.translate('ViewManager',
                                        'Move down one paragraph'),
             QKeySequence(QCoreApplication.translate('ViewManager',
                                                     'Alt+Down')),
 , self.editorActGrp, 'vm_edit_move_down_para')
         self.esm.setMapping(act, QsciScintilla.SCI_PARADOWN)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager', 'Move up one page'),
             QCoreApplication.translate('ViewManager', 'Move up one page'),
             QKeySequence(QCoreApplication.translate('ViewManager', 'PgUp')), 0,
             self.editorActGrp, 'vm_edit_move_up_page')
         self.esm.setMapping(act, QsciScintilla.SCI_PAGEUP)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager', 'Move down one page'),
             QCoreApplication.translate('ViewManager', 'Move down one page'),
             QKeySequence(QCoreApplication.translate('ViewManager', 'PgDown')),
 , self.editorActGrp, 'vm_edit_move_down_page')
         if isMacPlatform():
             act.setAlternateShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+V')))
         self.esm.setMapping(act, QsciScintilla.SCI_PAGEDOWN)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager',
                                        'Move to start of document'),
             QCoreApplication.translate('ViewManager',
                                        'Move to start of document'),
 , 0,
             self.editorActGrp, 'vm_edit_move_start_text')
         if isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Ctrl+Up')))
         else:
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Ctrl+Home')))
         self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTSTART)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager',
                                        'Move to end of document'),
             QCoreApplication.translate('ViewManager',
                                        'Move to end of document'),
 , 0,
             self.editorActGrp, 'vm_edit_move_end_text')
         if isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Ctrl+Down')))
         else:
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Ctrl+End')))
         self.esm.setMapping(act, QsciScintilla.SCI_DOCUMENTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager', 'Indent one level'),
             QCoreApplication.translate('ViewManager', 'Indent one level'),
             QKeySequence(QCoreApplication.translate('ViewManager', 'Tab')), 0,
             self.editorActGrp, 'vm_edit_indent_one_level')
         self.esm.setMapping(act, QsciScintilla.SCI_TAB)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate('ViewManager', 'Unindent one level'),
             QCoreApplication.translate('ViewManager', 'Unindent one level'),
             QKeySequence(QCoreApplication.translate('ViewManager',
                                                     'Shift+Tab')),
 , self.editorActGrp, 'vm_edit_unindent_one_level')
         self.esm.setMapping(act, QsciScintilla.SCI_BACKTAB)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager', 'Extend selection left one character'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection left one character'),
             QKeySequence(QCoreApplication.translate('ViewManager',
                                                     'Shift+Left')),
 , self.editorActGrp, 'vm_edit_extend_selection_left_char')
         if isMacPlatform():
             act.setAlternateShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+Shift+B')))
         self.esm.setMapping(act, QsciScintilla.SCI_CHARLEFTEXTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection right one character'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection right one character'),
             QKeySequence(QCoreApplication.translate('ViewManager',
                                                     'Shift+Right')),
 , self.editorActGrp, 'vm_edit_extend_selection_right_char')
         if isMacPlatform():
             act.setAlternateShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+Shift+F')))
         self.esm.setMapping(act, QsciScintilla.SCI_CHARRIGHTEXTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection up one line'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection up one line'),
             QKeySequence(QCoreApplication.translate('ViewManager',
                                                     'Shift+Up')),
 , self.editorActGrp, 'vm_edit_extend_selection_up_line')
         if isMacPlatform():
             act.setAlternateShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+Shift+P')))
         self.esm.setMapping(act, QsciScintilla.SCI_LINEUPEXTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection down one line'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection down one line'),
             QKeySequence(QCoreApplication.translate('ViewManager',
                                                     'Shift+Down')),
 , self.editorActGrp, 'vm_edit_extend_selection_down_line')
         if isMacPlatform():
             act.setAlternateShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Meta+Shift+N')))
         self.esm.setMapping(act, QsciScintilla.SCI_LINEDOWNEXTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection left one word part'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection left one word part'),
 , 0,
             self.editorActGrp, 'vm_edit_extend_selection_left_word_part')
         if not isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Alt+Shift+Left')))
         self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTLEFTEXTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection right one word part'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection right one word part'),
 , 0,
             self.editorActGrp, 'vm_edit_extend_selection_right_word_part')
         if not isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Alt+Shift+Right')))
         self.esm.setMapping(act, QsciScintilla.SCI_WORDPARTRIGHTEXTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager', 'Extend selection left one word'),
             QCoreApplication.translate(
                 'ViewManager', 'Extend selection left one word'),
 , 0,
             self.editorActGrp, 'vm_edit_extend_selection_left_word')
         if isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Alt+Shift+Left')))
         else:
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Ctrl+Shift+Left')))
         self.esm.setMapping(act, QsciScintilla.SCI_WORDLEFTEXTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager', 'Extend selection right one word'),
             QCoreApplication.translate(
                 'ViewManager', 'Extend selection right one word'),
 , 0,
             self.editorActGrp, 'vm_edit_extend_selection_right_word')
         if isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Alt+Shift+Right')))
         else:
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Ctrl+Shift+Right')))
         self.esm.setMapping(act, QsciScintilla.SCI_WORDRIGHTEXTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection to first visible character in document'
                 ' line'),
             QCoreApplication.translate(
                 'ViewManager',
                 'Extend selection to first visible character in document'
                 ' line'),
 , 0,
             self.editorActGrp, 'vm_edit_extend_selection_first_visible_char')
         if not isMacPlatform():
             act.setShortcut(QKeySequence(
                 QCoreApplication.translate('ViewManager', 'Shift+Home')))
         self.esm.setMapping(act, QsciScintilla.SCI_VCHOMEEXTEND)
         act.triggered.connect(self.esm.map)
         self.editActions.append(act)
         act = E5Action(
             QCoreApplication.translate(
                 'ViewManager', 'Extend selection to end of document line'),
             QCoreApplication.translate(
                 'ViewManager', 'Extend selection to end of document line'),
 , 0,
             self.editorActGrp, 'vm_edit_extend_selection_end_line')
         if isMacPlatform():
 36138359d3a3
Finished the Mac part of the QScintilla 2.6 support.

Detlev Offenbach <detlev@die-offenbachs.de>
parents: 
1198

Mercurial Repositories > eric / annotate

QScintilla/MiniEditor.py@5ecba04d31f2 (annotated)

QScintilla/MiniEditor.py