/Windows/Python3.8/WPy64-3830/WPy64-3830/python-3.8.3.amd64/Lib/idlelib/colorizer.py

import builtins

import keyword

import re

import time



from idlelib.config import idleConf

from idlelib.delegator import Delegator



DEBUG = False



def any(name, alternates):

    "Return a named group pattern matching list of alternates."

    return "(?P<%s>" % name + "|".join(alternates) + ")"



def make_pat():

    kw = r"\b" + any("KEYWORD", keyword.kwlist) + r"\b"

    builtinlist = [str(name) for name in dir(builtins)

                                        if not name.startswith('_') and \

                                        name not in keyword.kwlist]

    builtin = r"([^.'\"\\#]\b|^)" + any("BUILTIN", builtinlist) + r"\b"

    comment = any("COMMENT", [r"#[^\n]*"])

    stringprefix = r"(?i:r|u|f|fr|rf|b|br|rb)?"

    sqstring = stringprefix + r"'[^'\\\n]*(\\.[^'\\\n]*)*'?"

    dqstring = stringprefix + r'"[^"\\\n]*(\\.[^"\\\n]*)*"?'

    sq3string = stringprefix + r"'''[^'\\]*((\\.|'(?!''))[^'\\]*)*(''')?"

    dq3string = stringprefix + r'"""[^"\\]*((\\.|"(?!""))[^"\\]*)*(""")?'

    string = any("STRING", [sq3string, dq3string, sqstring, dqstring])

    return kw + "|" + builtin + "|" + comment + "|" + string +\

           "|" + any("SYNC", [r"\n"])



prog = re.compile(make_pat(), re.S)

idprog = re.compile(r"\s+(\w+)", re.S)



def color_config(text):

    """Set color options of Text widget.



    If ColorDelegator is used, this should be called first.

    """

    # Called from htest, TextFrame, Editor, and Turtledemo.

    # Not automatic because ColorDelegator does not know 'text'.

    theme = idleConf.CurrentTheme()

    normal_colors = idleConf.GetHighlight(theme, 'normal')

    cursor_color = idleConf.GetHighlight(theme, 'cursor')['foreground']

    select_colors = idleConf.GetHighlight(theme, 'hilite')

    text.config(

        foreground=normal_colors['foreground'],

        background=normal_colors['background'],

        insertbackground=cursor_color,

        selectforeground=select_colors['foreground'],

        selectbackground=select_colors['background'],

        inactiveselectbackground=select_colors['background'],  # new in 8.5

    )





