Example #1
0
    def __init__(self, document, lang):
        QSyntaxHighlighter.__init__(self, document)
        langSyntax = loader.syntax[lang]
        Highlighter.keywords = langSyntax.get('keywords', [])
        Highlighter.braces = langSyntax.get('brace', [])
        Highlighter.operators = langSyntax.get('operators', [])

        rules = []

        # Keyword, operator, and brace rules
        rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
            for w in Highlighter.keywords]
        rules += [(r'%s' % o, 0, STYLES['operator'])
            for o in Highlighter.operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
            for b in Highlighter.braces]

        # All other rules
        proper = langSyntax.get('properObject', None)
        if proper is not None:
            proper = '\\b' + str(proper[0]) + '\\b'
            rules += [
                # 'self'
                (proper, 0, STYLES['properObject'])]

        rules.append((r'__\w+__', 0, STYLES['properObject']))
            
        definition = langSyntax.get('definition', [])
        for de in definition:
            expr = '\\b' + de + '\\b\\s*(\\w+)'
            rules.append((expr, 1, STYLES['definition']))

        rules += [
            # 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']),
        ]

        stringChar = langSyntax.get('string', [])
        for sc in stringChar:
            expr = r'"[^"\\]*(\\.[^"\\]*)*"' if sc == '"' else r"'[^'\\]*(\\.[^'\\]*)*'"
            rules.append((expr, 0, STYLES['string']))

        # 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'])    #"""

        comments = langSyntax.get('comment', [])
        for co in comments:
            expr = co + '[^\\n]*'
            rules.append((expr, 0, STYLES['comment']))

        rules.append(('\s+', 0, STYLES['spaces']))

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
            for (pat, index, fmt) in rules]
Example #2
0
    def __init__(self, parent=None):
        QSyntaxHighlighter.__init__(self, parent)
        self.parent = parent
        sqlKeyword = QTextCharFormat()
        sqlOperator = QTextCharFormat()

        self.highlightingRules = []

        #Keywords
        sqlKeyword.setFontWeight(QFont.Bold)
        sqlKeyword.setForeground(Qt.blue)

        sqlKeywords = ["AND", "OR", "LIKE"]
        for word in sqlKeywords:
            regExp = QRegExp("\\b" + word + "\\b", Qt.CaseInsensitive)
            rule = HighlightingRule(regExp, sqlKeyword)
            self.highlightingRules.append(rule)

        #Comparison Operators
        sqlOperator.setForeground(Qt.magenta)
        sqlOperators = ["<", ">", "="]
        for operator in sqlOperators:
            regExp = QRegExp("\\W" + operator + "\\W", Qt.CaseInsensitive)
            rule = HighlightingRule(regExp, sqlOperator)
            self.highlightingRules.append(rule)
Example #3
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # 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 = []
        rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
            for w in Python.keywords]
        rules += [(r'%s' % o, 0, STYLES['operator'])
            for o in Python.operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
            for b in Python.braces]
        rules += [
            # 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']),
        ]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
            for (pat, index, fmt) in rules]
Example #4
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        rules = [
            (r'=', 0, STYLES['operator']),
            (r'\b[YN]\b', 0, STYLES['numbers']),

            # Double-quoted string, possibly containing escape sequences
            (r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
            # Single-quoted string, possibly containing escape sequences
            (r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']),

            # Numeric literals
            (r'\b[+-]?[0-9]+\b', 0, STYLES['numbers']),
            (r'\b[+-]?0[xX][0-9A-Fa-f]+\b', 0, STYLES['numbers']),
            (r'\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b', 0,
             STYLES['numbers']),

            # From '#' until a newline
            (r'#[^\n]*', 0, STYLES['comment']),
            (r'^\[.+\]', 0, STYLES['section']),
            (r'^[a-zA-Z0-9_-]+\s?=', 0, STYLES['key']),
        ]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
                      for (pat, index, fmt) in rules]
Example #5
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        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]

        rules += [
            (r'\bself\b', 0, STYLES['self']),
            (r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
            (r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']),

            (r'\bdef\b\s*(\w+)', 1, STYLES['defclass']),
            (r'\bclass\b\s*(\w+)', 1, STYLES['defclass']),

            (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']),
        ]

        self.rules = [(QRegExp(pat), index, fmt)
            for (pat, index, fmt) in rules]
Example #6
0
 def __init__(self, doc, *args, **kwargs):
     QSyntaxHighlighter.__init__(self, doc)
     for attr, val in default_colors.items():
         setattr(self, attr, val)
     self._rules = []
     self.enabled = True
     self.generate_rules()
Example #7
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        rules = []

        # LaTeX in-line math brace
        rules += [(r'%s' % b, 0, STYLES['brace'])
                  for b in LaTeXHighlighter.braces]
        # LaTeX in-line math brace
        rules += [(r'%s' % mb, 0, STYLES['mathbrace'])
                  for mb in LaTeXHighlighter.mathbrace]

        # All other rules
        rules += [
            # \ "something" ends with { or [ or white space - for environments and others
            # e.g. \begin{}, \something[]{} \texbf etc
            (r'[\\](?:(?![ \{ | \[ | \s ]).)*', 0, STYLES['environment']),
            (r'\\end', 0, STYLES['environment']),

            # LaTeX in-line math braces
            (r'\\\[', 0, STYLES['mathbrace']),
            (r'\\\]', 0, STYLES['mathbrace']),

            (r'\\\(', 0, STYLES['mathbrace']),
            (r'\\\)', 0, STYLES['mathbrace']),


            # From '%' until a newline - Commment
            (r'\%[^\n]*', 0, STYLES['comment']),

        ]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
                      for (pat, index, fmt) in rules]
Example #8
0
    def __init__(self, parent=None):
        QSyntaxHighlighter.__init__(self, parent)
        self.parent = parent
        sqlKeyword = QTextCharFormat()
        sqlOperator = QTextCharFormat()

        self.highlightingRules = []

        # Keywords
        sqlKeyword.setFontWeight(QFont.Bold)
        sqlKeyword.setForeground(Qt.blue)

        sqlKeywords = ["AND", "OR", "LIKE"]
        for word in sqlKeywords:
            regExp = QRegExp("\\b" + word + "\\b", Qt.CaseInsensitive)
            rule = HighlightingRule(regExp, sqlKeyword)
            self.highlightingRules.append(rule)

        # Comparison Operators
        sqlOperator.setForeground(Qt.magenta)
        sqlOperators = ["<", ">", "="]
        for operator in sqlOperators:
            regExp = QRegExp("\\W" + operator + "\\W", Qt.CaseInsensitive)
            rule = HighlightingRule(regExp, sqlOperator)
            self.highlightingRules.append(rule)
Example #9
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # 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 = []
        rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
            for w in Python.keywords]
        rules += [(r'%s' % o, 0, STYLES['operator'])
            for o in Python.operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
            for b in Python.braces]
        rules += [
            # 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']),
        ]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
            for (pat, index, fmt) in rules]
Example #10
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        rules = []
        rules += [(r'%s' % p, 0, 'phpBlock')
                for p in self.phpBlock]

        rules += [(r'%s' % k, 0, 'keywords')
                for k in self.keywords]

        rules += [(r'%s' % f, 0, 'functions')
                for f in self.functions]

        # $variables
        rules += [(r'\$[\w]*', 0, 'variables')]

        # comments
        rules += [(r'#[^\n]*', 0, 'comments')]
        rules += [(r'//[^\n]*', 0, 'comments')]
        rules += [(r'/\*+.*\*+/', 0, 'comments')]

        # strings
        rules += [(r'".*"', 0, 'strings')]
        rules += [(r"'.*'", 0, 'strings')]

        self.rules = [(QRegExp(pat), index, format)
                    for(pat, index, format) in rules]
