c8fcf7e220b4fbfd595ec0d45614a03e7d6d79a3
[reactos.git] / reactos / dll / win32 / 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 }