?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Restructure DirectSound. Remove dsound thread, use MM timers
[wine/testsucceed.git] / dlls / commdlg / filedlg.c
blobbefb8634dc38e60a9dc250aac0cdfd55744cc968
1 /*
2 * COMMDLG - File Dialogs
3 *
4 * Copyright 1994 Martin Ayotte
5 * Copyright 1996 Albrecht Kleine
6 */
7 #include <ctype.h>
8 #include <stdlib.h>
9 #include <stdio.h>
10 #include <string.h>
11 #include "windef.h"
12 #include "winbase.h"
13 #include "wingdi.h"
14 #include "wine/winbase16.h"
15 #include "wine/winuser16.h"
16 #include "ldt.h"
17 #include "heap.h"
18 #include "commdlg.h"
19 #include "dialog.h"
20 #include "dlgs.h"
21 #include "module.h"
22 #include "drive.h"
23 #include "debugtools.h"
24 #include "winproc.h"
25 #include "cderr.h"
26 #include "tweak.h"
27
28 DEFAULT_DEBUG_CHANNEL(commdlg);
29
30 #include "cdlg.h"
31
32 static HICON16 hFolder = 0;
33 static HICON16 hFolder2 = 0;
34 static HICON16 hFloppy = 0;
35 static HICON16 hHDisk = 0;
36 static HICON16 hCDRom = 0;
37 static HICON16 hNet = 0;
38 static int fldrHeight = 0;
39 static int fldrWidth = 0;
40
41 static const char defaultfilter[]=" \0\0";
42 #define OFN_PROP "FILEDLG_OFN_LPARAM"
43
44 /***********************************************************************
45 *
46 * Windows 3.1 OpenFileName/SaveFileName dialog
47 *
48 */
49
50 LRESULT WINAPI FileOpenDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
51 LPARAM lParam);
52 LRESULT WINAPI FileSaveDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
53 LPARAM lParam);
54
55 /***********************************************************************
56 * FileDlg_Init [internal]
57 */
58 static BOOL FileDlg_Init(void)
59 {
60 static BOOL initialized = 0;
61 CURSORICONINFO *fldrInfo;
62
63 if (!initialized) {
64 if (!hFolder) hFolder = LoadIcon16(0, MAKEINTRESOURCE16(OIC_FOLDER));
65 if (!hFolder2) hFolder2 = LoadIcon16(0, MAKEINTRESOURCE16(OIC_FOLDER2));
66 if (!hFloppy) hFloppy = LoadIcon16(0, MAKEINTRESOURCE16(OIC_FLOPPY));
67 if (!hHDisk) hHDisk = LoadIcon16(0, MAKEINTRESOURCE16(OIC_HDISK));
68 if (!hCDRom) hCDRom = LoadIcon16(0, MAKEINTRESOURCE16(OIC_CDROM));
69 if (!hNet) hNet = LoadIcon16(0, MAKEINTRESOURCE16(OIC_NETWORK));
70 if (hFolder == 0 || hFolder2 == 0 || hFloppy == 0 ||
71 hHDisk == 0 || hCDRom == 0 || hNet == 0)
72 {
73 ERR("Error loading icons !\n");
74 return FALSE;
75 }
76 fldrInfo = (CURSORICONINFO *) GlobalLock16( hFolder2 );
77 if (!fldrInfo)
78 {
79 ERR("Error measuring icons !\n");
80 return FALSE;
81 }
82 fldrHeight = fldrInfo -> nHeight;
83 fldrWidth = fldrInfo -> nWidth;
84 GlobalUnlock16( hFolder2 );
85 initialized = TRUE;
86 }
87 return TRUE;
88 }
89
90 /***********************************************************************
91 * FileOpenDlgProc [internal]
92 *
93 * FIXME: Convert to real 32-bit message processing
94 */
95 static LRESULT WINAPI FileOpenDlgProc(HWND hDlg, UINT msg,
96 WPARAM wParam, LPARAM lParam)
97 {
98 UINT16 msg16;
99 MSGPARAM16 mp16;
100
101 mp16.lParam = lParam;
102 if (WINPROC_MapMsg32ATo16( hDlg, msg, wParam,
103 &msg16, &mp16.wParam, &mp16.lParam ) == -1)
104 return 0;
105 mp16.lResult = FileOpenDlgProc16( (HWND16)hDlg, msg16,
106 mp16.wParam, mp16.lParam );
107
108 WINPROC_UnmapMsg32ATo16( hDlg, msg, wParam, lParam, &mp16 );
109 return mp16.lResult;
110 }
111
112 /***********************************************************************
113 * FileSaveDlgProc [internal]
114 *
115 * FIXME: Convert to real 32-bit message processing
116 */
117 static LRESULT WINAPI FileSaveDlgProc(HWND hDlg, UINT msg,
118 WPARAM wParam, LPARAM lParam)
119 {
120 UINT16 msg16;
121 MSGPARAM16 mp16;
122
123 mp16.lParam = lParam;
124 if (WINPROC_MapMsg32ATo16( hDlg, msg, wParam,
125 &msg16, &mp16.wParam, &mp16.lParam ) == -1)
126 return 0;
127 mp16.lResult = FileSaveDlgProc16( (HWND16)hDlg, msg16,
128 mp16.wParam, mp16.lParam );
129
130 WINPROC_UnmapMsg32ATo16( hDlg, msg, wParam, lParam, &mp16 );
131 return mp16.lResult;
132 }
133
134 /***********************************************************************
135 * GetOpenFileName16 (COMMDLG.1)
136 *
137 * Creates a dialog box for the user to select a file to open.
138 *
139 * RETURNS
140 * TRUE on success: user selected a valid file
141 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
142 *
143 * BUGS
144 * unknown, there are some FIXME's left.
145 */
146 BOOL16 WINAPI GetOpenFileName16(
147 SEGPTR ofn /* addess of structure with data*/
148 )
149 {
150 HINSTANCE hInst;
151 HANDLE hDlgTmpl = 0, hResInfo;
152 BOOL bRet = FALSE, win32Format = FALSE;
153 HWND hwndDialog;
154 LPOPENFILENAME16 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(ofn);
155 LPCVOID template;
156 char defaultopen[]="Open File";
157 char *str=0,*str1=0;
158
159 if (!lpofn || !FileDlg_Init()) return FALSE;
160
161 if (lpofn->Flags & OFN_WINE) {
162 if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
163 {
164 if (!(template = LockResource( MapHModuleSL(lpofn->hInstance ))))
165 {
166 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
167 return FALSE;
168 }
169 }
170 else if (lpofn->Flags & OFN_ENABLETEMPLATE)
171 {
172 if (!(hResInfo = FindResourceA(MapHModuleSL(lpofn->hInstance),
173 PTR_SEG_TO_LIN(lpofn->lpTemplateName), RT_DIALOGA)))
174 {
175 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
176 return FALSE;
177 }
178 if (!(hDlgTmpl = LoadResource( MapHModuleSL(lpofn->hInstance),
179 hResInfo )) ||
180 !(template = LockResource( hDlgTmpl )))
181 {
182 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
183 return FALSE;
184 }
185 } else {
186 if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "OPEN_FILE", RT_DIALOGA)))
187 {
188 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
189 return FALSE;
190 }
191 if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
192 !(template = LockResource( hDlgTmpl )))
193 {
194 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
195 return FALSE;
196 }
197 }
198 win32Format = TRUE;
199 } else {
200 if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
201 {
202 if (!(template = LockResource16( lpofn->hInstance )))
203 {
204 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
205 return FALSE;
206 }
207 }
208 else if (lpofn->Flags & OFN_ENABLETEMPLATE)
209 {
210 if (!(hResInfo = FindResource16(lpofn->hInstance,
211 lpofn->lpTemplateName,
212 RT_DIALOG16)))
213 {
214 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
215 return FALSE;
216 }
217 if (!(hDlgTmpl = LoadResource16( lpofn->hInstance, hResInfo )) ||
218 !(template = LockResource16( hDlgTmpl )))
219 {
220 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
221 return FALSE;
222 }
223 } else {
224 if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "OPEN_FILE", RT_DIALOGA)))
225 {
226 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
227 return FALSE;
228 }
229 if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
230 !(template = LockResource( hDlgTmpl )))
231 {
232 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
233 return FALSE;
234 }
235 win32Format = TRUE;
236 }
237 }
238
239 hInst = GetWindowLongA( lpofn->hwndOwner, GWL_HINSTANCE );
240
241 if (!(lpofn->lpstrFilter))
242 {
243 str = SEGPTR_ALLOC(sizeof(defaultfilter));
244 TRACE("Alloc %p default for Filetype in GetOpenFileName\n",str);
245 memcpy(str,defaultfilter,sizeof(defaultfilter));
246 lpofn->lpstrFilter=SEGPTR_GET(str);
247 }
248
249 if (!(lpofn->lpstrTitle))
250 {
251 str1 = SEGPTR_ALLOC(strlen(defaultopen)+1);
252 TRACE("Alloc %p default for Title in GetOpenFileName\n",str1);
253 strcpy(str1,defaultopen);
254 lpofn->lpstrTitle=SEGPTR_GET(str1);
255 }
256
257 /* FIXME: doesn't handle win32 format correctly yet */
258 hwndDialog = DIALOG_CreateIndirect( hInst, template, win32Format,
259 lpofn->hwndOwner,
260 (DLGPROC16)FileOpenDlgProc,
261 ofn, WIN_PROC_32A );
262 if (hwndDialog) bRet = DIALOG_DoDialogBox( hwndDialog, lpofn->hwndOwner );
263
264 if (str1)
265 {
266 TRACE("Freeing %p default for Title in GetOpenFileName\n",str1);
267 SEGPTR_FREE(str1);
268 lpofn->lpstrTitle=0;
269 }
270
271 if (str)
272 {
273 TRACE("Freeing %p default for Filetype in GetOpenFileName\n",str);
274 SEGPTR_FREE(str);
275 lpofn->lpstrFilter=0;
276 }
277
278 if (hDlgTmpl) {
279 if (lpofn->Flags & OFN_WINE)
280 FreeResource( hDlgTmpl );
281 else
282 FreeResource16( hDlgTmpl );
283 }
284
285 TRACE("return lpstrFile='%s' !\n",
286 (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFile));
287 return bRet;
288 }
289
290
291 /***********************************************************************
292 * GetSaveFileName (COMMDLG.2)
293 *
294 * Creates a dialog box for the user to select a file to save.
295 *
296 * RETURNS
297 * TRUE on succes: user enters a valid file
298 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
299 *
300 * BUGS
301 * unknown. There are some FIXME's left.
302 */
303 BOOL16 WINAPI GetSaveFileName16(
304 SEGPTR ofn /* addess of structure with data*/
305 )
306 {
307 HINSTANCE hInst;
308 HANDLE hDlgTmpl = 0;
309 BOOL bRet = FALSE, win32Format = FALSE;
310 LPOPENFILENAME16 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(ofn);
311 LPCVOID template;
312 HWND hwndDialog;
313 char defaultsave[]="Save as";
314 char *str =0,*str1=0;
315
316 if (!lpofn || !FileDlg_Init()) return FALSE;
317
318 if (lpofn->Flags & OFN_WINE) {
319 if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
320 {
321 if (!(template = LockResource( MapHModuleSL(lpofn->hInstance ))))
322 {
323 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
324 return FALSE;
325 }
326 }
327 else if (lpofn->Flags & OFN_ENABLETEMPLATE)
328 {
329 HANDLE hResInfo;
330 if (!(hResInfo = FindResourceA(MapHModuleSL(lpofn->hInstance),
331 PTR_SEG_TO_LIN(lpofn->lpTemplateName),
332 RT_DIALOGA)))
333 {
334 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
335 return FALSE;
336 }
337 if (!(hDlgTmpl = LoadResource(MapHModuleSL(lpofn->hInstance),
338 hResInfo)) ||
339 !(template = LockResource(hDlgTmpl)))
340 {
341 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
342 return FALSE;
343 }
344 win32Format= TRUE;
345 } else {
346 HANDLE hResInfo;
347 if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "SAVE_FILE", RT_DIALOGA)))
348 {
349 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
350 return FALSE;
351 }
352 if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
353 !(template = LockResource( hDlgTmpl )))
354 {
355 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
356 return FALSE;
357 }
358 win32Format = TRUE;
359 }
360 } else {
361 if (lpofn->Flags & OFN_ENABLETEMPLATEHANDLE)
362 {
363 if (!(template = LockResource16( lpofn->hInstance )))
364 {
365 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
366 return FALSE;
367 }
368 }
369 else if (lpofn->Flags & OFN_ENABLETEMPLATE)
370 {
371 HANDLE16 hResInfo;
372 if (!(hResInfo = FindResource16(lpofn->hInstance,
373 lpofn->lpTemplateName,
374 RT_DIALOG16)))
375 {
376 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
377 return FALSE;
378 }
379 if (!(hDlgTmpl = LoadResource16( lpofn->hInstance, hResInfo )) ||
380 !(template = LockResource16( hDlgTmpl )))
381 {
382 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
383 return FALSE;
384 }
385 } else {
386 HANDLE hResInfo;
387 if (!(hResInfo = FindResourceA(COMMDLG_hInstance32, "SAVE_FILE", RT_DIALOGA)))
388 {
389 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
390 return FALSE;
391 }
392 if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hResInfo )) ||
393 !(template = LockResource( hDlgTmpl )))
394 {
395 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
396 return FALSE;
397 }
398 win32Format = TRUE;
399 }
400 }
401
402 hInst = GetWindowLongA( lpofn->hwndOwner, GWL_HINSTANCE );
403
404 if (!(lpofn->lpstrFilter))
405 {
406 str = SEGPTR_ALLOC(sizeof(defaultfilter));
407 TRACE("Alloc default for Filetype in GetSaveFileName\n");
408 memcpy(str,defaultfilter,sizeof(defaultfilter));
409 lpofn->lpstrFilter=SEGPTR_GET(str);
410 }
411
412 if (!(lpofn->lpstrTitle))
413 {
414 str1 = SEGPTR_ALLOC(sizeof(defaultsave)+1);
415 TRACE("Alloc default for Title in GetSaveFileName\n");
416 strcpy(str1,defaultsave);
417 lpofn->lpstrTitle=SEGPTR_GET(str1);
418 }
419
420 hwndDialog = DIALOG_CreateIndirect( hInst, template, win32Format,
421 lpofn->hwndOwner,
422 (DLGPROC16)FileSaveDlgProc,
423 ofn, WIN_PROC_32A );
424 if (hwndDialog) bRet = DIALOG_DoDialogBox( hwndDialog, lpofn->hwndOwner );
425
426 if (str1)
427 {
428 TRACE("Freeing %p default for Title in GetSaveFileName\n",str1);
429 SEGPTR_FREE(str1);
430 lpofn->lpstrTitle=0;
431 }
432
433 if (str)
434 {
435 TRACE("Freeing %p default for Filetype in GetSaveFileName\n",str);
436 SEGPTR_FREE(str);
437 lpofn->lpstrFilter=0;
438 }
439
440 if (hDlgTmpl) {
441 if (lpofn->Flags & OFN_WINE)
442 FreeResource( hDlgTmpl );
443 else
444 FreeResource16( hDlgTmpl );
445 }
446
447 TRACE("return lpstrFile='%s' !\n",
448 (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFile));
449 return bRet;
450 }
451
452 /***********************************************************************
453 * FILEDLG_StripEditControl [internal]
454 * Strip pathnames off the contents of the edit control.
455 */
456 static void FILEDLG_StripEditControl(HWND16 hwnd)
457 {
458 char temp[512], *cp;
459
460 GetDlgItemTextA( hwnd, edt1, temp, sizeof(temp) );
461 cp = strrchr(temp, '\\');
462 if (cp != NULL) {
463 strcpy(temp, cp+1);
464 }
465 cp = strrchr(temp, ':');
466 if (cp != NULL) {
467 strcpy(temp, cp+1);
468 }
469 /* FIXME: shouldn't we do something with the result here? ;-) */
470 }
471
472 /***********************************************************************
473 * FILEDLG_ScanDir [internal]
474 */
475 static BOOL FILEDLG_ScanDir(HWND16 hWnd, LPSTR newPath)
476 {
477 char buffer[512];
478 char* str = buffer;
479 int drive;
480 HWND hlb;
481
482 lstrcpynA(buffer, newPath, sizeof(buffer));
483
484 if (str[0] && (str[1] == ':')) {
485 drive = toupper(str[0]) - 'A';
486 str += 2;
487 if (!DRIVE_SetCurrentDrive(drive))
488 return FALSE;
489 } else {
490 drive = DRIVE_GetCurrentDrive();
491 }
492
493 if (str[0] && !DRIVE_Chdir(drive, str)) {
494 return FALSE;
495 }
496
497 GetDlgItemTextA(hWnd, edt1, buffer, sizeof(buffer));
498 if ((hlb = GetDlgItem(hWnd, lst1)) != 0) {
499 char* scptr; /* ptr on semi-colon */
500 char* filter = buffer;
501
502 TRACE("Using filter %s\n", filter);
503 SendMessageA(hlb, LB_RESETCONTENT, 0, 0);
504 while (filter) {
505 scptr = strchr(filter, ';');
506 if (scptr) *scptr = 0;
507 TRACE("Using file spec %s\n", filter);
508 if (SendMessageA(hlb, LB_DIR, 0, (LPARAM)filter) == LB_ERR)
509 return FALSE;
510 if (scptr) *scptr = ';';
511 filter = (scptr) ? (scptr + 1) : 0;
512 }
513 }
514
515 strcpy(buffer, "*.*");
516 return DlgDirListA(hWnd, buffer, lst2, stc1, DDL_EXCLUSIVE | DDL_DIRECTORY);
517 }
518
519 /***********************************************************************
520 * FILEDLG_GetFileType [internal]
521 */
522
523 static LPSTR FILEDLG_GetFileType(LPSTR cfptr, LPSTR fptr, WORD index)
524 {
525 int n, i;
526 i = 0;
527 if (cfptr)
528 for ( ;(n = strlen(cfptr)) != 0; i++)
529 {
530 cfptr += n + 1;
531 if (i == index)
532 return cfptr;
533 cfptr += strlen(cfptr) + 1;
534 }
535 if (fptr)
536 for ( ;(n = strlen(fptr)) != 0; i++)
537 {
538 fptr += n + 1;
539 if (i == index)
540 return fptr;
541 fptr += strlen(fptr) + 1;
542 }
543 return "*.*"; /* FIXME */
544 }
545
546 /***********************************************************************
547 * FILEDLG_WMDrawItem [internal]
548 */
549 static LONG FILEDLG_WMDrawItem(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam,int savedlg)
550 {
551 LPDRAWITEMSTRUCT16 lpdis = (LPDRAWITEMSTRUCT16)PTR_SEG_TO_LIN(lParam);
552 char *str;
553 HICON16 hIcon;
554 COLORREF oldText = 0, oldBk = 0;
555
556 if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst1)
557 {
558 if (!(str = SEGPTR_ALLOC(512))) return FALSE;
559 SendMessage16(lpdis->hwndItem, LB_GETTEXT16, lpdis->itemID,
560 (LPARAM)SEGPTR_GET(str));
561
562 if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
563 {
564 oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
565 oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
566 }
567 if (savedlg)
568 SetTextColor(lpdis->hDC,GetSysColor(COLOR_GRAYTEXT) );
569
570 ExtTextOut16(lpdis->hDC, lpdis->rcItem.left + 1,
571 lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
572 &(lpdis->rcItem), str, strlen(str), NULL);
573
574 if (lpdis->itemState & ODS_SELECTED)
575 DrawFocusRect16( lpdis->hDC, &(lpdis->rcItem) );
576
577 if ((lpdis->itemState & ODS_SELECTED) && !savedlg)
578 {
579 SetBkColor( lpdis->hDC, oldBk );
580 SetTextColor( lpdis->hDC, oldText );
581 }
582 SEGPTR_FREE(str);
583 return TRUE;
584 }
585
586 if (lpdis->CtlType == ODT_LISTBOX && lpdis->CtlID == lst2)
587 {
588 if (!(str = SEGPTR_ALLOC(512))) return FALSE;
589 SendMessage16(lpdis->hwndItem, LB_GETTEXT16, lpdis->itemID,
590 (LPARAM)SEGPTR_GET(str));
591
592 if (lpdis->itemState & ODS_SELECTED)
593 {
594 oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
595 oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
596 }
597 ExtTextOut16(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
598 lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
599 &(lpdis->rcItem), str, strlen(str), NULL);
600
601 if (lpdis->itemState & ODS_SELECTED)
602 DrawFocusRect16( lpdis->hDC, &(lpdis->rcItem) );
603
604 if (lpdis->itemState & ODS_SELECTED)
605 {
606 SetBkColor( lpdis->hDC, oldBk );
607 SetTextColor( lpdis->hDC, oldText );
608 }
609 DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hFolder);
610 SEGPTR_FREE(str);
611 return TRUE;
612 }
613 if (lpdis->CtlType == ODT_COMBOBOX && lpdis->CtlID == cmb2)
614 {
615 if (!(str = SEGPTR_ALLOC(512))) return FALSE;
616 SendMessage16(lpdis->hwndItem, CB_GETLBTEXT16, lpdis->itemID,
617 (LPARAM)SEGPTR_GET(str));
618 switch(DRIVE_GetType( str[2] - 'a' ))
619 {
620 case TYPE_FLOPPY: hIcon = hFloppy; break;
621 case TYPE_CDROM: hIcon = hCDRom; break;
622 case TYPE_NETWORK: hIcon = hNet; break;
623 case TYPE_HD:
624 default: hIcon = hHDisk; break;
625 }
626 if (lpdis->itemState & ODS_SELECTED)
627 {
628 oldBk = SetBkColor( lpdis->hDC, GetSysColor( COLOR_HIGHLIGHT ) );
629 oldText = SetTextColor( lpdis->hDC, GetSysColor(COLOR_HIGHLIGHTTEXT));
630 }
631 ExtTextOut16(lpdis->hDC, lpdis->rcItem.left + fldrWidth,
632 lpdis->rcItem.top + 1, ETO_OPAQUE | ETO_CLIPPED,
633 &(lpdis->rcItem), str, strlen(str), NULL);
634
635 if (lpdis->itemState & ODS_SELECTED)
636 {
637 SetBkColor( lpdis->hDC, oldBk );
638 SetTextColor( lpdis->hDC, oldText );
639 }
640 DrawIcon(lpdis->hDC, lpdis->rcItem.left, lpdis->rcItem.top, hIcon);
641 SEGPTR_FREE(str);
642 return TRUE;
643 }
644 return FALSE;
645 }
646
647 /***********************************************************************
648 * FILEDLG_WMMeasureItem [internal]
649 */
650 static LONG FILEDLG_WMMeasureItem(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
651 {
652 LPMEASUREITEMSTRUCT16 lpmeasure;
653
654 lpmeasure = (LPMEASUREITEMSTRUCT16)PTR_SEG_TO_LIN(lParam);
655 lpmeasure->itemHeight = fldrHeight;
656 return TRUE;
657 }
658
659 /***********************************************************************
660 * FILEDLG_HookCallChk [internal]
661 */
662 static int FILEDLG_HookCallChk(LPOPENFILENAME16 lpofn)
663 {
664 if (lpofn)
665 if (lpofn->Flags & OFN_ENABLEHOOK)
666 if (lpofn->lpfnHook)
667 return 1;
668 return 0;
669 }
670
671 /***********************************************************************
672 * FILEDLG_CallWindowProc [internal]
673 *
674 * Adapt the structures back for win32 calls so the callee can read lpCustData
675 */
676 static BOOL FILEDLG_CallWindowProc(LPOPENFILENAME16 lpofn,HWND hwnd,
677 UINT wMsg,WPARAM wParam,LPARAM lParam
678
679 ) {
680 BOOL needstruct;
681 BOOL result = FALSE;
682 WINDOWPROCTYPE ProcType; /* Type of Hook Function to be called. */
683
684 /* TRUE if lParam points to the OPENFILENAME16 Structure */
685 needstruct = (PTR_SEG_TO_LIN(lParam) == lpofn);
686
687 ProcType = (lpofn->Flags & OFN_WINE)
688 ? (lpofn->Flags & OFN_UNICODE) /* 32-Bit call to GetOpenFileName */
689 ? WIN_PROC_32W : WIN_PROC_32A
690 : WIN_PROC_16; /* 16-Bit call to GetOpenFileName */
691
692 if (!(lpofn->Flags & OFN_WINE))
693 /* Call to 16-Bit Hooking function... No Problem at all. */
694 return (BOOL)CallWindowProc16(
695 (WNDPROC16)lpofn->lpfnHook,hwnd,(UINT16)wMsg,(WPARAM16)wParam,lParam
696 );
697 /* |OFN_WINE32 */
698 if (needstruct)
699 {
700 /* Parameter lParam points to lpofn... Convert Structure Data... */
701 if (lpofn->Flags & OFN_UNICODE)
702 {
703 OPENFILENAMEW ofnw;
704
705 /* FIXME: probably needs more converted */
706 ofnw.lCustData = lpofn->lCustData;
707 return (BOOL)CallWindowProcW(
708 (WNDPROC)lpofn->lpfnHook,hwnd,wMsg,wParam,(LPARAM)&ofnw
709 );
710 }
711 else /* ! |OFN_UNICODE */
712 {
713 OPENFILENAMEA ofna;
714
715 /* FIXME: probably needs more converted */
716 ofna.lCustData = lpofn->lCustData;
717 return (BOOL)CallWindowProcA(
718 (WNDPROC)lpofn->lpfnHook,hwnd,wMsg,wParam,(LPARAM)&ofna
719 );
720 }
721 }
722 else /* ! needstruct */
723 {
724 HWINDOWPROC hWindowProc=NULL;
725
726 if (WINPROC_SetProc(&hWindowProc, (WNDPROC16)lpofn->lpfnHook, ProcType, WIN_PROC_WINDOW))
727 {
728 /* Call Window Procedure converting 16-Bit Type Parameters to 32-Bit Type Parameters */
729 result = CallWindowProc16( (WNDPROC16)hWindowProc,
730 hwnd, wMsg, wParam, lParam );
731
732 result = LOWORD(result);
733
734 WINPROC_FreeProc( hWindowProc, WIN_PROC_WINDOW );
735 }
736
737 return result;
738
739 }
740 }
741
742
743 /***********************************************************************
744 * FILEDLG_WMInitDialog [internal]
745 */
746
747 static LONG FILEDLG_WMInitDialog(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
748 {
749 int i, n;
750 LPOPENFILENAME16 lpofn;
751 char tmpstr[512];
752 LPSTR pstr, old_pstr;
753 SetPropA(hWnd,OFN_PROP,lParam);
754 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(lParam);
755 if (lpofn->lpstrTitle) SetWindowText16( hWnd, lpofn->lpstrTitle );
756 /* read custom filter information */
757 if (lpofn->lpstrCustomFilter)
758 {
759 pstr = (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter);
760 n = 0;
761 TRACE("lpstrCustomFilter = %p\n", pstr);
762 while(*pstr)
763 {
764 old_pstr = pstr;
765 i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING16, 0,
766 (LPARAM)lpofn->lpstrCustomFilter + n );
767 n += strlen(pstr) + 1;
768 pstr += strlen(pstr) + 1;
769 TRACE("add str='%s' "
770 "associated to '%s'\n", old_pstr, pstr);
771 SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA16, i, (LPARAM)pstr);
772 n += strlen(pstr) + 1;
773 pstr += strlen(pstr) + 1;
774 }
775 }
776 /* read filter information */
777 if (lpofn->lpstrFilter) {
778 pstr = (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFilter);
779 n = 0;
780 while(*pstr) {
781 old_pstr = pstr;
782 i = SendDlgItemMessage16(hWnd, cmb1, CB_ADDSTRING16, 0,
783 (LPARAM)lpofn->lpstrFilter + n );
784 n += strlen(pstr) + 1;
785 pstr += strlen(pstr) + 1;
786 TRACE("add str='%s' "
787 "associated to '%s'\n", old_pstr, pstr);
788 SendDlgItemMessage16(hWnd, cmb1, CB_SETITEMDATA16, i, (LPARAM)pstr);
789 n += strlen(pstr) + 1;
790 pstr += strlen(pstr) + 1;
791 }
792 }
793 /* set default filter */
794 if (lpofn->nFilterIndex == 0 && lpofn->lpstrCustomFilter == (SEGPTR)NULL)
795 lpofn->nFilterIndex = 1;
796 SendDlgItemMessage16(hWnd, cmb1, CB_SETCURSEL16, lpofn->nFilterIndex - 1, 0);
797 lstrcpynA(tmpstr, FILEDLG_GetFileType(PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter),
798 PTR_SEG_TO_LIN(lpofn->lpstrFilter), lpofn->nFilterIndex - 1),512);
799 TRACE("nFilterIndex = %ld, SetText of edt1 to '%s'\n",
800 lpofn->nFilterIndex, tmpstr);
801 SetDlgItemTextA( hWnd, edt1, tmpstr );
802 /* get drive list */
803 *tmpstr = 0;
804 DlgDirListComboBoxA(hWnd, tmpstr, cmb2, 0, DDL_DRIVES | DDL_EXCLUSIVE);
805 /* read initial directory */
806 if (PTR_SEG_TO_LIN(lpofn->lpstrInitialDir) != NULL)
807 {
808 int len;
809 lstrcpynA(tmpstr, PTR_SEG_TO_LIN(lpofn->lpstrInitialDir), 511);
810 len=strlen(tmpstr);
811 if (len > 0 && tmpstr[len-1] != '\\' && tmpstr[len-1] != ':') {
812 tmpstr[len]='\\';
813 tmpstr[len+1]='\0';
814 }
815 }
816 else
817 *tmpstr = 0;
818 if (!FILEDLG_ScanDir(hWnd, tmpstr)) {
819 *tmpstr = 0;
820 if (!FILEDLG_ScanDir(hWnd, tmpstr))
821 WARN("Couldn't read initial directory %s!\n",tmpstr);
822 }
823 /* select current drive in combo 2, omit missing drives */
824 for(i=0, n=-1; i<=DRIVE_GetCurrentDrive(); i++)
825 if (DRIVE_IsValid(i)) n++;
826 SendDlgItemMessage16(hWnd, cmb2, CB_SETCURSEL16, n, 0);
827 if (!(lpofn->Flags & OFN_SHOWHELP))
828 ShowWindow(GetDlgItem(hWnd, pshHelp), SW_HIDE);
829 if (lpofn->Flags & OFN_HIDEREADONLY)
830 ShowWindow(GetDlgItem(hWnd, chx1), SW_HIDE);
831 if (FILEDLG_HookCallChk(lpofn))
832 return (BOOL16)FILEDLG_CallWindowProc(lpofn,hWnd,WM_INITDIALOG,wParam,lParam );
833 else
834 return TRUE;
835 }
836
837 /***********************************************************************
838 * FILEDLG_WMCommand [internal]
839 */
840 BOOL in_update=FALSE;
841
842 static LRESULT FILEDLG_WMCommand(HWND16 hWnd, WPARAM16 wParam, LPARAM lParam)
843 {
844 LONG lRet;
845 LPOPENFILENAME16 lpofn;
846 OPENFILENAME16 ofn2;
847 char tmpstr[512], tmpstr2[512];
848 LPSTR pstr, pstr2;
849 UINT16 control,notification;
850
851 /* Notifications are packaged differently in Win32 */
852 control = wParam;
853 notification = HIWORD(lParam);
854
855 lpofn = (LPOPENFILENAME16)PTR_SEG_TO_LIN(GetPropA(hWnd,OFN_PROP));
856 switch (control)
857 {
858 case lst1: /* file list */
859 FILEDLG_StripEditControl(hWnd);
860 if (notification == LBN_DBLCLK)
861 goto almost_ok;
862 lRet = SendDlgItemMessage16(hWnd, lst1, LB_GETCURSEL16, 0, 0);
863 if (lRet == LB_ERR) return TRUE;
864 if ((pstr = SEGPTR_ALLOC(512)))
865 {
866 SendDlgItemMessage16(hWnd, lst1, LB_GETTEXT16, lRet,
867 (LPARAM)SEGPTR_GET(pstr));
868 SetDlgItemTextA( hWnd, edt1, pstr );
869 SEGPTR_FREE(pstr);
870 }
871 if (FILEDLG_HookCallChk(lpofn))
872 FILEDLG_CallWindowProc(lpofn,hWnd,
873 RegisterWindowMessageA( LBSELCHSTRING ),
874 control, MAKELONG(lRet,CD_LBSELCHANGE));
875 /* FIXME: for OFN_ALLOWMULTISELECT we need CD_LBSELSUB, CD_SELADD, CD_LBSELNOITEMS */
876 return TRUE;
877 case lst2: /* directory list */
878 FILEDLG_StripEditControl(hWnd);
879 if (notification == LBN_DBLCLK)
880 {
881 lRet = SendDlgItemMessage16(hWnd, lst2, LB_GETCURSEL16, 0, 0);
882 if (lRet == LB_ERR) return TRUE;
883 pstr = SEGPTR_ALLOC(512);
884 SendDlgItemMessage16(hWnd, lst2, LB_GETTEXT16, lRet,
885 (LPARAM)SEGPTR_GET(pstr));
886 strcpy( tmpstr, pstr );
887 SEGPTR_FREE(pstr);
888 if (tmpstr[0] == '[')
889 {
890 tmpstr[strlen(tmpstr) - 1] = 0;
891 strcpy(tmpstr,tmpstr+1);
892 }
893 strcat(tmpstr, "\\");
894 goto reset_scan;
895 }
896 return TRUE;
897 case cmb1: /* file type drop list */
898 if (notification == CBN_SELCHANGE)
899 {
900 *tmpstr = 0;
901 goto reset_scan;
902 }
903 return TRUE;
904 case chx1:
905 return TRUE;
906 case pshHelp:
907 return TRUE;
908 case cmb2: /* disk drop list */
909 FILEDLG_StripEditControl(hWnd);
910 lRet = SendDlgItemMessage16(hWnd, cmb2, CB_GETCURSEL16, 0, 0L);
911 if (lRet == LB_ERR) return 0;
912 pstr = SEGPTR_ALLOC(512);
913 SendDlgItemMessage16(hWnd, cmb2, CB_GETLBTEXT16, lRet,
914 (LPARAM)SEGPTR_GET(pstr));
915 sprintf(tmpstr, "%c:", pstr[2]);
916 SEGPTR_FREE(pstr);
917 if (notification != CBN_SELCHANGE) return TRUE;
918 reset_scan:
919 lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL16, 0, 0);
920 if (lRet == LB_ERR)
921 return TRUE;
922 pstr = (LPSTR)SendDlgItemMessage16(hWnd, cmb1, CB_GETITEMDATA16, lRet, 0);
923 TRACE("Selected filter : %s\n", pstr);
924 SetDlgItemTextA( hWnd, edt1, pstr );
925 FILEDLG_ScanDir(hWnd, tmpstr);
926 in_update=TRUE;
927 case IDOK:
928 almost_ok:
929 ofn2=*lpofn; /* for later restoring */
930 GetDlgItemTextA( hWnd, edt1, tmpstr, sizeof(tmpstr) );
931 pstr = strrchr(tmpstr, '\\');
932 if (pstr == NULL)
933 pstr = strrchr(tmpstr, ':');
934 if (strchr(tmpstr,'*') != NULL || strchr(tmpstr,'?') != NULL)
935 {
936 /* edit control contains wildcards */
937 if (pstr != NULL)
938 {
939 lstrcpynA(tmpstr2, pstr+1, 512);
940 *(pstr+1) = 0;
941 }
942 else
943 {
944 strcpy(tmpstr2, tmpstr);
945 *tmpstr=0;
946 }
947 TRACE("tmpstr=%s, tmpstr2=%s\n", tmpstr, tmpstr2);
948 SetDlgItemTextA( hWnd, edt1, tmpstr2 );
949 FILEDLG_ScanDir(hWnd, tmpstr);
950 return TRUE;
951 }
952 /* no wildcards, we might have a directory or a filename */
953 /* try appending a wildcard and reading the directory */
954 pstr2 = tmpstr + strlen(tmpstr);
955 if (pstr == NULL || *(pstr+1) != 0)
956 strcat(tmpstr, "\\");
957 lRet = SendDlgItemMessage16(hWnd, cmb1, CB_GETCURSEL16, 0, 0);
958 if (lRet == LB_ERR) return TRUE;
959 lpofn->nFilterIndex = lRet + 1;
960 TRACE("lpofn->nFilterIndex=%ld\n", lpofn->nFilterIndex);
961 lstrcpynA(tmpstr2,
962 FILEDLG_GetFileType(PTR_SEG_TO_LIN(lpofn->lpstrCustomFilter),
963 PTR_SEG_TO_LIN(lpofn->lpstrFilter),
964 lRet), sizeof(tmpstr2));
965 SetDlgItemTextA( hWnd, edt1, tmpstr2 );
966 if (!in_update)
967 /* if ScanDir succeeds, we have changed the directory */
968 if (FILEDLG_ScanDir(hWnd, tmpstr)) return TRUE;
969 /* if not, this must be a filename */
970 *pstr2 = 0;
971 if (pstr != NULL)
972 {
973 /* strip off the pathname */
974 *pstr = 0;
975 SetDlgItemTextA( hWnd, edt1, pstr + 1 );
976 lstrcpynA(tmpstr2, pstr+1, sizeof(tmpstr2) );
977 /* Should we MessageBox() if this fails? */
978 if (!FILEDLG_ScanDir(hWnd, tmpstr)) return TRUE;
979 strcpy(tmpstr, tmpstr2);
980 }
981 else SetDlgItemTextA( hWnd, edt1, tmpstr );
982 #if 0
983 ShowWindow16(hWnd, SW_HIDE); /* this should not be necessary ?! (%%%) */
984 #endif
985 {
986 int lenstr2;
987 int drive = DRIVE_GetCurrentDrive();
988 tmpstr2[0] = 'A'+ drive;
989 tmpstr2[1] = ':';
990 tmpstr2[2] = '\\';
991 lstrcpynA(tmpstr2 + 3, DRIVE_GetDosCwd(drive), 507);
992 lenstr2=strlen(tmpstr2);
993 if (lenstr2 > 3)
994 tmpstr2[lenstr2++]='\\';
995 lstrcpynA(tmpstr2+lenstr2, tmpstr, 512-lenstr2);
996 if (lpofn->lpstrFile)
997 lstrcpynA(PTR_SEG_TO_LIN(lpofn->lpstrFile), tmpstr2,lpofn->nMaxFile);
998 }
999 lpofn->nFileOffset = strrchr(tmpstr2,'\\') - tmpstr2 +1;
1000 lpofn->nFileExtension = 0;
1001 while(tmpstr2[lpofn->nFileExtension] != '.' && tmpstr2[lpofn->nFileExtension] != '\0')
1002 lpofn->nFileExtension++;
1003 if (tmpstr2[lpofn->nFileExtension] == '\0')
1004 lpofn->nFileExtension = 0;
1005 else
1006 lpofn->nFileExtension++;
1007
1008 if(in_update)
1009 {
1010 if (FILEDLG_HookCallChk(lpofn))
1011 FILEDLG_CallWindowProc(lpofn,hWnd,
1012 RegisterWindowMessageA( LBSELCHSTRING ),
1013 control, MAKELONG(lRet,CD_LBSELCHANGE));
1014
1015 in_update = FALSE;
1016 return TRUE;
1017 }
1018 if (PTR_SEG_TO_LIN(lpofn->lpstrFileTitle) != NULL)
1019 {
1020 lRet = SendDlgItemMessage16(hWnd, lst1, LB_GETCURSEL16, 0, 0);
1021 SendDlgItemMessage16(hWnd, lst1, LB_GETTEXT16, lRet,
1022 lpofn->lpstrFileTitle );
1023 }
1024 if (FILEDLG_HookCallChk(lpofn))
1025 {
1026 lRet= (BOOL16)FILEDLG_CallWindowProc(lpofn,
1027 hWnd, RegisterWindowMessageA( FILEOKSTRING ), 0, lParam );
1028 if (lRet)
1029 {
1030 *lpofn=ofn2; /* restore old state */
1031 #if 0
1032 ShowWindow16(hWnd, SW_SHOW); /* only if above (%%%) SW_HIDE used */
1033 #endif
1034 break;
1035 }
1036 }
1037 if ((lpofn->Flags & OFN_ALLOWMULTISELECT) && (lpofn->Flags & OFN_EXPLORER)) {
1038 if (lpofn->lpstrFile) {
1039 LPSTR str = (LPSTR)PTR_SEG_TO_LIN(lpofn->lpstrFile);
1040 LPSTR ptr = strrchr(str, '\\');
1041 str[strlen(str) + 1] = '\0';
1042 *ptr = 0;
1043 }
1044 }
1045 EndDialog(hWnd, TRUE);
1046 return TRUE;
1047 case IDCANCEL:
1048 EndDialog(hWnd, FALSE);
1049 return TRUE;
1050 }
1051 return FALSE;
1052 }
1053
1054 /***********************************************************************
1055 * FileOpenDlgProc16 (COMMDLG.6)
1056 */
1057 LRESULT WINAPI FileOpenDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1058 LPARAM lParam)
1059 {
1060 LPOPENFILENAME16 lpofn =(LPOPENFILENAME16)PTR_SEG_TO_LIN(GetPropA(hWnd,OFN_PROP));
1061
1062 if (wMsg!=WM_INITDIALOG)
1063 if (FILEDLG_HookCallChk(lpofn))
1064 {
1065 LRESULT lRet=(BOOL16)FILEDLG_CallWindowProc(lpofn,hWnd,wMsg,wParam,lParam);
1066 if (lRet)
1067 return lRet; /* else continue message processing */
1068 }
1069 switch (wMsg)
1070 {
1071 case WM_INITDIALOG:
1072 return FILEDLG_WMInitDialog(hWnd, wParam, lParam);
1073 case WM_MEASUREITEM:
1074 return FILEDLG_WMMeasureItem(hWnd, wParam, lParam);
1075 case WM_DRAWITEM:
1076 return FILEDLG_WMDrawItem(hWnd, wParam, lParam, FALSE);
1077 case WM_COMMAND:
1078 return FILEDLG_WMCommand(hWnd, wParam, lParam);
1079 #if 0
1080 case WM_CTLCOLOR:
1081 SetBkColor((HDC16)wParam, 0x00C0C0C0);
1082 switch (HIWORD(lParam))
1083 {
1084 case CTLCOLOR_BTN:
1085 SetTextColor((HDC16)wParam, 0x00000000);
1086 return hGRAYBrush;
1087 case CTLCOLOR_STATIC:
1088 SetTextColor((HDC16)wParam, 0x00000000);
1089 return hGRAYBrush;
1090 }
1091 break;
1092 #endif
1093 }
1094 return FALSE;
1095 }
1096
1097 /***********************************************************************
1098 * FileSaveDlgProc16 (COMMDLG.7)
1099 */
1100 LRESULT WINAPI FileSaveDlgProc16(HWND16 hWnd, UINT16 wMsg, WPARAM16 wParam,
1101 LPARAM lParam)
1102 {
1103 LPOPENFILENAME16 lpofn =(LPOPENFILENAME16)PTR_SEG_TO_LIN(GetPropA(hWnd,OFN_PROP));
1104
1105 if (wMsg!=WM_INITDIALOG)
1106 if (FILEDLG_HookCallChk(lpofn))
1107 {
1108 LRESULT lRet=(BOOL16)FILEDLG_CallWindowProc(lpofn,hWnd,wMsg,wParam,lParam);
1109 if (lRet)
1110 return lRet; /* else continue message processing */
1111 }
1112 switch (wMsg) {
1113 case WM_INITDIALOG:
1114 return FILEDLG_WMInitDialog(hWnd, wParam, lParam);
1115
1116 case WM_MEASUREITEM:
1117 return FILEDLG_WMMeasureItem(hWnd, wParam, lParam);
1118
1119 case WM_DRAWITEM:
1120 return FILEDLG_WMDrawItem(hWnd, wParam, lParam, TRUE);
1121
1122 case WM_COMMAND:
1123 return FILEDLG_WMCommand(hWnd, wParam, lParam);
1124 }
1125
1126 /*
1127 case WM_CTLCOLOR:
1128 SetBkColor((HDC16)wParam, 0x00C0C0C0);
1129 switch (HIWORD(lParam))
1130 {
1131 case CTLCOLOR_BTN:
1132 SetTextColor((HDC16)wParam, 0x00000000);
1133 return hGRAYBrush;
1134 case CTLCOLOR_STATIC:
1135 SetTextColor((HDC16)wParam, 0x00000000);
1136 return hGRAYBrush;
1137 }
1138 return FALSE;
1139
1140 */
1141 return FALSE;
1142 }
1143
1144 static BOOL Commdlg_GetFileNameA( BOOL16 (CALLBACK *dofunction)(SEGPTR x),
1145 LPOPENFILENAMEA ofn )
1146 {
1147 BOOL16 ret;
1148 LPOPENFILENAME16 ofn16 = SEGPTR_ALLOC(sizeof(OPENFILENAME16));
1149
1150 memset(ofn16,'\0',sizeof(*ofn16));
1151 ofn16->lStructSize = sizeof(*ofn16);
1152 ofn16->hwndOwner = ofn->hwndOwner;
1153 ofn16->hInstance = MapHModuleLS(ofn->hInstance);
1154 if (ofn->lpstrFilter) {
1155 LPSTR s,x;
1156
1157 /* filter is a list... title\0ext\0......\0\0 */
1158 s = (LPSTR)ofn->lpstrFilter;
1159 while (*s)
1160 s = s+strlen(s)+1;
1161 s++;
1162 x = (LPSTR)SEGPTR_ALLOC(s-ofn->lpstrFilter);
1163 memcpy(x,ofn->lpstrFilter,s-ofn->lpstrFilter);
1164 ofn16->lpstrFilter = SEGPTR_GET(x);
1165 }
1166 if (ofn->lpstrCustomFilter) {
1167 LPSTR s,x;
1168
1169 /* filter is a list... title\0ext\0......\0\0 */
1170 s = (LPSTR)ofn->lpstrCustomFilter;
1171 while (*s)
1172 s = s+strlen(s)+1;
1173 s++;
1174 x = SEGPTR_ALLOC(s-ofn->lpstrCustomFilter);
1175 memcpy(x,ofn->lpstrCustomFilter,s-ofn->lpstrCustomFilter);
1176 ofn16->lpstrCustomFilter = SEGPTR_GET(x);
1177 }
1178 ofn16->nMaxCustFilter = ofn->nMaxCustFilter;
1179 ofn16->nFilterIndex = ofn->nFilterIndex;
1180 if (ofn->nMaxFile)
1181 ofn16->lpstrFile = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFile));
1182 ofn16->nMaxFile = ofn->nMaxFile;
1183 ofn16->nMaxFileTitle = ofn->nMaxFileTitle;
1184 if (ofn16->nMaxFileTitle)
1185 ofn16->lpstrFileTitle = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFileTitle));
1186 if (ofn->lpstrInitialDir)
1187 ofn16->lpstrInitialDir = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpstrInitialDir));
1188 if (ofn->lpstrTitle)
1189 ofn16->lpstrTitle = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpstrTitle));
1190 ofn16->Flags = ofn->Flags|OFN_WINE;
1191 ofn16->nFileOffset = ofn->nFileOffset;
1192 ofn16->nFileExtension = ofn->nFileExtension;
1193 if (ofn->lpstrDefExt)
1194 ofn16->lpstrDefExt = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpstrDefExt));
1195 ofn16->lCustData = ofn->lCustData;
1196 ofn16->lpfnHook = (LPOFNHOOKPROC16)ofn->lpfnHook;
1197
1198 if (ofn->lpTemplateName)
1199 ofn16->lpTemplateName = SEGPTR_GET(SEGPTR_STRDUP(ofn->lpTemplateName));
1200
1201 ret = dofunction(SEGPTR_GET(ofn16));
1202
1203 ofn->nFileOffset = ofn16->nFileOffset;
1204 ofn->nFileExtension = ofn16->nFileExtension;
1205 if (ofn16->lpstrFilter)
1206 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFilter));
1207 if (ofn16->lpTemplateName)
1208 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpTemplateName));
1209 if (ofn16->lpstrDefExt)
1210 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrDefExt));
1211 if (ofn16->lpstrTitle)
1212 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrTitle));
1213 if (ofn16->lpstrInitialDir)
1214 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrInitialDir));
1215 if (ofn16->lpstrCustomFilter)
1216 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrCustomFilter));
1217
1218 if (ofn16->lpstrFile)
1219 {
1220 LPCSTR src = PTR_SEG_TO_LIN(ofn16->lpstrFile);
1221 LPSTR dst = ofn->lpstrFile;
1222
1223 if ((ofn->Flags & OFN_ALLOWMULTISELECT) && (ofn->Flags & OFN_EXPLORER)) {
1224 /* FIXME(EPP): I tried to use:
1225 * memcpy(ofn->lpstrFile, PTR_SEG_TO_LIN(ofn16->lpstrFile, ofn->nMaxFile)
1226 * but it did crash with winamp 2.21, so copy string by string
1227 */
1228 int len;
1229 do {
1230 strcpy(dst, src);
1231 len = strlen(dst) + 1; /* strlen(dst) == strlen(src) */
1232 dst += len;
1233 src += len;
1234 } while (len > 1);
1235 } else {
1236 strcpy(dst, src);
1237 }
1238 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFile));
1239 }
1240
1241 if (ofn16->lpstrFileTitle)
1242 {
1243 if (ofn->lpstrFileTitle)
1244 strcpy(ofn->lpstrFileTitle,
1245 PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
1246 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
1247 }
1248 SEGPTR_FREE(ofn16);
1249 return ret;
1250 }
1251
1252 static BOOL Commdlg_GetFileNameW( BOOL16 (CALLBACK *dofunction)(SEGPTR x),
1253 LPOPENFILENAMEW ofn )
1254 {
1255 BOOL16 ret;
1256 LPOPENFILENAME16 ofn16 = SEGPTR_ALLOC(sizeof(OPENFILENAME16));
1257
1258 memset(ofn16,'\0',sizeof(*ofn16));
1259 ofn16->lStructSize = sizeof(*ofn16);
1260 ofn16->hwndOwner = ofn->hwndOwner;
1261 ofn16->hInstance = MapHModuleLS(ofn->hInstance);
1262 if (ofn->lpstrFilter) {
1263 LPWSTR s;
1264 LPSTR x,y;
1265 int n;
1266
1267 /* filter is a list... title\0ext\0......\0\0 */
1268 s = (LPWSTR)ofn->lpstrFilter;
1269 while (*s)
1270 s = s+lstrlenW(s)+1;
1271 s++;
1272 n = s - ofn->lpstrFilter; /* already divides by 2. ptr magic */
1273 x = y = (LPSTR)SEGPTR_ALLOC(n);
1274 s = (LPWSTR)ofn->lpstrFilter;
1275 while (*s) {
1276 lstrcpyWtoA(x,s);
1277 x+=lstrlenA(x)+1;
1278 s+=lstrlenW(s)+1;
1279 }
1280 *x=0;
1281 ofn16->lpstrFilter = SEGPTR_GET(y);
1282 }
1283 if (ofn->lpstrCustomFilter) {
1284 LPWSTR s;
1285 LPSTR x,y;
1286 int n;
1287
1288 /* filter is a list... title\0ext\0......\0\0 */
1289 s = (LPWSTR)ofn->lpstrCustomFilter;
1290 while (*s)
1291 s = s+lstrlenW(s)+1;
1292 s++;
1293 n = s - ofn->lpstrCustomFilter;
1294 x = y = (LPSTR)SEGPTR_ALLOC(n);
1295 s = (LPWSTR)ofn->lpstrCustomFilter;
1296 while (*s) {
1297 lstrcpyWtoA(x,s);
1298 x+=lstrlenA(x)+1;
1299 s+=lstrlenW(s)+1;
1300 }
1301 *x=0;
1302 ofn16->lpstrCustomFilter = SEGPTR_GET(y);
1303 }
1304 ofn16->nMaxCustFilter = ofn->nMaxCustFilter;
1305 ofn16->nFilterIndex = ofn->nFilterIndex;
1306 if (ofn->nMaxFile)
1307 ofn16->lpstrFile = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFile));
1308 ofn16->nMaxFile = ofn->nMaxFile;
1309 ofn16->nMaxFileTitle = ofn->nMaxFileTitle;
1310 if (ofn->nMaxFileTitle)
1311 ofn16->lpstrFileTitle = SEGPTR_GET(SEGPTR_ALLOC(ofn->nMaxFileTitle));
1312 if (ofn->lpstrInitialDir)
1313 ofn16->lpstrInitialDir = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpstrInitialDir));
1314 if (ofn->lpstrTitle)
1315 ofn16->lpstrTitle = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpstrTitle));
1316 ofn16->Flags = ofn->Flags|OFN_WINE|OFN_UNICODE;
1317 ofn16->nFileOffset = ofn->nFileOffset;
1318 ofn16->nFileExtension = ofn->nFileExtension;
1319 if (ofn->lpstrDefExt)
1320 ofn16->lpstrDefExt = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpstrDefExt));
1321 ofn16->lCustData = ofn->lCustData;
1322 ofn16->lpfnHook = (LPOFNHOOKPROC16)ofn->lpfnHook;
1323 if (ofn->lpTemplateName)
1324 ofn16->lpTemplateName = SEGPTR_GET(SEGPTR_STRDUP_WtoA(ofn->lpTemplateName));
1325 ret = dofunction(SEGPTR_GET(ofn16));
1326
1327 ofn->nFileOffset = ofn16->nFileOffset;
1328 ofn->nFileExtension = ofn16->nFileExtension;
1329 if (ofn16->lpstrFilter)
1330 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFilter));
1331 if (ofn16->lpTemplateName)
1332 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpTemplateName));
1333 if (ofn16->lpstrDefExt)
1334 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrDefExt));
1335 if (ofn16->lpstrTitle)
1336 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrTitle));
1337 if (ofn16->lpstrInitialDir)
1338 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrInitialDir));
1339 if (ofn16->lpstrCustomFilter)
1340 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrCustomFilter));
1341
1342 if (ofn16->lpstrFile)
1343 {
1344 LPCSTR src = PTR_SEG_TO_LIN(ofn16->lpstrFile);
1345 LPWSTR dst = ofn->lpstrFile;
1346
1347 if ((ofn->Flags & OFN_ALLOWMULTISELECT) && (ofn->Flags & OFN_EXPLORER)) {
1348 int len;
1349 do {
1350 lstrcpyAtoW(dst, src);
1351 dst += lstrlenW(dst) + 1;
1352 src += (len = strlen(src) + 1);
1353 } while (len > 1);
1354 } else {
1355 lstrcpyAtoW(ofn->lpstrFile,PTR_SEG_TO_LIN(ofn16->lpstrFile));
1356 }
1357 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFile));
1358 }
1359
1360 if (ofn16->lpstrFileTitle) {
1361 if (ofn->lpstrFileTitle)
1362 lstrcpyAtoW(ofn->lpstrFileTitle,
1363 PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
1364 SEGPTR_FREE(PTR_SEG_TO_LIN(ofn16->lpstrFileTitle));
1365 }
1366 SEGPTR_FREE(ofn16);
1367 return ret;
1368 }
1369 /***********************************************************************
1370 * GetOpenFileNameA (COMDLG32.10)
1371 *
1372 * Creates a dialog box for the user to select a file to open.
1373 *
1374 * RETURNS
1375 * TRUE on succes: user enters a valid file
1376 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1377 *
1378 */
1379 BOOL WINAPI GetOpenFileNameA(
1380 LPOPENFILENAMEA ofn) /* address of init structure */
1381 {
1382 BOOL newlook;
1383
1384 /* some flags don't allow to match the TWEAK_WineLook */
1385 if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
1386 {
1387 newlook = (ofn->Flags & OFN_EXPLORER) ? TRUE : FALSE;
1388 }
1389 else
1390 {
1391 /* no special flags set, we can match the TWEAK_WineLook */
1392 newlook = (TWEAK_WineLook>WIN31_LOOK) ? TRUE : FALSE;
1393 }
1394
1395 if (newlook)
1396 {
1397 return GetFileDialog95A(ofn, OPEN_DIALOG);
1398 }
1399 else
1400 {
1401 BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetOpenFileName16;
1402 return Commdlg_GetFileNameA(dofunction,ofn);
1403 }
1404 }
1405
1406 /***********************************************************************
1407 * GetOpenFileNameW (COMDLG32.11)
1408 *
1409 * Creates a dialog box for the user to select a file to open.
1410 *
1411 * RETURNS
1412 * TRUE on succes: user enters a valid file
1413 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1414 *
1415 */
1416 BOOL WINAPI GetOpenFileNameW(
1417 LPOPENFILENAMEW ofn) /* address of init structure */
1418 {
1419 BOOL newlook;
1420
1421 /* some flags don't allow to match the TWEAK_WineLook */
1422 if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
1423 {
1424 newlook = (ofn->Flags & OFN_EXPLORER) ? TRUE : FALSE;
1425 }
1426 else
1427 {
1428 /* no special flags set, we can match the TWEAK_WineLook */
1429 newlook = (TWEAK_WineLook>WIN31_LOOK) ? TRUE : FALSE;
1430 }
1431
1432 if (newlook)
1433 {
1434 return GetFileDialog95W(ofn, OPEN_DIALOG);
1435 }
1436 else
1437 {
1438 BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetOpenFileName16;
1439 return Commdlg_GetFileNameW(dofunction,ofn);
1440 }
1441 }
1442
1443 /***********************************************************************
1444 * GetSaveFileNameA (COMDLG32.12)
1445 *
1446 * Creates a dialog box for the user to select a file to save.
1447 *
1448 * RETURNS
1449 * TRUE on succes: user enters a valid file
1450 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1451 *
1452 */
1453 BOOL WINAPI GetSaveFileNameA(
1454 LPOPENFILENAMEA ofn) /* address of init structure */
1455 {
1456 BOOL newlook;
1457
1458 /* some flags don't allow to match the TWEAK_WineLook */
1459 if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
1460 {
1461 newlook = (ofn->Flags & OFN_EXPLORER) ? TRUE : FALSE;
1462 }
1463 else
1464 {
1465 /* no special flags set, we can match the TWEAK_WineLook */
1466 newlook = (TWEAK_WineLook>WIN31_LOOK) ? TRUE : FALSE;
1467 }
1468
1469 if (newlook)
1470 {
1471 return GetFileDialog95A(ofn, SAVE_DIALOG);
1472 }
1473 else
1474 {
1475 BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetSaveFileName16;
1476 return Commdlg_GetFileNameA(dofunction,ofn);
1477 }
1478 }
1479
1480 /***********************************************************************
1481 * GetSaveFileNameW (COMDLG32.13)
1482 *
1483 * Creates a dialog box for the user to select a file to save.
1484 *
1485 * RETURNS
1486 * TRUE on succes: user enters a valid file
1487 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
1488 *
1489 */
1490 BOOL WINAPI GetSaveFileNameW(
1491 LPOPENFILENAMEW ofn) /* address of init structure */
1492 {
1493 BOOL newlook;
1494
1495 /* some flags don't allow to match the TWEAK_WineLook */
1496 if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
1497 {
1498 newlook = (ofn->Flags & OFN_EXPLORER) ? TRUE : FALSE;
1499 }
1500 else
1501 {
1502 /* no special flags set, we can match the TWEAK_WineLook */
1503 newlook = (TWEAK_WineLook>WIN31_LOOK) ? TRUE : FALSE;
1504 }
1505
1506 if (newlook)
1507 {
1508 return GetFileDialog95W(ofn, SAVE_DIALOG);
1509 }
1510 else
1511 {
1512 BOOL16 (CALLBACK * dofunction)(SEGPTR ofn16) = GetSaveFileName16;
1513 return Commdlg_GetFileNameW(dofunction,ofn);
1514 }
1515 }
Quick hack tree for wine patches julliard doesn't want to commit