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