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