"""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:   [email protected]''' % __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

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.