huey"> rgb.txt"> ] >
&huey;: Internal maintenance specification John W. Shipman
tcc-doc@nmt.edu
$Revision: 1.39 $ $Date: 2008/01/09 04:57:43 $ Describes the implementation of &huey;, a graphical application for selecting colors and fonts, using the Python programming language and the Tkinter widget set. This publication is available in Web form and also as a PDF document. Please forward any comments to tcc-doc@nmt.edu.
Introduction This document describes the implementation of &huey;, a graphical user interface tool for displaying various colors and text fonts. See the external specification, &huey;: a color and font selection tool. For those interested in analyzing this program as an example of Python and Tkinter programming, the entire Python source for the program is presented here using a lightweight literate programming (LLP) style. For more on LLP, see the author's literate programming page.
Files discussed in this publication Here are online links to all the files required by this program (other than Python and Tkinter installs). huey: The main script. scrolledlist.py: Source for the ScrolledList compound widget. fontselect.py: Source for the FontSelect compound widget. hueyims.xml: DocBook source for this document.
References The author has relied heavily on one book as a comprehensive reference on color theory as it relates to computer graphics.
Foley, James D., Andries van Dam, Steven K. Feiner, and John F. Hughes. Computer graphics: principles and practice. Second edition. Addison-Wesley, 1992. ISBN 0-201-12110-7.
Design notes Before proceeding, be sure you have a basic understanding of how Tkinter applications are built. Strongly recommended is the author's Tkinter reference. This program has a lot of widgets. To keep the design conceptually simple, the architecture of the program uses boxes within boxes within boxes, grouping related widgets into frames, and related frames into larger frames, so that each grouping has a well-defined function, and connections within a grouping of widgets are hidden within a single Python class. One way to describe this technique is that we build compound widgets out of Tkinter's basic widgets. A compound widget is a Python class that inherits from the Frame widget. This application uses the .grid() geometry manager to position widgets. At the very highest level, the application is organized into two rows and three columns like this: The three columns of row 0 are spanned to make one wide, short grid cell that contains the general controls. The name .menuBar has a dot in front of it because it is an attribute of the Application class, the Frame that contains all the application's widgets. The compound widget that appears in this grid cell is an instance of class MenuBar; see . Similarly, three compound widgets fill out row 1. Column 0 contains a NamePicker compound widget, which is stored in attribute .namePicker of the Application class. Column 1 is an Adjuster widget, and column 2 is a Swatch widget. Below this level, design of each of the four major areas proceeds by stepwise refinement. Here is a diagram showing the layout of all the compound widgets in this program. is the entire application. contains the controls along the top edge. contains all controls for selecting colors by name. is the list of standard colors. contains controls for selecting text or background color, selecting the color model, and adjusting colors. shows the current text and background color names and allows the user to select which color is being adjusted. allows the user to select a color model. is a set of Scale widgets for making fine color adjustments. is one of those Scale widgets. displays the current font in the current text color against the current background color, and includes widgets for selecting the font. The actual code for &huey; starts in . The actual program logic starts with .
Code prologue The actual code starts with the usual Unix “pound-bang line” that makes the script self-executing. This is followed by a comment pointing the reader at this documentation. #!/usr/local/bin/python #================================================================ # huey: A color and font selection tool # For documentation, see: # &selfURL; #---------------------------------------------------------------- PROGRAM_NAME = "huey" EXTERNAL_VERSION = "1.0"
Imports Here are the module imports for this script. First is the standard Python math module. import math We'll need the os.path module to do file name manipulation. import os All the Tkinter GUI package is added directly to the global namespace. The tkFont module is necessary to select fonts. The Dialog module makes it easy to create pop-up menus. from Tkinter import * import tkFont from Dialog import Dialog ScrolledList is a compound widget, a combination of a Listbox and a vertical Scrollbar. For its documentation, see ScrolledList: A Tkinter scrollable list widget. from scrolledlist import ScrolledList The other compound widget described elsewhere is FontSelect: a group of controls for selecting and displaying fonts. For documentation, see FontSelect: A Tkinter widget to select fonts. from fontselect import FontSelect
Manifest constants The constant MAX_PARAM defines the maximum value for a color parameter. For example, black is represented as the triple (0,0,0), while white is represented as (65535,65535,65535). #================================================================ # Manifest constants #---------------------------------------------------------------- MAX_PARAM = 65535 The constant N_PARAMS is the number of parameters in a color model. This will always be three, but we use a manifest constant so that readers will not have to look at a literal “3” and try to figure out three of what. N_PARAMS = 3 The constant MAX_BYTE is the largest number that can be stored in a byte as an unsigned integer. MAX_BYTE = 255 Also global are the names of the fonts used throughout the application. BUTTON_FONT is used more or less everywhere; MONO_FONT is used where a monospaced font is required. BUTTON_FONT = ('times', 12) MONO_FONT = ('lucidatypewriter', 14, 'bold')
<code >main()</code >: The main program The graphical user interface as a whole is represented by the Application class. Calling the constructor initializes the application. See . # - - - - - m a i n def main(): """Main program. [ display a graphical application that allows the user to test various fonts in various colors displayed on various background colors ] """ #-- 1 -- # [ the screen := the screen with a graphical application # app := the graphical application ] app = Application() Before actually running the application, we need to place the title of the application in the top-level window. This title will be displayed in the decorations applied by the user's window manager. The .winfo_toplevel() method returns the top-level window of the application; the .title() method sets the title in that window. If we don't do this, the default window title will be just “tk”. #-- 2 -- # [ app := app with its window title set to the name of # this application ] app.winfo_toplevel().title( "%s %s" % (PROGRAM_NAME, EXTERNAL_VERSION) ) The .mainloop() method starts the application running. It will respond to events until the user terminates it by clicking the Quit button. #-- 3 -- # [ app := app responding to user events ] app.mainloop()
<code >class Color</code >: A specific color An instance of the Color class is used to represent a specific color. There are two obvious ways to represent the red, green, and blue components: as floating point numbers or as integers. The obvious way to use a float is to let 0.0 represent none and let 1.0 represent all of a component. However, the “#RRGGBB” representation is also common, and in that form each component is an integer in the range [0, MAX_PARAM]. An internal precision of 16 bits per color is plenty. Here is the class interface: # - - - - - c l a s s C o l o r class Color: """Represents an arbitrary color. Exports: Color ( red, green, blue ): [ (red is the red value as a float in [0.0,1.0] or as an int in [0,MAX_PARAM]) and (green is the green value as a float in [0.0,1.0] or as an int in [0,MAX_PARAM]) and (blue is the blue value as a float in [0.0,1.0] or as an int in [0,MAX_PARAM]) -> return a new Color instance with those color values ] Internally, a color is represented in the integer form. The three components are exported as read-only attributes. .r: [ the red component as an int in [0,MAX_PARAM] ] .g: [ the green component as an int in [0,MAX_PARAM] ] .b: [ the blue component as an int in [0,MAX_PARAM] ] The .__str__() method defines the behavior of the built-in Python str() function when applied to instances of this class. See . .__str__(self): [ return self as a string "#RRGGBB" ] The .__cmp__() function is used to compare two colors to see if they are the same color. See . .__cmp__(self, other): [ other is a Color instance -> if self's color name is less than other's -> return a negative number else if self's color name is greater than other's -> return a positive number else -> return 0 ] """
<code >Color.__init__()</code >: Constructor The constructor accepts each of the three color components as either a float or an integer. Floats are in the range [0.0, 1.0], but integers are in the range [0,MAX_PARAM]. The .__standardize() method translates the float form into the integer form; see . # - - - C o l o r . _ _ i n i t _ _ def __init__ ( self, red, green, blue ): """Constructor for Color """ #-- 1 -- # [ if red is a float in [0.0, 1.0] -> # self.r := red mapped onto [0, MAX_PARAM] # if red is an int in [0,MAX_PARAM] -> # self.r := red ] self.r = self.__standardize ( red ) #-- 2 -- # [ simile ] self.g = self.__standardize ( green ) #-- 3 -- self.b = self.__standardize ( blue )
<code >Color.__standardize()</code >: Standardize color component representation This method takes care of translating float-type arguments for color components into the standard integer range. # - - - C o l o r . _ _ s t a n d a r d i z e def __standardize ( self, rawValue ): """Standardize representation of a color component. [ if rawValue is a float in [0.0, 1.0] -> return int ( rawValue * MAX_PARAM ) if rawValue is an int in [0, MAX_PARAM] -> return rawValue else -> raise ValueError ] """ if type(rawValue) is float: if not 0.0 <= rawValue <= 1.0: raise ValueError, ( "Float color value %.4f " "out of bounds." % rawValue ) return int ( rawValue * MAX_PARAM ) elif type(rawValue) is int: if not 0 <= rawValue <= MAX_PARAM: raise ValueError, ( "Int color value %d " "out of bounds." % rawValue ) return rawValue else: raise ValueError, ( "Color component %s " "not int or float." % rawValue )
<code >Color.__str__()</code >: Convert to a string Converting each 16-bit color component to its 8-bit equivalent is a simple matter of shifting out the low-order bits. # - - - C o l o r . _ _ s t r _ _ def __str__ ( self ): """Convert self to an X color name. """ r8 = self.r >> 8 g8 = self.g >> 8 b8 = self.b >> 8 return "#%02X%02X%02X" % (r8, g8, b8)
<code >Color.__cmp__()</code >: Compare two colors This method implements the usual Python comparison function. It can be used to test two colors for equality. The definition of inequality is pretty arbitary, so we will just use their #RRGGBB color names to do the comparison. # - - - C o l o r . _ _ c m p _ _ def __cmp__ ( self, other ): """Compare two colors.""" return cmp ( str(self), str(other) )
<code >class ColorModel</code >: Base class for color models The various color model we support will be concrete classes that share an interface defined in this base class. # - - - - - c l a s s C o l o r M o d e l class ColorModel: """Base class for color models. Exports: ColorModel ( modelName, labelList ): [ (modelName is the name of this model as a string) and (labelList is a sequence of three strings naming the parameters of this model) -> return a ColorModel object with those names ] .modelName: [ as passed to constructor, read-only ] .labelList: [ as passed to constructor, read-only ] Functionally, a color model translates between a Color object (which internally uses RGB color space) and a trio of parameters that describe that color in the given model. The next two methods are the two conversions; see and . .paramsToColor ( params ): [ params is a sequence of three numbers in [0,MAX_PARAM] -> return that color in self's model as a Color instance ] .colorToParams ( color ): [ color is a Color instance -> return color's parameters in self's model as a sequence of three numbers in [0,MAX_PARAM] ] The class also contains two static methods used to convert between numbers in [0,MAX_PARAM] and floats in [0.0, 1.0]. See and . ColorModel.normalize(n): [ n is an int in [0,MAX_PARAM] -> return float(n)/MAX_PARAM ] ColorModel.discretize(n): [ n is a float in [0.0, 1.0] -> return int(n*MAX_PARAM) ] """
<code >ColorModel.__init__()</code >: Constructor All the constructor does is to store the arguments in the instance's namespace. # - - - C o l o r M o d e l . _ _ i n i t _ _ def __init__ ( self, modelName, labelList ): """Constructor for ColorModel.""" self.modelName = modelName self.labelList = labelList
<code >ColorModel.paramsToColor()</code > The polite way to implement a virtual method in Python (like this one) is to raise the NotImplementedError exception. For the interface, see . # - - - C o l o r M o d e l . p a r a m s T o C o l o r def paramsToColor ( self, params ): raise NotImplementedError, "ColorModel.paramsToColor"
<code >ColorModel.colorToParams()</code > A virtual method. For the interface, see . # - - - C o l o r M o d e l . c o l o r T o P a r a m s def colorToParams ( self, params ): raise NotImplementedError, "ColorModel.colorToParams"
<code >ColorModel.normalize()</code >: Normalize an integer color parameter This static method converts a color parameter in [0,MAX_PARAM] to a normalized float in [0.0, 1.0]. Values outside the range are forced back into the range. # - - - C o l o r M o d e l . n o r m a l i z e # @staticmethod def normalize ( n ): result = float(n)/MAX_PARAM if result < 0.0: return 0.0 elif result > 1.0: return 1.0 else: return result normalize = staticmethod ( normalize )
<code >ColorModel.discretize()</code >: Discretize an integer color parameter This static method converts a color parameter in [0.0, 1.0] to a discrete integer in [0, MAX_PARAM]. Values outside the range are forced back into the range; this prevents potential unpleasantnesses such as a color parameter being rounded to hex 100 when it must be no more than hex FF. # - - - C o l o r M o d e l . d i s c r e t i z e # @staticmethod def discretize ( n ): result = int(n*MAX_PARAM) if result < 0: return 0 elif result > MAX_PARAM: return MAX_PARAM else: return result discretize = staticmethod ( discretize )
<code >class HSVModel</code >: Hue-saturation-value color model The parameters of this color model are: Hue: an angle around the “color wheel”; angles 0° and 360° are red; 60° is yellow; 120° is green; 180° is cyan; 240° is blue; and 300° is magenta. Saturation: 1.0 for a fully saturated, pure color; reducing it toward zero moves toward white. Value: 1.0 for a fully saturated, pure color; reducing it toward zero moves toward black. Here is the class interface. # - - - - - c l a s s H S V M o d e l class HSVModel(ColorModel): """Represents the hue-saturation-value color model. """
<code >HSVModel.__init__()</code >: Constructor This constructor has nothing to do but call its parent constructor and pass it the names of the model and its parameters. Refer to . # - - - H S V M o d e l . _ _ i n i t _ _ def __init__ ( self ): ColorModel.__init__ ( self, "HSV", ("hue", "saturation", "value") )
<code >HSVModel.paramsToColor()</code > This method converts a set of HSV parameters to a Color instance. This algorithm comes from Foley & van Dam's algorithm “HSV_To_RGB”; see . # - - - H S V M o d e l . p a r a m s T o C o l o r def paramsToColor ( self, params ): """Convert the three HSV color parameters to a Color. """ First we normalize the three color components to [0.0, 1.0]; see . h = ColorModel.normalize ( params[0] ) s = ColorModel.normalize ( params[1] ) v = ColorModel.normalize ( params[2] ) Note that the Color() constructor will accept float values in [0.0, 1.0] as well as integer values in [0,MAX_PARAM]. if s == 0.0: return Color ( v, v, v ) Treat a hue of 1.0 or more as a hue of 0.0 due to wraparound. Otherwise, normalize the value of h to the half-open interval [0,6). if h >= 1.0: h = 0.0 else: h = h * 6.0 The math.modf() function returns a tuple (f, i) where f is the fractional part and i is the integral part. The rest follows Foley & van Dam's algorithm, using the same names. (f,i) = math.modf(h) i = int ( i ) p = v * ( 1.0 - s ) q = v * ( 1.0 - s * f ) t = v * ( 1.0 - s * ( 1.0 - f ) ) if i == 0: return Color ( v, t, p ) elif i == 1: return Color ( q, v, p ) elif i == 2: return Color ( p, v, t ) elif i == 3: return Color ( p, q, v ) elif i == 4: return Color ( t, p, v ) else: return Color ( v, p, q )
<code >HSVModel.colorToParams()</code > This method converts a Color object into the three parameters of the HSV model, each in the range [0,MAX_PARAM]. The algorithm is Foley & van Dam's “RGB_To_HSV”; see . # - - - H S V M o d e l . c o l o r T o P a r a m s def colorToParams ( self, color ): """Convert a Color to the three HSV parameters. """ First we normalize the three RGB parameters to [0.0, 1.0]. See . rNorm = ColorModel.normalize(color.r) gNorm = ColorModel.normalize(color.g) bNorm = ColorModel.normalize(color.b) The value parameter v is the maximum of the three values. We also calculate their minimum. v = maxColor = max ( rNorm, gNorm, bNorm ) minColor = min ( rNorm, gNorm, bNorm ) Next, calculate the saturation. If all the colors are zero, the saturation is zero. if maxColor == 0.0: s = 0.0 else: s = ( maxColor - minColor ) / maxColor Next, find the hue. If the saturation is zero, arbitrarily use a value of zero (red) for the hue. if s == 0.0: h = 0.0 # Hue is undefined; use red arbitrarily These three cases are: colors between Y and M; colors between C and Y; and colors between M and C. Negative values are then rotated to the range [0,6]. Finally, the hue is normalized to [0.0, 1.0]. else: delta = maxColor - minColor if rNorm == maxColor: # Between Y and M h = ( gNorm - bNorm ) / delta elif gNorm == maxColor: # Between C and Y h = 2.0 + ( bNorm - rNorm ) / delta else: # Between M and C h = 4.0 + ( rNorm - gNorm ) / delta if h < 0.0: h = h + 6.0 h = h / 6.0 # Normalize to [0,1] Finally, return the three parameters, discretized back to [0,MAX_PARAM]. See . return ( ColorModel.discretize ( h ), ColorModel.discretize ( s ), ColorModel.discretize ( v ) )
<code >class RGBModel</code >: Red-green-blue color model This is a concrete class inheriting from the base ColorModel class. It implements the red-green-blue color model. It doesn't have much work to do, since the Color object uses the RGB model as its internal representation. # - - - - - c l a s s R G B M o d e l class RGBModel(ColorModel): """Represents the red-green-blue color model. """
<code >RGBModel.__init_()</code >: Constructor All the constructor has to do is to call the parent class constructor, and supply the model's name and the names of its three parameters. See . # - - - R G B M o d e l . _ _ i n i t _ _ def __init__ ( self ): """Constructor for RGBModel.""" ColorModel.__init__ ( self, "RGB", ("red", "green", "blue") )
<code >RGBModel.paramsToColor()</code > This method takes a tuple (red, green, blue) and returns a color as a Colorinstance. The “*” used inside the call to the Color() constructor takes advantage of one of Python's features: that constructor expects three positional arguments, but since params is a three-element sequence, the “*” tells Python to allocate those three elements to the corresponding positional arguments. # - - - R G B M o d e l . p a r a m s T o C o l o r def paramsToColor ( self, params ): """Convert three RGB parameters to a Color. """ return Color ( *params )
<code >RGBModel.colorToParams()</code > This method takes a Color instance and returns the three parameters of that color in the RGB model. No conversion is necessary, since the Color instance uses the RGB model internally. # - - - R G B M o d e l . c o l o r T o P a r a m s def colorToParams ( self, color ): """Convert a Color to the three RGB parameters. """ return ( ( color.r, color.g, color.b ) )
<code >class CMYModel</code >: Cyan-magenta-yellow color model This class implements the CMY color model. It is a concrete class that inherits from the ColorModel abstract class. There is little more logic here than in the RGBModel class, since each parameter is the complement of one of the RGB parameters used internally by the Color class. # - - - - - c l a s s C M Y M o d e l class CMYModel(ColorModel): """Represents the cyan-yellow-magenta color model. """
<code >CMYModel.__init__()</code > This constructor calls the parent class constructor and supplies the name of the model and the names of its three parameters. See . # - - - C M Y M o d e l . _ _ i n i t _ _ def __init__ ( self ): """Constructor for CMYModel.""" ColorModel.__init__ ( self, "CMY", ("cyan", "yellow", "magenta") )
<code >CMYModel.paramsToColor()</code > This method takes a triple (c, m, y) containing the three CMY parameters of a color, and returns the equivalent color as a Color instance. # - - - C M Y M o d e l . p a r a m s T o C o l o r def paramsToColor ( self, params ): """Convert CMY parameters to a Color. """ Each parameter is the complement of one of the RGB colors: cyan is opposite red, magenta is opposite green, and yellow is opposite blue. Mathematically, we can convert a value by subtracting it from MAX_PARAM. cyan, magenta, yellow = params red = MAX_PARAM - cyan green = MAX_PARAM - magenta blue = MAX_PARAM - yellow return Color ( red, green, blue )
<code >CMYModel.colorToParams()</code > Converting a Color instance to cyan, magenta, and yellow values is straightforward, as each of the CMY colors is the complement of the corresponding RGB colors stored in attributes of the Color instance. To complement a number in [0,MAX_PARAM], we subtract that number from MAX_PARAM. # - - - C M Y M o d e l . c o l o r T o P a r a m s def colorToParams ( self, color ): """Convert a color to CMY parameters. """ cyan = MAX_PARAM - color.r magenta = MAX_PARAM - color.g yellow = MAX_PARAM - color.b return (cyan, magenta, yellow)
<code >class Application</code >: The outermost frame This class encapsulates the entire graphical application. It inherits from Tkinter's Frame class, which makes Application for all intents and purposes a Tkinter widget. # - - - - - c l a s s A p p l i c a t i o n class Application(Frame): """Contains the entire application. Contained widgets: .menuBar: [ a MenuBar widget ] .namePicker: [ a NamePicker widget ] .adjuster: [ an Adjuster widget ] .swatch: [ a Swatch widget ] Grid plan: 0 1 2 +---------------+-------------+-----------+ 0 | .__menuBar | +---------------+-------------+-----------+ 1 | .__namePicker | .__adjuster | .__swatch | +---------------+-------------+-----------+ """ This class is a container for four compound widgets. The MenuBar widget across the top edge contains general controls for the application. The bulk of the space is taken up by the three major sections of the application: the NamePicker widget for selecting colors by name; the Adjuster widget for adjusting colors and selecting color models; and the Swatch widget displaying the selected colors and fonts, and including font selection controls. At this level, there are only two important linkages between the contained widgets: Whenever the user selects a color in the NamePicker widget, that widget tells the Adjuster widget to display that color. Whenever the user adjusts the current color in the Adjuster widget, or when that widget is set by an outside call to change its color, it tells the Swatch widget to change to the new color as well. The current text and background colors reside inside the Adjuster widget.
<code >Application.__init__()</code >: Constructor The constructor creates the application window and populates it with its four contained widgets. # - - - A p p l i c a t i o n . _ _ i n i t _ _ def __init__ ( self ): """Constructor for Application. """ Because this class inherits from Frame, the first order of business is to call the parent class's constructor. The first argument is self, the new instance's namespace. The second argument is the parent window; passing None has the effect of creating a new root window. Calling the .grid() method on self is necessary to register the new window; if this isn't done, the application will not appear on the screen. #-- 1 -- # [ self := self as a new root window Frame ] Frame.__init__ ( self, None ) self.grid() Widget creation is handled by . #-- 2 -- # [ self := self with all widgets created and gridded ] self.__createWidgets()
<code >Application.__createWidgets()</code >: Set up the widgets This method creates and grids all the widgets for the Application class. # - - - A p p l i c a t i o n . _ _ c r e a t e W i d g e t s def __createWidgets ( self ): """Create and grid all widgets. """ The MenuBar compound widget occupies the full width of row 0. The sticky parameter makes it adhere to the left (west) side of its grid cell. See . #-- 1 -- # [ self := self with a new MenuBar widget added # self.__menuBar := that widget ] self.__menuBar = MenuBar ( self ) self.__menuBar.grid ( row=0, column=0, columnspan=3, sticky=W ) Next we add the NamePicker widget. The first argument to a widget constructor is always the parent widget, self in this case. The second argument is a callback function that is called whenever the user selects a color. See . #-- 2 -- # [ self := self with a new NamePicker widget added that # calls self.__nameHandler when a name is picked # self.__namePicker := that NamePicker ] self.__namePicker = NamePicker ( self, self.__nameHandler ) self.__namePicker.grid ( row=1, column=0, sticky=NW ) The Adjuster widget constructor also gets a second argument containing the name of a callback function, which will be called whenever the user adjusts the current color. See . #-- 3 -- # [ self := self with a new Adjuster widget added that calls # self.__adjustHandler when the color is adjusted # self.__adjuster := that Adjuster widget self.__adjuster = Adjuster ( self, self.__adjustHandler ) self.__adjuster.grid ( row=1, column=1, sticky=N, padx=4 ) Last to go in is the Swatch widget; see . #-- 4 -- # [ self := self with a new Swatch widget added, using # the background and text colors from self.__adjuster # self.__swatch := that widget ] self.__swatch = Swatch ( self, self.__adjuster.bgColor(), self.__adjuster.textColor() ) self.__swatch.grid ( row=1, column=2, sticky=N )
<code >Application.__nameHandler()</code >: Name picker handler This callback is called by the NamePicker widget whenever the user picks a color by name. The argument is a Color object representing the selected color. It passes the new color to the .set() method of the Adjuster widget, so the new color can be shown there. See . # - - - A p p l i c a t i o n . _ _ n a m e H a n d l e r def __nameHandler ( self, newColor ): """Handler for the NamePicker widget. [ newColor is a Color instance -> self := self with its Adjuster displaying newColor ] """ self.__adjuster.set ( newColor )
<code >Application.__adjustHandler()</code >: Adjuster handler This method is called whenever the Adjuster widget changes the color that it shows. It gets two arguments. The first argument is 0 for background, 1 for text color. The second argument is the new color. It passes that new color on to the Swatch widget to be displayed; for these methods, see . # - - - A p p l i c a t i o n . _ _ a d j u s t H a n d l e r def __adjustHandler ( self, isText, newColor ): """Handler for the Adjuster widget. [ newColor is a Color instance -> if isText -> self := self with its Swatch displaying its text in color (newColor) else -> self := self with its Swatch displaying its background in color (newColor) ] """ if isText: self.__swatch.setTextColor ( newColor ) else: self.__swatch.setBgColor ( newColor )
<code >class MenuBar</code >: General controls This class is a compound widget containing all the general controls for the program: The Quit button. The Help button. Because this widget is designed to take up a fairly thin slice across the top of the application, these controls are gridded in a horizontal row. The class inherits from Tkinter's Frame class, so it is effectively a compound widget—just a big widget with other widgets inside. # - - - - - c l a s s M e n u B a r class MenuBar(Frame): """Compound widget containing general program controls. Contained widgets: .__helpButton: [ a Menubutton that displays help text ] .__quitButton: [ a Button that terminates the application ] Grid plan: 0 1 +---------------+---------------+ 0 | .__helpButton | .__quitButton | +---------------+---------------+ """
<code >class NamePicker</code >: Select colors by name This class is a compound widget that gives the user two different ways to select a color by its name. They may type the name directly into an Entry widget. Most of the vertical space below this Entry contains a ScrolledList that displays a prefabricated list of color names; the user may instead click on any of these. # - - - - - c l a s s N a m e P i c k e r class NamePicker(Frame): """A compound widget for selecting a color by its name. Exports: NamePicker ( parent, callback=None ): [ (parent is a Frame) and (callback is a function or None) -> parent := parent with a new NamePicker widget added but not gridded, that calls callback whenever a color is selected return that NamePicker widget ] Contained widgets: .__entryLabel: [ a Label widget that labels self.__entry ] .__entry: [ an Entry widget for entering a color name ] .__pickLabel: [ a Label widget that labels self.__pickList ] .__pickList: [ a ScrolledList widget with color names ] Grid plan: Vertical stacking. Private attributes include .__callback, the callback function, and a StringVar control variable linked to the .__entry widget. State/Invariants: .__parent: [ as passed to constructor ] .__callback: [ as passed to constructor ] .__entryVar: [ a StringVar control variable for self.__entry ] """ The width of the Entry field, a manifest constant, is a class variable. NAME_WIDTH = 20
<code >NamePicker.__init()</code >: Constructor The constructor initializes the parent Frame, stores its argument, sets up a control variable for the Entry, and then creates all the widgets. See . # - - - N a m e P i c k e r . _ _ i n i t _ _ def __init__ ( self, parent, callback=None ): """Constructor for the NamePicker compound widget. """ #-- 1 -- # [ self := self as a Frame ] Frame.__init__ ( self, parent ) #-- 2 -- self.__parent = parent self.__callback = None #-- 3 -- # [ self := self with all contained widgets created and # gridded ] self.__createWidgets() #-- 4 -- self.__callback = callback
<code >NamePicker.__createWidgets()</code >: Create all widgets For gridding information, see . # - - - N a m e P i c k e r . _ _ c r e a t e W i d g e t s def __createWidgets ( self ): """Create all widgets.""" #-- 1 -- # [ self := self with a new Label to label the color # name entry field # self.__entryLabel := that Label ] self.__entryLabel = Label ( self, font=BUTTON_FONT, text="Type a color name:" ) rowx = 0 self.__entryLabel.grid ( row=rowx, column=0, sticky=W ) The Entry field has an important event binding: if the user presses the Enter key (which is called Return in Tkinter), that means they have selected a color, so the callback must be called. The binding uses the handler method . #-- 2 -- # [ self := self with a new Entry whose control variable # is self.__entryVar, and which calls self.__callback # when the user presses the Enter key ] self.__entryVar = StringVar() self.__entry = Entry ( self, relief=SUNKEN, font=BUTTON_FONT, width=self.NAME_WIDTH, textvariable=self.__entryVar ) rowx += 1 self.__entry.grid ( row=rowx, column=0, sticky=W ) self.__entry.bind ( "<Key-Return>", self.__entryHandler ) Placing the label for the color pick list is straightforward. However, creating the color pick list is pretty involved, so that logic is located in . #-- 3 -- # [ self := self with a Label added for the color pick list # self.__pickLabel := that Label ] self.__pickLabel = Label ( self, font=BUTTON_FONT, text="Or click on a name:" ) rowx += 1 self.__pickLabel.grid ( row=rowx, column=0, sticky=W ) #-- 4 -- # [ self := self with a PickList added containing # the color pick list, with bindings that will call # self.__callback when a color is clicked # self.__pickList := that ScrolledList ] self.__pickList = PickList ( self, self.__pickListHandler ) rowx += 1 self.__pickList.grid ( row=rowx, column=0, sticky=W )
<code >NamePicker.__entryHandler()</code >: Handler for the <keysym >Enter</keysym > key This method is called when the user presses the Enter key in the color name field. Assuming the color name is valid, we then call the class's callback to notify observers that the color has changed. # - - - N a m e P i c k e r . _ _ e n t r y H a n d l e r def __entryHandler ( self, event ): """Handle the Enter key in the color name field. [ event is an Event from self.__entry -> if self.__entryVar is a valid color name -> call self.__callback with a Color representing that name else -> pop up a Dialog informing the user that the color name is not valid ] """ The .get() method on self.__entryVar retrieves the text from the color name field. We then pass the name on to . #-- 1 -- # [ colorName := text from self.__entryVar ] colorName = self.__entryVar.get() #-- 2 -- # [ if self.__entryVar is a valid color name -> # call self.__callback with a Color representing # that name # else -> # pop up a Dialog informing the user that the # color name is not valid ] self.__setByName ( colorName )
<code >NamePicker.__setByName()</code >: Try to convert a color name to a color The purpose of this method is to convert a color name into a numeric value, and thence into a Color instance. # - - - N a m e P i c k e r . _ _ s e t B y N a m e def __setByName ( self, colorName ): """Convert a color name to RGB values as a Color instance. [ colorName is a string -> if colorName is defined in either Tkinter or our color pick list -> call self.__callback and pass it that color as a Color instance else -> pop up a Dialog window complaining about the undefined color name ] """ In theory, a properly installed X Window system will have a file named &rgb-txt; that lists all the standard color names. In theory, any application should be able to use a color name from that file, and the window system will recognize it. In practice, the presence of that file is not guaranteed, and even if does exist, we have no assurance that the set of color names accepted by the window system is the same as the contents of the file. In case the &rgb-txt; file is missing, this program contains a data structure which represents the contents of one version of that file. However, there is another source for translating color names to RGB values. Every Tkinter widget has a method named .winfo_rgb() which takes a color name and returns a triple (R, G, B) where each value is in the range [0,MAX_PARAM]. So, our liberal policy will be to try the latter technique first. If that fails, we can still use the list that appears in the pick list to convert names to RGB values. That way, if the two sources differ, we implement the union of their values. There is a discussion of the Dialog pop-up in . See also . #-- 1 -- # [ if (Tkinter recognizes (colorName) as a color) or # (colorName) is defined in self.__pickList) -> # rgb := that color as a tuple (r, g, b) of values # in [0,MAX_PARAM] # else -> # pop up a Dialog complaining about the undefined # color name # return ] try: rgb = self.winfo_rgb ( colorName ) except: rgb = self.__pickList.lookupName ( colorName ) if not rgb: Dialog ( self, title="Message", bitmap="info", default=0, strings=("Dismiss",), text=("Color '%s' is undefined." % colorName) ) return All that remains is to convert rgb to a Color and call the callback. #-- 2 -- # [ if self.__callback is not None -> # call self.__callback with a Color made from rgb # else -> I ] if self.__callback is not None: self.__callback ( Color ( *rgb ) )
<code >NamePicker.__pickListHandler()</code >: Somebody clicked on a color This method is called when the user clicks on a color name in the PickList. That object passes us that color as a Color instance, and we pass it on to our callback. # - - - N a m e P i c k e r . _ _ p i c k L i s t H a n d l e r def __pickListHandler ( self, color ): """Handler for self.__pickList. """ if self.__callback is not None: self.__callback ( color )
<code >class PickList</code >: The color names pick list This class is a compound widget containing the list of standard color names. It responds to user clicks by calling its callback function with a Color instance. It also contains a translation table for converting its color names to color values. For an important discussion of the two methods of converting color names, see . In GUI terms, it is a frame containing only a single widget, a ScrolledList. This widget is a compound widget from the author's widget library. It is a combination of a Tkinter Listbox widget with a vertical Scrollbar. For particulars of its call and implementation, see . To populate this list with standard color names, there are two possible sources. On most Unix boxen, there is a file named &rgb-txt; that defines the names and values. Depending on the age of the install, it may be in one of these paths; the first one reflects the more recent practice: /usr/share/X11 /usr/lib/X11 However, just so this program isn't useless in the absence of the file, this class contains an internal version of &rgb-txt; as a fallback measure. Here is the class interface: # - - - - - c l a s s P i c k L i s t class PickList(Frame): """Compound widget for the color pick list. Exports: PickList ( parent, callback=None ): [ (parent is a Frame) and (callback is a function or None) -> parent := parent with a new PickList widget added but not gridded return that new widget ] This method allows the caller to translate a color name to a Color instance; see . .lookupName ( colorName ): [ colorName is a string -> if colorName matches a color in self's list, case-insensitive -> return the corresponding value as a Color instance else -> return None ] Contained widgets: .__scrolledList: [ a scrolledlist.ScrolledList containing self's color names ] Grid plan: Only one widget Here are the internal attributes. First, we keep a copy of the callback procedure. State/Invariants: .__callback: [ as passed to the constructor ] For internal data structures, we need to be able to look up colors both by name and by their position in the pick list. The lists .__colorList and .__nameList are by position: the nth element in self.__colorList is the color displayed in the nth line of the pick list, and the nth element of self.__nameList is the name of the color displayed in that line. .__colorList: [ a list of Color instances such that self.__colorList[i] is the value of the color displayed in the (i)th line of self.__scrolledList, as a Color instance ] .__nameList: [ a list of color names such that self.__nameList[i] is the name of the color displayed in the (i)th line of self.__scrolledList ] The obvious data structure for looking up color names is a dictionary. To make the lookup case-insensitive, the keys of this dictionary are the color names, uppercased. Each value in the dictionary is a tuple (index, color, name), where: The index is an integer that sorts colors into the original order in their source, whether that source is the &rgb-txt; file or the built-in default color list. This index is important in the process of removing redundant colors from the list while retaining their original order; see . The color is the color value as an instance of the Color class. The name is the color name as a string. .__colorMap: [ a dictionary whose keys are the color names in self, uppercased, and each value is a tuple (index, color, name) where index orders the colors in their original source order, color is a Color instance, and name is the color name as a string ] """
<code >PickList</code > class constants The class has a few manifest constants. First is the name of the standard color names file. COLOR_NAMES_FILE = "&rgb-txt;" Next, a list of all the pathnames in which to look for that file. PATHS_LIST = [ '/usr/share/X11', '/usr/lib/X11' ] The physical width and height of the list box are given in characters and lines, respectively. NAME_WIDTH = 20 NAME_LINES = 22
<code >PickList</code >: Default color list The default color list is also a class variable. It's rather long, but it must be declared here. This list was generated by reformatting a 2001-era version of the stock &rgb-txt; file. Each line of that file is represented here as one string. The first three bytes of the string are the red, green, and blue parameters, each in the range [0,255], and the balance of the string is the actual color name. DEFAULT_COLORS = [ '\xFF\xFA\xFAsnow', '\xF8\xF8\xFFGhostWhite', '\xF5\xF5\xF5WhiteSmoke', '\xDC\xDC\xDCgainsboro', '\xFF\xFA\xF0FloralWhite', '\xFD\xF5\xE6OldLace', '\xFA\xF0\xE6linen', '\xFA\xEB\xD7AntiqueWhite', '\xFF\xEF\xD5PapayaWhip', '\xFF\xEB\xCDBlanchedAlmond', '\xFF\xE4\xC4bisque', '\xFF\xDA\xB9PeachPuff', '\xFF\xDE\xADNavajoWhite', '\xFF\xE4\xB5moccasin', '\xFF\xF8\xDCcornsilk', '\xFF\xFF\xF0ivory', '\xFF\xFA\xCDLemonChiffon', '\xFF\xF5\xEEseashell', '\xF0\xFF\xF0honeydew', '\xF5\xFF\xFAMintCream', '\xF0\xFF\xFFazure', '\xF0\xF8\xFFAliceBlue', '\xE6\xE6\xFAlavender', '\xFF\xF0\xF5LavenderBlush', '\xFF\xE4\xE1MistyRose', '\xFF\xFF\xFFwhite', '\x00\x00\x00black', '\x2F\x4F\x4FDarkSlateGray', '\x69\x69\x69DimGray', '\x70\x80\x90SlateGray', '\x77\x88\x99LightSlateGray', '\xBE\xBE\xBEgray', '\xD3\xD3\xD3LightGray', '\x19\x19\x70MidnightBlue', '\x00\x00\x80navy', '\x00\x00\x80NavyBlue', '\x64\x95\xEDCornflowerBlue', '\x48\x3D\x8BDarkSlateBlue', '\x6A\x5A\xCDSlateBlue', '\x7B\x68\xEEMediumSlateBlue', '\x84\x70\xFFLightSlateBlue', '\x00\x00\xCDMediumBlue', '\x41\x69\xE1RoyalBlue', '\x00\x00\xFFblue', '\x1E\x90\xFFDodgerBlue', '\x00\xBF\xFFDeepSkyBlue', '\x87\xCE\xEBSkyBlue', '\x87\xCE\xFALightSkyBlue', '\x46\x82\xB4SteelBlue', '\xB0\xC4\xDELightSteelBlue', '\xAD\xD8\xE6LightBlue', '\xB0\xE0\xE6PowderBlue', '\xAF\xEE\xEEPaleTurquoise', '\x00\xCE\xD1DarkTurquoise', '\x48\xD1\xCCMediumTurquoise', '\x40\xE0\xD0turquoise', '\x00\xFF\xFFcyan', '\xE0\xFF\xFFLightCyan', '\x5F\x9E\xA0CadetBlue', '\x66\xCD\xAAMediumAquamarine', '\x7F\xFF\xD4aquamarine', '\x00\x64\x00DarkGreen', '\x55\x6B\x2FDarkOliveGreen', '\x8F\xBC\x8FDarkSeaGreen', '\x2E\x8B\x57SeaGreen', '\x3C\xB3\x71MediumSeaGreen', '\x20\xB2\xAALightSeaGreen', '\x98\xFB\x98PaleGreen', '\x00\xFF\x7FSpringGreen', '\x7C\xFC\x00LawnGreen', '\x00\xFF\x00green', '\x7F\xFF\x00chartreuse', '\x00\xFA\x9AMediumSpringGreen', '\xAD\xFF\x2FGreenYellow', '\x32\xCD\x32LimeGreen', '\x9A\xCD\x32YellowGreen', '\x22\x8B\x22ForestGreen', '\x6B\x8E\x23OliveDrab', '\xBD\xB7\x6BDarkKhaki', '\xF0\xE6\x8Ckhaki', '\xEE\xE8\xAAPaleGoldenrod', '\xFA\xFA\xD2LightGoldenrodYellow', '\xFF\xFF\xE0LightYellow', '\xFF\xFF\x00yellow', '\xFF\xD7\x00gold', '\xEE\xDD\x82LightGoldenrod', '\xDA\xA5\x20goldenrod', '\xB8\x86\x0BDarkGoldenrod', '\xBC\x8F\x8FRosyBrown', '\xCD\x5C\x5CIndianRed', '\x8B\x45\x13SaddleBrown', '\xA0\x52\x2Dsienna', '\xCD\x85\x3Fperu', '\xDE\xB8\x87burlywood', '\xF5\xF5\xDCbeige', '\xF5\xDE\xB3wheat', '\xF4\xA4\x60SandyBrown', '\xD2\xB4\x8Ctan', '\xD2\x69\x1Echocolate', '\xB2\x22\x22firebrick', '\xA5\x2A\x2Abrown', '\xE9\x96\x7ADarkSalmon', '\xFA\x80\x72salmon', '\xFF\xA0\x7ALightSalmon', '\xFF\xA5\x00orange', '\xFF\x8C\x00DarkOrange', '\xFF\x7F\x50coral', '\xF0\x80\x80LightCoral', '\xFF\x63\x47tomato', '\xFF\x45\x00OrangeRed', '\xFF\x00\x00red', '\xFF\x69\xB4HotPink', '\xFF\x14\x93DeepPink', '\xFF\xC0\xCBpink', '\xFF\xB6\xC1LightPink', '\xDB\x70\x93PaleVioletRed', '\xB0\x30\x60maroon', '\xC7\x15\x85MediumVioletRed', '\xD0\x20\x90VioletRed', '\xFF\x00\xFFmagenta', '\xEE\x82\xEEviolet', '\xDD\xA0\xDDplum', '\xDA\x70\xD6orchid', '\xBA\x55\xD3MediumOrchid', '\x99\x32\xCCDarkOrchid', '\x94\x00\xD3DarkViolet', '\x8A\x2B\xE2BlueViolet', '\xA0\x20\xF0purple', '\x93\x70\xDBMediumPurple', '\xD8\xBF\xD8thistle', '\xFF\xFA\xFAsnow1', '\xEE\xE9\xE9snow2', '\xCD\xC9\xC9snow3', '\x8B\x89\x89snow4', '\xFF\xF5\xEEseashell1', '\xEE\xE5\xDEseashell2', '\xCD\xC5\xBFseashell3', '\x8B\x86\x82seashell4', '\xFF\xEF\xDBAntiqueWhite1', '\xEE\xDF\xCCAntiqueWhite2', '\xCD\xC0\xB0AntiqueWhite3', '\x8B\x83\x78AntiqueWhite4', '\xFF\xE4\xC4bisque1', '\xEE\xD5\xB7bisque2', '\xCD\xB7\x9Ebisque3', '\x8B\x7D\x6Bbisque4', '\xFF\xDA\xB9PeachPuff1', '\xEE\xCB\xADPeachPuff2', '\xCD\xAF\x95PeachPuff3', '\x8B\x77\x65PeachPuff4', '\xFF\xDE\xADNavajoWhite1', '\xEE\xCF\xA1NavajoWhite2', '\xCD\xB3\x8BNavajoWhite3', '\x8B\x79\x5ENavajoWhite4', '\xFF\xFA\xCDLemonChiffon1', '\xEE\xE9\xBFLemonChiffon2', '\xCD\xC9\xA5LemonChiffon3', '\x8B\x89\x70LemonChiffon4', '\xFF\xF8\xDCcornsilk1', '\xEE\xE8\xCDcornsilk2', '\xCD\xC8\xB1cornsilk3', '\x8B\x88\x78cornsilk4', '\xFF\xFF\xF0ivory1', '\xEE\xEE\xE0ivory2', '\xCD\xCD\xC1ivory3', '\x8B\x8B\x83ivory4', '\xF0\xFF\xF0honeydew1', '\xE0\xEE\xE0honeydew2', '\xC1\xCD\xC1honeydew3', '\x83\x8B\x83honeydew4', '\xFF\xF0\xF5LavenderBlush1', '\xEE\xE0\xE5LavenderBlush2', '\xCD\xC1\xC5LavenderBlush3', '\x8B\x83\x86LavenderBlush4', '\xFF\xE4\xE1MistyRose1', '\xEE\xD5\xD2MistyRose2', '\xCD\xB7\xB5MistyRose3', '\x8B\x7D\x7BMistyRose4', '\xF0\xFF\xFFazure1', '\xE0\xEE\xEEazure2', '\xC1\xCD\xCDazure3', '\x83\x8B\x8Bazure4', '\x83\x6F\xFFSlateBlue1', '\x7A\x67\xEESlateBlue2', '\x69\x59\xCDSlateBlue3', '\x47\x3C\x8BSlateBlue4', '\x48\x76\xFFRoyalBlue1', '\x43\x6E\xEERoyalBlue2', '\x3A\x5F\xCDRoyalBlue3', '\x27\x40\x8BRoyalBlue4', '\x00\x00\xFFblue1', '\x00\x00\xEEblue2', '\x00\x00\xCDblue3', '\x00\x00\x8Bblue4', '\x1E\x90\xFFDodgerBlue1', '\x1C\x86\xEEDodgerBlue2', '\x18\x74\xCDDodgerBlue3', '\x10\x4E\x8BDodgerBlue4', '\x63\xB8\xFFSteelBlue1', '\x5C\xAC\xEESteelBlue2', '\x4F\x94\xCDSteelBlue3', '\x36\x64\x8BSteelBlue4', '\x00\xBF\xFFDeepSkyBlue1', '\x00\xB2\xEEDeepSkyBlue2', '\x00\x9A\xCDDeepSkyBlue3', '\x00\x68\x8BDeepSkyBlue4', '\x87\xCE\xFFSkyBlue1', '\x7E\xC0\xEESkyBlue2', '\x6C\xA6\xCDSkyBlue3', '\x4A\x70\x8BSkyBlue4', '\xB0\xE2\xFFLightSkyBlue1', '\xA4\xD3\xEELightSkyBlue2', '\x8D\xB6\xCDLightSkyBlue3', '\x60\x7B\x8BLightSkyBlue4', '\xC6\xE2\xFFSlateGray1', '\xB9\xD3\xEESlateGray2', '\x9F\xB6\xCDSlateGray3', '\x6C\x7B\x8BSlateGray4', '\xCA\xE1\xFFLightSteelBlue1', '\xBC\xD2\xEELightSteelBlue2', '\xA2\xB5\xCDLightSteelBlue3', '\x6E\x7B\x8BLightSteelBlue4', '\xBF\xEF\xFFLightBlue1', '\xB2\xDF\xEELightBlue2', '\x9A\xC0\xCDLightBlue3', '\x68\x83\x8BLightBlue4', '\xE0\xFF\xFFLightCyan1', '\xD1\xEE\xEELightCyan2', '\xB4\xCD\xCDLightCyan3', '\x7A\x8B\x8BLightCyan4', '\xBB\xFF\xFFPaleTurquoise1', '\xAE\xEE\xEEPaleTurquoise2', '\x96\xCD\xCDPaleTurquoise3', '\x66\x8B\x8BPaleTurquoise4', '\x98\xF5\xFFCadetBlue1', '\x8E\xE5\xEECadetBlue2', '\x7A\xC5\xCDCadetBlue3', '\x53\x86\x8BCadetBlue4', '\x00\xF5\xFFturquoise1', '\x00\xE5\xEEturquoise2', '\x00\xC5\xCDturquoise3', '\x00\x86\x8Bturquoise4', '\x00\xFF\xFFcyan1', '\x00\xEE\xEEcyan2', '\x00\xCD\xCDcyan3', '\x00\x8B\x8Bcyan4', '\x97\xFF\xFFDarkSlateGray1', '\x8D\xEE\xEEDarkSlateGray2', '\x79\xCD\xCDDarkSlateGray3', '\x52\x8B\x8BDarkSlateGray4', '\x7F\xFF\xD4aquamarine1', '\x76\xEE\xC6aquamarine2', '\x66\xCD\xAAaquamarine3', '\x45\x8B\x74aquamarine4', '\xC1\xFF\xC1DarkSeaGreen1', '\xB4\xEE\xB4DarkSeaGreen2', '\x9B\xCD\x9BDarkSeaGreen3', '\x69\x8B\x69DarkSeaGreen4', '\x54\xFF\x9FSeaGreen1', '\x4E\xEE\x94SeaGreen2', '\x43\xCD\x80SeaGreen3', '\x2E\x8B\x57SeaGreen4', '\x9A\xFF\x9APaleGreen1', '\x90\xEE\x90PaleGreen2', '\x7C\xCD\x7CPaleGreen3', '\x54\x8B\x54PaleGreen4', '\x00\xFF\x7FSpringGreen1', '\x00\xEE\x76SpringGreen2', '\x00\xCD\x66SpringGreen3', '\x00\x8B\x45SpringGreen4', '\x00\xFF\x00green1', '\x00\xEE\x00green2', '\x00\xCD\x00green3', '\x00\x8B\x00green4', '\x7F\xFF\x00chartreuse1', '\x76\xEE\x00chartreuse2', '\x66\xCD\x00chartreuse3', '\x45\x8B\x00chartreuse4', '\xC0\xFF\x3EOliveDrab1', '\xB3\xEE\x3AOliveDrab2', '\x9A\xCD\x32OliveDrab3', '\x69\x8B\x22OliveDrab4', '\xCA\xFF\x70DarkOliveGreen1', '\xBC\xEE\x68DarkOliveGreen2', '\xA2\xCD\x5ADarkOliveGreen3', '\x6E\x8B\x3DDarkOliveGreen4', '\xFF\xF6\x8Fkhaki1', '\xEE\xE6\x85khaki2', '\xCD\xC6\x73khaki3', '\x8B\x86\x4Ekhaki4', '\xFF\xEC\x8BLightGoldenrod1', '\xEE\xDC\x82LightGoldenrod2', '\xCD\xBE\x70LightGoldenrod3', '\x8B\x81\x4CLightGoldenrod4', '\xFF\xFF\xE0LightYellow1', '\xEE\xEE\xD1LightYellow2', '\xCD\xCD\xB4LightYellow3', '\x8B\x8B\x7ALightYellow4', '\xFF\xFF\x00yellow1', '\xEE\xEE\x00yellow2', '\xCD\xCD\x00yellow3', '\x8B\x8B\x00yellow4', '\xFF\xD7\x00gold1', '\xEE\xC9\x00gold2', '\xCD\xAD\x00gold3', '\x8B\x75\x00gold4', '\xFF\xC1\x25goldenrod1', '\xEE\xB4\x22goldenrod2', '\xCD\x9B\x1Dgoldenrod3', '\x8B\x69\x14goldenrod4', '\xFF\xB9\x0FDarkGoldenrod1', '\xEE\xAD\x0EDarkGoldenrod2', '\xCD\x95\x0CDarkGoldenrod3', '\x8B\x65\x08DarkGoldenrod4', '\xFF\xC1\xC1RosyBrown1', '\xEE\xB4\xB4RosyBrown2', '\xCD\x9B\x9BRosyBrown3', '\x8B\x69\x69RosyBrown4', '\xFF\x6A\x6AIndianRed1', '\xEE\x63\x63IndianRed2', '\xCD\x55\x55IndianRed3', '\x8B\x3A\x3AIndianRed4', '\xFF\x82\x47sienna1', '\xEE\x79\x42sienna2', '\xCD\x68\x39sienna3', '\x8B\x47\x26sienna4', '\xFF\xD3\x9Bburlywood1', '\xEE\xC5\x91burlywood2', '\xCD\xAA\x7Dburlywood3', '\x8B\x73\x55burlywood4', '\xFF\xE7\xBAwheat1', '\xEE\xD8\xAEwheat2', '\xCD\xBA\x96wheat3', '\x8B\x7E\x66wheat4', '\xFF\xA5\x4Ftan1', '\xEE\x9A\x49tan2', '\xCD\x85\x3Ftan3', '\x8B\x5A\x2Btan4', '\xFF\x7F\x24chocolate1', '\xEE\x76\x21chocolate2', '\xCD\x66\x1Dchocolate3', '\x8B\x45\x13chocolate4', '\xFF\x30\x30firebrick1', '\xEE\x2C\x2Cfirebrick2', '\xCD\x26\x26firebrick3', '\x8B\x1A\x1Afirebrick4', '\xFF\x40\x40brown1', '\xEE\x3B\x3Bbrown2', '\xCD\x33\x33brown3', '\x8B\x23\x23brown4', '\xFF\x8C\x69salmon1', '\xEE\x82\x62salmon2', '\xCD\x70\x54salmon3', '\x8B\x4C\x39salmon4', '\xFF\xA0\x7ALightSalmon1', '\xEE\x95\x72LightSalmon2', '\xCD\x81\x62LightSalmon3', '\x8B\x57\x42LightSalmon4', '\xFF\xA5\x00orange1', '\xEE\x9A\x00orange2', '\xCD\x85\x00orange3', '\x8B\x5A\x00orange4', '\xFF\x7F\x00DarkOrange1', '\xEE\x76\x00DarkOrange2', '\xCD\x66\x00DarkOrange3', '\x8B\x45\x00DarkOrange4', '\xFF\x72\x56coral1', '\xEE\x6A\x50coral2', '\xCD\x5B\x45coral3', '\x8B\x3E\x2Fcoral4', '\xFF\x63\x47tomato1', '\xEE\x5C\x42tomato2', '\xCD\x4F\x39tomato3', '\x8B\x36\x26tomato4', '\xFF\x45\x00OrangeRed1', '\xEE\x40\x00OrangeRed2', '\xCD\x37\x00OrangeRed3', '\x8B\x25\x00OrangeRed4', '\xFF\x00\x00red1', '\xEE\x00\x00red2', '\xCD\x00\x00red3', '\x8B\x00\x00red4', '\xFF\x14\x93DeepPink1', '\xEE\x12\x89DeepPink2', '\xCD\x10\x76DeepPink3', '\x8B\x0A\x50DeepPink4', '\xFF\x6E\xB4HotPink1', '\xEE\x6A\xA7HotPink2', '\xCD\x60\x90HotPink3', '\x8B\x3A\x62HotPink4', '\xFF\xB5\xC5pink1', '\xEE\xA9\xB8pink2', '\xCD\x91\x9Epink3', '\x8B\x63\x6Cpink4', '\xFF\xAE\xB9LightPink1', '\xEE\xA2\xADLightPink2', '\xCD\x8C\x95LightPink3', '\x8B\x5F\x65LightPink4', '\xFF\x82\xABPaleVioletRed1', '\xEE\x79\x9FPaleVioletRed2', '\xCD\x68\x89PaleVioletRed3', '\x8B\x47\x5DPaleVioletRed4', '\xFF\x34\xB3maroon1', '\xEE\x30\xA7maroon2', '\xCD\x29\x90maroon3', '\x8B\x1C\x62maroon4', '\xFF\x3E\x96VioletRed1', '\xEE\x3A\x8CVioletRed2', '\xCD\x32\x78VioletRed3', '\x8B\x22\x52VioletRed4', '\xFF\x00\xFFmagenta1', '\xEE\x00\xEEmagenta2', '\xCD\x00\xCDmagenta3', '\x8B\x00\x8Bmagenta4', '\xFF\x83\xFAorchid1', '\xEE\x7A\xE9orchid2', '\xCD\x69\xC9orchid3', '\x8B\x47\x89orchid4', '\xFF\xBB\xFFplum1', '\xEE\xAE\xEEplum2', '\xCD\x96\xCDplum3', '\x8B\x66\x8Bplum4', '\xE0\x66\xFFMediumOrchid1', '\xD1\x5F\xEEMediumOrchid2', '\xB4\x52\xCDMediumOrchid3', '\x7A\x37\x8BMediumOrchid4', '\xBF\x3E\xFFDarkOrchid1', '\xB2\x3A\xEEDarkOrchid2', '\x9A\x32\xCDDarkOrchid3', '\x68\x22\x8BDarkOrchid4', '\x9B\x30\xFFpurple1', '\x91\x2C\xEEpurple2', '\x7D\x26\xCDpurple3', '\x55\x1A\x8Bpurple4', '\xAB\x82\xFFMediumPurple1', '\x9F\x79\xEEMediumPurple2', '\x89\x68\xCDMediumPurple3', '\x5D\x47\x8BMediumPurple4', '\xFF\xE1\xFFthistle1', '\xEE\xD2\xEEthistle2', '\xCD\xB5\xCDthistle3', '\x8B\x7B\x8Bthistle4', '\x00\x00\x00gray0', '\x03\x03\x03gray1', '\x05\x05\x05gray2', '\x08\x08\x08gray3', '\x0A\x0A\x0Agray4', '\x0D\x0D\x0Dgray5', '\x0F\x0F\x0Fgray6', '\x12\x12\x12gray7', '\x14\x14\x14gray8', '\x17\x17\x17gray9', '\x1A\x1A\x1Agray10', '\x1C\x1C\x1Cgray11', '\x1F\x1F\x1Fgray12', '\x21\x21\x21gray13', '\x24\x24\x24gray14', '\x26\x26\x26gray15', '\x29\x29\x29gray16', '\x2B\x2B\x2Bgray17', '\x2E\x2E\x2Egray18', '\x30\x30\x30gray19', '\x33\x33\x33gray20', '\x36\x36\x36gray21', '\x38\x38\x38gray22', '\x3B\x3B\x3Bgray23', '\x3D\x3D\x3Dgray24', '\x40\x40\x40gray25', '\x42\x42\x42gray26', '\x45\x45\x45gray27', '\x47\x47\x47gray28', '\x4A\x4A\x4Agray29', '\x4D\x4D\x4Dgray30', '\x4F\x4F\x4Fgray31', '\x52\x52\x52gray32', '\x54\x54\x54gray33', '\x57\x57\x57gray34', '\x59\x59\x59gray35', '\x5C\x5C\x5Cgray36', '\x5E\x5E\x5Egray37', '\x61\x61\x61gray38', '\x63\x63\x63gray39', '\x66\x66\x66gray40', '\x69\x69\x69gray41', '\x6B\x6B\x6Bgray42', '\x6E\x6E\x6Egray43', '\x70\x70\x70gray44', '\x73\x73\x73gray45', '\x75\x75\x75gray46', '\x78\x78\x78gray47', '\x7A\x7A\x7Agray48', '\x7D\x7D\x7Dgray49', '\x7F\x7F\x7Fgray50', '\x82\x82\x82gray51', '\x85\x85\x85gray52', '\x87\x87\x87gray53', '\x8A\x8A\x8Agray54', '\x8C\x8C\x8Cgray55', '\x8F\x8F\x8Fgray56', '\x91\x91\x91gray57', '\x94\x94\x94gray58', '\x96\x96\x96gray59', '\x99\x99\x99gray60', '\x9C\x9C\x9Cgray61', '\x9E\x9E\x9Egray62', '\xA1\xA1\xA1gray63', '\xA3\xA3\xA3gray64', '\xA6\xA6\xA6gray65', '\xA8\xA8\xA8gray66', '\xAB\xAB\xABgray67', '\xAD\xAD\xADgray68', '\xB0\xB0\xB0gray69', '\xB3\xB3\xB3gray70', '\xB5\xB5\xB5gray71', '\xB8\xB8\xB8gray72', '\xBA\xBA\xBAgray73', '\xBD\xBD\xBDgray74', '\xBF\xBF\xBFgray75', '\xC2\xC2\xC2gray76', '\xC4\xC4\xC4gray77', '\xC7\xC7\xC7gray78', '\xC9\xC9\xC9gray79', '\xCC\xCC\xCCgray80', '\xCF\xCF\xCFgray81', '\xD1\xD1\xD1gray82', '\xD4\xD4\xD4gray83', '\xD6\xD6\xD6gray84', '\xD9\xD9\xD9gray85', '\xDB\xDB\xDBgray86', '\xDE\xDE\xDEgray87', '\xE0\xE0\xE0gray88', '\xE3\xE3\xE3gray89', '\xE5\xE5\xE5gray90', '\xE8\xE8\xE8gray91', '\xEB\xEB\xEBgray92', '\xED\xED\xEDgray93', '\xF0\xF0\xF0gray94', '\xF2\xF2\xF2gray95', '\xF5\xF5\xF5gray96', '\xF7\xF7\xF7gray97', '\xFA\xFA\xFAgray98', '\xFC\xFC\xFCgray99', '\xFF\xFF\xFFgray100', '\xA9\xA9\xA9DarkGray', '\x00\x00\x8BDarkBlue', '\x00\x8B\x8BDarkCyan', '\x8B\x00\x8BDarkMagenta', '\x8B\x00\x00DarkRed', '\x90\xEE\x90LightGreen' ]
<code >PickList.lookupName()</code >: Convert a color name to a color value This method uses the internal self.__colorMap dictionary to lookup color names and, if found, return the corresponding color value as a Color instance. # - - - P i c k L i s t . l o o k u p N a m e def lookupName ( self, colorName ): """Look up a color name. """ #-- 1 -- # [ colorKey := colorName, uppercased ] colorKey = colorName.upper() #-- 2 -- # [ if colorKey is a key in self.__colorMap -> # return the corresponding value # else -> # return None ] try: index, color, name = self.__colorMap[colorKey] return color except KeyError: return None
<code >PickList.__init__()</code >: Constructor First the constructor calls the parent constructor to make it into a Frame. Then it creates and grids the PickList widget. # - - - P i c k L i s t . _ _ i n i t _ _ def __init__ ( self, parent, callback=None ): """Constructor for the color name PickList.""" #-- 1 -- # [ parent := parent with a new Frame added # self := that Frame ] Frame.__init__ ( self, parent ) Next we initialize the internal data structures. #-- 2 -- self.__colorList = [] self.__nameList = [] self.__colorMap = {} self.__callback = None Now create and grid the sole widget. See for documentation on the ScrolledList widget. #-- 3 -- # [ self := self with a new ScrolledList widget added # and gridded # self.__scrolledList := that widget ] self.__scrolledList = ScrolledList ( self, width=self.NAME_WIDTH, height=self.NAME_LINES, callback=self.__pickHandler ) self.__scrolledList.listbox["font"] = BUTTON_FONT self.__scrolledList.grid ( row=0, column=0 ) The logic that populates the widget with color names, and sets up the corresponding internal tables, is . #-- 4 -- # [ self.__scrolledList := self.__scrolledList populated # with non-redundant color names from the standard # file if found, defaulting to an internal color list # self.__colorMap +:= as invariant # self.__colorList +:= as invariant # self.__nameList +:= as invariant ] self.__addColors() Now that everything is set up, enable the callback mechanism. #-- 5 -- self.__callback = callback
<code >PickList.__addColors()</code >: Populate the color list The purpose of this method is to place a standard set of color names into self.__scrolledList and the internal data structures self.__colorMap, self.__colorMap and self.__colorList, that describe that same set of colors. # - - - P i c k L i s t . _ _ a d d C o l o r s def __addColors ( self ): """Populate the color set [ if a readable, valid self.COLOR_NAMES_FILE exists in one of the directories named in self.PATHS_LIST -> self.__scrolledList := self.pickList with the color names added from that file in the same order self.__colorMap := as invariant from that file self.__colorList := as invariant from that file self.__nameList := as invariant from that file else -> self.__scrolledList := self.pickList with the color names added from the internal default list self.__colorMap := as invariant from that list self.__colorList := as invariant from that list self.__nameList := as invariant from that file ] """ We will try to find the file first; see . #-- 1 -- # [ if self.COLOR_NAMES_FILE names a readable, valid # rgb.txt file in one of the directories named in # self.PATHS_LIST -> # self.__colorMap := as invariant from that file # else -> # self.__colorMap := an empty dictionary ] self.__findColorsFile() If that didn't work, set up self.__colorList from self.DEFAULT_COLORS; see . #-- 2 -- # [ if self.__colorMap is empty -> # self.__colorMap +:= as invariant from self.DEFAULT_COLORS # else -> I ] if len(self.__colorMap) == 0: self.__useDefaultColors() Because of historical differences in language and naming conventions, the color files usually have a large number of redundant colors. For example, in our local &rgb-txt;, colors “LightSlateGray”, “LightSlateGrey”, “light slate gray”, and “light slate grey” all refer to exactly the same color. So, to make it easier for the user to scroll through the list, we'll remove redundant colors from self.__colorMap; see . #-- 3 -- # [ self.__colorMap := self.__colorMap with redundant colors # removed ] self.__cleanColorMap() Now that the color set is finalized, populate the ScrolledList widget and build the self.__nameList and self.__colorList lists. Because the values in self.__colorMap are tuples starting the original color index, sorting these values will put them back in their original order. #-- 4 -- # [ valueList := values from self.__colorMap, sorted ] valueList = self.__colorMap.values() valueList.sort() #-- 5 -- # [ valueList is a list of tuples (index, color, name) -> # self.__scrolledList +:= names from valueList in the # same order # self.__colorList +:= colors from valueList in the # same order ] for index, color, name in valueList: self.__scrolledList.append ( name ) self.__nameList.append ( name ) self.__colorList.append ( color )
<code >PickList.__findColorsFile()</code >: Read the &rgb-txt; file This method searches various directories in hopes that there is a standard colors file there. If so, it sets up self.__colorList with the color values and self.__nameList with the corresponding names. # - - - P i c k L i s t . _ _ f i n d C o l o r s F i l e def __findColorsFile ( self ): """Try to find and read the standard colors file. [ if self.COLOR_NAMES_FILE names a readable, valid rgb.txt file in one of the directories named in self.PATHS_LIST -> self.__colorMap := as invariant from that file else -> self.__colorMap := an empty dictionary ] """ #-- 1 -- inFile = None #-- 2 -- # [ if self.PATHS_LIST names a directory that contains # a readable file named self._COLOR_NAMES_FILE -> # inFile := that file opened for reading # else -> I ] for dir in self.PATHS_LIST: fileName = os.path.join ( dir, self.COLOR_NAMES_FILE ) try: inFile = open ( fileName ) break except IOError: pass If we couldn't find the file, we set self.__colorMap to an empty list to signal failure, and return to the caller. #-- 2 -- if inFile is None: self.__colorMap = {} return We're not guaranteed success yet—the file might not be in the correct format. See for details of the file format and the process of reading it. #-- 3 -- # [ if inFile is a valid colors file -> # self.__colorMap := as invariant from that file # else -> # self.__colorMap := an empty dictionary ] self.__readColorsFile ( inFile )
<code >PickList.__readColorsFile()</code >: Process the &rgb-txt; file The purpose of this method is to attempt to read the rgb.txt file and use it to set up the list of standard colors. # - - - P i c k L i s t . _ _ r e a d C o l o r s F i l e def __readColorsFile ( self, inFile ): """Try to read the file of standard colors. [ inFile is a readable file -> if inFile is a valid colors file -> self.__colorMap := as invariant from that file else -> self.__colorMap := an dictionary ] """ The format of the colors file is fairly simple: Ignore comment lines beginning with a bang (!). Here is a typical line defining a color: 255 239 213 papaya whip The first three fields are numbers in [0,255] describing the red, green, and blue color values, respectively. The rest of the line contains the color name. The color files aren't huge, so we use .readlines() to return the contents of the file as a list of strings. This makes it easier to number the lines in the next step. #-- 1 -- # [ lineList := the lines from inFile as a list of strings ] lineList = inFile.readlines() Later steps need to know the original order of the colors, so we use the index in lineList as the induction variable of the loop to process the lines. If even so much as one line is not valid, we clear self.__colorMap and return. See . #-- 2 -- # [ if all the non-comment lines in inFile are valid -> # self.__colorMap := as invariant from those lines # else -> # self.__colorMap := an empty list ] try: for index in range ( len ( lineList ) ): #-- 2 body -- # [ if lineList[index] is a comment -> I # else if lineList[index] is a valid color line -> # self.__colorMap +:= an entry mapping the # uppercased color name |-> a tuple (index, # the color from that line as a Color instance), # the name from that line) # else -> # self.__colorMap := {} # return ] self.__readColorLine ( index, lineList[index] ) except IOError: self.__colorMap = {}
<code >PickList.__readColorLine()</code >: Process one line from &rgb-txt; This method reads and processes one line from the rgb.txt file. For a description of the format, see . # - - - P i c k L i s t . _ _ r e a d C o l o r L i n e def __readColorLine ( self, index, rawLine ): """Process one line from the rgb.txt file. [ (index is a nonnegative integer) and (rawLine is a string) -> if rawLine is a comment -> I else if rawLine is valid -> self.__colorMap +:= an entry mapping the uppercased color name |-> a tuple (index, the color from that line as a Color instance), the name from that line) else -> raise IOError ] """ First we remove any trailing whitespace. This will take care of any newline character. #-- 1 -- # [ line := rawLine with trailing whitespace removed ] line = rawLine.rstrip() If the line is a comment, return. #-- 2 -- if line.startswith('!'): return Python's string .split() method does a nice job of breaking the line into fields. In this call, there are two arguments. The first argument is the delimiter; passing None to this argument has the effect of using any contiguous string of whitespace characters as a delimiter. The second argument specifies an upper limit to the number of fields removed from the front of the string. By passing a value of 3 to this argument, we never get more than four fields; this will avoid splitting up color names that contain embedded spaces. #-- 3 -- # [ fieldList := line split on whitespace regions, but never # more than the first four ] fieldList = line.split ( None, 3 ) Now for some validity tests. There should be exactly four fields. Also, the first three must contain strings that can be converted to integers. For conversion of the integer values, see . #-- 4 -- if len(fieldList) < 4: raise IOError, "rgb.txt lines must have four fields" else: colorName = fieldList[-1] #-- 5 -- # [ if the first three elements of fieldList can be # converted to integers in [0,255] -> # red8 := int(fieldList[0]) # green8 := int(fieldList[1]) # blue8 := int(fieldList[2]) # else -> raise IOError ] red8 = self.__convert8 ( fieldList[0] ) green8 = self.__convert8 ( fieldList[1] ) blue8 = self.__convert8 ( fieldList[2] ) The Color class constructor expects values in the range [0,MAX_PARAM]. One possibility is just to multiply the values by 256, and that's probably sufficiently accurate. A rejected possibility was to duplicate the value, e.g., 0x80 becomes 0x8080, and 0xff becomes 0xffff. If anyone ever convinces me that it makes a difference, I'll change it. #-- 6 -- # [ color := a new Color instance made from red8, green8, # and blue8, each shifted left 8 bits ] color = Color ( red8<<8, green8<<8, blue8<<8 ) Finally, add a new entry to self.__colorMap for this color. #-- 7 -- colorKey = colorName.upper() colorTuple = (index, color, colorName) self.__colorMap [ colorKey ] = colorTuple
<code >PickList.__convert8()</code >: Convert an 8-bit number This method is used to process one of the 8-bit numbers from the &rgb-txt; file. # - - - P i c k L i s t . _ _ c o n v e r t 8 def __convert8 ( self, s ): """Convert a string to an 8-bit number. [ if s is the string representation of a number in [0,255] -> return s as an integer else -> raise IOError ] """ #-- 1 -- # [ if s can be converted to an integer -> # result := s converted to an integer # else -> raise IOError ] try: result = int ( s ) except ValueError: raise IOError, "Bad color value: '%s'" % s #-- 2 -- return result
<code >PickList.__useDefaultColors()</code >: Set up a default color list This method is called when the &rgb-txt; file is missing or invalid. It sets up the class's color list from the default color set in . # - - - P i c k L i s t . _ _ u s e D e f a u l t C o l o r s def __useDefaultColors ( self ): """Set up self's colors from the default list. [ self.__colorMap +:= as invariant from self.DEFAULT_COLORS ] """ This method sets up the color pick list from our internal, default list of colors. The self.DEFAULT_COLORS list is a list of strings with the same values as lines from rgb.txt: 8-bit values for red, green, and blue, followed by the color name. As we set up self.__colorMap, the 8-bit values are shifted left eight bits to scale them to the [0,MAX_PARAM] range expected by the Color() constructor. #-- 1 -- for index in range ( len ( self.DEFAULT_COLORS ) ): # [ self.DEFAULT_COLORS[index] is a string with the # 8-bit red, green, and blue values followed by the # color name -> # self.__colorMap +:= an entry mapping the uppercased # color name |-> a tuple (index, a Color instance # made from those color values, the color name) ] #-- 1.1 -- colorString = self.DEFAULT_COLORS [ index ] red = ord ( colorString[0] ) <<8 green = ord ( colorString[1] ) <<8 blue = ord ( colorString[2] ) <<8 color = Color ( red, green, blue ) colorName = colorString[3:] #-- 1.2 -- colorKey = colorName.upper() colorTuple = (index, color, colorName) #-- 1.3 -- self.__colorMap [ colorKey ] = colorTuple
<code >PickList.__cleanColorMap()</code >: Remove redundant colors This method removes duplicate color names. There are two mechanisms that create these: Spacing conventions: “light slate gray” is the same color as “LightSlateGray”. Spelling conventions: “LightSlateGray” is the same color as “LightSlateGrey”. Because of these variations, there may be as many as four names for the same color: “LightSlateGray” is also the same color as “light slate grey”. We'll arbitrary prefer the intercapitalized forms such as “LightSlateGray” to the versions with embedded spaces such as “light slate gray”. Equally arbitrarily, because the author happened to be born in the USA, we'll cast out the “grey” variants. # - - - P i c k L i s t . _ _ c l e a n C o l o r M a p def __cleanColorMap ( self ): """Remove redundant colors from the color map. [ self.__colorMap := self.__colorMap with redundant colors removed ] """ #-- 1 -- # [ nameList := keys of self.__colorMap ] nameList = self.__colorMap.keys() The logic for removing less preferred names is in . #-- 2 -- # [ self.__colorMap := self.__colorMap with names removed # when those names are less preferred alternatives to # names in nameList ] for colorName in nameList: self.__nameCleaner ( colorName )
<code >PickList.__nameCleaner()</code >: Remove redundant color names This method takes as an argument one of the keys to self.__colorMap, an uppercased color name. Its purpose is to find any other entries in self.__colorMap whose keys are less preferred names, and remove them. # - - - P i c k L i s t . _ _ n a m e C l e a n e r def __nameCleaner ( self, colorName ): """Remove any redundant names dominated by colorName. [ colorName is a key in self.__colorMap -> self.__colorMap := self.__colorMap with any entries removed whose keys are less-preferred alternatives to colorName ] """ For general remarks on the preference rules for color names, see . Because intercapitalized color names such as "DodgerBlue" are stored under their uppercase equivalents such as "DODGERBLUE", we need to pull out the original color name, or we won't know where spaces are to be inserted. If this lookup fails, that's okay, because the name may already have been purged. For example, the name “DarkGray” might purge “dark grey”, and then later when “dark gray” comes along it will also try to purge “dark grey”, but find that it's already gone. #-- 1 -- # [ if colorName is a key in self.__colorMap -> # origName := corresponding value's color # else -> return ] try: origName = self.__colorMap [ colorName.upper() ] [ 2 ] except KeyError: return There are two transformations on colorName to convert to the key for a less-preferred version. The .__lowerize() method converts intercapitalized names like “DodgerBlue” to their space-embedded equivalents such as "dodger blue". The .__anglicize() method converts the American spelling “gray” to the English spelling “grey”. However, we most also purge the list of names to which both transformations are applied. #-- 2 -- # [ anglican := colorName with 'gray' -> 'grey' ] anglican = self.__anglicize ( origName ) #-- 2 -- # [ if self.__colorMap has a key (anglican) -> # self.__colorMap := self.__colorMap with that key's # entry removed # else -> I ] self.__purgeName ( origName, anglican ) #-- 3 -- # [ if self.__colorMap has a key self.__lowerize(colorName) -> # self.__colorMap := self.__colorMap with that key's # entry removed # else -> I ] self.__purgeName ( origName, self.__lowerize ( origName ) ) #-- 4 -- # [ if self.__colorMap has a key self.__lowerize(anglican) -> # self.__colorMap := self.__colorMap with that key's # entry removed # else -> I ] self.__purgeName ( origName, self.__lowerize ( anglican ) )
<code >PickList.__anglicize()</code >: Convert “gray” to “grey” This method returns its string argument with the first occurrence of "gray" replaced by "grey", if there is one. # - - - P i c k L i s t . _ _ a n g l i c i z e def __anglicize ( self, name ): """Anglicize a name. [ name is a string -> if name contains "gray" -> return name with the first occurrence of "gray" replaced by "grey" else -> return name ] """ where = name.find ( "gray" ) if where >= 0: return name[:where] + "grey" + name[where+4:] else: where = name.find ( "Gray" ) if where >= 0: return name[:where] + "Grey" + name[where+4:] else: return name
<code >PickList.__lowerize()</code >: Convert intercapitalized names to lowercase This method converts an intercapitalized name such as “DarkSlateGray” to its lowercased, space-embedded form such as “dark slate gray”. # - - - P i c k L i s t . _ _ l o w e r i z e def __lowerize ( self, name ): """Convert an intercapitalized color name to lowercase form. [ name is a string -> return name with all letters lowercased, and single spaces inserted at each lowercase->uppercase transition ] """ First we break the name up into a list of individual characters. Then we work through the gaps between characters, adding a space after that gap if there was a lowercase-uppercase transition there. Finally, the str.join() method reassembles the pieces into a string. #-- 1 -- # [ letters := a list of the characters in name ] letters = list ( name ) #-- 2 -- # [ letters := letters with a space prefixed to any # uppercase letter preceded by a lowercase letter ] for i in range ( 1, len ( letters ) ): if ( letters[i-1].islower() and letters[i].isupper() ): letters[i] = " " + letters[i] #-- 3 -- return "".join ( letters )
<code >PickList.__purgeName()</code >: Remove one redundant color name This method takes two arguments. The goodName argument is a color name; badName is a less-preferred alternative. # - - - P i c k L i s t . _ _ p u r g e N a m e def __purgeName ( self, goodName, badName ): """If badName is redundant for goodName, remove it. [ (goodName is a color name in self.__colorMap) and (badName is a string) -> if goodName == badName -> I else if badName is a color name in self.__colorMap that is the same color as self.__colorMap[goodName] -> self.__colorMap := self.__colorName with its entry for badName removed else -> I ] """ First we test to see if goodName and badName are the same. For example, the .__lowerize() transformation on "red" yields "red". In this case we return. #-- 1 -- if goodName == badName: return Next, test to see if badName is even in the color map. If not, return. If it is there, retrieve the colors for both names. #-- 2 -- # [ if badName is a key in self.__colorMap -> # goodColor := self's color for goodName # badColor := self's color for badName # else -> # return ] badColor = self.lookupName ( badName ) if badColor is None: return else: goodColor = self.lookupName ( goodName ) If the colors are the same, we can safely remove the less preferred one. If they don't match, just for safety, retain the bad color. #-- 3 -- # [ if badColor == goodColor -> # self.__colorMap := self.__colorMap with the entry # for badColor removed # else -> I ] if badColor == goodColor: badKey = badName.upper() del self.__colorMap [ badKey ]
<code >PickList.__pickHandler()</code >: Someone clicked on a color name This method is called when the user clicks on a color name. The argument is the line number within the pick list. It passes the corresponding color through to the class's callback function. # - - - P i c k L i s t . _ _ p i c k H a n d l e r - - def __pickHandler ( self, linex ): """Handler for user click on a color name. """ #-- 1 -- color = self.__colorList[linex] #-- 2 -- if self.__callback is not None: self.__callback ( color )
<code >class Adjuster</code >: Color adjustment and color model selection This class includes all the widgets down the center third of the application: A ColorReadout widget shows the text and background colors in #RRGGBB form, and has a pair of radiobuttons for selecting whether the rest of this widget displays the text (foreground) color or the background color. A ModelSelector widget has radiobuttons that let the user select HSV, RGB, or CMY color space. A ColorSliders widget has three Tkinter Scale widgets the user can slide in order to make fine adjustments to a color. This Adjuster widget class, then, is really the central “brain” of the application. Inside this object are stored the current background and text colors. Here is the class interface. As with all compound widgets, it inherits its widgetness from the Frame class. # - - - - - c l a s s A d j u s t e r class Adjuster(Frame): """Widgets to store and adjust the current colors. Exports: Adjuster ( parent, callback=None ): [ (parent is a Frame) and (callback is a function or None) -> parent := parent with a new Adjuster widget added but not gridded, which will call callback whenever the displayed color is changed, where the calling sequence is callback(isText, newColor) and isText is True to set the text color, False to set the background color, and newColor is a the new color as a Color instance return that new Adjuster widget ] The next two methods return the current colors; see and . .textColor(): [ return the current text color as a Color instance ] .bgColor(): [ return the current background color as a Color instance ] The .set() method changes the currently displayed color; see . .set ( color ): [ color is a Color instance -> if self is displaying the text color -> self's text color := color else -> self's background color := color ] The .isText() method tests whether the sliders are displaying the text color or the background color; see . .isText(): [ if self is displaying the text color -> return True else -> return False ] One might ask, instead of making isText() a method call, why not make it simply an exported read-only Boolean? It is made a method strictly for the convenience of the implementer: this way, the actual value can be kept in the same Tkinter IntVar control variable that is linked to the two radiobuttons that control that switch. Here is the layout of the widgets inside. Contained widgets: .__colorReadout: [ a ColorReadout widget that displays self's text and background colors, and a pair of radiobuttons to switch between them ] .__modelSelector: [ a ModelSelector widget that lets the user select which color model to display ] .__colorSliders: [ a ColorSliders widget that lets the user adjust the color model's parameters ] Grid plan: Vertically stacked in a single column. """
Manifest constants Two class variables hold the initial colors, black text and red background. DEFAULT_TEXT_COLOR = Color ( 0, 0, 0 ) DEFAULT_BG_COLOR = Color ( MAX_PARAM, 0, 0 )
<code >Adjuster.set()</code >: Change the color This method changes the color to the given value. The actual color is stored inside the ColorReadout widget. See . # - - - A d j u s t e r . s e t def set ( self, color ): """Change the currently displayed color. """ #-- 1 -- # [ self.__colorReadout := self.__colorReadout # displaying color ] self.__colorReadout.set ( color ) Also change the slider positions to reflect the new color; see . #-- 2 -- # [ self.__colorSliders := self.__colorSliders # displaying color ] self.__colorSliders.setColor ( color )
<code >Adjuster.textColor()</code >: Return the current text color This is a pass-through method that extracts the current text color from the internal ColorReadout widget. See . # - - - A d j u s t e r . t e x t C o l o r def textColor ( self ): """Return self's current text color. """ return self.__colorReadout.textColor()
<code >Adjuster.bgColor()</code >: Return the current text color This is another pass-through method. The reference source for the current background color is in the ColorReadout widget. See . # - - - A d j u s t e r . b g C o l o r def bgColor ( self ): """Return self's current background color. """ return self.__colorReadout.bgColor()
<code >Adjuster.isText()</code >: Which color is being displayed? This method is a predicate that returns True if the text color is currently being displayed in the ColorSliders widget, False if the background color is being displayed. The actual state lives inside the ColorReadout widget, so this method interrogates that widget for the value. See . # - - - A d j u s t e r . i s T e x t def isText ( self ): """Is self displaying the text color? """ return self.__colorReadout.isText()
<code >Adjuster.__init__()</code >: Constructor The constructor starts out by calling the parent's constructor to initialize this instance's frame-nature. Then it stores the name of the callback, and calls to set up the contained widgets. # - - - A d j u s t e r . _ _ i n i t _ _ def __init__ ( self, parent, callback ): """Constructor for the Adjuster compound widget. """ #-- 1 -- # [ parent := parent with self added as a new Frame ] Frame.__init__ ( self, parent ) To prevent callbacks during initialization, we temporarily set the callback pointer to None. #-- 2 -- self.__callback = None takes care not only of widget creation, but also sets up the initial colors. #-- 3 -- # [ self := self with all contained widgets created and # gridded ] self.__createWidgets() One more initialization remains. The ModelSelector widget, just created, selects one of the models initially. We must now retrieve the current model from that widget and pass it down to the ColorSliders widget so that it can display the correct labels on the sliders. See and . #-- 4 -- # [ self.__colorSliders := self.__colorSliders displaying # the color model currently selected in # self.__modelSelector ] model = self.__modelSelector.getModel() self.__colorSliders.setModel ( model ) Now that everything is initialized, we can arm the callback mechanism. #-- 5 -- self.__callback = callback
<code >Adjuster.__createWidgets()</code >: Create internal widgets There are three contained widgets, stacked vertically in column 0 of the grid. # - - - A d j u s t e r . _ _ c r e a t e W i d g e t s def __createWidgets ( self ): """Create and grid all internal widgets """ First is the ColorReadout widget that displays the selected colors; see . The initial colors are defined as manifest class constants; see . The ColorReadout class expects a callback function; we pass it a reference to . #-- 1 -- # [ self := self with a new ColorReadout added and gridded # that will call self.__callback() when the user # changes the text/background choice # self.__colorReadout := that new ColorReadout ] self.__colorReadout = ColorReadout ( self, self.DEFAULT_BG_COLOR, self.DEFAULT_TEXT_COLOR, self.__readoutHandler ) rowx = 0 self.__colorReadout.grid ( row=rowx, column=0, sticky=E+W ) Next is the ModelSelector widget. It needs a callback function that will be called when the user changes the displayed color model. See . #-- 2 -- # [ self := self with a new ModelSelector added and gridded # that will select the color model displayed in # self.__colorSliders, and call self.__modelHandler # when the color model is changed ] self.__modelSelector = ModelSelector ( self, self.__modelHandler ) rowx += 1 self.__modelSelector.grid ( row=rowx, column=0, sticky=E+W, pady=4 ) Last is the ColorSliders widget that displays the current color model parameters. This too has a callback function, called when the user changes any of the current color model parameters. See . #-- 3 -- # [ self := self with a new ColorSliders widget added # that displays the current color model parameters # and calls self.__modelHandler whenever the user # changes a color model parameter # self.__colorSliders := that ColorSliders widget ] self.__colorSliders = ColorSliders ( self, self.bgColor(), self.__sliderHandler ) rowx += 1 self.__colorSliders.grid ( row=rowx, column=0, sticky=W )
<code >Adjuster.__readoutHandler()</code >: Change between text and background colors This method is called by the ColorReadout widget when the user changes between displaying the text color and displaying the background color. It has two functions: Internally, it tells the ColorSliders to display whichever color is now shown in the ColorReadout widget. Externally, it calls the Adjuster instance's callback function. # - - - A d j u s t e r . _ _ r e a d o u t H a n d l e r def __readoutHandler ( self ): """Change the internal and external colors. [ if self.isText() -> self := self displaying the text color call self.__callback(True, self.textColor()) else -> self := self displaying the background color call self.__callback(False, self.bgColor()) ] """ The first step is to determine which color the sliders display: the text color or the background color. Then order the ColorSliders widget to display that color using the current color model. #-- 1 -- if self.isText(): sliderColor = self.textColor() else: sliderColor = self.bgColor() #-- 2 -- # [ self.__colorSliders := self.__colorSliders displaying # sliderColor ] self.__colorSliders.setColor ( sliderColor ) We must also notify self's callback. #-- 3 -- if self.__callback is not None: self.__callback ( self.isText(), sliderColor )
<code >Adjuster.__modelHandler()</code >: Change the current color model This method is called when the user changes the currently selected color model. The internal text and background colors do not change, but the ColorSliders widget must change the labels and values shown on the three sliders for the color model's three parameters. Python's ability to pass classes as objects really simplifies life here. We define an abstract class in , with concrete subclasses for each color model. Then, when the user selects a new color model, we can pass the actual Python class to the ColorSliders object, where it is needed to convert between parameter values and colors. See also . # - - - A d j u s t e r . _ _ m o d e l H a n d l e r def __modelHandler ( self, model ): """Change the color model used in the color sliders. [ model is a concrete subclass of ColorModel -> self.__colorSliders := self.__colorSliders displaying its current color using (model) ] """ self.__colorSliders.setModel ( model )
<code >Adjuster.__sliderHandler()</code >: Handler for slider changes This method is called when the user changes the position of any of the color sliders in the ColorSliders widget. It updates the ColorReadout to show the new color. Then it calls this class's callback to inform external observers that the displayed color has changed. See . # - - - A d j u s t e r . _ _ s l i d e r H a n d l e r def __sliderHandler ( self, color ): """Notify observers of a change in the color sliders. """ #-- 1 -- # [ self.__colorReadout := self.__colorReadout displaying # color self.__colorReadout.internalSet ( color ) #-- 2 -- if self.__callback is not None: self.__callback ( self.isText(), color )
<code >class ColorReadout</code >: Text and background color readouts This class is a compound widget that has two functions: It displays the current text and background colors in #RRGGBB form. It has radiobuttons that allow the user to select whether the color sliders are displaying the text color or the background color. Here is the class interface: # - - - - - c l a s s C o l o r R e a d o u t class ColorReadout(Frame): """Displays text and background colors, and switches between them. Exports: ColorReadout ( parent, bg, fg, callback=None ): [ (parent is a Frame) and (bg is a background color as a Color) and (fg is a foreground color as a Color) and (callback is a function or None) -> parent := parent with a new ColorReadout widget added but not gridded, initially displaying the background color, which will call callback() whenever the user changes between text to bg color ] The next two methods return the current text and background colors, respectively; see and . .textColor(): [ return self's current text color as a Color instance ] .bgColor: [ return self's current background color as a Color instance ] The .set() method changes the currently displayed color; see . .set ( color ): [ if self is currently displaying the text color -> self's text color := color else -> self's background color := color In any case -> call self.__callback(color) ] To determine whether the user has selected text or background color, call this method; see . .isText(): [ if self is currently displaying the text color -> return True else -> return False ] Here is the layout of the internal widgets, and the internal attributes that control them. Contained widgets: .__rgbLabel: [ text label '#RRGGBB' ] .__textColorName: [ an Entry widget displaying self.__textColorVar ] .__bgColorName: [ an Entry widget displaying self.__bgColorVar ] .__textRadio: [ a Radiobutton selecting text color ] .__bgRadio: [ a Radiobutton selecting background color ] Grid plan: 0 1 +--------------+-------------------+ 0 | | .__rgbLabel | +--------------+-------------------+ 1 | .__bgRadio | .__bgColorName | +--------------+-------------------+ 2 | .__textRadio | .__textColorName | +--------------+-------------------+ State/Internals: .__callback: [ as passed to constructor, read-only ] .__isTextVar: [ an IntVar that is 1 if displaying text color, 0 if displaying background color ] .__bgColor: [ self's current background color as a Color instance ] .__bgColorVar: [ a StringVar displaying self.__bgColor as #RRGGBB ] .__textColor: [ self's current text color as a Color instance ] .__textColorVar: [ a StringVar displaying self.__textColor as #RRGGBB ] """
<code >ColorReadout.isText()</code >: Which color are we displaying? This method returns True if the text color is selected, False otherwise. The actual state item that contains this choice is self.__isTextVar, a Tkinter IntVar control variable that is also linked to the Radiobuttonwidgets. # - - - C o l o r R e a d o u t . i s T e x t def isText ( self ): """Is self showing the text color? """ return self.__isTextVar.get()
<code >ColorReadout.set()</code >: Change the displayed color When the user changes the current color, either by clicking on it in the color name pick list, or by adjusting one of the color parameter sliders, this method is called to display the new color's name. # - - - C o l o r R e a d o u t . s e t def set ( self, color ): """Change the currently selected color. """ Translating a color into "#RRGGBB" is done by the Color.__str__() method. The widgets that display this string are linked to control variables, so a call to the control variable's .set() method changes the displayed label. See . #-- 1 -- # [ if self.isText() -> # self's text color := color # else -> # self's background color := color ] self.internalSet ( color ) External observers must also be notified that the current color has changed. #-- 2 -- if self.__callback is not None: self.__callback ( )
<code >ColorReadout.internalSet()</code > This method actually displays the new color. It does not call the user's callback; it is used when the color change happens internal to the Adjuster widget. Originally, a change to the color sliders called the .set() method, but this lead to an infinite loop: the sliders called ColorReadout.set() which called its callback which told the sliders about the new color, and around and around we go until we reach the Python recursion limit. # - - - C o l o r R e a d o u t . i n t e r n a l S e t def internalSet ( self, color ): """Change the currently selected color without calling callbacks. [ color is a Color instance -> if self.isText() -> self's text color := color else -> self's background color := color ] """ if self.isText(): self.__textColor = color self.__textColorVar.set ( str ( color ) ) else: self.__bgColor = color self.__bgColorVar.set ( str ( color ) )
<code >ColorReadout.textColor()</code >: Return the current text color This method returns the current text color as a Color instance. The actual value is stored in self.__textColor, but this is a private attribute. # - - - C o l o r R e a d o u t . t e x t C o l o r def textColor ( self ): """Return self's current text color. """ return self.__textColor
<code >ColorReadout.bgColor()</code >: Return the current background color Another pass-through method that protects the internal background color in self.__bgColor. # - - - C o l o r R e a d o u t . b g C o l o r def bgColor ( self ): """Return self's current background color. """ return self.__bgColor
<code >ColorReadout.__init__()</code >: Constructor The constructor first calls it parent class constructor to make it into a Frame. Then it creates the control variable .__isTextVar, and set it initially to indicate the background color. Finally it calls to create and position its contained widgets. # - - - C o l o r R e a d o u t . _ _ i n i t _ _ def __init__ ( self, parent, bg, fg, callback=None ): """Constructor for ColorReadout. """ #-- 1 -- # [ parent := parent with self added as a new Frame ] Frame.__init__ ( self, parent, relief=SUNKEN, bd=4 ) #-- 2 -- # [ self.__isTextVar := a new IntVar control variable # initialized to 0 # self.__bgColor := bg # self.__bgColorVar := a new StringVar control # variable set to str(bg) # self.__textColor := fg # self.__textColorVar := a new StringVar control # variable set to str(fg) ] self.__isTextVar = IntVar() self.__isTextVar.set(0) self.__bgColor = bg self.__bgColorVar = StringVar() self.__bgColorVar.set ( str ( bg ) ) self.__textColor = fg self.__textColorVar = StringVar() self.__textColorVar.set ( str ( fg ) ) #-- 3 -- # [ self := self with all internal widgets created and # gridded ] self.__createWidgets() #-- 4 -- self.__callback = callback
<code >ColorReadout.__createWidgets()</code > This methods creates and grids all the widgets. For the grid plan, refer to . # - - - C o l o r R e a d o u t . _ _ c r e a t e W i d g e t s def __createWidgets ( self ): """Create and grid all internal widgets. """ The first row contains only a label "#RRGGBB" that helps the user interpret the background and text colors that appear aligned below it. #-- 1 -- # [ self.__rgbLabel := a new Label added and gridded ] self.__rgbLabel = Label ( self, font=MONO_FONT, text="#RRGGBB" ) rowx = 0 self.__rgbLabel.grid ( row=rowx, column=1, sticky=E+W ) The second row contains the radiobutton and readout for the background color. #-- 2 -- # [ self := self with a new Radiobutton widget that sets # self.__isTextVar to 0 and calls self.__radioHandler # when the radiobutton is changed # self.__bgRadio := that Radiobutton widget ] self.__bgRadio = Radiobutton ( self, command=self.__radioHandler, font=BUTTON_FONT, text="Background color", value=0, variable=self.__isTextVar ) rowx += 1 self.__bgRadio.grid ( row=rowx, column=0, sticky=W ) It might seem logical to use a Label widget to display color names, but they have one drawback: the user can't use the mouse to cut the color name for pasting elsewhere. Consequently, we use an Entry widget. Here are some of the less obvious options, and why we use them: relief=RAISED, bd=4 Make the labels look like they are sticking up. Use a four-pixel border to give some space for this 3-d effect. exportselection=1 Allow the user to cut text from this widget. takefocus=0 We don't want the user to be able to change the text displayed here; this option prevents the tab key from moving the input focus through this widget. #-- 3 -- # [ self.__bgColorName := a new Entry whose text is # linked to self.__bgColorVar ] self.__bgColorName = Entry ( self, exportselection=1, takefocus=0, width=7, relief=RAISED, bd=4, bg="white", font=MONO_FONT, textvariable=self.__bgColorVar ) self.__bgColorName.grid ( row=rowx, column=1, padx=4, sticky=W ) The next row is quite similar to the previous row, but it is for the text color. #-- 4 -- # [ self := self with a new Radiobutton widget that sets # self.__isTextVar to 1 and calls self.__radioHandler # when the radiobutton is changed # self.__textRadio := that Radiobutton widget ] self.__textRadio = Radiobutton ( self, command=self.__radioHandler, font=BUTTON_FONT, text="Text color", value=1, variable=self.__isTextVar ) rowx += 1 self.__textRadio.grid ( row=rowx, column=0, sticky=W ) #-- 5 -- # [ self.__textColorName := a new Entry whose text is # linked to self.__textColorVar ] self.__textColorName = Entry ( self, exportselection=1, takefocus=0, width=7, relief=RAISED, bd=4, bg="white", font=MONO_FONT, textvariable=self.__textColorVar ) self.__textColorName.grid ( row=rowx, column=1, padx=4, sticky=W ) There is a drawback to using an Entry widget to display the color values: the user can then edit the displayed values, which would mean they no longer reflect the actual color values. One trick we tried is to set state=DISABLED in both Entry widgets. This does a fine job of preventing the user from changing the value, and in an older Tkinter version, the fix worked. However, in a newer Tkinter install, it is now impossible to use cut-and-paste on a disabled widget. The solution is to bind all keyboard events to a little handler called . This event handler rewrites the values of both the names to keep them consistent with the internal colors. Here is the code that sets up that event binding. #-- 6 -- # [ self.__bgColorName := self.__bgColorName set up so # that any user keypresses cause self.__bgColorVar # to be set to str(self.__bgColor) # self.__textColorName := self.__textColorName set up so # that any user keypresses cause self.__textColorVar # to be set to str(self.__textColor) ] self.__bgColorName.bind ( "<Any-KeyRelease>", self.__fixNames ) self.__textColorName.bind ( "<Any-KeyRelease>", self.__fixNames )
<code >ColorReadout.__radioHandler()</code >: Radiobutton state change handler When the user changes the state of the radiobuttons, we need to call the external callback function. # - - - C o l o r R e a d o u t . _ _ r a d i o H a n d l e r def __radioHandler ( self ): """Handler for a change between text and background color. """ if self.__callback is not None: self.__callback ( )
<code >ColorReadout.__fixNames()</code >: Prevent user modification of the <code >Entry</code > widgets For an explanation of what this handler does and why it does it, see . It is called with the event handler protocol, so it expects an Event object as its argument. # - - - C o l o r R e a d o u t . _ _ f i x N a m e s def __fixNames ( self, event ): """Prevent the user from modifying color name Entry widgets. """ These lines re-assert the two class invariants: that the self.__bgColorVar control variable reflects the background color in self.__bgColor, and the same invariant for self.__textColorVar and self.__textColor. self.__bgColorVar.set ( str ( self.__bgColor ) ) self.__textColorVar.set ( str ( self.__textColor ) )
<code >class ModelSelector</code >: Widgets to select a color model This class is a compound widget that allows the user to select among different color models. There are a number of different ways to map color space onto coordinate systems, but three numbers are required in any case. Although originally designed to support three models (HSV, RGB, and CMY), there is no reason why other models cannot be added later. # - - - - - c l a s s M o d e l S e l e c t o r class ModelSelector(Frame): """Compound widget for selecting color models. Exports: ModelSelector ( parent, callback=None ): [ (parent is a Frame) and (callback is a function or None) -> parent := parent with a new ModelSelector widget added but not gridded, that lets the user select a color model (initially RGB), and calls callback(model) when a selection is made, where model is a concrete class that inherits from ColorModel return that new ModelSelector widget ] This method returns the currently selected model; see . .getModel(): [ returns self's model as a concrete class of ColorModel ] Internal widgets: .__topLabel: [ a Label that labels the radiobuttons ] .__radioList: [ a list of Radiobutton widgets, one per model ] Grid plan: 0 1 2... +-----------------+-----------------+-----+ 0 | .__topLabel | +-----------------+-----------------+-----+ 1 | .__radioList[0] | .__radioList[1] | ... | +-----------------+-----------------+-----+ Here are some private attributes of the class. First, self.__callback is the callback function. The control variable that links the radiobuttons together into a group is self.__radioVar. State/Invariants: .__callback: [ as passed to constructor, read-only ] .__radioVar: [ an IntVar control variable for the radiobuttons whose value is the model's index in self.__modelList ] There is also a class variable that enumerates the supported color models, as instances of concrete classes implementing the ColorModel abstract class. ModelSelector.__modelList: [ a list of instances of ColorModel concrete classes, in the same order as self.__radioList ] """
<code >ModelSelector</code >: Constants The set of concrete classes of ColorModel, representing the different color models that the user can select, is a class attribute. See , , and . __modelList = [ HSVModel(), RGBModel(), CMYModel() ] To add a new model, write its class inheriting from ColorModel, implement its virtual methods, and add a call to its constructor to the line above.
<code >ModelSelector.getModel()</code >: Return the current model This method returns the currently selected color model as a concrete class implementing ColorModel. The self.__radioVar control variable contains the index of the currently selected model. # - - - M o d e l S e l e c t o r . g e t M o d e l def getModel ( self ): """Returns self's current color model. """ #-- 1 -- # [ modelx := index in self.__radioList of the currently # selected color model ] modelx = self.__radioVar.get() #-- 2-- return self.__modelList[modelx]
<code >ModelSelector.__init__()</code >: Constructor The constructor first calls the parent class constructor, which makes self a Frame. # - - - M o d e l S e l e c t o r . _ _ i n i t _ _ def __init__ ( self, parent, callback ): """Constructor for the ModelSelector compound widget. """ #-- 1 -- # [ parent := parent with a new Frame widget added but # not gridded # self := that new Frame widget ] Frame.__init__ ( self, parent, relief=SUNKEN, bd=4 ) Next we store a reference to the callback function, and create the list that will contain the radiobuttons, and then create and initialize their associated control variable. Finally, we create all the widgets—see . #-- 2 -- self.__callback = None self.__radioList = [] self.__radioVar = IntVar() self.__radioVar.set(0) #-- 3 -- # [ self := self with all internal widgets created and # gridded ] self.__createWidgets() #-- 4 -- self.__callback = callback
<code >ModelSelector.__createWidgets()</code > For the list of internal widgets and the grid plan, see . # - - - M o d e l S e l e c t o r . _ _ c r e a t e W i d g e t s def __createWidgets ( self ): """Create and grid all internal widgets. """ #-- 1 -- # [ self.__topLabel := a Label labeling the radiobuttons ] self.__topLabel = Label ( self, font=BUTTON_FONT, text="Select a color model:" ) rowx = 0 self.__topLabel.grid ( row=rowx, column=0, columnspan=3, sticky=W ) The radiobuttons can be arranged either horizontally or vertically. We chose horizontal under the assumption that space may be at a premium, and also because the labels for the color models are short (all are three letters). First we create the associated control variable, then we populate self.__radioList with Radiobutton widgets, each displaying the name from the corresponding model as its label. #-- 2 -- # [ self.__modelList is a list of ColorModel instances -> # self := self with one Radiobutton added and gridded for # each element of self.__modelList, labeled with the # model name of that element, and setting self.__radioVar # to the position of that element in self.__modelList # self.__radioList +:= those Radiobuttons in the # same order ] rowx += 1 colx = 0 for radiox in range(len(self.__modelList)): #-- 2 body -- # [ radiox is an index in self.__modelList -> # self := self with a new Radiobutton added and # gridded, labeled with the model name from # self.__modelList[radiox], and setting # self.__radioVar to radiox ] model = self.__modelList[radiox] radio = Radiobutton ( self, font=BUTTON_FONT, command=self.__radioHandler, value=radiox, variable=self.__radioVar, text=model.modelName ) radio.grid ( row=rowx, column=colx, sticky=W, padx=6 ) colx += 1 self.__radioList.append ( radio )
<code >ModelSelector.__radioHandler()</code >: Handler for radiobutton action This method is called when the user selects one of the color model radiobuttons. # - - - M o d e l S e l e c t o r . _ _ r a d i o H a n d l e r def __radioHandler ( self ): """The user selected a different color model. """ When the model is changed, we must call our callback function to notify outside observers of the new model. The argument to the callback is a ColorModel instance. #-- 1 -- if self.__callback is not None: modelx = self.__radioVar.get() self.__callback ( self.__modelList[modelx] )
<code >class ColorSliders</code >: Color model parameter sliders This class is a compound widget containing three sliders (Tkinter Scale widgets) that the user can drag to change the value of one of the color model's parameters. # - - - - - c l a s s C o l o r S l i d e r s class ColorSliders(Frame): """Compound widget for displaying and adjusting color parameters Exports: ColorSliders ( parent, color, callback=None ): [ (parent is a Frame) and (color is the initial color as a Color instance) and (callback is a function or None) -> parent := parent with a new ColorSliders widget added but not gridded, using the HSV model, initially displaying white, that will call callback(color) whenever the user changes a color parameter return that new ColorSliders widget ] The .setModel() changes the model used to compute the slider positions; see . .setModel ( model ): [ model is a concrete subclass of ColorModel -> self := self with its current color displayed using model ] The .setColor() method changes the currently displayed color; see . .setColor ( color ): [ color is a Color instance -> self := self displaying color using its current model ] The label for this widget spans all the columns in row 0. The three ParamSlider widgets are gridded horizontally across row 1. Internal widgets: .__topLabel: [ a Label that describes this widget ] .__sliderList: [ a list containing three ParamSlider widgets corresponding to the three parameters of self.__model in the same order ] Grid plan: 0 1 2 +------------------+------------------+------------------+ 0 | .__topLabel | +------------------+------------------+------------------+ 1 | .__sliderList[0] | .__sliderList[1] | .__sliderList[2] | +------------------+------------------+------------------+ Internal state includes the current color and the current color model. State/Invariants: .__callback: [ as passed to the constructor ] .__color: [ the currently displayed color as a Color ] .__model: [ the current color model as a concrete subclass of ColorModel ] """
<code >ColorSliders.setModel()</code >: Display a new color model This method is called to changed the color model displayed in these sliders. # - - - C o l o r S l i d e r s . s e t M o d e l def setModel ( self, model ): """Change the displayed color model. """ It is not necessary to display the name of the currently selected color model here. The user can look at the ModelSelector widget to find that out, or they can look at the labels displayed on the parameter sliders. The primary work of this method, then, is to tell the ParamSlider widgets to change their labels to those of the parameters of the new models. Once they are relabeled, we call with the current color, which will tell the parameter sliders to redisplay that color using the newly selected model. #-- 1 -- self.__model = model #-- 2 -- # [ self.__sliderList := self.__sliderList with its # contained widgets relabeled for model (model) ] for paramx in range ( N_PARAMS ): self.__sliderList[paramx].setModel ( self.__model ) #-- 3 -- # [ self := self displaying the parameters self.__color # using model self.__model ] self.setColor ( self.__color )
<code >ColorSliders.setColor()</code >: Change the displayed color This method is called to change the color currently being displayed in this widget. # - - - C o l o r S l i d e r s . s e t C o l o r def setColor ( self, color ): """Change the displayed color. """ Because each ParamSlider widget knows which parameter of the model is displaying, all we have to do is tell each one the new color; see . #-- 1 -- self.__color = color #-- 2 -- for paramx in range ( N_PARAMS ): #-- 1 body -- # [ self.__sliderList[paramx] := self.__sliderList[paramx] # displaying the (paramx)th parameter of (color) # using its current color model ] self.__sliderList[paramx].setColor ( color )
<code >ColorSliders.__init__()</code >: Constructor The constructor starts by calling its parent class constructor. The calls to .columnconfigure() distribute the width of the included columns equally (weight) and assign a minimum column size (minsize). # - - - C o l o r S l i d e r s . _ _ i n i t _ _ def __init__ ( self, parent, color, callback ): """Constructor for the ColorSliders widget. """ #-- 1 -- # [ parent := parent with a new Frame added but not # gridded # self := that Frame ] Frame.__init__ ( self, parent ) self.columnconfigure ( 0, weight=1, minsize="80" ) self.columnconfigure ( 1, weight=1, minsize="80" ) self.columnconfigure ( 2, weight=1, minsize="80" ) Then it creates the initial color (red) and model (HSV), and calls to create its internal widgets. #-- 2 -- # [ self.__color := red # self.__model := the HSV color model # self.__callback := callback ] self.__color = color self.__model = HSVModel() self.__callback = None #-- 3 -- # [ self := self with all internal widgets created and # gridded ] self.__createWidgets() #-- 4 -- self.__callback = callback
<code >ColorSliders.__createWidgets()</code > For the widget layout, see . # - - - C o l o r S l i d e r s . _ _ c r e a t e W i d g e t s def __createWidgets ( self ): """Create and grid all internal widgets. """ #-- 1 -- # [ self := self with a new Label created and gridded # self.__topLabel := that new Label ] # self.__topLabel = Label ( self, font=BUTTON_FONT, text="Adjust colors here:" ) rowx = 0 self.__topLabel.grid ( row=rowx, column=0, columnspan=3, sticky=E+W ) Next we add a horizontal group of parameter slider widgets: see . #-- 2 -- self.__sliderList = [] # [ self := self with N_PARAMS new ParamSlider widgets # added and gridded # self.__sliderList +:= those widgets ] rowx += 1 for paramx in range ( N_PARAMS ): paramSlider = ParamSlider ( self, self.__model, self.__color, paramx, self.__sliderHandler ) paramSlider.grid ( row=rowx, column=paramx, sticky=E+W ) self.__sliderList.append ( paramSlider )
<code >ColorSliders.__sliderHandler()</code >: Handler for a parameter change This method is called when the user changes the setting of any of the ParamSlider widgets. This method takes no arguments; when any slider changes, we have to look at all three and convert those settings into the new color. # - - - C o l o r S l i d e r s . _ _ s l i d e r H a n d l e r def __sliderHandler ( self ): """Read the ParamSliders and convert them to a new color """ First we read all three sliders and build a list of their values, each value in [0,MAX_PARAM]. #-- 1 -- paramList = [] #-- 2 -- # [ paramList +:= parameter values of the ParamSlider # widgets in self.__sliderList ] for paramx in range(N_PARAMS): paramList.append (self.__sliderList[paramx].get() ) In classes that inherit from ColorModel, the .paramsToColor() method converts the list of parameters into a Color object. See . #-- 3 -- # [ paramList is a list of N_PARAMS numbers, each in # [0,MAX_PARAM] -> # self.__color := paramList converted to a color using # the color model in self.__model ] self.__color = self.__model.paramsToColor ( paramList ) We must call our callback now to notify external observers that the color has changed. #-- 4 -- if self.__callback is not None: self.__callback ( self.__color )
<code >class ParamSlider</code >: Scale widget for a color model parameter This class is a compound widget containing the controls that let the user adjust one of the parameters of the current color. Since colors in external form show only 8 bits per pixel, the length of the vertical Scale widget for the parameter is exactly 256 pixels, covering the range [0,255]. Because color model parameter values are in the range [0,65535], conversion from the scale value to the parameter value are a simple shift of 8 bits. # - - - - - c l a s s P a r a m S l i d e r class ParamSlider(Frame): """Compound widget with a Scale for adjusting one color parameter. Exports: ParamSlider ( parent, model, color, paramx, callback=None ): [ (parent is a Frame) and (model is a ColorModel) and (color is a Color) and (param is an int in [0,N_PARAMS)) and (callback is a function or None) -> parent := parent with a new ParamSlider widget added but not gridded, that displays the (paramx)th parameter of (color) using (model), and calls callback() whenever its scale is moved return that new ParamSlider widget ] The .get() method returns the 16-bit integer value of this parameter; see . .get(): [ return self's slider value in [0,MAX_PARAM] ] The .setModel() and .setColor() methods change the current color model and color, respectively; see and . .setModel ( model ): [ self := self displaying labels for the (paramx)th parameter of model ] .setColor ( color ): [ self := self displaying the (paramx)th parameter of self.model ] Each ParamSlider contains four widgets in a vertical row: Internal widgets: .__topLabel: [ Label showing the parameter's name ] .__plusButton: [ Button that increments the parameter ] .__scale: [ Scale for adjusting the parameter ] .__minusButton: [ Button that decrements the parameter ] Grid plan: One vertical column. Here are the private attributes. State/Invariants: .__paramx: [ as passed to the constructor ] .__callback: [ as passed to the constructor ] .__topLabelVar: [ StringVar for self.__topLabel ] .__scaleVar: [ IntVar for self.__scale ] .__model: [ current model as a ColorModel ] .__color: [ current color as a Color ] """
<code >ParamSlider.get()</code >: Retrieve the current parameter value This method returns the parameter value in the range [0,MAX_PARAM. The actual parameter value lives in the self.__scaleVar control variable, but it is an 8-bit value, so we must convert it. # - - - P a r a m S l i d e r . g e t def get ( self ): """Return self's parameter value in [0,MAX_PARAM]. """ return self.__scaleVar.get() << 8
<code >ParamSlider.setModel()</code >: Change the color model This method changes the color model being displayed. # - - - P a r a m S l i d e r . s e t M o d e l def setModel ( self, model ): """Change the current color model.""" First we store the new color model in self.__model. #-- 1 -- self.__model = model The label self.__topLabel displays the parameter name; retrieve the parameter name from the color model and change the label's text to that name. #-- 2 -- # [ self.__topLabelVar := self.__topLabelVar with its # value set to the (self.__paramx)th parameter name # of self.__model ] paramLabel = self.__model.labelList[self.__paramx] self.__topLabelVar.set ( paramLabel ) Note: Originally, there was logic here to change the displayed color. However, this led to a nasty defect. In the original version, the caller first sets the first slider's model—but then the callback to change the color would calculate a new color based on the positions of sliders 2 and 3, which still used the old model! The fix was to put the burden on the caller to redisplay the new color once all the sliders were moved to the new model.
<code >ParamSlider.setColor()</code >: Change the current color This method changes the color whose parameter is currently displayed. # - - - P a r a m S l i d e r . s e t C o l o r def setColor ( self, color ): """Change the currently displayed color.""" #-- 1 -- self.__color = color We must readjust the position of the Scale widget. First, we translate the new color into its three parameters using the current color model. For this interface, see . #-- 2 -- # [ paramList := self.__color expressed as a list of # N_PARAMS parameters using color model self.__model ] paramList = self.__model.colorToParams ( color ) The parameter displayed is an element of paramList, with that element's position specified by self.__paramx. This value must be shifted right by 8 bits to fit into the range [0,MAX_BYTE]. Then the Scale widget is repositioned by calling the .set() method on its control variable. #-- 3 -- scaleValue = paramList[self.__paramx] >> 8 #-- 4 -- # [ self.__scale := self.__scale repositioned to value # (scaleValue) ] self.__scaleVar.set ( scaleValue ) Finally, we must notify the external observers that the color has changed. #-- 5 -- if self.__callback is not None: self.__callback()
<code >ParamSlider.__init__()</code >: Constructor For internal widgets and their placement, see . # - - - P a r a m S l i d e r . _ _ i n i t _ _ def __init__ ( self, parent, model, color, paramx, callback=None ): """Constructor for ParamSlider. """ First we call the parent constructor and store all the constructor's arguments. #-- 1 -- # [ parent := parent with a new Frame widget added but # not gridded # self := that Frame widget ] Frame.__init__ ( self, parent ) #-- 2 -- self.__model = model self.__color = color self.__paramx = paramx self.__callback = None Create the two control variables. self.__scaleVar is for the Scale widget, so its values vary in the range [0,MAX_BYTE]. The second control variable, self.__topLabelVar, is for the Label widget that displays the parameter name. We can't create this Label using the normal text= parameter, because it can change any time the model is changed. For example, if this is the third parameter of the RGB model, this Label would display “B”. The paramx value in that case would be 2 (since indices count from 0). #-- 3 -- # [ self.__topLabelVar := a new StringVar control variable # set to the (paramxth) parameter name of self.__model # self.__scaleVar := a new IntVar control variable ] paramLabel = self.__model.labelList[self.__paramx] self.__topLabelVar = StringVar() self.__topLabelVar.set ( paramLabel ) self.__scaleVar = IntVar() Now we're ready to create the widgets; see . #-- 4 -- # [ self := self with all internal widgets created and # gridded ] self.__createWidgets() #-- 5 -- self.__callback = callback
<code >ParamSlider.__createWidgets()</code > # - - - P a r a m S l i d e r . _ _ c r e a t e W i d g e t s def __createWidgets ( self ): """Create and grid all widgets. """ The first widget is the Label that displays the parameter name. #-- 1 -- # [ self := self with a new Label added and gridded, # with control variable self.__topLabelVar # self.topLabel := that new Label ] self.__topLabel = Label ( self, font=BUTTON_FONT, textvariable=self.__topLabelVar ) rowx = 0 self.__topLabel.grid ( row=rowx, column=0 ) Next is a button with “+” on it that increments the parameter value by 256, which is equivalent to an increment of 1 in the Scale widget's control variable. For the associated handler, see . #-- 2 -- # [ self := self with a new Button widget added and gridded # that adds 1 to self.__scaleVar but no higher than # MAX_BYTE # self.__plusButton := that widget ] self.__plusButton = Button ( self, font=BUTTON_FONT, text="+", command=self.__plusHandler ) rowx += 1 self.__plusButton.grid ( row=rowx, column=0 ) The Scale widget comes next. Its handler, called when the user drags the slider, is . #-- 3 -- # [ self := self with a new Scale widget added and gridded, # with control variable self.__scaleVar, and a length # of (MAX_BYTE+1) pixels # self.__scale := that Scale widget ] self.__scale = Scale ( self, orient=VERTICAL, command=self.__scaleHandler, length=(MAX_BYTE+1), from_=MAX_BYTE, to=0, variable=self.__scaleVar ) rowx += 1 self.__scale.grid ( row=rowx, column=0 ) The “-” button is pretty similar to the “+” button. For its handler, see . #-- 4 -- # [ self := self with a new Button widget added and gridded # that subtracts 1 to self.__scaleVar but no lower than 0 # self.__minusButton := that widget ] self.__minusButton = Button ( self, font=BUTTON_FONT, text="-", command=self.__minusHandler ) rowx += 1 self.__minusButton.grid ( row=rowx, column=0 )
<code >ParamSlider.__plusHandler()</code >: Increment the parameter This method is called when the user clicks the “+” button to increment the parameter. # - - - P a r a m S l i d e r . _ _ p l u s H a n d l e r def __plusHandler ( self ): """Increment the parameter. """ #-- 1 -- # [ if self.__scaleVar has a value < MAX_BYTE _> # self.__scaleVar += 1 # else -> I ] oldValue = self.__scaleVar.get() if oldValue < MAX_BYTE: self.__scaleVar.set ( oldValue + 1 ) if self.__callback is not None: self.__callback()
<code >ParamSlider.__minusHandler()</code >: Decrement the parameter This method is called when the user clicks the “-” button to decrement the parameter. # - - - P a r a m S l i d e r . _ _ m i n u s H a n d l e r def __minusHandler ( self ): """Increment the parameter. """ #-- 1 -- # [ if self.__scaleVar has a value > 0 -> # self.__scaleVar -= 1 # else -> I ] oldValue = self.__scaleVar.get() if oldValue > 0: self.__scaleVar.set ( oldValue - 1 ) if self.__callback is not None: self.__callback()
<code >ParamSlider.__scaleHandler()</code >: Somebody dragged the scale This method is called whenever the slider in the Scale widget gets moved. # - - - P a r a m S l i d e r . _ _ s c a l e H a n d l e r def __scaleHandler ( self, value ): """Handler for self.__scale """ Whenever the scale changes, we must notify the external observers by calling the callback function in self.__callback. The callback doesn't take any arguments. #-- 1 -- if self.__callback is not None: self.__callback()
<code >class Swatch</code >: Font and color samples This class is a compound widget containing only two internal widgets. On top is a large Text widget that displays some text in the currently selected font using the currently selected foreground color, and its background color is the currently selected background color. Below that is a FontSelect widget that allows the user to select different text fonts. For a link to this compound widget's documentation, see . Here is the class interface. # - - - - - c l a s s S w a t c h class Swatch(Frame): """Compound widget for text/background display and font selection. Exports: Swatch ( parent, bg, fg ): [ (parent is a Frame) and (bg is the initial background color as a Color instance) and (fg is the initial foreground color as a Color instance) -> parent := parent with a new Swatch widget added but not gridded return that new Swatch widget ] These methods set either the foreground or background color; see and . .setTextColor ( color ): [ color is a color as a Color instance -> self := self with the text displayed in that color ] .setBgColor ( color ): [ color is a color as a Color instance -> self := self with the background set to color ] Internal widgets: .__text: [ a Text widget ] .__fontSelect: [ a FontSelect widget ] Grid plan: One vertical column. The internal state includes the current foreground and background colors, and also the current font. State/Invariants: .__textColor: [ current text color as a Color ] .__bgColor: [ current background color as a Color ] .__font: [ current font as a tkFont.Font ] """
Class constants These class variables contain constants used to configure the widget. SWATCH_TEXT is the sample text that appears in the swatch initially. SWATCH_TEXT = ( "The quick brown fox jumps over\n" "the lazy dog.\n" "ABCDEFGHIJKLMNOPQRSTUVWXYZ\n" "abcdefghijklmnopqrstuvwxyz\n" "0123456789 !\"#$%&'()*+,-./\n" ":;<=>?@[\\]^_/{|}~" ) These two constants specify the width in characters of the Text widget, and its height in lines. SWATCH_WIDE = 40 # Width of the color swatch in characters SWATCH_HIGH = 8 # Height of the color swatch in lines The next constant specifies the number of font family names that will be visible at once in the font selector widget. FONT_FAMILIES = 15
<code >Swatch.setTextColor()</code > This method sets the text (foreground) color in the Text widget. The text color of a Text widget is its "fg" (foreground) attribute. The str() function on a Color instance returns the color's name in the "#RRGGBB" form. # - - - S w a t c h . s e t T e x t C o l o r def setTextColor ( self, color ): """Sets the text color of self.__text. """ self.__text["fg"] = str(color)
<code >Swatch.setBgColor()</code > Similar to , but the background color is the "bg" attribute. # - - - S w a t c h . s e t B g C o l o r def setBgColor ( self, color ): """Sets the background color of self.__text. """ self.__text["bg"] = str(color)
<code >Swatch.__init__()</code >: Constructor Call the parent constructor, then create the widgets; see . # - - - S w a t c h . _ _ i n i t _ _ def __init__ ( self, parent, bg, fg ): """Constructor for Swatch. """ #-- 1 -- # [ parent := parent with a new Frame added # self := that Frame ] Frame.__init__ ( self, parent ) #-- 2 -- self.__textColor = fg self.__bgColor = bg #-- 3 -- # [ self := self with all internal widgets added and gridded ] self.__createWidgets() At this point the FontSelect widget contains an initial font, so we can set up the Text widget to use that font. Then we place some sample text into the Text widget. #-- 4 -- # [ self.__text := self.__text using the font from # self.__fontSelect ] self.__text["font"] = self.__fontSelect.get() #-- 5 -- # [ self.__text := self.__text with some sample text added ] self.__text.insert ( END, self.SWATCH_TEXT )
<code >Swatch.__createWidgets()</code > For the widget layout, see . # - - - S w a t c h . _ _ c r e a t e W i d g e t s def __createWidgets ( self ): """Create and grid all internal widgets. """ First comes the Text widget. The wrap=NONE operation causes the text to be cropped if it won't fit in the window. #-- 1 -- # [ self := self with a new Text widget added # self.__text := that widget ] self.__text = Text ( self, bg=self.__bgColor, fg=self.__textColor, width=self.SWATCH_WIDE, height=self.SWATCH_HIGH ) rowx = 0 self.__text.grid ( row=rowx, column=0, sticky=W ) Next is the FontSelect widget. For the documentation on this widget, see . Its callback, , is called whenever the user changes the font in any way. #-- 2 -- # [ self := self with a new FontSelect widget added that # calls self.__fontHandler when the font is changed # self.__fontSelect := that widget ] self.__fontSelect = FontSelect ( self, font=BUTTON_FONT, listCount=self.FONT_FAMILIES, observer=self.__fontHandler ) rowx += 1 self.__fontSelect.grid ( row=rowx, column=0, sticky=W )
<code >Swatch.__fontHandler()</code >: Handle a font change This method is called when the user changes the font displayed in the FontSelect widget. It changes the Text widget to use that font. # - - - S w a t c h . _ _ f o n t H a n d l e r def __fontHandler ( self, font ): """Handler for font changes. """ self.__text["font"] = font
Code epilogue The last lines of the script will actually run the application—provided it has been run as a script, in which case Python will set the built-in __name__ variable to "__main__". If another script wishes to import this script in order to reuse some of its pieces, name will not be set to "__main__" while the script is being read, and in that case main() will not be called. #================================================================ # Epilogue #---------------------------------------------------------------- # [ if this file is being run as a script -> # run an instance of the Application class # else -> I ] if __name__ == '__main__': main()