eric: QScintilla/Editor.py@34528aaedf1c (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2010 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the editor component of the eric5 IDE.
 """
 import os
 import re
 import difflib
 from PyQt4.Qsci import QsciScintilla, QsciMacro
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from E5Gui.E5Application import e5App
 from . import Exporters
 from . import Lexers
 from . import TypingCompleters
 from .QsciScintillaCompat import QsciScintillaCompat, QSCINTILLA_VERSION
 from .SpellChecker import SpellChecker
 from .SpellCheckingDialog import SpellCheckingDialog
 from Debugger.EditBreakpointDialog import EditBreakpointDialog
 from DebugClients.Python3.coverage import coverage
 from DataViews.CodeMetricsDialog import CodeMetricsDialog
 from DataViews.PyCoverageDialog import PyCoverageDialog
 from DataViews.PyProfileDialog import PyProfileDialog
 from .Printer import Printer
 import Preferences
 import Utilities
 from Utilities.py3flakes.checker import Checker
 from Utilities.py3flakes.messages import ImportStarUsed
 import UI.PixmapCache
 EditorAutoCompletionListID = 1
 TemplateCompletionListID = 2
 class Editor(QsciScintillaCompat):
     """
     Class implementing the editor component of the eric5 IDE.
     @signal modificationStatusChanged(boolean, editor) emitted when the
             modification status has changed
     @signal undoAvailable(boolean) emitted to signal the undo availability
     @signal redoAvailable(boolean) emitted to signal the redo availability
     @signal cursorChanged(string, int, int) emitted when the cursor position
             was changed
     @signal editorAboutToBeSaved(string) emitted before the editor is saved
     @signal editorSaved(string) emitted after the editor has been saved
     @signal editorRenamed(string) emitted after the editor got a new name
             (i.e. after a 'Save As')
     @signal captionChanged(string, editor) emitted when the caption is
             updated. Typically due to a readOnly attribute change.
     @signal breakpointToggled(editor) emitted when a breakpoint is toggled
     @signal bookmarkToggled(editor) emitted when a bookmark is toggled
     @signal syntaxerrorToggled(editor) emitted when a syntax error was discovered
     @signal autoCompletionAPIsAvailable(avail) emitted after the autocompletion
             function has been configured
     @signal coverageMarkersShown(boolean) emitted after the coverage markers have been
             shown or cleared
     @signal taskMarkersUpdated(editor) emitted when the task markers were updated
     @signal showMenu(string, QMenu, editor) emitted when a menu is about to be shown.
             The name of the menu, a reference to the menu and a reference to the
             editor are given.
     @signal languageChanged(language) emitted when the editors language was set. The
             language is passed as a parameter.
     @signal eolChanged(eol) emitted when the editors eol type was set. The eol string
             is passed as a parameter.
     @signal encodingChanged(encoding) emitted when the editors encoding was set. The
             encoding name is passed as a parameter.
     """
     # Autocompletion icon definitions
     ClassID              = 1
     ClassProtectedID     = 2
     ClassPrivateID       = 3
     MethodID             = 4
     MethodProtectedID    = 5
     MethodPrivateID      = 6
     AttributeID          = 7
     AttributeProtectedID = 8
     AttributePrivateID   = 9
     EnumID               = 10
     FromDocumentID       = 99
     TemplateImageID      = 100
     # Cooperation related definitions
     Separator = "@@@"
     StartEditToken      = "START_EDIT"
     EndEditToken        = "END_EDIT"
     CancelEditToken     = "CANCEL_EDIT"
     RequestSyncToken    = "REQUEST_SYNC"
     SyncToken           = "SYNC"
     def __init__(self, dbs, fn = None, vm = None,
                  filetype = "", editor = None, tv = None):
         """
         Constructor
         @param dbs reference to the debug server object
         @param fn name of the file to be opened (string). If it is None,
                 a new (empty) editor is opened
         @param vm reference to the view manager object (ViewManager.ViewManager)
         @param filetype type of the source file (string)
         @param editor reference to an Editor object, if this is a cloned view
         @param tv reference to the task viewer object
         """
         QsciScintillaCompat.__init__(self)
         self.setAttribute(Qt.WA_DeleteOnClose)
         self.setAttribute(Qt.WA_KeyCompression)
         self.setUtf8(True)
         self.pyExtensions = dbs.getExtensions('Python')
         self.py3Extensions = dbs.getExtensions('Python3')
         self.rbExtensions = dbs.getExtensions('Ruby')
         self.dbs = dbs
         self.taskViewer = tv
         self.fileName = fn
         self.vm = vm
         self.filetype = filetype
         self.noName = ""
         self.project = e5App().getObject("Project")
         # clear some variables
         self.lastHighlight   = None   # remember the last highlighted line
         self.lastErrorMarker = None   # remember the last error line
         self.lastCurrMarker  = None   # remember the last current line
         self.breaks = {}            # key:   marker handle,
                                     # value: (lineno, condition, temporary,
                                     #         enabled, ignorecount)
         self.bookmarks = []         # bookmarks are just a list of handles to the
                                     # bookmark markers
         self.syntaxerrors = {}      # key:   marker handle
                                     # value: error message
         self.warnings = {}          # key:   marker handle
                                     # value: list of warning messages
         self.notcoveredMarkers = [] # just a list of marker handles
         self.condHistory = []
         self.lexer_ = None
         self.__lexerReset = False
         self.completer = None
         self.encoding = Preferences.getEditor("DefaultEncoding")
         self.apiLanguage = ''
         self.lastModified = 0
         self.line = -1
         self.inReopenPrompt = False
             # true if the prompt to reload a changed source is present
         self.inFileRenamed = False      # true if we are propagating a rename action
         self.inLanguageChanged = False  # true if we are propagating a language change
         self.inEolChanged = False       # true if we are propagating an eol change
         self.inEncodingChanged = False  # true if we are propagating an encoding change
         self.inDragDrop = False         # true if we are in drop mode
         self.__hasTaskMarkers = False   # no task markers present
         self.macros = {}    # list of defined macros
         self.curMacro = None
         self.recording = False
         self.acAPI = False
         # list of clones
         self.__clones = []
         # clear QScintilla defined keyboard commands
         # we do our own handling through the view manager
         self.clearAlternateKeys()
         self.clearKeys()
         # initialize the mark occurrences timer
         self.__markOccurrencesTimer = QTimer(self)
         self.__markOccurrencesTimer.setSingleShot(True)
         self.__markOccurrencesTimer.setInterval(
             Preferences.getEditor("MarkOccurrencesTimeout"))
         self.connect(self.__markOccurrencesTimer, SIGNAL("timeout()"),
                      self.__markOccurrences)
         self.__markedText = ""
         # initialize some spellchecking stuff
         self.spell = None
         self.lastLine = 0
         self.lastIndex = 0
         # initialize some cooperation stuff
         self.__isSyncing = False
         self.__receivedWhileSyncing = []
         self.__savedText = ""
         self.__inSharedEdit = False
         self.__isShared = False
         self.__inRemoteSharedEdit = False
         self.connect(self, SIGNAL('modificationChanged(bool)'),
                      self.__modificationChanged)
         self.connect(self, SIGNAL('cursorPositionChanged(int,int)'),
                      self.__cursorPositionChanged)
         self.connect(self, SIGNAL('modificationAttempted()'),
                      self.__modificationReadOnly)
         self.connect(self, SIGNAL('userListActivated(int, const QString)'),
                      self.__completionListSelected)
         # margins layout
         if QSCINTILLA_VERSION() >= 0x020301:
             self.__unifiedMargins = Preferences.getEditor("UnifiedMargins")
         else:
             self.__unifiedMargins = True
         # define the margins markers
         self.breakpoint = \
             self.markerDefine(UI.PixmapCache.getPixmap("break.png"))
         self.cbreakpoint = \
             self.markerDefine(UI.PixmapCache.getPixmap("cBreak.png"))
         self.tbreakpoint = \
             self.markerDefine(UI.PixmapCache.getPixmap("tBreak.png"))
         self.tcbreakpoint = \
             self.markerDefine(UI.PixmapCache.getPixmap("tCBreak.png"))
         self.dbreakpoint = \
             self.markerDefine(UI.PixmapCache.getPixmap("breakDisabled.png"))
         self.bookmark = \
             self.markerDefine(UI.PixmapCache.getPixmap("bookmark.png"))
         self.syntaxerror = \
             self.markerDefine(UI.PixmapCache.getPixmap("syntaxError.png"))
         self.notcovered = \
             self.markerDefine(UI.PixmapCache.getPixmap("notcovered.png"))
         self.taskmarker = \
             self.markerDefine(UI.PixmapCache.getPixmap("task.png"))
         self.warning = \
             self.markerDefine(UI.PixmapCache.getPixmap("warning.png"))
         # define the line markers
         self.currentline = self.markerDefine(QsciScintilla.Background)
         self.errorline = self.markerDefine(QsciScintilla.Background)
         self.__setLineMarkerColours()
         self.breakpointMask = (1 << self.breakpoint)   | \
                               (1 << self.cbreakpoint)  | \
                               (1 << self.tbreakpoint)  | \
                               (1 << self.tcbreakpoint) | \
                               (1 << self.dbreakpoint)
         # configure the margins
         self.__setMarginsDisplay()
         self.connect(self, SIGNAL('marginClicked(int, int, Qt::KeyboardModifiers)'),
                     self.__marginClicked)
         # set the eol mode
         self.__setEolMode()
         self.isResourcesFile = False
         if editor is None:
             if self.fileName is not None:
                 if (QFileInfo(self.fileName).size() // 1024) > \
                    Preferences.getEditor("WarnFilesize"):
                     res = QMessageBox.warning(None,
                         self.trUtf8("Open File"),
                         self.trUtf8("""<p>The size of the file <b>{0}</b>"""
                                     """ is <b>{1} KB</b>."""
                                     """ Do you really want to load it?</p>""")\
                                     .format(self.fileName,
                                             QFileInfo(self.fileName).size() // 1024),
                         QMessageBox.StandardButtons(\
                             QMessageBox.No | \
                             QMessageBox.Yes),
                         QMessageBox.No)
                     if res == QMessageBox.No or res == QMessageBox.Cancel:
                         raise IOError()
                 self.readFile(self.fileName, True)
                 bindName = self.__bindName(self.text(0))
                 self.__bindLexer(bindName)
                 self.__bindCompleter(bindName)
                 self.__autoSyntaxCheck()
                 self.isResourcesFile = self.fileName.endswith(".qrc")
                 self.recolor()
         else:
             # clone the given editor
             self.setDocument(editor.document())
             self.breaks = editor.breaks
             self.bookmarks = editor.bookmarks
             self.syntaxerrors = editor.syntaxerrors
             self.notcoveredMarkers = editor.notcoveredMarkers
             self.isResourcesFile = editor.isResourcesFile
             self.lastModified = editor.lastModified
             self.addClone(editor)
             editor.addClone(self)
         self.gotoLine(0)
         # set the text display
         self.__setTextDisplay()
         # set the autocompletion and calltips function
         self.__acHookFunction = None
         self.__setAutoCompletion()
         self.__ctHookFunction = None
         self.__setCallTips()
         sh = self.sizeHint()
         if sh.height() < 300:
             sh.setHeight(300)
         self.resize(sh)
         # Make sure tabbing through a QWorkspace works.
         self.setFocusPolicy(Qt.StrongFocus)
         self.__updateReadOnly(True)
         self.setWhatsThis(self.trUtf8(
             """<b>A Source Editor Window</b>"""
             """<p>This window is used to display and edit a source file."""
             """  You can open as many of these as you like. The name of the file"""
             """ is displayed in the window's titlebar.</p>"""
             """<p>In order to set breakpoints just click in the space between"""
             """ the line numbers and the fold markers. Via the context menu"""
             """ of the margins they may be edited.</p>"""
             """<p>In order to set bookmarks just Shift click in the space between"""
             """ the line numbers and the fold markers.</p>"""
             """<p>These actions can be reversed via the context menu.</p>"""
             """<p>Ctrl clicking on a syntax error marker shows some info"""
             """ about this error.</p>"""
         ))
         # Set the editors size, if it is too big for the view manager.
         if self.vm is not None:
             req = self.size()
             bnd = req.boundedTo(self.vm.size())
             if bnd.width() < req.width() or bnd.height() < req.height():
                 self.resize(bnd)
         # set the autosave flag
         self.autosaveEnabled = Preferences.getEditor("AutosaveInterval") > 0
         self.autosaveManuallyDisabled = False
         self.__initContextMenu()
         self.__initContextMenuMargins()
         self.__checkEol()
         if editor is None:
             self.__checkLanguage()
             self.__checkEncoding()
         else:
             # it's a clone
             self.languageChanged(editor.apiLanguage, propagate = False)
             self.__encodingChanged(editor.encoding, propagate = False)
         self.coverageMarkersShown = False   # flag remembering the current status of the
                                             # code coverage markers
         self.setAcceptDrops(True)
         # breakpoint handling
         self.breakpointModel = self.dbs.getBreakPointModel()
         self.__restoreBreakpoints()
         self.breakpointModel.rowsAboutToBeRemoved.connect(
             self.__deleteBreakPoints)
         self.breakpointModel.dataAboutToBeChanged.connect(
             self.__breakPointDataAboutToBeChanged)
         self.breakpointModel.dataChanged.connect(
             self.__changeBreakPoints)
         self.breakpointModel.rowsInserted.connect(
             self.__addBreakPoints)
         self.connect(self, SIGNAL("linesChanged()"), self.__linesChanged)
         # establish connection to some ViewManager action groups
         self.addActions(self.vm.editorActGrp.actions())
         self.addActions(self.vm.editActGrp.actions())
         self.addActions(self.vm.copyActGrp.actions())
         self.addActions(self.vm.viewActGrp.actions())
         # register images to be shown in autocompletion lists
         self.__registerImages()
     def __registerImages(self):
         """
         Private method to register images for autocompletion lists.
         """
         self.registerImage(self.ClassID,
                            UI.PixmapCache.getPixmap("class.png"))
         self.registerImage(self.ClassProtectedID,
                            UI.PixmapCache.getPixmap("class_protected.png"))
         self.registerImage(self.ClassPrivateID,
                            UI.PixmapCache.getPixmap("class_private.png"))
         self.registerImage(self.MethodID,
                            UI.PixmapCache.getPixmap("method.png"))
         self.registerImage(self.MethodProtectedID,
                            UI.PixmapCache.getPixmap("method_protected.png"))
         self.registerImage(self.MethodPrivateID,
                            UI.PixmapCache.getPixmap("method_private.png"))
         self.registerImage(self.AttributeID,
                            UI.PixmapCache.getPixmap("attribute.png"))
         self.registerImage(self.AttributeProtectedID,
                            UI.PixmapCache.getPixmap("attribute_protected.png"))
         self.registerImage(self.AttributePrivateID,
                            UI.PixmapCache.getPixmap("attribute_private.png"))
         self.registerImage(self.EnumID,
                            UI.PixmapCache.getPixmap("enum.png"))
         self.registerImage(self.FromDocumentID,
                            UI.PixmapCache.getPixmap("editor.png"))
         self.registerImage(self.TemplateImageID,
                            UI.PixmapCache.getPixmap("templateViewer.png"))
     def addClone(self, editor):
         """
         Public method to add a clone to our list.
         @param clone reference to the cloned editor (Editor)
         """
         self.__clones.append(editor)
         self.connect(editor, SIGNAL('editorRenamed'), self.fileRenamed)
         self.connect(editor, SIGNAL('languageChanged'), self.languageChanged)
         self.connect(editor, SIGNAL('eolChanged'), self.__eolChanged)
         self.connect(editor, SIGNAL('encodingChanged'), self.__encodingChanged)
     def removeClone(self, editor):
         """
         Public method to remove a clone from our list.
         @param clone reference to the cloned editor (Editor)
         """
         if editor in self.__clones:
             self.disconnect(editor, SIGNAL('editorRenamed'), self.fileRenamed)
             self.disconnect(editor, SIGNAL('languageChanged'), self.languageChanged)
             self.disconnect(editor, SIGNAL('eolChanged'), self.__eolChanged)
             self.disconnect(editor, SIGNAL('encodingChanged'), self.__encodingChanged)
             self.__clones.remove(editor)
     def __bindName(self, line0):
         """
         Private method to generate a dummy filename for binding a lexer.
         @param line0 first line of text to use in the generation process (string)
         """
         bindName = self.fileName
         if line0.startswith("<?xml"):
             # override extension for XML files
             bindName = "dummy.xml"
         # check filetype
         if self.filetype == "Python":
             bindName = "dummy.py"
         elif self.filetype == "Ruby":
             bindName = "dummy.rb"
         elif self.filetype == "D":
             bindName = "dummy.d"
         elif self.filetype == "Properties":
             bindName = "dummy.ini"
         # #! marker detection
         if line0.startswith("#!"):
             if "python3" in line0:
                 bindName = "dummy.py"
                 self.filetype = "Python3"
             elif "python2" in line0:
                 bindName = "dummy.py"
                 self.filetype = "Python"
             elif "python" in line0:
                 bindName = "dummy.py"
                 self.filetype = "Python"
             elif ("/bash" in line0 or "/sh" in line0):
                 bindName = "dummy.sh"
             elif "ruby" in line0:
                 bindName = "dummy.rb"
                 self.filetype = "Ruby"
             elif "perl" in line0:
                 bindName = "dummy.pl"
             elif "lua" in line0:
                 bindName = "dummy.lua"
             elif "dmd" in line0:
                 bindName = "dummy.d"
                 self.filetype = "D"
         return bindName
     def getMenu(self, menuName):
         """
         Public method to get a reference to the main context menu or a submenu.
         @param menuName name of the menu (string)
         @return reference to the requested menu (QMenu) or None
         """
         try:
             return self.__menus[menuName]
         except KeyError:
             return None
     def hasMiniMenu(self):
         """
         Public method to check the miniMenu flag.
         @return flag indicating a minimized context menu (boolean)
         """
         return self.miniMenu
     def __initContextMenu(self):
         """
         Private method used to setup the context menu
         """
         self.miniMenu = Preferences.getEditor("MiniContextMenu")
         self.menuActs = {}
         self.menu = QMenu()
         self.__menus = {
             "Main" : self.menu,
         }
         self.languagesMenu = self.__initContextMenuLanguages()
         self.__menus["Languages"] = self.languagesMenu
         if self.isResourcesFile:
             self.resourcesMenu = self.__initContextMenuResources()
             self.__menus["Resources"] = self.resourcesMenu
         else:
             self.checksMenu = self.__initContextMenuChecks()
             self.showMenu = self.__initContextMenuShow()
             self.graphicsMenu = self.__initContextMenuGraphics()
             self.autocompletionMenu = self.__initContextMenuAutocompletion()
             self.__menus["Checks"] = self.checksMenu
             self.__menus["Show"] = self.showMenu
             self.__menus["Graphics"] = self.graphicsMenu
             self.__menus["Autocompletion"] = self.autocompletionMenu
         self.exportersMenu = self.__initContextMenuExporters()
         self.__menus["Exporters"] = self.exportersMenu
         self.eolMenu = self.__initContextMenuEol()
         self.__menus["Eol"] = self.eolMenu
         self.encodingsMenu = self.__initContextMenuEncodings()
         self.__menus["Encodings"] = self.encodingsMenu
         self.menuActs["Undo"] = \
             self.menu.addAction(UI.PixmapCache.getIcon("editUndo.png"),
             self.trUtf8('Undo'), self.undo)
         self.menuActs["Redo"] = \
             self.menu.addAction(UI.PixmapCache.getIcon("editRedo.png"),
             self.trUtf8('Redo'), self.redo)
         self.menuActs["Revert"] = \
             self.menu.addAction(self.trUtf8("Revert to last saved state"),
                 self.revertToUnmodified)
         self.menu.addSeparator()
         self.menuActs["Cut"] = \
             self.menu.addAction(UI.PixmapCache.getIcon("editCut.png"),
             self.trUtf8('Cut'), self.cut)
         self.menuActs["Copy"] = \
             self.menu.addAction(UI.PixmapCache.getIcon("editCopy.png"),
             self.trUtf8('Copy'), self.copy)
         self.menu.addAction(UI.PixmapCache.getIcon("editPaste.png"),
             self.trUtf8('Paste'), self.paste)
         if not self.miniMenu:
             self.menu.addSeparator()
             self.menu.addAction(UI.PixmapCache.getIcon("editIndent.png"),
                 self.trUtf8('Indent'), self.indentLineOrSelection)
             self.menu.addAction(UI.PixmapCache.getIcon("editUnindent.png"),
                 self.trUtf8('Unindent'), self.unindentLineOrSelection)
             self.menuActs["Comment"] = \
                 self.menu.addAction(UI.PixmapCache.getIcon("editComment.png"),
                     self.trUtf8('Comment'), self.commentLineOrSelection)
             self.menuActs["Uncomment"] = \
                 self.menu.addAction(UI.PixmapCache.getIcon("editUncomment.png"),
                     self.trUtf8('Uncomment'), self.uncommentLineOrSelection)
             self.menuActs["StreamComment"] = \
                 self.menu.addAction(self.trUtf8('Stream Comment'),
                     self.streamCommentLineOrSelection)
             self.menuActs["BoxComment"] = \
                 self.menu.addAction(self.trUtf8('Box Comment'),
                     self.boxCommentLineOrSelection)
             self.menu.addSeparator()
             self.menu.addAction(self.trUtf8('Select to brace'),
                 self.selectToMatchingBrace)
             self.menu.addAction(self.trUtf8('Select all'), self.__selectAll)
             self.menu.addAction(self.trUtf8('Deselect all'), self.__deselectAll)
             self.menu.addSeparator()
         self.menuActs["SpellCheck"] = \
             self.menu.addAction(UI.PixmapCache.getIcon("spellchecking.png"),
                 self.trUtf8('Check spelling...'), self.checkSpelling)
         self.menuActs["SpellCheckSelection"] = \
             self.menu.addAction(UI.PixmapCache.getIcon("spellchecking.png"),
                 self.trUtf8('Check spelling of selection...'),
                 self.__checkSpellingSelection)
         self.menuActs["SpellCheckRemove"] = \
             self.menu.addAction(self.trUtf8("Remove from dictionary"),
                 self.__removeFromSpellingDictionary)
         self.menu.addSeparator()
         self.menu.addAction(self.trUtf8('Shorten empty lines'),
             self.shortenEmptyLines)
         self.menu.addSeparator()
         self.menuActs["Languages"] = self.menu.addMenu(self.languagesMenu)
         self.menuActs["Encodings"] = self.menu.addMenu(self.encodingsMenu)
         self.menuActs["Eol"] = self.menu.addMenu(self.eolMenu)
         self.menu.addSeparator()
         self.menuActs["MonospacedFont"] = \
             self.menu.addAction(self.trUtf8("Use Monospaced Font"),
                 self.handleMonospacedEnable)
         self.menuActs["MonospacedFont"].setCheckable(True)
         self.menuActs["MonospacedFont"].setChecked(self.useMonospaced)
         self.menuActs["AutosaveEnable"] = \
             self.menu.addAction(self.trUtf8("Autosave enabled"),
                 self.__autosaveEnable)
         self.menuActs["AutosaveEnable"].setCheckable(True)
         self.menuActs["AutosaveEnable"].setChecked(self.autosaveEnabled)
         self.menuActs["TypingAidsEnabled"] = \
             self.menu.addAction(self.trUtf8("Typing aids enabled"),
                 self.__toggleTypingAids)
         self.menuActs["TypingAidsEnabled"].setCheckable(True)
         self.menuActs["TypingAidsEnabled"].setEnabled(self.completer is not None)
         self.menuActs["TypingAidsEnabled"].setChecked(\
             self.completer is not None and self.completer.isEnabled())
         self.menuActs["AutoCompletionEnable"] = \
             self.menu.addAction(self.trUtf8("Autocompletion enabled"),
                 self.__toggleAutoCompletionEnable)
         self.menuActs["AutoCompletionEnable"].setCheckable(True)
         self.menuActs["AutoCompletionEnable"].setChecked(\
             self.autoCompletionThreshold() != -1)
         if not self.isResourcesFile:
             self.menu.addMenu(self.autocompletionMenu)
         self.menu.addSeparator()
         if self.isResourcesFile:
             self.menu.addMenu(self.resourcesMenu)
         else:
             self.menuActs["Check"] = self.menu.addMenu(self.checksMenu)
             self.menu.addSeparator()
             self.menuActs["Show"] = self.menu.addMenu(self.showMenu)
             self.menu.addSeparator()
             self.menuActs["Diagrams"] = self.menu.addMenu(self.graphicsMenu)
         self.menu.addSeparator()
         self.menu.addAction(self.trUtf8('New view'), self.__newView)
         act = self.menu.addAction(self.trUtf8('New view (with new split)'),
             self.__newViewNewSplit)
         if not self.vm.canSplit():
                 act.setEnabled(False)
         self.menu.addAction(UI.PixmapCache.getIcon("close.png"),
             self.trUtf8('Close'), self.__contextClose)
         self.menu.addSeparator()
         self.menuActs["Save"] = \
             self.menu.addAction(UI.PixmapCache.getIcon("fileSave.png"),
             self.trUtf8('Save'), self.__contextSave)
         self.menu.addAction(UI.PixmapCache.getIcon("fileSaveAs.png"),
             self.trUtf8('Save As...'), self.__contextSaveAs)
         if not self.miniMenu:
             self.menu.addMenu(self.exportersMenu)
             self.menu.addSeparator()
             self.menu.addAction(UI.PixmapCache.getIcon("printPreview.png"),
             self.trUtf8("Print Preview"), self.printPreviewFile)
             self.menu.addAction(UI.PixmapCache.getIcon("print.png"),
                 self.trUtf8('Print'), self.printFile)
         self.menu.aboutToShow.connect(self.__showContextMenu)
         self.spellingMenu = QMenu()
         self.__menus["Spelling"] = self.spellingMenu
         self.spellingMenu.aboutToShow.connect(self.__showContextMenuSpelling)
         self.connect(self.spellingMenu, SIGNAL('triggered(QAction *)'),
                      self.__contextMenuSpellingTriggered)
     def __initContextMenuAutocompletion(self):
         """
         Private method used to setup the Checks context sub menu.
         """
         menu = QMenu(self.trUtf8('Autocomplete'))
         self.menuActs["acDynamic"] = \
             menu.addAction(self.trUtf8('dynamic'),
                 self.autoComplete)
         menu.addSeparator()
         menu.addAction(self.trUtf8('from Document'),
             self.autoCompleteFromDocument)
         self.menuActs["acAPI"] = \
             menu.addAction(self.trUtf8('from APIs'),
                 self.autoCompleteFromAPIs)
         self.menuActs["acAPIDocument"] = \
             menu.addAction(self.trUtf8('from Document and APIs'),
                 self.autoCompleteFromAll)
         menu.addSeparator()
         self.menuActs["calltip"] = \
             menu.addAction(self.trUtf8('Calltip'), self.callTip)
         menu.aboutToShow.connect(self.__showContextMenuAutocompletion)
         return menu
     def __initContextMenuChecks(self):
         """
         Private method used to setup the Checks context sub menu.
         """
         menu = QMenu(self.trUtf8('Check'))
         menu.aboutToShow.connect(self.__showContextMenuChecks)
         return menu
     def __initContextMenuShow(self):
         """
         Private method used to setup the Show context sub menu.
         """
         menu = QMenu(self.trUtf8('Show'))
         menu.addAction(self.trUtf8('Code metrics...'), self.__showCodeMetrics)
         self.coverageMenuAct = \
             menu.addAction(self.trUtf8('Code coverage...'), self.__showCodeCoverage)
         self.coverageShowAnnotationMenuAct = \
             menu.addAction(self.trUtf8('Show code coverage annotations'),
                 self.__codeCoverageShowAnnotations)
         self.coverageHideAnnotationMenuAct = \
             menu.addAction(self.trUtf8('Hide code coverage annotations'),
                 self.__codeCoverageHideAnnotations)
         self.profileMenuAct = \
             menu.addAction(self.trUtf8('Profile data...'), self.__showProfileData)
         menu.aboutToShow.connect(self.__showContextMenuShow)
         return menu
     def __initContextMenuGraphics(self):
         """
         Private method used to setup the diagrams context sub menu.
         """
         menu = QMenu(self.trUtf8('Diagrams'))
         menu.addAction(self.trUtf8('Class Diagram...'),
             self.__showClassDiagram)
         menu.addAction(self.trUtf8('Package Diagram...'),
             self.__showPackageDiagram)
         menu.addAction(self.trUtf8('Imports Diagram...'),
             self.__showImportsDiagram)
         self.applicationDiagramMenuAct = \
             menu.addAction(self.trUtf8('Application Diagram...'),
                 self.__showApplicationDiagram)
         menu.aboutToShow.connect(self.__showContextMenuGraphics)
         return menu
     def __initContextMenuLanguages(self):
         """
         Private method used to setup the Languages context sub menu.
         """
         menu = QMenu(self.trUtf8("Languages"))
         self.languagesActGrp = QActionGroup(self)
         self.noLanguageAct = menu.addAction(self.trUtf8("No Language"))
         self.noLanguageAct.setCheckable(True)
         self.noLanguageAct.setData("None")
         self.languagesActGrp.addAction(self.noLanguageAct)
         menu.addSeparator()
         self.supportedLanguages = {}
         supportedLanguages = Lexers.getSupportedLanguages()
         languages = sorted(list(supportedLanguages.keys()))
         for language in languages:
             if language != "Guessed":
                 self.supportedLanguages[language] = supportedLanguages[language][:]
                 act = menu.addAction(self.supportedLanguages[language][0])
                 act.setCheckable(True)
                 act.setData(language)
                 self.supportedLanguages[language].append(act)
                 self.languagesActGrp.addAction(act)
         menu.addSeparator()
         self.pygmentsAct = menu.addAction(self.trUtf8("Guessed"))
         self.pygmentsAct.setCheckable(True)
         self.pygmentsAct.setData("Guessed")
         self.languagesActGrp.addAction(self.pygmentsAct)
         self.pygmentsSelAct = menu.addAction(self.trUtf8("Alternatives"))
         self.pygmentsSelAct.setData("Alternatives")
         self.connect(menu, SIGNAL('triggered(QAction *)'), self.__languageMenuTriggered)
         menu.aboutToShow.connect(self.__showContextMenuLanguages)
         return menu
     def __initContextMenuEncodings(self):
         """
         Private method used to setup the Encodings context sub menu.
         """
         self.supportedEncodings = {}
         menu = QMenu(self.trUtf8("Encodings"))
         self.encodingsActGrp = QActionGroup(self)
         for encoding in sorted(Utilities.supportedCodecs):
             act = menu.addAction(encoding)
             act.setCheckable(True)
             act.setData(encoding)
             self.supportedEncodings[encoding] = act
             self.encodingsActGrp.addAction(act)
         self.connect(menu, SIGNAL('triggered(QAction *)'), self.__encodingsMenuTriggered)
         menu.aboutToShow.connect(self.__showContextMenuEncodings)
         return menu
     def __initContextMenuEol(self):
         """
         Private method to setup the eol context sub menu.
         """
         self.supportedEols = {}
         menu = QMenu(self.trUtf8("End-of-Line Type"))
         self.eolActGrp = QActionGroup(self)
         act = menu.addAction(self.trUtf8("Unix"))
         act.setCheckable(True)
         act.setData('\n')
         self.supportedEols['\n'] = act
         self.eolActGrp.addAction(act)
         act = menu.addAction(self.trUtf8("Windows"))
         act.setCheckable(True)
         act.setData('\r\n')
         self.supportedEols['\r\n'] = act
         self.eolActGrp.addAction(act)
         act = menu.addAction(self.trUtf8("Macintosh"))
         act.setCheckable(True)
         act.setData('\r')
         self.supportedEols['\r'] = act
         self.eolActGrp.addAction(act)
         self.connect(menu, SIGNAL('triggered(QAction *)'), self.__eolMenuTriggered)
         menu.aboutToShow.connect(self.__showContextMenuEol)
         return menu
     def __initContextMenuExporters(self):
         """
         Private method used to setup the Exporters context sub menu.
         """
         menu = QMenu(self.trUtf8("Export as"))
         supportedExporters = Exporters.getSupportedFormats()
         exporters = sorted(list(supportedExporters.keys()))
         for exporter in exporters:
             act = menu.addAction(supportedExporters[exporter])
             act.setData(exporter)
         self.connect(menu, SIGNAL('triggered(QAction *)'), self.__exportMenuTriggered)
         return menu
     def __initContextMenuMargins(self):
         """
         Private method used to setup the context menu for the margins
         """
         self.marginMenuActs = {}
         if self.__unifiedMargins:
             self.__initContextMenuUnifiedMargins()
         else:
             self.__initContextMenuSeparateMargins()
     def __initContextMenuSeparateMargins(self):
         """
         Private method used to setup the context menu for the separated margins
         """
         # bookmark margin
         self.bmMarginMenu = QMenu()
         self.bmMarginMenu.addAction(self.trUtf8('Toggle bookmark'),
             self.menuToggleBookmark)
         self.marginMenuActs["NextBookmark"] = \
             self.bmMarginMenu.addAction(self.trUtf8('Next bookmark'),
                 self.nextBookmark)
         self.marginMenuActs["PreviousBookmark"] = \
             self.bmMarginMenu.addAction(self.trUtf8('Previous bookmark'),
                 self.previousBookmark)
         self.marginMenuActs["ClearBookmark"] = \
             self.bmMarginMenu.addAction(self.trUtf8('Clear all bookmarks'),
                 self.clearBookmarks)
         self.bmMarginMenu.aboutToShow.connect(self.__showContextMenuMargin)
         # breakpoint margin
         self.bpMarginMenu = QMenu()
         self.marginMenuActs["Breakpoint"] = \
             self.bpMarginMenu.addAction(self.trUtf8('Toggle breakpoint'),
                 self.menuToggleBreakpoint)
         self.marginMenuActs["TempBreakpoint"] = \
             self.bpMarginMenu.addAction(self.trUtf8('Toggle temporary breakpoint'),
                 self.__menuToggleTemporaryBreakpoint)
         self.marginMenuActs["EditBreakpoint"] = \
             self.bpMarginMenu.addAction(self.trUtf8('Edit breakpoint...'),
                 self.menuEditBreakpoint)
         self.marginMenuActs["EnableBreakpoint"] = \
             self.bpMarginMenu.addAction(self.trUtf8('Enable breakpoint'),
                 self.__menuToggleBreakpointEnabled)
         self.marginMenuActs["NextBreakpoint"] = \
             self.bpMarginMenu.addAction(self.trUtf8('Next breakpoint'),
                 self.menuNextBreakpoint)
         self.marginMenuActs["PreviousBreakpoint"] = \
             self.bpMarginMenu.addAction(self.trUtf8('Previous breakpoint'),
                 self.menuPreviousBreakpoint)
         self.marginMenuActs["ClearBreakpoint"] = \
             self.bpMarginMenu.addAction(self.trUtf8('Clear all breakpoints'),
                 self.__menuClearBreakpoints)
         self.bpMarginMenu.aboutToShow.connect(self.__showContextMenuMargin)
         # indicator margin
         self.indicMarginMenu = QMenu()
         self.marginMenuActs["GotoSyntaxError"] = \
             self.indicMarginMenu.addAction(self.trUtf8('Goto syntax error'),
                 self.gotoSyntaxError)
         self.marginMenuActs["ShowSyntaxError"] = \
             self.indicMarginMenu.addAction(self.trUtf8('Show syntax error message'),
                 self.__showSyntaxError)
         self.marginMenuActs["ClearSyntaxError"] = \
             self.indicMarginMenu.addAction(self.trUtf8('Clear syntax error'),
                 self.clearSyntaxError)
         self.indicMarginMenu.addSeparator()
         self.marginMenuActs["NextWarningMarker"] = \
             self.indicMarginMenu.addAction(self.trUtf8("Next warning"),
                 self.nextFlakesWarning)
         self.marginMenuActs["PreviousWarningMarker"] = \
             self.indicMarginMenu.addAction(self.trUtf8("Previous warning"),
                 self.previousFlakesWarning)
         self.marginMenuActs["ShowWarning"] = \
             self.indicMarginMenu.addAction(self.trUtf8('Show warning message'),
                 self.__showFlakesWarning)
         self.marginMenuActs["ClearWarnings"] = \
             self.indicMarginMenu.addAction(self.trUtf8('Clear warnings'),
                 self.clearFlakesWarnings)
         self.indicMarginMenu.addSeparator()
         self.marginMenuActs["NextCoverageMarker"] = \
             self.indicMarginMenu.addAction(self.trUtf8('Next uncovered line'),
                 self.nextUncovered)
         self.marginMenuActs["PreviousCoverageMarker"] = \
             self.indicMarginMenu.addAction(self.trUtf8('Previous uncovered line'),
                 self.previousUncovered)
         self.indicMarginMenu.addSeparator()
         self.marginMenuActs["NextTaskMarker"] = \
             self.indicMarginMenu.addAction(self.trUtf8('Next task'),
                 self.nextTask)
         self.marginMenuActs["PreviousTaskMarker"] = \
             self.indicMarginMenu.addAction(self.trUtf8('Previous task'),
                 self.previousTask)
         self.indicMarginMenu.aboutToShow.connect(self.__showContextMenuMargin)
     def __initContextMenuUnifiedMargins(self):
         """
         Private method used to setup the context menu for the unified margins
         """
         self.marginMenu = QMenu()
         self.marginMenu.addAction(self.trUtf8('Toggle bookmark'),
             self.menuToggleBookmark)
         self.marginMenuActs["NextBookmark"] = \
             self.marginMenu.addAction(self.trUtf8('Next bookmark'),
                 self.nextBookmark)
         self.marginMenuActs["PreviousBookmark"] = \
             self.marginMenu.addAction(self.trUtf8('Previous bookmark'),
                 self.previousBookmark)
         self.marginMenuActs["ClearBookmark"] = \
             self.marginMenu.addAction(self.trUtf8('Clear all bookmarks'),
                 self.clearBookmarks)
         self.marginMenu.addSeparator()
         self.marginMenuActs["GotoSyntaxError"] = \
             self.marginMenu.addAction(self.trUtf8('Goto syntax error'),
                 self.gotoSyntaxError)
         self.marginMenuActs["ShowSyntaxError"] = \
             self.marginMenu.addAction(self.trUtf8('Show syntax error message'),
                 self.__showSyntaxError)
         self.marginMenuActs["ClearSyntaxError"] = \
             self.marginMenu.addAction(self.trUtf8('Clear syntax error'),
                 self.clearSyntaxError)
         self.marginMenu.addSeparator()
         self.marginMenuActs["NextWarningMarker"] = \
             self.marginMenu.addAction(self.trUtf8("Next warning"),
                 self.nextFlakesWarning)
         self.marginMenuActs["PreviousWarningMarker"] = \
             self.marginMenu.addAction(self.trUtf8("Previous warning"),
                 self.previousFlakesWarning)
         self.marginMenuActs["ShowWarning"] = \
             self.marginMenu.addAction(self.trUtf8('Show warning message'),
                 self.__showFlakesWarning)
         self.marginMenuActs["ClearWarnings"] = \
             self.marginMenu.addAction(self.trUtf8('Clear warnings'),
                 self.clearFlakesWarnings)
         self.marginMenu.addSeparator()
         self.marginMenuActs["Breakpoint"] = \
             self.marginMenu.addAction(self.trUtf8('Toggle breakpoint'),
                 self.menuToggleBreakpoint)
         self.marginMenuActs["TempBreakpoint"] = \
             self.marginMenu.addAction(self.trUtf8('Toggle temporary breakpoint'),
                 self.__menuToggleTemporaryBreakpoint)
         self.marginMenuActs["EditBreakpoint"] = \
             self.marginMenu.addAction(self.trUtf8('Edit breakpoint...'),
                 self.menuEditBreakpoint)
         self.marginMenuActs["EnableBreakpoint"] = \
             self.marginMenu.addAction(self.trUtf8('Enable breakpoint'),
                 self.__menuToggleBreakpointEnabled)
         self.marginMenuActs["NextBreakpoint"] = \
             self.marginMenu.addAction(self.trUtf8('Next breakpoint'),
                 self.menuNextBreakpoint)
         self.marginMenuActs["PreviousBreakpoint"] = \
             self.marginMenu.addAction(self.trUtf8('Previous breakpoint'),
                 self.menuPreviousBreakpoint)
         self.marginMenuActs["ClearBreakpoint"] = \
             self.marginMenu.addAction(self.trUtf8('Clear all breakpoints'),
                 self.__menuClearBreakpoints)
         self.marginMenu.addSeparator()
         self.marginMenuActs["NextCoverageMarker"] = \
             self.marginMenu.addAction(self.trUtf8('Next uncovered line'),
                 self.nextUncovered)
         self.marginMenuActs["PreviousCoverageMarker"] = \
             self.marginMenu.addAction(self.trUtf8('Previous uncovered line'),
                 self.previousUncovered)
         self.marginMenu.addSeparator()
         self.marginMenuActs["NextTaskMarker"] = \
             self.marginMenu.addAction(self.trUtf8('Next task'),
                 self.nextTask)
         self.marginMenuActs["PreviousTaskMarker"] = \
             self.marginMenu.addAction(self.trUtf8('Previous task'),
                 self.previousTask)
         self.marginMenu.addSeparator()
         self.marginMenuActs["LMBbookmarks"] = \
             self.marginMenu.addAction(self.trUtf8('LMB toggles bookmarks'),
                 self.__lmBbookmarks)
         self.marginMenuActs["LMBbookmarks"].setCheckable(True)
         self.marginMenuActs["LMBbookmarks"].setChecked(False)
         self.marginMenuActs["LMBbreakpoints"] = \
             self.marginMenu.addAction(self.trUtf8('LMB toggles breakpoints'),
                 self.__lmBbreakpoints)
         self.marginMenuActs["LMBbreakpoints"].setCheckable(True)
         self.marginMenuActs["LMBbreakpoints"].setChecked(True)
         self.marginMenu.aboutToShow.connect(self.__showContextMenuMargin)
     def __exportMenuTriggered(self, act):
         """
         Private method to handle the selection of an export format.
         @param act reference to the action that was triggered (QAction)
         """
         exporterFormat = act.data()
         self.exportFile(exporterFormat)
     def exportFile(self, exporterFormat):
         """
         Public method to export the file.
         @param exporterFormat format the file should be exported into (string)
         """
         if exporterFormat:
             exporter = Exporters.getExporter(exporterFormat, self)
             if exporter:
                 exporter.exportSource()
             else:
                 QMessageBox.critical(self,
                     self.trUtf8("Export source"),
                     self.trUtf8("""<p>No exporter available for the """
                                 """export format <b>{0}</b>. Aborting...</p>""")\
                         .format(exporterFormat),
                     QMessageBox.StandardButtons(\
                         QMessageBox.Ok))
         else:
             QMessageBox.critical(self,
                 self.trUtf8("Export source"),
                 self.trUtf8("""No export format given. Aborting..."""),
                 QMessageBox.StandardButtons(\
                     QMessageBox.Ok))
     def __showContextMenuLanguages(self):
         """
         Private slot handling the aboutToShow signal of the languages context menu.
         """
         if self.apiLanguage.startswith("Pygments|"

Mercurial Repositories > eric / annotate

QScintilla/Editor.py@34528aaedf1c (annotated)

QScintilla/Editor.py