Example #11
0
    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'(""")')

        QSyntaxHighlighter.__init__(self, parent)
Example #12
0
 def __init__(self, doc, *args, **kwargs):
     QSyntaxHighlighter.__init__(self, doc)
     for attr, val in default_colors.items():
         setattr(self, attr, val)
     self._rules = []
     self.enabled = True
     self.generate_rules()
Example #13
0
    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'(""")')

        QSyntaxHighlighter.__init__(self, parent)
Example #14
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # 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'%s' % o, 0, STYLES['operator']) for o in self.operators]
        rules += [(r'%s' % b, 0, STYLES['brace']) for b in self.braces]
        rules += [(r'\b%s\b' % w, 0, STYLES['keyword']) for w in self.keywords]

        # All other rules
        rules += [

            # From '#' until a newline
            (r':[^(\n|;|\})]*', 0, STYLES['value']),
            (r'\/\*(.*)\*\/*', 0, STYLES['comment']),

            # Double-quoted string, possibly containing escape sequences
            (r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
            # Single-quoted string, possibly containing escape sequences
            (r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']),
        ]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
                      for (pat, index, fmt) in rules]
Example #15
0
	def __init__(self, parent = None, theme = None, prefix = ''):
		QSyntaxHighlighter.__init__(self, parent)
		self.rules = []
		self.prefix = prefix

		kwFormat = QTextCharFormat()
		kwFormat.setForeground( Qt.blue )
		#kwFormat.setFontWeight( QFont.Bold )

		quoteFormat = QTextCharFormat()
		quoteFormat.setForeground( Qt.red )

		commentFormat = QTextCharFormat()
		commentFormat.setForeground( Qt.darkGray )

		keywords = ["and", "del", "for", "is", "raise",
					"assert", "elif", "from", "lambda",
					"break", "else", "global", "not", "try",
					"class", "except", "if", "or", "while",
					"continue", "exec", "import", "pass", "yield",
					"def", "finally", "in", "print", "self"
					]

		for kw in keywords:
			self.rules.append( (QRegExp("\\b" + kw + "\\b"), kwFormat) )

		self.rules.append( (QRegExp(r'"(?:[^"\\]|\\.)*"'), quoteFormat) )
		self.rules.append( (QRegExp(r"'(?:[^\']+|\.)*'"), quoteFormat) )

		self.rules.append( (QRegExp(r"#.*$"), commentFormat) )
Example #16
0
 def __init__(self, document, lang=None, scheme=None,
   errors=None, pep8=None):
     QSyntaxHighlighter.__init__(self, document)
     self.errors = errors
     self.pep8 = pep8
     if lang is not None:
         self.apply_highlight(lang, scheme)
Example #17
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        self.clb = ConfigurationLineBuilder(ErtKeywords())


        self.comment_format = QTextCharFormat()
        self.comment_format.setForeground(QColor(0, 128, 0))
        self.comment_format.setFontItalic(True)

        self.keyword_format = QTextCharFormat()
        self.keyword_format.setForeground(QColor(200, 100, 0))
        # self.keyword_format.setFontWeight(QFont.Bold)

        self.error_format = QTextCharFormat()
        # self.error_format.setForeground(QColor(255, 0, 0))
        self.error_format.setUnderlineStyle(QTextCharFormat.WaveUnderline)
        self.error_format.setUnderlineColor(QColor(255, 0, 0))

        self.search_format = QTextCharFormat()
        self.search_format.setBackground(QColor(220, 220, 220))

        self.builtin_format = QTextCharFormat()
        self.builtin_format.setForeground(QColor(0, 170, 227))

        self.search_string = ""
Example #18
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        self.clb = ConfigurationLineBuilder(ErtKeywords())

        self.comment_format = QTextCharFormat()
        self.comment_format.setForeground(QColor(0, 128, 0))
        self.comment_format.setFontItalic(True)

        self.keyword_format = QTextCharFormat()
        self.keyword_format.setForeground(QColor(200, 100, 0))
        # self.keyword_format.setFontWeight(QFont.Bold)

        self.error_format = QTextCharFormat()
        # self.error_format.setForeground(QColor(255, 0, 0))
        self.error_format.setUnderlineStyle(QTextCharFormat.WaveUnderline)
        self.error_format.setUnderlineColor(QColor(255, 0, 0))

        self.search_format = QTextCharFormat()
        self.search_format.setBackground(QColor(220, 220, 220))

        self.builtin_format = QTextCharFormat()
        self.builtin_format.setForeground(QColor(0, 170, 227))

        self.search_string = ""
Example #19
0
 def __init__(self, document):
     QSyntaxHighlighter.__init__(self, document)
     self._fridge = ly.lex.Fridge()
     app.settingsChanged.connect(self.rehighlight)
     self._highlighting = metainfo.info(document).highlighting
     document.loaded.connect(self._resetHighlighting)
     self._mode = documentinfo.mode(document, False)
     variables.manager(document).changed.connect(self._variablesChange)
Example #20
0
 def __init__(self, document):
     QSyntaxHighlighter.__init__(self, document)
     self._fridge = ly.lex.Fridge()
     app.settingsChanged.connect(self.rehighlight)
     self._initialState = None
     self._highlighting = True
     self._mode = None
     self.initializeDocument()
Example #21
0
 def __init__(self, document):
     QSyntaxHighlighter.__init__(self, document)
     self._fridge = ly.lex.Fridge()
     app.settingsChanged.connect(self.rehighlight)
     self._initialState = None
     self._highlighting = True
     self._mode = None
     self.initializeDocument()
Example #22
0
 def __init__(self, document, lang=None, scheme=None, errors=None, pep8=None):
     QSyntaxHighlighter.__init__(self, document)
     self.highlight_function = self.realtime_highlight
     self.errors = errors
     self.pep8 = pep8
     self.selected_word_lines = []
     self.visible_limits = (0, 50)
     if lang is not None:
         self.apply_highlight(lang, scheme)
 def __init__(self, widget):
     QSyntaxHighlighter.__init__(self, widget)
     self.regex = None
     # create format type
     self.odd_format = QTextCharFormat()
     self.odd_format.setFontWeight(QFont.Bold)
     self.odd_format.setForeground(Qt.darkBlue)
     self.even_format = QTextCharFormat()
     self.even_format.setFontWeight(QFont.Bold)
     self.even_format.setForeground(Qt.darkMagenta)
Example #24
0
 def __init__(self, document, lang=None, scheme=None,
   errors=None, pep8=None):
     QSyntaxHighlighter.__init__(self, document)
     self.highlight_function = self.realtime_highlight
     self.errors = errors
     self.pep8 = pep8
     self.selected_word_lines = []
     self.visible_limits = (0, 50)
     if lang is not None:
         self.apply_highlight(lang, scheme)
Example #25
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # 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']),

            # From replace
            (r'^#define', 0, STYLES['perso']),
            # From perso
            (r'\*\*\w+\*\*', 0, STYLES['replace']),
            # From qsub
            (r'qsub[^\n]*', 0, STYLES['replace']),


            # 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]
Example #26
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # 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'\b%s\b' % w, 0, STYLES['keyword2'])
                  for w in PythonHighlighter.keywords2]
        rules += [(r'\b%s\b' % w, 0, STYLES['datatype'])
                  for w in PythonHighlighter.datatypes]
        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']),

            # Multi-line comments - This needs to be a single rule
            (r'/\*', 0, STYLES['comment']),
            (r'\*[^\n]*', 0, STYLES['comment']),
            (r'\*/', 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]
