"""Strip viewer and related widgets.

The classes in this file implement the StripViewer shown in the top two thirds

of the main Pynche window.  It consists of three StripWidgets which display

the variations in red, green, and blue respectively of the currently selected

r/g/b color value.

Each StripWidget shows the color variations that are reachable by varying an

axis of the currently selected color.  So for example, if the color is

  (R,G,B)=(127,163,196)

then the Red variations show colors from (0,163,196) to (255,163,196), the

Green variations show colors from (127,0,196) to (127,255,196), and the Blue

variations show colors from (127,163,0) to (127,163,255).

The selected color is always visible in all three StripWidgets, and in fact

each StripWidget highlights the selected color, and has an arrow pointing to

the selected chip, which includes the value along that particular axis.

Clicking on any chip in any StripWidget selects that color, and updates all

arrows and other windows.  By toggling on Update while dragging, Pynche will

select the color under the cursor while you drag it, but be forewarned that

this can be slow.

"""

from Tkinter import *

import ColorDB

# Load this script into the Tcl interpreter and call it in

# StripWidget.set_color().  This is about as fast as it can be with the

# current _tkinter.c interface, which doesn't support Tcl Objects.

TCLPROC = '''\

proc setcolor {canv colors} {

    set i 1

    foreach c $colors {

        $canv itemconfigure $i -fill $c -outline $c

        incr i

    }

}

'''

# Tcl event types

BTNDOWN = 4

BTNUP = 5

BTNDRAG = 6

SPACE = ' '

def constant(numchips):

    step = 255.0 / (numchips - 1)

    start = 0.0

    seq = []

    while numchips > 0:

        seq.append(int(start))

        start = start + step

        numchips = numchips - 1

    return seq

# red variations, green+blue = cyan constant

def constant_red_generator(numchips, red, green, blue):

    seq = constant(numchips)

    return map(None, [red] * numchips, seq, seq)

# green variations, red+blue = magenta constant

def constant_green_generator(numchips, red, green, blue):

    seq = constant(numchips)

    return map(None, seq, [green] * numchips, seq)

# blue variations, red+green = yellow constant

def constant_blue_generator(numchips, red, green, blue):

    seq = constant(numchips)

    return map(None, seq, seq, [blue] * numchips)

# red variations, green+blue = cyan constant

def constant_cyan_generator(numchips, red, green, blue):

    seq = constant(numchips)

    return map(None, seq, [green] * numchips, [blue] * numchips)

# green variations, red+blue = magenta constant

def constant_magenta_generator(numchips, red, green, blue):

    seq = constant(numchips)

    return map(None, [red] * numchips, seq, [blue] * numchips)

# blue variations, red+green = yellow constant

def constant_yellow_generator(numchips, red, green, blue):

    seq = constant(numchips)

    return map(None, [red] * numchips, [green] * numchips, seq)

class LeftArrow:

    _ARROWWIDTH = 30

    _ARROWHEIGHT = 15

    _YOFFSET = 13

    _TEXTYOFFSET = 1

    _TAG = ('leftarrow',)

    def __init__(self, canvas, x):

        self._canvas = canvas

        self.__arrow, self.__text = self._create(x)

        self.move_to(x)

    def _create(self, x):

        arrow = self._canvas.create_line(

            x, self._ARROWHEIGHT + self._YOFFSET,

            x, self._YOFFSET,

            x + self._ARROWWIDTH, self._YOFFSET,

            arrow='first',

            width=3.0,

            tags=self._TAG)

        text = self._canvas.create_text(

            x + self._ARROWWIDTH + 13,

            self._ARROWHEIGHT - self._TEXTYOFFSET,

            tags=self._TAG,

            text='128')

        return arrow, text

    def _x(self):

        coords = self._canvas.coords(self._TAG)

        assert coords

        return coords[0]

    def move_to(self, x):

        deltax = x - self._x()

        self._canvas.move(self._TAG, deltax, 0)

    def set_text(self, text):

        self._canvas.itemconfigure(self.__text, text=text)

class RightArrow(LeftArrow):

    _TAG = ('rightarrow',)

    def _create(self, x):

        arrow = self._canvas.create_line(

            x, self._YOFFSET,

            x + self._ARROWWIDTH, self._YOFFSET,

            x + self._ARROWWIDTH, self._ARROWHEIGHT + self._YOFFSET,

            arrow='last',

            width=3.0,

            tags=self._TAG)

        text = self._canvas.create_text(

            x - self._ARROWWIDTH + 15,            # BAW: kludge

            self._ARROWHEIGHT - self._TEXTYOFFSET,

            justify=RIGHT,

            text='128',

            tags=self._TAG)

        return arrow, text

    def _x(self):

        coords = self._canvas.coords(self._TAG)

        assert coords

        return coords[0] + self._ARROWWIDTH

