added example scripts received from claudia frank by mail

Author: chcg

scripts/Samples/ColumnLexer.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+"""
+    ColumnLexer - Demo
+
+    A column based lexer, odd and even columns will be styled differently.
+    
+    Usage:
+    Default column separator is comma, redefine COLUMN_SEPARATOR if needed.
+    Run script.
+
+    Note: By commenting or deleting everything, including,
+    the <comment_or_delete> tags it is ready to be used
+    as an additional lexer
+
+"""
+
+from Npp import editor, notepad, LEXER, SCINTILLANOTIFICATION, NOTIFICATION, LANGTYPE
+
+try:
+    # on first run this will generate an NameError exception
+    COLUMN_LEXER().main()
+except NameError:
+
+    class COLUMN_LEXER_SINGLETON(type):
+        ''' Ensures that only one column lexer instance exists and 
+            prevents of getting multiple callbacks
+        '''
+        _instance = None
+        def __call__(cls, *args, **kwargs):
+            ''' The real constructor and first method called when
+                a new instance should be created.
+                On first instantiation class variable _instance gets itself assigned,
+                every subsequent instantiation try returns this object
+            '''
+            if cls._instance is None:
+                cls._instance = super(COLUMN_LEXER_SINGLETON, cls).__call__(*args, **kwargs)
+            return cls._instance
+
+    class COLUMN_LEXER(object):
+        ''' A column based lexer implementation.
+            Odd and even columns do get different styles assigned.
+            Only one separator can be defined.
+            Line-based approach - styling takes place when new line has been added
+        '''
+        __metaclass__ = COLUMN_LEXER_SINGLETON
+
+        DEFAULT = 0 # don't change it
+        ODD_COLUMN_STYLE = 50
+        EVEN_COLUMN_STYLE = 51
+        COLUMN_SEPARATOR = ','
+
+        def __init__(self):
+            ''' Register needed callbacks on first class instantiation '''
+            editor.callbackSync(self.styleneeded_callback, [SCINTILLANOTIFICATION.STYLENEEDED])
+            notepad.callback(self.bufferactivated_callback, [NOTIFICATION.BUFFERACTIVATED])
+            notepad.callback(self.langchanged_callback, [NOTIFICATION.LANGCHANGED])
+
+
+        def column_lexer(self, start_pos, end_pos):
+            ''' Main lexing logic.
+                Gets called by styleneeded callback
+            '''
+            
+            def style_it(start, length, STYLE):
+                ''' Inform scintilla to do the styling'''
+                if length >= 0:
+                    editor.startStyling(start, 31)
+                    editor.setStyling(length, STYLE)
+
+            # first everything will be styled with default style
+            style_it(start_pos, end_pos-start_pos, self.DEFAULT)
+
+            # loop over line indexes from start_pos and end_pos
+            for line in range(editor.lineFromPosition(start_pos), editor.lineFromPosition(end_pos)):
+                # get start position for each line
+                line_start_pos = editor.positionFromLine(line)
+                # split current line into columns
+                columns = editor.getLine(line).split(self.COLUMN_SEPARATOR)
+                if columns > 0:
+                    # iterate over all columns
+                    for i, column in enumerate(columns):
+                        # get the width of the current column
+                        col_length = len(column)
+                        if i % 2 == 0:
+                            # even column
+                            style_it(line_start_pos,col_length,self.EVEN_COLUMN_STYLE)
+                        else:
+                            # odd column
+                            style_it(line_start_pos,col_length, self.ODD_COLUMN_STYLE)
+                        # recalculate start position for next column
+                        line_start_pos += col_length+1
+
+            # this needs to stay and to be the last line, to signal scintilla we are done.
+            editor.startStyling(end_pos,31)
+
+        def init_scintilla(self):
+            ''' Initialize configured styles '''
+            editor.setMarginWidthN(0,38)
+            editor.setMarginWidthN(1,14)
+            editor.setMarginWidthN(2,0)
+
+            if editor.getLexer() != LEXER.CONTAINER:
+                editor.setLexer(LEXER.CONTAINER)
+
+            editor.styleSetFore(self.ODD_COLUMN_STYLE,  (54,125,198))
+            editor.styleSetFore(self.EVEN_COLUMN_STYLE, (87,166,74))
+            editor.styleSetBack(self.EVEN_COLUMN_STYLE, (0,50,20))
+
+
+        def set_lexer_doc(self, bool_value):
+            ''' Assign the class name as an additional property
+                to every document which should be handled by this lexer
+                A value of 1 indicates it should be handled.
+            '''
+            editor.setProperty(self.__class__.__name__, 1 if bool_value is True else 0)
+
+
+        def is_lexer_doc(self):
+            ''' Check if the current document is of interest
+                by reading the class name property.
+            '''
+            return True if editor.getPropertyInt(self.__class__.__name__) == 1 else False
+
+
+        def styleneeded_callback(self,args):
+            ''' Called by scintilla to inform the lexer 
+                about the need to style the document.
+                If document is of interest call main logic (column_lexer) function
+                Ensures that the start position is really the first position per line
+            '''
+            if self.is_lexer_doc():
+                startPos = editor.getEndStyled()
+                lineNumber = editor.lineFromPosition(startPos)
+                startPos = editor.positionFromLine(lineNumber)
+                self.column_lexer(startPos, args['position'])
+
+
+        def bufferactivated_callback(self,args):
+            ''' Called by notepad when document switch happens
+                If document is of interest styles need to be reinitialized
+            '''
+            if self.is_lexer_doc():
+                self.init_scintilla()
+
+
+        def langchanged_callback(self,args):
+            ''' Called by notepad when a built-in or udl language switch happens
+                If document was previously styled by this lexer it will be reset
+                and therefore will not be styled by this lexer anymore until 
+                script gets executed on this document again.
+            '''
+            if self.is_lexer_doc():
+                self.set_lexer_doc(False)
+
+
+        def main(self):
+            ''' Main entry point
+                To prevent issues with other lexers document language will 
+                be set to normal text, then document does get the class name
+                property assigned, styles do get initialized and main lexing
+                function does get called on whole document
+            '''
+            notepad.setLangType(LANGTYPE.TXT)
+            self.set_lexer_doc(True)
+            self.init_scintilla()
+            self.column_lexer(0, editor.getTextLength())
+
+        # <comment_or_delete>
+        # just some demo text not really needed by lexer
+        notepad.new()
+        editor.appendText('''
+col1,col2,col3,col4
+col1 , col2, col3  ,  col4
+,,col3,col4
+col1,column2,col3,colum4
+jdjkslddskjfd,jfdksldlskdfkjklsdfs,jfkdslldkjfds,jkfdjskdlskdfj
+'''
+        )
+        # </comment_or_delete>
+
+    COLUMN_LEXER().main()