Example #27
0
    def __init__(self, edit):
        self.textedit = edit
        document = edit.document()
        QSyntaxHighlighter.__init__(self, document)

        base_format = QTextCharFormat()
        base_format.setFont(edit.font())
        self.base_format = base_format
        self.document = document

        self.updateHighlighter(base_format.font())
Example #28
0
	def __init__(self,name,document):
		self.init= False
		self.name = name
		self.entities=[]
		self.initialized=False
		self.styles=[]
		self.blocks=[]
		self.braces = QRegExp('(\{|\}|\(|\)|\[|\])')
		self.font=QFont()
		self.Default=0
		QSyntaxHighlighter.__init__(self,document)
Example #29
0
    def __init__(self, edit):
        self.textedit = edit
        document = edit.document()
        QSyntaxHighlighter.__init__(self, document)

        base_format = QTextCharFormat()
        base_format.setFont(edit.font())
        self.base_format = base_format
        self.document = document
        
        self.updateHighlighter(base_format.font())
Example #30
0
  def __init__(self, document, pattern):
    QSyntaxHighlighter.__init__(self, document)

    self.keywords.append(pattern)

    rules = []

    rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
        for w in PythonHighlighter.keywords]

    self.rules = [(QRegExp(pat), index, fmt)
        for (pat, index, fmt) in rules]
Example #31
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # 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_R['string2'])
        self.tri_double = (QRegExp('"""'), 2, STYLES_R['string2'])

        rules = []

        # Keyword, operator, and brace rules
        rules += [(r'\b%s\b' % w, 0, STYLES_R['keyword'])
                  for w in RHighlighter.keywords]
        rules += [(r'%s' % o, 0, STYLES_R['operator'])
                  for o in RHighlighter.operators]
        rules += [(r'%s' % b, 0, STYLES_R['brace'])
                  for b in RHighlighter.braces]

        # All other rules
        rules += [

            # True or False
            (r'\bTrue', 0, STYLES_R['truefalse']),
            (r'\bFalse', 0, STYLES_R['truefalse']),

            # Assign
            (r'(\<)(\-)', 0, STYLES_R['assign']),

            # Function call
            (r'\b*(\w+)\(', 1, STYLES_R['function']),

            # Numeric literals
            (r'\b[+-]?[0-9]+[lL]?\b', 0, STYLES_R['numbers']),
            (r'\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b', 0, STYLES_R['numbers']),
            (r'\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b', 0,
             STYLES_R['numbers']),

            # Double-quoted string, possibly containing escape sequences
            (r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES_R['string']),
            # Single-quoted string, possibly containing escape sequences
            (r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES_R['string']),

            # Quicktrace Variables
            (r'(\@)(\{)[^\}]*(\})', 0, STYLES_R['quicktraceVariable']),

            # From '#' until a newline
            (r'#[^\n]*', 0, STYLES_R['comment']),
        ]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
                      for (pat, index, fmt) in rules]
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        rules = []

        rules += [(r'\b%s\b' % w, 0, STYLES['p_commands']) for w in ImagiHighlighter.p_commands]
        rules += [(r'\b%s\b' % w, 0, STYLES['l_commands']) for w in ImagiHighlighter.l_commands]
        rules += [(r'\b%s\b' % w, 0, STYLES['m_attributes']) for w in ImagiHighlighter.m_attributes]
        rules += [(r'\b%s\b' % w, 0, STYLES['types']) for w in ImagiHighlighter.types]
        rules += [(r'%s' % o, 0, STYLES['operators']) for o in ImagiHighlighter.operators]

        self.rules = [(QRegExp(pat), index, fmt) for (pat, index, fmt) in rules]
Example #33
0
 def __init__(self, document):
     QSyntaxHighlighter.__init__(self, document)
     rules = []
     rules += [(r'%s' % c, 0, STYLES['comment'])
         for c in self.comment]
     rules += [(r'%s' % g, 0, STYLES['group'])
         for g in self.group]
     rules += [(r'%s' % o, 0, STYLES['operator'])
        for o in self.operators]
      # Build a QRegExp for each pattern
     self.rules = [(QRegExp(pat), index, fmt)
         for (pat, index, fmt) in rules]
Example #34
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # 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.multi_cmnt = (QRegExp("\/\*"), QRegExp("\*\/"), 1,
                           STYLES['comment'])
        #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 VerilogHighlighter.keywords]
        rules += [(r'%s' % o, 0, STYLES['operator'])
                  for o in VerilogHighlighter.operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
                  for b in VerilogHighlighter.braces]

        # All other rules
        rules += [
            #Comments for
            #(r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
            #(r'\/\*[^\\]*(\\.[^\\]*)\*\/', 0, STYLES["comment"]),
            (r'\/\*[^\\]*(\\.[^\\]*)\*\/', 0, STYLES["string"]),
            #(r"\/\**(\\.[^\*\/]*)*", 0, STYLES['string']),

            ##Double-quoted string, possibly containing escape sequences
            #(r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
            ## Single-quoted string, possibly containing escape sequences
            #(r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']),
            #(r"\/\**(\\.[^'\\]*)\*\/", 0, STYLES['comment']),

            # 'def' followed by an identifier
            #(r'\balways\b\s*(\w+)', 1, STYLES['defclass']),
            # 'class' followed by an identifier
            #(r'\binitial\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]
Example #35
0
    def __init__(self, document, keywords=[], functions=[]):
        QSyntaxHighlighter.__init__(self, document)

        EHighlighter.keywords.extend(keywords)
        EHighlighter.functions.extend(functions)

        rules = []

        # Keyword, operator, and brace rules
        rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
                  for w in EHighlighter.keywords]

        rules += [(r'\b%s\b' % w, 0, STYLES['functions'])
                  for w in EHighlighter.functions]

        rules += [(r'%s' % o, 0, STYLES['operator'])
                  for o in EHighlighter.operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
                  for b in EHighlighter.braces]

        # All other rules
        rules += [
            # 'self'
            (r'\bself\b', 0, STYLES['self']),
            #(r'Traceback[^\n]*', 0, STYLES['Traceback']),



            # 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']),

            (r'(__[a-zA-Z_]*(__)?)', 0, STYLES['default']),

            (r'(\'[a-zA-Z_]*(\')?)', 0, STYLES['string']),

            # 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]
Example #36
0
 def __init__(self, parent=None):
     QSyntaxHighlighter.__init__(self, parent)
     for rule in Highlighter.Rules:
         if not rule[3]:
             rule[3] = QTextCharFormat()
             rule[3].setForeground(rule[0])
             if rule[1] & Highlighter.Normal:
                 rule[3].setFontWeight(QFont.Normal)
             if rule[1] & Highlighter.Bold:
                 rule[3].setFontWeight(QFont.Bold)
             if rule[1] & Highlighter.Italic: rule[3].setFontItalic(True)
     return
Example #37
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)
        
        # syntax highlighting from this point onward
        self.multiline_comment = (QRegExp("/\*"),QRegExp("\*/"), 1, STYLES['comment'])
        
        rules = []

        # Keyword, operator, and brace rules
        rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
            for w in CPPHighlighter.keywords]
        rules += [(r'%s' % o, 0, STYLES['operator'])
            for o in CPPHighlighter.operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
            for b in CPPHighlighter.braces]
        rules += [(r'\b%s\b' % b, 0, STYLES['modifiers'])
            for b in CPPHighlighter.modifiers]
        rules += [(r'\b%s\b' % b, 0, STYLES['datatypes'])
            for b in CPPHighlighter.datatypes]
        

        # All other rules
        rules += [
            
            # 'class' followed by an identifier
            (r'\bclass\b\s*(\w+)', 1, STYLES['defclass']),

            
            # From '#' until a newline
            (r'#[^\n]*', 0, STYLES['directive']),

            # 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']),

            # Double-quoted string, possibly containing escape sequences
            (r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),

            #For includes with doubly quoted strings
            (r'#+(.)+"+(.)+"',0,STYLES['directive']),
            # From '//' until a newline
            (r'//[^\n]*', 0, STYLES['comment']),
            
            #(r'/\*(.)+\*/',0,STYLES['comment']),
        ]
                       

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
            for (pat, index, fmt) in rules]
        self.comment_started = False
