cpython/Tools/pynche/StripViewer.py

from Tkinter import *
import Pmw
import ColorDB

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(Pmw.MegaWidget):
    _CHIPHEIGHT = 50
    _CHIPWIDTH = 10
    _NUMCHIPS = 40

    def __init__(self, parent=None, **kw):
	options = (('color', (128, 128, 128), self.__set_color),
		   ('delegate', None, None),
		   ('chipwidth', self._CHIPWIDTH, Pmw.INITOPT),
		   ('chipheight', self._CHIPHEIGHT, Pmw.INITOPT),
		   ('numchips', self._NUMCHIPS, Pmw.INITOPT),
		   ('generator', None, Pmw.INITOPT),
		   ('axis', None, Pmw.INITOPT),
		   ('label', '', Pmw.INITOPT),
		   )
	self.defineoptions(kw, options)

	Pmw.MegaWidget.__init__(self, parent)
	interiorarg = (self.interior(),)

	# group component contains a convas containing a bunch of objects
	# (moveable arrow + text label, relief'd rectangle color chips)
	chipwidth = self.__chipwidth = self['chipwidth']
	chipheight = self.__chipheight = self['chipheight']
	numchips = self.__numchips = self['numchips']

	canvaswidth = numchips * (chipwidth + 1)
	canvasheight = chipheight + 43		  # TBD: Kludge

	# create the canvas and pack it
	self.__canvas = Canvas(
	    parent,
	    width=canvaswidth,
	    height=canvasheight,
## 	    borderwidth=2,
## 	    relief=GROOVE
	    )

	self.__canvas.pack()
	self.__canvas.bind('<ButtonRelease-1>',
			   self.__select_chip)
	self.__canvas.bind('<B1-Motion>',
			   self.__select_chip)

	# create the color strip
	chips = self.__chips = []
	x = 1
	y = 30
	for c in range(self.__numchips):
	    rect = self.__canvas.create_rectangle(
		x, y, x+chipwidth, y+chipheight,
		fill='grey', outline='grey')

	    x = x + chipwidth + 1		  # for outline
	    chips.append(rect)

	# create the string tag
	self.__label = self.__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(self.__canvas, chipx)

	chipx = self.__arrow_x(len(chips) - 1)
	self.__rightarrow = RightArrow(self.__canvas, chipx)

	self.__generator = self['generator']
	self.__axis = self['axis']
	assert self.__axis in (0, 1, 2)
	self.initialiseoptions(StripWidget)

    def __set_color(self):
	rgbtuple = self['color']
	self.set_color(self, rgbtuple)

    def __arrow_x(self, chipnum):
	coords = self.__canvas.coords(self.__chips[chipnum])
	assert coords
	x0, y0, x1, y1 = coords
	return (x1 + x0) / 2.0

    def __select_chip(self, event=None):
	chip = self.__canvas.find_closest(event.x, event.y)
	delegate = self['delegate']
	if chip and delegate:
	    color = self.__canvas.itemcget(chip, 'fill')
	    rgbtuple = ColorDB.rrggbb_to_triplet(color)
	    delegate.set_color(self, rgbtuple)
	

    #
    # public interface
    #

    def set_color(self, obj, rgbtuple):
	red, green, blue = rgbtuple
	if self.__generator:
	    i = 0
	    chip = 0
	    for t in self.__generator(self.__numchips, rgbtuple):
		rrggbb = ColorDB.triplet_to_rrggbb(t)
		self.__canvas.itemconfigure(self.__chips[i],
					    fill=rrggbb,
					    outline=rrggbb)
		tred, tgreen, tblue = t
		if tred <= red and tgreen <= green and tblue <= blue:
		    chip = i
		i = i + 1
	    # 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 chip
		self.__leftarrow.set_text(text)
		self.__leftarrow.move_to(self.__arrow_x(chip))
		self.__rightarrow.move_to(-100)
	    else:
		# use the right chip
		self.__rightarrow.set_text(text)
		self.__rightarrow.move_to(self.__arrow_x(chip))
		self.__leftarrow.move_to(-100)
	    # and set the chip's outline
	    pmwrgb = ColorDB.triplet_to_pmwrgb(rgbtuple)
	    b = Pmw.Color.rgb2brightness(pmwrgb)
	    if b <= 0.5:
		outline = 'white'
	    else:
		outline = 'black'
	    self.__canvas.itemconfigure(self.__chips[chip],
					outline=outline)