class StripWidget:

    _CHIPHEIGHT = 50

    _CHIPWIDTH = 10

    _NUMCHIPS = 40

    def __init__(self, switchboard,

                 master     = None,

                 chipwidth  = _CHIPWIDTH,

                 chipheight = _CHIPHEIGHT,

                 numchips   = _NUMCHIPS,

                 generator  = None,

                 axis       = None,

                 label      = '',

                 uwdvar     = None,

                 hexvar     = None):

        # instance variables

        self.__generator = generator

        self.__axis = axis

        self.__numchips = numchips

        assert self.__axis in (0, 1, 2)

        self.__uwd = uwdvar

        self.__hexp = hexvar

        # the last chip selected

        self.__lastchip = None

        self.__sb = switchboard

        canvaswidth = numchips * (chipwidth + 1)

        canvasheight = chipheight + 43            # BAW: Kludge

        # create the canvas and pack it

        canvas = self.__canvas = Canvas(master,

                                        width=canvaswidth,

                                        height=canvasheight,

##                                        borderwidth=2,

##                                        relief=GROOVE

                                        )

        canvas.pack()

        canvas.bind('<ButtonPress-1>', self.__select_chip)

        canvas.bind('<ButtonRelease-1>', self.__select_chip)

        canvas.bind('<B1-Motion>', self.__select_chip)

        # Load a proc into the Tcl interpreter.  This is used in the

        # set_color() method to speed up setting the chip colors.

        canvas.tk.eval(TCLPROC)

        # create the color strip

        chips = self.__chips = []

        x = 1

        y = 30

        tags = ('chip',)

        for c in range(self.__numchips):

            color = 'grey'

            canvas.create_rectangle(

                x, y, x+chipwidth, y+chipheight,

                fill=color, outline=color,

                tags=tags)

            x = x + chipwidth + 1                 # for outline

            chips.append(color)

        # create the strip label

        self.__label = canvas.create_text(

            3, y + chipheight + 8,

            text=label,

            anchor=W)

        # create the arrow and text item

        chipx = self.__arrow_x(0)

        self.__leftarrow = LeftArrow(canvas, chipx)

        chipx = self.__arrow_x(len(chips) - 1)

        self.__rightarrow = RightArrow(canvas, chipx)

    def __arrow_x(self, chipnum):

        coords = self.__canvas.coords(chipnum+1)

        assert coords

        x0, y0, x1, y1 = coords

        return (x1 + x0) / 2.0

    # Invoked when one of the chips is clicked.  This should just tell the

    # switchboard to set the color on all the output components

    def __select_chip(self, event=None):

        x = event.x

        y = event.y

        canvas = self.__canvas

        chip = canvas.find_overlapping(x, y, x, y)

        if chip and (1 <= chip[0] <= self.__numchips):

            color = self.__chips[chip[0]-1]

            red, green, blue = ColorDB.rrggbb_to_triplet(color)

            etype = int(event.type)

            if (etype == BTNUP or self.__uwd.get()):

                # update everyone

                self.__sb.update_views(red, green, blue)

            else:

                # just track the arrows

                self.__trackarrow(chip[0], (red, green, blue))

    def __trackarrow(self, chip, rgbtuple):

        # invert the last chip

        if self.__lastchip is not None:

            color = self.__canvas.itemcget(self.__lastchip, 'fill')

            self.__canvas.itemconfigure(self.__lastchip, outline=color)

        self.__lastchip = chip

        # get the arrow's text

        coloraxis = rgbtuple[self.__axis]

        if self.__hexp.get():

            # hex

            text = hex(coloraxis)

        else:

            # decimal

            text = repr(coloraxis)

        # move the arrow, and set its text

        if coloraxis <= 128:

            # use the left arrow

            self.__leftarrow.set_text(text)

            self.__leftarrow.move_to(self.__arrow_x(chip-1))

            self.__rightarrow.move_to(-100)

        else:

            # use the right arrow

            self.__rightarrow.set_text(text)

            self.__rightarrow.move_to(self.__arrow_x(chip-1))

            self.__leftarrow.move_to(-100)

        # and set the chip's outline

        brightness = ColorDB.triplet_to_brightness(rgbtuple)

        if brightness <= 128:

            outline = 'white'

        else:

            outline = 'black'

        self.__canvas.itemconfigure(chip, outline=outline)

    def update_yourself(self, red, green, blue):

        assert self.__generator

        i = 1

        chip = 0

        chips = self.__chips = []

        tk = self.__canvas.tk

        # get the red, green, and blue components for all chips

        for t in self.__generator(self.__numchips, red, green, blue):

            rrggbb = ColorDB.triplet_to_rrggbb(t)

            chips.append(rrggbb)

            tred, tgreen, tblue = t

            if tred <= red and tgreen <= green and tblue <= blue:

                chip = i

            i = i + 1

        # call the raw tcl script

        colors = SPACE.join(chips)

        tk.eval('setcolor %s {%s}' % (self.__canvas._w, colors))

        # move the arrows around

        self.__trackarrow(chip, (red, green, blue))

    def set(self, label, generator):

        self.__canvas.itemconfigure(self.__label, text=label)

        self.__generator = generator

