Index: trunk/src/comdlg32/comdlg32.cpp
===================================================================
--- trunk/src/comdlg32/comdlg32.cpp	(revision 4931)
+++ trunk/src/comdlg32/comdlg32.cpp	(revision 4932)
@@ -1,3 +1,3 @@
-/* $Id: comdlg32.cpp,v 1.27 2000-12-30 13:43:57 sandervl Exp $ */
+/* $Id: comdlg32.cpp,v 1.28 2001-01-11 18:05:02 sandervl Exp $ */
 
 /*
@@ -41,420 +41,4 @@
   a->hwndOwner = Win32ToOS2Handle(a->hwndOwner);
 
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(BOOL, GetSaveFileNameA,
-              LPOPENFILENAMEA, lpofn)
-{
-  return GetFileDialog95A(lpofn, SAVE_DIALOG);
-}
-
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(BOOL, GetSaveFileNameW,
-              LPOPENFILENAMEW, lpofn)
-{
-  return GetFileDialog95W(lpofn, SAVE_DIALOG);
-}
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(BOOL, GetOpenFileNameA,
-              LPOPENFILENAMEA, lpofn)
-{
-  return GetFileDialog95A(lpofn, OPEN_DIALOG);
-}
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(BOOL, GetOpenFileNameW,
-              LPOPENFILENAMEW, lpofn)
-{
-  return GetFileDialog95W(lpofn, OPEN_DIALOG);
-}
-
-#if 0
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION3(INT16, GetFileTitleA32,
-              LPCSTR, lpFile,
-              LPSTR, lpTitle,
-              UINT, cbBuf)
-{
-  return O32_GetFileTitle(lpFile,
-                          lpTitle,
-                          cbBuf);
-}
-
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(BOOL, ChooseColorA,
-              LPCHOOSECOLORA, lpcc)
-{
-
-  COMDLG32_CHECKHOOK(lpcc, CC_ENABLEHOOK, LPCCHOOKPROC)
-
-  return O32_ChooseColor(lpcc);
-}
-
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    : casting is a little hot, should work however
- *             assuming lpcc->lpTemplateName is READONLY pointer!
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(BOOL, ChooseColorW,
-              LPCHOOSECOLORW, lpcc)
-{
-  BOOL            bResult;
-  LPCWSTR         lpTemplateNameBackup = lpcc->lpTemplateName;
-
-  // if no template is to convert, we can take this shortcut
-  if (!(lpcc->Flags & CC_ENABLETEMPLATE))
-    return O32_ChooseColor( (LPCHOOSECOLORA)lpcc );
-
-
-  // convert to ASCII string
-  if (lpcc->lpTemplateName != NULL)
-    lpcc->lpTemplateName = (LPCWSTR)UnicodeToAsciiString((WCHAR*)lpcc->lpTemplateName);
-
-  COMDLG32_CHECKHOOK(lpcc, CC_ENABLEHOOK, LPCCHOOKPROC)
-
-  bResult = O32_ChooseColor((LPCHOOSECOLORA)lpcc);  // call ASCII version
-
-  // free temporary ASCII string and restore UNICODE string
-  if (lpcc->lpTemplateName != NULL)
-  {
-    FreeAsciiString((char*)lpcc->lpTemplateName);
-    lpcc->lpTemplateName = lpTemplateNameBackup;
-  }
-
-  return bResult;
-}
-
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(BOOL, ChooseFontA,
-              LPCHOOSEFONTA, lpcf)
-{
-
-  COMDLG32_CHECKHOOK(lpcf, CF_ENABLEHOOK, WNDPROC)
-
-  return O32_ChooseFont(lpcf);
-}
-
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    : unknown yet, what is INPUT and what is OUTPUT string
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *             Edgar Buerkle  [Mon, 1999/06/28 19:35]
- *****************************************************************************/
-
-ODINFUNCTION1(BOOL, ChooseFontW,
-              LPCHOOSEFONTW, lpcf)
-{
-  BOOL            bResult;
-  CHOOSEFONTA     asciicf;
-  LOGFONTA        asciilf;
-  char            szAsciiStyle[64];
-
-  // NOTE: LOGFONTW/A is NOT converted !
-  dprintf(("COMDLG32: ChooseFontW not correctly implemented.\n"));
-
-  if (!lpcf)
-  {
-    SetLastError(ERROR_INVALID_PARAMETER);
-
-    return FALSE;
-  }
-
-  // convert to ASCII string
-  memcpy(&asciicf,     // make binary copy of CHOOSEFONTW
-         lpcf,         // to save the flags
-         sizeof(asciicf));
-
-  memcpy (&asciilf,
-          lpcf->lpLogFont,
-          sizeof(LOGFONTA));
-
-  asciicf.lpLogFont = &asciilf; // update pointer
-
-  // lpTemplatenName bug in open32 ?  This doesn't work.
-  // TODO: CF_ENABLETEMPLATEHANDLE
-  if (lpcf->Flags & CF_ENABLETEMPLATE)
-    if((int)asciicf.lpTemplateName >> 16 != 0)
-      asciicf.lpTemplateName = UnicodeToAsciiString((LPWSTR)lpcf->lpTemplateName);
-
-  //CB: NT's clock.exe traps here!
-  if (lpcf->lpszStyle)
-  {
-    UnicodeToAsciiN(lpcf->lpszStyle,
-                    szAsciiStyle,
-                    sizeof(szAsciiStyle));
-
-    asciicf.lpszStyle = szAsciiStyle;
-  }
-
-  UnicodeToAsciiN(lpcf->lpLogFont->lfFaceName,
-                  asciilf.lfFaceName,
-                  LF_FACESIZE-1);
-
-  // LPCFHOOKPROC != WNDPROC ?
-  COMDLG32_CHECKHOOK((&asciicf), CF_ENABLEHOOK, WNDPROC)
-
-  // switch strings
-  bResult = O32_ChooseFont((LPCHOOSEFONTA)&asciicf);        // call ASCII version
-
-  if (bResult)
-  {
-    // transfer BACK resulting strings !!!
-    AsciiToUnicodeN(asciicf.lpLogFont->lfFaceName,
-                    lpcf->lpLogFont->lfFaceName,
-                    LF_FACESIZE-1);
-
-    if (lpcf->lpszStyle) AsciiToUnicode(asciicf.lpszStyle,lpcf->lpszStyle);
-  }
-
-  if (lpcf->Flags & CF_ENABLETEMPLATE)
-    if((int)asciicf.lpTemplateName >> 16 != 0)
-      FreeAsciiString((char*)asciicf.lpTemplateName);
-
-  // copy back fields
-  lpcf->Flags = asciicf.Flags;
-
-  return bResult;
-}
-
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION0(DWORD, CommDlgExtendedError32)
-{
-  return O32_CommDlgExtendedError();
-}
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(HWND, FindTextA32,
-              LPFINDREPLACEA, lpfr)
-{
-
-  COMDLG32_CHECKHOOK(lpfr, FR_ENABLEHOOK, WNDPROC)
-
-  return O32_FindText(lpfr);
-}
-
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(HWND, FindTextW32,
-              LPFINDREPLACEW, lpfr)
-{
-  BOOL            bResult;
-  FINDREPLACEA    fr;
-
-  memcpy(&fr,          // make binary copy first to save all the fields
-         lpfr,
-         sizeof(fr));
-
-    // convert to ASCII string
-  if ((lpfr->Flags & FR_ENABLETEMPLATE) &&
-      (lpfr->lpTemplateName != NULL))
-    fr.lpTemplateName = UnicodeToAsciiString((WCHAR*)lpfr->lpTemplateName);
-  else
-    fr.lpTemplateName = NULL;
-
-  if (lpfr->lpstrFindWhat != NULL)
-    fr.lpstrFindWhat = UnicodeToAsciiString((WCHAR*)lpfr->lpstrFindWhat);
-
-  if (lpfr->lpstrReplaceWith != NULL)
-    fr.lpstrReplaceWith = UnicodeToAsciiString((WCHAR*)lpfr->lpstrReplaceWith);
-
-
-  COMDLG32_CHECKHOOK((&fr), FR_ENABLEHOOK, WNDPROC)
-
-  bResult = O32_FindText(&fr);                         // call ASCII version
-
-  // @@@PH: Note -- we might have to transfer BACK resulting strings !!!
-  // free temporary ASCII string and restore UNICODE string
-  if (fr.lpTemplateName != NULL)
-    FreeAsciiString((char*)fr.lpTemplateName);
-
-  // free temporary ASCII string and restore UNICODE string
-  if (fr.lpstrFindWhat != NULL)
-  {
-    AsciiToUnicode(fr.lpstrFindWhat,
-                   lpfr->lpstrFindWhat);
-
-    FreeAsciiString((char*)fr.lpstrFindWhat);
-  }
-
-  if (fr.lpstrReplaceWith != NULL)
-  {
-    AsciiToUnicode(fr.lpstrReplaceWith,
-                   lpfr->lpstrReplaceWith);
-
-    FreeAsciiString((char*)fr.lpstrReplaceWith);
-  }
-
-  // copy back fields
-  lpfr->Flags = fr.Flags;
-
-  return bResult;
-}
-
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION3(INT16, GetFileTitleW32,
-              LPCWSTR, lpFile,
-              LPWSTR, lpTitle,
-              UINT, cbBuf)
-{
-  LPSTR lpFileBackup;
-  char  szTitle[256];
-  INT16 iResult;
-
-  lpFileBackup = UnicodeToAsciiString((LPWSTR)lpFile);
-  iResult      = O32_GetFileTitle(lpFileBackup,
-                                  szTitle,
-                                  cbBuf);
-
-  FreeAsciiString(lpFileBackup);
-
-  // transform result into Unicode
-  AsciiToUnicode(szTitle,
-                 lpTitle);
-
-  return iResult;
-}
-#endif
 
 /*****************************************************************************
@@ -538,99 +122,4 @@
 
 
-#if 0
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(HWND, ReplaceTextA32,
-              LPFINDREPLACEA, lpfr)
-{
-
-  COMDLG32_CHECKHOOK(lpfr, FR_ENABLEHOOK, WNDPROC)
-
-  return O32_ReplaceText(lpfr);
-}
-
-
-/*****************************************************************************
- * Name      :
- * Purpose   :
- * Parameters:
- * Variables :
- * Result    :
- * Remark    :
- * Status    :
- *
- * Author    : Patrick Haller [Tue, 1998/02/10 01:55]
- *****************************************************************************/
-
-ODINFUNCTION1(HWND, ReplaceTextW32,
-              LPFINDREPLACEW, lpfr)
-{
-  BOOL            bResult;
-  FINDREPLACEA    fr;
-
-  dprintf(("COMDLG32: ReplaceTextW(%08xh)\n",
-           lpfr));
-
-  memcpy(&fr,          // make binary copy first to save all the fields
-         lpfr,
-         sizeof(fr));
-
-    // convert to ASCII string
-  if ((lpfr->Flags & FR_ENABLETEMPLATE) &&
-      (lpfr->lpTemplateName != NULL))
-    fr.lpTemplateName = UnicodeToAsciiString((WCHAR*)lpfr->lpTemplateName);
-  else
-    fr.lpTemplateName = NULL;
-
-  if (lpfr->lpstrFindWhat != NULL)
-    fr.lpstrFindWhat = UnicodeToAsciiString((WCHAR*)lpfr->lpstrFindWhat);
-
-  if (lpfr->lpstrReplaceWith != NULL)
-    fr.lpstrReplaceWith = UnicodeToAsciiString((WCHAR*)lpfr->lpstrReplaceWith);
-
-
-  COMDLG32_CHECKHOOK((&fr), FR_ENABLEHOOK, WNDPROC)
-
-  bResult = O32_ReplaceText(&fr);                         // call ASCII version
-
-  // @@@PH: Note -- we might have to transfer BACK resulting strings !!!
-  // free temporary ASCII string and restore UNICODE string
-  if (fr.lpTemplateName != NULL)
-    FreeAsciiString((char*)fr.lpTemplateName);
-
-  // free temporary ASCII string and restore UNICODE string
-  if (fr.lpstrFindWhat != NULL)
-  {
-    AsciiToUnicode(fr.lpstrFindWhat,
-                   lpfr->lpstrFindWhat);
-
-    FreeAsciiString((char*)fr.lpstrFindWhat);
-  }
-
-  if (fr.lpstrReplaceWith != NULL)
-  {
-    AsciiToUnicode(fr.lpstrReplaceWith,
-                   lpfr->lpstrReplaceWith);
-
-    FreeAsciiString((char*)fr.lpstrReplaceWith);
-  }
-
-  // copy back fields
-  lpfr->Flags = fr.Flags;
-
-  return bResult;
-}
-#endif
-
 /*****************************************************************************
  * Name      :
Index: trunk/src/comdlg32/filedlg.c
===================================================================
--- trunk/src/comdlg32/filedlg.c	(revision 4932)
+++ trunk/src/comdlg32/filedlg.c	(revision 4932)
@@ -0,0 +1,1761 @@
+/*
+ * COMMDLG - File Dialogs
+ *
+ * Copyright 1994 Martin Ayotte
+ * Copyright 1996 Albrecht Kleine
+ */
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "windef.h"
+#include "winnls.h"
+#include "winbase.h"
+#include "wingdi.h"
+#include "wine/winbase16.h"
+#include "wine/winuser16.h"
+#include "wine/unicode.h"
+#include "heap.h"
+#include "commdlg.h"
+#include "debugtools.h"
+#include "cderr.h"
+
+#ifdef __WIN32OS2__
+#include <win\cursoricon.h>
+
+#define GlobalFree16 GlobalFree
+#define GlobalLock16 GlobalLock
+#define GlobalUnlock16 GlobalUnlock
+#define GlobalAlloc16	GlobalAlloc
+#define FreeResource16	FreeResource
+#define LoadResource16  LoadResourceA
+#define FindResource16  FindResourceA
+#define MapSL(a)	a
+#define CallWindowProc16 CallWindowProcA
+
+#endif
+
+DEFAULT_DEBUG_CHANNEL(commdlg);
+
+#include "cdlg.h"
+
+#define BUFFILE 512
+#define BUFFILEALLOC 512 * sizeof(WCHAR)   
+
+struct FSPRIVATE 
+{
+    HWND hwnd; /* file dialog window handle */
+    BOOL hook; /* TRUE if the dialog is hooked */
+    UINT lbselchstring; /* registered message id */
+    UINT fileokstring; /* registered message id */
+    LPARAM lParam; /* save original lparam */
+#ifdef __WIN32OS2__
+    HANDLE hDlgTmpl16; /* handle for resource 16 */
+    HANDLE hResource16; /* handle for allocated resource 16 */
+    HANDLE hGlobal16; /* 16 bits mem block (resources) */
+#else
+    HANDLE16 hDlgTmpl16; /* handle for resource 16 */
+    HANDLE16 hResource16; /* handle for allocated resource 16 */
+    HANDLE16 hGlobal16; /* 16 bits mem block (resources) */
+#endif
+    LPCVOID template; /* template for 32 bits resource */
+    BOOL open; /* TRUE if open dialog, FALSE if save dialog */
+    OPENFILENAMEW *ofnW; /* original structure or work struct */
+    OPENFILENAMEA *ofnA; /* original structure if 32bits ansi dialog */
+#ifndef __WIN32OS2__
+    OPENFILENAME16 *ofn16; /* original structure if 16 bits dialog */
+#endif
+};
+
+
+#define LFSPRIVATE struct FSPRIVATE *
+
+#define LFS16 1
+#define LFS32A 2
+#define LFS32W 3
+ 
+static const WCHAR FILE_star[] = {'*','.','*', 0};
+static const WCHAR FILE_bslash[] = {'\\', 0};
+static const WCHAR FILE_specc[] = {'%','c',':', 0};
+
+#ifdef __WIN32OS2__
+static HICON hFolder = 0;
+static HICON hFolder2 = 0;
+static HICON hFloppy = 0;
+static HICON hHDisk = 0;
+static HICON hCDRom = 0;
+static HICON hNet = 0;
+#else
+static HICON16 hFolder = 0;
+static HICON16 hFolder2 = 0;
+static HICON16 hFloppy = 0;
+static HICON16 hHDisk = 0;
+static HICON16 hCDRom = 0;
+static HICON16 hNet = 0;
+#endif
+static int fldrHeight = 0;
+static int fldrWidth = 0;
+
+#define OFN_PROP "FILEDLG_OFN"
+
+static const char defaultfilter[]=" \0\0";
+static char defaultopen[]="Open File";
+static char defaultsave[]="Save as";
+
+/***********************************************************************
+ *
+ * Windows 3.1 style OpenFileName/SaveFileName dialog
+ *
+ */
+
+LRESULT WINAPI FileOpenDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
+				 LPARAM lParam);
+LRESULT WINAPI FileSaveDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
+				 LPARAM lParam);
+
+static LRESULT WINAPI FileOpenDlgProc(HWND hDlg, UINT msg,
+                                      WPARAM wParam, LPARAM lParam);
+
+/***********************************************************************
+ * 				FileDlg_Init			[internal]
+ */
+static BOOL FileDlg_Init(void)
+{
+    static BOOL initialized = 0;
+    CURSORICONINFO *fldrInfo;
+    
+    if (!initialized) {
+	if (!hFolder) hFolder = LoadIconA(0, MAKEINTRESOURCEA(OIC_FOLDER));
+	if (!hFolder2) hFolder2 = LoadIconA(0, MAKEINTRESOURCEA(OIC_FOLDER2));
+	if (!hFloppy) hFloppy = LoadIconA(0, MAKEINTRESOURCEA(OIC_FLOPPY));
+	if (!hHDisk) hHDisk = LoadIconA(0, MAKEINTRESOURCEA(OIC_HDISK));
+	if (!hCDRom) hCDRom = LoadIconA(0, MAKEINTRESOURCEA(OIC_CDROM));
+	if (!hNet) hNet = LoadIconA(0, MAKEINTRESOURCEA(OIC_NETWORK));
+	if (hFolder == 0 || hFolder2 == 0 || hFloppy == 0 || 
+	    hHDisk == 0 || hCDRom == 0 || hNet == 0)
+	{
+	    ERR("Error loading icons !\n");
+	    return FALSE;
+	}
+	fldrInfo = (CURSORICONINFO *) GlobalLock16( hFolder2 );
+	if (!fldrInfo)
+	{	
+	    ERR("Error measuring icons !\n");
+	    return FALSE;
+	}
+	fldrHeight = fldrInfo -> nHeight;
+	fldrWidth = fldrInfo -> nWidth;
+	GlobalUnlock16( hFolder2 );
+	initialized = TRUE;
+    }
+    return TRUE;
+}
+
+
+/***********************************************************************
+ *           Get32BitsTemplate                                  [internal]
+ *
+ * Get a template (or FALSE if failure) when 16 bits dialogs are used
+ * by a 32 bits application
+ *
+ */
+BOOL Get32BitsTemplate(LFSPRIVATE lfs)
+{
+    LPOPENFILENAMEW ofnW = lfs->ofnW;
+    HANDLE hDlgTmpl;
+
+    if (ofnW->Flags & OFN_ENABLETEMPLATEHANDLE)
+    {
+	if (!(lfs->template = LockResource( ofnW->hInstance )))
+	{
+	    COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
+	    return FALSE;
+	}
+    }
+    else if (ofnW->Flags & OFN_ENABLETEMPLATE)
+    {
+	HANDLE hResInfo;
+        if (lfs->ofnA)
+	    hResInfo = FindResourceA(lfs->ofnA->hInstance,
+				 lfs->ofnA->lpTemplateName,
+                                 RT_DIALOGA);
+        else
+	    hResInfo = FindResourceW(ofnW->hInstance,
+				 ofnW->lpTemplateName,
+                                 RT_DIALOGW);
+        if (!hResInfo)
+	{
+	    COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
+	    return FALSE;
+	}
+	if (!(hDlgTmpl = LoadResource(ofnW->hInstance,
+				hResInfo)) ||
+		    !(lfs->template = LockResource(hDlgTmpl)))
+	{
+	    COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
+	    return FALSE;
+	}
+    } else { /* get it from internal Wine resource */
+	HANDLE hResInfo;
+	if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, 
+             lfs->open? "OPEN_FILE":"SAVE_FILE", RT_DIALOGA)))
+	{
+	    COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
+	    return FALSE;
+        }
+        if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
+                !(lfs->template = LockResource( hDlgTmpl )))
+        {
+            COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
+            return FALSE;
+        }
+    }
+    return TRUE;
+}
+
+#ifndef __WIN32OS2__
+/***********************************************************************
+ *           Get16BitsTemplate                                [internal]
+ *
+ * Get a template (FALSE if failure) when 16 bits dialogs are used
+ * by a 16 bits application
+ *
+ */
+BOOL Get16BitsTemplate(LFSPRIVATE lfs)
+{
+    LPOPENFILENAME16 ofn16 = lfs->ofn16;
+    LPCVOID template;
+    HGLOBAL16 hGlobal16 = 0;
+
+    if (ofn16->Flags & OFN_ENABLETEMPLATEHANDLE)
+        lfs->hDlgTmpl16 = ofn16->hInstance;
+    else if (ofn16->Flags & OFN_ENABLETEMPLATE)
+    {
+	HANDLE16 hResInfo;
+	if (!(hResInfo = FindResource16(ofn16->hInstance,
+					MapSL(ofn16->lpTemplateName),
+                                        RT_DIALOGA)))
+	{
+	    COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
+	    return FALSE;
+	}
+	if (!(lfs->hDlgTmpl16 = LoadResource16( ofn16->hInstance, hResInfo )))
+	{
+	    COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
+	    return FALSE;
+	}
+        lfs->hResource16 = lfs->hDlgTmpl16;
+    }
+    else
+    { /* get resource from (32 bits) own Wine resource; convert it to 16 */
+	HANDLE hResInfo, hDlgTmpl32;
+        LPCVOID template32;
+        DWORD size;
+
+	if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, 
+               lfs->open ? "OPEN_FILE":"SAVE_FILE", RT_DIALOGA)))
+	{
+	    COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
+	    return FALSE;
+	}
+	if (!(hDlgTmpl32 = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
+	    !(template32 = LockResource( hDlgTmpl32 )))
+	{
+	    COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
+	    return FALSE;
+	}
+        size = SizeofResource(GetModuleHandleA("COMDLG32"), hResInfo);
+        hGlobal16 = GlobalAlloc16(0, size);
+        if (!hGlobal16)
+        {
+            COMDLG32_SetCommDlgExtendedError(CDERR_MEMALLOCFAILURE);
+            ERR("alloc failure for %ld bytes\n", size);
+            return FALSE;
+        }
+        template = GlobalLock16(hGlobal16);
+        if (!template)
+        {
+            COMDLG32_SetCommDlgExtendedError(CDERR_MEMLOCKFAILURE);
+            ERR("global lock failure for %x handle\n", hGlobal16);
+            GlobalFree16(hGlobal16);
+            return FALSE;
+        }
+        ConvertDialog32To16((LPVOID)template32, size, (LPVOID)template);
+        lfs->hDlgTmpl16 = hGlobal16;
+        lfs->hGlobal16 = hGlobal16;
+    }
+    return TRUE;
+}
+#endif
+
+/***********************************************************************
+ *                              FILEDLG_StripEditControl        [internal]
+ * Strip pathnames off the contents of the edit control.
+ */
+static void FILEDLG_StripEditControl(HWND hwnd)
+{
+    WCHAR temp[BUFFILE], *cp;
+
+    GetDlgItemTextW( hwnd, edt1, temp, sizeof(temp)/sizeof(WCHAR));
+    cp = strrchrW(temp, '\\');
+    if (cp != NULL) {
+	strcpyW(temp, cp+1);
+    }
+    cp = strrchrW(temp, ':');
+    if (cp != NULL) {
+	strcpyW(temp, cp+1);
+    }
+    /* FIXME: shouldn't we do something with the result here? ;-) */
+}
+
+
+
+/***********************************************************************
+ *                              FILEDLG_CallWindowProc          [internal]
+ *
+ *      Call the appropriate hook
+ */
+static BOOL FILEDLG_CallWindowProc(LFSPRIVATE lfs, UINT wMsg, WPARAM wParam,
+                                   LPARAM lParam)
+{
+#ifndef __WIN32OS2__
+    if (lfs->ofn16)
+    {
+        return (BOOL16) CallWindowProc16(
+          (WNDPROC16)lfs->ofn16->lpfnHook, lfs->hwnd,
+          (UINT16)wMsg, (WPARAM16)wParam, lParam);
+    }
+#endif
+    if (lfs->ofnA)
+    {
+        return (BOOL) CallWindowProcA(
+          (WNDPROC)lfs->ofnA->lpfnHook, lfs->hwnd,
+          wMsg, wParam, lParam);
+    }
+
+    if (lfs->ofnW)
+    {
+        return (BOOL) CallWindowProcW(
+          (WNDPROC)lfs->ofnW->lpfnHook, lfs->hwnd,
+          wMsg, wParam, lParam);
+    }
+    return FALSE;
+}
+
+
+/***********************************************************************
+ * 				FILEDLG_ScanDir                 [internal]
+ */
+static BOOL FILEDLG_ScanDir(HWND hWnd, LPWSTR newPath)
+{
+    WCHAR		buffer[BUFFILE];
+    HWND 		hdlg, hdlgDir;
+    LRESULT             lRet = TRUE;
+    HCURSOR             hCursorWait, oldCursor;
+
+    if  ( !SetCurrentDirectoryW( newPath ))
+        return FALSE;
+    lstrcpynW(buffer, newPath, sizeof(buffer)/sizeof(WCHAR));
+
+    /* get the list of spec files */
+    GetDlgItemTextW(hWnd, edt1, buffer, sizeof(buffer)/sizeof(WCHAR));
+
+    hCursorWait = LoadCursorA(0, IDC_WAITA);
+    oldCursor = SetCursor(hCursorWait);
+
+    /* list of files */
+    if ((hdlg = GetDlgItem(hWnd, lst1)) != 0) {
+        WCHAR*	scptr; /* ptr on semi-colon */
+	WCHAR*	filter = buffer;
+
+	TRACE("Using filter %s\n", debugstr_w(filter));
+	SendMessageW(hdlg, LB_RESETCONTENT, 0, 0);
+	while (filter) {
+	    scptr = strchrW(filter, ';');
+	    if (scptr)	*scptr = 0;
+            while (*filter == ' ') filter++;
+	    TRACE("Using file spec %s\n", debugstr_w(filter));
+	    if (SendMessageW(hdlg, LB_DIR, 0, (LPARAM)filter) == LB_ERR)
+	        return FALSE;
+	    if (scptr) *scptr = ';';
+	        filter = (scptr) ? (scptr + 1) : 0;
+	 }
+    }
+
+    /* list of directories */
+    strcpyW(buffer, FILE_star);
+
+    if ((hdlgDir = GetDlgItem(hWnd, lst2)) != 0) {
+        lRet = DlgDirListW(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY);
+    }
+    SetCursor(oldCursor);
+    return lRet;
+}
+
+
+/***********************************************************************
+ * 				FILEDLG_GetFileType		[internal]
+ */
+
+static LPWSTR FILEDLG_GetFileType(LPWSTR cfptr, LPWSTR fptr, WORD index)
+{
+  int n, i;
+  i = 0;
+  if (cfptr)
+    for ( ;(n = lstrlenW(cfptr)) != 0; i++) 
+      {
+	cfptr += n + 1;
+	if (i == index)
+	  return cfptr;
+	cfptr += lstrlenW(cfptr) + 1;
+      }
+  if (fptr)
+    for ( ;(n = lstrlenW(fptr)) != 0; i++) 
+      {
+	fptr += n + 1;
+	if (i == index)
+	  return fptr;
+	fptr += lstrlenW(fptr) + 1;
+    }
+  return (LPWSTR) FILE_star; /* FIXME */
+}
+
+/***********************************************************************
+ *                              FILEDLG_WMDrawItem              [internal]
+ */
+static LONG FILEDLG_WMDrawItem(HWND hWnd, WPARAM wParam, LPARAM lParam,
+       int savedlg, LPDRAWITEMSTRUCT lpdis)
+{
+    WCHAR *str;
+    HICON hIcon;
+    COLORREF oldText = 0, oldBk = 0;
+
+    if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst1)
+    {
+        if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC))) return FALSE;
+	SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID, 
+                      (LPARAM)str);
+
+	if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
+	{
+	    oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
+	    oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
+	}
+	if (savedlg)
+	    SetTextColor(lpdis->hDC,GetSysColor(COLOR_GRAYTEXT) );
+
+	ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + 1,
+                  lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
+                  &(lpdis->rcItem), str, lstrlenW(str), NULL);
+
+	if (lpdis->itemState & ODS_SELECTED)
+	    DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
+
+	if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
+	{
+	    SetBkColor( lpdis->hDC, oldBk );
+	    SetTextColor( lpdis->hDC, oldText );
+	}
+        HeapFree(GetProcessHeap(), 0, str);
+	return TRUE;
+    }
+
+    if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst2)
+    {
+        if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
+            return FALSE;
+	SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID, 
+                      (LPARAM)str);
+
+	if (lpdis->itemState & ODS_SELECTED)
+	{
+	    oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
+	    oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
+	}
+	ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
+                  lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
+                  &(lpdis->rcItem), str, lstrlenW(str), NULL);
+
+	if (lpdis->itemState & ODS_SELECTED)
+	    DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
+
+	if (lpdis->itemState & ODS_SELECTED)
+	{
+	    SetBkColor( lpdis->hDC, oldBk );
+	    SetTextColor( lpdis->hDC, oldText );
+	}
+	DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hFolder);
+        HeapFree(GetProcessHeap(), 0, str);
+	return TRUE;
+    }
+    if (lpdis->CtlType == ODT_COMBOBOX && lpdis->CtlID == cmb2)
+    {
+        char root[] = "a:";
+        if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
+            return FALSE;
+	SendMessageW(lpdis->hwndItem, CB_GETLBTEXT, lpdis->itemID, 
+                      (LPARAM)str);
+        root[0] += str[2] - 'a';
+        switch(GetDriveTypeA(root))
+        {
+        case DRIVE_REMOVABLE: hIcon = hFloppy; break;
+        case DRIVE_CDROM:     hIcon = hCDRom; break;
+        case DRIVE_REMOTE:    hIcon = hNet; break;
+        case DRIVE_FIXED:
+        default:           hIcon = hHDisk; break;
+        }
+	if (lpdis->itemState & ODS_SELECTED)
+	{
+	    oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
+	    oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
+	}
+	ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
+                  lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
+                  &(lpdis->rcItem), str, lstrlenW(str), NULL);
+
+	if (lpdis->itemState & ODS_SELECTED)
+	{
+	    SetBkColor( lpdis->hDC, oldBk );
+	    SetTextColor( lpdis->hDC, oldText );
+	}
+	DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hIcon);
+        HeapFree(GetProcessHeap(), 0, str);
+	return TRUE;
+    }
+    return FALSE;
+}
+
+/***********************************************************************
+ *                              FILEDLG_WMMeasureItem           [internal]
+ */
+static LONG FILEDLG_WMMeasureItem(HWND hWnd, WPARAM wParam, LPARAM lParam) 
+{
+    LPMEASUREITEMSTRUCT lpmeasure;
+    
+    lpmeasure = (LPMEASUREITEMSTRUCT)lParam;
+    lpmeasure->itemHeight = fldrHeight;
+    return TRUE;
+}
+/***********************************************************************
+ *                              FILEDLG_WMMeasureItem16         [internal]
+ */
+#ifdef __WIN32OS2__
+static LONG FILEDLG_WMMeasureItem16(HWND hWnd, WPARAM wParam, LPARAM lParam) 
+{
+    LPMEASUREITEMSTRUCT lpmeasure;
+    
+    lpmeasure = (LPMEASUREITEMSTRUCT)lParam;
+    lpmeasure->itemHeight = fldrHeight;
+    return TRUE;
+}
+#else
+static LONG FILEDLG_WMMeasureItem16(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam) 
+{
+    LPMEASUREITEMSTRUCT16 lpmeasure;
+    
+    lpmeasure = MapSL(lParam);
+    lpmeasure->itemHeight = fldrHeight;
+    return TRUE;
+}
+#endif
+
+/***********************************************************************
+ *                              FILEDLG_WMInitDialog            [internal]
+ */
+
+static LONG FILEDLG_WMInitDialog(HWND hWnd, WPARAM wParam, LPARAM lParam)
+{
+  int i, n;
+  WCHAR tmpstr[BUFFILE];
+  LPWSTR pstr, old_pstr;
+  LPOPENFILENAMEW ofn;
+  LFSPRIVATE lfs = (LFSPRIVATE) lParam;
+
+  if (!lfs) return FALSE;
+  SetPropA(hWnd, OFN_PROP, (HANDLE)lfs);
+  lfs->hwnd = hWnd;
+  ofn = lfs->ofnW;
+
+  TRACE("flags=%lx initialdir=%s\n", ofn->Flags, debugstr_w(ofn->lpstrInitialDir));
+
+  SetWindowTextW( hWnd, ofn->lpstrTitle );
+  /* read custom filter information */
+  if (ofn->lpstrCustomFilter)
+    {
+      pstr = ofn->lpstrCustomFilter;
+      n = 0;
+      TRACE("lpstrCustomFilter = %p\n", pstr);
+      while(*pstr)
+	{
+	  old_pstr = pstr;
+          i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
+                                   (LPARAM)(ofn->lpstrCustomFilter) + n );
+          n += lstrlenW(pstr) + 1;
+	  pstr += lstrlenW(pstr) + 1;
+	  TRACE("add str='%s' "
+	  "associated to '%s'\n", debugstr_w(old_pstr), debugstr_w(pstr));
+          SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
+          n += lstrlenW(pstr) + 1;
+	  pstr += lstrlenW(pstr) + 1;
+	}
+    }
+  /* read filter information */
+  if (ofn->lpstrFilter) {
+	pstr = (LPWSTR) ofn->lpstrFilter;
+	n = 0;
+	while(*pstr) {
+	  old_pstr = pstr;
+	  i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
+				       (LPARAM)(ofn->lpstrFilter + n) );
+	  n += lstrlenW(pstr) + 1;
+	  pstr += lstrlenW(pstr) + 1;
+	  TRACE("add str='%s' "
+		  "associated to '%s'\n", debugstr_w(old_pstr), debugstr_w(pstr));
+	  SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
+	  n += lstrlenW(pstr) + 1;
+	  pstr += lstrlenW(pstr) + 1;
+	}
+  }
+  /* set default filter */
+  if (ofn->nFilterIndex == 0 && ofn->lpstrCustomFilter == NULL)
+  	ofn->nFilterIndex = 1;
+  SendDlgItemMessageW(hWnd, cmb1, CB_SETCURSEL, ofn->nFilterIndex - 1, 0);    
+  lstrcpynW(tmpstr, FILEDLG_GetFileType(ofn->lpstrCustomFilter,
+	     (LPWSTR)ofn->lpstrFilter, ofn->nFilterIndex - 1),BUFFILE);
+  TRACE("nFilterIndex = %ld, SetText of edt1 to '%s'\n", 
+  			ofn->nFilterIndex, debugstr_w(tmpstr));
+  SetDlgItemTextW( hWnd, edt1, tmpstr );
+  /* get drive list */
+  *tmpstr = 0;
+  DlgDirListComboBoxW(hWnd, tmpstr, cmb2, 0, DDL_DRIVES | DDL_EXCLUSIVE);
+  /* read initial directory */
+  if (ofn->lpstrInitialDir != NULL) 
+    {
+      int len;
+      lstrcpynW(tmpstr, ofn->lpstrInitialDir, 511);
+      len = lstrlenW(tmpstr);
+      if (len > 0 && tmpstr[len-1] != '\\'  && tmpstr[len-1] != ':') {
+        tmpstr[len]='\\';
+        tmpstr[len+1]='\0';
+      }
+    }
+  else
+    *tmpstr = 0;
+  if (!FILEDLG_ScanDir(hWnd, tmpstr)) {
+    *tmpstr = 0;
+    if (!FILEDLG_ScanDir(hWnd, tmpstr))
+      WARN("Couldn't read initial directory %s!\n", debugstr_w(tmpstr));
+  }
+  /* select current drive in combo 2, omit missing drives */
+  {
+      char dir[MAX_PATH];
+      char str[4] = "a:\\";
+      GetCurrentDirectoryA( sizeof(dir), dir );
+      for(i = 0, n = -1; i < 26; i++)
+      {
+          str[0] = 'a' + i;
+          if (GetDriveTypeA(str) <= DRIVE_NO_ROOT_DIR) n++;
+          if (toupper(str[0]) == toupper(dir[0])) break;
+      }
+  }
+  SendDlgItemMessageW(hWnd, cmb2, CB_SETCURSEL, n, 0);
+  if (!(ofn->Flags & OFN_SHOWHELP))
+    ShowWindow(GetDlgItem(hWnd, pshHelp), SW_HIDE);
+  if (ofn->Flags & OFN_HIDEREADONLY)
+    ShowWindow(GetDlgItem(hWnd, chx1), SW_HIDE);
+  if (lfs->hook)
+      return (BOOL) FILEDLG_CallWindowProc(lfs, WM_INITDIALOG, wParam, lfs->lParam);
+  return TRUE;
+}
+
+/***********************************************************************
+ *                              FILEDLG_UpdateResult            [internal]
+ *      update the displayed file name (with path) 
+ */
+void FILEDLG_UpdateResult(LFSPRIVATE lfs, WCHAR *tmpstr)
+{
+    int lenstr2;
+    LPOPENFILENAMEW ofnW = lfs->ofnW;
+    WCHAR tmpstr2[BUFFILE];
+
+    GetCurrentDirectoryW(BUFFILE, tmpstr2);
+    lenstr2 = strlenW(tmpstr2);
+    if (lenstr2 > 3)
+        tmpstr2[lenstr2++]='\\';
+    lstrcpynW(tmpstr2+lenstr2, tmpstr, BUFFILE-lenstr2);
+    if (ofnW->lpstrFile)
+        lstrcpynW(ofnW->lpstrFile, tmpstr2, ofnW->nMaxFile);
+    ofnW->nFileOffset = strrchrW(tmpstr2,'\\') - tmpstr2 +1;
+    ofnW->nFileExtension = 0;
+    while(tmpstr2[ofnW->nFileExtension] != '.' && tmpstr2[ofnW->nFileExtension] != '\0')
+        ofnW->nFileExtension++;
+    if (tmpstr2[ofnW->nFileExtension] == '\0')
+        ofnW->nFileExtension = 0;
+    else
+        ofnW->nFileExtension++;
+    /* update the real client structures if any */
+#ifndef __WIN32OS2__
+    if (lfs->ofn16)
+    { /* we have to convert to short (8.3) path */
+	char tmp[1024]; /* MAX_PATHNAME_LEN */
+	LPOPENFILENAME16 ofn16 = lfs->ofn16;
+        char *dest = MapSL(ofn16->lpstrFile);
+        if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFile, -1,
+                                  tmp, ofnW->nMaxFile, NULL, NULL ))
+            tmp[ofnW->nMaxFile-1] = 0;
+	GetShortPathNameA(tmp, dest, ofn16->nMaxFile);
+
+	/* the same procedure as every year... */
+        ofn16->nFileOffset = strrchr(dest,'\\') - dest +1;
+        ofn16->nFileExtension = 0;
+        while(dest[ofn16->nFileExtension] != '.' && dest[ofn16->nFileExtension] != '\0')
+            ofn16->nFileExtension++;
+        if (dest[ofn16->nFileExtension] == '\0')
+            ofn16->nFileExtension = 0;
+        else
+            ofn16->nFileExtension++;
+    }
+#endif
+    if (lfs->ofnA)
+    {
+        if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFile, -1,
+                                  lfs->ofnA->lpstrFile, ofnW->nMaxFile, NULL, NULL ))
+            lfs->ofnA->lpstrFile[ofnW->nMaxFile-1] = 0;
+        lfs->ofnA->nFileOffset = ofnW->nFileOffset;
+        lfs->ofnA->nFileExtension = ofnW->nFileExtension;
+    }
+}
+
+
+/***********************************************************************
+ *                              FILEDLG_UpdateFileTitle         [internal]
+ *      update the displayed file name (without path) 
+ */
+void FILEDLG_UpdateFileTitle(LFSPRIVATE lfs)
+{
+  LONG lRet;
+  LPOPENFILENAMEW ofnW = lfs->ofnW;
+  if (ofnW->lpstrFileTitle != NULL) 
+  {
+    lRet = SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETCURSEL, 0, 0);
+    SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETTEXT, lRet,
+                             (LPARAM)ofnW->lpstrFileTitle );
+#ifndef __WIN32OS2__
+    if (lfs->ofn16)
+    {
+        char *dest = MapSL(lfs->ofn16->lpstrFileTitle);
+        if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFileTitle, -1,
+                                  dest, ofnW->nMaxFileTitle, NULL, NULL ))
+            dest[ofnW->nMaxFileTitle-1] = 0;
+    }
+#endif
+    if (lfs->ofnA)
+    {
+        if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFileTitle, -1,
+                                  lfs->ofnA->lpstrFileTitle, ofnW->nMaxFileTitle, NULL, NULL ))
+            lfs->ofnA->lpstrFileTitle[ofnW->nMaxFileTitle-1] = 0;
+    }
+  }
+}
+
+
+
+/***********************************************************************
+ *                              FILEDLG_DirListDblClick         [internal]
+ */
+static LRESULT FILEDLG_DirListDblClick( LFSPRIVATE lfs )
+{
+  LONG lRet;
+  HWND hWnd = lfs->hwnd;
+  LPWSTR pstr;
+  WCHAR tmpstr[BUFFILE];
+
+  /* get the raw string (with brackets) */
+  lRet = SendDlgItemMessageW(hWnd, lst2, LB_GETCURSEL, 0, 0);
+  if (lRet == LB_ERR) return TRUE;
+  pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
+  SendDlgItemMessageW(hWnd, lst2, LB_GETTEXT, lRet,
+		     (LPARAM)pstr);
+  strcpyW( tmpstr, pstr );
+  HeapFree(GetProcessHeap(), 0, pstr);
+  /* get the selected directory in tmpstr */
+  if (tmpstr[0] == '[')
+    {
+      tmpstr[lstrlenW(tmpstr) - 1] = 0;
+      strcpyW(tmpstr,tmpstr+1);
+    }
+  strcatW(tmpstr, FILE_bslash);
+
+  FILEDLG_ScanDir(hWnd, tmpstr);
+  /* notify the app */
+  if (lfs->hook)
+    {
+      if (FILEDLG_CallWindowProc(lfs, lfs->lbselchstring, lst2,
+              MAKELONG(lRet,CD_LBSELCHANGE)))
+        return TRUE;
+    }
+  return TRUE;
+}
+
+
+/***********************************************************************
+ *                              FILEDLG_FileListSelect         [internal]
+ *    called when a new item is picked in the file list
+ */
+static LRESULT FILEDLG_FileListSelect( LFSPRIVATE lfs )
+{
+    LONG lRet;
+    HWND hWnd = lfs->hwnd;
+    LPWSTR pstr;
+
+#ifdef __WIN32OS2__
+    lRet = SendDlgItemMessageW(hWnd, lst1, LB_GETCURSEL, 0, 0);
+#else
+    lRet = SendDlgItemMessageW(hWnd, lst1, LB_GETCURSEL16, 0, 0);
+#endif
+    if (lRet == LB_ERR)
+        return TRUE;
+
+    /* set the edit control to the choosen file */
+    if ((pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
+    {
+        SendDlgItemMessageW(hWnd, lst1, LB_GETTEXT, lRet,
+                       (LPARAM)pstr);
+        SetDlgItemTextW( hWnd, edt1, pstr );
+        HeapFree(GetProcessHeap(), 0, pstr);
+    }
+    if (lfs->hook)
+    {
+        FILEDLG_CallWindowProc(lfs, lfs->lbselchstring, lst1,
+                           MAKELONG(lRet,CD_LBSELCHANGE));
+    }
+    /* FIXME: for OFN_ALLOWMULTISELECT we need CD_LBSELSUB, CD_SELADD,
+           CD_LBSELNOITEMS */
+    return TRUE;
+}
+
+/***********************************************************************
+ *                              FILEDLG_TestPath      [internal]
+ *      before accepting the file name, test if it includes wild cards
+ *      tries to scan the directory and returns TRUE if no error.
+ */
+static LRESULT FILEDLG_TestPath( LFSPRIVATE lfs, LPWSTR path )
+{
+    HWND hWnd = lfs->hwnd;
+    LPWSTR pBeginFileName, pstr2;
+    WCHAR tmpstr2[BUFFILE];
+
+    pBeginFileName = strrchrW(path, '\\');
+    if (pBeginFileName == NULL)
+	pBeginFileName = strrchrW(path, ':');
+
+    if (strchrW(path,'*') != NULL || strchrW(path,'?') != NULL)
+    {
+        /* edit control contains wildcards */
+        if (pBeginFileName != NULL)
+        {
+	    lstrcpynW(tmpstr2, pBeginFileName + 1, BUFFILE);
+	    *(pBeginFileName + 1) = 0;
+	}
+	else
+	{
+	    strcpyW(tmpstr2, path);
+	    *path = 0;
+        }
+
+        TRACE("path=%s, tmpstr2=%s\n", debugstr_w(path), debugstr_w(tmpstr2));
+        SetDlgItemTextW( hWnd, edt1, tmpstr2 );
+        FILEDLG_ScanDir(hWnd, path);
+        return FALSE;
+    }
+
+    /* no wildcards, we might have a directory or a filename */
+    /* try appending a wildcard and reading the directory */
+
+    pstr2 = path + lstrlenW(path);
+    if (pBeginFileName == NULL || *(pBeginFileName + 1) != 0)
+        strcatW(path, FILE_bslash);
+
+    /* if ScanDir succeeds, we have changed the directory */
+    if (FILEDLG_ScanDir(hWnd, path))
+        return TRUE;
+
+    /* if not, this must be a filename */
+
+    *pstr2 = 0; /* remove the wildcard added before */
+
+    if (pBeginFileName != NULL)
+    {
+        /* strip off the pathname */
+        *pBeginFileName = 0;
+        SetDlgItemTextW( hWnd, edt1, pBeginFileName + 1 );
+
+        lstrcpynW(tmpstr2, pBeginFileName + 1, sizeof(tmpstr2)/sizeof(WCHAR) );
+        /* Should we MessageBox() if this fails? */
+        if (!FILEDLG_ScanDir(hWnd, path))
+        {
+            return FALSE;
+        }
+        strcpyW(path, tmpstr2);
+    }
+    else
+        SetDlgItemTextW( hWnd, edt1, path );
+    return TRUE;
+}
+
+/***********************************************************************
+ *                              FILEDLG_Validate               [internal]
+ *   called on: click Ok button, Enter in edit, DoubleClick in file list
+ */
+static LRESULT FILEDLG_Validate( LFSPRIVATE lfs, LPWSTR path, UINT control, INT itemIndex,
+                                 BOOL internalUse )
+{
+    LONG lRet;
+    HWND hWnd = lfs->hwnd;
+    OPENFILENAMEW ofnsav;
+    LPOPENFILENAMEW ofnW = lfs->ofnW;
+    WCHAR filename[BUFFILE];
+
+    ofnsav = *ofnW; /* for later restoring */
+
+    /* get current file name */
+    if (path)
+        lstrcpynW(filename, path, sizeof(filename)/sizeof(WCHAR));
+    else
+        GetDlgItemTextW( hWnd, edt1, filename, sizeof(filename)/sizeof(WCHAR));
+
+    /* if we did not click in file list to get there */
+    if (control != lst1)
+    {
+        if (!FILEDLG_TestPath( lfs, filename) )
+           return FALSE;
+    }
+    FILEDLG_UpdateResult(lfs, filename);
+
+    if (internalUse)
+    { /* called internally after a change in a combo */
+        if (lfs->hook)
+        {
+             FILEDLG_CallWindowProc(lfs, lfs->lbselchstring, control,
+                             MAKELONG(itemIndex,CD_LBSELCHANGE));
+        }
+        return TRUE;
+    }
+
+    FILEDLG_UpdateFileTitle(lfs);
+    if (lfs->hook)
+    {
+        lRet = (BOOL)FILEDLG_CallWindowProc(lfs, lfs->fileokstring,
+                  0, lfs->lParam );
+        if (lRet)       
+        {
+            *ofnW = ofnsav; /* restore old state */
+            return FALSE;
+        }
+    }
+    if ((ofnW->Flags & OFN_ALLOWMULTISELECT) && (ofnW->Flags & OFN_EXPLORER))
+    {
+        if (ofnW->lpstrFile)
+        {
+            LPWSTR str = (LPWSTR)ofnW->lpstrFile;
+            LPWSTR ptr = strrchrW(str, '\\');
+	    str[lstrlenW(str) + 1] = '\0';
+	    *ptr = 0;
+        }
+    }
+    return TRUE;
+}
+
+/***********************************************************************
+ *                              FILEDLG_DiskChange             [internal]
+ *    called when a new item is picked in the disk selection combo
+ */
+static LRESULT FILEDLG_DiskChange( LFSPRIVATE lfs )
+{
+    LONG lRet;
+    HWND hWnd = lfs->hwnd;
+    LPWSTR pstr;
+    WCHAR diskname[BUFFILE];
+
+    FILEDLG_StripEditControl(hWnd);
+    lRet = SendDlgItemMessageW(hWnd, cmb2, CB_GETCURSEL, 0, 0L);
+    if (lRet == LB_ERR)
+        return 0;
+    pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
+    SendDlgItemMessageW(hWnd, cmb2, CB_GETLBTEXT, lRet,
+                         (LPARAM)pstr);
+    wsprintfW(diskname, FILE_specc, pstr[2]);
+    HeapFree(GetProcessHeap(), 0, pstr);    
+
+    return FILEDLG_Validate( lfs, diskname, cmb2, lRet, TRUE );
+}
+
+
+/***********************************************************************
+ *                              FILEDLG_FileTypeChange         [internal]
+ *    called when a new item is picked in the file type combo
+ */
+static LRESULT FILEDLG_FileTypeChange( LFSPRIVATE lfs )
+{
+    LONG lRet;
+    WCHAR diskname[BUFFILE];
+    LPWSTR pstr;
+
+    diskname[0] = 0;
+
+    lRet = SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETCURSEL, 0, 0);
+    if (lRet == LB_ERR)
+        return TRUE;
+    pstr = (LPWSTR)SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETITEMDATA, lRet, 0);
+    TRACE("Selected filter : %s\n", debugstr_w(pstr));
+    SetDlgItemTextW( lfs->hwnd, edt1, pstr );
+
+    return FILEDLG_Validate( lfs, NULL, cmb1, lRet, TRUE );
+}
+
+/***********************************************************************
+ *                              FILEDLG_WMCommand               [internal]
+ */
+static LRESULT FILEDLG_WMCommand(HWND hWnd, LPARAM lParam, UINT notification,
+       UINT control, LFSPRIVATE lfs ) 
+{
+    switch (control)
+    {
+        case lst1: /* file list */
+        FILEDLG_StripEditControl(hWnd);
+        if (notification == LBN_DBLCLK)
+        {
+            if (FILEDLG_Validate( lfs, NULL, control, 0, FALSE ))
+                EndDialog(hWnd, TRUE);
+            return TRUE;
+        }
+        else if (notification == LBN_SELCHANGE)
+            return FILEDLG_FileListSelect( lfs );
+        break;
+
+        case lst2: /* directory list */
+        FILEDLG_StripEditControl(hWnd);
+        if (notification == LBN_DBLCLK)
+            return FILEDLG_DirListDblClick( lfs );
+        break;
+
+        case cmb1: /* file type drop list */
+        if (notification == CBN_SELCHANGE) 
+            return FILEDLG_FileTypeChange( lfs );
+        break;
+
+        case chx1:
+        break;
+
+        case pshHelp:
+        break;
+
+        case cmb2: /* disk dropdown combo */
+        if (notification == CBN_SELCHANGE)
+            return FILEDLG_DiskChange( lfs );
+        break;
+
+        case IDOK:
+        if (FILEDLG_Validate( lfs, NULL, control, 0, FALSE ))
+            EndDialog(hWnd, TRUE);
+        return TRUE;
+
+        case IDCANCEL:
+        EndDialog(hWnd, FALSE);
+        return TRUE;
+
+        case IDABORT: /* can be sent by the hook procedure */
+        EndDialog(hWnd, TRUE);
+        return TRUE;
+    }
+    return FALSE;
+}
+
+#ifndef __WIN32OS2__
+/***********************************************************************
+ *                              FILEDLG_MapDrawItemStruct       [internal]
+ *      map a 16 bits drawitem struct to 32
+ */
+void FILEDLG_MapDrawItemStruct(LPDRAWITEMSTRUCT16 lpdis16, LPDRAWITEMSTRUCT lpdis)
+{
+    lpdis->CtlType = lpdis16->CtlType;
+    lpdis->CtlID = lpdis16->CtlID;
+    lpdis->itemID = lpdis16->itemID;
+    lpdis->itemAction = lpdis16->itemAction;
+    lpdis->itemState = lpdis16->itemState;
+    lpdis->hwndItem = lpdis16->hwndItem;
+    lpdis->hDC = lpdis16->hDC;
+    lpdis->rcItem.right = lpdis16->rcItem.right;
+    lpdis->rcItem.left = lpdis16->rcItem.left;
+    lpdis->rcItem.top = lpdis16->rcItem.top;
+    lpdis->rcItem.bottom = lpdis16->rcItem.bottom;
+    lpdis->itemData = lpdis16->itemData;
+}
+#endif
+
+/************************************************************************
+ *                              FILEDLG_MapStringPairsToW       [internal]
+ *      map string pairs to Unicode
+ */
+LPWSTR FILEDLG_MapStringPairsToW(LPCSTR strA, UINT size)
+{
+    LPCSTR s;
+    LPWSTR x;
+    int n, len;
+
+    s = strA;
+    while (*s)
+        s = s+strlen(s)+1;
+    s++;
+    n = s - strA;
+    if (n < size) n = size;
+
+    len = MultiByteToWideChar( CP_ACP, 0, strA, n, NULL, 0 );
+    x = HeapAlloc(GetProcessHeap(),0, len * sizeof(WCHAR));
+    MultiByteToWideChar( CP_ACP, 0, strA, n, x, len );
+    return x;
+}
+
+
+/************************************************************************
+ *                              FILEDLG_DupToW                  [internal]
+ *      duplicates an Ansi string to unicode, with a buffer size
+ */
+LPWSTR FILEDLG_DupToW(LPCSTR str, DWORD size)
+{
+    LPWSTR strW = NULL;
+    if (str && (size > 0))
+    {
+        strW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
+        if (strW) MultiByteToWideChar( CP_ACP, 0, str, -1, strW, size );
+    }
+    return strW;
+}
+
+
+/************************************************************************
+ *                              FILEDLG_MapOfnStructA          [internal]
+ *      map a 32 bits Ansi structure to an Unicode one
+ */
+void FILEDLG_MapOfnStructA(LPOPENFILENAMEA ofnA, LPOPENFILENAMEW ofnW, BOOL open)
+{
+    LPCSTR str;
+
+    ofnW->lStructSize = sizeof(OPENFILENAMEW);
+    ofnW->hwndOwner = ofnA->hwndOwner;
+    ofnW->hInstance = ofnA->hInstance;
+    if (ofnA->lpstrFilter)
+        ofnW->lpstrFilter = FILEDLG_MapStringPairsToW(ofnA->lpstrFilter, 0);
+    else
+        ofnW->lpstrFilter = FILEDLG_MapStringPairsToW(defaultfilter, 0);
+
+    if ((ofnA->lpstrCustomFilter) && (*(ofnA->lpstrCustomFilter)))
+        ofnW->lpstrCustomFilter = FILEDLG_MapStringPairsToW(ofnA->lpstrCustomFilter, ofnA->nMaxCustFilter);
+    ofnW->nMaxCustFilter = ofnA->nMaxCustFilter;
+    ofnW->nFilterIndex = ofnA->nFilterIndex;
+    ofnW->nMaxFile = ofnA->nMaxFile;
+    ofnW->lpstrFile = FILEDLG_DupToW(ofnA->lpstrFile, ofnW->nMaxFile);
+    ofnW->nMaxFileTitle = ofnA->nMaxFileTitle;
+    ofnW->lpstrFileTitle = FILEDLG_DupToW(ofnA->lpstrFileTitle, ofnW->nMaxFileTitle);
+    if (ofnA->lpstrInitialDir)
+        ofnW->lpstrInitialDir = HEAP_strdupAtoW(GetProcessHeap(),0,ofnA->lpstrInitialDir);
+    if (ofnA->lpstrTitle)
+        str = ofnA->lpstrTitle;
+    else 
+        /* Allocates default title (FIXME : get it from resource) */
+        str = open ? defaultopen:defaultsave;
+    ofnW->lpstrTitle = HEAP_strdupAtoW(GetProcessHeap(),0, str);
+    ofnW->Flags = ofnA->Flags;
+    ofnW->nFileOffset = ofnA->nFileOffset;
+    ofnW->nFileExtension = ofnA->nFileExtension;
+    ofnW->lpstrDefExt = FILEDLG_DupToW(ofnA->lpstrDefExt, 3);
+    if ((ofnA->Flags & OFN_ENABLETEMPLATE) && (ofnA->lpTemplateName))
+    {
+        if (HIWORD(ofnA->lpTemplateName))
+            ofnW->lpTemplateName = HEAP_strdupAtoW(GetProcessHeap(), 0, ofnA->lpTemplateName);
+        else /* numbered resource */
+            ofnW->lpTemplateName = (LPWSTR) ofnA->lpTemplateName;
+    }
+}
+
+#ifndef __WIN32OS2__
+/************************************************************************
+ *                              FILEDLG_MapOfnStruct16          [internal]
+ *      map a 16 bits structure to an Unicode one
+ */
+void FILEDLG_MapOfnStruct16(LPOPENFILENAME16 ofn16, LPOPENFILENAMEW ofnW, BOOL open)
+{
+    OPENFILENAMEA ofnA;
+    /* first convert to linear pointers */
+    memset(&ofnA, 0, sizeof(OPENFILENAMEA));
+    ofnA.lStructSize = sizeof(OPENFILENAMEA);
+    ofnA.hwndOwner = ofn16->hwndOwner;
+    ofnA.hInstance = ofn16->hInstance;
+    if (ofn16->lpstrFilter)
+        ofnA.lpstrFilter = MapSL(ofn16->lpstrFilter);
+    if (ofn16->lpstrCustomFilter)
+        ofnA.lpstrCustomFilter = MapSL(ofn16->lpstrCustomFilter);
+    ofnA.nMaxCustFilter = ofn16->nMaxCustFilter;
+    ofnA.nFilterIndex = ofn16->nFilterIndex;
+    ofnA.lpstrFile = MapSL(ofn16->lpstrFile);
+    ofnA.nMaxFile = ofn16->nMaxFile;
+    ofnA.lpstrFileTitle = MapSL(ofn16->lpstrFileTitle);
+    ofnA.nMaxFileTitle = ofn16->nMaxFileTitle;
+    ofnA.lpstrInitialDir = MapSL(ofn16->lpstrInitialDir);
+    ofnA.lpstrTitle = MapSL(ofn16->lpstrTitle);
+    ofnA.Flags = ofn16->Flags;
+    ofnA.nFileOffset = ofn16->nFileOffset;
+    ofnA.nFileExtension = ofn16->nFileExtension;
+    ofnA.lpstrDefExt = MapSL(ofn16->lpstrDefExt);
+    if (HIWORD(ofn16->lpTemplateName))
+        ofnA.lpTemplateName = MapSL(ofn16->lpTemplateName);
+    else
+        ofnA.lpTemplateName = (LPSTR) ofn16->lpTemplateName; /* ressource number */
+    /* now calls the 32 bits Ansi to Unicode version to complete the job */
+    FILEDLG_MapOfnStructA(&ofnA, ofnW, open);
+}
+#endif
+
+/************************************************************************
+ *                              FILEDLG_DestroyPrivate            [internal]
+ *      destroys the private object 
+ */
+void FILEDLG_DestroyPrivate(LFSPRIVATE lfs)
+{
+    HWND hwnd;
+    if (!lfs) return;
+    hwnd = lfs->hwnd;
+    /* free resources for a 16 bits dialog */
+    if (lfs->hResource16) FreeResource16(lfs->hResource16);
+    if (lfs->hGlobal16)
+    {
+        GlobalUnlock16(lfs->hGlobal16);
+        GlobalFree16(lfs->hGlobal16);
+    }
+    /* if ofnW has been allocated, have to free everything in it */
+#ifndef __WIN32OS2__
+    if (lfs->ofn16 || lfs->ofnA)
+#else
+    if (lfs->ofnA)
+#endif
+    {
+       LPOPENFILENAMEW ofnW = lfs->ofnW;
+       if (ofnW->lpstrFilter) HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrFilter);
+       if (ofnW->lpstrCustomFilter) HeapFree(GetProcessHeap(), 0, ofnW->lpstrCustomFilter);
+       if (ofnW->lpstrFile) HeapFree(GetProcessHeap(), 0, ofnW->lpstrFile);
+       if (ofnW->lpstrFileTitle) HeapFree(GetProcessHeap(), 0, ofnW->lpstrFileTitle);
+       if (ofnW->lpstrInitialDir) HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrInitialDir);
+       if (ofnW->lpstrTitle) HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrTitle);
+       if ((ofnW->lpTemplateName) && (HIWORD(ofnW->lpTemplateName)))
+           HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpTemplateName);
+       HeapFree(GetProcessHeap(), 0, ofnW);
+    }
+    TRACE("destroying private allocation %p\n", lfs);
+    HeapFree(GetProcessHeap(), 0, lfs);
+    RemovePropA(hwnd, OFN_PROP);
+}
+
+/************************************************************************
+ *                              FILEDLG_AllocPrivate            [internal]
+ *      allocate a private object to hold 32 bits Unicode 
+ *      structure that will be used throughtout the calls, while
+ *      keeping available the original structures and a few variables
+ *      On entry : type = dialog procedure type (16,32A,32W)
+ *                 dlgType = dialog type (open or save)
+ */
+LFSPRIVATE FILEDLG_AllocPrivate(LPARAM lParam, int type, UINT dlgType)
+{
+    LFSPRIVATE lfs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct FSPRIVATE));
+    LFSPRIVATE ret;
+    TRACE("alloc private buf %p\n", lfs);
+    if (!lfs) return NULL;
+    lfs->hook = FALSE;
+    lfs->lParam = lParam;
+    if (dlgType == OPEN_DIALOG)
+        lfs->open = TRUE;
+    else
+        lfs->open = FALSE;
+    lfs->lbselchstring = RegisterWindowMessageA(LBSELCHSTRING);
+    lfs->fileokstring = RegisterWindowMessageA(FILEOKSTRING);
+    switch(type)
+    {
+#ifndef __WIN32OS2__
+        case LFS16:
+        lfs->ofn16 = MapSL(lParam);
+        if (lfs->ofn16->Flags & OFN_ENABLEHOOK)
+            if (lfs->ofn16->lpfnHook)
+                lfs->hook = TRUE;
+
+        break;
+#endif
+        case LFS32A:
+        lfs->ofnA = (LPOPENFILENAMEA) lParam;
+        if (lfs->ofnA->Flags & OFN_ENABLEHOOK)
+            if (lfs->ofnA->lpfnHook)
+                lfs->hook = TRUE;
+        break;
+
+        case LFS32W:
+        lfs->ofnW = (LPOPENFILENAMEW) lParam;
+        if (lfs->ofnW->Flags & OFN_ENABLEHOOK)
+            if (lfs->ofnW->lpfnHook)
+                lfs->hook = TRUE;
+        break;
+    }
+    ret = lfs;
+    if (!lfs->ofnW)
+    { /* this structure is needed internally, so create it */
+        lfs->ofnW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OPENFILENAMEW));
+        if (lfs->ofnW)
+        {
+#ifndef __WIN32OS2__
+            if (lfs->ofn16)
+                FILEDLG_MapOfnStruct16(lfs->ofn16, lfs->ofnW, lfs->open);
+#endif
+            if (lfs->ofnA)
+                FILEDLG_MapOfnStructA(lfs->ofnA, lfs->ofnW, lfs->open);
+        }
+        else 
+            ret = NULL;
+    }
+#ifndef __WIN32OS2__
+    if (lfs->ofn16)
+    {
+        if (!Get16BitsTemplate(lfs)) ret = NULL;
+    }
+    else
+#endif
+        if (!Get32BitsTemplate(lfs)) ret = NULL;
+    if (!ret) FILEDLG_DestroyPrivate(lfs);
+    return ret;
+}
+
+
+/***********************************************************************
+ *           GetFileName31A                                 [internal]
+ *
+ * Creates a win31 style dialog box for the user to select a file to open/save.
+ */
+BOOL WINAPI GetFileName31A( 
+                           LPOPENFILENAMEA lpofn, /* addess of structure with data*/
+                           UINT dlgType /* type dialogue : open/save */
+                          )
+{
+    HINSTANCE hInst;
+    BOOL bRet = FALSE;
+    LFSPRIVATE lfs;
+
+    if (!lpofn || !FileDlg_Init()) return FALSE;
+
+    lfs = FILEDLG_AllocPrivate((LPARAM) lpofn, LFS32A, dlgType);
+    if (lfs)
+    {
+        hInst = GetWindowLongA( lpofn->hwndOwner, GWL_HINSTANCE );
+        bRet = DialogBoxIndirectParamA( hInst, lfs->template, lpofn->hwndOwner, 
+             (DLGPROC) FileOpenDlgProc, (DWORD) lfs);
+        FILEDLG_DestroyPrivate(lfs);
+    }
+
+    TRACE("return lpstrFile='%s' !\n", lpofn->lpstrFile);
+    return bRet;
+}
+
+
+/***********************************************************************
+ *           GetFileName31W                                 [internal]
+ *
+ * Creates a win31 style dialog box for the user to select a file to open/save
+ */
+BOOL WINAPI GetFileName31W( 
+                           LPOPENFILENAMEW lpofn, /* addess of structure with data*/
+                           UINT dlgType /* type dialogue : open/save */
+                          )
+{
+    HINSTANCE hInst;
+    BOOL bRet = FALSE;
+    LFSPRIVATE lfs;
+
+    if (!lpofn || !FileDlg_Init()) return FALSE;
+
+    lfs = FILEDLG_AllocPrivate((LPARAM) lpofn, LFS32W, dlgType);
+    if (lfs)
+    {
+        hInst = GetWindowLongA( lpofn->hwndOwner, GWL_HINSTANCE );
+        bRet = DialogBoxIndirectParamW( hInst, lfs->template, lpofn->hwndOwner, 
+             (DLGPROC) FileOpenDlgProc, (DWORD) lfs);
+        FILEDLG_DestroyPrivate(lfs);
+    }
+
+    TRACE("return lpstrFile='%s' !\n", debugstr_w(lpofn->lpstrFile));
+    return bRet;
+}
+
+
+/* ------------------ Dialog procedures ---------------------- */
+
+#ifndef __WIN32OS2__
+/***********************************************************************
+ *           FileOpenDlgProc16   (COMMDLG.6)
+ */
+LRESULT WINAPI FileOpenDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
+                               LPARAM lParam)
+{  
+    LFSPRIVATE lfs = (LFSPRIVATE)GetPropA(hWnd,OFN_PROP);
+    DRAWITEMSTRUCT dis;
+ 
+    TRACE("msg=%x wparam=%x lParam=%lx\n", wMsg, wParam, lParam);
+    if ((wMsg != WM_INITDIALOG) && lfs && lfs->hook)
+        {
+            LRESULT lRet = (BOOL16)FILEDLG_CallWindowProc(lfs, wMsg, wParam, lParam);
+            if (lRet)   
+                return lRet;         /* else continue message processing */
+        }
+    switch (wMsg)
+    {
+    case WM_INITDIALOG:
+        return FILEDLG_WMInitDialog(hWnd, wParam, lParam);
+
+    case WM_MEASUREITEM:
+        return FILEDLG_WMMeasureItem16(hWnd, wParam, lParam);
+
+    case WM_DRAWITEM:
+        FILEDLG_MapDrawItemStruct(MapSL(lParam), &dis);
+        return FILEDLG_WMDrawItem(hWnd, wParam, lParam, FALSE, &dis);
+
+    case WM_COMMAND:
+        return FILEDLG_WMCommand(hWnd, lParam, HIWORD(lParam),wParam, lfs);
+#if 0
+    case WM_CTLCOLOR:
+         SetBkColor((HDC16)wParam, 0x00C0C0C0);
+         switch (HIWORD(lParam))
+         {
+	 case CTLCOLOR_BTN:
+	     SetTextColor((HDC16)wParam, 0x00000000);
+             return hGRAYBrush;
+	case CTLCOLOR_STATIC:
+             SetTextColor((HDC16)wParam, 0x00000000);
+             return hGRAYBrush;
+	}
+      break;
+#endif
+    }
+    return FALSE;
+}
+
+/***********************************************************************
+ *           FileSaveDlgProc16   (COMMDLG.7)
+ */
+LRESULT WINAPI FileSaveDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
+                               LPARAM lParam)
+{
+ LFSPRIVATE lfs = (LFSPRIVATE)GetPropA(hWnd,OFN_PROP);
+ DRAWITEMSTRUCT dis;
+
+ TRACE("msg=%x wparam=%x lParam=%lx\n", wMsg, wParam, lParam);
+ if ((wMsg != WM_INITDIALOG) && lfs && lfs->hook)
+  {
+   LRESULT  lRet;
+   lRet = (BOOL16)FILEDLG_CallWindowProc(lfs, wMsg, wParam, lParam);
+   if (lRet)   
+    return lRet;         /* else continue message processing */
+  }             
+  switch (wMsg) {
+   case WM_INITDIALOG:
+      return FILEDLG_WMInitDialog(hWnd, wParam, lParam);
+      
+   case WM_MEASUREITEM:
+      return FILEDLG_WMMeasureItem16(hWnd, wParam, lParam);
+    
+   case WM_DRAWITEM:
+      FILEDLG_MapDrawItemStruct(MapSL(lParam), &dis);
+      return FILEDLG_WMDrawItem(hWnd, wParam, lParam, TRUE, &dis);
+
+   case WM_COMMAND:
+      return FILEDLG_WMCommand(hWnd, lParam, HIWORD(lParam), wParam, lfs);
+  }
+  
+  /*
+  case WM_CTLCOLOR:
+   SetBkColor((HDC16)wParam, 0x00C0C0C0);
+   switch (HIWORD(lParam))
+   {
+    case CTLCOLOR_BTN:
+     SetTextColor((HDC16)wParam, 0x00000000);
+     return hGRAYBrush;
+    case CTLCOLOR_STATIC:
+     SetTextColor((HDC16)wParam, 0x00000000);
+     return hGRAYBrush;
+   }
+   return FALSE;
+   
+   */
+  return FALSE;
+}
+#endif //__WIN32OS2__
+
+/***********************************************************************
+ *           FileOpenDlgProc                                    [internal]
+ *      Used for open and save, in fact.   
+ */
+static LRESULT WINAPI FileOpenDlgProc(HWND hWnd, UINT wMsg,
+                                      WPARAM wParam, LPARAM lParam)
+{
+    LFSPRIVATE lfs = (LFSPRIVATE)GetPropA(hWnd,OFN_PROP);
+
+    TRACE("msg=%x wparam=%x lParam=%lx\n", wMsg, wParam, lParam);
+    if ((wMsg != WM_INITDIALOG) && lfs && lfs->hook)
+        {
+            LRESULT lRet;
+            lRet  = (BOOL)FILEDLG_CallWindowProc(lfs, wMsg, wParam, lParam);
+            if (lRet)   
+                return lRet;         /* else continue message processing */
+        }
+    switch (wMsg)
+    {
+    case WM_INITDIALOG:
+        return FILEDLG_WMInitDialog(hWnd, wParam, lParam);
+
+    case WM_MEASUREITEM:
+        return FILEDLG_WMMeasureItem(hWnd, wParam, lParam);
+
+    case WM_DRAWITEM:
+        return FILEDLG_WMDrawItem(hWnd, wParam, lParam, !lfs->open, (DRAWITEMSTRUCT *)lParam);
+
+    case WM_COMMAND:
+        return FILEDLG_WMCommand(hWnd, lParam, HIWORD(wParam), LOWORD(wParam), lfs);
+#if 0
+    case WM_CTLCOLOR:
+         SetBkColor((HDC16)wParam, 0x00C0C0C0);
+         switch (HIWORD(lParam))
+         {
+	 case CTLCOLOR_BTN:
+	     SetTextColor((HDC16)wParam, 0x00000000);
+             return hGRAYBrush;
+	case CTLCOLOR_STATIC:
+             SetTextColor((HDC16)wParam, 0x00000000);
+             return hGRAYBrush;
+	}
+      break;
+#endif
+    }
+    return FALSE;
+}
+
+/* ------------------ APIs ---------------------- */ 
+#ifndef __WIN32OS2__
+/***********************************************************************
+ *           GetOpenFileName16   (COMMDLG.1)
+ *
+ * Creates a dialog box for the user to select a file to open.
+ *
+ * RETURNS
+ *    TRUE on success: user selected a valid file
+ *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
+ *
+ * BUGS
+ *    unknown, there are some FIXME's left.
+ */
+BOOL16 WINAPI GetOpenFileName16( 
+				SEGPTR ofn /* [in/out] address of structure with data*/
+				)
+{
+    HINSTANCE hInst;
+    BOOL bRet = FALSE;
+    LPOPENFILENAME16 lpofn = MapSL(ofn);
+    LFSPRIVATE lfs;
+    FARPROC16 ptr;
+
+    if (!lpofn || !FileDlg_Init()) return FALSE;
+
+    lfs = FILEDLG_AllocPrivate((LPARAM) ofn, LFS16, OPEN_DIALOG);
+    if (lfs)
+    {
+        hInst = GetWindowLongA( lpofn->hwndOwner, GWL_HINSTANCE );
+        ptr = GetProcAddress16(GetModuleHandle16("COMMDLG"), (LPCSTR) 6);
+        bRet = DialogBoxIndirectParam16( hInst, lfs->hDlgTmpl16, lpofn->hwndOwner, 
+             (DLGPROC16) ptr, (DWORD) lfs);
+        FILEDLG_DestroyPrivate(lfs);
+    }
+
+    TRACE("return lpstrFile='%s' !\n", (char *)MapSL(lpofn->lpstrFile));
+    return bRet;
+}
+
+/***********************************************************************
+ *           GetSaveFileName16   (COMMDLG.2)
+ *
+ * Creates a dialog box for the user to select a file to save.
+ *
+ * RETURNS
+ *    TRUE on success: user enters a valid file
+ *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
+ *
+ * BUGS
+ *    unknown. There are some FIXME's left.
+ */
+BOOL16 WINAPI GetSaveFileName16( 
+				SEGPTR ofn /* [in/out] addess of structure with data*/
+				)
+{
+    HINSTANCE hInst;
+    BOOL bRet = FALSE;
+    LPOPENFILENAME16 lpofn = MapSL(ofn);
+    LFSPRIVATE lfs;
+    FARPROC16 ptr;
+
+    if (!lpofn || !FileDlg_Init()) return FALSE;
+
+    lfs = FILEDLG_AllocPrivate((LPARAM) ofn, LFS16, SAVE_DIALOG);
+    if (lfs)
+    {
+        hInst = GetWindowLongA( lpofn->hwndOwner, GWL_HINSTANCE );
+        ptr = GetProcAddress16(GetModuleHandle16("COMMDLG"), (LPCSTR) 7);
+        bRet = DialogBoxIndirectParam16( hInst, lfs->hDlgTmpl16, lpofn->hwndOwner, 
+             (DLGPROC16) ptr, (DWORD) lfs);
+        FILEDLG_DestroyPrivate(lfs);
+    } 
+
+    TRACE("return lpstrFile='%s' !\n", (char *)MapSL(lpofn->lpstrFile));
+    return bRet;
+}
+#endif //__WIN32OS2__
+
+/***********************************************************************
+ *            GetOpenFileNameA  (COMDLG32.10)
+ *
+ * Creates a dialog box for the user to select a file to open.
+ *
+ * RETURNS
+ *    TRUE on success: user enters a valid file
+ *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
+ *
+ */
+BOOL WINAPI GetOpenFileNameA(
+	LPOPENFILENAMEA ofn) /* [in/out] address of init structure */
+{
+    BOOL  newlook = TRUE; /* FIXME: TWEAK_WineLook */
+
+#ifdef __WIN32OS2__
+    dprintf(("GetOpenFileNameA %x", ofn));
+#endif
+
+    /* some flags don't allow to match the TWEAK_WineLook */
+    if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
+    {
+      newlook = (ofn->Flags & OFN_EXPLORER) ? TRUE : FALSE;
+    }
+
+    if (newlook)
+    {
+        return GetFileDialog95A(ofn, OPEN_DIALOG);
+    }
+    else
+    {
+        return GetFileName31A(ofn, OPEN_DIALOG);
+    }
+}
+
+/***********************************************************************
+ *            GetOpenFileNameW (COMDLG32.11)
+ *
+ * Creates a dialog box for the user to select a file to open.
+ *
+ * RETURNS
+ *    TRUE on success: user enters a valid file
+ *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
+ *
+ */
+BOOL WINAPI GetOpenFileNameW(
+	LPOPENFILENAMEW ofn) /* [in/out] address of init structure */
+{
+    BOOL  newlook = TRUE; /* FIXME: TWEAK_WineLook */
+
+#ifdef __WIN32OS2__
+    dprintf(("GetOpenFileNameW %x", ofn));
+#endif
+
+    /* some flags don't allow to match the TWEAK_WineLook */
+    if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
+    {
+      newlook = (ofn->Flags & OFN_EXPLORER) ? TRUE : FALSE;
+    }
+
+    if (newlook)
+    {
+        return GetFileDialog95W(ofn, OPEN_DIALOG);
+    }
+    else
+    {
+        return GetFileName31W(ofn, OPEN_DIALOG);
+    }
+}
+
+/***********************************************************************
+ *            GetSaveFileNameA  (COMDLG32.12)
+ *
+ * Creates a dialog box for the user to select a file to save.
+ *
+ * RETURNS
+ *    TRUE on success: user enters a valid file
+ *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
+ *
+ */
+BOOL WINAPI GetSaveFileNameA(
+	LPOPENFILENAMEA ofn) /* [in/out] address of init structure */
+{
+    BOOL  newlook = TRUE; /* FIXME: TWEAK_WineLook */
+
+#ifdef __WIN32OS2__
+    dprintf(("GetSaveFileNameA %x", ofn));
+#endif
+
+    /* some flags don't allow to match the TWEAK_WineLook */
+    if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
+    {
+      newlook = (ofn->Flags & OFN_EXPLORER) ? TRUE : FALSE;
+    }
+
+    if (newlook)
+    {
+        return GetFileDialog95A(ofn, SAVE_DIALOG);
+    } 
+    else
+    {
+        return GetFileName31A(ofn, SAVE_DIALOG);
+    }
+}
+
+/***********************************************************************
+ *            GetSaveFileNameW  (COMDLG32.13)
+ *
+ * Creates a dialog box for the user to select a file to save.
+ *
+ * RETURNS
+ *    TRUE on success: user enters a valid file
+ *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
+ *
+ */
+BOOL WINAPI GetSaveFileNameW(
+	LPOPENFILENAMEW ofn) /* [in/out] address of init structure */
+{
+    BOOL  newlook = TRUE; /* FIXME: TWEAK_WineLook */
+
+#ifdef __WIN32OS2__
+    dprintf(("GetSaveFileNameW %x", ofn));
+#endif
+
+    /* some flags don't allow to match the TWEAK_WineLook */
+    if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
+    {
+      newlook = (ofn->Flags & OFN_EXPLORER) ? TRUE : FALSE;
+    }
+
+    if (newlook)
+    {
+        return GetFileDialog95W(ofn, SAVE_DIALOG);
+    } 
+    else
+    {
+        return GetFileName31W(ofn, SAVE_DIALOG);
+    }
+}
Index: trunk/src/comdlg32/makefile
===================================================================
--- trunk/src/comdlg32/makefile	(revision 4931)
+++ trunk/src/comdlg32/makefile	(revision 4932)
@@ -1,3 +1,3 @@
-# $Id: makefile,v 1.22 2000-12-02 23:37:20 bird Exp $
+# $Id: makefile,v 1.23 2001-01-11 18:05:02 sandervl Exp $
 
 #
@@ -24,4 +24,5 @@
 $(OBJDIR)\filetitle.obj \
 $(OBJDIR)\finddlg32.obj \
+$(OBJDIR)\filedlg.obj \
 $(OBJDIR)\filedlg95.obj \
 $(OBJDIR)\comdlg32.obj \
