PrEditor 2.1.0__py3-none-any.whl

preditor/scintilla/lang/language.py

@@ -0,0 +1,240 @@
+from __future__ import absolute_import, print_function
+
+import re
+import sys
+
+try:
+    from configparser import ConfigParser
+except ImportError:
+    from ConfigParser import ConfigParser
+
+from .. import Qsci
+
+
+class MethodDescriptor(object):
+    def __init__(self, dtype, expr):
+        self.dtype = dtype
+        self.exprText = expr
+        try:
+            self.expr = re.compile(expr, re.DOTALL | re.MULTILINE)
+        except Exception:
+            print('error generating expression', expr)
+            self.expr = None
+
+    def search(self, text, startpos=-1):
+        if not self.expr:
+            return None
+
+        if startpos != -1:
+            return self.expr.search(text, startpos)
+        else:
+            return self.expr.search(text)
+
+
+class Language(object):
+    def __init__(self):
+        self._name = ''
+        self._fileTypes = []
+
+        # lexer class information
+        self._lexerClass = -1
+        self._lexerClassName = ''
+        self._lexerModule = ''
+        self._lexerColorTypes = {}
+        self._custom = False
+        self._sourcefile = ''
+
+        # comment information
+        self._lineComment = ''
+
+        # method descriptors
+        self._descriptors = []
+
+    def addDescriptor(self, type, expr):
+        self._descriptors.append(MethodDescriptor(type, expr))
+
+    def createLexer(self, parent=None):
+        # create an instance of the lexer
+        cls = self.lexerClass()
+        if not cls:
+            return None
+
+        output = cls(parent)
+        if output and parent:
+            output.setFont(parent.font())
+        return output
+
+    def descriptors(self):
+        return self._descriptors
+
+    def isCustom(self):
+        return self._custom
+
+    def name(self):
+        return self._name
+
+    def lexerColorTypes(self):
+        return self._lexerColorTypes
+
+    def lineComment(self):
+        return self._lineComment
+
+    def fileTypes(self):
+        return self._fileTypes
+
+    def lexerClass(self):
+        if self._lexerClass == -1:
+            # use a custom lexer module
+            if self._lexerModule:
+                # retrieve the lexer module
+                module = sys.modules.get(self._lexerModule)
+
+                # try to import the module
+                if not module:
+                    try:
+                        __import__(self._lexerModule)
+                        module = sys.modules.get(self._lexerModule)
+                    except Exception:
+                        print(
+                            (
+                                '[preditor.scintilla.lexers.Language.createLexer() '
+                                'Error] Could not import %s module'
+                            )
+                            % self._lexerModule
+                        )
+                        self._lexerClass = None
+                        return None
+
+            # otherwise, its in the Qsci module
+            else:
+                module = Qsci
+
+            # retrieve the lexer class
+            self._lexerClass = module.__dict__.get(self._lexerClassName)
+            if not self._lexerClass:
+                print(
+                    (
+                        '[preditor.scintilla.lexers.Language.createLexer() Error] '
+                        'No %s class in %s'
+                    )
+                    % (self._lexerClassName, module.__name__)
+                )
+
+        return self._lexerClass
+
+    def lexerClassName(self):
+        return self._lexerClassName
+
+    def lexerModule(self):
+        return self._lexerModule
+
+    def save(self, filename=''):
+        if not filename:
+            filename = self.filename()
+        if not filename:
+            return False
+
+        parser = ConfigParser()
+        parser.add_section('GLOBALS')
+        parser.set('GLOBALS', 'name', self.name())
+        parser.set('GLOBALS', 'filetypes', ';'.join(self.fileTypes()))
+        # quotes are to preserve spaces which configparser strips out
+        parser.set('GLOBALS', 'linecomment', '"{}"'.format(self.lineComment()))
+
+        parser.add_section('LEXER')
+        parser.set('LEXER', 'class', self.lexerClassName())
+        parser.set('LEXER', 'module', self.lexerModule())
+
+        parser.add_section('DESCRIPTORS')
+        for i, desc in enumerate(self._descriptors):
+            parser.set('DESCRIPTORS', '%s%i' % (desc.dtype, i), desc.exprText)
+
+        parser.add_section('COLOR_TYPES')
+        for key, value in self.lexerColorTypes().items():
+            parser.set('COLOR_TYPES', key, ','.join([str(val) for val in value]))
+
+        # save the language
+        f = open(filename, 'w')
+        parser.write(f)
+        f.close()
+
+        self._sourcefile = filename
+        return True
+
+    def setCustom(self, state):
+        self._custom = state
+
+    def setFileTypes(self, fileTypes):
+        self._fileTypes = fileTypes
+
+    def setLexerClassName(self, className):
+        self._lexerClassName = className
+
+    def setLexerModule(self, module):
+        self._lexerModule = module
+
+    def setLineComment(self, lineComment):
+        self._lineComment = lineComment
+
+    def setLexerColorTypes(self, lexerColorTypes):
+        self._lexerColorTypes = lexerColorTypes
+
+    def setName(self, name):
+        self._name = name
+
+    def sourcefile(self):
+        return self._sourcefile
+
+    @staticmethod
+    def fromConfig(filename):
+        parser = ConfigParser()
+
+        if not parser.read(filename):
+            return False
+
+        plugin = Language()
+        plugin._name = parser.get('GLOBALS', 'name')
+        plugin._fileTypes = parser.get('GLOBALS', 'filetypes').split(';')
+
+        # try to load the line comment information
+        try:
+            plugin._lineComment = parser.get('GLOBALS', 'linecomment').strip('"')
+        except Exception:
+            pass
+
+        # try to load the lexer information
+        try:
+            plugin._lexerClassName = parser.get('LEXER', 'class')
+            plugin._lexerModule = parser.get('LEXER', 'module')
+        except Exception:
+            pass
+
+        # load the different descriptor options
+        try:
+            options = parser.options('DESCRIPTORS')
+        except Exception:
+            options = []
+
+        for option in options:
+            expr = parser.get('DESCRIPTORS', option)
+            option = re.match(r'([^\d]*)\d*', option).groups()[0]
+            plugin._descriptors.append(MethodDescriptor(option, expr))
+
+        # load the different color map options
+        try:
+            options = parser.options('COLOR_TYPES')
+        except Exception:
+            options = []
+
+        for option in options:
+            vals = []
+            for val in parser.get('COLOR_TYPES', option).split(','):
+                try:
+                    vals.append(int(val))
+                except Exception:
+                    pass
+            plugin._lexerColorTypes[option] = vals
+
+        plugin._sourcefile = filename
+
+        return plugin

