| """Main Pynche (Pythonically Natural Color and Hue Editor) widget. |
| |
| This window provides the basic decorations, primarily including the menubar. |
| It is used to bring up other windows. |
| """ |
| |
| import sys |
| import os |
| from Tkinter import * |
| import tkMessageBox |
| import tkFileDialog |
| import ColorDB |
| |
| # Milliseconds between interrupt checks |
| KEEPALIVE_TIMER = 500 |
| |
| |
| |
| class PyncheWidget: |
| def __init__(self, version, switchboard, master=None, extrapath=[]): |
| self.__sb = switchboard |
| self.__version = version |
| self.__textwin = None |
| self.__listwin = None |
| self.__detailswin = None |
| self.__helpwin = None |
| self.__dialogstate = {} |
| modal = self.__modal = not not master |
| # If a master was given, we are running as a modal dialog servant to |
| # some other application. We rearrange our UI in this case (there's |
| # no File menu and we get `Okay' and `Cancel' buttons), and we do a |
| # grab_set() to make ourselves modal |
| if modal: |
| self.__tkroot = tkroot = Toplevel(master, class_='Pynche') |
| tkroot.grab_set() |
| tkroot.withdraw() |
| else: |
| # Is there already a default root for Tk, say because we're |
| # running under Guido's IDE? :-) Two conditions say no, either the |
| # import fails or _default_root is None. |
| tkroot = None |
| try: |
| from Tkinter import _default_root |
| tkroot = self.__tkroot = _default_root |
| except ImportError: |
| pass |
| if not tkroot: |
| tkroot = self.__tkroot = Tk(className='Pynche') |
| # but this isn't our top level widget, so make it invisible |
| tkroot.withdraw() |
| # create the menubar |
| menubar = self.__menubar = Menu(tkroot) |
| # |
| # File menu |
| # |
| filemenu = self.__filemenu = Menu(menubar, tearoff=0) |
| filemenu.add_command(label='Load palette...', |
| command=self.__load, |
| underline=0) |
| if not modal: |
| filemenu.add_command(label='Quit', |
| command=self.__quit, |
| accelerator='Alt-Q', |
| underline=0) |
| # |
| # View menu |
| # |
| views = make_view_popups(self.__sb, self.__tkroot, extrapath) |
| viewmenu = Menu(menubar, tearoff=0) |
| for v in views: |
| viewmenu.add_command(label=v.menutext(), |
| command=v.popup, |
| underline=v.underline()) |
| # |
| # Help menu |
| # |
| helpmenu = Menu(menubar, name='help', tearoff=0) |
| helpmenu.add_command(label='About Pynche...', |
| command=self.__popup_about, |
| underline=0) |
| helpmenu.add_command(label='Help...', |
| command=self.__popup_usage, |
| underline=0) |
| # |
| # Tie them all together |
| # |
| menubar.add_cascade(label='File', |
| menu=filemenu, |
| underline=0) |
| menubar.add_cascade(label='View', |
| menu=viewmenu, |
| underline=0) |
| menubar.add_cascade(label='Help', |
| menu=helpmenu, |
| underline=0) |
| |
| # now create the top level window |
| root = self.__root = Toplevel(tkroot, class_='Pynche', menu=menubar) |
| root.protocol('WM_DELETE_WINDOW', |
| modal and self.__bell or self.__quit) |
| root.title('Pynche %s' % version) |
| root.iconname('Pynche') |
| # Only bind accelerators for the File->Quit menu item if running as a |
| # standalone app |
| if not modal: |
| root.bind('<Alt-q>', self.__quit) |
| root.bind('<Alt-Q>', self.__quit) |
| else: |
| # We're a modal dialog so we have a new row of buttons |
| bframe = Frame(root, borderwidth=1, relief=RAISED) |
| bframe.grid(row=4, column=0, columnspan=2, |
| sticky='EW', |
| ipady=5) |
| okay = Button(bframe, |
| text='Okay', |
| command=self.__okay) |
| okay.pack(side=LEFT, expand=1) |
| cancel = Button(bframe, |
| text='Cancel', |
| command=self.__cancel) |
| cancel.pack(side=LEFT, expand=1) |
| |
| def __quit(self, event=None): |
| self.__tkroot.quit() |
| |
| def __bell(self, event=None): |
| self.__tkroot.bell() |
| |
| def __okay(self, event=None): |
| self.__sb.withdraw_views() |
| self.__tkroot.grab_release() |
| self.__quit() |
| |
| def __cancel(self, event=None): |
| self.__sb.canceled() |
| self.__okay() |
| |
| def __keepalive(self): |
| # Exercise the Python interpreter regularly so keyboard interrupts get |
| # through. |
| self.__tkroot.tk.createtimerhandler(KEEPALIVE_TIMER, self.__keepalive) |
| |
| def start(self): |
| if not self.__modal: |
| self.__keepalive() |
| self.__tkroot.mainloop() |
| |
| def window(self): |
| return self.__root |
| |
| def __popup_about(self, event=None): |
| from Main import __version__ |
| tkMessageBox.showinfo('About Pynche ' + __version__, |
| '''\ |
| Pynche %s |
| The PYthonically Natural |
| Color and Hue Editor |
| |
| For information |
| contact: Barry A. Warsaw |
| email: bwarsaw@python.org''' % __version__) |
| |
| def __popup_usage(self, event=None): |
| if not self.__helpwin: |
| self.__helpwin = Helpwin(self.__root, self.__quit) |
| self.__helpwin.deiconify() |
| |
| def __load(self, event=None): |
| while 1: |
| idir, ifile = os.path.split(self.__sb.colordb().filename()) |
| file = tkFileDialog.askopenfilename( |
| filetypes=[('Text files', '*.txt'), |
| ('All files', '*'), |
| ], |
| initialdir=idir, |
| initialfile=ifile) |
| if not file: |
| # cancel button |
| return |
| try: |
| colordb = ColorDB.get_colordb(file) |
| except IOError: |
| tkMessageBox.showerror('Read error', '''\ |
| Could not open file for reading: |
| %s''' % file) |
| continue |
| if colordb is None: |
| tkMessageBox.showerror('Unrecognized color file type', '''\ |
| Unrecognized color file type in file: |
| %s''' % file) |
| continue |
| break |
| self.__sb.set_colordb(colordb) |
| |
| def withdraw(self): |
| self.__root.withdraw() |
| |
| def deiconify(self): |
| self.__root.deiconify() |
| |
| |
| |
| class Helpwin: |
| def __init__(self, master, quitfunc): |
| from Main import docstring |
| self.__root = root = Toplevel(master, class_='Pynche') |
| root.protocol('WM_DELETE_WINDOW', self.__withdraw) |
| root.title('Pynche Help Window') |
| root.iconname('Pynche Help Window') |
| root.bind('<Alt-q>', quitfunc) |
| root.bind('<Alt-Q>', quitfunc) |
| root.bind('<Alt-w>', self.__withdraw) |
| root.bind('<Alt-W>', self.__withdraw) |
| |
| # more elaborate help is available in the README file |
| readmefile = os.path.join(sys.path[0], 'README') |
| try: |
| fp = None |
| try: |
| fp = open(readmefile) |
| contents = fp.read() |
| # wax the last page, it contains Emacs cruft |
| i = contents.rfind('\f') |
| if i > 0: |
| contents = contents[:i].rstrip() |
| finally: |
| if fp: |
| fp.close() |
| except IOError: |
| sys.stderr.write("Couldn't open Pynche's README, " |
| 'using docstring instead.\n') |
| contents = docstring() |
| |
| self.__text = text = Text(root, relief=SUNKEN, |
| width=80, height=24) |
| self.__text.focus_set() |
| text.insert(0.0, contents) |
| scrollbar = Scrollbar(root) |
| scrollbar.pack(fill=Y, side=RIGHT) |
| text.pack(fill=BOTH, expand=YES) |
| text.configure(yscrollcommand=(scrollbar, 'set')) |
| scrollbar.configure(command=(text, 'yview')) |
| |
| def __withdraw(self, event=None): |
| self.__root.withdraw() |
| |
| def deiconify(self): |
| self.__root.deiconify() |
| |
| |
| |
| class PopupViewer: |
| def __init__(self, module, name, switchboard, root): |
| self.__m = module |
| self.__name = name |
| self.__sb = switchboard |
| self.__root = root |
| self.__menutext = module.ADDTOVIEW |
| # find the underline character |
| underline = module.ADDTOVIEW.find('%') |
| if underline == -1: |
| underline = 0 |
| else: |
| self.__menutext = module.ADDTOVIEW.replace('%', '', 1) |
| self.__underline = underline |
| self.__window = None |
| |
| def menutext(self): |
| return self.__menutext |
| |
| def underline(self): |
| return self.__underline |
| |
| def popup(self, event=None): |
| if not self.__window: |
| # class and module must have the same name |
| class_ = getattr(self.__m, self.__name) |
| self.__window = class_(self.__sb, self.__root) |
| self.__sb.add_view(self.__window) |
| self.__window.deiconify() |
| |
| def __cmp__(self, other): |
| return cmp(self.__menutext, other.__menutext) |
| |
| |
| def make_view_popups(switchboard, root, extrapath): |
| viewers = [] |
| # where we are in the file system |
| dirs = [os.path.dirname(__file__)] + extrapath |
| for dir in dirs: |
| if dir == '': |
| dir = '.' |
| for file in os.listdir(dir): |
| if file[-9:] == 'Viewer.py': |
| name = file[:-3] |
| try: |
| module = __import__(name) |
| except ImportError: |
| # Pynche is running from inside a package, so get the |
| # module using the explicit path. |
| pkg = __import__('pynche.'+name) |
| module = getattr(pkg, name) |
| if hasattr(module, 'ADDTOVIEW') and module.ADDTOVIEW: |
| # this is an external viewer |
| v = PopupViewer(module, name, switchboard, root) |
| viewers.append(v) |
| # sort alphabetically |
| viewers.sort() |
| return viewers |