class ColorDelegator(Delegator):

    """Delegator for syntax highlighting (text coloring).



    Instance variables:

        delegate: Delegator below this one in the stack, meaning the

                one this one delegates to.



        Used to track state:

        after_id: Identifier for scheduled after event, which is a

                timer for colorizing the text.

        allow_colorizing: Boolean toggle for applying colorizing.

        colorizing: Boolean flag when colorizing is in process.

        stop_colorizing: Boolean flag to end an active colorizing

                process.

    """



    def __init__(self):

        Delegator.__init__(self)

        self.init_state()

        self.prog = prog

        self.idprog = idprog

        self.LoadTagDefs()



    def init_state(self):

        "Initialize variables that track colorizing state."

        self.after_id = None

        self.allow_colorizing = True

        self.stop_colorizing = False

        self.colorizing = False



    def setdelegate(self, delegate):

        """Set the delegate for this instance.



        A delegate is an instance of a Delegator class and each

        delegate points to the next delegator in the stack.  This

        allows multiple delegators to be chained together for a

        widget.  The bottom delegate for a colorizer is a Text

        widget.



        If there is a delegate, also start the colorizing process.

        """

        if self.delegate is not None:

            self.unbind("<<toggle-auto-coloring>>")

        Delegator.setdelegate(self, delegate)

        if delegate is not None:

            self.config_colors()

            self.bind("<<toggle-auto-coloring>>", self.toggle_colorize_event)

            self.notify_range("1.0", "end")

        else:

            # No delegate - stop any colorizing.

            self.stop_colorizing = True

            self.allow_colorizing = False



    def config_colors(self):

        "Configure text widget tags with colors from tagdefs."

        for tag, cnf in self.tagdefs.items():

            self.tag_configure(tag, **cnf)

        self.tag_raise('sel')



    def LoadTagDefs(self):

        "Create dictionary of tag names to text colors."

        theme = idleConf.CurrentTheme()

        self.tagdefs = {

            "COMMENT": idleConf.GetHighlight(theme, "comment"),

            "KEYWORD": idleConf.GetHighlight(theme, "keyword"),

            "BUILTIN": idleConf.GetHighlight(theme, "builtin"),

            "STRING": idleConf.GetHighlight(theme, "string"),

            "DEFINITION": idleConf.GetHighlight(theme, "definition"),

            "SYNC": {'background':None,'foreground':None},

            "TODO": {'background':None,'foreground':None},

            "ERROR": idleConf.GetHighlight(theme, "error"),

            # The following is used by ReplaceDialog:

            "hit": idleConf.GetHighlight(theme, "hit"),

            }



        if DEBUG: print('tagdefs',self.tagdefs)



    def insert(self, index, chars, tags=None):

        "Insert chars into widget at index and mark for colorizing."

        index = self.index(index)

        self.delegate.insert(index, chars, tags)

        self.notify_range(index, index + "+%dc" % len(chars))



    def delete(self, index1, index2=None):

        "Delete chars between indexes and mark for colorizing."

        index1 = self.index(index1)

        self.delegate.delete(index1, index2)

        self.notify_range(index1)



    def notify_range(self, index1, index2=None):

        "Mark text changes for processing and restart colorizing, if active."

        self.tag_add("TODO", index1, index2)

        if self.after_id:

            if DEBUG: print("colorizing already scheduled")

            return

        if self.colorizing:

            self.stop_colorizing = True

            if DEBUG: print("stop colorizing")

        if self.allow_colorizing:

            if DEBUG: print("schedule colorizing")

            self.after_id = self.after(1, self.recolorize)

        return



    def close(self):

        if self.after_id:

            after_id = self.after_id

            self.after_id = None

            if DEBUG: print("cancel scheduled recolorizer")

            self.after_cancel(after_id)

        self.allow_colorizing = False

        self.stop_colorizing = True



    def toggle_colorize_event(self, event=None):

        """Toggle colorizing on and off.



        When toggling off, if colorizing is scheduled or is in

        process, it will be cancelled and/or stopped.



        When toggling on, colorizing will be scheduled.

        """

        if self.after_id:

            after_id = self.after_id

            self.after_id = None

            if DEBUG: print("cancel scheduled recolorizer")

            self.after_cancel(after_id)

        if self.allow_colorizing and self.colorizing:

            if DEBUG: print("stop colorizing")

            self.stop_colorizing = True

        self.allow_colorizing = not self.allow_colorizing

        if self.allow_colorizing and not self.colorizing:

            self.after_id = self.after(1, self.recolorize)

        if DEBUG:

            print("auto colorizing turned",\

                  self.allow_colorizing and "on" or "off")

        return "break"



    def recolorize(self):

        """Timer event (every 1ms) to colorize text.



        Colorizing is only attempted when the text widget exists,

        when colorizing is toggled on, and when the colorizing

        process is not already running.



        After colorizing is complete, some cleanup is done to

        make sure that all the text has been colorized.

        """

        self.after_id = None

        if not self.delegate:

            if DEBUG: print("no delegate")

            return

        if not self.allow_colorizing:

            if DEBUG: print("auto colorizing is off")

            return

        if self.colorizing:

            if DEBUG: print("already colorizing")

            return

        try:

            self.stop_colorizing = False

            self.colorizing = True

            if DEBUG: print("colorizing...")

            t0 = time.perf_counter()

            self.recolorize_main()

            t1 = time.perf_counter()

            if DEBUG: print("%.3f seconds" % (t1-t0))

        finally:

            self.colorizing = False

        if self.allow_colorizing and self.tag_nextrange("TODO", "1.0"):

            if DEBUG: print("reschedule colorizing")

            self.after_id = self.after(1, self.recolorize)



    def recolorize_main(self):

        "Evaluate text and apply colorizing tags."

        next = "1.0"

        while True:

            item = self.tag_nextrange("TODO", next)

            if not item:

                break

            head, tail = item

            self.tag_remove("SYNC", head, tail)

            item = self.tag_prevrange("SYNC", head)

            if item:

                head = item[1]

            else:

                head = "1.0"



            chars = ""

            next = head

            lines_to_get = 1

            ok = False

            while not ok:

                mark = next

                next = self.index(mark + "+%d lines linestart" %

                                         lines_to_get)

                lines_to_get = min(lines_to_get * 2, 100)

                ok = "SYNC" in self.tag_names(next + "-1c")

                line = self.get(mark, next)

                ##print head, "get", mark, next, "->", repr(line)

                if not line:

                    return

                for tag in self.tagdefs:

                    self.tag_remove(tag, mark, next)

                chars = chars + line

                m = self.prog.search(chars)

                while m:

                    for key, value in m.groupdict().items():

                        if value:

                            a, b = m.span(key)

                            self.tag_add(key,

                                         head + "+%dc" % a,

                                         head + "+%dc" % b)

                            if value in ("def", "class"):

                                m1 = self.idprog.match(chars, b)

                                if m1:

                                    a, b = m1.span(1)

                                    self.tag_add("DEFINITION",

                                                 head + "+%dc" % a,

                                                 head + "+%dc" % b)

                    m = self.prog.search(chars, m.end())

                if "SYNC" in self.tag_names(next + "-1c"):

                    head = next

                    chars = ""

                else:

                    ok = False

                if not ok:

                    # We're in an inconsistent state, and the call to

                    # update may tell us to stop.  It may also change

                    # the correct value for "next" (since this is a

                    # line.col string, not a true mark).  So leave a

                    # crumb telling the next invocation to resume here

                    # in case update tells us to leave.

                    self.tag_add("TODO", next)

                self.update()

                if self.stop_colorizing:

                    if DEBUG: print("colorizing stopped")

                    return



    def removecolors(self):

        "Remove all colorizing tags."

        for tag in self.tagdefs:

            self.tag_remove(tag, "1.0", "end")





