| import string |
| 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 |
| |
| |
| |
| 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, # TBD: kludge |
| self._ARROWHEIGHT - self._TEXTYOFFSET, |
| text='128', |
| tags=self._TAG) |
| return arrow, text |
| |
| def _x(self): |
| coords = self._canvas.bbox(self._TAG) |
| assert coords |
| return coords[2] - 6 # TBD: kludge |
| |
| |
| |
| class StripWidget: |
| _CHIPHEIGHT = 50 |
| _CHIPWIDTH = 10 |
| _NUMCHIPS = 40 |
| |
| def __init__(self, switchboard, |
| parent = None, |
| color = (128, 128, 128), |
| chipwidth = self._CHIPWIDTH, |
| chipheight = self._CHIPHEIGHT, |
| numchips = self._NUMCHIPS, |
| generator = None, |
| axis = None, |
| label = ''): |
| # the last chip selected |
| self.__lastchip = None |
| self.__sb = switchboard |
| |
| canvaswidth = numchips * (chipwidth + 1) |
| canvasheight = chipheight + 43 # TBD: Kludge |
| |
| # create the canvas and pack it |
| canvas = self.__canvas = Canvas( |
| parent, |
| 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' |
| rect = 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=self['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) |
| |
| self.__generator = generator |
| self.__axis = axis |
| assert self.__axis in (0, 1, 2) |
| self.__update_while_dragging = 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 __set_color(self): |
| rgbtuple = self['color'] |
| self.set_color(self, rgbtuple) |
| |
| def __arrow_x(self, chipnum): |
| coords = self.__canvas.coords(chipnum+1) |
| assert coords |
| x0, y0, x1, y1 = coords |
| return (x1 + x0) / 2.0 |
| |
| def __select_chip(self, event=None): |
| if self.__delegate: |
| 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] |
| rgbtuple = ColorDB.rrggbb_to_triplet(color) |
| etype = int(event.type) |
| if (etype == BTNUP or self.__update_while_dragging): |
| # update everyone |
| self.__delegate.set_color(self, rgbtuple) |
| else: |
| # just track the arrows |
| self.__trackarrow(chip[0], rgbtuple) |
| |
| |
| def __set_delegate(self): |
| self.__delegate = self['delegate'] |
| |
| |
| 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] |
| text = repr(coloraxis) |
| # move the arrow, and set it's 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 <= 0.5: |
| outline = 'white' |
| else: |
| outline = 'black' |
| self.__canvas.itemconfigure(chip, outline=outline) |
| |
| |
| # |
| # public interface |
| # |
| |
| def update_yourself(self, red, green, blue): |
| assert self.__generator |
| i = 1 |
| chip = 0 |
| chips = self.__chips = [] |
| tclcmd = [] |
| tk = self.__canvas.tk |
| # get the red, green, and blue components for all chips |
| for t in self.__generator(self.__numchips, rgbtuple): |
| 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 = string.join(chips) |
| tk.eval('setcolor %s {%s}' % (self.__canvas._w, colors)) |
| # move the arrows around |
| self.__trackarrow(chip, (red, green, blue)) |
| |
| def set_update_while_dragging(self, flag): |
| self.__update_while_dragging = flag |