def __init__( self, parent = None ):
QsciLexerPython.__init__( self, parent )
Lexer.__init__( self )
self.commentString = "#"
return
def __init__(self, text, parent=None):
super(ScriptEditorWidget, self).__init__(parent)
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(10)
self.setFont(font)
self.setMarginsFont(font)
fontmetrics = QFontMetrics(font)
self.setMarginsFont(font)
self.setMarginWidth(0, fontmetrics.width("00000") + 6)
self.setMarginLineNumbers(0, True)
self.setMarginsBackgroundColor(QColor("#cccccc"))
self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
self.setCaretLineVisible(True)
self.setCaretLineBackgroundColor(QColor("#ffe4e4"))
lexer = QsciLexerPython()
lexer.setDefaultFont(font)
self.setLexer(lexer)
self.SendScintilla(QsciScintilla.SCI_STYLESETFONT, 1, 'Courier')
self.setText(text)
def __init__(self, colorStyle, parent=None):
QsciLexerPython.__init__(self, parent)
# self.parent = parent
# self.sci = self.parent
self.colorStyle = colorStyle
self.plainFont = QFont()
self.plainFont.setFamily(fontName)
self.plainFont.setFixedPitch(True)
self.plainFont.setPointSize(fontSize)
self.marginFont = QFont()
self.marginFont.setPointSize(10)
self.marginFont.setFamily("MS Dlg")
self.boldFont = QFont(self.plainFont)
self.boldFont.setBold(True)
"""
enum {
Default = 0, Comment = 1, Number = 2,
DoubleQuotedString = 3, SingleQuotedString = 4, Keyword = 5,
TripleSingleQuotedString = 6, TripleDoubleQuotedString = 7, ClassName = 8,
FunctionMethodName = 9, Operator = 10, Identifier = 11,
CommentBlock = 12, UnclosedString = 13, HighlightedIdentifier = 14,
Decorator = 15
}
enum IndentationWarning {
NoWarning = 0, Inconsistent = 1, TabsAfterSpaces = 2,
Spaces = 3, Tabs = 4
}
"""
self.styles = [
# index description color paper font eol
QsciStyle(0, QString("base"), self.colorStyle.color, self.colorStyle.paper, self.plainFont, True),
QsciStyle(1, QString("comment"), QColor("#008000"), self.colorStyle.paper, self.plainFont, True),
QsciStyle(2, QString("number"), QColor("#008000"), self.colorStyle.paper, self.boldFont, False),
QsciStyle(3, QString("DoubleQuotedString"), QColor("#008000"), self.colorStyle.paper, self.plainFont, True),
QsciStyle(4, QString("SingleQuotedString"), QColor("#008000"), self.colorStyle.paper, self.plainFont, True),
QsciStyle(5, QString("Keyword"), QColor("#000000"), self.colorStyle.paper, self.boldFont, True),
QsciStyle(
6, QString("TripleSingleQuotedString"), QColor("#ffd0d0"), self.colorStyle.paper, self.plainFont, True
),
QsciStyle(
7, QString("TripleDoubleQuotedString"), QColor("#001111"), self.colorStyle.paper, self.plainFont, False
),
QsciStyle(8, QString("ClassName"), QColor("#000000"), self.colorStyle.paper, self.plainFont, False),
QsciStyle(
9, QString("FunctionMethodName"), QColor("#000000"), self.colorStyle.paper, self.plainFont, False
),
QsciStyle(10, QString("Operator"), QColor("#ff00ff"), self.colorStyle.paper, self.plainFont, False),
QsciStyle(11, QString("Identifier"), QColor("#000000"), self.colorStyle.paper, self.plainFont, False),
QsciStyle(12, QString("CommentBlock"), QColor("#000000"), self.colorStyle.paper, self.plainFont, False),
QsciStyle(13, QString("UnclosedString"), QColor("#010101"), self.colorStyle.paper, self.plainFont, False),
QsciStyle(
14, QString("HighlightedIdentifier"), QColor("#0000ff"), self.colorStyle.paper, self.plainFont, False
),
QsciStyle(15, QString("Decorator"), QColor("#ff00ff"), self.colorStyle.paper, self.plainFont, False)
# QsciStyle(7, QString("MultiComment_start"), QColor("#ff00ff"), QColor("#001111"), self.plainFont, False),
# QsciStyle(8, QString("MultiComment"), QColor("#ff00ff"), QColor("#001111"), self.plainFont, False),
# QsciStyle(9, QString("MultiComment_stop"), QColor("#ff00ff"), QColor("#001111"), self.plainFont, False)
]
self._foldcompact = True
def __init__(self, parent=None):
super(SimplePythonEditor, self).__init__(parent)
# Set the default font
font = QFont()
font.setFamily('Inconsolata')
font.setFixedPitch(True)
font.setPointSize(16)
self.setFont(font)
self.setMarginsFont(font)
# Margin 0 is used for line numbers
fontmetrics = QFontMetrics(font)
self.setMarginsFont(font)
self.setMarginWidth(0, fontmetrics.width("00000") + 6)
self.setMarginLineNumbers(0, True)
self.setMarginsBackgroundColor(QColor("#cccccc"))
# Clickable margin 1 for showing markers
self.setMarginSensitivity(1, True)
self.connect(self,
SIGNAL('marginClicked(int, int, Qt::KeyboardModifiers)'),
self.on_margin_clicked)
self.markerDefine(QsciScintilla.RightArrow,
self.ARROW_MARKER_NUM)
self.setMarkerBackgroundColor(QColor("#ee1111"),
self.ARROW_MARKER_NUM)
# Brace matching: enable for a brace immediately before or after
# the current position
#
self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
# Current line visible with special background color
self.setCaretLineVisible(True)
self.setCaretLineBackgroundColor(QColor("#ffe4e4"))
# Set Python lexer
# Set style for Python comments (style number 1) to a fixed-width
# courier.
#
lexer = QsciLexerPython()
lexer.setDefaultFont(font)
self.setLexer(lexer)
# Set all the styles to the same font, size
for idx in xrange(0, QsciScintilla.STYLE_LASTPREDEFINED):
self.SendScintilla(QsciScintilla.SCI_STYLESETFONT, idx, 'Inconsolata')
self.SendScintilla(QsciScintilla.SCI_STYLESETSIZE, idx, 16)
# Don't want to see the horizontal scrollbar at all
# Use raw message to Scintilla here (all messages are documented
# here: http://www.scintilla.org/ScintillaDoc.html)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
# not too small
self.setMinimumSize(600, 450)
def __init__(self, parent=None):
"""
Constructor
@param parent parent widget of this lexer
"""
QsciLexerPython.__init__(self, parent)
Lexer.__init__(self)
self.commentString = QString("#")
def __init__(self, parent):
QsciLexerPython.__init__(self, parent)
self.parent = parent
self.plainFont = QFont()
self.plainFont.setFamily(config.fontName())
self.plainFont.setFixedPitch(True)
self.plainFont.setPointSize(config.fontSize())
self.boldFont = QFont(self.plainFont)
self.boldFont.setBold(True)
self.setFoldCompact(True)
def __init__(self, parent=None):
QsciScintilla.__init__(self, parent)
## set the default font of the editor
## and take the same font for line numbers
font = CurrentTheme.PYTHON_SOURCE_EDITOR_FONT
self.setFont(font)
fm = QtGui.QFontMetrics(font)
## Line numbers
# conventionally, margin 0 is for line numbers
self.setMarginWidth(0, fm.width( "0000" ) + 4)
self.setMarginLineNumbers(0, True)
self.setAutoIndent(True)
## Edge Mode shows a red vetical bar at 80 chars
self.setEdgeMode(QsciScintilla.EdgeLine)
self.setEdgeColumn(80)
self.setEdgeColor(QtGui.QColor("#CCCCCC"))
## Folding visual : we will use boxes
self.setFolding(QsciScintilla.BoxedTreeFoldStyle)
## Braces matching
self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
## Editing line color
# self.setCaretLineVisible(True)
# self.setCaretLineBackgroundColor(QtGui.QColor("#CDA869"))
## Margins colors
# line numbers margin
self.setMarginsBackgroundColor(QtGui.QColor("#FFFFFF"))
self.setMarginsForegroundColor(QtGui.QColor("#000000"))
# folding margin colors (foreground,background)
self.setFoldMarginColors(QtGui.QColor("#DDDDDD"),QtGui.QColor("#DDDDDD"))
# do not use tabs
self.setIndentationsUseTabs(False)
self.setTabWidth(4)
self.setTabIndents(True)
## Choose a lexer
lexer = QsciLexerPython()
lexer.setDefaultFont(font)
lexer.setFont(font)
self.setLexer(lexer)
# set autocompletion
self.setAutoCompletionThreshold(2)
self.setAutoCompletionSource(QsciScintilla.AcsDocument)
self.setAutoCompletionCaseSensitivity(True)
self.setAutoCompletionReplaceWord(True)
self.setAutoCompletionFillupsEnabled(True)
def __init__(self, font): """ Constructor Arguments: font -- a QFont """ QsciLexerPython.__init__(self) self.setDefaultFont(font) self.setIndentationWarning(self.Inconsistent)
def __init__(self, mainwindow):
QsciScintilla.__init__(self, mainwindow)
self.mainwindow = mainwindow
## define the font to use
font = QFont()
font.setFamily("Consolas")
font.setFixedPitch(True)
font.setPointSize(10)
# the font metrics here will help
# building the margin width later
fm = QFontMetrics(font)
## set the default font of the editor
## and take the same font for line numbers
self.setFont(font)
self.setMarginsFont(font)
## Line numbers
# conventionnaly, margin 0 is for line numbers
self.setMarginWidth(0, fm.width( "00000" ) + 5)
self.setMarginLineNumbers(0, True)
## Edge Mode shows a red vetical bar at 80 chars
self.setEdgeMode(QsciScintilla.EdgeLine)
self.setEdgeColumn(80)
self.setEdgeColor(QColor("#CCCCCC"))
## Folding visual : we will use boxes
self.setFolding(QsciScintilla.BoxedTreeFoldStyle)
## Braces matching
self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
## Editing line color
#self.setCaretLineVisible(True)
#self.setCaretLineBackgroundColor(QColor("#CDA869"))
## Margins colors
# line numbers margin
self.setMarginsBackgroundColor(QColor("#333333"))
self.setMarginsForegroundColor(QColor("#CCCCCC"))
# folding margin colors (foreground,background)
#self.setFoldMarginColors(QColor("#99CC66"),QColor("#333300"))
self.setFoldMarginColors(QColor("#CCCCCC"),QColor("#CCCCCC"))
## Choose a lexer
lexer = QsciLexerPython()
lexer.setDefaultFont(font)
self.setLexer(lexer)
def __init__(self, parent=None):
super(SimplePythonEditor, self).__init__(parent)
# Set the default font
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(10)
self.setFont(font)
self.setMarginsFont(font)
# Margin 0 is used for line numbers
fontmetrics = QFontMetrics(font)
self.setMarginsFont(font)
self.setMarginWidth(0, 40)
self.setMarginLineNumbers(0, True)
self.setMarginsBackgroundColor(QColor("#cccccc"))
# Clickable margin 1 for showing markers
self.setMarginSensitivity(1, True)
self.connect(self,
SIGNAL('marginClicked(int, int, Qt::KeyboardModifiers)'),
self.on_margin_clicked)
self.markerDefine(QsciScintilla.RightArrow,
self.ARROW_MARKER_NUM)
self.setMarkerBackgroundColor(QColor("#ee1111"),
self.ARROW_MARKER_NUM)
# Brace matching: enable for a brace immediately before or after
# the current position
#
self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
#replacing tabs for 4 spaces
self.setIndentationWidth(4)
# Current line visible with special background color
self.setCaretLineVisible(True)
self.setCaretLineBackgroundColor(QColor("#ffe4e4"))
# Set Python lexer
# Set style for Python comments (style number 1) to a fixed-width
# courier.
#
lexer = QsciLexerPython()
lexer.setDefaultFont(font)
self.setLexer(lexer)
self.SendScintilla(QsciScintilla.SCI_STYLESETFONT, 1, 'Courier')
def _load_code_editor_settings(self):
"""
Load settings on the code editor like, font style, margins, scroll, etc.
Based on the example from http://eli.thegreenplace.net/2011/04/01/sample-using-qscintilla-with-pyqt/
"""
# Set the default font
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(14)
self._code_editor.setFont(font)
self._code_editor.setMarginsFont(font)
# Margin 0 is used for line numbers
fontmetrics = QFontMetrics(font)
self._code_editor.setMarginsFont(font)
self._code_editor.setMarginWidth(0, fontmetrics.width("00000") + 6)
self._code_editor.setMarginLineNumbers(0, True)
self._code_editor.setMarginsBackgroundColor(QColor("#cccccc"))
# Clickable margin 1 for showing markers
self._code_editor.setMarginSensitivity(1, True)
self._code_editor.marginClicked.connect(self.on_margin_clicked)
self._code_editor.markerDefine(QsciScintilla.RightArrow, self.ARROW_MARKER_NUM)
self._code_editor.setMarkerBackgroundColor(QColor("#ee1111"), self.ARROW_MARKER_NUM)
# Detect changes to text
self._code_editor.modificationChanged.connect(self.on_modification_changed)
# Brace matching: enable for a brace immediately before or after the current position
self._code_editor.setBraceMatching(QsciScintilla.SloppyBraceMatch)
# Current line visible with special background color
self._code_editor.setCaretLineVisible(True)
self._code_editor.setCaretLineBackgroundColor(QColor("#ffe4e4"))
# Set Python lexer
# Set style for Python comments (style number 1) to a fixed-width Courier.
lexer = QsciLexerPython()
lexer.setDefaultFont(font)
self._code_editor.setLexer(lexer)
# self._code_editor.SendScintilla(QsciScintilla.SCI_STYLESETFONT, 1, 'Courier')
self._code_editor.SendScintilla(QsciScintilla.SCI_STYLESETFONT, 1)
# Don't want to see the horizontal scrollbar at all
# Use raw message to Scintilla here (all messages are documented here: http://www.scintilla.org/ScintillaDoc.html)
self._code_editor.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
def __init__(self, parent=None):
super(CommandShell, self).__init__(parent)
self.setMinimumHeight(50)
self.setMaximumHeight(50)
self.settings = QSettings()
self.lex = QsciLexerPython(self)
self.apis = QsciAPIs(self.lex)
self.lex.setAPIs(self.apis)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
self.SendScintilla(QsciScintilla.SCI_SETVSCROLLBAR, 0)
self.setFolding(0)
self._start_prompt = _start_prompt
self.prompt = self._start_prompt
self.currentfunction = None
self.setAutoCompletionSource(self.AcsAPIs)
self.setAutoCompletionThreshold(1)
self.setAutoCompletionReplaceWord(True)
self.setCallTipsStyle(QsciScintilla.CallTipsNoContext)
self.parent().installEventFilter(self)
self.textChanged.connect(self.text_changed)
self._lastcompletions = None
self.autocompletemodel = QStandardItemModel()
self.autocompletefilter = QSortFilterProxyModel()
self.autocompletefilter.setSourceModel(self.autocompletemodel)
self.autocompleteview = QListView(self.parent())
self.autocompleteview.setStyleSheet(
"QListView::item:selected {border: 1px solid black; }")
self.autocompleteview.setModel(self.autocompletefilter)
self.autocompleteview.hide()
self.selectionmodel = self.autocompleteview.selectionModel()
self.autocompleteview.setEditTriggers(QAbstractItemView.NoEditTriggers)
# command.register_command(self.run_last_command,
# alias="!!",
# nohistory=True)
self.setLexers()
def setLexers(self):
self.lexer = QsciLexerPython()
loadFont = self.settings.value("pythonConsole/fontfamilytext", "Monospace").toString()
fontSize = self.settings.value("pythonConsole/fontsize", 10).toInt()[0]
font = QFont(loadFont)
font.setFixedPitch(True)
font.setPointSize(fontSize)
font.setStyleHint(QFont.TypeWriter)
font.setStretch(QFont.SemiCondensed)
font.setLetterSpacing(QFont.PercentageSpacing, 87.0)
font.setBold(False)
self.lexer.setDefaultFont(font)
self.lexer.setColor(Qt.red, 1)
self.lexer.setColor(Qt.darkGreen, 5)
self.lexer.setColor(Qt.darkBlue, 15)
self.lexer.setFont(font, 1)
self.lexer.setFont(font, 3)
self.lexer.setFont(font, 4)
self.api = QsciAPIs(self.lexer)
chekBoxAPI = self.settings.value("pythonConsole/preloadAPI", True).toBool()
if chekBoxAPI:
self.api.loadPrepared(QgsApplication.pkgDataPath() + "/python/qsci_apis/pyqgis_master.pap")
else:
apiPath = self.settings.value("pythonConsole/userAPI").toStringList()
for i in range(0, len(apiPath)):
self.api.load(QString(unicode(apiPath[i])))
self.api.prepare()
self.lexer.setAPIs(self.api)
self.setLexer(self.lexer)
def __init__(self, parent=None, line_num_margin=3, autocomplete_list=None):
super(PythonEditor, self).__init__(parent, line_num_margin, autocomplete_list)
# Set Python lexer
self.lexer = QsciLexerPython(self)
self.lexer.setDefaultFont(self.editor_font)
self.lexer.setFont(self.editor_font, QsciLexerPython.Comment)
# Indentation warning ("The indentation is inconsistent when compared to the previous line")
self.lexer.setIndentationWarning(QsciLexerPython.Inconsistent)
# Set auto-completion
self.api = QsciAPIs(self.lexer)
if autocomplete_list is not None:
# Add additional completion strings
for i in autocomplete_list:
self.api.add(i)
self.api.prepare()
self.setAutoCompletionThreshold(3)
self.setAutoCompletionSource(QsciScintilla.AcsAll)
self.setAutoCompletionUseSingle(QsciScintilla.AcusExplicit)
self.setLexer(self.lexer)
# PEP8 tabs
self.setIndentationsUseTabs(False)
self.setAutoIndent(True)
self.setIndentationGuides(True)
# PEP8 edge column line
self.edgecol = 80
# Linters
self.linter = 'internal'
def __init__(self, parent=None):
super(CommandShell, self).__init__(parent)
self.setMinimumHeight(50)
self.setMaximumHeight(50)
self.settings = QSettings()
self.lex = QsciLexerPython(self)
self.apis = QsciAPIs(self.lex)
self.lex.setAPIs(self.apis)
self.setLexers()
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
self.SendScintilla(QsciScintilla.SCI_SETVSCROLLBAR, 0)
self.setFolding(0)
self._start_prompt = _start_prompt
self.prompt = self._start_prompt
self.currentfunction = None
self.setAutoCompletionSource(self.AcsAPIs)
self.setAutoCompletionThreshold(1)
self.setAutoCompletionReplaceWord(True)
self.setCallTipsStyle(QsciScintilla.CallTipsNoContext)
self.parent().installEventFilter(self)
self.textChanged.connect(self.text_changed)
self._lastcompletions = None
self.autocompletemodel = QStandardItemModel()
self.autocompletefilter = QSortFilterProxyModel()
self.autocompletefilter.setSourceModel(self.autocompletemodel)
self.autocompleteview = QListView(self.parent())
self.autocompleteview.setModel(self.autocompletefilter)
self.autocompleteview.hide()
self.selectionmodel = self.autocompleteview.selectionModel()
def setLexers(self, lexer):
from qgis.core import QgsApplication
if lexer:
font = QFont()
font.setFamily('Mono') ## Courier New
font.setFixedPitch(True)
## check platform for font size
if sys.platform.startswith('darwin'):
font.setPointSize(13)
else:
font.setPointSize(10)
self.setFont(font)
self.setMarginsFont(font)
self.lexer = QsciLexerPython()
self.lexer.setDefaultFont(font)
self.lexer.setColor(Qt.red, 1)
self.lexer.setColor(Qt.darkGreen, 5)
self.lexer.setColor(Qt.darkBlue, 15)
self.lexer.setFont(font, 1)
self.lexer.setFont(font, 3)
self.lexer.setFont(font, 4)
self.api = QsciAPIs(self.lexer)
self.api.loadPrepared( QgsApplication.pkgDataPath() + "/python/qsci_apis/pyqgis_master.pap" )
self.setLexer(self.lexer)
def keywords( self, setNumber ):
" Adds True and False into the list of keywords "
standardSet = QsciLexerPython.keywords( self, setNumber )
if standardSet is None:
return standardSet
return str( standardSet ) + " " + TREAT_AS_KEYWORDS
def setLexers(self):
self.lexer = QsciLexerPython()
loadFont = self.settings.value("pythonConsole/fontfamilytext", "Monospace")
fontSize = self.settings.value("pythonConsole/fontsize", 10, type=int)
font = QFont(loadFont)
font.setFixedPitch(True)
font.setPointSize(fontSize)
font.setStyleHint(QFont.TypeWriter)
font.setStretch(QFont.SemiCondensed)
font.setLetterSpacing(QFont.PercentageSpacing, 87.0)
font.setBold(False)
self.lexer.setDefaultFont(font)
self.lexer.setDefaultColor(QColor(self.settings.value("pythonConsole/defaultFontColor", QColor(Qt.black))))
self.lexer.setColor(QColor(self.settings.value("pythonConsole/commentFontColor", QColor(Qt.gray))), 1)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/keywordFontColor", QColor(Qt.darkGreen))), 5)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/methodFontColor", QColor(Qt.darkGray))), 9)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/decorFontColor", QColor(Qt.darkBlue))), 15)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/commentBlockFontColor", QColor(Qt.gray))), 12)
self.lexer.setColor(QColor(Qt.red), 14)
self.lexer.setFont(font, 1)
self.lexer.setFont(font, 2)
self.lexer.setFont(font, 3)
self.lexer.setFont(font, 4)
self.setLexer(self.lexer)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.editor = self.ui.editor
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(12)
self.editor.setFont(font)
self.editor.setMarginsFont(font)
self.editor.setMarginsFont(font)
self.lexer = QsciLexerPython()
self.lexer.setDefaultFont(font)
self.api = Qsci.QsciAPIs(self.lexer)
self.editor.setLexer(self.lexer)
self.editor.setAutoCompletionThreshold(1)
self.editor.setMarginLineNumbers(1,True)
self.editor.setMarginWidth(1,"0000")
self.editor.setIndentationWidth(4)
self.editor.setFolding(QsciScintilla.BoxedTreeFoldStyle)
self.editor.setBraceMatching(QsciScintilla.SloppyBraceMatch)
self.editor.setCaretLineBackgroundColor(QColor("#fbf6f6"))
self.editor.setAutoCompletionSource(self.editor.AcsAPIs)
self.editor.setAutoIndent(True)
self.editor.setUtf8(True)
self.ui.find_bar.hide()
self.filename=""
def setLexers(self, lexer):
if lexer:
font = QFont()
font.setFamily("Mono") ## Courier New
font.setFixedPitch(True)
## check platform for font size
if sys.platform.startswith("darwin"):
font.setPointSize(13)
else:
font.setPointSize(10)
self.setFont(font)
self.setMarginsFont(font)
self.lexer = QsciLexerPython()
self.lexer.setDefaultFont(font)
# self.lexer.setDefaultFont(QFont('Mono', 10, 0, False))
# self.lexer.setDefaultColor(Qt.darkGray)
self.lexer.setColor(Qt.red, 1)
self.lexer.setColor(Qt.darkGreen, 5)
self.lexer.setColor(Qt.darkBlue, 15)
self.lexer.setFont(font, 1)
self.lexer.setFont(font, 3)
self.lexer.setFont(font, 4)
self.api = QsciAPIs(self.lexer)
self.api.loadPrepared(QString(os.path.dirname(__file__) + "/api/pyqgis_master.pap"))
# self.api.load(os.path.dirname(__file__) + "/api/PyQGIS_1.8.api")
# self.api.load(os.path.dirname(__file__) + "/api/osgeo_gdal-ogr_1.9.1-1.api")
# self.api.load("qgis.networkanalysis.api")
# self.api.load("qgis.gui.api")
# self.api.load("qgis.core.api")
# self.api.load("qgis.analysis.api")
# self.api.prepare()
# self.lexer.setAPIs(self.api)
self.setLexer(self.lexer)
def setup_lexer(self):
# Set Python lexer
lexer = QsciLexerPython(self)
lexer.setDefaultFont(self._font)
self.setLexer(lexer)
lexer.setDefaultPaper(QtGui.QColor("#000000"))
lexer.setPaper(QtGui.QColor("#000000"))
lexer.setAutoIndentStyle(QsciScintilla.AiOpening)
self.setstyle()
self.setIndentationsUseTabs(False)
self.setBackspaceUnindents(True)
self.setIndentationWidth(4)
def defaultKeywords(self, kwSet):
"""
Public method to get the default keywords.
@param kwSet number of the keyword set (integer)
@return string giving the keywords (string) or None
"""
return QsciLexerPython.keywords(self, kwSet)
def setup_editor(self, editor):
"""Set various properties of a QScintilla widget.
"""
# Brace matching: enable for a brace immediately before or after
# the current position
editor.setBraceMatching(QsciScintilla.SloppyBraceMatch)
# Current line visible with special background color
editor.setCaretLineVisible(True)
editor.setCaretLineBackgroundColor(Qt.QColor("#ffe4e4"))
# Make the cursor visible.
editor.ensureCursorVisible()
# Deal with indentation.
editor.setAutoIndent(True)
editor.setIndentationWidth(4)
editor.setIndentationGuides(1)
editor.setIndentationsUseTabs(0)
editor.setAutoCompletionThreshold(2)
editor.setBackspaceUnindents(True)
# Deal with margins and breakpoint markers.
editor.setMarginSensitivity(1, True)
editor.connect(editor,
Qt.SIGNAL('marginClicked(int, int, Qt::KeyboardModifiers)'), self.on_margin_clicked)
editor.markerDefine(QsciScintilla.RightArrow,
StyleMixin.BREAK_MARKER_NUM)
editor.setMarkerBackgroundColor(Qt.QColor("#0099FF"),
StyleMixin.BREAK_MARKER_NUM)
editor.setMarkerForegroundColor(Qt.QColor("#000000"),
StyleMixin.BREAK_MARKER_NUM)
editor.setFont(self.font)
editor.setMarginsFont(self.font)
# Mark the 79th column.
editor.setEdgeColumn(79)
editor.setEdgeMode(1)
# Margin 0 is used for line numbers.
fontmetrics = Qt.QFontMetrics(self.font)
editor.setMarginsFont(self.font)
editor.setMarginWidth(0, fontmetrics.width("00000") + 6)
editor.setMarginLineNumbers(0, True)
editor.setMarginsBackgroundColor(Qt.QColor("#cccccc"))
# Set Python lexer and its fonts.
lexer = QsciLexerPython()
lexer.setDefaultFont(self.font)
editor.setLexer(lexer)
editor.SendScintilla(QsciScintilla.SCI_STYLESETFONT, 1, 'Courier')
return
def __init__(self, top=None):
"""
Initialize the editor
"""
super(Code_Editor, self).__init__(top)
## define the font to use
font = QtGui.QFont()
font.setFamily("Consolas")
font.setFixedPitch(True)
# the font metrics here will help
# building the margin width later
fm = QtGui.QFontMetrics(font)
## set the default font of the editor
## and take the same font for line numbers
self.setFont(font)
self.setMarginsFont(font)
## Line numbers
self.setMarginLineNumbers(1, True)
## Folding visual : we will use boxes
self.setFolding(QsciScintilla.BoxedTreeFoldStyle)
## Braces matching
self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
## Editing line color
self.setCaretLineVisible(True)
self.setCaretLineBackgroundColor(QtGui.QColor("#CDA869"))
## Margins colors
# line numbers margin
self.setMarginsBackgroundColor(QtGui.QColor("#333333"))
self.setMarginsForegroundColor(QtGui.QColor("#CCCCCC"))
# folding margin colors (foreground,background)
self.setFoldMarginColors(QtGui.QColor("#99CC66"), QtGui.QColor("#333300"))
## Choose a lexer
lexer = QsciLexerPython()
lexer.setDefaultFont(font)
self.setLexer(lexer)
def __init__(self, parent):
QsciLexerPython.__init__(self, parent)
self.lexer = Lexer.Lexer(self.language())
self.setDefaultPaper(self.lexer.get_globaldefault_paper())
self.setFont(self.lexer.get_default_font())
self.setIndentationWarning(QsciLexerPython.Inconsistent)
self.apiwords = self.lexer.api_words.split('\n')
api = PyQt4.Qsci.QsciAPIs(self)
for word in self.apiwords:
api.add(word)
api.prepare()
self.comment_string = QString("#")
self.stream_comment_string = {
'start' : QString(''),
'end' : QString('')
}
def createTab(self, py_de, ext, filename=""):
newTabName = "tab" + str(self.centralwidget.count())
newTextEditName = "textEdit" + str(self.centralwidget.count())
print "createTab(): creating tab %s" % (newTabName)
self.tab = QtGui.QWidget()
self.tab.setObjectName(newTabName)
self.tablayout = QtGui.QGridLayout(self.tab)
self.centralwidget.addTab(self.tab,"")
newTabIndex = self.centralwidget.indexOf(self.tab)
if filename == "":
filename = "Untitled" + str((newTabIndex + 1))
newTabTitle = str(filename) + str(ext)
self.centralwidget.setCurrentIndex(self.centralwidget.indexOf(self.tab))
self.centralwidget.setTabText(newTabIndex, QtGui.QApplication.translate("py_de", newTabTitle, None, QtGui.QApplication.UnicodeUTF8))
self.textEdit = QsciScintilla(self.tab)
self.textEdit.setFont(self.font)
self.textEdit.setMarginsFont(self.font)
self.textEdit.setMarginWidth(0, self.fm.width( "00000" ) + 5)
self.textEdit.setMarginLineNumbers(0, True)
self.textEdit.setEdgeMode(QsciScintilla.EdgeLine)
self.textEdit.setEdgeColumn(80)
self.textEdit.setEdgeColor(QtGui.QColor("#FF0000"))
self.textEdit.setFolding(QsciScintilla.BoxedTreeFoldStyle)
self.textEdit.setBraceMatching(QsciScintilla.SloppyBraceMatch)
self.textEdit.setCaretLineVisible(True)
self.textEdit.setCaretLineBackgroundColor(QtGui.QColor("#CDA869"))
self.textEdit.setMarginsBackgroundColor(QtGui.QColor("#333333"))
self.textEdit.setMarginsForegroundColor(QtGui.QColor("#CCCCCC"))
self.textEdit.setFoldMarginColors(QtGui.QColor("#99CC66"),QtGui.QColor("#333300"))
lexer = QsciLexerPython()
lexer.setDefaultFont(self.font)
self.textEdit.setLexer(lexer)
self.textEdit.show()
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Policy(1),QtGui.QSizePolicy.Policy(1))
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.textEdit.sizePolicy().hasHeightForWidth())
self.textEdit.setSizePolicy(sizePolicy)
self.textEdit.setObjectName(newTextEditName)
self.tablayout.addWidget(self.textEdit, 0, 0, 1, 1)
def __init__(self, parent=None):
self.__styles = {
QsciLexerPython.Default: "text",
QsciLexerPython.Comment: "comment",
QsciLexerPython.Number: "def:number",
QsciLexerPython.DoubleQuotedString: "def:string",
QsciLexerPython.SingleQuotedString: "def:string",
QsciLexerPython.Keyword: "def:keyword",
QsciLexerPython.TripleSingleQuotedString: "def:string",
QsciLexerPython.TripleDoubleQuotedString: "def:string",
QsciLexerPython.ClassName: "def:function",
QsciLexerPython.FunctionMethodName: "def:function",
QsciLexerPython.Operator: "def:specials",
QsciLexerPython.Identifier: "text",
QsciLexerPython.CommentBlock: "comment",
QsciLexerPython.UnclosedString: "def:error",
QsciLexerPython.HighlightedIdentifier: "text",
QsciLexerPython.Decorator: "def:specials",
}
BaseLexer.__init__(self)
QsciLexerPython.__init__(self, parent)
def Setup( self, parentWidget ):
editor = QsciScintilla( parentWidget )
size = parentWidget.size()
editor.resize( size.width() / 2, size.height() )
# Set up the font
font = QtGui.QFont()
font.setFamily("Consolas")
font.setFixedPitch(True)
font.setPointSize(13)
fm = QtGui.QFontMetrics(font)
editor.setFont( font )
editor.setMarginsFont( font )
# Add in line numbers
editor.setMarginWidth( 0, fm.width("000") + 5 )
editor.setMarginLineNumbers( 0, True )
editor.setBraceMatching( QsciScintilla.SloppyBraceMatch )
# Set up a python lexer
lexer = QsciLexerPython()
lexer.setDefaultFont( font )
editor.setLexer( lexer )
# Set up indentation
editor.setAutoIndent( True )
editor.setIndentationsUseTabs( False )
editor.setTabWidth( 4 )
self.editor = editor
self.editor.linesChanged.connect( self.OnLineChange )
self.editor.textChanged.connect( self.OnChange )
timer = QtCore.QTimer( self )
timer.timeout.connect( self.OnTick )
timer.start( 500 )
class PyEditor(QsciScintilla):
def __init__(self, parent=None):
QsciScintilla.__init__(self, parent)
self.setTabWidth(4)
self.setTabIndents(True)
self.setIndentationsUseTabs(False)
self._lexer = QsciLexerPython()
self._lexer.setFont(QFont('DejaVu Sans Mono'))
self._lexer.setIndentationWarning(QsciLexerPython.Tabs)
# load current preview to lexer
api = QsciAPIs(self._lexer)
api.load('/tmp/preview.py')
api.prepare()
self.setLexer(self._lexer)
self.setAutoCompletionSource(QsciScintilla.AcsAll)
self.setAutoCompletionThreshold(2)
self.setAutoIndent(True)
self.setCaretForegroundColor(g.cursor_color)
self.zoomTo(5)
def setLexers(self):
self.lexer = QsciLexerPython()
loadFont = self.settings.value("pythonConsole/fontfamilytext", "Monospace")
fontSize = self.settings.value("pythonConsole/fontsize", 10, type=int)
font = QFont(loadFont)
font.setFixedPitch(True)
font.setPointSize(fontSize)
font.setStyleHint(QFont.TypeWriter)
font.setStretch(QFont.SemiCondensed)
font.setLetterSpacing(QFont.PercentageSpacing, 87.0)
font.setBold(False)
self.lexer.setDefaultFont(font)
self.lexer.setDefaultColor(QColor(self.settings.value("pythonConsole/defaultFontColor", QColor(Qt.black))))
self.lexer.setColor(QColor(self.settings.value("pythonConsole/commentFontColor", QColor(Qt.gray))), 1)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/keywordFontColor", QColor(Qt.darkGreen))), 5)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/classFontColor", QColor(Qt.blue))), 8)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/methodFontColor", QColor(Qt.darkGray))), 9)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/decorFontColor", QColor(Qt.darkBlue))), 15)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/commentBlockFontColor", QColor(Qt.gray))), 12)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/singleQuoteFontColor", QColor(Qt.blue))), 4)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/doubleQuoteFontColor", QColor(Qt.blue))), 3)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/tripleSingleQuoteFontColor", QColor(Qt.blue))), 6)
self.lexer.setColor(QColor(self.settings.value("pythonConsole/tripleDoubleQuoteFontColor", QColor(Qt.blue))), 7)
self.lexer.setFont(font, 1)
self.lexer.setFont(font, 3)
self.lexer.setFont(font, 4)
for style in range(0, 33):
paperColor = QColor(self.settings.value("pythonConsole/paperBackgroundColor", QColor(Qt.white)))
self.lexer.setPaper(paperColor, style)
self.api = QsciAPIs(self.lexer)
chekBoxAPI = self.settings.value("pythonConsole/preloadAPI", True, type=bool)
chekBoxPreparedAPI = self.settings.value("pythonConsole/usePreparedAPIFile", False, type=bool)
if chekBoxAPI:
pap = os.path.join(QgsApplication.pkgDataPath(), "python", "qsci_apis", "pyqgis.pap")
self.api.loadPrepared(pap)
elif chekBoxPreparedAPI:
self.api.loadPrepared(self.settings.value("pythonConsole/preparedAPIFile"))
else:
apiPath = self.settings.value("pythonConsole/userAPI", [])
for i in range(0, len(apiPath)):
self.api.load(unicode(apiPath[i]))
self.api.prepare()
self.lexer.setAPIs(self.api)
self.setLexer(self.lexer)
def initEditor(self):
editor = QsciScintilla()
## define the font to use
font = QtGui.QFont()
#font.setFamily("Consolas")
font.setFixedPitch(True)
font.setPointSize(9)
# the font metrics here will help
# building the margin width later
fm = QtGui.QFontMetrics(font)
## set the default font of the editor
## and take the same font for line numbers
editor.setFont(font)
editor.setMarginsFont(font)
## Line numbers
# conventionnaly, margin 0 is for line numbers
editor.setMarginWidth(0, fm.width("0000"))
editor.setMarginLineNumbers(0, True)
## Edge Mode shows a red vetical bar at 80 chars
editor.setEdgeMode(QsciScintilla.EdgeLine)
editor.setEdgeColumn(80)
editor.setEdgeColor(QtGui.QColor("#FF0000"))
## Folding visual : we will use boxes
editor.setFolding(QsciScintilla.BoxedTreeFoldStyle)
## Braces matching
editor.setBraceMatching(QsciScintilla.SloppyBraceMatch)
## Editing line color
editor.setCaretLineVisible(True)
#editor.setCaretLineBackgroundColor(QtGui.QColor("#F5F5DC"))
## Margins colors
# line numbers margin
#editor.setMarginsBackgroundColor(QtGui.QColor("#333333"))
#editor.setMarginsForegroundColor(QtGui.QColor("#CCCCCC"))
# folding margin colors (foreground,background)
#editor.setFoldMarginColors(QtGui.QColor("#99CC66"),QtGui.QColor("#333300"))
## Choose a lexer
lexer = QsciLexerPython()
lexer.setDefaultFont(font)
editor.setLexer(lexer)
## Render on screen
#editor.show()
## Show this file in the editor
#editor.setText(open("examples\charriot_obj.txt").read())
# Show all the methods of the editor
#methods = sorted(QsciScintilla.__dict__.keys())
#for m in methods :
# print m
#editor.setWidth(400)
editor.setEolMode(QsciScintilla.EolUnix)
return editor
def __init__(self, interpreter, message="", log='', parent=None):
"""Constructor.
@param interpreter : InteractiveInterpreter in which
the code will be executed
@param message : welcome message string
@param 'parent' : specifies the parent widget.
If no parent widget has been specified, it is possible to
exit the interpreter by Ctrl-D.
"""
QsciScintilla.__init__(self, parent)
GraphicalStreamRedirection.__init__(self)
self.interpreter = interpreter
# user interface setup
self.setAutoIndent(True)
self.setAutoCompletionThreshold(4)
self.setAutoCompletionSource(QsciScintilla.AcsDocument)
# Lexer
self.setLexer(QsciLexerPython(self))
# Search
self.incrementalSearchString = ""
self.incrementalSearchActive = False
self.inRawMode = False
self.echoInput = True
# Initialize history
self.historyLists = {}
self.maxHistoryEntries = 30
self.history = []
self.histidx = -1
self.reading = 0
# interpreter prompt.
try:
sys.ps1
except AttributeError:
sys.ps1 = ">>> "
try:
sys.ps2
except AttributeError:
sys.ps2 = "... "
#self.completionText = ""
# Excecution Status
self.more = False
# Multi line execution Buffer
self.execlines = []
# interpreter banner
self.write('The shell running Python %s on %s.\n' %
(sys.version, sys.platform))
self.write('Type "copyright", "credits" or "license"'
' for more information on Python.\n')
self.write(message + '\n')
#self.write("help -> Python help system.\n")
self.write(" object? -> Print details about 'object'\n\n")
self.write(sys.ps1)
#self.standardCommands().clearKeys()
self.keymap = {
Qt.Key_Backspace: self.__QScintillaDeleteBack,
Qt.Key_Delete: self.__QScintillaDelete,
Qt.Key_Return: self.__QScintillaNewline,
Qt.Key_Enter: self.__QScintillaNewline,
Qt.Key_Tab: self.__QScintillaTab,
Qt.Key_Left: self.__QScintillaCharLeft,
Qt.Key_Right: self.__QScintillaCharRight,
Qt.Key_Up: self.__QScintillaLineUp,
Qt.Key_Down: self.__QScintillaLineDown,
Qt.Key_Home: self.__QScintillaVCHome,
Qt.Key_End: self.__QScintillaLineEnd,
}
self.connect(self, QtCore.SIGNAL('userListActivated(int)'),
self.__completionListSelected)
self.setFocus()
class ShellOutputScintilla(QsciScintilla):
def __init__(self, parent=None):
super(ShellOutputScintilla, self).__init__(parent)
self.parent = parent
self.shell = self.parent.shell
self.settings = QSettings()
# Creates layout for message bar
self.layout = QGridLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.layout.addItem(spacerItem, 1, 0, 1, 1)
# messageBar instance
self.infoBar = QgsMessageBar()
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.infoBar.setSizePolicy(sizePolicy)
self.layout.addWidget(self.infoBar, 0, 0, 1, 1)
# Enable non-ascii chars for editor
self.setUtf8(True)
sys.stdout = writeOut(self, sys.stdout)
sys.stderr = writeOut(self, sys.stderr, "_traceback")
self.insertInitText()
self.setLexers()
self.setReadOnly(True)
# Set the default font
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(10)
self.setFont(font)
self.setMarginsFont(font)
# Margin 0 is used for line numbers
self.setMarginWidth(0, 0)
self.setMarginWidth(1, 0)
self.setMarginWidth(2, 0)
#fm = QFontMetrics(font)
self.setMarginsFont(font)
self.setMarginWidth(1, "00000")
self.setMarginLineNumbers(1, True)
self.setMarginsForegroundColor(QColor("#3E3EE3"))
self.setMarginsBackgroundColor(QColor("#f9f9f9"))
self.setCaretLineVisible(True)
self.setCaretLineBackgroundColor(QColor("#fcf3ed"))
self.setMinimumHeight(120)
self.setWrapMode(QsciScintilla.WrapCharacter)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
self.runScut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_E), self)
self.runScut.setContext(Qt.WidgetShortcut)
self.runScut.activated.connect(self.enteredSelected)
# Reimplemeted copy action to prevent paste prompt (>>>,...) in command view
self.copyShortcut = QShortcut(QKeySequence.Copy, self)
self.copyShortcut.activated.connect(self.copy)
self.selectAllShortcut = QShortcut(QKeySequence.SelectAll, self)
self.selectAllShortcut.activated.connect(self.selectAll)
def insertInitText(self):
txtInit = QCoreApplication.translate(
"PythonConsole", "Python {} on {}\n"
"## Type help(iface) for more info and list of methods.\n".format(
sys.version, socket.gethostname()))
initText = self.setText(txtInit)
def refreshLexerProperties(self):
self.setLexers()
def setLexers(self):
self.lexer = QsciLexerPython()
loadFont = self.settings.value("pythonConsole/fontfamilytext",
"Monospace")
fontSize = self.settings.value("pythonConsole/fontsize", 10, type=int)
font = QFont(loadFont)
font.setFixedPitch(True)
font.setPointSize(fontSize)
font.setStyleHint(QFont.TypeWriter)
font.setStretch(QFont.SemiCondensed)
font.setLetterSpacing(QFont.PercentageSpacing, 87.0)
font.setBold(False)
self.lexer.setDefaultFont(font)
self.lexer.setColor(Qt.red, 1)
self.lexer.setColor(Qt.darkGreen, 5)
self.lexer.setColor(Qt.darkBlue, 15)
self.lexer.setFont(font, 1)
self.lexer.setFont(font, 2)
self.lexer.setFont(font, 3)
self.lexer.setFont(font, 4)
self.setLexer(self.lexer)
def clearConsole(self):
self.setText('')
self.insertInitText()
self.shell.setFocus()
def contextMenuEvent(self, e):
menu = QMenu(self)
iconRun = QgsApplication.getThemeIcon("console/iconRunConsole.png")
iconClear = QgsApplication.getThemeIcon("console/iconClearConsole.png")
iconHideTool = QgsApplication.getThemeIcon(
"console/iconHideToolConsole.png")
iconSettings = QgsApplication.getThemeIcon(
"console/iconSettingsConsole.png")
hideToolBar = menu.addAction(
iconHideTool,
QCoreApplication.translate("PythonConsole", "Hide/Show Toolbar"),
self.hideToolBar)
menu.addSeparator()
showEditorAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Show Editor"),
self.showEditor)
menu.addSeparator()
runAction = menu.addAction(
iconRun,
QCoreApplication.translate("PythonConsole", "Enter Selected"),
self.enteredSelected, QKeySequence(Qt.CTRL + Qt.Key_E))
clearAction = menu.addAction(
iconClear,
QCoreApplication.translate("PythonConsole", "Clear console"),
self.clearConsole)
menu.addSeparator()
copyAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Copy"), self.copy,
QKeySequence.Copy)
menu.addSeparator()
selectAllAction = menu.addAction(
QCoreApplication.translate("PythonConsole", "Select All"),
self.selectAll, QKeySequence.SelectAll)
menu.addSeparator()
settingsDialog = menu.addAction(
iconSettings,
QCoreApplication.translate("PythonConsole", "Settings"),
self.parent.openSettings)
runAction.setEnabled(False)
clearAction.setEnabled(False)
copyAction.setEnabled(False)
selectAllAction.setEnabled(False)
showEditorAction.setEnabled(True)
if self.hasSelectedText():
runAction.setEnabled(True)
copyAction.setEnabled(True)
if not self.text(3) == '':
selectAllAction.setEnabled(True)
clearAction.setEnabled(True)
if self.parent.tabEditorWidget.isVisible():
showEditorAction.setEnabled(False)
action = menu.exec_(self.mapToGlobal(e.pos()))
def hideToolBar(self):
tB = self.parent.toolBar
tB.hide() if tB.isVisible() else tB.show()
self.shell.setFocus()
def showEditor(self):
Ed = self.parent.splitterObj
if not Ed.isVisible():
Ed.show()
self.parent.showEditorButton.setChecked(True)
self.shell.setFocus()
def copy(self):
"""Copy text to clipboard... or keyboard interrupt"""
if self.hasSelectedText():
text = unicode(self.selectedText())
text = text.replace('>>> ',
'').replace('... ',
'').strip() # removing prompts
QApplication.clipboard().setText(text)
else:
self.emit(SIGNAL("keyboard_interrupt()"))
def enteredSelected(self):
cmd = self.selectedText()
self.shell.insertFromDropPaste(cmd)
self.shell.entered()
def keyPressEvent(self, e):
# empty text indicates possible shortcut key sequence so stay in output
txt = e.text()
if len(txt) and txt >= " ":
self.shell.append(txt)
self.shell.move_cursor_to_end()
self.shell.setFocus()
e.ignore()
else:
# possible shortcut key sequence, accept it
e.accept()
def widgetMessageBar(self, iface, text):
timeout = iface.messageTimeout()
self.infoBar.pushMessage(text, QgsMessageBar.INFO, timeout)
class EditorOutput(QsciScintilla):
def __init__(self, parent=None):
#QsciScintilla.__init__(self, parent)
super(EditorOutput, self).__init__(parent)
self.parent = parent
self.edit = self.parent.edit
# Creates layout for message bar
self.layout = QGridLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.layout.addItem(spacerItem, 1, 0, 1, 1)
# messageBar instance
self.infoBar = QgsMessageBar()
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.infoBar.setSizePolicy(sizePolicy)
self.layout.addWidget(self.infoBar, 0, 0, 1, 1)
# Enable non-ascii chars for editor
self.setUtf8(True)
sys.stdout = writeOut(self, sys.stdout)
sys.stderr = writeOut(self, sys.stderr, "traceback")
self.insertInitText()
self.setLexers()
self.setReadOnly(True)
# Set the default font
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(10)
self.setFont(font)
self.setMarginsFont(font)
# Margin 0 is used for line numbers
#fm = QFontMetrics(font)
self.setMarginsFont(font)
self.setMarginWidth(1, "00000")
self.setMarginLineNumbers(1, True)
self.setMarginsForegroundColor(QColor("#3E3EE3"))
self.setMarginsBackgroundColor(QColor("#f9f9f9"))
self.setCaretLineVisible(True)
self.setCaretLineBackgroundColor(QColor("#fcf3ed"))
self.setMinimumHeight(120)
# Folding
#self.setFolding(QsciScintilla.BoxedTreeFoldStyle)
#self.setFoldMarginColors(QColor("#99CC66"),QColor("#333300"))
#self.setWrapMode(QsciScintilla.WrapCharacter)
## Edge Mode
#self.setEdgeMode(QsciScintilla.EdgeLine)
#self.setEdgeColumn(80)
#self.setEdgeColor(QColor("#FF0000"))
self.setWrapMode(QsciScintilla.WrapCharacter)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
self.runShortcut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_E), self)
self.runShortcut.activated.connect(self.enteredSelected)
# Reimplemeted copy action to prevent paste prompt (>>>,...) in command view
self.copyShortcut = QShortcut(QKeySequence.Copy, self)
self.copyShortcut.activated.connect(self.copy)
self.selectAllShortcut = QShortcut(QKeySequence.SelectAll, self)
self.selectAllShortcut.activated.connect(self.selectAll)
def insertInitText(self):
txtInit = QCoreApplication.translate(
"PythonConsole",
"## To access Quantum GIS environment from this console\n"
"## use iface object (instance of QgisInterface class).\n"
"## Type help(iface) for more info and list of methods.\n\n")
initText = self.setText(txtInit)
def refreshLexerProperties(self):
self.setLexers()
def setLexers(self):
self.lexer = QsciLexerPython()
settings = QSettings()
loadFont = settings.value("pythonConsole/fontfamilytext",
"Monospace").toString()
fontSize = settings.value("pythonConsole/fontsize", 10).toInt()[0]
font = QFont(loadFont)
font.setFixedPitch(True)
font.setPointSize(fontSize)
self.lexer.setDefaultFont(font)
self.lexer.setColor(Qt.red, 1)
self.lexer.setColor(Qt.darkGreen, 5)
self.lexer.setColor(Qt.darkBlue, 15)
self.lexer.setFont(font, 1)
self.lexer.setFont(font, 2)
self.lexer.setFont(font, 3)
self.lexer.setFont(font, 4)
self.setLexer(self.lexer)
def getTextFromEditor(self):
text = self.text()
textList = text.split("\n")
return textList
def clearConsole(self):
#self.SendScintilla(QsciScintilla.SCI_CLEARALL)
self.setText('')
self.insertInitText()
self.edit.setFocus()
def contextMenuEvent(self, e):
menu = QMenu(self)
iconRun = QgsApplication.getThemeIcon("console/iconRunConsole.png")
iconPastebin = QgsApplication.getThemeIcon(
"console/iconCodepadConsole.png")
iconClear = QgsApplication.getThemeIcon("console/iconClearConsole.png")
iconHideTool = QgsApplication.getThemeIcon(
"console/iconHideToolConsole.png")
hideToolBar = menu.addAction(iconHideTool, "Hide/Show Toolbar",
self.hideToolBar)
menu.addSeparator()
runAction = menu.addAction(iconRun, "Enter Selected",
self.enteredSelected,
QKeySequence(Qt.CTRL + Qt.Key_E))
clearAction = menu.addAction(iconClear, "Clear console",
self.clearConsole)
menu.addSeparator()
copyAction = menu.addAction("Copy", self.copy, QKeySequence.Copy)
pastebinAction = menu.addAction(iconPastebin, "Share on codepad",
self.pastebin)
menu.addSeparator()
selectAllAction = menu.addAction("Select All", self.selectAll,
QKeySequence.SelectAll)
runAction.setEnabled(False)
clearAction.setEnabled(False)
copyAction.setEnabled(False)
pastebinAction.setEnabled(False)
selectAllAction.setEnabled(False)
if self.hasSelectedText():
runAction.setEnabled(True)
copyAction.setEnabled(True)
pastebinAction.setEnabled(True)
if not self.text(3) == '':
selectAllAction.setEnabled(True)
clearAction.setEnabled(True)
action = menu.exec_(self.mapToGlobal(e.pos()))
def hideToolBar(self):
tB = self.parent.toolBar
tB.hide() if tB.isVisible() else tB.show()
self.edit.setFocus()
def copy(self):
"""Copy text to clipboard... or keyboard interrupt"""
if self.hasSelectedText():
text = unicode(self.selectedText())
text = text.replace('>>> ',
'').replace('... ',
'').strip() # removing prompts
QApplication.clipboard().setText(text)
else:
self.emit(SIGNAL("keyboard_interrupt()"))
def enteredSelected(self):
cmd = self.selectedText()
self.edit.insertFromDropPaste(cmd)
self.edit.entered()
def keyPressEvent(self, e):
# empty text indicates possible shortcut key sequence so stay in output
txt = e.text()
if txt.length() and txt >= " ":
self.edit.append(txt)
self.edit.move_cursor_to_end()
self.edit.setFocus()
e.ignore()
else:
# possible shortcut key sequence, accept it
e.accept()
def pastebin(self):
import urllib2, urllib
listText = self.selectedText().split('\n')
getCmd = []
for strLine in listText:
if strLine != "":
#if s[0:3] in (">>>", "..."):
# filter for special command (_save,_clear) and comment
if strLine[4] != "_" and strLine[:2] != "##":
strLine.replace(">>> ", "").replace("... ", "")
getCmd.append(unicode(strLine))
pasteText = u"\n".join(getCmd)
url = 'http://codepad.org'
values = {'lang': 'Python', 'code': pasteText, 'submit': 'Submit'}
try:
response = urllib2.urlopen(url, urllib.urlencode(values))
url = response.read()
for href in url.split("</a>"):
if "Link:" in href:
ind = href.index('Link:')
found = href[ind + 5:]
for i in found.split('">'):
if '<a href=' in i:
link = i.replace('<a href="', "").strip()
if link:
QApplication.clipboard().setText(link)
msgText = QCoreApplication.translate(
'PythonConsole', 'URL copied to clipboard.')
self.parent.callWidgetMessageBar(msgText)
except urllib2.URLError, e:
msgText = QCoreApplication.translate('PythonConsole',
'Connection error: ')
self.parent.callWidgetMessageBar(msgText + str(e.args))
class ShellScintilla(QsciScintilla, code.InteractiveInterpreter):
def __init__(self, parent=None):
super(ShellScintilla,self).__init__(parent)
code.InteractiveInterpreter.__init__(self, locals=None)
self.parent = parent
self.opening = ['(', '{', '[', "'", '"']
self.closing = [')', '}', ']', "'", '"']
self.settings = QSettings()
# Enable non-ascii chars for editor
self.setUtf8(True)
self.new_input_line = True
self.setMarginWidth(0, 0)
self.setMarginWidth(1, 0)
self.setMarginWidth(2, 0)
self.buffer = []
self.displayPrompt(False)
for line in _init_commands:
self.runsource(line)
self.history = QStringList()
self.historyIndex = 0
# Read history command file
self.readHistoryFile()
self.historyDlg = HistoryDialog(self)
# Brace matching: enable for a brace immediately before or after
# the current position
self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
self.setMatchedBraceBackgroundColor(QColor("#b7f907"))
# Current line visible with special background color
self.setCaretWidth(2)
self.settingsShell()
# Don't want to see the horizontal scrollbar at all
# Use raw message to Scintilla here (all messages are documented
# here: http://www.scintilla.org/ScintillaDoc.html)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
# not too small
#self.setMinimumSize(500, 300)
self.setMinimumHeight(20)
self.setWrapMode(QsciScintilla.WrapCharacter)
self.SendScintilla(QsciScintilla.SCI_EMPTYUNDOBUFFER)
## Disable command key
ctrl, shift = self.SCMOD_CTRL<<16, self.SCMOD_SHIFT<<16
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('L')+ ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('T')+ ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('D')+ ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('Z')+ ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('Y')+ ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('L')+ ctrl+shift)
## New QShortcut = ctrl+space/ctrl+alt+space for Autocomplete
self.newShortcutCSS = QShortcut(QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_Space), self)
self.newShortcutCAS = QShortcut(QKeySequence(Qt.CTRL + Qt.ALT + Qt.Key_Space), self)
self.newShortcutCSS.setContext(Qt.WidgetShortcut)
self.newShortcutCAS.setContext(Qt.WidgetShortcut)
self.newShortcutCAS.activated.connect(self.autoCompleteKeyBinding)
self.newShortcutCSS.activated.connect(self.showHistory)
def settingsShell(self):
# Set Python lexer
self.setLexers()
threshold = self.settings.value("pythonConsole/autoCompThreshold", 2).toInt()[0]
self.setAutoCompletionThreshold(threshold)
radioButtonSource = self.settings.value("pythonConsole/autoCompleteSource", 'fromAPI').toString()
autoCompEnabled = self.settings.value("pythonConsole/autoCompleteEnabled", True).toBool()
self.setAutoCompletionThreshold(threshold)
if autoCompEnabled:
if radioButtonSource == 'fromDoc':
self.setAutoCompletionSource(self.AcsDocument)
elif radioButtonSource == 'fromAPI':
self.setAutoCompletionSource(self.AcsAPIs)
elif radioButtonSource == 'fromDocAPI':
self.setAutoCompletionSource(self.AcsAll)
else:
self.setAutoCompletionSource(self.AcsNone)
def showHistory(self):
if not self.historyDlg.isVisible():
self.historyDlg.show()
self.historyDlg._reloadHistory()
self.historyDlg.activateWindow()
def autoCompleteKeyBinding(self):
radioButtonSource = self.settings.value("pythonConsole/autoCompleteSource").toString()
autoCompEnabled = self.settings.value("pythonConsole/autoCompleteEnabled").toBool()
if autoCompEnabled:
if radioButtonSource == 'fromDoc':
self.autoCompleteFromDocument()
elif radioButtonSource == 'fromAPI':
self.autoCompleteFromAPIs()
elif radioButtonSource == 'fromDocAPI':
self.autoCompleteFromAll()
def commandConsole(self, command):
if not self.is_cursor_on_last_line():
self.move_cursor_to_end()
line, pos = self.getCursorPosition()
selCmdLenght = self.text(line).length()
self.setSelection(line, 4, line, selCmdLenght)
self.removeSelectedText()
if command == "sextante":
# import Sextante class
self.append('import sextante')
elif command == "qtCore":
# import QtCore class
self.append('from PyQt4.QtCore import *')
elif command == "qtGui":
# import QtGui class
self.append('from PyQt4.QtGui import *')
self.entered()
self.move_cursor_to_end()
self.setFocus()
def setLexers(self):
self.lexer = QsciLexerPython()
loadFont = self.settings.value("pythonConsole/fontfamilytext", "Monospace").toString()
fontSize = self.settings.value("pythonConsole/fontsize", 10).toInt()[0]
font = QFont(loadFont)
font.setFixedPitch(True)
font.setPointSize(fontSize)
font.setStyleHint(QFont.TypeWriter)
font.setStretch(QFont.SemiCondensed)
font.setLetterSpacing(QFont.PercentageSpacing, 87.0)
font.setBold(False)
self.lexer.setDefaultFont(font)
self.lexer.setColor(Qt.red, 1)
self.lexer.setColor(Qt.darkGreen, 5)
self.lexer.setColor(Qt.darkBlue, 15)
self.lexer.setFont(font, 1)
self.lexer.setFont(font, 3)
self.lexer.setFont(font, 4)
self.api = QsciAPIs(self.lexer)
chekBoxAPI = self.settings.value("pythonConsole/preloadAPI", True).toBool()
if chekBoxAPI:
self.api.loadPrepared( QgsApplication.pkgDataPath() + "/python/qsci_apis/pyqgis_master.pap" )
else:
apiPath = self.settings.value("pythonConsole/userAPI").toStringList()
for i in range(0, len(apiPath)):
self.api.load(QString(unicode(apiPath[i])))
self.api.prepare()
self.lexer.setAPIs(self.api)
self.setLexer(self.lexer)
## TODO: show completion list for file and directory
def getText(self):
""" Get the text as a unicode string. """
value = self.getBytes().decode('utf-8')
# print (value) printing can give an error because the console font
# may not have all unicode characters
return value
def getBytes(self):
""" Get the text as bytes (utf-8 encoded). This is how
the data is stored internally. """
len = self.SendScintilla(self.SCI_GETLENGTH)+1
bb = QByteArray(len,'0')
N = self.SendScintilla(self.SCI_GETTEXT, len, bb)
return bytes(bb)[:-1]
def getTextLength(self):
return self.SendScintilla(QsciScintilla.SCI_GETLENGTH)
def get_end_pos(self):
"""Return (line, index) position of the last character"""
line = self.lines() - 1
return (line, self.text(line).length())
def is_cursor_at_end(self):
"""Return True if cursor is at the end of text"""
cline, cindex = self.getCursorPosition()
return (cline, cindex) == self.get_end_pos()
def move_cursor_to_end(self):
"""Move cursor to end of text"""
line, index = self.get_end_pos()
self.setCursorPosition(line, index)
self.ensureCursorVisible()
self.ensureLineVisible(line)
def is_cursor_on_last_line(self):
"""Return True if cursor is on the last line"""
cline, _ = self.getCursorPosition()
return cline == self.lines() - 1
def is_cursor_on_edition_zone(self):
""" Return True if the cursor is in the edition zone """
cline, cindex = self.getCursorPosition()
return cline == self.lines() - 1 and cindex >= 4
def new_prompt(self, prompt):
"""
Print a new prompt and save its (line, index) position
"""
self.write(prompt, prompt=True)
# now we update our cursor giving end of prompt
line, index = self.getCursorPosition()
self.ensureCursorVisible()
self.ensureLineVisible(line)
def displayPrompt(self, more=False):
self.append("... ") if more else self.append(">>> ")
self.move_cursor_to_end()
def updateHistory(self, command):
if isinstance(command, QStringList):
for line in command:
self.history.append(line)
elif not command == "":
if len(self.history) <= 0 or \
not command == self.history[-1]:
self.history.append(command)
self.historyIndex = len(self.history)
def writeHistoryFile(self):
ok = False
try:
wH = open(_historyFile, 'w')
for s in self.history:
wH.write(s + '\n')
ok = True
except:
raise
wH.close()
if ok:
msgText = QCoreApplication.translate('PythonConsole',
'History saved successfully.')
self.parent.callWidgetMessageBar(msgText)
def readHistoryFile(self):
fileExist = QFile.exists(_historyFile)
if fileExist:
rH = open(_historyFile, 'r')
for line in rH:
if line != "\n":
l = line.rstrip('\n')
self.updateHistory(l)
else:
return
def clearHistory(self, clearSession=False):
if clearSession:
self.history = QStringList()
msgText = QCoreApplication.translate('PythonConsole',
'Session and file history cleared successfully.')
self.parent.callWidgetMessageBar(msgText)
return
ok = False
try:
cH = open(_historyFile, 'w')
ok = True
except:
raise
cH.close()
if ok:
msgText = QCoreApplication.translate('PythonConsole',
'History cleared successfully.')
self.parent.callWidgetMessageBar(msgText)
def clearHistorySession(self):
self.clearHistory(True)
def showPrevious(self):
if self.historyIndex < len(self.history) and not self.history.isEmpty():
line, pos = self.getCursorPosition()
selCmdLenght = self.text(line).length()
self.setSelection(line, 4, line, selCmdLenght)
self.removeSelectedText()
self.historyIndex += 1
if self.historyIndex == len(self.history):
self.insert("")
pass
else:
self.insert(self.history[self.historyIndex])
self.move_cursor_to_end()
#self.SendScintilla(QsciScintilla.SCI_DELETEBACK)
def showNext(self):
if self.historyIndex > 0 and not self.history.isEmpty():
line, pos = self.getCursorPosition()
selCmdLenght = self.text(line).length()
self.setSelection(line, 4, line, selCmdLenght)
self.removeSelectedText()
self.historyIndex -= 1
if self.historyIndex == len(self.history):
self.insert("")
else:
self.insert(self.history[self.historyIndex])
self.move_cursor_to_end()
#self.SendScintilla(QsciScintilla.SCI_DELETEBACK)
def keyPressEvent(self, e):
startLine, _, endLine, _ = self.getSelection()
# handle invalid cursor position and multiline selections
if not self.is_cursor_on_edition_zone() or startLine < endLine:
# allow to copy and select
if e.modifiers() & (Qt.ControlModifier | Qt.MetaModifier):
if e.key() in (Qt.Key_C, Qt.Key_A):
QsciScintilla.keyPressEvent(self, e)
return
# allow selection
if e.modifiers() & Qt.ShiftModifier:
if e.key() in (Qt.Key_Left, Qt.Key_Right, Qt.Key_Home, Qt.Key_End):
QsciScintilla.keyPressEvent(self, e)
return
# all other keystrokes get sent to the input line
self.move_cursor_to_end()
line, index = self.getCursorPosition()
cmd = self.text(line)
if e.key() in (Qt.Key_Return, Qt.Key_Enter) and not self.isListActive():
self.entered()
elif e.key() in (Qt.Key_Left, Qt.Key_Home):
QsciScintilla.keyPressEvent(self, e)
# check whether the cursor is moved out of the edition zone
newline, newindex = self.getCursorPosition()
if newline < line or newindex < 4:
# fix selection and the cursor position
if self.hasSelectedText():
self.setSelection(line, self.getSelection()[3], line, 4)
else:
self.setCursorPosition(line, 4)
elif e.key() in (Qt.Key_Backspace, Qt.Key_Delete):
QsciScintilla.keyPressEvent(self, e)
# check whether the cursor is moved out of the edition zone
_, newindex = self.getCursorPosition()
if newindex < 4:
# restore the prompt chars (if removed) and
# fix the cursor position
self.insert( cmd[:3-newindex] + " " )
self.setCursorPosition(line, 4)
self.recolor()
elif (e.modifiers() & (Qt.ControlModifier | Qt.MetaModifier) and \
e.key() == Qt.Key_V) or \
(e.modifiers() & Qt.ShiftModifier and e.key() == Qt.Key_Insert):
self.paste()
e.accept()
elif e.key() == Qt.Key_Down and not self.isListActive():
self.showPrevious()
elif e.key() == Qt.Key_Up and not self.isListActive():
self.showNext()
## TODO: press event for auto-completion file directory
else:
if self.settings.value("pythonConsole/autoCloseBracket", True).toBool():
t = unicode(e.text())
## Close bracket automatically
if t in self.opening:
i = self.opening.index(t)
self.insert(self.closing[i])
QsciScintilla.keyPressEvent(self, e)
def contextMenuEvent(self, e):
menu = QMenu(self)
subMenu = QMenu(menu)
titleHistoryMenu = QCoreApplication.translate("PythonConsole", "Command History")
subMenu.setTitle(titleHistoryMenu)
showHistoryAction = subMenu.addAction(QCoreApplication.translate("PythonConsole",
"Show"),
self.showHistory, 'Ctrl+Shift+SPACE')
subMenu.addSeparator()
saveHistoryAction = subMenu.addAction(QCoreApplication.translate("PythonConsole",
"Save"),
self.writeHistoryFile)
subMenu.addSeparator()
clearHistoryAction = subMenu.addAction(QCoreApplication.translate("PythonConsole",
"Clear File"),
self.clearHistory)
clearSessHistoryAction = subMenu.addAction(QCoreApplication.translate("PythonConsole",
"Clear Session"),
self.clearHistorySession)
menu.addMenu(subMenu)
menu.addSeparator()
copyAction = menu.addAction(QCoreApplication.translate("PythonConsole",
"Copy"),
self.copy, QKeySequence.Copy)
pasteAction = menu.addAction(QCoreApplication.translate("PythonConsole",
"Paste"),
self.paste, QKeySequence.Paste)
copyAction.setEnabled(False)
pasteAction.setEnabled(False)
if self.hasSelectedText():
copyAction.setEnabled(True)
if QApplication.clipboard().text():
pasteAction.setEnabled(True)
action = menu.exec_(self.mapToGlobal(e.pos()))
def mousePressEvent(self, e):
"""
Re-implemented to handle the mouse press event.
e: the mouse press event (QMouseEvent)
"""
self.setFocus()
if e.button() == Qt.MidButton:
stringSel = unicode(QApplication.clipboard().text(QClipboard.Selection))
if not self.is_cursor_on_last_line():
self.move_cursor_to_end()
self.insertFromDropPaste(stringSel)
e.accept()
else:
QsciScintilla.mousePressEvent(self, e)
def paste(self):
"""
Method to display data from the clipboard.
XXX: It should reimplement the virtual QScintilla.paste method,
but it seems not used by QScintilla code.
"""
stringPaste = unicode(QApplication.clipboard().text())
if self.is_cursor_on_last_line():
if self.hasSelectedText():
self.removeSelectedText()
else:
self.move_cursor_to_end()
self.insertFromDropPaste(stringPaste)
## Drag and drop
def dropEvent(self, e):
if e.mimeData().hasText():
stringDrag = e.mimeData().text()
self.insertFromDropPaste(stringDrag)
self.setFocus()
e.setDropAction(Qt.CopyAction)
e.accept()
else:
QsciScintillaCompat.dropEvent(self, e)
def insertFromDropPaste(self, textDP):
pasteList = str(textDP).splitlines()
for line in pasteList[:-1]:
cleanLine = line.replace(">>> ", "").replace("... ", "")
self.insert(unicode(cleanLine))
self.move_cursor_to_end()
self.runCommand(unicode(self.currentCommand()))
if pasteList[-1] != "":
line = pasteList[-1]
cleanLine = line.replace(">>> ", "").replace("... ", "")
self.insert(unicode(cleanLine))
self.move_cursor_to_end()
def insertTextFromFile(self, listOpenFile):
for line in listOpenFile[:-1]:
self.append(line)
self.move_cursor_to_end()
self.SendScintilla(QsciScintilla.SCI_DELETEBACK)
self.runCommand(unicode(self.currentCommand()))
self.append(unicode(listOpenFile[-1]))
self.move_cursor_to_end()
self.SendScintilla(QsciScintilla.SCI_DELETEBACK)
def entered(self):
self.move_cursor_to_end()
self.runCommand( unicode(self.currentCommand()) )
self.setFocus()
self.move_cursor_to_end()
def currentCommand(self):
linenr, index = self.getCursorPosition()
txtLength = self.text(linenr).length()
string = self.text()
cmdLine = string.right(txtLength - 4)
cmd = unicode(cmdLine)
return cmd
def runCommand(self, cmd):
self.writeCMD(cmd)
import webbrowser
self.updateHistory(cmd)
if cmd in ('_pyqgis', '_api'):
if cmd == '_pyqgis':
webbrowser.open( "http://www.qgis.org/pyqgis-cookbook/" )
elif cmd == '_api':
webbrowser.open( "http://www.qgis.org/api/" )
if msgText:
self.parent.callWidgetMessageBar(msgText)
more = False
else:
self.buffer.append(cmd)
src = u"\n".join(self.buffer)
more = self.runsource(src, "<input>")
if not more:
self.buffer = []
## prevents to commands with more lines to break the console
## in the case they have a eol different from '\n'
self.setText('')
self.move_cursor_to_end()
self.displayPrompt(more)
def write(self, txt):
sys.stderr.write(txt)
def writeCMD(self, txt):
if len(txt) > 0:
getCmdString = self.text()
prompt = getCmdString[0:4]
sys.stdout.write(prompt+txt+'\n')
