?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed some alignment issues (based on a patch by Gregg Mattinson).
[wine.git] / dlls / commdlg / filedlg95.c
blob560e05236257e1d5e48f1ca2118b22470fcd6608
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * FIXME: The whole concept of handling unicode is badly broken.
22 * many hook-messages expecting 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 if would likely cause
26 * a complete rewrite with after we shouldhandle 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: lpstrCustomFilter not handled
36 *
37 * FIXME: if the size of lpstrFile (nMaxFile) is too small the first
38 * two bytes of lpstrFile should contain the needed size
39 *
40 * FIXME: algorithm for selecting the initial directory is too simple
41 *
42 * FIXME: add to recent docs
43 *
44 * FIXME: flags not implemented: OFN_CREATEPROMPT, OFN_DONTADDTORECENT,
45 * OFN_ENABLEINCLUDENOTIFY, OFN_ENABLESIZING, OFN_EXTENSIONDIFFERENT,
46 * OFN_NODEREFERENCELINKS, OFN_NOREADONLYRETURN,
47 * OFN_NOTESTFILECREATE, OFN_OVERWRITEPROMPT, OFN_USEMONIKERS
48 *
49 * FIXME: lCustData for lpfnHook (WM_INITDIALOG)
50 *
51 *
52 */
53
54 #include "config.h"
55 #include "wine/port.h"
56
57 #include <ctype.h>
58 #include <stdlib.h>
59 #include <stdio.h>
60 #include <string.h>
61
62 #include "winbase.h"
63 #include "ntddk.h"
64 #include "winnls.h"
65 #include "wine/unicode.h"
66 #include "commdlg.h"
67 #include "dlgs.h"
68 #include "cdlg.h"
69 #include "wine/debug.h"
70 #include "cderr.h"
71 #include "shellapi.h"
72 #include "shlguid.h"
73 #include "filedlgbrowser.h"
74 #include "shlwapi.h"
75 #include "wine/obj_contextmenu.h"
76
77 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
78
79 #define UNIMPLEMENTED_FLAGS \
80 (OFN_CREATEPROMPT | OFN_DONTADDTORECENT |\
81 OFN_ENABLEINCLUDENOTIFY | OFN_ENABLESIZING | OFN_EXTENSIONDIFFERENT |\
82 OFN_NODEREFERENCELINKS | OFN_NOREADONLYRETURN |\
83 OFN_NOTESTFILECREATE | OFN_OVERWRITEPROMPT /*| OFN_USEMONIKERS*/)
84
85 #define IsHooked(fodInfos) \
86 ((fodInfos->ofnInfos->Flags & OFN_ENABLEHOOK) && fodInfos->ofnInfos->lpfnHook)
87 /***********************************************************************
88 * Data structure and global variables
89 */
90 typedef struct SFolder
91 {
92 int m_iImageIndex; /* Index of picture in image list */
93 HIMAGELIST hImgList;
94 int m_iIndent; /* Indentation index */
95 LPITEMIDLIST pidlItem; /* absolute pidl of the item */
96
97 } SFOLDER,*LPSFOLDER;
98
99 typedef struct tagLookInInfo
100 {
101 int iMaxIndentation;
102 UINT uSelectedItem;
103 } LookInInfos;
104
105
106 /***********************************************************************
107 * Defines and global variables
108 */
109
110 /* Draw item constant */
111 #define ICONWIDTH 18
112 #define XTEXTOFFSET 3
113
114 /* AddItem flags*/
115 #define LISTEND -1
116
117 /* SearchItem methods */
118 #define SEARCH_PIDL 1
119 #define SEARCH_EXP 2
120 #define ITEM_NOTFOUND -1
121
122 /* Undefined windows message sent by CreateViewObject*/
123 #define WM_GETISHELLBROWSER WM_USER+7
124
125 /* NOTE
126 * Those macros exist in windowsx.h. However, you can't really use them since
127 * they rely on the UNICODE defines and can't be used inside Wine itself.
128 */
129
130 /* Combo box macros */
131 #define CBAddString(hwnd,str) \
132 SendMessageA(hwnd,CB_ADDSTRING,0,(LPARAM)str);
133
134 #define CBInsertString(hwnd,str,pos) \
135 SendMessageA(hwnd,CB_INSERTSTRING,(WPARAM)pos,(LPARAM)str);
136
137 #define CBDeleteString(hwnd,pos) \
138 SendMessageA(hwnd,CB_DELETESTRING,(WPARAM)pos,0);
139
140 #define CBSetItemDataPtr(hwnd,iItemId,dataPtr) \
141 SendMessageA(hwnd,CB_SETITEMDATA,(WPARAM)iItemId,(LPARAM)dataPtr);
142
143 #define CBGetItemDataPtr(hwnd,iItemId) \
144 SendMessageA(hwnd,CB_GETITEMDATA,(WPARAM)iItemId,0)
145
146 #define CBGetLBText(hwnd,iItemId,str) \
147 SendMessageA(hwnd,CB_GETLBTEXT,(WPARAM)iItemId,(LPARAM)str);
148
149 #define CBGetCurSel(hwnd) \
150 SendMessageA(hwnd,CB_GETCURSEL,0,0);
151
152 #define CBSetCurSel(hwnd,pos) \
153 SendMessageA(hwnd,CB_SETCURSEL,(WPARAM)pos,0);
154
155 #define CBGetCount(hwnd) \
156 SendMessageA(hwnd,CB_GETCOUNT,0,0);
157 #define CBShowDropDown(hwnd,show) \
158 SendMessageA(hwnd,CB_SHOWDROPDOWN,(WPARAM)show,0);
159 #define CBSetItemHeight(hwnd,index,height) \
160 SendMessageA(hwnd,CB_SETITEMHEIGHT,(WPARAM)index,(LPARAM)height);
161
162
163 const char *FileOpenDlgInfosStr = "FileOpenDlgInfos"; /* windows property description string */
164 const char *LookInInfosStr = "LookInInfos"; /* LOOKIN combo box property */
165
166 static const char defaultFilter[] = "*.*";
167
168 /***********************************************************************
169 * Prototypes
170 */
171
172 /* Internal functions used by the dialog */
173 static LRESULT FILEDLG95_FillControls(HWND hwnd, WPARAM wParam, LPARAM lParam);
174 static LRESULT FILEDLG95_OnWMCommand(HWND hwnd, WPARAM wParam, LPARAM lParam);
175 static LRESULT FILEDLG95_OnWMGetIShellBrowser(HWND hwnd);
176 BOOL FILEDLG95_OnOpen(HWND hwnd);
177 static LRESULT FILEDLG95_InitControls(HWND hwnd);
178 static void FILEDLG95_Clean(HWND hwnd);
179
180 /* Functions used by the shell navigation */
181 static LRESULT FILEDLG95_SHELL_Init(HWND hwnd);
182 static BOOL FILEDLG95_SHELL_UpFolder(HWND hwnd);
183 static BOOL FILEDLG95_SHELL_ExecuteCommand(HWND hwnd, LPCSTR lpVerb);
184 static void FILEDLG95_SHELL_Clean(HWND hwnd);
185 static BOOL FILEDLG95_SHELL_BrowseToDesktop(HWND hwnd);
186
187 /* Functions used by the filetype combo box */
188 static HRESULT FILEDLG95_FILETYPE_Init(HWND hwnd);
189 static BOOL FILEDLG95_FILETYPE_OnCommand(HWND hwnd, WORD wNotifyCode);
190 static int FILEDLG95_FILETYPE_SearchExt(HWND hwnd,LPCSTR lpstrExt);
191 static void FILEDLG95_FILETYPE_Clean(HWND hwnd);
192
193 /* Functions used by the Look In combo box */
194 static HRESULT FILEDLG95_LOOKIN_Init(HWND hwndCombo);
195 static LRESULT FILEDLG95_LOOKIN_DrawItem(LPDRAWITEMSTRUCT pDIStruct);
196 static BOOL FILEDLG95_LOOKIN_OnCommand(HWND hwnd, WORD wNotifyCode);
197 static int FILEDLG95_LOOKIN_AddItem(HWND hwnd,LPITEMIDLIST pidl, int iInsertId);
198 static int FILEDLG95_LOOKIN_SearchItem(HWND hwnd,WPARAM searchArg,int iSearchMethod);
199 static int FILEDLG95_LOOKIN_InsertItemAfterParent(HWND hwnd,LPITEMIDLIST pidl);
200 static int FILEDLG95_LOOKIN_RemoveMostExpandedItem(HWND hwnd);
201 int FILEDLG95_LOOKIN_SelectItem(HWND hwnd,LPITEMIDLIST pidl);
202 static void FILEDLG95_LOOKIN_Clean(HWND hwnd);
203
204 /* Miscellaneous tool functions */
205 HRESULT GetName(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl,DWORD dwFlags,LPSTR lpstrFileName);
206 HRESULT GetFileName(HWND hwnd, LPITEMIDLIST pidl, LPSTR lpstrFileName);
207 IShellFolder* GetShellFolderFromPidl(LPITEMIDLIST pidlAbs);
208 LPITEMIDLIST GetParentPidl(LPITEMIDLIST pidl);
209 LPITEMIDLIST GetPidlFromName(IShellFolder *psf,LPCSTR lpcstrFileName);
210
211 /* Shell memory allocation */
212 static void *MemAlloc(UINT size);
213 static void MemFree(void *mem);
214
215 BOOL WINAPI GetFileName95(FileOpenDlgInfos *fodInfos);
216 HRESULT WINAPI FileOpenDlgProc95(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
217 HRESULT SendCustomDlgNotificationMessage(HWND hwndParentDlg, UINT uCode);
218 HRESULT FILEDLG95_HandleCustomDialogMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
219 BOOL FILEDLG95_OnOpenMultipleFiles(HWND hwnd, LPSTR lpstrFileList, UINT nFileCount, UINT sizeUsed);
220 static BOOL BrowseSelectedFolder(HWND hwnd);
221
222 /***********************************************************************
223 * GetFileName95
224 *
225 * Creates an Open common dialog box that lets the user select
226 * the drive, directory, and the name of a file or set of files to open.
227 *
228 * IN : The FileOpenDlgInfos structure associated with the dialog
229 * OUT : TRUE on success
230 * FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
231 */
232 BOOL WINAPI GetFileName95(FileOpenDlgInfos *fodInfos)
233 {
234
235 LRESULT lRes;
236 LPCVOID template;
237 HRSRC hRes;
238 HANDLE hDlgTmpl = 0;
239
240 /* test for missing functionality */
241 if (fodInfos->ofnInfos->Flags & UNIMPLEMENTED_FLAGS)
242 {
243 FIXME("Flags 0x%08lx not yet implemented\n",
244 fodInfos->ofnInfos->Flags & UNIMPLEMENTED_FLAGS);
245 }
246
247 /* Create the dialog from a template */
248
249 if(!(hRes = FindResourceA(COMMDLG_hInstance32,MAKEINTRESOURCEA(NEWFILEOPENORD),RT_DIALOGA)))
250 {
251 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
252 return FALSE;
253 }
254 if (!(hDlgTmpl = LoadResource(COMMDLG_hInstance32, hRes )) ||
255 !(template = LockResource( hDlgTmpl )))
256 {
257 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
258 return FALSE;
259 }
260
261 /* old style hook messages */
262 if (IsHooked(fodInfos))
263 {
264 fodInfos->HookMsg.fileokstring = RegisterWindowMessageA(FILEOKSTRINGA);
265 fodInfos->HookMsg.lbselchstring = RegisterWindowMessageA(LBSELCHSTRINGA);
266 fodInfos->HookMsg.helpmsgstring = RegisterWindowMessageA(HELPMSGSTRINGA);
267 fodInfos->HookMsg.sharevistring = RegisterWindowMessageA(SHAREVISTRINGA);
268 }
269
270 lRes = DialogBoxIndirectParamA(COMMDLG_hInstance32,
271 (LPDLGTEMPLATEA) template,
272 fodInfos->ofnInfos->hwndOwner,
273 (DLGPROC) FileOpenDlgProc95,
274 (LPARAM) fodInfos);
275
276 /* Unable to create the dialog */
277 if( lRes == -1)
278 return FALSE;
279
280 return lRes;
281 }
282
283 /***********************************************************************
284 * GetFileDialog95A
285 *
286 * Call GetFileName95 with this structure and clean the memory.
287 *
288 * IN : The OPENFILENAMEA initialisation structure passed to
289 * GetOpenFileNameA win api function (see filedlg.c)
290 */
291 BOOL WINAPI GetFileDialog95A(LPOPENFILENAMEA ofn,UINT iDlgType)
292 {
293
294 BOOL ret;
295 FileOpenDlgInfos *fodInfos;
296 HINSTANCE hInstance;
297 LPCSTR lpstrInitialDir = (LPCSTR)-1;
298 LPSTR lpstrSavDir = NULL;
299 DWORD dwFlags = 0;
300
301 /* Initialize FileOpenDlgInfos structure */
302 fodInfos = (FileOpenDlgInfos*)MemAlloc(sizeof(FileOpenDlgInfos));
303 ZeroMemory(fodInfos, sizeof(FileOpenDlgInfos));
304
305 /* Pass in the original ofn */
306 fodInfos->ofnInfos = ofn;
307
308 /* Save original hInstance value */
309 hInstance = ofn->hInstance;
310 fodInfos->ofnInfos->hInstance = MapHModuleLS(ofn->hInstance);
311
312 /* save current directory */
313 if (ofn->Flags & OFN_NOCHANGEDIR)
314 {
315 lpstrSavDir = MemAlloc(MAX_PATH);
316 GetCurrentDirectoryA(MAX_PATH, lpstrSavDir);
317 }
318
319 dwFlags = ofn->Flags;
320 ofn->Flags = ofn->Flags|OFN_WINE;
321
322 /* Initialize the dialog property */
323 fodInfos->DlgInfos.dwDlgProp = 0;
324 fodInfos->DlgInfos.hwndCustomDlg = (HWND)NULL;
325
326 switch(iDlgType)
327 {
328 case OPEN_DIALOG :
329 ret = GetFileName95(fodInfos);
330 break;
331 case SAVE_DIALOG :
332 fodInfos->DlgInfos.dwDlgProp |= FODPROP_SAVEDLG;
333 ret = GetFileName95(fodInfos);
334 break;
335 default :
336 ret = 0;
337 }
338
339 if (lpstrSavDir)
340 {
341 SetCurrentDirectoryA(lpstrSavDir);
342 MemFree(lpstrSavDir);
343 }
344
345 if (lpstrInitialDir != (LPCSTR)-1)
346 {
347 MemFree((LPVOID)(ofn->lpstrInitialDir));
348 ofn->lpstrInitialDir = lpstrInitialDir;
349 }
350
351 ofn->Flags = dwFlags;
352 ofn->hInstance = hInstance;
353 MemFree((LPVOID)(fodInfos));
354 return ret;
355 }
356
357 /***********************************************************************
358 * GetFileDialog95W
359 *
360 * Copy the OPENFILENAMEW structure in a FileOpenDlgInfos structure.
361 * Call GetFileName95 with this structure and clean the memory.
362 *
363 * FIXME: lpstrCustomFilter has to converted back
364 *
365 */
366
367 /* converting IN arguments */
368 #define AllocInArgWtoA(arg, save) \
369 if(arg) \
370 { \
371 DWORD _len = WideCharToMultiByte( CP_ACP, 0, arg, -1, NULL, 0, NULL, NULL ); \
372 save = arg; \
373 arg = MemAlloc(_len); \
374 WideCharToMultiByte( CP_ACP, 0, save, -1, (LPSTR)arg, _len, NULL, NULL ); \
375 }
376
377 #define FreeInArg(arg, save) \
378 if(arg) \
379 { \
380 MemFree((LPSTR)arg); \
381 arg = save; \
382 }
383
384 /* converting OUT arguments */
385 #define AllocOutArgWtoA(arg, save, len) \
386 if(arg) \
387 { \
388 save = arg; \
389 arg = MemAlloc(len); \
390 }
391
392 #define FreeOutArg(arg, save, len) \
393 if(arg) \
394 { \
395 MultiByteToWideChar( CP_ACP, 0, (LPCSTR)(arg), -1, (save), (len) ); \
396 MemFree(arg); \
397 arg = save; \
398 }
399
400 BOOL WINAPI GetFileDialog95W(LPOPENFILENAMEW ofn,UINT iDlgType)
401 {
402 BOOL ret;
403 FileOpenDlgInfos *fodInfos;
404 HINSTANCE hInstance;
405
406 /* out arguments */
407 LPWSTR lpstrFile = NULL;
408 LPWSTR lpstrFileTitle = NULL;
409
410 /* in/out arguments */
411 LPWSTR lpstrCustomFilter = NULL;
412
413 /* input arguments */
414 LPCWSTR lpstrFilter = NULL;
415 LPCWSTR lpstrInitialDir = NULL;
416 LPCWSTR lpstrTitle = NULL;
417 LPCWSTR lpstrDefExt = NULL;
418 LPCWSTR lpTemplateName = NULL;
419 DWORD dwFlags;
420
421 /* Initialize FileOpenDlgInfos structure */
422 fodInfos = (FileOpenDlgInfos*)MemAlloc(sizeof(FileOpenDlgInfos));
423 ZeroMemory(fodInfos, sizeof(FileOpenDlgInfos));
424
425 /* Pass in the original ofn */
426 fodInfos->ofnInfos = (LPOPENFILENAMEA) ofn;
427
428 /* convert lpstrFilter */
429 if (ofn->lpstrFilter)
430 {
431 LPCWSTR s;
432 LPSTR y;
433 int n, len;
434
435 lpstrFilter = ofn->lpstrFilter;
436
437 /* filter is a list... title\0ext\0......\0\0 */
438 s = ofn->lpstrFilter;
439
440 while (*s) s = s+strlenW(s)+1;
441 s++;
442 n = s - ofn->lpstrFilter; /* already divides by 2. ptr magic */
443 len = WideCharToMultiByte( CP_ACP, 0, ofn->lpstrFilter, n, NULL, 0, NULL, NULL );
444 y = (LPSTR)MemAlloc(len);
445 WideCharToMultiByte( CP_ACP, 0, ofn->lpstrFilter, n, y, len, NULL, NULL );
446 (LPSTR)ofn->lpstrFilter = y;
447 }
448
449 /* convert lpstrCustomFilter */
450 if (ofn->lpstrCustomFilter)
451 {
452 LPWSTR s;
453 LPSTR y;
454 int n, len;
455
456 lpstrCustomFilter = ofn->lpstrCustomFilter;
457 /* filter is a list... title\0ext\0......\0\0 */
458 s = ofn->lpstrCustomFilter;
459 while (*s) s = s+strlenW(s)+1;
460 s++;
461 n = s - ofn->lpstrCustomFilter;
462 len = WideCharToMultiByte( CP_ACP, 0, ofn->lpstrCustomFilter, n, NULL, 0, NULL, NULL );
463 y = (LPSTR)MemAlloc(len);
464 WideCharToMultiByte( CP_ACP, 0, ofn->lpstrCustomFilter, n, y, len, NULL, NULL );
465 (LPSTR)ofn->lpstrCustomFilter = y;
466 }
467
468 /* convert string arguments, save others */
469 AllocOutArgWtoA(ofn->lpstrFile, lpstrFile, ofn->nMaxFile);
470 AllocOutArgWtoA(ofn->lpstrFileTitle, lpstrFileTitle, ofn->nMaxFileTitle);
471 AllocInArgWtoA(ofn->lpstrInitialDir, lpstrInitialDir);
472 AllocInArgWtoA(ofn->lpstrTitle, lpstrTitle);
473 AllocInArgWtoA(ofn->lpstrDefExt, lpstrDefExt);
474 AllocInArgWtoA(ofn->lpTemplateName, lpTemplateName);
475 dwFlags = ofn->Flags;
476 hInstance = ofn->hInstance;
477
478 ofn->Flags = ofn->Flags|OFN_WINE|OFN_UNICODE;
479 ofn->hInstance = MapHModuleLS(ofn->hInstance);
480
481 switch(iDlgType)
482 {
483 case OPEN_DIALOG :
484 ret = GetFileName95(fodInfos);
485 break;
486 case SAVE_DIALOG :
487 fodInfos->DlgInfos.dwDlgProp |= FODPROP_SAVEDLG;
488 ret = GetFileName95(fodInfos);
489 break;
490 default :
491 ret = 0;
492 }
493
494 /* restore saved IN arguments and convert OUT arguments back */
495 ofn->Flags = dwFlags;
496 ofn->hInstance = hInstance;
497 FreeInArg(ofn->lpstrFilter, lpstrFilter);
498 FreeInArg(ofn->lpstrCustomFilter, lpstrCustomFilter);
499 FreeOutArg(ofn->lpstrFile, lpstrFile, ofn->nMaxFile);
500 FreeOutArg(ofn->lpstrFileTitle, lpstrFileTitle, ofn->nMaxFileTitle);
501 FreeInArg(ofn->lpstrInitialDir, lpstrInitialDir);
502 FreeInArg(ofn->lpstrTitle, lpstrTitle);
503 FreeInArg(ofn->lpstrDefExt, lpstrDefExt);
504 FreeInArg(ofn->lpTemplateName, lpTemplateName);
505
506 MemFree((LPVOID)(fodInfos));
507 return ret;
508 }
509
510 void ArrangeCtrlPositions( HWND hwndChildDlg, HWND hwndParentDlg)
511 {
512 HWND hwndChild,hwndStc32;
513 RECT rectParent, rectChild, rectCtrl, rectStc32, rectTemp;
514 POINT ptMoveCtl;
515 POINT ptParentClient;
516
517 TRACE("\n");
518
519 ptMoveCtl.x = ptMoveCtl.y = 0;
520 hwndStc32=GetDlgItem(hwndChildDlg,stc32);
521 GetClientRect(hwndParentDlg,&rectParent);
522 GetClientRect(hwndChildDlg,&rectChild);
523
524 if(hwndStc32)
525 {
526 GetWindowRect(hwndStc32,&rectStc32);
527 MapWindowPoints(0, hwndChildDlg,(LPPOINT)&rectStc32,2);
528 CopyRect(&rectTemp,&rectStc32);
529
530 SetRect(&rectStc32,rectStc32.left,rectStc32.top,rectStc32.left + (rectParent.right-rectParent.left),rectStc32.top+(rectParent.bottom-rectParent.top));
531 SetWindowPos(hwndStc32,0,rectStc32.left,rectStc32.top,rectStc32.right-rectStc32.left,rectStc32.bottom-rectStc32.top,SWP_NOMOVE|SWP_NOZORDER | SWP_NOACTIVATE);
532
533 if(rectStc32.right < rectTemp.right)
534 {
535 ptParentClient.x = max((rectParent.right-rectParent.left),(rectChild.right-rectChild.left));
536 ptMoveCtl.x = 0;
537 }
538 else
539 {
540 ptMoveCtl.x = (rectStc32.right - rectTemp.right);
541 ptParentClient.x = max((rectParent.right-rectParent.left),((rectChild.right-rectChild.left)+rectStc32.right-rectTemp.right));
542 }
543
544 if(rectStc32.bottom < rectTemp.bottom)
545 {
546 ptParentClient.y = max((rectParent.bottom-rectParent.top),(rectChild.bottom-rectChild.top));
547 ptMoveCtl.y = 0;
548 }
549 else
550 {
551 ptMoveCtl.y = (rectStc32.bottom - rectTemp.bottom);
552 ptParentClient.y = max((rectParent.bottom-rectParent.top),((rectChild.bottom-rectChild.top)+rectStc32.bottom-rectTemp.bottom));
553 }
554 }
555 else
556 {
557 if( (GetWindow(hwndChildDlg,GW_CHILD)) == (HWND) NULL) return;
558
559 SetRectEmpty(&rectTemp);
560 ptParentClient.x = max((rectParent.right-rectParent.left),(rectChild.right-rectChild.left));
561 ptParentClient.y = (rectParent.bottom-rectParent.top) + (rectChild.bottom-rectChild.top);
562 ptMoveCtl.y = rectParent.bottom-rectParent.top;
563 ptMoveCtl.x=0;
564 }
565 SetRect(&rectParent,rectParent.left,rectParent.top,rectParent.left+ptParentClient.x,rectParent.top+ptParentClient.y);
566 AdjustWindowRectEx( &rectParent,GetWindowLongA(hwndParentDlg,GWL_STYLE),FALSE,GetWindowLongA(hwndParentDlg,GWL_EXSTYLE));
567
568 SetWindowPos(hwndChildDlg, 0, 0,0, ptParentClient.x,ptParentClient.y, SWP_NOZORDER );
569 SetWindowPos(hwndParentDlg, 0, rectParent.left,rectParent.top, (rectParent.right- rectParent.left),
570 (rectParent.bottom-rectParent.top),SWP_NOMOVE | SWP_NOZORDER);
571
572 hwndChild = GetWindow(hwndChildDlg,GW_CHILD);
573 if(hwndStc32)
574 {
575 GetWindowRect(hwndStc32,&rectStc32);
576 MapWindowPoints( 0, hwndChildDlg,(LPPOINT)&rectStc32,2);
577 }
578 else
579 SetRect(&rectStc32,0,0,0,0);
580
581 if (hwndChild )
582 {
583 do
584 {
585 if(hwndChild != hwndStc32)
586 {
587 if (GetWindowLongA( hwndChild, GWL_STYLE ) & WS_MAXIMIZE)
588 continue;
589 GetWindowRect(hwndChild,&rectCtrl);
590 MapWindowPoints( 0, hwndParentDlg,(LPPOINT)&rectCtrl,2);
591
592 /*
593 Check the initial position of the controls relative to the initial
594 position and size of stc32 (before it is expanded).
595 */
596 if (rectCtrl.left >= rectTemp.right && rectCtrl.top >= rectTemp.bottom)
597 {
598 rectCtrl.left += ptMoveCtl.x;
599 rectCtrl.top += ptMoveCtl.y;
600 }
601 else if (rectCtrl.left >= rectTemp.right)
602 {
603 rectCtrl.left += ptMoveCtl.x;
604 }
605 else if (rectCtrl.top >= rectTemp.bottom)
606 {
607 rectCtrl.top += ptMoveCtl.y;
608 }
609
610 SetWindowPos( hwndChild, 0, rectCtrl.left, rectCtrl.top,
611 rectCtrl.right-rectCtrl.left,rectCtrl.bottom-rectCtrl.top,
612 SWP_NOSIZE | SWP_NOZORDER );
613 }
614 } while ((hwndChild=GetWindow( hwndChild, GW_HWNDNEXT )) != (HWND)NULL);
615 }
616 hwndChild = GetWindow(hwndParentDlg,GW_CHILD);
617
618 if(hwndStc32)
619 {
620 GetWindowRect(hwndStc32,&rectStc32);
621 MapWindowPoints( 0, hwndChildDlg,(LPPOINT)&rectStc32,2);
622 ptMoveCtl.x = rectStc32.left - 0;
623 ptMoveCtl.y = rectStc32.top - 0;
624 if (hwndChild )
625 {
626 do
627 {
628 if(hwndChild != hwndChildDlg)
629 {
630 if (GetWindowLongA( hwndChild, GWL_STYLE ) & WS_MAXIMIZE)
631 continue;
632 GetWindowRect(hwndChild,&rectCtrl);
633 MapWindowPoints( 0, hwndParentDlg,(LPPOINT)&rectCtrl,2);
634
635 rectCtrl.left += ptMoveCtl.x;
636 rectCtrl.top += ptMoveCtl.y;
637
638 SetWindowPos( hwndChild, 0, rectCtrl.left, rectCtrl.top,
639 rectCtrl.right-rectCtrl.left,rectCtrl.bottom-rectCtrl.top,
640 SWP_NOSIZE |SWP_NOZORDER );
641 }
642 } while ((hwndChild=GetWindow( hwndChild, GW_HWNDNEXT )) != (HWND)NULL);
643 }
644 }
645 }
646
647
648 HRESULT WINAPI FileOpenDlgProcUserTemplate(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
649 {
650 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(GetParent(hwnd),FileOpenDlgInfosStr);
651
652 #if 0
653 TRACE("0x%04x\n", uMsg);
654 #endif
655
656 switch(uMsg)
657 {
658 case WM_INITDIALOG:
659 {
660 /* Hide caption since some program may leave it */
661 DWORD Style = GetWindowLongA(hwnd, GWL_STYLE);
662 if (Style & WS_CAPTION) SetWindowLongA(hwnd, GWL_STYLE, Style & (~WS_CAPTION));
663
664 fodInfos = (FileOpenDlgInfos *)lParam;
665 lParam = (LPARAM) fodInfos->ofnInfos;
666 ArrangeCtrlPositions(hwnd,GetParent(hwnd));
667
668 if(fodInfos && IsHooked(fodInfos))
669 return CallWindowProcA((WNDPROC)fodInfos->ofnInfos->lpfnHook,hwnd,uMsg,wParam,lParam);
670 return 0;
671 }
672 }
673
674 if(fodInfos && IsHooked(fodInfos))
675 return CallWindowProcA((WNDPROC)fodInfos->ofnInfos->lpfnHook,hwnd,uMsg,wParam,lParam);
676
677 return DefWindowProcA(hwnd,uMsg,wParam,lParam);
678 }
679
680 HWND CreateTemplateDialog(FileOpenDlgInfos *fodInfos, HWND hwnd)
681 {
682 LPCVOID template;
683 HRSRC hRes;
684 HANDLE hDlgTmpl = 0;
685 HWND hChildDlg = 0;
686
687 TRACE("\n");
688
689 if (fodInfos->ofnInfos->Flags & OFN_ENABLETEMPLATE ||
690 fodInfos->ofnInfos->Flags & OFN_ENABLETEMPLATEHANDLE)
691 {
692 if (fodInfos->ofnInfos->Flags & OFN_ENABLETEMPLATEHANDLE)
693 {
694 if( !(template = LockResource( fodInfos->ofnInfos->hInstance)))
695 {
696 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
697 return (HWND)NULL;
698 }
699 }
700 else
701 {
702 if (!(hRes = FindResourceA(MapHModuleSL(fodInfos->ofnInfos->hInstance),
703 (fodInfos->ofnInfos->lpTemplateName), RT_DIALOGA)))
704 {
705 COMDLG32_SetCommDlgExtendedError(CDERR_FINDRESFAILURE);
706 return (HWND)NULL;
707 }
708 if (!(hDlgTmpl = LoadResource( MapHModuleSL(fodInfos->ofnInfos->hInstance),
709 hRes )) || !(template = LockResource( hDlgTmpl )))
710 {
711 COMDLG32_SetCommDlgExtendedError(CDERR_LOADRESFAILURE);
712 return (HWND)NULL;
713 }
714 }
715
716 hChildDlg= CreateDialogIndirectParamA(fodInfos->ofnInfos->hInstance,template,hwnd,(DLGPROC)FileOpenDlgProcUserTemplate,(LPARAM)fodInfos);
717 if(hChildDlg)
718 {
719 ShowWindow(hChildDlg,SW_SHOW);
720 return hChildDlg;
721 }
722 }
723 else if( IsHooked(fodInfos))
724 {
725 RECT rectHwnd;
726 struct {
727 DLGTEMPLATE tmplate;
728 WORD menu,class,title;
729 } temp;
730 GetClientRect(hwnd,&rectHwnd);
731 temp.tmplate.style = WS_CHILD | WS_CLIPSIBLINGS;
732 temp.tmplate.dwExtendedStyle = 0;
733 temp.tmplate.cdit = 0;
734 temp.tmplate.x = 0;
735 temp.tmplate.y = 0;
736 temp.tmplate.cx = rectHwnd.right-rectHwnd.left;
737 temp.tmplate.cy = rectHwnd.bottom-rectHwnd.top;
738 temp.menu = temp.class = temp.title = 0;
739 hChildDlg = CreateDialogIndirectParamA(fodInfos->ofnInfos->hInstance,&temp,
740 hwnd,(DLGPROC)FileOpenDlgProcUserTemplate,(LPARAM)fodInfos);
741 return hChildDlg;
742 }
743 return (HWND)NULL;
744 }
745
746 /***********************************************************************
747 * SendCustomDlgNotificationMessage
748 *
749 * Send CustomDialogNotification (CDN_FIRST -- CDN_LAST) message to the custom template dialog
750 */
751
752 HRESULT SendCustomDlgNotificationMessage(HWND hwndParentDlg, UINT uCode)
753 {
754 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwndParentDlg,FileOpenDlgInfosStr);
755
756 TRACE("0x%04x 0x%04x\n",hwndParentDlg, uCode);
757
758 if(!fodInfos) return 0;
759
760 if(fodInfos->ofnInfos->Flags & OFN_UNICODE)
761 FIXME("sending OPENFILENAMEA structure. Hook is expecting OPENFILENAMEW!\n");
762
763 if(fodInfos->DlgInfos.hwndCustomDlg)
764 {
765 OFNOTIFYA ofnNotify;
766 HRESULT ret;
767 ofnNotify.hdr.hwndFrom=hwndParentDlg;
768 ofnNotify.hdr.idFrom=0;
769 ofnNotify.hdr.code = uCode;
770 ofnNotify.lpOFN = fodInfos->ofnInfos;
771 TRACE("CALL NOTIFY for %x\n", uCode);
772 ret = SendMessageA(fodInfos->DlgInfos.hwndCustomDlg,WM_NOTIFY,0,(LPARAM)&ofnNotify);
773 TRACE("RET NOTIFY\n");
774 return ret;
775 }
776 return TRUE;
777 }
778
779 /***********************************************************************
780 * FILEDLG95_HandleCustomDialogMessages
781 *
782 * Handle Custom Dialog Messages (CDM_FIRST -- CDM_LAST) messages
783 */
784 HRESULT FILEDLG95_HandleCustomDialogMessages(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
785 {
786 LPSTR lpstrFileSpec;
787 int reqSize;
788 char lpstrPath[MAX_PATH];
789 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
790 if(!fodInfos) return -1;
791
792 switch(uMsg)
793 {
794 case CDM_GETFILEPATH:
795 GetDlgItemTextA(hwnd,IDC_FILENAME,lpstrPath, sizeof(lpstrPath));
796 lpstrFileSpec = (LPSTR)PathFindFileNameA(lpstrPath);
797 if (lpstrFileSpec==lpstrPath)
798 {
799 char lpstrCurrentDir[MAX_PATH];
800 /* Prepend the current path */
801 SHGetPathFromIDListA(fodInfos->ShellInfos.pidlAbsCurrent,lpstrCurrentDir);
802 if ((LPSTR)lParam!=NULL)
803 snprintf((LPSTR)lParam,(int)wParam,"%s\\%s",lpstrCurrentDir,lpstrPath);
804 reqSize=strlen(lpstrCurrentDir)+1+strlen(lpstrPath)+1;
805 }
806 else
807 {
808 lstrcpynA((LPSTR)lParam,(LPSTR)lpstrPath,(int)wParam);
809 reqSize=strlen(lpstrPath);
810 }
811 /* return the required buffer size */
812 return reqSize;
813
814 case CDM_GETFOLDERPATH:
815 SHGetPathFromIDListA(fodInfos->ShellInfos.pidlAbsCurrent,lpstrPath);
816 if ((LPSTR)lParam!=NULL)
817 lstrcpynA((LPSTR)lParam,lpstrPath,(int)wParam);
818 return strlen(lpstrPath);
819
820 case CDM_GETSPEC:
821 reqSize=GetDlgItemTextA(hwnd,IDC_FILENAME,lpstrPath, sizeof(lpstrPath));
822 lpstrFileSpec = (LPSTR)PathFindFileNameA(lpstrPath);
823 if ((LPSTR)lParam!=NULL)
824 lstrcpynA((LPSTR)lParam, lpstrFileSpec, (int)wParam);
825 return strlen(lpstrFileSpec);
826
827 case CDM_SETCONTROLTEXT:
828 if ( 0 != lParam )
829 SetDlgItemTextA( hwnd, (UINT) wParam, (LPSTR) lParam );
830 return TRUE;
831
832 case CDM_HIDECONTROL:
833 case CDM_SETDEFEXT:
834 FIXME("CDM_HIDECONTROL,CDM_SETCONTROLTEXT,CDM_SETDEFEXT not implemented\n");
835 return -1;
836 }
837 return TRUE;
838 }
839
840 /***********************************************************************
841 * FileOpenDlgProc95
842 *
843 * File open dialog procedure
844 */
845 HRESULT WINAPI FileOpenDlgProc95(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
846 {
847 #if 0
848 TRACE("0x%04x 0x%04x\n", hwnd, uMsg);
849 #endif
850
851 switch(uMsg)
852 {
853 case WM_INITDIALOG:
854 {
855 FileOpenDlgInfos * fodInfos = (FileOpenDlgInfos *)lParam;
856
857 /* Adds the FileOpenDlgInfos in the property list of the dialog
858 so it will be easily accessible through a GetPropA(...) */
859 SetPropA(hwnd, FileOpenDlgInfosStr, (HANDLE) fodInfos);
860
861 fodInfos->DlgInfos.hwndCustomDlg =
862 CreateTemplateDialog((FileOpenDlgInfos *)lParam, hwnd);
863
864 FILEDLG95_InitControls(hwnd);
865 SendCustomDlgNotificationMessage(hwnd,CDN_INITDONE);
866 FILEDLG95_FillControls(hwnd, wParam, lParam);
867 SendCustomDlgNotificationMessage(hwnd,CDN_SELCHANGE);
868 SetWindowPos(fodInfos->DlgInfos.hwndCustomDlg, HWND_BOTTOM,
869 0,0,0,0, SWP_NOMOVE|SWP_NOSIZE);
870 return 0;
871 }
872 case WM_COMMAND:
873 return FILEDLG95_OnWMCommand(hwnd, wParam, lParam);
874 case WM_DRAWITEM:
875 {
876 switch(((LPDRAWITEMSTRUCT)lParam)->CtlID)
877 {
878 case IDC_LOOKIN:
879 FILEDLG95_LOOKIN_DrawItem((LPDRAWITEMSTRUCT) lParam);
880 return TRUE;
881 }
882 }
883 return FALSE;
884
885 case WM_GETISHELLBROWSER:
886 return FILEDLG95_OnWMGetIShellBrowser(hwnd);
887
888 case WM_DESTROY:
889 RemovePropA(hwnd, FileOpenDlgInfosStr);
890 return FALSE;
891
892 case WM_NOTIFY:
893 {
894 LPNMHDR lpnmh = (LPNMHDR)lParam;
895 UINT stringId = -1;
896
897 /* set up the button tooltips strings */
898 if(TTN_GETDISPINFOA == lpnmh->code )
899 {
900 LPNMTTDISPINFOA lpdi = (LPNMTTDISPINFOA)lParam;
901 switch(lpnmh->idFrom )
902 {
903 /* Up folder button */
904 case FCIDM_TB_UPFOLDER:
905 stringId = IDS_UPFOLDER;
906 break;
907 /* New folder button */
908 case FCIDM_TB_NEWFOLDER:
909 stringId = IDS_NEWFOLDER;
910 break;
911 /* List option button */
912 case FCIDM_TB_SMALLICON:
913 stringId = IDS_LISTVIEW;
914 break;
915 /* Details option button */
916 case FCIDM_TB_REPORTVIEW:
917 stringId = IDS_REPORTVIEW;
918 break;
919 /* Desktop button */
920 case FCIDM_TB_DESKTOP:
921 stringId = IDS_TODESKTOP;
922 break;
923 default:
924 stringId = 0;
925 }
926 lpdi->hinst = COMMDLG_hInstance32;
927 lpdi->lpszText = (LPSTR) stringId;
928 }
929 return FALSE;
930 }
931 default :
932 if(uMsg >= CDM_FIRST && uMsg <= CDM_LAST)
933 return FILEDLG95_HandleCustomDialogMessages(hwnd, uMsg, wParam, lParam);
934 return FALSE;
935 }
936 }
937
938 /***********************************************************************
939 * FILEDLG95_InitControls
940 *
941 * WM_INITDIALOG message handler (before hook notification)
942 */
943 static LRESULT FILEDLG95_InitControls(HWND hwnd)
944 {
945 TBBUTTON tbb[] =
946 {
947 {0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0, 0}, 0, 0 },
948 {VIEW_PARENTFOLDER, FCIDM_TB_UPFOLDER, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
949 {0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0, 0}, 0, 0 },
950 {VIEW_NEWFOLDER+1, FCIDM_TB_DESKTOP, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
951 {0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0, 0}, 0, 0 },
952 {VIEW_NEWFOLDER, FCIDM_TB_NEWFOLDER, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
953 {0, 0, TBSTATE_ENABLED, TBSTYLE_SEP, {0, 0}, 0, 0 },
954 {VIEW_LIST, FCIDM_TB_SMALLICON, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
955 {VIEW_DETAILS, FCIDM_TB_REPORTVIEW, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0, 0}, 0, 0 },
956 };
957 TBADDBITMAP tba[] =
958 {
959 { HINST_COMMCTRL, IDB_VIEW_SMALL_COLOR },
960 { COMDLG32_hInstance, 800 } /* desktop icon */
961 };
962
963 RECT rectTB;
964
965 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
966
967 TRACE("%p\n", fodInfos);
968
969 /* Get the hwnd of the controls */
970 fodInfos->DlgInfos.hwndFileName = GetDlgItem(hwnd,IDC_FILENAME);
971 fodInfos->DlgInfos.hwndFileTypeCB = GetDlgItem(hwnd,IDC_FILETYPE);
972 fodInfos->DlgInfos.hwndLookInCB = GetDlgItem(hwnd,IDC_LOOKIN);
973
974 /* construct the toolbar */
975 GetWindowRect(GetDlgItem(hwnd,IDC_TOOLBARSTATIC),&rectTB);
976 MapWindowPoints( 0, hwnd,(LPPOINT)&rectTB,2);
977
978 fodInfos->DlgInfos.hwndTB = CreateWindowExA(0, TOOLBARCLASSNAMEA, (LPSTR) NULL,
979 WS_CHILD | WS_GROUP | TBSTYLE_TOOLTIPS | CCS_NODIVIDER | CCS_NORESIZE,
980 0, 0, 150, 26, hwnd, (HMENU) IDC_TOOLBAR, COMMDLG_hInstance32, NULL);
981
982 SetWindowPos(fodInfos->DlgInfos.hwndTB, 0,
983 rectTB.left,rectTB.top, rectTB.right-rectTB.left, rectTB.bottom-rectTB.top,
984 SWP_SHOWWINDOW | SWP_NOACTIVATE | SWP_NOZORDER );
985
986 SendMessageA(fodInfos->DlgInfos.hwndTB, TB_BUTTONSTRUCTSIZE, (WPARAM) sizeof(TBBUTTON), 0);
987
988 /* FIXME: use TB_LOADIMAGES when implemented */
989 /* SendMessageA(fodInfos->DlgInfos.hwndTB, TB_LOADIMAGES, (WPARAM) IDB_VIEW_SMALL_COLOR, HINST_COMMCTRL);*/
990 SendMessageA(fodInfos->DlgInfos.hwndTB, TB_ADDBITMAP, (WPARAM) 12, (LPARAM) &tba[0]);
991 SendMessageA(fodInfos->DlgInfos.hwndTB, TB_ADDBITMAP, (WPARAM) 1, (LPARAM) &tba[1]);
992
993 SendMessageA(fodInfos->DlgInfos.hwndTB, TB_ADDBUTTONSA, (WPARAM) 9,(LPARAM) &tbb);
994 SendMessageA(fodInfos->DlgInfos.hwndTB, TB_AUTOSIZE, 0, 0);
995
996 /* Set the window text with the text specified in the OPENFILENAME structure */
997 if(fodInfos->ofnInfos->lpstrTitle)
998 {
999 SetWindowTextA(hwnd,fodInfos->ofnInfos->lpstrTitle);
1000 }
1001 else if (fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG)
1002 {
1003 SetWindowTextA(hwnd,"Save");
1004 }
1005
1006 /* Initialise the file name edit control */
1007 if(fodInfos->ofnInfos->lpstrFile)
1008 {
1009 LPSTR lpstrFile = PathFindFileNameA(fodInfos->ofnInfos->lpstrFile);
1010 SetDlgItemTextA(hwnd, IDC_FILENAME, lpstrFile);
1011 }
1012
1013 /* Must the open as read only check box be checked ?*/
1014 if(fodInfos->ofnInfos->Flags & OFN_READONLY)
1015 {
1016 SendDlgItemMessageA(hwnd,IDC_OPENREADONLY,BM_SETCHECK,(WPARAM)TRUE,0);
1017 }
1018
1019 /* Must the open as read only check box be hid ?*/
1020 if(fodInfos->ofnInfos->Flags & OFN_HIDEREADONLY)
1021 {
1022 ShowWindow(GetDlgItem(hwnd,IDC_OPENREADONLY),SW_HIDE);
1023 }
1024
1025 /* Must the help button be hid ?*/
1026 if (!(fodInfos->ofnInfos->Flags & OFN_SHOWHELP))
1027 {
1028 ShowWindow(GetDlgItem(hwnd, pshHelp), SW_HIDE);
1029 }
1030
1031 /* Resize the height, if open as read only checkbox ad help button
1032 are hidden and we are not using a custom template */
1033 if ( (fodInfos->ofnInfos->Flags & OFN_HIDEREADONLY) &&
1034 (!(fodInfos->ofnInfos->Flags &
1035 (OFN_SHOWHELP|OFN_ENABLETEMPLATE|OFN_ENABLETEMPLATEHANDLE))))
1036 {
1037 RECT rectDlg, rectHelp, rectCancel;
1038 GetWindowRect(hwnd, &rectDlg);
1039 GetWindowRect(GetDlgItem(hwnd, pshHelp), &rectHelp);
1040 GetWindowRect(GetDlgItem(hwnd, IDCANCEL), &rectCancel);
1041 /* subtract the height of the help button plus the space between
1042 the help button and the cancel button to the height of the dialog */
1043 SetWindowPos(hwnd, 0, 0, 0, rectDlg.right-rectDlg.left,
1044 (rectDlg.bottom-rectDlg.top) - (rectHelp.bottom - rectCancel.bottom),
1045 SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOZORDER);
1046 }
1047
1048 /* change Open to Save FIXME: use resources */
1049 if (fodInfos->DlgInfos.dwDlgProp & FODPROP_SAVEDLG)
1050 {
1051 SetDlgItemTextA(hwnd,IDOK,"&Save");
1052 SetDlgItemTextA(hwnd,IDC_LOOKINSTATIC,"Save &in");
1053 }
1054 return 0;
1055 }
1056
1057 /***********************************************************************
1058 * FILEDLG95_FillControls
1059 *
1060 * WM_INITDIALOG message handler (after hook notification)
1061 */
1062 static LRESULT FILEDLG95_FillControls(HWND hwnd, WPARAM wParam, LPARAM lParam)
1063 {
1064 LPITEMIDLIST pidlItemId = NULL;
1065
1066 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) lParam;
1067
1068 TRACE("dir=%s file=%s\n",
1069 fodInfos->ofnInfos->lpstrInitialDir, fodInfos->ofnInfos->lpstrFile);
1070
1071 /* Get the initial directory pidl */
1072
1073 if(!(pidlItemId = GetPidlFromName(fodInfos->Shell.FOIShellFolder,fodInfos->ofnInfos->lpstrInitialDir)))
1074 {
1075 char path[MAX_PATH];
1076
1077 GetCurrentDirectoryA(MAX_PATH,path);
1078 pidlItemId = GetPidlFromName(fodInfos->Shell.FOIShellFolder, path);
1079 }
1080
1081 /* Initialise shell objects */
1082 FILEDLG95_SHELL_Init(hwnd);
1083
1084 /* Initialize the Look In combo box */
1085 FILEDLG95_LOOKIN_Init(fodInfos->DlgInfos.hwndLookInCB);
1086
1087 /* Initialize the filter combo box */
1088 FILEDLG95_FILETYPE_Init(hwnd);
1089
1090 /* Browse to the initial directory */
1091 IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,pidlItemId, SBSP_ABSOLUTE);
1092
1093 /* Free pidlItem memory */
1094 COMDLG32_SHFree(pidlItemId);
1095
1096 return TRUE;
1097 }
1098 /***********************************************************************
1099 * FILEDLG95_Clean
1100 *
1101 * Regroups all the cleaning functions of the filedlg
1102 */
1103 void FILEDLG95_Clean(HWND hwnd)
1104 {
1105 FILEDLG95_FILETYPE_Clean(hwnd);
1106 FILEDLG95_LOOKIN_Clean(hwnd);
1107 FILEDLG95_SHELL_Clean(hwnd);
1108 }
1109 /***********************************************************************
1110 * FILEDLG95_OnWMCommand
1111 *
1112 * WM_COMMAND message handler
1113 */
1114 static LRESULT FILEDLG95_OnWMCommand(HWND hwnd, WPARAM wParam, LPARAM lParam)
1115 {
1116 WORD wNotifyCode = HIWORD(wParam); /* notification code */
1117 WORD wID = LOWORD(wParam); /* item, control, or accelerator identifier */
1118 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1119
1120 switch(wID)
1121 {
1122 /* OK button */
1123 case IDOK:
1124 FILEDLG95_OnOpen(hwnd);
1125 break;
1126 /* Cancel button */
1127 case IDCANCEL:
1128 FILEDLG95_Clean(hwnd);
1129 EndDialog(hwnd, FALSE);
1130 break;
1131 /* Filetype combo box */
1132 case IDC_FILETYPE:
1133 FILEDLG95_FILETYPE_OnCommand(hwnd,wNotifyCode);
1134 break;
1135 /* LookIn combo box */
1136 case IDC_LOOKIN:
1137 FILEDLG95_LOOKIN_OnCommand(hwnd,wNotifyCode);
1138 break;
1139
1140 /* --- toolbar --- */
1141 /* Up folder button */
1142 case FCIDM_TB_UPFOLDER:
1143 FILEDLG95_SHELL_UpFolder(hwnd);
1144 break;
1145 /* New folder button */
1146 case FCIDM_TB_NEWFOLDER:
1147 FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_NEWFOLDER);
1148 break;
1149 /* List option button */
1150 case FCIDM_TB_SMALLICON:
1151 FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_VIEWLIST);
1152 break;
1153 /* Details option button */
1154 case FCIDM_TB_REPORTVIEW:
1155 FILEDLG95_SHELL_ExecuteCommand(hwnd,CMDSTR_VIEWDETAILS);
1156 break;
1157 /* Details option button */
1158 case FCIDM_TB_DESKTOP:
1159 FILEDLG95_SHELL_BrowseToDesktop(hwnd);
1160 break;
1161
1162 case IDC_FILENAME:
1163 break;
1164
1165 }
1166 /* Do not use the listview selection anymore */
1167 fodInfos->DlgInfos.dwDlgProp &= ~FODPROP_USEVIEW;
1168 return 0;
1169 }
1170
1171 /***********************************************************************
1172 * FILEDLG95_OnWMGetIShellBrowser
1173 *
1174 * WM_GETISHELLBROWSER message handler
1175 */
1176 static LRESULT FILEDLG95_OnWMGetIShellBrowser(HWND hwnd)
1177 {
1178
1179 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1180
1181 TRACE("\n");
1182
1183 SetWindowLongA(hwnd,DWL_MSGRESULT,(LONG)fodInfos->Shell.FOIShellBrowser);
1184
1185 return TRUE;
1186 }
1187
1188
1189 /***********************************************************************
1190 * FILEDLG95_OnOpenMultipleFiles
1191 *
1192 * Handles the opening of multiple files.
1193 *
1194 * FIXME
1195 * check destination buffer size
1196 */
1197 BOOL FILEDLG95_OnOpenMultipleFiles(HWND hwnd, LPSTR lpstrFileList, UINT nFileCount, UINT sizeUsed)
1198 {
1199 CHAR lpstrPathSpec[MAX_PATH] = "";
1200 LPSTR lpstrFile;
1201 UINT nCount, nSizePath;
1202 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1203
1204 TRACE("\n");
1205
1206 lpstrFile = fodInfos->ofnInfos->lpstrFile;
1207 lpstrFile[0] = '\0';
1208
1209 SHGetPathFromIDListA( fodInfos->ShellInfos.pidlAbsCurrent, lpstrPathSpec );
1210
1211 if ( !(fodInfos->ofnInfos->Flags & OFN_NOVALIDATE) &&
1212 ( fodInfos->ofnInfos->Flags & OFN_FILEMUSTEXIST))
1213 {
1214 LPSTR lpstrTemp = lpstrFileList;
1215
1216 for ( nCount = 0; nCount < nFileCount; nCount++ )
1217 {
1218 LPITEMIDLIST pidl;
1219
1220 pidl = GetPidlFromName(fodInfos->Shell.FOIShellFolder, lpstrTemp);
1221 if (!pidl)
1222 {
1223 CHAR lpstrNotFound[100];
1224 CHAR lpstrMsg[100];
1225 CHAR tmp[400];
1226
1227 LoadStringA(COMMDLG_hInstance32, IDS_FILENOTFOUND, lpstrNotFound, 100);
1228 LoadStringA(COMMDLG_hInstance32, IDS_VERIFYFILE, lpstrMsg, 100);
1229
1230 strcpy(tmp, lpstrTemp);
1231 strcat(tmp, "\n");
1232 strcat(tmp, lpstrNotFound);
1233 strcat(tmp, "\n");
1234 strcat(tmp, lpstrMsg);
1235
1236 MessageBoxA(hwnd, tmp, fodInfos->ofnInfos->lpstrTitle, MB_OK | MB_ICONEXCLAMATION);
1237 return FALSE;
1238 }
1239
1240 /* move to the next file in the list of files */
1241 lpstrTemp += strlen(lpstrTemp) + 1;
1242 COMDLG32_SHFree(pidl);
1243 }
1244 }
1245
1246 nSizePath = strlen(lpstrPathSpec);
1247 strcpy( lpstrFile, lpstrPathSpec);
1248 memcpy( lpstrFile + nSizePath + 1, lpstrFileList, sizeUsed );
1249
1250 fodInfos->ofnInfos->nFileOffset = nSizePath + 1;
1251 fodInfos->ofnInfos->nFileExtension = 0;
1252
1253 /* clean and exit */
1254 FILEDLG95_Clean(hwnd);
1255 return EndDialog(hwnd,TRUE);
1256 }
1257
1258 /***********************************************************************
1259 * FILEDLG95_OnOpen
1260 *
1261 * Ok button WM_COMMAND message handler
1262 *
1263 * If the function succeeds, the return value is nonzero.
1264 */
1265 #define ONOPEN_BROWSE 1
1266 #define ONOPEN_OPEN 2
1267 #define ONOPEN_SEARCH 3
1268 static void FILEDLG95_OnOpenMessage(HWND hwnd, int idCaption, int idText)
1269 {
1270 char strMsgTitle[MAX_PATH];
1271 char strMsgText [MAX_PATH];
1272 if (idCaption)
1273 LoadStringA(COMDLG32_hInstance, idCaption, strMsgTitle, sizeof(strMsgTitle));
1274 else
1275 strMsgTitle[0] = '\0';
1276 LoadStringA(COMDLG32_hInstance, idText, strMsgText, sizeof(strMsgText));
1277 MessageBoxA(hwnd,strMsgText, strMsgTitle, MB_OK | MB_ICONHAND);
1278 }
1279
1280 BOOL FILEDLG95_OnOpen(HWND hwnd)
1281 {
1282 char * lpstrFileList;
1283 UINT nFileCount = 0;
1284 UINT sizeUsed = 0;
1285 BOOL ret = TRUE;
1286 char lpstrPathAndFile[MAX_PATH];
1287 char lpstrTemp[MAX_PATH];
1288 LPSHELLFOLDER lpsf = NULL;
1289 int nOpenAction;
1290 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1291
1292 TRACE("hwnd=0x%04x\n", hwnd);
1293
1294 /* get the files from the edit control */
1295 nFileCount = FILEDLG95_FILENAME_GetFileNames(hwnd, &lpstrFileList, &sizeUsed);
1296
1297 /* try if the user selected a folder in the shellview */
1298 if(nFileCount == 0)
1299 {
1300 BrowseSelectedFolder(hwnd);
1301 return FALSE;
1302 }
1303
1304 if(nFileCount > 1)
1305 {
1306 ret = FILEDLG95_OnOpenMultipleFiles(hwnd, lpstrFileList, nFileCount, sizeUsed);
1307 goto ret;
1308 }
1309
1310 TRACE("count=%u len=%u file=%s\n", nFileCount, sizeUsed, lpstrFileList);
1311
1312 /*
1313 Step 1: Build a complete path name from the current folder and
1314 the filename or path in the edit box.
1315 Special cases:
1316 - the path in the edit box is a root path
1317 (with or without drive letter)
1318 - the edit box contains ".." (or a path with ".." in it)
1319 */
1320
1321 /* Get the current directory name */
1322 if (!SHGetPathFromIDListA(fodInfos->ShellInfos.pidlAbsCurrent, lpstrPathAndFile))
1323 {
1324 /* we are in a special folder, default to desktop */
1325 if(FAILED(COMDLG32_SHGetFolderPathA(hwnd, CSIDL_DESKTOPDIRECTORY|CSIDL_FLAG_CREATE, 0, 0, lpstrPathAndFile)))
1326 {
1327 /* last fallback */
1328 GetCurrentDirectoryA(MAX_PATH, lpstrPathAndFile);
1329 }
1330 }
1331 PathAddBackslashA(lpstrPathAndFile);
1332
1333 TRACE("current directory=%s\n", lpstrPathAndFile);
1334
1335 /* if the user specifyed a fully qualified path use it */
1336 if(PathIsRelativeA(lpstrFileList))
1337 {
1338 strcat(lpstrPathAndFile, lpstrFileList);
1339 }
1340 else
1341 {
1342 /* does the path have a drive letter? */
1343 if (PathGetDriveNumberA(lpstrFileList) == -1)
1344 strcpy(lpstrPathAndFile+2, lpstrFileList);
1345 else
1346 strcpy(lpstrPathAndFile, lpstrFileList);
1347 }
1348
1349 /* resolve "." and ".." */
1350 PathCanonicalizeA(lpstrTemp, lpstrPathAndFile );
1351 strcpy(lpstrPathAndFile, lpstrTemp);
1352 TRACE("canon=%s\n", lpstrPathAndFile);
1353
1354 MemFree(lpstrFileList);
1355
1356 /*
1357 Step 2: here we have a cleaned up path
1358
1359 We have to parse the path step by step to see if we have to browse
1360 to a folder if the path points to a directory or the last
1361 valid element is a directory.
1362
1363 valid variables:
1364 lpstrPathAndFile: cleaned up path
1365 */
1366
1367 nOpenAction = ONOPEN_BROWSE;
1368
1369 /* dont apply any checks with OFN_NOVALIDATE */
1370 if(!(fodInfos->ofnInfos->Flags & OFN_NOVALIDATE))
1371 {
1372 LPSTR lpszTemp, lpszTemp1;
1373 LPITEMIDLIST pidl = NULL;
1374
1375 /* check for invalid chars */
1376 if(strpbrk(lpstrPathAndFile+3, "/:<>|") != NULL)
1377 {
1378 FILEDLG95_OnOpenMessage(hwnd, IDS_INVALID_FILENAME_TITLE, IDS_INVALID_FILENAME);
1379 ret = FALSE;
1380 goto ret;
1381 }
1382
1383 if (FAILED (SHGetDesktopFolder(&lpsf))) return FALSE;
1384
1385 lpszTemp1 = lpszTemp = lpstrPathAndFile;
1386 while (lpszTemp1)
1387 {
1388 LPSHELLFOLDER lpsfChild;
1389 WCHAR lpwstrTemp[MAX_PATH];
1390 DWORD dwEaten, dwAttributes;
1391
1392 lpszTemp = PathFindNextComponentA(lpszTemp);
1393
1394 if (!lpszTemp) break; /* end of path */
1395
1396 if(*lpszTemp)
1397 {
1398 DWORD len = MultiByteToWideChar( CP_ACP, 0, lpszTemp1, lpszTemp - lpszTemp1,
1399 lpwstrTemp, MAX_PATH );
1400 lpwstrTemp[len] = 0;
1401 }
1402 else
1403 {
1404 MultiByteToWideChar( CP_ACP, 0, lpszTemp1, -1,
1405 lpwstrTemp, sizeof(lpwstrTemp)/sizeof(WCHAR) );
1406
1407 /* if the last element is a wildcard do a search */
1408 if(strpbrk(lpszTemp1, "*?") != NULL)
1409 {
1410 nOpenAction = ONOPEN_SEARCH;
1411 break;
1412 }
1413 }
1414 lpszTemp1 = lpszTemp;
1415
1416 TRACE("parse now=%s next=%s sf=%p\n",debugstr_w(lpwstrTemp), debugstr_a(lpszTemp), lpsf);
1417
1418 if(lstrlenW(lpwstrTemp)==2) PathAddBackslashW(lpwstrTemp);
1419
1420 dwAttributes = SFGAO_FOLDER;
1421 if(SUCCEEDED(IShellFolder_ParseDisplayName(lpsf, hwnd, NULL, lpwstrTemp, &dwEaten, &pidl, &dwAttributes)))
1422 {
1423 /* the path component is valid, we have a pidl of the next path component */
1424 TRACE("parse OK attr=0x%08lx pidl=%p\n", dwAttributes, pidl);
1425 if(dwAttributes & SFGAO_FOLDER)
1426 {
1427 if(FAILED(IShellFolder_BindToObject(lpsf, pidl, 0, &IID_IShellFolder, (LPVOID*)&lpsfChild)))
1428 {
1429 ERR("bind to failed\n"); /* should not fail */
1430 break;
1431 }
1432 IShellFolder_Release(lpsf);
1433 lpsf = lpsfChild;
1434 lpsfChild = NULL;
1435 }
1436 else
1437 {
1438 TRACE("value\n");
1439
1440 /* end dialog, return value */
1441 nOpenAction = ONOPEN_OPEN;
1442 break;
1443 }
1444 COMDLG32_SHFree(pidl);
1445 pidl = NULL;
1446 }
1447 else
1448 {
1449 if(*lpszTemp) /* points to trailing null for last path element */
1450 {
1451 if(fodInfos->ofnInfos->Flags & OFN_PATHMUSTEXIST)
1452 {
1453 FILEDLG95_OnOpenMessage(hwnd, 0, IDS_PATHNOTEXISTING);
1454 break;
1455 }
1456 }
1457 else
1458 {
1459 if(fodInfos->ofnInfos->Flags & OFN_FILEMUSTEXIST)
1460 {
1461 FILEDLG95_OnOpenMessage(hwnd, 0, IDS_FILENOTEXISTING);
1462 break;
1463 }
1464 }
1465 /* change to the current folder */
1466 nOpenAction = ONOPEN_OPEN;
1467 break;
1468 }
1469 }
1470 if(pidl) COMDLG32_SHFree(pidl);
1471 }
1472
1473 /*
1474 Step 3: here we have a cleaned up and validated path
1475
1476 valid variables:
1477 lpsf: ShellFolder bound to the rightmost valid path component
1478 lpstrPathAndFile: cleaned up path
1479 nOpenAction: action to do
1480 */
1481 TRACE("end validate sf=%p\n", lpsf);
1482
1483 switch(nOpenAction)
1484 {
1485 case ONOPEN_SEARCH: /* set the current filter to the file mask and refresh */
1486 TRACE("ONOPEN_SEARCH %s\n", lpstrPathAndFile);
1487 {
1488 int iPos;
1489 LPSTR lpszTemp = PathFindFileNameA(lpstrPathAndFile);
1490 DWORD len;
1491
1492 /* replace the current filter */
1493 if(fodInfos->ShellInfos.lpstrCurrentFilter)
1494 MemFree((LPVOID)fodInfos->ShellInfos.lpstrCurrentFilter);
1495 len = MultiByteToWideChar( CP_ACP, 0, lpszTemp, -1, NULL, 0 );
1496 fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc(len * sizeof(WCHAR));
1497 MultiByteToWideChar( CP_ACP, 0, lpszTemp, -1,
1498 fodInfos->ShellInfos.lpstrCurrentFilter, len );
1499
1500 /* set the filter cb to the extension when possible */
1501 if(-1 < (iPos = FILEDLG95_FILETYPE_SearchExt(fodInfos->DlgInfos.hwndFileTypeCB, lpszTemp)))
1502 CBSetCurSel(fodInfos->DlgInfos.hwndFileTypeCB, iPos);
1503 }
1504 /* fall through */
1505 case ONOPEN_BROWSE: /* browse to the highest folder we could bind to */
1506 TRACE("ONOPEN_BROWSE\n");
1507 {
1508 IPersistFolder2 * ppf2;
1509 if(SUCCEEDED(IShellFolder_QueryInterface( lpsf, &IID_IPersistFolder2, (LPVOID*)&ppf2)))
1510 {
1511 LPITEMIDLIST pidlCurrent;
1512 IPersistFolder2_GetCurFolder(ppf2, &pidlCurrent);
1513 IPersistFolder2_Release(ppf2);
1514 if( ! COMDLG32_PIDL_ILIsEqual(pidlCurrent, fodInfos->ShellInfos.pidlAbsCurrent))
1515 {
1516 IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser, pidlCurrent, SBSP_ABSOLUTE);
1517 }
1518 else if( nOpenAction == ONOPEN_SEARCH )
1519 {
1520 IShellView_Refresh(fodInfos->Shell.FOIShellView);
1521 }
1522 COMDLG32_SHFree(pidlCurrent);
1523 }
1524 }
1525 ret = FALSE;
1526 break;
1527 case ONOPEN_OPEN: /* fill in the return struct and close the dialog */
1528 TRACE("ONOPEN_OPEN %s\n", lpstrPathAndFile);
1529 {
1530 /* add default extension */
1531 if (fodInfos->ofnInfos->lpstrDefExt)
1532 {
1533 if (! *PathFindExtensionA(lpstrPathAndFile))
1534 {
1535 /* only add "." in case a default extension does exist */
1536 if (*fodInfos->ofnInfos->lpstrDefExt != '\0')
1537 {
1538 int PathLength;
1539 PathLength = strlen(lpstrPathAndFile);
1540
1541 strcat(lpstrPathAndFile, ".");
1542 strcat(lpstrPathAndFile, fodInfos->ofnInfos->lpstrDefExt);
1543
1544 /* if file does not exist try without extension */
1545 if (!PathFileExistsA(lpstrPathAndFile))
1546 lpstrPathAndFile[PathLength] = '\0';
1547 }
1548 }
1549 }
1550
1551 /* Check that the size of the file does not exceed buffer size.
1552 (Allow for extra \0 if OFN_MULTISELECT is set.) */
1553 if(strlen(lpstrPathAndFile) < fodInfos->ofnInfos->nMaxFile -
1554 ((fodInfos->ofnInfos->Flags & OFN_ALLOWMULTISELECT) ? 1 : 0))
1555 {
1556 LPSTR lpszTemp;
1557
1558 /* fill destination buffer */
1559 strcpy(fodInfos->ofnInfos->lpstrFile, lpstrPathAndFile);
1560 if (fodInfos->ofnInfos->Flags & OFN_ALLOWMULTISELECT)
1561 fodInfos->ofnInfos->lpstrFile[strlen(fodInfos->ofnInfos->lpstrFile)
1562 + 1] = '\0';
1563
1564 /* set filename offset */
1565 lpszTemp = PathFindFileNameA(lpstrPathAndFile);
1566 fodInfos->ofnInfos->nFileOffset = lpszTemp - lpstrPathAndFile;
1567
1568 /* set extension offset */
1569 lpszTemp = PathFindExtensionA(lpstrPathAndFile);
1570 fodInfos->ofnInfos->nFileExtension = (*lpszTemp) ? lpszTemp - lpstrPathAndFile + 1 : 0;
1571
1572 /* set the lpstrFileTitle */
1573 if(fodInfos->ofnInfos->lpstrFileTitle)
1574 {
1575 LPSTR lpstrFileTitle = PathFindFileNameA(lpstrPathAndFile);
1576 strncpy(fodInfos->ofnInfos->lpstrFileTitle, lpstrFileTitle, fodInfos->ofnInfos->nMaxFileTitle);
1577 }
1578
1579 /* ask the hook if we can close */
1580 if(IsHooked(fodInfos))
1581 {
1582 TRACE("---\n");
1583 /* First send CDN_FILEOK as MSDN doc says */
1584 SendCustomDlgNotificationMessage(hwnd,CDN_FILEOK);
1585
1586 /* FIXME we are sending ASCII-structures. Does not work with NT */
1587 CallWindowProcA((WNDPROC)fodInfos->ofnInfos->lpfnHook,
1588 fodInfos->DlgInfos.hwndCustomDlg,
1589 fodInfos->HookMsg.fileokstring, 0, (LPARAM)fodInfos->ofnInfos);
1590 if (GetWindowLongA(fodInfos->DlgInfos.hwndCustomDlg, DWL_MSGRESULT))
1591 {
1592 TRACE("canceled\n");
1593 ret = FALSE;
1594 goto ret;
1595 }
1596 }
1597
1598 TRACE("close\n");
1599 FILEDLG95_Clean(hwnd);
1600 ret = EndDialog(hwnd, TRUE);
1601 }
1602 else
1603 {
1604 /* FIXME set error FNERR_BUFFERTOSMALL */
1605 FILEDLG95_Clean(hwnd);
1606 ret = EndDialog(hwnd, FALSE);
1607 }
1608 goto ret;
1609 }
1610 break;
1611 }
1612
1613 ret:
1614 if(lpsf) IShellFolder_Release(lpsf);
1615 return ret;
1616 }
1617
1618 /***********************************************************************
1619 * FILEDLG95_SHELL_Init
1620 *
1621 * Initialisation of the shell objects
1622 */
1623 static HRESULT FILEDLG95_SHELL_Init(HWND hwnd)
1624 {
1625 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1626
1627 TRACE("\n");
1628
1629 /*
1630 * Initialisation of the FileOpenDialogInfos structure
1631 */
1632
1633 /* Shell */
1634
1635 /*ShellInfos */
1636 fodInfos->ShellInfos.hwndOwner = hwnd;
1637
1638 /* Disable multi-select if flag not set */
1639 if (!(fodInfos->ofnInfos->Flags & OFN_ALLOWMULTISELECT))
1640 {
1641 fodInfos->ShellInfos.folderSettings.fFlags |= FWF_SINGLESEL;
1642 }
1643 fodInfos->ShellInfos.folderSettings.fFlags |= FWF_AUTOARRANGE | FWF_ALIGNLEFT;
1644 fodInfos->ShellInfos.folderSettings.ViewMode = FVM_LIST;
1645
1646 GetWindowRect(GetDlgItem(hwnd,IDC_SHELLSTATIC),&fodInfos->ShellInfos.rectView);
1647 ScreenToClient(hwnd,(LPPOINT)&fodInfos->ShellInfos.rectView.left);
1648 ScreenToClient(hwnd,(LPPOINT)&fodInfos->ShellInfos.rectView.right);
1649
1650 /* Construct the IShellBrowser interface */
1651 fodInfos->Shell.FOIShellBrowser = IShellBrowserImpl_Construct(hwnd);
1652
1653 return NOERROR;
1654 }
1655
1656 /***********************************************************************
1657 * FILEDLG95_SHELL_ExecuteCommand
1658 *
1659 * Change the folder option and refresh the view
1660 * If the function succeeds, the return value is nonzero.
1661 */
1662 static BOOL FILEDLG95_SHELL_ExecuteCommand(HWND hwnd, LPCSTR lpVerb)
1663 {
1664 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1665
1666 IContextMenu * pcm;
1667 TRACE("(0x%08x,%p)\n", hwnd, lpVerb);
1668
1669 if(SUCCEEDED(IShellView_GetItemObject(fodInfos->Shell.FOIShellView,
1670 SVGIO_BACKGROUND,
1671 &IID_IContextMenu,
1672 (LPVOID*)&pcm)))
1673 {
1674 CMINVOKECOMMANDINFO ci;
1675 ZeroMemory(&ci, sizeof(CMINVOKECOMMANDINFO));
1676 ci.cbSize = sizeof(CMINVOKECOMMANDINFO);
1677 ci.lpVerb = lpVerb;
1678 ci.hwnd = hwnd;
1679
1680 IContextMenu_InvokeCommand(pcm, &ci);
1681 IContextMenu_Release(pcm);
1682 }
1683
1684 return FALSE;
1685 }
1686
1687 /***********************************************************************
1688 * FILEDLG95_SHELL_UpFolder
1689 *
1690 * Browse to the specified object
1691 * If the function succeeds, the return value is nonzero.
1692 */
1693 static BOOL FILEDLG95_SHELL_UpFolder(HWND hwnd)
1694 {
1695 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1696
1697 TRACE("\n");
1698
1699 if(SUCCEEDED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
1700 NULL,
1701 SBSP_PARENT)))
1702 {
1703 return TRUE;
1704 }
1705 return FALSE;
1706 }
1707
1708 /***********************************************************************
1709 * FILEDLG95_SHELL_BrowseToDesktop
1710 *
1711 * Browse to the Desktop
1712 * If the function succeeds, the return value is nonzero.
1713 */
1714 static BOOL FILEDLG95_SHELL_BrowseToDesktop(HWND hwnd)
1715 {
1716 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1717 LPITEMIDLIST pidl;
1718 HRESULT hres;
1719
1720 TRACE("\n");
1721
1722 SHGetSpecialFolderLocation(0,CSIDL_DESKTOP,&pidl);
1723 hres = IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser, pidl, SBSP_ABSOLUTE);
1724 COMDLG32_SHFree(pidl);
1725 return SUCCEEDED(hres);
1726 }
1727 /***********************************************************************
1728 * FILEDLG95_SHELL_Clean
1729 *
1730 * Cleans the memory used by shell objects
1731 */
1732 static void FILEDLG95_SHELL_Clean(HWND hwnd)
1733 {
1734 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1735
1736 TRACE("\n");
1737
1738 COMDLG32_SHFree(fodInfos->ShellInfos.pidlAbsCurrent);
1739
1740 /* clean Shell interfaces */
1741 IShellView_DestroyViewWindow(fodInfos->Shell.FOIShellView);
1742 IShellView_Release(fodInfos->Shell.FOIShellView);
1743 IShellFolder_Release(fodInfos->Shell.FOIShellFolder);
1744 IShellBrowser_Release(fodInfos->Shell.FOIShellBrowser);
1745 if (fodInfos->Shell.FOIDataObject)
1746 IDataObject_Release(fodInfos->Shell.FOIDataObject);
1747 }
1748
1749 /***********************************************************************
1750 * FILEDLG95_FILETYPE_Init
1751 *
1752 * Initialisation of the file type combo box
1753 */
1754 static HRESULT FILEDLG95_FILETYPE_Init(HWND hwnd)
1755 {
1756 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1757
1758 TRACE("\n");
1759
1760 if(fodInfos->ofnInfos->lpstrFilter)
1761 {
1762 int nFilters = 0; /* number of filters */
1763 LPSTR lpstrFilter;
1764 LPCSTR lpstrPos = fodInfos->ofnInfos->lpstrFilter;
1765
1766 for(;;)
1767 {
1768 /* filter is a list... title\0ext\0......\0\0
1769 * Set the combo item text to the title and the item data
1770 * to the ext
1771 */
1772 LPCSTR lpstrDisplay;
1773 LPSTR lpstrExt;
1774
1775 /* Get the title */
1776 if(! *lpstrPos) break; /* end */
1777 lpstrDisplay = lpstrPos;
1778 lpstrPos += strlen(lpstrPos) + 1;
1779
1780 /* Copy the extensions */
1781 if (! *lpstrPos) return E_FAIL; /* malformed filter */
1782 if (!(lpstrExt = (LPSTR) MemAlloc(strlen(lpstrPos)+1))) return E_FAIL;
1783 strcpy(lpstrExt,lpstrPos);
1784 lpstrPos += strlen(lpstrPos) + 1;
1785
1786 /* Add the item at the end of the combo */
1787 CBAddString(fodInfos->DlgInfos.hwndFileTypeCB, lpstrDisplay);
1788 CBSetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB, nFilters, lpstrExt);
1789 nFilters++;
1790 }
1791 /*
1792 * Set the current filter to the one specified
1793 * in the initialisation structure
1794 * FIXME: lpstrCustomFilter not handled at all
1795 */
1796
1797 /* set default filter index */
1798 if(fodInfos->ofnInfos->nFilterIndex == 0 && fodInfos->ofnInfos->lpstrCustomFilter == NULL)
1799 fodInfos->ofnInfos->nFilterIndex = 1;
1800
1801 /* First, check to make sure our index isn't out of bounds. */
1802 if ( fodInfos->ofnInfos->nFilterIndex > nFilters )
1803 fodInfos->ofnInfos->nFilterIndex = nFilters;
1804
1805 /* Set the current index selection. */
1806 CBSetCurSel(fodInfos->DlgInfos.hwndFileTypeCB, fodInfos->ofnInfos->nFilterIndex-1);
1807
1808 /* Get the corresponding text string from the combo box. */
1809 lpstrFilter = (LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,
1810 fodInfos->ofnInfos->nFilterIndex-1);
1811
1812 if ((INT)lpstrFilter == CB_ERR) /* control is empty */
1813 lpstrFilter = NULL;
1814
1815 if(lpstrFilter)
1816 {
1817 DWORD len;
1818 CharLowerA(lpstrFilter); /* lowercase */
1819 len = MultiByteToWideChar( CP_ACP, 0, lpstrFilter, -1, NULL, 0 );
1820 fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc( len * sizeof(WCHAR) );
1821 MultiByteToWideChar( CP_ACP, 0, lpstrFilter, -1,
1822 fodInfos->ShellInfos.lpstrCurrentFilter, len );
1823 }
1824 }
1825 return NOERROR;
1826 }
1827
1828 /***********************************************************************
1829 * FILEDLG95_FILETYPE_OnCommand
1830 *
1831 * WM_COMMAND of the file type combo box
1832 * If the function succeeds, the return value is nonzero.
1833 */
1834 static BOOL FILEDLG95_FILETYPE_OnCommand(HWND hwnd, WORD wNotifyCode)
1835 {
1836 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1837
1838 switch(wNotifyCode)
1839 {
1840 case CBN_SELENDOK:
1841 {
1842 LPSTR lpstrFilter;
1843
1844 /* Get the current item of the filetype combo box */
1845 int iItem = CBGetCurSel(fodInfos->DlgInfos.hwndFileTypeCB);
1846
1847 /* set the current filter index - indexed from 1 */
1848 fodInfos->ofnInfos->nFilterIndex = iItem + 1;
1849
1850 /* Set the current filter with the current selection */
1851 if(fodInfos->ShellInfos.lpstrCurrentFilter)
1852 MemFree((LPVOID)fodInfos->ShellInfos.lpstrCurrentFilter);
1853
1854 lpstrFilter = (LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,
1855 iItem);
1856 if((int)lpstrFilter != CB_ERR)
1857 {
1858 DWORD len;
1859 CharLowerA(lpstrFilter); /* lowercase */
1860 len = MultiByteToWideChar( CP_ACP, 0, lpstrFilter, -1, NULL, 0 );
1861 fodInfos->ShellInfos.lpstrCurrentFilter = MemAlloc( len * sizeof(WCHAR) );
1862 MultiByteToWideChar( CP_ACP, 0, lpstrFilter, -1,
1863 fodInfos->ShellInfos.lpstrCurrentFilter, len );
1864 SendCustomDlgNotificationMessage(hwnd,CDN_TYPECHANGE);
1865 }
1866
1867 /* Refresh the actual view to display the included items*/
1868 IShellView_Refresh(fodInfos->Shell.FOIShellView);
1869 }
1870 }
1871 return FALSE;
1872 }
1873 /***********************************************************************
1874 * FILEDLG95_FILETYPE_SearchExt
1875 *
1876 * searches for a extension in the filetype box
1877 */
1878 static int FILEDLG95_FILETYPE_SearchExt(HWND hwnd,LPCSTR lpstrExt)
1879 {
1880 int i, iCount = CBGetCount(hwnd);
1881
1882 TRACE("%s\n", lpstrExt);
1883
1884 if(iCount != CB_ERR)
1885 {
1886 for(i=0;i<iCount;i++)
1887 {
1888 if(!strcasecmp(lpstrExt,(LPSTR)CBGetItemDataPtr(hwnd,i)))
1889 return i;
1890 }
1891 }
1892 return -1;
1893 }
1894
1895 /***********************************************************************
1896 * FILEDLG95_FILETYPE_Clean
1897 *
1898 * Clean the memory used by the filetype combo box
1899 */
1900 static void FILEDLG95_FILETYPE_Clean(HWND hwnd)
1901 {
1902 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
1903 int iPos;
1904 int iCount = CBGetCount(fodInfos->DlgInfos.hwndFileTypeCB);
1905
1906 TRACE("\n");
1907
1908 /* Delete each string of the combo and their associated data */
1909 if(iCount != CB_ERR)
1910 {
1911 for(iPos = iCount-1;iPos>=0;iPos--)
1912 {
1913 MemFree((LPSTR) CBGetItemDataPtr(fodInfos->DlgInfos.hwndFileTypeCB,iPos));
1914 CBDeleteString(fodInfos->DlgInfos.hwndFileTypeCB,iPos);
1915 }
1916 }
1917 /* Current filter */
1918 if(fodInfos->ShellInfos.lpstrCurrentFilter)
1919 MemFree(fodInfos->ShellInfos.lpstrCurrentFilter);
1920
1921 }
1922
1923 /***********************************************************************
1924 * FILEDLG95_LOOKIN_Init
1925 *
1926 * Initialisation of the look in combo box
1927 */
1928 static HRESULT FILEDLG95_LOOKIN_Init(HWND hwndCombo)
1929 {
1930 IShellFolder *psfRoot, *psfDrives;
1931 IEnumIDList *lpeRoot, *lpeDrives;
1932 LPITEMIDLIST pidlDrives, pidlTmp, pidlTmp1, pidlAbsTmp;
1933
1934 LookInInfos *liInfos = MemAlloc(sizeof(LookInInfos));
1935
1936 TRACE("\n");
1937
1938 liInfos->iMaxIndentation = 0;
1939
1940 SetPropA(hwndCombo, LookInInfosStr, (HANDLE) liInfos);
1941
1942 /* set item height for both text field and listbox */
1943 CBSetItemHeight(hwndCombo,-1,GetSystemMetrics(SM_CYSMICON));
1944 CBSetItemHeight(hwndCombo,0,GetSystemMetrics(SM_CYSMICON));
1945
1946 /* Initialise data of Desktop folder */
1947 SHGetSpecialFolderLocation(0,CSIDL_DESKTOP,&pidlTmp);
1948 FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlTmp,LISTEND);
1949 COMDLG32_SHFree(pidlTmp);
1950
1951 SHGetSpecialFolderLocation(0,CSIDL_DRIVES,&pidlDrives);
1952
1953 SHGetDesktopFolder(&psfRoot);
1954
1955 if (psfRoot)
1956 {
1957 /* enumerate the contents of the desktop */
1958 if(SUCCEEDED(IShellFolder_EnumObjects(psfRoot, hwndCombo, SHCONTF_FOLDERS, &lpeRoot)))
1959 {
1960 while (S_OK == IEnumIDList_Next(lpeRoot, 1, &pidlTmp, NULL))
1961 {
1962 FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlTmp,LISTEND);
1963
1964 /* special handling for CSIDL_DRIVES */
1965 if (COMDLG32_PIDL_ILIsEqual(pidlTmp, pidlDrives))
1966 {
1967 if(SUCCEEDED(IShellFolder_BindToObject(psfRoot, pidlTmp, NULL, &IID_IShellFolder, (LPVOID*)&psfDrives)))
1968 {
1969 /* enumerate the drives */
1970 if(SUCCEEDED(IShellFolder_EnumObjects(psfDrives, hwndCombo,SHCONTF_FOLDERS, &lpeDrives)))
1971 {
1972 while (S_OK == IEnumIDList_Next(lpeDrives, 1, &pidlTmp1, NULL))
1973 {
1974 pidlAbsTmp = COMDLG32_PIDL_ILCombine(pidlTmp, pidlTmp1);
1975 FILEDLG95_LOOKIN_AddItem(hwndCombo, pidlAbsTmp,LISTEND);
1976 COMDLG32_SHFree(pidlAbsTmp);
1977 COMDLG32_SHFree(pidlTmp1);
1978 }
1979 IEnumIDList_Release(lpeDrives);
1980 }
1981 IShellFolder_Release(psfDrives);
1982 }
1983 }
1984 COMDLG32_SHFree(pidlTmp);
1985 }
1986 IEnumIDList_Release(lpeRoot);
1987 }
1988 }
1989
1990 IShellFolder_Release(psfRoot);
1991 COMDLG32_SHFree(pidlDrives);
1992 return NOERROR;
1993 }
1994
1995 /***********************************************************************
1996 * FILEDLG95_LOOKIN_DrawItem
1997 *
1998 * WM_DRAWITEM message handler
1999 */
2000 static LRESULT FILEDLG95_LOOKIN_DrawItem(LPDRAWITEMSTRUCT pDIStruct)
2001 {
2002 COLORREF crWin = GetSysColor(COLOR_WINDOW);
2003 COLORREF crHighLight = GetSysColor(COLOR_HIGHLIGHT);
2004 COLORREF crText = GetSysColor(COLOR_WINDOWTEXT);
2005 RECT rectText;
2006 RECT rectIcon;
2007 SHFILEINFOA sfi;
2008 HIMAGELIST ilItemImage;
2009 int iIndentation;
2010 TEXTMETRICA tm;
2011 LPSFOLDER tmpFolder;
2012
2013
2014 LookInInfos *liInfos = (LookInInfos *)GetPropA(pDIStruct->hwndItem,LookInInfosStr);
2015
2016 TRACE("\n");
2017
2018 if(pDIStruct->itemID == -1)
2019 return 0;
2020
2021 if(!(tmpFolder = (LPSFOLDER) CBGetItemDataPtr(pDIStruct->hwndItem,
2022 pDIStruct->itemID)))
2023 return 0;
2024
2025
2026 if(pDIStruct->itemID == liInfos->uSelectedItem)
2027 {
2028 ilItemImage = (HIMAGELIST) SHGetFileInfoA ((LPCSTR) tmpFolder->pidlItem,
2029 0,
2030 &sfi,
2031 sizeof (SHFILEINFOA),
2032 SHGFI_PIDL | SHGFI_SMALLICON |
2033 SHGFI_OPENICON | SHGFI_SYSICONINDEX |
2034 SHGFI_DISPLAYNAME );
2035 }
2036 else
2037 {
2038 ilItemImage = (HIMAGELIST) SHGetFileInfoA ((LPCSTR) tmpFolder->pidlItem,
2039 0,
2040 &sfi,
2041 sizeof (SHFILEINFOA),
2042 SHGFI_PIDL | SHGFI_SMALLICON |
2043 SHGFI_SYSICONINDEX |
2044 SHGFI_DISPLAYNAME);
2045 }
2046
2047 /* Is this item selected ? */
2048 if(pDIStruct->itemState & ODS_SELECTED)
2049 {
2050 SetTextColor(pDIStruct->hDC,(0x00FFFFFF & ~(crText)));
2051 SetBkColor(pDIStruct->hDC,crHighLight);
2052 FillRect(pDIStruct->hDC,&pDIStruct->rcItem,GetSysColorBrush(COLOR_HIGHLIGHT));
2053 }
2054 else
2055 {
2056 SetTextColor(pDIStruct->hDC,crText);
2057 SetBkColor(pDIStruct->hDC,crWin);
2058 FillRect(pDIStruct->hDC,&pDIStruct->rcItem,GetSysColorBrush(COLOR_WINDOW));
2059 }
2060
2061 /* Do not indent item if drawing in the edit of the combo */
2062 if(pDIStruct->itemState & ODS_COMBOBOXEDIT)
2063 {
2064 iIndentation = 0;
2065 ilItemImage = (HIMAGELIST) SHGetFileInfoA ((LPCSTR) tmpFolder->pidlItem,
2066 0,
2067 &sfi,
2068 sizeof (SHFILEINFOA),
2069 SHGFI_PIDL | SHGFI_SMALLICON | SHGFI_OPENICON
2070 | SHGFI_SYSICONINDEX | SHGFI_DISPLAYNAME );
2071
2072 }
2073 else
2074 {
2075 iIndentation = tmpFolder->m_iIndent;
2076 }
2077 /* Draw text and icon */
2078
2079 /* Initialise the icon display area */
2080 rectIcon.left = pDIStruct->rcItem.left + ICONWIDTH/2 * iIndentation;
2081 rectIcon.top = pDIStruct->rcItem.top;
2082 rectIcon.right = rectIcon.left + ICONWIDTH;
2083 rectIcon.bottom = pDIStruct->rcItem.bottom;
2084
2085 /* Initialise the text display area */
2086 GetTextMetricsA(pDIStruct->hDC, &tm);
2087 rectText.left = rectIcon.right;
2088 rectText.top =
2089 (pDIStruct->rcItem.top + pDIStruct->rcItem.bottom - tm.tmHeight) / 2;
2090 rectText.right = pDIStruct->rcItem.right + XTEXTOFFSET;
2091 rectText.bottom =
2092 (pDIStruct->rcItem.top + pDIStruct->rcItem.bottom + tm.tmHeight) / 2;
2093
2094 /* Draw the icon from the image list */
2095 ImageList_Draw(ilItemImage,
2096 sfi.iIcon,
2097 pDIStruct->hDC,
2098 rectIcon.left,
2099 rectIcon.top,
2100 ILD_TRANSPARENT );
2101
2102 /* Draw the associated text */
2103 if(sfi.szDisplayName)
2104 TextOutA(pDIStruct->hDC,rectText.left,rectText.top,sfi.szDisplayName,strlen(sfi.szDisplayName));
2105
2106
2107 return NOERROR;
2108 }
2109
2110 /***********************************************************************
2111 * FILEDLG95_LOOKIN_OnCommand
2112 *
2113 * LookIn combo box WM_COMMAND message handler
2114 * If the function succeeds, the return value is nonzero.
2115 */
2116 static BOOL FILEDLG95_LOOKIN_OnCommand(HWND hwnd, WORD wNotifyCode)
2117 {
2118 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
2119
2120 TRACE("%p\n", fodInfos);
2121
2122 switch(wNotifyCode)
2123 {
2124 case CBN_SELENDOK:
2125 {
2126 LPSFOLDER tmpFolder;
2127 int iItem;
2128
2129 iItem = CBGetCurSel(fodInfos->DlgInfos.hwndLookInCB);
2130
2131 if(!(tmpFolder = (LPSFOLDER) CBGetItemDataPtr(fodInfos->DlgInfos.hwndLookInCB,
2132 iItem)))
2133 return FALSE;
2134
2135
2136 if(SUCCEEDED(IShellBrowser_BrowseObject(fodInfos->Shell.FOIShellBrowser,
2137 tmpFolder->pidlItem,
2138 SBSP_ABSOLUTE)))
2139 {
2140 return TRUE;
2141 }
2142 break;
2143 }
2144
2145 }
2146 return FALSE;
2147 }
2148
2149 /***********************************************************************
2150 * FILEDLG95_LOOKIN_AddItem
2151 *
2152 * Adds an absolute pidl item to the lookin combo box
2153 * returns the index of the inserted item
2154 */
2155 static int FILEDLG95_LOOKIN_AddItem(HWND hwnd,LPITEMIDLIST pidl, int iInsertId)
2156 {
2157 LPITEMIDLIST pidlNext;
2158 SHFILEINFOA sfi;
2159 SFOLDER *tmpFolder;
2160 LookInInfos *liInfos;
2161
2162 TRACE("%08x\n", iInsertId);
2163
2164 if(!pidl)
2165 return -1;
2166
2167 if(!(liInfos = (LookInInfos *)GetPropA(hwnd,LookInInfosStr)))
2168 return -1;
2169
2170 tmpFolder = MemAlloc(sizeof(SFOLDER));
2171 tmpFolder->m_iIndent = 0;
2172
2173 /* Calculate the indentation of the item in the lookin*/
2174 pidlNext = pidl;
2175 while( (pidlNext=COMDLG32_PIDL_ILGetNext(pidlNext)) )
2176 {
2177 tmpFolder->m_iIndent++;
2178 }
2179
2180 tmpFolder->pidlItem = COMDLG32_PIDL_ILClone(pidl); /* FIXME: memory leak*/
2181
2182 if(tmpFolder->m_iIndent > liInfos->iMaxIndentation)
2183 liInfos->iMaxIndentation = tmpFolder->m_iIndent;
2184
2185 sfi.dwAttributes = SFGAO_FILESYSANCESTOR | SFGAO_FILESYSTEM;
2186 SHGetFileInfoA((LPSTR)pidl,
2187 0,
2188 &sfi,
2189 sizeof(sfi),
2190 SHGFI_DISPLAYNAME | SHGFI_SYSICONINDEX
2191 | SHGFI_PIDL | SHGFI_SMALLICON | SHGFI_ATTRIBUTES | SHGFI_ATTR_SPECIFIED);
2192
2193 TRACE("-- Add %s attr=%08lx\n", sfi.szDisplayName, sfi.dwAttributes);
2194
2195 if((sfi.dwAttributes & SFGAO_FILESYSANCESTOR) || (sfi.dwAttributes & SFGAO_FILESYSTEM))
2196 {
2197 int iItemID;
2198
2199 TRACE("-- Add %s at %u\n", sfi.szDisplayName, tmpFolder->m_iIndent);
2200
2201 /* Add the item at the end of the list */
2202 if(iInsertId < 0)
2203 {
2204 iItemID = CBAddString(hwnd,sfi.szDisplayName);
2205 }
2206 /* Insert the item at the iInsertId position*/
2207 else
2208 {
2209 iItemID = CBInsertString(hwnd,sfi.szDisplayName,iInsertId);
2210 }
2211
2212 CBSetItemDataPtr(hwnd,iItemID,tmpFolder);
2213 return iItemID;
2214 }
2215
2216 MemFree( tmpFolder );
2217 return -1;
2218
2219 }
2220
2221 /***********************************************************************
2222 * FILEDLG95_LOOKIN_InsertItemAfterParent
2223 *
2224 * Insert an item below its parent
2225 */
2226 static int FILEDLG95_LOOKIN_InsertItemAfterParent(HWND hwnd,LPITEMIDLIST pidl)
2227 {
2228
2229 LPITEMIDLIST pidlParent = GetParentPidl(pidl);
2230 int iParentPos;
2231
2232 TRACE("\n");
2233
2234 iParentPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)pidlParent,SEARCH_PIDL);
2235
2236 if(iParentPos < 0)
2237 {
2238 iParentPos = FILEDLG95_LOOKIN_InsertItemAfterParent(hwnd,pidlParent);
2239 }
2240
2241 /* Free pidlParent memory */
2242 COMDLG32_SHFree((LPVOID)pidlParent);
2243
2244 return FILEDLG95_LOOKIN_AddItem(hwnd,pidl,iParentPos + 1);
2245 }
2246
2247 /***********************************************************************
2248 * FILEDLG95_LOOKIN_SelectItem
2249 *
2250 * Adds an absolute pidl item to the lookin combo box
2251 * returns the index of the inserted item
2252 */
2253 int FILEDLG95_LOOKIN_SelectItem(HWND hwnd,LPITEMIDLIST pidl)
2254 {
2255 int iItemPos;
2256 LookInInfos *liInfos;
2257
2258 TRACE("\n");
2259
2260 iItemPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)pidl,SEARCH_PIDL);
2261
2262 liInfos = (LookInInfos *)GetPropA(hwnd,LookInInfosStr);
2263
2264 if(iItemPos < 0)
2265 {
2266 while(FILEDLG95_LOOKIN_RemoveMostExpandedItem(hwnd) > -1);
2267 iItemPos = FILEDLG95_LOOKIN_InsertItemAfterParent(hwnd,pidl);
2268 }
2269
2270 else
2271 {
2272 SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,iItemPos);
2273 while(liInfos->iMaxIndentation > tmpFolder->m_iIndent)
2274 {
2275 int iRemovedItem;
2276
2277 if(-1 == (iRemovedItem = FILEDLG95_LOOKIN_RemoveMostExpandedItem(hwnd)))
2278 break;
2279 if(iRemovedItem < iItemPos)
2280 iItemPos--;
2281 }
2282 }
2283
2284 CBSetCurSel(hwnd,iItemPos);
2285 liInfos->uSelectedItem = iItemPos;
2286
2287 return 0;
2288
2289 }
2290
2291 /***********************************************************************
2292 * FILEDLG95_LOOKIN_RemoveMostExpandedItem
2293 *
2294 * Remove the item with an expansion level over iExpansionLevel
2295 */
2296 static int FILEDLG95_LOOKIN_RemoveMostExpandedItem(HWND hwnd)
2297 {
2298 int iItemPos;
2299
2300 LookInInfos *liInfos = (LookInInfos *)GetPropA(hwnd,LookInInfosStr);
2301
2302 TRACE("\n");
2303
2304 if(liInfos->iMaxIndentation <= 2)
2305 return -1;
2306
2307 if((iItemPos = FILEDLG95_LOOKIN_SearchItem(hwnd,(WPARAM)liInfos->iMaxIndentation,SEARCH_EXP)) >=0)
2308 {
2309 SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,iItemPos);
2310 COMDLG32_SHFree(tmpFolder->pidlItem);
2311 MemFree(tmpFolder);
2312 CBDeleteString(hwnd,iItemPos);
2313 liInfos->iMaxIndentation--;
2314
2315 return iItemPos;
2316 }
2317
2318 return -1;
2319 }
2320
2321 /***********************************************************************
2322 * FILEDLG95_LOOKIN_SearchItem
2323 *
2324 * Search for pidl in the lookin combo box
2325 * returns the index of the found item
2326 */
2327 static int FILEDLG95_LOOKIN_SearchItem(HWND hwnd,WPARAM searchArg,int iSearchMethod)
2328 {
2329 int i = 0;
2330 int iCount = CBGetCount(hwnd);
2331
2332 TRACE("0x%08x 0x%x\n",searchArg, iSearchMethod);
2333
2334 if (iCount != CB_ERR)
2335 {
2336 for(;i<iCount;i++)
2337 {
2338 LPSFOLDER tmpFolder = (LPSFOLDER) CBGetItemDataPtr(hwnd,i);
2339
2340 if(iSearchMethod == SEARCH_PIDL && COMDLG32_PIDL_ILIsEqual((LPITEMIDLIST)searchArg,tmpFolder->pidlItem))
2341 return i;
2342 if(iSearchMethod == SEARCH_EXP && tmpFolder->m_iIndent == (int)searchArg)
2343 return i;
2344 }
2345 }
2346
2347 return -1;
2348 }
2349
2350 /***********************************************************************
2351 * FILEDLG95_LOOKIN_Clean
2352 *
2353 * Clean the memory used by the lookin combo box
2354 */
2355 static void FILEDLG95_LOOKIN_Clean(HWND hwnd)
2356 {
2357 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
2358 int iPos;
2359 int iCount = CBGetCount(fodInfos->DlgInfos.hwndLookInCB);
2360
2361 TRACE("\n");
2362
2363 /* Delete each string of the combo and their associated data */
2364 if (iCount != CB_ERR)
2365 {
2366 for(iPos = iCount-1;iPos>=0;iPos--)
2367 {
2368 SFOLDER *tmpFolder = (LPSFOLDER) CBGetItemDataPtr(fodInfos->DlgInfos.hwndLookInCB,iPos);
2369 COMDLG32_SHFree(tmpFolder->pidlItem);
2370 MemFree(tmpFolder);
2371 CBDeleteString(fodInfos->DlgInfos.hwndLookInCB,iPos);
2372 }
2373 }
2374
2375 /* LookInInfos structure */
2376 RemovePropA(fodInfos->DlgInfos.hwndLookInCB,LookInInfosStr);
2377
2378 }
2379 /***********************************************************************
2380 * FILEDLG95_FILENAME_FillFromSelection
2381 *
2382 * fills the edit box from the cached DataObject
2383 */
2384 void FILEDLG95_FILENAME_FillFromSelection (HWND hwnd)
2385 {
2386 FileOpenDlgInfos *fodInfos;
2387 LPITEMIDLIST pidl;
2388 UINT nFiles = 0, nFileToOpen, nFileSelected, nLength = 0;
2389 char lpstrTemp[MAX_PATH];
2390 LPSTR lpstrAllFile = NULL, lpstrCurrFile = NULL;
2391
2392 TRACE("\n");
2393 fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
2394
2395 /* Count how many files we have */
2396 nFileSelected = GetNumSelected( fodInfos->Shell.FOIDataObject );
2397
2398 /* calculate the string length, count files */
2399 if (nFileSelected >= 1)
2400 {
2401 nLength += 3; /* first and last quotes, trailing \0 */
2402 for ( nFileToOpen = 0; nFileToOpen < nFileSelected; nFileToOpen++ )
2403 {
2404 pidl = GetPidlFromDataObject( fodInfos->Shell.FOIDataObject, nFileToOpen+1 );
2405
2406 if (pidl)
2407 {
2408 /* get the total length of the selected file names*/
2409 lpstrTemp[0] = '\0';
2410 GetName( fodInfos->Shell.FOIShellFolder, pidl, SHGDN_INFOLDER|SHGDN_FORPARSING, lpstrTemp );
2411
2412 if ( ! IsPidlFolder(fodInfos->Shell.FOIShellFolder, pidl) ) /* Ignore folders */
2413 {
2414 nLength += strlen( lpstrTemp ) + 3;
2415 nFiles++;
2416 }
2417 COMDLG32_SHFree( pidl );
2418 }
2419 }
2420 }
2421
2422 /* allocate the buffer */
2423 if (nFiles <= 1) nLength = MAX_PATH;
2424 lpstrAllFile = (LPSTR)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, nLength);
2425 lpstrAllFile[0] = '\0';
2426
2427 /* Generate the string for the edit control */
2428 if(nFiles >= 1)
2429 {
2430 lpstrCurrFile = lpstrAllFile;
2431 for ( nFileToOpen = 0; nFileToOpen < nFileSelected; nFileToOpen++ )
2432 {
2433 pidl = GetPidlFromDataObject( fodInfos->Shell.FOIDataObject, nFileToOpen+1 );
2434
2435 if (pidl)
2436 {
2437 /* get the file name */
2438 lpstrTemp[0] = '\0';
2439 GetName( fodInfos->Shell.FOIShellFolder, pidl, SHGDN_INFOLDER|SHGDN_FORPARSING, lpstrTemp );
2440
2441 if (! IsPidlFolder(fodInfos->Shell.FOIShellFolder, pidl)) /* Ignore folders */
2442 {
2443 if ( nFiles > 1)
2444 {
2445 *lpstrCurrFile++ = '\"';
2446 strcpy( lpstrCurrFile, lpstrTemp );
2447 lpstrCurrFile += strlen( lpstrTemp );
2448 strcpy( lpstrCurrFile, "\" " );
2449 lpstrCurrFile += 2;
2450 }
2451 else
2452 {
2453 strcpy( lpstrAllFile, lpstrTemp );
2454 }
2455 }
2456 COMDLG32_SHFree( (LPVOID) pidl );
2457 }
2458 }
2459 }
2460
2461 SetWindowTextA( fodInfos->DlgInfos.hwndFileName, lpstrAllFile );
2462 HeapFree(GetProcessHeap(),0, lpstrAllFile );
2463 }
2464
2465
2466 /* copied from shell32 to avoid linking to it */
2467 static HRESULT COMDLG32_StrRetToStrNA (LPVOID dest, DWORD len, LPSTRRET src, LPITEMIDLIST pidl)
2468 {
2469 switch (src->uType)
2470 {
2471 case STRRET_WSTR:
2472 WideCharToMultiByte(CP_ACP, 0, src->u.pOleStr, -1, (LPSTR)dest, len, NULL, NULL);
2473 COMDLG32_SHFree(src->u.pOleStr);
2474 break;
2475
2476 case STRRET_CSTRA:
2477 lstrcpynA((LPSTR)dest, src->u.cStr, len);
2478 break;
2479
2480 case STRRET_OFFSETA:
2481 lstrcpynA((LPSTR)dest, ((LPCSTR)&pidl->mkid)+src->u.uOffset, len);
2482 break;
2483
2484 default:
2485 FIXME("unknown type!\n");
2486 if (len)
2487 {
2488 *(LPSTR)dest = '\0';
2489 }
2490 return(FALSE);
2491 }
2492 return S_OK;
2493 }
2494
2495 /***********************************************************************
2496 * FILEDLG95_FILENAME_GetFileNames
2497 *
2498 * copies the filenames to a 0-delimited string list (A\0B\0C\0\0)
2499 */
2500 int FILEDLG95_FILENAME_GetFileNames (HWND hwnd, LPSTR * lpstrFileList, UINT * sizeUsed)
2501 {
2502 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
2503 UINT nStrCharCount = 0; /* index in src buffer */
2504 UINT nFileIndex = 0; /* index in dest buffer */
2505 UINT nFileCount = 0; /* number of files */
2506 UINT nStrLen = 0; /* length of string in edit control */
2507 LPSTR lpstrEdit; /* buffer for string from edit control */
2508
2509 TRACE("\n");
2510
2511 /* get the filenames from the edit control */
2512 nStrLen = SendMessageA(fodInfos->DlgInfos.hwndFileName, WM_GETTEXTLENGTH, 0, 0);
2513 lpstrEdit = MemAlloc(nStrLen+1);
2514 GetDlgItemTextA(hwnd, IDC_FILENAME, lpstrEdit, nStrLen+1);
2515
2516 TRACE("nStrLen=%u str=%s\n", nStrLen, lpstrEdit);
2517
2518 /* we might get single filename without any '"',
2519 * so we need nStrLen + terminating \0 + end-of-list \0 */
2520 *lpstrFileList = MemAlloc(nStrLen+2);
2521 *sizeUsed = 0;
2522
2523 /* build 0-delimited file list from filenames */
2524 while ( nStrCharCount <= nStrLen )
2525 {
2526 if ( lpstrEdit[nStrCharCount]=='"' )
2527 {
2528 nStrCharCount++;
2529 while ((lpstrEdit[nStrCharCount]!='"') && (nStrCharCount <= nStrLen))
2530 {
2531 (*lpstrFileList)[nFileIndex++] = lpstrEdit[nStrCharCount];
2532 (*sizeUsed)++;
2533 nStrCharCount++;
2534 }
2535 (*lpstrFileList)[nFileIndex++] = '\0';
2536 (*sizeUsed)++;
2537 nFileCount++;
2538 }
2539 nStrCharCount++;
2540 }
2541
2542 /* single, unquoted string */
2543 if ((nStrLen > 0) && (*sizeUsed == 0) )
2544 {
2545 strcpy(*lpstrFileList, lpstrEdit);
2546 nFileIndex = strlen(lpstrEdit) + 1;
2547 (*sizeUsed) = nFileIndex;
2548 nFileCount = 1;
2549 }
2550
2551 /* trailing \0 */
2552 (*lpstrFileList)[nFileIndex] = '\0';
2553 (*sizeUsed)++;
2554
2555 MemFree(lpstrEdit);
2556 return nFileCount;
2557 }
2558
2559 #define SETDefFormatEtc(fe,cf,med) \
2560 { \
2561 (fe).cfFormat = cf;\
2562 (fe).dwAspect = DVASPECT_CONTENT; \
2563 (fe).ptd =NULL;\
2564 (fe).tymed = med;\
2565 (fe).lindex = -1;\
2566 };
2567
2568 /*
2569 * DATAOBJECT Helper functions
2570 */
2571
2572 /***********************************************************************
2573 * COMCTL32_ReleaseStgMedium
2574 *
2575 * like ReleaseStgMedium from ole32
2576 */
2577 static void COMCTL32_ReleaseStgMedium (STGMEDIUM medium)
2578 {
2579 if(medium.pUnkForRelease)
2580 {
2581 IUnknown_Release(medium.pUnkForRelease);
2582 }
2583 else
2584 {
2585 GlobalUnlock(medium.u.hGlobal);
2586 GlobalFree(medium.u.hGlobal);
2587 }
2588 }
2589
2590 /***********************************************************************
2591 * GetPidlFromDataObject
2592 *
2593 * Return pidl(s) by number from the cached DataObject
2594 *
2595 * nPidlIndex=0 gets the fully qualified root path
2596 */
2597 LPITEMIDLIST GetPidlFromDataObject ( IDataObject *doSelected, UINT nPidlIndex)
2598 {
2599
2600 STGMEDIUM medium;
2601 FORMATETC formatetc;
2602 LPITEMIDLIST pidl = NULL;
2603
2604 TRACE("sv=%p index=%u\n", doSelected, nPidlIndex);
2605
2606 /* Set the FORMATETC structure*/
2607 SETDefFormatEtc(formatetc, RegisterClipboardFormatA(CFSTR_SHELLIDLIST), TYMED_HGLOBAL);
2608
2609 /* Get the pidls from IDataObject */
2610 if(SUCCEEDED(IDataObject_GetData(doSelected,&formatetc,&medium)))
2611 {
2612 LPIDA cida = GlobalLock(medium.u.hGlobal);
2613 if(nPidlIndex <= cida->cidl)
2614 {
2615 pidl = COMDLG32_PIDL_ILClone((LPITEMIDLIST)(&((LPBYTE)cida)[cida->aoffset[nPidlIndex]]));
2616 }
2617 COMCTL32_ReleaseStgMedium(medium);
2618 }
2619 return pidl;
2620 }
2621
2622 /***********************************************************************
2623 * GetNumSelected
2624 *
2625 * Return the number of selected items in the DataObject.
2626 *
2627 */
2628 UINT GetNumSelected( IDataObject *doSelected )
2629 {
2630 UINT retVal = 0;
2631 STGMEDIUM medium;
2632 FORMATETC formatetc;
2633
2634 TRACE("sv=%p\n", doSelected);
2635
2636 if (!doSelected) return 0;
2637
2638 /* Set the FORMATETC structure*/
2639 SETDefFormatEtc(formatetc, RegisterClipboardFormatA(CFSTR_SHELLIDLIST), TYMED_HGLOBAL);
2640
2641 /* Get the pidls from IDataObject */
2642 if(SUCCEEDED(IDataObject_GetData(doSelected,&formatetc,&medium)))
2643 {
2644 LPIDA cida = GlobalLock(medium.u.hGlobal);
2645 retVal = cida->cidl;
2646 COMCTL32_ReleaseStgMedium(medium);
2647 return retVal;
2648 }
2649 return 0;
2650 }
2651
2652 /*
2653 * TOOLS
2654 */
2655
2656 /***********************************************************************
2657 * GetName
2658 *
2659 * Get the pidl's display name (relative to folder) and
2660 * put it in lpstrFileName.
2661 *
2662 * Return NOERROR on success,
2663 * E_FAIL otherwise
2664 */
2665
2666 HRESULT GetName(LPSHELLFOLDER lpsf, LPITEMIDLIST pidl,DWORD dwFlags,LPSTR lpstrFileName)
2667 {
2668 STRRET str;
2669 HRESULT hRes;
2670
2671 TRACE("sf=%p pidl=%p\n", lpsf, pidl);
2672
2673 if(!lpsf)
2674 {
2675 HRESULT hRes;
2676 SHGetDesktopFolder(&lpsf);
2677 hRes = GetName(lpsf,pidl,dwFlags,lpstrFileName);
2678 IShellFolder_Release(lpsf);
2679 return hRes;
2680 }
2681
2682 /* Get the display name of the pidl relative to the folder */
2683 if (SUCCEEDED(hRes = IShellFolder_GetDisplayNameOf(lpsf, pidl, dwFlags, &str)))
2684 {
2685 return COMDLG32_StrRetToStrNA(lpstrFileName, MAX_PATH, &str, pidl);
2686 }
2687 return E_FAIL;
2688 }
2689
2690 /***********************************************************************
2691 * GetShellFolderFromPidl
2692 *
2693 * pidlRel is the item pidl relative
2694 * Return the IShellFolder of the absolute pidl
2695 */
2696 IShellFolder *GetShellFolderFromPidl(LPITEMIDLIST pidlAbs)
2697 {
2698 IShellFolder *psf = NULL,*psfParent;
2699
2700 TRACE("%p\n", pidlAbs);
2701
2702 if(SUCCEEDED(SHGetDesktopFolder(&psfParent)))
2703 {
2704 psf = psfParent;
2705 if(pidlAbs && pidlAbs->mkid.cb)
2706 {
2707 if(SUCCEEDED(IShellFolder_BindToObject(psfParent, pidlAbs, NULL, &IID_IShellFolder, (LPVOID*)&psf)))
2708 {
2709 IShellFolder_Release(psfParent);
2710 return psf;
2711 }
2712 }
2713 /* return the desktop */
2714 return psfParent;
2715 }
2716 return NULL;
2717 }
2718
2719 /***********************************************************************
2720 * GetParentPidl
2721 *
2722 * Return the LPITEMIDLIST to the parent of the pidl in the list
2723 */
2724 LPITEMIDLIST GetParentPidl(LPITEMIDLIST pidl)
2725 {
2726 LPITEMIDLIST pidlParent;
2727
2728 TRACE("%p\n", pidl);
2729
2730 pidlParent = COMDLG32_PIDL_ILClone(pidl);
2731 COMDLG32_PIDL_ILRemoveLastID(pidlParent);
2732
2733 return pidlParent;
2734 }
2735
2736 /***********************************************************************
2737 * GetPidlFromName
2738 *
2739 * returns the pidl of the file name relative to folder
2740 * NULL if an error occurred
2741 */
2742 LPITEMIDLIST GetPidlFromName(IShellFolder *lpsf,LPCSTR lpcstrFileName)
2743 {
2744 LPITEMIDLIST pidl;
2745 ULONG ulEaten;
2746 WCHAR lpwstrDirName[MAX_PATH];
2747
2748 TRACE("sf=%p file=%s\n", lpsf, lpcstrFileName);
2749
2750 if(!lpcstrFileName) return NULL;
2751 if(!*lpcstrFileName) return NULL;
2752
2753 MultiByteToWideChar(CP_ACP,MB_PRECOMPOSED,lpcstrFileName,-1,(LPWSTR)lpwstrDirName,MAX_PATH);
2754
2755 if(!lpsf)
2756 {
2757 SHGetDesktopFolder(&lpsf);
2758 pidl = GetPidlFromName(lpsf, lpcstrFileName);
2759 IShellFolder_Release(lpsf);
2760 }
2761 else
2762 {
2763 IShellFolder_ParseDisplayName(lpsf, 0, NULL, (LPWSTR)lpwstrDirName, &ulEaten, &pidl, NULL);
2764 }
2765 return pidl;
2766 }
2767
2768 /*
2769 */
2770 BOOL IsPidlFolder (LPSHELLFOLDER psf, LPITEMIDLIST pidl)
2771 {
2772 ULONG uAttr = SFGAO_FOLDER | SFGAO_HASSUBFOLDER;
2773 HRESULT ret;
2774
2775 TRACE("%p, %p\n", psf, pidl);
2776
2777 ret = IShellFolder_GetAttributesOf( psf, 1, &pidl, &uAttr );
2778
2779 TRACE("-- 0x%08lx 0x%08lx\n", uAttr, ret);
2780 /* see documentation shell 4.1*/
2781 return uAttr & (SFGAO_FOLDER | SFGAO_HASSUBFOLDER);
2782 }
2783
2784 /***********************************************************************
2785 * BrowseSelectedFolder
2786 */
2787 static BOOL BrowseSelectedFolder(HWND hwnd)
2788 {
2789 BOOL bBrowseSelFolder = FALSE;
2790 FileOpenDlgInfos *fodInfos = (FileOpenDlgInfos *) GetPropA(hwnd,FileOpenDlgInfosStr);
2791
2792 TRACE("\n");
2793
2794 if (GetNumSelected(fodInfos->Shell.FOIDataObject) == 1)
2795 {
2796 LPITEMIDLIST pidlSelection;
2797
2798 /* get the file selected */
2799 pidlSelection = GetPidlFromDataObject( fodInfos->Shell.FOIDataObject, 1);
2800 if (IsPidlFolder (fodInfos->Shell.FOIShellFolder, pidlSelection))
2801 {
2802 if ( FAILED( IShellBrowser_BrowseObject( fodInfos->Shell.FOIShellBrowser,
2803 pidlSelection, SBSP_RELATIVE ) ) )
2804 {
2805 MessageBoxA( hwnd, "Path does not exist", fodInfos->ofnInfos->lpstrTitle,
2806 MB_OK | MB_ICONEXCLAMATION );
2807 }
2808
2809 bBrowseSelFolder = TRUE;
2810 }
2811 COMDLG32_SHFree( pidlSelection );
2812 }
2813
2814 return bBrowseSelFolder;
2815 }
2816
2817 /*
2818 * Memory allocation methods */
2819 static void *MemAlloc(UINT size)
2820 {
2821 return HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,size);
2822 }
2823
2824 static void MemFree(void *mem)
2825 {
2826 if(mem)
2827 {
2828 HeapFree(GetProcessHeap(),0,mem);
2829 }
2830 }
2831
Windows API implementation