projects / reactos.git / blob
? search:


a28c4574e9fcef42f8ab37a46029e12cd8424eb6
[reactos.git] / reactos / dll / win32 / comdlg32 / filedlg.c
1 /*
2 * COMMDLG - File Open Dialogs Win95 look and feel
3 *
4 * Copyright 1999 Francois Boisvert
5 * Copyright 1999, 2000 Juergen Schmied
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * FIXME: The whole concept of handling unicode is badly broken.
22 * many hook-messages expect a pointer to a
23 * OPENFILENAMEA or W structure. With the current architecture
24 * we would have to convert the beast at every call to a hook.
25 * we have to find a better solution but it would likely cause
26 * a complete rewrite after which we should handle the
27 * OPENFILENAME structure without any converting (jsch).
28 *
29 * FIXME: any hook gets a OPENFILENAMEA structure
30 *
31 * FIXME: CDN_FILEOK is wrong implemented, other CDN_ messages likely too
32 *
33 * FIXME: old style hook messages are not implemented (except FILEOKSTRING)
34 *
35 * FIXME: algorithm for selecting the initial directory is too simple
36 *
37 * FIXME: add to recent docs
38 *
39 * FIXME: flags not implemented: OFN_DONTADDTORECENT,
40 * OFN_NODEREFERENCELINKS, OFN_NOREADONLYRETURN,
41 * OFN_NOTESTFILECREATE, OFN_USEMONIKERS
42 *
43 * FIXME: lCustData for lpfnHook (WM_INITDIALOG)
44 *
45 *
46 */
47
48 #include "config.h"
49 #include "wine/port.h"
50
51 #include <ctype.h>
52 #include <stdlib.h>
53 #include <stdarg.h>
54 #include <stdio.h>
55 #include <string.h>
56
57 #define COBJMACROS
58 #define NONAMELESSUNION
59 #define NONAMELESSSTRUCT
60
61 #include "windef.h"
62 #include "winbase.h"
63 #include "winternl.h"
64 #include "winnls.h"
65 #include "wingdi.h"
66 #include "winreg.h"
67 #include "winuser.h"
68 #include "commdlg.h"
69 #include "dlgs.h"
70 #include "cdlg.h"
71 #include "filedlg31.h"
72 #include "cderr.h"
73 #include "shellapi.h"
74 #include "shlobj.h"
75 #include "filedlgbrowser.h"
76 #include "shlwapi.h"
77
78 #include "wine/unicode.h"
79 #include "wine/debug.h"
80
81 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
82
83 #define UNIMPLEMENTED_FLAGS \
84 (OFN_DONTADDTORECENT |\
85 OFN_NODEREFERENCELINKS | OFN_NOREADONLYRETURN |\
86 OFN_NOTESTFILECREATE /*| OFN_USEMONIKERS*/)
87
88 #define IsHooked(fodInfos) \
89 ((fodInfos->ofnInfos->Flags & OFN_ENABLEHOOK) && fodInfos->ofnInfos->lpfnHook)
90 /***********************************************************************
91 * Data structure and global variables
92 */
93 typedef struct SFolder
94 {
95 int m_iImageIndex; /* Index of picture in image list */
96 HIMAGELIST hImgList;
97 int m_iIndent; /* Indentation index */
98 LPITEMIDLIST pidlItem; /* absolute pidl of the item */
99
100 } SFOLDER,*LPSFOLDER;
101
102 typedef struct tagLookInInfo
103 {
104 int iMaxIndentation;
105 UINT uSelectedItem;
106 } LookInInfos;
107
108 typedef struct tagFD32_PRIVATE
109 {
110 OPENFILENAMEA *ofnA; /* original structure if 32bits ansi dialog */
111 } FD32_PRIVATE, *PFD32_PRIVATE;
112
113
114 /***********************************************************************
115 * Defines and global variables
116 */
117
118 /* Draw item constant */
119 #define ICONWIDTH 18
120 #define XTEXTOFFSET 3
121
122 /* AddItem flags*/
123 #define LISTEND -1
124
125 /* SearchItem methods */
126 #define SEARCH_PIDL 1
127 #define SEARCH_EXP 2
128 #define ITEM_NOTFOUND -1
129
130 /* Undefined windows message sent by CreateViewObject*/
131 #define WM_GETISHELLBROWSER WM_USER+7
132
133 /* NOTE
134 * Those macros exist in windowsx.h. However, you can't really use them since
135 * they rely on the UNICODE defines and can't be used inside Wine itself.
136 */
137
138 /* Combo box macros */
139 #define CBAddString(hwnd,str) \
140 SendMessageW(hwnd, CB_ADDSTRING, 0, (LPARAM)(str));
141
142 #define CBInsertString(hwnd,str,pos) \
143 SendMessageW(hwnd, CB_INSERTSTRING, (WPARAM)(pos), (LPARAM)(str));
144
145 #define CBDeleteString(hwnd,pos) \
146 SendMessageW(hwnd, CB_DELETESTRING, (WPARAM)(pos), 0);
147
148 #define CBSetItemDataPtr(hwnd,iItemId,dataPtr) \
149 SendMessageW(hwnd, CB_SETITEMDATA, (WPARAM)(iItemId), (LPARAM)(dataPtr));
150
151 #define CBGetItemDataPtr(hwnd,iItemId) \
152 SendMessageW(hwnd, CB_GETITEMDATA, (WPARAM)(iItemId), 0)
153
154 #define CBGetLBText(hwnd,iItemId,str) \
155 SendMessageW(hwnd, CB_GETLBTEXT, (WPARAM)(iItemId), (LPARAM)(str));
156
157 #define CBGetCurSel(hwnd) \
158 SendMessageW(hwnd, CB_GETCURSEL, 0, 0);
159
160 #define CBSetCurSel(hwnd,pos) \
161 SendMessageW(hwnd, CB_SETCURSEL, (WPARAM)(pos), 0);
162
163 #define CBGetCount(hwnd) \
164 SendMessageW(hwnd, CB_GETCOUNT, 0, 0);
165 #define CBShowDropDown(hwnd,show) \
166 SendMessageW(hwnd, CB_SHOWDROPDOWN, (WPARAM)(show), 0);
167 #define CBSetItemHeight(hwnd,index,height) \
168 SendMessageW(hwnd, CB_SETITEMHEIGHT, (WPARAM)(index), (LPARAM)(height));
169
170 #define CBSetExtendedUI(hwnd,flag) \
171 SendMessageW(hwnd, CB_SETEXTENDEDUI, (WPARAM)(flag), 0)
172
173 const char FileOpenDlgInfosStr[] = "FileOpenDlgInfos"; /* windows property description string */
174 static const char LookInInfosStr[] = "LookInInfos"; /* LOOKIN combo box property */
175 static SIZE MemDialogSize = { 0, 0}; /* keep size of the (resizable) dialog */
176
177 /***********************************************************************
178 * Prototypes
179 */
180
181 /* Internal functions used by the dialog */
182 static LRESULT FILEDLG95_ResizeControls(HWND hwnd, WPARAM wParam, LPARAM lParam);
183 static LRESULT FILEDLG95_FillControls(HWND hwnd, WPARAM wParam, LPARAM lParam);
184 static LRESULT FILEDLG95_OnWMCommand(HWND hwnd, WPARAM wParam, LPARAM lParam);
185 static LRESULT FILEDLG95_OnWMGetIShellBrowser(HWND hwnd);
186 static BOOL FILEDLG95_OnOpen(HWND hwnd);
187 static LRESULT FILEDLG95_InitControls(HWND hwnd);
188 static void FILEDLG95_Clean(HWND hwnd);
189
190 /* Functions used by the shell navigation */
191 static LRESULT FILEDLG95_SHELL_Init(HWND hwnd);
192 static BOOL FILEDLG95_SHELL_UpFolder(HWND hwnd);
193 static BOOL FILEDLG95_SHELL_ExecuteCommand(HWND hwnd, LPCSTR lpVerb);
194 static void FILEDLG95_SHELL_Clean(HWND hwnd);
195 static BOOL FILEDLG95_SHELL_BrowseToDesktop(HWND hwnd);
196
197 /* Functions used by the EDIT box */
198 static int FILEDLG95_FILENAME_GetFileNames (HWND hwnd, LPWSTR * lpstrFileList, UINT * sizeUsed);
199
200 /* Functions used by the filetype combo box */
201 static HRESULT FILEDLG95_FILETYPE_Init(HWND hwnd);
202 static BOOL FILEDLG95_FILETYPE_OnCommand(HWND hwnd, WORD wNotifyCode);
203 static int FILEDLG95_FILETYPE_SearchExt(HWND hwnd,LPCWSTR lpstrExt);
204 static void FILEDLG95_FILETYPE_Clean(HWND hwnd);
205
206 /* Functions used by the Look In combo box */
207 static void FILEDLG95_LOOKIN_Init(HWND hwndCombo);
208 static LRESULT FILEDLG95_LOOKIN_DrawItem(LPDRAWITEMSTRUCT pDIStruct);
209 static BOOL FILEDLG95_LOOKIN_OnCommand(HWND hwnd, WORD wNotifyCode);
210 static int FILEDLG95_LOOKIN_AddItem(HWND hwnd,LPITEMIDLIST pidl, int iInsertId);
211 static int FILEDLG95_LOOKIN_SearchItem(HWND hwnd,WPARAM searchArg,int iSearchMethod);
212 static int FILEDLG95_LOOKIN_InsertItemAfterParent(HWND hwnd,LPITEMIDLIST pidl);
213 static int FILEDLG95_LOOKIN_RemoveMostExpandedItem(HWND hwnd);
214 int FILEDLG95_LOOKIN_SelectItem(HWND hwnd,LPITEMIDLIST pidl);
215 static void FILEDLG95_LOOKIN_Clean(HWND hwnd);
216
217 /* Miscellaneous tool functions */
218 static HRESULT GetName(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl,DWORD dwFlags,LPWSTR lpstrFileName);
219 IShellFolder* GetShellFolderFromPidl(LPITEMIDLIST pidlAbs);
220 LPITEMIDLIST GetParentPidl(LPITEMIDLIST pidl);
221 static LPITEMIDLIST GetPidlFromName(IShellFolder *psf,LPWSTR lpcstrFileName);
222 static BOOL IsPidlFolder (LPSHELLFOLDER psf, LPCITEMIDLIST pidl);
223 static UINT GetNumSelected( IDataObject *doSelected );
224
225 /* Shell memory allocation */
226 static void *MemAlloc(UINT size);
227 static void MemFree(void *mem);
228
229 static INT_PTR CALLBACK FileOpenDlgProc95(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
230 static INT_PTR FILEDLG95_HandleCustomDialogMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
231 static BOOL FILEDLG95_OnOpenMultipleFiles(HWND hwnd, LPWSTR lpstrFileList, UINT nFileCount, UINT sizeUsed);
232 static BOOL BrowseSelectedFolder(HWND hwnd);
233
234 /***********************************************************************
235 * GetFileName95
236 *
237 * Creates an Open common dialog box that lets the user select
238 * the drive, directory, and the name of a file or set of files to open.
239 *
240 * IN : The FileOpenDlgInfos structure associated with the dialog
241 * OUT : TRUE on success
242 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
243 */
244 static BOOL GetFileName95(FileOpenDlgInfos *fodInfos)
245 {
246
247 LRESULT lRes;
248 LPCVOID template;
249 HRSRC hRes;
250 HANDLE hDlgTmpl = 0;
251 HRESULT hr;
252
253 /* test for missing functionality */
254 if (fodInfos->ofnInfos->Flags & UNIMPLEMENTED_FLAGS)
255 {
256 FIXME("Flags 0x%08x not yet implemented\n",
257 fodInfos->ofnInfos->Flags & UNIMPLEMENTED_FLAGS);
258 }
259
260 /* Create the dialog from a template */
261
262 if(!(hRes = FindResourceW(COMDLG32_hInstance,MAKEINTRESOURCEW(NEWFILEOPENORD),(LPCWSTR)RT_DIALOG)))
263 {
264 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
265 return FALSE;
266 }
267 if (!(hDlgTmpl = LoadResource(COMDLG32_hInstance, hRes )) ||
268 !(template = LockResource( hDlgTmpl )))
269 {
270 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
271 return FALSE;
272 }
273
274 if (fodInfos->ofnInfos->Flags & OFN_ENABLESIZING)
275 {
276 ((LPDLGTEMPLATEW)template)->style |= WS_SIZEBOX;
277 fodInfos->sizedlg.cx = fodInfos->sizedlg.cy = 0;
278 fodInfos->initial_size.x = fodInfos->initial_size.y = 0;
279 }
280 else
281 ((LPDLGTEMPLATEW)template)->style &= ~WS_SIZEBOX;
282
283
284 /* old style hook messages */
285 if (IsHooked(fodInfos))
286 {
287 fodInfos->HookMsg.fileokstring = RegisterWindowMessageW(FILEOKSTRINGW);
288 fodInfos->HookMsg.lbselchstring = RegisterWindowMessageW(LBSELCHSTRINGW);
289 fodInfos->HookMsg.helpmsgstring = RegisterWindowMessageW(HELPMSGSTRINGW);
290 fodInfos->HookMsg.sharevistring = RegisterWindowMessageW(SHAREVISTRINGW);
291 }
292
293 /* Some shell namespace extensions depend on COM being initialized. */
294 hr = OleInitialize(NULL);
295
296 if (fodInfos->unicode)
297 lRes = DialogBoxIndirectParamW(COMDLG32_hInstance,
298 template,
299 fodInfos->ofnInfos->hwndOwner,
300 FileOpenDlgProc95,
301 (LPARAM) fodInfos);
302 else
303 lRes = DialogBoxIndirectParamA(COMDLG32_hInstance,
304 template,
305 fodInfos->ofnInfos->hwndOwner,
306 FileOpenDlgProc95,
307 (LPARAM) fodInfos);
308 if (SUCCEEDED(hr))
309 OleUninitialize();
310
311 /* Unable to create the dialog */
312 if( lRes == -1)
313 return FALSE;
314
315 return lRes;
316 }
317
318 /***********************************************************************
319 * GetFileDialog95A
320 *
321 * Call GetFileName95 with this structure and clean the memory.
322 *
323 * IN : The OPENFILENAMEA initialisation structure passed to
324 * GetOpenFileNameA win api function (see filedlg.c)
325 */
326 static BOOL GetFileDialog95A(LPOPENFILENAMEA ofn,UINT iDlgType)
327 {
328 BOOL ret;
329 FileOpenDlgInfos fodInfos;
330 LPSTR lpstrSavDir = NULL;
331 LPWSTR title = NULL;
332 LPWSTR defext = NULL;
333 LPWSTR filter = NULL;
334 LPWSTR customfilter = NULL;
335
336 /* Initialize CommDlgExtendedError() */
337 COMDLG32_SetCommDlgExtendedError(0);
338
339 /* Initialize FileOpenDlgInfos structure */
340 ZeroMemory(&fodInfos, sizeof(FileOpenDlgInfos));
341
342 /* Pass in the original ofn */
343 fodInfos.ofnInfos = (LPOPENFILENAMEW)ofn;
344
345 /* save current directory */
346 if (ofn->Flags & OFN_NOCHANGEDIR)
347 {
348 lpstrSavDir = MemAlloc(MAX_PATH);
349 GetCurrentDirectoryA(MAX_PATH, lpstrSavDir);
350 }
351
352 fodInfos.unicode = FALSE;
353
354 /* convert all the input strings to unicode */
355 if(ofn->lpstrInitialDir)
356 {
357 DWORD len = MultiByteToWideChar( CP_ACP, 0, ofn->lpstrInitialDir, -1, NULL, 0 );
358 fodInfos.initdir = MemAlloc((len+1)*sizeof(WCHAR));
359 MultiByteToWideChar( CP_ACP, 0, ofn->lpstrInitialDir, -1, fodInfos.initdir, len);
360 }
361 else
362 fodInfos.initdir = NULL;
363
364 if(ofn->lpstrFile)
365 {
366 fodInfos.filename = MemAlloc(ofn->nMaxFile*sizeof(WCHAR));
367 MultiByteToWideChar( CP_ACP, 0, ofn->lpstrFile, -1, fodInfos.filename, ofn->nMaxFile);
368 }
369 else
370 fodInfos.filename = NULL;
371
372 if(ofn->lpstrDefExt)
373 {
374 DWORD len = MultiByteToWideChar( CP_ACP, 0, ofn->lpstrDefExt, -1, NULL, 0 );
375 defext = MemAlloc((len+1)*sizeof(WCHAR));
376 MultiByteToWideChar( CP_ACP, 0, ofn->lpstrDefExt, -1, defext, len);
377 }
378 fodInfos.defext = defext;
379
380 if(ofn->lpstrTitle)
381 {
382 DWORD len = MultiByteToWideChar( CP_ACP, 0, ofn->lpstrTitle, -1, NULL, 0 );
383 title = MemAlloc((len+1)*sizeof(WCHAR));
384 MultiByteToWideChar( CP_ACP, 0, ofn->lpstrTitle, -1, title, len);
385 }
386 fodInfos.title = title;
387
388 if (ofn->lpstrFilter)
389 {
390 LPCSTR s;
391 int n, len;
392
393 /* filter is a list... title\0ext\0......\0\0 */
394 s = ofn->lpstrFilter;
395 while (*s) s = s+strlen(s)+1;
396 s++;
397 n = s - ofn->lpstrFilter;
398 len = MultiByteToWideChar( CP_ACP, 0, ofn->lpstrFilter, n, NULL, 0 );
399 filter = MemAlloc(len*sizeof(WCHAR));
400 MultiByteToWideChar( CP_ACP, 0, ofn->lpstrFilter, n, filter, len );
401 }
402 fodInfos.filter = filter;
403
404 /* convert lpstrCustomFilter */
405 if (ofn->lpstrCustomFilter)
406 {
407 LPCSTR s;
408 int n, len;
409
410 /* customfilter contains a pair of strings... title\0ext\0 */
411 s = ofn->lpstrCustomFilter;
412 if (*s) s = s+strlen(s)+1;
413 if (*s) s = s+strlen(s)+1;
414 n = s - ofn->lpstrCustomFilter;
415 len = MultiByteToWideChar( CP_ACP, 0, ofn->lpstrCustomFilter, n, NULL, 0 );
416 customfilter = MemAlloc(len*sizeof(WCHAR));
417 MultiByteToWideChar( CP_ACP, 0, ofn->lpstrCustomFilter, n, customfilter, len );
418 }
419 fodInfos.customfilter = customfilter;
420
421 /* Initialize the dialog property */
422 fodInfos.DlgInfos.dwDlgProp = 0;
423 fodInfos.DlgInfos.hwndCustomDlg = NULL;
424
425 switch(iDlgType)
426 {
427 case OPEN_DIALOG :
428 ret = GetFileName95(&fodInfos);
429 break;
430 case SAVE_DIALOG :
431 fodInfos.DlgInfos.dwDlgProp |= FODPROP_SAVEDLG;
432 ret = GetFileName95(&fodInfos);
433 break;
434 default :
435 ret = 0;
436 }
437
438 if (lpstrSavDir)
439 {
440 SetCurrentDirectoryA(lpstrSavDir);
441 MemFree(lpstrSavDir);
442 }
443
444 MemFree(title);
445 MemFree(defext);
446 MemFree(filter);
447 MemFree(customfilter);
448 MemFree(fodInfos.initdir);
449 MemFree(fodInfos.filename);
450
451 TRACE("selected file: %s\n",ofn->lpstrFile);
452
453 return ret;
454 }
455
456 /***********************************************************************
457 * GetFileDialog95W
458 *
459 * Copy the OPENFILENAMEW structure in a FileOpenDlgInfos structure.
460 * Call GetFileName95 with this structure and clean the memory.
461 *
462 */
463 static BOOL GetFileDialog95W(LPOPENFILENAMEW ofn,UINT iDlgType)
464 {
465 BOOL ret;
466 FileOpenDlgInfos fodInfos;
467 LPWSTR lpstrSavDir = NULL;
468
469 /* Initialize CommDlgExtendedError() */
470 COMDLG32_SetCommDlgExtendedError(0);
471
472 /* Initialize FileOpenDlgInfos structure */
473 ZeroMemory(&fodInfos, sizeof(FileOpenDlgInfos));
474
475 /* Pass in the original ofn */
476 fodInfos.ofnInfos = ofn;
477
478 fodInfos.title = ofn->lpstrTitle;
479 fodInfos.defext = ofn->lpstrDefExt;
480 fodInfos.filter = ofn->lpstrFilter;
481 fodInfos.customfilter = ofn->lpstrCustomFilter;
482
483 /* convert string arguments, save others */
484 if(ofn->lpstrFile)
485 {
486 fodInfos.filename = MemAlloc(ofn->nMaxFile*sizeof(WCHAR));
487 lstrcpynW(fodInfos.filename,ofn->lpstrFile,ofn->nMaxFile);
488 }
489 else
490 fodInfos.filename = NULL;
491
492 if(ofn->lpstrInitialDir)
493 {
494 /* fodInfos.initdir = strdupW(ofn->lpstrInitialDir); */
495 DWORD len = lstrlenW(ofn->lpstrInitialDir)+1;
496 fodInfos.initdir = MemAlloc(len*sizeof(WCHAR));
497 memcpy(fodInfos.initdir,ofn->lpstrInitialDir,len*sizeof(WCHAR));
498 }
499 else
500 fodInfos.initdir = NULL;
501
502 /* save current directory */
503 if (ofn->Flags & OFN_NOCHANGEDIR)
504 {
505 lpstrSavDir = MemAlloc(MAX_PATH*sizeof(WCHAR));
506 GetCurrentDirectoryW(MAX_PATH, lpstrSavDir);
507 }
508
509 fodInfos.unicode = TRUE;
510
511 switch(iDlgType)
512 {
513 case OPEN_DIALOG :
514 ret = GetFileName95(&fodInfos);
515 break;
516 case SAVE_DIALOG :
517 fodInfos.DlgInfos.dwDlgProp |= FODPROP_SAVEDLG;
518 ret = GetFileName95(&fodInfos);
519 break;
520 default :
521 ret = 0;
522 }
523
524 if (lpstrSavDir)
525 {
526 SetCurrentDirectoryW(lpstrSavDir);
527 MemFree(lpstrSavDir);
528 }
529
530 /* restore saved IN arguments and convert OUT arguments back */
531 MemFree(fodInfos.filename);
532 MemFree(fodInfos.initdir);
533 return ret;
534 }
535
536 /******************************************************************************
537 * COMDLG32_GetDisplayNameOf [internal]
538 *
539 * Helper function to get the display name for a pidl.
540 */
541 static BOOL COMDLG32_GetDisplayNameOf(LPCITEMIDLIST pidl, LPWSTR pwszPath) {
542 LPSHELLFOLDER psfDesktop;
543 STRRET strret;
544
545 if (FAILED(SHGetDesktopFolder(&psfDesktop)))
546 return FALSE;
547
548 if (FAILED(IShellFolder_GetDisplayNameOf(psfDesktop, pidl, SHGDN_FORPARSING, &strret))) {
549 IShellFolder_Release(psfDesktop);
550 return FALSE;
551 }
552
553 IShellFolder_Release(psfDesktop);
554 return SUCCEEDED(StrRetToBufW(&strret, pidl, pwszPath, MAX_PATH));
555 }
556
557 /***********************************************************************
558 * ArrangeCtrlPositions [internal]
559 *
560 * NOTE: Make sure to add testcases for any changes made here.
561 */
562 static void ArrangeCtrlPositions(HWND hwndChildDlg, HWND hwndParentDlg, BOOL hide_help)
563 {
564 HWND hwndChild, hwndStc32;
565 RECT rectParent, rectChild, rectStc32;
566 INT help_fixup = 0;
567 int chgx, chgy;
568
569 /* Take into account if open as read only checkbox and help button
570 * are hidden
571 */
572 if (hide_help)
573 {
574 RECT rectHelp, rectCancel;
575 GetWindowRect(GetDlgItem(hwndParentDlg, pshHelp), &rectHelp);
576 GetWindowRect(GetDlgItem(hwndParentDlg, IDCANCEL), &rectCancel);
577 /* subtract the height of the help button plus the space between
578 * the help button and the cancel button to the height of the dialog
579 */
580 help_fixup = rectHelp.bottom - rectCancel.bottom;
581 }
582
583 /*
584 There are two possibilities to add components to the default file dialog box.
585
586 By default, all the new components are added below the standard dialog box (the else case).
587
588 However, if there is a static text component with the stc32 id, a special case happens.
589 The x and y coordinates of stc32 indicate the top left corner where to place the standard file dialog box
590 in the window and the cx and cy indicate how to size the window.
591 Moreover, if the new component's coordinates are on the left of the stc32 , it is placed on the left
592 of the standard file dialog box. If they are above the stc32 component, it is placed above and so on....
593
594 */
595
596 GetClientRect(hwndParentDlg, &rectParent);
597
598 /* when arranging controls we have to use fixed parent size */
599 rectParent.bottom -= help_fixup;
600
601 hwndStc32 = GetDlgItem(hwndChildDlg, stc32);
602 if (hwndStc32)
603 {
604 GetWindowRect(hwndStc32, &rectStc32);
605 MapWindowPoints(0, hwndChildDlg, (LPPOINT)&rectStc32, 2);
606
607 /* set the size of the stc32 control according to the size of
608 * client area of the parent dialog
609 */
610 SetWindowPos(hwndStc32, 0,
611 0, 0,
612 rectParent.right, rectParent.bottom,
613 SWP_NOMOVE | SWP_NOZORDER);
614 }
615 else
616 SetRectEmpty(&rectStc32);
617
618 /* this part moves controls of the child dialog */
619 hwndChild = GetWindow(hwndChildDlg, GW_CHILD);
620 while (hwndChild)
621 {
622 if (hwndChild != hwndStc32)
623 {
624 GetWindowRect(hwndChild, &rectChild);
625 MapWindowPoints(0, hwndChildDlg, (LPPOINT)&rectChild, 2);
626
627 /* move only if stc32 exist */
628 if (hwndStc32 && rectChild.left > rectStc32.right)
629 {
630 /* move to the right of visible controls of the parent dialog */
631 rectChild.left += rectParent.right;
632 rectChild.left -= rectStc32.right;
633 }
634 /* move even if stc32 doesn't exist */
635 if (rectChild.top >= rectStc32.bottom)
636 {
637 /* move below visible controls of the parent dialog */
638 rectChild.top += rectParent.bottom;
639 rectChild.top -= rectStc32.bottom - rectStc32.top;
640 }
641
642 SetWindowPos(hwndChild, 0, rectChild.left, rectChild.top,
643 0, 0, SWP_NOSIZE | SWP_NOZORDER);
644 }
645 hwndChild = GetWindow(hwndChild, GW_HWNDNEXT);
646 }
647
648 /* this part moves controls of the parent dialog */
649 hwndChild = GetWindow(hwndParentDlg, GW_CHILD);
650 while (hwndChild)
651 {
652 if (hwndChild != hwndChildDlg)
653 {
654 GetWindowRect(hwndChild, &rectChild);
655 MapWindowPoints(0, hwndParentDlg, (LPPOINT)&rectChild, 2);
656
657 /* left,top of stc32 marks the position of controls
658 * from the parent dialog
659 */
660 rectChild.left += rectStc32.left;
661 rectChild.top += rectStc32.top;
662
663 SetWindowPos(hwndChild, 0, rectChild.left, rectChild.top,
664 0, 0, SWP_NOSIZE | SWP_NOZORDER);
665 }
666 hwndChild = GetWindow(hwndChild, GW_HWNDNEXT);
667 }
668
669 /* calculate the size of the resulting dialog */
670
671 /* here we have to use original parent size */
672 GetClientRect(hwndParentDlg, &rectParent);
673 GetClientRect(hwndChildDlg, &rectChild);
674 TRACE( "parent %s child %s stc32 %s\n", wine_dbgstr_rect( &rectParent),
675 wine_dbgstr_rect( &rectChild), wine_dbgstr_rect( &rectStc32));
676
677 if (hwndStc32)
678 {
679 /* width */
680 if (rectParent.right > rectStc32.right - rectStc32.left)
681 chgx = rectChild.right - ( rectStc32.right - rectStc32.left);
682 else
683 chgx = rectChild.right - rectParent.right;
684 /* height */
685 if (rectParent.bottom > rectStc32.bottom - rectStc32.top)
686 chgy = rectChild.bottom - ( rectStc32.bottom - rectStc32.top) - help_fixup;
687 else
688 /* Unconditionally set new dialog
689 * height to that of the child
690 */
691 chgy = rectChild.bottom - rectParent.bottom;
692 }
693 else
694 {
695 chgx = 0;
696 chgy = rectChild.bottom - help_fixup;
697 }
698 /* set the size of the parent dialog */
699 GetWindowRect(hwndParentDlg, &rectParent);
700 SetWindowPos(hwndParentDlg, 0,
701 0, 0,
702 rectParent.right - rectParent.left + chgx,
703 rectParent.bottom - rectParent.top + chgy,
704 SWP_NOMOVE | SWP_NOZORDER);
705 }
706
707 static INT_PTR CALLBACK FileOpenDlgProcUserTemplate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
708 {
709 switch(uMsg) {
710 case WM_INITDIALOG:
711 return TRUE;
712 }
713 return FALSE;
714 }
715
716 static HWND CreateTemplateDialog(FileOpenDlgInfos *fodInfos, HWND hwnd)
717 {
718 LPCVOID template;
719 HRSRC hRes;
720 HANDLE hDlgTmpl = 0;
721 HWND hChildDlg = 0;
722
723 TRACE("\n");
724
725 /*
726 * If OFN_ENABLETEMPLATEHANDLE is specified, the OPENFILENAME
727 * structure's hInstance parameter is not a HINSTANCE, but
728 * instead a pointer to a template resource to use.
729 */
730 if (fodInfos->ofnInfos->Flags & (OFN_ENABLETEMPLATE | OFN_ENABLETEMPLATEHANDLE))
731 {
732 HINSTANCE hinst;
733 if (fodInfos->ofnInfos->Flags & OFN_ENABLETEMPLATEHANDLE)
734 {
735 hinst = COMDLG32_hInstance;
736 if( !(template = LockResource( fodInfos->ofnInfos->hInstance)))
737 {
738 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
739 return NULL;
740 }
741 }
742 else
743 {
744 hinst = fodInfos->ofnInfos->hInstance;
745 if(fodInfos->unicode)
746 {
747 LPOPENFILENAMEW ofn = fodInfos->ofnInfos;
748 hRes = FindResourceW( hinst, ofn->lpTemplateName, (LPWSTR)RT_DIALOG);
749 }
750 else
751 {
752 LPOPENFILENAMEA ofn = (LPOPENFILENAMEA)fodInfos->ofnInfos;
753 hRes = FindResourceA( hinst, ofn->lpTemplateName, (LPSTR)RT_DIALOG);
754 }
755 if (!hRes)
756 {
757 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
758 return NULL;
759 }
760 if (!(hDlgTmpl = LoadResource( hinst, hRes )) ||
761 !(template = LockResource( hDlgTmpl )))
762 {
763 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
764 return NULL;
765 }
766 }
767 if (fodInfos->unicode)
768 hChildDlg = CreateDialogIndirectParamW(hinst, template, hwnd,
769 IsHooked(fodInfos) ? (DLGPROC)fodInfos->ofnInfos->lpfnHook : FileOpenDlgProcUserTemplate,
770 (LPARAM)fodInfos->ofnInfos);
771 else
772 hChildDlg = CreateDialogIndirectParamA(hinst, template, hwnd,
773 IsHooked(fodInfos) ? (DLGPROC)fodInfos->ofnInfos->lpfnHook : FileOpenDlgProcUserTemplate,
774 (LPARAM)fodInfos->ofnInfos);
775 return hChildDlg;
776 }
777 else if( IsHooked(fodInfos))
778 {
779 RECT rectHwnd;
780 struct {
781 DLGTEMPLATE tmplate;
782 WORD menu,class,title;
783 } temp;
784 GetClientRect(hwnd,&rectHwnd);
785 temp.tmplate.style = WS_CHILD | WS_CLIPSIBLINGS | WS_VISIBLE | DS_CONTROL | DS_3DLOOK;
786 temp.tmplate.dwExtendedStyle = 0;
787 temp.tmplate.cdit = 0;
788 temp.tmplate.x = 0;
789 temp.tmplate.y = 0;
790 temp.tmplate.cx = 0;
791 temp.tmplate.cy = 0;
792 temp.menu = temp.class = temp.title = 0;
793
794 hChildDlg = CreateDialogIndirectParamA(COMDLG32_hInstance, &temp.tmplate,
795 hwnd, (DLGPROC)fodInfos->ofnInfos->lpfnHook, (LPARAM)fodInfos->ofnInfos);
796
797 return hChildDlg;
798 }
799 return NULL;
800 }
801
802 /***********************************************************************
803 * SendCustomDlgNotificationMessage
804 *
805 * Send CustomDialogNotification (CDN_FIRST -- CDN_LAST) message to the custom template dialog
806 */
807
808 LRESULT SendCustomDlgNotificationMessage(HWND hwndParentDlg, UINT uCode)
809 {
810 LRESULT hook_result = 0;
811 FileOpenDlgInfos *fodInfos = GetPropA(hwndParentDlg,FileOpenDlgInfosStr);
812
813 TRACE("%p 0x%04x\n",hwndParentDlg, uCode);
814
815 if(!fodInfos) return 0;
816
817 if(fodInfos->DlgInfos.hwndCustomDlg)
818 {
819 TRACE("CALL NOTIFY for %x\n", uCode);
820 if(fodInfos->unicode)
821 {
822 OFNOTIFYW ofnNotify;
823 ofnNotify.hdr.hwndFrom=hwndParentDlg;
824 ofnNotify.hdr.idFrom=0;
825 ofnNotify.hdr.code = uCode;
826 ofnNotify.lpOFN = fodInfos->ofnInfos;
827 ofnNotify.pszFile = NULL;
828 hook_result = SendMessageW(fodInfos->DlgInfos.hwndCustomDlg,WM_NOTIFY,0,(LPARAM)&ofnNotify);
829 }
830 else
831 {
832 OFNOTIFYA ofnNotify;
833 ofnNotify.hdr.hwndFrom=hwndParentDlg;
834 ofnNotify.hdr.idFrom=0;
835 ofnNotify.hdr.code = uCode;
836 ofnNotify.lpOFN = (LPOPENFILENAMEA)fodInfos->ofnInfos;
837 ofnNotify.pszFile = NULL;
838 hook_result = SendMessageA(fodInfos->DlgInfos.hwndCustomDlg,WM_NOTIFY,0,(LPARAM)&ofnNotify);
839 }
840 TRACE("RET NOTIFY\n");
841 }
842 TRACE("Retval: 0x%08lx\n", hook_result);
843 return hook_result;
844 }
845
846 static INT_PTR FILEDLG95_Handle_GetFilePath(HWND hwnd, DWORD size, LPVOID result)
847 {
848 UINT len, total;
849 WCHAR *p, *buffer;
850 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
851
852 TRACE("CDM_GETFILEPATH:\n");
853
854 if ( ! (fodInfos->ofnInfos->Flags & OFN_EXPLORER ) )
855 return -1;
856
857 /* get path and filenames */
858 len = SendMessageW( fodInfos->DlgInfos.hwndFileName, WM_GETTEXTLENGTH, 0, 0 );
859 buffer = HeapAlloc( GetProcessHeap(), 0, (len + 2 + MAX_PATH) * sizeof(WCHAR) );
860 COMDLG32_GetDisplayNameOf( fodInfos->ShellInfos.pidlAbsCurrent, buffer );
861 if (len)
862 {
863 p = buffer + strlenW(buffer);
864 *p++ = '\\';
865 SendMessageW( fodInfos->DlgInfos.hwndFileName, WM_GETTEXT, len + 1, (LPARAM)p );
866 }
867 if (fodInfos->unicode)
868 {
869 total = strlenW( buffer) + 1;
870 if (result) lstrcpynW( result, buffer, size );
871 TRACE( "CDM_GETFILEPATH: returning %u %s\n", total, debugstr_w(result));
872 }
873 else
874 {
875 total = WideCharToMultiByte( CP_ACP, 0, buffer, -1, NULL, 0, NULL, NULL );
876 if (total <= size) WideCharToMultiByte( CP_ACP, 0, buffer, -1, result, size, NULL, NULL );
877 TRACE( "CDM_GETFILEPATH: returning %u %s\n", total, debugstr_a(result));
878 }
879 HeapFree( GetProcessHeap(), 0, buffer );
880 return total;
881 }
882
883 /***********************************************************************
884 * FILEDLG95_HandleCustomDialogMessages
885 *
886 * Handle Custom Dialog Messages (CDM_FIRST -- CDM_LAST) messages
887 */
888 static INT_PTR FILEDLG95_HandleCustomDialogMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
889 {
890 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
891 WCHAR lpstrPath[MAX_PATH];
892 INT_PTR retval;
893
894 if(!fodInfos) return FALSE;
895
896 switch(uMsg)
897 {
898 case CDM_GETFILEPATH:
899 retval = FILEDLG95_Handle_GetFilePath(hwnd, (UINT)wParam, (LPVOID)lParam);
900 break;
901
902 case CDM_GETFOLDERPATH:
903 TRACE("CDM_GETFOLDERPATH:\n");
904 COMDLG32_GetDisplayNameOf(fodInfos->ShellInfos.pidlAbsCurrent, lpstrPath);
905 if (lParam)
906 {
907 if (fodInfos->unicode)
908 lstrcpynW((LPWSTR)lParam, lpstrPath, (int)wParam);
909 else
910 WideCharToMultiByte(CP_ACP, 0, lpstrPath, -1,
911 (LPSTR)lParam, (int)wParam, NULL, NULL);
912 }
913 retval = lstrlenW(lpstrPath) + 1;
914 break;
915
916 case CDM_GETFOLDERIDLIST:
917 retval = COMDLG32_PIDL_ILGetSize(fodInfos->ShellInfos.pidlAbsCurrent);
918 if (retval <= wParam)
919 memcpy((void*)lParam, fodInfos->ShellInfos.pidlAbsCurrent, retval);
920 break;
921
922 case CDM_GETSPEC:
923 TRACE("CDM_GETSPEC:\n");
924 retval = SendMessageW(fodInfos->DlgInfos.hwndFileName, WM_GETTEXTLENGTH, 0, 0) + 1;
925 if (lParam)
926 {
927 if (fodInfos->unicode)
928 SendMessageW(fodInfos->DlgInfos.hwndFileName, WM_GETTEXT, wParam, lParam);
929 else
930 SendMessageA(fodInfos->DlgInfos.hwndFileName, WM_GETTEXT, wParam, lParam);
931 }
932 break;
933
934 case CDM_SETCONTROLTEXT:
935 TRACE("CDM_SETCONTROLTEXT:\n");
936 if ( lParam )
937 {
938 if( fodInfos->unicode )
939 SetDlgItemTextW( hwnd, (UINT) wParam, (LPWSTR) lParam );
940 else
941 SetDlgItemTextA( hwnd, (UINT) wParam, (LPSTR) lParam );
942 }
943 retval = TRUE;
944 break;
945
946 case CDM_HIDECONTROL:
947 /* MSDN states that it should fail for not OFN_EXPLORER case */
948 if (fodInfos->ofnInfos->Flags & OFN_EXPLORER)
949 {
950 HWND control = GetDlgItem( hwnd, wParam );
951 if (control) ShowWindow( control, SW_HIDE );
952 retval = TRUE;
953 }
954 else retval = FALSE;
955 break;
956
957 default:
958 if (uMsg >= CDM_FIRST && uMsg <= CDM_LAST)
959 FIXME("message CDM_FIRST+%04x not implemented\n", uMsg - CDM_FIRST);
960 return FALSE;
961 }
962 SetWindowLongPtrW(hwnd, DWLP_MSGRESULT, retval);
963 return TRUE;
964 }
965
966 /***********************************************************************
967 * FILEDLG95_OnWMGetMMI
968 *
969 * WM_GETMINMAXINFO message handler for resizable dialogs
970 */
971 static LRESULT FILEDLG95_OnWMGetMMI( HWND hwnd, LPMINMAXINFO mmiptr)
972 {
973 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
974 if( !(fodInfos->ofnInfos->Flags & OFN_ENABLESIZING)) return FALSE;
975 if( fodInfos->initial_size.x || fodInfos->initial_size.y)
976 {
977 mmiptr->ptMinTrackSize = fodInfos->initial_size;
978 }
979 return TRUE;
980 }
981
982 /***********************************************************************
983 * FILEDLG95_OnWMSize
984 *
985 * WM_SIZE message handler, resize the dialog. Re-arrange controls.
986 *
987 * FIXME: this could be made more elaborate. Now use a simple scheme
988 * where the file view is enlarged and the controls are either moved
989 * vertically or horizontally to get out of the way. Only the "grip"
990 * is moved in both directions to stay in the corner.
991 */
992 static LRESULT FILEDLG95_OnWMSize(HWND hwnd, WPARAM wParam, LPARAM lParam)
993 {
994 RECT rc, rcview;
995 int chgx, chgy;
996 HWND ctrl;
997 HDWP hdwp;
998 FileOpenDlgInfos *fodInfos;
999
1000 if( wParam != SIZE_RESTORED) return FALSE;
1001 fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
1002 if( !(fodInfos->ofnInfos->Flags & OFN_ENABLESIZING)) return FALSE;
1003 /* get the new dialog rectangle */
1004 GetWindowRect( hwnd, &rc);
1005 TRACE("Size from %d,%d to %d,%d\n", fodInfos->sizedlg.cx, fodInfos->sizedlg.cy,
1006 rc.right -rc.left, rc.bottom -rc.top);
1007 /* not initialized yet */
1008 if( (fodInfos->sizedlg.cx == 0 && fodInfos->sizedlg.cy == 0) ||
1009 ((fodInfos->sizedlg.cx == rc.right -rc.left) && /* no change */
1010 (fodInfos->sizedlg.cy == rc.bottom -rc.top)))
1011 return FALSE;
1012 chgx = rc.right - rc.left - fodInfos->sizedlg.cx;
1013 chgy = rc.bottom - rc.top - fodInfos->sizedlg.cy;
1014 fodInfos->sizedlg.cx = rc.right - rc.left;
1015 fodInfos->sizedlg.cy = rc.bottom - rc.top;
1016 /* change the size of the view window */
1017 GetWindowRect( fodInfos->ShellInfos.hwndView, &rcview);
1018 MapWindowPoints( NULL, hwnd, (LPPOINT) &rcview, 2);
1019 hdwp = BeginDeferWindowPos( 10);
1020 DeferWindowPos( hdwp, fodInfos->ShellInfos.hwndView, NULL, 0, 0,
1021 rcview.right - rcview.left + chgx,
1022 rcview.bottom - rcview.top + chgy,
1023 SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
1024 /* change position and sizes of the controls */
1025 for( ctrl = GetWindow( hwnd, GW_CHILD); ctrl ; ctrl = GetWindow( ctrl, GW_HWNDNEXT))
1026 {
1027 int ctrlid = GetDlgCtrlID( ctrl);
1028 GetWindowRect( ctrl, &rc);
1029 MapWindowPoints( NULL, hwnd, (LPPOINT) &rc, 2);
1030 if( ctrl == fodInfos->DlgInfos.hwndGrip)
1031 {
1032 DeferWindowPos( hdwp, ctrl, NULL, rc.left + chgx, rc.top + chgy,
1033 0, 0,
1034 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
1035 }
1036 else if( rc.top > rcview.bottom)
1037 {
1038 /* if it was below the shell view
1039 * move to bottom */
1040 switch( ctrlid)
1041 {
1042 /* file name box and file types combo change also width */
1043 case edt1:
1044 case cmb1:
1045 DeferWindowPos( hdwp, ctrl, NULL, rc.left, rc.top + chgy,
1046 rc.right - rc.left + chgx, rc.bottom - rc.top,
1047 SWP_NOACTIVATE | SWP_NOZORDER);
1048 break;
1049 /* then these buttons must move out of the way */
1050 case IDOK:
1051 case IDCANCEL:
1052 case pshHelp:
1053 DeferWindowPos( hdwp, ctrl, NULL, rc.left + chgx, rc.top + chgy,
1054 0, 0,
1055 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
1056 break;
1057 default:
1058 DeferWindowPos( hdwp, ctrl, NULL, rc.left, rc.top + chgy,
1059 0, 0,
1060 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
1061 }
1062 }
1063 else if( rc.left > rcview.right)
1064 {
1065 /* if it was to the right of the shell view
1066 * move to right */
1067 DeferWindowPos( hdwp, ctrl, NULL, rc.left + chgx, rc.top,
1068 0, 0,
1069 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
1070 }
1071 else
1072 /* special cases */
1073 {
1074 switch( ctrlid)
1075 {
1076 #if 0 /* this is Win2k, Win XP. Vista and Higher don't move/size these controls */
1077 case IDC_LOOKIN:
1078 DeferWindowPos( hdwp, ctrl, NULL, 0, 0,
1079 rc.right - rc.left + chgx, rc.bottom - rc.top,
1080 SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
1081 break;
1082 case IDC_TOOLBARSTATIC:
1083 case IDC_TOOLBAR:
1084 DeferWindowPos( hdwp, ctrl, NULL, rc.left + chgx, rc.top,
1085 0, 0,
1086 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
1087 break;
1088 #endif
1089 /* not resized in windows. Since wine uses this invisible control
1090 * to size the browser view it needs to be resized */
1091 case IDC_SHELLSTATIC:
1092 DeferWindowPos( hdwp, ctrl, NULL, 0, 0,
1093 rc.right - rc.left + chgx,
1094 rc.bottom - rc.top + chgy,
1095 SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
1096 break;
1097 }
1098 }
1099 }
1100 if(fodInfos->DlgInfos.hwndCustomDlg &&
1101 (fodInfos->ofnInfos->Flags & (OFN_ENABLETEMPLATE | OFN_ENABLETEMPLATEHANDLE)))
1102 {
1103 for( ctrl = GetWindow( fodInfos->DlgInfos.hwndCustomDlg, GW_CHILD);
1104 ctrl ; ctrl = GetWindow( ctrl, GW_HWNDNEXT))
1105 {
1106 GetWindowRect( ctrl, &rc);
1107 MapWindowPoints( NULL, hwnd, (LPPOINT) &rc, 2);
1108 if( rc.top > rcview.bottom)
1109 {
1110 /* if it was below the shell view
1111 * move to bottom */
1112 DeferWindowPos( hdwp, ctrl, NULL, rc.left, rc.top + chgy,
1113 rc.right - rc.left, rc.bottom - rc.top,
1114 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
1115 }
1116 else if( rc.left > rcview.right)
1117 {
1118 /* if it was to the right of the shell view
1119 * move to right */
1120 DeferWindowPos( hdwp, ctrl, NULL, rc.left + chgx, rc.top,
1121 rc.right - rc.left, rc.bottom - rc.top,
1122 SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
1123 }
1124 }
1125 /* size the custom dialog at the end: some applications do some
1126 * control re-arranging at this point */
1127 GetClientRect(hwnd, &rc);
1128 DeferWindowPos( hdwp,fodInfos->DlgInfos.hwndCustomDlg, NULL,
1129 0, 0, rc.right, rc.bottom, SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
1130 }
1131 EndDeferWindowPos( hdwp);
1132 /* should not be needed */
1133 RedrawWindow( hwnd, NULL, 0, RDW_ALLCHILDREN | RDW_INVALIDATE );
1134 return TRUE;
1135 }
1136
1137 /***********************************************************************
1138 * FileOpenDlgProc95
1139 *
1140 * File open dialog procedure
1141 */
1142 INT_PTR CALLBACK FileOpenDlgProc95(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1143 {
1144 #if 0
1145 TRACE("%p 0x%04x\n", hwnd, uMsg);
1146 #endif
1147
1148 switch(uMsg)
1149 {
1150 case WM_INITDIALOG:
1151 {
1152 FileOpenDlgInfos * fodInfos = (FileOpenDlgInfos *)lParam;
1153 RECT rc, rcstc;
1154 int gripx = GetSystemMetrics( SM_CYHSCROLL);
1155 int gripy = GetSystemMetrics( SM_CYVSCROLL);
1156
1157 /* Adds the FileOpenDlgInfos in the property list of the dialog
1158 so it will be easily accessible through a GetPropA(...) */
1159 SetPropA(hwnd, FileOpenDlgInfosStr, fodInfos);
1160
1161 FILEDLG95_InitControls(hwnd);
1162
1163 if (fodInfos->ofnInfos->Flags & OFN_ENABLESIZING)
1164 {
1165 GetWindowRect( hwnd, &rc);
1166 fodInfos->DlgInfos.hwndGrip =
1167 CreateWindowExA( 0, "SCROLLBAR", NULL,
1168 WS_CHILD | WS_GROUP | WS_VISIBLE | WS_CLIPSIBLINGS |
1169 SBS_SIZEGRIP | SBS_SIZEBOXBOTTOMRIGHTALIGN,
1170 rc.right - gripx, rc.bottom - gripy,
1171 gripx, gripy, hwnd, (HMENU) -1, COMDLG32_hInstance, NULL);
1172 }
1173
1174 fodInfos->DlgInfos.hwndCustomDlg =
1175 CreateTemplateDialog((FileOpenDlgInfos *)lParam, hwnd);
1176
1177 FILEDLG95_ResizeControls(hwnd, wParam, lParam);
1178 FILEDLG95_FillControls(hwnd, wParam, lParam);
1179
1180 if( fodInfos->DlgInfos.hwndCustomDlg)
1181 ShowWindow( fodInfos->DlgInfos.hwndCustomDlg, SW_SHOW);
1182
1183 if(fodInfos->ofnInfos->Flags & OFN_EXPLORER) {
1184 SendCustomDlgNotificationMessage(hwnd,CDN_INITDONE);
1185 SendCustomDlgNotificationMessage(hwnd,CDN_FOLDERCHANGE);
1186 }
1187
1188 /* if the app has changed the position of the invisible listbox,
1189 * change that of the listview (browser) as well */
1190 GetWindowRect( fodInfos->ShellInfos.hwndView, &rc);
1191 GetWindowRect( GetDlgItem( hwnd, IDC_SHELLSTATIC ), &rcstc);
1192 if( !EqualRect( &rc, &rcstc))
1193 {
1194 MapWindowPoints( NULL, hwnd, (LPPOINT) &rcstc, 2);
1195 SetWindowPos( fodInfos->ShellInfos.hwndView, NULL,
1196 rcstc.left, rcstc.top, rcstc.right - rcstc.left, rcstc.bottom - rcstc.top,
1197 SWP_NOACTIVATE | SWP_NOZORDER);
1198 }
1199
1200 if (fodInfos->ofnInfos->Flags & OFN_ENABLESIZING)
1201 {
1202 GetWindowRect( hwnd, &rc);
1203 fodInfos->sizedlg.cx = rc.right - rc.left;
1204 fodInfos->sizedlg.cy = rc.bottom - rc.top;
1205 fodInfos->initial_size.x = fodInfos->sizedlg.cx;
1206 fodInfos->initial_size.y = fodInfos->sizedlg.cy;
1207 GetClientRect( hwnd, &rc);
1208 SetWindowPos( fodInfos->DlgInfos.hwndGrip, NULL,
1209 rc.right - gripx, rc.bottom - gripy,
1210 0, 0, SWP_NOSIZE | SWP_NOACTIVATE | SWP_NOZORDER);
1211 /* resize the dialog to the previous invocation */
1212 if( MemDialogSize.cx && MemDialogSize.cy)
1213 SetWindowPos( hwnd, NULL,
1214 0, 0, MemDialogSize.cx, MemDialogSize.cy,
1215 SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER);
1216 }
1217
1218 if(fodInfos->ofnInfos->Flags & OFN_EXPLORER)
1219 SendCustomDlgNotificationMessage(hwnd,CDN_SELCHANGE);
1220
1221 return 0;
1222 }
1223 case WM_SIZE:
1224 return FILEDLG95_OnWMSize(hwnd, wParam, lParam);
1225 case WM_GETMINMAXINFO:
1226 return FILEDLG95_OnWMGetMMI( hwnd, (LPMINMAXINFO)lParam);
1227 case WM_COMMAND:
1228 return FILEDLG95_OnWMCommand(hwnd, wParam, lParam);
1229 case WM_DRAWITEM:
1230 {
1231 switch(((LPDRAWITEMSTRUCT)lParam)->CtlID)
1232 {
1233 case IDC_LOOKIN:
1234 FILEDLG95_LOOKIN_DrawItem((LPDRAWITEMSTRUCT) lParam);
1235 return TRUE;
1236 }
1237 }
1238 return FALSE;
1239
1240 case WM_GETISHELLBROWSER:
1241 return FILEDLG95_OnWMGetIShellBrowser(hwnd);
1242
1243 case WM_DESTROY:
1244 {
1245 FileOpenDlgInfos * fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
1246 if (fodInfos && fodInfos->ofnInfos->Flags & OFN_ENABLESIZING)
1247 MemDialogSize = fodInfos->sizedlg;
1248 RemovePropA(hwnd, FileOpenDlgInfosStr);
1249 return FALSE;
1250 }
1251 case WM_NOTIFY:
1252 {
1253 LPNMHDR lpnmh = (LPNMHDR)lParam;
1254 UINT stringId = -1;
1255
1256 /* set up the button tooltips strings */
1257 if(TTN_GETDISPINFOA == lpnmh->code )
1258 {
1259 LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
1260 switch(lpnmh->idFrom )
1261 {
1262 /* Up folder button */
1263 case FCIDM_TB_UPFOLDER:
1264 stringId = IDS_UPFOLDER;
1265 break;
1266 /* New folder button */
1267 case FCIDM_TB_NEWFOLDER:
1268 stringId = IDS_NEWFOLDER;
1269 break;
1270 /* List option button */
1271 case FCIDM_TB_SMALLICON:
1272 stringId = IDS_LISTVIEW;
1273 break;
1274 /* Details option button */
1275 case FCIDM_TB_REPORTVIEW:
1276 stringId = IDS_REPORTVIEW;
1277 break;
1278 /* Desktop button */
1279 case FCIDM_TB_DESKTOP:
1280 stringId = IDS_TODESKTOP;
1281 break;
1282 default:
1283 stringId = 0;
1284 }
1285 lpdi->hinst = COMDLG32_hInstance;
1286 lpdi->lpszText = MAKEINTRESOURCEA(stringId);
1287 }
1288 return FALSE;
1289 }
1290 default :
1291 if(uMsg >= CDM_FIRST && uMsg <= CDM_LAST)
1292 return FILEDLG95_HandleCustomDialogMessages(hwnd, uMsg, wParam, lParam);
1293 return FALSE;
1294 }
1295 }
1296
1297 /***********************************************************************
1298 * FILEDLG95_InitControls
1299 *
1300 * WM_INITDIALOG message handler (before hook notification)
1301 */
1302 static LRESULT FILEDLG95_InitControls(HWND hwnd)
1303 {
1304 int win2000plus = 0;
1305 int win98plus = 0;
1306 int handledPath = FALSE;
1307 OSVERSIONINFOW osVi;
1308 static const WCHAR szwSlash[] = { '\\', 0 };
1309 static const WCHAR szwStar[] = { '*',0 };
1310
1311 static const TBBUTTON tbb[] =
1312 {
1313 {0, 0, TBSTATE_ENABLED, BTNS_SEP, {0, 0}, 0, 0 },
1314 {VIEW_PARENTFOLDER, FCIDM_TB_UPFOLDER, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0 },
1315 {0, 0, TBSTATE_ENABLED, BTNS_SEP, {0, 0}, 0, 0 },
1316 {VIEW_NEWFOLDER+1, FCIDM_TB_DESKTOP, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0 },
1317 {0, 0, TBSTATE_ENABLED, BTNS_SEP, {0, 0}, 0, 0 },
1318 {VIEW_NEWFOLDER, FCIDM_TB_NEWFOLDER, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0 },
1319 {0, 0, TBSTATE_ENABLED, BTNS_SEP, {0, 0}, 0, 0 },
1320 {VIEW_LIST, FCIDM_TB_SMALLICON, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0 },
1321 {VIEW_DETAILS, FCIDM_TB_REPORTVIEW, TBSTATE_ENABLED, BTNS_BUTTON, {0, 0}, 0, 0 },
1322 };
1323 TBADDBITMAP tba[2];
1324 RECT rectTB;
1325 RECT rectlook;
1326 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
1327
1328 tba[0].hInst = HINST_COMMCTRL;
1329 tba[0].nID = IDB_VIEW_SMALL_COLOR;
1330 tba[1].hInst = COMDLG32_hInstance;
1331 tba[1].nID = 800;
1332
1333 TRACE("%p\n", fodInfos);
1334
1335 /* Get windows version emulating */
1336 osVi.dwOSVersionInfoSize = sizeof(osVi);
1337 GetVersionExW(&osVi);
1338 if (osVi.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
1339 win98plus = ((osVi.dwMajorVersion > 4) || ((osVi.dwMajorVersion == 4) && (osVi.dwMinorVersion > 0)));
1340 } else if (osVi.dwPlatformId == VER_PLATFORM_WIN32_NT) {
1341 win2000plus = (osVi.dwMajorVersion > 4);
1342 if (win2000plus) win98plus = TRUE;
1343 }
1344 TRACE("Running on 2000+ %d, 98+ %d\n", win2000plus, win98plus);
1345
1346 /* Get the hwnd of the controls */
1347 fodInfos->DlgInfos.hwndFileName = GetDlgItem(hwnd,IDC_FILENAME);
1348 fodInfos->DlgInfos.hwndFileTypeCB = GetDlgItem(hwnd,IDC_FILETYPE);
1349 fodInfos->DlgInfos.hwndLookInCB = GetDlgItem(hwnd,IDC_LOOKIN);
1350
1351 GetWindowRect( fodInfos->DlgInfos.hwndLookInCB,&rectlook);
1352 MapWindowPoints( 0, hwnd,(LPPOINT)&rectlook,2);
1353
1354 /* construct the toolbar */
1355 GetWindowRect(GetDlgItem(hwnd,IDC_TOOLBARSTATIC),&rectTB);
1356 MapWindowPoints( 0, hwnd,(LPPOINT)&rectTB,2);
1357
1358 rectTB.right = rectlook.right + rectTB.right - rectTB.left;
1359 rectTB.bottom = rectlook.top - 1 + rectTB.bottom - rectTB.top;
1360 rectTB.left = rectlook.right;
1361 rectTB.top = rectlook.top-1;
1362
1363 if (fodInfos->unicode)
1364 fodInfos->DlgInfos.hwndTB = CreateWindowExW(0, TOOLBARCLASSNAMEW, NULL,
1365 WS_CHILD | WS_GROUP | WS_VISIBLE | WS_CLIPSIBLINGS | TBSTYLE_TOOLTIPS | CCS_NODIVIDER | CCS_NORESIZE,
1366 rectTB.left, rectTB.top,
1367 rectTB.right - rectTB.left, rectTB.bottom - rectTB.top,
1368 hwnd, (HMENU)IDC_TOOLBAR, COMDLG32_hInstance, NULL);
1369 else
1370 fodInfos->DlgInfos.hwndTB = CreateWindowExA(0, TOOLBARCLASSNAMEA, NULL,
1371 WS_CHILD | WS_GROUP | WS_VISIBLE | WS_CLIPSIBLINGS | TBSTYLE_TOOLTIPS | CCS_NODIVIDER | CCS_NORESIZE,
1372 rectTB.left, rectTB.top,
1373 rectTB.right - rectTB.left, rectTB.bottom - rectTB.top,
1374 hwnd, (HMENU)IDC_TOOLBAR, COMDLG32_hInstance, NULL);
1375
1376 SendMessageW(fodInfos->DlgInfos.hwndTB, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
1377
1378 /* FIXME: use TB_LOADIMAGES when implemented */
1379 /* SendMessageW(fodInfos->DlgInfos.hwndTB, TB_LOADIMAGES, IDB_VIEW_SMALL_COLOR, HINST_COMMCTRL);*/
1380 SendMessageW(fodInfos->DlgInfos.hwndTB, TB_SETMAXTEXTROWS, 0, 0);
1381 SendMessageW(fodInfos->DlgInfos.hwndTB, TB_ADDBITMAP, 12, (LPARAM) &tba[0]);
1382 SendMessageW(fodInfos->DlgInfos.hwndTB, TB_ADDBITMAP, 1, (LPARAM) &tba[1]);
1383
1384 SendMessageW(fodInfos->DlgInfos.hwndTB, TB_ADDBUTTONSW, 9, (LPARAM) tbb);
1385 SendMessageW(fodInfos->DlgInfos.hwndTB, TB_AUTOSIZE, 0, 0);
1386
1387 /* Set the window text with the text specified in the OPENFILENAME structure */
1388 if(fodInfos->title)
1389 {
1390 SetWindowTextW(hwnd,fodInfos->title);
1391 }
1392 else if (fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG)
1393 {
1394 WCHAR buf[16];
1395 LoadStringW(COMDLG32_hInstance, IDS_SAVE, buf, sizeof(buf)/sizeof(WCHAR));
1396 SetWindowTextW(hwnd, buf);
1397 }
1398
1399 /* Initialise the file name edit control */
1400 handledPath = FALSE;
1401 TRACE("Before manipilation, file = %s, dir = %s\n", debugstr_w(fodInfos->filename), debugstr_w(fodInfos->initdir));
1402
1403 if(fodInfos->filename)
1404 {
1405 /* 1. If win2000 or higher and filename contains a path, use it
1406 in preference over the lpstrInitialDir */
1407 if (win2000plus && *fodInfos->filename && strpbrkW(fodInfos->filename, szwSlash)) {
1408 WCHAR tmpBuf[MAX_PATH];
1409 WCHAR *nameBit;
1410 DWORD result;
1411
1412 result = GetFullPathNameW(fodInfos->filename, MAX_PATH, tmpBuf, &nameBit);
1413 if (result) {
1414
1415 /* nameBit is always shorter than the original filename */
1416 lstrcpyW(fodInfos->filename,nameBit);
1417
1418 *nameBit = 0x00;
1419 if (fodInfos->initdir == NULL)
1420 MemFree(fodInfos->initdir);
1421 fodInfos->initdir = MemAlloc((lstrlenW(tmpBuf) + 1)*sizeof(WCHAR));
1422 lstrcpyW(fodInfos->initdir, tmpBuf);
1423 handledPath = TRUE;
1424 TRACE("Value in Filename includes path, overriding InitialDir: %s, %s\n",
1425 debugstr_w(fodInfos->filename), debugstr_w(fodInfos->initdir));
1426 }
1427 SetDlgItemTextW(hwnd, IDC_FILENAME, fodInfos->filename);
1428
1429 } else {
1430 SetDlgItemTextW(hwnd, IDC_FILENAME, fodInfos->filename);
1431 }
1432 }
1433
1434 /* 2. (All platforms) If initdir is not null, then use it */
1435 if ((handledPath == FALSE) && (fodInfos->initdir!=NULL) &&
1436 (*fodInfos->initdir!=0x00))
1437 {
1438 /* Work out the proper path as supplied one might be relative */
1439 /* (Here because supplying '.' as dir browses to My Computer) */
1440 if (handledPath==FALSE) {
1441 WCHAR tmpBuf[MAX_PATH];
1442 WCHAR tmpBuf2[MAX_PATH];
1443 WCHAR *nameBit;
1444 DWORD result;
1445
1446 lstrcpyW(tmpBuf, fodInfos->initdir);
1447 if( PathFileExistsW(tmpBuf) ) {
1448 /* initdir does not have to be a directory. If a file is
1449 * specified, the dir part is taken */
1450 if( PathIsDirectoryW(tmpBuf)) {
1451 if (tmpBuf[lstrlenW(tmpBuf)-1] != '\\') {
1452 lstrcatW(tmpBuf, szwSlash);
1453 }
1454 lstrcatW(tmpBuf, szwStar);
1455 }
1456 result = GetFullPathNameW(tmpBuf, MAX_PATH, tmpBuf2, &nameBit);
1457 if (result) {
1458 *nameBit = 0x00;
1459 MemFree(fodInfos->initdir);
1460 fodInfos->initdir = MemAlloc((lstrlenW(tmpBuf2) + 1)*sizeof(WCHAR));
1461 lstrcpyW(fodInfos->initdir, tmpBuf2);
1462 handledPath = TRUE;
1463 TRACE("Value in InitDir changed to %s\n", debugstr_w(fodInfos->initdir));
1464 }
1465 }
1466 else if (fodInfos->initdir)
1467 {
1468 MemFree(fodInfos->initdir);
1469 fodInfos->initdir = NULL;
1470 TRACE("Value in InitDir is not an existing path, changed to (nil)\n");
1471 }
1472 }
1473 }
1474
1475 if ((handledPath == FALSE) && ((fodInfos->initdir==NULL) ||
1476 (*fodInfos->initdir==0x00)))
1477 {
1478 /* 3. All except w2k+: if filename contains a path use it */
1479 if (!win2000plus && fodInfos->filename &&
1480 *fodInfos->filename &&
1481 strpbrkW(fodInfos->filename, szwSlash)) {
1482 WCHAR tmpBuf[MAX_PATH];
1483 WCHAR *nameBit;
1484 DWORD result;
1485
1486 result = GetFullPathNameW(fodInfos->filename, MAX_PATH,
1487 tmpBuf, &nameBit);
1488 if (result) {
1489 int len;
1490
1491 /* nameBit is always shorter than the original filename */
1492 lstrcpyW(fodInfos->filename, nameBit);
1493 *nameBit = 0x00;
1494
1495 len = lstrlenW(tmpBuf);
1496 MemFree(fodInfos->initdir);
1497 fodInfos->initdir = MemAlloc((len+1)*sizeof(WCHAR));
1498 lstrcpyW(fodInfos->initdir, tmpBuf);
1499
1500 handledPath = TRUE;
1501 TRACE("Value in Filename includes path, overriding initdir: %s, %s\n",
1502 debugstr_w(fodInfos->filename), debugstr_w(fodInfos->initdir));
1503 }
1504 SetDlgItemTextW(hwnd, IDC_FILENAME, fodInfos->filename);
1505 }
1506
1507 /* 4. win98+ and win2000+ if any files of specified filter types in
1508 current directory, use it */
1509 if ( win98plus && handledPath == FALSE &&
1510 fodInfos->filter && *fodInfos->filter) {
1511
1512 BOOL searchMore = TRUE;
1513 LPCWSTR lpstrPos = fodInfos->filter;
1514 WIN32_FIND_DATAW FindFileData;
1515 HANDLE hFind;
1516
1517 while (searchMore)
1518 {
1519 /* filter is a list... title\0ext\0......\0\0 */
1520
1521 /* Skip the title */
1522 if(! *lpstrPos) break; /* end */
1523 lpstrPos += lstrlenW(lpstrPos) + 1;
1524
1525 /* See if any files exist in the current dir with this extension */
1526 if(! *lpstrPos) break; /* end */
1527
1528 hFind = FindFirstFileW(lpstrPos, &FindFileData);
1529
1530 if (hFind == INVALID_HANDLE_VALUE) {
1531 /* None found - continue search */
1532 lpstrPos += lstrlenW(lpstrPos) + 1;
1533
1534 } else {
1535 searchMore = FALSE;
1536
1537 MemFree(fodInfos->initdir);
1538 fodInfos->initdir = MemAlloc(MAX_PATH*sizeof(WCHAR));
1539 GetCurrentDirectoryW(MAX_PATH, fodInfos->initdir);
1540
1541 handledPath = TRUE;
1542 TRACE("No initial dir specified, but files of type %s found in current, so using it\n",
1543 debugstr_w(lpstrPos));
1544 break;
1545 }
1546 }
1547 }
1548
1549 /* 5. Win2000+: FIXME: Next, Recently used? Not sure how windows does this */
1550
1551 /* 6. Win98+ and 2000+: Use personal files dir, others use current dir */
1552 if (handledPath == FALSE && (win2000plus || win98plus)) {
1553 fodInfos->initdir = MemAlloc(MAX_PATH*sizeof(WCHAR));
1554
1555 if(!COMDLG32_SHGetFolderPathW(hwnd, CSIDL_PERSONAL, 0, 0, fodInfos->initdir))
1556 {
1557 if(!COMDLG32_SHGetFolderPathW(hwnd, CSIDL_DESKTOPDIRECTORY|CSIDL_FLAG_CREATE, 0, 0, fodInfos->initdir))
1558 {
1559 /* last fallback */
1560 GetCurrentDirectoryW(MAX_PATH, fodInfos->initdir);
1561 TRACE("No personal or desktop dir, using cwd as failsafe: %s\n", debugstr_w(fodInfos->initdir));
1562 } else {
1563 TRACE("No personal dir, using desktop instead: %s\n", debugstr_w(fodInfos->initdir));
1564 }
1565 } else {
1566 TRACE("No initial dir specified, using personal files dir of %s\n", debugstr_w(fodInfos->initdir));
1567 }
1568 handledPath = TRUE;
1569 } else if (handledPath==FALSE) {
1570 fodInfos->initdir = MemAlloc(MAX_PATH*sizeof(WCHAR));
1571 GetCurrentDirectoryW(MAX_PATH, fodInfos->initdir);
1572 handledPath = TRUE;
1573 TRACE("No initial dir specified, using current dir of %s\n", debugstr_w(fodInfos->initdir));
1574 }
1575 }
1576 SetFocus(GetDlgItem(hwnd, IDC_FILENAME));
1577 TRACE("After manipulation, file = %s, dir = %s\n", debugstr_w(fodInfos->filename), debugstr_w(fodInfos->initdir));
1578
1579 /* Must the open as read only check box be checked ?*/
1580 if(fodInfos->ofnInfos->Flags & OFN_READONLY)
1581 {
1582 SendDlgItemMessageW(hwnd,IDC_OPENREADONLY,BM_SETCHECK,TRUE,0);
1583 }
1584
1585 /* Must the open as read only check box be hidden? */
1586 if(fodInfos->ofnInfos->Flags & OFN_HIDEREADONLY)
1587 {
1588 ShowWindow(GetDlgItem(hwnd,IDC_OPENREADONLY),SW_HIDE);
1589 EnableWindow(GetDlgItem(hwnd, IDC_OPENREADONLY), FALSE);
1590 }
1591
1592 /* Must the help button be hidden? */
1593 if (!(fodInfos->ofnInfos->Flags & OFN_SHOWHELP))
1594 {
1595 ShowWindow(GetDlgItem(hwnd, pshHelp), SW_HIDE);
1596 EnableWindow(GetDlgItem(hwnd, pshHelp), FALSE);
1597 }
1598
1599 /* change Open to Save */
1600 if (fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG)
1601 {
1602 WCHAR buf[16];
1603 LoadStringW(COMDLG32_hInstance, IDS_SAVE_BUTTON, buf, sizeof(buf)/sizeof(WCHAR));
1604 SetDlgItemTextW(hwnd, IDOK, buf);
1605 LoadStringW(COMDLG32_hInstance, IDS_SAVE_IN, buf, sizeof(buf)/sizeof(WCHAR));
1606 SetDlgItemTextW(hwnd, IDC_LOOKINSTATIC, buf);
1607 }
1608
1609 /* Initialize the filter combo box */
1610 FILEDLG95_FILETYPE_Init(hwnd);
1611
1612 return 0;
1613 }
1614
1615 /***********************************************************************
1616 * FILEDLG95_ResizeControls
1617 *
1618 * WM_INITDIALOG message handler (after hook notification)
1619 */
1620 static LRESULT FILEDLG95_ResizeControls(HWND hwnd, WPARAM wParam, LPARAM lParam)
1621 {
1622 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) lParam;
1623
1624 if (fodInfos->DlgInfos.hwndCustomDlg)
1625 {
1626 RECT rc;
1627 UINT flags = SWP_NOACTIVATE;
1628
1629 ArrangeCtrlPositions(fodInfos->DlgInfos.hwndCustomDlg, hwnd,
1630 (fodInfos->ofnInfos->Flags & (OFN_HIDEREADONLY | OFN_SHOWHELP)) == OFN_HIDEREADONLY);
1631
1632 /* resize the custom dialog to the parent size */
1633 if (fodInfos->ofnInfos->Flags & (OFN_ENABLETEMPLATE | OFN_ENABLETEMPLATEHANDLE))
1634 GetClientRect(hwnd, &rc);
1635 else
1636 {
1637 /* our own fake template is zero sized and doesn't have children, so
1638 * there is no need to resize it. Picasa depends on it.
1639 */
1640 flags |= SWP_NOSIZE;
1641 SetRectEmpty(&rc);
1642 }
1643 SetWindowPos(fodInfos->DlgInfos.hwndCustomDlg, HWND_BOTTOM,
1644 0, 0, rc.right, rc.bottom, flags);
1645 }
1646 else
1647 {
1648 /* Resize the height, if open as read only checkbox ad help button are
1649 * hidden and we are not using a custom template nor a customDialog
1650 */
1651 if ( (fodInfos->ofnInfos->Flags & OFN_HIDEREADONLY) &&
1652 (!(fodInfos->ofnInfos->Flags &
1653 (OFN_SHOWHELP|OFN_ENABLETEMPLATE|OFN_ENABLETEMPLATEHANDLE))))
1654 {
1655 RECT rectDlg, rectHelp, rectCancel;
1656 GetWindowRect(hwnd, &rectDlg);
1657 GetWindowRect(GetDlgItem(hwnd, pshHelp), &rectHelp);
1658 GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rectCancel);
1659 /* subtract the height of the help button plus the space between the help
1660 * button and the cancel button to the height of the dialog
1661 */
1662 SetWindowPos(hwnd, 0, 0, 0, rectDlg.right-rectDlg.left,
1663 (rectDlg.bottom-rectDlg.top) - (rectHelp.bottom - rectCancel.bottom),
1664 SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER);
1665 }
1666 }
1667 return TRUE;
1668 }
1669
1670 /***********************************************************************
1671 * FILEDLG95_FillControls
1672 *
1673 * WM_INITDIALOG message handler (after hook notification)
1674 */
1675 static LRESULT FILEDLG95_FillControls(HWND hwnd, WPARAM wParam, LPARAM lParam)
1676 {
1677 LPITEMIDLIST pidlItemId = NULL;
1678
1679 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) lParam;
1680
1681 TRACE("dir=%s file=%s\n",
1682 debugstr_w(fodInfos->initdir), debugstr_w(fodInfos->filename));
1683
1684 /* Get the initial directory pidl */
1685
1686 if(!(pidlItemId = GetPidlFromName(fodInfos->Shell.FOIShellFolder,fodInfos->initdir)))
1687 {
1688 WCHAR path[MAX_PATH];
1689
1690 GetCurrentDirectoryW(MAX_PATH,path);
1691 pidlItemId = GetPidlFromName(fodInfos->Shell.FOIShellFolder, path);
1692 }
1693
1694 /* Initialise shell objects */
1695 FILEDLG95_SHELL_Init(hwnd);
1696
1697 /* Initialize the Look In combo box */
1698 FILEDLG95_LOOKIN_Init(fodInfos->DlgInfos.hwndLookInCB);
1699
1700 /* Browse to the initial directory */
1701 IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,pidlItemId, SBSP_ABSOLUTE);
1702
1703 /* Free pidlItem memory */
1704 COMDLG32_SHFree(pidlItemId);
1705
1706 return TRUE;
1707 }
1708 /***********************************************************************
1709 * FILEDLG95_Clean
1710 *
1711 * Regroups all the cleaning functions of the filedlg
1712 */
1713 void FILEDLG95_Clean(HWND hwnd)
1714 {
1715 FILEDLG95_FILETYPE_Clean(hwnd);
1716 FILEDLG95_LOOKIN_Clean(hwnd);
1717 FILEDLG95_SHELL_Clean(hwnd);
1718 }
1719 /***********************************************************************
1720 * FILEDLG95_OnWMCommand
1721 *
1722 * WM_COMMAND message handler
1723 */
1724 static LRESULT FILEDLG95_OnWMCommand(HWND hwnd, WPARAM wParam, LPARAM lParam)
1725 {
1726 WORD wNotifyCode = HIWORD(wParam); /* notification code */
1727 WORD wID = LOWORD(wParam); /* item, control, or accelerator identifier */
1728 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
1729
1730 switch(wID)
1731 {
1732 /* OK button */
1733 case IDOK:
1734 FILEDLG95_OnOpen(hwnd);
1735 break;
1736 /* Cancel button */
1737 case IDCANCEL:
1738 FILEDLG95_Clean(hwnd);
1739 EndDialog(hwnd, FALSE);
1740 break;
1741 /* Filetype combo box */
1742 case IDC_FILETYPE:
1743 FILEDLG95_FILETYPE_OnCommand(hwnd,wNotifyCode);
1744 break;
1745 /* LookIn combo box */
1746 case IDC_LOOKIN:
1747 FILEDLG95_LOOKIN_OnCommand(hwnd,wNotifyCode);
1748 break;
1749
1750 /* --- toolbar --- */
1751 /* Up folder button */
1752 case FCIDM_TB_UPFOLDER:
1753 FILEDLG95_SHELL_UpFolder(hwnd);
1754 break;
1755 /* New folder button */
1756 case FCIDM_TB_NEWFOLDER:
1757 FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_NEWFOLDERA);
1758 break;
1759 /* List option button */
1760 case FCIDM_TB_SMALLICON:
1761 FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_VIEWLISTA);
1762 break;
1763 /* Details option button */
1764 case FCIDM_TB_REPORTVIEW:
1765 FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_VIEWDETAILSA);
1766 break;
1767 /* Details option button */
1768 case FCIDM_TB_DESKTOP:
1769 FILEDLG95_SHELL_BrowseToDesktop(hwnd);
1770 break;
1771
1772 case IDC_FILENAME:
1773 break;
1774
1775 }
1776 /* Do not use the listview selection anymore */
1777 fodInfos->DlgInfos.dwDlgProp &= ~FODPROP_USEVIEW;
1778 return 0;
1779 }
1780
1781 /***********************************************************************
1782 * FILEDLG95_OnWMGetIShellBrowser
1783 *
1784 * WM_GETISHELLBROWSER message handler
1785 */
1786 static LRESULT FILEDLG95_OnWMGetIShellBrowser(HWND hwnd)
1787 {
1788 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
1789
1790 TRACE("\n");
1791
1792 SetWindowLongPtrW(hwnd,DWLP_MSGRESULT,(LONG_PTR)fodInfos->Shell.FOIShellBrowser);
1793
1794 return TRUE;
1795 }
1796
1797
1798 /***********************************************************************
1799 * FILEDLG95_SendFileOK
1800 *
1801 * Sends the CDN_FILEOK notification if required
1802 *
1803 * RETURNS
1804 * TRUE if the dialog should close
1805 * FALSE if the dialog should not be closed
1806 */
1807 static BOOL FILEDLG95_SendFileOK( HWND hwnd, FileOpenDlgInfos *fodInfos )
1808 {
1809 /* ask the hook if we can close */
1810 if(IsHooked(fodInfos))
1811 {
1812 LRESULT retval = 0;
1813
1814 TRACE("---\n");
1815 /* First send CDN_FILEOK as MSDN doc says */
1816 if(fodInfos->ofnInfos->Flags & OFN_EXPLORER)
1817 retval = SendCustomDlgNotificationMessage(hwnd,CDN_FILEOK);
1818 if( retval)
1819 {
1820 TRACE("canceled\n");
1821 return FALSE;
1822 }
1823
1824 /* fodInfos->ofnInfos points to an ASCII or UNICODE structure as appropriate */
1825 retval = SendMessageW(fodInfos->DlgInfos.hwndCustomDlg,
1826 fodInfos->HookMsg.fileokstring, 0, (LPARAM)fodInfos->ofnInfos);
1827 if( retval)
1828 {
1829 TRACE("canceled\n");
1830 return FALSE;
1831 }
1832 }
1833 return TRUE;
1834 }
1835
1836 /***********************************************************************
1837 * FILEDLG95_OnOpenMultipleFiles
1838 *
1839 * Handles the opening of multiple files.
1840 *
1841 * FIXME
1842 * check destination buffer size
1843 */
1844 BOOL FILEDLG95_OnOpenMultipleFiles(HWND hwnd, LPWSTR lpstrFileList, UINT nFileCount, UINT sizeUsed)
1845 {
1846 WCHAR lpstrPathSpec[MAX_PATH] = {0};
1847 UINT nCount, nSizePath;
1848 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
1849
1850 TRACE("\n");
1851
1852 if(fodInfos->unicode)
1853 {
1854 LPOPENFILENAMEW ofn = fodInfos->ofnInfos;
1855 ofn->lpstrFile[0] = '\0';
1856 }
1857 else
1858 {
1859 LPOPENFILENAMEA ofn = (LPOPENFILENAMEA) fodInfos->ofnInfos;
1860 ofn->lpstrFile[0] = '\0';
1861 }
1862
1863 COMDLG32_GetDisplayNameOf( fodInfos->ShellInfos.pidlAbsCurrent, lpstrPathSpec );
1864
1865 if ( !(fodInfos->ofnInfos->Flags & OFN_NOVALIDATE) &&
1866 ( fodInfos->ofnInfos->Flags & OFN_FILEMUSTEXIST) &&
1867 ! ( fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG ) )
1868 {
1869 LPWSTR lpstrTemp = lpstrFileList;
1870
1871 for ( nCount = 0; nCount < nFileCount; nCount++ )
1872 {
1873 LPITEMIDLIST pidl;
1874
1875 pidl = GetPidlFromName(fodInfos->Shell.FOIShellFolder, lpstrTemp);
1876 if (!pidl)
1877 {
1878 WCHAR lpstrNotFound[100];
1879 WCHAR lpstrMsg[100];
1880 WCHAR tmp[400];
1881 static const WCHAR nl[] = {'\n',0};
1882
1883 LoadStringW(COMDLG32_hInstance, IDS_FILENOTFOUND, lpstrNotFound, 100);
1884 LoadStringW(COMDLG32_hInstance, IDS_VERIFYFILE, lpstrMsg, 100);
1885
1886 lstrcpyW(tmp, lpstrTemp);
1887 lstrcatW(tmp, nl);
1888 lstrcatW(tmp, lpstrNotFound);
1889 lstrcatW(tmp, nl);
1890 lstrcatW(tmp, lpstrMsg);
1891
1892 MessageBoxW(hwnd, tmp, fodInfos->title, MB_OK | MB_ICONEXCLAMATION);
1893 return FALSE;
1894 }
1895
1896 /* move to the next file in the list of files */
1897 lpstrTemp += lstrlenW(lpstrTemp) + 1;
1898 COMDLG32_SHFree(pidl);
1899 }
1900 }
1901
1902 nSizePath = lstrlenW(lpstrPathSpec) + 1;
1903 if ( !(fodInfos->ofnInfos->Flags & OFN_EXPLORER) )
1904 {
1905 /* For "oldstyle" dialog the components have to
1906 be separated by blanks (not '\0'!) and short
1907 filenames have to be used! */
1908 FIXME("Components have to be separated by blanks\n");
1909 }
1910 if(fodInfos->unicode)
1911 {
1912 LPOPENFILENAMEW ofn = fodInfos->ofnInfos;
1913 lstrcpyW( ofn->lpstrFile, lpstrPathSpec);
1914 memcpy( ofn->lpstrFile + nSizePath, lpstrFileList, sizeUsed*sizeof(WCHAR) );
1915 }
1916 else
1917 {
1918 LPOPENFILENAMEA ofn = (LPOPENFILENAMEA)fodInfos->ofnInfos;
1919
1920 if (ofn->lpstrFile != NULL)
1921 {
1922 nSizePath = WideCharToMultiByte(CP_ACP, 0, lpstrPathSpec, -1,
1923 ofn->lpstrFile, ofn->nMaxFile, NULL, NULL);
1924 if (ofn->nMaxFile > nSizePath)
1925 {
1926 WideCharToMultiByte(CP_ACP, 0, lpstrFileList, sizeUsed,
1927 ofn->lpstrFile + nSizePath,
1928 ofn->nMaxFile - nSizePath, NULL, NULL);
1929 }
1930 }
1931 }
1932
1933 fodInfos->ofnInfos->nFileOffset = nSizePath;
1934 fodInfos->ofnInfos->nFileExtension = 0;
1935
1936 if ( !FILEDLG95_SendFileOK(hwnd, fodInfos) )
1937 return FALSE;
1938
1939 /* clean and exit */
1940 FILEDLG95_Clean(hwnd);
1941 return EndDialog(hwnd,TRUE);
1942 }
1943
1944 /***********************************************************************
1945 * FILEDLG95_OnOpen
1946 *
1947 * Ok button WM_COMMAND message handler
1948 *
1949 * If the function succeeds, the return value is nonzero.
1950 */
1951 #define ONOPEN_BROWSE 1
1952 #define ONOPEN_OPEN 2
1953 #define ONOPEN_SEARCH 3
1954 static void FILEDLG95_OnOpenMessage(HWND hwnd, int idCaption, int idText)
1955 {
1956 WCHAR strMsgTitle[MAX_PATH];
1957 WCHAR strMsgText [MAX_PATH];
1958 if (idCaption)
1959 LoadStringW(COMDLG32_hInstance, idCaption, strMsgTitle, sizeof(strMsgTitle)/sizeof(WCHAR));
1960 else
1961 strMsgTitle[0] = '\0';
1962 LoadStringW(COMDLG32_hInstance, idText, strMsgText, sizeof(strMsgText)/sizeof(WCHAR));
1963 MessageBoxW(hwnd,strMsgText, strMsgTitle, MB_OK | MB_ICONHAND);
1964 }
1965
1966 BOOL FILEDLG95_OnOpen(HWND hwnd)
1967 {
1968 LPWSTR lpstrFileList;
1969 UINT nFileCount = 0;
1970 UINT sizeUsed = 0;
1971 BOOL ret = TRUE;
1972 WCHAR lpstrPathAndFile[MAX_PATH];
1973 WCHAR lpstrTemp[MAX_PATH];
1974 LPSHELLFOLDER lpsf = NULL;
1975 int nOpenAction;
1976 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
1977
1978 TRACE("hwnd=%p\n", hwnd);
1979
1980 /* get the files from the edit control */
1981 nFileCount = FILEDLG95_FILENAME_GetFileNames(hwnd, &lpstrFileList, &sizeUsed);
1982
1983 /* try if the user selected a folder in the shellview */
1984 if(nFileCount == 0)
1985 {
1986 BrowseSelectedFolder(hwnd);
1987 return FALSE;
1988 }
1989
1990 if(nFileCount > 1)
1991 {
1992 ret = FILEDLG95_OnOpenMultipleFiles(hwnd, lpstrFileList, nFileCount, sizeUsed);
1993 goto ret;
1994 }
1995
1996 TRACE("count=%u len=%u file=%s\n", nFileCount, sizeUsed, debugstr_w(lpstrFileList));
1997
1998 /*
1999 Step 1: Build a complete path name from the current folder and
2000 the filename or path in the edit box.
2001 Special cases:
2002 - the path in the edit box is a root path
2003 (with or without drive letter)
2004 - the edit box contains ".." (or a path with ".." in it)
2005 */
2006
2007 /* Get the current directory name */
2008 if (!COMDLG32_GetDisplayNameOf(fodInfos->ShellInfos.pidlAbsCurrent, lpstrPathAndFile))
2009 {
2010 /* last fallback */
2011 GetCurrentDirectoryW(MAX_PATH, lpstrPathAndFile);
2012 }
2013 PathAddBackslashW(lpstrPathAndFile);
2014
2015 TRACE("current directory=%s\n", debugstr_w(lpstrPathAndFile));
2016
2017 /* if the user specified a fully qualified path use it */
2018 if(PathIsRelativeW(lpstrFileList))
2019 {
2020 lstrcatW(lpstrPathAndFile, lpstrFileList);
2021 }
2022 else
2023 {
2024 /* does the path have a drive letter? */
2025 if (PathGetDriveNumberW(lpstrFileList) == -1)
2026 lstrcpyW(lpstrPathAndFile+2, lpstrFileList);
2027 else
2028 lstrcpyW(lpstrPathAndFile, lpstrFileList);
2029 }
2030
2031 /* resolve "." and ".." */
2032 PathCanonicalizeW(lpstrTemp, lpstrPathAndFile );
2033 lstrcpyW(lpstrPathAndFile, lpstrTemp);
2034 TRACE("canon=%s\n", debugstr_w(lpstrPathAndFile));
2035
2036 MemFree(lpstrFileList);
2037
2038 /*
2039 Step 2: here we have a cleaned up path
2040
2041 We have to parse the path step by step to see if we have to browse
2042 to a folder if the path points to a directory or the last
2043 valid element is a directory.
2044
2045 valid variables:
2046 lpstrPathAndFile: cleaned up path
2047 */
2048
2049 if (nFileCount &&
2050 (fodInfos->ofnInfos->Flags & OFN_NOVALIDATE) &&
2051 !(fodInfos->ofnInfos->Flags & OFN_FILEMUSTEXIST))
2052 nOpenAction = ONOPEN_OPEN;
2053 else
2054 nOpenAction = ONOPEN_BROWSE;
2055
2056 /* don't apply any checks with OFN_NOVALIDATE */
2057 {
2058 LPWSTR lpszTemp, lpszTemp1;
2059 LPITEMIDLIST pidl = NULL;
2060 static const WCHAR szwInvalid[] = { '/',':','<','>','|', 0};
2061
2062 /* check for invalid chars */
2063 if((strpbrkW(lpstrPathAndFile+3, szwInvalid) != NULL) && !(fodInfos->ofnInfos->Flags & OFN_NOVALIDATE))
2064 {
2065 FILEDLG95_OnOpenMessage(hwnd, IDS_INVALID_FILENAME_TITLE, IDS_INVALID_FILENAME);
2066 ret = FALSE;
2067 goto ret;
2068 }
2069
2070 if (FAILED (SHGetDesktopFolder(&lpsf))) return FALSE;
2071
2072 lpszTemp1 = lpszTemp = lpstrPathAndFile;
2073 while (lpszTemp1)
2074 {
2075 LPSHELLFOLDER lpsfChild;
2076 WCHAR lpwstrTemp[MAX_PATH];
2077 DWORD dwEaten, dwAttributes;
2078 LPWSTR p;
2079
2080 lstrcpyW(lpwstrTemp, lpszTemp);
2081 p = PathFindNextComponentW(lpwstrTemp);
2082
2083 if (!p) break; /* end of path */
2084
2085 *p = 0;
2086 lpszTemp = lpszTemp + lstrlenW(lpwstrTemp);
2087
2088 /* There are no wildcards when OFN_NOVALIDATE is set */
2089 if(*lpszTemp==0 && !(fodInfos->ofnInfos->Flags & OFN_NOVALIDATE))
2090 {
2091 static const WCHAR wszWild[] = { '*', '?', 0 };
2092 /* if the last element is a wildcard do a search */
2093 if(strpbrkW(lpszTemp1, wszWild) != NULL)
2094 {
2095 nOpenAction = ONOPEN_SEARCH;
2096 break;
2097 }
2098 }
2099 lpszTemp1 = lpszTemp;
2100
2101 TRACE("parse now=%s next=%s sf=%p\n",debugstr_w(lpwstrTemp), debugstr_w(lpszTemp), lpsf);
2102
2103 /* append a backslash to drive letters */
2104 if(lstrlenW(lpwstrTemp)==2 && lpwstrTemp[1] == ':' &&
2105 ((lpwstrTemp[0] >= 'a' && lpwstrTemp[0] <= 'z') ||
2106 (lpwstrTemp[0] >= 'A' && lpwstrTemp[0] <= 'Z')))
2107 {
2108 PathAddBackslashW(lpwstrTemp);
2109 }
2110
2111 dwAttributes = SFGAO_FOLDER;
2112 if(SUCCEEDED(IShellFolder_ParseDisplayName(lpsf, hwnd, NULL, lpwstrTemp, &dwEaten, &pidl, &dwAttributes)))
2113 {
2114 /* the path component is valid, we have a pidl of the next path component */
2115 TRACE("parse OK attr=0x%08x pidl=%p\n", dwAttributes, pidl);
2116 if(dwAttributes & SFGAO_FOLDER)
2117 {
2118 if(FAILED(IShellFolder_BindToObject(lpsf, pidl, 0, &IID_IShellFolder, (LPVOID*)&lpsfChild)))
2119 {
2120 ERR("bind to failed\n"); /* should not fail */
2121 break;
2122 }
2123 IShellFolder_Release(lpsf);
2124 lpsf = lpsfChild;
2125 lpsfChild = NULL;
2126 }
2127 else
2128 {
2129 TRACE("value\n");
2130
2131 /* end dialog, return value */
2132 nOpenAction = ONOPEN_OPEN;
2133 break;
2134 }
2135 COMDLG32_SHFree(pidl);
2136 pidl = NULL;
2137 }
2138 else if (!(fodInfos->ofnInfos->Flags & OFN_NOVALIDATE))
2139 {
2140 if(*lpszTemp || /* points to trailing null for last path element */
2141 (lpwstrTemp[strlenW(lpwstrTemp)-1] == '\\')) /* or if last element ends in '\' */
2142 {
2143 if(fodInfos->ofnInfos->Flags & OFN_PATHMUSTEXIST)
2144 {
2145 FILEDLG95_OnOpenMessage(hwnd, 0, IDS_PATHNOTEXISTING);
2146 break;
2147 }
2148 }
2149 else
2150 {
2151 if( (fodInfos->ofnInfos->Flags & OFN_FILEMUSTEXIST) &&
2152 !( fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG ) )
2153 {
2154 FILEDLG95_OnOpenMessage(hwnd, 0, IDS_FILENOTEXISTING);
2155 break;
2156 }
2157 }
2158 /* change to the current folder */
2159 nOpenAction = ONOPEN_OPEN;
2160 break;
2161 }
2162 else
2163 {
2164 nOpenAction = ONOPEN_OPEN;
2165 break;
2166 }
2167 }
2168 if(pidl) COMDLG32_SHFree(pidl);
2169 }
2170
2171 /*
2172 Step 3: here we have a cleaned up and validated path
2173
2174 valid variables:
2175 lpsf: ShellFolder bound to the rightmost valid path component
2176 lpstrPathAndFile: cleaned up path
2177 nOpenAction: action to do
2178 */
2179 TRACE("end validate sf=%p\n", lpsf);
2180
2181 switch(nOpenAction)
2182 {
2183 case ONOPEN_SEARCH: /* set the current filter to the file mask and refresh */
2184 TRACE("ONOPEN_SEARCH %s\n", debugstr_w(lpstrPathAndFile));
2185 {
2186 int iPos;
2187 LPWSTR lpszTemp = PathFindFileNameW(lpstrPathAndFile);
2188 DWORD len;
2189
2190 /* replace the current filter */
2191 MemFree(fodInfos->ShellInfos.lpstrCurrentFilter);
2192 len = lstrlenW(lpszTemp)+1;
2193 fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc(len * sizeof(WCHAR));
2194 lstrcpyW( fodInfos->ShellInfos.lpstrCurrentFilter, lpszTemp);
2195
2196 /* set the filter cb to the extension when possible */
2197 if(-1 < (iPos = FILEDLG95_FILETYPE_SearchExt(fodInfos->DlgInfos.hwndFileTypeCB, lpszTemp)))
2198 CBSetCurSel(fodInfos->DlgInfos.hwndFileTypeCB, iPos);
2199 }
2200 /* fall through */
2201 case ONOPEN_BROWSE: /* browse to the highest folder we could bind to */
2202 TRACE("ONOPEN_BROWSE\n");
2203 {
2204 IPersistFolder2 * ppf2;
2205 if(SUCCEEDED(IShellFolder_QueryInterface( lpsf, &IID_IPersistFolder2, (LPVOID*)&ppf2)))
2206 {
2207 LPITEMIDLIST pidlCurrent;
2208 IPersistFolder2_GetCurFolder(ppf2, &pidlCurrent);
2209 IPersistFolder2_Release(ppf2);
2210 if( ! COMDLG32_PIDL_ILIsEqual(pidlCurrent, fodInfos->ShellInfos.pidlAbsCurrent))
2211 {
2212 if (SUCCEEDED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser, pidlCurrent, SBSP_ABSOLUTE))
2213 && fodInfos->ofnInfos->Flags & OFN_EXPLORER)
2214 {
2215 SendCustomDlgNotificationMessage(hwnd, CDN_FOLDERCHANGE);
2216 }
2217 }
2218 else if( nOpenAction == ONOPEN_SEARCH )
2219 {
2220 if (fodInfos->Shell.FOIShellView)
2221 IShellView_Refresh(fodInfos->Shell.FOIShellView);
2222 }
2223 COMDLG32_SHFree(pidlCurrent);
2224 SendMessageW(fodInfos->DlgInfos.hwndFileName, EM_SETSEL, 0, -1);
2225 }
2226 }
2227 ret = FALSE;
2228 break;
2229 case ONOPEN_OPEN: /* fill in the return struct and close the dialog */
2230 TRACE("ONOPEN_OPEN %s\n", debugstr_w(lpstrPathAndFile));
2231 {
2232 WCHAR *ext = NULL;
2233
2234 /* update READONLY check box flag */
2235 if ((SendMessageW(GetDlgItem(hwnd,IDC_OPENREADONLY),BM_GETCHECK,0,0) & 0x03) == BST_CHECKED)
2236 fodInfos->ofnInfos->Flags |= OFN_READONLY;
2237 else
2238 fodInfos->ofnInfos->Flags &= ~OFN_READONLY;
2239
2240 /* Attach the file extension with file name*/
2241 ext = PathFindExtensionW(lpstrPathAndFile);
2242 if (! *ext)
2243 {
2244 /* if no extension is specified with file name, then */
2245 /* attach the extension from file filter or default one */
2246
2247 WCHAR *filterExt = NULL;
2248 LPWSTR lpstrFilter = NULL;
2249 static const WCHAR szwDot[] = {'.',0};
2250 int PathLength = lstrlenW(lpstrPathAndFile);
2251
2252 /* Attach the dot*/
2253 lstrcatW(lpstrPathAndFile, szwDot);
2254
2255 /*Get the file extension from file type filter*/
2256 lpstrFilter = (LPWSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,
2257 fodInfos->ofnInfos->nFilterIndex-1);
2258
2259 if (lpstrFilter != (LPWSTR)CB_ERR) /* control is not empty */
2260 filterExt = PathFindExtensionW(lpstrFilter);
2261
2262 if ( filterExt && *filterExt ) /* attach the file extension from file type filter*/
2263 lstrcatW(lpstrPathAndFile, filterExt + 1);
2264 else if ( fodInfos->defext ) /* attach the default file extension*/
2265 lstrcatW(lpstrPathAndFile, fodInfos->defext);
2266
2267 /* In Open dialog: if file does not exist try without extension */
2268 if (!(fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG) && !PathFileExistsW(lpstrPathAndFile))
2269 lpstrPathAndFile[PathLength] = '\0';
2270 }
2271
2272 if (fodInfos->defext) /* add default extension */
2273 {
2274 /* Set/clear the output OFN_EXTENSIONDIFFERENT flag */
2275 if (*ext)
2276 ext++;
2277 if (!lstrcmpiW(fodInfos->defext, ext))
2278 fodInfos->ofnInfos->Flags &= ~OFN_EXTENSIONDIFFERENT;
2279 else
2280 fodInfos->ofnInfos->Flags |= OFN_EXTENSIONDIFFERENT;
2281 }
2282
2283 /* In Save dialog: check if the file already exists */
2284 if (fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG
2285 && fodInfos->ofnInfos->Flags & OFN_OVERWRITEPROMPT
2286 && PathFileExistsW(lpstrPathAndFile))
2287 {
2288 WCHAR lpstrOverwrite[100];
2289 int answer;
2290
2291 LoadStringW(COMDLG32_hInstance, IDS_OVERWRITEFILE, lpstrOverwrite, 100);
2292 answer = MessageBoxW(hwnd, lpstrOverwrite, fodInfos->title,
2293 MB_YESNO | MB_ICONEXCLAMATION);
2294 if (answer == IDNO)
2295 {
2296 ret = FALSE;
2297 goto ret;
2298 }
2299 }
2300
2301 /* In Open dialog: check if it should be created if it doesn't exist */
2302 if (!(fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG)
2303 && fodInfos->ofnInfos->Flags & OFN_CREATEPROMPT
2304 && !PathFileExistsW(lpstrPathAndFile))
2305 {
2306 WCHAR lpstrCreate[100];
2307 int answer;
2308
2309 LoadStringW(COMDLG32_hInstance, IDS_CREATEFILE, lpstrCreate, 100);
2310 answer = MessageBoxW(hwnd, lpstrCreate, fodInfos->title,
2311 MB_YESNO | MB_ICONEXCLAMATION);
2312 if (answer == IDNO)
2313 {
2314 ret = FALSE;
2315 goto ret;
2316 }
2317 }
2318
2319 /* Check that the size of the file does not exceed buffer size.
2320 (Allow for extra \0 if OFN_MULTISELECT is set.) */
2321 if(lstrlenW(lpstrPathAndFile) < fodInfos->ofnInfos->nMaxFile -
2322 ((fodInfos->ofnInfos->Flags & OFN_ALLOWMULTISELECT) ? 1 : 0))
2323 {
2324
2325 /* fill destination buffer */
2326 if (fodInfos->ofnInfos->lpstrFile)
2327 {
2328 if(fodInfos->unicode)
2329 {
2330 LPOPENFILENAMEW ofn = fodInfos->ofnInfos;
2331
2332 lstrcpynW(ofn->lpstrFile, lpstrPathAndFile, ofn->nMaxFile);
2333 if (ofn->Flags & OFN_ALLOWMULTISELECT)
2334 ofn->lpstrFile[lstrlenW(ofn->lpstrFile) + 1] = '\0';
2335 }
2336 else
2337 {
2338 LPOPENFILENAMEA ofn = (LPOPENFILENAMEA)fodInfos->ofnInfos;
2339
2340 WideCharToMultiByte(CP_ACP, 0, lpstrPathAndFile, -1,
2341 ofn->lpstrFile, ofn->nMaxFile, NULL, NULL);
2342 if (ofn->Flags & OFN_ALLOWMULTISELECT)
2343 ofn->lpstrFile[lstrlenA(ofn->lpstrFile) + 1] = '\0';
2344 }
2345 }
2346
2347 if(fodInfos->unicode)
2348 {
2349 LPWSTR lpszTemp;
2350
2351 /* set filename offset */
2352 lpszTemp = PathFindFileNameW(lpstrPathAndFile);
2353 fodInfos->ofnInfos->nFileOffset = (lpszTemp - lpstrPathAndFile);
2354
2355 /* set extension offset */
2356 lpszTemp = PathFindExtensionW(lpstrPathAndFile);
2357 fodInfos->ofnInfos->nFileExtension = (*lpszTemp) ? (lpszTemp - lpstrPathAndFile) + 1 : 0;
2358 }
2359 else
2360 {
2361 LPSTR lpszTemp;
2362 LPOPENFILENAMEA ofn = (LPOPENFILENAMEA)fodInfos->ofnInfos;
2363
2364 /* set filename offset */
2365 lpszTemp = PathFindFileNameA(ofn->lpstrFile);
2366 fodInfos->ofnInfos->nFileOffset = (lpszTemp - ofn->lpstrFile);
2367
2368 /* set extension offset */
2369 lpszTemp = PathFindExtensionA(ofn->lpstrFile);
2370 fodInfos->ofnInfos->nFileExtension = (*lpszTemp) ? (lpszTemp - ofn->lpstrFile) + 1 : 0;
2371 }
2372
2373 /* set the lpstrFileTitle */
2374 if(fodInfos->ofnInfos->lpstrFileTitle)
2375 {
2376 LPWSTR lpstrFileTitle = PathFindFileNameW(lpstrPathAndFile);
2377 if(fodInfos->unicode)
2378 {
2379 LPOPENFILENAMEW ofn = fodInfos->ofnInfos;
2380 lstrcpynW(ofn->lpstrFileTitle, lpstrFileTitle, ofn->nMaxFileTitle);
2381 }
2382 else
2383 {
2384 LPOPENFILENAMEA ofn = (LPOPENFILENAMEA)fodInfos->ofnInfos;
2385 WideCharToMultiByte(CP_ACP, 0, lpstrFileTitle, -1,
2386 ofn->lpstrFileTitle, ofn->nMaxFileTitle, NULL, NULL);
2387 }
2388 }
2389
2390 /* copy currently selected filter to lpstrCustomFilter */
2391 if (fodInfos->ofnInfos->lpstrCustomFilter)
2392 {
2393 LPOPENFILENAMEA ofn = (LPOPENFILENAMEA)fodInfos->ofnInfos;
2394 int len = WideCharToMultiByte(CP_ACP, 0, fodInfos->ShellInfos.lpstrCurrentFilter, -1,
2395 NULL, 0, NULL, NULL);
2396 if (len + strlen(ofn->lpstrCustomFilter) + 1 <= ofn->nMaxCustFilter)
2397 {
2398 LPSTR s = ofn->lpstrCustomFilter;
2399 s += strlen(ofn->lpstrCustomFilter)+1;
2400 WideCharToMultiByte(CP_ACP, 0, fodInfos->ShellInfos.lpstrCurrentFilter, -1,
2401 s, len, NULL, NULL);
2402 }
2403 }
2404
2405
2406 if ( !FILEDLG95_SendFileOK(hwnd, fodInfos) )
2407 goto ret;
2408
2409 TRACE("close\n");
2410 FILEDLG95_Clean(hwnd);
2411 ret = EndDialog(hwnd, TRUE);
2412 }
2413 else
2414 {
2415 WORD size;
2416
2417 size = lstrlenW(lpstrPathAndFile) + 1;
2418 if (fodInfos->ofnInfos->Flags & OFN_ALLOWMULTISELECT)
2419 size += 1;
2420 /* return needed size in first two bytes of lpstrFile */
2421 *(WORD *)fodInfos->ofnInfos->lpstrFile = size;
2422 FILEDLG95_Clean(hwnd);
2423 ret = EndDialog(hwnd, FALSE);
2424 COMDLG32_SetCommDlgExtendedError(FNERR_BUFFERTOOSMALL);
2425 }
2426 }
2427 break;
2428 }
2429
2430 ret:
2431 if(lpsf) IShellFolder_Release(lpsf);
2432 return ret;
2433 }
2434
2435 /***********************************************************************
2436 * FILEDLG95_SHELL_Init
2437 *
2438 * Initialisation of the shell objects
2439 */
2440 static LRESULT FILEDLG95_SHELL_Init(HWND hwnd)
2441 {
2442 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
2443
2444 TRACE("\n");
2445
2446 /*
2447 * Initialisation of the FileOpenDialogInfos structure
2448 */
2449
2450 /* Shell */
2451
2452 /*ShellInfos */
2453 fodInfos->ShellInfos.hwndOwner = hwnd;
2454
2455 /* Disable multi-select if flag not set */
2456 if (!(fodInfos->ofnInfos->Flags & OFN_ALLOWMULTISELECT))
2457 {
2458 fodInfos->ShellInfos.folderSettings.fFlags |= FWF_SINGLESEL;
2459 }
2460 fodInfos->ShellInfos.folderSettings.fFlags |= FWF_AUTOARRANGE | FWF_ALIGNLEFT;
2461 fodInfos->ShellInfos.folderSettings.ViewMode = FVM_LIST;
2462
2463 /* Construct the IShellBrowser interface */
2464 fodInfos->Shell.FOIShellBrowser = IShellBrowserImpl_Construct(hwnd);
2465
2466 return NOERROR;
2467 }
2468
2469 /***********************************************************************
2470 * FILEDLG95_SHELL_ExecuteCommand
2471 *
2472 * Change the folder option and refresh the view
2473 * If the function succeeds, the return value is nonzero.
2474 */
2475 static BOOL FILEDLG95_SHELL_ExecuteCommand(HWND hwnd, LPCSTR lpVerb)
2476 {
2477 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
2478 IContextMenu * pcm;
2479
2480 TRACE("(%p,%p)\n", hwnd, lpVerb);
2481
2482 if(SUCCEEDED(IShellView_GetItemObject(fodInfos->Shell.FOIShellView,
2483 SVGIO_BACKGROUND,
2484 &IID_IContextMenu,
2485 (LPVOID*)&pcm)))
2486 {
2487 CMINVOKECOMMANDINFO ci;
2488 ZeroMemory(&ci, sizeof(CMINVOKECOMMANDINFO));
2489 ci.cbSize = sizeof(CMINVOKECOMMANDINFO);
2490 ci.lpVerb = lpVerb;
2491 ci.hwnd = hwnd;
2492
2493 IContextMenu_InvokeCommand(pcm, &ci);
2494 IContextMenu_Release(pcm);
2495 }
2496
2497 return FALSE;
2498 }
2499
2500 /***********************************************************************
2501 * FILEDLG95_SHELL_UpFolder
2502 *
2503 * Browse to the specified object
2504 * If the function succeeds, the return value is nonzero.
2505 */
2506 static BOOL FILEDLG95_SHELL_UpFolder(HWND hwnd)
2507 {
2508 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
2509
2510 TRACE("\n");
2511
2512 if(SUCCEEDED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
2513 NULL,
2514 SBSP_PARENT)))
2515 {
2516 if(fodInfos->ofnInfos->Flags & OFN_EXPLORER)
2517 SendCustomDlgNotificationMessage(hwnd, CDN_FOLDERCHANGE);
2518 return TRUE;
2519 }
2520 return FALSE;
2521 }
2522
2523 /***********************************************************************
2524 * FILEDLG95_SHELL_BrowseToDesktop
2525 *
2526 * Browse to the Desktop
2527 * If the function succeeds, the return value is nonzero.
2528 */
2529 static BOOL FILEDLG95_SHELL_BrowseToDesktop(HWND hwnd)
2530 {
2531 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
2532 LPITEMIDLIST pidl;
2533 HRESULT hres;
2534
2535 TRACE("\n");
2536
2537 SHGetSpecialFolderLocation(0,CSIDL_DESKTOP,&pidl);
2538 hres = IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser, pidl, SBSP_ABSOLUTE);
2539 if(fodInfos->ofnInfos->Flags & OFN_EXPLORER)
2540 SendCustomDlgNotificationMessage(hwnd, CDN_FOLDERCHANGE);
2541 COMDLG32_SHFree(pidl);
2542 return SUCCEEDED(hres);
2543 }
2544 /***********************************************************************
2545 * FILEDLG95_SHELL_Clean
2546 *
2547 * Cleans the memory used by shell objects
2548 */
2549 static void FILEDLG95_SHELL_Clean(HWND hwnd)
2550 {
2551 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
2552
2553 TRACE("\n");
2554
2555 COMDLG32_SHFree(fodInfos->ShellInfos.pidlAbsCurrent);
2556
2557 /* clean Shell interfaces */
2558 if (fodInfos->Shell.FOIShellView)
2559 {
2560 IShellView_DestroyViewWindow(fodInfos->Shell.FOIShellView);
2561 IShellView_Release(fodInfos->Shell.FOIShellView);
2562 }
2563 IShellFolder_Release(fodInfos->Shell.FOIShellFolder);
2564 IShellBrowser_Release(fodInfos->Shell.FOIShellBrowser);
2565 if (fodInfos->Shell.FOIDataObject)
2566 IDataObject_Release(fodInfos->Shell.FOIDataObject);
2567 }
2568
2569 /***********************************************************************
2570 * FILEDLG95_FILETYPE_Init
2571 *
2572 * Initialisation of the file type combo box
2573 */
2574 static HRESULT FILEDLG95_FILETYPE_Init(HWND hwnd)
2575 {
2576 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
2577 int nFilters = 0; /* number of filters */
2578 int nFilterIndexCB;
2579
2580 TRACE("\n");
2581
2582 if(fodInfos->customfilter)
2583 {
2584 /* customfilter has one entry... title\0ext\0
2585 * Set first entry of combo box item with customfilter
2586 */
2587 LPWSTR lpstrExt;
2588 LPCWSTR lpstrPos = fodInfos->customfilter;
2589
2590 /* Get the title */
2591 lpstrPos += lstrlenW(fodInfos->customfilter) + 1;
2592
2593 /* Copy the extensions */
2594 if (! *lpstrPos) return E_FAIL; /* malformed filter */
2595 if (!(lpstrExt = MemAlloc((lstrlenW(lpstrPos)+1)*sizeof(WCHAR)))) return E_FAIL;
2596 lstrcpyW(lpstrExt,lpstrPos);
2597
2598 /* Add the item at the end of the combo */
2599 CBAddString(fodInfos->DlgInfos.hwndFileTypeCB, fodInfos->customfilter);
2600 CBSetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB, nFilters, lpstrExt);
2601 nFilters++;
2602 }
2603 if(fodInfos->filter)
2604 {
2605 LPCWSTR lpstrPos = fodInfos->filter;
2606
2607 for(;;)
2608 {
2609 /* filter is a list... title\0ext\0......\0\0
2610 * Set the combo item text to the title and the item data
2611 * to the ext
2612 */
2613 LPCWSTR lpstrDisplay;
2614 LPWSTR lpstrExt;
2615
2616 /* Get the title */
2617 if(! *lpstrPos) break; /* end */
2618 lpstrDisplay = lpstrPos;
2619 lpstrPos += lstrlenW(lpstrPos) + 1;
2620
2621 CBAddString(fodInfos->DlgInfos.hwndFileTypeCB, lpstrDisplay);
2622
2623 nFilters++;
2624
2625 /* Copy the extensions */
2626 if (!(lpstrExt = MemAlloc((lstrlenW(lpstrPos)+1)*sizeof(WCHAR)))) return E_FAIL;
2627 lstrcpyW(lpstrExt,lpstrPos);
2628 lpstrPos += lstrlenW(lpstrPos) + 1;
2629
2630 /* Add the item at the end of the combo */
2631 CBSetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB, nFilters-1, lpstrExt);
2632
2633 /* malformed filters are added anyway... */
2634 if (!*lpstrExt) break;
2635 }
2636 }
2637
2638 /*
2639 * Set the current filter to the one specified
2640 * in the initialisation structure
2641 */
2642 if (fodInfos->filter || fodInfos->customfilter)
2643 {
2644 LPWSTR lpstrFilter;
2645
2646 /* Check to make sure our index isn't out of bounds. */
2647 if ( fodInfos->ofnInfos->nFilterIndex >
2648 nFilters - (fodInfos->customfilter == NULL ? 0 : 1) )
2649 fodInfos->ofnInfos->nFilterIndex = (fodInfos->customfilter == NULL ? 1 : 0);
2650
2651 /* set default filter index */
2652 if(fodInfos->ofnInfos->nFilterIndex == 0 && fodInfos->customfilter == NULL)
2653 fodInfos->ofnInfos->nFilterIndex = 1;
2654
2655 /* calculate index of Combo Box item */
2656 nFilterIndexCB = fodInfos->ofnInfos->nFilterIndex;
2657 if (fodInfos->customfilter == NULL)
2658 nFilterIndexCB--;
2659
2660 /* Set the current index selection. */
2661 CBSetCurSel(fodInfos->DlgInfos.hwndFileTypeCB, nFilterIndexCB);
2662
2663 /* Get the corresponding text string from the combo box. */
2664 lpstrFilter = (LPWSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,
2665 nFilterIndexCB);
2666
2667 if ((INT_PTR)lpstrFilter == CB_ERR) /* control is empty */
2668 lpstrFilter = NULL;
2669
2670 if(lpstrFilter)
2671 {
2672 DWORD len;
2673 CharLowerW(lpstrFilter); /* lowercase */
2674 len = lstrlenW(lpstrFilter)+1;
2675 fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc( len * sizeof(WCHAR) );
2676 lstrcpyW(fodInfos->ShellInfos.lpstrCurrentFilter,lpstrFilter);
2677 }
2678 } else
2679 fodInfos->ofnInfos->nFilterIndex = 0;
2680 return S_OK;
2681 }
2682
2683 /***********************************************************************
2684 * FILEDLG95_FILETYPE_OnCommand
2685 *
2686 * WM_COMMAND of the file type combo box
2687 * If the function succeeds, the return value is nonzero.
2688 */
2689 static BOOL FILEDLG95_FILETYPE_OnCommand(HWND hwnd, WORD wNotifyCode)
2690 {
2691 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
2692
2693 switch(wNotifyCode)
2694 {
2695 case CBN_SELENDOK:
2696 {
2697 LPWSTR lpstrFilter;
2698
2699 /* Get the current item of the filetype combo box */
2700 int iItem = CBGetCurSel(fodInfos->DlgInfos.hwndFileTypeCB);
2701
2702 /* set the current filter index */
2703 fodInfos->ofnInfos->nFilterIndex = iItem +
2704 (fodInfos->customfilter == NULL ? 1 : 0);
2705
2706 /* Set the current filter with the current selection */
2707 MemFree(fodInfos->ShellInfos.lpstrCurrentFilter);
2708
2709 lpstrFilter = (LPWSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,
2710 iItem);
2711 if((INT_PTR)lpstrFilter != CB_ERR)
2712 {
2713 DWORD len;
2714 CharLowerW(lpstrFilter); /* lowercase */
2715 len = lstrlenW(lpstrFilter)+1;
2716 fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc( len * sizeof(WCHAR) );
2717 lstrcpyW(fodInfos->ShellInfos.lpstrCurrentFilter,lpstrFilter);
2718 if(fodInfos->ofnInfos->Flags & OFN_EXPLORER)
2719 SendCustomDlgNotificationMessage(hwnd,CDN_TYPECHANGE);
2720 }
2721
2722 /* Refresh the actual view to display the included items*/
2723 if (fodInfos->Shell.FOIShellView)
2724 IShellView_Refresh(fodInfos->Shell.FOIShellView);
2725 }
2726 }
2727 return FALSE;
2728 }
2729 /***********************************************************************
2730 * FILEDLG95_FILETYPE_SearchExt
2731 *
2732 * searches for an extension in the filetype box
2733 */
2734 static int FILEDLG95_FILETYPE_SearchExt(HWND hwnd,LPCWSTR lpstrExt)
2735 {
2736 int i, iCount = CBGetCount(hwnd);
2737
2738 TRACE("%s\n", debugstr_w(lpstrExt));
2739
2740 if(iCount != CB_ERR)
2741 {
2742 for(i=0;i<iCount;i++)
2743 {
2744 if(!lstrcmpiW(lpstrExt,(LPWSTR)CBGetItemDataPtr(hwnd,i)))
2745 return i;
2746 }
2747 }
2748 return -1;
2749 }
2750
2751 /***********************************************************************
2752 * FILEDLG95_FILETYPE_Clean
2753 *
2754 * Clean the memory used by the filetype combo box
2755 */
2756 static void FILEDLG95_FILETYPE_Clean(HWND hwnd)
2757 {
2758 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
2759 int iPos;
2760 int iCount = CBGetCount(fodInfos->DlgInfos.hwndFileTypeCB);
2761
2762 TRACE("\n");
2763
2764 /* Delete each string of the combo and their associated data */
2765 if(iCount != CB_ERR)
2766 {
2767 for(iPos = iCount-1;iPos>=0;iPos--)
2768 {
2769 MemFree((LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,iPos));
2770 CBDeleteString(fodInfos->DlgInfos.hwndFileTypeCB,iPos);
2771 }
2772 }
2773 /* Current filter */
2774 MemFree(fodInfos->ShellInfos.lpstrCurrentFilter);
2775
2776 }
2777
2778 /***********************************************************************
2779 * FILEDLG95_LOOKIN_Init
2780 *
2781 * Initialisation of the look in combo box
2782 */
2783
2784 /* Small helper function, to determine if the unixfs shell extension is rooted
2785 * at the desktop. Copied from dlls/shell32/shfldr_unixfs.c.
2786 */
2787 static inline BOOL FILEDLG95_unixfs_is_rooted_at_desktop(void) {
2788 HKEY hKey;
2789 static const WCHAR wszRootedAtDesktop[] = { 'S','o','f','t','w','a','r','e','\\',
2790 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
2791 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
2792 'E','x','p','l','o','r','e','r','\\','D','e','s','k','t','o','p','\\',
2793 'N','a','m','e','S','p','a','c','e','\\','{','9','D','2','0','A','A','E','8',
2794 '-','0','6','2','5','-','4','4','B','0','-','9','C','A','7','-',
2795 '7','1','8','8','9','C','2','2','5','4','D','9','}',0 };
2796
2797 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, wszRootedAtDesktop, 0, KEY_READ, &hKey) != ERROR_SUCCESS)
2798 return FALSE;
2799
2800 RegCloseKey(hKey);
2801 return TRUE;
2802 }
2803
2804 static void FILEDLG95_LOOKIN_Init(HWND hwndCombo)
2805 {
2806 IShellFolder *psfRoot, *psfDrives;
2807 IEnumIDList *lpeRoot, *lpeDrives;
2808 LPITEMIDLIST pidlDrives, pidlTmp, pidlTmp1, pidlAbsTmp;
2809
2810 LookInInfos *liInfos = MemAlloc(sizeof(LookInInfos));
2811
2812 TRACE("\n");
2813
2814 liInfos->iMaxIndentation = 0;
2815
2816 SetPropA(hwndCombo, LookInInfosStr, liInfos);
2817
2818 /* set item height for both text field and listbox */
2819 CBSetItemHeight(hwndCombo,-1,GetSystemMetrics(SM_CYSMICON));
2820 CBSetItemHeight(hwndCombo,0,GetSystemMetrics(SM_CYSMICON));
2821
2822 /* Turn on the extended UI for the combo box like Windows does */
2823 CBSetExtendedUI(hwndCombo, TRUE);
2824
2825 /* Initialise data of Desktop folder */
2826 SHGetSpecialFolderLocation(0,CSIDL_DESKTOP,&pidlTmp);
2827 FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlTmp,LISTEND);
2828 COMDLG32_SHFree(pidlTmp);
2829
2830 SHGetSpecialFolderLocation(0,CSIDL_DRIVES,&pidlDrives);
2831
2832 SHGetDesktopFolder(&psfRoot);
2833
2834 if (psfRoot)
2835 {
2836 /* enumerate the contents of the desktop */
2837 if(SUCCEEDED(IShellFolder_EnumObjects(psfRoot, hwndCombo, SHCONTF_FOLDERS, &lpeRoot)))
2838 {
2839 while (S_OK == IEnumIDList_Next(lpeRoot, 1, &pidlTmp, NULL))
2840 {
2841 FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlTmp,LISTEND);
2842
2843 /* If the unixfs extension is rooted, we don't expand the drives by default */
2844 if (!FILEDLG95_unixfs_is_rooted_at_desktop())
2845 {
2846 /* special handling for CSIDL_DRIVES */
2847 if (COMDLG32_PIDL_ILIsEqual(pidlTmp, pidlDrives))
2848 {
2849 if(SUCCEEDED(IShellFolder_BindToObject(psfRoot, pidlTmp, NULL, &IID_IShellFolder, (LPVOID*)&psfDrives)))
2850 {
2851 /* enumerate the drives */
2852 if(SUCCEEDED(IShellFolder_EnumObjects(psfDrives, hwndCombo,SHCONTF_FOLDERS, &lpeDrives)))
2853 {
2854 while (S_OK == IEnumIDList_Next(lpeDrives, 1, &pidlTmp1, NULL))
2855 {
2856 pidlAbsTmp = COMDLG32_PIDL_ILCombine(pidlTmp, pidlTmp1);
2857 FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlAbsTmp,LISTEND);
2858 COMDLG32_SHFree(pidlAbsTmp);
2859 COMDLG32_SHFree(pidlTmp1);
2860 }
2861 IEnumIDList_Release(lpeDrives);
2862 }
2863 IShellFolder_Release(psfDrives);
2864 }
2865 }
2866 }
2867
2868 COMDLG32_SHFree(pidlTmp);
2869 }
2870 IEnumIDList_Release(lpeRoot);
2871 }
2872 IShellFolder_Release(psfRoot);
2873 }
2874
2875 COMDLG32_SHFree(pidlDrives);
2876 }
2877
2878 /***********************************************************************
2879 * FILEDLG95_LOOKIN_DrawItem
2880 *
2881 * WM_DRAWITEM message handler
2882 */
2883 static LRESULT FILEDLG95_LOOKIN_DrawItem(LPDRAWITEMSTRUCT pDIStruct)
2884 {
2885 COLORREF crWin = GetSysColor(COLOR_WINDOW);
2886 COLORREF crHighLight = GetSysColor(COLOR_HIGHLIGHT);
2887 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
2888 RECT rectText;
2889 RECT rectIcon;
2890 SHFILEINFOW sfi;
2891 HIMAGELIST ilItemImage;
2892 int iIndentation;
2893 TEXTMETRICW tm;
2894 LPSFOLDER tmpFolder;
2895 LookInInfos *liInfos = GetPropA(pDIStruct->hwndItem,LookInInfosStr);
2896
2897 TRACE("\n");
2898
2899 if(pDIStruct->itemID == -1)
2900 return 0;
2901
2902 if(!(tmpFolder = (LPSFOLDER) CBGetItemDataPtr(pDIStruct->hwndItem,
2903 pDIStruct->itemID)))
2904 return 0;
2905
2906
2907 if(pDIStruct->itemID == liInfos->uSelectedItem)
2908 {
2909 ilItemImage = (HIMAGELIST) SHGetFileInfoW ((LPCWSTR) tmpFolder->pidlItem,
2910 0,
2911 &sfi,
2912 sizeof (sfi),
2913 SHGFI_PIDL | SHGFI_SMALLICON |
2914 SHGFI_OPENICON | SHGFI_SYSICONINDEX |
2915 SHGFI_DISPLAYNAME );
2916 }
2917 else
2918 {
2919 ilItemImage = (HIMAGELIST) SHGetFileInfoW ((LPCWSTR) tmpFolder->pidlItem,
2920 0,
2921 &sfi,
2922 sizeof (sfi),
2923 SHGFI_PIDL | SHGFI_SMALLICON |
2924 SHGFI_SYSICONINDEX |
2925 SHGFI_DISPLAYNAME);
2926 }
2927
2928 /* Is this item selected ? */
2929 if(pDIStruct->itemState & ODS_SELECTED)
2930 {
2931 SetTextColor(pDIStruct->hDC,(0x00FFFFFF & ~(crText)));
2932 SetBkColor(pDIStruct->hDC,crHighLight);
2933 FillRect(pDIStruct->hDC,&pDIStruct->rcItem,GetSysColorBrush(COLOR_HIGHLIGHT));
2934 }
2935 else
2936 {
2937 SetTextColor(pDIStruct->hDC,crText);
2938 SetBkColor(pDIStruct->hDC,crWin);
2939 FillRect(pDIStruct->hDC,&pDIStruct->rcItem,GetSysColorBrush(COLOR_WINDOW));
2940 }
2941
2942 /* Do not indent item if drawing in the edit of the combo */
2943 if(pDIStruct->itemState & ODS_COMBOBOXEDIT)
2944 {
2945 iIndentation = 0;
2946 ilItemImage = (HIMAGELIST) SHGetFileInfoW ((LPCWSTR) tmpFolder->pidlItem,
2947 0,
2948 &sfi,
2949 sizeof (sfi),
2950 SHGFI_PIDL | SHGFI_SMALLICON | SHGFI_OPENICON
2951 | SHGFI_SYSICONINDEX | SHGFI_DISPLAYNAME );
2952
2953 }
2954 else
2955 {
2956 iIndentation = tmpFolder->m_iIndent;
2957 }
2958 /* Draw text and icon */
2959
2960 /* Initialise the icon display area */
2961 rectIcon.left = pDIStruct->rcItem.left + ICONWIDTH/2 * iIndentation;
2962 rectIcon.top = pDIStruct->rcItem.top;
2963 rectIcon.right = rectIcon.left + ICONWIDTH;
2964 rectIcon.bottom = pDIStruct->rcItem.bottom;
2965
2966 /* Initialise the text display area */
2967 GetTextMetricsW(pDIStruct->hDC, &tm);
2968 rectText.left = rectIcon.right;
2969 rectText.top =
2970 (pDIStruct->rcItem.top + pDIStruct->rcItem.bottom - tm.tmHeight) / 2;
2971 rectText.right = pDIStruct->rcItem.right + XTEXTOFFSET;
2972 rectText.bottom =
2973 (pDIStruct->rcItem.top + pDIStruct->rcItem.bottom + tm.tmHeight) / 2;
2974
2975 /* Draw the icon from the image list */
2976 ImageList_Draw(ilItemImage,
2977 sfi.iIcon,
2978 pDIStruct->hDC,
2979 rectIcon.left,
2980 rectIcon.top,
2981 ILD_TRANSPARENT );
2982
2983 /* Draw the associated text */
2984 if(sfi.szDisplayName)
2985 TextOutW(pDIStruct->hDC,rectText.left,rectText.top,sfi.szDisplayName,lstrlenW(sfi.szDisplayName));
2986
2987
2988 return NOERROR;
2989 }
2990
2991 /***********************************************************************
2992 * FILEDLG95_LOOKIN_OnCommand
2993 *
2994 * LookIn combo box WM_COMMAND message handler
2995 * If the function succeeds, the return value is nonzero.
2996 */
2997 static BOOL FILEDLG95_LOOKIN_OnCommand(HWND hwnd, WORD wNotifyCode)
2998 {
2999 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
3000
3001 TRACE("%p\n", fodInfos);
3002
3003 switch(wNotifyCode)
3004 {
3005 case CBN_SELENDOK:
3006 {
3007 LPSFOLDER tmpFolder;
3008 int iItem;
3009
3010 iItem = CBGetCurSel(fodInfos->DlgInfos.hwndLookInCB);
3011
3012 if( iItem == CB_ERR) return FALSE;
3013
3014 if(!(tmpFolder = (LPSFOLDER) CBGetItemDataPtr(fodInfos->DlgInfos.hwndLookInCB,
3015 iItem)))
3016 return FALSE;
3017
3018
3019 if(SUCCEEDED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
3020 tmpFolder->pidlItem,
3021 SBSP_ABSOLUTE)))
3022 {
3023 if(fodInfos->ofnInfos->Flags & OFN_EXPLORER)
3024 SendCustomDlgNotificationMessage(hwnd, CDN_FOLDERCHANGE);
3025 return TRUE;
3026 }
3027 break;
3028 }
3029
3030 }
3031 return FALSE;
3032 }
3033
3034 /***********************************************************************
3035 * FILEDLG95_LOOKIN_AddItem
3036 *
3037 * Adds an absolute pidl item to the lookin combo box
3038 * returns the index of the inserted item
3039 */
3040 static int FILEDLG95_LOOKIN_AddItem(HWND hwnd,LPITEMIDLIST pidl, int iInsertId)
3041 {
3042 LPITEMIDLIST pidlNext;
3043 SHFILEINFOW sfi;
3044 SFOLDER *tmpFolder;
3045 LookInInfos *liInfos;
3046
3047 TRACE("%08x\n", iInsertId);
3048
3049 if(!pidl)
3050 return -1;
3051
3052 if(!(liInfos = GetPropA(hwnd,LookInInfosStr)))
3053 return -1;
3054
3055 tmpFolder = MemAlloc(sizeof(SFOLDER));
3056 tmpFolder->m_iIndent = 0;
3057
3058 /* Calculate the indentation of the item in the lookin*/
3059 pidlNext = pidl;
3060 while( (pidlNext=COMDLG32_PIDL_ILGetNext(pidlNext)) )
3061 {
3062 tmpFolder->m_iIndent++;
3063 }
3064
3065 tmpFolder->pidlItem = COMDLG32_PIDL_ILClone(pidl);
3066
3067 if(tmpFolder->m_iIndent > liInfos->iMaxIndentation)
3068 liInfos->iMaxIndentation = tmpFolder->m_iIndent;
3069
3070 sfi.dwAttributes = SFGAO_FILESYSANCESTOR | SFGAO_FILESYSTEM;
3071 SHGetFileInfoW((LPCWSTR)pidl,
3072 0,
3073 &sfi,
3074 sizeof(sfi),
3075 SHGFI_DISPLAYNAME | SHGFI_SYSICONINDEX
3076 | SHGFI_PIDL | SHGFI_SMALLICON | SHGFI_ATTRIBUTES | SHGFI_ATTR_SPECIFIED);
3077
3078 TRACE("-- Add %s attr=%08x\n", debugstr_w(sfi.szDisplayName), sfi.dwAttributes);
3079
3080 if((sfi.dwAttributes & SFGAO_FILESYSANCESTOR) || (sfi.dwAttributes & SFGAO_FILESYSTEM))
3081 {
3082 int iItemID;
3083
3084 TRACE("-- Add %s at %u\n", debugstr_w(sfi.szDisplayName), tmpFolder->m_iIndent);
3085
3086 /* Add the item at the end of the list */
3087 if(iInsertId < 0)
3088 {
3089 iItemID = CBAddString(hwnd,sfi.szDisplayName);
3090 }
3091 /* Insert the item at the iInsertId position*/
3092 else
3093 {
3094 iItemID = CBInsertString(hwnd,sfi.szDisplayName,iInsertId);
3095 }
3096
3097 CBSetItemDataPtr(hwnd,iItemID,tmpFolder);
3098 return iItemID;
3099 }
3100
3101 COMDLG32_SHFree( tmpFolder->pidlItem );
3102 MemFree( tmpFolder );
3103 return -1;
3104
3105 }
3106
3107 /***********************************************************************
3108 * FILEDLG95_LOOKIN_InsertItemAfterParent
3109 *
3110 * Insert an item below its parent
3111 */
3112 static int FILEDLG95_LOOKIN_InsertItemAfterParent(HWND hwnd,LPITEMIDLIST pidl)
3113 {
3114
3115 LPITEMIDLIST pidlParent = GetParentPidl(pidl);
3116 int iParentPos;
3117
3118 TRACE("\n");
3119
3120 iParentPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)pidlParent,SEARCH_PIDL);
3121
3122 if(iParentPos < 0)
3123 {
3124 iParentPos = FILEDLG95_LOOKIN_InsertItemAfterParent(hwnd,pidlParent);
3125 }
3126
3127 /* Free pidlParent memory */
3128 COMDLG32_SHFree(pidlParent);
3129
3130 return FILEDLG95_LOOKIN_AddItem(hwnd,pidl,iParentPos + 1);
3131 }
3132
3133 /***********************************************************************
3134 * FILEDLG95_LOOKIN_SelectItem
3135 *
3136 * Adds an absolute pidl item to the lookin combo box
3137 * returns the index of the inserted item
3138 */
3139 int FILEDLG95_LOOKIN_SelectItem(HWND hwnd,LPITEMIDLIST pidl)
3140 {
3141 int iItemPos;
3142 LookInInfos *liInfos;
3143
3144 TRACE("\n");
3145
3146 iItemPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)pidl,SEARCH_PIDL);
3147
3148 liInfos = GetPropA(hwnd,LookInInfosStr);
3149
3150 if(iItemPos < 0)
3151 {
3152 while(FILEDLG95_LOOKIN_RemoveMostExpandedItem(hwnd) > -1);
3153 iItemPos = FILEDLG95_LOOKIN_InsertItemAfterParent(hwnd,pidl);
3154 }
3155
3156 else
3157 {
3158 SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,iItemPos);
3159 while(liInfos->iMaxIndentation > tmpFolder->m_iIndent)
3160 {
3161 int iRemovedItem;
3162
3163 if(-1 == (iRemovedItem = FILEDLG95_LOOKIN_RemoveMostExpandedItem(hwnd)))
3164 break;
3165 if(iRemovedItem < iItemPos)
3166 iItemPos--;
3167 }
3168 }
3169
3170 CBSetCurSel(hwnd,iItemPos);
3171 liInfos->uSelectedItem = iItemPos;
3172
3173 return 0;
3174
3175 }
3176
3177 /***********************************************************************
3178 * FILEDLG95_LOOKIN_RemoveMostExpandedItem
3179 *
3180 * Remove the item with an expansion level over iExpansionLevel
3181 */
3182 static int FILEDLG95_LOOKIN_RemoveMostExpandedItem(HWND hwnd)
3183 {
3184 int iItemPos;
3185 LookInInfos *liInfos = GetPropA(hwnd,LookInInfosStr);
3186
3187 TRACE("\n");
3188
3189 if(liInfos->iMaxIndentation <= 2)
3190 return -1;
3191
3192 if((iItemPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)liInfos->iMaxIndentation,SEARCH_EXP)) >=0)
3193 {
3194 SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,iItemPos);
3195 COMDLG32_SHFree(tmpFolder->pidlItem);
3196 MemFree(tmpFolder);
3197 CBDeleteString(hwnd,iItemPos);
3198 liInfos->iMaxIndentation--;
3199
3200 return iItemPos;
3201 }
3202
3203 return -1;
3204 }
3205
3206 /***********************************************************************
3207 * FILEDLG95_LOOKIN_SearchItem
3208 *
3209 * Search for pidl in the lookin combo box
3210 * returns the index of the found item
3211 */
3212 static int FILEDLG95_LOOKIN_SearchItem(HWND hwnd,WPARAM searchArg,int iSearchMethod)
3213 {
3214 int i = 0;
3215 int iCount = CBGetCount(hwnd);
3216
3217 TRACE("0x%08lx 0x%x\n",searchArg, iSearchMethod);
3218
3219 if (iCount != CB_ERR)
3220 {
3221 for(;i<iCount;i++)
3222 {
3223 LPSFOLDER tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,i);
3224
3225 if(iSearchMethod == SEARCH_PIDL && COMDLG32_PIDL_ILIsEqual((LPITEMIDLIST)searchArg,tmpFolder->pidlItem))
3226 return i;
3227 if(iSearchMethod == SEARCH_EXP && tmpFolder->m_iIndent == (int)searchArg)
3228 return i;
3229 }
3230 }
3231
3232 return -1;
3233 }
3234
3235 /***********************************************************************
3236 * FILEDLG95_LOOKIN_Clean
3237 *
3238 * Clean the memory used by the lookin combo box
3239 */
3240 static void FILEDLG95_LOOKIN_Clean(HWND hwnd)
3241 {
3242 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
3243 int iPos;
3244 int iCount = CBGetCount(fodInfos->DlgInfos.hwndLookInCB);
3245
3246 TRACE("\n");
3247
3248 /* Delete each string of the combo and their associated data */
3249 if (iCount != CB_ERR)
3250 {
3251 for(iPos = iCount-1;iPos>=0;iPos--)
3252 {
3253 SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(fodInfos->DlgInfos.hwndLookInCB,iPos);
3254 COMDLG32_SHFree(tmpFolder->pidlItem);
3255 MemFree(tmpFolder);
3256 CBDeleteString(fodInfos->DlgInfos.hwndLookInCB,iPos);
3257 }
3258 }
3259
3260 /* LookInInfos structure */
3261 RemovePropA(fodInfos->DlgInfos.hwndLookInCB,LookInInfosStr);
3262
3263 }
3264 /***********************************************************************
3265 * FILEDLG95_FILENAME_FillFromSelection
3266 *
3267 * fills the edit box from the cached DataObject
3268 */
3269 void FILEDLG95_FILENAME_FillFromSelection (HWND hwnd)
3270 {
3271 FileOpenDlgInfos *fodInfos;
3272 LPITEMIDLIST pidl;
3273 UINT nFiles = 0, nFileToOpen, nFileSelected, nLength = 0;
3274 WCHAR lpstrTemp[MAX_PATH];
3275 LPWSTR lpstrAllFile, lpstrCurrFile;
3276
3277 TRACE("\n");
3278 fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
3279
3280 /* Count how many files we have */
3281 nFileSelected = GetNumSelected( fodInfos->Shell.FOIDataObject );
3282
3283 /* calculate the string length, count files */
3284 if (nFileSelected >= 1)
3285 {
3286 nLength += 3; /* first and last quotes, trailing \0 */
3287 for ( nFileToOpen = 0; nFileToOpen < nFileSelected; nFileToOpen++ )
3288 {
3289 pidl = GetPidlFromDataObject( fodInfos->Shell.FOIDataObject, nFileToOpen+1 );
3290
3291 if (pidl)
3292 {
3293 /* get the total length of the selected file names */
3294 lpstrTemp[0] = '\0';
3295 GetName( fodInfos->Shell.FOIShellFolder, pidl, SHGDN_INFOLDER|SHGDN_FORPARSING, lpstrTemp );
3296
3297 if ( ! IsPidlFolder(fodInfos->Shell.FOIShellFolder, pidl) ) /* Ignore folders */
3298 {
3299 nLength += lstrlenW( lpstrTemp ) + 3;
3300 nFiles++;
3301 }
3302 COMDLG32_SHFree( pidl );
3303 }
3304 }
3305 }
3306
3307 /* allocate the buffer */
3308 if (nFiles <= 1) nLength = MAX_PATH;
3309 lpstrAllFile = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nLength * sizeof(WCHAR));
3310
3311 /* Generate the string for the edit control */
3312 if(nFiles >= 1)
3313 {
3314 lpstrCurrFile = lpstrAllFile;
3315 for ( nFileToOpen = 0; nFileToOpen < nFileSelected; nFileToOpen++ )
3316 {
3317 pidl = GetPidlFromDataObject( fodInfos->Shell.FOIDataObject, nFileToOpen+1 );
3318
3319 if (pidl)
3320 {
3321 /* get the file name */
3322 lpstrTemp[0] = '\0';
3323 GetName( fodInfos->Shell.FOIShellFolder, pidl, SHGDN_INFOLDER|SHGDN_FORPARSING, lpstrTemp );
3324
3325 if (! IsPidlFolder(fodInfos->Shell.FOIShellFolder, pidl)) /* Ignore folders */
3326 {
3327 if ( nFiles > 1)
3328 {
3329 *lpstrCurrFile++ = '\"';
3330 lstrcpyW( lpstrCurrFile, lpstrTemp );
3331 lpstrCurrFile += lstrlenW( lpstrTemp );
3332 *lpstrCurrFile++ = '\"';
3333 *lpstrCurrFile++ = ' ';
3334 *lpstrCurrFile = 0;
3335 }
3336 else
3337 {
3338 lstrcpyW( lpstrAllFile, lpstrTemp );
3339 }
3340 }
3341 COMDLG32_SHFree( pidl );
3342 }
3343 }
3344 SetWindowTextW( fodInfos->DlgInfos.hwndFileName, lpstrAllFile );
3345
3346 /* Select the file name like Windows does */
3347 SendMessageW(fodInfos->DlgInfos.hwndFileName, EM_SETSEL, 0, (LPARAM)-1);
3348 }
3349 HeapFree(GetProcessHeap(),0, lpstrAllFile );
3350 }
3351
3352
3353 /* copied from shell32 to avoid linking to it
3354 * Although shell32 is already linked the behaviour of exported StrRetToStrN
3355 * is dependent on whether emulated OS is unicode or not.
3356 */
3357 static HRESULT COMDLG32_StrRetToStrNW (LPWSTR dest, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
3358 {
3359 switch (src->uType)
3360 {
3361 case STRRET_WSTR:
3362 lstrcpynW(dest, src->u.pOleStr, len);
3363 COMDLG32_SHFree(src->u.pOleStr);
3364 break;
3365
3366 case STRRET_CSTR:
3367 if (!MultiByteToWideChar( CP_ACP, 0, src->u.cStr, -1, dest, len ) && len)
3368 dest[len-1] = 0;
3369 break;
3370
3371 case STRRET_OFFSET:
3372 if (!MultiByteToWideChar( CP_ACP, 0, ((LPCSTR)&pidl->mkid)+src->u.uOffset, -1, dest, len ) && len)
3373 dest[len-1] = 0;
3374 break;
3375
3376 default:
3377 FIXME("unknown type %x!\n", src->uType);
3378 if (len) *dest = '\0';
3379 return E_FAIL;
3380 }
3381 return S_OK;
3382 }
3383
3384 /***********************************************************************
3385 * FILEDLG95_FILENAME_GetFileNames
3386 *
3387 * Copies the filenames to a delimited string list.
3388 * The delimiter is specified by the parameter 'separator',
3389 * usually either a space or a nul
3390 */
3391 static int FILEDLG95_FILENAME_GetFileNames (HWND hwnd, LPWSTR * lpstrFileList, UINT * sizeUsed)
3392 {
3393 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
3394 UINT nStrCharCount = 0; /* index in src buffer */
3395 UINT nFileIndex = 0; /* index in dest buffer */
3396 UINT nFileCount = 0; /* number of files */
3397 UINT nStrLen = 0; /* length of string in edit control */
3398 LPWSTR lpstrEdit; /* buffer for string from edit control */
3399
3400 TRACE("\n");
3401
3402 /* get the filenames from the edit control */
3403 nStrLen = SendMessageW(fodInfos->DlgInfos.hwndFileName, WM_GETTEXTLENGTH, 0, 0);
3404 lpstrEdit = MemAlloc( (nStrLen+1)*sizeof(WCHAR) );
3405 GetDlgItemTextW(hwnd, IDC_FILENAME, lpstrEdit, nStrLen+1);
3406
3407 TRACE("nStrLen=%u str=%s\n", nStrLen, debugstr_w(lpstrEdit));
3408
3409 /* we might get single filename without any '"',
3410 * so we need nStrLen + terminating \0 + end-of-list \0 */
3411 *lpstrFileList = MemAlloc( (nStrLen+2)*sizeof(WCHAR) );
3412 *sizeUsed = 0;
3413
3414 /* build delimited file list from filenames */
3415 while ( nStrCharCount <= nStrLen )
3416 {
3417 if ( lpstrEdit[nStrCharCount]=='"' )
3418 {
3419 nStrCharCount++;
3420 while ((lpstrEdit[nStrCharCount]!='"') && (nStrCharCount <= nStrLen))
3421 {
3422 (*lpstrFileList)[nFileIndex++] = lpstrEdit[nStrCharCount];
3423 nStrCharCount++;
3424 }
3425 (*lpstrFileList)[nFileIndex++] = 0;
3426 nFileCount++;
3427 }
3428 nStrCharCount++;
3429 }
3430
3431 /* single, unquoted string */
3432 if ((nStrLen > 0) && (nFileIndex == 0) )
3433 {
3434 lstrcpyW(*lpstrFileList, lpstrEdit);
3435 nFileIndex = lstrlenW(lpstrEdit) + 1;
3436 nFileCount = 1;
3437 }
3438
3439 /* trailing \0 */
3440 (*lpstrFileList)[nFileIndex++] = '\0';
3441
3442 *sizeUsed = nFileIndex;
3443 MemFree(lpstrEdit);
3444 return nFileCount;
3445 }
3446
3447 #define SETDefFormatEtc(fe,cf,med) \
3448 { \
3449 (fe).cfFormat = cf;\
3450 (fe).dwAspect = DVASPECT_CONTENT; \
3451 (fe).ptd =NULL;\
3452 (fe).tymed = med;\
3453 (fe).lindex = -1;\
3454 };
3455
3456 /*
3457 * DATAOBJECT Helper functions
3458 */
3459
3460 /***********************************************************************
3461 * COMCTL32_ReleaseStgMedium
3462 *
3463 * like ReleaseStgMedium from ole32
3464 */
3465 static void COMCTL32_ReleaseStgMedium (STGMEDIUM medium)
3466 {
3467 if(medium.pUnkForRelease)
3468 {
3469 IUnknown_Release(medium.pUnkForRelease);
3470 }
3471 else
3472 {
3473 GlobalUnlock(medium.u.hGlobal);
3474 GlobalFree(medium.u.hGlobal);
3475 }
3476 }
3477
3478 /***********************************************************************
3479 * GetPidlFromDataObject
3480 *
3481 * Return pidl(s) by number from the cached DataObject
3482 *
3483 * nPidlIndex=0 gets the fully qualified root path
3484 */
3485 LPITEMIDLIST GetPidlFromDataObject ( IDataObject *doSelected, UINT nPidlIndex)
3486 {
3487
3488 STGMEDIUM medium;
3489 FORMATETC formatetc;
3490 LPITEMIDLIST pidl = NULL;
3491
3492 TRACE("sv=%p index=%u\n", doSelected, nPidlIndex);
3493
3494 if (!doSelected)
3495 return NULL;
3496
3497 /* Set the FORMATETC structure*/
3498 SETDefFormatEtc(formatetc, RegisterClipboardFormatA(CFSTR_SHELLIDLISTA), TYMED_HGLOBAL);
3499
3500 /* Get the pidls from IDataObject */
3501 if(SUCCEEDED(IDataObject_GetData(doSelected,&formatetc,&medium)))
3502 {
3503 LPIDA cida = GlobalLock(medium.u.hGlobal);
3504 if(nPidlIndex <= cida->cidl)
3505 {
3506 pidl = COMDLG32_PIDL_ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[nPidlIndex]]));
3507 }
3508 COMCTL32_ReleaseStgMedium(medium);
3509 }
3510 return pidl;
3511 }
3512
3513 /***********************************************************************
3514 * GetNumSelected
3515 *
3516 * Return the number of selected items in the DataObject.
3517 *
3518 */
3519 static UINT GetNumSelected( IDataObject *doSelected )
3520 {
3521 UINT retVal = 0;
3522 STGMEDIUM medium;
3523 FORMATETC formatetc;
3524
3525 TRACE("sv=%p\n", doSelected);
3526
3527 if (!doSelected) return 0;
3528
3529 /* Set the FORMATETC structure*/
3530 SETDefFormatEtc(formatetc, RegisterClipboardFormatA(CFSTR_SHELLIDLISTA), TYMED_HGLOBAL);
3531
3532 /* Get the pidls from IDataObject */
3533 if(SUCCEEDED(IDataObject_GetData(doSelected,&formatetc,&medium)))
3534 {
3535 LPIDA cida = GlobalLock(medium.u.hGlobal);
3536 retVal = cida->cidl;
3537 COMCTL32_ReleaseStgMedium(medium);
3538 return retVal;
3539 }
3540 return 0;
3541 }
3542
3543 /*
3544 * TOOLS
3545 */
3546
3547 /***********************************************************************
3548 * GetName
3549 *
3550 * Get the pidl's display name (relative to folder) and
3551 * put it in lpstrFileName.
3552 *
3553 * Return NOERROR on success,
3554 * E_FAIL otherwise
3555 */
3556
3557 static HRESULT GetName(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl,DWORD dwFlags,LPWSTR lpstrFileName)
3558 {
3559 STRRET str;
3560 HRESULT hRes;
3561
3562 TRACE("sf=%p pidl=%p\n", lpsf, pidl);
3563
3564 if(!lpsf)
3565 {
3566 SHGetDesktopFolder(&lpsf);
3567 hRes = GetName(lpsf,pidl,dwFlags,lpstrFileName);
3568 IShellFolder_Release(lpsf);
3569 return hRes;
3570 }
3571
3572 /* Get the display name of the pidl relative to the folder */
3573 if (SUCCEEDED(hRes = IShellFolder_GetDisplayNameOf(lpsf, pidl, dwFlags, &str)))
3574 {
3575 return COMDLG32_StrRetToStrNW(lpstrFileName, MAX_PATH, &str, pidl);
3576 }
3577 return E_FAIL;
3578 }
3579
3580 /***********************************************************************
3581 * GetShellFolderFromPidl
3582 *
3583 * pidlRel is the item pidl relative
3584 * Return the IShellFolder of the absolute pidl
3585 */
3586 IShellFolder *GetShellFolderFromPidl(LPITEMIDLIST pidlAbs)
3587 {
3588 IShellFolder *psf = NULL,*psfParent;
3589
3590 TRACE("%p\n", pidlAbs);
3591
3592 if(SUCCEEDED(SHGetDesktopFolder(&psfParent)))
3593 {
3594 psf = psfParent;
3595 if(pidlAbs && pidlAbs->mkid.cb)
3596 {
3597 if(SUCCEEDED(IShellFolder_BindToObject(psfParent, pidlAbs, NULL, &IID_IShellFolder, (LPVOID*)&psf)))
3598 {
3599 IShellFolder_Release(psfParent);
3600 return psf;
3601 }
3602 }
3603 /* return the desktop */
3604 return psfParent;
3605 }
3606 return NULL;
3607 }
3608
3609 /***********************************************************************
3610 * GetParentPidl
3611 *
3612 * Return the LPITEMIDLIST to the parent of the pidl in the list
3613 */
3614 LPITEMIDLIST GetParentPidl(LPITEMIDLIST pidl)
3615 {
3616 LPITEMIDLIST pidlParent;
3617
3618 TRACE("%p\n", pidl);
3619
3620 pidlParent = COMDLG32_PIDL_ILClone(pidl);
3621 COMDLG32_PIDL_ILRemoveLastID(pidlParent);
3622
3623 return pidlParent;
3624 }
3625
3626 /***********************************************************************
3627 * GetPidlFromName
3628 *
3629 * returns the pidl of the file name relative to folder
3630 * NULL if an error occurred
3631 */
3632 static LPITEMIDLIST GetPidlFromName(IShellFolder *lpsf,LPWSTR lpcstrFileName)
3633 {
3634 LPITEMIDLIST pidl = NULL;
3635 ULONG ulEaten;
3636
3637 TRACE("sf=%p file=%s\n", lpsf, debugstr_w(lpcstrFileName));
3638
3639 if(!lpcstrFileName) return NULL;
3640 if(!*lpcstrFileName) return NULL;
3641
3642 if(!lpsf)
3643 {
3644 if (SUCCEEDED(SHGetDesktopFolder(&lpsf))) {
3645 IShellFolder_ParseDisplayName(lpsf, 0, NULL, lpcstrFileName, &ulEaten, &pidl, NULL);
3646 IShellFolder_Release(lpsf);
3647 }
3648 }
3649 else
3650 {
3651 IShellFolder_ParseDisplayName(lpsf, 0, NULL, lpcstrFileName, &ulEaten, &pidl, NULL);
3652 }
3653 return pidl;
3654 }
3655
3656 /*
3657 */
3658 static BOOL IsPidlFolder (LPSHELLFOLDER psf, LPCITEMIDLIST pidl)
3659 {
3660 ULONG uAttr = SFGAO_FOLDER | SFGAO_HASSUBFOLDER;
3661 HRESULT ret;
3662
3663 TRACE("%p, %p\n", psf, pidl);
3664
3665 ret = IShellFolder_GetAttributesOf( psf, 1, &pidl, &uAttr );
3666
3667 TRACE("-- 0x%08x 0x%08x\n", uAttr, ret);
3668 /* see documentation shell 4.1*/
3669 return uAttr & (SFGAO_FOLDER | SFGAO_HASSUBFOLDER);
3670 }
3671
3672 /***********************************************************************
3673 * BrowseSelectedFolder
3674 */
3675 static BOOL BrowseSelectedFolder(HWND hwnd)
3676 {
3677 BOOL bBrowseSelFolder = FALSE;
3678 FileOpenDlgInfos *fodInfos = GetPropA(hwnd,FileOpenDlgInfosStr);
3679
3680 TRACE("\n");
3681
3682 if (GetNumSelected(fodInfos->Shell.FOIDataObject) == 1)
3683 {
3684 LPITEMIDLIST pidlSelection;
3685
3686 /* get the file selected */
3687 pidlSelection = GetPidlFromDataObject( fodInfos->Shell.FOIDataObject, 1);
3688 if (IsPidlFolder (fodInfos->Shell.FOIShellFolder, pidlSelection))
3689 {
3690 if ( FAILED( IShellBrowser_BrowseObject( fodInfos->Shell.FOIShellBrowser,
3691 pidlSelection, SBSP_RELATIVE ) ) )
3692 {
3693 static const WCHAR notexist[] = {'P','a','t','h',' ','d','o','e','s',
3694 ' ','n','o','t',' ','e','x','i','s','t',0};
3695 MessageBoxW( hwnd, notexist, fodInfos->title, MB_OK | MB_ICONEXCLAMATION );
3696 }
3697 bBrowseSelFolder = TRUE;
3698 if(fodInfos->ofnInfos->Flags & OFN_EXPLORER)
3699 SendCustomDlgNotificationMessage(hwnd,CDN_FOLDERCHANGE);
3700 }
3701 COMDLG32_SHFree( pidlSelection );
3702 }
3703
3704 return bBrowseSelFolder;
3705 }
3706
3707 /*
3708 * Memory allocation methods */
3709 static void *MemAlloc(UINT size)
3710 {
3711 return HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size);
3712 }
3713
3714 static void MemFree(void *mem)
3715 {
3716 HeapFree(GetProcessHeap(),0,mem);
3717 }
3718
3719 /*
3720 * Old-style (win3.1) dialogs */
3721
3722 /***********************************************************************
3723 * FD32_GetTemplate [internal]
3724 *
3725 * Get a template (or FALSE if failure) when 16 bits dialogs are used
3726 * by a 32 bits application
3727 *
3728 */
3729 static BOOL FD32_GetTemplate(PFD31_DATA lfs)
3730 {
3731 LPOPENFILENAMEW ofnW = lfs->ofnW;
3732 PFD32_PRIVATE priv = (PFD32_PRIVATE) lfs->private1632;
3733 HANDLE hDlgTmpl;
3734
3735 if (ofnW->Flags & OFN_ENABLETEMPLATEHANDLE)
3736 {
3737 if (!(lfs->template = LockResource( ofnW->hInstance )))
3738 {
3739 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
3740 return FALSE;
3741 }
3742 }
3743 else if (ofnW->Flags & OFN_ENABLETEMPLATE)
3744 {
3745 HRSRC hResInfo;
3746 if (priv->ofnA)
3747 hResInfo = FindResourceA(priv->ofnA->hInstance,
3748 priv->ofnA->lpTemplateName,
3749 (LPSTR)RT_DIALOG);
3750 else
3751 hResInfo = FindResourceW(ofnW->hInstance,
3752 ofnW->lpTemplateName,
3753 (LPWSTR)RT_DIALOG);
3754 if (!hResInfo)
3755 {
3756 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
3757 return FALSE;
3758 }
3759 if (!(hDlgTmpl = LoadResource(ofnW->hInstance,
3760 hResInfo)) ||
3761 !(lfs->template = LockResource(hDlgTmpl)))
3762 {
3763 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
3764 return FALSE;
3765 }
3766 } else { /* get it from internal Wine resource */
3767 HRSRC hResInfo;
3768 if (!(hResInfo = FindResourceA(COMDLG32_hInstance,
3769 lfs->open? "OPEN_FILE":"SAVE_FILE", (LPSTR)RT_DIALOG)))
3770 {
3771 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
3772 return FALSE;
3773 }
3774 if (!(hDlgTmpl = LoadResource(COMDLG32_hInstance, hResInfo )) ||
3775 !(lfs->template = LockResource( hDlgTmpl )))
3776 {
3777 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
3778 return FALSE;
3779 }
3780 }
3781 return TRUE;
3782 }
3783
3784
3785 /************************************************************************
3786 * FD32_Init [internal]
3787 * called from the common 16/32 code to initialize 32 bit data
3788 */
3789 static BOOL CALLBACK FD32_Init(LPARAM lParam, PFD31_DATA lfs, DWORD data)
3790 {
3791 BOOL IsUnicode = (BOOL) data;
3792 PFD32_PRIVATE priv;
3793
3794 priv = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(FD32_PRIVATE));
3795 lfs->private1632 = priv;
3796 if (NULL == lfs->private1632) return FALSE;
3797 if (IsUnicode)
3798 {
3799 lfs->ofnW = (LPOPENFILENAMEW) lParam;
3800 if (lfs->ofnW->Flags & OFN_ENABLEHOOK)
3801 if (lfs->ofnW->lpfnHook)
3802 lfs->hook = TRUE;
3803 }
3804 else
3805 {
3806 priv->ofnA = (LPOPENFILENAMEA) lParam;
3807 if (priv->ofnA->Flags & OFN_ENABLEHOOK)
3808 if (priv->ofnA->lpfnHook)
3809 lfs->hook = TRUE;
3810 lfs->ofnW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*lfs->ofnW));
3811 FD31_MapOfnStructA(priv->ofnA, lfs->ofnW, lfs->open);
3812 }
3813
3814 if (! FD32_GetTemplate(lfs)) return FALSE;
3815
3816 return TRUE;
3817 }
3818
3819 /***********************************************************************
3820 * FD32_CallWindowProc [internal]
3821 *
3822 * called from the common 16/32 code to call the appropriate hook
3823 */
3824 static BOOL CALLBACK FD32_CallWindowProc(const FD31_DATA *lfs, UINT wMsg, WPARAM wParam,
3825 LPARAM lParam)
3826 {
3827 BOOL ret;
3828 PFD32_PRIVATE priv = (PFD32_PRIVATE) lfs->private1632;
3829
3830 if (priv->ofnA)
3831 {
3832 TRACE("Call hookA %p (%p, %04x, %08lx, %08lx)\n",
3833 priv->ofnA->lpfnHook, lfs->hwnd, wMsg, wParam, lParam);
3834 ret = priv->ofnA->lpfnHook(lfs->hwnd, wMsg, wParam, lParam);
3835 TRACE("ret hookA %p (%p, %04x, %08lx, %08lx)\n",
3836 priv->ofnA->lpfnHook, lfs->hwnd, wMsg, wParam, lParam);
3837 return ret;
3838 }
3839
3840 TRACE("Call hookW %p (%p, %04x, %08lx, %08lx)\n",
3841 lfs->ofnW->lpfnHook, lfs->hwnd, wMsg, wParam, lParam);
3842 ret = lfs->ofnW->lpfnHook(lfs->hwnd, wMsg, wParam, lParam);
3843 TRACE("Ret hookW %p (%p, %04x, %08lx, %08lx)\n",
3844 lfs->ofnW->lpfnHook, lfs->hwnd, wMsg, wParam, lParam);
3845 return ret;
3846 }
3847
3848 /***********************************************************************
3849 * FD32_UpdateResult [internal]
3850 * update the real client structures if any
3851 */
3852 static void CALLBACK FD32_UpdateResult(const FD31_DATA *lfs)
3853 {
3854 PFD32_PRIVATE priv = (PFD32_PRIVATE) lfs->private1632;
3855 LPOPENFILENAMEW ofnW = lfs->ofnW;
3856
3857 if (priv->ofnA)
3858 {
3859 LPSTR lpszTemp;
3860 if (ofnW->nMaxFile &&
3861 !WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFile, -1,
3862 priv->ofnA->lpstrFile, ofnW->nMaxFile, NULL, NULL ))
3863 priv->ofnA->lpstrFile[ofnW->nMaxFile-1] = 0;
3864
3865 /* offsets are not guaranteed to be the same in WCHAR to MULTIBYTE conversion */
3866 /* set filename offset */
3867 lpszTemp = PathFindFileNameA(priv->ofnA->lpstrFile);
3868 priv->ofnA->nFileOffset = (lpszTemp - priv->ofnA->lpstrFile);
3869
3870 /* set extension offset */
3871 lpszTemp = PathFindExtensionA(priv->ofnA->lpstrFile);
3872 priv->ofnA->nFileExtension = (*lpszTemp) ? (lpszTemp - priv->ofnA->lpstrFile) + 1 : 0;
3873 }
3874 }
3875
3876 /***********************************************************************
3877 * FD32_UpdateFileTitle [internal]
3878 * update the real client structures if any
3879 */
3880 static void CALLBACK FD32_UpdateFileTitle(const FD31_DATA *lfs)
3881 {
3882 PFD32_PRIVATE priv = (PFD32_PRIVATE) lfs->private1632;
3883 LPOPENFILENAMEW ofnW = lfs->ofnW;
3884
3885 if (priv->ofnA)
3886 {
3887 if (!WideCharToMultiByte( CP_ACP, 0, ofnW->lpstrFileTitle, -1,
3888 priv->ofnA->lpstrFileTitle, ofnW->nMaxFileTitle, NULL, NULL ))
3889 priv->ofnA->lpstrFileTitle[ofnW->nMaxFileTitle-1] = 0;
3890 }
3891 }
3892
3893
3894 /***********************************************************************
3895 * FD32_SendLbGetCurSel [internal]
3896 * retrieve selected listbox item
3897 */
3898 static LRESULT CALLBACK FD32_SendLbGetCurSel(const FD31_DATA *lfs)
3899 {
3900 return SendDlgItemMessageW(lfs->hwnd, lst1, LB_GETCURSEL, 0, 0);
3901 }
3902
3903
3904 /************************************************************************
3905 * FD32_Destroy [internal]
3906 * called from the common 16/32 code to cleanup 32 bit data
3907 */
3908 static void CALLBACK FD32_Destroy(const FD31_DATA *lfs)
3909 {
3910 PFD32_PRIVATE priv = (PFD32_PRIVATE) lfs->private1632;
3911
3912 /* if ofnW has been allocated, have to free everything in it */
3913 if (NULL != priv && NULL != priv->ofnA)
3914 {
3915 FD31_FreeOfnW(lfs->ofnW);
3916 HeapFree(GetProcessHeap(), 0, lfs->ofnW);
3917 }
3918 }
3919
3920 static void FD32_SetupCallbacks(PFD31_CALLBACKS callbacks)
3921 {
3922 callbacks->Init = FD32_Init;
3923 callbacks->CWP = FD32_CallWindowProc;
3924 callbacks->UpdateResult = FD32_UpdateResult;
3925 callbacks->UpdateFileTitle = FD32_UpdateFileTitle;
3926 callbacks->SendLbGetCurSel = FD32_SendLbGetCurSel;
3927 callbacks->Destroy = FD32_Destroy;
3928 }
3929
3930 /***********************************************************************
3931 * FD32_WMMeasureItem [internal]
3932 */
3933 static LONG FD32_WMMeasureItem(HWND hWnd, WPARAM wParam, LPARAM lParam)
3934 {
3935 LPMEASUREITEMSTRUCT lpmeasure;
3936
3937 lpmeasure = (LPMEASUREITEMSTRUCT)lParam;
3938 lpmeasure->itemHeight = FD31_GetFldrHeight();
3939 return TRUE;
3940 }
3941
3942
3943 /***********************************************************************
3944 * FileOpenDlgProc [internal]
3945 * Used for open and save, in fact.
3946 */
3947 static INT_PTR CALLBACK FD32_FileOpenDlgProc(HWND hWnd, UINT wMsg,
3948 WPARAM wParam, LPARAM lParam)
3949 {
3950 PFD31_DATA lfs = (PFD31_DATA)GetPropA(hWnd,FD31_OFN_PROP);
3951
3952 TRACE("msg=%x wparam=%lx lParam=%lx\n", wMsg, wParam, lParam);
3953 if ((wMsg != WM_INITDIALOG) && lfs && lfs->hook)
3954 {
3955 INT_PTR lRet;
3956 lRet = (INT_PTR)FD31_CallWindowProc(lfs, wMsg, wParam, lParam);
3957 if (lRet)
3958 return lRet; /* else continue message processing */
3959 }
3960 switch (wMsg)
3961 {
3962 case WM_INITDIALOG:
3963 return FD31_WMInitDialog(hWnd, wParam, lParam);
3964
3965 case WM_MEASUREITEM:
3966 return FD32_WMMeasureItem(hWnd, wParam, lParam);
3967
3968 case WM_DRAWITEM:
3969 return FD31_WMDrawItem(hWnd, wParam, lParam, !lfs->open, (DRAWITEMSTRUCT *)lParam);
3970
3971 case WM_COMMAND:
3972 return FD31_WMCommand(hWnd, lParam, HIWORD(wParam), LOWORD(wParam), lfs);
3973 #if 0
3974 case WM_CTLCOLOR:
3975 SetBkColor((HDC16)wParam, 0x00C0C0C0);
3976 switch (HIWORD(lParam))
3977 {
3978 case CTLCOLOR_BTN:
3979 SetTextColor((HDC16)wParam, 0x00000000);
3980 return hGRAYBrush;
3981 case CTLCOLOR_STATIC:
3982 SetTextColor((HDC16)wParam, 0x00000000);
3983 return hGRAYBrush;
3984 }
3985 break;
3986 #endif
3987 }
3988 return FALSE;
3989 }
3990
3991
3992 /***********************************************************************
3993 * GetFileName31A [internal]
3994 *
3995 * Creates a win31 style dialog box for the user to select a file to open/save.
3996 */
3997 static BOOL GetFileName31A(LPOPENFILENAMEA lpofn, /* address of structure with data*/
3998 UINT dlgType /* type dialogue : open/save */
3999 )
4000 {
4001 HINSTANCE hInst;
4002 BOOL bRet = FALSE;
4003 PFD31_DATA lfs;
4004 FD31_CALLBACKS callbacks;
4005
4006 if (!lpofn || !FD31_Init()) return FALSE;
4007
4008 TRACE("ofn flags %08x\n", lpofn->Flags);
4009 FD32_SetupCallbacks(&callbacks);
4010 lfs = FD31_AllocPrivate((LPARAM) lpofn, dlgType, &callbacks, (DWORD) FALSE);
4011 if (lfs)
4012 {
4013 hInst = (HINSTANCE)GetWindowLongPtrW( lpofn->hwndOwner, GWLP_HINSTANCE );
4014 bRet = DialogBoxIndirectParamA( hInst, lfs->template, lpofn->hwndOwner,
4015 FD32_FileOpenDlgProc, (LPARAM)lfs);
4016 FD31_DestroyPrivate(lfs);
4017 }
4018
4019 TRACE("return lpstrFile='%s' !\n", lpofn->lpstrFile);
4020 return bRet;
4021 }
4022
4023 /***********************************************************************
4024 * GetFileName31W [internal]
4025 *
4026 * Creates a win31 style dialog box for the user to select a file to open/save
4027 */
4028 static BOOL GetFileName31W(LPOPENFILENAMEW lpofn, /* address of structure with data*/
4029 UINT dlgType /* type dialogue : open/save */
4030 )
4031 {
4032 HINSTANCE hInst;
4033 BOOL bRet = FALSE;
4034 PFD31_DATA lfs;
4035 FD31_CALLBACKS callbacks;
4036
4037 if (!lpofn || !FD31_Init()) return FALSE;
4038
4039 FD32_SetupCallbacks(&callbacks);
4040 lfs = FD31_AllocPrivate((LPARAM) lpofn, dlgType, &callbacks, (DWORD) TRUE);
4041 if (lfs)
4042 {
4043 hInst = (HINSTANCE)GetWindowLongPtrW( lpofn->hwndOwner, GWLP_HINSTANCE );
4044 bRet = DialogBoxIndirectParamW( hInst, lfs->template, lpofn->hwndOwner,
4045 FD32_FileOpenDlgProc, (LPARAM)lfs);
4046 FD31_DestroyPrivate(lfs);
4047 }
4048
4049 TRACE("file %s, file offset %d, ext offset %d\n",
4050 debugstr_w(lpofn->lpstrFile), lpofn->nFileOffset, lpofn->nFileExtension);
4051 return bRet;
4052 }
4053
4054 /* ------------------ APIs ---------------------- */
4055
4056 /***********************************************************************
4057 * GetOpenFileNameA (COMDLG32.@)
4058 *
4059 * Creates a dialog box for the user to select a file to open.
4060 *
4061 * RETURNS
4062 * TRUE on success: user enters a valid file
4063 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
4064 *
4065 */
4066 BOOL WINAPI GetOpenFileNameA(
4067 LPOPENFILENAMEA ofn) /* [in/out] address of init structure */
4068 {
4069 BOOL win16look = FALSE;
4070
4071 TRACE("flags %08x\n", ofn->Flags);
4072
4073 /* OFN_FILEMUSTEXIST implies OFN_PATHMUSTEXIST */
4074 if (ofn->Flags & OFN_FILEMUSTEXIST)
4075 ofn->Flags |= OFN_PATHMUSTEXIST;
4076
4077 if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
4078 win16look = (ofn->Flags & OFN_EXPLORER) ? FALSE : TRUE;
4079
4080 if (win16look)
4081 return GetFileName31A(ofn, OPEN_DIALOG);
4082 else
4083 return GetFileDialog95A(ofn, OPEN_DIALOG);
4084 }
4085
4086 /***********************************************************************
4087 * GetOpenFileNameW (COMDLG32.@)
4088 *
4089 * Creates a dialog box for the user to select a file to open.
4090 *
4091 * RETURNS
4092 * TRUE on success: user enters a valid file
4093 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
4094 *
4095 */
4096 BOOL WINAPI GetOpenFileNameW(
4097 LPOPENFILENAMEW ofn) /* [in/out] address of init structure */
4098 {
4099 BOOL win16look = FALSE;
4100
4101 TRACE("flags %08x\n", ofn->Flags);
4102
4103 /* OFN_FILEMUSTEXIST implies OFN_PATHMUSTEXIST */
4104 if (ofn->Flags & OFN_FILEMUSTEXIST)
4105 ofn->Flags |= OFN_PATHMUSTEXIST;
4106
4107 if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
4108 win16look = (ofn->Flags & OFN_EXPLORER) ? FALSE : TRUE;
4109
4110 if (win16look)
4111 return GetFileName31W(ofn, OPEN_DIALOG);
4112 else
4113 return GetFileDialog95W(ofn, OPEN_DIALOG);
4114 }
4115
4116
4117 /***********************************************************************
4118 * GetSaveFileNameA (COMDLG32.@)
4119 *
4120 * Creates a dialog box for the user to select a file to save.
4121 *
4122 * RETURNS
4123 * TRUE on success: user enters a valid file
4124 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
4125 *
4126 */
4127 BOOL WINAPI GetSaveFileNameA(
4128 LPOPENFILENAMEA ofn) /* [in/out] address of init structure */
4129 {
4130 BOOL win16look = FALSE;
4131
4132 if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
4133 win16look = (ofn->Flags & OFN_EXPLORER) ? FALSE : TRUE;
4134
4135 if (win16look)
4136 return GetFileName31A(ofn, SAVE_DIALOG);
4137 else
4138 return GetFileDialog95A(ofn, SAVE_DIALOG);
4139 }
4140
4141 /***********************************************************************
4142 * GetSaveFileNameW (COMDLG32.@)
4143 *
4144 * Creates a dialog box for the user to select a file to save.
4145 *
4146 * RETURNS
4147 * TRUE on success: user enters a valid file
4148 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
4149 *
4150 */
4151 BOOL WINAPI GetSaveFileNameW(
4152 LPOPENFILENAMEW ofn) /* [in/out] address of init structure */
4153 {
4154 BOOL win16look = FALSE;
4155
4156 if (ofn->Flags & (OFN_ALLOWMULTISELECT|OFN_ENABLEHOOK|OFN_ENABLETEMPLATE))
4157 win16look = (ofn->Flags & OFN_EXPLORER) ? FALSE : TRUE;
4158
4159 if (win16look)
4160 return GetFileName31W(ofn, SAVE_DIALOG);
4161 else
4162 return GetFileDialog95W(ofn, SAVE_DIALOG);
4163 }
4164
4165 /***********************************************************************
4166 * GetFileTitleA (COMDLG32.@)
4167 *
4168 * See GetFileTitleW.
4169 */
4170 short WINAPI GetFileTitleA(LPCSTR lpFile, LPSTR lpTitle, WORD cbBuf)
4171 {
4172 int ret;
4173 UNICODE_STRING strWFile;
4174 LPWSTR lpWTitle;
4175
4176 RtlCreateUnicodeStringFromAsciiz(&strWFile, lpFile);
4177 lpWTitle = RtlAllocateHeap( GetProcessHeap(), 0, cbBuf*sizeof(WCHAR));
4178 ret = GetFileTitleW(strWFile.Buffer, lpWTitle, cbBuf);
4179 if (!ret) WideCharToMultiByte( CP_ACP, 0, lpWTitle, -1, lpTitle, cbBuf, NULL, NULL );
4180 RtlFreeUnicodeString( &strWFile );
4181 RtlFreeHeap( GetProcessHeap(), 0, lpWTitle );
4182 return ret;
4183 }
4184
4185
4186 /***********************************************************************
4187 * GetFileTitleW (COMDLG32.@)
4188 *
4189 * Get the name of a file.
4190 *
4191 * PARAMS
4192 * lpFile [I] name and location of file
4193 * lpTitle [O] returned file name
4194 * cbBuf [I] buffer size of lpTitle
4195 *
4196 * RETURNS
4197 * Success: zero
4198 * Failure: negative number.
4199 */
4200 short WINAPI GetFileTitleW(LPCWSTR lpFile, LPWSTR lpTitle, WORD cbBuf)
4201 {
4202 int i, len;
4203 static const WCHAR brkpoint[] = {'*','[',']',0};
4204 TRACE("(%p %p %d);\n", lpFile, lpTitle, cbBuf);
4205
4206 if(lpFile == NULL || lpTitle == NULL)
4207 return -1;
4208
4209 len = lstrlenW(lpFile);
4210
4211 if (len == 0)
4212 return -1;
4213
4214 if(strpbrkW(lpFile, brkpoint))
4215 return -1;
4216
4217 len--;
4218
4219 if(lpFile[len] == '/' || lpFile[len] == '\\' || lpFile[len] == ':')
4220 return -1;
4221
4222 for(i = len; i >= 0; i--)
4223 {
4224 if (lpFile[i] == '/' || lpFile[i] == '\\' || lpFile[i] == ':')
4225 {
4226 i++;
4227 break;
4228 }
4229 }
4230
4231 if(i == -1)
4232 i++;
4233
4234 TRACE("---> %s\n", debugstr_w(&lpFile[i]));
4235
4236 len = lstrlenW(lpFile+i)+1;
4237 if(cbBuf < len)
4238 return len;
4239
4240 lstrcpyW(lpTitle, &lpFile[i]);
4241 return 0;
4242 }
A free Windows-compatible Operating System