Example #38
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # syntax highlighting from this point onward
        self.multiline_comment = (QRegExp("/\*"), QRegExp("\*/"), 1,
                                  STYLES['comment'])

        rules = []

        # Keyword, operator, and brace rules
        rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
                  for w in CPPHighlighter.keywords]
        rules += [(r'%s' % o, 0, STYLES['operator'])
                  for o in CPPHighlighter.operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
                  for b in CPPHighlighter.braces]
        rules += [(r'\b%s\b' % b, 0, STYLES['modifiers'])
                  for b in CPPHighlighter.modifiers]
        rules += [(r'\b%s\b' % b, 0, STYLES['datatypes'])
                  for b in CPPHighlighter.datatypes]

        # All other rules
        rules += [

            # 'class' followed by an identifier
            (r'\bclass\b\s*(\w+)', 1, STYLES['defclass']),

            # From '#' until a newline
            (r'#[^\n]*', 0, STYLES['directive']),

            # 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']),

            # Double-quoted string, possibly containing escape sequences
            (r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),

            #For includes with doubly quoted strings
            (r'#+(.)+"+(.)+"', 0, STYLES['directive']),
            # From '//' until a newline
            (r'//[^\n]*', 0, STYLES['comment']),

            #(r'/\*(.)+\*/',0,STYLES['comment']),
        ]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
                      for (pat, index, fmt) in rules]
        self.comment_started = False
Example #39
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # 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.multi_cmnt = (QRegExp("\/\*"), QRegExp("\*\/"), 1, STYLES['comment'])
        #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 VerilogHighlighter.keywords]
        rules += [(r'%s' % o, 0, STYLES['operator'])
            for o in VerilogHighlighter.operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
            for b in VerilogHighlighter.braces]

        # All other rules
        rules += [
            #Comments for
            #(r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
            #(r'\/\*[^\\]*(\\.[^\\]*)\*\/', 0, STYLES["comment"]),
            (r'\/\*[^\\]*(\\.[^\\]*)\*\/', 0, STYLES["string"]),
            #(r"\/\**(\\.[^\*\/]*)*", 0, STYLES['string']),

            ##Double-quoted string, possibly containing escape sequences
            #(r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
            ## Single-quoted string, possibly containing escape sequences
            #(r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']),
            #(r"\/\**(\\.[^'\\]*)\*\/", 0, STYLES['comment']),

            # 'def' followed by an identifier
            #(r'\balways\b\s*(\w+)', 1, STYLES['defclass']),
            # 'class' followed by an identifier
            #(r'\binitial\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]
Example #40
0
	def __init__(self, parent=None):
		"""
		Initializes the class.

		:param parent: Widget parent.
		:type parent: QObject
		"""

		LOGGER.debug("> Initializing '{0}()' class.".format(self.__class__.__name__))

		QSyntaxHighlighter.__init__(self, parent)

		# --- Setting class attributes. ---
		self.__formats = None
		self.__rules = None
Example #41
0
    def __init__(self, doc):
        QSyntaxHighlighter.__init__(self, doc)

        commentFormat = QTextCharFormat()
        commentFormat.setFontItalic(True)
        commentFormat.setFontWeight(0)
        commentFormat.setForeground(QColor('grey'))
        self.commentFormat = commentFormat

        mysqlObjectFormat = QTextCharFormat()
        mysqlObjectFormat.setFontItalic(True)
        mysqlObjectFormat.setFontWeight(0)
        mysqlObjectFormat.setForeground(QColor().fromRgb(128, 128, 0))
        self.mysqlObjectFormat = mysqlObjectFormat

        self.mysqlObjectRegex = re.compile('(`.+?`)')
	def __init__(self, doc):
		QSyntaxHighlighter.__init__(self, doc)

		commentFormat = QTextCharFormat()
		commentFormat.setFontItalic(True)
		commentFormat.setFontWeight(0)
		commentFormat.setForeground(QColor('grey'))
		self.commentFormat = commentFormat

		mysqlObjectFormat = QTextCharFormat()
		mysqlObjectFormat.setFontItalic(True)
		mysqlObjectFormat.setFontWeight(0)
		mysqlObjectFormat.setForeground(QColor().fromRgb(128, 128, 0))
		self.mysqlObjectFormat = mysqlObjectFormat

		self.mysqlObjectRegex = re.compile('(`.+?`)')
 def __init__(self,textboxdoc,valid_list_of_commands):
     QSyntaxHighlighter.__init__(self,textboxdoc)
     self.valid_syntax="|".join([command.regexp_str for command in valid_list_of_commands])
     self.my_expression = QRegExp(self.valid_syntax)
     #define a blue font format for valid commands
     self.valid = QTextCharFormat()
     self.valid.setForeground(Qt.black)
     #define a bold red font format for invalid commands
     self.invalid = QTextCharFormat()
     self.invalid.setFontWeight(QFont.Bold)
     self.invalid.setForeground(Qt.red)
     #define a blue font format for valid parameters
     self.valid_value=QTextCharFormat()        
     self.valid_value.setFontWeight(QFont.Bold)
     #self.valid_value.setForeground(QColor.fromRgb(255,85,0))
     self.valid_value.setForeground(Qt.blue)
Example #44
0
 def __init__(self, textboxdoc, valid_list_of_commands):
     QSyntaxHighlighter.__init__(self, textboxdoc)
     self.valid_syntax = "|".join(
         [command.regexp_str for command in valid_list_of_commands])
     self.my_expression = QRegExp(self.valid_syntax)
     #define a blue font format for valid commands
     self.valid = QTextCharFormat()
     self.valid.setForeground(Qt.black)
     #define a bold red font format for invalid commands
     self.invalid = QTextCharFormat()
     self.invalid.setFontWeight(QFont.Bold)
     self.invalid.setForeground(Qt.red)
     #define a blue font format for valid parameters
     self.valid_value = QTextCharFormat()
     self.valid_value.setFontWeight(QFont.Bold)
     #self.valid_value.setForeground(QColor.fromRgb(255,85,0))
     self.valid_value.setForeground(Qt.blue)
Example #45
0
    def __init__(self, textEdit):
        QSyntaxHighlighter.__init__(self, textEdit)
        self._textEdit = textEdit
        textEdit.setFont(QFont("Monospace"))

        self._bracePattern = re.compile('[\(\)]')

        """Single line string formatting are applied at the end. Therefore even if some items in the string
        was highlighted with other style, it will be replaced
        """
        self._patternsToApply = { 'keyword':          self._makePatternFromList(self.KEYWORDS),
                                  'standardFunction': self._makePatternFromList(self.STANDARD_FUNCTIONS),
                                  'number':           self._makePatternFromList(self.NUMBERS),
                                }

        textEdit.cursorPositionChanged.connect(self._rehighlightMatchingBraces)
        textEdit.textChanged.connect(self._rehighlightMatchingBraces)  # When user presses Del, cursor is not moved
Example #46
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        self.start_of_chorus = (QRegExp("\{soc\}"), QRegExp("\{eoc\}"), 1, STYLES['chorus'])

        rules = []

        # Rules
        # TODO: make a nice rule for chord definition
        # TODO: make rules for keywords that take special arguments (like numbers)
        rules += [(r'\{%s\:(.)*\}' % w, 0, STYLES['argument']) for w in ChordProHighlighter.argumentKeywords]
        rules += [(r'\{%s\:?' % w, 0, STYLES['keyword']) for w in ChordProHighlighter.keywords]
        rules += [(r'%s' % b, 0, STYLES['curlyBrace']) for b in ChordProHighlighter.curlyBraces]
        rules += [(r'\[[^\]]*\]', 0, STYLES['chord'])]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
                      for (pat, index, fmt) in rules]