class StripViewer:

    def __init__(self, switchboard, master=None):

        self.__sb = switchboard

        optiondb = switchboard.optiondb()

        # create a frame inside the master.

        frame = Frame(master, relief=RAISED, borderwidth=1)

        frame.grid(row=1, column=0, columnspan=2, sticky='NSEW')

        # create the options to be used later

        uwd = self.__uwdvar = BooleanVar()

        uwd.set(optiondb.get('UPWHILEDRAG', 0))

        hexp = self.__hexpvar = BooleanVar()

        hexp.set(optiondb.get('HEXSTRIP', 0))

        # create the red, green, blue strips inside their own frame

        frame1 = Frame(frame)

        frame1.pack(expand=YES, fill=BOTH)

        self.__reds = StripWidget(switchboard, frame1,

                                  generator=constant_cyan_generator,

                                  axis=0,

                                  label='Red Variations',

                                  uwdvar=uwd, hexvar=hexp)

        self.__greens = StripWidget(switchboard, frame1,

                                    generator=constant_magenta_generator,

                                    axis=1,

                                    label='Green Variations',

                                    uwdvar=uwd, hexvar=hexp)

        self.__blues = StripWidget(switchboard, frame1,

                                   generator=constant_yellow_generator,

                                   axis=2,

                                   label='Blue Variations',

                                   uwdvar=uwd, hexvar=hexp)

        # create a frame to contain the controls

        frame2 = Frame(frame)

        frame2.pack(expand=YES, fill=BOTH)

        frame2.columnconfigure(0, weight=20)

        frame2.columnconfigure(2, weight=20)

        padx = 8

        # create the black button

        blackbtn = Button(frame2,

                          text='Black',

                          command=self.__toblack)

        blackbtn.grid(row=0, column=0, rowspan=2, sticky=W, padx=padx)

        # create the controls

        uwdbtn = Checkbutton(frame2,

                             text='Update while dragging',

                             variable=uwd)

        uwdbtn.grid(row=0, column=1, sticky=W)

        hexbtn = Checkbutton(frame2,

                             text='Hexadecimal',

                             variable=hexp,

                             command=self.__togglehex)

        hexbtn.grid(row=1, column=1, sticky=W)

        # XXX: ignore this feature for now; it doesn't work quite right yet

##        gentypevar = self.__gentypevar = IntVar()

##        self.__variations = Radiobutton(frame,

##                                        text='Variations',

##                                        variable=gentypevar,

##                                        value=0,

##                                        command=self.__togglegentype)

##        self.__variations.grid(row=0, column=1, sticky=W)

##        self.__constants = Radiobutton(frame,

##                                       text='Constants',

##                                       variable=gentypevar,

##                                       value=1,

##                                       command=self.__togglegentype)

##        self.__constants.grid(row=1, column=1, sticky=W)

        # create the white button

        whitebtn = Button(frame2,

                          text='White',

                          command=self.__towhite)

        whitebtn.grid(row=0, column=2, rowspan=2, sticky=E, padx=padx)

    def update_yourself(self, red, green, blue):

        self.__reds.update_yourself(red, green, blue)

        self.__greens.update_yourself(red, green, blue)

        self.__blues.update_yourself(red, green, blue)

    def __togglehex(self, event=None):

        red, green, blue = self.__sb.current_rgb()

        self.update_yourself(red, green, blue)

##    def __togglegentype(self, event=None):

##        which = self.__gentypevar.get()

##        if which == 0:

##            self.__reds.set(label='Red Variations',

##                            generator=constant_cyan_generator)

##            self.__greens.set(label='Green Variations',

##                              generator=constant_magenta_generator)

##            self.__blues.set(label='Blue Variations',

##                             generator=constant_yellow_generator)

##        elif which == 1:

##            self.__reds.set(label='Red Constant',

##                            generator=constant_red_generator)

##            self.__greens.set(label='Green Constant',

##                              generator=constant_green_generator)

##            self.__blues.set(label='Blue Constant',

##                             generator=constant_blue_generator)

##        else:

##            assert 0

##        self.__sb.update_views_current()

    def __toblack(self, event=None):

        self.__sb.update_views(0, 0, 0)

    def __towhite(self, event=None):

        self.__sb.update_views(255, 255, 255)

    def save_options(self, optiondb):

        optiondb['UPWHILEDRAG'] = self.__uwdvar.get()

        optiondb['HEXSTRIP'] = self.__hexpvar.get()