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