"""Switchboard class. This class is used to coordinate updates among all Viewers.  Every Viewer mustconform to the following interface:     - it must include a method called update_yourself() which takes three      arguments; the red, green, and blue values of the selected color.     - When a Viewer selects a color and wishes to update all other Views, it      should call update_views() on the Switchboard object.  Note that the      Viewer typically does *not* update itself before calling update_views(),      since this would cause it to get updated twice. Optionally, Viewers can also implement:     - save_options() which takes an optiondb (a dictionary).  Store into this      dictionary any values the Viewer wants to save in the persistent      ~/.pynche file.  This dictionary is saved using marshal.  The namespace      for the keys is ad-hoc; make sure you don't clobber some other Viewer's      keys!     - withdraw() which takes no arguments.  This is called when Pynche is      unmapped.  All Viewers should implement this.     - colordb_changed() which takes a single argument, an instance of      ColorDB.  This is called whenever the color name database is changed and      gives a chance for the Viewers to do something on those events.  See      ListViewer for details. External Viewers are found dynamically.  Viewer modules should have names suchas FooViewer.py.  If such a named module has a module global variable calledADDTOVIEW and this variable is true, the Viewer will be added dynamically tothe `View' menu.  ADDTOVIEW contains a string which is used as the menu itemto display the Viewer (one kludge: if the string contains a `%', this is usedto indicate that the next character will get an underline in the menu,otherwise the first character is underlined). FooViewer.py should contain a class called FooViewer, and its constructorshould take two arguments, an instance of Switchboard, and optionally a Tkmaster window. """ import sysfrom types import DictTypeimport marshal  class Switchboard:    def __init__(self, initfile):        self.__initfile = initfile        self.__colordb = None        self.__optiondb = {}        self.__views = []        self.__red = 0        self.__green = 0        self.__blue = 0        self.__canceled = 0        # read the initialization file        fp = None        if initfile:            try:                try:                    fp = open(initfile)                    self.__optiondb = marshal.load(fp)                    if not isinstance(self.__optiondb, DictType):                        print >> sys.stderr, \                              'Problem reading options from file:', initfile                        self.__optiondb = {}                except (IOError, EOFError, ValueError):                    pass            finally:                if fp:                    fp.close()     def add_view(self, view):        self.__views.append(view)     def update_views(self, red, green, blue):        self.__red = red        self.__green = green        self.__blue = blue        for v in self.__views:            v.update_yourself(red, green, blue)     def update_views_current(self):        self.update_views(self.__red, self.__green, self.__blue)     def current_rgb(self):        return self.__red, self.__green, self.__blue     def colordb(self):        return self.__colordb     def set_colordb(self, colordb):        self.__colordb = colordb        for v in self.__views:            if hasattr(v, 'colordb_changed'):                v.colordb_changed(colordb)        self.update_views_current()     def optiondb(self):        return self.__optiondb     def save_views(self):        # save the current color        self.__optiondb['RED'] = self.__red        self.__optiondb['GREEN'] = self.__green        self.__optiondb['BLUE'] = self.__blue        for v in self.__views:            if hasattr(v, 'save_options'):                v.save_options(self.__optiondb)        # save the name of the file used for the color database.  we'll try to        # load this first.        self.__optiondb['DBFILE'] = self.__colordb.filename()        fp = None        try:            try:                fp = open(self.__initfile, 'w')            except IOError:                print >> sys.stderr, 'Cannot write options to file:', \                      self.__initfile            else:                marshal.dump(self.__optiondb, fp)        finally:            if fp:                fp.close()     def withdraw_views(self):        for v in self.__views:            if hasattr(v, 'withdraw'):                v.withdraw()     def canceled(self, flag=1):        self.__canceled = flag     def canceled_p(self):        return self.__canceled