Example #47
0
    def __init__(self, textEdit):
        QSyntaxHighlighter.__init__(self, textEdit)
        self._textEdit = textEdit
        textEdit.setFont(QFont("Monospace"))

        self._bracePattern = re.compile('[\(\)]')
        """Single line string formatting are applied at the end. Therefore even if some items in the string
        was highlighted with other style, it will be replaced
        """
        self._patternsToApply = {
            'keyword': self._makePatternFromList(self.KEYWORDS),
            'standardFunction':
            self._makePatternFromList(self.STANDARD_FUNCTIONS),
            'number': self._makePatternFromList(self.NUMBERS),
        }

        textEdit.cursorPositionChanged.connect(self._rehighlightMatchingBraces)
        textEdit.textChanged.connect(
            self._rehighlightMatchingBraces
        )  # When user presses Del, cursor is not moved
Example #48
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        self.tri_single = (QRegExp("'''"), 2, ESTILOS['cadena2'])
        self.tri_double = (QRegExp('"""'), 2, ESTILOS['cadena2'])

        reglas = []

        # Keyword, operator, and brace rules
        reglas += [(r'\b%s\b' % w, 0, ESTILOS['palabra'])
            for w in const.PALABRAS]
        reglas += [(r'%s' % o, 0, ESTILOS['operador'])
            for o in const.OPERADORES]
        reglas += [(r'%s' % b, 0, ESTILOS['corchetes'])
            for b in const.CORCHETES]
        reglas += [(r'%s' % b, 0, ESTILOS['tipos'])
            for b in const.TIPOS]

        # All other rules
        reglas += [

            (r'\bINICIO\b', 0, ESTILOS['INICIO']),

            # Double-quoted string, possibly containing escape sequences
            (r'"[^"\\]*(\\.[^"\\]*)*"', 0, ESTILOS['cadena']),
            # Single-quoted string, possibly containing escape sequences
            (r"'[^'\\]*(\\.[^'\\]*)*'", 0, ESTILOS['cadena']),

            # From '#' until a newline
            (r'#[^\n]*', 0, ESTILOS['libreria']),
            (r'//[^\n]*', 0, ESTILOS['commentario']),

            # Numeric literals
            (r'\b[+-]?[0-9]+[lL]?\b', 0, ESTILOS['numberos']),
            (r'\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b', 0, ESTILOS['numberos']),
            (r'\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b', 0, ESTILOS['numberos']),
        ]

        # Build a QRegExp for each pattern
        self.reglas = [(QRegExp(pat), index, fmt)
            for (pat, index, fmt) in reglas]
Example #49
0
    def __init__(self, document, main_win):
        global gtk_enabled, gtk_struct_str
        QSyntaxHighlighter.__init__(self, document)

        self.build_rules()

        self.comment_started = False
        self.index_comment_start = -1
        self.index_comment_end = -1

        self.document = document

        self.list_multi_line_comment_pos = []
        print 'kkkkkk'
        gtk_enabled = False
        gtk_struct_str = ''
        self.main_win = main_win
        if self.main_win.gtk_support_structs != None:
            gtk_enabled = True
            gtk_struct_str = main_win.gtk_support_structs.all_structs_str
        print gtk_enabled
Example #50
0
 def __init__(self, document):
     QSyntaxHighlighter.__init__(self, document)
Example #51
0
 def __init__(self, parent, mode):
     QSyntaxHighlighter.__init__(self, parent)
     self.tstamp = time.time()
     self.formatter = QFormatter()
     self.lexer = get_lexer_by_name(mode)
     return
Example #52
0
 def rehighlight(self):
     QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
     QSyntaxHighlighter.rehighlight(self)
     QApplication.restoreOverrideCursor()
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # Syntax styles specific for Gaffer
        self.styles = {
            'keyword': self.text_format("#CC7832", 'bold'),
            'operator': self.text_format("#FFC68D"),
            'brace': self.text_format("#EEEEEE"),
            'defclass': self.text_format("#EEEEEE", 'bold'),
            'string': self.text_format("#8AA779"),
            'string2': self.text_format("#8AA779", 'italic'),
            'comment': self.text_format("#808080", 'italic'),
            'self': self.text_format("#8A653B", 'italic'),
            'numbers': self.text_format("#6897BB")
        }

        # Python keywords
        self.keywords = [
            'and',
            'assert',
            'break',
            'class',
            'continue',
            'def',
            'del',
            'elif',
            'else',
            'except',
            'exec',
            'finally',
            'for',
            'from',
            'global',
            'if',
            'import',
            'in',
            'is',
            'lambda',
            'not',
            'or',
            'pass',
            'print',
            'raise',
            'return',
            'try',
            'while',
            'yield',
            'None',
            'True',
            'False',
        ]

        # Python operators
        self.operators = [
            '=',
            # Comparison
            '==',
            '!=',
            '<',
            '<=',
            '>',
            '>=',
            # Arithmetic
            '\+',
            '-',
            '\*',
            '/',
            '//',
            '\%',
            '\*\*',
            # In-place
            '\+=',
            '-=',
            '\*=',
            '/=',
            '\%=',
            # Bitwise
            '\^',
            '\|',
            '\&',
            '\~',
            '>>',
            '<<',
        ]

        # Python braces
        self.braces = [
            '\{',
            '\}',
            '\(',
            '\)',
            '\[',
            '\]',
        ]

        self.block_state_id = {"'": 2, '"': 3, "'''": 4, '"""': 5, '#': 6}

        rules = []

        # Keyword, operator, and brace rules
        rules += [(r'\b%s\b' % w, 0, 'keyword') for w in self.keywords]
        rules += [(r'%s' % o, 0, 'operator') for o in self.operators]
        rules += [(r'%s' % b, 0, 'brace') for b in self.braces]

        # All other rules
        rules += [
            # 'self'
            (r'\bself\b', 0, 'self'),

            # 'def' followed by an identifier
            (r'\bdef\b\s*(\w+)', 1, 'defclass'),
            # 'class' followed by an identifier
            (r'\bclass\b\s*(\w+)', 1, 'defclass'),

            # Numeric literals
            (r'\b[+-]?[0-9]+[lL]?\b', 0, 'numbers'),
            (r'\b[+-]?0[xX][0-9A-Fa-f]+[lL]?\b', 0, 'numbers'),
            (r'\b[+-]?[0-9]+(?:\.[0-9]+)?(?:[eE][+-]?[0-9]+)?\b', 0,
             'numbers'),
        ]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
                      for (pat, index, fmt) in rules]

        self.formats = {}
