git.oblomov.eu Git - wine/blob - dlls/commdlg/filedlg16.c

   1 /*
   2  * COMMDLG - File Dialogs
   3  *
   4  * Copyright 1994 Martin Ayotte
   5  * Copyright 1996 Albrecht Kleine
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21 #include <ctype.h>
  22 #include <stdlib.h>
  23 #include <stdarg.h>
  24 #include <stdio.h>
  25 #include <string.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winnls.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "wine/winbase16.h"
  32 #include "wine/winuser16.h"
  33 #include "wine/unicode.h"
  34 #include "wine/debug.h"
  35 #include "cderr.h"
  36 #include "winreg.h"
  37 #include "winternl.h"
  38 #include "winuser.h"
  39 #include "commdlg.h"
  40 #include "cderr.h"
  41 #include "winreg.h"
  42 #include "winternl.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
  45
  46 #include "cdlg.h"
  47 #include "cdlg16.h"
  48
  49 #define BUFFILE 512
  50 #define BUFFILEALLOC 512 * sizeof(WCHAR)
  51
  52 struct FSPRIVATE
  53 {
  54     HWND hwnd; /* file dialog window handle */
  55     BOOL hook; /* TRUE if the dialog is hooked */
  56     UINT lbselchstring; /* registered message id */
  57     UINT fileokstring; /* registered message id */
  58     LPARAM lParam; /* save original lparam */
  59     HANDLE16 hDlgTmpl16; /* handle for resource 16 */
  60     HANDLE16 hResource16; /* handle for allocated resource 16 */
  61     HANDLE16 hGlobal16; /* 16 bits mem block (resources) */
  62     LPCVOID template; /* template for 32 bits resource */
  63     BOOL open; /* TRUE if open dialog, FALSE if save dialog */
  64     OPENFILENAMEW *ofnW; /* original structure or work struct */
  65     OPENFILENAMEA *ofnA; /* original structure if 32bits ansi dialog */
  66     OPENFILENAME16 *ofn16; /* original structure if 16 bits dialog */
  67 };
  68
  69 #define LFSPRIVATE struct FSPRIVATE *
  70 #define LFS16 1
  71 #define LFS32A 2
  72 #define LFS32W 3
  73 #define OFN_PROP "FILEDLG_OFN"
  74
  75 static const WCHAR FILE_star[] = {'*','.','*', 0};
  76 static const WCHAR FILE_bslash[] = {'\\', 0};
  77 static const WCHAR FILE_specc[] = {'%','c',':', 0};
  78 static const int fldrHeight = 16;
  79 static const int fldrWidth = 20;
  80
  81 static HICON hFolder = 0;
  82 static HICON hFolder2 = 0;
  83 static HICON hFloppy = 0;
  84 static HICON hHDisk = 0;
  85 static HICON hCDRom = 0;
  86 static HICON hNet = 0;
  87 static char defaultopen[]="Open File";
  88 static char defaultsave[]="Save as";
  89
  90 /***********************************************************************
  91  *                              FileDlg_Init                    [internal]
  92  */
  93 static BOOL FileDlg_Init(void)
  94 {
  95     static BOOL initialized = 0;
  96
  97     if (!initialized) {
  98         hFolder  = LoadImageA( COMDLG32_hInstance, "FOLDER", IMAGE_ICON, 16, 16, LR_SHARED );
  99         hFolder2 = LoadImageA( COMDLG32_hInstance, "FOLDER2", IMAGE_ICON, 16, 16, LR_SHARED );
 100         hFloppy  = LoadImageA( COMDLG32_hInstance, "FLOPPY", IMAGE_ICON, 16, 16, LR_SHARED );
 101         hHDisk   = LoadImageA( COMDLG32_hInstance, "HDISK", IMAGE_ICON, 16, 16, LR_SHARED );
 102         hCDRom   = LoadImageA( COMDLG32_hInstance, "CDROM", IMAGE_ICON, 16, 16, LR_SHARED );
 103         hNet     = LoadImageA( COMDLG32_hInstance, "NETWORK", IMAGE_ICON, 16, 16, LR_SHARED );
 104         if (hFolder == 0 || hFolder2 == 0 || hFloppy == 0 ||
 105             hHDisk == 0 || hCDRom == 0 || hNet == 0)
 106         {
 107             ERR("Error loading icons !\n");
 108             return FALSE;
 109         }
 110         initialized = TRUE;
 111     }
 112     return TRUE;
 113 }
 114
 115 /***********************************************************************
 116  *           Get32BitsTemplate                                  [internal]
 117  *
 118  * Get a template (or FALSE if failure) when 16 bits dialogs are used
 119  * by a 32 bits application
 120  *
 121  */
 122 BOOL Get32BitsTemplate(LFSPRIVATE lfs)
 123 {
 124     LPOPENFILENAMEW ofnW = lfs->ofnW;
 125     HANDLE hDlgTmpl;
 126
 127     if (ofnW->Flags & OFN_ENABLETEMPLATEHANDLE)
 128     {
 129         if (!(lfs->template = LockResource( ofnW->hInstance )))
 130         {
 131             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 132             return FALSE;
 133         }
 134     }
 135     else if (ofnW->Flags & OFN_ENABLETEMPLATE)
 136     {
 137         HRSRC hResInfo;
 138         if (lfs->ofnA)
 139             hResInfo = FindResourceA(lfs->ofnA->hInstance,
 140                                  lfs->ofnA->lpTemplateName,
 141                                  (LPSTR)RT_DIALOG);
 142         else
 143             hResInfo = FindResourceW(ofnW->hInstance,
 144                                  ofnW->lpTemplateName,
 145                                  (LPWSTR)RT_DIALOG);
 146         if (!hResInfo)
 147         {
 148             COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 149             return FALSE;
 150         }
 151         if (!(hDlgTmpl = LoadResource(ofnW->hInstance,
 152                                 hResInfo)) ||
 153                     !(lfs->template = LockResource(hDlgTmpl)))
 154         {
 155             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 156             return FALSE;
 157         }
 158     } else { /* get it from internal Wine resource */
 159         HRSRC hResInfo;
 160         if (!(hResInfo = FindResourceA(COMDLG32_hInstance,
 161              lfs->open? "OPEN_FILE":"SAVE_FILE", (LPSTR)RT_DIALOG)))
 162         {
 163             COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 164             return FALSE;
 165         }
 166         if (!(hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo )) ||
 167                 !(lfs->template = LockResource( hDlgTmpl )))
 168         {
 169             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 170             return FALSE;
 171         }
 172     }
 173     return TRUE;
 174 }
 175
 176 /***********************************************************************
 177  *           Get16BitsTemplate                                [internal]
 178  *
 179  * Get a template (FALSE if failure) when 16 bits dialogs are used
 180  * by a 16 bits application
 181  *
 182  */
 183 BOOL Get16BitsTemplate(LFSPRIVATE lfs)
 184 {
 185     LPOPENFILENAME16 ofn16 = lfs->ofn16;
 186     LPCVOID template;
 187     HGLOBAL16 hGlobal16 = 0;
 188
 189     if (ofn16->Flags & OFN_ENABLETEMPLATEHANDLE)
 190         lfs->hDlgTmpl16 = ofn16->hInstance;
 191     else if (ofn16->Flags & OFN_ENABLETEMPLATE)
 192     {
 193         HANDLE16 hResInfo;
 194         if (!(hResInfo = FindResource16(ofn16->hInstance,
 195                                         MapSL(ofn16->lpTemplateName),
 196                                         (LPSTR)RT_DIALOG)))
 197         {
 198             COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 199             return FALSE;
 200         }
 201         if (!(lfs->hDlgTmpl16 = LoadResource16( ofn16->hInstance, hResInfo )))
 202         {
 203             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 204             return FALSE;
 205         }
 206         lfs->hResource16 = lfs->hDlgTmpl16;
 207     }
 208     else
 209     { /* get resource from (32 bits) own Wine resource; convert it to 16 */
 210         HRSRC hResInfo;
 211         HGLOBAL hDlgTmpl32;
 212         LPCVOID template32;
 213         DWORD size;
 214
 215         if (!(hResInfo = FindResourceA(COMDLG32_hInstance,
 216                lfs->open ? "OPEN_FILE":"SAVE_FILE", (LPSTR)RT_DIALOG)))
 217         {
 218             COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
 219             return FALSE;
 220         }
 221         if (!(hDlgTmpl32 = LoadResource(COMDLG32_hInstance, hResInfo )) ||
 222             !(template32 = LockResource( hDlgTmpl32 )))
 223         {
 224             COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
 225             return FALSE;
 226         }
 227         size = SizeofResource(COMDLG32_hInstance, hResInfo);
 228         hGlobal16 = GlobalAlloc16(0, size);
 229         if (!hGlobal16)
 230         {
 231             COMDLG32_SetCommDlgExtendedError(CDERR_MEMALLOCFAILURE);
 232             ERR("alloc failure for %ld bytes\n", size);
 233             return FALSE;
 234         }
 235         template = GlobalLock16(hGlobal16);
 236         if (!template)
 237         {
 238             COMDLG32_SetCommDlgExtendedError(CDERR_MEMLOCKFAILURE);
 239             ERR("global lock failure for %x handle\n", hGlobal16);
 240             GlobalFree16(hGlobal16);
 241             return FALSE;
 242         }
 243         ConvertDialog32To16((LPVOID)template32, size, (LPVOID)template);
 244         lfs->hDlgTmpl16 = hGlobal16;
 245         lfs->hGlobal16 = hGlobal16;
 246     }
 247     return TRUE;
 248 }
 249
 250 /***********************************************************************
 251  *                              FILEDLG_StripEditControl        [internal]
 252  * Strip pathnames off the contents of the edit control.
 253  */
 254 static void FILEDLG_StripEditControl(HWND hwnd)
 255 {
 256     WCHAR temp[BUFFILE], *cp;
 257
 258     GetDlgItemTextW( hwnd, edt1, temp, sizeof(temp)/sizeof(WCHAR));
 259     cp = strrchrW(temp, '\\');
 260     if (cp != NULL) {
 261         strcpyW(temp, cp+1);
 262     }
 263     cp = strrchrW(temp, ':');
 264     if (cp != NULL) {
 265         strcpyW(temp, cp+1);
 266     }
 267     /* FIXME: shouldn't we do something with the result here? ;-) */
 268 }
 269
 270 /***********************************************************************
 271  *                              FILEDLG_CallWindowProc          [internal]
 272  *
 273  *      Call the appropriate hook
 274  */
 275 static BOOL FILEDLG_CallWindowProc(LFSPRIVATE lfs, UINT wMsg, WPARAM wParam,
 276                                    LPARAM lParam)
 277 {
 278     if (lfs->ofnA)
 279     {
 280         return (BOOL) CallWindowProcA(
 281           (WNDPROC)lfs->ofnA->lpfnHook, lfs->hwnd,
 282           wMsg, wParam, lParam);
 283     }
 284
 285     if (lfs->ofnW)
 286     {
 287         return (BOOL) CallWindowProcW(
 288           (WNDPROC)lfs->ofnW->lpfnHook, lfs->hwnd,
 289           wMsg, wParam, lParam);
 290     }
 291     return FALSE;
 292 }
 293
 294 /***********************************************************************
 295  *                              FILEDLG_ScanDir                 [internal]
 296  */
 297 static BOOL FILEDLG_ScanDir(HWND hWnd, LPWSTR newPath)
 298 {
 299     WCHAR               buffer[BUFFILE];
 300     HWND                hdlg, hdlgDir;
 301     LRESULT             lRet = TRUE;
 302     HCURSOR             hCursorWait, oldCursor;
 303
 304     TRACE("Trying to change to %s\n", debugstr_w(newPath));
 305     if  ( !SetCurrentDirectoryW( newPath ))
 306         return FALSE;
 307     lstrcpynW(buffer, newPath, sizeof(buffer)/sizeof(WCHAR));
 308
 309     /* get the list of spec files */
 310     GetDlgItemTextW(hWnd, edt1, buffer, sizeof(buffer)/sizeof(WCHAR));
 311
 312     hCursorWait = LoadCursorA(0, (LPSTR)IDC_WAIT);
 313     oldCursor = SetCursor(hCursorWait);
 314
 315     /* list of files */
 316     if ((hdlg = GetDlgItem(hWnd, lst1)) != 0) {
 317         WCHAR*  scptr; /* ptr on semi-colon */
 318         WCHAR*  filter = buffer;
 319
 320         TRACE("Using filter %s\n", debugstr_w(filter));
 321         SendMessageW(hdlg, LB_RESETCONTENT, 0, 0);
 322         while (filter) {
 323             scptr = strchrW(filter, ';');
 324             if (scptr)  *scptr = 0;
 325             while (*filter == ' ') filter++;
 326             TRACE("Using file spec %s\n", debugstr_w(filter));
 327             if (SendMessageW(hdlg, LB_DIR, 0, (LPARAM)filter) == LB_ERR)
 328                 return FALSE;
 329             if (scptr) *scptr = ';';
 330                 filter = (scptr) ? (scptr + 1) : 0;
 331          }
 332     }
 333
 334     /* list of directories */
 335     strcpyW(buffer, FILE_star);
 336
 337     if ((hdlgDir = GetDlgItem(hWnd, lst2)) != 0) {
 338         lRet = DlgDirListW(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY);
 339     }
 340     SetCursor(oldCursor);
 341     return lRet;
 342 }
 343
 344 /***********************************************************************
 345  *                              FILEDLG_GetFileType             [internal]
 346  */
 347
 348 static LPWSTR FILEDLG_GetFileType(LPWSTR cfptr, LPWSTR fptr, WORD index)
 349 {
 350   int n, i;
 351   i = 0;
 352   if (cfptr)
 353     for ( ;(n = lstrlenW(cfptr)) != 0; i++)
 354       {
 355         cfptr += n + 1;
 356         if (i == index)
 357           return cfptr;
 358         cfptr += lstrlenW(cfptr) + 1;
 359       }
 360   if (fptr)
 361     for ( ;(n = lstrlenW(fptr)) != 0; i++)
 362       {
 363         fptr += n + 1;
 364         if (i == index)
 365           return fptr;
 366         fptr += lstrlenW(fptr) + 1;
 367     }
 368   return (LPWSTR) FILE_star; /* FIXME */
 369 }
 370
 371 /***********************************************************************
 372  *                              FILEDLG_WMDrawItem              [internal]
 373  */
 374 static LONG FILEDLG_WMDrawItem(HWND hWnd, WPARAM wParam, LPARAM lParam,
 375        int savedlg, LPDRAWITEMSTRUCT lpdis)
 376 {
 377     WCHAR *str;
 378     HICON hIcon;
 379     COLORREF oldText = 0, oldBk = 0;
 380
 381     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst1)
 382     {
 383         if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC))) return FALSE;
 384         SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID,
 385                       (LPARAM)str);
 386
 387         if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
 388         {
 389             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
 390             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 391         }
 392         if (savedlg)
 393             SetTextColor(lpdis->hDC,GetSysColor(COLOR_GRAYTEXT) );
 394
 395         ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + 1,
 396                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
 397                   &(lpdis->rcItem), str, lstrlenW(str), NULL);
 398
 399         if (lpdis->itemState & ODS_SELECTED)
 400             DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
 401
 402         if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
 403         {
 404             SetBkColor( lpdis->hDC, oldBk );
 405             SetTextColor( lpdis->hDC, oldText );
 406         }
 407         HeapFree(GetProcessHeap(), 0, str);
 408         return TRUE;
 409     }
 410
 411     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst2)
 412     {
 413         if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
 414             return FALSE;
 415         SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID,
 416                       (LPARAM)str);
 417
 418         if (lpdis->itemState & ODS_SELECTED)
 419         {
 420             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
 421             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 422         }
 423         ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
 424                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
 425                   &(lpdis->rcItem), str, lstrlenW(str), NULL);
 426
 427         if (lpdis->itemState & ODS_SELECTED)
 428             DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
 429
 430         if (lpdis->itemState & ODS_SELECTED)
 431         {
 432             SetBkColor( lpdis->hDC, oldBk );
 433             SetTextColor( lpdis->hDC, oldText );
 434         }
 435         DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hFolder);
 436         HeapFree(GetProcessHeap(), 0, str);
 437         return TRUE;
 438     }
 439     if (lpdis->CtlType == ODT_COMBOBOX && lpdis->CtlID == cmb2)
 440     {
 441         char root[] = "a:";
 442         if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
 443             return FALSE;
 444         SendMessageW(lpdis->hwndItem, CB_GETLBTEXT, lpdis->itemID,
 445                       (LPARAM)str);
 446         root[0] += str[2] - 'a';
 447         switch(GetDriveTypeA(root))
 448         {
 449         case DRIVE_REMOVABLE: hIcon = hFloppy; break;
 450         case DRIVE_CDROM:     hIcon = hCDRom; break;
 451         case DRIVE_REMOTE:    hIcon = hNet; break;
 452         case DRIVE_FIXED:
 453         default:           hIcon = hHDisk; break;
 454         }
 455         if (lpdis->itemState & ODS_SELECTED)
 456         {
 457             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
 458             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
 459         }
 460         ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
 461                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
 462                   &(lpdis->rcItem), str, lstrlenW(str), NULL);
 463
 464         if (lpdis->itemState & ODS_SELECTED)
 465         {
 466             SetBkColor( lpdis->hDC, oldBk );
 467             SetTextColor( lpdis->hDC, oldText );
 468         }
 469         DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hIcon);
 470         HeapFree(GetProcessHeap(), 0, str);
 471         return TRUE;
 472     }
 473     return FALSE;
 474 }
 475
 476 /***********************************************************************
 477  *                              FILEDLG_UpdateResult            [internal]
 478  *      update the displayed file name (with path)
 479  */
 480 void FILEDLG_UpdateResult(LFSPRIVATE lfs, WCHAR *tmpstr)
 481 {
 482     int lenstr2;
 483     LPOPENFILENAMEW ofnW = lfs->ofnW;
 484     WCHAR tmpstr2[BUFFILE];
 485     WCHAR *bs;
 486
 487     TRACE("%s\n", debugstr_w(tmpstr));
 488     if(ofnW->Flags & OFN_NOVALIDATE)
 489         tmpstr2[0] = '\0';
 490     else
 491         GetCurrentDirectoryW(BUFFILE, tmpstr2);
 492     lenstr2 = strlenW(tmpstr2);
 493     if (lenstr2 > 3)
 494         tmpstr2[lenstr2++]='\\';
 495     lstrcpynW(tmpstr2+lenstr2, tmpstr, BUFFILE-lenstr2);
 496     if (ofnW->lpstrFile)
 497         lstrcpynW(ofnW->lpstrFile, tmpstr2, ofnW->nMaxFile);
 498     if((bs = strrchrW(tmpstr2, '\\')) != NULL)
 499         ofnW->nFileOffset = bs - tmpstr2 +1;
 500     else
 501         ofnW->nFileOffset = 0;
 502     ofnW->nFileExtension = 0;
 503     while(tmpstr2[ofnW->nFileExtension] != '.' && tmpstr2[ofnW->nFileExtension] != '\0')
 504         ofnW->nFileExtension++;
 505     if (tmpstr2[ofnW->nFileExtension] == '\0')
 506         ofnW->nFileExtension = 0;
 507     else
 508         ofnW->nFileExtension++;
 509     /* update the real client structures if any */
 510     if (lfs->ofn16)
 511     { /* we have to convert to short (8.3) path */
 512         char tmp[1024]; /* MAX_PATHNAME_LEN */
 513         LPOPENFILENAME16 ofn16 = lfs->ofn16;
 514         char *dest = MapSL(ofn16->lpstrFile);
 515         char *bs16;
 516         if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFile, -1,
 517                                   tmp, sizeof(tmp), NULL, NULL ))
 518             tmp[sizeof(tmp)-1] = 0;
 519         GetShortPathNameA(tmp, dest, ofn16->nMaxFile);
 520
 521         /* the same procedure as every year... */
 522         if((bs16 = strrchr(dest, '\\')) != NULL)
 523             ofn16->nFileOffset = bs16 - dest +1;
 524         else
 525             ofn16->nFileOffset = 0;
 526         ofn16->nFileExtension = 0;
 527         while(dest[ofn16->nFileExtension] != '.' && dest[ofn16->nFileExtension] != '\0')
 528             ofn16->nFileExtension++;
 529         if (dest[ofn16->nFileExtension] == '\0')
 530             ofn16->nFileExtension = 0;
 531         else
 532             ofn16->nFileExtension++;
 533     }
 534     if (lfs->ofnA)
 535     {
 536         if (ofnW->nMaxFile &&
 537             !WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFile, -1,
 538                                   lfs->ofnA->lpstrFile, ofnW->nMaxFile, NULL, NULL ))
 539             lfs->ofnA->lpstrFile[ofnW->nMaxFile-1] = 0;
 540         lfs->ofnA->nFileOffset = ofnW->nFileOffset;
 541         lfs->ofnA->nFileExtension = ofnW->nFileExtension;
 542     }
 543 }
 544
 545 /***********************************************************************
 546  *                              FILEDLG_UpdateFileTitle         [internal]
 547  *      update the displayed file name (without path)
 548  */
 549 void FILEDLG_UpdateFileTitle(LFSPRIVATE lfs)
 550 {
 551   LONG lRet;
 552   LPOPENFILENAMEW ofnW = lfs->ofnW;
 553   if (ofnW->lpstrFileTitle != NULL)
 554   {
 555     lRet = SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETCURSEL, 0, 0);
 556     SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETTEXT, lRet,
 557                              (LPARAM)ofnW->lpstrFileTitle );
 558     if (lfs->ofn16)
 559     {
 560         char *dest = MapSL(lfs->ofn16->lpstrFileTitle);
 561         if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFileTitle, -1,
 562                                   dest, ofnW->nMaxFileTitle, NULL, NULL ))
 563             dest[ofnW->nMaxFileTitle-1] = 0;
 564     }
 565     if (lfs->ofnA)
 566     {
 567         if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFileTitle, -1,
 568                                   lfs->ofnA->lpstrFileTitle, ofnW->nMaxFileTitle, NULL, NULL ))
 569             lfs->ofnA->lpstrFileTitle[ofnW->nMaxFileTitle-1] = 0;
 570     }
 571   }
 572 }
 573
 574 /***********************************************************************
 575  *                              FILEDLG_DirListDblClick         [internal]
 576  */
 577 static LRESULT FILEDLG_DirListDblClick( LFSPRIVATE lfs )
 578 {
 579   LONG lRet;
 580   HWND hWnd = lfs->hwnd;
 581   LPWSTR pstr;
 582   WCHAR tmpstr[BUFFILE];
 583
 584   /* get the raw string (with brackets) */
 585   lRet = SendDlgItemMessageW(hWnd, lst2, LB_GETCURSEL, 0, 0);
 586   if (lRet == LB_ERR) return TRUE;
 587   pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
 588   SendDlgItemMessageW(hWnd, lst2, LB_GETTEXT, lRet,
 589                      (LPARAM)pstr);
 590   strcpyW( tmpstr, pstr );
 591   HeapFree(GetProcessHeap(), 0, pstr);
 592   /* get the selected directory in tmpstr */
 593   if (tmpstr[0] == '[')
 594     {
 595       tmpstr[lstrlenW(tmpstr) - 1] = 0;
 596       strcpyW(tmpstr,tmpstr+1);
 597     }
 598   strcatW(tmpstr, FILE_bslash);
 599
 600   FILEDLG_ScanDir(hWnd, tmpstr);
 601   /* notify the app */
 602   if (lfs->hook)
 603     {
 604       if (FILEDLG_CallWindowProc(lfs, lfs->lbselchstring, lst2,
 605               MAKELONG(lRet,CD_LBSELCHANGE)))
 606         return TRUE;
 607     }
 608   return TRUE;
 609 }
 610
 611 /***********************************************************************
 612  *                              FILEDLG_FileListSelect         [internal]
 613  *    called when a new item is picked in the file list
 614  */
 615 static LRESULT FILEDLG_FileListSelect( LFSPRIVATE lfs )
 616 {
 617     LONG lRet;
 618     HWND hWnd = lfs->hwnd;
 619     LPWSTR pstr;
 620
 621     lRet = SendDlgItemMessageW(hWnd, lst1, LB_GETCURSEL16, 0, 0);
 622     if (lRet == LB_ERR)
 623         return TRUE;
 624
 625     /* set the edit control to the choosen file */
 626     if ((pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
 627     {
 628         SendDlgItemMessageW(hWnd, lst1, LB_GETTEXT, lRet,
 629                        (LPARAM)pstr);
 630         SetDlgItemTextW( hWnd, edt1, pstr );
 631         HeapFree(GetProcessHeap(), 0, pstr);
 632     }
 633     if (lfs->hook)
 634     {
 635         FILEDLG_CallWindowProc(lfs, lfs->lbselchstring, lst1,
 636                            MAKELONG(lRet,CD_LBSELCHANGE));
 637     }
 638     /* FIXME: for OFN_ALLOWMULTISELECT we need CD_LBSELSUB, CD_SELADD,
 639            CD_LBSELNOITEMS */
 640     return TRUE;
 641 }
 642
 643 /***********************************************************************
 644  *                              FILEDLG_TestPath      [internal]
 645  *      before accepting the file name, test if it includes wild cards
 646  *      tries to scan the directory and returns TRUE if no error.
 647  */
 648 static LRESULT FILEDLG_TestPath( LFSPRIVATE lfs, LPWSTR path )
 649 {
 650     HWND hWnd = lfs->hwnd;
 651     LPWSTR pBeginFileName, pstr2;
 652     WCHAR tmpstr2[BUFFILE];
 653
 654     pBeginFileName = strrchrW(path, '\\');
 655     if (pBeginFileName == NULL)
 656         pBeginFileName = strrchrW(path, ':');
 657
 658     if (strchrW(path,'*') != NULL || strchrW(path,'?') != NULL)
 659     {
 660         /* edit control contains wildcards */
 661         if (pBeginFileName != NULL)
 662         {
 663             lstrcpynW(tmpstr2, pBeginFileName + 1, BUFFILE);
 664             *(pBeginFileName + 1) = 0;
 665         }
 666         else
 667         {
 668             strcpyW(tmpstr2, path);
 669             if(!(lfs->ofnW->Flags & OFN_NOVALIDATE))
 670                 *path = 0;
 671         }
 672
 673         TRACE("path=%s, tmpstr2=%s\n", debugstr_w(path), debugstr_w(tmpstr2));
 674         SetDlgItemTextW( hWnd, edt1, tmpstr2 );
 675         FILEDLG_ScanDir(hWnd, path);
 676         return (lfs->ofnW->Flags & OFN_NOVALIDATE) ? TRUE : FALSE;
 677     }
 678
 679     /* no wildcards, we might have a directory or a filename */
 680     /* try appending a wildcard and reading the directory */
 681
 682     pstr2 = path + lstrlenW(path);
 683     if (pBeginFileName == NULL || *(pBeginFileName + 1) != 0)
 684         strcatW(path, FILE_bslash);
 685
 686     /* if ScanDir succeeds, we have changed the directory */
 687     if (FILEDLG_ScanDir(hWnd, path))
 688         return FALSE; /* and path is not a valid file name */
 689
 690     /* if not, this must be a filename */
 691
 692     *pstr2 = 0; /* remove the wildcard added before */
 693
 694     if (pBeginFileName != NULL)
 695     {
 696         /* strip off the pathname */
 697         *pBeginFileName = 0;
 698         SetDlgItemTextW( hWnd, edt1, pBeginFileName + 1 );
 699
 700         lstrcpynW(tmpstr2, pBeginFileName + 1, sizeof(tmpstr2)/sizeof(WCHAR) );
 701         /* Should we MessageBox() if this fails? */
 702         if (!FILEDLG_ScanDir(hWnd, path))
 703         {
 704             return FALSE;
 705         }
 706         strcpyW(path, tmpstr2);
 707     }
 708     else
 709         SetDlgItemTextW( hWnd, edt1, path );
 710     return TRUE;
 711 }
 712
 713 /***********************************************************************
 714  *                              FILEDLG_Validate               [internal]
 715  *   called on: click Ok button, Enter in edit, DoubleClick in file list
 716  */
 717 static LRESULT FILEDLG_Validate( LFSPRIVATE lfs, LPWSTR path, UINT control, INT itemIndex,
 718                                  BOOL internalUse )
 719 {
 720     LONG lRet;
 721     HWND hWnd = lfs->hwnd;
 722     OPENFILENAMEW ofnsav;
 723     LPOPENFILENAMEW ofnW = lfs->ofnW;
 724     WCHAR filename[BUFFILE];
 725
 726     ofnsav = *ofnW; /* for later restoring */
 727
 728     /* get current file name */
 729     if (path)
 730         lstrcpynW(filename, path, sizeof(filename)/sizeof(WCHAR));
 731     else
 732         GetDlgItemTextW( hWnd, edt1, filename, sizeof(filename)/sizeof(WCHAR));
 733
 734     TRACE("got filename = %s\n", debugstr_w(filename));
 735     /* if we did not click in file list to get there */
 736     if (control != lst1)
 737     {
 738         if (!FILEDLG_TestPath( lfs, filename) )
 739            return FALSE;
 740     }
 741     FILEDLG_UpdateResult(lfs, filename);
 742
 743     if (internalUse)
 744     { /* called internally after a change in a combo */
 745         if (lfs->hook)
 746         {
 747              FILEDLG_CallWindowProc(lfs, lfs->lbselchstring, control,
 748                              MAKELONG(itemIndex,CD_LBSELCHANGE));
 749         }
 750         return TRUE;
 751     }
 752
 753     FILEDLG_UpdateFileTitle(lfs);
 754     if (lfs->hook)
 755     {
 756         lRet = (BOOL)FILEDLG_CallWindowProc(lfs, lfs->fileokstring,
 757                   0, lfs->lParam );
 758         if (lRet)
 759         {
 760             *ofnW = ofnsav; /* restore old state */
 761             return FALSE;
 762         }
 763     }
 764     if ((ofnW->Flags & OFN_ALLOWMULTISELECT) && (ofnW->Flags & OFN_EXPLORER))
 765     {
 766         if (ofnW->lpstrFile)
 767         {
 768             LPWSTR str = (LPWSTR)ofnW->lpstrFile;
 769             LPWSTR ptr = strrchrW(str, '\\');
 770             str[lstrlenW(str) + 1] = '\0';
 771             *ptr = 0;
 772         }
 773     }
 774     return TRUE;
 775 }
 776
 777 /***********************************************************************
 778  *                              FILEDLG_DiskChange             [internal]
 779  *    called when a new item is picked in the disk selection combo
 780  */
 781 static LRESULT FILEDLG_DiskChange( LFSPRIVATE lfs )
 782 {
 783     LONG lRet;
 784     HWND hWnd = lfs->hwnd;
 785     LPWSTR pstr;
 786     WCHAR diskname[BUFFILE];
 787
 788     FILEDLG_StripEditControl(hWnd);
 789     lRet = SendDlgItemMessageW(hWnd, cmb2, CB_GETCURSEL, 0, 0L);
 790     if (lRet == LB_ERR)
 791         return 0;
 792     pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
 793     SendDlgItemMessageW(hWnd, cmb2, CB_GETLBTEXT, lRet,
 794                          (LPARAM)pstr);
 795     wsprintfW(diskname, FILE_specc, pstr[2]);
 796     HeapFree(GetProcessHeap(), 0, pstr);
 797
 798     return FILEDLG_Validate( lfs, diskname, cmb2, lRet, TRUE );
 799 }
 800
 801 /***********************************************************************
 802  *                              FILEDLG_FileTypeChange         [internal]
 803  *    called when a new item is picked in the file type combo
 804  */
 805 static LRESULT FILEDLG_FileTypeChange( LFSPRIVATE lfs )
 806 {
 807     LONG lRet;
 808     WCHAR diskname[BUFFILE];
 809     LPWSTR pstr;
 810
 811     diskname[0] = 0;
 812
 813     lRet = SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETCURSEL, 0, 0);
 814     if (lRet == LB_ERR)
 815         return TRUE;
 816     pstr = (LPWSTR)SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETITEMDATA, lRet, 0);
 817     TRACE("Selected filter : %s\n", debugstr_w(pstr));
 818     SetDlgItemTextW( lfs->hwnd, edt1, pstr );
 819
 820     return FILEDLG_Validate( lfs, NULL, cmb1, lRet, TRUE );
 821 }
 822
 823 /***********************************************************************
 824  *                              FILEDLG_WMCommand               [internal]
 825  */
 826 static LRESULT FILEDLG_WMCommand(HWND hWnd, LPARAM lParam, UINT notification,
 827        UINT control, LFSPRIVATE lfs )
 828 {
 829     switch (control)
 830     {
 831         case lst1: /* file list */
 832         FILEDLG_StripEditControl(hWnd);
 833         if (notification == LBN_DBLCLK)
 834         {
 835             if (FILEDLG_Validate( lfs, NULL, control, 0, FALSE ))
 836                 EndDialog(hWnd, TRUE);
 837             return TRUE;
 838         }
 839         else if (notification == LBN_SELCHANGE)
 840             return FILEDLG_FileListSelect( lfs );
 841         break;
 842
 843         case lst2: /* directory list */
 844         FILEDLG_StripEditControl(hWnd);
 845         if (notification == LBN_DBLCLK)
 846             return FILEDLG_DirListDblClick( lfs );
 847         break;
 848
 849         case cmb1: /* file type drop list */
 850         if (notification == CBN_SELCHANGE)
 851             return FILEDLG_FileTypeChange( lfs );
 852         break;
 853
 854         case chx1:
 855         break;
 856
 857         case pshHelp:
 858         break;
 859
 860         case cmb2: /* disk dropdown combo */
 861         if (notification == CBN_SELCHANGE)
 862             return FILEDLG_DiskChange( lfs );
 863         break;
 864
 865         case IDOK:
 866         TRACE("OK pressed\n");
 867         if (FILEDLG_Validate( lfs, NULL, control, 0, FALSE ))
 868             EndDialog(hWnd, TRUE);
 869         return TRUE;
 870
 871         case IDCANCEL:
 872         EndDialog(hWnd, FALSE);
 873         return TRUE;
 874
 875         case IDABORT: /* can be sent by the hook procedure */
 876         EndDialog(hWnd, TRUE);
 877         return TRUE;
 878     }
 879     return FALSE;
 880 }
 881
 882 /***********************************************************************
 883  *                              FILEDLG_MapDrawItemStruct       [internal]
 884  *      map a 16 bits drawitem struct to 32
 885  */
 886 static void FILEDLG_MapDrawItemStruct(LPDRAWITEMSTRUCT16 lpdis16, LPDRAWITEMSTRUCT lpdis)
 887 {
 888     lpdis->CtlType = lpdis16->CtlType;
 889     lpdis->CtlID = lpdis16->CtlID;
 890     lpdis->itemID = lpdis16->itemID;
 891     lpdis->itemAction = lpdis16->itemAction;
 892     lpdis->itemState = lpdis16->itemState;
 893     lpdis->hwndItem = HWND_32(lpdis16->hwndItem);
 894     lpdis->hDC = HDC_32(lpdis16->hDC);
 895     lpdis->rcItem.right = lpdis16->rcItem.right;
 896     lpdis->rcItem.left = lpdis16->rcItem.left;
 897     lpdis->rcItem.top = lpdis16->rcItem.top;
 898     lpdis->rcItem.bottom = lpdis16->rcItem.bottom;
 899     lpdis->itemData = lpdis16->itemData;
 900 }
 901
 902 /************************************************************************
 903  *                              FILEDLG_MapStringPairsToW       [internal]
 904  *      map string pairs to Unicode
 905  */
 906 static LPWSTR FILEDLG_MapStringPairsToW(LPCSTR strA, UINT size)
 907 {
 908     LPCSTR s;
 909     LPWSTR x;
 910     int n, len;
 911
 912     s = strA;
 913     while (*s)
 914         s = s+strlen(s)+1;
 915     s++;
 916     n = s + 1 - strA; /* Don't forget the other \0 */
 917     if (n < size) n = size;
 918
 919     len = MultiByteToWideChar( CP_ACP, 0, strA, n, NULL, 0 );
 920     x = HeapAlloc(GetProcessHeap(),0, len * sizeof(WCHAR));
 921     MultiByteToWideChar( CP_ACP, 0, strA, n, x, len );
 922     return x;
 923 }
 924
 925
 926 /************************************************************************
 927  *                              FILEDLG_DupToW                  [internal]
 928  *      duplicates an Ansi string to unicode, with a buffer size
 929  */
 930 LPWSTR FILEDLG_DupToW(LPCSTR str, DWORD size)
 931 {
 932     LPWSTR strW = NULL;
 933     if (str && (size > 0))
 934     {
 935         strW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
 936         if (strW) MultiByteToWideChar( CP_ACP, 0, str, -1, strW, size );
 937     }
 938     return strW;
 939 }
 940
 941
 942 /************************************************************************
 943  *                              FILEDLG_MapOfnStructA          [internal]
 944  *      map a 32 bits Ansi structure to an Unicode one
 945  */
 946 void FILEDLG_MapOfnStructA(LPOPENFILENAMEA ofnA, LPOPENFILENAMEW ofnW, BOOL open)
 947 {
 948     LPCSTR str;
 949     UNICODE_STRING usBuffer;
 950
 951     ofnW->lStructSize = sizeof(OPENFILENAMEW);
 952     ofnW->hwndOwner = ofnA->hwndOwner;
 953     ofnW->hInstance = ofnA->hInstance;
 954     if (ofnA->lpstrFilter)
 955         ofnW->lpstrFilter = FILEDLG_MapStringPairsToW(ofnA->lpstrFilter, 0);
 956
 957     if ((ofnA->lpstrCustomFilter) && (*(ofnA->lpstrCustomFilter)))
 958         ofnW->lpstrCustomFilter = FILEDLG_MapStringPairsToW(ofnA->lpstrCustomFilter, ofnA->nMaxCustFilter);
 959     ofnW->nMaxCustFilter = ofnA->nMaxCustFilter;
 960     ofnW->nFilterIndex = ofnA->nFilterIndex;
 961     ofnW->nMaxFile = ofnA->nMaxFile;
 962     ofnW->lpstrFile = FILEDLG_DupToW(ofnA->lpstrFile, ofnW->nMaxFile);
 963     ofnW->nMaxFileTitle = ofnA->nMaxFileTitle;
 964     ofnW->lpstrFileTitle = FILEDLG_DupToW(ofnA->lpstrFileTitle, ofnW->nMaxFileTitle);
 965     if (ofnA->lpstrInitialDir)
 966     {
 967         RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpstrInitialDir);
 968         ofnW->lpstrInitialDir = usBuffer.Buffer;
 969     }
 970     if (ofnA->lpstrTitle)
 971         str = ofnA->lpstrTitle;
 972     else
 973         /* Allocates default title (FIXME : get it from resource) */
 974         str = open ? defaultopen:defaultsave;
 975     RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpstrTitle);
 976     ofnW->lpstrTitle = usBuffer.Buffer;
 977     ofnW->Flags = ofnA->Flags;
 978     ofnW->nFileOffset = ofnA->nFileOffset;
 979     ofnW->nFileExtension = ofnA->nFileExtension;
 980     ofnW->lpstrDefExt = FILEDLG_DupToW(ofnA->lpstrDefExt, 3);
 981     if ((ofnA->Flags & OFN_ENABLETEMPLATE) && (ofnA->lpTemplateName))
 982     {
 983         if (HIWORD(ofnA->lpTemplateName))
 984         {
 985             RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpTemplateName);
 986             ofnW->lpTemplateName = usBuffer.Buffer;
 987         }
 988         else /* numbered resource */
 989             ofnW->lpTemplateName = (LPWSTR) ofnA->lpTemplateName;
 990     }
 991 }
 992
 993 /************************************************************************
 994  *                              FILEDLG_MapOfnStruct16          [internal]
 995  *      map a 16 bits structure to an Unicode one
 996  */
 997 void FILEDLG_MapOfnStruct16(LPOPENFILENAME16 ofn16, LPOPENFILENAMEW ofnW, BOOL open)
 998 {
 999     OPENFILENAMEA ofnA;
1000     /* first convert to linear pointers */
1001     memset(&ofnA, 0, sizeof(OPENFILENAMEA));
1002     ofnA.lStructSize = sizeof(OPENFILENAMEA);
1003     ofnA.hwndOwner = HWND_32(ofn16->hwndOwner);
1004     ofnA.hInstance = HINSTANCE_32(ofn16->hInstance);
1005     if (ofn16->lpstrFilter)
1006         ofnA.lpstrFilter = MapSL(ofn16->lpstrFilter);
1007     if (ofn16->lpstrCustomFilter)
1008         ofnA.lpstrCustomFilter = MapSL(ofn16->lpstrCustomFilter);
1009     ofnA.nMaxCustFilter = ofn16->nMaxCustFilter;
1010     ofnA.nFilterIndex = ofn16->nFilterIndex;
1011     ofnA.lpstrFile = MapSL(ofn16->lpstrFile);
1012     ofnA.nMaxFile = ofn16->nMaxFile;
1013     ofnA.lpstrFileTitle = MapSL(ofn16->lpstrFileTitle);
1014     ofnA.nMaxFileTitle = ofn16->nMaxFileTitle;
1015     ofnA.lpstrInitialDir = MapSL(ofn16->lpstrInitialDir);
1016     ofnA.lpstrTitle = MapSL(ofn16->lpstrTitle);
1017     ofnA.Flags = ofn16->Flags;
1018     ofnA.nFileOffset = ofn16->nFileOffset;
1019     ofnA.nFileExtension = ofn16->nFileExtension;
1020     ofnA.lpstrDefExt = MapSL(ofn16->lpstrDefExt);
1021     if (HIWORD(ofn16->lpTemplateName))
1022         ofnA.lpTemplateName = MapSL(ofn16->lpTemplateName);
1023     else
1024         ofnA.lpTemplateName = (LPSTR) ofn16->lpTemplateName; /* ressource number */
1025     /* now calls the 32 bits Ansi to Unicode version to complete the job */
1026     FILEDLG_MapOfnStructA(&ofnA, ofnW, open);
1027 }
1028
1029 /************************************************************************
1030  *                              FILEDLG_DestroyPrivate            [internal]
1031  *      destroys the private object
1032  */
1033 static void FILEDLG_DestroyPrivate(LFSPRIVATE lfs)
1034 {
1035     HWND hwnd;
1036     if (!lfs) return;
1037     hwnd = lfs->hwnd;
1038     /* free resources for a 16 bits dialog */
1039     if (lfs->hResource16) FreeResource16(lfs->hResource16);
1040     if (lfs->hGlobal16)
1041     {
1042         GlobalUnlock16(lfs->hGlobal16);
1043         GlobalFree16(lfs->hGlobal16);
1044     }
1045     /* if ofnW has been allocated, have to free everything in it */
1046     if (lfs->ofn16 || lfs->ofnA)
1047     {
1048        LPOPENFILENAMEW ofnW = lfs->ofnW;
1049        if (ofnW->lpstrFilter) HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrFilter);
1050        if (ofnW->lpstrCustomFilter) HeapFree(GetProcessHeap(), 0, ofnW->lpstrCustomFilter);
1051        if (ofnW->lpstrFile) HeapFree(GetProcessHeap(), 0, ofnW->lpstrFile);
1052        if (ofnW->lpstrFileTitle) HeapFree(GetProcessHeap(), 0, ofnW->lpstrFileTitle);
1053        if (ofnW->lpstrInitialDir) HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrInitialDir);
1054        if (ofnW->lpstrTitle) HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrTitle);
1055        if ((ofnW->lpTemplateName) && (HIWORD(ofnW->lpTemplateName)))
1056            HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpTemplateName);
1057        HeapFree(GetProcessHeap(), 0, ofnW);
1058     }
1059     TRACE("destroying private allocation %p\n", lfs);
1060     HeapFree(GetProcessHeap(), 0, lfs);
1061     RemovePropA(hwnd, OFN_PROP);
1062 }
1063
1064 /************************************************************************
1065  *                              FILEDLG_AllocPrivate            [internal]
1066  *      allocate a private object to hold 32 bits Unicode
1067  *      structure that will be used throughtout the calls, while
1068  *      keeping available the original structures and a few variables
1069  *      On entry : type = dialog procedure type (16,32A,32W)
1070  *                 dlgType = dialog type (open or save)
1071  */
1072 static LFSPRIVATE FILEDLG_AllocPrivate(LPARAM lParam, int type, UINT dlgType)
1073 {
1074     LFSPRIVATE lfs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct FSPRIVATE));
1075     LFSPRIVATE ret;
1076     TRACE("alloc private buf %p\n", lfs);
1077     if (!lfs) return NULL;
1078     lfs->hook = FALSE;
1079     lfs->lParam = lParam;
1080     if (dlgType == OPEN_DIALOG)
1081         lfs->open = TRUE;
1082     else
1083         lfs->open = FALSE;
1084     lfs->lbselchstring = RegisterWindowMessageA(LBSELCHSTRINGA);
1085     lfs->fileokstring = RegisterWindowMessageA(FILEOKSTRINGA);
1086     switch(type)
1087     {
1088         case LFS16:
1089         lfs->ofn16 = MapSL(lParam);
1090         if (lfs->ofn16->Flags & OFN_ENABLEHOOK)
1091             if (lfs->ofn16->lpfnHook)
1092                 lfs->hook = TRUE;
1093
1094         break;
1095
1096         case LFS32A:
1097         lfs->ofnA = (LPOPENFILENAMEA) lParam;
1098         if (lfs->ofnA->Flags & OFN_ENABLEHOOK)
1099             if (lfs->ofnA->lpfnHook)
1100                 lfs->hook = TRUE;
1101         break;
1102
1103         case LFS32W:
1104         lfs->ofnW = (LPOPENFILENAMEW) lParam;
1105         if (lfs->ofnW->Flags & OFN_ENABLEHOOK)
1106             if (lfs->ofnW->lpfnHook)
1107                 lfs->hook = TRUE;
1108         break;
1109     }
1110     ret = lfs;
1111     if (!lfs->ofnW)
1112     { /* this structure is needed internally, so create it */
1113         lfs->ofnW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OPENFILENAMEW));
1114         if (lfs->ofnW)
1115         {
1116             if (lfs->ofn16)
1117                 FILEDLG_MapOfnStruct16(lfs->ofn16, lfs->ofnW, lfs->open);
1118             if (lfs->ofnA)
1119                 FILEDLG_MapOfnStructA(lfs->ofnA, lfs->ofnW, lfs->open);
1120         }
1121         else
1122             ret = NULL;
1123     }
1124     if (lfs->ofn16)
1125     {
1126         if (!Get16BitsTemplate(lfs)) ret = NULL;
1127     }
1128     else
1129         if (!Get32BitsTemplate(lfs)) ret = NULL;
1130     if (!ret) FILEDLG_DestroyPrivate(lfs);
1131     return ret;
1132 }
1133
1134 /***********************************************************************
1135  *                              FILEDLG_CallWindowProc16          [internal]
1136  *
1137  *      Call the appropriate hook
1138  */
1139 static BOOL FILEDLG_CallWindowProc16(LFSPRIVATE lfs, UINT wMsg, WPARAM wParam,
1140                                    LPARAM lParam)
1141 {
1142     if (lfs->ofn16)
1143     {
1144         return (BOOL16) CallWindowProc16(
1145           (WNDPROC16)lfs->ofn16->lpfnHook, HWND_16(lfs->hwnd),
1146           (UINT16)wMsg, (WPARAM16)wParam, lParam);
1147     }
1148     return FALSE;
1149 }
1150
1151 /***********************************************************************
1152  *                              FILEDLG_WMInitDialog16            [internal]
1153  *      The is a duplicate of the 32bit FILEDLG_WMInitDialog function
1154  *      The only differnce is that it calls FILEDLG_CallWindowProc16
1155  *      for a 16 bit Window Proc.
1156  */
1157
1158 static LONG FILEDLG_WMInitDialog16(HWND hWnd, WPARAM wParam, LPARAM lParam)
1159 {
1160   int i, n;
1161   WCHAR tmpstr[BUFFILE];
1162   LPWSTR pstr, old_pstr;
1163   LPOPENFILENAMEW ofn;
1164   LFSPRIVATE lfs = (LFSPRIVATE) lParam;
1165
1166   if (!lfs) return FALSE;
1167   SetPropA(hWnd, OFN_PROP, (HANDLE)lfs);
1168   lfs->hwnd = hWnd;
1169   ofn = lfs->ofnW;
1170
1171   TRACE("flags=%lx initialdir=%s\n", ofn->Flags, debugstr_w(ofn->lpstrInitialDir));
1172
1173   SetWindowTextW( hWnd, ofn->lpstrTitle );
1174   /* read custom filter information */
1175   if (ofn->lpstrCustomFilter)
1176     {
1177       pstr = ofn->lpstrCustomFilter;
1178       n = 0;
1179       TRACE("lpstrCustomFilter = %p\n", pstr);
1180       while(*pstr)
1181         {
1182           old_pstr = pstr;
1183           i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
1184                                    (LPARAM)(ofn->lpstrCustomFilter) + n );
1185           n += lstrlenW(pstr) + 1;
1186           pstr += lstrlenW(pstr) + 1;
1187           TRACE("add str=%s associated to %s\n",
1188                 debugstr_w(old_pstr), debugstr_w(pstr));
1189           SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
1190           n += lstrlenW(pstr) + 1;
1191           pstr += lstrlenW(pstr) + 1;
1192         }
1193     }
1194   /* read filter information */
1195   if (ofn->lpstrFilter) {
1196         pstr = (LPWSTR) ofn->lpstrFilter;
1197         n = 0;
1198         while(*pstr) {
1199           old_pstr = pstr;
1200           i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
1201                                        (LPARAM)(ofn->lpstrFilter + n) );
1202           n += lstrlenW(pstr) + 1;
1203           pstr += lstrlenW(pstr) + 1;
1204           TRACE("add str=%s associated to %s\n",
1205                 debugstr_w(old_pstr), debugstr_w(pstr));
1206           SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
1207           n += lstrlenW(pstr) + 1;
1208           pstr += lstrlenW(pstr) + 1;
1209         }
1210   }
1211   /* set default filter */
1212   if (ofn->nFilterIndex == 0 && ofn->lpstrCustomFilter == NULL)
1213         ofn->nFilterIndex = 1;
1214   SendDlgItemMessageW(hWnd, cmb1, CB_SETCURSEL, ofn->nFilterIndex - 1, 0);
1215   lstrcpynW(tmpstr, FILEDLG_GetFileType(ofn->lpstrCustomFilter,
1216              (LPWSTR)ofn->lpstrFilter, ofn->nFilterIndex - 1),BUFFILE);
1217   TRACE("nFilterIndex = %ld, SetText of edt1 to %s\n",
1218                         ofn->nFilterIndex, debugstr_w(tmpstr));
1219   SetDlgItemTextW( hWnd, edt1, tmpstr );
1220   /* get drive list */
1221   *tmpstr = 0;
1222   DlgDirListComboBoxW(hWnd, tmpstr, cmb2, 0, DDL_DRIVES | DDL_EXCLUSIVE);
1223   /* read initial directory */
1224   /* FIXME: Note that this is now very version-specific (See MSDN description of
1225    * the OPENFILENAME structure).  For example under 2000/XP any path in the
1226    * lpstrFile overrides the lpstrInitialDir, but not under 95/98/ME
1227    */
1228   if (ofn->lpstrInitialDir != NULL)
1229     {
1230       int len;
1231       lstrcpynW(tmpstr, ofn->lpstrInitialDir, 511);
1232       len = lstrlenW(tmpstr);
1233       if (len > 0 && tmpstr[len-1] != '\\'  && tmpstr[len-1] != ':') {
1234         tmpstr[len]='\\';
1235         tmpstr[len+1]='\0';
1236       }
1237     }
1238   else
1239     *tmpstr = 0;
1240   if (!FILEDLG_ScanDir(hWnd, tmpstr)) {
1241     *tmpstr = 0;
1242     if (!FILEDLG_ScanDir(hWnd, tmpstr))
1243       WARN("Couldn't read initial directory %s!\n", debugstr_w(tmpstr));
1244   }
1245   /* select current drive in combo 2, omit missing drives */
1246   {
1247       char dir[MAX_PATH];
1248       char str[4] = "a:\\";
1249       GetCurrentDirectoryA( sizeof(dir), dir );
1250       for(i = 0, n = -1; i < 26; i++)
1251       {
1252           str[0] = 'a' + i;
1253           if (GetDriveTypeA(str) > DRIVE_NO_ROOT_DIR) n++;
1254           if (toupper(str[0]) == toupper(dir[0])) break;
1255       }
1256   }
1257   SendDlgItemMessageW(hWnd, cmb2, CB_SETCURSEL, n, 0);
1258   if (!(ofn->Flags & OFN_SHOWHELP))
1259     ShowWindow(GetDlgItem(hWnd, pshHelp), SW_HIDE);
1260   if (ofn->Flags & OFN_HIDEREADONLY)
1261     ShowWindow(GetDlgItem(hWnd, chx1), SW_HIDE);
1262   if (lfs->hook)
1263       return (BOOL) FILEDLG_CallWindowProc16(lfs, WM_INITDIALOG, wParam, lfs->lParam);
1264   return TRUE;
1265 }
1266
1267 /***********************************************************************
1268  *                              FILEDLG_WMMeasureItem16         [internal]
1269  */
1270 static LONG FILEDLG_WMMeasureItem16(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
1271 {
1272     LPMEASUREITEMSTRUCT16 lpmeasure;
1273
1274     lpmeasure = MapSL(lParam);
1275     lpmeasure->itemHeight = fldrHeight;
1276     return TRUE;
1277 }
1278
1279 /* ------------------ Dialog procedures ---------------------- */
1280
1281 /***********************************************************************
1282  *           FileOpenDlgProc   (COMMDLG.6)
1283  */
1284 BOOL16 CALLBACK FileOpenDlgProc16(HWND16 hWnd16, UINT16 wMsg, WPARAM16 wParam,
1285                                LPARAM lParam)
1286 {
1287     HWND hWnd = HWND_32(hWnd16);
1288     LFSPRIVATE lfs = (LFSPRIVATE)GetPropA(hWnd,OFN_PROP);
1289     DRAWITEMSTRUCT dis;
1290
1291     TRACE("msg=%x wparam=%x lParam=%lx\n", wMsg, wParam, lParam);
1292     if ((wMsg != WM_INITDIALOG) && lfs && lfs->hook)
1293         {
1294             LRESULT lRet = (BOOL16)FILEDLG_CallWindowProc16(lfs, wMsg, wParam, lParam);
1295             if (lRet)
1296                 return lRet;         /* else continue message processing */
1297         }
1298     switch (wMsg)
1299     {
1300     case WM_INITDIALOG:
1301         return FILEDLG_WMInitDialog16(hWnd, wParam, lParam);
1302
1303     case WM_MEASUREITEM:
1304         return FILEDLG_WMMeasureItem16(hWnd16, wParam, lParam);
1305
1306     case WM_DRAWITEM:
1307         FILEDLG_MapDrawItemStruct(MapSL(lParam), &dis);
1308         return FILEDLG_WMDrawItem(hWnd, wParam, lParam, FALSE, &dis);
1309
1310     case WM_COMMAND:
1311         return FILEDLG_WMCommand(hWnd, lParam, HIWORD(lParam),wParam, lfs);
1312 #if 0
1313     case WM_CTLCOLOR:
1314          SetBkColor((HDC16)wParam, 0x00C0C0C0);
1315          switch (HIWORD(lParam))
1316          {
1317          case CTLCOLOR_BTN:
1318              SetTextColor((HDC16)wParam, 0x00000000);
1319              return hGRAYBrush;
1320         case CTLCOLOR_STATIC:
1321              SetTextColor((HDC16)wParam, 0x00000000);
1322              return hGRAYBrush;
1323         }
1324       break;
1325 #endif
1326     }
1327     return FALSE;
1328 }
1329
1330 /***********************************************************************
1331  *           FileSaveDlgProc   (COMMDLG.7)
1332  */
1333 BOOL16 CALLBACK FileSaveDlgProc16(HWND16 hWnd16, UINT16 wMsg, WPARAM16 wParam,
1334                                LPARAM lParam)
1335 {
1336  HWND hWnd = HWND_32(hWnd16);
1337  LFSPRIVATE lfs = (LFSPRIVATE)GetPropA(hWnd,OFN_PROP);
1338  DRAWITEMSTRUCT dis;
1339
1340  TRACE("msg=%x wparam=%x lParam=%lx\n", wMsg, wParam, lParam);
1341  if ((wMsg != WM_INITDIALOG) && lfs && lfs->hook)
1342   {
1343    LRESULT  lRet;
1344    lRet = (BOOL16)FILEDLG_CallWindowProc16(lfs, wMsg, wParam, lParam);
1345    if (lRet)
1346     return lRet;         /* else continue message processing */
1347   }
1348   switch (wMsg) {
1349    case WM_INITDIALOG:
1350       return FILEDLG_WMInitDialog16(hWnd, wParam, lParam);
1351
1352    case WM_MEASUREITEM:
1353       return FILEDLG_WMMeasureItem16(hWnd16, wParam, lParam);
1354
1355    case WM_DRAWITEM:
1356       FILEDLG_MapDrawItemStruct(MapSL(lParam), &dis);
1357       return FILEDLG_WMDrawItem(hWnd, wParam, lParam, TRUE, &dis);
1358
1359    case WM_COMMAND:
1360       return FILEDLG_WMCommand(hWnd, lParam, HIWORD(lParam), wParam, lfs);
1361   }
1362
1363   /*
1364   case WM_CTLCOLOR:
1365    SetBkColor((HDC16)wParam, 0x00C0C0C0);
1366    switch (HIWORD(lParam))
1367    {
1368     case CTLCOLOR_BTN:
1369      SetTextColor((HDC16)wParam, 0x00000000);
1370      return hGRAYBrush;
1371     case CTLCOLOR_STATIC:
1372      SetTextColor((HDC16)wParam, 0x00000000);
1373      return hGRAYBrush;
1374    }
1375    return FALSE;
1376
1377    */
1378   return FALSE;
1379 }
1380
1381 /* ------------------ APIs ---------------------- */
1382
1383 /***********************************************************************
1384  *           GetOpenFileName   (COMMDLG.1)
1385  *
1386  * Creates a dialog box for the user to select a file to open.
1387  *
1388  * RETURNS
1389  *    TRUE on success: user selected a valid file
1390  *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1391  *
1392  * BUGS
1393  *    unknown, there are some FIXME's left.
1394  */
1395 BOOL16 WINAPI GetOpenFileName16(
1396                                 SEGPTR ofn /* [in/out] address of structure with data*/
1397                                 )
1398 {
1399     HINSTANCE16 hInst;
1400     BOOL bRet = FALSE;
1401     LPOPENFILENAME16 lpofn = MapSL(ofn);
1402     LFSPRIVATE lfs;
1403     FARPROC16 ptr;
1404
1405     if (!lpofn || !FileDlg_Init()) return FALSE;
1406
1407     lfs = FILEDLG_AllocPrivate((LPARAM) ofn, LFS16, OPEN_DIALOG);
1408     if (lfs)
1409     {
1410         hInst = GetWindowWord( HWND_32(lpofn->hwndOwner), GWL_HINSTANCE );
1411         ptr = GetProcAddress16(GetModuleHandle16("COMMDLG"), (LPCSTR) 6);
1412         bRet = DialogBoxIndirectParam16( hInst, lfs->hDlgTmpl16, lpofn->hwndOwner,
1413                                          (DLGPROC16) ptr, (LPARAM) lfs);
1414         FILEDLG_DestroyPrivate(lfs);
1415     }
1416
1417     TRACE("return lpstrFile='%s' !\n", (char *)MapSL(lpofn->lpstrFile));
1418     return bRet;
1419 }
1420
1421 /***********************************************************************
1422  *           GetSaveFileName   (COMMDLG.2)
1423  *
1424  * Creates a dialog box for the user to select a file to save.
1425  *
1426  * RETURNS
1427  *    TRUE on success: user enters a valid file
1428  *    FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1429  *
1430  * BUGS
1431  *    unknown. There are some FIXME's left.
1432  */
1433 BOOL16 WINAPI GetSaveFileName16(
1434                                 SEGPTR ofn /* [in/out] addess of structure with data*/
1435                                 )
1436 {
1437     HINSTANCE16 hInst;
1438     BOOL bRet = FALSE;
1439     LPOPENFILENAME16 lpofn = MapSL(ofn);
1440     LFSPRIVATE lfs;
1441     FARPROC16 ptr;
1442
1443     if (!lpofn || !FileDlg_Init()) return FALSE;
1444
1445     lfs = FILEDLG_AllocPrivate((LPARAM) ofn, LFS16, SAVE_DIALOG);
1446     if (lfs)
1447     {
1448         hInst = GetWindowWord( HWND_32(lpofn->hwndOwner), GWL_HINSTANCE );
1449         ptr = GetProcAddress16(GetModuleHandle16("COMMDLG"), (LPCSTR) 7);
1450         bRet = DialogBoxIndirectParam16( hInst, lfs->hDlgTmpl16, lpofn->hwndOwner,
1451                                          (DLGPROC16) ptr, (LPARAM) lfs);
1452         FILEDLG_DestroyPrivate(lfs);
1453     }
1454
1455     TRACE("return lpstrFile='%s' !\n", (char *)MapSL(lpofn->lpstrFile));
1456     return bRet;
1457 }