|
|
"""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
|
