eric: comparison QScintilla/Editor.py

--1:000000000000
+:de9c2efb9d02
+# -*- coding: utf-8 -*-
+# Copyright (c) 2002 - 2009 Detlev Offenbach <detlev@die-offenbachs.de>
+#
+"""
+Module implementing the editor component of the eric4 IDE.
+"""
+import os
+import re
+import types
+from PyQt4.Qsci import QsciScintilla, QsciMacro
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+from E4Gui.E4Application import e4App
+import Exporters
+import Lexers
+import TypingCompleters
+from QsciScintillaCompat import QsciScintillaCompat, QSCINTILLA_VERSION
+from SpellChecker import SpellChecker
+from SpellCheckingDialog import SpellCheckingDialog
+from Debugger.EditBreakpointDialog import EditBreakpointDialog
+from DebugClients.Python.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
+import UI.PixmapCache
+EditorAutoCompletionListID = 1
+TemplateCompletionListID = 2
+class Editor(QsciScintillaCompat):
+"""
+Class implementing the editor component of the eric4 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.
+"""
+ClassID              = 1
+ClassProtectedID     = 2
+ClassPrivateID       = 3
+MethodID             = 4
+MethodProtectedID    = 5
+MethodPrivateID      = 6
+AttributeID          = 7
+AttributeProtectedID = 8
+AttributePrivateID   = 9
+EnumID               = 10
+FromDocumentID       = 99
+TemplateImageID      = 100
+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 = ""
+# 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.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()
+# initialise 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 = ""
+# initialise some spellchecking stuff
+self.spell = None
+self.lastLine = 0
+self.lastIndex = 0
+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"))
+# 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()
+line0 = self.readLine0(self.fileName)
+bindName = self.__bindName(line0)
+self.__bindLexer(bindName)
+self.readFile(self.fileName, True)
+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.connect(self.breakpointModel,
+SIGNAL("rowsAboutToBeRemoved(const QModelIndex &, int, int)"),
+self.__deleteBreakPoints)
+self.connect(self.breakpointModel,
+SIGNAL("dataAboutToBeChanged(const QModelIndex &, const QModelIndex &)"),
+self.__breakPointDataAboutToBeChanged)
+self.connect(self.breakpointModel,
+SIGNAL("dataChanged(const QModelIndex &, const QModelIndex &)"),
+self.__changeBreakPoints)
+self.connect(self.breakpointModel,
+SIGNAL("rowsInserted(const QModelIndex &, int, int)"),
+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.connect(self.menu, SIGNAL('aboutToShow()'), self.__showContextMenu)
+self.spellingMenu = QMenu()
+self.__menus["Spelling"] = self.spellingMenu
+self.connect(self.spellingMenu, SIGNAL('aboutToShow()'),
+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)
+self.connect(menu, SIGNAL('aboutToShow()'), self.__showContextMenuAutocompletion)
+return menu
+def __initContextMenuChecks(self):
+"""
+Private method used to setup the Checks context sub menu.
+"""
+menu = QMenu(self.trUtf8('Check'))
+self.connect(menu, SIGNAL("aboutToShow()"), 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)
+self.connect(menu, SIGNAL('aboutToShow()'), 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)
+self.connect(menu, SIGNAL('aboutToShow()'), 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(QVariant("None"))
+self.languagesActGrp.addAction(self.noLanguageAct)
+menu.addSeparator()
+self.supportedLanguages = {}
+supportedLanguages = Lexers.getSupportedLanguages()
+languages = supportedLanguages.keys()
+languages.sort()
+for language in languages:
+if language != "Guessed":
+self.supportedLanguages[language] = supportedLanguages[language][:]
+act = menu.addAction(self.supportedLanguages[language][0])
+act.setCheckable(True)
+act.setData(QVariant(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(QVariant("Guessed"))
+self.languagesActGrp.addAction(self.pygmentsAct)
+self.pygmentsSelAct = menu.addAction(self.trUtf8("Alternatives"))
+self.pygmentsSelAct.setData(QVariant("Alternatives"))
+self.connect(menu, SIGNAL('triggered(QAction *)'), self.__languageMenuTriggered)
+self.connect(menu, SIGNAL('aboutToShow()'), 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(QVariant(encoding))
+self.supportedEncodings[encoding] = act
+self.encodingsActGrp.addAction(act)
+self.connect(menu, SIGNAL('triggered(QAction *)'), self.__encodingsMenuTriggered)
+self.connect(menu, SIGNAL('aboutToShow()'), 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(QVariant('\n'))
+self.supportedEols['\n'] = act
+self.eolActGrp.addAction(act)
+act = menu.addAction(self.trUtf8("Windows"))
+act.setCheckable(True)
+act.setData(QVariant('\r\n'))
+self.supportedEols['\r\n'] = act
+self.eolActGrp.addAction(act)
+act = menu.addAction(self.trUtf8("Macintosh"))
+act.setCheckable(True)
+act.setData(QVariant('\r'))
+self.supportedEols['\r'] = act
+self.eolActGrp.addAction(act)
+self.connect(menu, SIGNAL('triggered(QAction *)'), self.__eolMenuTriggered)
+self.connect(menu, SIGNAL('aboutToShow()'), 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 = 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
+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.connect(self.bmMarginMenu, SIGNAL('aboutToShow()'),
+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.connect(self.bpMarginMenu, SIGNAL('aboutToShow()'),
+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["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.connect(self.indicMarginMenu, SIGNAL('aboutToShow()'),
+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["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.connect(self.marginMenu, SIGNAL('aboutToShow()'),
+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().toString()
+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|"):
+self.pygmentsSelAct.setText(
+self.trUtf8("Alternatives ({0})").format(self.getLanguage()))
+else:
+self.pygmentsSelAct.setText(self.trUtf8("Alternatives"))
+self.emit(SIGNAL("showMenu"), "Languages", self.languagesMenu,  self)
+def __selectPygmentsLexer(self):
+"""
+Private method to select a specific pygments lexer.
+@return name of the selected pygments lexer (string)
+"""
+from pygments.lexers import get_all_lexers
+lexerList = sorted([l[0] for l in get_all_lexers()])
+try:
+lexerSel = lexerList.index(self.getLanguage())
+except ValueError:
+lexerSel = 0
+lexerName, ok = QInputDialog.getItem(\
+self,
+self.trUtf8("Pygments Lexer"),
+self.trUtf8("Select the Pygments lexer to apply."),
+lexerList,
+lexerSel,
+False)
+if ok and lexerName:
+return lexerName
+else:
+return ""
+def __languageMenuTriggered(self, act):
+"""
+Private method to handle the selection of a lexer language.
+@param act reference to the action that was triggered (QAction)
+"""
+if act == self.noLanguageAct:
+self.__resetLanguage()
+elif act == self.pygmentsAct:
+self.setLanguage("dummy.pygments")
+elif act == self.pygmentsSelAct:
+language = self.__selectPygmentsLexer()
+if language:
+self.setLanguage("dummy.pygments", pyname = language)
+else:
+language = act.data().toString()
+if language:
+self.setLanguage(self.supportedLanguages[language][1])
+def languageChanged(self, language, propagate = True):
+"""
+Public slot handling a change of a connected editor's language.
+@param language language to be set (string)
+@keyparam propagate flag indicating to propagate the change (boolean)
+"""
+if language == '':
+self.__resetLanguage(propagate = propagate)
+elif language == "Guessed":
+self.setLanguage("dummy.pygments")
+elif language.startswith("Pygments|"):
+pyname = language.split("|", 1)[1]
+self.setLanguage("dummy.pygments", pyname = pyname)
+else:
+self.setLanguage(self.supportedLanguages[language][1], propagate = propagate)
+def __resetLanguage(self, propagate = True):
+"""
+Private method used to reset the language selection.
+@keyparam propagate flag indicating to propagate the change (boolean)
+"""
+if self.lexer_ is not None and \
+(self.lexer_.lexer() == "container" or self.lexer_.lexer() is None):
+self.disconnect(self, SIGNAL("SCN_STYLENEEDED(int)"), self.__styleNeeded)
+self.apiLanguage = ""
+self.lexer_ = None
+self.__lexerReset = True
+self.setLexer()
+self.setMonospaced(self.useMonospaced)
+if self.completer is not None:
+self.completer.setEnabled(False)
+self.completer = None
+self.__setTextDisplay()
+if not self.inLanguageChanged and propagate:
+self.inLanguageChanged = True
+self.emit(SIGNAL('languageChanged'), self.apiLanguage)
+self.inLanguageChanged = False
+def setLanguage(self, filename, initTextDisplay = True, propagate = True,
+pyname = ""):
+"""
+Public method to set a lexer language.
+@param filename filename used to determine the associated lexer language (string)
+@param initTextDisplay flag indicating an initialization of the text display
+is required as well (boolean)
+@keyparam propagate flag indicating to propagate the change (boolean)
+@keyparam pyname name of the pygments lexer to use (string)
+"""
+self.__lexerReset = False
+self.__bindLexer(filename, pyname = pyname)
+self.__bindCompleter(filename)
+self.recolor()
+self.__checkLanguage()
+# set the text display
+if initTextDisplay:
+self.__setTextDisplay()
+# set the autocompletion and calltips function
+self.__setAutoCompletion()
+self.__setCallTips()
+if not self.inLanguageChanged and propagate:
+self.inLanguageChanged = True
+self.emit(SIGNAL('languageChanged'), self.apiLanguage)
+self.inLanguageChanged = False
+def __checkLanguage(self):
+"""
+Private method to check the selected language of the language submenu.
+"""
+if self.apiLanguage == "":
+self.noLanguageAct.setChecked(True)
+elif self.apiLanguage == "Guessed":
+self.pygmentsAct.setChecked(True)
+elif self.apiLanguage.startswith("Pygments|"):
+act = self.languagesActGrp.checkedAction()
+if act:
+act.setChecked(False)
+else:
+self.supportedLanguages[self.apiLanguage][2].setChecked(True)
+def projectLexerAssociationsChanged(self):
+"""
+Public slot to handle changes of the project lexer associations.
+"""
+self.setLanguage(self.fileName)
+def __showContextMenuEncodings(self):
+"""
+Private slot handling the aboutToShow signal of the encodings context menu.
+"""
+self.emit(SIGNAL("showMenu"), "Encodings", self.encodingsMenu,  self)
+def __encodingsMenuTriggered(self, act):
+"""
+Private method to handle the selection of an encoding.
+@param act reference to the action that was triggered (QAction)
+"""
+encoding = act.data().toString()
+self.__encodingChanged("%s-selected" % encoding)
+def __checkEncoding(self):
+"""
+Private method to check the selected encoding of the encodings submenu.
+"""
+try:
+self.supportedEncodings[self.__normalizedEncoding()].setChecked(True)
+except (AttributeError, KeyError):
+pass
+def __encodingChanged(self, encoding, propagate = True):
+"""
+Private slot to handle a change of the encoding.
+@keyparam propagate flag indicating to propagate the change (boolean)
+"""
+self.encoding = encoding
+self.__checkEncoding()
+if not self.inEncodingChanged and propagate:
+self.inEncodingChanged = True
+self.emit(SIGNAL("encodingChanged"), self.encoding)
+self.inEncodingChanged = False
+def __normalizedEncoding(self):
+"""
+Private method to calculate the normalized encoding string.
+@return normalized encoding (string)
+"""
+return self.encoding.replace("-default", "")\
+.replace("-guessed", "")\
+.replace("-selected", "")
+def __showContextMenuEol(self):
+"""
+Private slot handling the aboutToShow signal of the eol context menu.
+"""
+self.emit(SIGNAL("showMenu"), "Eol", self.eolMenu,  self)
+def __eolMenuTriggered(self, act):
+"""
+Private method to handle the selection of an eol type.
+@param act reference to the action that was triggered (QAction)
+"""
+eol = act.data().toString()
+self.setEolModeByEolString(eol)
+self.convertEols(self.eolMode())
+def __checkEol(self):
+"""
+Private method to check the selected eol type of the eol submenu.
+"""
+try:
+self.supportedEols[self.getLineSeparator()].setChecked(True)
+except AttributeError:
+pass
+def __eolChanged(self):
+"""
+Private slot to handle a change of the eol mode.
+"""
+self.__checkEol()
+if not self.inEolChanged:
+self.inEolChanged = True
+eol = self.getLineSeparator()
+self.emit(SIGNAL("eolChanged"), eol)
+self.inEolChanged = False
+def __bindLexer(self, filename, pyname = ""):
+"""
+Private slot to set the correct lexer depending on language.
+@param filename filename used to determine the associated lexer language (string)
+@keyparam pyname name of the pygments lexer to use (string)
+"""
+if self.lexer_ is not None and \
+(self.lexer_.lexer() == "container" or self.lexer_.lexer() is None):
+self.disconnect(self, SIGNAL("SCN_STYLENEEDED(int)"), self.__styleNeeded)
+language = ""
+project = e4App().getObject("Project")
+if project.isOpen() and project.isProjectFile(filename):
+language = project.getEditorLexerAssoc(os.path.basename(filename))
+if not language:
+filename = os.path.basename(filename)
+language = Preferences.getEditorLexerAssoc(filename)
+if language.startswith("Pygments|"):
+pyname = language.split("|", 1)[1]
+language = ""
+self.lexer_ = Lexers.getLexer(language, self, pyname = pyname)
+if self.lexer_ is None:
+self.setLexer()
+self.apiLanguage = ""
+return
+if pyname:
+self.apiLanguage = "Pygments|%s" % pyname
+else:
+self.apiLanguage = self.lexer_.language()
+if self.apiLanguage == "POV":
+self.apiLanguage = "Povray"
+self.setLexer(self.lexer_)
+self.__setMarginsDisplay()
+if self.lexer_.lexer() == "container" or self.lexer_.lexer() is None:
+self.setStyleBits(self.lexer_.styleBitsNeeded())
+self.connect(self, SIGNAL("SCN_STYLENEEDED(int)"), self.__styleNeeded)
+# get the font for style 0 and set it as the default font
+key = 'Scintilla/%s/style0/font' % self.lexer_.language()
+fontVariant = Preferences.Prefs.settings.value(key)
+if fontVariant.isValid():
+fdesc = fontVariant.toStringList()
+font = QFont(fdesc[0], int(fdesc[1]))
+self.lexer_.setDefaultFont(font)
+self.lexer_.readSettings(Preferences.Prefs.settings, "Scintilla")
+# now set the lexer properties
+self.lexer_.initProperties()
+# initialize the auto indent style of the lexer
+ais = self.lexer_.autoIndentStyle()
+# initialize the lexer APIs settings
+api = self.vm.getAPIsManager().getAPIs(self.apiLanguage)
+if api is not None:
+self.lexer_.setAPIs(api.getQsciAPIs())
+self.acAPI = True
+else:
+self.acAPI = False
+self.emit(SIGNAL("autoCompletionAPIsAvailable"), self.acAPI)
+def __styleNeeded(self, position):
+"""
+Private slot to handle the need for more styling.
+@param position end position, that needs styling (integer)
+"""
+self.lexer_.styleText(self.getEndStyled(), position)
+def getLexer(self):
+"""
+Public method to retrieve a reference to the lexer object.
+@return the lexer object (Lexer)
+"""
+return self.lexer_
+def getLanguage(self):
+"""
+Public method to retrieve the language of the editor.
+@return language of the editor (string)
+"""
+if self.apiLanguage == "Guessed" or self.apiLanguage.startswith("Pygments|"):
+return self.lexer_.name()
+else:
+return self.apiLanguage
+def __bindCompleter(self, filename):
+"""
+Private slot to set the correct typing completer depending on language.
+@param filename filename used to determine the associated typing
+completer language (string)
+"""
+if self.completer is not None:
+self.completer.setEnabled(False)
+self.completer = None
+filename = os.path.basename(filename)
+apiLanguage = Preferences.getEditorLexerAssoc(filename)
+self.completer = TypingCompleters.getCompleter(apiLanguage, self)
+def getCompleter(self):
+"""
+Public method to retrieve a reference to the completer object.
+@return the completer object (CompleterBase)
+"""
+return self.completer
+def __modificationChanged(self, m):
+"""
+Private slot to handle the modificationChanged signal.
+It emits the signal modificationStatusChanged with parameters
+m and self.
+@param m modification status
+"""
+if not m and self.fileName is not None:
+self.lastModified = QFileInfo(self.fileName).lastModified()
+if Preferences.getEditor("AutoCheckSyntax"):
+self.clearSyntaxError()
+self.emit(SIGNAL('modificationStatusChanged'), m, self)
+self.emit(SIGNAL('undoAvailable'), self.isUndoAvailable())
+self.emit(SIGNAL('redoAvailable'), self.isRedoAvailable())
+def __cursorPositionChanged(self, line, index):
+"""
+Private slot to handle the cursorPositionChanged signal.
+It emits the signal cursorChanged with parameters fileName,
+line and pos.
+@param line line number of the cursor
+@param index position in line of the cursor
+"""
+self.emit(SIGNAL('cursorChanged'), self.fileName, line+1, index)
+if Preferences.getEditor("MarkOccurrencesEnabled"):
+self.__markOccurrencesTimer.stop()
+self.__markOccurrencesTimer.start()
+if self.spell is not None:
+# do spell checking
+doSpelling = True
+if self.lastLine == line:
+start, end = self.getWordBoundaries(line, index, useWordChars = False)
+if start <= self.lastIndex and self.lastIndex <= end:
+doSpelling = False
+if doSpelling:
+pos = self.positionFromLineIndex(self.lastLine, self.lastIndex)
+self.spell.checkWord(pos)
+self.lastLine = line
+self.lastIndex = index
+def __modificationReadOnly(self):
+"""
+Private slot to handle the modificationAttempted signal.
+"""
+QMessageBox.warning(None,
+self.trUtf8("Modification of Read Only file"),
+self.trUtf8("""You are attempting to change a read only file. """
+"""Please save to a different file first."""))
+def setNoName(self, noName):
+"""
+Public method to set the display string for an unnamed editor.
+@param noName display string for this unnamed editor (string)
+"""
+self.noName = noName
+def getNoName(self):
+"""
+Public method to get the display string for an unnamed editor.
+@return display string for this unnamed editor (string)
+"""
+return self.noName
+def getFileName(self):
+"""
+Public method to return the name of the file being displayed.
+@return filename of the displayed file (string)
+"""
+return self.fileName
+def getFileType(self):
+"""
+Public method to return the type of the file being displayed.
+@return type of the displayed file (string)
+"""
+return self.filetype
+def getEncoding(self):
+"""
+Public method to return the current encoding.
+@return current encoding (string)
+"""
+return self.encoding
+def getFolds(self):
+"""
+Public method to get a list line numbers of collapsed folds.
+@return list of line numbers of folded lines (list of integer)
+"""
+line = 0
+folds = []
+maxline = self.lines()
+while line < maxline:
+if self.foldHeaderAt(line) and not self.foldExpandedAt(line):
+folds.append(line)
+line += 1
+return folds
+def isPyFile(self):
+"""
+Public method to return a flag indicating a Python file.
+@return flag indicating a Python file (boolean)
+"""
+return self.filetype == "Python" or \
+(self.fileName is not None and \
+os.path.splitext(self.fileName)[1] in self.pyExtensions)
+def isPy3File(self):
+"""
+Public method to return a flag indicating a Python3 file.
+@return flag indicating a Python3 file (boolean)
+"""
+return self.filetype == "Python3" or \
+(self.fileName is not None and \
+os.path.splitext(self.fileName)[1] in self.py3Extensions)
+def isRubyFile(self):
+"""
+Public method to return a flag indicating a Ruby file.
+@return flag indicating a Ruby file (boolean)
+"""
+return self.filetype == "Ruby" or \
+(self.fileName is not None and \
+os.path.splitext(self.fileName)[1] in self.rbExtensions)
+def highlightVisible(self):
+"""
+Public method to make sure that the highlight is visible.
+"""
+if self.lastHighlight is not None:
+lineno = self.markerLine(self.lastHighlight)
+self.ensureVisible(lineno+1)
+def highlight(self, line = None, error = False, syntaxError = False):
+"""
+Public method to highlight (or de-highlight) a particular line.
+@param line line number to highlight (integer)
+@param error flag indicating whether the error highlight should be used (boolean)
+@param syntaxError flag indicating a syntax error (boolean)
+"""
+if line is None:
+self.lastHighlight = None
+if self.lastErrorMarker is not None:
+self.markerDeleteHandle(self.lastErrorMarker)
+self.lastErrorMarker = None
+if self.lastCurrMarker is not None:
+self.markerDeleteHandle(self.lastCurrMarker)
+self.lastCurrMarker = None
+else:
+if error:
+if self.lastErrorMarker is not None:
+self.markerDeleteHandle(self.lastErrorMarker)
+self.lastErrorMarker = self.markerAdd(line-1, self.errorline)
+self.lastHighlight = self.lastErrorMarker
+else:
+if self.lastCurrMarker is not None:
+self.markerDeleteHandle(self.lastCurrMarker)
+self.lastCurrMarker = self.markerAdd(line-1, self.currentline)
+self.lastHighlight = self.lastCurrMarker
+self.setCursorPosition(line-1, 0)
+def getHighlightPosition(self):
+"""
+Public method to return the position of the highlight bar.
+@return line number of the highlight bar (integer)
+"""
+if self.lastHighlight is not None:
+return self.markerLine(self.lastHighlight)
+else:
+return 1
+############################################################################
+## Breakpoint handling methods below
+############################################################################
+def __linesChanged(self):
+"""
+Private method to track text changes.
+This method checks, if lines have been inserted or removed in order to
+update the breakpoints.
+"""
+if self.breaks:
+bps = []    # list of breakpoints
+for handle, (ln, cond, temp, enabled, ignorecount) in self.breaks.items():
+line = self.markerLine(handle) + 1
+bps.append((ln, line, (cond, temp, enabled, ignorecount)))
+self.markerDeleteHandle(handle)
+self.breaks = {}
+for bp in bps:
+index = self.breakpointModel.getBreakPointIndex(self.fileName, bp[0])
+self.breakpointModel.setBreakPointByIndex(index,
+self.fileName, bp[1], bp[2])
+def __restoreBreakpoints(self):
+"""
+Private method to restore the breakpoints.
+"""
+for handle in self.breaks.keys():
+self.markerDeleteHandle(handle)
+self.__addBreakPoints(QModelIndex(), 0, self.breakpointModel.rowCount() - 1)
+def __deleteBreakPoints(self, parentIndex, start, end):
+"""
+Private slot to delete breakpoints.
+@param parentIndex index of parent item (QModelIndex)
+@param start start row (integer)
+@param end end row (integer)
+"""
+for row in range(start, end + 1):
+index = self.breakpointModel.index(row, 0, parentIndex)
+fn, lineno = self.breakpointModel.getBreakPointByIndex(index)[0:2]
+if fn == self.fileName:
+self.clearBreakpoint(lineno)
+def __changeBreakPoints(self, startIndex, endIndex):
+"""
+Private slot to set changed breakpoints.
+@param indexes indexes of changed breakpoints.
+"""
+self.__addBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
+def __breakPointDataAboutToBeChanged(self, startIndex, endIndex):
+"""
+Private slot to handle the dataAboutToBeChanged signal of the breakpoint model.
+@param startIndex start index of the rows to be changed (QModelIndex)
+@param endIndex end index of the rows to be changed (QModelIndex)
+"""
+self.__deleteBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
+def __addBreakPoints(self, parentIndex, start, end):
+"""
+Private slot to add breakpoints.
+@param parentIndex index of parent item (QModelIndex)
+@param start start row (integer)
+@param end end row (integer)
+"""
+for row in range(start, end + 1):
+index = self.breakpointModel.index(row, 0, parentIndex)
+fn, line, cond, temp, enabled, ignorecount = \
+self.breakpointModel.getBreakPointByIndex(index)[:6]
+if fn == self.fileName:
+self.newBreakpointWithProperties(line, (cond, temp, enabled, ignorecount))
+def clearBreakpoint(self, line):
+"""
+Public method to clear a breakpoint.
+Note: This doesn't clear the breakpoint in the debugger,
+it just deletes it from the editor internal list of breakpoints.
+@param line linenumber of the breakpoint (integer)
+"""
+for handle, (ln, _, _, _, _) in self.breaks.items():
+if self.markerLine(handle) == line-1:
+break
+else:
+# not found, simply ignore it
+return
+del self.breaks[handle]
+self.markerDeleteHandle(handle)
+def newBreakpointWithProperties(self, line, properties):
+"""
+Private method to set a new breakpoint and its properties.
+@param line line number of the breakpoint (integer)
+@param properties properties for the breakpoint (tuple)
+(condition, temporary flag, enabled flag, ignore count)
+"""
+if not properties[2]:
+marker = self.dbreakpoint
+elif properties[0]:
+marker = properties[1] and self.tcbreakpoint or self.cbreakpoint
+else:
+marker = properties[1] and self.tbreakpoint or self.breakpoint
+handle = self.markerAdd(line-1, marker)
+self.breaks[handle] = (line,) + properties
+self.emit(SIGNAL('breakpointToggled'), self)
+def __toggleBreakpoint(self, line, temporary = False):
+"""
+Private method to toggle a breakpoint.
+@param line line number of the breakpoint (integer)
+@param temporary flag indicating a temporary breakpoint (boolean)
+"""
+for handle, (ln, _, _, _, _) in self.breaks.items():
+if self.markerLine(handle) == line - 1:
+# delete breakpoint or toggle it to the next state
+index = self.breakpointModel.getBreakPointIndex(self.fileName, line)
+if Preferences.getDebugger("ThreeStateBreakPoints") and \
+not self.breakpointModel.isBreakPointTemporaryByIndex(index):
+self.breakpointModel.deleteBreakPointByIndex(index)
+self.__addBreakPoint(line, True)
+else:
+self.breakpointModel.deleteBreakPointByIndex(index)
+self.emit(SIGNAL('breakpointToggled'), self)
+break
+else:
+self.__addBreakPoint(line, temporary)
+def __addBreakPoint(self, line, temporary):
+"""
+Private method to add a new breakpoint.
+@param line line number of the breakpoint (integer)
+@param temporary flag indicating a temporary breakpoint (boolean)
+"""
+if self.fileName and \
+(self.isPyFile() or self.isPy3File() or self.isRubyFile()):
+self.breakpointModel.addBreakPoint(self.fileName, line,
+('', temporary, True, 0))
+self.emit(SIGNAL('breakpointToggled'), self)
+def __toggleBreakpointEnabled(self, line):
+"""
+Private method to toggle a breakpoints enabled status.
+@param line line number of the breakpoint (integer)
+"""
+for handle, (ln, cond, temp, enabled, ignorecount) in self.breaks.items():
+if self.markerLine(handle) == line - 1:
+break
+else:
+# no breakpoint found on that line
+return
+index = self.breakpointModel.getBreakPointIndex(self.fileName, line)
+self.breakpointModel.setBreakPointEnabledByIndex(index, not enabled)
+def curLineHasBreakpoint(self):
+"""
+Public method to check for the presence of a breakpoint at the current line.
+@return flag indicating the presence of a breakpoint (boolean)
+"""
+line, _ = self.getCursorPosition()
+return self.markersAtLine(line) & self.breakpointMask != 0
+def hasBreakpoints(self):
+"""
+Public method to check for the presence of breakpoints.
+@return flag indicating the presence of breakpoints (boolean)
+"""
+return len(self.breaks) > 0
+def __menuToggleTemporaryBreakpoint(self):
+"""
+Private slot to handle the 'Toggle temporary breakpoint' context menu action.
+"""
+if self.line < 0:
+self.line, index = self.getCursorPosition()
+self.line += 1
+self.__toggleBreakpoint(self.line, 1)
+self.line = -1
+def menuToggleBreakpoint(self):
+"""
+Public slot to handle the 'Toggle breakpoint' context menu action.
+"""
+if self.line < 0:
+self.line, index = self.getCursorPosition()
+self.line += 1
+self.__toggleBreakpoint(self.line)
+self.line = -1
+def __menuToggleBreakpointEnabled(self):
+"""
+Private slot to handle the 'Enable/Disable breakpoint' context menu action.
+"""
+if self.line < 0:
+self.line, index = self.getCursorPosition()
+self.line += 1
+self.__toggleBreakpointEnabled(self.line)
+self.line = -1
+def menuEditBreakpoint(self, line = None):
+"""
+Public slot to handle the 'Edit breakpoint' context menu action.
+@param line linenumber of the breakpoint to edit
+"""
+if line is not None:
+self.line = line - 1
+if self.line < 0:
+self.line, index = self.getCursorPosition()
+found = False
+for handle, (ln, cond, temp, enabled, ignorecount) in self.breaks.items():
+if self.markerLine(handle) == self.line:
+found = True
+break
+if found:
+index = self.breakpointModel.getBreakPointIndex(self.fileName, ln)
+if not index.isValid():
+return
+dlg = EditBreakpointDialog((self.fileName, ln),
+(cond, temp, enabled, ignorecount),
+self.condHistory, self, modal = True)
+if dlg.exec_() == QDialog.Accepted:
+cond, temp, enabled, ignorecount = dlg.getData()
+self.breakpointModel.setBreakPointByIndex(index,
+self.fileName, ln, (cond, temp, enabled, ignorecount))
+self.line = -1
+def menuNextBreakpoint(self):
+"""
+Public slot to handle the 'Next breakpoint' context menu action.
+"""
+line, index = self.getCursorPosition()
+if line == self.lines()-1:
+line = 0
+else:
+line += 1
+bpline = self.markerFindNext(line, self.breakpointMask)
+if bpline < 0:
+# wrap around
+bpline = self.markerFindNext(0, self.breakpointMask)
+if bpline >= 0:
+self.setCursorPosition(bpline, 0)
+self.ensureLineVisible(bpline)
+def menuPreviousBreakpoint(self):
+"""
+Public slot to handle the 'Previous breakpoint' context menu action.
+"""
+line, index = self.getCursorPosition()
+if line == 0:
+line = self.lines()-1
+else:
+line -= 1
+bpline = self.markerFindPrevious(line, self.breakpointMask)
+if bpline < 0:
+# wrap around
+bpline = self.markerFindPrevious(self.lines()-1, self.breakpointMask)
+if bpline >= 0:
+self.setCursorPosition(bpline, 0)
+self.ensureLineVisible(bpline)
+def __menuClearBreakpoints(self):
+"""
+Private slot to handle the 'Clear all breakpoints' context menu action.
+"""
+self.__clearBreakpoints(self.fileName)
+def __clearBreakpoints(self, fileName):
+"""
+Private slot to clear all breakpoints.
+"""
+idxList = []
+for handle, (ln, _, _, _, _) in self.breaks.items():
+index = self.breakpointModel.getBreakPointIndex(fileName, ln)
+if index.isValid():
+idxList.append(index)
+if idxList:
+self.breakpointModel.deleteBreakPoints(idxList)
+############################################################################
+## Bookmark handling methods below
+############################################################################
+def toggleBookmark(self, line):
+"""
+Public method to toggle a bookmark.
+@param line line number of the bookmark (integer)
+"""
+for handle in self.bookmarks:
+if self.markerLine(handle) == line - 1:
+break
+else:
+# set a new bookmark
+handle = self.markerAdd(line - 1, self.bookmark)
+self.bookmarks.append(handle)
+self.emit(SIGNAL('bookmarkToggled'), self)
+return
+self.bookmarks.remove(handle)
+self.markerDeleteHandle(handle)
+self.emit(SIGNAL('bookmarkToggled'), self)
+def getBookmarks(self):
+"""
+Public method to retrieve the bookmarks.
+@return sorted list of all lines containing a bookmark
+(list of integer)
+"""
+bmlist = []
+for handle in self.bookmarks:
+bmlist.append(self.markerLine(handle) + 1)
+bmlist.sort()
+return bmlist
+def hasBookmarks(self):
+"""
+Public method to check for the presence of bookmarks.
+@return flag indicating the presence of bookmarks (boolean)
+"""
+return len(self.bookmarks) > 0
+def menuToggleBookmark(self):
+"""
+Public slot to handle the 'Toggle bookmark' context menu action.
+"""
+if self.line < 0:
+self.line, index = self.getCursorPosition()
+self.line += 1
+self.toggleBookmark(self.line)
+self.line = -1
+def nextBookmark(self):
+"""
+Public slot to handle the 'Next bookmark' context menu action.
+"""
+line, index = self.getCursorPosition()
+if line == self.lines()-1:
+line = 0
+else:
+line += 1
+bmline = self.markerFindNext(line, 1 << self.bookmark)
+if bmline < 0:
+# wrap around
+bmline = self.markerFindNext(0, 1 << self.bookmark)
+if bmline >= 0:
+self.setCursorPosition(bmline, 0)
+self.ensureLineVisible(bmline)
+def previousBookmark(self):
+"""
+Public slot to handle the 'Previous bookmark' context menu action.
+"""
+line, index = self.getCursorPosition()
+if line == 0:
+line = self.lines()-1
+else:
+line -= 1
+bmline = self.markerFindPrevious(line, 1 << self.bookmark)
+if bmline < 0:
+# wrap around
+bmline = self.markerFindPrevious(self.lines() - 1, 1 << self.bookmark)
+if bmline >= 0:
+self.setCursorPosition(bmline, 0)
+self.ensureLineVisible(bmline)
+def clearBookmarks(self):
+"""
+Public slot to handle the 'Clear all bookmarks' context menu action.
+"""
+for handle in self.bookmarks:
+self.markerDeleteHandle(handle)
+self.bookmarks = []
+self.emit(SIGNAL('bookmarkToggled'), self)
+############################################################################
+## Printing methods below
+############################################################################
+def printFile(self):
+"""
+Public slot to print the text.
+"""
+printer = Printer(mode = QPrinter.HighResolution)
+sb = e4App().getObject("UserInterface").statusBar()
+printDialog = QPrintDialog(printer, self)
+if self.hasSelectedText():
+printDialog.addEnabledOption(QAbstractPrintDialog.PrintSelection)
+if printDialog.exec_() == QDialog.Accepted:
+sb.showMessage(self.trUtf8('Printing...'))
+QApplication.processEvents()
+fn = self.getFileName()
+if fn is not None:
+printer.setDocName(os.path.basename(fn))
+else:
+printer.setDocName(self.noName)
+if printDialog.printRange() == QAbstractPrintDialog.Selection:
+# get the selection
+fromLine, fromIndex, toLine, toIndex = self.getSelection()
+if toIndex == 0:
+toLine -= 1
+# Qscintilla seems to print one line more than told
+res = printer.printRange(self, fromLine, toLine-1)
+else:
+res = printer.printRange(self)
+if res:
+sb.showMessage(self.trUtf8('Printing completed'), 2000)
+else:
+sb.showMessage(self.trUtf8('Error while printing'), 2000)
+QApplication.processEvents()
+else:
+sb.showMessage(self.trUtf8('Printing aborted'), 2000)
+QApplication.processEvents()
+def printPreviewFile(self):
+"""
+Public slot to show a print preview of the text.
+"""
+from PyQt4.QtGui import QPrintPreviewDialog
+printer = Printer(mode = QPrinter.HighResolution)
+fn = self.getFileName()
+if fn is not None:
+printer.setDocName(os.path.basename(fn))
+else:
+printer.setDocName(self.noName)
+preview = QPrintPreviewDialog(printer, self)
+self.connect(preview, SIGNAL("paintRequested(QPrinter*)"), self.__printPreview)
+preview.exec_()
+def __printPreview(self, printer):
+"""
+Private slot to generate a print preview.
+@param printer reference to the printer object (QScintilla.Printer.Printer)
+"""
+printer.printRange(self)
+############################################################################
+## Task handling methods below
+############################################################################
+def hasTaskMarkers(self):
+"""
+Public method to determine, if this editor contains any task markers.
+@return flag indicating the presence of task markers (boolean)
+"""
+return self.__hasTaskMarkers
+def nextTask(self):
+"""
+Public slot to handle the 'Next task' context menu action.
+"""
+line, index = self.getCursorPosition()
+if line == self.lines()-1:
+line = 0
+else:
+line += 1
+taskline = self.markerFindNext(line, 1 << self.taskmarker)
+if taskline < 0:
+# wrap around
+taskline = self.markerFindNext(0, 1 << self.taskmarker)
+if taskline >= 0:
+self.setCursorPosition(taskline, 0)
+self.ensureLineVisible(taskline)
+def previousTask(self):
+"""
+Public slot to handle the 'Previous task' context menu action.
+"""
+line, index = self.getCursorPosition()
+if line == 0:
+line = self.lines()-1
+else:
+line -= 1
+taskline = self.markerFindPrevious(line, 1 << self.taskmarker)
+if taskline < 0:
+# wrap around
+taskline = self.markerFindPrevious(self.lines() - 1, 1 << self.taskmarker)
+if taskline >= 0:
+self.setCursorPosition(taskline, 0)
+self.ensureLineVisible(taskline)
+def extractTasks(self):
+"""
+Public slot to extract all tasks.
+"""
+todoMarkers = Preferences.getTasks("TasksMarkers").split()
+bugfixMarkers = Preferences.getTasks("TasksMarkersBugfix").split()
+txtList = self.text().split(self.getLineSeparator())
+# clear all task markers and tasks
+self.markerDeleteAll(self.taskmarker)
+self.taskViewer.clearFileTasks(self.fileName)
+self.__hasTaskMarkers = False
+# now search tasks and record them
+lineIndex = -1
+for line in txtList:
+lineIndex += 1
+shouldContinue = False
+# normal tasks first
+for tasksMarker in todoMarkers:
+index = line.find(tasksMarker)
+if index > -1:
+task = line[index:]
+self.markerAdd(lineIndex, self.taskmarker)
+self.taskViewer.addFileTask(task, self.fileName, lineIndex + 1, False)
+self.__hasTaskMarkers = True
+shouldContinue = True
+break
+if shouldContinue:
+continue
+# bugfix tasks second
+for tasksMarker in bugfixMarkers:
+index = line.find(tasksMarker)
+if index > -1:
+task = line[index:]
+self.markerAdd(lineIndex, self.taskmarker)
+self.taskViewer.addFileTask(task, self.fileName, lineIndex+1, True)
+self.__hasTaskMarkers = True
+break
+self.emit(SIGNAL('taskMarkersUpdated'), self)
+############################################################################
+## File handling methods below
+############################################################################
+def checkDirty(self):
+"""
+Public method to check dirty status and open a message window.
+@return flag indicating successful reset of the dirty flag (boolean)
+"""
+if self.isModified():
+fn = self.fileName
+if fn is None:
+fn = self.noName
+res = QMessageBox.warning(self.vm,
+self.trUtf8("File Modified"),
+self.trUtf8("<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 = self.saveFile()
+if ok:
+self.vm.setEditorName(self, newName)
+return ok
+elif res == QMessageBox.Abort or res == QMessageBox.Cancel:
+return False
+return True
+def revertToUnmodified(self):
+"""
+Public method to revert back to the last saved state.
+"""
+undo_ = True
+while self.isModified():
+if undo_:
+# try undo first
+if self.isUndoAvailable():
+self.undo()
+else:
+undo_ = False
+else:
+# try redo next
+if self.isRedoAvailable():
+self.redo()
+else:
+break
+# Couldn't find the unmodified state
+def readLine0(self, fn, createIt = False):
+"""
+Public slot to read the first line from a file.
+@param fn filename to read from (string)
+@param createIt flag indicating the creation of a new file, if the given
+one doesn't exist (boolean)
+@return first line of the file (string)
+"""
+try:
+if createIt and not os.path.exists(fn):
+f = open(fn, "wb")
+f.close()
+f = open(fn, 'rb')
+except IOError:
+QMessageBox.critical(self.vm, self.trUtf8('Open File'),
+self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>')
+.format(fn))
+raise
+txt = f.readline()
+f.close()
+return txt
+def readFile(self, fn, createIt = False):
+"""
+Public slot to read the text from a file.
+@param fn filename to read from (string)
+@param createIt flag indicating the creation of a new file, if the given
+one doesn't exist (boolean)
+"""
+try:
+if createIt and not os.path.exists(fn):
+f = open(fn, "wb")
+f.close()
+f = open(fn, 'rb')
+except IOError:
+QMessageBox.critical(self.vm, self.trUtf8('Open File'),
+self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>')
+.format(fn))
+raise
+QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
+if fn.endswith('.ts') or fn.endswith('.ui'):
+# special treatment for Qt-Linguist and Qt-Designer files
+txt = f.read()
+self.encoding = 'latin-1'
+else:
+txt, self.encoding = Utilities.decode(f.read())
+f.close()
+fileEol = self.detectEolString(txt)
+modified = False
+if (not Preferences.getEditor("TabForIndentation")) and \
+Preferences.getEditor("ConvertTabsOnLoad") and \
+not (self.lexer_ and \
+self.lexer_.alwaysKeepTabs()):
+txtExpanded = txt.expandtabs(Preferences.getEditor("TabWidth"))
+if txtExpanded != txt:
+modified = True
+txt = txtExpanded
+del txtExpanded
+self.setText(txt)
+# perform automatic eol conversion
+if Preferences.getEditor("AutomaticEOLConversion"):
+self.convertEols(self.eolMode())
+else:
+self.setEolModeByEolString(fileEol)
+self.extractTasks()
+QApplication.restoreOverrideCursor()
+self.setModified(modified)
+self.lastModified = QFileInfo(self.fileName).lastModified()
+def setEolModeByEolString(self, eolStr):
+"""
+Public method to set the eol mode given the eol string.
+@param eolStr eol string (string)
+"""
+if eolStr == '\r\n':
+self.setEolMode(QsciScintilla.EolMode(QsciScintilla.EolWindows))
+elif eolStr == '\n':
+self.setEolMode(QsciScintilla.EolMode(QsciScintilla.EolUnix))
+elif eolStr == '\r':
+self.setEolMode(QsciScintilla.EolMode(QsciScintilla.EolMac))
+self.__eolChanged()
+def __removeTrailingWhitespace(self):
+"""
+Private 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()
+def writeFile(self, fn):
+"""
+Public slot to write the text to a file.
+@param fn filename to write to (string)
+@return flag indicating success
+"""
+if Preferences.getEditor("StripTrailingWhitespace"):
+self.__removeTrailingWhitespace()
+txt = self.text()
+# work around glitch in scintilla: always make sure,
+# that the last line is terminated properly
+eol = self.getLineSeparator()
+if eol:
+if len(txt) >= len(eol):
+if txt[-len(eol):] != eol:
+txt += eol
+else:
+txt += eol
+try:
+txt, self.encoding = Utilities.encode(txt, self.encoding)
+except Utilities.CodingError, e:
+QMessageBox.critical(self, self.trUtf8('Save File'),
+self.trUtf8('<p>The file <b>{0}</b> could not be saved.<br/>'
+'Reason: {1}</p>')
+.format(fn, unicode(e)))
+return False
+# create a backup file, if the option is set
+createBackup = Preferences.getEditor("CreateBackupFile")
+if createBackup:
+if os.path.islink(fn):
+fn = os.path.realpath(fn)
+bfn = '%s~' % fn
+try:
+permissions = os.stat(fn).st_mode
+perms_valid = True
+except EnvironmentError:
+# if there was an error, ignore it
+perms_valid = False
+try:
+os.remove(bfn)
+except EnvironmentError:
+# if there was an error, ignore it
+pass
+try:
+os.rename(fn, bfn)
+except EnvironmentError:
+# if there was an error, ignore it
+pass
+# now write text to the file fn
+try:
+f = open(fn, 'wb')
+f.write(txt)
+f.close()
+if createBackup and perms_valid:
+os.chmod(fn, permissions)
+return True
+except IOError, why:
+QMessageBox.critical(self, self.trUtf8('Save File'),
+self.trUtf8('<p>The file <b>{0}</b> could not be saved.<br/>'
+'Reason: {1}</p>')
+.format(fn, unicode(why)))
+return False
+def saveFile(self, saveas = False, path = None):
+"""
+Public slot to save the text to a file.
+@param saveas flag indicating a 'save as' action (boolean)
+@param path directory to save the file in (string)
+@return tuple of two values (boolean, string) giving a success indicator and
+the name of the saved file
+"""
+if not saveas and not self.isModified():
+return (False, None)      # do nothing if text wasn't changed
+newName = None
+if saveas or self.fileName is None:
+saveas = True
+if not path and self.fileName is not None:
+path = os.path.dirname(self.fileName)
+if path is None:
+path = ""
+defaultFilter = Preferences.getEditor("DefaultSaveFilter")
+fn, selectedFilter = QFileDialog.getSaveFileNameAndFilter(
+self,
+self.trUtf8("Save File"),
+path,
+Lexers.getSaveFileFiltersList(True, True),
+defaultFilter,
+QFileDialog.Options(QFileDialog.DontConfirmOverwrite))
+if fn:
+ext = QFileInfo(fn).suffix()
+if not ext:
+ex = selectedFilter.split("(*")[1].split(")")[0]
+if ex:
+fn += ex
+if QFileInfo(fn).exists():
+res = QMessageBox.warning(self,
+self.trUtf8("Save File"),
+self.trUtf8("<p>The file <b>{0}</b> already exists.</p>")
+.format(fn),
+QMessageBox.StandardButtons(\
+QMessageBox.Abort | \
+QMessageBox.Save),
+QMessageBox.Abort)
+if res == QMessageBox.Abort or res == QMessageBox.Cancel:
+return (False, None)
+fn = Utilities.toNativeSeparators(fn)
+newName = fn
+else:
+return (False, None)
+else:
+fn = self.fileName
+self.emit(SIGNAL('editorAboutToBeSaved'), self.fileName)
+if self.writeFile(fn):
+if saveas:
+self.__clearBreakpoints(self.fileName)
+self.fileName = fn
+self.setModified(False)
+self.setReadOnly(False)
+self.setWindowTitle(self.fileName)
+if self.lexer_ is None and not self.__lexerReset:
+self.setLanguage(self.fileName)
+if saveas:
+self.isResourcesFile = self.fileName.endswith(".qrc")
+self.__initContextMenu()
+self.emit(SIGNAL('editorRenamed'), self.fileName)
+self.lastModified = QFileInfo(self.fileName).lastModified()
+if newName is not None:
+self.vm.addToRecentList(newName)
+self.emit(SIGNAL('editorSaved'), self.fileName)
+self.__autoSyntaxCheck()
+self.extractTasks()
+return (True, self.fileName)
+else:
+self.lastModified = QFileInfo(fn).lastModified()
+return (False, None)
+def saveFileAs(self, path = None):
+"""
+Public slot to save a file with a new name.
+@param path directory to save the file in (string)
+@return tuple of two values (boolean, string) giving a success indicator and
+the name of the saved file
+"""
+return self.saveFile(True, path)
+def handleRenamed(self, fn):
+"""
+Public slot to handle the editorRenamed signal.
+@param fn filename to be set for the editor (string).
+"""
+self.__clearBreakpoints(fn)
+self.fileName = fn
+self.setWindowTitle(self.fileName)
+if self.lexer_ is None:
+self.setLanguage(self.fileName)
+self.lastModified = QFileInfo(self.fileName).lastModified()
+self.vm.setEditorName(self, self.fileName)
+self.__updateReadOnly(True)
+def fileRenamed(self, fn):
+"""
+Public slot to handle the editorRenamed signal.
+@param fn filename to be set for the editor (string).
+"""
+self.handleRenamed(fn)
+if not self.inFileRenamed:
+self.inFileRenamed = True
+self.emit(SIGNAL('editorRenamed'), self.fileName)
+self.inFileRenamed = False
+############################################################################
+## Utility methods below
+############################################################################
+def ensureVisible(self, line):
+"""
+Public slot to ensure, that the specified line is visible.
+@param line line number to make visible
+"""
+self.ensureLineVisible(line-1)
+def ensureVisibleTop(self, line):
+"""
+Public slot to ensure, that the specified line is visible at the top
+of the editor.
+@param line line number to make visible
+"""
+topLine = self.firstVisibleLine()
+linesToScroll = line - topLine
+self.scrollVertical(linesToScroll)
+def __marginClicked(self, margin, line, modifiers):
+"""
+Private slot to handle the marginClicked signal.
+@param margin id of the clicked margin (integer)
+@param line line number of the click (integer)
+@param modifiers keyboard modifiers (Qt.KeyboardModifiers)
+"""
+if self.__unifiedMargins:
+if margin == 1:
+if modifiers & Qt.KeyboardModifiers(Qt.ShiftModifier):
+if self.marginMenuActs["LMBbreakpoints"].isChecked():
+self.toggleBookmark(line + 1)
+else:
+self.__toggleBreakpoint(line + 1)
+elif modifiers & Qt.KeyboardModifiers(Qt.ControlModifier):
+if self.markersAtLine(line) & (1 << self.syntaxerror):
+self.__showSyntaxError(line)
+else:
+if self.marginMenuActs["LMBbreakpoints"].isChecked():
+self.__toggleBreakpoint(line + 1)
+else:
+self.toggleBookmark(line + 1)
+else:
+if margin == self.__bmMargin:
+self.toggleBookmark(line + 1)
+elif margin == self.__bpMargin:
+self.__toggleBreakpoint(line + 1)
+elif margin == self.__indicMargin:
+if self.markersAtLine(line) & (1 << self.syntaxerror):
+self.__showSyntaxError(line)
+def handleMonospacedEnable(self):
+"""
+Private slot to handle the Use Monospaced Font context menu entry.
+"""
+if self.menuActs["MonospacedFont"].isChecked():
+self.setMonospaced(True)
+else:
+if self.lexer_:
+self.lexer_.readSettings(Preferences.Prefs.settings, "Scintilla")
+self.lexer_.initProperties()
+self.setMonospaced(False)
+self.__setMarginsDisplay()
+def getWordBoundaries(self, line, index, useWordChars = True):
+"""
+Public method to get the word boundaries at a position.
+@param line number of line to look at (int)
+@param index position to look at (int)
+@keyparam useWordChars flag indicating to use the wordCharacters
+method (boolean)
+@return tuple with start and end indices of the word at the position
+(integer, integer)
+"""
+text = self.text(line)
+if self.caseSensitive():
+cs = Qt.CaseSensitive
+else:
+cs = Qt.CaseInsensitive
+wc = self.wordCharacters()
+if wc is None or not useWordChars:
+regExp = QRegExp('[^\w_]', cs)
+else:
+regExp = QRegExp('[^%s]' % re.escape(wc), cs)
+start = regExp.lastIndexIn(text, index) + 1
+end = regExp.indexIn(text, index)
+if start == end + 1 and index > 0:
+# we are on a word boundary, try again
+start = regExp.lastIndexIn(text, index - 1) + 1
+if start == -1:
+start = 0
+if end == -1:
+end = len(text)
+return (start, end)
+def getWord(self, line, index, direction = 0, useWordChars = True):
+"""
+Public method to get the word at a position.
+@param line number of line to look at (int)
+@param index position to look at (int)
+@param direction direction to look in (0 = whole word, 1 = left, 2 = right)
+@keyparam useWordChars flag indicating to use the wordCharacters
+method (boolean)
+@return the word at that position (string)
+"""
+start, end = self.getWordBoundaries(line, index, useWordChars)
+if direction == 1:
+end = index
+elif direction == 2:
+start = index
+if end > start:
+text = self.text(line)
+word = text[start:end]
+else:
+word = ''
+return word
+def getWordLeft(self, line, index):
+"""
+Public method to get the word to the left of a position.
+@param line number of line to look at (int)
+@param index position to look at (int)
+@return the word to the left of that position (string)
+"""
+return self.getWord(line, index, 1)
+def getWordRight(self, line, index):
+"""
+Public method to get the word to the right of a position.
+@param line number of line to look at (int)
+@param index position to look at (int)
+@return the word to the right of that position (string)
+"""
+return self.getWord(line, index, 2)
+def getCurrentWord(self):
+"""
+Public method to get the word at the current position.
+@return the word at that current position (string)
+"""
+line, index = self.getCursorPosition()
+return self.getWord(line, index)
+def selectWord(self, line, index):
+"""
+Public method to select the word at a position.
+@param line number of line to look at (int)
+@param index position to look at (int)
+"""
+start, end = self.getWordBoundaries(line, index)
+self.setSelection(line, start, line, end)
+def selectCurrentWord(self):
+"""
+Public method to select the current word.
+"""
+line, index = self.getCursorPosition()
+self.selectWord(line, index)
+def __getCharacter(self, pos):
+"""
+Private method to get the character to the left of the current position
+in the current line.
+@param pos position to get character at (integer)
+@return requested character or "", if there are no more (string) and
+the next position (i.e. pos - 1)
+"""
+if pos <= 0:
+return "", pos
+pos = self.positionBefore(pos)
+ch = self.charAt(pos)
+# Don't go past the end of the previous line
+if ch == '\n' or ch == '\r':
+return "", pos
+return ch, pos
+def getSearchText(self, selectionOnly = False):
+"""
+Public method to determine the selection or the current word for the next
+search operation.
+@param selectionOnly flag indicating that only selected text should be
+returned (boolean)
+@return selection or current word (string)
+"""
+if self.hasSelectedText():
+text = self.selectedText()
+if '\r' in text or '\n' in text:
+# the selection contains at least a newline, it is
+# unlikely to be the expression to search for
+return ''
+return text
+if not selectionOnly:
+# no selected text, determine the word at the current position
+return self.getCurrentWord()
+return ''
+def setSearchIndicator(self, startPos, indicLength):
+"""
+Public method to set a search indicator for the given range.
+@param startPos start position of the indicator (integer)
+@param indicLength length of the indicator (integer)
+"""
+self.setIndicatorRange(self.searchIndicator, startPos, indicLength)
+def clearSearchIndicators(self):
+"""
+Public method to clear all search indicators.
+"""
+self.clearAllIndicators(self.searchIndicator)
+self.__markedText = ""
+def __markOccurrences(self):
+"""
+Private method to mark all occurrences of the current word.
+"""
+word = self.getCurrentWord()
+if not word:
+self.clearSearchIndicators()
+return
+if self.__markedText == word:
+return
+self.clearSearchIndicators()
+ok = self.findFirstTarget(word, False, self.caseSensitive(), True, 0, 0)
+while ok:
+tgtPos, tgtLen = self.getFoundTarget()
+self.setSearchIndicator(tgtPos, tgtLen)
+ok = self.findNextTarget()
+self.__markedText = word
+############################################################################
+## Comment handling methods below
+############################################################################
+def commentLine(self):
+"""
+Public slot to comment the current line.
+"""
+if self.lexer_ is None or not self.lexer_.canBlockComment():
+return
+line, index = self.getCursorPosition()
+self.beginUndoAction()
+if Preferences.getEditor("CommentColumn0"):
+self.insertAt(self.lexer_.commentStr(), line, 0)
+else:
+self.insertAt(self.lexer_.commentStr(), line, self.indentation(line))
+self.endUndoAction()
+def uncommentLine(self):
+"""
+Public slot to uncomment the current line.
+"""
+if self.lexer_ is None or not self.lexer_.canBlockComment():
+return
+commentStr = self.lexer_.commentStr()
+line, index = self.getCursorPosition()
+# check if line starts with our comment string (i.e. was commented
+# by our comment...() slots
+if not self.text(line).strip().startswith(commentStr):
+return
+# now remove the comment string
+self.beginUndoAction()
+if Preferences.getEditor("CommentColumn0"):
+self.setSelection(line, 0, line, len(commentStr))
+else:
+self.setSelection(line, self.indentation(line),
+line, self.indentation(line) + len(commentStr))
+self.removeSelectedText()
+self.endUndoAction()
+def commentSelection(self):
+"""
+Public slot to comment the current selection.
+"""
+if self.lexer_ is None or not self.lexer_.canBlockComment():
+return
+if not self.hasSelectedText():
+return
+commentStr = self.lexer_.commentStr()
+# get the selection boundaries
+lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
+if indexTo == 0:
+endLine = lineTo - 1
+else:
+endLine = lineTo
+self.beginUndoAction()
+# iterate over the lines
+for line in range(lineFrom, endLine + 1):
+if Preferences.getEditor("CommentColumn0"):
+self.insertAt(commentStr, line, 0)
+else:
+self.insertAt(commentStr, line, self.indentation(line))
+# change the selection accordingly
+self.setSelection(lineFrom, 0, endLine + 1, 0)
+self.endUndoAction()
+def uncommentSelection(self):
+"""
+Public slot to uncomment the current selection.
+"""
+if self.lexer_ is None or not self.lexer_.canBlockComment():
+return
+if not self.hasSelectedText():
+return
+commentStr = self.lexer_.commentStr()
+# get the selection boundaries
+lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
+if indexTo == 0:
+endLine = lineTo - 1
+else:
+endLine = lineTo
+self.beginUndoAction()
+# iterate over the lines
+for line in range(lineFrom, endLine+1):
+# check if line starts with our comment string (i.e. was commented
+# by our comment...() slots
+if not self.text(line).strip().startswith(commentStr):
+continue
+if Preferences.getEditor("CommentColumn0"):
+self.setSelection(line, 0, line, len(commentStr))
+else:
+self.setSelection(line, self.indentation(line),
+line, self.indentation(line) + len(commentStr))
+self.removeSelectedText()
+# adjust selection start
+if line == lineFrom:
+indexFrom -= len(commentStr)
+if indexFrom < 0:
+indexFrom = 0
+# adjust selection end
+if line == lineTo:
+indexTo -= len(commentStr)
+if indexTo < 0:
+indexTo = 0
+# change the selection accordingly
+self.setSelection(lineFrom, indexFrom, lineTo, indexTo)
+self.endUndoAction()
+def commentLineOrSelection(self):
+"""
+Public slot to comment the current line or current selection.
+"""
+if self.hasSelectedText():
+self.commentSelection()
+else:
+self.commentLine()
+def uncommentLineOrSelection(self):
+"""
+Public slot to uncomment the current line or current selection.
+"""
+if self.hasSelectedText():
+self.uncommentSelection()
+else:
+self.uncommentLine()
+def streamCommentLine(self):
+"""
+Public slot to stream comment the current line.
+"""
+if self.lexer_ is None or not self.lexer_.canStreamComment():
+return
+commentStr = self.lexer_.streamCommentStr()
+line, index = self.getCursorPosition()
+self.beginUndoAction()
+self.insertAt(commentStr['end'], line, self.lineLength(line))
+self.insertAt(commentStr['start'], line, 0)
+self.endUndoAction()
+def streamCommentSelection(self):
+"""
+Public slot to comment the current selection.
+"""
+if self.lexer_ is None or not self.lexer_.canStreamComment():
+return
+if not self.hasSelectedText():
+return
+commentStr = self.lexer_.streamCommentStr()
+# get the selection boundaries
+lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
+if indexTo == 0:
+endLine = lineTo - 1
+endIndex = self.lineLength(endLine)
+else:
+endLine = lineTo
+endIndex = indexTo
+self.beginUndoAction()
+self.insertAt(commentStr['end'], endLine, endIndex)
+self.insertAt(commentStr['start'], lineFrom, indexFrom)
+# change the selection accordingly
+if indexTo > 0:
+indexTo += len(commentStr['end'])
+if lineFrom == endLine:
+indexTo += len(commentStr['start'])
+self.setSelection(lineFrom, indexFrom, lineTo, indexTo)
+self.endUndoAction()
+def streamCommentLineOrSelection(self):
+"""
+Public slot to stream comment the current line or current selection.
+"""
+if self.hasSelectedText():
+self.streamCommentSelection()
+else:
+self.streamCommentLine()
+def boxCommentLine(self):
+"""
+Public slot to box comment the current line.
+"""
+if self.lexer_ is None or not self.lexer_.canBoxComment():
+return
+commentStr = self.lexer_.boxCommentStr()
+line, index = self.getCursorPosition()
+eol = self.getLineSeparator()
+self.beginUndoAction()
+self.insertAt(eol, line, self.lineLength(line))
+self.insertAt(commentStr['end'], line + 1, 0)
+self.insertAt(commentStr['middle'], line, 0)
+self.insertAt(eol, line, 0)
+self.insertAt(commentStr['start'], line, 0)
+self.endUndoAction()
+def boxCommentSelection(self):
+"""
+Public slot to box comment the current selection.
+"""
+if self.lexer_ is None or not self.lexer_.canBoxComment():
+return
+if not self.hasSelectedText():
+return
+commentStr = self.lexer_.boxCommentStr()
+# get the selection boundaries
+lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
+if indexTo == 0:
+endLine = lineTo - 1
+else:
+endLine = lineTo
+self.beginUndoAction()
+# iterate over the lines
+for line in range(lineFrom, endLine + 1):
+self.insertAt(commentStr['middle'], line, 0)
+# now do the comments before and after the selection
+eol = self.getLineSeparator()
+self.insertAt(eol, endLine, self.lineLength(endLine))
+self.insertAt(commentStr['end'], endLine + 1, 0)
+self.insertAt(eol, lineFrom, 0)
+self.insertAt(commentStr['start'], lineFrom, 0)
+# change the selection accordingly
+self.setSelection(lineFrom, 0, endLine + 3, 0)
+self.endUndoAction()
+def boxCommentLineOrSelection(self):
+"""
+Public slot to box comment the current line or current selection.
+"""
+if self.hasSelectedText():
+self.boxCommentSelection()
+else:
+self.boxCommentLine()
+############################################################################
+## Indentation handling methods below
+############################################################################
+def __indentLine(self, indent = True):
+"""
+Private method to indent or unindent the current line.
+@param indent flag indicating an indent operation (boolean)
+<br />If the flag is true, an indent operation is performed.
+Otherwise the current line is unindented.
+"""
+line, index = self.getCursorPosition()
+self.beginUndoAction()
+if indent:
+self.indent(line)
+else:
+self.unindent(line)
+self.endUndoAction()
+if indent:
+self.setCursorPosition(line, index + self.indentationWidth())
+else:
+self.setCursorPosition(line, index - self.indentationWidth())
+def __indentSelection(self, indent = True):
+"""
+Private method to indent or unindent the current selection.
+@param indent flag indicating an indent operation (boolean)
+<br />If the flag is true, an indent operation is performed.
+Otherwise the current line is unindented.
+"""
+if not self.hasSelectedText():
+return
+# get the selection
+lineFrom, indexFrom, lineTo, indexTo = self.getSelection()
+if indexTo == 0:
+endLine = lineTo - 1
+else:
+endLine = lineTo
+self.beginUndoAction()
+# iterate over the lines
+for line in range(lineFrom, endLine + 1):
+if indent:
+self.indent(line)
+else:
+self.unindent(line)
+self.endUndoAction()
+if indent:
+if indexTo == 0:
+self.setSelection(lineFrom, indexFrom + self.indentationWidth(),
+lineTo, 0)
+else:
+self.setSelection(lineFrom, indexFrom + self.indentationWidth(),
+lineTo, indexTo + self.indentationWidth())
+else:
+indexStart = indexFrom - self.indentationWidth()
+if indexStart < 0:
+indexStart = 0
+indexEnd = indexTo - self.indentationWidth()
+if indexEnd < 0:
+indexEnd = 0
+self.setSelection(lineFrom, indexStart, lineTo, indexEnd)
+def indentLineOrSelection(self):
+"""
+Public slot to indent the current line or current selection
+"""
+if self.hasSelectedText():
+self.__indentSelection(True)
+else:
+self.__indentLine(True)
+def unindentLineOrSelection(self):
+"""
+Public slot to unindent the current line or current selection.
+"""
+if self.hasSelectedText():
+self.__indentSelection(False)
+else:
+self.__indentLine(False)
+def smartIndentLineOrSelection(self):
+"""
+Public slot to indent current line smartly.
+"""
+if self.hasSelectedText():
+if self.lexer_ and self.lexer_.hasSmartIndent():
+self.lexer_.smartIndentSelection(self)
+else:
+self.__indentSelection(True)
+else:
+if self.lexer_ and self.lexer_.hasSmartIndent():
+self.lexer_.smartIndentLine(self)
+else:
+self.__indentLine(True)
+def gotoLine(self, line):
+"""
+Public slot to jump to the beginning of a line.
+@param line line number to go to (integer)
+"""
+self.setCursorPosition(line - 1, 0)
+self.ensureVisible(line)
+############################################################################
+## Setup methods below
+############################################################################
+def readSettings(self):
+"""
+Public slot to read the settings into our lexer.
+"""
+# read the lexer settings and reinit the properties
+if self.lexer_ is not None:
+self.lexer_.readSettings(Preferences.Prefs.settings, "Scintilla")
+self.lexer_.initProperties()
+# initialize the auto indent style of the lexer
+ais = self.lexer_.autoIndentStyle()
+# read the typing completer settings
+if self.completer is not None:
+self.completer.readSettings()
+# set the margins layout
+if QSCINTILLA_VERSION() >= 0x020301:
+self.__unifiedMargins = Preferences.getEditor("UnifiedMargins")
+# set the line marker colours
+self.__setLineMarkerColours()
+# set the text display
+self.__setTextDisplay()
+# set margin 0 and 2 configuration
+self.__setMarginsDisplay()
+# set the autocompletion and calltips function
+self.__setAutoCompletion()
+self.__setCallTips()
+# set the autosave flags
+self.autosaveEnabled = Preferences.getEditor("AutosaveInterval") > 0
+if Preferences.getEditor("MiniContextMenu") != self.miniMenu:
+# regenerate context menu
+self.__initContextMenu()
+else:
+# set checked context menu items
+self.menuActs["AutoCompletionEnable"].setChecked(\
+self.autoCompletionThreshold() != -1)
+self.menuActs["MonospacedFont"].setChecked(\
+self.useMonospaced)
+self.menuActs["AutosaveEnable"].setChecked(\
+self.autosaveEnabled and not self.autosaveManuallyDisabled)
+# regenerate the margins context menu(s)
+self.__initContextMenuMargins()
+if Preferences.getEditor("MarkOccurrencesEnabled"):
+self.__markOccurrencesTimer.setInterval(
+Preferences.getEditor("MarkOccurrencesTimeout"))
+else:
+self.__markOccurrencesTimer.stop()
+self.clearSearchIndicators()
+def __setLineMarkerColours(self):
+"""
+Private method to set the line marker colours.
+"""
+self.setMarkerForegroundColor(Preferences.getEditorColour("CurrentMarker"),
+self.currentline)
+self.setMarkerBackgroundColor(Preferences.getEditorColour("CurrentMarker"),
+self.currentline)
+self.setMarkerForegroundColor(Preferences.getEditorColour("ErrorMarker"),
+self.errorline)
+self.setMarkerBackgroundColor(Preferences.getEditorColour("ErrorMarker"),
+self.errorline)
+def __setMarginsDisplay(self):
+"""
+Private method to configure margins 0 and 2.
+"""
+# set the settings for all margins
+self.setMarginsFont(Preferences.getEditorOtherFonts("MarginsFont"))
+self.setMarginsForegroundColor(Preferences.getEditorColour("MarginsForeground"))
+self.setMarginsBackgroundColor(Preferences.getEditorColour("MarginsBackground"))
+# reset standard margins settings
+for margin in range(5):
+self.setMarginLineNumbers(margin, False)
+self.setMarginMarkerMask(margin, 0)
+self.setMarginWidth(margin, 0)
+self.setMarginSensitivity(margin, False)
+# set marker margin(s) settings
+if self.__unifiedMargins:
+margin1Mask = (1 << self.breakpoint)   | \
+(1 << self.cbreakpoint)  | \
+(1 << self.tbreakpoint)  | \
+(1 << self.tcbreakpoint) | \
+(1 << self.dbreakpoint)  | \
+(1 << self.currentline)  | \
+(1 << self.errorline)    | \
+(1 << self.bookmark)     | \
+(1 << self.syntaxerror)  | \
+(1 << self.notcovered)   | \
+(1 << self.taskmarker)
+self.setMarginWidth(1, 16)
+self.setMarginSensitivity(1, True)
+self.setMarginMarkerMask(1, margin1Mask)
+self.__linenoMargin = 0
+self.__foldMargin = 2
+else:
+self.__bmMargin = 0
+self.__linenoMargin = 1
+self.__bpMargin = 2
+self.__foldMargin = 3
+self.__indicMargin = 4
+marginBmMask = (1 << self.bookmark)
+self.setMarginWidth(self.__bmMargin, 16)
+self.setMarginSensitivity(self.__bmMargin, True)
+self.setMarginMarkerMask(self.__bmMargin, marginBmMask)
+marginBpMask = (1 << self.breakpoint)   | \
+(1 << self.cbreakpoint)  | \
+(1 << self.tbreakpoint)  | \
+(1 << self.tcbreakpoint) | \
+(1 << self.dbreakpoint)  | \
+(1 << self.currentline)  | \
+(1 << self.errorline)
+self.setMarginWidth(self.__bpMargin, 16)
+self.setMarginSensitivity(self.__bpMargin, True)
+self.setMarginMarkerMask(self.__bpMargin, marginBpMask)
+marginIndicMask = (1 << self.syntaxerror)  | \
+(1 << self.notcovered)   | \
+(1 << self.taskmarker)
+self.setMarginWidth(self.__indicMargin, 16)
+self.setMarginSensitivity(self.__indicMargin, True)
+self.setMarginMarkerMask(self.__indicMargin, marginIndicMask)
+# set linenumber margin settings
+linenoMargin = Preferences.getEditor("LinenoMargin")
+self.setMarginLineNumbers(self.__linenoMargin, linenoMargin)
+if linenoMargin:
+self.setMarginWidth(self.__linenoMargin,
+' ' + '8' * Preferences.getEditor("LinenoWidth"))
+else:
+self.setMarginWidth(self.__linenoMargin, 0)
+# set folding margin settings
+if Preferences.getEditor("FoldingMargin"):
+self.setMarginWidth(self.__foldMargin, 16)
+folding = Preferences.getEditor("FoldingStyle")
+try:
+folding = QsciScintilla.FoldStyle(folding)
+except AttributeError:
+pass
+try:
+self.setFolding(folding, self.__foldMargin)
+except TypeError:
+self.setFolding(folding)
+self.setFoldMarginColors(Preferences.getEditorColour("FoldmarginBackground"),
+Preferences.getEditorColour("FoldmarginBackground"))
+else:
+self.setMarginWidth(self.__foldMargin, 0)
+try:
+self.setFolding(QsciScintilla.NoFoldStyle, self.__foldMargin)
+except TypeError:
+self.setFolding(QsciScintilla.NoFoldStyle)
+def __setTextDisplay(self):
+"""
+Private method to configure the text display.
+"""
+self.setTabWidth(Preferences.getEditor("TabWidth"))
+self.setIndentationWidth(Preferences.getEditor("IndentWidth"))
+if self.lexer_ and self.lexer_.alwaysKeepTabs():
+self.setIndentationsUseTabs(True)
+else:
+self.setIndentationsUseTabs(Preferences.getEditor("TabForIndentation"))
+self.setTabIndents(Preferences.getEditor("TabIndents"))
+self.setBackspaceUnindents(Preferences.getEditor("TabIndents"))
+self.setIndentationGuides(Preferences.getEditor("IndentationGuides"))
+if Preferences.getEditor("ShowWhitespace"):
+self.setWhitespaceVisibility(QsciScintilla.WsVisible)
+else:
+self.setWhitespaceVisibility(QsciScintilla.WsInvisible)
+self.setEolVisibility(Preferences.getEditor("ShowEOL"))
+self.setAutoIndent(Preferences.getEditor("AutoIndentation"))
+if Preferences.getEditor("BraceHighlighting"):
+self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
+else:
+self.setBraceMatching(QsciScintilla.NoBraceMatch)
+self.setMatchedBraceForegroundColor(
+Preferences.getEditorColour("MatchingBrace"))
+self.setMatchedBraceBackgroundColor(
+Preferences.getEditorColour("MatchingBraceBack"))
+self.setUnmatchedBraceForegroundColor(
+Preferences.getEditorColour("NonmatchingBrace"))
+self.setUnmatchedBraceBackgroundColor(
+Preferences.getEditorColour("NonmatchingBraceBack"))
+if Preferences.getEditor("CustomSelectionColours"):
+self.setSelectionBackgroundColor(\
+Preferences.getEditorColour("SelectionBackground"))
+else:
+self.setSelectionBackgroundColor(\
+QApplication.palette().color(QPalette.Highlight))
+if Preferences.getEditor("ColourizeSelText"):
+self.resetSelectionForegroundColor()
+elif Preferences.getEditor("CustomSelectionColours"):
+self.setSelectionForegroundColor(\
+Preferences.getEditorColour("SelectionForeground"))
+else:
+self.setSelectionForegroundColor(\
+QApplication.palette().color(QPalette.HighlightedText))
+self.setSelectionToEol(Preferences.getEditor("ExtendSelectionToEol"))
+self.setCaretForegroundColor(
+Preferences.getEditorColour("CaretForeground"))
+self.setCaretLineBackgroundColor(
+Preferences.getEditorColour("CaretLineBackground"))
+self.setCaretLineVisible(Preferences.getEditor("CaretLineVisible"))
+self.caretWidth = Preferences.getEditor("CaretWidth")
+self.setCaretWidth(self.caretWidth)
+self.useMonospaced = Preferences.getEditor("UseMonospacedFont")
+self.setMonospaced(self.useMonospaced)
+edgeMode = Preferences.getEditor("EdgeMode")
+edge = QsciScintilla.EdgeMode(edgeMode)
+self.setEdgeMode(edge)
+if edgeMode:
+self.setEdgeColumn(Preferences.getEditor("EdgeColumn"))
+self.setEdgeColor(Preferences.getEditorColour("Edge"))
+if Preferences.getEditor("WrapLongLines"):
+self.setWrapMode(QsciScintilla.WrapWord)
+self.setWrapVisualFlags(\
+QsciScintilla.WrapFlagByBorder, QsciScintilla.WrapFlagByBorder)
+else:
+self.setWrapMode(QsciScintilla.WrapNone)
+self.setWrapVisualFlags(\
+QsciScintilla.WrapFlagNone, QsciScintilla.WrapFlagNone)
+self.searchIndicator = QsciScintilla.INDIC_CONTAINER
+self.indicatorDefine(self.searchIndicator, QsciScintilla.INDIC_BOX,
+Preferences.getEditorColour("SearchMarkers"))
+if not Preferences.getEditor("SearchMarkersEnabled") and \
+not Preferences.getEditor("QuickSearchMarkersEnabled") and \
+not Preferences.getEditor("MarkOccurrencesEnabled"):
+self.clearAllIndicators(self.searchIndicator)
+self.spellingIndicator = QsciScintilla.INDIC_CONTAINER + 1
+self.indicatorDefine(self.spellingIndicator, QsciScintilla.INDIC_SQUIGGLE,
+Preferences.getEditorColour("SpellingMarkers"))
+self.__setSpelling()
+def __setEolMode(self):
+"""
+Private method to configure the eol mode of the editor.
+"""
+eolMode = Preferences.getEditor("EOLMode")
+eolMode = QsciScintilla.EolMode(eolMode)
+self.setEolMode(eolMode)
+self.__eolChanged()
+def __setAutoCompletion(self):
+"""
+Private method to configure the autocompletion function.
+"""
+if self.lexer_:
+self.setAutoCompletionFillupsEnabled(
+Preferences.getEditor("AutoCompletionFillups"))
+self.setAutoCompletionCaseSensitivity(
+Preferences.getEditor("AutoCompletionCaseSensitivity"))
+self.setAutoCompletionReplaceWord(
+Preferences.getEditor("AutoCompletionReplaceWord"))
+self.setAutoCompletionShowSingle(
+Preferences.getEditor("AutoCompletionShowSingle"))
+autoCompletionSource = Preferences.getEditor("AutoCompletionSource")
+if autoCompletionSource == QsciScintilla.AcsDocument:
+self.setAutoCompletionSource(QsciScintilla.AcsDocument)
+elif autoCompletionSource == QsciScintilla.AcsAPIs:
+self.setAutoCompletionSource(QsciScintilla.AcsAPIs)
+else:
+self.setAutoCompletionSource(QsciScintilla.AcsAll)
+if Preferences.getEditor("AutoCompletionEnabled"):
+if self.__acHookFunction is None:
+self.setAutoCompletionThreshold(
+Preferences.getEditor("AutoCompletionThreshold"))
+else:
+self.setAutoCompletionThreshold(0)
+else:
+self.setAutoCompletionThreshold(-1)
+self.setAutoCompletionSource(QsciScintilla.AcsNone)
+def __setCallTips(self):
+"""
+Private method to configure the calltips function.
+"""
+if Preferences.getEditor("CallTipsEnabled"):
+self.setCallTipsBackgroundColor(
+Preferences.getEditorColour("CallTipsBackground"))
+self.setCallTipsVisible(Preferences.getEditor("CallTipsVisible"))
+calltipsStyle = Preferences.getEditor("CallTipsStyle")
+if calltipsStyle == QsciScintilla.CallTipsNoContext:
+self.setCallTipsStyle(QsciScintilla.CallTipsNoContext)
+elif calltipsStyle == QsciScintilla.CallTipsNoAutoCompletionContext:
+self.setCallTipsStyle(QsciScintilla.CallTipsNoAutoCompletionContext)
+else:
+self.setCallTipsStyle(QsciScintilla.CallTipsContext)
+else:
+self.setCallTipsStyle(QsciScintilla.CallTipsNone)
+############################################################################
+## Autocompletion handling methods below
+############################################################################
+def canAutoCompleteFromAPIs(self):
+"""
+Public method to check for API availablity.
+@return flag indicating autocompletion from APIs is available (boolean)
+"""
+return self.acAPI
+def autoCompleteQScintilla(self):
+"""
+Public method to perform an autocompletion using QScintilla methods.
+"""
+acs = Preferences.getEditor("AutoCompletionSource")
+if acs == QsciScintilla.AcsDocument:
+self.autoCompleteFromDocument()
+elif acs == QsciScintilla.AcsAPIs:
+self.autoCompleteFromAPIs()
+elif acs == QsciScintilla.AcsAll:
+self.autoCompleteFromAll()
+else:
+QMessageBox.information(None,
+self.trUtf8("Autocompletion"),
+self.trUtf8("""Autocompletion is not available because"""
+""" there is no autocompletion source set."""))
+def setAutoCompletionEnabled(self, enable):
+"""
+Public method to enable/disable autocompletion.
+@param enable flag indicating the desired autocompletion status (boolean)
+"""
+if enable:
+self.setAutoCompletionThreshold(
+Preferences.getEditor("AutoCompletionThreshold"))
+autoCompletionSource = Preferences.getEditor("AutoCompletionSource")
+if autoCompletionSource == QsciScintilla.AcsDocument:
+self.setAutoCompletionSource(QsciScintilla.AcsDocument)
+elif autoCompletionSource == QsciScintilla.AcsAPIs:
+self.setAutoCompletionSource(QsciScintilla.AcsAPIs)
+else:
+self.setAutoCompletionSource(QsciScintilla.AcsAll)
+else:
+self.setAutoCompletionThreshold(-1)
+self.setAutoCompletionSource(QsciScintilla.AcsNone)
+def __toggleAutoCompletionEnable(self):
+"""
+Private slot to handle the Enable Autocompletion context menu entry.
+"""
+if self.menuActs["AutoCompletionEnable"].isChecked():
+self.setAutoCompletionEnabled(True)
+else:
+self.setAutoCompletionEnabled(False)
+#################################################################
+## Support for autocompletion hook methods
+#################################################################
+def __charAdded(self, charNumber):
+"""
+Public slot called to handle the user entering a character.
+@param charNumber value of the character entered (integer)
+"""
+if self.isListActive():
+char = unichr(charNumber)
+if self.__isStartChar(char):
+self.cancelList()
+self.autoComplete(auto = True, context = True)
+return
+elif char == '(':
+self.cancelList()
+if self.callTipsStyle() != QsciScintilla.CallTipsNone and \
+self.lexer_ is not None and unichr(charNumber) in '()':
+self.callTip()
+if not self.isCallTipActive():
+char = unichr(charNumber)
+if self.__isStartChar(char):
+self.autoComplete(auto = True, context = True)
+return
+line, col = self.getCursorPosition()
+txt = self.getWordLeft(line, col)
+if len(txt) >= Preferences.getEditor("AutoCompletionThreshold"):
+self.autoComplete(auto = True, context = False)
+return
+def __isStartChar(self, ch):
+"""
+Private method to check, if a character is an autocompletion start character.
+@param ch character to be checked (one character string)
+@return flag indicating the result (boolean)
+"""
+if self.lexer_ is None:
+return False
+wseps = self.lexer_.autoCompletionWordSeparators()
+for wsep in wseps:
+if wsep.endswith(ch):
+return True
+return False
+def setAutoCompletionHook(self, func):
+"""
+Public method to set an autocompletion hook.
+@param func Function to be set to handle autocompletion. func
+should be a function taking a reference to the editor and
+a boolean indicating to complete a context.
+"""
+if self.autoCompletionThreshold() > 0:
+self.setAutoCompletionThreshold(0)
+self.__acHookFunction = func
+self.connect(self, SIGNAL("SCN_CHARADDED(int)"), self.__charAdded)
+def unsetAutoCompletionHook(self):
+"""
+Public method to unset a previously installed autocompletion hook.
+"""
+self.disconnect(self, SIGNAL("SCN_CHARADDED(int)"), self.__charAdded)
+self.__acHookFunction = None
+if self.autoCompletionThreshold() == 0:
+self.setAutoCompletionThreshold(
+Preferences.getEditor("AutoCompletionThreshold"))
+def autoCompletionHook(self):
+"""
+Public method to get the autocompletion hook function.
+@return function set by setAutoCompletionHook()
+"""
+return self.__acHookFunction
+def autoComplete(self, auto = False, context = True):
+"""
+Public method to start autocompletion.
+@keyparam auto flag indicating a call from the __charAdded method (boolean)
+@keyparam context flag indicating to complete a context (boolean)
+"""
+if auto and self.autoCompletionThreshold() == -1:
+# autocompletion is disabled
+return
+if self.__acHookFunction is not None:
+self.__acHookFunction(self, context)
+elif not auto:
+self.autoCompleteQScintilla()
+elif self.autoCompletionSource() != QsciScintilla.AcsNone:
+self.autoCompleteQScintilla()
+def callTip(self):
+"""
+Public method to show calltips.
+"""
+if self.__ctHookFunction is not None:
+self.__callTip()
+else:
+QsciScintillaCompat.callTip(self)
+def __callTip(self):
+"""
+Private method to show call tips provided by a plugin.
+"""
+pos = self.currentPosition()
+# move backward to the start of the current calltip working out which argument
+# to highlight
+commas = 0
+found = False
+ch, pos = self.__getCharacter(pos)
+while ch:
+if ch == ',':
+commas += 1
+elif ch == ')':
+depth = 1
+# ignore everything back to the start of the corresponding parenthesis
+ch, pos = self.__getCharacter(pos)
+while ch:
+if ch == ')':
+depth += 1
+elif ch == '(':
+depth -= 1
+if depth == 0:
+break
+ch,  pos = self.__getCharacter(pos)
+elif ch == '(':
+found = True
+break
+ch, pos = self.__getCharacter(pos)
+self.SendScintilla(QsciScintilla.SCI_CALLTIPCANCEL)
+if not found:
+return
+try:
+callTips = self.__ctHookFunction(self, pos, commas)
+except TypeError:
+# for backward compatibility
+callTips = self.__ctHookFunction(self, pos)
+if len(callTips) == 0:
+if Preferences.getEditor("CallTipsScintillaOnFail"):
+# try QScintilla calltips
+QsciScintillaCompat.callTip(self)
+return
+ctshift = 0
+for ct in callTips:
+shift = ct.index("(")
+if ctshift < shift:
+ctshift = shift
+cv = self.callTipsVisible()
+if cv > 0:
+# this is just a safe guard
+ct = "\n".join(callTips[:cv])
+else:
+# until here and unindent below
+ct = "\n".join(callTips)
+self.SendScintilla(QsciScintilla.SCI_CALLTIPSHOW,
+self.__adjustedCallTipPosition(ctshift, pos), ct)
+if '\n' in ct:
+return
+# Highlight the current argument
+if commas == 0:
+astart = ct.find('(')
+else:
+astart = ct.find(',')
+commas -= 1
+while astart != -1 and commas > 0:
+astart = ct.find(',', astart + 1)
+commas -= 1
+if astart == -1:
+return
+depth = 0
+for aend in range(astart + 1, len(ct)):
+ch = ct[aend]
+if ch == ',' and depth == 0:
+break
+elif ch == '(':
+depth += 1
+elif ch == ')':
+if depth == 0:
+break
+depth -= 1
+if astart != aend:
+self.SendScintilla(QsciScintilla.SCI_CALLTIPSETHLT, astart, aend)
+def __adjustedCallTipPosition(self, ctshift, pos):
+"""
+Private method to calculate an adjusted position for showing calltips.
+@param ctshift amount the calltip shall be shifted (integer)
+@param pos position into the text (integer)
+@return new position for the calltip (integer)
+"""
+ct = pos
+if ctshift:
+ctmin = self.SendScintilla(QsciScintilla.SCI_POSITIONFROMLINE,
+self.SendScintilla(QsciScintilla.SCI_LINEFROMPOSITION, ct))
+if ct - ctshift < ctmin:
+ct = ctmin
+else:
+ct = ct - ctshift
+return ct
+def setCallTipHook(self, func):
+"""
+Public method to set a calltip hook.
+@param func Function to be set to determine calltips. func
+should be a function taking a reference to the editor,
+a position into the text and the amount of commas to the
+left of the cursor. It should return the possible
+calltips as a list of strings.
+"""
+self.__ctHookFunction = func
+def unsetCallTipHook(self):
+"""
+Public method to unset a calltip hook.
+"""
+self.__ctHookFunction = None
+def callTipHook(self):
+"""
+Public method to get the calltip hook function.
+@return function set by setCallTipHook()
+"""
+return self.__ctHookFunction
+#################################################################
+## Methods needed by the context menu
+#################################################################
+def __marginNumber(self, xPos):
+"""
+Private method to calculate the margin number based on a x position.
+@param xPos x position (integer)
+@return margin number (integer, -1 for no margin)
+"""
+width = 0
+for margin in range(5):
+width += self.marginWidth(margin)
+if xPos <= width:
+return margin
+return -1
+def contextMenuEvent(self, evt):
+"""
+Private method implementing the context menu event.
+@param evt the context menu event (QContextMenuEvent)
+"""
+evt.accept()
+if self.__marginNumber(evt.x()) == -1:
+self.spellingMenuPos = self.positionFromPoint(evt.pos())
+if self.spellingMenuPos >= 0 and \
+self.spell is not None and \
+self.hasIndicator(self.spellingIndicator, self.spellingMenuPos):
+self.spellingMenu.popup(evt.globalPos())
+else:
+self.menu.popup(evt.globalPos())
+else:
+self.line = self.lineAt(evt.pos())
+if self.__unifiedMargins:
+self.marginMenu.popup(evt.globalPos())
+else:
+if self.__marginNumber(evt.x()) in [self.__bmMargin, self.__linenoMargin]:
+self.bmMarginMenu.popup(evt.globalPos())
+elif self.__marginNumber(evt.x()) == self.__bpMargin:
+self.bpMarginMenu.popup(evt.globalPos())
+elif self.__marginNumber(evt.x()) == self.__indicMargin:
+self.indicMarginMenu.popup(evt.globalPos())
+def __showContextMenu(self):
+"""
+Private slot handling the aboutToShow signal of the context menu.
+"""
+self.menuActs["Save"].setEnabled(self.isModified())
+self.menuActs["Undo"].setEnabled(self.isUndoAvailable())
+self.menuActs["Redo"].setEnabled(self.isRedoAvailable())
+self.menuActs["Revert"].setEnabled(self.isModified())
+if not self.miniMenu:
+self.menuActs["Cut"].setEnabled(self.hasSelectedText())
+self.menuActs["Copy"].setEnabled(self.hasSelectedText())
+if not self.isResourcesFile:
+if self.fileName and \
+(self.isPyFile() or self.isPy3File()):
+self.menuActs["Show"].setEnabled(True)
+else:
+self.menuActs["Show"].setEnabled(False)
+if self.fileName and \
+(self.isPyFile() or self.isPy3File() or self.isRubyFile()):
+self.menuActs["Diagrams"].setEnabled(True)
+else:
+self.menuActs["Diagrams"].setEnabled(False)
+if not self.miniMenu:
+if self.lexer_ is not None:
+self.menuActs["Comment"].setEnabled(self.lexer_.canBlockComment())
+self.menuActs["Uncomment"].setEnabled(self.lexer_.canBlockComment())
+self.menuActs["StreamComment"].setEnabled(self.lexer_.canStreamComment())
+self.menuActs["BoxComment"].setEnabled(self.lexer_.canBoxComment())
+else:
+self.menuActs["Comment"].setEnabled(False)
+self.menuActs["Uncomment"].setEnabled(False)
+self.menuActs["StreamComment"].setEnabled(False)
+self.menuActs["BoxComment"].setEnabled(False)
+self.menuActs["TypingAidsEnabled"].setEnabled(self.completer is not None)
+self.menuActs["TypingAidsEnabled"].setChecked(\
+self.completer is not None and self.completer.isEnabled())
+spellingAvailable = SpellChecker.isAvailable()
+self.menuActs["SpellCheck"].setEnabled(spellingAvailable)
+self.menuActs["SpellCheckSelection"].setEnabled(
+spellingAvailable and self.hasSelectedText())
+self.menuActs["SpellCheckRemove"].setEnabled(
+spellingAvailable and self.spellingMenuPos >= 0)
+self.emit(SIGNAL("showMenu"), "Main", self.menu,  self)
+def __showContextMenuAutocompletion(self):
+"""
+Private slot called before the autocompletion menu is shown.
+"""
+self.menuActs["acDynamic"].setEnabled(
+self.acAPI or self.__acHookFunction is not None)
+self.menuActs["acAPI"].setEnabled(self.acAPI)
+self.menuActs["acAPIDocument"].setEnabled(self.acAPI)
+self.menuActs["calltip"].setEnabled(self.acAPI)
+self.emit(SIGNAL("showMenu"), "Autocompletion", self.autocompletionMenu,  self)
+def __showContextMenuShow(self):
+"""
+Private slot called before the show menu is shown.
+"""
+prEnable = False
+coEnable = False
+# first check if the file belongs to a project
+project = e4App().getObject("Project")
+if project.isOpen() and project.isProjectSource(self.fileName):
+fn = project.getMainScript(True)
+if fn is not None:
+tfn = Utilities.getTestFileName(fn)
+basename = os.path.splitext(fn)[0]
+tbasename = os.path.splitext(tfn)[0]
+prEnable = prEnable or \
+os.path.isfile("%s.profile" % basename) or \
+os.path.isfile("%s.profile" % tbasename)
+coEnable = coEnable or \
+os.path.isfile("%s.coverage" % basename) or \
+os.path.isfile("%s.coverage" % tbasename)
+# now check ourself
+fn = self.getFileName()
+if fn is not None:
+tfn = Utilities.getTestFileName(fn)
+basename = os.path.splitext(fn)[0]
+tbasename = os.path.splitext(tfn)[0]
+prEnable = prEnable or \
+os.path.isfile("%s.profile" % basename) or \
+os.path.isfile("%s.profile" % tbasename)
+coEnable = coEnable or \
+os.path.isfile("%s.coverage" % basename) or \
+os.path.isfile("%s.coverage" % tbasename)
+self.profileMenuAct.setEnabled(prEnable)
+self.coverageMenuAct.setEnabled(coEnable)
+self.coverageShowAnnotationMenuAct.setEnabled(\
+coEnable and not self.coverageMarkersShown)
+self.coverageHideAnnotationMenuAct.setEnabled(\
+self.coverageMarkersShown)
+self.emit(SIGNAL("showMenu"), "Show", self.showMenu,  self)
+def __showContextMenuGraphics(self):
+"""
+Private slot handling the aboutToShow signal of the diagrams context menu.
+"""
+project = e4App().getObject("Project")
+if project.isOpen() and project.isProjectSource(self.fileName):
+self.applicationDiagramMenuAct.setEnabled(True)
+else:
+self.applicationDiagramMenuAct.setEnabled(False)
+self.emit(SIGNAL("showMenu"), "Graphics", self.graphicsMenu,  self)
+def __showContextMenuMargin(self):
+"""
+Private slot handling the aboutToShow signal of the margins context menu.
+"""
+if self.fileName and \
+(self.isPyFile() or self.isPy3File() or self.isRubyFile()):
+self.marginMenuActs["Breakpoint"].setEnabled(True)
+self.marginMenuActs["TempBreakpoint"].setEnabled(True)
+if self.markersAtLine(self.line) & self.breakpointMask:
+self.marginMenuActs["EditBreakpoint"].setEnabled(True)
+self.marginMenuActs["EnableBreakpoint"].setEnabled(True)
+else:
+self.marginMenuActs["EditBreakpoint"].setEnabled(False)
+self.marginMenuActs["EnableBreakpoint"].setEnabled(False)
+if self.markersAtLine(self.line) & (1 << self.dbreakpoint):
+self.marginMenuActs["EnableBreakpoint"].setText(\
+self.trUtf8('Enable breakpoint'))
+else:
+self.marginMenuActs["EnableBreakpoint"].setText(\
+self.trUtf8('Disable breakpoint'))
+if self.breaks:
+self.marginMenuActs["NextBreakpoint"].setEnabled(True)
+self.marginMenuActs["PreviousBreakpoint"].setEnabled(True)
+self.marginMenuActs["ClearBreakpoint"].setEnabled(True)
+else:
+self.marginMenuActs["NextBreakpoint"].setEnabled(False)
+self.marginMenuActs["PreviousBreakpoint"].setEnabled(False)
+self.marginMenuActs["ClearBreakpoint"].setEnabled(False)
+else:
+self.marginMenuActs["Breakpoint"].setEnabled(False)
+self.marginMenuActs["TempBreakpoint"].setEnabled(False)
+self.marginMenuActs["EditBreakpoint"].setEnabled(False)
+self.marginMenuActs["EnableBreakpoint"].setEnabled(False)
+self.marginMenuActs["NextBreakpoint"].setEnabled(False)
+self.marginMenuActs["PreviousBreakpoint"].setEnabled(False)
+self.marginMenuActs["ClearBreakpoint"].setEnabled(False)
+if self.bookmarks:
+self.marginMenuActs["NextBookmark"].setEnabled(True)
+self.marginMenuActs["PreviousBookmark"].setEnabled(True)
+self.marginMenuActs["ClearBookmark"].setEnabled(True)
+else:
+self.marginMenuActs["NextBookmark"].setEnabled(False)
+self.marginMenuActs["PreviousBookmark"].setEnabled(False)
+self.marginMenuActs["ClearBookmark"].setEnabled(False)
+if len(self.syntaxerrors):
+self.marginMenuActs["GotoSyntaxError"].setEnabled(True)
+self.marginMenuActs["ClearSyntaxError"].setEnabled(True)
+if self.markersAtLine(self.line) & (1 << self.syntaxerror):
+self.marginMenuActs["ShowSyntaxError"].setEnabled(True)
+else:
+self.marginMenuActs["ShowSyntaxError"].setEnabled(False)
+else:
+self.marginMenuActs["GotoSyntaxError"].setEnabled(False)
+self.marginMenuActs["ClearSyntaxError"].setEnabled(False)
+self.marginMenuActs["ShowSyntaxError"].setEnabled(False)
+if self.notcoveredMarkers:
+self.marginMenuActs["NextCoverageMarker"].setEnabled(True)
+self.marginMenuActs["PreviousCoverageMarker"].setEnabled(True)
+else:
+self.marginMenuActs["NextCoverageMarker"].setEnabled(False)
+self.marginMenuActs["PreviousCoverageMarker"].setEnabled(False)
+if self.__hasTaskMarkers:
+self.marginMenuActs["PreviousTaskMarker"].setEnabled(True)
+self.marginMenuActs["NextTaskMarker"].setEnabled(True)
+else:
+self.marginMenuActs["PreviousTaskMarker"].setEnabled(False)
+self.marginMenuActs["NextTaskMarker"].setEnabled(False)
+self.emit(SIGNAL("showMenu"), "Margin", self.sender(),  self)
+def __showContextMenuChecks(self):
+"""
+Private slot handling the aboutToShow signal of the checks context menu.
+"""
+self.emit(SIGNAL("showMenu"), "Checks", self.checksMenu,  self)
+def __contextSave(self):
+"""
+Private slot handling the save context menu entry.
+"""
+ok, newName = self.saveFile()
+if ok:
+self.vm.setEditorName(self, newName)
+def __contextSaveAs(self):
+"""
+Private slot handling the save as context menu entry.
+"""
+ok, newName = self.saveFileAs()
+if ok:
+self.vm.setEditorName(self, newName)
+def __contextClose(self):
+"""
+Private slot handling the close context menu entry.
+"""
+self.vm.closeEditor(self)
+def __newView(self):
+"""
+Private slot to create a new view to an open document.
+"""
+self.vm.newEditorView(self.fileName, self, self.filetype)
+def __newViewNewSplit(self):
+"""
+Private slot to create a new view to an open document.
+"""
+self.vm.addSplit()
+self.vm.newEditorView(self.fileName, self, self.filetype)
+def __selectAll(self):
+"""
+Private slot handling the select all context menu action.
+"""
+self.selectAll(True)
+def __deselectAll(self):
+"""
+Private slot handling the deselect all context menu action.
+"""
+self.selectAll(False)
+def shortenEmptyLines(self):
+"""
+Public slot to compress lines consisting solely of whitespace characters.
+"""
+searchRE = r"^[ \t]+$"
+ok = self.findFirstTarget(searchRE, True, False, False, 0, 0)
+self.beginUndoAction()
+while ok:
+self.replaceTarget("")
+ok = self.findNextTarget()
+self.endUndoAction()
+def __autosaveEnable(self):
+"""
+Private slot handling the autosave enable context menu action.
+"""
+if self.menuActs["AutosaveEnable"].isChecked():
+self.autosaveManuallyDisabled = False
+else:
+self.autosaveManuallyDisabled = True
+def shouldAutosave(self):
+"""
+Public slot to check the autosave flags.
+@return flag indicating this editor should be saved (boolean)
+"""
+return self.fileName is not None and \
+not self.autosaveManuallyDisabled and \
+not self.isReadOnly()
+def __autoSyntaxCheck(self):
+"""
+Private method to perform an automatic syntax check of the file.
+"""
+if Preferences.getEditor("AutoCheckSyntax"):
+self.clearSyntaxError()
+if self.isPyFile():
+syntaxError, _fn, errorline, _code, _error = \
+Utilities.compile(self.fileName, self.text())
+if syntaxError:
+self.toggleSyntaxError(int(errorline), 1, _error)
+def __showCodeMetrics(self):
+"""
+Private method to handle the code metrics context menu action.
+"""
+if not self.checkDirty():
+return
+self.codemetrics = CodeMetricsDialog()
+self.codemetrics.show()
+self.codemetrics.start(self.fileName)
+def __getCodeCoverageFile(self):
+"""
+Private method to get the filename of the file containing coverage info.
+@return filename of the coverage file (string)
+"""
+files = []
+# first check if the file belongs to a project and there is
+# a project coverage file
+project = e4App().getObject("Project")
+if project.isOpen() and project.isProjectSource(self.fileName):
+fn = project.getMainScript(True)
+if fn is not None:
+tfn = Utilities.getTestFileName(fn)
+basename = os.path.splitext(fn)[0]
+tbasename = os.path.splitext(tfn)[0]
+f = "%s.coverage" % basename
+tf = "%s.coverage" % tbasename
+if os.path.isfile(f):
+files.append(f)
+if os.path.isfile(tf):
+files.append(tf)
+# now check, if there are coverage files belonging to ourself
+fn = self.getFileName()
+if fn is not None:
+tfn = Utilities.getTestFileName(fn)
+basename = os.path.splitext(fn)[0]
+tbasename = os.path.splitext(tfn)[0]
+f = "%s.coverage" % basename
+tf = "%s.coverage" % tbasename
+if os.path.isfile(f) and not f in files:
+files.append(f)
+if os.path.isfile(tf) and not tf in files:
+files.append(tf)
+if files:
+if len(files) > 1:
+fn, ok = QInputDialog.getItem(\
+self,
+self.trUtf8("Code Coverage"),
+self.trUtf8("Please select a coverage file"),
+files,
+0, False)
+if not ok:
+return
+else:
+fn = files[0]
+else:
+fn = None
+return fn
+def __showCodeCoverage(self):
+"""
+Private method to handle the code coverage context menu action.
+"""
+fn = self.__getCodeCoverageFile()
+if fn:
+self.codecoverage = PyCoverageDialog()
+self.codecoverage.show()
+self.codecoverage.start(fn, self.fileName)
+def __codeCoverageShowAnnotations(self):
+"""
+Private method to handle the show code coverage annotations context menu action.
+"""
+fn = self.__getCodeCoverageFile()
+if fn:
+cover = coverage(data_file = fn)
+cover.use_cache(True)
+cover.load()
+missing = cover.analysis2(self.fileName)[3]
+if missing:
+for line in missing:
+handle = self.markerAdd(line - 1, self.notcovered)
+self.notcoveredMarkers.append(handle)
+self.emit(SIGNAL('coverageMarkersShown'), True)
+self.coverageMarkersShown = True
+else:
+QMessageBox.information(None,
+self.trUtf8("Show Code Coverage Annotations"),
+self.trUtf8("""All lines have been covered."""))
+else:
+QMessageBox.warning(None,
+self.trUtf8("Show Code Coverage Annotations"),
+self.trUtf8("""There is no coverage file available."""))
+def __codeCoverageHideAnnotations(self):
+"""
+Private method to handle the hide code coverage annotations context menu action.
+"""
+for handle in self.notcoveredMarkers:
+self.markerDeleteHandle(handle)
+self.notcoveredMarkers = []
+self.emit(SIGNAL('coverageMarkersShown'), False)
+self.coverageMarkersShown = False
+def hasCoverageMarkers(self):
+"""
+Public method to test, if there are coverage markers.
+"""
+return len(self.notcoveredMarkers) > 0
+def nextUncovered(self):
+"""
+Public slot to handle the 'Next uncovered' context menu action.
+"""
+line, index = self.getCursorPosition()
+if line == self.lines()-1:
+line = 0
+else:
+line += 1
+ucline = self.markerFindNext(line, 1 << self.notcovered)
+if ucline < 0:
+# wrap around
+ucline = self.markerFindNext(0, 1 << self.notcovered)
+if ucline >= 0:
+self.setCursorPosition(ucline, 0)
+self.ensureLineVisible(ucline)
+def previousUncovered(self):
+"""
+Public slot to handle the 'Previous uncovered' context menu action.
+"""
+line, index = self.getCursorPosition()
+if line == 0:
+line = self.lines()-1
+else:
+line -= 1
+ucline = self.markerFindPrevious(line, 1 << self.notcovered)
+if ucline < 0:
+# wrap around
+ucline = self.markerFindPrevious(self.lines() - 1, 1 << self.notcovered)
+if ucline >= 0:
+self.setCursorPosition(ucline, 0)
+self.ensureLineVisible(ucline)
+def __showProfileData(self):
+"""
+Private method to handle the show profile data context menu action.
+"""
+files = []
+# first check if the file belongs to a project and there is
+# a project profile file
+project = e4App().getObject("Project")
+if project.isOpen() and project.isProjectSource(self.fileName):
+fn = project.getMainScript(True)
+if fn is not None:
+tfn = Utilities.getTestFileName(fn)
+basename = os.path.splitext(fn)[0]
+tbasename = os.path.splitext(tfn)[0]
+f = "%s.profile" % basename
+tf = "%s.profile" % tbasename
+if os.path.isfile(f):
+files.append(f)
+if os.path.isfile(tf):
+files.append(tf)
+# now check, if there are profile files belonging to ourself
+fn = self.getFileName()
+if fn is not None:
+tfn = Utilities.getTestFileName(fn)
+basename = os.path.splitext(fn)[0]
+tbasename = os.path.splitext(tfn)[0]
+f = "%s.profile" % basename
+tf = "%s.profile" % tbasename
+if os.path.isfile(f) and not f in files:
+files.append(f)
+if os.path.isfile(tf) and not tf in files:
+files.append(tf)
+if files:
+if len(files) > 1:
+fn, ok = QInputDialog.getItem(\
+self,
+self.trUtf8("Profile Data"),
+self.trUtf8("Please select a profile file"),
+files,
+0, False)
+if not ok:
+return
+else:
+fn = files[0]
+else:
+return
+self.profiledata = PyProfileDialog()
+self.profiledata.show()
+self.profiledata.start(fn, self.fileName)
+def __lmBbookmarks(self):
+"""
+Private method to handle the 'LMB toggles bookmark' context menu action.
+"""
+self.marginMenuActs["LMBbookmarks"].setChecked(True)
+self.marginMenuActs["LMBbreakpoints"].setChecked(False)
+def __lmBbreakpoints(self):
+"""
+Private method to handle the 'LMB toggles breakpoint' context menu action.
+"""
+self.marginMenuActs["LMBbookmarks"].setChecked(True)
+self.marginMenuActs["LMBbreakpoints"].setChecked(False)
+############################################################################
+## Syntax error handling methods below
+############################################################################
+def toggleSyntaxError(self, line, error, msg = ""):
+"""
+Public method to toggle a syntax error indicator.
+@param line line number of the syntax error
+@param error flag indicating if the error marker should be
+set or deleted (boolean)
+@param msg error message (string)
+"""
+if line == 0:
+line = 1
+# hack to show a syntax error marker, if line is reported to be 0
+if error:
+# set a new syntax error marker
+markers = self.markersAtLine(line - 1)
+if not (markers & (1 << self.syntaxerror)):
+handle = self.markerAdd(line - 1, self.syntaxerror)
+self.syntaxerrors[handle] = msg
+self.emit(SIGNAL('syntaxerrorToggled'), self)
+else:
+for handle in self.syntaxerrors.keys():
+if self.markerLine(handle) == line - 1:
+del self.syntaxerrors[handle]
+self.markerDeleteHandle(handle)
+self.emit(SIGNAL('syntaxerrorToggled'), self)
+def getSyntaxErrors(self):
+"""
+Public method to retrieve the syntax error markers.
+@return sorted list of all lines containing a syntax error
+(list of integer)
+"""
+selist = []
+for handle in self.syntaxerrors.keys():
+selist.append(self.markerLine(handle) + 1)
+selist.sort()
+return selist
+def hasSyntaxErrors(self):
+"""
+Public method to check for the presence of bookmarks.
+@return flag indicating the presence of bookmarks (boolean)
+"""
+return len(self.syntaxerrors) > 0
+def gotoSyntaxError(self):
+"""
+Public slot to handle the 'Goto syntax error' context menu action.
+"""
+seline = self.markerFindNext(0, 1 << self.syntaxerror)
+if seline >= 0:
+self.setCursorPosition(seline, 0)
+self.ensureLineVisible(seline)
+def clearSyntaxError(self):
+"""
+Public slot to handle the 'Clear all syntax error' context menu action.
+"""
+for handle in self.syntaxerrors.keys():
+line = self.markerLine(handle) + 1
+self.toggleSyntaxError(line, False)
+def __showSyntaxError(self, line = -1):
+"""
+Private slot to handle the 'Show syntax error message' context menu action.
+@param line line number to show the syntax error for (integer)
+"""
+if line == -1:
+line = self.line
+for handle in self.syntaxerrors.keys():
+if self.markerLine(handle) == line:
+QMessageBox.critical(None,
+self.trUtf8("Syntax Error"),
+self.syntaxerrors[handle])
+break
+else:
+QMessageBox.critical(None,
+self.trUtf8("Syntax Error"),
+self.trUtf8("No syntax error message available."))
+#################################################################
+## Macro handling methods
+#################################################################
+def __getMacroName(self):
+"""
+Private method to select a macro name from the list of macros.
+@return Tuple of macro name and a flag, indicating, if the user pressed ok or
+canceled the operation. (string, boolean)
+"""
+qs = []
+for s in self.macros.keys():
+qs.append(s)
+qs.sort()
+return QInputDialog.getItem(\
+self,
+self.trUtf8("Macro Name"),
+self.trUtf8("Select a macro name:"),
+qs,
+0, False)
+def macroRun(self):
+"""
+Public method to execute a macro.
+"""
+name, ok = self.__getMacroName()
+if ok and name:
+self.macros[name].play()
+def macroDelete(self):
+"""
+Public method to delete a macro.
+"""
+name, ok = self.__getMacroName()
+if ok and name:
+del self.macros[name]
+def macroLoad(self):
+"""
+Public method to load a macro from a file.
+"""
+configDir = Utilities.getConfigDir()
+fname = QFileDialog.getOpenFileName(
+self,
+self.trUtf8("Load macro file"),
+configDir,
+self.trUtf8("Macro files (*.macro)"))
+if not fname:
+return  # user aborted
+try:
+f = open(fname, "rb")
+lines = f.readlines()
+f.close()
+except IOError:
+QMessageBox.critical(self,
+self.trUtf8("Error loading macro"),
+self.trUtf8("<p>The macro file <b>{0}</b> could not be read.</p>")
+.format(fname))
+return
+if len(lines) != 2:
+QMessageBox.critical(self,
+self.trUtf8("Error loading macro"),
+self.trUtf8("<p>The macro file <b>{0}</b> is corrupt.</p>")
+.format(fname))
+return
+macro = QsciMacro(lines[1], self)
+self.macros[lines[0].strip()] = macro
+def macroSave(self):
+"""
+Public method to save a macro to a file.
+"""
+configDir = Utilities.getConfigDir()
+name, ok = self.__getMacroName()
+if not ok or not name:
+return  # user abort
+fname, selectedFilter = QFileDialog.getSaveFileNameAndFilter(\
+self,
+self.trUtf8("Save macro file"),
+configDir,
+self.trUtf8("Macro files (*.macro)"),
+"",
+QFileDialog.Options(QFileDialog.DontConfirmOverwrite))
+if not fname:
+return  # user aborted
+ext = QFileInfo(fname).suffix()
+if not ext:
+ex = selectedFilter.split("(*")[1].split(")")[0]
+if ex:
+fname += ex
+if QFileInfo(fname).exists():
+res = QMessageBox.warning(self,
+self.trUtf8("Save macro"),
+self.trUtf8("<p>The macro file <b>{0}</b> already exists.</p>")
+.format(fname),
+QMessageBox.StandardButtons(\
+QMessageBox.Abort | \
+QMessageBox.Save),
+QMessageBox.Abort)
+if res == QMessageBox.Abort or res == QMessageBox.Cancel:
+return
+fname = Utilities.toNativeSeparators(fname)
+try:
+f = open(fname, "wb")
+f.write("%s%s" % (name, os.linesep))
+f.write(self.macros[name].save())
+f.close()
+except IOError:
+QMessageBox.critical(self,
+self.trUtf8("Error saving macro"),
+self.trUtf8("<p>The macro file <b>{0}</b> could not be written.</p>")
+.format(fname))
+return
+def macroRecordingStart(self):
+"""
+Public method to start macro recording.
+"""
+if self.recording:
+res = QMessageBox.warning(self,
+self.trUtf8("Start Macro Recording"),
+self.trUtf8("Macro recording is already active. Start new?"),
+QMessageBox.StandardButtons(\
+QMessageBox.No | \
+QMessageBox.Yes),
+QMessageBox.Yes)
+if res == QMessageBox.Yes:
+self.macroRecordingStop()
+else:
+return
+else:
+self.recording = True
+self.curMacro = QsciMacro(self)
+self.curMacro.startRecording()
+def macroRecordingStop(self):
+"""
+Public method to stop macro recording.
+"""
+if not self.recording:
+return      # we are not recording
+self.curMacro.endRecording()
+self.recording = False
+name, ok = QInputDialog.getText(\
+self,
+self.trUtf8("Macro Recording"),
+self.trUtf8("Enter name of the macro:"),
+QLineEdit.Normal)
+if ok and name:
+self.macros[name] = self.curMacro
+self.curMacro = None
+#################################################################
+## Overwritten methods
+#################################################################
+def undo(self):
+"""
+Public method to undo the last recorded change.
+"""
+QsciScintillaCompat.undo(self)
+self.emit(SIGNAL('undoAvailable'), self.isUndoAvailable())
+self.emit(SIGNAL('redoAvailable'), self.isRedoAvailable())
+def redo(self):
+"""
+Public method to redo the last recorded change.
+"""
+QsciScintillaCompat.redo(self)
+self.emit(SIGNAL('undoAvailable'), self.isUndoAvailable())
+self.emit(SIGNAL('redoAvailable'), self.isRedoAvailable())
+def close(self, alsoDelete = False):
+"""
+Public method called when the window gets closed.
+This overwritten method redirects the action to our
+ViewManager.closeEditor, which in turn calls our closeIt
+method.
+@param alsoDelete ignored
+"""
+return self.vm.closeEditor(self)
+def closeIt(self):
+"""
+Public method called by the viewmanager to finally get rid of us.
+"""
+if Preferences.getEditor("ClearBreaksOnClose"):
+self.__menuClearBreakpoints()
+for clone in self.__clones[:]:
+clone.removeClone(self)
+self.disconnect(self.breakpointModel,
+SIGNAL("rowsAboutToBeRemoved(const QModelIndex &, int, int)"),
+self.__deleteBreakPoints)
+self.disconnect(self.breakpointModel,
+SIGNAL("dataAboutToBeChanged(const QModelIndex &, const QModelIndex &)"),
+self.__breakPointDataAboutToBeChanged)
+self.disconnect(self.breakpointModel,
+SIGNAL("dataChanged(const QModelIndex &, const QModelIndex &)"),
+self.__changeBreakPoints)
+self.disconnect(self.breakpointModel,
+SIGNAL("rowsInserted(const QModelIndex &, int, int)"),
+self.__addBreakPoints)
+self.disconnect(e4App().getObject("Project"), SIGNAL("projectPropertiesChanged"),
+self.__projectPropertiesChanged)
+if self.spell:
+self.spell.stopIncrementalCheck()
+QsciScintillaCompat.close(self)
+def keyPressEvent(self, ev):
+"""
+Re-implemented to handle the user input a key at a time.
+@param ev key event (QKeyEvent)
+"""
+txt = ev.text()
+key = ev.key()
+# See it is text to insert.
+if len(txt) and txt >= " ":
+QsciScintillaCompat.keyPressEvent(self, ev)
+else:
+ev.ignore()
+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.vm.editActGrp.setEnabled(True)
+self.vm.editorActGrp.setEnabled(True)
+self.vm.copyActGrp.setEnabled(True)
+self.vm.viewActGrp.setEnabled(True)
+try:
+self.setCaretWidth(self.caretWidth)
+except AttributeError:
+pass
+self.__updateReadOnly(False)
+if self.vm.editorsCheckFocusInEnabled() and \
+not self.inReopenPrompt and self.fileName and \
+QFileInfo(self.fileName).lastModified().toString() != \
+self.lastModified.toString():
+if Preferences.getEditor("AutoReopen") and not self.isModified():
+self.refresh()
+else:
+self.inReopenPrompt = True
+msg = self.trUtf8(\
+"""<p>The file <b>{0}</b> has been changed while it was opened in"""
+""" eric4. Reread it?</p>""").format(self.fileName)
+default = QMessageBox.No
+if self.isModified():
+msg += self.trUtf8(\
+"""<br><b>Warning:</b> You will loose"""
+""" your changes upon reopening it.""")
+default = QMessageBox.Ok
+res = QMessageBox.warning(None,
+self.trUtf8("File changed"), msg,
+QMessageBox.StandardButtons(\
+QMessageBox.Yes | \
+QMessageBox.No),
+default)
+if res == QMessageBox.Yes:
+self.refresh()
+else:
+# do not prompt for this change again...
+self.lastModified = QFileInfo(self.fileName).lastModified()
+self.inReopenPrompt = False
+QsciScintillaCompat.focusInEvent(self, event)
+def focusOutEvent(self, event):
+"""
+Public method called when the editor loses focus.
+@param event the event object (QFocusEvent)
+"""
+self.vm.editorActGrp.setEnabled(False)
+self.setCaretWidth(0)
+QsciScintillaCompat.focusOutEvent(self, event)
+def changeEvent(self, evt):
+"""
+Protected method called to process an event.
+This implements special handling for the events showMaximized,
+showMinimized and showNormal. The windows caption is shortened
+for the minimized mode and reset to the full filename for the
+other modes. This is to make the editor windows work nicer
+with the QWorkspace.
+@param evt the event, that was generated (QEvent)
+@return flag indicating if the event could be processed (bool)
+"""
+if evt.type() == QEvent.WindowStateChange and \
+self.fileName is not None:
+if self.windowState() == Qt.WindowStates(Qt.WindowMinimized):
+cap = os.path.basename(self.fileName)
+else:
+cap = self.fileName
+if self.isReadOnly():
+cap = self.trUtf8("{0} (ro)").format(cap)
+self.setWindowTitle(cap)
+QsciScintillaCompat.changeEvent(self, evt)
+def mousePressEvent(self, event):
+"""
+Protected method to handle the mouse press event.
+@param event the mouse press event (QMouseEvent)
+"""
+self.vm.eventFilter(self, event)
+QsciScintillaCompat.mousePressEvent(self, event)
+def __updateReadOnly(self, bForce = True):
+"""
+Private method to update the readOnly information for this editor.
+If bForce is True, then updates everything regardless if
+the attributes have actually changed, such as during
+initialization time.  A signal is emitted after the
+caption change.
+@param bForce True to force change, False to only update and emit
+signal if there was an attribute change.
+"""
+if self.fileName is None:
+return
+readOnly = not QFileInfo(self.fileName).isWritable()
+if not bForce and (readOnly == self.isReadOnly()):
+return
+cap = self.fileName
+if readOnly:
+cap = self.trUtf8("{0} (ro)".format(cap))
+self.setReadOnly(readOnly)
+self.setWindowTitle(cap)
+self.emit(SIGNAL('captionChanged'), cap, self)
+def refresh(self):
+"""
+Public slot to refresh the editor contents.
+"""
+# save cursor position
+cline, cindex = self.getCursorPosition()
+# save bookmarks and breakpoints and clear them
+bmlist = self.getBookmarks()
+self.clearBookmarks()
+# clear syntax error markers
+self.clearSyntaxError()
+# clear breakpoint markers
+for handle in self.breaks.keys():
+self.markerDeleteHandle(handle)
+self.breaks = {}
+# reread the file
+try:
+self.readFile(self.fileName)
+except IOError:
+# do not prompt for this change again...
+self.lastModified = QDateTime.currentDateTime()
+self.setModified(False)
+# reset cursor position
+self.setCursorPosition(cline, cindex)
+self.ensureCursorVisible()
+# reset bookmarks and breakpoints to their old position
+if bmlist:
+for bm in bmlist:
+self.toggleBookmark(bm)
+self.__restoreBreakpoints()
+self.emit(SIGNAL('editorSaved'), self.fileName)
+self.__autoSyntaxCheck()
+def setMonospaced(self, on):
+"""
+Public method to set/reset a monospaced font.
+@param on flag to indicate usage of a monospace font (boolean)
+"""
+if on:
+f = Preferences.getEditorOtherFonts("MonospacedFont")
+self.monospacedStyles(f)
+else:
+if not self.lexer_:
+self.clearStyles()
+self.__setMarginsDisplay()
+self.setFont(Preferences.getEditorOtherFonts("DefaultFont"))
+self.useMonospaced = on
+#################################################################
+## Drag and Drop Support
+#################################################################
+def dragEnterEvent(self, event):
+"""
+Protected method to handle the drag enter event.
+@param event the drag enter event (QDragEnterEvent)
+"""
+self.inDragDrop = event.mimeData().hasUrls()
+if self.inDragDrop:
+event.acceptProposedAction()
+else:
+QsciScintillaCompat.dragEnterEvent(self, event)
+def dragMoveEvent(self, event):
+"""
+Protected method to handle the drag move event.
+@param event the drag move event (QDragMoveEvent)
+"""
+if self.inDragDrop:
+event.accept()
+else:
+QsciScintillaCompat.dragMoveEvent(self, event)
+def dragLeaveEvent(self, event):
+"""
+Protected method to handle the drag leave event.
+@param event the drag leave event (QDragLeaveEvent)
+"""
+if self.inDragDrop:
+self.inDragDrop = False
+event.accept()
+else:
+QsciScintillaCompat.dragLeaveEvent(self, event)
+def dropEvent(self, event):
+"""
+Protected method to handle the drop event.
+@param event the drop event (QDropEvent)
+"""
+if event.mimeData().hasUrls():
+for url in event.mimeData().urls():
+fname = url.toLocalFile()
+if fname:
+if not QFileInfo(fname).isDir():
+self.vm.openSourceFile(fname)
+else:
+QMessageBox.information(None,
+self.trUtf8("Drop Error"),
+self.trUtf8("""<p><b>{0}</b> is not a file.</p>""")
+.format(fname))
+event.acceptProposedAction()
+else:
+QsciScintillaCompat.dropEvent(self, event)
+self.inDragDrop = False
+#################################################################
+## Support for Qt resources files
+#################################################################
+def __initContextMenuResources(self):
+"""
+Private method used to setup the Resources context sub menu.
+"""
+menu = QMenu(self.trUtf8('Resources'))
+menu.addAction(self.trUtf8('Add file...'),
+self.__addFileResource)
+menu.addAction(self.trUtf8('Add files...'),
+self.__addFileResources)
+menu.addAction(self.trUtf8('Add aliased file...'),
+self.__addFileAliasResource)
+menu.addAction(self.trUtf8('Add localized resource...'),
+self.__addLocalizedResource)
+menu.addSeparator()
+menu.addAction(self.trUtf8('Add resource frame'),
+self.__addResourceFrame)
+self.connect(menu, SIGNAL('aboutToShow()'), self.__showContextMenuResources)
+return menu
+def __showContextMenuResources(self):
+"""
+Private slot handling the aboutToShow signal of the resources context menu.
+"""
+self.emit(SIGNAL("showMenu"), "Resources", self.resourcesMenu,  self)
+def __addFileResource(self):
+"""
+Private method to handle the Add file context menu action.
+"""
+dirStr = os.path.dirname(self.fileName)
+file = QFileDialog.getOpenFileName(\
+self,
+self.trUtf8("Add file resource"),
+dirStr,
+"")
+if file:
+relFile = QDir(dirStr).relativeFilePath(file)
+line, index = self.getCursorPosition()
+self.insert("  <file>{0}</file>\n".format(relFile))
+self.setCursorPosition(line + 1, index)
+def __addFileResources(self):
+"""
+Private method to handle the Add files context menu action.
+"""
+dirStr = os.path.dirname(self.fileName)
+files = QFileDialog.getOpenFileNames(\
+self,
+self.trUtf8("Add file resources"),
+dirStr,
+"")
+if files:
+myDir = QDir(dirStr)
+filesText = ""
+for file in files:
+relFile = myDir.relativeFilePath(file)
+filesText += "  <file>{0}</file>\n".format(relFile)
+line, index = self.getCursorPosition()
+self.insert(filesText)
+self.setCursorPosition(line + len(files), index)
+def __addFileAliasResource(self):
+"""
+Private method to handle the Add aliased file context menu action.
+"""
+dirStr = os.path.dirname(self.fileName)
+file = QFileDialog.getOpenFileName(\
+self,
+self.trUtf8("Add aliased file resource"),
+dirStr,
+"")
+if file:
+relFile = QDir(dirStr).relativeFilePath(file)
+alias, ok = QInputDialog.getText(\
+self,
+self.trUtf8("Add aliased file resource"),
+self.trUtf8("Alias for file <b>{0}</b>:").format(relFile),
+QLineEdit.Normal,
+relFile)
+if ok and alias:
+line, index = self.getCursorPosition()
+self.insert('  <file alias="{1}">{0}</file>\n'\
+.format(relFile, alias))
+self.setCursorPosition(line + 1, index)
+def __addLocalizedResource(self):
+"""
+Private method to handle the Add localized resource context menu action.
+"""
+from Project.AddLanguageDialog import AddLanguageDialog
+dlg = AddLanguageDialog(self)
+if dlg.exec_() == QDialog.Accepted:
+lang = dlg.getSelectedLanguage()
+line, index = self.getCursorPosition()
+self.insert('<qresource lang="{0}">\n</qresource>\n'.format(lang))
+self.setCursorPosition(line + 2, index)
+def __addResourceFrame(self):
+"""
+Private method to handle the Add resource frame context menu action.
+"""
+line, index = self.getCursorPosition()
+self.insert('<!DOCTYPE RCC>\n'
+'<RCC version="1.0">\n'
+'<qresource>\n'
+'</qresource>\n'
+'</RCC>\n')
+self.setCursorPosition(line + 5, index)
+#################################################################
+## Support for diagrams below
+#################################################################
+def __showClassDiagram(self):
+"""
+Private method to handle the Class Diagram context menu action.
+"""
+from Graphics.UMLClassDiagram import UMLClassDiagram
+if not self.checkDirty():
+return
+self.classDiagram = UMLClassDiagram(self.fileName, self, noAttrs = False)
+self.classDiagram.show()
+def __showPackageDiagram(self):
+"""
+Private method to handle the Package Diagram context menu action.
+"""
+from Graphics.PackageDiagram import PackageDiagram
+if not self.checkDirty():
+return
+package = os.path.isdir(self.fileName) and self.fileName \
+or os.path.dirname(self.fileName)
+res = QMessageBox.question(None,
+self.trUtf8("Package Diagram"),
+self.trUtf8("""Include class attributes?"""),
+QMessageBox.StandardButtons(\
+QMessageBox.No | \
+QMessageBox.Yes),
+QMessageBox.Yes)
+self.packageDiagram = PackageDiagram(package, self,
+noAttrs = (res == QMessageBox.No))
+self.packageDiagram.show()
+def __showImportsDiagram(self):
+"""
+Private method to handle the Imports Diagram context menu action.
+"""
+from Graphics.ImportsDiagram import ImportsDiagram
+if not self.checkDirty():
+return
+package = os.path.isdir(self.fileName) and self.fileName \
+or os.path.dirname(self.fileName)
+res = QMessageBox.question(None,
+self.trUtf8("Imports Diagram"),
+self.trUtf8("""Include imports from external modules?"""),
+QMessageBox.StandardButtons(\
+QMessageBox.No | \
+QMessageBox.Yes),
+QMessageBox.No)
+self.importsDiagram = ImportsDiagram(package, self,
+showExternalImports = (res == QMessageBox.Yes))
+self.importsDiagram.show()
+def __showApplicationDiagram(self):
+"""
+Private method to handle the Imports Diagram context menu action.
+"""
+from Graphics.ApplicationDiagram import ApplicationDiagram
+res = QMessageBox.question(None,
+self.trUtf8("Application Diagram"),
+self.trUtf8("""Include module names?"""),
+QMessageBox.StandardButtons(\
+QMessageBox.No | \
+QMessageBox.Yes),
+QMessageBox.Yes)
+self.applicationDiagram = ApplicationDiagram(e4App().getObject("Project"),
+self, noModules = (res == QMessageBox.No))
+self.applicationDiagram.show()
+#######################################################################
+## Typing aids related methods below
+#######################################################################
+def __toggleTypingAids(self):
+"""
+Private slot to toggle the typing aids.
+"""
+if self.menuActs["TypingAidsEnabled"].isChecked():
+self.completer.setEnabled(True)
+else:
+self.completer.setEnabled(False)
+#######################################################################
+## Autocompleting templates
+#######################################################################
+def editorCommand(self, cmd):
+"""
+Public method to perform a simple editor command.
+@param cmd the scintilla command to be performed
+"""
+if cmd == QsciScintilla.SCI_TAB:
+line, index = self.getCursorPosition()
+tmplName = self.getWordLeft(line, index)
+if tmplName:
+if e4App().getObject("TemplateViewer").hasTemplate(tmplName):
+self.__applyTemplate(tmplName)
+return
+else:
+templateNames = \
+e4App().getObject("TemplateViewer").getTemplateNames(tmplName)
+if len(templateNames) == 1:
+self.__applyTemplate(templateNames[0])
+return
+elif len(templateNames) > 1:
+self.showUserList(TemplateCompletionListID,
+["%s?%d" % (t, self.TemplateImageID) for t in templateNames])
+return
+QsciScintillaCompat.editorCommand(self, cmd)
+def __completionListSelected(self, id, txt):
+"""
+Private slot to handle the selection from the completion list.
+@param id the ID of the user list (should be 1) (integer)
+@param txt the selected text (string)
+"""
+if id == TemplateCompletionListID:
+self.__applyTemplate(txt)
+def __applyTemplate(self, templateName):
+"""
+Private method to apply a template by name.
+@param templateName name of the template to apply (string)
+"""
+if e4App().getObject("TemplateViewer").hasTemplate(templateName):
+self.extendSelectionWordLeft()
+e4App().getObject("TemplateViewer").applyNamedTemplate(templateName)
+#######################################################################
+## Project related methods
+#######################################################################
+def __projectPropertiesChanged(self):
+"""
+Private slot to handle changes of the project properties.
+"""
+project = e4App().getObject("Project")
+if self.spell:
+pwl, pel = project.getProjectDictionaries()
+self.__setSpellingLanguage(project.getProjectSpellLanguage(),
+pwl = pwl, pel = pel)
+def addedToProject(self):
+"""
+Public method to signal, that this editor has been added to a project.
+"""
+project = e4App().getObject("Project")
+if self.spell:
+pwl, pel = project.getProjectDictionaries()
+self.__setSpellingLanguage(project.getProjectSpellLanguage(),
+pwl = pwl, pel = pel)
+self.connect(project, SIGNAL("projectPropertiesChanged"),
+self.__projectPropertiesChanged)
+#######################################################################
+## Spellchecking related methods
+#######################################################################
+def __setSpellingLanguage(self, language, pwl = "", pel = ""):
+"""
+Private slot to set the spell checking language.
+@param language spell checking language to be set (string)
+@keyparam pwl name of the personal/project word list (string)
+@keyparam pel name of the personal/project exclude list (string)
+"""
+if self.spell and self.spell.getLanguage() != language:
+self.spell.setLanguage(language, pwl = pwl, pel = pel)
+self.spell.checkDocumentIncrementally()
+def __setSpelling(self):
+"""
+Private method to initialize the spell checking functionality.
+"""
+if Preferences.getEditor("SpellCheckingEnabled"):
+self.__spellCheckStringsOnly = Preferences.getEditor("SpellCheckStringsOnly")
+if self.spell is None:
+self.spell = SpellChecker(self, self.spellingIndicator,
+checkRegion = self.isSpellCheckRegion)
+self.setSpellingForProject()
+self.connect(e4App().getObject("Project"), SIGNAL("projectPropertiesChanged"),
+self.__projectPropertiesChanged)
+self.spell.setMinimumWordSize(
+Preferences.getEditor("SpellCheckingMinWordSize"))
+self.setAutoSpellChecking()
+else:
+self.spell = None
+self.clearAllIndicators(self.spellingIndicator)
+def setSpellingForProject(self):
+"""
+Public method to set the spell checking options for files belonging
+to the current project.
+"""
+project = e4App().getObject("Project")
+if project.isOpen() and project.isProjectSource(self.fileName):
+pwl, pel = project.getProjectDictionaries()
+self.__setSpellingLanguage(project.getProjectSpellLanguage(),
+pwl = pwl, pel = pel)
+def setAutoSpellChecking(self):
+"""
+Public method to set the automatic spell checking.
+"""
+if Preferences.getEditor("AutoSpellCheckingEnabled"):
+self.connect(self, SIGNAL("SCN_CHARADDED(int)"), self.__spellCharAdded)
+self.spell.checkDocumentIncrementally()
+else:
+self.disconnect(self, SIGNAL("SCN_CHARADDED(int)"), self.__spellCharAdded)
+self.clearAllIndicators(self.spellingIndicator)
+def isSpellCheckRegion(self, pos):
+"""
+Public method to check, if the given position is within a region, that should
+be spell checked.
+@param pos position to be checked (integer)
+@return flag indicating pos is in a spell check region (boolean)
+"""
+if self.__spellCheckStringsOnly:
+style = self.styleAt(pos)
+if self.lexer_ is not None:
+return self.lexer_.isCommentStyle(style) or \
+self.lexer_.isStringStyle(style)
+return True
+def __spellCharAdded(self, charNumber):
+"""
+Public slot called to handle the user entering a character.
+@param charNumber value of the character entered (integer)
+"""
+if self.spell:
+if not unichr(charNumber).isalnum():
+self.spell.checkWord(self.positionBefore(self.currentPosition()), True)
+elif self.hasIndicator(self.spellingIndicator, self.currentPosition()):
+self.spell.checkWord(self.currentPosition())
+def checkSpelling(self):
+"""
+Public slot to perform an interactive spell check of the document.
+"""
+if self.spell:
+cline, cindex = self.getCursorPosition()
+dlg = SpellCheckingDialog(self.spell, 0, self.length(), self)
+dlg.exec_()
+self.setCursorPosition(cline, cindex)
+if Preferences.getEditor("AutoSpellCheckingEnabled"):
+self.spell.checkDocumentIncrementally()
+def __checkSpellingSelection(self):
+"""
+Private slot to spell check the current selection.
+"""
+sline, sindex, eline, eindex = self.getSelection()
+startPos = self.positionFromLineIndex(sline, sindex)
+endPos = self.positionFromLineIndex(eline, eindex)
+dlg = SpellCheckingDialog(self.spell, startPos, endPos, self)
+dlg.exec_()
+def __checkSpellingWord(self):
+"""
+Private slot to check the word below the spelling context menu.
+"""
+line, index = self.lineIndexFromPosition(self.spellingMenuPos)
+wordStart, wordEnd = self.getWordBoundaries(line, index)
+wordStartPos = self.positionFromLineIndex(line, wordStart)
+wordEndPos = self.positionFromLineIndex(line, wordEnd)
+dlg = SpellCheckingDialog(self.spell, wordStartPos, wordEndPos, self)
+dlg.exec_()
+def __showContextMenuSpelling(self):
+"""
+Private slot to set up the spelling menu before it is shown.
+"""
+self.spellingMenu.clear()
+self.spellingSuggActs = []
+line, index = self.lineIndexFromPosition(self.spellingMenuPos)
+word = self.getWord(line, index)
+suggestions = self.spell.getSuggestions(word)
+for suggestion in suggestions[:5]:
+self.spellingSuggActs.append(self.spellingMenu.addAction(suggestion))
+if suggestions:
+self.spellingMenu.addSeparator()
+self.spellingMenu.addAction(UI.PixmapCache.getIcon("spellchecking.png"),
+self.trUtf8("Check spelling..."), self.__checkSpellingWord)
+self.spellingMenu.addAction(self.trUtf8("Add to dictionary"),
+self.__addToSpellingDictionary)
+self.spellingMenu.addAction(self.trUtf8("Ignore All"),
+self.__ignoreSpellingAlways)
+self.emit(SIGNAL("showMenu"), "Spelling", self.spellingMenu,  self)
+def __contextMenuSpellingTriggered(self, action):
+"""
+Private slot to handle the selection of a suggestion of the spelling context menu.
+@param action reference to the action that was selected (QAction)
+"""
+if action in self.spellingSuggActs:
+replacement = action.text()
+line, index = self.lineIndexFromPosition(self.spellingMenuPos)
+wordStart, wordEnd = self.getWordBoundaries(line, index)
+self.setSelection(line, wordStart, line, wordEnd)
+self.beginUndoAction()
+self.removeSelectedText()
+self.insert(replacement)
+self.endUndoAction()
+def __addToSpellingDictionary(self):
+"""
+Private slot to add the word below the spelling context menu to the dictionary.
+"""
+line, index = self.lineIndexFromPosition(self.spellingMenuPos)
+word = self.getWord(line, index)
+self.spell.add(word)
+wordStart, wordEnd = self.getWordBoundaries(line, index)
+self.clearIndicator(self.spellingIndicator, line, wordStart, line, wordEnd)
+if Preferences.getEditor("AutoSpellCheckingEnabled"):
+self.spell.checkDocumentIncrementally()
+def __removeFromSpellingDictionary(self):
+"""
+Private slot to remove the word below the context menu to the dictionary.
+"""
+line, index = self.lineIndexFromPosition(self.spellingMenuPos)
+word = self.getWord(line, index)
+self.spell.remove(word)
+if Preferences.getEditor("AutoSpellCheckingEnabled"):
+self.spell.checkDocumentIncrementally()
+def __ignoreSpellingAlways(self):
+"""
+Private to always ignore the word below the spelling context menu.
+"""
+line, index = self.lineIndexFromPosition(self.spellingMenuPos)
+word = self.getWord(line, index)
+self.spell.ignoreAlways(word)
+if Preferences.getEditor("AutoSpellCheckingEnabled"):
+self.spell.checkDocumentIncrementally()

Mercurial Repositories > eric / file comparison

comparison: QScintilla/Editor.py

QScintilla/Editor.py