def __init__(self, parent=None):
self.keywordFormat = text_format(Qt.blue, QFont.Bold)
self.stringFormat = text_format(Qt.darkGreen)
self.defFormat = text_format(Qt.black, QFont.Bold)
self.commentFormat = text_format(Qt.lightGray)
self.decoratorFormat = text_format(Qt.darkGray)
self.keywords = list(keyword.kwlist)
self.rules = [(QRegExp(r"\b%s\b" % kwd), self.keywordFormat)
for kwd in self.keywords] + \
[(QRegExp(r"\bdef\s+([A-Za-z_]+[A-Za-z0-9_]+)\s*\("),
self.defFormat),
(QRegExp(r"\bclass\s+([A-Za-z_]+[A-Za-z0-9_]+)\s*\("),
self.defFormat),
(QRegExp(r"'.*'"), self.stringFormat),
(QRegExp(r'".*"'), self.stringFormat),
(QRegExp(r"#.*"), self.commentFormat),
(QRegExp(r"@[A-Za-z_]+[A-Za-z0-9_]+"),
self.decoratorFormat)]
self.multilineStart = QRegExp(r"(''')|" + r'(""")')
self.multilineEnd = QRegExp(r"(''')|" + r'(""")')
super().__init__(parent)
def __init__(self, parent):
QSyntaxHighlighter.__init__(self, parent)
self._multiLineCommentFormat = QTextCharFormat()
self._multiLineCommentFormat.setForeground(Qt.lightGray)
self._commentStartExpression = QRegExp("/\\*")
self._commentEndExpression = QRegExp("\\*/")
self.createKeywords()
self.createOperators()
self.createStrings()
self.createArrows()
self.createComments()
def highlightBlock(self, text):
for pattern, fmt in self.rules:
exp = QRegExp(pattern)
index = exp.indexIn(text)
while index >= 0:
length = exp.matchedLength()
if exp.captureCount() > 0:
self.setFormat(exp.pos(1), len(str(exp.cap(1))), fmt)
else:
self.setFormat(exp.pos(0), len(str(exp.cap(0))), fmt)
index = exp.indexIn(text, index + length)
# Multi line strings
start = self.multilineStart
end = self.multilineEnd
self.setCurrentBlockState(0)
startIndex, skip = 0, 0
if self.previousBlockState() != 1:
startIndex, skip = start.indexIn(text), 3
while startIndex >= 0:
endIndex = end.indexIn(text, startIndex + skip)
if endIndex == -1:
self.setCurrentBlockState(1)
commentLen = len(text) - startIndex
else:
commentLen = endIndex - startIndex + 3
self.setFormat(startIndex, commentLen, self.stringFormat)
startIndex, skip = (start.indexIn(text,
startIndex + commentLen + 3), 3)
def popup(self, pos=None, searchText=""):
"""
Popup the menu at `pos` (in screen coordinates). 'Search' text field
is initialized with `searchText` if provided.
"""
if pos is None:
pos = QPoint()
self.__clearCurrentItems()
self.__search.setText(searchText)
patt = QRegExp("(^|\W)" + searchText)
patt.setCaseSensitivity(False)
self.__suggestPage.setFilterRegExp(patt)
self.ensurePolished()
if self.testAttribute(Qt.WA_Resized) and self.sizeGripEnabled():
size = self.size()
else:
size = self.sizeHint()
desktop = QApplication.desktop()
screen_geom = desktop.availableGeometry(pos)
# Adjust the size to fit inside the screen.
if size.height() > screen_geom.height():
size.setHeight(screen_geom.height())
if size.width() > screen_geom.width():
size.setWidth(screen_geom.width())
geom = QRect(pos, size)
if geom.top() < screen_geom.top():
geom.setTop(screen_geom.top())
if geom.left() < screen_geom.left():
geom.setLeft(screen_geom.left())
bottom_margin = screen_geom.bottom() - geom.bottom()
right_margin = screen_geom.right() - geom.right()
if bottom_margin < 0:
# Falls over the bottom of the screen, move it up.
geom.translate(0, bottom_margin)
# TODO: right to left locale
if right_margin < 0:
# Falls over the right screen edge, move the menu to the
# other side of pos.
geom.translate(-size.width(), 0)
self.setGeometry(geom)
self.show()
if searchText:
self.setFocusProxy(self.__search)
else:
self.setFocusProxy(None)
def createKeywords(self):
keywordFormat = QTextCharFormat()
keywordFormat.setForeground(QColor(64, 155, 11))
keywords = [
'\\babstract\\b', '\\bas\\b', '\\bbase\\b', '\\bbool\\b',
'\\bbreak\\b', '\\bbyte\\b', '\\bcase\\b', '\\bcatch\\b',
'\\bchar\\b', '\\bchecked\\b', '\\bclass\\b', '\\bconst\\b',
'\\bcontinue\\b', '\\bdecimal\\b', '\\bdefault\\b',
'\\bdelegate\\b', '\\bif\\b', '\\bimplicit\\b', '\\bin\\b',
'\\bdo\\b', '\\bdouble\\b', '\\bint\\b', '\\binterface\\b',
'\\belse\\b', '\\benum\\b', '\\bevent\\b', '\\bexplicit\\b',
'\\bextern\\b', '\\bfalse\\b', '\\btrue\\b', '\\binternal\\b',
'\\bfinally\\b', '\\bfixed\\b', '\\bfloat\\b', '\\bfor\\b',
'\\bforeach\\b', '\\bgoto\\b', '\\bis\\b', '\\block\\b',
'\\blong\\b', '\\bnamepsace\\b', '\\bnew\\b', '\\bnull\\b',
'\\bobject\\b', '\\boperator\\b', '\\bout\\b', '\\boverride\\b',
'\\bparams\\b', '\\bprivate\\b', '\\bprotected\\b', '\\bpublic\\b',
'\\breadonly\\b', '\\bref\\b', '\\breturn\\b', '\\bsbyte\\b',
'\\bsealed\\b', '\\bshort\\b', '\\bsizeof\\b', '\\bstackalloc\\b',
'\\bstatic\\b', '\\bstring\\b', '\\bstruct\\b', '\\bswitch\\b',
'\\bthis\\b', '\\bthrow\\b', '\\btry\\b', '\\btypeof\\b',
'\\buint\\b', '\\bulong\\b', '\\bunchecked\\b', '\\bunsafe\\b',
'\\bushort\\b', '\\busing\\b', '\\bvirtual\\b', '\\bvoid\\b',
'\\bvolatile\\b', '\\bwhile\\b', '\\bpackage\\b', '\\bimport\\b',
'\\bthrows\\b'
]
self.highlightingRules = [(QRegExp(pattern), keywordFormat)
for pattern in keywords]
def __on_textEdited(self, text):
patt = QRegExp("(^|\W)" + text)
patt.setCaseSensitivity(False)
self.__suggestPage.setFilterRegExp(patt)
self.__pages.setCurrentPage(self.__suggestPage)
self.__selectFirstIndex()
UsageStatistics.set_last_search_query(text)
def _filter_table_variables(self):
regex = QRegExp(self.filter_string)
# If the user explicitly types different cases, we assume they know
# what they are searching for and account for letter case in filter
different_case = (any(c.islower() for c in self.filter_string)
and any(c.isupper() for c in self.filter_string))
if not different_case:
regex.setCaseSensitivity(Qt.CaseInsensitive)
def __on_textEdited(self, text):
# type: (str) -> None
patt = QRegExp(r"(^|\W)" + text)
patt.setCaseSensitivity(Qt.CaseInsensitive)
self.__suggestPage.setFilterRegExp(patt)
self.__pages.setCurrentPage(self.__suggestPage)
self.__selectFirstIndex()
UsageStatistics.set_last_search_query(text)
def createClassVariables(self):
keywordFormat = QTextCharFormat()
keywordFormat.setForeground(QColor(223, 109, 209))
keywords = ['self', '__init__']
self.highlightingRules.extend([(QRegExp(pattern), keywordFormat)
for pattern in keywords])
def createOperators(self):
operatorFormat = QTextCharFormat()
operatorFormat.setForeground(Qt.blue)
operators = ['\\+', '-', '/', '\\*', '(', ')', '[', ']', '{', '}']
self.highlightingRules.extend([(QRegExp(pattern), operatorFormat)
for pattern in operators])
def __init__(self, tree, dataset, master, parent=None):
QLineEdit.__init__(self, parent)
Control.__init__(self, tree, dataset, master)
if hasattr(tree, "regexp"):
self.setValidator(QRegExpValidator(QRegExp(tree.regexp), self))
if hasattr(tree, "defaultValue"):
self.setText(tree.defaultValue)
def createOperators(self):
operatorFormat = QTextCharFormat()
operatorFormat.setForeground(QColor(148, 99, 233))
operatorFormat.setFontWeight(QFont.Bold)
operators = [
'\\+', '-', '/', '\\*', '=', '==', '!=', '<=', '>=', '<', '>'
]
self.highlightingRules.extend([(QRegExp(pattern), operatorFormat)
for pattern in operators])
def createKeywords(self):
keywordFormat = QTextCharFormat()
keywordFormat.setForeground(QColor(64, 155, 11))
keywords = [
'\\bchar\\b', '\\bclass\\b', '\\bconst\\b', '\\bdouble\\b',
'\\benum\\b', '\\bexplicit\\b', '\\bfriend\\b', '\\binline\\b',
'\\bint\\b', '\\blong\\b', '\\bnamespace\\b', '\\boperator\\b',
'\\bprivate\\b', '\\bprotected\\b', '\\bpublic\\b', '\\bshort\\b',
'\\bfloat\\b', '\\bbool\\b', '\\bsignals\\b', '\\bsigned\\b',
'\\bslots\\b', '\\bstatic\\b', '\\bstruct\\b', '\\btemplate\\b',
'\\btypedef\\b', '\\btypename\\b', '\\bunion\\b', '\\bunsigned\\b',
'\\bvirtual\\b', '\\bvoid\\b', '\\bvolatile\\b'
]
self.highlightingRules = [(QRegExp(pattern), keywordFormat)
for pattern in keywords]
def createKeywords(self):
keywordFormat = QTextCharFormat()
keywordFormat.setForeground(Qt.darkBlue)
keywordFormat.setFontWeight(QFont.Bold)
keywords = [
'\\band\\b', '\\bdel\\b', '\\bfor\\b', '\\bas\\b', '\\bassert\\b',
'\\bbreak\\b', '\\bclass\\b', '\\bcontinue\\b', '\\bdef\\b',
'\\belif\\b', '\\belse\\b', '\\bexcept\\b', '\\bexec\\b',
'\\bFalse\\b', '\\bfinally\\b', '\\bfrom\\b', '\\bglobal\\b',
'\\bif\\b', '\\bimport\\b', '\\bin\\b', '\\bis\\b', '\\blambda\\b',
'\\bNone\\b', '\\bnonlocal\\b', '\\bnot\\b', '\bor\b',
'\\bpass\\b', '\\bprint\\b', '\\braise\\b', '\\breturn\\b',
'\\bTrue\\b', '\\btry\\b', '\\bwhile\\b', '\\bwith\\b',
'\\byield\\b', '<', '<=', '>', '>=', '==', '!='
]
self.highlightingRules = [(QRegExp(pattern), keywordFormat)
for pattern in keywords]
def add_datetime(contents):
le = add_textual(contents)
le.setValidator(QRegExpValidator(QRegExp(TimeVariable.REGEX)))
return le
def createComments(self):
singleLineCommentFormat = QTextCharFormat()
singleLineCommentFormat.setForeground(Qt.gray)
self.highlightingRules.append(
(QRegExp('//[^\n]*'), singleLineCommentFormat))
def createArrows(self):
arrowFormat = QTextCharFormat()
arrowFormat.setForeground(Qt.red)
arrows = ['<-', '->']
self.highlightingRules.extend([(QRegExp(pattern), arrowFormat)
for pattern in arrows])
def createStrings(self):
stringFormat = QTextCharFormat()
stringFormat.setForeground(Qt.lightGray)
self.highlightingRules.append((QRegExp('\".*\"'), stringFormat))
self.highlightingRules.append((QRegExp('\'.*\''), stringFormat))
def __on_textEdited(self, text):
patt = QRegExp("(^|\W)" + text)
patt.setCaseSensitivity(False)
self.__suggestPage.setFilterRegExp(patt)
self.__pages.setCurrentPage(self.__suggestPage)
def createAnnotations(self):
annotationFormat = QTextCharFormat()
annotationFormat.setForeground(QColor(108, 204, 255))
self.highlightingRules.append((QRegExp('@[^\n]*'), annotationFormat))