preditor/scintilla/lexers/cpplexer.py

@@ -0,0 +1,22 @@
+from __future__ import absolute_import
+
+from Qt.QtGui import QColor
+
+from .. import Qsci
+
+
+class CppLexer(Qsci.QsciLexerCPP):
+    # Items in this list will be highlighted using the color for self.KeywordSet2
+    highlightedKeywords = ''
+
+    def defaultPaper(self, style):
+        if style == self.CommentLine:
+            # Set the highlight color for this lexer
+            return QColor(155, 255, 155)
+        return super(CppLexer, self).defaultPaper(style)
+
+    def keywords(self, style):
+        # Words to be highlighted
+        if style == self.CommentLine and self.highlightedKeywords:
+            return self.highlightedKeywords
+        return super(CppLexer, self).keywords(style)

preditor/scintilla/lexers/javascriptlexer.py

@@ -0,0 +1,27 @@
+from __future__ import absolute_import
+
+from Qt.QtGui import QColor
+
+from .. import Qsci
+
+
+class JavaScriptLexer(Qsci.QsciLexerJavaScript):
+    # Items in this list will be highlighted using the color for
+    # `Qsci.QsciLexerJavaScript.KeywordSet2`
+    highlightedKeywords = ''
+
+    def defaultFont(self, index):
+        # HACK: TODO: I should probably preserve the existing fonts
+        return self.font(0)
+
+    def defaultPaper(self, style):
+        if style == Qsci.QsciLexerJavaScript.KeywordSet2:
+            # Set the highlight color for this lexer
+            return QColor(155, 255, 155)
+        return super(JavaScriptLexer, self).defaultPaper(style)
+
+    def keywords(self, style):
+        # Words to be highlighted
+        if style == 2 and self.highlightedKeywords:
+            return self.highlightedKeywords
+        return super(JavaScriptLexer, self).keywords(style)

