3e431782d2157f5bdd27345a3f73efcd0f00d3a2
[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 return;
317
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(lfs->ofnW, 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(lfs->ofnW, 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(lfs->ofnW, 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(lfs->ofnW, 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 = 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 = 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
594 return FD31_Validate( lfs, NULL, cmb1, lRet, TRUE );
595 }
596
597 /***********************************************************************
598 * FD31_WMCommand [internal]
599 */
600 LRESULT FD31_WMCommand(HWND hWnd, LPARAM lParam, UINT notification,
601 UINT control, const FD31_DATA *lfs )
602 {
603 switch (control)
604 {
605 case lst1: /* file list */
606 FD31_StripEditControl(hWnd);
607 if (notification == LBN_DBLCLK)
608 {
609 return SendMessageW(hWnd, WM_COMMAND, IDOK, 0);
610 }
611 else if (notification == LBN_SELCHANGE)
612 return FD31_FileListSelect( lfs );
613 break;
614
615 case lst2: /* directory list */
616 FD31_StripEditControl(hWnd);
617 if (notification == LBN_DBLCLK)
618 return FD31_DirListDblClick( lfs );
619 break;
620
621 case cmb1: /* file type drop list */
622 if (notification == CBN_SELCHANGE)
623 return FD31_FileTypeChange( lfs );
624 break;
625
626 case chx1:
627 break;
628
629 case pshHelp:
630 break;
631
632 case cmb2: /* disk dropdown combo */
633 if (notification == CBN_SELCHANGE)
634 return FD31_DiskChange( lfs );
635 break;
636
637 case IDOK:
638 TRACE("OK pressed\n");
639 if (FD31_Validate( lfs, NULL, control, 0, FALSE ))
640 EndDialog(hWnd, TRUE);
641 return TRUE;
642
643 case IDCANCEL:
644 EndDialog(hWnd, FALSE);
645 return TRUE;
646
647 case IDABORT: /* can be sent by the hook procedure */
648 EndDialog(hWnd, TRUE);
649 return TRUE;
650 }
651 return FALSE;
652 }
653
654 /************************************************************************
655 * FD31_MapStringPairsToW [internal]
656 * map string pairs to Unicode
657 */
658 static LPWSTR FD31_MapStringPairsToW(LPCSTR strA, UINT size)
659 {
660 LPCSTR s;
661 LPWSTR x;
662 unsigned int n, len;
663
664 s = strA;
665 while (*s)
666 s = s+strlen(s)+1;
667 s++;
668 n = s + 1 - strA; /* Don't forget the other \0 */
669 if (n < size) n = size;
670
671 len = MultiByteToWideChar( CP_ACP, 0, strA, n, NULL, 0 );
672 x = HeapAlloc(GetProcessHeap(),0, len * sizeof(WCHAR));
673 MultiByteToWideChar( CP_ACP, 0, strA, n, x, len );
674 return x;
675 }
676
677
678 /************************************************************************
679 * FD31_DupToW [internal]
680 * duplicates an Ansi string to unicode, with a buffer size
681 */
682 static LPWSTR FD31_DupToW(LPCSTR str, DWORD size)
683 {
684 LPWSTR strW = NULL;
685 if (str && (size > 0))
686 {
687 strW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
688 if (strW) MultiByteToWideChar( CP_ACP, 0, str, -1, strW, size );
689 }
690 return strW;
691 }
692
693 /************************************************************************
694 * FD31_MapOfnStructA [internal]
695 * map a 32 bits Ansi structure to a Unicode one
696 */
697 void FD31_MapOfnStructA(const OPENFILENAMEA *ofnA, LPOPENFILENAMEW ofnW, BOOL open)
698 {
699 UNICODE_STRING usBuffer;
700
701 ofnW->lStructSize = sizeof(OPENFILENAMEW);
702 ofnW->hwndOwner = ofnA->hwndOwner;
703 ofnW->hInstance = ofnA->hInstance;
704 if (ofnA->lpstrFilter)
705 ofnW->lpstrFilter = FD31_MapStringPairsToW(ofnA->lpstrFilter, 0);
706
707 if ((ofnA->lpstrCustomFilter) && (*(ofnA->lpstrCustomFilter)))
708 ofnW->lpstrCustomFilter = FD31_MapStringPairsToW(ofnA->lpstrCustomFilter, ofnA->nMaxCustFilter);
709 ofnW->nMaxCustFilter = ofnA->nMaxCustFilter;
710 ofnW->nFilterIndex = ofnA->nFilterIndex;
711 ofnW->nMaxFile = ofnA->nMaxFile;
712 ofnW->lpstrFile = FD31_DupToW(ofnA->lpstrFile, ofnW->nMaxFile);
713 ofnW->nMaxFileTitle = ofnA->nMaxFileTitle;
714 ofnW->lpstrFileTitle = FD31_DupToW(ofnA->lpstrFileTitle, ofnW->nMaxFileTitle);
715 if (ofnA->lpstrInitialDir)
716 {
717 RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpstrInitialDir);
718 ofnW->lpstrInitialDir = usBuffer.Buffer;
719 }
720 if (ofnA->lpstrTitle) {
721 RtlCreateUnicodeStringFromAsciiz (&usBuffer, ofnA->lpstrTitle);
722 ofnW->lpstrTitle = usBuffer.Buffer;
723 } else {
724 WCHAR buf[16];
725 LPWSTR title_tmp;
726 int len;
727 LoadStringW(COMDLG32_hInstance, open ? IDS_OPEN_FILE : IDS_SAVE_AS,
728 buf, sizeof(buf)/sizeof(WCHAR));
729 len = lstrlenW(buf)+1;
730 title_tmp = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
731 memcpy(title_tmp, buf, len * sizeof(WCHAR));
732 ofnW->lpstrTitle = title_tmp;
733 }
734 ofnW->Flags = ofnA->Flags;
735 ofnW->nFileOffset = ofnA->nFileOffset;
736 ofnW->nFileExtension = ofnA->nFileExtension;
737 ofnW->lpstrDefExt = FD31_DupToW(ofnA->lpstrDefExt, 3);
738 if ((ofnA->Flags & OFN_ENABLETEMPLATE) && (ofnA->lpTemplateName))
739 {
740 if (HIWORD(ofnA->lpTemplateName))
741 {
742 RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpTemplateName);
743 ofnW->lpTemplateName = usBuffer.Buffer;
744 }
745 else /* numbered resource */
746 ofnW->lpTemplateName = (LPCWSTR) ofnA->lpTemplateName;
747 }
748 }
749
750
751 /************************************************************************
752 * FD31_FreeOfnW [internal]
753 * Undo all allocations done by FD31_MapOfnStructA
754 */
755 void FD31_FreeOfnW(OPENFILENAMEW *ofnW)
756 {
757 HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrFilter);
758 HeapFree(GetProcessHeap(), 0, ofnW->lpstrCustomFilter);
759 HeapFree(GetProcessHeap(), 0, ofnW->lpstrFile);
760 HeapFree(GetProcessHeap(), 0, ofnW->lpstrFileTitle);
761 HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrInitialDir);
762 HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrTitle);
763 if (HIWORD(ofnW->lpTemplateName))
764 HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpTemplateName);
765 }
766
767 /************************************************************************
768 * FD31_DestroyPrivate [internal]
769 * destroys the private object
770 */
771 void FD31_DestroyPrivate(PFD31_DATA lfs)
772 {
773 HWND hwnd;
774 if (!lfs) return;
775 hwnd = lfs->hwnd;
776 TRACE("destroying private allocation %p\n", lfs);
777 lfs->callbacks->Destroy(lfs);
778 HeapFree(GetProcessHeap(), 0, lfs);
779 RemovePropA(hwnd, FD31_OFN_PROP);
780 }
781
782 /************************************************************************
783 * FD31_AllocPrivate [internal]
784 * allocate a private object to hold 32 bits Unicode
785 * structure that will be used throughout the calls, while
786 * keeping available the original structures and a few variables
787 * On entry : type = dialog procedure type (16,32A,32W)
788 * dlgType = dialog type (open or save)
789 */
790 PFD31_DATA FD31_AllocPrivate(LPARAM lParam, UINT dlgType,
791 PFD31_CALLBACKS callbacks, DWORD data)
792 {
793 PFD31_DATA lfs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FD31_DATA));
794
795 TRACE("alloc private buf %p\n", lfs);
796 if (!lfs) return NULL;
797 lfs->hook = FALSE;
798 lfs->lParam = lParam;
799 lfs->open = (dlgType == OPEN_DIALOG);
800 lfs->callbacks = callbacks;
801 if (! lfs->callbacks->Init(lParam, lfs, data))
802 {
803 FD31_DestroyPrivate(lfs);
804 return NULL;
805 }
806 lfs->lbselchstring = RegisterWindowMessageA(LBSELCHSTRINGA);
807 lfs->fileokstring = RegisterWindowMessageA(FILEOKSTRINGA);
808
809 return lfs;
810 }
811
812 /***********************************************************************
813 * FD31_WMInitDialog [internal]
814 */
815
816 LONG FD31_WMInitDialog(HWND hWnd, WPARAM wParam, LPARAM lParam)
817 {
818 int i, n;
819 WCHAR tmpstr[BUFFILE];
820 LPWSTR pstr, old_pstr;
821 LPOPENFILENAMEW ofn;
822 PFD31_DATA lfs = (PFD31_DATA) lParam;
823
824 if (!lfs) return FALSE;
825 SetPropA(hWnd, FD31_OFN_PROP, lfs);
826 lfs->hwnd = hWnd;
827 ofn = lfs->ofnW;
828
829 TRACE("flags=%x initialdir=%s\n", ofn->Flags, debugstr_w(ofn->lpstrInitialDir));
830
831 SetWindowTextW( hWnd, ofn->lpstrTitle );
832 /* read custom filter information */
833 if (ofn->lpstrCustomFilter)
834 {
835 pstr = ofn->lpstrCustomFilter;
836 n = 0;
837 TRACE("lpstrCustomFilter = %p\n", pstr);
838 while(*pstr)
839 {
840 old_pstr = pstr;
841 i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
842 (LPARAM)(ofn->lpstrCustomFilter) + n );
843 n += lstrlenW(pstr) + 1;
844 pstr += lstrlenW(pstr) + 1;
845 TRACE("add str=%s associated to %s\n",
846 debugstr_w(old_pstr), debugstr_w(pstr));
847 SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
848 n += lstrlenW(pstr) + 1;
849 pstr += lstrlenW(pstr) + 1;
850 }
851 }
852 /* read filter information */
853 if (ofn->lpstrFilter) {
854 pstr = (LPWSTR) ofn->lpstrFilter;
855 n = 0;
856 while(*pstr) {
857 old_pstr = pstr;
858 i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
859 (LPARAM)(ofn->lpstrFilter + n) );
860 n += lstrlenW(pstr) + 1;
861 pstr += lstrlenW(pstr) + 1;
862 TRACE("add str=%s associated to %s\n",
863 debugstr_w(old_pstr), debugstr_w(pstr));
864 SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
865 n += lstrlenW(pstr) + 1;
866 pstr += lstrlenW(pstr) + 1;
867 }
868 }
869 /* set default filter */
870 if (ofn->nFilterIndex == 0 && ofn->lpstrCustomFilter == NULL)
871 ofn->nFilterIndex = 1;
872 SendDlgItemMessageW(hWnd, cmb1, CB_SETCURSEL, ofn->nFilterIndex - 1, 0);
873 if (ofn->lpstrFile && ofn->lpstrFile[0])
874 {
875 TRACE( "SetText of edt1 to %s\n", debugstr_w(ofn->lpstrFile) );
876 SetDlgItemTextW( hWnd, edt1, ofn->lpstrFile );
877 }
878 else
879 {
880 lstrcpynW(tmpstr, FD31_GetFileType(ofn->lpstrCustomFilter,
881 ofn->lpstrFilter, ofn->nFilterIndex - 1),BUFFILE);
882 TRACE("nFilterIndex = %d, SetText of edt1 to %s\n",
883 ofn->nFilterIndex, debugstr_w(tmpstr));
884 SetDlgItemTextW( hWnd, edt1, tmpstr );
885 }
886 /* get drive list */
887 *tmpstr = 0;
888 DlgDirListComboBoxW(hWnd, tmpstr, cmb2, 0, DDL_DRIVES | DDL_EXCLUSIVE);
889 /* read initial directory */
890 /* FIXME: Note that this is now very version-specific (See MSDN description of
891 * the OPENFILENAME structure). For example under 2000/XP any path in the
892 * lpstrFile overrides the lpstrInitialDir, but not under 95/98/ME
893 */
894 if (ofn->lpstrInitialDir != NULL)
895 {
896 int len;
897 lstrcpynW(tmpstr, ofn->lpstrInitialDir, 511);
898 len = lstrlenW(tmpstr);
899 if (len > 0 && tmpstr[len-1] != '\\' && tmpstr[len-1] != ':') {
900 tmpstr[len]='\\';
901 tmpstr[len+1]='\0';
902 }
903 }
904 else
905 *tmpstr = 0;
906 if (!FD31_ScanDir(ofn, hWnd, tmpstr)) {
907 *tmpstr = 0;
908 if (!FD31_ScanDir(ofn, hWnd, tmpstr))
909 WARN("Couldn't read initial directory %s!\n", debugstr_w(tmpstr));
910 }
911 /* select current drive in combo 2, omit missing drives */
912 {
913 char dir[MAX_PATH];
914 char str[4] = "a:\\";
915 GetCurrentDirectoryA( sizeof(dir), dir );
916 for(i = 0, n = -1; i < 26; i++)
917 {
918 str[0] = 'a' + i;
919 if (GetDriveTypeA(str) > DRIVE_NO_ROOT_DIR) n++;
920 if (toupper(str[0]) == toupper(dir[0])) break;
921 }
922 }
923 SendDlgItemMessageW(hWnd, cmb2, CB_SETCURSEL, n, 0);
924 if (!(ofn->Flags & OFN_SHOWHELP))
925 ShowWindow(GetDlgItem(hWnd, pshHelp), SW_HIDE);
926 if (ofn->Flags & OFN_HIDEREADONLY)
927 ShowWindow(GetDlgItem(hWnd, chx1), SW_HIDE);
928 if (lfs->hook)
929 return FD31_CallWindowProc(lfs, WM_INITDIALOG, wParam, lfs->lParam);
930 return TRUE;
931 }
932
933 int FD31_GetFldrHeight(void)
934 {
935 return fldrHeight;
936 }