home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 April / PCWorld_2001-04_cd.bin / Software / TemaCD / webclean / !!!python!!! / BeOpen-Python-2.0.exe / STRIPVIEWER.PY < prev    next >
Encoding:
Python Source  |  2000-09-28  |  14.7 KB  |  433 lines
  1. """Strip viewer and related widgets.
  2.  
  3. The classes in this file implement the StripViewer shown in the top two thirds 
  4. of the main Pynche window.  It consists of three StripWidgets which display
  5. the variations in red, green, and blue respectively of the currently selected
  6. r/g/b color value.
  7.  
  8. Each StripWidget shows the color variations that are reachable by varying an
  9. axis of the currently selected color.  So for example, if the color is
  10.  
  11.   (R,G,B)=(127,163,196)
  12.  
  13. then the Red variations show colors from (0,163,196) to (255,163,196), the
  14. Green variations show colors from (127,0,196) to (127,255,196), and the Blue
  15. variations show colors from (127,163,0) to (127,163,255).
  16.  
  17. The selected color is always visible in all three StripWidgets, and in fact
  18. each StripWidget highlights the selected color, and has an arrow pointing to
  19. the selected chip, which includes the value along that particular axis.
  20.  
  21. Clicking on any chip in any StripWidget selects that color, and updates all
  22. arrows and other windows.  By toggling on Update while dragging, Pynche will
  23. select the color under the cursor while you drag it, but be forewarned that
  24. this can be slow.
  25. """
  26.  
  27. import string
  28. from Tkinter import *
  29. import ColorDB
  30.  
  31. # Load this script into the Tcl interpreter and call it in
  32. # StripWidget.set_color().  This is about as fast as it can be with the
  33. # current _tkinter.c interface, which doesn't support Tcl Objects.
  34. TCLPROC = '''\
  35. proc setcolor {canv colors} {
  36.     set i 1
  37.     foreach c $colors {
  38.         $canv itemconfigure $i -fill $c -outline $c
  39.     incr i
  40.     }
  41. }
  42. '''
  43.  
  44. # Tcl event types
  45. BTNDOWN = 4
  46. BTNUP = 5
  47. BTNDRAG = 6
  48.  
  49.  
  50. def constant(numchips):
  51.     step = 255.0 / (numchips - 1)
  52.     start = 0.0
  53.     seq = []
  54.     while numchips > 0:
  55.     seq.append(int(start))
  56.     start = start + step
  57.     numchips = numchips - 1
  58.     return seq
  59.  
  60. # red variations, green+blue = cyan constant
  61. def constant_red_generator(numchips, red, green, blue):
  62.     seq = constant(numchips)
  63.     return map(None, [red] * numchips, seq, seq)
  64.  
  65. # green variations, red+blue = magenta constant
  66. def constant_green_generator(numchips, red, green, blue):
  67.     seq = constant(numchips)
  68.     return map(None, seq, [green] * numchips, seq)
  69.  
  70. # blue variations, red+green = yellow constant
  71. def constant_blue_generator(numchips, red, green, blue):
  72.     seq = constant(numchips)
  73.     return map(None, seq, seq, [blue] * numchips)
  74.  
  75. # red variations, green+blue = cyan constant
  76. def constant_cyan_generator(numchips, red, green, blue):
  77.     seq = constant(numchips)
  78.     return map(None, seq, [green] * numchips, [blue] * numchips)
  79.  
  80. # green variations, red+blue = magenta constant
  81. def constant_magenta_generator(numchips, red, green, blue):
  82.     seq = constant(numchips)
  83.     return map(None, [red] * numchips, seq, [blue] * numchips)
  84.  
  85. # blue variations, red+green = yellow constant
  86. def constant_yellow_generator(numchips, red, green, blue):
  87.     seq = constant(numchips)
  88.     return map(None, [red] * numchips, [green] * numchips, seq)
  89.  
  90.  
  91.  
  92. class LeftArrow:
  93.     _ARROWWIDTH = 30
  94.     _ARROWHEIGHT = 15
  95.     _YOFFSET = 13
  96.     _TEXTYOFFSET = 1
  97.     _TAG = ('leftarrow',)
  98.  
  99.     def __init__(self, canvas, x):
  100.     self._canvas = canvas
  101.     self.__arrow, self.__text = self._create(x)
  102.     self.move_to(x)
  103.  
  104.     def _create(self, x):
  105.     arrow = self._canvas.create_line(
  106.         x, self._ARROWHEIGHT + self._YOFFSET,
  107.         x, self._YOFFSET,
  108.         x + self._ARROWWIDTH, self._YOFFSET,
  109.         arrow='first',
  110.         width=3.0,
  111.         tags=self._TAG)
  112.     text = self._canvas.create_text(
  113.         x + self._ARROWWIDTH + 13,
  114.         self._ARROWHEIGHT - self._TEXTYOFFSET,
  115.         tags=self._TAG,
  116.         text='128')
  117.     return arrow, text
  118.  
  119.     def _x(self):
  120.     coords = self._canvas.coords(self._TAG)
  121.     assert coords
  122.     return coords[0]
  123.  
  124.     def move_to(self, x):
  125.     deltax = x - self._x()
  126.     self._canvas.move(self._TAG, deltax, 0)
  127.  
  128.     def set_text(self, text):
  129.     self._canvas.itemconfigure(self.__text, text=text)
  130.  
  131.  
  132. class RightArrow(LeftArrow):
  133.     _TAG = ('rightarrow',)
  134.  
  135.     def _create(self, x):
  136.     arrow = self._canvas.create_line(
  137.         x, self._YOFFSET,
  138.         x + self._ARROWWIDTH, self._YOFFSET,
  139.         x + self._ARROWWIDTH, self._ARROWHEIGHT + self._YOFFSET,
  140.         arrow='last',
  141.         width=3.0,
  142.         tags=self._TAG)
  143.     text = self._canvas.create_text(
  144.         x - self._ARROWWIDTH + 15,          # TBD: kludge
  145.         self._ARROWHEIGHT - self._TEXTYOFFSET,
  146.             justify=RIGHT,
  147.         text='128',
  148.         tags=self._TAG)
  149.     return arrow, text
  150.  
  151.     def _x(self):
  152.     coords = self._canvas.bbox(self._TAG)
  153.     assert coords
  154.     return coords[2] - 6              # TBD: kludge
  155.  
  156.  
  157.  
  158. class StripWidget:
  159.     _CHIPHEIGHT = 50
  160.     _CHIPWIDTH = 10
  161.     _NUMCHIPS = 40
  162.  
  163.     def __init__(self, switchboard,
  164.                  master     = None,
  165.                  chipwidth  = _CHIPWIDTH,
  166.                  chipheight = _CHIPHEIGHT,
  167.                  numchips   = _NUMCHIPS,
  168.                  generator  = None,
  169.                  axis       = None,
  170.                  label      = '',
  171.                  uwdvar     = None,
  172.                  hexvar     = None):
  173.         # instance variables
  174.     self.__generator = generator
  175.     self.__axis = axis
  176.         self.__numchips = numchips
  177.     assert self.__axis in (0, 1, 2)
  178.     self.__uwd = uwdvar
  179.         self.__hexp = hexvar
  180.         # the last chip selected
  181.         self.__lastchip = None
  182.         self.__sb = switchboard
  183.         
  184.     canvaswidth = numchips * (chipwidth + 1)
  185.     canvasheight = chipheight + 43          # TBD: Kludge
  186.  
  187.     # create the canvas and pack it
  188.     canvas = self.__canvas = Canvas(master,
  189.                                         width=canvaswidth,
  190.                                         height=canvasheight,
  191. ##                                        borderwidth=2,
  192. ##                                        relief=GROOVE
  193.                                         )
  194.  
  195.     canvas.pack()
  196.     canvas.bind('<ButtonPress-1>', self.__select_chip)
  197.     canvas.bind('<ButtonRelease-1>', self.__select_chip)
  198.     canvas.bind('<B1-Motion>', self.__select_chip)
  199.  
  200.     # Load a proc into the Tcl interpreter.  This is used in the
  201.     # set_color() method to speed up setting the chip colors.
  202.     canvas.tk.eval(TCLPROC)
  203.  
  204.     # create the color strip
  205.     chips = self.__chips = []
  206.     x = 1
  207.     y = 30
  208.     tags = ('chip',)
  209.     for c in range(self.__numchips):
  210.         color = 'grey'
  211.         rect = canvas.create_rectangle(
  212.         x, y, x+chipwidth, y+chipheight,
  213.         fill=color, outline=color,
  214.         tags=tags)
  215.         x = x + chipwidth + 1          # for outline
  216.         chips.append(color)
  217.  
  218.     # create the strip label
  219.     self.__label = canvas.create_text(
  220.         3, y + chipheight + 8,
  221.         text=label,
  222.         anchor=W)
  223.  
  224.     # create the arrow and text item
  225.     chipx = self.__arrow_x(0)
  226.     self.__leftarrow = LeftArrow(canvas, chipx)
  227.  
  228.     chipx = self.__arrow_x(len(chips) - 1)
  229.     self.__rightarrow = RightArrow(canvas, chipx)
  230.  
  231.     def __arrow_x(self, chipnum):
  232.     coords = self.__canvas.coords(chipnum+1)
  233.     assert coords
  234.     x0, y0, x1, y1 = coords
  235.     return (x1 + x0) / 2.0
  236.  
  237.     # Invoked when one of the chips is clicked.  This should just tell the
  238.     # switchboard to set the color on all the output components
  239.     def __select_chip(self, event=None):
  240.         x = event.x
  241.         y = event.y
  242.         canvas = self.__canvas
  243.         chip = canvas.find_overlapping(x, y, x, y)
  244.         if chip and (1 <= chip[0] <= self.__numchips):
  245.             color = self.__chips[chip[0]-1]
  246.             red, green, blue = ColorDB.rrggbb_to_triplet(color)
  247.             etype = int(event.type)
  248.             if (etype == BTNUP or self.__uwd.get()):
  249.                 # update everyone
  250.                 self.__sb.update_views(red, green, blue)
  251.             else:
  252.                 # just track the arrows
  253.                 self.__trackarrow(chip[0], (red, green, blue))
  254.  
  255.     def __trackarrow(self, chip, rgbtuple):
  256.         # invert the last chip
  257.         if self.__lastchip is not None:
  258.             color = self.__canvas.itemcget(self.__lastchip, 'fill')
  259.             self.__canvas.itemconfigure(self.__lastchip, outline=color)
  260.         self.__lastchip = chip
  261.     # get the arrow's text
  262.     coloraxis = rgbtuple[self.__axis]
  263.         if self.__hexp.get():
  264.             # hex
  265.             text = hex(coloraxis)
  266.         else:
  267.             # decimal
  268.             text = repr(coloraxis)
  269.     # move the arrow, and set it's text
  270.     if coloraxis <= 128:
  271.         # use the left arrow
  272.         self.__leftarrow.set_text(text)
  273.         self.__leftarrow.move_to(self.__arrow_x(chip-1))
  274.         self.__rightarrow.move_to(-100)
  275.     else:
  276.         # use the right arrow
  277.         self.__rightarrow.set_text(text)
  278.         self.__rightarrow.move_to(self.__arrow_x(chip-1))
  279.         self.__leftarrow.move_to(-100)
  280.     # and set the chip's outline
  281.         brightness = ColorDB.triplet_to_brightness(rgbtuple)
  282.     if brightness <= 128:
  283.         outline = 'white'
  284.     else:
  285.         outline = 'black'
  286.     self.__canvas.itemconfigure(chip, outline=outline)
  287.  
  288.  
  289.     def update_yourself(self, red, green, blue):
  290.     assert self.__generator
  291.     i = 1
  292.     chip = 0
  293.     chips = self.__chips = []
  294.     tclcmd = []
  295.     tk = self.__canvas.tk
  296.         # get the red, green, and blue components for all chips
  297.         for t in self.__generator(self.__numchips, red, green, blue):
  298.             rrggbb = ColorDB.triplet_to_rrggbb(t)
  299.             chips.append(rrggbb)
  300.             tred, tgreen, tblue = t
  301.             if tred <= red and tgreen <= green and tblue <= blue:
  302.                 chip = i
  303.             i = i + 1
  304.         # call the raw tcl script
  305.         colors = string.join(chips)
  306.         tk.eval('setcolor %s {%s}' % (self.__canvas._w, colors))
  307.         # move the arrows around
  308.         self.__trackarrow(chip, (red, green, blue))
  309.  
  310.     def set(self, label, generator):
  311.         self.__canvas.itemconfigure(self.__label, text=label)
  312.         self.__generator = generator
  313.  
  314.  
  315. class StripViewer:
  316.     def __init__(self, switchboard, master=None):
  317.         self.__sb = switchboard
  318.         optiondb = switchboard.optiondb()
  319.         # create a frame inside the master.
  320.         frame = Frame(master, relief=RAISED, borderwidth=1)
  321.         frame.grid(row=1, column=0, columnspan=2, sticky='NSEW')
  322.         # create the options to be used later
  323.         uwd = self.__uwdvar = BooleanVar()
  324.         uwd.set(optiondb.get('UPWHILEDRAG', 0))
  325.         hexp = self.__hexpvar = BooleanVar()
  326.         hexp.set(optiondb.get('HEXSTRIP', 0))
  327.         # create the red, green, blue strips inside their own frame
  328.         frame1 = Frame(frame)
  329.         frame1.pack(expand=YES, fill=BOTH)
  330.         self.__reds = StripWidget(switchboard, frame1,
  331.                                   generator=constant_cyan_generator,
  332.                                   axis=0,
  333.                                   label='Red Variations',
  334.                                   uwdvar=uwd, hexvar=hexp)
  335.  
  336.         self.__greens = StripWidget(switchboard, frame1,
  337.                                     generator=constant_magenta_generator,
  338.                                     axis=1,
  339.                                     label='Green Variations',
  340.                                     uwdvar=uwd, hexvar=hexp)
  341.  
  342.         self.__blues = StripWidget(switchboard, frame1,
  343.                                    generator=constant_yellow_generator,
  344.                                    axis=2,
  345.                                    label='Blue Variations',
  346.                                    uwdvar=uwd, hexvar=hexp)
  347.  
  348.         # create a frame to contain the controls
  349.         frame2 = Frame(frame)
  350.         frame2.pack(expand=YES, fill=BOTH)
  351.         frame2.columnconfigure(0, weight=20)
  352.         frame2.columnconfigure(2, weight=20)
  353.  
  354.         padx = 8
  355.  
  356.         # create the black button
  357.         blackbtn = Button(frame2,
  358.                           text='Black',
  359.                           command=self.__toblack)
  360.         blackbtn.grid(row=0, column=0, rowspan=2, sticky=W, padx=padx)
  361.  
  362.         # create the controls
  363.         uwdbtn = Checkbutton(frame2,
  364.                              text='Update while dragging',
  365.                              variable=uwd)
  366.         uwdbtn.grid(row=0, column=1, sticky=W)
  367.         hexbtn = Checkbutton(frame2,
  368.                              text='Hexadecimal',
  369.                              variable=hexp,
  370.                              command=self.__togglehex)
  371.         hexbtn.grid(row=1, column=1, sticky=W)
  372.  
  373.         # XXX: ignore this feature for now; it doesn't work quite right yet
  374.         
  375. ##        gentypevar = self.__gentypevar = IntVar()
  376. ##        self.__variations = Radiobutton(frame,
  377. ##                                        text='Variations',
  378. ##                                        variable=gentypevar,
  379. ##                                        value=0,
  380. ##                                        command=self.__togglegentype)
  381. ##        self.__variations.grid(row=0, column=1, sticky=W)
  382. ##        self.__constants = Radiobutton(frame,
  383. ##                                       text='Constants',
  384. ##                                       variable=gentypevar,
  385. ##                                       value=1,
  386. ##                                       command=self.__togglegentype)
  387. ##        self.__constants.grid(row=1, column=1, sticky=W)
  388.  
  389.         # create the white button
  390.         whitebtn = Button(frame2,
  391.                           text='White',
  392.                           command=self.__towhite)
  393.         whitebtn.grid(row=0, column=2, rowspan=2, sticky=E, padx=padx)
  394.  
  395.     def update_yourself(self, red, green, blue):
  396.         self.__reds.update_yourself(red, green, blue)
  397.         self.__greens.update_yourself(red, green, blue)
  398.         self.__blues.update_yourself(red, green, blue)
  399.  
  400.     def __togglehex(self, event=None):
  401.         red, green, blue = self.__sb.current_rgb()
  402.         self.update_yourself(red, green, blue)
  403.  
  404.     def __togglegentype(self, event=None):
  405.         which = self.__gentypevar.get()
  406.         if which == 0:
  407.             self.__reds.set(label='Red Variations',
  408.                             generator=constant_cyan_generator)
  409.             self.__greens.set(label='Green Variations',
  410.                               generator=constant_magenta_generator)
  411.             self.__blues.set(label='Blue Variations',
  412.                              generator=constant_yellow_generator)
  413.         elif which == 1:
  414.             self.__reds.set(label='Red Constant',
  415.                             generator=constant_red_generator)
  416.             self.__greens.set(label='Green Constant',
  417.                               generator=constant_green_generator)
  418.             self.__blues.set(label='Blue Constant',
  419.                              generator=constant_blue_generator)
  420.         else:
  421.             assert 0
  422.         self.__sb.update_views_current()
  423.  
  424.     def __toblack(self, event=None):
  425.         self.__sb.update_views(0, 0, 0)
  426.  
  427.     def __towhite(self, event=None):
  428.         self.__sb.update_views(255, 255, 255)
  429.  
  430.     def save_options(self, optiondb):
  431.         optiondb['UPWHILEDRAG'] = self.__uwdvar.get()
  432.         optiondb['HEXSTRIP'] = self.__hexpvar.get()
  433.