From 7e6b33f00a73dad5ffe59aaf1d6ccef6ba0a47ac Mon Sep 17 00:00:00 2001
From: Georg Brandl <georg@python.org>
Date: Sat, 17 May 2008 15:07:03 +0000
Subject: [PATCH] Tkinter rename: merge tkSimpleDialog and tkFileDialog into
 simpledialog and filedialog.

---
 Lib/tkinter/filedialog.py   | 207 ++++++++++++++++++++++++
 Lib/tkinter/simpledialog.py | 314 +++++++++++++++++++++++++++++++++++-
 2 files changed, 519 insertions(+), 2 deletions(-)

diff --git a/Lib/tkinter/filedialog.py b/Lib/tkinter/filedialog.py
index 727b3d74e45..8583cb03af3 100644
--- a/Lib/tkinter/filedialog.py
+++ b/Lib/tkinter/filedialog.py
@@ -6,10 +6,15 @@ Classes:
 - LoadFileDialog
 - SaveFileDialog
 
+This module also presents tk common file dialogues, it provides interfaces
+to the native file dialogues available in Tk 4.2 and newer, and the
+directory dialogue available in Tk 8.3 and newer.
+These interfaces were written by Fredrik Lundh, May 1997.
 """
 
 from tkinter import *
 from tkinter.dialog import Dialog
+from tkinter import commondialog
 
 import os
 import fnmatch
@@ -259,6 +264,176 @@ class SaveFileDialog(FileDialog):
         self.quit(file)
 
 
+
+# For the following classes and modules:
+#
+# options (all have default values):
+#
+# - defaultextension: added to filename if not explicitly given
+#
+# - filetypes: sequence of (label, pattern) tuples.  the same pattern
+#   may occur with several patterns.  use "*" as pattern to indicate
+#   all files.
+#
+# - initialdir: initial directory.  preserved by dialog instance.
+#
+# - initialfile: initial file (ignored by the open dialog).  preserved
+#   by dialog instance.
+#
+# - parent: which window to place the dialog on top of
+#
+# - title: dialog title
+#
+# - multiple: if true user may select more than one file
+#
+# options for the directory chooser:
+#
+# - initialdir, parent, title: see above
+#
+# - mustexist: if true, user must pick an existing directory
+#
+
+
+class _Dialog(commondialog.Dialog):
+
+    def _fixoptions(self):
+        try:
+            # make sure "filetypes" is a tuple
+            self.options["filetypes"] = tuple(self.options["filetypes"])
+        except KeyError:
+            pass
+
+    def _fixresult(self, widget, result):
+        if result:
+            # keep directory and filename until next time
+            import os
+            # convert Tcl path objects to strings
+            try:
+                result = result.string
+            except AttributeError:
+                # it already is a string
+                pass
+            path, file = os.path.split(result)
+            self.options["initialdir"] = path
+            self.options["initialfile"] = file
+        self.filename = result # compatibility
+        return result
+
+
+#
+# file dialogs
+
+class Open(_Dialog):
+    "Ask for a filename to open"
+
+    command = "tk_getOpenFile"
+
+    def _fixresult(self, widget, result):
+        if isinstance(result, tuple):
+            # multiple results:
+            result = tuple([getattr(r, "string", r) for r in result])
+            if result:
+                import os
+                path, file = os.path.split(result[0])
+                self.options["initialdir"] = path
+                # don't set initialfile or filename, as we have multiple of these
+            return result
+        if not widget.tk.wantobjects() and "multiple" in self.options:
+            # Need to split result explicitly
+            return self._fixresult(widget, widget.tk.splitlist(result))
+        return _Dialog._fixresult(self, widget, result)
+
+class SaveAs(_Dialog):
+    "Ask for a filename to save as"
+
+    command = "tk_getSaveFile"
+
+
+# the directory dialog has its own _fix routines.
+class Directory(Dialog):
+    "Ask for a directory"
+
+    command = "tk_chooseDirectory"
+
+    def _fixresult(self, widget, result):
+        if result:
+            # convert Tcl path objects to strings
+            try:
+                result = result.string
+            except AttributeError:
+                # it already is a string
+                pass
+            # keep directory until next time
+            self.options["initialdir"] = result
+        self.directory = result # compatibility
+        return result
+
+#
+# convenience stuff
+
+def askopenfilename(**options):
+    "Ask for a filename to open"
+
+    return Open(**options).show()
+
+def asksaveasfilename(**options):
+    "Ask for a filename to save as"
+
+    return SaveAs(**options).show()
+
+def askopenfilenames(**options):
+    """Ask for multiple filenames to open
+
+    Returns a list of filenames or empty list if
+    cancel button selected
+    """
+    options["multiple"]=1
+    return Open(**options).show()
+
+# FIXME: are the following  perhaps a bit too convenient?
+
+def askopenfile(mode = "r", **options):
+    "Ask for a filename to open, and returned the opened file"
+
+    filename = Open(**options).show()
+    if filename:
+        return open(filename, mode)
+    return None
+
+def askopenfiles(mode = "r", **options):
+    """Ask for multiple filenames and return the open file
+    objects
+
+    returns a list of open file objects or an empty list if
+    cancel selected
+    """
+
+    files = askopenfilenames(**options)
+    if files:
+        ofiles=[]
+        for filename in files:
+            ofiles.append(open(filename, mode))
+        files=ofiles
+    return files
+
+
+def asksaveasfile(mode = "w", **options):
+    "Ask for a filename to save as, and returned the opened file"
+
+    filename = SaveAs(**options).show()
+    if filename:
+        return open(filename, mode)
+    return None
+
+def askdirectory (**options):
+    "Ask for a directory, and return the file name"
+    return Directory(**options).show()
+
+
+
+# --------------------------------------------------------------------
+# test stuff
+
 def test():
     """Simple test program."""
     root = Tk()
@@ -269,6 +444,38 @@ def test():
     savefile = fd.go(key="test")
     print loadfile, savefile
 
+    # Since the file name may contain non-ASCII characters, we need
+    # to find an encoding that likely supports the file name, and
+    # displays correctly on the terminal.
+
+    # Start off with UTF-8
+    enc = "utf-8"
+    import sys
+
+    # See whether CODESET is defined
+    try:
+        import locale
+        locale.setlocale(locale.LC_ALL,'')
+        enc = locale.nl_langinfo(locale.CODESET)
+    except (ImportError, AttributeError):
+        pass
+
+    # dialog for openening files
+
+    openfilename=askopenfilename(filetypes=[("all files", "*")])
+    try:
+        fp=open(openfilename,"r")
+        fp.close()
+    except:
+        print "Could not open File: "
+        print sys.exc_info()[1]
+
+    print "open", openfilename.encode(enc)
+
+    # dialog for saving files
+
+    saveasfilename=asksaveasfilename()
+    print "saveas", saveasfilename.encode(enc)
 
 if __name__ == '__main__':
     test()
diff --git a/Lib/tkinter/simpledialog.py b/Lib/tkinter/simpledialog.py
index c89160de5be..f6fce097156 100644
--- a/Lib/tkinter/simpledialog.py
+++ b/Lib/tkinter/simpledialog.py
@@ -1,9 +1,30 @@
-"""A simple but flexible modal dialog box."""
+#
+# An Introduction to Tkinter
+#
+# Copyright (c) 1997 by Fredrik Lundh
+#
+# This copyright applies to Dialog, askinteger, askfloat and asktring
+#
+# fredrik@pythonware.com
+# http://www.pythonware.com
+#
+"""This modules handles dialog boxes.
 
