?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20040408.
[wine.git] / dlls / commdlg / filedlg16.c
blobdac494f2f1e900139ec3af0778549c44b57ad097
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 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/winbase16.h"
32 #include "wine/winuser16.h"
33 #include "wine/unicode.h"
34 #include "wine/debug.h"
35 #include "cderr.h"
36 #include "winreg.h"
37 #include "winternl.h"
38 #include "winuser.h"
39 #include "commdlg.h"
40 #include "cderr.h"
41 #include "winreg.h"
42 #include "winternl.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
45
46 #include "cdlg.h"
47 #include "cdlg16.h"
48
49 #define BUFFILE 512
50 #define BUFFILEALLOC 512 * sizeof(WCHAR)
51
52 struct FSPRIVATE
53 {
54 HWND hwnd; /* file dialog window handle */
55 BOOL hook; /* TRUE if the dialog is hooked */
56 UINT lbselchstring; /* registered message id */
57 UINT fileokstring; /* registered message id */
58 LPARAM lParam; /* save original lparam */
59 HANDLE16 hDlgTmpl16; /* handle for resource 16 */
60 HANDLE16 hResource16; /* handle for allocated resource 16 */
61 HANDLE16 hGlobal16; /* 16 bits mem block (resources) */
62 LPCVOID template; /* template for 32 bits resource */
63 BOOL open; /* TRUE if open dialog, FALSE if save dialog */
64 OPENFILENAMEW *ofnW; /* original structure or work struct */
65 OPENFILENAMEA *ofnA; /* original structure if 32bits ansi dialog */
66 OPENFILENAME16 *ofn16; /* original structure if 16 bits dialog */
67 };
68
69 #define LFSPRIVATE struct FSPRIVATE *
70 #define LFS16 1
71 #define LFS32A 2
72 #define LFS32W 3
73 #define OFN_PROP "FILEDLG_OFN"
74
75 static const WCHAR FILE_star[] = {'*','.','*', 0};
76 static const WCHAR FILE_bslash[] = {'\\', 0};
77 static const WCHAR FILE_specc[] = {'%','c',':', 0};
78 static const int fldrHeight = 16;
79 static const int fldrWidth = 20;
80
81 static HICON hFolder = 0;
82 static HICON hFolder2 = 0;
83 static HICON hFloppy = 0;
84 static HICON hHDisk = 0;
85 static HICON hCDRom = 0;
86 static HICON hNet = 0;
87 static char defaultopen[]="Open File";
88 static char defaultsave[]="Save as";
89
90 /***********************************************************************
91 * FileDlg_Init [internal]
92 */
93 static BOOL FileDlg_Init(void)
94 {
95 static BOOL initialized = 0;
96
97 if (!initialized) {
98 hFolder = LoadImageA( COMDLG32_hInstance, "FOLDER", IMAGE_ICON, 16, 16, LR_SHARED );
99 hFolder2 = LoadImageA( COMDLG32_hInstance, "FOLDER2", IMAGE_ICON, 16, 16, LR_SHARED );
100 hFloppy = LoadImageA( COMDLG32_hInstance, "FLOPPY", IMAGE_ICON, 16, 16, LR_SHARED );
101 hHDisk = LoadImageA( COMDLG32_hInstance, "HDISK", IMAGE_ICON, 16, 16, LR_SHARED );
102 hCDRom = LoadImageA( COMDLG32_hInstance, "CDROM", IMAGE_ICON, 16, 16, LR_SHARED );
103 hNet = LoadImageA( COMDLG32_hInstance, "NETWORK", IMAGE_ICON, 16, 16, LR_SHARED );
104 if (hFolder == 0 || hFolder2 == 0 || hFloppy == 0 ||
105 hHDisk == 0 || hCDRom == 0 || hNet == 0)
106 {
107 ERR("Error loading icons !\n");
108 return FALSE;
109 }
110 initialized = TRUE;
111 }
112 return TRUE;
113 }
114
115 /***********************************************************************
116 * Get32BitsTemplate [internal]
117 *
118 * Get a template (or FALSE if failure) when 16 bits dialogs are used
119 * by a 32 bits application
120 *
121 */
122 BOOL Get32BitsTemplate(LFSPRIVATE lfs)
123 {
124 LPOPENFILENAMEW ofnW = lfs->ofnW;
125 HANDLE hDlgTmpl;
126
127 if (ofnW->Flags & OFN_ENABLETEMPLATEHANDLE)
128 {
129 if (!(lfs->template = LockResource( ofnW->hInstance )))
130 {
131 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
132 return FALSE;
133 }
134 }
135 else if (ofnW->Flags & OFN_ENABLETEMPLATE)
136 {
137 HRSRC hResInfo;
138 if (lfs->ofnA)
139 hResInfo = FindResourceA(lfs->ofnA->hInstance,
140 lfs->ofnA->lpTemplateName,
141 (LPSTR)RT_DIALOG);
142 else
143 hResInfo = FindResourceW(ofnW->hInstance,
144 ofnW->lpTemplateName,
145 (LPWSTR)RT_DIALOG);
146 if (!hResInfo)
147 {
148 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
149 return FALSE;
150 }
151 if (!(hDlgTmpl = LoadResource(ofnW->hInstance,
152 hResInfo)) ||
153 !(lfs->template = LockResource(hDlgTmpl)))
154 {
155 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
156 return FALSE;
157 }
158 } else { /* get it from internal Wine resource */
159 HRSRC hResInfo;
160 if (!(hResInfo = FindResourceA(COMDLG32_hInstance,
161 lfs->open? "OPEN_FILE":"SAVE_FILE", (LPSTR)RT_DIALOG)))
162 {
163 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
164 return FALSE;
165 }
166 if (!(hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo )) ||
167 !(lfs->template = LockResource( hDlgTmpl )))
168 {
169 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
170 return FALSE;
171 }
172 }
173 return TRUE;
174 }
175
176 /***********************************************************************
177 * Get16BitsTemplate [internal]
178 *
179 * Get a template (FALSE if failure) when 16 bits dialogs are used
180 * by a 16 bits application
181 *
182 */
183 BOOL Get16BitsTemplate(LFSPRIVATE lfs)
184 {
185 LPOPENFILENAME16 ofn16 = lfs->ofn16;
186 LPCVOID template;
187 HGLOBAL16 hGlobal16 = 0;
188
189 if (ofn16->Flags & OFN_ENABLETEMPLATEHANDLE)
190 lfs->hDlgTmpl16 = ofn16->hInstance;
191 else if (ofn16->Flags & OFN_ENABLETEMPLATE)
192 {
193 HANDLE16 hResInfo;
194 if (!(hResInfo = FindResource16(ofn16->hInstance,
195 MapSL(ofn16->lpTemplateName),
196 (LPSTR)RT_DIALOG)))
197 {
198 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
199 return FALSE;
200 }
201 if (!(lfs->hDlgTmpl16 = LoadResource16( ofn16->hInstance, hResInfo )))
202 {
203 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
204 return FALSE;
205 }
206 lfs->hResource16 = lfs->hDlgTmpl16;
207 }
208 else
209 { /* get resource from (32 bits) own Wine resource; convert it to 16 */
210 HRSRC hResInfo;
211 HGLOBAL hDlgTmpl32;
212 LPCVOID template32;
213 DWORD size;
214
215 if (!(hResInfo = FindResourceA(COMDLG32_hInstance,
216 lfs->open ? "OPEN_FILE":"SAVE_FILE", (LPSTR)RT_DIALOG)))
217 {
218 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
219 return FALSE;
220 }
221 if (!(hDlgTmpl32 = LoadResource(COMDLG32_hInstance, hResInfo )) ||
222 !(template32 = LockResource( hDlgTmpl32 )))
223 {
224 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
225 return FALSE;
226 }
227 size = SizeofResource(COMDLG32_hInstance, hResInfo);
228 hGlobal16 = GlobalAlloc16(0, size);
229 if (!hGlobal16)
230 {
231 COMDLG32_SetCommDlgExtendedError(CDERR_MEMALLOCFAILURE);
232 ERR("alloc failure for %ld bytes\n", size);
233 return FALSE;
234 }
235 template = GlobalLock16(hGlobal16);
236 if (!template)
237 {
238 COMDLG32_SetCommDlgExtendedError(CDERR_MEMLOCKFAILURE);
239 ERR("global lock failure for %x handle\n", hGlobal16);
240 GlobalFree16(hGlobal16);
241 return FALSE;
242 }
243 ConvertDialog32To16((LPVOID)template32, size, (LPVOID)template);
244 lfs->hDlgTmpl16 = hGlobal16;
245 lfs->hGlobal16 = hGlobal16;
246 }
247 return TRUE;
248 }
249
250 /***********************************************************************
251 * FILEDLG_StripEditControl [internal]
252 * Strip pathnames off the contents of the edit control.
253 */
254 static void FILEDLG_StripEditControl(HWND hwnd)
255 {
256 WCHAR temp[BUFFILE], *cp;
257
258 GetDlgItemTextW( hwnd, edt1, temp, sizeof(temp)/sizeof(WCHAR));
259 cp = strrchrW(temp, '\\');
260 if (cp != NULL) {
261 strcpyW(temp, cp+1);
262 }
263 cp = strrchrW(temp, ':');
264 if (cp != NULL) {
265 strcpyW(temp, cp+1);
266 }
267 /* FIXME: shouldn't we do something with the result here? ;-) */
268 }
269
270 /***********************************************************************
271 * FILEDLG_CallWindowProc [internal]
272 *
273 * Call the appropriate hook
274 */
275 static BOOL FILEDLG_CallWindowProc(LFSPRIVATE lfs, UINT wMsg, WPARAM wParam,
276 LPARAM lParam)
277 {
278 if (lfs->ofnA)
279 {
280 return (BOOL) CallWindowProcA(
281 (WNDPROC)lfs->ofnA->lpfnHook, lfs->hwnd,
282 wMsg, wParam, lParam);
283 }
284
285 if (lfs->ofnW)
286 {
287 return (BOOL) CallWindowProcW(
288 (WNDPROC)lfs->ofnW->lpfnHook, lfs->hwnd,
289 wMsg, wParam, lParam);
290 }
291 return FALSE;
292 }
293
294 /***********************************************************************
295 * FILEDLG_ScanDir [internal]
296 */
297 static BOOL FILEDLG_ScanDir(HWND hWnd, LPWSTR newPath)
298 {
299 WCHAR buffer[BUFFILE];
300 HWND hdlg, hdlgDir;
301 LRESULT lRet = TRUE;
302 HCURSOR hCursorWait, oldCursor;
303
304 TRACE("Trying to change to %s\n", debugstr_w(newPath));
305 if ( !SetCurrentDirectoryW( newPath ))
306 return FALSE;
307 lstrcpynW(buffer, newPath, sizeof(buffer)/sizeof(WCHAR));
308
309 /* get the list of spec files */
310 GetDlgItemTextW(hWnd, edt1, buffer, sizeof(buffer)/sizeof(WCHAR));
311
312 hCursorWait = LoadCursorA(0, (LPSTR)IDC_WAIT);
313 oldCursor = SetCursor(hCursorWait);
314
315 /* list of files */
316 if ((hdlg = GetDlgItem(hWnd, lst1)) != 0) {
317 WCHAR* scptr; /* ptr on semi-colon */
318 WCHAR* filter = buffer;
319
320 TRACE("Using filter %s\n", debugstr_w(filter));
321 SendMessageW(hdlg, LB_RESETCONTENT, 0, 0);
322 while (filter) {
323 scptr = strchrW(filter, ';');
324 if (scptr) *scptr = 0;
325 while (*filter == ' ') filter++;
326 TRACE("Using file spec %s\n", debugstr_w(filter));
327 if (SendMessageW(hdlg, LB_DIR, 0, (LPARAM)filter) == LB_ERR)
328 return FALSE;
329 if (scptr) *scptr = ';';
330 filter = (scptr) ? (scptr + 1) : 0;
331 }
332 }
333
334 /* list of directories */
335 strcpyW(buffer, FILE_star);
336
337 if ((hdlgDir = GetDlgItem(hWnd, lst2)) != 0) {
338 lRet = DlgDirListW(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY);
339 }
340 SetCursor(oldCursor);
341 return lRet;
342 }
343
344 /***********************************************************************
345 * FILEDLG_GetFileType [internal]
346 */
347
348 static LPWSTR FILEDLG_GetFileType(LPWSTR cfptr, LPWSTR fptr, WORD index)
349 {
350 int n, i;
351 i = 0;
352 if (cfptr)
353 for ( ;(n = lstrlenW(cfptr)) != 0; i++)
354 {
355 cfptr += n + 1;
356 if (i == index)
357 return cfptr;
358 cfptr += lstrlenW(cfptr) + 1;
359 }
360 if (fptr)
361 for ( ;(n = lstrlenW(fptr)) != 0; i++)
362 {
363 fptr += n + 1;
364 if (i == index)
365 return fptr;
366 fptr += lstrlenW(fptr) + 1;
367 }
368 return (LPWSTR) FILE_star; /* FIXME */
369 }
370
371 /***********************************************************************
372 * FILEDLG_WMDrawItem [internal]
373 */
374 static LONG FILEDLG_WMDrawItem(HWND hWnd, WPARAM wParam, LPARAM lParam,
375 int savedlg, LPDRAWITEMSTRUCT lpdis)
376 {
377 WCHAR *str;
378 HICON hIcon;
379 COLORREF oldText = 0, oldBk = 0;
380
381 if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst1)
382 {
383 if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC))) return FALSE;
384 SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID,
385 (LPARAM)str);
386
387 if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
388 {
389 oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
390 oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
391 }
392 if (savedlg)
393 SetTextColor(lpdis->hDC,GetSysColor(COLOR_GRAYTEXT) );
394
395 ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + 1,
396 lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
397 &(lpdis->rcItem), str, lstrlenW(str), NULL);
398
399 if (lpdis->itemState & ODS_SELECTED)
400 DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
401
402 if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
403 {
404 SetBkColor( lpdis->hDC, oldBk );
405 SetTextColor( lpdis->hDC, oldText );
406 }
407 HeapFree(GetProcessHeap(), 0, str);
408 return TRUE;
409 }
410
411 if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst2)
412 {
413 if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
414 return FALSE;
415 SendMessageW(lpdis->hwndItem, LB_GETTEXT, lpdis->itemID,
416 (LPARAM)str);
417
418 if (lpdis->itemState & ODS_SELECTED)
419 {
420 oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
421 oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
422 }
423 ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
424 lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
425 &(lpdis->rcItem), str, lstrlenW(str), NULL);
426
427 if (lpdis->itemState & ODS_SELECTED)
428 DrawFocusRect( lpdis->hDC, &(lpdis->rcItem) );
429
430 if (lpdis->itemState & ODS_SELECTED)
431 {
432 SetBkColor( lpdis->hDC, oldBk );
433 SetTextColor( lpdis->hDC, oldText );
434 }
435 DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hFolder);
436 HeapFree(GetProcessHeap(), 0, str);
437 return TRUE;
438 }
439 if (lpdis->CtlType == ODT_COMBOBOX && lpdis->CtlID == cmb2)
440 {
441 char root[] = "a:";
442 if (!(str = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
443 return FALSE;
444 SendMessageW(lpdis->hwndItem, CB_GETLBTEXT, lpdis->itemID,
445 (LPARAM)str);
446 root[0] += str[2] - 'a';
447 switch(GetDriveTypeA(root))
448 {
449 case DRIVE_REMOVABLE: hIcon = hFloppy; break;
450 case DRIVE_CDROM: hIcon = hCDRom; break;
451 case DRIVE_REMOTE: hIcon = hNet; break;
452 case DRIVE_FIXED:
453 default: hIcon = hHDisk; break;
454 }
455 if (lpdis->itemState & ODS_SELECTED)
456 {
457 oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
458 oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
459 }
460 ExtTextOutW(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
461 lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
462 &(lpdis->rcItem), str, lstrlenW(str), NULL);
463
464 if (lpdis->itemState & ODS_SELECTED)
465 {
466 SetBkColor( lpdis->hDC, oldBk );
467 SetTextColor( lpdis->hDC, oldText );
468 }
469 DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hIcon);
470 HeapFree(GetProcessHeap(), 0, str);
471 return TRUE;
472 }
473 return FALSE;
474 }
475
476 /***********************************************************************
477 * FILEDLG_UpdateResult [internal]
478 * update the displayed file name (with path)
479 */
480 void FILEDLG_UpdateResult(LFSPRIVATE lfs, WCHAR *tmpstr)
481 {
482 int lenstr2;
483 LPOPENFILENAMEW ofnW = lfs->ofnW;
484 WCHAR tmpstr2[BUFFILE];
485 WCHAR *bs;
486
487 TRACE("%s\n", debugstr_w(tmpstr));
488 if(ofnW->Flags & OFN_NOVALIDATE)
489 tmpstr2[0] = '\0';
490 else
491 GetCurrentDirectoryW(BUFFILE, tmpstr2);
492 lenstr2 = strlenW(tmpstr2);
493 if (lenstr2 > 3)
494 tmpstr2[lenstr2++]='\\';
495 lstrcpynW(tmpstr2+lenstr2, tmpstr, BUFFILE-lenstr2);
496 if (ofnW->lpstrFile)
497 lstrcpynW(ofnW->lpstrFile, tmpstr2, ofnW->nMaxFile);
498 if((bs = strrchrW(tmpstr2, '\\')) != NULL)
499 ofnW->nFileOffset = bs - tmpstr2 +1;
500 else
501 ofnW->nFileOffset = 0;
502 ofnW->nFileExtension = 0;
503 while(tmpstr2[ofnW->nFileExtension] != '.' && tmpstr2[ofnW->nFileExtension] != '\0')
504 ofnW->nFileExtension++;
505 if (tmpstr2[ofnW->nFileExtension] == '\0')
506 ofnW->nFileExtension = 0;
507 else
508 ofnW->nFileExtension++;
509 /* update the real client structures if any */
510 if (lfs->ofn16)
511 { /* we have to convert to short (8.3) path */
512 char tmp[1024]; /* MAX_PATHNAME_LEN */
513 LPOPENFILENAME16 ofn16 = lfs->ofn16;
514 char *dest = MapSL(ofn16->lpstrFile);
515 char *bs16;
516 if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFile, -1,
517 tmp, sizeof(tmp), NULL, NULL ))
518 tmp[sizeof(tmp)-1] = 0;
519 GetShortPathNameA(tmp, dest, ofn16->nMaxFile);
520
521 /* the same procedure as every year... */
522 if((bs16 = strrchr(dest, '\\')) != NULL)
523 ofn16->nFileOffset = bs16 - dest +1;
524 else
525 ofn16->nFileOffset = 0;
526 ofn16->nFileExtension = 0;
527 while(dest[ofn16->nFileExtension] != '.' && dest[ofn16->nFileExtension] != '\0')
528 ofn16->nFileExtension++;
529 if (dest[ofn16->nFileExtension] == '\0')
530 ofn16->nFileExtension = 0;
531 else
532 ofn16->nFileExtension++;
533 }
534 if (lfs->ofnA)
535 {
536 if (ofnW->nMaxFile &&
537 !WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFile, -1,
538 lfs->ofnA->lpstrFile, ofnW->nMaxFile, NULL, NULL ))
539 lfs->ofnA->lpstrFile[ofnW->nMaxFile-1] = 0;
540 lfs->ofnA->nFileOffset = ofnW->nFileOffset;
541 lfs->ofnA->nFileExtension = ofnW->nFileExtension;
542 }
543 }
544
545 /***********************************************************************
546 * FILEDLG_UpdateFileTitle [internal]
547 * update the displayed file name (without path)
548 */
549 void FILEDLG_UpdateFileTitle(LFSPRIVATE lfs)
550 {
551 LONG lRet;
552 LPOPENFILENAMEW ofnW = lfs->ofnW;
553 if (ofnW->lpstrFileTitle != NULL)
554 {
555 lRet = SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETCURSEL, 0, 0);
556 SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETTEXT, lRet,
557 (LPARAM)ofnW->lpstrFileTitle );
558 if (lfs->ofn16)
559 {
560 char *dest = MapSL(lfs->ofn16->lpstrFileTitle);
561 if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFileTitle, -1,
562 dest, ofnW->nMaxFileTitle, NULL, NULL ))
563 dest[ofnW->nMaxFileTitle-1] = 0;
564 }
565 if (lfs->ofnA)
566 {
567 if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFileTitle, -1,
568 lfs->ofnA->lpstrFileTitle, ofnW->nMaxFileTitle, NULL, NULL ))
569 lfs->ofnA->lpstrFileTitle[ofnW->nMaxFileTitle-1] = 0;
570 }
571 }
572 }
573
574 /***********************************************************************
575 * FILEDLG_DirListDblClick [internal]
576 */
577 static LRESULT FILEDLG_DirListDblClick( LFSPRIVATE lfs )
578 {
579 LONG lRet;
580 HWND hWnd = lfs->hwnd;
581 LPWSTR pstr;
582 WCHAR tmpstr[BUFFILE];
583
584 /* get the raw string (with brackets) */
585 lRet = SendDlgItemMessageW(hWnd, lst2, LB_GETCURSEL, 0, 0);
586 if (lRet == LB_ERR) return TRUE;
587 pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
588 SendDlgItemMessageW(hWnd, lst2, LB_GETTEXT, lRet,
589 (LPARAM)pstr);
590 strcpyW( tmpstr, pstr );
591 HeapFree(GetProcessHeap(), 0, pstr);
592 /* get the selected directory in tmpstr */
593 if (tmpstr[0] == '[')
594 {
595 tmpstr[lstrlenW(tmpstr) - 1] = 0;
596 strcpyW(tmpstr,tmpstr+1);
597 }
598 strcatW(tmpstr, FILE_bslash);
599
600 FILEDLG_ScanDir(hWnd, tmpstr);
601 /* notify the app */
602 if (lfs->hook)
603 {
604 if (FILEDLG_CallWindowProc(lfs, lfs->lbselchstring, lst2,
605 MAKELONG(lRet,CD_LBSELCHANGE)))
606 return TRUE;
607 }
608 return TRUE;
609 }
610
611 /***********************************************************************
612 * FILEDLG_FileListSelect [internal]
613 * called when a new item is picked in the file list
614 */
615 static LRESULT FILEDLG_FileListSelect( LFSPRIVATE lfs )
616 {
617 LONG lRet;
618 HWND hWnd = lfs->hwnd;
619 LPWSTR pstr;
620
621 lRet = SendDlgItemMessageW(hWnd, lst1, LB_GETCURSEL16, 0, 0);
622 if (lRet == LB_ERR)
623 return TRUE;
624
625 /* set the edit control to the choosen file */
626 if ((pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC)))
627 {
628 SendDlgItemMessageW(hWnd, lst1, LB_GETTEXT, lRet,
629 (LPARAM)pstr);
630 SetDlgItemTextW( hWnd, edt1, pstr );
631 HeapFree(GetProcessHeap(), 0, pstr);
632 }
633 if (lfs->hook)
634 {
635 FILEDLG_CallWindowProc(lfs, lfs->lbselchstring, lst1,
636 MAKELONG(lRet,CD_LBSELCHANGE));
637 }
638 /* FIXME: for OFN_ALLOWMULTISELECT we need CD_LBSELSUB, CD_SELADD,
639 CD_LBSELNOITEMS */
640 return TRUE;
641 }
642
643 /***********************************************************************
644 * FILEDLG_TestPath [internal]
645 * before accepting the file name, test if it includes wild cards
646 * tries to scan the directory and returns TRUE if no error.
647 */
648 static LRESULT FILEDLG_TestPath( LFSPRIVATE lfs, LPWSTR path )
649 {
650 HWND hWnd = lfs->hwnd;
651 LPWSTR pBeginFileName, pstr2;
652 WCHAR tmpstr2[BUFFILE];
653
654 pBeginFileName = strrchrW(path, '\\');
655 if (pBeginFileName == NULL)
656 pBeginFileName = strrchrW(path, ':');
657
658 if (strchrW(path,'*') != NULL || strchrW(path,'?') != NULL)
659 {
660 /* edit control contains wildcards */
661 if (pBeginFileName != NULL)
662 {
663 lstrcpynW(tmpstr2, pBeginFileName + 1, BUFFILE);
664 *(pBeginFileName + 1) = 0;
665 }
666 else
667 {
668 strcpyW(tmpstr2, path);
669 if(!(lfs->ofnW->Flags & OFN_NOVALIDATE))
670 *path = 0;
671 }
672
673 TRACE("path=%s, tmpstr2=%s\n", debugstr_w(path), debugstr_w(tmpstr2));
674 SetDlgItemTextW( hWnd, edt1, tmpstr2 );
675 FILEDLG_ScanDir(hWnd, path);
676 return (lfs->ofnW->Flags & OFN_NOVALIDATE) ? TRUE : FALSE;
677 }
678
679 /* no wildcards, we might have a directory or a filename */
680 /* try appending a wildcard and reading the directory */
681
682 pstr2 = path + lstrlenW(path);
683 if (pBeginFileName == NULL || *(pBeginFileName + 1) != 0)
684 strcatW(path, FILE_bslash);
685
686 /* if ScanDir succeeds, we have changed the directory */
687 if (FILEDLG_ScanDir(hWnd, path))
688 return FALSE; /* and path is not a valid file name */
689
690 /* if not, this must be a filename */
691
692 *pstr2 = 0; /* remove the wildcard added before */
693
694 if (pBeginFileName != NULL)
695 {
696 /* strip off the pathname */
697 *pBeginFileName = 0;
698 SetDlgItemTextW( hWnd, edt1, pBeginFileName + 1 );
699
700 lstrcpynW(tmpstr2, pBeginFileName + 1, sizeof(tmpstr2)/sizeof(WCHAR) );
701 /* Should we MessageBox() if this fails? */
702 if (!FILEDLG_ScanDir(hWnd, path))
703 {
704 return FALSE;
705 }
706 strcpyW(path, tmpstr2);
707 }
708 else
709 SetDlgItemTextW( hWnd, edt1, path );
710 return TRUE;
711 }
712
713 /***********************************************************************
714 * FILEDLG_Validate [internal]
715 * called on: click Ok button, Enter in edit, DoubleClick in file list
716 */
717 static LRESULT FILEDLG_Validate( LFSPRIVATE lfs, LPWSTR path, UINT control, INT itemIndex,
718 BOOL internalUse )
719 {
720 LONG lRet;
721 HWND hWnd = lfs->hwnd;
722 OPENFILENAMEW ofnsav;
723 LPOPENFILENAMEW ofnW = lfs->ofnW;
724 WCHAR filename[BUFFILE];
725
726 ofnsav = *ofnW; /* for later restoring */
727
728 /* get current file name */
729 if (path)
730 lstrcpynW(filename, path, sizeof(filename)/sizeof(WCHAR));
731 else
732 GetDlgItemTextW( hWnd, edt1, filename, sizeof(filename)/sizeof(WCHAR));
733
734 TRACE("got filename = %s\n", debugstr_w(filename));
735 /* if we did not click in file list to get there */
736 if (control != lst1)
737 {
738 if (!FILEDLG_TestPath( lfs, filename) )
739 return FALSE;
740 }
741 FILEDLG_UpdateResult(lfs, filename);
742
743 if (internalUse)
744 { /* called internally after a change in a combo */
745 if (lfs->hook)
746 {
747 FILEDLG_CallWindowProc(lfs, lfs->lbselchstring, control,
748 MAKELONG(itemIndex,CD_LBSELCHANGE));
749 }
750 return TRUE;
751 }
752
753 FILEDLG_UpdateFileTitle(lfs);
754 if (lfs->hook)
755 {
756 lRet = (BOOL)FILEDLG_CallWindowProc(lfs, lfs->fileokstring,
757 0, lfs->lParam );
758 if (lRet)
759 {
760 *ofnW = ofnsav; /* restore old state */
761 return FALSE;
762 }
763 }
764 if ((ofnW->Flags & OFN_ALLOWMULTISELECT) && (ofnW->Flags & OFN_EXPLORER))
765 {
766 if (ofnW->lpstrFile)
767 {
768 LPWSTR str = (LPWSTR)ofnW->lpstrFile;
769 LPWSTR ptr = strrchrW(str, '\\');
770 str[lstrlenW(str) + 1] = '\0';
771 *ptr = 0;
772 }
773 }
774 return TRUE;
775 }
776
777 /***********************************************************************
778 * FILEDLG_DiskChange [internal]
779 * called when a new item is picked in the disk selection combo
780 */
781 static LRESULT FILEDLG_DiskChange( LFSPRIVATE lfs )
782 {
783 LONG lRet;
784 HWND hWnd = lfs->hwnd;
785 LPWSTR pstr;
786 WCHAR diskname[BUFFILE];
787
788 FILEDLG_StripEditControl(hWnd);
789 lRet = SendDlgItemMessageW(hWnd, cmb2, CB_GETCURSEL, 0, 0L);
790 if (lRet == LB_ERR)
791 return 0;
792 pstr = HeapAlloc(GetProcessHeap(), 0, BUFFILEALLOC);
793 SendDlgItemMessageW(hWnd, cmb2, CB_GETLBTEXT, lRet,
794 (LPARAM)pstr);
795 wsprintfW(diskname, FILE_specc, pstr[2]);
796 HeapFree(GetProcessHeap(), 0, pstr);
797
798 return FILEDLG_Validate( lfs, diskname, cmb2, lRet, TRUE );
799 }
800
801 /***********************************************************************
802 * FILEDLG_FileTypeChange [internal]
803 * called when a new item is picked in the file type combo
804 */
805 static LRESULT FILEDLG_FileTypeChange( LFSPRIVATE lfs )
806 {
807 LONG lRet;
808 WCHAR diskname[BUFFILE];
809 LPWSTR pstr;
810
811 diskname[0] = 0;
812
813 lRet = SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETCURSEL, 0, 0);
814 if (lRet == LB_ERR)
815 return TRUE;
816 pstr = (LPWSTR)SendDlgItemMessageW(lfs->hwnd, cmb1, CB_GETITEMDATA, lRet, 0);
817 TRACE("Selected filter : %s\n", debugstr_w(pstr));
818 SetDlgItemTextW( lfs->hwnd, edt1, pstr );
819
820 return FILEDLG_Validate( lfs, NULL, cmb1, lRet, TRUE );
821 }
822
823 /***********************************************************************
824 * FILEDLG_WMCommand [internal]
825 */
826 static LRESULT FILEDLG_WMCommand(HWND hWnd, LPARAM lParam, UINT notification,
827 UINT control, LFSPRIVATE lfs )
828 {
829 switch (control)
830 {
831 case lst1: /* file list */
832 FILEDLG_StripEditControl(hWnd);
833 if (notification == LBN_DBLCLK)
834 {
835 if (FILEDLG_Validate( lfs, NULL, control, 0, FALSE ))
836 EndDialog(hWnd, TRUE);
837 return TRUE;
838 }
839 else if (notification == LBN_SELCHANGE)
840 return FILEDLG_FileListSelect( lfs );
841 break;
842
843 case lst2: /* directory list */
844 FILEDLG_StripEditControl(hWnd);
845 if (notification == LBN_DBLCLK)
846 return FILEDLG_DirListDblClick( lfs );
847 break;
848
849 case cmb1: /* file type drop list */
850 if (notification == CBN_SELCHANGE)
851 return FILEDLG_FileTypeChange( lfs );
852 break;
853
854 case chx1:
855 break;
856
857 case pshHelp:
858 break;
859
860 case cmb2: /* disk dropdown combo */
861 if (notification == CBN_SELCHANGE)
862 return FILEDLG_DiskChange( lfs );
863 break;
864
865 case IDOK:
866 TRACE("OK pressed\n");
867 if (FILEDLG_Validate( lfs, NULL, control, 0, FALSE ))
868 EndDialog(hWnd, TRUE);
869 return TRUE;
870
871 case IDCANCEL:
872 EndDialog(hWnd, FALSE);
873 return TRUE;
874
875 case IDABORT: /* can be sent by the hook procedure */
876 EndDialog(hWnd, TRUE);
877 return TRUE;
878 }
879 return FALSE;
880 }
881
882 /***********************************************************************
883 * FILEDLG_MapDrawItemStruct [internal]
884 * map a 16 bits drawitem struct to 32
885 */
886 static void FILEDLG_MapDrawItemStruct(LPDRAWITEMSTRUCT16 lpdis16, LPDRAWITEMSTRUCT lpdis)
887 {
888 lpdis->CtlType = lpdis16->CtlType;
889 lpdis->CtlID = lpdis16->CtlID;
890 lpdis->itemID = lpdis16->itemID;
891 lpdis->itemAction = lpdis16->itemAction;
892 lpdis->itemState = lpdis16->itemState;
893 lpdis->hwndItem = HWND_32(lpdis16->hwndItem);
894 lpdis->hDC = HDC_32(lpdis16->hDC);
895 lpdis->rcItem.right = lpdis16->rcItem.right;
896 lpdis->rcItem.left = lpdis16->rcItem.left;
897 lpdis->rcItem.top = lpdis16->rcItem.top;
898 lpdis->rcItem.bottom = lpdis16->rcItem.bottom;
899 lpdis->itemData = lpdis16->itemData;
900 }
901
902 /************************************************************************
903 * FILEDLG_MapStringPairsToW [internal]
904 * map string pairs to Unicode
905 */
906 static LPWSTR FILEDLG_MapStringPairsToW(LPCSTR strA, UINT size)
907 {
908 LPCSTR s;
909 LPWSTR x;
910 int n, len;
911
912 s = strA;
913 while (*s)
914 s = s+strlen(s)+1;
915 s++;
916 n = s + 1 - strA; /* Don't forget the other \0 */
917 if (n < size) n = size;
918
919 len = MultiByteToWideChar( CP_ACP, 0, strA, n, NULL, 0 );
920 x = HeapAlloc(GetProcessHeap(),0, len * sizeof(WCHAR));
921 MultiByteToWideChar( CP_ACP, 0, strA, n, x, len );
922 return x;
923 }
924
925
926 /************************************************************************
927 * FILEDLG_DupToW [internal]
928 * duplicates an Ansi string to unicode, with a buffer size
929 */
930 LPWSTR FILEDLG_DupToW(LPCSTR str, DWORD size)
931 {
932 LPWSTR strW = NULL;
933 if (str && (size > 0))
934 {
935 strW = HeapAlloc(GetProcessHeap(), 0, size * sizeof(WCHAR));
936 if (strW) MultiByteToWideChar( CP_ACP, 0, str, -1, strW, size );
937 }
938 return strW;
939 }
940
941
942 /************************************************************************
943 * FILEDLG_MapOfnStructA [internal]
944 * map a 32 bits Ansi structure to an Unicode one
945 */
946 void FILEDLG_MapOfnStructA(LPOPENFILENAMEA ofnA, LPOPENFILENAMEW ofnW, BOOL open)
947 {
948 LPCSTR str;
949 UNICODE_STRING usBuffer;
950
951 ofnW->lStructSize = sizeof(OPENFILENAMEW);
952 ofnW->hwndOwner = ofnA->hwndOwner;
953 ofnW->hInstance = ofnA->hInstance;
954 if (ofnA->lpstrFilter)
955 ofnW->lpstrFilter = FILEDLG_MapStringPairsToW(ofnA->lpstrFilter, 0);
956
957 if ((ofnA->lpstrCustomFilter) && (*(ofnA->lpstrCustomFilter)))
958 ofnW->lpstrCustomFilter = FILEDLG_MapStringPairsToW(ofnA->lpstrCustomFilter, ofnA->nMaxCustFilter);
959 ofnW->nMaxCustFilter = ofnA->nMaxCustFilter;
960 ofnW->nFilterIndex = ofnA->nFilterIndex;
961 ofnW->nMaxFile = ofnA->nMaxFile;
962 ofnW->lpstrFile = FILEDLG_DupToW(ofnA->lpstrFile, ofnW->nMaxFile);
963 ofnW->nMaxFileTitle = ofnA->nMaxFileTitle;
964 ofnW->lpstrFileTitle = FILEDLG_DupToW(ofnA->lpstrFileTitle, ofnW->nMaxFileTitle);
965 if (ofnA->lpstrInitialDir)
966 {
967 RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpstrInitialDir);
968 ofnW->lpstrInitialDir = usBuffer.Buffer;
969 }
970 if (ofnA->lpstrTitle)
971 str = ofnA->lpstrTitle;
972 else
973 /* Allocates default title (FIXME : get it from resource) */
974 str = open ? defaultopen:defaultsave;
975 RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpstrTitle);
976 ofnW->lpstrTitle = usBuffer.Buffer;
977 ofnW->Flags = ofnA->Flags;
978 ofnW->nFileOffset = ofnA->nFileOffset;
979 ofnW->nFileExtension = ofnA->nFileExtension;
980 ofnW->lpstrDefExt = FILEDLG_DupToW(ofnA->lpstrDefExt, 3);
981 if ((ofnA->Flags & OFN_ENABLETEMPLATE) && (ofnA->lpTemplateName))
982 {
983 if (HIWORD(ofnA->lpTemplateName))
984 {
985 RtlCreateUnicodeStringFromAsciiz (&usBuffer,ofnA->lpTemplateName);
986 ofnW->lpTemplateName = usBuffer.Buffer;
987 }
988 else /* numbered resource */
989 ofnW->lpTemplateName = (LPWSTR) ofnA->lpTemplateName;
990 }
991 }
992
993 /************************************************************************
994 * FILEDLG_MapOfnStruct16 [internal]
995 * map a 16 bits structure to an Unicode one
996 */
997 void FILEDLG_MapOfnStruct16(LPOPENFILENAME16 ofn16, LPOPENFILENAMEW ofnW, BOOL open)
998 {
999 OPENFILENAMEA ofnA;
1000 /* first convert to linear pointers */
1001 memset(&ofnA, 0, sizeof(OPENFILENAMEA));
1002 ofnA.lStructSize = sizeof(OPENFILENAMEA);
1003 ofnA.hwndOwner = HWND_32(ofn16->hwndOwner);
1004 ofnA.hInstance = HINSTANCE_32(ofn16->hInstance);
1005 if (ofn16->lpstrFilter)
1006 ofnA.lpstrFilter = MapSL(ofn16->lpstrFilter);
1007 if (ofn16->lpstrCustomFilter)
1008 ofnA.lpstrCustomFilter = MapSL(ofn16->lpstrCustomFilter);
1009 ofnA.nMaxCustFilter = ofn16->nMaxCustFilter;
1010 ofnA.nFilterIndex = ofn16->nFilterIndex;
1011 ofnA.lpstrFile = MapSL(ofn16->lpstrFile);
1012 ofnA.nMaxFile = ofn16->nMaxFile;
1013 ofnA.lpstrFileTitle = MapSL(ofn16->lpstrFileTitle);
1014 ofnA.nMaxFileTitle = ofn16->nMaxFileTitle;
1015 ofnA.lpstrInitialDir = MapSL(ofn16->lpstrInitialDir);
1016 ofnA.lpstrTitle = MapSL(ofn16->lpstrTitle);
1017 ofnA.Flags = ofn16->Flags;
1018 ofnA.nFileOffset = ofn16->nFileOffset;
1019 ofnA.nFileExtension = ofn16->nFileExtension;
1020 ofnA.lpstrDefExt = MapSL(ofn16->lpstrDefExt);
1021 if (HIWORD(ofn16->lpTemplateName))
1022 ofnA.lpTemplateName = MapSL(ofn16->lpTemplateName);
1023 else
1024 ofnA.lpTemplateName = (LPSTR) ofn16->lpTemplateName; /* ressource number */
1025 /* now calls the 32 bits Ansi to Unicode version to complete the job */
1026 FILEDLG_MapOfnStructA(&ofnA, ofnW, open);
1027 }
1028
1029 /************************************************************************
1030 * FILEDLG_DestroyPrivate [internal]
1031 * destroys the private object
1032 */
1033 static void FILEDLG_DestroyPrivate(LFSPRIVATE lfs)
1034 {
1035 HWND hwnd;
1036 if (!lfs) return;
1037 hwnd = lfs->hwnd;
1038 /* free resources for a 16 bits dialog */
1039 if (lfs->hResource16) FreeResource16(lfs->hResource16);
1040 if (lfs->hGlobal16)
1041 {
1042 GlobalUnlock16(lfs->hGlobal16);
1043 GlobalFree16(lfs->hGlobal16);
1044 }
1045 /* if ofnW has been allocated, have to free everything in it */
1046 if (lfs->ofn16 || lfs->ofnA)
1047 {
1048 LPOPENFILENAMEW ofnW = lfs->ofnW;
1049 if (ofnW->lpstrFilter) HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrFilter);
1050 if (ofnW->lpstrCustomFilter) HeapFree(GetProcessHeap(), 0, ofnW->lpstrCustomFilter);
1051 if (ofnW->lpstrFile) HeapFree(GetProcessHeap(), 0, ofnW->lpstrFile);
1052 if (ofnW->lpstrFileTitle) HeapFree(GetProcessHeap(), 0, ofnW->lpstrFileTitle);
1053 if (ofnW->lpstrInitialDir) HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrInitialDir);
1054 if (ofnW->lpstrTitle) HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpstrTitle);
1055 if ((ofnW->lpTemplateName) && (HIWORD(ofnW->lpTemplateName)))
1056 HeapFree(GetProcessHeap(), 0, (LPWSTR) ofnW->lpTemplateName);
1057 HeapFree(GetProcessHeap(), 0, ofnW);
1058 }
1059 TRACE("destroying private allocation %p\n", lfs);
1060 HeapFree(GetProcessHeap(), 0, lfs);
1061 RemovePropA(hwnd, OFN_PROP);
1062 }
1063
1064 /************************************************************************
1065 * FILEDLG_AllocPrivate [internal]
1066 * allocate a private object to hold 32 bits Unicode
1067 * structure that will be used throughtout the calls, while
1068 * keeping available the original structures and a few variables
1069 * On entry : type = dialog procedure type (16,32A,32W)
1070 * dlgType = dialog type (open or save)
1071 */
1072 static LFSPRIVATE FILEDLG_AllocPrivate(LPARAM lParam, int type, UINT dlgType)
1073 {
1074 LFSPRIVATE lfs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct FSPRIVATE));
1075 LFSPRIVATE ret;
1076 TRACE("alloc private buf %p\n", lfs);
1077 if (!lfs) return NULL;
1078 lfs->hook = FALSE;
1079 lfs->lParam = lParam;
1080 if (dlgType == OPEN_DIALOG)
1081 lfs->open = TRUE;
1082 else
1083 lfs->open = FALSE;
1084 lfs->lbselchstring = RegisterWindowMessageA(LBSELCHSTRINGA);
1085 lfs->fileokstring = RegisterWindowMessageA(FILEOKSTRINGA);
1086 switch(type)
1087 {
1088 case LFS16:
1089 lfs->ofn16 = MapSL(lParam);
1090 if (lfs->ofn16->Flags & OFN_ENABLEHOOK)
1091 if (lfs->ofn16->lpfnHook)
1092 lfs->hook = TRUE;
1093
1094 break;
1095
1096 case LFS32A:
1097 lfs->ofnA = (LPOPENFILENAMEA) lParam;
1098 if (lfs->ofnA->Flags & OFN_ENABLEHOOK)
1099 if (lfs->ofnA->lpfnHook)
1100 lfs->hook = TRUE;
1101 break;
1102
1103 case LFS32W:
1104 lfs->ofnW = (LPOPENFILENAMEW) lParam;
1105 if (lfs->ofnW->Flags & OFN_ENABLEHOOK)
1106 if (lfs->ofnW->lpfnHook)
1107 lfs->hook = TRUE;
1108 break;
1109 }
1110 ret = lfs;
1111 if (!lfs->ofnW)
1112 { /* this structure is needed internally, so create it */
1113 lfs->ofnW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(OPENFILENAMEW));
1114 if (lfs->ofnW)
1115 {
1116 if (lfs->ofn16)
1117 FILEDLG_MapOfnStruct16(lfs->ofn16, lfs->ofnW, lfs->open);
1118 if (lfs->ofnA)
1119 FILEDLG_MapOfnStructA(lfs->ofnA, lfs->ofnW, lfs->open);
1120 }
1121 else
1122 ret = NULL;
1123 }
1124 if (lfs->ofn16)
1125 {
1126 if (!Get16BitsTemplate(lfs)) ret = NULL;
1127 }
1128 else
1129 if (!Get32BitsTemplate(lfs)) ret = NULL;
1130 if (!ret) FILEDLG_DestroyPrivate(lfs);
1131 return ret;
1132 }
1133
1134 /***********************************************************************
1135 * FILEDLG_CallWindowProc16 [internal]
1136 *
1137 * Call the appropriate hook
1138 */
1139 static BOOL FILEDLG_CallWindowProc16(LFSPRIVATE lfs, UINT wMsg, WPARAM wParam,
1140 LPARAM lParam)
1141 {
1142 if (lfs->ofn16)
1143 {
1144 return (BOOL16) CallWindowProc16(
1145 (WNDPROC16)lfs->ofn16->lpfnHook, HWND_16(lfs->hwnd),
1146 (UINT16)wMsg, (WPARAM16)wParam, lParam);
1147 }
1148 return FALSE;
1149 }
1150
1151 /***********************************************************************
1152 * FILEDLG_WMInitDialog16 [internal]
1153 * The is a duplicate of the 32bit FILEDLG_WMInitDialog function
1154 * The only differnce is that it calls FILEDLG_CallWindowProc16
1155 * for a 16 bit Window Proc.
1156 */
1157
1158 static LONG FILEDLG_WMInitDialog16(HWND hWnd, WPARAM wParam, LPARAM lParam)
1159 {
1160 int i, n;
1161 WCHAR tmpstr[BUFFILE];
1162 LPWSTR pstr, old_pstr;
1163 LPOPENFILENAMEW ofn;
1164 LFSPRIVATE lfs = (LFSPRIVATE) lParam;
1165
1166 if (!lfs) return FALSE;
1167 SetPropA(hWnd, OFN_PROP, (HANDLE)lfs);
1168 lfs->hwnd = hWnd;
1169 ofn = lfs->ofnW;
1170
1171 TRACE("flags=%lx initialdir=%s\n", ofn->Flags, debugstr_w(ofn->lpstrInitialDir));
1172
1173 SetWindowTextW( hWnd, ofn->lpstrTitle );
1174 /* read custom filter information */
1175 if (ofn->lpstrCustomFilter)
1176 {
1177 pstr = ofn->lpstrCustomFilter;
1178 n = 0;
1179 TRACE("lpstrCustomFilter = %p\n", pstr);
1180 while(*pstr)
1181 {
1182 old_pstr = pstr;
1183 i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
1184 (LPARAM)(ofn->lpstrCustomFilter) + n );
1185 n += lstrlenW(pstr) + 1;
1186 pstr += lstrlenW(pstr) + 1;
1187 TRACE("add str=%s associated to %s\n",
1188 debugstr_w(old_pstr), debugstr_w(pstr));
1189 SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
1190 n += lstrlenW(pstr) + 1;
1191 pstr += lstrlenW(pstr) + 1;
1192 }
1193 }
1194 /* read filter information */
1195 if (ofn->lpstrFilter) {
1196 pstr = (LPWSTR) ofn->lpstrFilter;
1197 n = 0;
1198 while(*pstr) {
1199 old_pstr = pstr;
1200 i = SendDlgItemMessageW(hWnd, cmb1, CB_ADDSTRING, 0,
1201 (LPARAM)(ofn->lpstrFilter + n) );
1202 n += lstrlenW(pstr) + 1;
1203 pstr += lstrlenW(pstr) + 1;
1204 TRACE("add str=%s associated to %s\n",
1205 debugstr_w(old_pstr), debugstr_w(pstr));
1206 SendDlgItemMessageW(hWnd, cmb1, CB_SETITEMDATA, i, (LPARAM)pstr);
1207 n += lstrlenW(pstr) + 1;
1208 pstr += lstrlenW(pstr) + 1;
1209 }
1210 }
1211 /* set default filter */
1212 if (ofn->nFilterIndex == 0 && ofn->lpstrCustomFilter == NULL)
1213 ofn->nFilterIndex = 1;
1214 SendDlgItemMessageW(hWnd, cmb1, CB_SETCURSEL, ofn->nFilterIndex - 1, 0);
1215 lstrcpynW(tmpstr, FILEDLG_GetFileType(ofn->lpstrCustomFilter,
1216 (LPWSTR)ofn->lpstrFilter, ofn->nFilterIndex - 1),BUFFILE);
1217 TRACE("nFilterIndex = %ld, SetText of edt1 to %s\n",
1218 ofn->nFilterIndex, debugstr_w(tmpstr));
1219 SetDlgItemTextW( hWnd, edt1, tmpstr );
1220 /* get drive list */
1221 *tmpstr = 0;
1222 DlgDirListComboBoxW(hWnd, tmpstr, cmb2, 0, DDL_DRIVES | DDL_EXCLUSIVE);
1223 /* read initial directory */
1224 /* FIXME: Note that this is now very version-specific (See MSDN description of
1225 * the OPENFILENAME structure). For example under 2000/XP any path in the
1226 * lpstrFile overrides the lpstrInitialDir, but not under 95/98/ME
1227 */
1228 if (ofn->lpstrInitialDir != NULL)
1229 {
1230 int len;
1231 lstrcpynW(tmpstr, ofn->lpstrInitialDir, 511);
1232 len = lstrlenW(tmpstr);
1233 if (len > 0 && tmpstr[len-1] != '\\' && tmpstr[len-1] != ':') {
1234 tmpstr[len]='\\';
1235 tmpstr[len+1]='\0';
1236 }
1237 }
1238 else
1239 *tmpstr = 0;
1240 if (!FILEDLG_ScanDir(hWnd, tmpstr)) {
1241 *tmpstr = 0;
1242 if (!FILEDLG_ScanDir(hWnd, tmpstr))
1243 WARN("Couldn't read initial directory %s!\n", debugstr_w(tmpstr));
1244 }
1245 /* select current drive in combo 2, omit missing drives */
1246 {
1247 char dir[MAX_PATH];
1248 char str[4] = "a:\\";
1249 GetCurrentDirectoryA( sizeof(dir), dir );
1250 for(i = 0, n = -1; i < 26; i++)
1251 {
1252 str[0] = 'a' + i;
1253 if (GetDriveTypeA(str) > DRIVE_NO_ROOT_DIR) n++;
1254 if (toupper(str[0]) == toupper(dir[0])) break;
1255 }
1256 }
1257 SendDlgItemMessageW(hWnd, cmb2, CB_SETCURSEL, n, 0);
1258 if (!(ofn->Flags & OFN_SHOWHELP))
1259 ShowWindow(GetDlgItem(hWnd, pshHelp), SW_HIDE);
1260 if (ofn->Flags & OFN_HIDEREADONLY)
1261 ShowWindow(GetDlgItem(hWnd, chx1), SW_HIDE);
1262 if (lfs->hook)
1263 return (BOOL) FILEDLG_CallWindowProc16(lfs, WM_INITDIALOG, wParam, lfs->lParam);
1264 return TRUE;
1265 }
1266
1267 /***********************************************************************
1268 * FILEDLG_WMMeasureItem16 [internal]
1269 */
1270 static LONG FILEDLG_WMMeasureItem16(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
1271 {
1272 LPMEASUREITEMSTRUCT16 lpmeasure;
1273
1274 lpmeasure = MapSL(lParam);
1275 lpmeasure->itemHeight = fldrHeight;
1276 return TRUE;
1277 }
1278
1279 /* ------------------ Dialog procedures ---------------------- */
1280
1281 /***********************************************************************
1282 * FileOpenDlgProc (COMMDLG.6)
1283 */
1284 BOOL16 CALLBACK FileOpenDlgProc16(HWND16 hWnd16, UINT16 wMsg, WPARAM16 wParam,
1285 LPARAM lParam)
1286 {
1287 HWND hWnd = HWND_32(hWnd16);
1288 LFSPRIVATE lfs = (LFSPRIVATE)GetPropA(hWnd,OFN_PROP);
1289 DRAWITEMSTRUCT dis;
1290
1291 TRACE("msg=%x wparam=%x lParam=%lx\n", wMsg, wParam, lParam);
1292 if ((wMsg != WM_INITDIALOG) && lfs && lfs->hook)
1293 {
1294 LRESULT lRet = (BOOL16)FILEDLG_CallWindowProc16(lfs, wMsg, wParam, lParam);
1295 if (lRet)
1296 return lRet; /* else continue message processing */
1297 }
1298 switch (wMsg)
1299 {
1300 case WM_INITDIALOG:
1301 return FILEDLG_WMInitDialog16(hWnd, wParam, lParam);
1302
1303 case WM_MEASUREITEM:
1304 return FILEDLG_WMMeasureItem16(hWnd16, wParam, lParam);
1305
1306 case WM_DRAWITEM:
1307 FILEDLG_MapDrawItemStruct(MapSL(lParam), &dis);
1308 return FILEDLG_WMDrawItem(hWnd, wParam, lParam, FALSE, &dis);
1309
1310 case WM_COMMAND:
1311 return FILEDLG_WMCommand(hWnd, lParam, HIWORD(lParam),wParam, lfs);
1312 #if 0
1313 case WM_CTLCOLOR:
1314 SetBkColor((HDC16)wParam, 0x00C0C0C0);
1315 switch (HIWORD(lParam))
1316 {
1317 case CTLCOLOR_BTN:
1318 SetTextColor((HDC16)wParam, 0x00000000);
1319 return hGRAYBrush;
1320 case CTLCOLOR_STATIC:
1321 SetTextColor((HDC16)wParam, 0x00000000);
1322 return hGRAYBrush;
1323 }
1324 break;
1325 #endif
1326 }
1327 return FALSE;
1328 }
1329
1330 /***********************************************************************
1331 * FileSaveDlgProc (COMMDLG.7)
1332 */
1333 BOOL16 CALLBACK FileSaveDlgProc16(HWND16 hWnd16, UINT16 wMsg, WPARAM16 wParam,
1334 LPARAM lParam)
1335 {
1336 HWND hWnd = HWND_32(hWnd16);
1337 LFSPRIVATE lfs = (LFSPRIVATE)GetPropA(hWnd,OFN_PROP);
1338 DRAWITEMSTRUCT dis;
1339
1340 TRACE("msg=%x wparam=%x lParam=%lx\n", wMsg, wParam, lParam);
1341 if ((wMsg != WM_INITDIALOG) && lfs && lfs->hook)
1342 {
1343 LRESULT lRet;
1344 lRet = (BOOL16)FILEDLG_CallWindowProc16(lfs, wMsg, wParam, lParam);
1345 if (lRet)
1346 return lRet; /* else continue message processing */
1347 }
1348 switch (wMsg) {
1349 case WM_INITDIALOG:
1350 return FILEDLG_WMInitDialog16(hWnd, wParam, lParam);
1351
1352 case WM_MEASUREITEM:
1353 return FILEDLG_WMMeasureItem16(hWnd16, wParam, lParam);
1354
1355 case WM_DRAWITEM:
1356 FILEDLG_MapDrawItemStruct(MapSL(lParam), &dis);
1357 return FILEDLG_WMDrawItem(hWnd, wParam, lParam, TRUE, &dis);
1358
1359 case WM_COMMAND:
1360 return FILEDLG_WMCommand(hWnd, lParam, HIWORD(lParam), wParam, lfs);
1361 }
1362
1363 /*
1364 case WM_CTLCOLOR:
1365 SetBkColor((HDC16)wParam, 0x00C0C0C0);
1366 switch (HIWORD(lParam))
1367 {
1368 case CTLCOLOR_BTN:
1369 SetTextColor((HDC16)wParam, 0x00000000);
1370 return hGRAYBrush;
1371 case CTLCOLOR_STATIC:
1372 SetTextColor((HDC16)wParam, 0x00000000);
1373 return hGRAYBrush;
1374 }
1375 return FALSE;
1376
1377 */
1378 return FALSE;
1379 }
1380
1381 /* ------------------ APIs ---------------------- */
1382
1383 /***********************************************************************
1384 * GetOpenFileName (COMMDLG.1)
1385 *
1386 * Creates a dialog box for the user to select a file to open.
1387 *
1388 * RETURNS
1389 * TRUE on success: user selected a valid file
1390 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1391 *
1392 * BUGS
1393 * unknown, there are some FIXME's left.
1394 */
1395 BOOL16 WINAPI GetOpenFileName16(
1396 SEGPTR ofn /* [in/out] address of structure with data*/
1397 )
1398 {
1399 HINSTANCE16 hInst;
1400 BOOL bRet = FALSE;
1401 LPOPENFILENAME16 lpofn = MapSL(ofn);
1402 LFSPRIVATE lfs;
1403 FARPROC16 ptr;
1404
1405 if (!lpofn || !FileDlg_Init()) return FALSE;
1406
1407 lfs = FILEDLG_AllocPrivate((LPARAM) ofn, LFS16, OPEN_DIALOG);
1408 if (lfs)
1409 {
1410 hInst = GetWindowWord( HWND_32(lpofn->hwndOwner), GWL_HINSTANCE );
1411 ptr = GetProcAddress16(GetModuleHandle16("COMMDLG"), (LPCSTR) 6);
1412 bRet = DialogBoxIndirectParam16( hInst, lfs->hDlgTmpl16, lpofn->hwndOwner,
1413 (DLGPROC16) ptr, (LPARAM) lfs);
1414 FILEDLG_DestroyPrivate(lfs);
1415 }
1416
1417 TRACE("return lpstrFile='%s' !\n", (char *)MapSL(lpofn->lpstrFile));
1418 return bRet;
1419 }
1420
1421 /***********************************************************************
1422 * GetSaveFileName (COMMDLG.2)
1423 *
1424 * Creates a dialog box for the user to select a file to save.
1425 *
1426 * RETURNS
1427 * TRUE on success: user enters a valid file
1428 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1429 *
1430 * BUGS
1431 * unknown. There are some FIXME's left.
1432 */
1433 BOOL16 WINAPI GetSaveFileName16(
1434 SEGPTR ofn /* [in/out] addess of structure with data*/
1435 )
1436 {
1437 HINSTANCE16 hInst;
1438 BOOL bRet = FALSE;
1439 LPOPENFILENAME16 lpofn = MapSL(ofn);
1440 LFSPRIVATE lfs;
1441 FARPROC16 ptr;
1442
1443 if (!lpofn || !FileDlg_Init()) return FALSE;
1444
1445 lfs = FILEDLG_AllocPrivate((LPARAM) ofn, LFS16, SAVE_DIALOG);
1446 if (lfs)
1447 {
1448 hInst = GetWindowWord( HWND_32(lpofn->hwndOwner), GWL_HINSTANCE );
1449 ptr = GetProcAddress16(GetModuleHandle16("COMMDLG"), (LPCSTR) 7);
1450 bRet = DialogBoxIndirectParam16( hInst, lfs->hDlgTmpl16, lpofn->hwndOwner,
1451 (DLGPROC16) ptr, (LPARAM) lfs);
1452 FILEDLG_DestroyPrivate(lfs);
1453 }
1454
1455 TRACE("return lpstrFile='%s' !\n", (char *)MapSL(lpofn->lpstrFile));
1456 return bRet;
1457 }
Windows API implementation