Return correct attributes in ParseDisplayName.
[wine] / dlls / commdlg / filedlg31.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/unicode.h"
32 #include "wine/debug.h"
33 #include "cderr.h"
34 #include "winreg.h"
35 #include "winternl.h"
36 #include "winuser.h"
37 #include "commdlg.h"
38 #include "cderr.h"
39 #include "winreg.h"
40 #include "winternl.h"
41 #include "shlwapi.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
44
45 #include "cdlg.h"
46 #include "filedlg31.h"
47
48 #define BUFFILE 512
49 #define BUFFILEALLOC 512 * sizeof(WCHAR)
50
51 static const WCHAR FILE_star[] = {'*','.','*', 0};
52 static const WCHAR FILE_bslash[] = {'\\', 0};
53 static const WCHAR FILE_specc[] = {'%','c',':', 0};
54 static const int fldrHeight = 16;
55 static const int fldrWidth = 20;
56
57 static HICON hFolder = 0;
58 static HICON hFolder2 = 0;
59 static HICON hFloppy = 0;
60 static HICON hHDisk = 0;
61 static HICON hCDRom = 0;
62 static HICON hNet = 0;
63
64 /***********************************************************************
65  *                              FD31_Init                       [internal]
66  */
67 BOOL FD31_Init(void)
68 {
69     static BOOL initialized = 0;
70
71     if (!initialized) {
72         hFolder  = LoadImageA( COMDLG32_hInstance, "FOLDER", IMAGE_ICON, 16, 16, LR_SHARED );
73         hFolder2 = LoadImageA( COMDLG32_hInstance, "FOLDER2", IMAGE_ICON, 16, 16, LR_SHARED );
74         hFloppy  = LoadImageA( COMDLG32_hInstance, "FLOPPY", IMAGE_ICON, 16, 16, LR_SHARED );
75         hHDisk   = LoadImageA( COMDLG32_hInstance, "HDISK", IMAGE_ICON, 16, 16, LR_SHARED );
76         hCDRom   = LoadImageA( COMDLG32_hInstance, "CDROM", IMAGE_ICON, 16, 16, LR_SHARED );
77         hNet     = LoadImageA( COMDLG32_hInstance, "NETWORK", IMAGE_ICON, 16, 16, LR_SHARED );
78         if (hFolder == 0 || hFolder2 == 0 || hFloppy == 0 ||
79             hHDisk == 0 || hCDRom == 0 || hNet == 0)
80         {
81             ERR("Error loading icons !\n");
82             return FALSE;
83         }
84         initialized = TRUE;
85     }
86     return TRUE;
87 }
88
89 /***********************************************************************
90  *                              FD31_StripEditControl        [internal]
91  * Strip pathnames off the contents of the edit control.
92  */
93 static void FD31_StripEditControl(HWND hwnd)
94 {
95     WCHAR temp[BUFFILE], *cp;
96
97     GetDlgItemTextW( hwnd, edt1, temp, sizeof(temp)/sizeof(WCHAR));
98     cp = strrchrW(temp, '\\');
99     if (cp != NULL) {
100         strcpyW(temp, cp+1);
101     }
102     cp = strrchrW(temp, ':');
103     if (cp != NULL) {
104         strcpyW(temp, cp+1);
105     }
106     /* FIXME: shouldn't we do something with the result here? ;-) */
107 }
108
109 /***********************************************************************
110  *                              FD31_CallWindowProc          [internal]
111  *
112  *      Call the appropriate hook
113  */
114 BOOL FD31_CallWindowProc(PFD31_DATA lfs, UINT wMsg, WPARAM wParam,
115                          LPARAM lParam)
116 {
117     return lfs->callbacks->CWP(lfs, wMsg, wParam, lParam);
118 }
119
120 /***********************************************************************
121  *                              FD31_ScanDir                 [internal]
122  */
123 static BOOL FD31_ScanDir(HWND hWnd, LPWSTR newPath)
124 {
125     WCHAR               buffer[BUFFILE];
126     HWND                hdlg, hdlgDir;
127     LRESULT             lRet = TRUE;
128     HCURSOR             hCursorWait, oldCursor;
129
130     TRACE("Trying to change to %s\n", debugstr_w(newPath));
131     if  ( newPath[0] && !SetCurrentDirectoryW( newPath ))
132         return FALSE;
133     lstrcpynW(buffer, newPath, sizeof(buffer)/sizeof(WCHAR));
134
135     /* get the list of spec files */
136     GetDlgItemTextW(hWnd, edt1, buffer, sizeof(buffer)/sizeof(WCHAR));
137
138     hCursorWait = LoadCursorA(0, (LPSTR)IDC_WAIT);
139     oldCursor = SetCursor(hCursorWait);
140
141     /* list of files */
142     if ((hdlg = GetDlgItem(hWnd, lst1)) != 0) {
143         WCHAR*  scptr; /* ptr on semi-colon */
144         WCHAR*  filter = buffer;
145
146         TRACE("Using filter %s\n", debugstr_w(filter));
147         SendMessageW(hdlg, LB_RESETCONTENT, 0, 0);
148         while (filter) {
149             scptr = strchrW(filter, ';');
150             if (scptr)  *scptr = 0;
151             while (*filter == ' ') filter++;
152             TRACE("Using file spec %s\n", debugstr_w(filter));
153             if (SendMessageW(hdlg, LB_DIR, 0, (LPARAM)filter) == LB_ERR)
154                 return FALSE;
155             if (scptr) *scptr = ';';
156                 filter = (scptr) ? (scptr + 1) : 0;
157          }
158     }
159
160     /* list of directories */
161     strcpyW(buffer, FILE_star);
162
163     if ((hdlgDir = GetDlgItem(hWnd, lst2)) != 0) {
164         lRet = DlgDirListW(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY);
165     }
166     SetCursor(oldCursor);
167     return lRet;
168 }
169
170 /***********************************************************************
171  *                              FD31_GetFileType                [internal]
172  */
173
174 static LPWSTR FD31_GetFileType(LPWSTR cfptr, LPWSTR fptr, WORD index)
175 {
176   int n, i;
177   i = 0;
178   if (cfptr)
179     for ( ;(n = lstrlenW(cfptr)) != 0; i++)
180       {
181         cfptr += n + 1;
182         if (i == index)
183           return cfptr;
184         cfptr += lstrlenW(cfptr) + 1;
185       }
186   if (fptr)
187     for ( ;(n = lstrlenW(fptr)) != 0; i++)
188       {
189         fptr += n + 1;
190         if (i == index)
191           return fptr;
192         fptr += lstrlenW(fptr) + 1;
193     }
194   return (LPWSTR) FILE_star; /* FIXME */
195 }
196
197 /***********************************************************************
198  *                              FD31_WMDrawItem              [internal]
199  */
200 LONG FD31_WMDrawItem(HWND hWnd, WPARAM wParam, LPARAM lParam,
201        int savedlg, LPDRAWITEMSTRUCT lpdis)
202 {
203     WCHAR *str;
204     HICON hIcon;
205     COLORREF oldText = 0, oldBk = 0;
206
207     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst1)
208     {
209         if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC))) return FALSE;
210         SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID,
211                       (LPARAM)str);
212
213         if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
214         {
215             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
216             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
217         }
218         if (savedlg)
219             SetTextColor(lpdis->hDC,GetSysColor(COLOR_GRAYTEXT) );
220
221         ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + 1,
222                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
223                   &(lpdis->rcItem), str, lstrlenW(str), NULL);
224
225         if (lpdis->itemState & ODS_SELECTED)
226             DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
227
228         if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
229         {
230             SetBkColor( lpdis->hDC, oldBk );
231             SetTextColor( lpdis->hDC, oldText );
232         }
233         HeapFree(GetProcessHeap(), 0, str);
234         return TRUE;
235     }
236
237     if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst2)
238     {
239         if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
240             return FALSE;
241         SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID,
242                       (LPARAM)str);
243
244         if (lpdis->itemState & ODS_SELECTED)
245         {
246             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
247             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
248         }
249         ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
250                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
251                   &(lpdis->rcItem), str, lstrlenW(str), NULL);
252
253         if (lpdis->itemState & ODS_SELECTED)
254             DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
255
256         if (lpdis->itemState & ODS_SELECTED)
257         {
258             SetBkColor( lpdis->hDC, oldBk );
259             SetTextColor( lpdis->hDC, oldText );
260         }
261         DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hFolder);
262         HeapFree(GetProcessHeap(), 0, str);
263         return TRUE;
264     }
265     if (lpdis->CtlType == ODT_COMBOBOX && lpdis->CtlID == cmb2)
266     {
267         char root[] = "a:";
268         if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
269             return FALSE;
270         SendMessageW(lpdis->hwndItem, CB_GETLBTEXT, lpdis->itemID,
271                       (LPARAM)str);
272         root[0] += str[2] - 'a';
273         switch(GetDriveTypeA(root))
274         {
275         case DRIVE_REMOVABLE: hIcon = hFloppy; break;
276         case DRIVE_CDROM:     hIcon = hCDRom; break;
277         case DRIVE_REMOTE:    hIcon = hNet; break;
278         case DRIVE_FIXED:
279         default:           hIcon = hHDisk; break;
280         }
281         if (lpdis->itemState & ODS_SELECTED)
282         {
283             oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
284             oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
285         }
286         ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
287                   lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
288                   &(lpdis->rcItem), str, lstrlenW(str), NULL);
289
290         if (lpdis->itemState & ODS_SELECTED)
291         {
292             SetBkColor( lpdis->hDC, oldBk );
293             SetTextColor( lpdis->hDC, oldText );
294         }
295         DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hIcon);
296         HeapFree(GetProcessHeap(), 0, str);
297         return TRUE;
298     }
299     return FALSE;
300 }
301
302 /***********************************************************************
303  *                              FD31_UpdateResult            [internal]
304  *      update the displayed file name (with path)
305  */
306 static void FD31_UpdateResult(PFD31_DATA lfs, WCHAR *tmpstr)
307 {
308     int lenstr2;
309     LPOPENFILENAMEW ofnW = lfs->ofnW;
310     WCHAR tmpstr2[BUFFILE];
311     WCHAR *p;
312
313     TRACE("%s\n", debugstr_w(tmpstr));
314     if(ofnW->Flags & OFN_NOVALIDATE)
315         tmpstr2[0] = '\0';
316     else
317         GetCurrentDirectoryW(BUFFILE, tmpstr2);
318     lenstr2 = strlenW(tmpstr2);
319     if (lenstr2 > 3)
320         tmpstr2[lenstr2++]='\\';
321     lstrcpynW(tmpstr2+lenstr2, tmpstr, BUFFILE-lenstr2);
322     if (ofnW->lpstrFile)
323         lstrcpynW(ofnW->lpstrFile, tmpstr2, ofnW->nMaxFile);
324
325     /* set filename offset */
326     p = PathFindFileNameW(ofnW->lpstrFile);
327     ofnW->nFileOffset = (p - ofnW->lpstrFile);
328
329     /* set extension offset */
330     p = PathFindExtensionW(ofnW->lpstrFile);
331     ofnW->nFileExtension = (*p) ? (p - ofnW->lpstrFile) + 1 : 0;
332
333     TRACE("file %s, file offset %d, ext offset %d\n",
334           debugstr_w(ofnW->lpstrFile), ofnW->nFileOffset, ofnW->nFileExtension);
335
336     /* update the real client structures if any */
337     lfs->callbacks->UpdateResult(lfs);
338 }
339
340 /***********************************************************************
341  *                              FD31_UpdateFileTitle         [internal]
342  *      update the displayed file name (without path)
343  */
344 static void FD31_UpdateFileTitle(PFD31_DATA lfs)
345 {
346   LONG lRet;
347   LPOPENFILENAMEW ofnW = lfs->ofnW;
348   if (ofnW->lpstrFileTitle != NULL)
349   {
350     lRet = SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETCURSEL, 0, 0);
351     SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETTEXT, lRet,
352                              (LPARAM)ofnW->lpstrFileTitle );
353     lfs->callbacks->UpdateFileTitle(lfs);
354   }
355 }
356
357 /***********************************************************************
358  *                              FD31_DirListDblClick         [internal]
359  */
360 static LRESULT FD31_DirListDblClick( PFD31_DATA lfs )
361 {
362   LONG lRet;
363   HWND hWnd = lfs->hwnd;
364   LPWSTR pstr;
365   WCHAR tmpstr[BUFFILE];
366
367   /* get the raw string (with brackets) */
368   lRet = SendDlgItemMessageW(hWnd, lst2, LB_GETCURSEL, 0, 0);
369   if (lRet == LB_ERR) return TRUE;
370   pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
371   SendDlgItemMessageW(hWnd, lst2, LB_GETTEXT, lRet,
372                      (LPARAM)pstr);
373   strcpyW( tmpstr, pstr );
374   HeapFree(GetProcessHeap(), 0, pstr);
375   /* get the selected directory in tmpstr */
376   if (tmpstr[0] == '[')
377     {
378       tmpstr[lstrlenW(tmpstr) - 1] = 0;
379       strcpyW(tmpstr,tmpstr+1);
380     }
381   strcatW(tmpstr, FILE_bslash);
382
383   FD31_ScanDir(hWnd, tmpstr);
384   /* notify the app */
385   if (lfs->hook)
386     {
387       if (FD31_CallWindowProc(lfs, lfs->lbselchstring, lst2,
388               MAKELONG(lRet,CD_LBSELCHANGE)))
389         return TRUE;
390     }
391   return TRUE;
392 }
393
394 /***********************************************************************
395  *                              FD31_FileListSelect         [internal]
396  *    called when a new item is picked in the file list
397  */
398 static LRESULT FD31_FileListSelect( PFD31_DATA lfs )
399 {
400     LONG lRet;
401     HWND hWnd = lfs->hwnd;
402     LPWSTR pstr;
403
404     lRet = lfs->callbacks->SendLbGetCurSel(lfs);
405     if (lRet == LB_ERR)
406         return TRUE;
407
408     /* set the edit control to the choosen file */
409     if ((pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
410     {
411         SendDlgItemMessageW(hWnd, lst1, LB_GETTEXT, lRet,
412                        (LPARAM)pstr);
413         SetDlgItemTextW( hWnd, edt1, pstr );
414         HeapFree(GetProcessHeap(), 0, pstr);
415     }
416     if (lfs->hook)
417     {
418         FD31_CallWindowProc(lfs, lfs->lbselchstring, lst1,
419                            MAKELONG(lRet,CD_LBSELCHANGE));
420     }
421     /* FIXME: for OFN_ALLOWMULTISELECT we need CD_LBSELSUB, CD_SELADD,
422            CD_LBSELNOITEMS */
423     return TRUE;
424 }
425
426 /***********************************************************************
427  *                              FD31_TestPath      [internal]
428  *      before accepting the file name, test if it includes wild cards
429  *      tries to scan the directory and returns TRUE if no error.
430  */
431 static LRESULT FD31_TestPath( PFD31_DATA lfs, LPWSTR path )
432 {
433     HWND hWnd = lfs->hwnd;
434     LPWSTR pBeginFileName, pstr2;
435     WCHAR tmpstr2[BUFFILE];
436
437     pBeginFileName = strrchrW(path, '\\');
438     if (pBeginFileName == NULL)
439         pBeginFileName = strrchrW(path, ':');
440
441     if (strchrW(path,'*') != NULL || strchrW(path,'?') != NULL)
442     {
443         /* edit control contains wildcards */
444         if (pBeginFileName != NULL)
445         {
446             lstrcpynW(tmpstr2, pBeginFileName + 1, BUFFILE);
447             *(pBeginFileName + 1) = 0;
448         }
449         else
450         {
451             strcpyW(tmpstr2, path);
452             if(!(lfs->ofnW->Flags & OFN_NOVALIDATE))
453                 *path = 0;
454         }
455
456         TRACE("path=%s, tmpstr2=%s\n", debugstr_w(path), debugstr_w(tmpstr2));
457         SetDlgItemTextW( hWnd, edt1, tmpstr2 );
458         FD31_ScanDir(hWnd, path);
459         return (lfs->ofnW->Flags & OFN_NOVALIDATE) ? TRUE : FALSE;
460     }
461
462     /* no wildcards, we might have a directory or a filename */
463     /* try appending a wildcard and reading the directory */
464
465     pstr2 = path + lstrlenW(path);
466     if (pBeginFileName == NULL || *(pBeginFileName + 1) != 0)
467         strcatW(path, FILE_bslash);
468
469     /* if ScanDir succeeds, we have changed the directory */
470     if (FD31_ScanDir(hWnd, path))
471         return FALSE; /* and path is not a valid file name */
472
473     /* if not, this must be a filename */
474
475     *pstr2 = 0; /* remove the wildcard added before */
476
477     if (pBeginFileName != NULL)
478     {
479         /* strip off the pathname */
480         *pBeginFileName = 0;
481         SetDlgItemTextW( hWnd, edt1, pBeginFileName + 1 );
482
483         lstrcpynW(tmpstr2, pBeginFileName + 1, sizeof(tmpstr2)/sizeof(WCHAR) );
484         /* Should we MessageBox() if this fails? */
485         if (!FD31_ScanDir(hWnd, path))
486         {
487             return FALSE;
488         }
489         strcpyW(path, tmpstr2);
490     }
491     else
492         SetDlgItemTextW( hWnd, edt1, path );
493     return TRUE;
494 }
495
496 /***********************************************************************
497  *                              FD31_Validate               [internal]
498  *   called on: click Ok button, Enter in edit, DoubleClick in file list
499  */
500 static LRESULT FD31_Validate( PFD31_DATA lfs, LPWSTR path, UINT control, INT itemIndex,
501                                  BOOL internalUse )
502 {
503     LONG lRet;
504     HWND hWnd = lfs->hwnd;
505     OPENFILENAMEW ofnsav;
506     LPOPENFILENAMEW ofnW = lfs->ofnW;
507     WCHAR filename[BUFFILE];
508
509     ofnsav = *ofnW; /* for later restoring */
510
511     /* get current file name */
512     if (path)
513         lstrcpynW(filename, path, sizeof(filename)/sizeof(WCHAR));
514     else
515         GetDlgItemTextW( hWnd, edt1, filename, sizeof(filename)/sizeof(WCHAR));
516
517     TRACE("got filename = %s\n", debugstr_w(filename));
518     /* if we did not click in file list to get there */
519     if (control != lst1)
520     {
521         if (!FD31_TestPath( lfs, filename) )
522            return FALSE;
523     }
524     FD31_UpdateResult(lfs, filename);
525
526     if (internalUse)
527     { /* called internally after a change in a combo */
528         if (lfs->hook)
529         {
530              FD31_CallWindowProc(lfs, lfs->lbselchstring, control,
531                              MAKELONG(itemIndex,CD_LBSELCHANGE));
532         }
533         return TRUE;
534     }
535
536     FD31_UpdateFileTitle(lfs);
537     if (lfs->hook)
538     {
539         lRet = (BOOL)FD31_CallWindowProc(lfs, lfs->fileokstring,
540                   0, lfs->lParam );
541         if (lRet)
542         {
543             *ofnW = ofnsav; /* restore old state */
544             return FALSE;
545         }
546     }
547     if ((ofnW->Flags & OFN_ALLOWMULTISELECT) && (ofnW->Flags & OFN_EXPLORER))
548     {
549         if (ofnW->lpstrFile)
550         {
551             LPWSTR str = (LPWSTR)ofnW->lpstrFile;
552             LPWSTR ptr = strrchrW(str, '\\');
553             str[lstrlenW(str) + 1] = '\0';
554             *ptr = 0;
555         }
556     }
557     return TRUE;
558 }
559
560 /***********************************************************************
561  *                              FD31_DiskChange             [internal]
562  *    called when a new item is picked in the disk selection combo
563  */
564 static LRESULT FD31_DiskChange( PFD31_DATA lfs )
565 {
566     LONG lRet;
567     HWND hWnd = lfs->hwnd;
568     LPWSTR pstr;
569     WCHAR diskname[BUFFILE];
570
571     FD31_StripEditControl(hWnd);
572     lRet = SendDlgItemMessageW(hWnd, cmb2, CB_GETCURSEL, 0, 0L);
573     if (lRet == LB_ERR)
574         return 0;
575     pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
576     SendDlgItemMessageW(hWnd, cmb2, CB_GETLBTEXT, lRet,
577                          (LPARAM)pstr);
578     wsprintfW(diskname, FILE_specc, pstr[2]);
579     HeapFree(GetProcessHeap(), 0, pstr);
580
581     return FD31_Validate( lfs, diskname, cmb2, lRet, TRUE );
582 }
583
584 /***********************************************************************
585  *                              FD31_FileTypeChange         [internal]
586  *    called when a new item is picked in the file type combo
587  */
588 static LRESULT FD31_FileTypeChange( PFD31_DATA lfs )
589 {
590     LONG lRet;
591     LPWSTR pstr;
592
593     lRet = SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETCURSEL, 0, 0);
594     if (lRet == LB_ERR)
595         return TRUE;
596     pstr = (LPWSTR)SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETITEMDATA, lRet, 0);
597     TRACE("Selected filter : %s\n", debugstr_w(pstr));
598     SetDlgItemTextW( lfs->hwnd, edt1, pstr );
599
600     return FD31_Validate( lfs, NULL, cmb1, lRet, TRUE );
601 }
602
603 /***********************************************************************
604  *                              FD31_WMCommand               [internal]
605  */
606 LRESULT FD31_WMCommand(HWND hWnd, LPARAM lParam, UINT notification,
607        UINT control, PFD31_DATA lfs )
608 {
609     switch (control)
610     {
611         case lst1: /* file list */
612         FD31_StripEditControl(hWnd);
613         if (notification == LBN_DBLCLK)
614         {
615             return SendMessageW(hWnd, WM_COMMAND, IDOK, 0);
616         }
617         else if (notification == LBN_SELCHANGE)
618             return FD31_FileListSelect( lfs );
619         break;
620
621         case lst2: /* directory list */
622         FD31_StripEditControl(hWnd);
623         if (notification == LBN_DBLCLK)
624             return FD31_DirListDblClick( lfs );
625         break;
626
627         case cmb1: /* file type drop list */
628         if (notification == CBN_SELCHANGE)
629             return FD31_FileTypeChange( lfs );
630         break;
631
632         case chx1:
633         break;
634
635         case pshHelp:
636         break;
637
638         case cmb2: /* disk dropdown combo */
639         if (notification == CBN_SELCHANGE)
640             return FD31_DiskChange( lfs );
641         break;
642
643         case IDOK:
644         TRACE("OK pressed\n");
645         if (FD31_Validate( lfs, NULL, control, 0, FALSE ))
646             EndDialog(hWnd, TRUE);
647         return TRUE;
648
649         case IDCANCEL:
650         EndDialog(hWnd, FALSE);
651         return TRUE;
652
653         case IDABORT: /* can be sent by the hook procedure */
654         EndDialog(hWnd, TRUE);
655         return TRUE;
656     }
657     return FALSE;
658 }
659
660 /************************************************************************
661  *                              FD31_MapStringPairsToW       [internal]
662  *      map string pairs to Unicode
663  */
664 static LPWSTR FD31_MapStringPairsToW(LPCSTR strA, UINT size)
665 {
666     LPCSTR s;
667     LPWSTR x;
668     unsigned int n, len;
669
670     s = strA;
671     while (*s)
672         s = s+strlen(s)+1;
673     s++;
674     n = s + 1 - strA; /* Don't forget the other \0 */
675     if (n < size) n = size;
676
677     len = MultiByteToWideChar( CP_ACP, 0, strA, n, NULL, 0 );
678     x = HeapAlloc(GetProcessHeap(),0, len * sizeof(WCHAR));
679     MultiByteToWideChar( CP_ACP, 0, strA, n, x, len );
680     return x;
681 }
682
683
684 /************************************************************************
685  *                              FD31_DupToW                  [internal]
686  *      duplicates an Ansi string to unicode, with a buffer size
687  */
688 static LPWSTR FD31_DupToW(LPCSTR str, DWORD size)
689 {
690     LPWSTR strW = NULL;
691     if (str && (size > 0))
692     {
693         strW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
694         if (strW) MultiByteToWideChar( CP_ACP, 0, str, -1, strW, size );
695     }
696     return strW;
697 }
698
699 /************************************************************************
700  *                              FD31_MapOfnStructA          [internal]
701  *      map a 32 bits Ansi structure to an Unicode one
702  */
703 void FD31_MapOfnStructA(const LPOPENFILENAMEA ofnA, LPOPENFILENAMEW ofnW, BOOL open)
704 {
705     UNICODE_STRING usBuffer;
706
707     ofnW->lStructSize = sizeof(OPENFILENAMEW);
708     ofnW->hwndOwner = ofnA->hwndOwner;
709     ofnW->hInstance = ofnA->hInstance;
710     if (ofnA->lpstrFilter)
711         ofnW->lpstrFilter = FD31_MapStringPairsToW(ofnA->lpstrFilter, 0);
712
713     if ((ofnA->lpstrCustomFilter) && (*(ofnA->lpstrCustomFilter)))
714         ofnW->lpstrCustomFilter = FD31_MapStringPairsToW(ofnA->lpstrCustomFilter, ofnA->nMaxCustFilter);
715     ofnW->nMaxCustFilter = ofnA->nMaxCustFilter;
716     ofnW->nFilterIndex = ofnA->nFilterIndex;
717     ofnW->nMaxFile = ofnA->nMaxFile;
718     ofnW->lpstrFile = FD31_DupToW(ofnA->lpstrFile, ofnW->nMaxFile);
719     ofnW->nMaxFileTitle = ofnA->nMaxFileTitle;
720     ofnW->lpstrFileTitle = FD31_DupToW(ofnA->lpstrFileTitle, ofnW->nMaxFileTitle);
721     if (ofnA->lpstrInitialDir)
722     {
723         RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpstrInitialDir);
724         ofnW->lpstrInitialDir = usBuffer.Buffer;
725     }
726     if (ofnA->lpstrTitle) {
727         RtlCreateUnicodeStringFromAsciiz (&usBuffer, ofnA->lpstrTitle);
728         ofnW->lpstrTitle = usBuffer.Buffer;
729     } else {
730         WCHAR buf[16];
731         int len;
732         LoadStringW(COMDLG32_hInstance, open ? IDS_OPEN_FILE : IDS_SAVE_AS,
733                     buf, sizeof(buf)/sizeof(WCHAR));
734         len = lstrlenW(buf)+1;
735         ofnW->lpstrTitle = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
736         memcpy((void*)ofnW->lpstrTitle, buf, len*sizeof(WCHAR));
737     }
738     ofnW->Flags = ofnA->Flags;
739     ofnW->nFileOffset = ofnA->nFileOffset;
740     ofnW->nFileExtension = ofnA->nFileExtension;
741     ofnW->lpstrDefExt = FD31_DupToW(ofnA->lpstrDefExt, 3);
742     if ((ofnA->Flags & OFN_ENABLETEMPLATE) && (ofnA->lpTemplateName))
743     {
744         if (HIWORD(ofnA->lpTemplateName))
745         {
746             RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpTemplateName);
747             ofnW->lpTemplateName = usBuffer.Buffer;
748         }
749         else /* numbered resource */
750             ofnW->lpTemplateName = (LPWSTR) ofnA->lpTemplateName;
751     }
752 }
753
754
755 /************************************************************************
756  *                              FD31_FreeOfnW          [internal]
757  *      Undo all allocations done by FD31_MapOfnStructA
758  */
759 void FD31_FreeOfnW(LPOPENFILENAMEW ofnW)
760 {
761    HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrFilter);
762    HeapFree(GetProcessHeap(), 0, ofnW->lpstrCustomFilter);
763    HeapFree(GetProcessHeap(), 0, ofnW->lpstrFile);
764    HeapFree(GetProcessHeap(), 0, ofnW->lpstrFileTitle);
765    HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrInitialDir);
766    HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrTitle);
767    if ((ofnW->lpTemplateName) && (HIWORD(ofnW->lpTemplateName)))
768        HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpTemplateName);
769 }
770
771 /************************************************************************
772  *                              FD31_DestroyPrivate            [internal]
773  *      destroys the private object
774  */
775 void FD31_DestroyPrivate(PFD31_DATA lfs)
776 {
777     HWND hwnd;
778     if (!lfs) return;
779     hwnd = lfs->hwnd;
780     TRACE("destroying private allocation %p\n", lfs);
781     lfs->callbacks->Destroy(lfs);
782     HeapFree(GetProcessHeap(), 0, lfs);
783     RemovePropA(hwnd, FD31_OFN_PROP);
784 }
785
786 /************************************************************************
787  *                              FD31_AllocPrivate            [internal]
788  *      allocate a private object to hold 32 bits Unicode
789  *      structure that will be used throughtout the calls, while
790  *      keeping available the original structures and a few variables
791  *      On entry : type = dialog procedure type (16,32A,32W)
792  *                 dlgType = dialog type (open or save)
793  */
794 PFD31_DATA FD31_AllocPrivate(LPARAM lParam, UINT dlgType,
795                              PFD31_CALLBACKS callbacks, DWORD data)
796 {
797     PFD31_DATA lfs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FD31_DATA));
798
799     TRACE("alloc private buf %p\n", lfs);
800     if (!lfs) return NULL;
801     lfs->hook = FALSE;
802     lfs->lParam = lParam;
803     lfs->open = (dlgType == OPEN_DIALOG);
804     lfs->callbacks = callbacks;
805     if (! lfs->callbacks->Init(lParam, lfs, data))
806     {
807         FD31_DestroyPrivate(lfs);
808         return NULL;
809     }
810     lfs->lbselchstring = RegisterWindowMessageA(LBSELCHSTRINGA);
811     lfs->fileokstring = RegisterWindowMessageA(FILEOKSTRINGA);
812
813     return lfs;
814 }
815
816 /***********************************************************************
817  *                              FD31_WMInitDialog            [internal]
818  */
819
820 LONG FD31_WMInitDialog(HWND hWnd, WPARAM wParam, LPARAM lParam)
821 {
822   int i, n;
823   WCHAR tmpstr[BUFFILE];
824   LPWSTR pstr, old_pstr;
825   LPOPENFILENAMEW ofn;
826   PFD31_DATA lfs = (PFD31_DATA) lParam;
827
828   if (!lfs) return FALSE;
829   SetPropA(hWnd, FD31_OFN_PROP, (HANDLE)lfs);
830   lfs->hwnd = hWnd;
831   ofn = lfs->ofnW;
832
833   TRACE("flags=%lx initialdir=%s\n", ofn->Flags, debugstr_w(ofn->lpstrInitialDir));
834
835   SetWindowTextW( hWnd, ofn->lpstrTitle );
836   /* read custom filter information */
837   if (ofn->lpstrCustomFilter)
838     {
839       pstr = ofn->lpstrCustomFilter;
840       n = 0;
841       TRACE("lpstrCustomFilter = %p\n", pstr);
842       while(*pstr)
843         {
844           old_pstr = pstr;
845           i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
846                                    (LPARAM)(ofn->lpstrCustomFilter) + n );
847           n += lstrlenW(pstr) + 1;
848           pstr += lstrlenW(pstr) + 1;
849           TRACE("add str=%s associated to %s\n",
850                 debugstr_w(old_pstr), debugstr_w(pstr));
851           SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
852           n += lstrlenW(pstr) + 1;
853           pstr += lstrlenW(pstr) + 1;
854         }
855     }
856   /* read filter information */
857   if (ofn->lpstrFilter) {
858         pstr = (LPWSTR) ofn->lpstrFilter;
859         n = 0;
860         while(*pstr) {
861           old_pstr = pstr;
862           i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
863                                        (LPARAM)(ofn->lpstrFilter + n) );
864           n += lstrlenW(pstr) + 1;
865           pstr += lstrlenW(pstr) + 1;
866           TRACE("add str=%s associated to %s\n",
867                 debugstr_w(old_pstr), debugstr_w(pstr));
868           SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
869           n += lstrlenW(pstr) + 1;
870           pstr += lstrlenW(pstr) + 1;
871         }
872   }
873   /* set default filter */
874   if (ofn->nFilterIndex == 0 && ofn->lpstrCustomFilter == NULL)
875         ofn->nFilterIndex = 1;
876   SendDlgItemMessageW(hWnd, cmb1, CB_SETCURSEL, ofn->nFilterIndex - 1, 0);
877   lstrcpynW(tmpstr, FD31_GetFileType(ofn->lpstrCustomFilter,
878              (LPWSTR)ofn->lpstrFilter, ofn->nFilterIndex - 1),BUFFILE);
879   TRACE("nFilterIndex = %ld, SetText of edt1 to %s\n",
880                         ofn->nFilterIndex, debugstr_w(tmpstr));
881   SetDlgItemTextW( hWnd, edt1, tmpstr );
882   /* get drive list */
883   *tmpstr = 0;
884   DlgDirListComboBoxW(hWnd, tmpstr, cmb2, 0, DDL_DRIVES | DDL_EXCLUSIVE);
885   /* read initial directory */
886   /* FIXME: Note that this is now very version-specific (See MSDN description of
887    * the OPENFILENAME structure).  For example under 2000/XP any path in the
888    * lpstrFile overrides the lpstrInitialDir, but not under 95/98/ME
889    */
890   if (ofn->lpstrInitialDir != NULL)
891     {
892       int len;
893       lstrcpynW(tmpstr, ofn->lpstrInitialDir, 511);
894       len = lstrlenW(tmpstr);
895       if (len > 0 && tmpstr[len-1] != '\\'  && tmpstr[len-1] != ':') {
896         tmpstr[len]='\\';
897         tmpstr[len+1]='\0';
898       }
899     }
900   else
901     *tmpstr = 0;
902   if (!FD31_ScanDir(hWnd, tmpstr)) {
903     *tmpstr = 0;
904     if (!FD31_ScanDir(hWnd, tmpstr))
905       WARN("Couldn't read initial directory %s!\n", debugstr_w(tmpstr));
906   }
907   /* select current drive in combo 2, omit missing drives */
908   {
909       char dir[MAX_PATH];
910       char str[4] = "a:\\";
911       GetCurrentDirectoryA( sizeof(dir), dir );
912       for(i = 0, n = -1; i < 26; i++)
913       {
914           str[0] = 'a' + i;
915           if (GetDriveTypeA(str) > DRIVE_NO_ROOT_DIR) n++;
916           if (toupper(str[0]) == toupper(dir[0])) break;
917       }
918   }
919   SendDlgItemMessageW(hWnd, cmb2, CB_SETCURSEL, n, 0);
920   if (!(ofn->Flags & OFN_SHOWHELP))
921     ShowWindow(GetDlgItem(hWnd, pshHelp), SW_HIDE);
922   if (ofn->Flags & OFN_HIDEREADONLY)
923     ShowWindow(GetDlgItem(hWnd, chx1), SW_HIDE);
924   if (lfs->hook)
925       return (BOOL) FD31_CallWindowProc(lfs, WM_INITDIALOG, wParam, lfs->lParam);
926   return TRUE;
927 }
928
929 int FD31_GetFldrHeight(void)
930 {
931   return fldrHeight;
932 }