Example #54
0
    def __init__(self, document, lang, scheme=None):
        QSyntaxHighlighter.__init__(self, document)
        langSyntax = loader.syntax[lang]
        if scheme is not None and not {}:
            restyle(scheme)

        keywords = langSyntax.get('keywords', [])
        operators = langSyntax.get('operators', [])
        extras = langSyntax.get('extras', [])

        rules = []

        # Keyword, operator, brace and extras rules
        rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
            for w in keywords]
        rules += [(r'%s' % o, 0, STYLES['operator'])
            for o in operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
            for b in Highlighter.braces]
        rules += [(r'\b%s\b' % e, 0, STYLES['extras'])
            for e in extras]

        # All other rules
        proper = langSyntax.get('properObject', None)
        if proper is not None:
            proper = '\\b' + str(proper[0]) + '\\b'
            rules += [(proper, 0, STYLES['properObject'])]

        rules.append((r'__\w+__', 0, STYLES['properObject']))

        definition = langSyntax.get('definition', [])
        for de in definition:
            expr = '\\b' + de + '\\b\\s*(\\w+)'
            rules.append((expr, 1, STYLES['definition']))

        # Numeric literals
        rules += [
            (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']),
        ]

        regex = langSyntax.get('regex', [])
        for reg in regex:
            expr = reg[0]
            color = color_scheme['extras']
            style = ''
            if len(reg) > 2:
                color = reg[1]
                style = reg[2]
            elif len(reg) > 1:
                color = reg[1]
            rules.append((expr, 0, format(color, style)))

        comments = langSyntax.get('comment', [])
        for co in comments:
            expr = co + '[^\\n]*'
            rules.append((expr, 0, STYLES['comment']))

        stringChar = langSyntax.get('string', [])
        for sc in stringChar:
            expr = r'"[^"\\]*(\\.[^"\\]*)*"' if sc == '"' else r"'[^'\\]*(\\.[^'\\]*)*'"
            rules.append((expr, 0, STYLES['string']))

        # 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'])    #"""

        multi = langSyntax.get('multiline_comment', [])
        if multi:
            self.multi_start = (QRegExp(multi['open']), STYLES['comment'])
            self.multi_end = (QRegExp(multi['close']), STYLES['comment'])
        else:
            self.multi_start = None

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
            for (pat, index, fmt) in rules]
Example #55
0
 def __init__(self, document, lang=None, scheme=None):
     QSyntaxHighlighter.__init__(self, document)
     if lang is not None:
         self.apply_highlight(lang, scheme)
Example #56
0
 def __init__(self, document, lang, scheme=None):
     QSyntaxHighlighter.__init__(self, document)
     self.apply_highlight(lang, scheme)
Example #57
0
    def __init__(self, document):
        QSyntaxHighlighter.__init__(self, document)

        # 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 MelHighlighter.keywords]
        rules += [(r'%s' % o, 0, STYLES['operator'])
                  for o in MelHighlighter.operators]
        rules += [(r'%s' % b, 0, STYLES['brace'])
                  for b in MelHighlighter.braces]

        rules += [(r'%s' % b, 0, STYLES['keyword'])
                  for b in MelHighlighter.pyKeywords]

        rules += [(r'%s' % "|".join(MelHighlighter.pyKeywords), 0,
                   STYLES['keyword'])]

        # 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']),

            # 'proc' followed by an identifier
            # (r'\bproc\b\s*(\w+)', 1, STYLES['defclass']),
            # 'global proc' followed by an identifier
            # (r'\bglobal proc\b\s*(\w+)', 1, STYLES['defclass']),

            # 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']),

            # From '//' until a newline
            (r'//[^\n]*', 0, STYLES['comment']),
        ]

        # Build a QRegExp for each pattern
        self.rules = [(QRegExp(pat), index, fmt)
                      for (pat, index, fmt) in rules]

        # Quotes
        self._singleQuotes = QtCore.QRegExp("'''")
        self._doubleQuotes = QtCore.QRegExp('"""')

        # mel multi-line comment: /*  */
        self._melMLComStart = re.compile('/\\*')
        self._melMLComEnd = re.compile('\\*/')
