* Merged 8.1 branch into the main trunk

1 files changed, 986 insertions, 605 deletions

diff --git a/win/tkWinDialog.c b/win/tkWinDialog.c
index aa79171..bb3eb19 100644
--- a/win/tkWinDialog.c
+++ b/win/tkWinDialog.c
@@ -1,3 +1,4 @@
+
 /*
  * tkWinDialog.c --
  *
@@ -8,10 +9,10 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkWinDialog.c,v 1.2 1998/09/14 18:23:59 stanton Exp $
+ * RCS: @(#) $Id: tkWinDialog.c,v 1.3 1999/04/16 01:51:50 stanton Exp $
  *
  */
- 
+
 #include "tkWinInt.h"
 #include "tkFileFilter.h"
 
@@ -19,138 +20,139 @@
 #include <dlgs.h>       /* includes common dialog template defines */
 #include <cderr.h>      /* includes the common dialog error codes */
 
-#if ((TK_MAJOR_VERSION == 4) && (TK_MINOR_VERSION <= 2))
+typedef struct ThreadSpecificData { 
+    int debugFlag;            /* Flags whether we should output debugging 
+			       * information while displaying a builtin 
+			       * dialog. */
+    Tcl_Interp *debugInterp;  /* Interpreter to used for debugging. */
+    UINT WM_LBSELCHANGED;     /* Holds a registered windows event used for
+			       * communicating between the Directory
+			       * Chooser dialog and its hook proc. */
+} ThreadSpecificData;
+static Tcl_ThreadDataKey dataKey;
+
 /*
- * The following function is implemented on tk4.3 and after only 
+ * The following structures are used by Tk_MessageBox() to parse 
+ * arguments and return results.
  */
-#define Tk_GetHWND TkWinGetHWND
-#endif
 
-#define SAVE_FILE 0
-#define OPEN_FILE 1
+static const TkStateMap iconMap[] = {
+    {MB_ICONERROR,		"error"},
+    {MB_ICONINFORMATION,	"info"},
+    {MB_ICONQUESTION,		"question"},
+    {MB_ICONWARNING,		"warning"},
+    {-1,			NULL}
+};
+	  
+static const TkStateMap typeMap[] = {
+    {MB_ABORTRETRYIGNORE,	"abortretryignore"},
+    {MB_OK, 			"ok"},
+    {MB_OKCANCEL,		"okcancel"},
+    {MB_RETRYCANCEL,		"retrycancel"},
+    {MB_YESNO,			"yesno"},
+    {MB_YESNOCANCEL,		"yesnocancel"},
+    {-1,			NULL}
+};
 
