--- a/QScintilla/Editor.py Sun Jan 31 11:52:29 2010 +0000
+++ b/QScintilla/Editor.py Sun Jan 31 11:58:27 2010 +0000
@@ -1,5454 +1,5458 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2002 - 2010 Detlev Offenbach <detlev@die-offenbachs.de>
-#
-
-"""
-Module implementing the editor component of the eric5 IDE.
-"""
-
-import os
-import re
-import types
-
-from PyQt4.Qsci import QsciScintilla, QsciMacro
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from E5Gui.E5Application import e5App
-
-from . import Exporters
-from . import Lexers
-from . import TypingCompleters
-from .QsciScintillaCompat import QsciScintillaCompat, QSCINTILLA_VERSION
-from .SpellChecker import SpellChecker
-from .SpellCheckingDialog import SpellCheckingDialog
-
-from Debugger.EditBreakpointDialog import EditBreakpointDialog
-
-from DebugClients.Python3.coverage import coverage
-
-from DataViews.CodeMetricsDialog import CodeMetricsDialog
-from DataViews.PyCoverageDialog import PyCoverageDialog
-from DataViews.PyProfileDialog import PyProfileDialog
-
-from .Printer import Printer
-
-import Preferences
-import Utilities
-from Utilities.py3flakes.checker import Checker
-from Utilities.py3flakes.messages import ImportStarUsed
-
-import UI.PixmapCache
-
-EditorAutoCompletionListID = 1
-TemplateCompletionListID = 2
-
-class Editor(QsciScintillaCompat):
- """
- Class implementing the editor component of the eric5 IDE.
-
- @signal modificationStatusChanged(boolean, editor) emitted when the
- modification status has changed
- @signal undoAvailable(boolean) emitted to signal the undo availability
- @signal redoAvailable(boolean) emitted to signal the redo availability
- @signal cursorChanged(string, int, int) emitted when the cursor position
- was changed
- @signal editorAboutToBeSaved(string) emitted before the editor is saved
- @signal editorSaved(string) emitted after the editor has been saved
- @signal editorRenamed(string) emitted after the editor got a new name
- (i.e. after a 'Save As')
- @signal captionChanged(string, editor) emitted when the caption is
- updated. Typically due to a readOnly attribute change.
- @signal breakpointToggled(editor) emitted when a breakpoint is toggled
- @signal bookmarkToggled(editor) emitted when a bookmark is toggled
- @signal syntaxerrorToggled(editor) emitted when a syntax error was discovered
- @signal autoCompletionAPIsAvailable(avail) emitted after the autocompletion
- function has been configured
- @signal coverageMarkersShown(boolean) emitted after the coverage markers have been
- shown or cleared
- @signal taskMarkersUpdated(editor) emitted when the task markers were updated
- @signal showMenu(string, QMenu, editor) emitted when a menu is about to be shown.
- The name of the menu, a reference to the menu and a reference to the
- editor are given.
- @signal languageChanged(language) emitted when the editors language was set. The
- language is passed as a parameter.
- @signal eolChanged(eol) emitted when the editors eol type was set. The eol string
- is passed as a parameter.
- @signal encodingChanged(encoding) emitted when the editors encoding was set. The
- encoding name is passed as a parameter.
- """
- 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.warnings = {} # key: marker handle
- # value: warning 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"))
- self.warning = \
- self.markerDefine(UI.PixmapCache.getPixmap("warning.png"))
-
- # define the line markers
- self.currentline = self.markerDefine(QsciScintilla.Background)
- self.errorline = self.markerDefine(QsciScintilla.Background)
- self.__setLineMarkerColours()
-
- self.breakpointMask = (1 << self.breakpoint) | \
- (1 << self.cbreakpoint) | \
- (1 << self.tbreakpoint) | \
- (1 << self.tcbreakpoint) | \
- (1 << self.dbreakpoint)
-
- # configure the margins
- self.__setMarginsDisplay()
-
- self.connect(self, SIGNAL('marginClicked(int, int, Qt::KeyboardModifiers)'),
- self.__marginClicked)
-
- # set the eol mode
- self.__setEolMode()
-
- self.isResourcesFile = False
- if editor is None:
- if self.fileName is not None:
- if (QFileInfo(self.fileName).size() // 1024) > \
- Preferences.getEditor("WarnFilesize"):
- res = QMessageBox.warning(None,
- self.trUtf8("Open File"),
- self.trUtf8("""<p>The size of the file <b>{0}</b>"""
- """ is <b>{1} KB</b>."""
- """ Do you really want to load it?</p>""")\
- .format(self.fileName,
- QFileInfo(self.fileName).size() // 1024),
- QMessageBox.StandardButtons(\
- QMessageBox.No | \
- QMessageBox.Yes),
- QMessageBox.No)
- if res == QMessageBox.No or res == QMessageBox.Cancel:
- raise IOError()
- self.readFile(self.fileName, True)
- bindName = self.__bindName(self.text(0))
- self.__bindLexer(bindName)
- self.__bindCompleter(bindName)
- self.__autoSyntaxCheck()
- self.isResourcesFile = self.fileName.endswith(".qrc")
-
- self.recolor()
- else:
- # clone the given editor
- self.setDocument(editor.document())
- self.breaks = editor.breaks
- self.bookmarks = editor.bookmarks
- self.syntaxerrors = editor.syntaxerrors
- self.notcoveredMarkers = editor.notcoveredMarkers
- self.isResourcesFile = editor.isResourcesFile
- self.lastModified = editor.lastModified
-
- self.addClone(editor)
- editor.addClone(self)
-
- self.gotoLine(0)
-
- # set the text display
- self.__setTextDisplay()
-
- # set the autocompletion and calltips function
- self.__acHookFunction = None
- self.__setAutoCompletion()
- self.__ctHookFunction = None
- self.__setCallTips()
-
- sh = self.sizeHint()
- if sh.height() < 300:
- sh.setHeight(300)
- self.resize(sh)
-
- # Make sure tabbing through a QWorkspace works.
- self.setFocusPolicy(Qt.StrongFocus)
-
- self.__updateReadOnly(True)
-
- self.setWhatsThis(self.trUtf8(
- """<b>A Source Editor Window</b>"""
- """<p>This window is used to display and edit a source file."""
- """ You can open as many of these as you like. The name of the file"""
- """ is displayed in the window's titlebar.</p>"""
- """<p>In order to set breakpoints just click in the space between"""
- """ the line numbers and the fold markers. Via the context menu"""
- """ of the margins they may be edited.</p>"""
- """<p>In order to set bookmarks just Shift click in the space between"""
- """ the line numbers and the fold markers.</p>"""
- """<p>These actions can be reversed via the context menu.</p>"""
- """<p>Ctrl clicking on a syntax error marker shows some info"""
- """ about this error.</p>"""
- ))
-
- # Set the editors size, if it is too big for the view manager.
- if self.vm is not None:
- req = self.size()
- bnd = req.boundedTo(self.vm.size())
-
- if bnd.width() < req.width() or bnd.height() < req.height():
- self.resize(bnd)
-
- # set the autosave flag
- self.autosaveEnabled = Preferences.getEditor("AutosaveInterval") > 0
- self.autosaveManuallyDisabled = False
-
- self.__initContextMenu()
- self.__initContextMenuMargins()
-
- self.__checkEol()
- if editor is None:
- self.__checkLanguage()
- self.__checkEncoding()
- else:
- # it's a clone
- self.languageChanged(editor.apiLanguage, propagate = False)
- self.__encodingChanged(editor.encoding, propagate = False)
-
- self.coverageMarkersShown = False # flag remembering the current status of the
- # code coverage markers
-
- self.setAcceptDrops(True)
-
- # breakpoint handling
- self.breakpointModel = self.dbs.getBreakPointModel()
- self.__restoreBreakpoints()
- self.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("None")
- self.languagesActGrp.addAction(self.noLanguageAct)
- menu.addSeparator()
-
- self.supportedLanguages = {}
- supportedLanguages = Lexers.getSupportedLanguages()
- languages = sorted(list(supportedLanguages.keys()))
- for language in languages:
- if language != "Guessed":
- self.supportedLanguages[language] = supportedLanguages[language][:]
- act = menu.addAction(self.supportedLanguages[language][0])
- act.setCheckable(True)
- act.setData(language)
- self.supportedLanguages[language].append(act)
- self.languagesActGrp.addAction(act)
-
- menu.addSeparator()
- self.pygmentsAct = menu.addAction(self.trUtf8("Guessed"))
- self.pygmentsAct.setCheckable(True)
- self.pygmentsAct.setData("Guessed")
- self.languagesActGrp.addAction(self.pygmentsAct)
- self.pygmentsSelAct = menu.addAction(self.trUtf8("Alternatives"))
- self.pygmentsSelAct.setData("Alternatives")
-
- self.connect(menu, SIGNAL('triggered(QAction *)'), self.__languageMenuTriggered)
- 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(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('\n')
- self.supportedEols['\n'] = act
- self.eolActGrp.addAction(act)
-
- act = menu.addAction(self.trUtf8("Windows"))
- act.setCheckable(True)
- act.setData('\r\n')
- self.supportedEols['\r\n'] = act
- self.eolActGrp.addAction(act)
-
- act = menu.addAction(self.trUtf8("Macintosh"))
- act.setCheckable(True)
- act.setData('\r')
- self.supportedEols['\r'] = act
- self.eolActGrp.addAction(act)
-
- self.connect(menu, SIGNAL('triggered(QAction *)'), self.__eolMenuTriggered)
- 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 = sorted(list(supportedExporters.keys()))
- for exporter in exporters:
- act = menu.addAction(supportedExporters[exporter])
- act.setData(exporter)
-
- self.connect(menu, SIGNAL('triggered(QAction *)'), self.__exportMenuTriggered)
-
- return menu
-
- def __initContextMenuMargins(self):
- """
- Private method used to setup the context menu for the margins
- """
- self.marginMenuActs = {}
-
- if self.__unifiedMargins:
- self.__initContextMenuUnifiedMargins()
- else:
- self.__initContextMenuSeparateMargins()
-
- def __initContextMenuSeparateMargins(self):
- """
- Private method used to setup the context menu for the separated margins
- """
- # bookmark margin
- self.bmMarginMenu = QMenu()
-
- self.bmMarginMenu.addAction(self.trUtf8('Toggle bookmark'),
- self.menuToggleBookmark)
- self.marginMenuActs["NextBookmark"] = \
- self.bmMarginMenu.addAction(self.trUtf8('Next bookmark'),
- self.nextBookmark)
- self.marginMenuActs["PreviousBookmark"] = \
- self.bmMarginMenu.addAction(self.trUtf8('Previous bookmark'),
- self.previousBookmark)
- self.marginMenuActs["ClearBookmark"] = \
- self.bmMarginMenu.addAction(self.trUtf8('Clear all bookmarks'),
- self.clearBookmarks)
-
- self.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["NextWarningMarker"] = \
- self.indicMarginMenu.addAction(self.trUtf8("Next warning"),
- self.nextFlakesWarning)
- self.marginMenuActs["PreviousWarningMarker"] = \
- self.indicMarginMenu.addAction(self.trUtf8("Previous warning"),
- self.previousFlakesWarning)
- self.marginMenuActs["ShowWarning"] = \
- self.indicMarginMenu.addAction(self.trUtf8('Show warning message'),
- self.__showFlakesWarning)
- self.marginMenuActs["ClearWarnings"] = \
- self.indicMarginMenu.addAction(self.trUtf8('Clear warnings'),
- self.clearFlakesWarnings)
- self.indicMarginMenu.addSeparator()
- self.marginMenuActs["NextCoverageMarker"] = \
- self.indicMarginMenu.addAction(self.trUtf8('Next uncovered line'),
- self.nextUncovered)
- self.marginMenuActs["PreviousCoverageMarker"] = \
- self.indicMarginMenu.addAction(self.trUtf8('Previous uncovered line'),
- self.previousUncovered)
- self.indicMarginMenu.addSeparator()
- self.marginMenuActs["NextTaskMarker"] = \
- self.indicMarginMenu.addAction(self.trUtf8('Next task'),
- self.nextTask)
- self.marginMenuActs["PreviousTaskMarker"] = \
- self.indicMarginMenu.addAction(self.trUtf8('Previous task'),
- self.previousTask)
-
- self.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["NextWarningMarker"] = \
- self.marginMenu.addAction(self.trUtf8("Next warning"),
- self.nextFlakesWarning)
- self.marginMenuActs["PreviousWarningMarker"] = \
- self.marginMenu.addAction(self.trUtf8("Previous warning"),
- self.previousFlakesWarning)
- self.marginMenuActs["ShowWarning"] = \
- self.marginMenu.addAction(self.trUtf8('Show warning message'),
- self.__showFlakesWarning)
- self.marginMenuActs["ClearWarnings"] = \
- self.marginMenu.addAction(self.trUtf8('Clear warnings'),
- self.clearFlakesWarnings)
- self.marginMenu.addSeparator()
- self.marginMenuActs["Breakpoint"] = \
- self.marginMenu.addAction(self.trUtf8('Toggle breakpoint'),
- self.menuToggleBreakpoint)
- self.marginMenuActs["TempBreakpoint"] = \
- self.marginMenu.addAction(self.trUtf8('Toggle temporary breakpoint'),
- self.__menuToggleTemporaryBreakpoint)
- self.marginMenuActs["EditBreakpoint"] = \
- self.marginMenu.addAction(self.trUtf8('Edit breakpoint...'),
- self.menuEditBreakpoint)
- self.marginMenuActs["EnableBreakpoint"] = \
- self.marginMenu.addAction(self.trUtf8('Enable breakpoint'),
- self.__menuToggleBreakpointEnabled)
- self.marginMenuActs["NextBreakpoint"] = \
- self.marginMenu.addAction(self.trUtf8('Next breakpoint'),
- self.menuNextBreakpoint)
- self.marginMenuActs["PreviousBreakpoint"] = \
- self.marginMenu.addAction(self.trUtf8('Previous breakpoint'),
- self.menuPreviousBreakpoint)
- self.marginMenuActs["ClearBreakpoint"] = \
- self.marginMenu.addAction(self.trUtf8('Clear all breakpoints'),
- self.__menuClearBreakpoints)
- self.marginMenu.addSeparator()
- self.marginMenuActs["NextCoverageMarker"] = \
- self.marginMenu.addAction(self.trUtf8('Next uncovered line'),
- self.nextUncovered)
- self.marginMenuActs["PreviousCoverageMarker"] = \
- self.marginMenu.addAction(self.trUtf8('Previous uncovered line'),
- self.previousUncovered)
- self.marginMenu.addSeparator()
- self.marginMenuActs["NextTaskMarker"] = \
- self.marginMenu.addAction(self.trUtf8('Next task'),
- self.nextTask)
- self.marginMenuActs["PreviousTaskMarker"] = \
- self.marginMenu.addAction(self.trUtf8('Previous task'),
- self.previousTask)
- self.marginMenu.addSeparator()
- self.marginMenuActs["LMBbookmarks"] = \
- self.marginMenu.addAction(self.trUtf8('LMB toggles bookmarks'),
- self.__lmBbookmarks)
- self.marginMenuActs["LMBbookmarks"].setCheckable(True)
- self.marginMenuActs["LMBbookmarks"].setChecked(False)
- self.marginMenuActs["LMBbreakpoints"] = \
- self.marginMenu.addAction(self.trUtf8('LMB toggles breakpoints'),
- self.__lmBbreakpoints)
- self.marginMenuActs["LMBbreakpoints"].setCheckable(True)
- self.marginMenuActs["LMBbreakpoints"].setChecked(True)
-
- self.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()
- 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()
- 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()
- 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()
- 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 = e5App().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()
- fdesc = Preferences.Prefs.settings.value(key)
- if fdesc is not None:
- 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 list(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 list(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 list(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 list(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 list(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 list(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 list(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 = e5App().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 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)
- """
- QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
-
- try:
- if createIt and not os.path.exists(fn):
- f = open(fn, "w")
- f.close()
- txt, self.encoding = Utilities.readEncodedFile(fn)
- except (UnicodeDecodeError, IOError) as why:
- QApplication.restoreOverrideCursor()
- QMessageBox.critical(self.vm, self.trUtf8('Open File'),
- self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>'
- '<p>Reason: {1}</p>')
- .format(fn, str(why)))
- QApplication.restoreOverrideCursor()
- raise
- 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 (boolean)
- """
- 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
-
- # 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:
- self.encoding = Utilities.writeEncodedFile(fn, txt, self.encoding)
- if createBackup and perms_valid:
- os.chmod(fn, permissions)
- return True
- except (IOError, Utilities.CodingError, UnicodeError) as 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, str(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)
- elif self.markersAtLine(line) & (1 << self.warning):
- self.__showFlakesWarning(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)
- elif self.markersAtLine(line) & (1 << self.warning):
- self.__showFlakesWarning(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) | \
- (1 << self.warning)
- 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) | \
- (1 << self.warning)
- 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 = chr(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 chr(charNumber) in '()':
- self.callTip()
-
- if not self.isCallTipActive():
- char = chr(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 = e5App().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)
-
- # now check for syntax errors
- if self.hasSyntaxErrors():
- coEnable = False
-
- 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 = e5App().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 len(self.warnings):
- self.marginMenuActs["NextWarningMarker"].setEnabled(True)
- self.marginMenuActs["PreviousWarningMarker"].setEnabled(True)
- self.marginMenuActs["ClearWarnings"].setEnabled(True)
- if self.markersAtLine(self.line) & (1 << self.warning):
- self.marginMenuActs["ShowWarning"].setEnabled(True)
- else:
- self.marginMenuActs["ShowWarning"].setEnabled(False)
- else:
- self.marginMenuActs["NextWarningMarker"].setEnabled(False)
- self.marginMenuActs["PreviousWarningMarker"].setEnabled(True)
- self.marginMenuActs["ClearWarnings"].setEnabled(False)
- self.marginMenuActs["ShowWarning"].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()
- self.clearFlakesWarnings()
- if self.isPy3File():
- syntaxError, _fn, errorline, _code, _error = \
- Utilities.compile(self.fileName, self.text())
- if syntaxError:
- self.toggleSyntaxError(int(errorline), True, _error)
- else:
- if Preferences.getFlakes("IncludeInSyntaxCheck"):
- ignoreStarImportWarnings = \
- Preferences.getFlakes("IgnoreStarImportWarnings")
- warnings = Checker(self.text(), self.fileName)
- warnings.messages.sort(key = lambda a: a.lineno)
- for warning in warnings.messages:
- if ignoreStarImportWarnings and \
- isinstance(warning, ImportStarUsed):
- continue
-
- _fn, lineno, message = warning.getMessageData()
- self.toggleFlakesWarning(lineno, True, message)
-
- 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 = e5App().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 = e5App().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 list(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 list(self.syntaxerrors.keys()):
- selist.append(self.markerLine(handle) + 1)
-
- selist.sort()
- return selist
-
- def hasSyntaxErrors(self):
- """
- Public method to check for the presence of syntax errors.
-
- @return flag indicating the presence of syntax errors (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 list(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 list(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."))
-
- ############################################################################
- ## Flakes warning handling methods below
- ############################################################################
-
- def toggleFlakesWarning(self, line, warning, msg = ""):
- """
- Public method to toggle a flakes warning indicator.
-
- @param line line number of the flakes warning
- @param erwarningror flag indicating if the warning marker should be
- set or deleted (boolean)
- @param msg warning message (string)
- """
- if line == 0:
- line = 1
- # hack to show a warning marker, if line is reported to be 0
- if warning:
- # set a new warning marker
- markers = self.markersAtLine(line - 1)
- if not (markers & (1 << self.warning)):
- handle = self.markerAdd(line - 1, self.warning)
- self.warnings[handle] = msg
- self.emit(SIGNAL('syntaxerrorToggled'), self)
- else:
- for handle in list(self.warnings.keys()):
- if self.markerLine(handle) == line - 1:
- del self.warnings[handle]
- self.markerDeleteHandle(handle)
- self.emit(SIGNAL('syntaxerrorToggled'), self)
-
- def getFlakesWarnings(self):
- """
- Public method to retrieve the flakes warning markers.
-
- @return sorted list of all lines containing a flakes warning
- (list of integer)
- """
- fwlist = []
- for handle in list(self.warnings.keys()):
- fwlist.append(self.markerLine(handle) + 1)
-
- fwlist.sort()
- return fwlist
-
- def hasFlakesWarnings(self):
- """
- Public method to check for the presence of flakes warnings.
-
- @return flag indicating the presence of flakes warnings (boolean)
- """
- return len(self.warnings) > 0
-
- def nextFlakesWarning(self):
- """
- Public slot to handle the 'Next warning' context menu action.
- """
- line, index = self.getCursorPosition()
- if line == self.lines() - 1:
- line = 0
- else:
- line += 1
- fwline = self.markerFindNext(line, 1 << self.warning)
- if fwline < 0:
- # wrap around
- fwline = self.markerFindNext(0, 1 << self.warning)
- if fwline >= 0:
- self.setCursorPosition(fwline, 0)
- self.ensureLineVisible(fwline)
-
- def previousFlakesWarning(self):
- """
- Public slot to handle the 'Previous warning' context menu action.
- """
- line, index = self.getCursorPosition()
- if line == 0:
- line = self.lines() - 1
- else:
- line -= 1
- fwline = self.markerFindPrevious(line, 1 << self.warning)
- if fwline < 0:
- # wrap around
- fwline = self.markerFindPrevious(self.lines() - 1, 1 << self.warning)
- if fwline >= 0:
- self.setCursorPosition(fwline, 0)
- self.ensureLineVisible(fwline)
-
- def clearFlakesWarnings(self):
- """
- Public slot to handle the 'Clear all warnings' context menu action.
- """
- for handle in self.warnings:
- self.markerDeleteHandle(handle)
- self.warnings = {}
- self.emit(SIGNAL('syntaxerrorToggled'), self)
-
- def __showFlakesWarning(self, line = -1):
- """
- Private slot to handle the 'Show warning' context menu action.
-
- @param line line number to show the flakes warning for (integer)
- """
- if line == -1:
- line = self.line
-
- for handle in list(self.warnings.keys()):
- if self.markerLine(handle) == line:
- QMessageBox.warning(None,
- self.trUtf8("py3flakes Warning"),
- self.warnings[handle])
- break
- else:
- QMessageBox.warning(None,
- self.trUtf8("py3flakes Warning"),
- self.trUtf8("No py3flakes warning 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 list(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, "r", encoding = "utf-8")
- 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, "w", encoding = "utf-8")
- 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[:]:
- self.removeClone(clone)
- 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(e5App().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.recolor()
- 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"""
- """ eric5. 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 flakes warning markers
- self.clearFlakesWarnings()
-
- # clear breakpoint markers
- for handle in list(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(e5App().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 e5App().getObject("TemplateViewer").hasTemplate(tmplName):
- self.__applyTemplate(tmplName)
- return
- else:
- templateNames = \
- e5App().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 e5App().getObject("TemplateViewer").hasTemplate(templateName):
- self.extendSelectionWordLeft()
- e5App().getObject("TemplateViewer").applyNamedTemplate(templateName)
-
- #######################################################################
- ## Project related methods
- #######################################################################
-
- def __projectPropertiesChanged(self):
- """
- Private slot to handle changes of the project properties.
- """
- project = e5App().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 = e5App().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(e5App().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 = e5App().getObject("Project")
- if self.fileName and \
- 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 chr(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()
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2002 - 2010 Detlev Offenbach <detlev@die-offenbachs.de>
+#
+
+"""
+Module implementing the editor component of the eric5 IDE.
+"""
+
+import os
+import re
+import types
+
+from PyQt4.Qsci import QsciScintilla, QsciMacro
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+
+from E5Gui.E5Application import e5App
+
+from . import Exporters
+from . import Lexers
+from . import TypingCompleters
+from .QsciScintillaCompat import QsciScintillaCompat, QSCINTILLA_VERSION
+from .SpellChecker import SpellChecker
+from .SpellCheckingDialog import SpellCheckingDialog
+
+from Debugger.EditBreakpointDialog import EditBreakpointDialog
+
+from DebugClients.Python3.coverage import coverage
+
+from DataViews.CodeMetricsDialog import CodeMetricsDialog
+from DataViews.PyCoverageDialog import PyCoverageDialog
+from DataViews.PyProfileDialog import PyProfileDialog
+
+from .Printer import Printer
+
+import Preferences
+import Utilities
+from Utilities.py3flakes.checker import Checker
+from Utilities.py3flakes.messages import ImportStarUsed
+
+import UI.PixmapCache
+
+EditorAutoCompletionListID = 1
+TemplateCompletionListID = 2
+
+class Editor(QsciScintillaCompat):
+ """
+ Class implementing the editor component of the eric5 IDE.
+
+ @signal modificationStatusChanged(boolean, editor) emitted when the
+ modification status has changed
+ @signal undoAvailable(boolean) emitted to signal the undo availability
+ @signal redoAvailable(boolean) emitted to signal the redo availability
+ @signal cursorChanged(string, int, int) emitted when the cursor position
+ was changed
+ @signal editorAboutToBeSaved(string) emitted before the editor is saved
+ @signal editorSaved(string) emitted after the editor has been saved
+ @signal editorRenamed(string) emitted after the editor got a new name
+ (i.e. after a 'Save As')
+ @signal captionChanged(string, editor) emitted when the caption is
+ updated. Typically due to a readOnly attribute change.
+ @signal breakpointToggled(editor) emitted when a breakpoint is toggled
+ @signal bookmarkToggled(editor) emitted when a bookmark is toggled
+ @signal syntaxerrorToggled(editor) emitted when a syntax error was discovered
+ @signal autoCompletionAPIsAvailable(avail) emitted after the autocompletion
+ function has been configured
+ @signal coverageMarkersShown(boolean) emitted after the coverage markers have been
+ shown or cleared
+ @signal taskMarkersUpdated(editor) emitted when the task markers were updated
+ @signal showMenu(string, QMenu, editor) emitted when a menu is about to be shown.
+ The name of the menu, a reference to the menu and a reference to the
+ editor are given.
+ @signal languageChanged(language) emitted when the editors language was set. The
+ language is passed as a parameter.
+ @signal eolChanged(eol) emitted when the editors eol type was set. The eol string
+ is passed as a parameter.
+ @signal encodingChanged(encoding) emitted when the editors encoding was set. The
+ encoding name is passed as a parameter.
+ """
+ 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.warnings = {} # key: marker handle
+ # value: warning 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"))
+ self.warning = \
+ self.markerDefine(UI.PixmapCache.getPixmap("warning.png"))
+
+ # define the line markers
+ self.currentline = self.markerDefine(QsciScintilla.Background)
+ self.errorline = self.markerDefine(QsciScintilla.Background)
+ self.__setLineMarkerColours()
+
+ self.breakpointMask = (1 << self.breakpoint) | \
+ (1 << self.cbreakpoint) | \
+ (1 << self.tbreakpoint) | \
+ (1 << self.tcbreakpoint) | \
+ (1 << self.dbreakpoint)
+
+ # configure the margins
+ self.__setMarginsDisplay()
+
+ self.connect(self, SIGNAL('marginClicked(int, int, Qt::KeyboardModifiers)'),
+ self.__marginClicked)
+
+ # set the eol mode
+ self.__setEolMode()
+
+ self.isResourcesFile = False
+ if editor is None:
+ if self.fileName is not None:
+ if (QFileInfo(self.fileName).size() // 1024) > \
+ Preferences.getEditor("WarnFilesize"):
+ res = QMessageBox.warning(None,
+ self.trUtf8("Open File"),
+ self.trUtf8("""<p>The size of the file <b>{0}</b>"""
+ """ is <b>{1} KB</b>."""
+ """ Do you really want to load it?</p>""")\
+ .format(self.fileName,
+ QFileInfo(self.fileName).size() // 1024),
+ QMessageBox.StandardButtons(\
+ QMessageBox.No | \
+ QMessageBox.Yes),
+ QMessageBox.No)
+ if res == QMessageBox.No or res == QMessageBox.Cancel:
+ raise IOError()
+ self.readFile(self.fileName, True)
+ bindName = self.__bindName(self.text(0))
+ self.__bindLexer(bindName)
+ self.__bindCompleter(bindName)
+ self.__autoSyntaxCheck()
+ self.isResourcesFile = self.fileName.endswith(".qrc")
+
+ self.recolor()
+ else:
+ # clone the given editor
+ self.setDocument(editor.document())
+ self.breaks = editor.breaks
+ self.bookmarks = editor.bookmarks
+ self.syntaxerrors = editor.syntaxerrors
+ self.notcoveredMarkers = editor.notcoveredMarkers
+ self.isResourcesFile = editor.isResourcesFile
+ self.lastModified = editor.lastModified
+
+ self.addClone(editor)
+ editor.addClone(self)
+
+ self.gotoLine(0)
+
+ # set the text display
+ self.__setTextDisplay()
+
+ # set the autocompletion and calltips function
+ self.__acHookFunction = None
+ self.__setAutoCompletion()
+ self.__ctHookFunction = None
+ self.__setCallTips()
+
+ sh = self.sizeHint()
+ if sh.height() < 300:
+ sh.setHeight(300)
+ self.resize(sh)
+
+ # Make sure tabbing through a QWorkspace works.
+ self.setFocusPolicy(Qt.StrongFocus)
+
+ self.__updateReadOnly(True)
+
+ self.setWhatsThis(self.trUtf8(
+ """<b>A Source Editor Window</b>"""
+ """<p>This window is used to display and edit a source file."""
+ """ You can open as many of these as you like. The name of the file"""
+ """ is displayed in the window's titlebar.</p>"""
+ """<p>In order to set breakpoints just click in the space between"""
+ """ the line numbers and the fold markers. Via the context menu"""
+ """ of the margins they may be edited.</p>"""
+ """<p>In order to set bookmarks just Shift click in the space between"""
+ """ the line numbers and the fold markers.</p>"""
+ """<p>These actions can be reversed via the context menu.</p>"""
+ """<p>Ctrl clicking on a syntax error marker shows some info"""
+ """ about this error.</p>"""
+ ))
+
+ # Set the editors size, if it is too big for the view manager.
+ if self.vm is not None:
+ req = self.size()
+ bnd = req.boundedTo(self.vm.size())
+
+ if bnd.width() < req.width() or bnd.height() < req.height():
+ self.resize(bnd)
+
+ # set the autosave flag
+ self.autosaveEnabled = Preferences.getEditor("AutosaveInterval") > 0
+ self.autosaveManuallyDisabled = False
+
+ self.__initContextMenu()
+ self.__initContextMenuMargins()
+
+ self.__checkEol()
+ if editor is None:
+ self.__checkLanguage()
+ self.__checkEncoding()
+ else:
+ # it's a clone
+ self.languageChanged(editor.apiLanguage, propagate = False)
+ self.__encodingChanged(editor.encoding, propagate = False)
+
+ self.coverageMarkersShown = False # flag remembering the current status of the
+ # code coverage markers
+
+ self.setAcceptDrops(True)
+
+ # breakpoint handling
+ self.breakpointModel = self.dbs.getBreakPointModel()
+ self.__restoreBreakpoints()
+ self.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("None")
+ self.languagesActGrp.addAction(self.noLanguageAct)
+ menu.addSeparator()
+
+ self.supportedLanguages = {}
+ supportedLanguages = Lexers.getSupportedLanguages()
+ languages = sorted(list(supportedLanguages.keys()))
+ for language in languages:
+ if language != "Guessed":
+ self.supportedLanguages[language] = supportedLanguages[language][:]
+ act = menu.addAction(self.supportedLanguages[language][0])
+ act.setCheckable(True)
+ act.setData(language)
+ self.supportedLanguages[language].append(act)
+ self.languagesActGrp.addAction(act)
+
+ menu.addSeparator()
+ self.pygmentsAct = menu.addAction(self.trUtf8("Guessed"))
+ self.pygmentsAct.setCheckable(True)
+ self.pygmentsAct.setData("Guessed")
+ self.languagesActGrp.addAction(self.pygmentsAct)
+ self.pygmentsSelAct = menu.addAction(self.trUtf8("Alternatives"))
+ self.pygmentsSelAct.setData("Alternatives")
+
+ self.connect(menu, SIGNAL('triggered(QAction *)'), self.__languageMenuTriggered)
+ 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(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('\n')
+ self.supportedEols['\n'] = act
+ self.eolActGrp.addAction(act)
+
+ act = menu.addAction(self.trUtf8("Windows"))
+ act.setCheckable(True)
+ act.setData('\r\n')
+ self.supportedEols['\r\n'] = act
+ self.eolActGrp.addAction(act)
+
+ act = menu.addAction(self.trUtf8("Macintosh"))
+ act.setCheckable(True)
+ act.setData('\r')
+ self.supportedEols['\r'] = act
+ self.eolActGrp.addAction(act)
+
+ self.connect(menu, SIGNAL('triggered(QAction *)'), self.__eolMenuTriggered)
+ 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 = sorted(list(supportedExporters.keys()))
+ for exporter in exporters:
+ act = menu.addAction(supportedExporters[exporter])
+ act.setData(exporter)
+
+ self.connect(menu, SIGNAL('triggered(QAction *)'), self.__exportMenuTriggered)
+
+ return menu
+
+ def __initContextMenuMargins(self):
+ """
+ Private method used to setup the context menu for the margins
+ """
+ self.marginMenuActs = {}
+
+ if self.__unifiedMargins:
+ self.__initContextMenuUnifiedMargins()
+ else:
+ self.__initContextMenuSeparateMargins()
+
+ def __initContextMenuSeparateMargins(self):
+ """
+ Private method used to setup the context menu for the separated margins
+ """
+ # bookmark margin
+ self.bmMarginMenu = QMenu()
+
+ self.bmMarginMenu.addAction(self.trUtf8('Toggle bookmark'),
+ self.menuToggleBookmark)
+ self.marginMenuActs["NextBookmark"] = \
+ self.bmMarginMenu.addAction(self.trUtf8('Next bookmark'),
+ self.nextBookmark)
+ self.marginMenuActs["PreviousBookmark"] = \
+ self.bmMarginMenu.addAction(self.trUtf8('Previous bookmark'),
+ self.previousBookmark)
+ self.marginMenuActs["ClearBookmark"] = \
+ self.bmMarginMenu.addAction(self.trUtf8('Clear all bookmarks'),
+ self.clearBookmarks)
+
+ self.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["NextWarningMarker"] = \
+ self.indicMarginMenu.addAction(self.trUtf8("Next warning"),
+ self.nextFlakesWarning)
+ self.marginMenuActs["PreviousWarningMarker"] = \
+ self.indicMarginMenu.addAction(self.trUtf8("Previous warning"),
+ self.previousFlakesWarning)
+ self.marginMenuActs["ShowWarning"] = \
+ self.indicMarginMenu.addAction(self.trUtf8('Show warning message'),
+ self.__showFlakesWarning)
+ self.marginMenuActs["ClearWarnings"] = \
+ self.indicMarginMenu.addAction(self.trUtf8('Clear warnings'),
+ self.clearFlakesWarnings)
+ self.indicMarginMenu.addSeparator()
+ self.marginMenuActs["NextCoverageMarker"] = \
+ self.indicMarginMenu.addAction(self.trUtf8('Next uncovered line'),
+ self.nextUncovered)
+ self.marginMenuActs["PreviousCoverageMarker"] = \
+ self.indicMarginMenu.addAction(self.trUtf8('Previous uncovered line'),
+ self.previousUncovered)
+ self.indicMarginMenu.addSeparator()
+ self.marginMenuActs["NextTaskMarker"] = \
+ self.indicMarginMenu.addAction(self.trUtf8('Next task'),
+ self.nextTask)
+ self.marginMenuActs["PreviousTaskMarker"] = \
+ self.indicMarginMenu.addAction(self.trUtf8('Previous task'),
+ self.previousTask)
+
+ self.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["NextWarningMarker"] = \
+ self.marginMenu.addAction(self.trUtf8("Next warning"),
+ self.nextFlakesWarning)
+ self.marginMenuActs["PreviousWarningMarker"] = \
+ self.marginMenu.addAction(self.trUtf8("Previous warning"),
+ self.previousFlakesWarning)
+ self.marginMenuActs["ShowWarning"] = \
+ self.marginMenu.addAction(self.trUtf8('Show warning message'),
+ self.__showFlakesWarning)
+ self.marginMenuActs["ClearWarnings"] = \
+ self.marginMenu.addAction(self.trUtf8('Clear warnings'),
+ self.clearFlakesWarnings)
+ self.marginMenu.addSeparator()
+ self.marginMenuActs["Breakpoint"] = \
+ self.marginMenu.addAction(self.trUtf8('Toggle breakpoint'),
+ self.menuToggleBreakpoint)
+ self.marginMenuActs["TempBreakpoint"] = \
+ self.marginMenu.addAction(self.trUtf8('Toggle temporary breakpoint'),
+ self.__menuToggleTemporaryBreakpoint)
+ self.marginMenuActs["EditBreakpoint"] = \
+ self.marginMenu.addAction(self.trUtf8('Edit breakpoint...'),
+ self.menuEditBreakpoint)
+ self.marginMenuActs["EnableBreakpoint"] = \
+ self.marginMenu.addAction(self.trUtf8('Enable breakpoint'),
+ self.__menuToggleBreakpointEnabled)
+ self.marginMenuActs["NextBreakpoint"] = \
+ self.marginMenu.addAction(self.trUtf8('Next breakpoint'),
+ self.menuNextBreakpoint)
+ self.marginMenuActs["PreviousBreakpoint"] = \
+ self.marginMenu.addAction(self.trUtf8('Previous breakpoint'),
+ self.menuPreviousBreakpoint)
+ self.marginMenuActs["ClearBreakpoint"] = \
+ self.marginMenu.addAction(self.trUtf8('Clear all breakpoints'),
+ self.__menuClearBreakpoints)
+ self.marginMenu.addSeparator()
+ self.marginMenuActs["NextCoverageMarker"] = \
+ self.marginMenu.addAction(self.trUtf8('Next uncovered line'),
+ self.nextUncovered)
+ self.marginMenuActs["PreviousCoverageMarker"] = \
+ self.marginMenu.addAction(self.trUtf8('Previous uncovered line'),
+ self.previousUncovered)
+ self.marginMenu.addSeparator()
+ self.marginMenuActs["NextTaskMarker"] = \
+ self.marginMenu.addAction(self.trUtf8('Next task'),
+ self.nextTask)
+ self.marginMenuActs["PreviousTaskMarker"] = \
+ self.marginMenu.addAction(self.trUtf8('Previous task'),
+ self.previousTask)
+ self.marginMenu.addSeparator()
+ self.marginMenuActs["LMBbookmarks"] = \
+ self.marginMenu.addAction(self.trUtf8('LMB toggles bookmarks'),
+ self.__lmBbookmarks)
+ self.marginMenuActs["LMBbookmarks"].setCheckable(True)
+ self.marginMenuActs["LMBbookmarks"].setChecked(False)
+ self.marginMenuActs["LMBbreakpoints"] = \
+ self.marginMenu.addAction(self.trUtf8('LMB toggles breakpoints'),
+ self.__lmBbreakpoints)
+ self.marginMenuActs["LMBbreakpoints"].setCheckable(True)
+ self.marginMenuActs["LMBbreakpoints"].setChecked(True)
+
+ self.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()
+ 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()
+ 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()
+ 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()
+ 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 = e5App().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()
+ fdesc = Preferences.Prefs.settings.value(key)
+ if fdesc is not None:
+ 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 list(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 list(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 list(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 list(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 list(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 list(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 list(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 = e5App().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 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)
+ """
+ QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
+
+ try:
+ if createIt and not os.path.exists(fn):
+ f = open(fn, "w")
+ f.close()
+ txt, self.encoding = Utilities.readEncodedFile(fn)
+ except (UnicodeDecodeError, IOError) as why:
+ QApplication.restoreOverrideCursor()
+ QMessageBox.critical(self.vm, self.trUtf8('Open File'),
+ self.trUtf8('<p>The file <b>{0}</b> could not be opened.</p>'
+ '<p>Reason: {1}</p>')
+ .format(fn, str(why)))
+ QApplication.restoreOverrideCursor()
+ raise
+ 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 (boolean)
+ """
+ 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
+
+ # 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:
+ self.encoding = Utilities.writeEncodedFile(fn, txt, self.encoding)
+ if createBackup and perms_valid:
+ os.chmod(fn, permissions)
+ return True
+ except (IOError, Utilities.CodingError, UnicodeError) as 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, str(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)
+ elif self.markersAtLine(line) & (1 << self.warning):
+ self.__showFlakesWarning(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)
+ elif self.markersAtLine(line) & (1 << self.warning):
+ self.__showFlakesWarning(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) | \
+ (1 << self.warning)
+ 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) | \
+ (1 << self.warning)
+ 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 = chr(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 chr(charNumber) in '()':
+ self.callTip()
+
+ if not self.isCallTipActive():
+ char = chr(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 = e5App().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)
+
+ # now check for syntax errors
+ if self.hasSyntaxErrors():
+ coEnable = False
+
+ 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 = e5App().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 len(self.warnings):
+ self.marginMenuActs["NextWarningMarker"].setEnabled(True)
+ self.marginMenuActs["PreviousWarningMarker"].setEnabled(True)
+ self.marginMenuActs["ClearWarnings"].setEnabled(True)
+ if self.markersAtLine(self.line) & (1 << self.warning):
+ self.marginMenuActs["ShowWarning"].setEnabled(True)
+ else:
+ self.marginMenuActs["ShowWarning"].setEnabled(False)
+ else:
+ self.marginMenuActs["NextWarningMarker"].setEnabled(False)
+ self.marginMenuActs["PreviousWarningMarker"].setEnabled(True)
+ self.marginMenuActs["ClearWarnings"].setEnabled(False)
+ self.marginMenuActs["ShowWarning"].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()
+ self.clearFlakesWarnings()
+ if self.isPy3File():
+ syntaxError, _fn, errorline, _code, _error = \
+ Utilities.compile(self.fileName, self.text())
+ if syntaxError:
+ self.toggleSyntaxError(int(errorline), True, _error)
+ else:
+ if Preferences.getFlakes("IncludeInSyntaxCheck"):
+ ignoreStarImportWarnings = \
+ Preferences.getFlakes("IgnoreStarImportWarnings")
+ warnings = Checker(self.text(), self.fileName)
+ warnings.messages.sort(key = lambda a: a.lineno)
+ for warning in warnings.messages:
+ if ignoreStarImportWarnings and \
+ isinstance(warning, ImportStarUsed):
+ continue
+
+ _fn, lineno, message = warning.getMessageData()
+ self.toggleFlakesWarning(lineno, True, message)
+
+ 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 = e5App().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 = e5App().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 list(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 list(self.syntaxerrors.keys()):
+ selist.append(self.markerLine(handle) + 1)
+
+ selist.sort()
+ return selist
+
+ def hasSyntaxErrors(self):
+ """
+ Public method to check for the presence of syntax errors.
+
+ @return flag indicating the presence of syntax errors (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 list(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 list(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."))
+
+ ############################################################################
+ ## Flakes warning handling methods below
+ ############################################################################
+
+ def toggleFlakesWarning(self, line, warning, msg = ""):
+ """
+ Public method to toggle a flakes warning indicator.
+
+ @param line line number of the flakes warning
+ @param erwarningror flag indicating if the warning marker should be
+ set or deleted (boolean)
+ @param msg warning message (string)
+ """
+ if line == 0:
+ line = 1
+ # hack to show a warning marker, if line is reported to be 0
+ if warning:
+ # set/ammend a new warning marker
+ markers = self.markersAtLine(line - 1)
+ if not (markers & (1 << self.warning)):
+ handle = self.markerAdd(line - 1, self.warning)
+ self.warnings[handle] = msg
+ self.emit(SIGNAL('syntaxerrorToggled'), self)
+ else:
+ for handle in list(self.warnings.keys()):
+ if self.markerLine(handle) == line - 1:
+ self.warnings[handle] += "\n" + msg
+ else:
+ for handle in list(self.warnings.keys()):
+ if self.markerLine(handle) == line - 1:
+ del self.warnings[handle]
+ self.markerDeleteHandle(handle)
+ self.emit(SIGNAL('syntaxerrorToggled'), self)
+
+ def getFlakesWarnings(self):
+ """
+ Public method to retrieve the flakes warning markers.
+
+ @return sorted list of all lines containing a flakes warning
+ (list of integer)
+ """
+ fwlist = []
+ for handle in list(self.warnings.keys()):
+ fwlist.append(self.markerLine(handle) + 1)
+
+ fwlist.sort()
+ return fwlist
+
+ def hasFlakesWarnings(self):
+ """
+ Public method to check for the presence of flakes warnings.
+
+ @return flag indicating the presence of flakes warnings (boolean)
+ """
+ return len(self.warnings) > 0
+
+ def nextFlakesWarning(self):
+ """
+ Public slot to handle the 'Next warning' context menu action.
+ """
+ line, index = self.getCursorPosition()
+ if line == self.lines() - 1:
+ line = 0
+ else:
+ line += 1
+ fwline = self.markerFindNext(line, 1 << self.warning)
+ if fwline < 0:
+ # wrap around
+ fwline = self.markerFindNext(0, 1 << self.warning)
+ if fwline >= 0:
+ self.setCursorPosition(fwline, 0)
+ self.ensureLineVisible(fwline)
+
+ def previousFlakesWarning(self):
+ """
+ Public slot to handle the 'Previous warning' context menu action.
+ """
+ line, index = self.getCursorPosition()
+ if line == 0:
+ line = self.lines() - 1
+ else:
+ line -= 1
+ fwline = self.markerFindPrevious(line, 1 << self.warning)
+ if fwline < 0:
+ # wrap around
+ fwline = self.markerFindPrevious(self.lines() - 1, 1 << self.warning)
+ if fwline >= 0:
+ self.setCursorPosition(fwline, 0)
+ self.ensureLineVisible(fwline)
+
+ def clearFlakesWarnings(self):
+ """
+ Public slot to handle the 'Clear all warnings' context menu action.
+ """
+ for handle in self.warnings:
+ self.markerDeleteHandle(handle)
+ self.warnings = {}
+ self.emit(SIGNAL('syntaxerrorToggled'), self)
+
+ def __showFlakesWarning(self, line = -1):
+ """
+ Private slot to handle the 'Show warning' context menu action.
+
+ @param line line number to show the flakes warning for (integer)
+ """
+ if line == -1:
+ line = self.line
+
+ for handle in list(self.warnings.keys()):
+ if self.markerLine(handle) == line:
+ QMessageBox.warning(None,
+ self.trUtf8("py3flakes Warning"),
+ self.warnings[handle])
+ break
+ else:
+ QMessageBox.warning(None,
+ self.trUtf8("py3flakes Warning"),
+ self.trUtf8("No py3flakes warning 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 list(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, "r", encoding = "utf-8")
+ 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, "w", encoding = "utf-8")
+ 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[:]:
+ self.removeClone(clone)
+ 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(e5App().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.recolor()
+ 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"""
+ """ eric5. 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 flakes warning markers
+ self.clearFlakesWarnings()
+
+ # clear breakpoint markers
+ for handle in list(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(e5App().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 e5App().getObject("TemplateViewer").hasTemplate(tmplName):
+ self.__applyTemplate(tmplName)
+ return
+ else:
+ templateNames = \
+ e5App().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 e5App().getObject("TemplateViewer").hasTemplate(templateName):
+ self.extendSelectionWordLeft()
+ e5App().getObject("TemplateViewer").applyNamedTemplate(templateName)
+
+ #######################################################################
+ ## Project related methods
+ #######################################################################
+
+ def __projectPropertiesChanged(self):
+ """
+ Private slot to handle changes of the project properties.
+ """
+ project = e5App().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 = e5App().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(e5App().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 = e5App().getObject("Project")
+ if self.fileName and \
+ 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 chr(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()
