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