+It contains the following public symbols:
+
+SimpleDialog -- A simple but flexible modal dialog box
+
+Dialog -- a base class for dialogs
+
+askinteger -- get an integer from the user
+
+askfloat -- get a float from the user
+
+askstring -- get a string from the user
+"""
 
 from tkinter import *
 
-
 class SimpleDialog:
 
     def __init__(self, master,
@@ -87,6 +108,290 @@ class SimpleDialog:
         self.root.quit()
 
 
+class Dialog(Toplevel):
+
+    '''Class to open dialogs.
+
+    This class is intended as a base class for custom dialogs
+    '''
+
+    def __init__(self, parent, title = None):
+
+        '''Initialize a dialog.
+
+        Arguments:
+
+            parent -- a parent window (the application window)
+
+            title -- the dialog title
+        '''
+        Toplevel.__init__(self, parent)
+
+        # If the master is not viewable, don't
+        # make the child transient, or else it
+        # would be opened withdrawn
+        if parent.winfo_viewable():
+            self.transient(parent)
+
+        if title:
+            self.title(title)
+
+        self.parent = parent
+
+        self.result = None
+
+        body = Frame(self)
+        self.initial_focus = self.body(body)
+        body.pack(padx=5, pady=5)
+
+        self.buttonbox()
+
+        self.wait_visibility() # window needs to be visible for the grab
+        self.grab_set()
+
+        if not self.initial_focus:
+            self.initial_focus = self
+
+        self.protocol("WM_DELETE_WINDOW", self.cancel)
+
+        if self.parent is not None:
+            self.geometry("+%d+%d" % (parent.winfo_rootx()+50,
+                                      parent.winfo_rooty()+50))
+
+        self.initial_focus.focus_set()
+
+        self.wait_window(self)
+
+    def destroy(self):
+        '''Destroy the window'''
+        self.initial_focus = None
+        Toplevel.destroy(self)
+
+    #
+    # construction hooks
+
+    def body(self, master):
+        '''create dialog body.
+
+        return widget that should have initial focus.
+        This method should be overridden, and is called
+        by the __init__ method.
+        '''
+        pass
+
+    def buttonbox(self):
+        '''add standard button box.
+
+        override if you do not want the standard buttons
+        '''
+
+        box = Frame(self)
+
+        w = Button(box, text="OK", width=10, command=self.ok, default=ACTIVE)
+        w.pack(side=LEFT, padx=5, pady=5)
+        w = Button(box, text="Cancel", width=10, command=self.cancel)
+        w.pack(side=LEFT, padx=5, pady=5)
+
+        self.bind("<Return>", self.ok)
+        self.bind("<Escape>", self.cancel)
+
+        box.pack()
+
+    #
+    # standard button semantics
+
+    def ok(self, event=None):
+
+        if not self.validate():
+            self.initial_focus.focus_set() # put focus back
+            return
+
+        self.withdraw()
+        self.update_idletasks()
+
+        try:
+            self.apply()
+        finally:
+            self.cancel()
+
+    def cancel(self, event=None):
+
+        # put focus back to the parent window
+        if self.parent is not None:
+            self.parent.focus_set()
+        self.destroy()
+
+    #
+    # command hooks
+
+    def validate(self):
+        '''validate the data
+
+        This method is called automatically to validate the data before the
+        dialog is destroyed. By default, it always validates OK.
+        '''
+
+        return 1 # override
+
+    def apply(self):
+        '''process the data
+
+        This method is called automatically to process the data, *after*
+        the dialog is destroyed. By default, it does nothing.
+        '''
+
+        pass # override
+
+
+# --------------------------------------------------------------------
+# convenience dialogues
+
+class _QueryDialog(Dialog):
+
+    def __init__(self, title, prompt,
+                 initialvalue=None,
+                 minvalue = None, maxvalue = None,
+                 parent = None):
+
+        if not parent:
+            import Tkinter
+            parent = Tkinter._default_root
+
+        self.prompt   = prompt
+        self.minvalue = minvalue
+        self.maxvalue = maxvalue
+
+        self.initialvalue = initialvalue
+
+        Dialog.__init__(self, parent, title)
+
+    def destroy(self):
+        self.entry = None
+        Dialog.destroy(self)
+
+    def body(self, master):
+
+        w = Label(master, text=self.prompt, justify=LEFT)
+        w.grid(row=0, padx=5, sticky=W)
+
+        self.entry = Entry(master, name="entry")
+        self.entry.grid(row=1, padx=5, sticky=W+E)
+
+        if self.initialvalue:
+            self.entry.insert(0, self.initialvalue)
+            self.entry.select_range(0, END)
+
+        return self.entry
+
+    def validate(self):
+
+        import tkMessageBox
+
+        try:
+            result = self.getresult()
+        except ValueError:
+            tkMessageBox.showwarning(
+                "Illegal value",
+                self.errormessage + "\nPlease try again",
+                parent = self
+            )
+            return 0
+
+        if self.minvalue is not None and result < self.minvalue:
+            tkMessageBox.showwarning(
+                "Too small",
+                "The allowed minimum value is %s. "
+                "Please try again." % self.minvalue,
+                parent = self
+            )
+            return 0
+
+        if self.maxvalue is not None and result > self.maxvalue:
+            tkMessageBox.showwarning(
+                "Too large",
+                "The allowed maximum value is %s. "
+                "Please try again." % self.maxvalue,
+                parent = self
+            )
+            return 0
+
+        self.result = result
+
+        return 1
+
+
+class _QueryInteger(_QueryDialog):
+    errormessage = "Not an integer."
+    def getresult(self):
+        return int(self.entry.get())
+
+def askinteger(title, prompt, **kw):
+    '''get an integer from the user
+
+    Arguments:
+
+        title -- the dialog title
+        prompt -- the label text
+        **kw -- see SimpleDialog class
+
+    Return value is an integer
+    '''
+    d = _QueryInteger(title, prompt, **kw)
+    return d.result
+
+class _QueryFloat(_QueryDialog):
+    errormessage = "Not a floating point value."
+    def getresult(self):
+        return float(self.entry.get())
+
+def askfloat(title, prompt, **kw):
+    '''get a float from the user
+
+    Arguments:
+
+        title -- the dialog title
+        prompt -- the label text
+        **kw -- see SimpleDialog class
+
+    Return value is a float
+    '''
+    d = _QueryFloat(title, prompt, **kw)
+    return d.result
+
+class _QueryString(_QueryDialog):
+    def __init__(self, *args, **kw):
+        if kw.has_key("show"):
+            self.__show = kw["show"]
+            del kw["show"]
+        else:
+            self.__show = None
+        _QueryDialog.__init__(self, *args, **kw)
+
+    def body(self, master):
+        entry = _QueryDialog.body(self, master)
+        if self.__show is not None:
+            entry.configure(show=self.__show)
+        return entry
+
+    def getresult(self):
+        return self.entry.get()
+
+def askstring(title, prompt, **kw):
+    '''get a string from the user
+
+    Arguments:
+
+        title -- the dialog title
+        prompt -- the label text
+        **kw -- see SimpleDialog class
+
+    Return value is a string
+    '''
+    d = _QueryString(title, prompt, **kw)
+    return d.result
+
+
+
 if __name__ == '__main__':
 
     def test():
@@ -103,6 +408,11 @@ if __name__ == '__main__':
                          cancel=2,
                          title="Test Dialog")
             print d.go()
+            print askinteger("Spam", "Egg count", initialvalue=12*12)
+            print askfloat("Spam", "Egg weight\n(in tons)", minvalue=1,
+                           maxvalue=100)
+            print askstring("Spam", "Egg label")
+
         t = Button(root, text='Test', command=doit)
         t.pack()
         q = Button(root, text='Quit', command=t.quit)