Example #58
0
    def __init__(self, document, filename, syntax_mode, syntax_theme):
        self.document = document
        QSyntaxHighlighter.__init__(self, self.document)

        try:
            filename_extension = filename.rsplit('.', 1)
            filename_extension = filename_extension[1]
        except:
            filename_extension = ""

        for extension in BoostSourceHighlighter.file_extensions:
            if extension == filename_extension:
                syntax_mode = filename_extension

        # Syntax styles that can be shared by all languages
        # Theme support: temporarily sys.argv input
        try:
            if syntax_theme == "Monochrome" or str(
                    sys.argv[1]) == "monochrome":
                STYLES = {
                    'keyword': format('#38898C'),
                    'operator': format('#419141'),
                    'brace': format('#878787'),
                    'defclass': format('#759F6F'),
                    'string': format('#759F6F'),
                    'string2': format('#759F6F'),
                    'comment': format('#6b6b6b'),
                    'self': format('#38898C'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Red" or str(sys.argv[1]) == "red":
                STYLES = {
                    'keyword': format('#770000'),
                    'operator': format('#7A7A7A'),
                    'brace': format('#878787'),
                    'defclass': format('#9C4343'),
                    'string': format('#9C4343'),
                    'string2': format('#9C4343'),
                    'comment': format('#494949'),
                    'self': format('#770000'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Orange" or str(sys.argv[1]) == "orange":
                STYLES = {
                    'keyword': format('#8F471E'),
                    'operator': format('#7A7A7A'),
                    'brace': format('#878787'),
                    'defclass': format('#e87330'),
                    'string': format('#e87330'),
                    'string2': format('#e87330'),
                    'comment': format('#494949'),
                    'self': format('#8F471E'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Yellow" or str(sys.argv[1]) == "yellow":
                STYLES = {
                    'keyword': format('#777700'),
                    'operator': format('#7A7A7A'),
                    'brace': format('#878787'),
                    'defclass': format('#A5A448'),
                    'string': format('#848337'),
                    'string2': format('#848337'),
                    'comment': format('#494949'),
                    'self': format('#777700'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Blue" or str(sys.argv[1]) == "blue":
                STYLES = {
                    'keyword': format('#003377'),
                    'operator': format('#7A7A7A'),
                    'brace': format('#878787'),
                    'defclass': format('#375c84'),
                    'string': format('#375c84'),
                    'string2': format('#375c84'),
                    'comment': format('#494949'),
                    'self': format('#003377'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Green" or str(sys.argv[1]) == "green":
                STYLES = {
                    'keyword': format('#007765'),
                    'operator': format('#7A7A7A'),
                    'brace': format('#878787'),
                    'defclass': format('#378437'),
                    'string': format('#378437'),
                    'string2': format('#378437'),
                    'comment': format('#494949'),
                    'self': format('#007765'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Flo\'s V8 Cafe" or str(
                    sys.argv[1]) == "flosv8cafe":
                STYLES = {
                    'keyword': format('#0D8580'),
                    'operator': format('#7A7A7A'),
                    'brace': format('#878787'),
                    'defclass': format('#EF7196'),
                    'string': format('#EF7196'),
                    'string2': format('#EF7196'),
                    'comment': format('#494949'),
                    'self': format('#0D8580'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Stranger Things" or str(
                    sys.argv[1]) == "strangerthings":
                STYLES = {
                    'keyword': format('#222F57'),
                    'operator': format('#7A7A7A'),
                    'brace': format('#878787'),
                    'defclass': format('#BF1515'),
                    'string': format('#BF1515'),
                    'string2': format('#BF1515'),
                    'comment': format('#494949'),
                    'self': format('#222F57'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Royal" or str(sys.argv[1]) == "royal":
                STYLES = {
                    'keyword': format('#00626a'),
                    'operator': format('#4D1675'),
                    'brace': format('#878787'),
                    'defclass': format('#e8b290'),
                    'string': format('#e8b290'),
                    'string2': format('#e8b290'),
                    'comment': format('#494949'),
                    'self': format('#00626a'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Scoops Ahoy" or str(
                    sys.argv[1]) == "scoopsahoy":
                STYLES = {
                    'keyword': format('#473B5F'),
                    'operator': format('#943B41'),
                    'brace': format('#878787'),
                    'defclass': format('#943B41'),
                    'string': format('#D2A89C'),
                    'string2': format('#D2A89C'),
                    'comment': format('#494949'),
                    'self': format('#473B5F'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Old Locomotive" or str(
                    sys.argv[1]) == "oldlocomotive":
                STYLES = {
                    'keyword': format('#916438'),
                    'operator': format('#878787'),
                    'brace': format('#878787'),
                    'defclass': format('#389138'),
                    'string': format('#389138'),
                    'string2': format('#389138'),
                    'comment': format('#6b6b6b'),
                    'self': format('#916438'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Green (Muted)" or str(
                    sys.argv[1]) == "greenmuted":
                STYLES = {
                    'keyword': format('#38898C'),
                    'operator': format('#878787'),
                    'brace': format('#878787'),
                    'defclass': format('#759F6F'),
                    'string': format('#759F6F'),
                    'string2': format('#759F6F'),
                    'comment': format('#6b6b6b'),
                    'self': format('#38898C'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Winter" or str(sys.argv[1]) == "winter":
                STYLES = {
                    'keyword': format('#875F5F'),
                    'operator': format('#878787'),
                    'brace': format('#878787'),
                    'defclass': format('#5F5F87'),
                    'string': format('#38898C'),
                    'string2': format('#38898C'),
                    'comment': format('#6b6b6b'),
                    'self': format('#38898C'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "SpaCy" or str(sys.argv[1]) == "spacy":
                STYLES = {
                    'keyword': format('#DB2C55'),
                    'operator': format('#878787'),
                    'brace': format('#878787'),
                    'defclass': format('#FFB86C'),
                    'string': format('#FFB86C'),
                    'string2': format('#FFB86C'),
                    'comment': format('#6b6b6b'),
                    'self': format('#DEDEDE'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Alabaster" or str(
                    sys.argv[1]) == "alabaster":
                STYLES = {
                    'keyword': format('#007765'),
                    'operator': format('#7A7A7A'),
                    'brace': format('#000000'),
                    'defclass': format('#378437'),
                    'string': format('#378437'),
                    'string2': format('#378437'),
                    'comment': format('#378437'),
                    'self': format('#000000'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "SpaceX" or str(sys.argv[1]) == "spacex":
                STYLES = {
                    'keyword': format('#186298'),
                    'operator': format('#878787'),
                    'brace': format('#878787'),
                    'defclass': format('#287FB1'),
                    'string': format('#FF9210'),
                    'string2': format('#FF9210'),
                    'comment': format('#FF9210'),
                    'self': format('#DEDEDE'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "Forest" or str(sys.argv[1]) == "forest":
                STYLES = {
                    'keyword': format('#379439'),
                    'operator': format('#BBC1A8'),
                    'brace': format('#8C8C8C'),
                    'defclass': format('#CC652D'),
                    'string': format('#CC652D'),
                    'string2': format('#CC652D'),
                    'comment': format('#8C8C8C'),
                    'self': format('#FFFFFF'),
                    'numbers': format('#8A8A8A'),
                }
            elif syntax_theme == "":
                STYLES = {
                    'keyword': format('#2273A5'),
                    'operator': format('#DBD9D5'),
                    'brace': format('#DBD9D5'),
                    'defclass': format('#ccac55'),
                    'string': format('#77D479'),
                    'string2': format('#77D479'),
                    'comment': format('#8b939b'),
                    'self': format('#C37A5A'),
                    'numbers': format('#DBD9D5'),
                }
        except:
            STYLES = {
                'keyword': format('#2273A5'),
                'operator': format('#DBD9D5'),
                'brace': format('#DBD9D5'),
                'defclass': format('#ccac55'),
                'string': format('#77D479'),
                'string2': format('#77D479'),
                'comment': format('#8b939b'),
                'self': format('#C37A5A'),
                'numbers': format('#DBD9D5'),
            }

        if syntax_mode == "html":
            keywords = [
                'a',
                'abbr',
                'acronym',
                'address',
                'applet',
                'area',
                'article',
                'aside',
                'audio',
                'b',
                'base',
                'basefont',
                'bdi',
                'bdo',
                'bgsound',
                'big',
                'blink',
                'blockquote',
                'body',
                'br',
                'button',
                'canvas',
                'caption',
                'center',
                'cite',
                'code',
                'col',
                'colgroup',
                'command',
                'content',
                'data',
                'datalist',
                'dd',
                'del',
                'details',
                'dfn',
                'dialog',
                'dir',
                'div',
                'dl',
                'dt',
                'element',
                'em',
                'embed',
                'fieldset',
                'figcaption',
                'figure',
                'font',
                'footer',
                'form',
                'frame',
                'frameset',
                'h1',
                'head',
                'header',
                'hgroup',
                'hr',
                'html',
                'i',
                'iframe',
                'image',
                'img',
                'input',
                'ins',
                'isindex',
                'kbd',
                'keygen',
                'label',
                'legend',
                'li',
                'link',
                'listing',
                'main',
                'map',
                'mark',
                'marquee',
                'menu',
                'menuitem',
                'meta',
                'meter',
                'multicol',
                'nav',
                'nextid',
                'nobr',
                'noembed',
                'noframes',
                'noscript',
                'object',
                'ol',
                'optgroup',
                'option',
                'output',
                'p',
                'param',
                'picture',
                'plaintext',
                'pre',
                'progress',
                'q',
                'rb',
                'rp',
                'rt',
                'rtc',
                'ruby',
                's',
                'samp',
                'script',
                'section',
                'select',
                'shadow',
                'slot',
                'small',
                'source',
                'spacer',
                'span',
                'strike',
                'strong',
                'style',
                'sub',
                'summary',
                'sup',
                'table',
                'tbody',
                'td',
                'template',
                'textarea',
                'tfoot',
                'th',
                'thead',
                'time',
                'title',
                'tr',
                'track',
                'tt',
                'u',
                'ul',
                'var',
                'video',
                'wbr',
                'xmp',
            ]
            operators = [
                # Arithmetic
                '\+',
                '-',
                '\*',
                '/',
                '//',
                '\%',
                '\*\*',
            ]
            braces = [
                '\{',
                '\}',
                '\(',
                '\)',
                '\[',
                '\]',
            ]

        elif syntax_mode == "js":
            keywords = [
                'abstract', 'arguments', 'await*', 'boolean', 'break', 'byte',
                'case', 'catch', 'char', 'class*', 'const', 'continue',
                'debugger', 'default', 'delete', 'do', 'double', 'else',
                'enum*', 'evalexport*', 'extends*', 'false', 'final',
                'finally', 'float', 'for', 'function', 'goto', 'if',
                'implements', 'import*', 'in', 'instanceof', 'int',
                'interface', 'let*', 'long', 'native', 'new', 'null',
                'package', 'private', 'protected', 'public', 'return', 'short',
                'static', 'super*', 'switch', 'synchronized', 'this', 'throw',
                'throws', 'transient', 'true', 'try', 'typeof', 'var', 'void',
                'volatile', 'while', 'with', 'yield'
            ]

            operators = [
                # Arithmetic
                '\+',
                '-',
                '\*',
                '/',
                '//',
                '\%',
                '\*\*',
            ]

            braces = [
                '\{',
                '\}',
                '\(',
                '\)',
                '\[',
                '\]',
            ]

        elif syntax_mode == "cpp":
            keywords = [
                '__abstract', '__alignof', 'Operator', '__asm', '__assume',
                '__based', '__box', '__cdecl', '__declspec', '__delegate',
                '__event', '__except', '__fastcall', '__finally',
                '__forceinline', '__gc', '__hook', '__identifier',
                '__if_exists', '__if_not_exists', '__inline', '__int16',
                '__int32', '__int64', '__int8', '__interface', '__leave',
                '__m128', '__m128d', '__m128i', '__m64',
                '__multiple_inheritance', '__nogc', '__noop', '__pin',
                '__property', '__ptr32', '__ptr644', '__raise', '__restrict',
                '__sealed', '__single_inheritance4', '__sptr4', '__stdcall',
                '__super', '__thiscall', '__try_cast', '__unaligned',
                '__unhook', '__uptr', '__uuidof', '__value', '__vectorcall',
                '__virtual_inheritance', '__w64', '__wchar_t', 'abstract',
                'alignas', 'array', 'auto', 'bool', 'break', 'case', 'catch',
                'char', 'char16_t', 'char32_t', 'class', 'const', 'const_cast',
                'constexpr', 'continue', 'decltype', 'default', 'delegate',
                'delete', 'deprecated', 'dllexport', 'dllimport', 'do',
                'double', 'dynamic_cast', 'else', 'enum', 'enum', 'class',
                'enum', 'include', 'struct', 'event', 'explicit', 'extern',
                'false', 'finally', 'float', 'for', 'for', 'each', 'in',
                'friend', 'friend_as', 'gcnew', 'generic', 'goto', 'if',
                'initonly', 'inline', 'int', 'interface', 'class', 'interface',
                'struct', 'interior_ptr', 'literal', 'long', 'mutable',
                'naked', 'namespace', 'new', 'new', 'noexcept', 'noinline',
                'noreturn', 'nothrow', 'novtable', 'nullptr', 'operator',
                'private', 'property', 'property', 'protected', 'public',
                'ref', 'class', 'ref', 'struct', 'register',
                'reinterpret_cast', 'return', 'safecast', 'sealed',
                'selectany', 'short', 'signed', 'sizeof', 'static',
                'static_assert', 'static_cast', 'struct', 'string', 'switch',
                'template', 'this', 'thread', 'throw', 'true', 'try',
                'typedef', 'typeid', 'typeid', 'typename', 'union', 'unsigned',
                'using', 'declaration', 'using', 'directive', 'uuid', 'value',
                'class', 'value', 'struct', 'virtual', 'void', 'volatile',
                'while'
            ]

            operators = [
                # Arithmetic
                '\+',
                '-',
                '\*',
                '/',
                '//',
                '\%',
                '\*\*',
            ]

            braces = [
                '\{',
                '\}',
                '\(',
                '\)',
                '\[',
                '\]',
            ]

        elif syntax_mode == "rs":
            keywords = [
                '_', 'abstract', 'alignof', 'as', 'become', 'box', 'break',
                'const', 'continue', 'crate', 'do', 'else', 'enum', 'extern',
                'false', 'final', 'fn', 'for', 'if', 'impl', 'in', 'let',
                'loop', 'macro', 'match', 'mod', 'move', 'mut', 'offsetof',
                'override', 'priv', 'proc', 'pub', 'pure', 'ref', 'return',
                'Self', 'self', 'sizeof', 'static', 'struct', 'super', 'trait',
                'true', 'type', 'typeof', 'unsafe', 'unsized', 'use',
                'virtual', 'where', 'while', 'yield'
            ]

            operators = [
                # Arithmetic
                '\+',
                '-',
                '\*',
                '/',
                '//',
                '\%',
                '\*\*',
            ]

            braces = [
                '\{',
                '\}',
                '\(',
                '\)',
                '\[',
                '\]',
            ]

        # Python operators
        elif syntax_mode in BoostSourceHighlighter.file_extensions:
            # Python keywords
            keywords = [
                'and',
                'assert',
                'break',
                'class',
                'continue',
                'def',
                'del',
                'elif',
                'else',
                'except',
                'exec',
                'finally',
                'for',
                'from',
                'global',
                'if',
                'import',
                'in',
                'is',
                'lambda',
                'not',
                'or',
                'pass',
                'print',
                'raise',
                'return',
                'try',
                'while',
                'yield',
                'None',
                'True',
                'False',
            ]
            operators = [
                '=',
                # Comparison
                '==',
                '!=',
                '<',
                '<=',
                '>',
                '>=',
                # Arithmetic
                '\+',
                '-',
                '\*',
                '/',
                '//',
                '\%',
                '\*\*',
                # In-place
                '\+=',
                '-=',
                '\*=',
                '/=',
                '\%=',
                # Bitwise
                '\^',
                '\|',
                '\&',
                '\~',
                '>>',
                '<<',
            ]

            # Python braces
            braces = [
                '\{',
                '\}',
                '\(',
                '\)',
                '\[',
                '\]',
            ]

        #Everything not a source file
        else:
            keywords = []
            operators = []
            braces = []

            STYLES = {
                'keyword': format('#DBD9D5'),
                'operator': format('#DBD9D5'),
                'brace': format('#DBD9D5'),
                'defclass': format('#DBD9D5'),
                'string': format('#DBD9D5'),
                'string2': format('#DBD9D5'),
                'comment': format('#DBD9D5'),
                'self': format('#DBD9D5'),
                'numbers': format('#DBD9D5'),
            }

        QSyntaxHighlighter.__init__(self, self.document)

        # 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['comment'])
        self.tri_double = (QRegExp('"""'), 2, STYLES['comment'])

        highlight_rules = []

        # Keyword, operator, and brace rules
        highlight_rules += [(r'\b%s\b' % w, 0, STYLES['keyword'])
                            for w in keywords]
        highlight_rules += [(r'%s' % o, 0, STYLES['operator'])
                            for o in operators]
        highlight_rules += [(r'%s' % b, 0, STYLES['brace']) for b in braces]

        # All other rules
        if str(syntax_mode) != "html" and str(syntax_mode) != "htm":
            highlight_rules += [
                # 'self'
                (r'\bself\b', 0, STYLES['self']),

                # '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']),

                # Function call after . and before (
                #	(r'\.(?:[^\.]*(?=([(])))', 0, STYLES['function']),
                #	(r'\.[\w]+(?=\()', 0, STYLES['function']),

                # 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']),

                # From '//' until a newline
                (r'//[^\n]*', 0, STYLES['comment']),

                #Comments between /* and */
                (r'\/\*(?:(?!\*)(?:.|[\r\n]+))*\*\/', 1, STYLES['comment']),
            ]

        #Python comment
        if str(syntax_mode) == "py":
            highlight_rules += [
                # From '#' until a newline
                (r'#[^\n]*', 0, STYLES['comment']),
            ]

        elif str(syntax_mode) == "html" or str(syntax_mode) == "htm":
            highlight_rules += [
                (r'\<![ \r\n\t]*(--([^\-]|[\r\n]|-[^\-])*--[ \r\n\t]*)\>', 1,
                 STYLES['comment']),
            ]

        highlight_rules += [
            # Double-quoted string, possibly containing escape sequences
            (r'"[^"\\]*(\\.[^"\\]*)*"', 0, STYLES['string']),
            # Single-quoted string, possibly containing escape sequences
            (r"'[^'\\]*(\\.[^'\\]*)*'", 0, STYLES['string']),
        ]

        self.rules = [(QRegExp(pat), index, fmt)
                      for (pat, index, fmt) in highlight_rules]