def _color_delegator(parent):  # htest #

    from tkinter import Toplevel, Text

    from idlelib.percolator import Percolator



    top = Toplevel(parent)

    top.title("Test ColorDelegator")

    x, y = map(int, parent.geometry().split('+')[1:])

    top.geometry("700x250+%d+%d" % (x + 20, y + 175))

    source = (

        "if True: int ('1') # keyword, builtin, string, comment\n"

        "elif False: print(0)\n"

        "else: float(None)\n"

        "if iF + If + IF: 'keyword matching must respect case'\n"

        "if'': x or''  # valid string-keyword no-space combinations\n"

        "async def f(): await g()\n"

        "# All valid prefixes for unicode and byte strings should be colored.\n"

        "'x', '''x''', \"x\", \"\"\"x\"\"\"\n"

        "r'x', u'x', R'x', U'x', f'x', F'x'\n"

        "fr'x', Fr'x', fR'x', FR'x', rf'x', rF'x', Rf'x', RF'x'\n"

        "b'x',B'x', br'x',Br'x',bR'x',BR'x', rb'x', rB'x',Rb'x',RB'x'\n"

        "# Invalid combinations of legal characters should be half colored.\n"

        "ur'x', ru'x', uf'x', fu'x', UR'x', ufr'x', rfu'x', xf'x', fx'x'\n"

        )

    text = Text(top, background="white")

    text.pack(expand=1, fill="both")

    text.insert("insert", source)

    text.focus_set()



    color_config(text)

    p = Percolator(text)

    d = ColorDelegator()

    p.insertfilter(d)





if __name__ == "__main__":

    from unittest import main

    main('idlelib.idle_test.test_colorizer', verbosity=2, exit=False)



    from idlelib.idle_test.htest import run

    run(_color_delegator)