preditor/scintilla/lexers/maxscriptlexer.py

@@ -0,0 +1,235 @@
+from __future__ import absolute_import
+
+import re
+from builtins import str as text
+
+from future.utils import iteritems
+
+from .. import Qsci, QsciScintilla
+
+MS_KEYWORDS = """
+if then else not and or key collect
+do while for in with where
+function fn rollout struct parameters attributes exit continue
+local global
+true false
+ok undefined unsupplied return
+filein open close flush include print
+"""
+
+
+class MaxscriptLexer(Qsci.QsciLexerCustom):
+    # Items in this list will be highligheded using the color for self.SmartHighlight
+    highlightedKeywords = ''
+
+    def __init__(self, parent=None):
+        super(MaxscriptLexer, self).__init__(parent)
+        self._styles = {
+            0: 'Default',
+            1: 'Comment',
+            2: 'CommentLine',
+            3: 'Keyword',
+            4: 'Operator',
+            5: 'Number',
+            6: 'String',
+            7: 'SmartHighlight',
+        }
+
+        for key, value in iteritems(self._styles):
+            setattr(self, value, key)
+
+    def description(self, style):
+        return self._styles.get(style, '')
+
+    def defaultColor(self, style):
+        from Qt.QtCore import Qt
+        from Qt.QtGui import QColor
+
+        if style in (self.Comment, self.CommentLine):
+            return QColor(40, 160, 40)
+
+        elif style in (self.Keyword, self.Operator):
+            return QColor(Qt.GlobalColor.blue)
+
+        elif style == self.Number:
+            return QColor(Qt.GlobalColor.red)
+
+        elif style == self.String:
+            return QColor(180, 140, 30)
+
+        return super(MaxscriptLexer, self).defaultColor(style)
+
+    def defaultPaper(self, style):
+        if style == self.SmartHighlight:
+            from Qt.QtGui import QColor
+
+            # Set the highlight color for this lexer
+            return QColor(155, 255, 155)
+        return super(MaxscriptLexer, self).defaultPaper(style)
+
+    def font(self, style):
+        font = super(MaxscriptLexer, self).font(style)
+        if style in (self.Comment, self.CommentLine):
+            font.setFamily('Arial Bold')
+        return font
+
+    def keywords(self, style):
+        if style == self.Keyword:
+            return MS_KEYWORDS
+        if style == self.SmartHighlight:
+            return self.highlightedKeywords
+        return super(MaxscriptLexer, self).keywords(style)
+
+    def processChunk(self, chunk, lastState, keywords):
+        # process the length of the chunk
+        if isinstance(chunk, bytearray):
+            chunk = chunk.decode('utf8')
+        length = len(chunk)
+
+        # check to see if our last state was a block comment
+        if lastState == self.Comment:
+            pos = chunk.find('*/')
+            if pos != -1:
+                self.setStyling(pos + 2, self.Comment)
+                return self.processChunk(chunk[pos + 2 :], self.Default, keywords)
+            else:
+                self.setStyling(length, self.Comment)
+                return (self.Comment, 0)
+
+        # check to see if our last state was a string
+        elif lastState == self.String:
+            # remove special case backslashes
+            while r'\\' in chunk:
+                chunk = chunk.replace(r'\\', '||')
+
+            # remove special case strings
+            while r'\"' in chunk:
+                chunk = chunk.replace(r'\"', r"\'")
+
+            pos = chunk.find('"')
+            if pos != -1:
+                self.setStyling(pos + 1, self.String)
+                return self.processChunk(chunk[pos + 1 :], self.Default, keywords)
+            else:
+                self.setStyling(length, self.String)
+                return (self.String, 0)
+
+        # otherwise, process a default chunk
+        else:
+            blockpos = chunk.find('/*')
+            linepos = chunk.find('--')
+            strpos = chunk.find('"')
+            order = [blockpos, linepos, strpos]
+            order.sort()
+
+            # any of the above symbols will affect how a symbol following it is treated,
+            # so make sure we process in the proper order
+            for i in order:
+                if i == -1:
+                    continue
+
+                # process a string
+                if i == strpos:
+                    state, folding = self.processChunk(chunk[:i], lastState, keywords)
+                    self.setStyling(1, self.String)
+                    newstate, newfolding = self.processChunk(
+                        chunk[i + 1 :], self.String, keywords
+                    )
+                    return (newstate, newfolding + folding)
+
+                # process a line comment
+                elif i == linepos:
+                    state, folding = self.processChunk(chunk[:i], lastState, keywords)
+                    self.setStyling(length - i, self.CommentLine)
+                    return (self.Default, folding)
+
+                # process a block comment
+                elif i == blockpos:
+                    state, folding = self.processChunk(chunk[:i], lastState, keywords)
+                    self.setStyling(2, self.Comment)
+                    newstate, newfolding = self.processChunk(
+                        chunk[i + 2 :], self.Comment, keywords
+                    )
+                    return (newstate, newfolding + folding)
+
+            # otherwise, we are processing a default set of text whose syntaxing is
+            # irrelavent from the previous one TODO: this needs to handle QStrings.
+            # However I do not thing QStrings are the problem, its more likely a
+            # bytearray problem. the conversion at the start of this function may have
+            # resolved it.
+            results = self.chunkRegex.findall(chunk)
+            for space, kwd in results:
+                if not (space or kwd):
+                    break
+
+                self.setStyling(len(space), self.Default)
+
+                if kwd.lower() in self.hlkwords:
+                    self.setStyling(len(kwd), self.SmartHighlight)
+                elif kwd.lower() in keywords:
+                    self.setStyling(len(kwd), self.Keyword)
+                else:
+                    self.setStyling(len(kwd), self.Default)
+
+            # in this context, look for opening and closing parenthesis which will
+            # determine folding scope
+            return (self.Default, chunk.count('(') - chunk.count(')'))
+
+    def styleText(self, start, end):
+        editor = self.editor()
+        if not editor:
+            return
+
+        # scintilla works with encoded bytes, not decoded characters
+        # this matters if the source contains non-ascii characters and
+        # a multi-byte encoding is used (e.g. utf-8)
+        source = ''
+        if end > editor.length():
+            end = editor.length()
+
+        # define commonly used methods
+        SCI = editor.SendScintilla
+        SETFOLDLEVEL = QsciScintilla.SCI_SETFOLDLEVEL
+        HEADERFLAG = QsciScintilla.SC_FOLDLEVELHEADERFLAG
+        CURRFOLDLEVEL = QsciScintilla.SC_FOLDLEVELBASE
+
+        if end > start:
+            source = bytearray(end - start)
+            editor.SendScintilla(editor.SCI_GETTEXTRANGE, start, end, source)
+
+        if not source:
+            return
+        self.parent().blockSignals(True)
+
+        # the line index will also need to implement folding
+        index = editor.SendScintilla(editor.SCI_LINEFROMPOSITION, start)
+        if index > 0:
+            # the previous state may be needed for multi-line styling
+            pos = editor.SendScintilla(editor.SCI_GETLINEENDPOSITION, index - 1)
+            lastState = editor.SendScintilla(editor.SCI_GETSTYLEAT, pos)
+        else:
+            lastState = self.Default
+
+        self.startStyling(start, 0x1F)
+
+        # cache objects used by processChunk that do not need updated every time it is
+        # called
+        self.hlkwords = set(text(self.keywords(self.SmartHighlight)).lower().split())
+        self.chunkRegex = re.compile('([^A-Za-z0-9]*)([A-Za-z0-9]*)')
+        kwrds = set(MS_KEYWORDS.split())
+
+        # scintilla always asks to style whole lines
+        for line in source.splitlines(True):
+            lastState, folding = self.processChunk(line, lastState, kwrds)
+
+            # open folding levels
+            if folding > 0:
+                SCI(SETFOLDLEVEL, index, CURRFOLDLEVEL | HEADERFLAG)
+                CURRFOLDLEVEL += folding
+            else:
+                SCI(SETFOLDLEVEL, index, CURRFOLDLEVEL)
+                CURRFOLDLEVEL += folding
+
+            # folding implementation goes here
+            index += 1
+        self.parent().blockSignals(False)