scripts/Samples/EnhancedPythonLexer.py

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+"""
+    EnhancedPythonLexer
+    
+    Sometimes a built-in lexer isn't doing what one wants.
+    To enhance the built-in lexer, indicators can be used, which also automatically 
+    prevent clashes with the styling operations done by the built-in lexer.
+    The only potential issue might be using an indicator used by npp itself.
+    
+    Usage: 
+        In the main function
+            - define the lexer_name to be enhanced and
+            - create the regex_dict with the regular expressions and
+            - the associate colours
+            
+        The regex dict must be in form key_tuple:value_tuple.
+        
+        The key_tuple needs to have an unique ID followed by a colour tuple,
+        like (3, (181, 188, 201)). 
+        In this case the same colour can be used with different regexes.
+        
+        The value_tuple should use an unicode string followed by a number
+        indicating the (sub-)match, 
+        like (u'\\b(cls|self)\\b',0)
+        which would colour the main match (the words cls and self) or like
+        (u'(?:(?:def)\s\w+)\s*\((.*)\):',1)
+        which would colour the first submatch, which is (.*) and in this case
+        are basically the parameters of a python function.      
+        
+        Run script.
+        
+        Note: could be used as an UDL alternative as well.
+
+"""
+
+from Npp import editor, editor1, editor2, notepad, NOTIFICATION, SCINTILLANOTIFICATION, INDICATORSTYLE
+
+try:
+    EnhancedPythonLexer().main()
+except NameError:
+
+    # ensure that only a single instance is used to prevent getting
+    # multiple callbacks executed
+    class SingletonEnhancedPythonLexer(type):
+        _instance = None
+        def __call__(cls, *args, **kwargs):
+            if cls._instance is None:
+                cls._instance = super(SingletonEnhancedPythonLexer, cls).__call__(*args, **kwargs)
+            return cls._instance
+
+
+    # main class
+    class EnhancedPythonLexer(object):
+
+        __metaclass__ = SingletonEnhancedPythonLexer
+
+        @staticmethod
+        def set_indicator_attributes(indicator_number, fore=(0,0,0)):
+            editor1.indicSetFore(indicator_number, fore)
+            editor1.indicSetStyle(indicator_number, INDICATORSTYLE.TEXTFORE)
+            editor2.indicSetFore(indicator_number, fore)
+            editor2.indicSetStyle(indicator_number, INDICATORSTYLE.TEXTFORE)
+            return indicator_number
+
+
+        @staticmethod
+        def paint_it(indicator, pos, length):
+            current_line = editor.lineFromPosition(pos)
+            line_start_position = editor.positionFromLine(current_line)
+            text = editor.getLine(current_line)
+            found_comment_char = text.find('#')
+            relative_line_position = pos-line_start_position
+            if((-1 < found_comment_char < relative_line_position) or
+               (text.count('"', 0, relative_line_position) % 2 == 1) or
+               (text.count("'", 0, relative_line_position) % 2 == 1)):
+                return
+            else:
+                editor.setIndicatorCurrent(indicator)
+                editor.indicatorFillRange(pos,length)
+
+
+        def do_regex(self, regex, indicator, start_position, end_position):
+            editor.setIndicatorCurrent(indicator)
+            editor.indicatorClearRange(start_position, end_position-start_position)
+            editor.research(regex[0],
+                            lambda m: self.paint_it(indicator, m.span(regex[1])[0], m.span(regex[1])[1] - m.span(regex[1])[0]),
+                            0,
+                            start_position,
+                            end_position)
+
+
+        def style(self):
+            line_number = editor.getFirstVisibleLine()
+            start_position = editor.positionFromLine(line_number)
+            end_position = editor.getLineEndPosition(line_number + editor.linesOnScreen())
+            for indicator, regex in self.regex_dict.items():
+                self.do_regex(regex, indicator, start_position, end_position)
+
+
+        def __init__(self):
+            editor.callbackSync(self.on_updateui, [SCINTILLANOTIFICATION.UPDATEUI])
+            notepad.callback(self.on_langchanged, [NOTIFICATION.LANGCHANGED])
+            notepad.callback(self.on_bufferactivated, [NOTIFICATION.BUFFERACTIVATED])
+            self.__is_lexer_doc = False
+            self.get_lexer_name = lambda: notepad.getLanguageName(notepad.getLangType())
+
+
+        def set_lexer_doc(self,bool_value):
+            editor.setProperty(self.__class__.__name__, 1 if bool_value is True else -1)
+            self.__is_lexer_doc = bool_value
+
+
+        def on_bufferactivated(self,args):
+            if (self.get_lexer_name() == self.lexer_name) and (editor.getPropertyInt(self.__class__.__name__) != -1):
+                self.__is_lexer_doc = True
+            else:
+                self.__is_lexer_doc = False
+
+
+        def on_updateui(self,args):
+            if self.__is_lexer_doc:
+                self.style()
+
+
+        def on_langchanged(self,args):
+            self.set_lexer_doc(True if self.get_lexer_name() == self.lexer_name else False)
+
+
+        # customize, if needed
+        def main(self):
+            # basically what is returned by notepad.getLanguageName(notepad.getLangType())
+            self.lexer_name = 'Python'
+
+            self.regex_dict = {
+                                self.set_indicator_attributes(0, (224, 108, 117)) : (u'\\b(cls|self)\\b', 0), # cls and self objects
+                                self.set_indicator_attributes(1, (209, 154, 102)) : (u'(?:(?:def)\s\w+)\s*\((.*)\):', 1), # function parameter
+                                self.set_indicator_attributes(2, (86, 182, 194))  : (u'(\\beditor\\b|\\beditor1\\b|\\beditor2\\b|\\bnotepad\\b|\\bconsole\\b|\\b__init__\\b|\\b__call__\\b|\\b__del__\\b|\\bsuper\\b|\\bobject\\b|\\btype\\b|\\bprint\\b)', 0), # dunder functions and special keywords
+                                self.set_indicator_attributes(3, (181, 188, 201)) : (u'[\(\)\[\]\{\}\=,]', 0), # delimiters - default color
+                                self.set_indicator_attributes(4, (181, 188, 201)) : (u'\(\\b(bcls|self)\\b', 1), # cls and self object within function parameters - default color
+                                self.set_indicator_attributes(5, (181, 188, 201)) : (u'\(\s*\K\*\*|\(\s*\K\*|,\s*\K\*\*|,\s*\K\*', 0), # args and kwargs references within function parameters - default color
+                                self.set_indicator_attributes(6, (79, 175, 239))  : (u'(?(?<=def )(?:)(?=\()|(?(?<!class )\\b\w+?\\b(?=\()|(?:)))', 0), # functions and class instances but not definitions
+                              }
+
+            self.set_lexer_doc(True)
+            self.style()
+
+
+    EnhancedPythonLexer().main()
+