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