我写了一个小的 Python PyQt4 程序来语法高亮 QPlainTextEdit 字段中的 MySQL 源代码。以下代码用于正确地对 MySQL 文本进行颜色编码。
如果有人编辑明文字段，我如何自动更新文本颜色？ 任何帮助或建议表示赞赏。
import sys, time
from PyQt4 import QtCore, QtGui
import syntax
class MyApp(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setGeometry(300, 300, 410, 220)
self.setWindowTitle('MySQL Source Color Coding')
self.layout = QtGui.QVBoxLayout(self)
self.plaintext = QtGui.QPlainTextEdit()
self.plaintext.setFont(QtGui.QFont ("Consolas", 9))
self.plaintext.setLineWrapMode(QtGui.QPlainTextEdit.NoWrap)
x = syntax.PythonHighlighter(self.plaintext.document())
self.layout.addWidget(self.plaintext)
mysqlcode = """\
select dt as 'Date',
dayName as "Day",
count(create_date) as 'Transaction Count'
from calendar
left join transaction
on dt = date(create_date)
where dt <= NOW()
and dt >= '2015-07-21'
group by dt
order by dt desc;
"""
self.plaintext.setPlainText(mysqlcode)
if __name__ == "__main__":
app = QtGui.QApplication(sys.argv)
window = MyApp()
window.show()
app.exec_()
语法.py
import sys
from PyQt4.QtCore import QRegExp
from PyQt4.QtGui import QColor, QTextCharFormat, QFont, QSyntaxHighlighter
def format(color, style=''):
"""Return a QTextCharFormat with the given attributes.
"""
_color = QColor()
_color.setNamedColor(color)
_format = QTextCharFormat()
_format.setForeground(_color)
if 'bold' in style:
_format.setFontWeight(QFont.Bold)
if 'italic' in style:
_format.setFontItalic(True)
return _format
# Syntax styles that can be shared by all languages
STYLES = {
'keyword': format('blue'),
'operator': format('darkred'),
'brace': format('black','bold'),
'defclass': format('black', 'bold'),
'string': format('darkGreen'),
'string2': format('darkMagenta'),
'comment': format('Grey', 'italic'),
'self': format('black', 'italic'),
'numbers': format('darkMagenta'),
}
class PythonHighlighter (QSyntaxHighlighter):
"""Syntax highlighter for the mysql language.
"""
# mysql keywords
keywords = [
"use", "select", "as", "then", "case", "end",
"from", "where", "group by", "order by", "desc", "asc",
"distinct", "on", "left join", "right join", "count",
"sum", "max", "min","distinct", "and", "in", "or",
"date","NOW", "like",
]
# Python operators
operators = [
"&&", "between", "binary", "&",
"\\^", "=", ">=", ">",
"is null", "null", "<=", "<",
" like ", "regexp", "not", ";",",",
]
# Python braces
braces = [
'\{', '\}', '\(', '\)', '\[', '\]',
]
def __init__(self, document):
QSyntaxHighlighter.__init__(self, document)
print "QSyntaxHighlighter"
# Multi-line strings (expression, flag, style)
# FIXME: The triple-quotes in these two lines will mess up the
# syntax highlighting from this point onward
self.tri_single = (QRegExp("'''"), 1, STYLES['string2'])
self.tri_double = (QRegExp('"""'), 2, STYLES['string2'])
rules = []
# Keyword, operator, and brace rules
rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
for w in PythonHighlighter.keywords]
rules += [(r'%s' % o, 0, STYLES['operator'])
for o in PythonHighlighter.operators]
rules += [(r'%s' % b, 0, STYLES['brace'])
for b in PythonHighlighter.braces]
# All other rules
rules += [
# 'self'
(r'\bself\b', 0, STYLES['self']),
# Double-quoted string, possibly containing escape sequences
(r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
# Single-quoted string, possibly containing escape sequences
(r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']),
# 'def' followed by an identifier
(r'\bdef\b\s*(\w+)', 1, STYLES['defclass']),
# 'class' followed by an identifier
(r'\bclass\b\s*(\w+)', 1, STYLES['defclass']),
# From '#' until a newline
(r'#[^\n]*', 0, STYLES['comment']),
# Numeric literals
(r'\b[+-]?[0-9]+[lL]?\b', 0, STYLES['numbers']),
(r'\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b', 0, STYLES['numbers']),
(r'\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b', 0, STYLES['numbers']),
]
# Build a QRegExp for each pattern
self.rules = [(QRegExp(pat), index, fmt)
for (pat, index, fmt) in rules]
def highlightBlock(self, text):
print "highlightBlock"
"""Apply syntax highlighting to the given block of text.
"""
# Do other syntax formatting
for expression, nth, format in self.rules:
index = expression.indexIn(text, 0)
while index >= 0:
# We actually want the index of the nth match
index = expression.pos(nth)
length = expression.cap(nth).length()
self.setFormat(index, length, format)
index = expression.indexIn(text, index + length)
self.setCurrentBlockState(0)
# Do multi-line strings
in_multiline = self.match_multiline(text, *self.tri_single)
if not in_multiline:
in_multiline = self.match_multiline(text, *self.tri_double)
def match_multiline(self, text, delimiter, in_state, style):
"""Do highlighting of multi-line strings. ``delimiter`` should be a
``QRegExp`` for triple-single-quotes or triple-double-quotes, and
``in_state`` should be a unique integer to represent the corresponding
state changes when inside those strings. Returns True if we're still
inside a multi-line string when this function is finished.
"""
# If inside triple-single quotes, start at 0
if self.previousBlockState() == in_state:
start = 0
add = 0
# Otherwise, look for the delimiter on this line
else:
start = delimiter.indexIn(text)
# Move past this match
add = delimiter.matchedLength()
# As long as there's a delimiter match on this line...
while start >= 0:
# Look for the ending delimiter
end = delimiter.indexIn(text, start + add)
# Ending delimiter on this line?
if end >= add:
length = end - start + add + delimiter.matchedLength()
self.setCurrentBlockState(0)
# No; multi-line string
else:
self.setCurrentBlockState(in_state)
length = text.length() - start + add
# Apply formatting
self.setFormat(start, length, style)
# Look for the next match
start = delimiter.indexIn(text, start + length)
# Return True if still inside a multi-line string, False otherwise
if self.currentBlockState() == in_state:
return True
else:
return False
我在以下位置找到了一个很好的如何使用 QSyntaxHighlighter 的示例：
http://carsonfarmer.com/2009/07/syntax-highlighting-with-pyqt/
Carson Farmer 的 QSyntaxHighlighter 实现效果很好，当用户修改文本字段时自动更新语法颜色编码。
'''
Python Syntax Highlighting Example
Copyright (C) 2009 Carson J. Q. Farmer
'''
import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *
class MyHighlighter( QSyntaxHighlighter ):
def __init__( self, parent, theme ):
QSyntaxHighlighter.__init__( self, parent )
self.parent = parent
keyword = QTextCharFormat()
reservedClasses = QTextCharFormat()
assignmentOperator = QTextCharFormat()
delimiter = QTextCharFormat()
specialConstant = QTextCharFormat()
boolean = QTextCharFormat()
number = QTextCharFormat()
comment = QTextCharFormat()
string = QTextCharFormat()
singleQuotedString = QTextCharFormat()
self.highlightingRules = []
# keyword
brush = QBrush( Qt.darkBlue, Qt.SolidPattern )
keyword.setForeground( brush )
keyword.setFontWeight( QFont.Bold )
keywords = QStringList( [ "break", "else", "for", "if", "in",
"next", "repeat", "return", "switch",
"try", "while" ] )
for word in keywords:
pattern = QRegExp("\\b" + word + "\\b")
rule = HighlightingRule( pattern, keyword )
self.highlightingRules.append( rule )
# reservedClasses
reservedClasses.setForeground( brush )
reservedClasses.setFontWeight( QFont.Bold )
keywords = QStringList( [ "array", "character", "complex",
"data.frame", "double", "factor",
"function", "integer", "list",
"logical", "matrix", "numeric",
"vector" ] )
for word in keywords:
pattern = QRegExp("\\b" + word + "\\b")
rule = HighlightingRule( pattern, reservedClasses )
self.highlightingRules.append( rule )
# assignmentOperator
brush = QBrush( Qt.yellow, Qt.SolidPattern )
pattern = QRegExp( "(<){1,2}-" )
assignmentOperator.setForeground( brush )
assignmentOperator.setFontWeight( QFont.Bold )
rule = HighlightingRule( pattern, assignmentOperator )
self.highlightingRules.append( rule )
# delimiter
pattern = QRegExp( "[\)\(]+|[\{\}]+|[][]+" )
delimiter.setForeground( brush )
delimiter.setFontWeight( QFont.Bold )
rule = HighlightingRule( pattern, delimiter )
self.highlightingRules.append( rule )
# specialConstant
brush = QBrush( Qt.green, Qt.SolidPattern )
specialConstant.setForeground( brush )
keywords = QStringList( [ "Inf", "NA", "NaN", "NULL" ] )
for word in keywords:
pattern = QRegExp("\\b" + word + "\\b")
rule = HighlightingRule( pattern, specialConstant )
self.highlightingRules.append( rule )
# boolean
boolean.setForeground( brush )
keywords = QStringList( [ "TRUE", "FALSE" ] )
for word in keywords:
pattern = QRegExp("\\b" + word + "\\b")
rule = HighlightingRule( pattern, boolean )
self.highlightingRules.append( rule )
# number
pattern = QRegExp( "[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?" )
pattern.setMinimal( True )
number.setForeground( brush )
rule = HighlightingRule( pattern, number )
self.highlightingRules.append( rule )
# comment
brush = QBrush( Qt.blue, Qt.SolidPattern )
pattern = QRegExp( "#[^\n]*" )
comment.setForeground( brush )
rule = HighlightingRule( pattern, comment )
self.highlightingRules.append( rule )
# string
brush = QBrush( Qt.red, Qt.SolidPattern )
pattern = QRegExp( "\".*\"" )
pattern.setMinimal( True )
string.setForeground( brush )
rule = HighlightingRule( pattern, string )
self.highlightingRules.append( rule )
# singleQuotedString
pattern = QRegExp( "\'.*\'" )
pattern.setMinimal( True )
singleQuotedString.setForeground( brush )
rule = HighlightingRule( pattern, singleQuotedString )
self.highlightingRules.append( rule )
def highlightBlock( self, text ):
for rule in self.highlightingRules:
expression = QRegExp( rule.pattern )
index = expression.indexIn( text )
while index >= 0:
length = expression.matchedLength()
self.setFormat( index, length, rule.format )
index = text.indexOf( expression, index + length )
self.setCurrentBlockState( 0 )
class HighlightingRule():
def __init__( self, pattern, format ):
self.pattern = pattern
self.format = format
class TestApp( QMainWindow ):
def __init__(self):
QMainWindow.__init__(self)
font = QFont()
font.setFamily( "Courier" )
font.setFixedPitch( True )
font.setPointSize( 10 )
editor = QTextEdit()
editor.setFont( font )
highlighter = MyHighlighter( editor, "Classic" )
self.setCentralWidget( editor )
self.setWindowTitle( "Syntax Highlighter" )
if __name__ == "__main__":
app = QApplication( sys.argv )
window = TestApp()
window.show()
sys.exit( app.exec_() )
工作正常。只需要改变
index = text.indexOf( 表达式, 索引 + 长度 )
至：
index = expression.indexIn( text, index + length )