-/*----------------------------------------------------------------------
- * MsgTypeInfo --
- *
- *	This structure stores the type of available message box in an
- *	easy-to-process format. Used by th Tk_MessageBox() function
- *----------------------------------------------------------------------
- */
-typedef struct MsgTypeInfo {
-    char * name;
-    int type;
-    int numButtons;
-    char * btnNames[3];
-} MsgTypeInfo;
-
-#define NUM_TYPES 6
-
-static MsgTypeInfo 
-msgTypeInfo[NUM_TYPES] = {
-    {"abortretryignore", MB_ABORTRETRYIGNORE, 3, {"abort", "retry", "ignore"}},
-    {"ok", 		 MB_OK, 	      1, {"ok"                      }},
-    {"okcancel",	 MB_OKCANCEL,	      2, {"ok",    "cancel"         }},
-    {"retrycancel",	 MB_RETRYCANCEL,      2, {"retry", "cancel"         }},
-    {"yesno",		 MB_YESNO,	      2, {"yes",   "no"             }},
-    {"yesnocancel",	 MB_YESNOCANCEL,      3, {"yes",   "no",    "cancel"}}
+static const TkStateMap buttonMap[] = {
+    {IDABORT,			"abort"},
+    {IDRETRY,			"retry"},
+    {IDIGNORE,			"ignore"},
+    {IDOK,			"ok"},
+    {IDCANCEL,			"cancel"},
+    {IDNO,			"no"},
+    {IDYES,			"yes"},
+    {-1,			NULL}
+};
+
+static const int buttonFlagMap[] = {
+    MB_DEFBUTTON1, MB_DEFBUTTON2, MB_DEFBUTTON3, MB_DEFBUTTON4
+};
+
+static const struct {int type; int btnIds[3];} allowedTypes[] = {
+    {MB_ABORTRETRYIGNORE,	{IDABORT, IDRETRY,  IDIGNORE}},
+    {MB_OK, 			{IDOK,    -1,       -1      }},
+    {MB_OKCANCEL,		{IDOK,    IDCANCEL, -1      }},
+    {MB_RETRYCANCEL,		{IDRETRY, IDCANCEL, -1      }},
+    {MB_YESNO,			{IDYES,   IDNO,     -1      }},
+    {MB_YESNOCANCEL,		{IDYES,   IDNO,     IDCANCEL}}
 };
 
+#define NUM_TYPES (sizeof(allowedTypes) / sizeof(allowedTypes[0]))
+
 /*
- * The following structure is used in the GetOpenFileName() and
- * GetSaveFileName() calls.
+ * The following structure is used to pass information between the directory
+ * chooser procedure, Tk_ChooseDirectoryObjCmd(), and its dialog hook proc.
  */
-typedef struct _OpenFileData {
-    Tcl_Interp * interp;
-    TCHAR szFile[MAX_PATH+1];
-} OpenFileData;
+
+typedef struct ChooseDir {
+    Tcl_Interp *interp;		/* Interp, used only if debug is turned on, 
+				 * for setting the "tk_dialog" variable. */
+    int lastCtrl;		/* Used by hook proc to keep track of last
+				 * control that had input focus, so when OK
+				 * is pressed we know whether to browse a
+				 * new directory or return. */
+    int lastIdx;		/* Last item that was selected in directory 
+				 * browser listbox. */
+    TCHAR path[MAX_PATH];	/* On return from choose directory dialog, 
+				 * holds the selected path.  Cannot return 
+				 * selected path in ofnPtr->lpstrFile because
+				 * the default dialog proc stores a '\0' in 
+				 * it, since, of course, no _file_ was 
+				 * selected. */
+} ChooseDir;
 
 /*
- * The following structure is used in the ChooseColor() call.
+ * Definitions of procedures used only in this file.
  */
-typedef struct _ChooseColorData {
-    Tcl_Interp * interp;
-    char * title;			/* Title of the color dialog */
-} ChooseColorData;
-
-
-static int 		GetFileName _ANSI_ARGS_((ClientData clientData,
-    			    Tcl_Interp *interp, int argc, char **argv,
-    			    int isOpen));
-static UINT CALLBACK	ColorDlgHookProc _ANSI_ARGS_((HWND hDlg, UINT uMsg,
-			    WPARAM wParam, LPARAM lParam));
-static int 		MakeFilter _ANSI_ARGS_((Tcl_Interp *interp,
-    			    OPENFILENAME *ofnPtr, char * string));
-static int		ParseFileDlgArgs _ANSI_ARGS_((Tcl_Interp * interp,
-    			    OPENFILENAME *ofnPtr, int argc, char ** argv,
-			    int isOpen));
-static int 		ProcessCDError _ANSI_ARGS_((Tcl_Interp * interp,
-			    DWORD dwErrorCode, HWND hWnd));
+
+static UINT APIENTRY	ChooseDirectoryHookProc(HWND hdlg, UINT uMsg, 
+			    WPARAM wParam, LPARAM lParam);
+static UINT CALLBACK	ColorDlgHookProc(HWND hDlg, UINT uMsg, WPARAM wParam,
+			    LPARAM lParam);
+static int 		GetFileName(ClientData clientData, 
+			    Tcl_Interp *interp, int objc, 
+			    Tcl_Obj *CONST objv[], int isOpen);
+static int 		MakeFilter(Tcl_Interp *interp, char *string, 
+			    Tcl_DString *dsPtr);
+static UINT APIENTRY	OFNHookProc(HWND hdlg, UINT uMsg, WPARAM wParam, 
+			    LPARAM lParam);
+static void		SetTkDialog(ClientData clientData);
+static int		TrySetDirectory(HWND hwnd, const TCHAR *dir);
 
 /*
- *----------------------------------------------------------------------
+ *-------------------------------------------------------------------------
  *
- * EvalArgv --
+ * TkWinDialogDebug --
  *
- *	Invokes the Tcl procedure with the arguments. argv[0] is set by
- *	the caller of this function. It may be different than cmdName.
- *	The TCL command will see argv[0], not cmdName, as its name if it
- *	invokes [lindex [info level 0] 0]
+ *	Function to turn on/off debugging support for common dialogs under
+ *	windows.  The variable "tk_debug" is set to the identifier of the
+ *	dialog window when the modal dialog window pops up and it is safe to 
+ *	send messages to the dialog.
  *
  * Results:
- *	TCL_ERROR if the command does not exist and cannot be autoloaded.
- *	Otherwise, return the result of the evaluation of the command.
+ *	None.
  *
  * Side effects:
- *	The command may be autoloaded.
+ *	This variable only makes sense if just one dialog is up at a time.
  *
- *----------------------------------------------------------------------
+ *-------------------------------------------------------------------------
  */
 
-static int 
-EvalArgv(interp, cmdName, argc, argv)
-    Tcl_Interp *interp;		/* Current interpreter. */
-    char * cmdName;		/* Name of the TCL command to call */
-    int argc;			/* Number of arguments. */
-    char **argv;		/* Argument strings. */
+void	    	
+TkWinDialogDebug(
+    int debug)
 {
-    Tcl_CmdInfo cmdInfo;
-
-    if (!Tcl_GetCommandInfo(interp, cmdName, &cmdInfo)) {
-	char * cmdArgv[2];
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
-	/*
-	 * This comand is not in the interpreter yet -- looks like we
-	 * have to auto-load it
-	 */
-	if (!Tcl_GetCommandInfo(interp, "auto_load", &cmdInfo)) {
-	    Tcl_ResetResult(interp);
-	    Tcl_AppendResult(interp, "cannot execute command \"auto_load\"",
-		NULL);
-	    return TCL_ERROR;
-	}
-
-	cmdArgv[0] = "auto_load";
-	cmdArgv[1] = cmdName;
-
-	if ((*cmdInfo.proc)(cmdInfo.clientData, interp, 2, cmdArgv)!= TCL_OK){ 
-	    return TCL_ERROR;
-	}
-
-	if (!Tcl_GetCommandInfo(interp, cmdName, &cmdInfo)) {
-	    Tcl_ResetResult(interp);
-	    Tcl_AppendResult(interp, "cannot auto-load command \"",
-		cmdName, "\"",NULL);
-	    return TCL_ERROR;
-	}
-    }
-
-    return (*cmdInfo.proc)(cmdInfo.clientData, interp, argc, argv);
+    tsdPtr->debugFlag = debug;
 }
 
 /*
- *----------------------------------------------------------------------
+ *-------------------------------------------------------------------------
  *
- * Tk_ChooseColorCmd --
+ * Tk_ChooseColorObjCmd --
  *
  *	This procedure implements the color dialog box for the Windows
  *	platform. See the user documentation for details on what it
@@ -164,106 +166,105 @@ EvalArgv(interp, cmdName, argc, argv)
  *	This window is not destroyed and will be reused the next time the
  *	application invokes the "tk_chooseColor" command.
  *
- *----------------------------------------------------------------------
+ *-------------------------------------------------------------------------
  */
 
 int
-Tk_ChooseColorCmd(clientData, interp, argc, argv)
+Tk_ChooseColorObjCmd(clientData, interp, objc, objv)
     ClientData clientData;	/* Main window associated with interpreter. */
     Tcl_Interp *interp;		/* Current interpreter. */
-    int argc;			/* Number of arguments. */
-    char **argv;		/* Argument strings. */
+    int objc;			/* Number of arguments. */
+    Tcl_Obj *CONST objv[];	/* Argument objects. */
 {
-    Tk_Window parent = Tk_MainWindow(interp);
-    ChooseColorData custData;
-    int oldMode;
+    Tk_Window tkwin, parent;
+    int i, oldMode, winCode;
     CHOOSECOLOR chooseColor;
-    char * colorStr = NULL;
-    int i;
-    int winCode, tclCode;
-    XColor * colorPtr = NULL;
     static inited = 0;
-    static long dwCustColors[16];
+    static COLORREF dwCustColors[16];
     static long oldColor;		/* the color selected last time */
-
-    custData.title     = NULL;
-
-    if (!inited) {
+    static char *optionStrings[] = {
+	"-initialcolor",    "-parent",	    "-title",	    NULL
+    };
+    enum options {
+	COLOR_INITIAL,	    COLOR_PARENT,   COLOR_TITLE
+    };
+
+    if (inited == 0) {
 	/*
 	 * dwCustColors stores the custom color which the user can
-	 * modify. We store these colors in a fixed array so that the next
+	 * modify. We store these colors in a static array so that the next
 	 * time the color dialog pops up, the same set of custom colors
 	 * remain in the dialog.
 	 */
-	for (i=0; i<16; i++) {
-	    dwCustColors[i] = (RGB(255-i*10, i, i*10)) ;
+	for (i = 0; i < 16; i++) {
+	    dwCustColors[i] = RGB(255-i * 10, i, i * 10);
 	}
-	oldColor = RGB(0xa0,0xa0,0xa0);
+	oldColor = RGB(0xa0, 0xa0, 0xa0);
 	inited = 1;
     }
 
-    /*
-     * 1. Parse the arguments
-     */
-
-    chooseColor.lStructSize  = sizeof(CHOOSECOLOR) ;
-    chooseColor.hwndOwner    = 0;			/* filled in below */
-    chooseColor.hInstance    = 0;
-    chooseColor.rgbResult    = oldColor;
-    chooseColor.lpCustColors = (LPDWORD) dwCustColors ;
-    chooseColor.Flags        = CC_RGBINIT | CC_FULLOPEN | CC_ENABLEHOOK;
-    chooseColor.lCustData    = (LPARAM)&custData;
-    chooseColor.lpfnHook     = ColorDlgHookProc;
-    chooseColor.lpTemplateName = NULL;
-
-    for (i=1; i<argc; i+=2) {
-        int v = i+1;
-	int len = strlen(argv[i]);
-
-	if (strncmp(argv[i], "-initialcolor", len)==0) {
-	    if (v==argc) {goto arg_missing;}
-
-	    colorStr = argv[v];
+    tkwin = (Tk_Window) clientData;
+
+    parent			= tkwin;
+    chooseColor.lStructSize	= sizeof(CHOOSECOLOR) ;
+    chooseColor.hwndOwner	= 0;			
+    chooseColor.hInstance	= 0;
+    chooseColor.rgbResult	= oldColor;
+    chooseColor.lpCustColors	= dwCustColors ;
+    chooseColor.Flags		= CC_RGBINIT | CC_FULLOPEN | CC_ENABLEHOOK;
+    chooseColor.lCustData	= (LPARAM) NULL;
+    chooseColor.lpfnHook	= ColorDlgHookProc;
+    chooseColor.lpTemplateName	= (LPTSTR) interp;
+
+    for (i = 1; i < objc; i += 2) {
+	int index;
+	char *string;
+	Tcl_Obj *optionPtr, *valuePtr;
+
+	optionPtr = objv[i];
+	valuePtr = objv[i + 1];
+
+	if (Tcl_GetIndexFromObj(interp, optionPtr, optionStrings, "option",
+		TCL_EXACT, &index) != TCL_OK) {
+	    return TCL_ERROR;
 	}
-	else if (strncmp(argv[i], "-parent", len)==0) {
-	    if (v==argc) {goto arg_missing;}
-
-	    parent=Tk_NameToWindow(interp, argv[v], Tk_MainWindow(interp));
-	    if (parent == NULL) {
-		return TCL_ERROR;
-	    }
+	if (i + 1 == objc) {
+	    string = Tcl_GetStringFromObj(optionPtr, NULL);
+	    Tcl_AppendResult(interp, "value for \"", string, "\" missing", 
+		    (char *) NULL);
+	    return TCL_ERROR;
 	}
-	else if (strncmp(argv[i], "-title", len)==0) {
-	    if (v==argc) {goto arg_missing;}
 
-	    custData.title = argv[v];
-	}
-	else {
-    	    Tcl_AppendResult(interp, "unknown option \"", 
-		argv[i], "\", must be -initialcolor, -parent or -title",
-		NULL);
-		return TCL_ERROR;
+	string = Tcl_GetStringFromObj(valuePtr, NULL);
+	switch ((enum options) index) {
+	    case COLOR_INITIAL: {
+		XColor *colorPtr;
+
+		colorPtr = Tk_GetColor(interp, tkwin, string);
+		if (colorPtr == NULL) {
+		    return TCL_ERROR;
+		}
+		chooseColor.rgbResult = RGB(colorPtr->red / 0x100, 
+			colorPtr->green / 0x100, colorPtr->blue / 0x100);
+		break;
+	    }
+	    case COLOR_PARENT: {
+		parent = Tk_NameToWindow(interp, string, tkwin);
+		if (parent == NULL) {
+		    return TCL_ERROR;
+		}
+		break;
+	    }
+	    case COLOR_TITLE: {
+		chooseColor.lCustData = (LPARAM) string;
+		break;
+	    }
 	}
     }
 
-    if (Tk_WindowId(parent) == None) {
-	Tk_MakeWindowExist(parent);
-    }
+    Tk_MakeWindowExist(parent);
     chooseColor.hwndOwner = Tk_GetHWND(Tk_WindowId(parent));
 
-    if (colorStr != NULL) {
-	colorPtr = Tk_GetColor(interp, Tk_MainWindow(interp), colorStr);
-	if (!colorPtr) {
-	    return TCL_ERROR;
-	}
-	chooseColor.rgbResult = RGB((colorPtr->red/0x100), 
-	    (colorPtr->green/0x100), (colorPtr->blue/0x100));
-    }	
-
-    /*
-     * 2. Popup the dialog
-     */
-
     oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL);
     winCode = ChooseColor(&chooseColor);
     (void) Tcl_SetServiceMode(oldMode);
@@ -278,6 +279,7 @@ Tk_ChooseColorCmd(clientData, interp, argc, argv)
     /*
      * 3. Process the result of the dialog
      */
+
     if (winCode) {
 	/*
 	 * User has selected a color
@@ -285,75 +287,67 @@ Tk_ChooseColorCmd(clientData, interp, argc, argv)
 	char result[100];
 
 	sprintf(result, "#%02x%02x%02x",
-	    GetRValue(chooseColor.rgbResult), 
-	    GetGValue(chooseColor.rgbResult), 
-	    GetBValue(chooseColor.rgbResult));
+	GetRValue(chooseColor.rgbResult), 
+	        GetGValue(chooseColor.rgbResult), 
+		GetBValue(chooseColor.rgbResult));
         Tcl_AppendResult(interp, result, NULL);
-	tclCode = TCL_OK;
-
 	oldColor = chooseColor.rgbResult;
-    } else {
-	/*
-	 * User probably pressed Cancel, or an error occurred
-	 */
-	tclCode = ProcessCDError(interp, CommDlgExtendedError(), 
-	     chooseColor.hwndOwner);
-    }
-
-    if (colorPtr) {
-	Tk_FreeColor(colorPtr);
     }
-
-    return tclCode;
-
-  arg_missing:
-    Tcl_AppendResult(interp, "value for \"", argv[argc-1], "\" missing",
-	NULL);
-    return TCL_ERROR;
+    return TCL_OK;
 }
 
 /*
- *----------------------------------------------------------------------
+ *-------------------------------------------------------------------------
  *
  * ColorDlgHookProc --
  *
- *	Gets called during the execution of the color dialog. It processes
- *	the "interesting" messages that Windows send to the dialog.
+ *	Provides special handling of messages for the Color common dialog
+ *	box.  Used to set the title when the dialog first appears.
  *
  * Results:
- *	TRUE if the message has been processed, FALSE otherwise.
+ *	The return value is 0 if the default dialog box procedure should
+ *	handle the message, non-zero otherwise. 
  *
  * Side effects:
- *	Changes the title of the dialog window when it is popped up.
+ *	Changes the title of the dialog window.
  *
  *----------------------------------------------------------------------
  */
 
-static UINT
-CALLBACK ColorDlgHookProc(hDlg, uMsg, wParam, lParam)
-    HWND hDlg;			/* Handle to the color dialog */
-    UINT uMsg;			/* Type of message */
-    WPARAM wParam;		/* word param, interpretation depends on uMsg*/
-    LPARAM lParam;		/* long param, interpretation depends on uMsg*/
+static UINT CALLBACK 
+ColorDlgHookProc(hDlg, uMsg, wParam, lParam)
+    HWND hDlg;			/* Handle to the color dialog. */
+    UINT uMsg;			/* Type of message. */
+    WPARAM wParam;		/* First message parameter. */
+    LPARAM lParam;		/* Second message parameter. */
 {
-    CHOOSECOLOR * ccPtr;
-    ChooseColorData * pCustData;
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
 
     switch (uMsg) {
-      case WM_INITDIALOG:
-	/* Save the pointer to CHOOSECOLOR so that we can use it later */
-	SetWindowLong(hDlg, DWL_USER, lParam);
-
-	/* Set the title string of the dialog */
-	ccPtr = (CHOOSECOLOR*)lParam;
-	pCustData = (ChooseColorData*)(ccPtr->lCustData);
-	if (pCustData->title && *(pCustData->title)) {
- 	    SetWindowText(hDlg, (LPCSTR)pCustData->title);
-	}
+	case WM_INITDIALOG: {
+	    const char *title;
+	    CHOOSECOLOR *ccPtr;
+	    Tcl_DString ds;
 
-	return TRUE;
-    }
+	    /* 
+	     * Set the title string of the dialog.
+	     */
 
+	    ccPtr = (CHOOSECOLOR *) lParam;
+	    title = (const char *) ccPtr->lCustData;
+	    if ((title != NULL) && (title[0] != '\0')) {
+		Tcl_UtfToExternalDString(NULL, title, -1, &ds);
+		SetWindowText(hDlg, (TCHAR *) Tcl_DStringValue(&ds));
+		Tcl_DStringFree(&ds);
+	    }
+	    if (tsdPtr->debugFlag) {
+		tsdPtr->debugInterp = (Tcl_Interp *) ccPtr->lpTemplateName;
+		Tcl_DoWhenIdle(SetTkDialog, (ClientData) hDlg);
+	    }
+	    return TRUE;
+	}
+    }
     return FALSE;
 }
 
@@ -371,21 +365,18 @@ CALLBACK ColorDlgHookProc(hDlg, uMsg, wParam, lParam)
  *
  * Side effects:
  *	A dialog window is created the first this procedure is called.
- *	This window is not destroyed and will be reused the next time
- *	the application invokes the "tk_getOpenFile" or
- *	"tk_getSaveFile" command.
  *
  *----------------------------------------------------------------------
  */
 
 int
-Tk_GetOpenFileCmd(clientData, interp, argc, argv)
+Tk_GetOpenFileObjCmd(clientData, interp, objc, objv)
     ClientData clientData;	/* Main window associated with interpreter. */
     Tcl_Interp *interp;		/* Current interpreter. */
-    int argc;			/* Number of arguments. */
-    char **argv;		/* Argument strings. */
+    int objc;			/* Number of arguments. */
+    Tcl_Obj *CONST objv[];	/* Argument objects. */
 {
-    return GetFileName(clientData, interp, argc, argv, OPEN_FILE);
+    return GetFileName(clientData, interp, objc, objv, 1);
 }
 
 /*
@@ -406,13 +397,13 @@ Tk_GetOpenFileCmd(clientData, interp, argc, argv)
  */
 
 int
-Tk_GetSaveFileCmd(clientData, interp, argc, argv)
+Tk_GetSaveFileObjCmd(clientData, interp, objc, objv)
     ClientData clientData;	/* Main window associated with interpreter. */
     Tcl_Interp *interp;		/* Current interpreter. */
-    int argc;			/* Number of arguments. */
-    char **argv;		/* Argument strings. */
+    int objc;			/* Number of arguments. */
+    Tcl_Obj *CONST objv[];	/* Argument objects. */
 {
-    return GetFileName(clientData, interp, argc, argv, SAVE_FILE);
+    return GetFileName(clientData, interp, objc, objv, 0);
 }
 
 /*
@@ -432,41 +423,197 @@ Tk_GetSaveFileCmd(clientData, interp, argc, argv)
  */
 
 static int 
-GetFileName(clientData, interp, argc, argv, isOpen)
+GetFileName(clientData, interp, objc, objv, open)
     ClientData clientData;	/* Main window associated with interpreter. */
     Tcl_Interp *interp;		/* Current interpreter. */
-    int argc;			/* Number of arguments. */
-    char **argv;		/* Argument strings. */
-    int isOpen;			/* true if we should call GetOpenFileName(),
-				 * false if we should call GetSaveFileName() */
+    int objc;			/* Number of arguments. */
+    Tcl_Obj *CONST objv[];	/* Argument objects. */
+    int open;			/* 1 to call GetOpenFileName(), 0 to 
+				 * call GetSaveFileName(). */
 {
-    OPENFILENAME openFileName, *ofnPtr;
-    int tclCode, winCode, oldMode;
-    OpenFileData *custData;
-    char buffer[MAX_PATH+1];
-    
-    ofnPtr = &openFileName;
+    OPENFILENAME ofn;
+    TCHAR file[MAX_PATH], savePath[MAX_PATH];
+    int result, winCode, oldMode, i;
+    char *extension, *filter, *title;
+    Tk_Window tkwin;
+    Tcl_DString utfFilterString, utfDirString;
+    Tcl_DString extString, filterString, dirString, titleString;
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    static char *optionStrings[] = {
+	"-defaultextension", "-filetypes", "-initialdir", "-initialfile",
+	"-parent",	"-title",	NULL
+    };
+    enum options {
+	FILE_DEFAULT,	FILE_TYPES,	FILE_INITDIR,	FILE_INITFILE,
+	FILE_PARENT,	FILE_TITLE
+    };
+
+    result = TCL_ERROR;
+    file[0] = '\0';
 
     /*
-     * 1. Parse the arguments.
+     * Parse the arguments.
      */
-    if (ParseFileDlgArgs(interp, ofnPtr, argc, argv, isOpen) != TCL_OK) {
-	return TCL_ERROR;
+
+    extension = NULL;
+    filter = NULL;
+    Tcl_DStringInit(&utfFilterString);
+    Tcl_DStringInit(&utfDirString);
+    tkwin = (Tk_Window) clientData;
+    title = NULL;
+
+    for (i = 1; i < objc; i += 2) {
+	int index;
+	char *string;
+	Tcl_Obj *optionPtr, *valuePtr;
+
+	optionPtr = objv[i];
+	valuePtr = objv[i + 1];
+
+	if (Tcl_GetIndexFromObj(interp, optionPtr, optionStrings, "option", 
+		0, &index) != TCL_OK) {
+	    goto end;
+	}
+	if (i + 1 == objc) {
+	    string = Tcl_GetStringFromObj(optionPtr, NULL);
+	    Tcl_AppendResult(interp, "value for \"", string, "\" missing", 
+		    (char *) NULL);
+	    goto end;
+	}
+
+	string = Tcl_GetStringFromObj(valuePtr, NULL);
+	switch ((enum options) index) {
+	    case FILE_DEFAULT: {
+		if (string[0] == '.') {
+		    string++;
+		}
+		extension = string;
+		break;
+	    }
+	    case FILE_TYPES: {
+		Tcl_DStringFree(&utfFilterString);
+		if (MakeFilter(interp, string, &utfFilterString) != TCL_OK) {
+		    goto end;
+		}
+		filter = Tcl_DStringValue(&utfFilterString);
+		break;
+	    }
+	    case FILE_INITDIR: {
+		Tcl_DStringFree(&utfDirString);
+		if (Tcl_TranslateFileName(interp, string, 
+			&utfDirString) == NULL) {
+		    goto end;
+		}
+		break;
+	    }
+	    case FILE_INITFILE: {
+		Tcl_DString ds;
+
+		if (Tcl_TranslateFileName(interp, string, &ds) == NULL) {
+		    goto end;
+		}
+		Tcl_UtfToExternal(NULL, NULL, Tcl_DStringValue(&ds), 
+			Tcl_DStringLength(&ds), 0, NULL, (char *) file, 
+			sizeof(file), NULL, NULL, NULL);
+		break;
+	    }
+	    case FILE_PARENT: {
+		tkwin = Tk_NameToWindow(interp, string, tkwin);
+		if (tkwin == NULL) {
+		    goto end;
+		}
+		break;
+	    }
+	    case FILE_TITLE: {
+		title = string;
+		break;
+	    }
+	}
+    }
+
+    if (filter == NULL) {
+	if (MakeFilter(interp, "", &utfFilterString) != TCL_OK) {
+	    goto end;
+	}
+    }
+
+    Tk_MakeWindowExist(tkwin);
+
+    ofn.lStructSize		= sizeof(ofn);
+    ofn.hwndOwner		= Tk_GetHWND(Tk_WindowId(tkwin));
+    ofn.hInstance		= (HINSTANCE) GetWindowLong(ofn.hwndOwner, 
+					GWL_HINSTANCE);
+    ofn.lpstrFilter		= NULL;
+    ofn.lpstrCustomFilter	= NULL;
+    ofn.nMaxCustFilter		= 0;
+    ofn.nFilterIndex		= 0;
+    ofn.lpstrFile		= (LPTSTR) file;
+    ofn.nMaxFile		= MAX_PATH;
+    ofn.lpstrFileTitle		= NULL;
+    ofn.nMaxFileTitle		= 0;
+    ofn.lpstrInitialDir		= NULL;
+    ofn.lpstrTitle		= NULL;
+    ofn.Flags			= OFN_HIDEREADONLY | OFN_PATHMUSTEXIST 
+				  | OFN_NOCHANGEDIR;
+    ofn.nFileOffset		= 0;
+    ofn.nFileExtension		= 0;
+    ofn.lpstrDefExt		= NULL;
+    ofn.lpfnHook		= OFNHookProc;
+    ofn.lCustData		= (LPARAM) interp;
+    ofn.lpTemplateName		= NULL;
+
+    if (LOBYTE(LOWORD(GetVersion())) >= 4) {
+	/*
+	 * Use the "explorer" style file selection box on platforms that
+	 * support it (Win95 and NT4.0 both have a major version number
+	 * of 4).
+	 */
+
+	ofn.Flags |= OFN_EXPLORER;
+    }
+
+    if (open != 0) {
+	ofn.Flags |= OFN_FILEMUSTEXIST;
+    } else {
+	ofn.Flags |= OFN_OVERWRITEPROMPT;
+    }
+
+    if (tsdPtr->debugFlag != 0) {
+	ofn.Flags |= OFN_ENABLEHOOK;
+    }
+
+    if (extension != NULL) {
+	Tcl_UtfToExternalDString(NULL, extension, -1, &extString);
+	ofn.lpstrDefExt = (LPTSTR) Tcl_DStringValue(&extString);
+    }
+    Tcl_UtfToExternalDString(NULL, Tcl_DStringValue(&utfFilterString),
+	    Tcl_DStringLength(&utfFilterString), &filterString);
+    ofn.lpstrFilter = (LPTSTR) Tcl_DStringValue(&filterString);
+
+    if (Tcl_DStringValue(&utfDirString)[0] != '\0') {
+	Tcl_UtfToExternalDString(NULL, Tcl_DStringValue(&utfDirString),
+		Tcl_DStringLength(&utfDirString), &dirString);
+        ofn.lpstrInitialDir = (LPTSTR) Tcl_DStringValue(&dirString);
+    }
+    if (title != NULL) {
+	Tcl_UtfToExternalDString(NULL, title, -1, &titleString);
+	ofn.lpstrTitle = (LPTSTR) Tcl_DStringValue(&titleString);
     }
-    custData = (OpenFileData*) ofnPtr->lCustData;
 
     /*
-     * 2. Call the common dialog function.
+     * Popup the dialog.  
      */
+
+    GetCurrentDirectory(MAX_PATH, savePath);
     oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL);
-    GetCurrentDirectory(MAX_PATH+1, buffer);
-    if (isOpen) {
-	winCode = GetOpenFileName(ofnPtr);
+    if (open != 0) {
+	winCode = GetOpenFileName(&ofn);
     } else {
-	winCode = GetSaveFileName(ofnPtr);
+	winCode = GetSaveFileName(&ofn);
     }
-    SetCurrentDirectory(buffer);
-    (void) Tcl_SetServiceMode(oldMode);
+    Tcl_SetServiceMode(oldMode);
+    SetCurrentDirectory(savePath);
 
     /*
      * Clear the interp result since anything may have happened during the
@@ -475,18 +622,16 @@ GetFileName(clientData, interp, argc, argv, isOpen)
 
     Tcl_ResetResult(interp);
 
-    if (ofnPtr->lpstrInitialDir != NULL) {
-	ckfree((char*) ofnPtr->lpstrInitialDir);
-    }
-
     /*
-     * 3. Process the results.
+     * Process the results.
      */
-    if (winCode) {
+
+    if (winCode != 0) {
 	char *p;
-	Tcl_ResetResult(interp);
+	Tcl_DString ds;
 
-	for (p = custData->szFile; p && *p; p++) {
+	Tcl_ExternalToUtfDString(NULL, (char *) ofn.lpstrFile, -1, &ds);
+	for (p = Tcl_DStringValue(&ds); *p != '\0'; p++) {
 	    /*
 	     * Change the pathname to the Tcl "normalized" pathname, where
 	     * back slashes are used instead of forward slashes
@@ -495,177 +640,80 @@ GetFileName(clientData, interp, argc, argv, isOpen)
 		*p = '/';
 	    }
 	}
-	Tcl_AppendResult(interp, custData->szFile, NULL);
-	tclCode = TCL_OK;
-    } else {
-	tclCode = ProcessCDError(interp, CommDlgExtendedError(),
-		ofnPtr->hwndOwner);
+	Tcl_AppendResult(interp, Tcl_DStringValue(&ds), NULL);
+	Tcl_DStringFree(&ds);
     }
 
-    if (custData) {
-	ckfree((char*)custData);
+    if (ofn.lpstrTitle != NULL) {
+	Tcl_DStringFree(&titleString);
+    }
+    if (ofn.lpstrInitialDir != NULL) {
+	Tcl_DStringFree(&dirString);
     }
-    if (ofnPtr->lpstrFilter) {
-	ckfree((char*)ofnPtr->lpstrFilter);
+    Tcl_DStringFree(&filterString);
+    if (ofn.lpstrDefExt != NULL) {
+	Tcl_DStringFree(&extString);
     }
+    result = TCL_OK;
+
+    end:
+    Tcl_DStringFree(&utfDirString);
+    Tcl_DStringFree(&utfFilterString);
 
-    return tclCode;
+    return result;
 }
 
 /*
- *----------------------------------------------------------------------
+ *-------------------------------------------------------------------------
  *
- * ParseFileDlgArgs --
+ * OFNHookProc --
  *
- *	Parses the arguments passed to tk_getOpenFile and tk_getSaveFile.
+ *	Hook procedure called only if debugging is turned on.  Sets
+ *	the "tk_dialog" variable when the dialog is ready to receive
+ *	messages.
  *
  * Results:
- *	A standard TCL return value.
+ *	Returns 0 to allow default processing of messages to occur.
  *
  * Side effects:
- *	The OPENFILENAME structure is initialized and modified according
- *	to the arguments.
+ *	None.
  *
- *----------------------------------------------------------------------
+ *-------------------------------------------------------------------------
  */
 
-static int 
-ParseFileDlgArgs(interp, ofnPtr, argc, argv, isOpen)
-    Tcl_Interp * interp;	/* Current interpreter. */
-    OPENFILENAME *ofnPtr;	/* Info about the file dialog */
-    int argc;			/* Number of arguments. */
-    char **argv;		/* Argument strings. */
-    int isOpen;			/* true if we should call GetOpenFileName(),
-				 * false if we should call GetSaveFileName() */
+static UINT APIENTRY 
+OFNHookProc(
+    HWND hdlg,		// handle to child dialog window
+    UINT uMsg,		// message identifier
+    WPARAM wParam,	// message parameter
+    LPARAM lParam) 	// message parameter
 {
-    OpenFileData * custData;
-    int i;
-    Tk_Window parent = Tk_MainWindow(interp);
-    int doneFilter = 0;
-    int windowsMajorVersion;
-    Tcl_DString buffer;
-
-    custData = (OpenFileData*)ckalloc(sizeof(OpenFileData));
-    custData->interp = interp;
-    strcpy(custData->szFile, "");
-
-    /* Fill in the OPENFILENAME structure to */
-    ofnPtr->lStructSize       = sizeof(OPENFILENAME);
-    ofnPtr->hwndOwner         = 0;			/* filled in below */
-    ofnPtr->lpstrFilter       = NULL;
-    ofnPtr->lpstrCustomFilter = NULL;
-    ofnPtr->nMaxCustFilter    = 0;
-    ofnPtr->nFilterIndex      = 0;
-    ofnPtr->lpstrFile         = custData->szFile;
-    ofnPtr->nMaxFile          = sizeof(custData->szFile);
-    ofnPtr->lpstrFileTitle    = NULL;
-    ofnPtr->nMaxFileTitle     = 0;
-    ofnPtr->lpstrInitialDir   = NULL;
-    ofnPtr->lpstrTitle        = NULL;
-    ofnPtr->nFileOffset       = 0;
-    ofnPtr->nFileExtension    = 0;
-    ofnPtr->lpstrDefExt       = NULL;
-    ofnPtr->lpfnHook 	      = NULL; 
-    ofnPtr->lCustData         = (DWORD)custData;
-    ofnPtr->lpTemplateName    = NULL;
-    ofnPtr->Flags             = OFN_HIDEREADONLY | OFN_PATHMUSTEXIST;
-
-    windowsMajorVersion = LOBYTE(LOWORD(GetVersion()));
-    if (windowsMajorVersion >= 4) {
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    OPENFILENAME *ofnPtr;
+
+    if (uMsg == WM_INITDIALOG) {
+	SetWindowLong(hdlg, GWL_USERDATA, lParam);
+    } else if (uMsg == WM_WINDOWPOSCHANGED) {
 	/*
-	 * Use the "explorer" style file selection box on platforms that
-	 * support it (Win95 and NT4.0, both have a major version number
-	 * of 4)
+	 * This message is delivered at the right time to both 
+	 * old-style and explorer-style hook procs to enable Tk
+	 * to set the debug information.  Unhooks itself so it 
+	 * won't set the debug information every time it gets a 
+	 * WM_WINDOWPOSCHANGED message.
 	 */
-	ofnPtr->Flags |= OFN_EXPLORER;
-    }
-
-
-    if (isOpen) {
-	ofnPtr->Flags |= OFN_FILEMUSTEXIST;
-    } else {
-	ofnPtr->Flags |= OFN_OVERWRITEPROMPT;
-    }
-
-    for (i=1; i<argc; i+=2) {
-        int v = i+1;
-	int len = strlen(argv[i]);
-
-	if (strncmp(argv[i], "-defaultextension", len)==0) {
-	    if (v==argc) {goto arg_missing;}
-
-	    ofnPtr->lpstrDefExt = argv[v];
-	    if (ofnPtr->lpstrDefExt[0] == '.') {
-		/* Windows will insert the dot for us */
-		ofnPtr->lpstrDefExt ++;
-	    }
-	}
-	else if (strncmp(argv[i], "-filetypes", len)==0) {
-	    if (v==argc) {goto arg_missing;}
-
-	    if (MakeFilter(interp, ofnPtr, argv[v]) != TCL_OK) {
-		return TCL_ERROR;
-	    }
-	    doneFilter = 1;
-	}
-	else if (strncmp(argv[i], "-initialdir", len)==0) {
-	    if (v==argc) {goto arg_missing;}
-
-	    if (Tcl_TranslateFileName(interp, argv[v], &buffer) == NULL) {
-		return TCL_ERROR;
-	    }
-	    ofnPtr->lpstrInitialDir = ckalloc(Tcl_DStringLength(&buffer)+1);
-	    strcpy((char*)ofnPtr->lpstrInitialDir, Tcl_DStringValue(&buffer));
-	    Tcl_DStringFree(&buffer);
-	}
-	else if (strncmp(argv[i], "-initialfile", len)==0) {
-	    if (v==argc) {goto arg_missing;}
 
-	    if (Tcl_TranslateFileName(interp, argv[v], &buffer) == NULL) {
-		return TCL_ERROR;
+        ofnPtr = (OPENFILENAME *) GetWindowLong(hdlg, GWL_USERDATA);
+	if (ofnPtr != NULL) {
+	    if (ofnPtr->Flags & OFN_EXPLORER) {
+		hdlg = GetParent(hdlg);
 	    }
-	    strcpy(ofnPtr->lpstrFile, Tcl_DStringValue(&buffer));
-	    Tcl_DStringFree(&buffer);
+	    tsdPtr->debugInterp = (Tcl_Interp *) ofnPtr->lCustData;
+	    Tcl_DoWhenIdle(SetTkDialog, (ClientData) hdlg);
+	    SetWindowLong(hdlg, GWL_USERDATA, (LPARAM) NULL);
 	}
-	else if (strncmp(argv[i], "-parent", len)==0) {
-	    if (v==argc) {goto arg_missing;}
-
-	    parent=Tk_NameToWindow(interp, argv[v], Tk_MainWindow(interp));
-	    if (parent == NULL) {
-		return TCL_ERROR;
-	    }
-	}
-	else if (strncmp(argv[i], "-title", len)==0) {
-	    if (v==argc) {goto arg_missing;}
-
-	    ofnPtr->lpstrTitle = argv[v];
-	}
-	else {
-    	    Tcl_AppendResult(interp, "unknown option \"", 
-		argv[i], "\", must be -defaultextension, ",
-		"-filetypes, -initialdir, -initialfile, -parent or -title",
-		NULL);
-	    return TCL_ERROR;
-	}
-    }
-
-    if (!doneFilter) {
-	if (MakeFilter(interp, ofnPtr, "") != TCL_OK) {
-	    return TCL_ERROR;
-	}
-    }
-
-    if (Tk_WindowId(parent) == None) {
-	Tk_MakeWindowExist(parent);
     }
-    ofnPtr->hwndOwner = Tk_GetHWND(Tk_WindowId(parent));
-
-    return TCL_OK;
-
-  arg_missing:
-    Tcl_AppendResult(interp, "value for \"", argv[argc-1], "\" missing",
-	NULL);
-    return TCL_ERROR;
+    return 0;
 }
 
 /*
@@ -684,10 +732,11 @@ ParseFileDlgArgs(interp, ofnPtr, argc, argv, isOpen)
  *
  *----------------------------------------------------------------------
  */
-static int MakeFilter(interp, ofnPtr, string) 
+static int 
+MakeFilter(interp, string, dsPtr) 
     Tcl_Interp *interp;		/* Current interpreter. */
-    OPENFILENAME *ofnPtr;	/* Info about the file dialog */
     char *string;		/* String value of the -filetypes option */
+    Tcl_DString *dsPtr;		/* Filled with windows filter string. */
 {
     char *filterStr;
     char *p;
@@ -702,7 +751,7 @@ static int MakeFilter(interp, ofnPtr, string)
 
     if (flist.filters == NULL) {
 	/*
-	 * Use "All Files (*.*) as the default filter is none is specified
+	 * Use "All Files (*.*) as the default filter if none is specified
 	 */
 	char *defaultFilter = "All Files (*.*)";
 
@@ -790,10 +839,8 @@ static int MakeFilter(interp, ofnPtr, string)
 	*p = '\0';
     }
 
-    if (ofnPtr->lpstrFilter != NULL) {
-	ckfree((char*)ofnPtr->lpstrFilter);
-    }
-    ofnPtr->lpstrFilter = filterStr;
+    Tcl_DStringAppend(dsPtr, filterStr, p - filterStr);
+    ckfree((char *) filterStr);
 
     TkFreeFileFilters(&flist);
     return TCL_OK;
@@ -802,249 +849,583 @@ static int MakeFilter(interp, ofnPtr, string)
 /*
  *----------------------------------------------------------------------
  *
- * Tk_MessageBoxCmd --
+ * Tk_ChooseDirectoryObjCmd --
  *
- *	This procedure implements the MessageBox window for the
- *	Windows platform. See the user documentation for details on what
- *	it does.
+ *	This procedure implements the "tk_chooseDirectory" dialog box 
+ *	for the Windows platform. See the user documentation for details 
+ *	on what it does.
  *
  * Results:
  *	See user documentation.
  *
  * Side effects:
- *	None. The MessageBox window will be destroy before this procedure
- *	returns.
+ *	A modal dialog window is created.  Tcl_SetServiceMode() is
+ *	called to allow background events to be processed
  *
  *----------------------------------------------------------------------
  */
 
 int
-Tk_MessageBoxCmd(clientData, interp, argc, argv)
+Tk_ChooseDirectoryObjCmd(clientData, interp, objc, objv)
     ClientData clientData;	/* Main window associated with interpreter. */
     Tcl_Interp *interp;		/* Current interpreter. */
-    int argc;			/* Number of arguments. */
-    char **argv;		/* Argument strings. */
+    int objc;			/* Number of arguments. */
+    Tcl_Obj *CONST objv[];	/* Argument objects. */
 {
-    int flags;
-    Tk_Window parent = Tk_MainWindow(interp);
-    HWND hWnd;
-    char *message = "";
-    char *title = "";
-    int icon = MB_ICONINFORMATION;
-    int type = MB_OK;
-    int i, j;
-    char *result;
-    int code, oldMode;
-    char *defaultBtn = NULL;
-    int defaultBtnIdx = -1;
-
-    for (i=1; i<argc; i+=2) {
-	int v = i+1;
-	int len = strlen(argv[i]);
-
-	if (strncmp(argv[i], "-default", len)==0) {
-	    if (v==argc) {goto arg_missing;}
-
-	    defaultBtn = argv[v];
+    OPENFILENAME ofn;
+    TCHAR path[MAX_PATH], savePath[MAX_PATH];
+    ChooseDir cd;
+    int result, mustExist, code, mode, i;
+    Tk_Window tkwin;
+    char *utfTitle;
+    Tcl_DString utfDirString;
+    Tcl_DString titleString, dirString;
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    static char *optionStrings[] = {
+	"-initialdir",	"-mustexist",	"-parent",	"-title",
+	NULL
+    };
+    enum options {
+	DIR_INITIAL,	DIR_EXIST,	DIR_PARENT,	FILE_TITLE
+    };
+
+    if (tsdPtr->WM_LBSELCHANGED == 0) {
+        tsdPtr->WM_LBSELCHANGED = RegisterWindowMessage(LBSELCHSTRING);
+    }
+   
+    result = TCL_ERROR;
+    path[0] = '\0';
+
+    Tcl_DStringInit(&utfDirString);
+    mustExist = 0;
+    tkwin = (Tk_Window) clientData;
+    utfTitle = NULL;
+
+    for (i = 1; i < objc; i += 2) {
+	int index;
+	char *string;
+	Tcl_Obj *optionPtr, *valuePtr;
+
+	optionPtr = objv[i];
+	valuePtr = objv[i + 1];
+
+	if (Tcl_GetIndexFromObj(interp, optionPtr, optionStrings, "option",
+		0, &index) != TCL_OK) {
+	    goto cleanup;
+	}
+	if (i + 1 == objc) {
+	    string = Tcl_GetStringFromObj(optionPtr, NULL);
+	    Tcl_AppendResult(interp, "value for \"", string, "\" missing", 
+		    (char *) NULL);
+	    goto cleanup;
 	}
-	else if (strncmp(argv[i], "-icon", len)==0) {
-	    if (v==argc) {goto arg_missing;}
 
-	    if (strcmp(argv[v], "error") == 0) {
-		icon = MB_ICONERROR;
+	string = Tcl_GetStringFromObj(valuePtr, NULL);
+	switch ((enum options) index) {
+	    case DIR_INITIAL: {
+		Tcl_DStringFree(&utfDirString);
+		if (Tcl_TranslateFileName(interp, string, 
+			&utfDirString) == NULL) {
+		    goto cleanup;
+		}
+		break;
 	    }
-	    else if (strcmp(argv[v], "info") == 0) {
-		icon = MB_ICONINFORMATION;
+	    case DIR_EXIST: {
+		if (Tcl_GetBooleanFromObj(interp, valuePtr, &mustExist) != TCL_OK) {
+		    goto cleanup;
+		}
+		break;
 	    }
-	    else if (strcmp(argv[v], "question") == 0) {
-		icon = MB_ICONQUESTION;
+	    case DIR_PARENT: {
+		tkwin = Tk_NameToWindow(interp, string, tkwin);
+		if (tkwin == NULL) {
+		    goto cleanup;
+		}
+		break;
 	    }
-	    else if (strcmp(argv[v], "warning") == 0) {
-		icon = MB_ICONWARNING;
+	    case FILE_TITLE: {
+		utfTitle = string;
+		break;
 	    }
-	    else {
-	        Tcl_AppendResult(interp, "invalid icon \"", argv[v],
-		    "\", must be error, info, question or warning", NULL);
-		return TCL_ERROR;
+	}
+    }
+
+    Tk_MakeWindowExist(tkwin);
+
+    cd.interp = interp;
+
+    ofn.lStructSize		= sizeof(ofn);
+    ofn.hwndOwner		= Tk_GetHWND(Tk_WindowId(tkwin));
+    ofn.hInstance		= (HINSTANCE) GetWindowLong(ofn.hwndOwner, 
+					GWL_HINSTANCE);
+    ofn.lpstrFilter		= NULL;
+    ofn.lpstrCustomFilter	= NULL;
+    ofn.nMaxCustFilter		= 0;
+    ofn.nFilterIndex		= 0;
+    ofn.lpstrFile		= NULL; //(TCHAR *) path;
+    ofn.nMaxFile		= MAX_PATH;
+    ofn.lpstrFileTitle		= NULL;
+    ofn.nMaxFileTitle		= 0;
+    ofn.lpstrInitialDir		= NULL;
+    ofn.lpstrTitle		= NULL;
+    ofn.Flags			= OFN_HIDEREADONLY  
+				  | OFN_ENABLEHOOK | OFN_ENABLETEMPLATE;
+    ofn.nFileOffset		= 0;
+    ofn.nFileExtension		= 0;
+    ofn.lpstrDefExt		= NULL;
+    ofn.lCustData		= (LPARAM) &cd;
+    ofn.lpfnHook		= ChooseDirectoryHookProc;
+    ofn.lpTemplateName		= MAKEINTRESOURCE(FILEOPENORD);
+
+    if (Tcl_DStringValue(&utfDirString)[0] != '\0') {
+	Tcl_UtfToExternalDString(NULL, Tcl_DStringValue(&utfDirString), 
+		Tcl_DStringLength(&utfDirString), &dirString);
+	ofn.lpstrInitialDir = (LPTSTR) Tcl_DStringValue(&dirString);
+    }
+    if (mustExist) {
+	ofn.Flags |= OFN_PATHMUSTEXIST;
+    }
+    if (utfTitle != NULL) {
+	Tcl_UtfToExternalDString(NULL, utfTitle, -1, &titleString);
+	ofn.lpstrTitle = (LPTSTR) Tcl_DStringValue(&titleString);
+    }
+
+    /*
+     * Display dialog.  The choose directory dialog doesn't preserve the
+     * current directory, so it must be saved and restored here.
+     */
+    
+    GetCurrentDirectory(MAX_PATH, savePath);
+    mode = Tcl_SetServiceMode(TCL_SERVICE_ALL);
+    code = GetOpenFileName(&ofn);
+    Tcl_SetServiceMode(mode);
+    SetCurrentDirectory(savePath);
+
+    Tcl_ResetResult(interp);
+    if (code != 0) {
+	/*
+	 * Change the pathname to the Tcl "normalized" pathname, where
+	 * back slashes are used instead of forward slashes
+	 */
+
+	char *p;
+	Tcl_DString ds;
+
+	Tcl_ExternalToUtfDString(NULL, (char *) cd.path, -1, &ds);
+	for (p = Tcl_DStringValue(&ds); *p != '\0'; p++) {
+	    if (*p == '\\') {
+		*p = '/';
 	    }
 	}
-	else if (strncmp(argv[i], "-message", len)==0) {
-	    if (v==argc) {goto arg_missing;}
+	Tcl_AppendResult(interp, Tcl_DStringValue(&ds), NULL);
+	Tcl_DStringFree(&ds);
+    }
 
-	    message = argv[v];
+    if (ofn.lpstrTitle != NULL) {
+	Tcl_DStringFree(&titleString);
+    }
+    if (ofn.lpstrInitialDir != NULL) {
+	Tcl_DStringFree(&dirString);
+    }
+    result = TCL_OK;
+
+    cleanup:
+    Tcl_DStringFree(&utfDirString);
+
+    return result;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * ChooseDirectoryHookProc --
+ *
+ *	Hook procedure called by the ChooseDirectory dialog to modify
+ *	its default behavior.  The ChooseDirectory dialog is really an
+ *	OpenFile dialog with certain controls rearranged and certain
+ *	behaviors changed.  For instance, typing a name in the 
+ *	ChooseDirectory dialog selects a directory, rather than 
+ *	selecting a file.
+ *
+ * Results:
+ *	Returns 0 to allow default processing of message, or 1 to 
+ *	tell default dialog procedure not to process the message.
+ *
+ * Side effects:
+ *	A dialog window is created the first this procedure is called.
+ *	This window is not destroyed and will be reused the next time
+ *	the application invokes the "tk_getOpenFile" or
+ *	"tk_getSaveFile" command.
+ *
+ *----------------------------------------------------------------------
+ */
+
+static UINT APIENTRY 
+ChooseDirectoryHookProc(
+    HWND hwnd,
+    UINT message,
+    WPARAM wParam,
+    LPARAM lParam)
+{
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    OPENFILENAME *ofnPtr;
+
+    /*
+     * GWL_USERDATA keeps track of ofnPtr.
+     */
+    
+    ofnPtr = (OPENFILENAME *) GetWindowLong(hwnd, GWL_USERDATA);
+
+    if (message == WM_INITDIALOG) {
+        ChooseDir *cdPtr;
+
+	SetWindowLong(hwnd, GWL_USERDATA, lParam);
+	ofnPtr = (OPENFILENAME *) lParam;
+	cdPtr = (ChooseDir *) ofnPtr->lCustData;
+	cdPtr->lastCtrl = 0;
+	cdPtr->lastIdx = 1000;
+	cdPtr->path[0] = '\0';
+
+	if (ofnPtr->lpstrInitialDir == NULL) {
+	    GetCurrentDirectory(MAX_PATH, cdPtr->path);
+	} else {
+	    lstrcpy(cdPtr->path, ofnPtr->lpstrInitialDir);
 	}
-	else if (strncmp(argv[i], "-parent", len)==0) {
-	    if (v==argc) {goto arg_missing;}
+	SetDlgItemText(hwnd, edt10, cdPtr->path);
+	SendDlgItemMessage(hwnd, edt10, EM_SETSEL, 0, -1);
+	if (tsdPtr->debugFlag) {
+	    tsdPtr->debugInterp = cdPtr->interp;
+	    Tcl_DoWhenIdle(SetTkDialog, (ClientData) hwnd);
+	}
+	return 0;
+    }
+    if (ofnPtr == NULL) {
+	return 0;
+    }
 
-	    parent=Tk_NameToWindow(interp, argv[v], Tk_MainWindow(interp));
-	    if (parent == NULL) {
-		return TCL_ERROR;
+    if (message == tsdPtr->WM_LBSELCHANGED) {
+	/*
+	 * Called when double-clicking on directory.
+	 * If directory wasn't already open, browse that directory.
+	 * If directory was already open, return selected directory.
+	 */
+
+        ChooseDir *cdPtr;
+	int idCtrl, thisItem;
+
+	idCtrl = (int) wParam;
+        thisItem = LOWORD(lParam);
+	cdPtr = (ChooseDir *) ofnPtr->lCustData;
+
+	GetCurrentDirectory(MAX_PATH, cdPtr->path);
+	if (idCtrl == lst2) {
+	    if ((cdPtr->lastIdx < 0) || (cdPtr->lastIdx == thisItem)) {
+		EndDialog(hwnd, IDOK);
+		return 1;
 	    }
+	    cdPtr->lastIdx = thisItem;
 	}
-	else if (strncmp(argv[i], "-title", len)==0) {
-	    if (v==argc) {goto arg_missing;}
+	SetDlgItemText(hwnd, edt10, cdPtr->path);
+	SendDlgItemMessage(hwnd, edt10, EM_SETSEL, 0, -1);
+    } else if (message == WM_COMMAND) {
+        ChooseDir *cdPtr;
+	int idCtrl, notifyCode;
+
+	idCtrl = LOWORD(wParam);
+	notifyCode = HIWORD(wParam);
+	cdPtr = (ChooseDir *) ofnPtr->lCustData;
+
+	if ((idCtrl != IDOK) || (notifyCode != BN_CLICKED)) {
+	    /*
+	     * OK Button wasn't clicked.  Do the default.
+	     */
 
-	    title = argv[v];
+	    if ((idCtrl == lst2) || (idCtrl == edt10)) {
+		cdPtr->lastCtrl = idCtrl;
+	    }
+	    return 0;
 	}
-	else if (strncmp(argv[i], "-type", len)==0) {
-	    int found = 0;
 
-	    if (v==argc) {goto arg_missing;}
+	/*
+	 * Dialogs also get the message that OK was clicked when Enter 
+	 * is pressed in some other control.  Find out what window
+	 * we were really in when we got the supposed "OK", because the 
+	 * behavior is different.
+	 */
+
+	if (cdPtr->lastCtrl == edt10) {
+	    /*
+	     * Hit Enter or clicked OK while typing a directory name in the 
+	     * edit control.
+	     * If it's a new name, try to go to that directory.
+	     * If the name hasn't changed since last time, return selected 
+	     * directory.
+	     */
 
-	    for (j=0; j<NUM_TYPES; j++) {
-		if (strcmp(argv[v], msgTypeInfo[j].name) == 0) {
-		    type = msgTypeInfo[j].type;
-		    found = 1;
-		    break;
+	    int changed;
+	    TCHAR tmp[MAX_PATH];
+
+	    if (GetDlgItemText(hwnd, edt10, tmp, MAX_PATH) == 0) {
+		return 0;
+	    }
+
+	    changed = lstrcmp(cdPtr->path, tmp);
+	    lstrcpy(cdPtr->path, tmp);
+
+	    if (SetCurrentDirectory(cdPtr->path) == 0) {
+		/*
+		 * Non-existent directory.
+		 */
+
+		if (ofnPtr->Flags & OFN_PATHMUSTEXIST) {
+		    /*
+		     * Directory must exist.  Complain, then rehighlight text.
+		     */
+
+		    wsprintf(tmp, _T("Cannot change directory to \"%.200s\"."), 
+			    cdPtr->path);
+		    MessageBox(hwnd, tmp, NULL, MB_OK);
+		    SendDlgItemMessage(hwnd, edt10, EM_SETSEL, 0, -1);
+		    return 0;
+		} 
+		if (changed) {
+		    /*
+		     * Directory was invalid, but we want to keep displaying
+		     * this name.  Don't update the listbox that displays the 
+		     * current directory heirarchy, or it'll erase the name.
+		     */
+		    
+		    SendDlgItemMessage(hwnd, edt10, EM_SETSEL, 0, -1);
+		    return 0;
 		}
 	    }
-	    if (!found) {
-		Tcl_AppendResult(interp, "invalid message box type \"", 
-		    argv[v], "\", must be abortretryignore, ok, ",
-		    "okcancel, retrycancel, yesno or yesnocancel", NULL);
-		return TCL_ERROR;
+	    if (changed == 0) {
+		/*
+		 * Name hasn't changed since the last time we hit return
+		 * or double-clicked on a directory, so return this.
+		 */
+
+		EndDialog(hwnd, IDOK);
+		return 1;
 	    }
+	    
+	    cdPtr->lastCtrl = IDOK;
+
+	    /*
+	     * The following is the magic code, determined by running 
+	     * Spy++ on some other directory chooser, that it takes to 
+	     * get this dialog to update the listbox to display the 
+	     * current directory.
+	     */
+
+	    SetDlgItemText(hwnd, edt1, cdPtr->path);
+	    SendMessage(hwnd, WM_COMMAND, (WPARAM) MAKELONG(cmb2, 0x8003), 
+		    (LPARAM) GetDlgItem(hwnd, cmb2));
+	    return 0;
+	} else if (idCtrl == lst2) {
+	    /*
+	     * Enter key was pressed while in listbox.  
+	     * If it's a new directory, allow default behavior to open dir.
+	     * If the directory hasn't changed, return selected directory.
+	     */
+
+	    int thisItem;
+
+	    thisItem = (int) SendDlgItemMessage(hwnd, lst2, LB_GETCURSEL, 0, 0);
+	    if (cdPtr->lastIdx == thisItem) {
+		GetCurrentDirectory(MAX_PATH, cdPtr->path);
+		EndDialog(hwnd, IDOK);
+		return 1;
+	    }
+	} else if (idCtrl == IDOK) {
+	    /* 
+	     * The OK button was clicked.  Return the path currently specified
+	     * in the listbox.  
+	     *
+	     * The directory has not yet been changed to the one specified in
+	     * the listbox.  Returning 0 allows the default dialog proc to 
+	     * change the directory to the one specified in the listbox and 
+	     * then causes it to send a WM_LBSELCHANGED back to the hook proc.  
+	     * When we get that message, we will record the current directory
+	     * and then quit.
+	     */
+
+	    cdPtr->lastIdx = -1;
+	}
+    }
+    return 0;
+}
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * Tk_MessageBoxObjCmd --
+ *
+ *	This procedure implements the MessageBox window for the
+ *	Windows platform. See the user documentation for details on what
+ *	it does.
+ *
+ * Results:
+ *	See user documentation.
+ *
+ * Side effects:
+ *	None. The MessageBox window will be destroy before this procedure
+ *	returns.
+ *
+ *----------------------------------------------------------------------
+ */
+
+int
+Tk_MessageBoxObjCmd(clientData, interp, objc, objv)
+    ClientData clientData;	/* Main window associated with interpreter. */
+    Tcl_Interp *interp;		/* Current interpreter. */
+    int objc;			/* Number of arguments. */
+    Tcl_Obj *CONST objv[];	/* Argument objects. */
+{
+    Tk_Window tkwin, parent;
+    HWND hWnd;
+    char *message, *title;
+    int defaultBtn, icon, type;
+    int i, oldMode, flags, winCode;
+    Tcl_DString messageString, titleString;
+    static char *optionStrings[] = {
+	"-default",	"-icon",	"-message",	"-parent",
+	"-title",	"-type",	NULL
+    };
+    enum options {
+	MSG_DEFAULT,	MSG_ICON,	MSG_MESSAGE,	MSG_PARENT,
+	MSG_TITLE,	MSG_TYPE
+    };
+
+    tkwin = (Tk_Window) clientData;
+
+    defaultBtn	= -1;
+    icon	= MB_ICONINFORMATION;
+    message	= NULL;
+    parent	= tkwin;
+    title	= NULL;
+    type	= MB_OK;
+
+    for (i = 1; i < objc; i += 2) {
+	int index;
+	char *string;
+	Tcl_Obj *optionPtr, *valuePtr;
+
+	optionPtr = objv[i];
+	valuePtr = objv[i + 1];
+
+	if (Tcl_GetIndexFromObj(interp, optionPtr, optionStrings, "option",
+		TCL_EXACT, &index) != TCL_OK) {
+	    return TCL_ERROR;
+	}
+	if (i + 1 == objc) {
+	    string = Tcl_GetStringFromObj(optionPtr, NULL);
+	    Tcl_AppendResult(interp, "value for \"", string, "\" missing", 
+		    (char *) NULL);
+	    return TCL_ERROR;
 	}
-	else {
-    	    Tcl_AppendResult(interp, "unknown option \"", 
-		argv[i], "\", must be -default, -icon, ",
-		"-message, -parent, -title or -type", NULL);
+
+        string = Tcl_GetStringFromObj(valuePtr, NULL);
+	switch ((enum options) index) {
+        case MSG_DEFAULT:
+	    defaultBtn = TkFindStateNumObj(interp, optionPtr, buttonMap, 
+		    valuePtr);
+	    if (defaultBtn < 0) {
+		return TCL_ERROR;
+	    }
+	    break;
+
+	case MSG_ICON:
+	    icon = TkFindStateNumObj(interp, optionPtr, iconMap, valuePtr);
+	    if (icon < 0) {
+		return TCL_ERROR;
+	    }
+	    break;
+
+	case MSG_MESSAGE:
+	    message = string;
+	    break;
+
+	case MSG_PARENT: 
+	    parent = Tk_NameToWindow(interp, string, tkwin);
+	    if (parent == NULL) {
 		return TCL_ERROR;
+	    }
+	    break;
+
+	case MSG_TITLE:
+	    title = string;
+	    break;
+
+	case MSG_TYPE:
+	    type = TkFindStateNumObj(interp, optionPtr, typeMap, valuePtr);
+	    if (type < 0) {
+		return TCL_ERROR;
+	    }
+	    break;
+
 	}
     }
 
-    /* Make sure we have a valid hWnd to act as the parent of this message box
-     */
-    if (Tk_WindowId(parent) == None) {
-	Tk_MakeWindowExist(parent);
-    }
+    Tk_MakeWindowExist(parent);
     hWnd = Tk_GetHWND(Tk_WindowId(parent));
 
-    if (defaultBtn != NULL) {
-	for (i=0; i<NUM_TYPES; i++) {
-	    if (type == msgTypeInfo[i].type) {
-		for (j=0; j<msgTypeInfo[i].numButtons; j++) {
-		    if (strcmp(defaultBtn, msgTypeInfo[i].btnNames[j])==0) {
-		        defaultBtnIdx = j;
+    flags = 0;
+    if (defaultBtn >= 0) {
+	int defaultBtnIdx;
+
+	defaultBtnIdx = -1;
+	for (i = 0; i < NUM_TYPES; i++) {
+	    if (type == allowedTypes[i].type) {
+		int j;
+
+		for (j = 0; j < 3; j++) {
+		    if (allowedTypes[i].btnIds[j] == defaultBtn) {
+			defaultBtnIdx = j;
 			break;
 		    }
 		}
 		if (defaultBtnIdx < 0) {
 		    Tcl_AppendResult(interp, "invalid default button \"",
-			defaultBtn, "\"", NULL);
+			    TkFindStateString(buttonMap, defaultBtn), 
+			    "\"", NULL);
 		    return TCL_ERROR;
 		}
 		break;
 	    }
 	}
-
-	switch (defaultBtnIdx) {
-	  case 0: flags = MB_DEFBUTTON1; break;
-	  case 1: flags = MB_DEFBUTTON2; break;
-	  case 2: flags = MB_DEFBUTTON3; break;
-	  case 3: flags = MB_DEFBUTTON4; break;
-	}
-    } else {
-	flags = 0;
+	flags = buttonFlagMap[defaultBtnIdx];
     }
     
-    flags |= icon | type;
+    flags |= icon | type | MB_SYSTEMMODAL;
+
+    Tcl_UtfToExternalDString(NULL, message, -1, &messageString);
+    Tcl_UtfToExternalDString(NULL, title, -1, &titleString);
+
     oldMode = Tcl_SetServiceMode(TCL_SERVICE_ALL);
-    code = MessageBox(hWnd, message, title, flags|MB_SYSTEMMODAL);
+    winCode = MessageBox(hWnd, Tcl_DStringValue(&messageString),
+		Tcl_DStringValue(&titleString), flags);
     (void) Tcl_SetServiceMode(oldMode);
 
-    switch (code) {
-      case IDABORT:	result = "abort";  break;
-      case IDCANCEL:	result = "cancel"; break;
-      case IDIGNORE:	result = "ignore"; break;
-      case IDNO:	result = "no";     break;
-      case IDOK:	result = "ok";     break;
-      case IDRETRY:	result = "retry";  break;
-      case IDYES:	result = "yes";    break;
-      default:		result = "";
-    }
-
-    /*
-     * When we come to here interp->result may have been changed by some
-     * background scripts. Call Tcl_SetResult() to make sure that any stuff
-     * lingering in interp->result will not appear in the result of
-     * this command.
-     */
+    Tcl_DStringFree(&messageString);
+    Tcl_DStringFree(&titleString);
 
-    Tcl_SetResult(interp, result, TCL_STATIC);
+    Tcl_SetResult(interp, TkFindStateString(buttonMap, winCode), TCL_STATIC);
     return TCL_OK;
-
-  arg_missing:
-    Tcl_AppendResult(interp, "value for \"", argv[argc-1], "\" missing",
-	NULL);
-    return TCL_ERROR;
 }
-
-/*
- *----------------------------------------------------------------------
- *
- * ProcessCDError --
- *
- *	This procedure gets called if a Windows-specific error message
- *	has occurred during the execution of a common dialog or the
- *	user has pressed the CANCEL button.
- *
- * Results:
- *	If an error has indeed happened, returns a standard TCL result
- *	that reports the error code in string format. If the user has
- *	pressed the CANCEL button (dwErrorCode == 0), resets
- *	interp->result to the empty string.
- *
- * Side effects:
- *	interp->result is changed.
- *
- *----------------------------------------------------------------------
- */
-static int ProcessCDError(interp, dwErrorCode, hWnd)
-    Tcl_Interp * interp;		/* Current interpreter. */
-    DWORD dwErrorCode;			/* The Windows-specific error code */
-    HWND hWnd;				/* window in which the error happened*/
-{
-    char *string;
 
-    Tcl_ResetResult(interp);
+static void 
+SetTkDialog(ClientData clientData)
+{
+    ThreadSpecificData *tsdPtr = (ThreadSpecificData *) 
+            Tcl_GetThreadData(&dataKey, sizeof(ThreadSpecificData));
+    char buf[32];
+    HWND hwnd;
 
-    switch(dwErrorCode) {
-      case 0:	  /* User has hit CANCEL */
-	return TCL_OK;
-
-      case CDERR_DIALOGFAILURE:   string="CDERR_DIALOGFAILURE";  	break;
-      case CDERR_STRUCTSIZE:      string="CDERR_STRUCTSIZE";   		break;
-      case CDERR_INITIALIZATION:  string="CDERR_INITIALIZATION";   	break;
-      case CDERR_NOTEMPLATE:      string="CDERR_NOTEMPLATE";   		break;
-      case CDERR_NOHINSTANCE:     string="CDERR_NOHINSTANCE";   	break;
-      case CDERR_LOADSTRFAILURE:  string="CDERR_LOADSTRFAILURE";   	break;
-      case CDERR_FINDRESFAILURE:  string="CDERR_FINDRESFAILURE";   	break;
-      case CDERR_LOADRESFAILURE:  string="CDERR_LOADRESFAILURE";   	break;
-      case CDERR_LOCKRESFAILURE:  string="CDERR_LOCKRESFAILURE";   	break;
-      case CDERR_MEMALLOCFAILURE: string="CDERR_MEMALLOCFAILURE";   	break;
-      case CDERR_MEMLOCKFAILURE:  string="CDERR_MEMLOCKFAILURE";   	break;
-      case CDERR_NOHOOK:          string="CDERR_NOHOOK";   	 	break;
-      case PDERR_SETUPFAILURE:    string="PDERR_SETUPFAILURE";   	break;
-      case PDERR_PARSEFAILURE:    string="PDERR_PARSEFAILURE";   	break;
-      case PDERR_RETDEFFAILURE:   string="PDERR_RETDEFFAILURE";   	break;
-      case PDERR_LOADDRVFAILURE:  string="PDERR_LOADDRVFAILURE";   	break;
-      case PDERR_GETDEVMODEFAIL:  string="PDERR_GETDEVMODEFAIL";   	break;
-      case PDERR_INITFAILURE:     string="PDERR_INITFAILURE";   	break;
-      case PDERR_NODEVICES:       string="PDERR_NODEVICES";   		break;
-      case PDERR_NODEFAULTPRN:    string="PDERR_NODEFAULTPRN";   	break;
-      case PDERR_DNDMMISMATCH:    string="PDERR_DNDMMISMATCH";   	break;
-      case PDERR_CREATEICFAILURE: string="PDERR_CREATEICFAILURE";   	break;
-      case PDERR_PRINTERNOTFOUND: string="PDERR_PRINTERNOTFOUND";   	break;
-      case CFERR_NOFONTS:         string="CFERR_NOFONTS";   	 	break;
-      case FNERR_SUBCLASSFAILURE: string="FNERR_SUBCLASSFAILURE";   	break;
-      case FNERR_INVALIDFILENAME: string="FNERR_INVALIDFILENAME";   	break;
-      case FNERR_BUFFERTOOSMALL:  string="FNERR_BUFFERTOOSMALL";   	break;
-	
-      default:
-	string="unknown error";
-    }
+    hwnd = (HWND) clientData;
 
-    Tcl_AppendResult(interp, "Win32 internal error: ", string, NULL); 
-    return TCL_ERROR;
+    sprintf(buf, "0x%08x", hwnd);
+    Tcl_SetVar(tsdPtr->debugInterp, "tk_dialog", buf, TCL_GLOBAL_ONLY);
 }