?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ddraw/tests: Add another invalid arguments test for surface QI.
[wine.git] / dlls / comdlg32 / itemdlg.c
blob309601785733b33ff179162b0871dfc513467401
1 /*
2 * Common Item Dialog
3 *
4 * Copyright 2010,2011 David Hedberg
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdarg.h>
22
23 #define COBJMACROS
24 #define NONAMELESSUNION
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "wingdi.h"
30 #include "winreg.h"
31 #include "shlwapi.h"
32
33 #include "commdlg.h"
34 #include "cdlg.h"
35 #include "filedlgbrowser.h"
36
37 #include "wine/debug.h"
38 #include "wine/list.h"
39
40 #define IDC_NAV_TOOLBAR 200
41 #define IDC_NAVBACK 201
42 #define IDC_NAVFORWARD 202
43
44 #include <initguid.h>
45 /* This seems to be another version of IID_IFileDialogCustomize. If
46 * there is any difference I have yet to find it. */
47 DEFINE_GUID(IID_IFileDialogCustomizeAlt, 0x8016B7B3, 0x3D49, 0x4504, 0xA0,0xAA, 0x2A,0x37,0x49,0x4E,0x60,0x6F);
48
49 WINE_DEFAULT_DEBUG_CHANNEL(commdlg);
50
51 static const WCHAR notifysink_childW[] = {'n','f','s','_','c','h','i','l','d',0};
52 static const WCHAR floatnotifysinkW[] = {'F','l','o','a','t','N','o','t','i','f','y','S','i','n','k',0};
53 static const WCHAR radiobuttonlistW[] = {'R','a','d','i','o','B','u','t','t','o','n','L','i','s','t',0};
54
55 enum ITEMDLG_TYPE {
56 ITEMDLG_TYPE_OPEN,
57 ITEMDLG_TYPE_SAVE
58 };
59
60 enum ITEMDLG_CCTRL_TYPE {
61 IDLG_CCTRL_MENU,
62 IDLG_CCTRL_PUSHBUTTON,
63 IDLG_CCTRL_COMBOBOX,
64 IDLG_CCTRL_RADIOBUTTONLIST,
65 IDLG_CCTRL_CHECKBUTTON,
66 IDLG_CCTRL_EDITBOX,
67 IDLG_CCTRL_SEPARATOR,
68 IDLG_CCTRL_TEXT,
69 IDLG_CCTRL_OPENDROPDOWN,
70 IDLG_CCTRL_VISUALGROUP
71 };
72
73 typedef struct cctrl_item {
74 DWORD id, parent_id;
75 LPWSTR label;
76 CDCONTROLSTATEF cdcstate;
77 HWND hwnd;
78 struct list entry;
79 } cctrl_item;
80
81 typedef struct {
82 HWND hwnd, wrapper_hwnd;
83 UINT id, dlgid;
84 enum ITEMDLG_CCTRL_TYPE type;
85 CDCONTROLSTATEF cdcstate;
86 struct list entry;
87
88 struct list sub_cctrls;
89 struct list sub_cctrls_entry;
90 struct list sub_items;
91 } customctrl;
92
93 typedef struct {
94 struct list entry;
95 IFileDialogEvents *pfde;
96 DWORD cookie;
97 } events_client;
98
99 typedef struct FileDialogImpl {
100 IFileDialog2 IFileDialog2_iface;
101 union {
102 IFileOpenDialog IFileOpenDialog_iface;
103 IFileSaveDialog IFileSaveDialog_iface;
104 } u;
105 enum ITEMDLG_TYPE dlg_type;
106 IExplorerBrowserEvents IExplorerBrowserEvents_iface;
107 IServiceProvider IServiceProvider_iface;
108 ICommDlgBrowser3 ICommDlgBrowser3_iface;
109 IOleWindow IOleWindow_iface;
110 IFileDialogCustomize IFileDialogCustomize_iface;
111 LONG ref;
112
113 FILEOPENDIALOGOPTIONS options;
114 COMDLG_FILTERSPEC *filterspecs;
115 UINT filterspec_count;
116 UINT filetypeindex;
117
118 struct list events_clients;
119 DWORD events_next_cookie;
120
121 IShellItemArray *psia_selection;
122 IShellItemArray *psia_results;
123 IShellItem *psi_defaultfolder;
124 IShellItem *psi_setfolder;
125 IShellItem *psi_folder;
126
127 HWND dlg_hwnd;
128 IExplorerBrowser *peb;
129 DWORD ebevents_cookie;
130
131 LPWSTR set_filename;
132 LPWSTR default_ext;
133 LPWSTR custom_title;
134 LPWSTR custom_okbutton;
135 LPWSTR custom_cancelbutton;
136 LPWSTR custom_filenamelabel;
137
138 UINT cctrl_width, cctrl_def_height, cctrls_cols;
139 UINT cctrl_indent, dpi_x, dpi_y;
140 HWND cctrls_hwnd;
141 struct list cctrls;
142 UINT_PTR cctrl_next_dlgid;
143 customctrl *cctrl_active_vg;
144
145 HMENU hmenu_opendropdown;
146 customctrl cctrl_opendropdown;
147 HFONT hfont_opendropdown;
148 BOOL opendropdown_has_selection;
149 DWORD opendropdown_selection;
150
151 GUID client_guid;
152 } FileDialogImpl;
153
154 /**************************************************************************
155 * Event wrappers.
156 */
157 static HRESULT events_OnFileOk(FileDialogImpl *This)
158 {
159 events_client *cursor;
160 HRESULT hr = S_OK;
161 TRACE("%p\n", This);
162
163 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
164 {
165 TRACE("Notifying %p\n", cursor);
166 hr = IFileDialogEvents_OnFileOk(cursor->pfde, (IFileDialog*)&This->IFileDialog2_iface);
167 if(FAILED(hr) && hr != E_NOTIMPL)
168 break;
169 }
170
171 if(hr == E_NOTIMPL)
172 hr = S_OK;
173
174 return hr;
175 }
176
177 static HRESULT events_OnFolderChanging(FileDialogImpl *This, IShellItem *folder)
178 {
179 events_client *cursor;
180 HRESULT hr = S_OK;
181 TRACE("%p (%p)\n", This, folder);
182
183 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
184 {
185 TRACE("Notifying %p\n", cursor);
186 hr = IFileDialogEvents_OnFolderChanging(cursor->pfde, (IFileDialog*)&This->IFileDialog2_iface, folder);
187 if(FAILED(hr) && hr != E_NOTIMPL)
188 break;
189 }
190
191 if(hr == E_NOTIMPL)
192 hr = S_OK;
193
194 return hr;
195 }
196
197 static void events_OnFolderChange(FileDialogImpl *This)
198 {
199 events_client *cursor;
200 TRACE("%p\n", This);
201
202 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
203 {
204 TRACE("Notifying %p\n", cursor);
205 IFileDialogEvents_OnFolderChange(cursor->pfde, (IFileDialog*)&This->IFileDialog2_iface);
206 }
207 }
208
209 static void events_OnSelectionChange(FileDialogImpl *This)
210 {
211 events_client *cursor;
212 TRACE("%p\n", This);
213
214 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
215 {
216 TRACE("Notifying %p\n", cursor);
217 IFileDialogEvents_OnSelectionChange(cursor->pfde, (IFileDialog*)&This->IFileDialog2_iface);
218 }
219 }
220
221 static void events_OnTypeChange(FileDialogImpl *This)
222 {
223 events_client *cursor;
224 TRACE("%p\n", This);
225
226 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
227 {
228 TRACE("Notifying %p\n", cursor);
229 IFileDialogEvents_OnTypeChange(cursor->pfde, (IFileDialog*)&This->IFileDialog2_iface);
230 }
231 }
232
233 static HRESULT events_OnOverwrite(FileDialogImpl *This, IShellItem *shellitem)
234 {
235 events_client *cursor;
236 HRESULT hr = S_OK;
237 FDE_OVERWRITE_RESPONSE response = FDEOR_DEFAULT;
238 TRACE("%p %p\n", This, shellitem);
239
240 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
241 {
242 TRACE("Notifying %p\n", cursor);
243 hr = IFileDialogEvents_OnOverwrite(cursor->pfde, (IFileDialog*)&This->IFileDialog2_iface, shellitem, &response);
244 TRACE("<-- hr=%x response=%u\n", hr, response);
245 if(FAILED(hr) && hr != E_NOTIMPL)
246 break;
247 }
248
249 if(hr == E_NOTIMPL)
250 hr = S_OK;
251
252 if(SUCCEEDED(hr))
253 {
254 if (response == FDEOR_DEFAULT)
255 {
256 WCHAR buf[100];
257 int answer;
258
259 LoadStringW(COMDLG32_hInstance, IDS_OVERWRITEFILE, buf, 100);
260 answer = MessageBoxW(This->dlg_hwnd, buf, This->custom_title,
261 MB_YESNO | MB_ICONEXCLAMATION);
262 if (answer == IDNO || answer == IDCANCEL)
263 {
264 hr = E_FAIL;
265 }
266 }
267 else if (response == FDEOR_REFUSE)
268 hr = E_FAIL;
269 }
270
271 return hr;
272 }
273
274 static inline HRESULT get_cctrl_event(IFileDialogEvents *pfde, IFileDialogControlEvents **pfdce)
275 {
276 return IFileDialogEvents_QueryInterface(pfde, &IID_IFileDialogControlEvents, (void**)pfdce);
277 }
278
279 static HRESULT cctrl_event_OnButtonClicked(FileDialogImpl *This, DWORD ctl_id)
280 {
281 events_client *cursor;
282 TRACE("%p\n", This);
283
284 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
285 {
286 IFileDialogControlEvents *pfdce;
287 if(SUCCEEDED(get_cctrl_event(cursor->pfde, &pfdce)))
288 {
289 TRACE("Notifying %p\n", cursor);
290 IFileDialogControlEvents_OnButtonClicked(pfdce, &This->IFileDialogCustomize_iface, ctl_id);
291 IFileDialogControlEvents_Release(pfdce);
292 }
293 }
294
295 return S_OK;
296 }
297
298 static HRESULT cctrl_event_OnItemSelected(FileDialogImpl *This, DWORD ctl_id, DWORD item_id)
299 {
300 events_client *cursor;
301 TRACE("%p %i %i\n", This, ctl_id, item_id);
302
303 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
304 {
305 IFileDialogControlEvents *pfdce;
306 if(SUCCEEDED(get_cctrl_event(cursor->pfde, &pfdce)))
307 {
308 TRACE("Notifying %p\n", cursor);
309 IFileDialogControlEvents_OnItemSelected(pfdce, &This->IFileDialogCustomize_iface, ctl_id, item_id);
310 IFileDialogControlEvents_Release(pfdce);
311 }
312 }
313
314 return S_OK;
315 }
316
317 static HRESULT cctrl_event_OnCheckButtonToggled(FileDialogImpl *This, DWORD ctl_id, BOOL checked)
318 {
319 events_client *cursor;
320 TRACE("%p\n", This);
321
322 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
323 {
324 IFileDialogControlEvents *pfdce;
325 if(SUCCEEDED(get_cctrl_event(cursor->pfde, &pfdce)))
326 {
327 TRACE("Notifying %p\n", cursor);
328 IFileDialogControlEvents_OnCheckButtonToggled(pfdce, &This->IFileDialogCustomize_iface, ctl_id, checked);
329 IFileDialogControlEvents_Release(pfdce);
330 }
331 }
332
333 return S_OK;
334 }
335
336 static HRESULT cctrl_event_OnControlActivating(FileDialogImpl *This,
337 DWORD ctl_id)
338 {
339 events_client *cursor;
340 TRACE("%p\n", This);
341
342 LIST_FOR_EACH_ENTRY(cursor, &This->events_clients, events_client, entry)
343 {
344 IFileDialogControlEvents *pfdce;
345 if(SUCCEEDED(get_cctrl_event(cursor->pfde, &pfdce)))
346 {
347 TRACE("Notifying %p\n", cursor);
348 IFileDialogControlEvents_OnControlActivating(pfdce, &This->IFileDialogCustomize_iface, ctl_id);
349 IFileDialogControlEvents_Release(pfdce);
350 }
351 }
352
353 return S_OK;
354 }
355
356 /**************************************************************************
357 * Helper functions.
358 */
359 static UINT get_file_name(FileDialogImpl *This, LPWSTR *str)
360 {
361 HWND hwnd_edit = GetDlgItem(This->dlg_hwnd, IDC_FILENAME);
362 UINT len;
363
364 if(!hwnd_edit)
365 {
366 if(This->set_filename)
367 {
368 len = lstrlenW(This->set_filename);
369 *str = CoTaskMemAlloc(sizeof(WCHAR)*(len+1));
370 lstrcpyW(*str, This->set_filename);
371 return len;
372 }
373 return 0;
374 }
375
376 len = SendMessageW(hwnd_edit, WM_GETTEXTLENGTH, 0, 0);
377 *str = CoTaskMemAlloc(sizeof(WCHAR)*(len+1));
378 if(!*str)
379 return 0;
380
381 SendMessageW(hwnd_edit, WM_GETTEXT, len+1, (LPARAM)*str);
382 return len;
383 }
384
385 static BOOL set_file_name(FileDialogImpl *This, LPCWSTR str)
386 {
387 if(This->set_filename)
388 LocalFree(This->set_filename);
389
390 This->set_filename = str ? StrDupW(str) : NULL;
391
392 return SetDlgItemTextW(This->dlg_hwnd, IDC_FILENAME, This->set_filename);
393 }
394
395 static void fill_filename_from_selection(FileDialogImpl *This)
396 {
397 IShellItem *psi;
398 LPWSTR *names;
399 HRESULT hr;
400 UINT item_count, valid_count;
401 UINT len_total, i;
402
403 if(!This->psia_selection)
404 return;
405
406 hr = IShellItemArray_GetCount(This->psia_selection, &item_count);
407 if(FAILED(hr) || !item_count)
408 return;
409
410 names = HeapAlloc(GetProcessHeap(), 0, item_count*sizeof(LPWSTR));
411
412 /* Get names of the selected items */
413 valid_count = 0; len_total = 0;
414 for(i = 0; i < item_count; i++)
415 {
416 hr = IShellItemArray_GetItemAt(This->psia_selection, i, &psi);
417 if(SUCCEEDED(hr))
418 {
419 UINT attr;
420
421 hr = IShellItem_GetAttributes(psi, SFGAO_FOLDER, &attr);
422 if(SUCCEEDED(hr) &&
423 (( (This->options & FOS_PICKFOLDERS) && !(attr & SFGAO_FOLDER)) ||
424 (!(This->options & FOS_PICKFOLDERS) && (attr & SFGAO_FOLDER))))
425 continue;
426
427 hr = IShellItem_GetDisplayName(psi, SIGDN_PARENTRELATIVEPARSING, &names[valid_count]);
428 if(SUCCEEDED(hr))
429 {
430 len_total += lstrlenW(names[valid_count]) + 3;
431 valid_count++;
432 }
433 IShellItem_Release(psi);
434 }
435 }
436
437 if(valid_count == 1)
438 {
439 set_file_name(This, names[0]);
440 CoTaskMemFree(names[0]);
441 }
442 else if(valid_count > 1)
443 {
444 LPWSTR string = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*len_total);
445 LPWSTR cur_point = string;
446
447 for(i = 0; i < valid_count; i++)
448 {
449 LPWSTR file = names[i];
450 *cur_point++ = '\"';
451 lstrcpyW(cur_point, file);
452 cur_point += lstrlenW(file);
453 *cur_point++ = '\"';
454 *cur_point++ = ' ';
455 CoTaskMemFree(file);
456 }
457 *(cur_point-1) = '\0';
458
459 set_file_name(This, string);
460 HeapFree(GetProcessHeap(), 0, string);
461 }
462
463 HeapFree(GetProcessHeap(), 0, names);
464 return;
465 }
466
467 static LPWSTR get_first_ext_from_spec(LPWSTR buf, LPCWSTR spec)
468 {
469 WCHAR *endpos, *ext;
470
471 lstrcpyW(buf, spec);
472 if( (endpos = StrChrW(buf, ';')) )
473 *endpos = '\0';
474
475 ext = PathFindExtensionW(buf);
476 if(StrChrW(ext, '*'))
477 return NULL;
478
479 return ext;
480 }
481
482 static BOOL shell_item_exists(IShellItem* shellitem)
483 {
484 LPWSTR filename;
485 HRESULT hr;
486 BOOL result;
487
488 hr = IShellItem_GetDisplayName(shellitem, SIGDN_FILESYSPATH, &filename);
489 if (SUCCEEDED(hr))
490 {
491 /* FIXME: Implement SFGAO_VALIDATE in Wine and use it instead. */
492 result = (GetFileAttributesW(filename) != INVALID_FILE_ATTRIBUTES);
493 CoTaskMemFree(filename);
494 }
495 else
496 {
497 SFGAOF attributes;
498 result = SUCCEEDED(IShellItem_GetAttributes(shellitem, SFGAO_VALIDATE, &attributes));
499 }
500
501 return result;
502 }
503
504 static HRESULT on_default_action(FileDialogImpl *This)
505 {
506 IShellFolder *psf_parent, *psf_desktop;
507 LPITEMIDLIST *pidla;
508 LPITEMIDLIST current_folder;
509 LPWSTR fn_iter, files = NULL, tmp_files;
510 UINT file_count = 0, len, i;
511 int open_action;
512 HRESULT hr, ret = E_FAIL;
513
514 len = get_file_name(This, &tmp_files);
515 if(len)
516 {
517 UINT size_used;
518 file_count = COMDLG32_SplitFileNames(tmp_files, len, &files, &size_used);
519 CoTaskMemFree(tmp_files);
520 }
521 if(!file_count) return E_FAIL;
522
523 hr = SHGetIDListFromObject((IUnknown*)This->psi_folder, &current_folder);
524 if(FAILED(hr))
525 {
526 ERR("Failed to get pidl for current directory.\n");
527 HeapFree(GetProcessHeap(), 0, files);
528 return hr;
529 }
530
531 TRACE("Acting on %d file(s).\n", file_count);
532
533 pidla = HeapAlloc(GetProcessHeap(), 0, sizeof(LPITEMIDLIST) * file_count);
534 open_action = ONOPEN_OPEN;
535 fn_iter = files;
536
537 for(i = 0; i < file_count && open_action == ONOPEN_OPEN; i++)
538 {
539 WCHAR canon_filename[MAX_PATH];
540 psf_parent = NULL;
541
542 COMDLG32_GetCanonicalPath(current_folder, fn_iter, canon_filename);
543
544 if( (This->options & FOS_NOVALIDATE) &&
545 !(This->options & FOS_FILEMUSTEXIST) )
546 open_action = ONOPEN_OPEN;
547 else
548 open_action = ONOPEN_BROWSE;
549
550 open_action = FILEDLG95_ValidatePathAction(canon_filename, &psf_parent, This->dlg_hwnd,
551 This->options & ~FOS_FILEMUSTEXIST,
552 (This->dlg_type == ITEMDLG_TYPE_SAVE),
553 open_action);
554
555 /* Add the proper extension */
556 if(open_action == ONOPEN_OPEN)
557 {
558 static const WCHAR dotW[] = {'.',0};
559
560 if(This->dlg_type == ITEMDLG_TYPE_SAVE)
561 {
562 WCHAR extbuf[MAX_PATH], *newext = NULL;
563
564 if(This->filterspec_count)
565 {
566 newext = get_first_ext_from_spec(extbuf, This->filterspecs[This->filetypeindex].pszSpec);
567 }
568 else if(This->default_ext)
569 {
570 lstrcpyW(extbuf, dotW);
571 lstrcatW(extbuf, This->default_ext);
572 newext = extbuf;
573 }
574
575 if(newext)
576 {
577 WCHAR *ext = PathFindExtensionW(canon_filename);
578 if(lstrcmpW(ext, newext))
579 lstrcatW(canon_filename, newext);
580 }
581 }
582 else
583 {
584 if( !(This->options & FOS_NOVALIDATE) && (This->options & FOS_FILEMUSTEXIST) &&
585 !PathFileExistsW(canon_filename))
586 {
587 if(This->default_ext)
588 {
589 lstrcatW(canon_filename, dotW);
590 lstrcatW(canon_filename, This->default_ext);
591
592 if(!PathFileExistsW(canon_filename))
593 {
594 FILEDLG95_OnOpenMessage(This->dlg_hwnd, 0, IDS_FILENOTEXISTING);
595 open_action = ONOPEN_BROWSE;
596 }
597 }
598 else
599 {
600 FILEDLG95_OnOpenMessage(This->dlg_hwnd, 0, IDS_FILENOTEXISTING);
601 open_action = ONOPEN_BROWSE;
602 }
603 }
604 }
605 }
606
607 pidla[i] = COMDLG32_SHSimpleIDListFromPathAW(canon_filename);
608
609 if(psf_parent && !(open_action == ONOPEN_BROWSE))
610 IShellFolder_Release(psf_parent);
611
612 fn_iter += (WCHAR)lstrlenW(fn_iter) + 1;
613 }
614
615 HeapFree(GetProcessHeap(), 0, files);
616 ILFree(current_folder);
617
618 if((This->options & FOS_PICKFOLDERS) && open_action == ONOPEN_BROWSE)
619 open_action = ONOPEN_OPEN; /* FIXME: Multiple folders? */
620
621 switch(open_action)
622 {
623 case ONOPEN_SEARCH:
624 FIXME("Filtering not implemented.\n");
625 break;
626
627 case ONOPEN_BROWSE:
628 hr = IExplorerBrowser_BrowseToObject(This->peb, (IUnknown*)psf_parent, SBSP_DEFBROWSER);
629 if(FAILED(hr))
630 ERR("Failed to browse to directory: %08x\n", hr);
631
632 IShellFolder_Release(psf_parent);
633 break;
634
635 case ONOPEN_OPEN:
636 hr = SHGetDesktopFolder(&psf_desktop);
637 if(SUCCEEDED(hr))
638 {
639 if(This->psia_results)
640 {
641 IShellItemArray_Release(This->psia_results);
642 This->psia_results = NULL;
643 }
644
645 hr = SHCreateShellItemArray(NULL, psf_desktop, file_count, (PCUITEMID_CHILD_ARRAY)pidla,
646 &This->psia_results);
647
648 IShellFolder_Release(psf_desktop);
649
650 if(FAILED(hr))
651 break;
652
653 if(This->options & FOS_PICKFOLDERS)
654 {
655 SFGAOF attributes;
656 hr = IShellItemArray_GetAttributes(This->psia_results, SIATTRIBFLAGS_AND, SFGAO_FOLDER, &attributes);
657 if(hr != S_OK)
658 {
659 WCHAR buf[64];
660 LoadStringW(COMDLG32_hInstance, IDS_INVALID_FOLDERNAME, buf, sizeof(buf)/sizeof(WCHAR));
661
662 MessageBoxW(This->dlg_hwnd, buf, This->custom_title, MB_OK | MB_ICONEXCLAMATION);
663
664 IShellItemArray_Release(This->psia_results);
665 This->psia_results = NULL;
666 break;
667 }
668 }
669
670 if((This->options & FOS_OVERWRITEPROMPT) && This->dlg_type == ITEMDLG_TYPE_SAVE)
671 {
672 IShellItem *shellitem;
673
674 for (i=0; SUCCEEDED(hr) && i<file_count; i++)
675 {
676 hr = IShellItemArray_GetItemAt(This->psia_results, i, &shellitem);
677 if (SUCCEEDED(hr))
678 {
679 if (shell_item_exists(shellitem))
680 hr = events_OnOverwrite(This, shellitem);
681
682 IShellItem_Release(shellitem);
683 }
684 }
685
686 if (FAILED(hr))
687 break;
688 }
689
690 if(events_OnFileOk(This) == S_OK)
691 ret = S_OK;
692 }
693 break;
694
695 default:
696 ERR("Failed.\n");
697 break;
698 }
699
700 /* Clean up */
701 for(i = 0; i < file_count; i++)
702 ILFree(pidla[i]);
703 HeapFree(GetProcessHeap(), 0, pidla);
704
705 /* Success closes the dialog */
706 return ret;
707 }
708
709 static void show_opendropdown(FileDialogImpl *This)
710 {
711 HWND open_hwnd;
712 RECT open_rc;
713 MSG msg;
714
715 open_hwnd = GetDlgItem(This->dlg_hwnd, IDOK);
716
717 GetWindowRect(open_hwnd, &open_rc);
718
719 if (TrackPopupMenu(This->hmenu_opendropdown, 0, open_rc.left, open_rc.bottom, 0, This->dlg_hwnd, NULL) &&
720 PeekMessageW(&msg, This->dlg_hwnd, WM_MENUCOMMAND, WM_MENUCOMMAND, PM_REMOVE))
721 {
722 MENUITEMINFOW mii;
723
724 This->opendropdown_has_selection = TRUE;
725
726 mii.cbSize = sizeof(mii);
727 mii.fMask = MIIM_ID;
728 GetMenuItemInfoW((HMENU)msg.lParam, msg.wParam, TRUE, &mii);
729 This->opendropdown_selection = mii.wID;
730
731 if(SUCCEEDED(on_default_action(This)))
732 EndDialog(This->dlg_hwnd, S_OK);
733 else
734 This->opendropdown_has_selection = FALSE;
735 }
736 }
737
738 /**************************************************************************
739 * Control item functions.
740 */
741
742 static void item_free(cctrl_item *item)
743 {
744 DestroyWindow(item->hwnd);
745 HeapFree(GetProcessHeap(), 0, item->label);
746 HeapFree(GetProcessHeap(), 0, item);
747 }
748
749 static cctrl_item* get_item(customctrl* parent, DWORD itemid, CDCONTROLSTATEF visible_flags, DWORD* position)
750 {
751 DWORD dummy;
752 cctrl_item* item;
753
754 if (!position) position = &dummy;
755
756 *position = 0;
757
758 LIST_FOR_EACH_ENTRY(item, &parent->sub_items, cctrl_item, entry)
759 {
760 if (item->id == itemid)
761 return item;
762
763 if ((item->cdcstate & visible_flags) == visible_flags)
764 (*position)++;
765 }
766
767 return NULL;
768 }
769
770 static cctrl_item* get_first_item(customctrl* parent)
771 {
772 cctrl_item* item;
773
774 LIST_FOR_EACH_ENTRY(item, &parent->sub_items, cctrl_item, entry)
775 {
776 if ((item->cdcstate & (CDCS_VISIBLE|CDCS_ENABLED)) == (CDCS_VISIBLE|CDCS_ENABLED))
777 return item;
778 }
779
780 return NULL;
781 }
782
783 static HRESULT add_item(customctrl* parent, DWORD itemid, LPCWSTR label, cctrl_item** result)
784 {
785 cctrl_item* item;
786 LPWSTR label_copy;
787
788 if (get_item(parent, itemid, 0, NULL))
789 return E_INVALIDARG;
790
791 item = HeapAlloc(GetProcessHeap(), 0, sizeof(*item));
792 label_copy = HeapAlloc(GetProcessHeap(), 0, (lstrlenW(label)+1)*sizeof(WCHAR));
793
794 if (!item || !label_copy)
795 {
796 HeapFree(GetProcessHeap(), 0, item);
797 HeapFree(GetProcessHeap(), 0, label_copy);
798 return E_OUTOFMEMORY;
799 }
800
801 item->id = itemid;
802 item->parent_id = parent->id;
803 lstrcpyW(label_copy, label);
804 item->label = label_copy;
805 item->cdcstate = CDCS_VISIBLE|CDCS_ENABLED;
806 item->hwnd = NULL;
807 list_add_tail(&parent->sub_items, &item->entry);
808
809 *result = item;
810
811 return S_OK;
812 }
813
814 /**************************************************************************
815 * Control functions.
816 */
817 static inline customctrl *get_cctrl_from_dlgid(FileDialogImpl *This, DWORD dlgid)
818 {
819 customctrl *ctrl, *sub_ctrl;
820
821 LIST_FOR_EACH_ENTRY(ctrl, &This->cctrls, customctrl, entry)
822 {
823 if(ctrl->dlgid == dlgid)
824 return ctrl;
825
826 LIST_FOR_EACH_ENTRY(sub_ctrl, &ctrl->sub_cctrls, customctrl, sub_cctrls_entry)
827 if(sub_ctrl->dlgid == dlgid)
828 return sub_ctrl;
829 }
830
831 ERR("Failed to find control with dialog id %d\n", dlgid);
832 return NULL;
833 }
834
835 static inline customctrl *get_cctrl(FileDialogImpl *This, DWORD ctlid)
836 {
837 customctrl *ctrl, *sub_ctrl;
838
839 LIST_FOR_EACH_ENTRY(ctrl, &This->cctrls, customctrl, entry)
840 {
841 if(ctrl->id == ctlid)
842 return ctrl;
843
844 LIST_FOR_EACH_ENTRY(sub_ctrl, &ctrl->sub_cctrls, customctrl, sub_cctrls_entry)
845 if(sub_ctrl->id == ctlid)
846 return sub_ctrl;
847 }
848
849 if (This->hmenu_opendropdown && This->cctrl_opendropdown.id == ctlid)
850 return &This->cctrl_opendropdown;
851
852 TRACE("No existing control with control id %d\n", ctlid);
853 return NULL;
854 }
855
856 static void ctrl_resize(HWND hctrl, UINT min_width, UINT max_width, BOOL multiline)
857 {
858 LPWSTR text;
859 UINT len, final_width;
860 UINT lines, final_height;
861 SIZE size;
862 RECT rc;
863 HDC hdc;
864 WCHAR *c;
865 HFONT font;
866
867 TRACE("\n");
868
869 len = SendMessageW(hctrl, WM_GETTEXTLENGTH, 0, 0);
870 text = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR)*(len+1));
871 if(!text) return;
872 SendMessageW(hctrl, WM_GETTEXT, len+1, (LPARAM)text);
873
874 hdc = GetDC(hctrl);
875 font = (HFONT)SendMessageW(hctrl, WM_GETFONT, 0, 0);
876 font = SelectObject(hdc, font);
877 GetTextExtentPoint32W(hdc, text, lstrlenW(text), &size);
878 SelectObject(hdc, font);
879 ReleaseDC(hctrl, hdc);
880
881 if(len && multiline)
882 {
883 /* FIXME: line-wrap */
884 for(lines = 1, c = text; *c != '\0'; c++)
885 if(*c == '\n') lines++;
886
887 final_height = size.cy*lines + 2*4;
888 }
889 else
890 {
891 GetWindowRect(hctrl, &rc);
892 final_height = rc.bottom - rc.top;
893 }
894
895 final_width = min(max(size.cx, min_width) + 4, max_width);
896 SetWindowPos(hctrl, NULL, 0, 0, final_width, final_height,
897 SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
898
899 HeapFree(GetProcessHeap(), 0, text);
900 }
901
902 static UINT ctrl_get_height(customctrl *ctrl) {
903 RECT rc;
904 GetWindowRect(ctrl->wrapper_hwnd, &rc);
905 return rc.bottom - rc.top;
906 }
907
908 static void ctrl_free(customctrl *ctrl)
909 {
910 customctrl *sub_cur1, *sub_cur2;
911 cctrl_item *item_cur1, *item_cur2;
912
913 TRACE("Freeing control %p\n", ctrl);
914 if(ctrl->type == IDLG_CCTRL_MENU)
915 {
916 TBBUTTON tbb;
917 SendMessageW(ctrl->hwnd, TB_GETBUTTON, 0, (LPARAM)&tbb);
918 DestroyMenu((HMENU)tbb.dwData);
919 }
920
921 LIST_FOR_EACH_ENTRY_SAFE(sub_cur1, sub_cur2, &ctrl->sub_cctrls, customctrl, sub_cctrls_entry)
922 {
923 list_remove(&sub_cur1->sub_cctrls_entry);
924 ctrl_free(sub_cur1);
925 }
926
927 LIST_FOR_EACH_ENTRY_SAFE(item_cur1, item_cur2, &ctrl->sub_items, cctrl_item, entry)
928 {
929 list_remove(&item_cur1->entry);
930 item_free(item_cur1);
931 }
932
933 DestroyWindow(ctrl->hwnd);
934 HeapFree(GetProcessHeap(), 0, ctrl);
935 }
936
937 static void customctrl_resize(FileDialogImpl *This, customctrl *ctrl)
938 {
939 RECT rc;
940 UINT total_height;
941 UINT max_width, size;
942 customctrl *sub_ctrl;
943
944 switch(ctrl->type)
945 {
946 case IDLG_CCTRL_PUSHBUTTON:
947 case IDLG_CCTRL_COMBOBOX:
948 case IDLG_CCTRL_CHECKBUTTON:
949 case IDLG_CCTRL_TEXT:
950 size = MulDiv(160, This->dpi_x, USER_DEFAULT_SCREEN_DPI);
951 ctrl_resize(ctrl->hwnd, size, size, TRUE);
952 GetWindowRect(ctrl->hwnd, &rc);
953 SetWindowPos(ctrl->wrapper_hwnd, NULL, 0, 0, rc.right-rc.left, rc.bottom-rc.top,
954 SWP_NOZORDER|SWP_NOMOVE);
955 break;
956 case IDLG_CCTRL_VISUALGROUP:
957 total_height = 0;
958 ctrl_resize(ctrl->hwnd, 0, This->cctrl_indent, TRUE);
959
960 LIST_FOR_EACH_ENTRY(sub_ctrl, &ctrl->sub_cctrls, customctrl, sub_cctrls_entry)
961 {
962 customctrl_resize(This, sub_ctrl);
963 SetWindowPos(sub_ctrl->wrapper_hwnd, NULL, This->cctrl_indent, total_height, 0, 0,
964 SWP_NOZORDER|SWP_NOSIZE);
965
966 total_height += ctrl_get_height(sub_ctrl);
967 }
968
969 /* The label should be right adjusted */
970 {
971 UINT width, height;
972
973 GetWindowRect(ctrl->hwnd, &rc);
974 width = rc.right - rc.left;
975 height = rc.bottom - rc.top;
976
977 SetWindowPos(ctrl->hwnd, NULL, This->cctrl_indent - width, 0, width, height, SWP_NOZORDER);
978 }
979
980 /* Resize the wrapper window to fit all the sub controls */
981 SetWindowPos(ctrl->wrapper_hwnd, NULL, 0, 0, This->cctrl_width + This->cctrl_indent, total_height,
982 SWP_NOZORDER|SWP_NOMOVE);
983 break;
984 case IDLG_CCTRL_RADIOBUTTONLIST:
985 {
986 cctrl_item* item;
987
988 total_height = 0;
989 max_width = 0;
990
991 LIST_FOR_EACH_ENTRY(item, &ctrl->sub_items, cctrl_item, entry)
992 {
993 size = MulDiv(160, This->dpi_x, USER_DEFAULT_SCREEN_DPI);
994 ctrl_resize(item->hwnd, size, size, TRUE);
995 SetWindowPos(item->hwnd, NULL, 0, total_height, 0, 0,
996 SWP_NOZORDER|SWP_NOSIZE);
997
998 GetWindowRect(item->hwnd, &rc);
999
1000 total_height += rc.bottom - rc.top;
1001 max_width = max(rc.right - rc.left, max_width);
1002 }
1003
1004 SetWindowPos(ctrl->hwnd, NULL, 0, 0, max_width, total_height,
1005 SWP_NOZORDER|SWP_NOMOVE);
1006
1007 SetWindowPos(ctrl->wrapper_hwnd, NULL, 0, 0, max_width, total_height,
1008 SWP_NOZORDER|SWP_NOMOVE);
1009
1010 break;
1011 }
1012 case IDLG_CCTRL_EDITBOX:
1013 case IDLG_CCTRL_SEPARATOR:
1014 case IDLG_CCTRL_MENU:
1015 case IDLG_CCTRL_OPENDROPDOWN:
1016 /* Nothing */
1017 break;
1018 }
1019 }
1020
1021 static LRESULT notifysink_on_create(HWND hwnd, CREATESTRUCTW *crs)
1022 {
1023 FileDialogImpl *This = crs->lpCreateParams;
1024 TRACE("%p\n", This);
1025
1026 SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LPARAM)This);
1027 return TRUE;
1028 }
1029
1030 static LRESULT notifysink_on_bn_clicked(FileDialogImpl *This, HWND hwnd, WPARAM wparam)
1031 {
1032 customctrl *ctrl = get_cctrl_from_dlgid(This, LOWORD(wparam));
1033
1034 TRACE("%p, %lx\n", This, wparam);
1035
1036 if(ctrl)
1037 {
1038 if(ctrl->type == IDLG_CCTRL_CHECKBUTTON)
1039 {
1040 BOOL checked = (SendMessageW(ctrl->hwnd, BM_GETCHECK, 0, 0) == BST_CHECKED);
1041 cctrl_event_OnCheckButtonToggled(This, ctrl->id, checked);
1042 }
1043 else
1044 cctrl_event_OnButtonClicked(This, ctrl->id);
1045 }
1046
1047 return TRUE;
1048 }
1049
1050 static LRESULT notifysink_on_cbn_selchange(FileDialogImpl *This, HWND hwnd, WPARAM wparam)
1051 {
1052 customctrl *ctrl = get_cctrl_from_dlgid(This, LOWORD(wparam));
1053 TRACE("%p, %p (%lx)\n", This, ctrl, wparam);
1054
1055 if(ctrl)
1056 {
1057 UINT index = SendMessageW(ctrl->hwnd, CB_GETCURSEL, 0, 0);
1058 UINT selid = SendMessageW(ctrl->hwnd, CB_GETITEMDATA, index, 0);
1059
1060 cctrl_event_OnItemSelected(This, ctrl->id, selid);
1061 }
1062 return TRUE;
1063 }
1064
1065 static LRESULT notifysink_on_tvn_dropdown(FileDialogImpl *This, LPARAM lparam)
1066 {
1067 NMTOOLBARW *nmtb = (NMTOOLBARW*)lparam;
1068 customctrl *ctrl = get_cctrl_from_dlgid(This, GetDlgCtrlID(nmtb->hdr.hwndFrom));
1069 POINT pt = { 0, nmtb->rcButton.bottom };
1070 TBBUTTON tbb;
1071 UINT idcmd;
1072
1073 TRACE("%p, %p (%lx)\n", This, ctrl, lparam);
1074
1075 if(ctrl)
1076 {
1077 cctrl_event_OnControlActivating(This,ctrl->id);
1078
1079 SendMessageW(ctrl->hwnd, TB_GETBUTTON, 0, (LPARAM)&tbb);
1080 ClientToScreen(ctrl->hwnd, &pt);
1081 idcmd = TrackPopupMenu((HMENU)tbb.dwData, TPM_RETURNCMD, pt.x, pt.y, 0, This->dlg_hwnd, NULL);
1082 if(idcmd)
1083 cctrl_event_OnItemSelected(This, ctrl->id, idcmd);
1084 }
1085
1086 return TBDDRET_DEFAULT;
1087 }
1088
1089 static LRESULT notifysink_on_wm_command(FileDialogImpl *This, HWND hwnd, WPARAM wparam, LPARAM lparam)
1090 {
1091 switch(HIWORD(wparam))
1092 {
1093 case BN_CLICKED: return notifysink_on_bn_clicked(This, hwnd, wparam);
1094 case CBN_SELCHANGE: return notifysink_on_cbn_selchange(This, hwnd, wparam);
1095 }
1096
1097 return FALSE;
1098 }
1099
1100 static LRESULT notifysink_on_wm_notify(FileDialogImpl *This, HWND hwnd, WPARAM wparam, LPARAM lparam)
1101 {
1102 NMHDR *nmhdr = (NMHDR*)lparam;
1103
1104 switch(nmhdr->code)
1105 {
1106 case TBN_DROPDOWN: return notifysink_on_tvn_dropdown(This, lparam);
1107 }
1108
1109 return FALSE;
1110 }
1111
1112 static LRESULT CALLBACK notifysink_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
1113 {
1114 FileDialogImpl *This = (FileDialogImpl*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
1115 customctrl *ctrl;
1116 HWND hwnd_child;
1117 RECT rc;
1118
1119 switch(message)
1120 {
1121 case WM_NCCREATE: return notifysink_on_create(hwnd, (CREATESTRUCTW*)lparam);
1122 case WM_COMMAND: return notifysink_on_wm_command(This, hwnd, wparam, lparam);
1123 case WM_NOTIFY: return notifysink_on_wm_notify(This, hwnd, wparam, lparam);
1124 case WM_SIZE:
1125 hwnd_child = GetPropW(hwnd, notifysink_childW);
1126 ctrl = (customctrl*)GetWindowLongPtrW(hwnd_child, GWLP_USERDATA);
1127 if(ctrl && ctrl->type != IDLG_CCTRL_VISUALGROUP)
1128 {
1129 GetClientRect(hwnd, &rc);
1130 SetWindowPos(hwnd_child, NULL, 0, 0, rc.right, rc.bottom, SWP_NOMOVE|SWP_NOACTIVATE|SWP_NOZORDER);
1131 }
1132 return TRUE;
1133 }
1134
1135 return DefWindowProcW(hwnd, message, wparam, lparam);
1136 }
1137
1138 static HRESULT cctrl_create_new(FileDialogImpl *This, DWORD id,
1139 LPCWSTR text, LPCWSTR wndclass, DWORD ctrl_wsflags,
1140 DWORD ctrl_exflags, UINT height, customctrl **ppctrl)
1141 {
1142 HWND ns_hwnd, control_hwnd, parent_hwnd;
1143 DWORD wsflags = WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS;
1144 customctrl *ctrl;
1145
1146 if(get_cctrl(This, id))
1147 return E_UNEXPECTED; /* Duplicate id */
1148
1149 if(This->cctrl_active_vg)
1150 parent_hwnd = This->cctrl_active_vg->wrapper_hwnd;
1151 else
1152 parent_hwnd = This->cctrls_hwnd;
1153
1154 ns_hwnd = CreateWindowExW(0, floatnotifysinkW, NULL, wsflags,
1155 0, 0, This->cctrl_width, height, parent_hwnd,
1156 (HMENU)This->cctrl_next_dlgid, COMDLG32_hInstance, This);
1157 control_hwnd = CreateWindowExW(ctrl_exflags, wndclass, text, wsflags | ctrl_wsflags,
1158 0, 0, This->cctrl_width, height, ns_hwnd,
1159 (HMENU)This->cctrl_next_dlgid, COMDLG32_hInstance, 0);
1160
1161 if(!ns_hwnd || !control_hwnd)
1162 {
1163 ERR("Failed to create wrapper (%p) or control (%p)\n", ns_hwnd, control_hwnd);
1164 DestroyWindow(ns_hwnd);
1165 DestroyWindow(control_hwnd);
1166
1167 return E_FAIL;
1168 }
1169
1170 SetPropW(ns_hwnd, notifysink_childW, control_hwnd);
1171
1172 ctrl = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(customctrl));
1173 if(!ctrl)
1174 return E_OUTOFMEMORY;
1175
1176 ctrl->hwnd = control_hwnd;
1177 ctrl->wrapper_hwnd = ns_hwnd;
1178 ctrl->id = id;
1179 ctrl->dlgid = This->cctrl_next_dlgid;
1180 ctrl->cdcstate = CDCS_ENABLED | CDCS_VISIBLE;
1181 list_init(&ctrl->sub_cctrls);
1182 list_init(&ctrl->sub_items);
1183
1184 if(This->cctrl_active_vg)
1185 list_add_tail(&This->cctrl_active_vg->sub_cctrls, &ctrl->sub_cctrls_entry);
1186 else
1187 list_add_tail(&This->cctrls, &ctrl->entry);
1188
1189 SetWindowLongPtrW(ctrl->hwnd, GWLP_USERDATA, (LPARAM)ctrl);
1190
1191 if(ppctrl) *ppctrl = ctrl;
1192
1193 This->cctrl_next_dlgid++;
1194 return S_OK;
1195 }
1196
1197 /**************************************************************************
1198 * Container functions.
1199 */
1200 static UINT ctrl_container_resize(FileDialogImpl *This, UINT container_width)
1201 {
1202 UINT container_height;
1203 UINT column_width;
1204 UINT nr_of_cols;
1205 UINT max_control_height, total_height = 0;
1206 UINT cur_col_pos, cur_row_pos;
1207 customctrl *ctrl;
1208 BOOL fits_height;
1209 UINT cspacing = MulDiv(90, This->dpi_x, USER_DEFAULT_SCREEN_DPI); /* Columns are spaced with 90px */
1210 UINT rspacing = MulDiv(4, This->dpi_y, USER_DEFAULT_SCREEN_DPI); /* Rows are spaced with 4 px. */
1211
1212 /* Given the new width of the container, this function determines the
1213 * needed height of the container and places the controls according to
1214 * the new layout. Returns the new height.
1215 */
1216
1217 TRACE("%p\n", This);
1218
1219 column_width = This->cctrl_width + cspacing;
1220 nr_of_cols = (container_width - This->cctrl_indent + cspacing) / column_width;
1221
1222 /* We don't need to do anything unless the number of visible columns has changed. */
1223 if(nr_of_cols == This->cctrls_cols)
1224 {
1225 RECT rc;
1226 GetWindowRect(This->cctrls_hwnd, &rc);
1227 return rc.bottom - rc.top;
1228 }
1229
1230 This->cctrls_cols = nr_of_cols;
1231
1232 /* Get the size of the tallest control, and the total size of
1233 * all the controls to figure out the number of slots we need.
1234 */
1235 max_control_height = 0;
1236 LIST_FOR_EACH_ENTRY(ctrl, &This->cctrls, customctrl, entry)
1237 {
1238 if(ctrl->cdcstate & CDCS_VISIBLE)
1239 {
1240 UINT control_height = ctrl_get_height(ctrl);
1241 max_control_height = max(max_control_height, control_height);
1242
1243 total_height += control_height + rspacing;
1244 }
1245 }
1246
1247 if(!total_height)
1248 return 0;
1249
1250 container_height = max(total_height / nr_of_cols, max_control_height + rspacing);
1251 TRACE("Guess: container_height: %d\n",container_height);
1252
1253 /* Incrementally increase container_height until all the controls
1254 * fit.
1255 */
1256 do {
1257 UINT columns_needed = 1;
1258 cur_row_pos = 0;
1259
1260 fits_height = TRUE;
1261 LIST_FOR_EACH_ENTRY(ctrl, &This->cctrls, customctrl, entry)
1262 {
1263 if(ctrl->cdcstate & CDCS_VISIBLE)
1264 {
1265 UINT control_height = ctrl_get_height(ctrl);
1266
1267 if(cur_row_pos + control_height > container_height)
1268 {
1269 if(++columns_needed > nr_of_cols)
1270 {
1271 container_height += 1;
1272 fits_height = FALSE;
1273 break;
1274 }
1275 cur_row_pos = 0;
1276 }
1277
1278 cur_row_pos += control_height + rspacing;
1279 }
1280 }
1281 } while(!fits_height);
1282
1283 TRACE("Final container height: %d\n", container_height);
1284
1285 /* Move the controls to their final destination
1286 */
1287 cur_col_pos = 0, cur_row_pos = 0;
1288 LIST_FOR_EACH_ENTRY(ctrl, &This->cctrls, customctrl, entry)
1289 {
1290 if(ctrl->cdcstate & CDCS_VISIBLE)
1291 {
1292 RECT rc;
1293 UINT control_height, control_indent;
1294 GetWindowRect(ctrl->wrapper_hwnd, &rc);
1295 control_height = rc.bottom - rc.top;
1296
1297 if(cur_row_pos + control_height > container_height)
1298 {
1299 cur_row_pos = 0;
1300 cur_col_pos += This->cctrl_width + cspacing;
1301 }
1302
1303
1304 if(ctrl->type == IDLG_CCTRL_VISUALGROUP)
1305 control_indent = 0;
1306 else
1307 control_indent = This->cctrl_indent;
1308
1309 SetWindowPos(ctrl->wrapper_hwnd, NULL, cur_col_pos + control_indent, cur_row_pos, 0, 0,
1310 SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
1311
1312 cur_row_pos += control_height + rspacing;
1313 }
1314 }
1315
1316 /* Sanity check */
1317 if(cur_row_pos + This->cctrl_width > container_width)
1318 ERR("-- Failed to place controls properly.\n");
1319
1320 return container_height;
1321 }
1322
1323 static void ctrl_set_font(customctrl *ctrl, HFONT font)
1324 {
1325 customctrl *sub_ctrl;
1326 cctrl_item* item;
1327
1328 SendMessageW(ctrl->hwnd, WM_SETFONT, (WPARAM)font, TRUE);
1329
1330 LIST_FOR_EACH_ENTRY(sub_ctrl, &ctrl->sub_cctrls, customctrl, sub_cctrls_entry)
1331 {
1332 ctrl_set_font(sub_ctrl, font);
1333 }
1334
1335 if (ctrl->type == IDLG_CCTRL_RADIOBUTTONLIST)
1336 {
1337 LIST_FOR_EACH_ENTRY(item, &ctrl->sub_items, cctrl_item, entry)
1338 {
1339 SendMessageW(item->hwnd, WM_SETFONT, (WPARAM)font, TRUE);
1340 }
1341 }
1342 }
1343
1344 static void ctrl_container_reparent(FileDialogImpl *This, HWND parent)
1345 {
1346 LONG wndstyle;
1347
1348 if(parent)
1349 {
1350 customctrl *ctrl;
1351 HFONT font;
1352
1353 wndstyle = GetWindowLongW(This->cctrls_hwnd, GWL_STYLE);
1354 wndstyle &= ~(WS_POPUP);
1355 wndstyle |= WS_CHILD;
1356 SetWindowLongW(This->cctrls_hwnd, GWL_STYLE, wndstyle);
1357
1358 SetParent(This->cctrls_hwnd, parent);
1359 ShowWindow(This->cctrls_hwnd, TRUE);
1360
1361 /* Set the fonts to match the dialog font. */
1362 font = (HFONT)SendMessageW(parent, WM_GETFONT, 0, 0);
1363 if(!font)
1364 ERR("Failed to get font handle from dialog.\n");
1365
1366 LIST_FOR_EACH_ENTRY(ctrl, &This->cctrls, customctrl, entry)
1367 {
1368 if(font) ctrl_set_font(ctrl, font);
1369 customctrl_resize(This, ctrl);
1370 }
1371 }
1372 else
1373 {
1374 ShowWindow(This->cctrls_hwnd, FALSE);
1375
1376 wndstyle = GetWindowLongW(This->cctrls_hwnd, GWL_STYLE);
1377 wndstyle &= ~(WS_CHILD);
1378 wndstyle |= WS_POPUP;
1379 SetWindowLongW(This->cctrls_hwnd, GWL_STYLE, wndstyle);
1380
1381 SetParent(This->cctrls_hwnd, NULL);
1382 }
1383 }
1384
1385 static LRESULT ctrl_container_on_create(HWND hwnd, CREATESTRUCTW *crs)
1386 {
1387 FileDialogImpl *This = crs->lpCreateParams;
1388 TRACE("%p\n", This);
1389
1390 SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LPARAM)This);
1391 return TRUE;
1392 }
1393
1394 static LRESULT ctrl_container_on_wm_destroy(FileDialogImpl *This)
1395 {
1396 customctrl *cur1, *cur2;
1397 TRACE("%p\n", This);
1398
1399 LIST_FOR_EACH_ENTRY_SAFE(cur1, cur2, &This->cctrls, customctrl, entry)
1400 {
1401 list_remove(&cur1->entry);
1402 ctrl_free(cur1);
1403 }
1404
1405 return TRUE;
1406 }
1407
1408 static LRESULT CALLBACK ctrl_container_wndproc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam)
1409 {
1410 FileDialogImpl *This = (FileDialogImpl*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
1411
1412 switch(umessage)
1413 {
1414 case WM_NCCREATE: return ctrl_container_on_create(hwnd, (CREATESTRUCTW*)lparam);
1415 case WM_DESTROY: return ctrl_container_on_wm_destroy(This);
1416 default: return DefWindowProcW(hwnd, umessage, wparam, lparam);
1417 }
1418
1419 return FALSE;
1420 }
1421
1422 static void radiobuttonlist_set_selected_item(FileDialogImpl *This, customctrl *ctrl, cctrl_item *item)
1423 {
1424 cctrl_item *cursor;
1425
1426 LIST_FOR_EACH_ENTRY(cursor, &ctrl->sub_items, cctrl_item, entry)
1427 {
1428 SendMessageW(cursor->hwnd, BM_SETCHECK, (cursor == item) ? BST_CHECKED : BST_UNCHECKED, 0);
1429 }
1430 }
1431
1432 static LRESULT radiobuttonlist_on_bn_clicked(FileDialogImpl *This, HWND hwnd, HWND child)
1433 {
1434 DWORD ctrl_id = (DWORD)GetWindowLongPtrW(hwnd, GWLP_ID);
1435 customctrl *ctrl;
1436 cctrl_item *item;
1437 BOOL found_item=FALSE;
1438
1439 ctrl = get_cctrl_from_dlgid(This, ctrl_id);
1440
1441 if (!ctrl)
1442 {
1443 ERR("Can't find this control\n");
1444 return 0;
1445 }
1446
1447 LIST_FOR_EACH_ENTRY(item, &ctrl->sub_items, cctrl_item, entry)
1448 {
1449 if (item->hwnd == child)
1450 {
1451 found_item = TRUE;
1452 break;
1453 }
1454 }
1455
1456 if (!found_item)
1457 {
1458 ERR("Can't find control item\n");
1459 return 0;
1460 }
1461
1462 radiobuttonlist_set_selected_item(This, ctrl, item);
1463
1464 cctrl_event_OnItemSelected(This, ctrl->id, item->id);
1465
1466 return 0;
1467 }
1468
1469 static LRESULT radiobuttonlist_on_wm_command(FileDialogImpl *This, HWND hwnd, WPARAM wparam, LPARAM lparam)
1470 {
1471 switch(HIWORD(wparam))
1472 {
1473 case BN_CLICKED: return radiobuttonlist_on_bn_clicked(This, hwnd, (HWND)lparam);
1474 }
1475
1476 return FALSE;
1477 }
1478
1479 static LRESULT CALLBACK radiobuttonlist_proc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
1480 {
1481 FileDialogImpl *This = (FileDialogImpl*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
1482
1483 switch(message)
1484 {
1485 case WM_COMMAND: return radiobuttonlist_on_wm_command(This, hwnd, wparam, lparam);
1486 }
1487
1488 return DefWindowProcW(hwnd, message, wparam, lparam);
1489 }
1490
1491 static HRESULT init_custom_controls(FileDialogImpl *This)
1492 {
1493 WNDCLASSW wc;
1494 HDC hdc;
1495 static const WCHAR ctrl_container_classname[] =
1496 {'i','d','l','g','_','c','o','n','t','a','i','n','e','r','_','p','a','n','e',0};
1497
1498 InitCommonControlsEx(NULL);
1499
1500 if( !GetClassInfoW(COMDLG32_hInstance, ctrl_container_classname, &wc) )
1501 {
1502 wc.style = CS_HREDRAW | CS_VREDRAW;
1503 wc.lpfnWndProc = ctrl_container_wndproc;
1504 wc.cbClsExtra = 0;
1505 wc.cbWndExtra = 0;
1506 wc.hInstance = COMDLG32_hInstance;
1507 wc.hIcon = 0;
1508 wc.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
1509 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
1510 wc.lpszMenuName = NULL;
1511 wc.lpszClassName = ctrl_container_classname;
1512
1513 if(!RegisterClassW(&wc)) return E_FAIL;
1514 }
1515
1516 This->cctrls_hwnd = CreateWindowExW(0, ctrl_container_classname, NULL,
1517 WS_CLIPSIBLINGS | WS_CLIPCHILDREN,
1518 0, 0, 0, 0, NULL, 0,
1519 COMDLG32_hInstance, This);
1520 if(!This->cctrls_hwnd)
1521 return E_FAIL;
1522
1523 hdc = GetDC(This->cctrls_hwnd);
1524 This->dpi_x = GetDeviceCaps(hdc, LOGPIXELSX);
1525 This->dpi_y = GetDeviceCaps(hdc, LOGPIXELSY);
1526 ReleaseDC(This->cctrls_hwnd, hdc);
1527
1528 This->cctrl_width = MulDiv(160, This->dpi_x, USER_DEFAULT_SCREEN_DPI); /* Controls have a fixed width */
1529 This->cctrl_indent = MulDiv(100, This->dpi_x, USER_DEFAULT_SCREEN_DPI);
1530 This->cctrl_def_height = MulDiv(23, This->dpi_y, USER_DEFAULT_SCREEN_DPI);
1531 This->cctrls_cols = 0;
1532
1533 This->cctrl_next_dlgid = 0x2000;
1534 list_init(&This->cctrls);
1535 This->cctrl_active_vg = NULL;
1536
1537 SetWindowLongW(This->cctrls_hwnd, GWL_STYLE, WS_TABSTOP);
1538
1539 /* Register class for */
1540 if( !GetClassInfoW(COMDLG32_hInstance, floatnotifysinkW, &wc) ||
1541 wc.hInstance != COMDLG32_hInstance)
1542 {
1543 wc.style = CS_HREDRAW | CS_VREDRAW;
1544 wc.lpfnWndProc = notifysink_proc;
1545 wc.cbClsExtra = 0;
1546 wc.cbWndExtra = 0;
1547 wc.hInstance = COMDLG32_hInstance;
1548 wc.hIcon = 0;
1549 wc.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
1550 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
1551 wc.lpszMenuName = NULL;
1552 wc.lpszClassName = floatnotifysinkW;
1553
1554 if (!RegisterClassW(&wc))
1555 ERR("Failed to register FloatNotifySink window class.\n");
1556 }
1557
1558 if( !GetClassInfoW(COMDLG32_hInstance, radiobuttonlistW, &wc) ||
1559 wc.hInstance != COMDLG32_hInstance)
1560 {
1561 wc.style = CS_HREDRAW | CS_VREDRAW;
1562 wc.lpfnWndProc = radiobuttonlist_proc;
1563 wc.cbClsExtra = 0;
1564 wc.cbWndExtra = 0;
1565 wc.hInstance = COMDLG32_hInstance;
1566 wc.hIcon = 0;
1567 wc.hCursor = LoadCursorW(0, (LPWSTR)IDC_ARROW);
1568 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
1569 wc.lpszMenuName = NULL;
1570 wc.lpszClassName = radiobuttonlistW;
1571
1572 if (!RegisterClassW(&wc))
1573 ERR("Failed to register RadioButtonList window class.\n");
1574 }
1575
1576 return S_OK;
1577 }
1578
1579 /**************************************************************************
1580 * Window related functions.
1581 */
1582 static BOOL update_open_dropdown(FileDialogImpl *This)
1583 {
1584 /* Show or hide the open dropdown button as appropriate */
1585 BOOL show=FALSE, showing;
1586 HWND open_hwnd, dropdown_hwnd;
1587
1588 if (This->hmenu_opendropdown)
1589 {
1590 INT num_visible_items=0;
1591 cctrl_item* item;
1592
1593 LIST_FOR_EACH_ENTRY(item, &This->cctrl_opendropdown.sub_items, cctrl_item, entry)
1594 {
1595 if (item->cdcstate & CDCS_VISIBLE)
1596 {
1597 num_visible_items++;
1598 if (num_visible_items >= 2)
1599 {
1600 show = TRUE;
1601 break;
1602 }
1603 }
1604 }
1605 }
1606
1607 open_hwnd = GetDlgItem(This->dlg_hwnd, IDOK);
1608 dropdown_hwnd = GetDlgItem(This->dlg_hwnd, psh1);
1609
1610 showing = (GetWindowLongPtrW(dropdown_hwnd, GWL_STYLE) & WS_VISIBLE) != 0;
1611
1612 if (showing != show)
1613 {
1614 RECT open_rc, dropdown_rc;
1615
1616 GetWindowRect(open_hwnd, &open_rc);
1617 GetWindowRect(dropdown_hwnd, &dropdown_rc);
1618
1619 if (show)
1620 {
1621 ShowWindow(dropdown_hwnd, SW_SHOW);
1622
1623 SetWindowPos(open_hwnd, NULL, 0, 0,
1624 (open_rc.right - open_rc.left) - (dropdown_rc.right - dropdown_rc.left),
1625 open_rc.bottom - open_rc.top, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
1626 }
1627 else
1628 {
1629 ShowWindow(dropdown_hwnd, SW_HIDE);
1630
1631 SetWindowPos(open_hwnd, NULL, 0, 0,
1632 (open_rc.right - open_rc.left) + (dropdown_rc.right - dropdown_rc.left),
1633 open_rc.bottom - open_rc.top, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE);
1634 }
1635 }
1636
1637 return show;
1638 }
1639
1640 static void update_layout(FileDialogImpl *This)
1641 {
1642 HDWP hdwp;
1643 HWND hwnd;
1644 RECT dialog_rc;
1645 RECT cancel_rc, dropdown_rc, open_rc;
1646 RECT filetype_rc, filename_rc, filenamelabel_rc;
1647 RECT toolbar_rc, ebrowser_rc, customctrls_rc;
1648 static const UINT vspacing = 4, hspacing = 4;
1649 static const UINT min_width = 320, min_height = 200;
1650 BOOL show_dropdown;
1651
1652 if (!GetClientRect(This->dlg_hwnd, &dialog_rc))
1653 {
1654 TRACE("Invalid dialog window, not updating layout\n");
1655 return;
1656 }
1657
1658 if(dialog_rc.right < min_width || dialog_rc.bottom < min_height)
1659 {
1660 TRACE("Dialog size (%d, %d) too small, not updating layout\n", dialog_rc.right, dialog_rc.bottom);
1661 return;
1662 }
1663
1664 /****
1665 * Calculate the size of the dialog and all the parts.
1666 */
1667
1668 /* Cancel button */
1669 hwnd = GetDlgItem(This->dlg_hwnd, IDCANCEL);
1670 if(hwnd)
1671 {
1672 int cancel_width, cancel_height;
1673 GetWindowRect(hwnd, &cancel_rc);
1674 cancel_width = cancel_rc.right - cancel_rc.left;
1675 cancel_height = cancel_rc.bottom - cancel_rc.top;
1676
1677 cancel_rc.left = dialog_rc.right - cancel_width - hspacing;
1678 cancel_rc.top = dialog_rc.bottom - cancel_height - vspacing;
1679 cancel_rc.right = cancel_rc.left + cancel_width;
1680 cancel_rc.bottom = cancel_rc.top + cancel_height;
1681 }
1682
1683 /* Open/Save dropdown */
1684 show_dropdown = update_open_dropdown(This);
1685
1686 if(show_dropdown)
1687 {
1688 int dropdown_width, dropdown_height;
1689 hwnd = GetDlgItem(This->dlg_hwnd, psh1);
1690
1691 GetWindowRect(hwnd, &dropdown_rc);
1692 dropdown_width = dropdown_rc.right - dropdown_rc.left;
1693 dropdown_height = dropdown_rc.bottom - dropdown_rc.top;
1694
1695 dropdown_rc.left = cancel_rc.left - dropdown_width - hspacing;
1696 dropdown_rc.top = cancel_rc.top;
1697 dropdown_rc.right = dropdown_rc.left + dropdown_width;
1698 dropdown_rc.bottom = dropdown_rc.top + dropdown_height;
1699 }
1700 else
1701 {
1702 dropdown_rc.left = dropdown_rc.right = cancel_rc.left - hspacing;
1703 dropdown_rc.top = cancel_rc.top;
1704 dropdown_rc.bottom = cancel_rc.bottom;
1705 }
1706
1707 /* Open/Save button */
1708 hwnd = GetDlgItem(This->dlg_hwnd, IDOK);
1709 if(hwnd)
1710 {
1711 int open_width, open_height;
1712 GetWindowRect(hwnd, &open_rc);
1713 open_width = open_rc.right - open_rc.left;
1714 open_height = open_rc.bottom - open_rc.top;
1715
1716 open_rc.left = dropdown_rc.left - open_width;
1717 open_rc.top = dropdown_rc.top;
1718 open_rc.right = open_rc.left + open_width;
1719 open_rc.bottom = open_rc.top + open_height;
1720 }
1721
1722 /* The filetype combobox. */
1723 hwnd = GetDlgItem(This->dlg_hwnd, IDC_FILETYPE);
1724 if(hwnd)
1725 {
1726 int filetype_width, filetype_height;
1727 GetWindowRect(hwnd, &filetype_rc);
1728
1729 filetype_width = filetype_rc.right - filetype_rc.left;
1730 filetype_height = filetype_rc.bottom - filetype_rc.top;
1731
1732 filetype_rc.right = cancel_rc.right;
1733
1734 filetype_rc.left = filetype_rc.right - filetype_width;
1735 filetype_rc.top = cancel_rc.top - filetype_height - vspacing;
1736 filetype_rc.bottom = filetype_rc.top + filetype_height;
1737
1738 if(!This->filterspec_count)
1739 filetype_rc.left = filetype_rc.right;
1740 }
1741
1742 /* Filename label. */
1743 hwnd = GetDlgItem(This->dlg_hwnd, IDC_FILENAMESTATIC);
1744 if(hwnd)
1745 {
1746 int filetypelabel_width, filetypelabel_height;
1747 GetWindowRect(hwnd, &filenamelabel_rc);
1748
1749 filetypelabel_width = filenamelabel_rc.right - filenamelabel_rc.left;
1750 filetypelabel_height = filenamelabel_rc.bottom - filenamelabel_rc.top;
1751
1752 filenamelabel_rc.left = 160; /* FIXME */
1753 filenamelabel_rc.top = filetype_rc.top;
1754 filenamelabel_rc.right = filenamelabel_rc.left + filetypelabel_width;
1755 filenamelabel_rc.bottom = filenamelabel_rc.top + filetypelabel_height;
1756 }
1757
1758 /* Filename edit box. */
1759 hwnd = GetDlgItem(This->dlg_hwnd, IDC_FILENAME);
1760 if(hwnd)
1761 {
1762 int filename_width, filename_height;
1763 GetWindowRect(hwnd, &filename_rc);
1764
1765 filename_width = filetype_rc.left - filenamelabel_rc.right - hspacing*2;
1766 filename_height = filename_rc.bottom - filename_rc.top;
1767
1768 filename_rc.left = filenamelabel_rc.right + hspacing;
1769 filename_rc.top = filetype_rc.top;
1770 filename_rc.right = filename_rc.left + filename_width;
1771 filename_rc.bottom = filename_rc.top + filename_height;
1772 }
1773
1774 hwnd = GetDlgItem(This->dlg_hwnd, IDC_NAV_TOOLBAR);
1775 if(hwnd)
1776 {
1777 GetWindowRect(hwnd, &toolbar_rc);
1778 MapWindowPoints(NULL, This->dlg_hwnd, (POINT*)&toolbar_rc, 2);
1779 }
1780
1781 /* The custom controls */
1782 customctrls_rc.left = dialog_rc.left + hspacing;
1783 customctrls_rc.right = dialog_rc.right - hspacing;
1784 customctrls_rc.bottom = filename_rc.top - vspacing;
1785 customctrls_rc.top = customctrls_rc.bottom -
1786 ctrl_container_resize(This, customctrls_rc.right - customctrls_rc.left);
1787
1788 /* The ExplorerBrowser control. */
1789 ebrowser_rc.left = dialog_rc.left + hspacing;
1790 ebrowser_rc.top = toolbar_rc.bottom + vspacing;
1791 ebrowser_rc.right = dialog_rc.right - hspacing;
1792 ebrowser_rc.bottom = customctrls_rc.top - vspacing;
1793
1794 /****
1795 * Move everything to the right place.
1796 */
1797
1798 /* FIXME: The Save Dialog uses a slightly different layout. */
1799 hdwp = BeginDeferWindowPos(7);
1800
1801 if(hdwp && This->peb)
1802 IExplorerBrowser_SetRect(This->peb, &hdwp, ebrowser_rc);
1803
1804 if(hdwp && This->cctrls_hwnd)
1805 DeferWindowPos(hdwp, This->cctrls_hwnd, NULL,
1806 customctrls_rc.left, customctrls_rc.top,
1807 customctrls_rc.right - customctrls_rc.left, customctrls_rc.bottom - customctrls_rc.top,
1808 SWP_NOZORDER | SWP_NOACTIVATE);
1809
1810 /* The default controls */
1811 if(hdwp && (hwnd = GetDlgItem(This->dlg_hwnd, IDC_FILETYPE)) )
1812 DeferWindowPos(hdwp, hwnd, NULL, filetype_rc.left, filetype_rc.top, 0, 0,
1813 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1814
1815 if(hdwp && (hwnd = GetDlgItem(This->dlg_hwnd, IDC_FILENAME)) )
1816 DeferWindowPos(hdwp, hwnd, NULL, filename_rc.left, filename_rc.top,
1817 filename_rc.right - filename_rc.left, filename_rc.bottom - filename_rc.top,
1818 SWP_NOZORDER | SWP_NOACTIVATE);
1819
1820 if(hdwp && (hwnd = GetDlgItem(This->dlg_hwnd, IDC_FILENAMESTATIC)) )
1821 DeferWindowPos(hdwp, hwnd, NULL, filenamelabel_rc.left, filenamelabel_rc.top, 0, 0,
1822 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1823
1824 if(hdwp && (hwnd = GetDlgItem(This->dlg_hwnd, IDOK)) )
1825 DeferWindowPos(hdwp, hwnd, NULL, open_rc.left, open_rc.top, 0, 0,
1826 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1827
1828 if(hdwp && This->hmenu_opendropdown && (hwnd = GetDlgItem(This->dlg_hwnd, psh1)))
1829 DeferWindowPos(hdwp, hwnd, NULL, dropdown_rc.left, dropdown_rc.top, 0, 0,
1830 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1831
1832 if(hdwp && (hwnd = GetDlgItem(This->dlg_hwnd, IDCANCEL)) )
1833 DeferWindowPos(hdwp, hwnd, NULL, cancel_rc.left, cancel_rc.top, 0, 0,
1834 SWP_NOZORDER | SWP_NOSIZE | SWP_NOACTIVATE);
1835
1836 if(hdwp)
1837 EndDeferWindowPos(hdwp);
1838 else
1839 ERR("Failed to position dialog controls.\n");
1840
1841 return;
1842 }
1843
1844 static HRESULT init_explorerbrowser(FileDialogImpl *This)
1845 {
1846 IShellItem *psi_folder;
1847 IObjectWithSite *client;
1848 FOLDERSETTINGS fos;
1849 RECT rc = {0};
1850 HRESULT hr;
1851
1852 /* Create ExplorerBrowser instance */
1853 OleInitialize(NULL);
1854
1855 hr = CoCreateInstance(&CLSID_ExplorerBrowser, NULL, CLSCTX_INPROC_SERVER,
1856 &IID_IExplorerBrowser, (void**)&This->peb);
1857 if(FAILED(hr))
1858 {
1859 ERR("Failed to instantiate ExplorerBrowser control.\n");
1860 return hr;
1861 }
1862
1863 IExplorerBrowser_SetOptions(This->peb, EBO_SHOWFRAMES | EBO_NOBORDER);
1864
1865 hr = IExplorerBrowser_Initialize(This->peb, This->dlg_hwnd, &rc, NULL);
1866 if(FAILED(hr))
1867 {
1868 ERR("Failed to initialize the ExplorerBrowser control.\n");
1869 IExplorerBrowser_Release(This->peb);
1870 This->peb = NULL;
1871 return hr;
1872 }
1873 hr = IExplorerBrowser_Advise(This->peb, &This->IExplorerBrowserEvents_iface, &This->ebevents_cookie);
1874 if(FAILED(hr))
1875 ERR("Advise (ExplorerBrowser) failed.\n");
1876
1877 /* Get previous options? */
1878 fos.ViewMode = fos.fFlags = 0;
1879 if(!(This->options & FOS_ALLOWMULTISELECT))
1880 fos.fFlags |= FWF_SINGLESEL;
1881
1882 IExplorerBrowser_SetFolderSettings(This->peb, &fos);
1883
1884 hr = IExplorerBrowser_QueryInterface(This->peb, &IID_IObjectWithSite, (void**)&client);
1885 if (hr == S_OK)
1886 {
1887 hr = IObjectWithSite_SetSite(client, (IUnknown*)&This->IFileDialog2_iface);
1888 IObjectWithSite_Release(client);
1889 if(FAILED(hr))
1890 ERR("SetSite failed, 0x%08x\n", hr);
1891 }
1892
1893 /* Browse somewhere */
1894 psi_folder = This->psi_setfolder ? This->psi_setfolder : This->psi_defaultfolder;
1895 IExplorerBrowser_BrowseToObject(This->peb, (IUnknown*)psi_folder, SBSP_DEFBROWSER);
1896
1897 return S_OK;
1898 }
1899
1900 static void init_toolbar(FileDialogImpl *This, HWND hwnd)
1901 {
1902 HWND htoolbar;
1903 TBADDBITMAP tbab;
1904 TBBUTTON button[2];
1905
1906 htoolbar = CreateWindowExW(0, TOOLBARCLASSNAMEW, NULL, TBSTYLE_FLAT | WS_CHILD | WS_VISIBLE,
1907 0, 0, 0, 0,
1908 hwnd, (HMENU)IDC_NAV_TOOLBAR, NULL, NULL);
1909
1910 tbab.hInst = HINST_COMMCTRL;
1911 tbab.nID = IDB_HIST_LARGE_COLOR;
1912 SendMessageW(htoolbar, TB_ADDBITMAP, 0, (LPARAM)&tbab);
1913
1914 button[0].iBitmap = HIST_BACK;
1915 button[0].idCommand = IDC_NAVBACK;
1916 button[0].fsState = TBSTATE_ENABLED;
1917 button[0].fsStyle = BTNS_BUTTON;
1918 button[0].dwData = 0;
1919 button[0].iString = 0;
1920
1921 button[1].iBitmap = HIST_FORWARD;
1922 button[1].idCommand = IDC_NAVFORWARD;
1923 button[1].fsState = TBSTATE_ENABLED;
1924 button[1].fsStyle = BTNS_BUTTON;
1925 button[1].dwData = 0;
1926 button[1].iString = 0;
1927
1928 SendMessageW(htoolbar, TB_ADDBUTTONSW, 2, (LPARAM)button);
1929 SendMessageW(htoolbar, TB_SETBUTTONSIZE, 0, MAKELPARAM(24,24));
1930 SendMessageW(htoolbar, TB_AUTOSIZE, 0, 0);
1931 }
1932
1933 static void update_control_text(FileDialogImpl *This)
1934 {
1935 HWND hitem;
1936 LPCWSTR custom_okbutton;
1937 cctrl_item* item;
1938 UINT min_width = MulDiv(50, This->dpi_x, USER_DEFAULT_SCREEN_DPI);
1939 UINT max_width = MulDiv(250, This->dpi_x, USER_DEFAULT_SCREEN_DPI);
1940
1941 if(This->custom_title)
1942 SetWindowTextW(This->dlg_hwnd, This->custom_title);
1943
1944 if(This->hmenu_opendropdown && (item = get_first_item(&This->cctrl_opendropdown)))
1945 custom_okbutton = item->label;
1946 else
1947 custom_okbutton = This->custom_okbutton;
1948
1949 if(custom_okbutton &&
1950 (hitem = GetDlgItem(This->dlg_hwnd, IDOK)))
1951 {
1952 SetWindowTextW(hitem, custom_okbutton);
1953 ctrl_resize(hitem, min_width, max_width, FALSE);
1954 }
1955
1956 if(This->custom_cancelbutton &&
1957 (hitem = GetDlgItem(This->dlg_hwnd, IDCANCEL)))
1958 {
1959 SetWindowTextW(hitem, This->custom_cancelbutton);
1960 ctrl_resize(hitem, min_width, max_width, FALSE);
1961 }
1962
1963 if(This->custom_filenamelabel &&
1964 (hitem = GetDlgItem(This->dlg_hwnd, IDC_FILENAMESTATIC)))
1965 {
1966 SetWindowTextW(hitem, This->custom_filenamelabel);
1967 ctrl_resize(hitem, min_width, max_width, FALSE);
1968 }
1969 }
1970
1971 static LRESULT CALLBACK dropdown_subclass_proc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam)
1972 {
1973 static const WCHAR prop_this[] = {'i','t','e','m','d','l','g','_','T','h','i','s',0};
1974 static const WCHAR prop_oldwndproc[] = {'i','t','e','m','d','l','g','_','o','l','d','w','n','d','p','r','o','c',0};
1975
1976 if (umessage == WM_LBUTTONDOWN)
1977 {
1978 FileDialogImpl *This = GetPropW(hwnd, prop_this);
1979
1980 SendMessageW(hwnd, BM_SETCHECK, BST_CHECKED, 0);
1981 show_opendropdown(This);
1982 SendMessageW(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
1983
1984 return 0;
1985 }
1986
1987 return CallWindowProcW((WNDPROC)GetPropW(hwnd, prop_oldwndproc), hwnd, umessage, wparam, lparam);
1988 }
1989
1990 static LRESULT on_wm_initdialog(HWND hwnd, LPARAM lParam)
1991 {
1992 FileDialogImpl *This = (FileDialogImpl*)lParam;
1993 HWND hitem;
1994
1995 TRACE("(%p, %p)\n", This, hwnd);
1996
1997 SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LPARAM)This);
1998 This->dlg_hwnd = hwnd;
1999
2000 hitem = GetDlgItem(This->dlg_hwnd, pshHelp);
2001 if(hitem) ShowWindow(hitem, SW_HIDE);
2002
2003 hitem = GetDlgItem(This->dlg_hwnd, IDC_FILETYPESTATIC);
2004 if(hitem) ShowWindow(hitem, SW_HIDE);
2005
2006 /* Fill filetypes combobox, or hide it. */
2007 hitem = GetDlgItem(This->dlg_hwnd, IDC_FILETYPE);
2008 if(This->filterspec_count)
2009 {
2010 HDC hdc;
2011 HFONT font;
2012 SIZE size;
2013 UINT i, maxwidth = 0;
2014
2015 hdc = GetDC(hitem);
2016 font = (HFONT)SendMessageW(hitem, WM_GETFONT, 0, 0);
2017 SelectObject(hdc, font);
2018
2019 for(i = 0; i < This->filterspec_count; i++)
2020 {
2021 SendMessageW(hitem, CB_ADDSTRING, 0, (LPARAM)This->filterspecs[i].pszName);
2022
2023 if(GetTextExtentPoint32W(hdc, This->filterspecs[i].pszName, lstrlenW(This->filterspecs[i].pszName), &size))
2024 maxwidth = max(maxwidth, size.cx);
2025 }
2026 ReleaseDC(hitem, hdc);
2027
2028 if(maxwidth > 0)
2029 {
2030 maxwidth += GetSystemMetrics(SM_CXVSCROLL) + 4;
2031 SendMessageW(hitem, CB_SETDROPPEDWIDTH, (WPARAM)maxwidth, 0);
2032 }
2033 else
2034 ERR("Failed to calculate width of filetype dropdown\n");
2035
2036 SendMessageW(hitem, CB_SETCURSEL, This->filetypeindex, 0);
2037 }
2038 else
2039 ShowWindow(hitem, SW_HIDE);
2040
2041 if(This->set_filename &&
2042 (hitem = GetDlgItem(This->dlg_hwnd, IDC_FILENAME)) )
2043 SendMessageW(hitem, WM_SETTEXT, 0, (LPARAM)This->set_filename);
2044
2045 if(This->hmenu_opendropdown)
2046 {
2047 HWND dropdown_hwnd;
2048 LOGFONTW lfw, lfw_marlett;
2049 HFONT dialog_font;
2050 static const WCHAR marlett[] = {'M','a','r','l','e','t','t',0};
2051 static const WCHAR prop_this[] = {'i','t','e','m','d','l','g','_','T','h','i','s',0};
2052 static const WCHAR prop_oldwndproc[] = {'i','t','e','m','d','l','g','_','o','l','d','w','n','d','p','r','o','c',0};
2053
2054 dropdown_hwnd = GetDlgItem(This->dlg_hwnd, psh1);
2055
2056 /* Change dropdown button font to Marlett */
2057 dialog_font = (HFONT)SendMessageW(dropdown_hwnd, WM_GETFONT, 0, 0);
2058
2059 GetObjectW(dialog_font, sizeof(lfw), &lfw);
2060
2061 memset(&lfw_marlett, 0, sizeof(lfw_marlett));
2062 lstrcpyW(lfw_marlett.lfFaceName, marlett);
2063 lfw_marlett.lfHeight = lfw.lfHeight;
2064 lfw_marlett.lfCharSet = SYMBOL_CHARSET;
2065
2066 This->hfont_opendropdown = CreateFontIndirectW(&lfw_marlett);
2067
2068 SendMessageW(dropdown_hwnd, WM_SETFONT, (LPARAM)This->hfont_opendropdown, 0);
2069
2070 /* Subclass button so we can handle LBUTTONDOWN */
2071 SetPropW(dropdown_hwnd, prop_this, This);
2072 SetPropW(dropdown_hwnd, prop_oldwndproc,
2073 (HANDLE)SetWindowLongPtrW(dropdown_hwnd, GWLP_WNDPROC, (LONG_PTR)dropdown_subclass_proc));
2074 }
2075
2076 ctrl_container_reparent(This, This->dlg_hwnd);
2077 init_explorerbrowser(This);
2078 init_toolbar(This, hwnd);
2079 update_control_text(This);
2080 update_layout(This);
2081
2082 if(This->filterspec_count)
2083 events_OnTypeChange(This);
2084
2085 if ((hitem = GetDlgItem(This->dlg_hwnd, IDC_FILENAME)))
2086 SetFocus(hitem);
2087
2088 return FALSE;
2089 }
2090
2091 static LRESULT on_wm_size(FileDialogImpl *This)
2092 {
2093 update_layout(This);
2094 return FALSE;
2095 }
2096
2097 static LRESULT on_wm_getminmaxinfo(FileDialogImpl *This, LPARAM lparam)
2098 {
2099 MINMAXINFO *mmi = (MINMAXINFO*)lparam;
2100 TRACE("%p (%p)\n", This, mmi);
2101
2102 /* FIXME */
2103 mmi->ptMinTrackSize.x = 640;
2104 mmi->ptMinTrackSize.y = 480;
2105
2106 return FALSE;
2107 }
2108
2109 static LRESULT on_wm_destroy(FileDialogImpl *This)
2110 {
2111 TRACE("%p\n", This);
2112
2113 if(This->peb)
2114 {
2115 IExplorerBrowser_Destroy(This->peb);
2116 IExplorerBrowser_Release(This->peb);
2117 This->peb = NULL;
2118 }
2119
2120 ctrl_container_reparent(This, NULL);
2121 This->dlg_hwnd = NULL;
2122
2123 DeleteObject(This->hfont_opendropdown);
2124 This->hfont_opendropdown = NULL;
2125
2126 return TRUE;
2127 }
2128
2129 static LRESULT on_idok(FileDialogImpl *This)
2130 {
2131 TRACE("%p\n", This);
2132
2133 if(SUCCEEDED(on_default_action(This)))
2134 EndDialog(This->dlg_hwnd, S_OK);
2135
2136 return FALSE;
2137 }
2138
2139 static LRESULT on_idcancel(FileDialogImpl *This)
2140 {
2141 TRACE("%p\n", This);
2142
2143 EndDialog(This->dlg_hwnd, HRESULT_FROM_WIN32(ERROR_CANCELLED));
2144
2145 return FALSE;
2146 }
2147
2148 static LRESULT on_command_opendropdown(FileDialogImpl *This, WPARAM wparam, LPARAM lparam)
2149 {
2150 if(HIWORD(wparam) == BN_CLICKED)
2151 {
2152 HWND hwnd = (HWND)lparam;
2153 SendMessageW(hwnd, BM_SETCHECK, BST_CHECKED, 0);
2154 show_opendropdown(This);
2155 SendMessageW(hwnd, BM_SETCHECK, BST_UNCHECKED, 0);
2156 }
2157
2158 return FALSE;
2159 }
2160
2161 static LRESULT on_browse_back(FileDialogImpl *This)
2162 {
2163 TRACE("%p\n", This);
2164 IExplorerBrowser_BrowseToIDList(This->peb, NULL, SBSP_NAVIGATEBACK);
2165 return FALSE;
2166 }
2167
2168 static LRESULT on_browse_forward(FileDialogImpl *This)
2169 {
2170 TRACE("%p\n", This);
2171 IExplorerBrowser_BrowseToIDList(This->peb, NULL, SBSP_NAVIGATEFORWARD);
2172 return FALSE;
2173 }
2174
2175 static LRESULT on_command_filetype(FileDialogImpl *This, WPARAM wparam, LPARAM lparam)
2176 {
2177 if(HIWORD(wparam) == CBN_SELCHANGE)
2178 {
2179 IShellView *psv;
2180 HRESULT hr;
2181 LPWSTR filename;
2182 UINT prev_index = This->filetypeindex;
2183
2184 This->filetypeindex = SendMessageW((HWND)lparam, CB_GETCURSEL, 0, 0);
2185 TRACE("File type selection changed to %d.\n", This->filetypeindex);
2186
2187 if(prev_index == This->filetypeindex)
2188 return FALSE;
2189
2190 hr = IExplorerBrowser_GetCurrentView(This->peb, &IID_IShellView, (void**)&psv);
2191 if(SUCCEEDED(hr))
2192 {
2193 IShellView_Refresh(psv);
2194 IShellView_Release(psv);
2195 }
2196
2197 if(This->dlg_type == ITEMDLG_TYPE_SAVE && get_file_name(This, &filename))
2198 {
2199 WCHAR buf[MAX_PATH], extbuf[MAX_PATH], *ext;
2200
2201 ext = get_first_ext_from_spec(extbuf, This->filterspecs[This->filetypeindex].pszSpec);
2202 if(ext)
2203 {
2204 lstrcpyW(buf, filename);
2205
2206 if(PathMatchSpecW(buf, This->filterspecs[prev_index].pszSpec))
2207 PathRemoveExtensionW(buf);
2208
2209 lstrcatW(buf, ext);
2210 set_file_name(This, buf);
2211 }
2212 CoTaskMemFree(filename);
2213 }
2214
2215 /* The documentation claims that OnTypeChange is called only
2216 * when the dialog is opened, but this is obviously not the
2217 * case. */
2218 events_OnTypeChange(This);
2219 }
2220
2221 return FALSE;
2222 }
2223
2224 static LRESULT on_wm_command(FileDialogImpl *This, WPARAM wparam, LPARAM lparam)
2225 {
2226 switch(LOWORD(wparam))
2227 {
2228 case IDOK: return on_idok(This);
2229 case IDCANCEL: return on_idcancel(This);
2230 case psh1: return on_command_opendropdown(This, wparam, lparam);
2231 case IDC_NAVBACK: return on_browse_back(This);
2232 case IDC_NAVFORWARD: return on_browse_forward(This);
2233 case IDC_FILETYPE: return on_command_filetype(This, wparam, lparam);
2234 default: TRACE("Unknown command.\n");
2235 }
2236 return FALSE;
2237 }
2238
2239 static LRESULT CALLBACK itemdlg_dlgproc(HWND hwnd, UINT umessage, WPARAM wparam, LPARAM lparam)
2240 {
2241 FileDialogImpl *This = (FileDialogImpl*)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
2242
2243 switch(umessage)
2244 {
2245 case WM_INITDIALOG: return on_wm_initdialog(hwnd, lparam);
2246 case WM_COMMAND: return on_wm_command(This, wparam, lparam);
2247 case WM_SIZE: return on_wm_size(This);
2248 case WM_GETMINMAXINFO: return on_wm_getminmaxinfo(This, lparam);
2249 case WM_DESTROY: return on_wm_destroy(This);
2250 }
2251
2252 return FALSE;
2253 }
2254
2255 static HRESULT create_dialog(FileDialogImpl *This, HWND parent)
2256 {
2257 INT_PTR res;
2258
2259 SetLastError(0);
2260 res = DialogBoxParamW(COMDLG32_hInstance,
2261 MAKEINTRESOURCEW(NEWFILEOPENV3ORD),
2262 parent, itemdlg_dlgproc, (LPARAM)This);
2263 This->dlg_hwnd = NULL;
2264 if(res == -1)
2265 {
2266 ERR("Failed to show dialog (LastError: %d)\n", GetLastError());
2267 return E_FAIL;
2268 }
2269
2270 TRACE("Returning 0x%08x\n", (HRESULT)res);
2271 return (HRESULT)res;
2272 }
2273
2274 /**************************************************************************
2275 * IFileDialog implementation
2276 */
2277 static inline FileDialogImpl *impl_from_IFileDialog2(IFileDialog2 *iface)
2278 {
2279 return CONTAINING_RECORD(iface, FileDialogImpl, IFileDialog2_iface);
2280 }
2281
2282 static HRESULT WINAPI IFileDialog2_fnQueryInterface(IFileDialog2 *iface,
2283 REFIID riid,
2284 void **ppvObject)
2285 {
2286 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2287 TRACE("%p (%s, %p)\n", This, debugstr_guid(riid), ppvObject);
2288
2289 *ppvObject = NULL;
2290 if(IsEqualGUID(riid, &IID_IUnknown) ||
2291 IsEqualGUID(riid, &IID_IFileDialog) ||
2292 IsEqualGUID(riid, &IID_IFileDialog2))
2293 {
2294 *ppvObject = iface;
2295 }
2296 else if(IsEqualGUID(riid, &IID_IFileOpenDialog) && This->dlg_type == ITEMDLG_TYPE_OPEN)
2297 {
2298 *ppvObject = &This->u.IFileOpenDialog_iface;
2299 }
2300 else if(IsEqualGUID(riid, &IID_IFileSaveDialog) && This->dlg_type == ITEMDLG_TYPE_SAVE)
2301 {
2302 *ppvObject = &This->u.IFileSaveDialog_iface;
2303 }
2304 else if(IsEqualGUID(riid, &IID_IExplorerBrowserEvents))
2305 {
2306 *ppvObject = &This->IExplorerBrowserEvents_iface;
2307 }
2308 else if(IsEqualGUID(riid, &IID_IServiceProvider))
2309 {
2310 *ppvObject = &This->IServiceProvider_iface;
2311 }
2312 else if(IsEqualGUID(&IID_ICommDlgBrowser3, riid) ||
2313 IsEqualGUID(&IID_ICommDlgBrowser2, riid) ||
2314 IsEqualGUID(&IID_ICommDlgBrowser, riid))
2315 {
2316 *ppvObject = &This->ICommDlgBrowser3_iface;
2317 }
2318 else if(IsEqualGUID(&IID_IOleWindow, riid))
2319 {
2320 *ppvObject = &This->IOleWindow_iface;
2321 }
2322 else if(IsEqualGUID(riid, &IID_IFileDialogCustomize) ||
2323 IsEqualGUID(riid, &IID_IFileDialogCustomizeAlt))
2324 {
2325 *ppvObject = &This->IFileDialogCustomize_iface;
2326 }
2327 else
2328 FIXME("Unknown interface requested: %s.\n", debugstr_guid(riid));
2329
2330 if(*ppvObject)
2331 {
2332 IUnknown_AddRef((IUnknown*)*ppvObject);
2333 return S_OK;
2334 }
2335
2336 return E_NOINTERFACE;
2337 }
2338
2339 static ULONG WINAPI IFileDialog2_fnAddRef(IFileDialog2 *iface)
2340 {
2341 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2342 LONG ref = InterlockedIncrement(&This->ref);
2343 TRACE("%p - ref %d\n", This, ref);
2344
2345 return ref;
2346 }
2347
2348 static ULONG WINAPI IFileDialog2_fnRelease(IFileDialog2 *iface)
2349 {
2350 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2351 LONG ref = InterlockedDecrement(&This->ref);
2352 TRACE("%p - ref %d\n", This, ref);
2353
2354 if(!ref)
2355 {
2356 UINT i;
2357 for(i = 0; i < This->filterspec_count; i++)
2358 {
2359 LocalFree((void*)This->filterspecs[i].pszName);
2360 LocalFree((void*)This->filterspecs[i].pszSpec);
2361 }
2362 HeapFree(GetProcessHeap(), 0, This->filterspecs);
2363
2364 DestroyWindow(This->cctrls_hwnd);
2365
2366 if(This->psi_defaultfolder) IShellItem_Release(This->psi_defaultfolder);
2367 if(This->psi_setfolder) IShellItem_Release(This->psi_setfolder);
2368 if(This->psi_folder) IShellItem_Release(This->psi_folder);
2369 if(This->psia_selection) IShellItemArray_Release(This->psia_selection);
2370 if(This->psia_results) IShellItemArray_Release(This->psia_results);
2371
2372 LocalFree(This->set_filename);
2373 LocalFree(This->default_ext);
2374 LocalFree(This->custom_title);
2375 LocalFree(This->custom_okbutton);
2376 LocalFree(This->custom_cancelbutton);
2377 LocalFree(This->custom_filenamelabel);
2378
2379 DestroyMenu(This->hmenu_opendropdown);
2380 DeleteObject(This->hfont_opendropdown);
2381
2382 HeapFree(GetProcessHeap(), 0, This);
2383 }
2384
2385 return ref;
2386 }
2387
2388 static HRESULT WINAPI IFileDialog2_fnShow(IFileDialog2 *iface, HWND hwndOwner)
2389 {
2390 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2391 TRACE("%p (%p)\n", iface, hwndOwner);
2392
2393 This->opendropdown_has_selection = FALSE;
2394
2395 return create_dialog(This, hwndOwner);
2396 }
2397
2398 static HRESULT WINAPI IFileDialog2_fnSetFileTypes(IFileDialog2 *iface, UINT cFileTypes,
2399 const COMDLG_FILTERSPEC *rgFilterSpec)
2400 {
2401 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2402 UINT i;
2403 TRACE("%p (%d, %p)\n", This, cFileTypes, rgFilterSpec);
2404
2405 if(This->filterspecs)
2406 return E_UNEXPECTED;
2407
2408 if(!rgFilterSpec)
2409 return E_INVALIDARG;
2410
2411 if(!cFileTypes)
2412 return S_OK;
2413
2414 This->filterspecs = HeapAlloc(GetProcessHeap(), 0, sizeof(COMDLG_FILTERSPEC)*cFileTypes);
2415 for(i = 0; i < cFileTypes; i++)
2416 {
2417 This->filterspecs[i].pszName = StrDupW(rgFilterSpec[i].pszName);
2418 This->filterspecs[i].pszSpec = StrDupW(rgFilterSpec[i].pszSpec);
2419 }
2420 This->filterspec_count = cFileTypes;
2421
2422 return S_OK;
2423 }
2424
2425 static HRESULT WINAPI IFileDialog2_fnSetFileTypeIndex(IFileDialog2 *iface, UINT iFileType)
2426 {
2427 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2428 TRACE("%p (%d)\n", This, iFileType);
2429
2430 if(!This->filterspecs)
2431 return E_FAIL;
2432
2433 iFileType = max(iFileType, 1);
2434 iFileType = min(iFileType, This->filterspec_count);
2435 This->filetypeindex = iFileType-1;
2436
2437 return S_OK;
2438 }
2439
2440 static HRESULT WINAPI IFileDialog2_fnGetFileTypeIndex(IFileDialog2 *iface, UINT *piFileType)
2441 {
2442 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2443 TRACE("%p (%p)\n", This, piFileType);
2444
2445 if(!piFileType)
2446 return E_INVALIDARG;
2447
2448 if(This->filterspec_count == 0)
2449 *piFileType = 0;
2450 else
2451 *piFileType = This->filetypeindex + 1;
2452
2453 return S_OK;
2454 }
2455
2456 static HRESULT WINAPI IFileDialog2_fnAdvise(IFileDialog2 *iface, IFileDialogEvents *pfde, DWORD *pdwCookie)
2457 {
2458 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2459 events_client *client;
2460 TRACE("%p (%p, %p)\n", This, pfde, pdwCookie);
2461
2462 if(!pfde || !pdwCookie)
2463 return E_INVALIDARG;
2464
2465 client = HeapAlloc(GetProcessHeap(), 0, sizeof(events_client));
2466 client->pfde = pfde;
2467 client->cookie = ++This->events_next_cookie;
2468
2469 IFileDialogEvents_AddRef(pfde);
2470 *pdwCookie = client->cookie;
2471
2472 list_add_tail(&This->events_clients, &client->entry);
2473
2474 return S_OK;
2475 }
2476
2477 static HRESULT WINAPI IFileDialog2_fnUnadvise(IFileDialog2 *iface, DWORD dwCookie)
2478 {
2479 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2480 events_client *client, *found = NULL;
2481 TRACE("%p (%d)\n", This, dwCookie);
2482
2483 LIST_FOR_EACH_ENTRY(client, &This->events_clients, events_client, entry)
2484 {
2485 if(client->cookie == dwCookie)
2486 {
2487 found = client;
2488 break;
2489 }
2490 }
2491
2492 if(found)
2493 {
2494 list_remove(&found->entry);
2495 IFileDialogEvents_Release(found->pfde);
2496 HeapFree(GetProcessHeap(), 0, found);
2497 return S_OK;
2498 }
2499
2500 return E_INVALIDARG;
2501 }
2502
2503 static HRESULT WINAPI IFileDialog2_fnSetOptions(IFileDialog2 *iface, FILEOPENDIALOGOPTIONS fos)
2504 {
2505 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2506 TRACE("%p (0x%x)\n", This, fos);
2507
2508 if( !(This->options & FOS_PICKFOLDERS) && (fos & FOS_PICKFOLDERS) )
2509 {
2510 WCHAR buf[30];
2511 LoadStringW(COMDLG32_hInstance, IDS_SELECT_FOLDER, buf, sizeof(buf)/sizeof(WCHAR));
2512 IFileDialog2_SetTitle(iface, buf);
2513 }
2514
2515 This->options = fos;
2516
2517 return S_OK;
2518 }
2519
2520 static HRESULT WINAPI IFileDialog2_fnGetOptions(IFileDialog2 *iface, FILEOPENDIALOGOPTIONS *pfos)
2521 {
2522 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2523 TRACE("%p (%p)\n", This, pfos);
2524
2525 if(!pfos)
2526 return E_INVALIDARG;
2527
2528 *pfos = This->options;
2529
2530 return S_OK;
2531 }
2532
2533 static HRESULT WINAPI IFileDialog2_fnSetDefaultFolder(IFileDialog2 *iface, IShellItem *psi)
2534 {
2535 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2536 TRACE("%p (%p)\n", This, psi);
2537 if(This->psi_defaultfolder)
2538 IShellItem_Release(This->psi_defaultfolder);
2539
2540 This->psi_defaultfolder = psi;
2541
2542 if(This->psi_defaultfolder)
2543 IShellItem_AddRef(This->psi_defaultfolder);
2544
2545 return S_OK;
2546 }
2547
2548 static HRESULT WINAPI IFileDialog2_fnSetFolder(IFileDialog2 *iface, IShellItem *psi)
2549 {
2550 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2551 TRACE("%p (%p)\n", This, psi);
2552 if(This->psi_setfolder)
2553 IShellItem_Release(This->psi_setfolder);
2554
2555 This->psi_setfolder = psi;
2556
2557 if(This->psi_setfolder)
2558 IShellItem_AddRef(This->psi_setfolder);
2559
2560 return S_OK;
2561 }
2562
2563 static HRESULT WINAPI IFileDialog2_fnGetFolder(IFileDialog2 *iface, IShellItem **ppsi)
2564 {
2565 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2566 TRACE("%p (%p)\n", This, ppsi);
2567 if(!ppsi)
2568 return E_INVALIDARG;
2569
2570 /* FIXME:
2571 If the dialog is shown, return the current(ly selected) folder. */
2572
2573 *ppsi = NULL;
2574 if(This->psi_folder)
2575 *ppsi = This->psi_folder;
2576 else if(This->psi_setfolder)
2577 *ppsi = This->psi_setfolder;
2578 else if(This->psi_defaultfolder)
2579 *ppsi = This->psi_defaultfolder;
2580
2581 if(*ppsi)
2582 {
2583 IShellItem_AddRef(*ppsi);
2584 return S_OK;
2585 }
2586
2587 return E_FAIL;
2588 }
2589
2590 static HRESULT WINAPI IFileDialog2_fnGetCurrentSelection(IFileDialog2 *iface, IShellItem **ppsi)
2591 {
2592 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2593 HRESULT hr;
2594 TRACE("%p (%p)\n", This, ppsi);
2595
2596 if(!ppsi)
2597 return E_INVALIDARG;
2598
2599 if(This->psia_selection)
2600 {
2601 /* FIXME: Check filename edit box */
2602 hr = IShellItemArray_GetItemAt(This->psia_selection, 0, ppsi);
2603 return hr;
2604 }
2605
2606 return E_FAIL;
2607 }
2608
2609 static HRESULT WINAPI IFileDialog2_fnSetFileName(IFileDialog2 *iface, LPCWSTR pszName)
2610 {
2611 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2612 TRACE("%p (%s)\n", iface, debugstr_w(pszName));
2613
2614 set_file_name(This, pszName);
2615
2616 return S_OK;
2617 }
2618
2619 static HRESULT WINAPI IFileDialog2_fnGetFileName(IFileDialog2 *iface, LPWSTR *pszName)
2620 {
2621 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2622 TRACE("%p (%p)\n", iface, pszName);
2623
2624 if(!pszName)
2625 return E_INVALIDARG;
2626
2627 *pszName = NULL;
2628 get_file_name(This, pszName);
2629 return *pszName ? S_OK : E_FAIL;
2630 }
2631
2632 static HRESULT WINAPI IFileDialog2_fnSetTitle(IFileDialog2 *iface, LPCWSTR pszTitle)
2633 {
2634 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2635 TRACE("%p (%s)\n", This, debugstr_w(pszTitle));
2636
2637 LocalFree(This->custom_title);
2638 This->custom_title = StrDupW(pszTitle);
2639 update_control_text(This);
2640
2641 return S_OK;
2642 }
2643
2644 static HRESULT WINAPI IFileDialog2_fnSetOkButtonLabel(IFileDialog2 *iface, LPCWSTR pszText)
2645 {
2646 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2647 TRACE("%p (%s)\n", This, debugstr_w(pszText));
2648
2649 LocalFree(This->custom_okbutton);
2650 This->custom_okbutton = StrDupW(pszText);
2651 update_control_text(This);
2652 update_layout(This);
2653
2654 return S_OK;
2655 }
2656
2657 static HRESULT WINAPI IFileDialog2_fnSetFileNameLabel(IFileDialog2 *iface, LPCWSTR pszLabel)
2658 {
2659 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2660 TRACE("%p (%s)\n", This, debugstr_w(pszLabel));
2661
2662 LocalFree(This->custom_filenamelabel);
2663 This->custom_filenamelabel = StrDupW(pszLabel);
2664 update_control_text(This);
2665 update_layout(This);
2666
2667 return S_OK;
2668 }
2669
2670 static HRESULT WINAPI IFileDialog2_fnGetResult(IFileDialog2 *iface, IShellItem **ppsi)
2671 {
2672 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2673 HRESULT hr;
2674 TRACE("%p (%p)\n", This, ppsi);
2675
2676 if(!ppsi)
2677 return E_INVALIDARG;
2678
2679 if(This->psia_results)
2680 {
2681 UINT item_count;
2682 hr = IShellItemArray_GetCount(This->psia_results, &item_count);
2683 if(SUCCEEDED(hr))
2684 {
2685 if(item_count != 1)
2686 return E_FAIL;
2687
2688 /* Adds a reference. */
2689 hr = IShellItemArray_GetItemAt(This->psia_results, 0, ppsi);
2690 }
2691
2692 return hr;
2693 }
2694
2695 return E_UNEXPECTED;
2696 }
2697
2698 static HRESULT WINAPI IFileDialog2_fnAddPlace(IFileDialog2 *iface, IShellItem *psi, FDAP fdap)
2699 {
2700 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2701 FIXME("stub - %p (%p, %d)\n", This, psi, fdap);
2702 return S_OK;
2703 }
2704
2705 static HRESULT WINAPI IFileDialog2_fnSetDefaultExtension(IFileDialog2 *iface, LPCWSTR pszDefaultExtension)
2706 {
2707 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2708 TRACE("%p (%s)\n", This, debugstr_w(pszDefaultExtension));
2709
2710 LocalFree(This->default_ext);
2711 This->default_ext = StrDupW(pszDefaultExtension);
2712
2713 return S_OK;
2714 }
2715
2716 static HRESULT WINAPI IFileDialog2_fnClose(IFileDialog2 *iface, HRESULT hr)
2717 {
2718 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2719 TRACE("%p (0x%08x)\n", This, hr);
2720
2721 if(This->dlg_hwnd)
2722 EndDialog(This->dlg_hwnd, hr);
2723
2724 return S_OK;
2725 }
2726
2727 static HRESULT WINAPI IFileDialog2_fnSetClientGuid(IFileDialog2 *iface, REFGUID guid)
2728 {
2729 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2730 TRACE("%p (%s)\n", This, debugstr_guid(guid));
2731 This->client_guid = *guid;
2732 return S_OK;
2733 }
2734
2735 static HRESULT WINAPI IFileDialog2_fnClearClientData(IFileDialog2 *iface)
2736 {
2737 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2738 FIXME("stub - %p\n", This);
2739 return E_NOTIMPL;
2740 }
2741
2742 static HRESULT WINAPI IFileDialog2_fnSetFilter(IFileDialog2 *iface, IShellItemFilter *pFilter)
2743 {
2744 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2745 FIXME("stub - %p (%p)\n", This, pFilter);
2746 return E_NOTIMPL;
2747 }
2748
2749 static HRESULT WINAPI IFileDialog2_fnSetCancelButtonLabel(IFileDialog2 *iface, LPCWSTR pszLabel)
2750 {
2751 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2752 TRACE("%p (%s)\n", This, debugstr_w(pszLabel));
2753
2754 LocalFree(This->custom_cancelbutton);
2755 This->custom_cancelbutton = StrDupW(pszLabel);
2756 update_control_text(This);
2757 update_layout(This);
2758
2759 return S_OK;
2760 }
2761
2762 static HRESULT WINAPI IFileDialog2_fnSetNavigationRoot(IFileDialog2 *iface, IShellItem *psi)
2763 {
2764 FileDialogImpl *This = impl_from_IFileDialog2(iface);
2765 FIXME("stub - %p (%p)\n", This, psi);
2766 return E_NOTIMPL;
2767 }
2768
2769 static const IFileDialog2Vtbl vt_IFileDialog2 = {
2770 IFileDialog2_fnQueryInterface,
2771 IFileDialog2_fnAddRef,
2772 IFileDialog2_fnRelease,
2773 IFileDialog2_fnShow,
2774 IFileDialog2_fnSetFileTypes,
2775 IFileDialog2_fnSetFileTypeIndex,
2776 IFileDialog2_fnGetFileTypeIndex,
2777 IFileDialog2_fnAdvise,
2778 IFileDialog2_fnUnadvise,
2779 IFileDialog2_fnSetOptions,
2780 IFileDialog2_fnGetOptions,
2781 IFileDialog2_fnSetDefaultFolder,
2782 IFileDialog2_fnSetFolder,
2783 IFileDialog2_fnGetFolder,
2784 IFileDialog2_fnGetCurrentSelection,
2785 IFileDialog2_fnSetFileName,
2786 IFileDialog2_fnGetFileName,
2787 IFileDialog2_fnSetTitle,
2788 IFileDialog2_fnSetOkButtonLabel,
2789 IFileDialog2_fnSetFileNameLabel,
2790 IFileDialog2_fnGetResult,
2791 IFileDialog2_fnAddPlace,
2792 IFileDialog2_fnSetDefaultExtension,
2793 IFileDialog2_fnClose,
2794 IFileDialog2_fnSetClientGuid,
2795 IFileDialog2_fnClearClientData,
2796 IFileDialog2_fnSetFilter,
2797 IFileDialog2_fnSetCancelButtonLabel,
2798 IFileDialog2_fnSetNavigationRoot
2799 };
2800
2801 /**************************************************************************
2802 * IFileOpenDialog
2803 */
2804 static inline FileDialogImpl *impl_from_IFileOpenDialog(IFileOpenDialog *iface)
2805 {
2806 return CONTAINING_RECORD(iface, FileDialogImpl, u.IFileOpenDialog_iface);
2807 }
2808
2809 static HRESULT WINAPI IFileOpenDialog_fnQueryInterface(IFileOpenDialog *iface,
2810 REFIID riid, void **ppvObject)
2811 {
2812 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2813 return IFileDialog2_QueryInterface(&This->IFileDialog2_iface, riid, ppvObject);
2814 }
2815
2816 static ULONG WINAPI IFileOpenDialog_fnAddRef(IFileOpenDialog *iface)
2817 {
2818 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2819 return IFileDialog2_AddRef(&This->IFileDialog2_iface);
2820 }
2821
2822 static ULONG WINAPI IFileOpenDialog_fnRelease(IFileOpenDialog *iface)
2823 {
2824 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2825 return IFileDialog2_Release(&This->IFileDialog2_iface);
2826 }
2827
2828 static HRESULT WINAPI IFileOpenDialog_fnShow(IFileOpenDialog *iface, HWND hwndOwner)
2829 {
2830 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2831 return IFileDialog2_Show(&This->IFileDialog2_iface, hwndOwner);
2832 }
2833
2834 static HRESULT WINAPI IFileOpenDialog_fnSetFileTypes(IFileOpenDialog *iface, UINT cFileTypes,
2835 const COMDLG_FILTERSPEC *rgFilterSpec)
2836 {
2837 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2838 return IFileDialog2_SetFileTypes(&This->IFileDialog2_iface, cFileTypes, rgFilterSpec);
2839 }
2840
2841 static HRESULT WINAPI IFileOpenDialog_fnSetFileTypeIndex(IFileOpenDialog *iface, UINT iFileType)
2842 {
2843 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2844 return IFileDialog2_SetFileTypeIndex(&This->IFileDialog2_iface, iFileType);
2845 }
2846
2847 static HRESULT WINAPI IFileOpenDialog_fnGetFileTypeIndex(IFileOpenDialog *iface, UINT *piFileType)
2848 {
2849 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2850 return IFileDialog2_GetFileTypeIndex(&This->IFileDialog2_iface, piFileType);
2851 }
2852
2853 static HRESULT WINAPI IFileOpenDialog_fnAdvise(IFileOpenDialog *iface, IFileDialogEvents *pfde,
2854 DWORD *pdwCookie)
2855 {
2856 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2857 return IFileDialog2_Advise(&This->IFileDialog2_iface, pfde, pdwCookie);
2858 }
2859
2860 static HRESULT WINAPI IFileOpenDialog_fnUnadvise(IFileOpenDialog *iface, DWORD dwCookie)
2861 {
2862 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2863 return IFileDialog2_Unadvise(&This->IFileDialog2_iface, dwCookie);
2864 }
2865
2866 static HRESULT WINAPI IFileOpenDialog_fnSetOptions(IFileOpenDialog *iface, FILEOPENDIALOGOPTIONS fos)
2867 {
2868 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2869 return IFileDialog2_SetOptions(&This->IFileDialog2_iface, fos);
2870 }
2871
2872 static HRESULT WINAPI IFileOpenDialog_fnGetOptions(IFileOpenDialog *iface, FILEOPENDIALOGOPTIONS *pfos)
2873 {
2874 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2875 return IFileDialog2_GetOptions(&This->IFileDialog2_iface, pfos);
2876 }
2877
2878 static HRESULT WINAPI IFileOpenDialog_fnSetDefaultFolder(IFileOpenDialog *iface, IShellItem *psi)
2879 {
2880 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2881 return IFileDialog2_SetDefaultFolder(&This->IFileDialog2_iface, psi);
2882 }
2883
2884 static HRESULT WINAPI IFileOpenDialog_fnSetFolder(IFileOpenDialog *iface, IShellItem *psi)
2885 {
2886 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2887 return IFileDialog2_SetFolder(&This->IFileDialog2_iface, psi);
2888 }
2889
2890 static HRESULT WINAPI IFileOpenDialog_fnGetFolder(IFileOpenDialog *iface, IShellItem **ppsi)
2891 {
2892 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2893 return IFileDialog2_GetFolder(&This->IFileDialog2_iface, ppsi);
2894 }
2895
2896 static HRESULT WINAPI IFileOpenDialog_fnGetCurrentSelection(IFileOpenDialog *iface, IShellItem **ppsi)
2897 {
2898 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2899 return IFileDialog2_GetCurrentSelection(&This->IFileDialog2_iface, ppsi);
2900 }
2901
2902 static HRESULT WINAPI IFileOpenDialog_fnSetFileName(IFileOpenDialog *iface, LPCWSTR pszName)
2903 {
2904 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2905 return IFileDialog2_SetFileName(&This->IFileDialog2_iface, pszName);
2906 }
2907
2908 static HRESULT WINAPI IFileOpenDialog_fnGetFileName(IFileOpenDialog *iface, LPWSTR *pszName)
2909 {
2910 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2911 return IFileDialog2_GetFileName(&This->IFileDialog2_iface, pszName);
2912 }
2913
2914 static HRESULT WINAPI IFileOpenDialog_fnSetTitle(IFileOpenDialog *iface, LPCWSTR pszTitle)
2915 {
2916 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2917 return IFileDialog2_SetTitle(&This->IFileDialog2_iface, pszTitle);
2918 }
2919
2920 static HRESULT WINAPI IFileOpenDialog_fnSetOkButtonLabel(IFileOpenDialog *iface, LPCWSTR pszText)
2921 {
2922 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2923 return IFileDialog2_SetOkButtonLabel(&This->IFileDialog2_iface, pszText);
2924 }
2925
2926 static HRESULT WINAPI IFileOpenDialog_fnSetFileNameLabel(IFileOpenDialog *iface, LPCWSTR pszLabel)
2927 {
2928 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2929 return IFileDialog2_SetFileNameLabel(&This->IFileDialog2_iface, pszLabel);
2930 }
2931
2932 static HRESULT WINAPI IFileOpenDialog_fnGetResult(IFileOpenDialog *iface, IShellItem **ppsi)
2933 {
2934 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2935 return IFileDialog2_GetResult(&This->IFileDialog2_iface, ppsi);
2936 }
2937
2938 static HRESULT WINAPI IFileOpenDialog_fnAddPlace(IFileOpenDialog *iface, IShellItem *psi, FDAP fdap)
2939 {
2940 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2941 return IFileDialog2_AddPlace(&This->IFileDialog2_iface, psi, fdap);
2942 }
2943
2944 static HRESULT WINAPI IFileOpenDialog_fnSetDefaultExtension(IFileOpenDialog *iface,
2945 LPCWSTR pszDefaultExtension)
2946 {
2947 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2948 return IFileDialog2_SetDefaultExtension(&This->IFileDialog2_iface, pszDefaultExtension);
2949 }
2950
2951 static HRESULT WINAPI IFileOpenDialog_fnClose(IFileOpenDialog *iface, HRESULT hr)
2952 {
2953 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2954 return IFileDialog2_Close(&This->IFileDialog2_iface, hr);
2955 }
2956
2957 static HRESULT WINAPI IFileOpenDialog_fnSetClientGuid(IFileOpenDialog *iface, REFGUID guid)
2958 {
2959 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2960 return IFileDialog2_SetClientGuid(&This->IFileDialog2_iface, guid);
2961 }
2962
2963 static HRESULT WINAPI IFileOpenDialog_fnClearClientData(IFileOpenDialog *iface)
2964 {
2965 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2966 return IFileDialog2_ClearClientData(&This->IFileDialog2_iface);
2967 }
2968
2969 static HRESULT WINAPI IFileOpenDialog_fnSetFilter(IFileOpenDialog *iface, IShellItemFilter *pFilter)
2970 {
2971 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2972 return IFileDialog2_SetFilter(&This->IFileDialog2_iface, pFilter);
2973 }
2974
2975 static HRESULT WINAPI IFileOpenDialog_fnGetResults(IFileOpenDialog *iface, IShellItemArray **ppenum)
2976 {
2977 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2978 TRACE("%p (%p)\n", This, ppenum);
2979
2980 *ppenum = This->psia_results;
2981
2982 if(*ppenum)
2983 {
2984 IShellItemArray_AddRef(*ppenum);
2985 return S_OK;
2986 }
2987
2988 return E_FAIL;
2989 }
2990
2991 static HRESULT WINAPI IFileOpenDialog_fnGetSelectedItems(IFileOpenDialog *iface, IShellItemArray **ppsai)
2992 {
2993 FileDialogImpl *This = impl_from_IFileOpenDialog(iface);
2994 TRACE("%p (%p)\n", This, ppsai);
2995
2996 if(This->psia_selection)
2997 {
2998 *ppsai = This->psia_selection;
2999 IShellItemArray_AddRef(*ppsai);
3000 return S_OK;
3001 }
3002
3003 return E_FAIL;
3004 }
3005
3006 static const IFileOpenDialogVtbl vt_IFileOpenDialog = {
3007 IFileOpenDialog_fnQueryInterface,
3008 IFileOpenDialog_fnAddRef,
3009 IFileOpenDialog_fnRelease,
3010 IFileOpenDialog_fnShow,
3011 IFileOpenDialog_fnSetFileTypes,
3012 IFileOpenDialog_fnSetFileTypeIndex,
3013 IFileOpenDialog_fnGetFileTypeIndex,
3014 IFileOpenDialog_fnAdvise,
3015 IFileOpenDialog_fnUnadvise,
3016 IFileOpenDialog_fnSetOptions,
3017 IFileOpenDialog_fnGetOptions,
3018 IFileOpenDialog_fnSetDefaultFolder,
3019 IFileOpenDialog_fnSetFolder,
3020 IFileOpenDialog_fnGetFolder,
3021 IFileOpenDialog_fnGetCurrentSelection,
3022 IFileOpenDialog_fnSetFileName,
3023 IFileOpenDialog_fnGetFileName,
3024 IFileOpenDialog_fnSetTitle,
3025 IFileOpenDialog_fnSetOkButtonLabel,
3026 IFileOpenDialog_fnSetFileNameLabel,
3027 IFileOpenDialog_fnGetResult,
3028 IFileOpenDialog_fnAddPlace,
3029 IFileOpenDialog_fnSetDefaultExtension,
3030 IFileOpenDialog_fnClose,
3031 IFileOpenDialog_fnSetClientGuid,
3032 IFileOpenDialog_fnClearClientData,
3033 IFileOpenDialog_fnSetFilter,
3034 IFileOpenDialog_fnGetResults,
3035 IFileOpenDialog_fnGetSelectedItems
3036 };
3037
3038 /**************************************************************************
3039 * IFileSaveDialog
3040 */
3041 static inline FileDialogImpl *impl_from_IFileSaveDialog(IFileSaveDialog *iface)
3042 {
3043 return CONTAINING_RECORD(iface, FileDialogImpl, u.IFileSaveDialog_iface);
3044 }
3045
3046 static HRESULT WINAPI IFileSaveDialog_fnQueryInterface(IFileSaveDialog *iface,
3047 REFIID riid,
3048 void **ppvObject)
3049 {
3050 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3051 return IFileDialog2_QueryInterface(&This->IFileDialog2_iface, riid, ppvObject);
3052 }
3053
3054 static ULONG WINAPI IFileSaveDialog_fnAddRef(IFileSaveDialog *iface)
3055 {
3056 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3057 return IFileDialog2_AddRef(&This->IFileDialog2_iface);
3058 }
3059
3060 static ULONG WINAPI IFileSaveDialog_fnRelease(IFileSaveDialog *iface)
3061 {
3062 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3063 return IFileDialog2_Release(&This->IFileDialog2_iface);
3064 }
3065
3066 static HRESULT WINAPI IFileSaveDialog_fnShow(IFileSaveDialog *iface, HWND hwndOwner)
3067 {
3068 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3069 return IFileDialog2_Show(&This->IFileDialog2_iface, hwndOwner);
3070 }
3071
3072 static HRESULT WINAPI IFileSaveDialog_fnSetFileTypes(IFileSaveDialog *iface, UINT cFileTypes,
3073 const COMDLG_FILTERSPEC *rgFilterSpec)
3074 {
3075 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3076 return IFileDialog2_SetFileTypes(&This->IFileDialog2_iface, cFileTypes, rgFilterSpec);
3077 }
3078
3079 static HRESULT WINAPI IFileSaveDialog_fnSetFileTypeIndex(IFileSaveDialog *iface, UINT iFileType)
3080 {
3081 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3082 return IFileDialog2_SetFileTypeIndex(&This->IFileDialog2_iface, iFileType);
3083 }
3084
3085 static HRESULT WINAPI IFileSaveDialog_fnGetFileTypeIndex(IFileSaveDialog *iface, UINT *piFileType)
3086 {
3087 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3088 return IFileDialog2_GetFileTypeIndex(&This->IFileDialog2_iface, piFileType);
3089 }
3090
3091 static HRESULT WINAPI IFileSaveDialog_fnAdvise(IFileSaveDialog *iface, IFileDialogEvents *pfde,
3092 DWORD *pdwCookie)
3093 {
3094 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3095 return IFileDialog2_Advise(&This->IFileDialog2_iface, pfde, pdwCookie);
3096 }
3097
3098 static HRESULT WINAPI IFileSaveDialog_fnUnadvise(IFileSaveDialog *iface, DWORD dwCookie)
3099 {
3100 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3101 return IFileDialog2_Unadvise(&This->IFileDialog2_iface, dwCookie);
3102 }
3103
3104 static HRESULT WINAPI IFileSaveDialog_fnSetOptions(IFileSaveDialog *iface, FILEOPENDIALOGOPTIONS fos)
3105 {
3106 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3107 return IFileDialog2_SetOptions(&This->IFileDialog2_iface, fos);
3108 }
3109
3110 static HRESULT WINAPI IFileSaveDialog_fnGetOptions(IFileSaveDialog *iface, FILEOPENDIALOGOPTIONS *pfos)
3111 {
3112 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3113 return IFileDialog2_GetOptions(&This->IFileDialog2_iface, pfos);
3114 }
3115
3116 static HRESULT WINAPI IFileSaveDialog_fnSetDefaultFolder(IFileSaveDialog *iface, IShellItem *psi)
3117 {
3118 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3119 return IFileDialog2_SetDefaultFolder(&This->IFileDialog2_iface, psi);
3120 }
3121
3122 static HRESULT WINAPI IFileSaveDialog_fnSetFolder(IFileSaveDialog *iface, IShellItem *psi)
3123 {
3124 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3125 return IFileDialog2_SetFolder(&This->IFileDialog2_iface, psi);
3126 }
3127
3128 static HRESULT WINAPI IFileSaveDialog_fnGetFolder(IFileSaveDialog *iface, IShellItem **ppsi)
3129 {
3130 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3131 return IFileDialog2_GetFolder(&This->IFileDialog2_iface, ppsi);
3132 }
3133
3134 static HRESULT WINAPI IFileSaveDialog_fnGetCurrentSelection(IFileSaveDialog *iface, IShellItem **ppsi)
3135 {
3136 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3137 return IFileDialog2_GetCurrentSelection(&This->IFileDialog2_iface, ppsi);
3138 }
3139
3140 static HRESULT WINAPI IFileSaveDialog_fnSetFileName(IFileSaveDialog *iface, LPCWSTR pszName)
3141 {
3142 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3143 return IFileDialog2_SetFileName(&This->IFileDialog2_iface, pszName);
3144 }
3145
3146 static HRESULT WINAPI IFileSaveDialog_fnGetFileName(IFileSaveDialog *iface, LPWSTR *pszName)
3147 {
3148 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3149 return IFileDialog2_GetFileName(&This->IFileDialog2_iface, pszName);
3150 }
3151
3152 static HRESULT WINAPI IFileSaveDialog_fnSetTitle(IFileSaveDialog *iface, LPCWSTR pszTitle)
3153 {
3154 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3155 return IFileDialog2_SetTitle(&This->IFileDialog2_iface, pszTitle);
3156 }
3157
3158 static HRESULT WINAPI IFileSaveDialog_fnSetOkButtonLabel(IFileSaveDialog *iface, LPCWSTR pszText)
3159 {
3160 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3161 return IFileDialog2_SetOkButtonLabel(&This->IFileDialog2_iface, pszText);
3162 }
3163
3164 static HRESULT WINAPI IFileSaveDialog_fnSetFileNameLabel(IFileSaveDialog *iface, LPCWSTR pszLabel)
3165 {
3166 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3167 return IFileDialog2_SetFileNameLabel(&This->IFileDialog2_iface, pszLabel);
3168 }
3169
3170 static HRESULT WINAPI IFileSaveDialog_fnGetResult(IFileSaveDialog *iface, IShellItem **ppsi)
3171 {
3172 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3173 return IFileDialog2_GetResult(&This->IFileDialog2_iface, ppsi);
3174 }
3175
3176 static HRESULT WINAPI IFileSaveDialog_fnAddPlace(IFileSaveDialog *iface, IShellItem *psi, FDAP fdap)
3177 {
3178 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3179 return IFileDialog2_AddPlace(&This->IFileDialog2_iface, psi, fdap);
3180 }
3181
3182 static HRESULT WINAPI IFileSaveDialog_fnSetDefaultExtension(IFileSaveDialog *iface,
3183 LPCWSTR pszDefaultExtension)
3184 {
3185 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3186 return IFileDialog2_SetDefaultExtension(&This->IFileDialog2_iface, pszDefaultExtension);
3187 }
3188
3189 static HRESULT WINAPI IFileSaveDialog_fnClose(IFileSaveDialog *iface, HRESULT hr)
3190 {
3191 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3192 return IFileDialog2_Close(&This->IFileDialog2_iface, hr);
3193 }
3194
3195 static HRESULT WINAPI IFileSaveDialog_fnSetClientGuid(IFileSaveDialog *iface, REFGUID guid)
3196 {
3197 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3198 return IFileDialog2_SetClientGuid(&This->IFileDialog2_iface, guid);
3199 }
3200
3201 static HRESULT WINAPI IFileSaveDialog_fnClearClientData(IFileSaveDialog *iface)
3202 {
3203 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3204 return IFileDialog2_ClearClientData(&This->IFileDialog2_iface);
3205 }
3206
3207 static HRESULT WINAPI IFileSaveDialog_fnSetFilter(IFileSaveDialog *iface, IShellItemFilter *pFilter)
3208 {
3209 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3210 return IFileDialog2_SetFilter(&This->IFileDialog2_iface, pFilter);
3211 }
3212
3213 static HRESULT WINAPI IFileSaveDialog_fnSetSaveAsItem(IFileSaveDialog* iface, IShellItem *psi)
3214 {
3215 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3216 FIXME("stub - %p (%p)\n", This, psi);
3217 return E_NOTIMPL;
3218 }
3219
3220 static HRESULT WINAPI IFileSaveDialog_fnSetProperties(IFileSaveDialog* iface, IPropertyStore *pStore)
3221 {
3222 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3223 FIXME("stub - %p (%p)\n", This, pStore);
3224 return E_NOTIMPL;
3225 }
3226
3227 static HRESULT WINAPI IFileSaveDialog_fnSetCollectedProperties(IFileSaveDialog* iface,
3228 IPropertyDescriptionList *pList,
3229 BOOL fAppendDefault)
3230 {
3231 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3232 FIXME("stub - %p (%p, %d)\n", This, pList, fAppendDefault);
3233 return E_NOTIMPL;
3234 }
3235
3236 static HRESULT WINAPI IFileSaveDialog_fnGetProperties(IFileSaveDialog* iface, IPropertyStore **ppStore)
3237 {
3238 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3239 FIXME("stub - %p (%p)\n", This, ppStore);
3240 return E_NOTIMPL;
3241 }
3242
3243 static HRESULT WINAPI IFileSaveDialog_fnApplyProperties(IFileSaveDialog* iface,
3244 IShellItem *psi,
3245 IPropertyStore *pStore,
3246 HWND hwnd,
3247 IFileOperationProgressSink *pSink)
3248 {
3249 FileDialogImpl *This = impl_from_IFileSaveDialog(iface);
3250 FIXME("%p (%p, %p, %p, %p)\n", This, psi, pStore, hwnd, pSink);
3251 return E_NOTIMPL;
3252 }
3253
3254 static const IFileSaveDialogVtbl vt_IFileSaveDialog = {
3255 IFileSaveDialog_fnQueryInterface,
3256 IFileSaveDialog_fnAddRef,
3257 IFileSaveDialog_fnRelease,
3258 IFileSaveDialog_fnShow,
3259 IFileSaveDialog_fnSetFileTypes,
3260 IFileSaveDialog_fnSetFileTypeIndex,
3261 IFileSaveDialog_fnGetFileTypeIndex,
3262 IFileSaveDialog_fnAdvise,
3263 IFileSaveDialog_fnUnadvise,
3264 IFileSaveDialog_fnSetOptions,
3265 IFileSaveDialog_fnGetOptions,
3266 IFileSaveDialog_fnSetDefaultFolder,
3267 IFileSaveDialog_fnSetFolder,
3268 IFileSaveDialog_fnGetFolder,
3269 IFileSaveDialog_fnGetCurrentSelection,
3270 IFileSaveDialog_fnSetFileName,
3271 IFileSaveDialog_fnGetFileName,
3272 IFileSaveDialog_fnSetTitle,
3273 IFileSaveDialog_fnSetOkButtonLabel,
3274 IFileSaveDialog_fnSetFileNameLabel,
3275 IFileSaveDialog_fnGetResult,
3276 IFileSaveDialog_fnAddPlace,
3277 IFileSaveDialog_fnSetDefaultExtension,
3278 IFileSaveDialog_fnClose,
3279 IFileSaveDialog_fnSetClientGuid,
3280 IFileSaveDialog_fnClearClientData,
3281 IFileSaveDialog_fnSetFilter,
3282 IFileSaveDialog_fnSetSaveAsItem,
3283 IFileSaveDialog_fnSetProperties,
3284 IFileSaveDialog_fnSetCollectedProperties,
3285 IFileSaveDialog_fnGetProperties,
3286 IFileSaveDialog_fnApplyProperties
3287 };
3288
3289 /**************************************************************************
3290 * IExplorerBrowserEvents implementation
3291 */
3292 static inline FileDialogImpl *impl_from_IExplorerBrowserEvents(IExplorerBrowserEvents *iface)
3293 {
3294 return CONTAINING_RECORD(iface, FileDialogImpl, IExplorerBrowserEvents_iface);
3295 }
3296
3297 static HRESULT WINAPI IExplorerBrowserEvents_fnQueryInterface(IExplorerBrowserEvents *iface,
3298 REFIID riid, void **ppvObject)
3299 {
3300 FileDialogImpl *This = impl_from_IExplorerBrowserEvents(iface);
3301 TRACE("%p (%s, %p)\n", This, debugstr_guid(riid), ppvObject);
3302
3303 return IFileDialog2_QueryInterface(&This->IFileDialog2_iface, riid, ppvObject);
3304 }
3305
3306 static ULONG WINAPI IExplorerBrowserEvents_fnAddRef(IExplorerBrowserEvents *iface)
3307 {
3308 FileDialogImpl *This = impl_from_IExplorerBrowserEvents(iface);
3309 TRACE("%p\n", This);
3310 return IFileDialog2_AddRef(&This->IFileDialog2_iface);
3311 }
3312
3313 static ULONG WINAPI IExplorerBrowserEvents_fnRelease(IExplorerBrowserEvents *iface)
3314 {
3315 FileDialogImpl *This = impl_from_IExplorerBrowserEvents(iface);
3316 TRACE("%p\n", This);
3317 return IFileDialog2_Release(&This->IFileDialog2_iface);
3318 }
3319
3320 static HRESULT WINAPI IExplorerBrowserEvents_fnOnNavigationPending(IExplorerBrowserEvents *iface,
3321 PCIDLIST_ABSOLUTE pidlFolder)
3322 {
3323 FileDialogImpl *This = impl_from_IExplorerBrowserEvents(iface);
3324 IShellItem *psi;
3325 HRESULT hr;
3326 TRACE("%p (%p)\n", This, pidlFolder);
3327
3328 hr = SHCreateItemFromIDList(pidlFolder, &IID_IShellItem, (void**)&psi);
3329 if(SUCCEEDED(hr))
3330 {
3331 hr = events_OnFolderChanging(This, psi);
3332 IShellItem_Release(psi);
3333
3334 /* The ExplorerBrowser treats S_FALSE as S_OK, we don't. */
3335 if(hr == S_FALSE)
3336 hr = E_FAIL;
3337
3338 return hr;
3339 }
3340 else
3341 ERR("Failed to convert pidl (%p) to a shellitem.\n", pidlFolder);
3342
3343 return S_OK;
3344 }
3345
3346 static HRESULT WINAPI IExplorerBrowserEvents_fnOnViewCreated(IExplorerBrowserEvents *iface,
3347 IShellView *psv)
3348 {
3349 FileDialogImpl *This = impl_from_IExplorerBrowserEvents(iface);
3350 TRACE("%p (%p)\n", This, psv);
3351 return S_OK;
3352 }
3353
3354 static HRESULT WINAPI IExplorerBrowserEvents_fnOnNavigationComplete(IExplorerBrowserEvents *iface,
3355 PCIDLIST_ABSOLUTE pidlFolder)
3356 {
3357 FileDialogImpl *This = impl_from_IExplorerBrowserEvents(iface);
3358 HRESULT hr;
3359 TRACE("%p (%p)\n", This, pidlFolder);
3360
3361 if(This->psi_folder)
3362 IShellItem_Release(This->psi_folder);
3363
3364 hr = SHCreateItemFromIDList(pidlFolder, &IID_IShellItem, (void**)&This->psi_folder);
3365 if(FAILED(hr))
3366 {
3367 ERR("Failed to get the current folder.\n");
3368 This->psi_folder = NULL;
3369 }
3370
3371 events_OnFolderChange(This);
3372
3373 return S_OK;
3374 }
3375
3376 static HRESULT WINAPI IExplorerBrowserEvents_fnOnNavigationFailed(IExplorerBrowserEvents *iface,
3377 PCIDLIST_ABSOLUTE pidlFolder)
3378 {
3379 FileDialogImpl *This = impl_from_IExplorerBrowserEvents(iface);
3380 TRACE("%p (%p)\n", This, pidlFolder);
3381 return S_OK;
3382 }
3383
3384 static const IExplorerBrowserEventsVtbl vt_IExplorerBrowserEvents = {
3385 IExplorerBrowserEvents_fnQueryInterface,
3386 IExplorerBrowserEvents_fnAddRef,
3387 IExplorerBrowserEvents_fnRelease,
3388 IExplorerBrowserEvents_fnOnNavigationPending,
3389 IExplorerBrowserEvents_fnOnViewCreated,
3390 IExplorerBrowserEvents_fnOnNavigationComplete,
3391 IExplorerBrowserEvents_fnOnNavigationFailed
3392 };
3393
3394 /**************************************************************************
3395 * IServiceProvider implementation
3396 */
3397 static inline FileDialogImpl *impl_from_IServiceProvider(IServiceProvider *iface)
3398 {
3399 return CONTAINING_RECORD(iface, FileDialogImpl, IServiceProvider_iface);
3400 }
3401
3402 static HRESULT WINAPI IServiceProvider_fnQueryInterface(IServiceProvider *iface,
3403 REFIID riid, void **ppvObject)
3404 {
3405 FileDialogImpl *This = impl_from_IServiceProvider(iface);
3406 TRACE("%p\n", This);
3407 return IFileDialog2_QueryInterface(&This->IFileDialog2_iface, riid, ppvObject);
3408 }
3409
3410 static ULONG WINAPI IServiceProvider_fnAddRef(IServiceProvider *iface)
3411 {
3412 FileDialogImpl *This = impl_from_IServiceProvider(iface);
3413 TRACE("%p\n", This);
3414 return IFileDialog2_AddRef(&This->IFileDialog2_iface);
3415 }
3416
3417 static ULONG WINAPI IServiceProvider_fnRelease(IServiceProvider *iface)
3418 {
3419 FileDialogImpl *This = impl_from_IServiceProvider(iface);
3420 TRACE("%p\n", This);
3421 return IFileDialog2_Release(&This->IFileDialog2_iface);
3422 }
3423
3424 static HRESULT WINAPI IServiceProvider_fnQueryService(IServiceProvider *iface,
3425 REFGUID guidService,
3426 REFIID riid, void **ppv)
3427 {
3428 FileDialogImpl *This = impl_from_IServiceProvider(iface);
3429 HRESULT hr = E_NOTIMPL;
3430 TRACE("%p (%s, %s, %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
3431
3432 *ppv = NULL;
3433 if(IsEqualGUID(guidService, &SID_STopLevelBrowser) && This->peb)
3434 hr = IExplorerBrowser_QueryInterface(This->peb, riid, ppv);
3435 else if(IsEqualGUID(guidService, &SID_SExplorerBrowserFrame))
3436 hr = IFileDialog2_QueryInterface(&This->IFileDialog2_iface, riid, ppv);
3437 else
3438 FIXME("Interface %s requested from unknown service %s\n",
3439 debugstr_guid(riid), debugstr_guid(guidService));
3440
3441 return hr;
3442 }
3443
3444 static const IServiceProviderVtbl vt_IServiceProvider = {
3445 IServiceProvider_fnQueryInterface,
3446 IServiceProvider_fnAddRef,
3447 IServiceProvider_fnRelease,
3448 IServiceProvider_fnQueryService
3449 };
3450
3451 /**************************************************************************
3452 * ICommDlgBrowser3 implementation
3453 */
3454 static inline FileDialogImpl *impl_from_ICommDlgBrowser3(ICommDlgBrowser3 *iface)
3455 {
3456 return CONTAINING_RECORD(iface, FileDialogImpl, ICommDlgBrowser3_iface);
3457 }
3458
3459 static HRESULT WINAPI ICommDlgBrowser3_fnQueryInterface(ICommDlgBrowser3 *iface,
3460 REFIID riid, void **ppvObject)
3461 {
3462 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3463 TRACE("%p\n", This);
3464 return IFileDialog2_QueryInterface(&This->IFileDialog2_iface, riid, ppvObject);
3465 }
3466
3467 static ULONG WINAPI ICommDlgBrowser3_fnAddRef(ICommDlgBrowser3 *iface)
3468 {
3469 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3470 TRACE("%p\n", This);
3471 return IFileDialog2_AddRef(&This->IFileDialog2_iface);
3472 }
3473
3474 static ULONG WINAPI ICommDlgBrowser3_fnRelease(ICommDlgBrowser3 *iface)
3475 {
3476 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3477 TRACE("%p\n", This);
3478 return IFileDialog2_Release(&This->IFileDialog2_iface);
3479 }
3480
3481 static HRESULT WINAPI ICommDlgBrowser3_fnOnDefaultCommand(ICommDlgBrowser3 *iface,
3482 IShellView *shv)
3483 {
3484 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3485 HRESULT hr;
3486 TRACE("%p (%p)\n", This, shv);
3487
3488 hr = on_default_action(This);
3489
3490 if(SUCCEEDED(hr))
3491 EndDialog(This->dlg_hwnd, S_OK);
3492
3493 return S_OK;
3494 }
3495
3496 static HRESULT WINAPI ICommDlgBrowser3_fnOnStateChange(ICommDlgBrowser3 *iface,
3497 IShellView *shv, ULONG uChange )
3498 {
3499 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3500 IDataObject *new_selection;
3501 HRESULT hr;
3502 TRACE("%p (%p, %x)\n", This, shv, uChange);
3503
3504 switch(uChange)
3505 {
3506 case CDBOSC_SELCHANGE:
3507 if(This->psia_selection)
3508 {
3509 IShellItemArray_Release(This->psia_selection);
3510 This->psia_selection = NULL;
3511 }
3512
3513 hr = IShellView_GetItemObject(shv, SVGIO_SELECTION, &IID_IDataObject, (void**)&new_selection);
3514 if(SUCCEEDED(hr))
3515 {
3516 hr = SHCreateShellItemArrayFromDataObject(new_selection, &IID_IShellItemArray,
3517 (void**)&This->psia_selection);
3518 if(SUCCEEDED(hr))
3519 {
3520 fill_filename_from_selection(This);
3521 events_OnSelectionChange(This);
3522 }
3523
3524 IDataObject_Release(new_selection);
3525 }
3526 break;
3527 default:
3528 TRACE("Unhandled state change\n");
3529 }
3530 return S_OK;
3531 }
3532
3533 static HRESULT WINAPI ICommDlgBrowser3_fnIncludeObject(ICommDlgBrowser3 *iface,
3534 IShellView *shv, LPCITEMIDLIST pidl)
3535 {
3536 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3537 IShellItem *psi;
3538 LPWSTR filename;
3539 LPITEMIDLIST parent_pidl;
3540 HRESULT hr;
3541 ULONG attr;
3542 TRACE("%p (%p, %p)\n", This, shv, pidl);
3543
3544 if(!This->filterspec_count && !(This->options & FOS_PICKFOLDERS))
3545 return S_OK;
3546
3547 hr = SHGetIDListFromObject((IUnknown*)shv, &parent_pidl);
3548 if(SUCCEEDED(hr))
3549 {
3550 LPITEMIDLIST full_pidl = ILCombine(parent_pidl, pidl);
3551 hr = SHCreateItemFromIDList(full_pidl, &IID_IShellItem, (void**)&psi);
3552 ILFree(parent_pidl);
3553 ILFree(full_pidl);
3554 }
3555 if(FAILED(hr))
3556 {
3557 ERR("Failed to get shellitem (%08x).\n", hr);
3558 return S_OK;
3559 }
3560
3561 hr = IShellItem_GetAttributes(psi, SFGAO_FOLDER|SFGAO_LINK, &attr);
3562 if(FAILED(hr) || (attr & (SFGAO_FOLDER | SFGAO_LINK)))
3563 {
3564 IShellItem_Release(psi);
3565 return S_OK;
3566 }
3567
3568 if((This->options & FOS_PICKFOLDERS) && !(attr & (SFGAO_FOLDER | SFGAO_LINK)))
3569 {
3570 IShellItem_Release(psi);
3571 return S_FALSE;
3572 }
3573
3574 hr = S_OK;
3575 if(SUCCEEDED(IShellItem_GetDisplayName(psi, SIGDN_PARENTRELATIVEPARSING, &filename)))
3576 {
3577 if(!PathMatchSpecW(filename, This->filterspecs[This->filetypeindex].pszSpec))
3578 hr = S_FALSE;
3579 CoTaskMemFree(filename);
3580 }
3581
3582 IShellItem_Release(psi);
3583 return hr;
3584 }
3585
3586 static HRESULT WINAPI ICommDlgBrowser3_fnNotify(ICommDlgBrowser3 *iface,
3587 IShellView *ppshv, DWORD dwNotifyType)
3588 {
3589 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3590 FIXME("Stub: %p (%p, 0x%x)\n", This, ppshv, dwNotifyType);
3591 return E_NOTIMPL;
3592 }
3593
3594 static HRESULT WINAPI ICommDlgBrowser3_fnGetDefaultMenuText(ICommDlgBrowser3 *iface,
3595 IShellView *pshv,
3596 LPWSTR pszText, int cchMax)
3597 {
3598 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3599 FIXME("Stub: %p (%p, %p, %d)\n", This, pshv, pszText, cchMax);
3600 return E_NOTIMPL;
3601 }
3602
3603 static HRESULT WINAPI ICommDlgBrowser3_fnGetViewFlags(ICommDlgBrowser3 *iface, DWORD *pdwFlags)
3604 {
3605 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3606 FIXME("Stub: %p (%p)\n", This, pdwFlags);
3607 return E_NOTIMPL;
3608 }
3609
3610 static HRESULT WINAPI ICommDlgBrowser3_fnOnColumnClicked(ICommDlgBrowser3 *iface,
3611 IShellView *pshv, int iColumn)
3612 {
3613 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3614 FIXME("Stub: %p (%p, %d)\n", This, pshv, iColumn);
3615 return E_NOTIMPL;
3616 }
3617
3618 static HRESULT WINAPI ICommDlgBrowser3_fnGetCurrentFilter(ICommDlgBrowser3 *iface,
3619 LPWSTR pszFileSpec, int cchFileSpec)
3620 {
3621 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3622 FIXME("Stub: %p (%p, %d)\n", This, pszFileSpec, cchFileSpec);
3623 return E_NOTIMPL;
3624 }
3625
3626 static HRESULT WINAPI ICommDlgBrowser3_fnOnPreviewCreated(ICommDlgBrowser3 *iface,
3627 IShellView *pshv)
3628 {
3629 FileDialogImpl *This = impl_from_ICommDlgBrowser3(iface);
3630 FIXME("Stub: %p (%p)\n", This, pshv);
3631 return E_NOTIMPL;
3632 }
3633
3634 static const ICommDlgBrowser3Vtbl vt_ICommDlgBrowser3 = {
3635 ICommDlgBrowser3_fnQueryInterface,
3636 ICommDlgBrowser3_fnAddRef,
3637 ICommDlgBrowser3_fnRelease,
3638 ICommDlgBrowser3_fnOnDefaultCommand,
3639 ICommDlgBrowser3_fnOnStateChange,
3640 ICommDlgBrowser3_fnIncludeObject,
3641 ICommDlgBrowser3_fnNotify,
3642 ICommDlgBrowser3_fnGetDefaultMenuText,
3643 ICommDlgBrowser3_fnGetViewFlags,
3644 ICommDlgBrowser3_fnOnColumnClicked,
3645 ICommDlgBrowser3_fnGetCurrentFilter,
3646 ICommDlgBrowser3_fnOnPreviewCreated
3647 };
3648
3649 /**************************************************************************
3650 * IOleWindow implementation
3651 */
3652 static inline FileDialogImpl *impl_from_IOleWindow(IOleWindow *iface)
3653 {
3654 return CONTAINING_RECORD(iface, FileDialogImpl, IOleWindow_iface);
3655 }
3656
3657 static HRESULT WINAPI IOleWindow_fnQueryInterface(IOleWindow *iface, REFIID riid, void **ppvObject)
3658 {
3659 FileDialogImpl *This = impl_from_IOleWindow(iface);
3660 return IFileDialog2_QueryInterface(&This->IFileDialog2_iface, riid, ppvObject);
3661 }
3662
3663 static ULONG WINAPI IOleWindow_fnAddRef(IOleWindow *iface)
3664 {
3665 FileDialogImpl *This = impl_from_IOleWindow(iface);
3666 return IFileDialog2_AddRef(&This->IFileDialog2_iface);
3667 }
3668
3669 static ULONG WINAPI IOleWindow_fnRelease(IOleWindow *iface)
3670 {
3671 FileDialogImpl *This = impl_from_IOleWindow(iface);
3672 return IFileDialog2_Release(&This->IFileDialog2_iface);
3673 }
3674
3675 static HRESULT WINAPI IOleWindow_fnContextSensitiveHelp(IOleWindow *iface, BOOL fEnterMOde)
3676 {
3677 FileDialogImpl *This = impl_from_IOleWindow(iface);
3678 FIXME("Stub: %p (%d)\n", This, fEnterMOde);
3679 return E_NOTIMPL;
3680 }
3681
3682 static HRESULT WINAPI IOleWindow_fnGetWindow(IOleWindow *iface, HWND *phwnd)
3683 {
3684 FileDialogImpl *This = impl_from_IOleWindow(iface);
3685 TRACE("%p (%p)\n", This, phwnd);
3686 *phwnd = This->dlg_hwnd;
3687 return S_OK;
3688 }
3689
3690 static const IOleWindowVtbl vt_IOleWindow = {
3691 IOleWindow_fnQueryInterface,
3692 IOleWindow_fnAddRef,
3693 IOleWindow_fnRelease,
3694 IOleWindow_fnGetWindow,
3695 IOleWindow_fnContextSensitiveHelp
3696 };
3697
3698 /**************************************************************************
3699 * IFileDialogCustomize implementation
3700 */
3701 static inline FileDialogImpl *impl_from_IFileDialogCustomize(IFileDialogCustomize *iface)
3702 {
3703 return CONTAINING_RECORD(iface, FileDialogImpl, IFileDialogCustomize_iface);
3704 }
3705
3706 static HRESULT WINAPI IFileDialogCustomize_fnQueryInterface(IFileDialogCustomize *iface,
3707 REFIID riid, void **ppvObject)
3708 {
3709 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3710 return IFileDialog2_QueryInterface(&This->IFileDialog2_iface, riid, ppvObject);
3711 }
3712
3713 static ULONG WINAPI IFileDialogCustomize_fnAddRef(IFileDialogCustomize *iface)
3714 {
3715 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3716 return IFileDialog2_AddRef(&This->IFileDialog2_iface);
3717 }
3718
3719 static ULONG WINAPI IFileDialogCustomize_fnRelease(IFileDialogCustomize *iface)
3720 {
3721 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3722 return IFileDialog2_Release(&This->IFileDialog2_iface);
3723 }
3724
3725 static HRESULT WINAPI IFileDialogCustomize_fnEnableOpenDropDown(IFileDialogCustomize *iface,
3726 DWORD dwIDCtl)
3727 {
3728 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3729 MENUINFO mi;
3730 TRACE("%p (%d)\n", This, dwIDCtl);
3731
3732 if (This->hmenu_opendropdown || get_cctrl(This, dwIDCtl))
3733 return E_UNEXPECTED;
3734
3735 This->hmenu_opendropdown = CreatePopupMenu();
3736
3737 if (!This->hmenu_opendropdown)
3738 return E_OUTOFMEMORY;
3739
3740 mi.cbSize = sizeof(mi);
3741 mi.fMask = MIM_STYLE;
3742 mi.dwStyle = MNS_NOTIFYBYPOS;
3743 SetMenuInfo(This->hmenu_opendropdown, &mi);
3744
3745 This->cctrl_opendropdown.hwnd = NULL;
3746 This->cctrl_opendropdown.wrapper_hwnd = NULL;
3747 This->cctrl_opendropdown.id = dwIDCtl;
3748 This->cctrl_opendropdown.dlgid = 0;
3749 This->cctrl_opendropdown.type = IDLG_CCTRL_OPENDROPDOWN;
3750 This->cctrl_opendropdown.cdcstate = CDCS_ENABLED | CDCS_VISIBLE;
3751 list_init(&This->cctrl_opendropdown.sub_cctrls);
3752 list_init(&This->cctrl_opendropdown.sub_items);
3753
3754 return S_OK;
3755 }
3756
3757 static HRESULT WINAPI IFileDialogCustomize_fnAddMenu(IFileDialogCustomize *iface,
3758 DWORD dwIDCtl,
3759 LPCWSTR pszLabel)
3760 {
3761 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3762 customctrl *ctrl;
3763 TBBUTTON tbb;
3764 HRESULT hr;
3765 TRACE("%p (%d, %p)\n", This, dwIDCtl, pszLabel);
3766
3767 hr = cctrl_create_new(This, dwIDCtl, NULL, TOOLBARCLASSNAMEW,
3768 TBSTYLE_FLAT | CCS_NODIVIDER, 0,
3769 This->cctrl_def_height, &ctrl);
3770 if(SUCCEEDED(hr))
3771 {
3772 SendMessageW(ctrl->hwnd, TB_BUTTONSTRUCTSIZE, sizeof(tbb), 0);
3773 ctrl->type = IDLG_CCTRL_MENU;
3774
3775 /* Add the actual button with a popup menu. */
3776 tbb.iBitmap = I_IMAGENONE;
3777 tbb.dwData = (DWORD_PTR)CreatePopupMenu();
3778 tbb.iString = (DWORD_PTR)pszLabel;
3779 tbb.fsState = TBSTATE_ENABLED;
3780 tbb.fsStyle = BTNS_WHOLEDROPDOWN;
3781 tbb.idCommand = 1;
3782
3783 SendMessageW(ctrl->hwnd, TB_ADDBUTTONSW, 1, (LPARAM)&tbb);
3784 }
3785
3786 return hr;
3787 }
3788
3789 static HRESULT WINAPI IFileDialogCustomize_fnAddPushButton(IFileDialogCustomize *iface,
3790 DWORD dwIDCtl,
3791 LPCWSTR pszLabel)
3792 {
3793 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3794 customctrl *ctrl;
3795 HRESULT hr;
3796 TRACE("%p (%d, %p)\n", This, dwIDCtl, pszLabel);
3797
3798 hr = cctrl_create_new(This, dwIDCtl, pszLabel, WC_BUTTONW, BS_MULTILINE, 0,
3799 This->cctrl_def_height, &ctrl);
3800 if(SUCCEEDED(hr))
3801 ctrl->type = IDLG_CCTRL_PUSHBUTTON;
3802
3803 return hr;
3804 }
3805
3806 static HRESULT WINAPI IFileDialogCustomize_fnAddComboBox(IFileDialogCustomize *iface,
3807 DWORD dwIDCtl)
3808 {
3809 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3810 customctrl *ctrl;
3811 HRESULT hr;
3812 TRACE("%p (%d)\n", This, dwIDCtl);
3813
3814 hr = cctrl_create_new(This, dwIDCtl, NULL, WC_COMBOBOXW, CBS_DROPDOWNLIST, 0,
3815 This->cctrl_def_height, &ctrl);
3816 if(SUCCEEDED(hr))
3817 ctrl->type = IDLG_CCTRL_COMBOBOX;
3818
3819 return hr;
3820 }
3821
3822 static HRESULT WINAPI IFileDialogCustomize_fnAddRadioButtonList(IFileDialogCustomize *iface,
3823 DWORD dwIDCtl)
3824 {
3825 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3826 customctrl *ctrl;
3827 HRESULT hr;
3828 TRACE("%p (%d)\n", This, dwIDCtl);
3829
3830 hr = cctrl_create_new(This, dwIDCtl, NULL, radiobuttonlistW, 0, 0, 0, &ctrl);
3831 if(SUCCEEDED(hr))
3832 {
3833 ctrl->type = IDLG_CCTRL_RADIOBUTTONLIST;
3834 SetWindowLongPtrW(ctrl->hwnd, GWLP_USERDATA, (LPARAM)This);
3835 }
3836
3837 return hr;
3838 }
3839
3840 static HRESULT WINAPI IFileDialogCustomize_fnAddCheckButton(IFileDialogCustomize *iface,
3841 DWORD dwIDCtl,
3842 LPCWSTR pszLabel,
3843 BOOL bChecked)
3844 {
3845 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3846 customctrl *ctrl;
3847 HRESULT hr;
3848 TRACE("%p (%d, %p, %d)\n", This, dwIDCtl, pszLabel, bChecked);
3849
3850 hr = cctrl_create_new(This, dwIDCtl, pszLabel, WC_BUTTONW, BS_AUTOCHECKBOX|BS_MULTILINE, 0,
3851 This->cctrl_def_height, &ctrl);
3852 if(SUCCEEDED(hr))
3853 {
3854 ctrl->type = IDLG_CCTRL_CHECKBUTTON;
3855 SendMessageW(ctrl->hwnd, BM_SETCHECK, bChecked ? BST_CHECKED : BST_UNCHECKED, 0);
3856 }
3857
3858 return hr;
3859 }
3860
3861 static HRESULT WINAPI IFileDialogCustomize_fnAddEditBox(IFileDialogCustomize *iface,
3862 DWORD dwIDCtl,
3863 LPCWSTR pszText)
3864 {
3865 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3866 customctrl *ctrl;
3867 HRESULT hr;
3868 TRACE("%p (%d, %p)\n", This, dwIDCtl, pszText);
3869
3870 hr = cctrl_create_new(This, dwIDCtl, pszText, WC_EDITW, ES_AUTOHSCROLL, WS_EX_CLIENTEDGE,
3871 This->cctrl_def_height, &ctrl);
3872 if(SUCCEEDED(hr))
3873 ctrl->type = IDLG_CCTRL_EDITBOX;
3874
3875 return hr;
3876 }
3877
3878 static HRESULT WINAPI IFileDialogCustomize_fnAddSeparator(IFileDialogCustomize *iface,
3879 DWORD dwIDCtl)
3880 {
3881 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3882 customctrl *ctrl;
3883 HRESULT hr;
3884 TRACE("%p (%d)\n", This, dwIDCtl);
3885
3886 hr = cctrl_create_new(This, dwIDCtl, NULL, WC_STATICW, SS_ETCHEDHORZ, 0,
3887 GetSystemMetrics(SM_CYEDGE), &ctrl);
3888 if(SUCCEEDED(hr))
3889 ctrl->type = IDLG_CCTRL_SEPARATOR;
3890
3891 return hr;
3892 }
3893
3894 static HRESULT WINAPI IFileDialogCustomize_fnAddText(IFileDialogCustomize *iface,
3895 DWORD dwIDCtl,
3896 LPCWSTR pszText)
3897 {
3898 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3899 customctrl *ctrl;
3900 HRESULT hr;
3901 TRACE("%p (%d, %p)\n", This, dwIDCtl, pszText);
3902
3903 hr = cctrl_create_new(This, dwIDCtl, pszText, WC_STATICW, 0, 0,
3904 This->cctrl_def_height, &ctrl);
3905 if(SUCCEEDED(hr))
3906 ctrl->type = IDLG_CCTRL_TEXT;
3907
3908 return hr;
3909 }
3910
3911 static HRESULT WINAPI IFileDialogCustomize_fnSetControlLabel(IFileDialogCustomize *iface,
3912 DWORD dwIDCtl,
3913 LPCWSTR pszLabel)
3914 {
3915 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3916 customctrl *ctrl = get_cctrl(This, dwIDCtl);
3917 TRACE("%p (%d, %p)\n", This, dwIDCtl, pszLabel);
3918
3919 if(!ctrl) return E_INVALIDARG;
3920
3921 switch(ctrl->type)
3922 {
3923 case IDLG_CCTRL_MENU:
3924 case IDLG_CCTRL_PUSHBUTTON:
3925 case IDLG_CCTRL_CHECKBUTTON:
3926 case IDLG_CCTRL_TEXT:
3927 case IDLG_CCTRL_VISUALGROUP:
3928 SendMessageW(ctrl->hwnd, WM_SETTEXT, 0, (LPARAM)pszLabel);
3929 break;
3930 case IDLG_CCTRL_OPENDROPDOWN:
3931 return E_NOTIMPL;
3932 default:
3933 break;
3934 }
3935
3936 return S_OK;
3937 }
3938
3939 static HRESULT WINAPI IFileDialogCustomize_fnGetControlState(IFileDialogCustomize *iface,
3940 DWORD dwIDCtl,
3941 CDCONTROLSTATEF *pdwState)
3942 {
3943 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3944 customctrl *ctrl = get_cctrl(This, dwIDCtl);
3945 TRACE("%p (%d, %p)\n", This, dwIDCtl, pdwState);
3946
3947 if(!ctrl || ctrl->type == IDLG_CCTRL_OPENDROPDOWN) return E_NOTIMPL;
3948
3949 *pdwState = ctrl->cdcstate;
3950 return S_OK;
3951 }
3952
3953 static HRESULT WINAPI IFileDialogCustomize_fnSetControlState(IFileDialogCustomize *iface,
3954 DWORD dwIDCtl,
3955 CDCONTROLSTATEF dwState)
3956 {
3957 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3958 customctrl *ctrl = get_cctrl(This,dwIDCtl);
3959 TRACE("%p (%d, %x)\n", This, dwIDCtl, dwState);
3960
3961 if(ctrl && ctrl->hwnd)
3962 {
3963 LONG wndstyle = GetWindowLongW(ctrl->hwnd, GWL_STYLE);
3964
3965 if(dwState & CDCS_ENABLED)
3966 wndstyle &= ~(WS_DISABLED);
3967 else
3968 wndstyle |= WS_DISABLED;
3969
3970 if(dwState & CDCS_VISIBLE)
3971 wndstyle |= WS_VISIBLE;
3972 else
3973 wndstyle &= ~(WS_VISIBLE);
3974
3975 SetWindowLongW(ctrl->hwnd, GWL_STYLE, wndstyle);
3976
3977 /* We save the state separately since at least one application
3978 * relies on being able to hide a control. */
3979 ctrl->cdcstate = dwState;
3980 }
3981
3982 return S_OK;
3983 }
3984
3985 static HRESULT WINAPI IFileDialogCustomize_fnGetEditBoxText(IFileDialogCustomize *iface,
3986 DWORD dwIDCtl,
3987 WCHAR **ppszText)
3988 {
3989 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
3990 customctrl *ctrl = get_cctrl(This, dwIDCtl);
3991 WCHAR len, *text;
3992 TRACE("%p (%d, %p)\n", This, dwIDCtl, ppszText);
3993
3994 if(!ctrl || !ctrl->hwnd || !(len = SendMessageW(ctrl->hwnd, WM_GETTEXTLENGTH, 0, 0)))
3995 return E_FAIL;
3996
3997 text = CoTaskMemAlloc(sizeof(WCHAR)*(len+1));
3998 if(!text) return E_FAIL;
3999
4000 SendMessageW(ctrl->hwnd, WM_GETTEXT, len+1, (LPARAM)text);
4001 *ppszText = text;
4002 return S_OK;
4003 }
4004
4005 static HRESULT WINAPI IFileDialogCustomize_fnSetEditBoxText(IFileDialogCustomize *iface,
4006 DWORD dwIDCtl,
4007 LPCWSTR pszText)
4008 {
4009 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4010 customctrl *ctrl = get_cctrl(This, dwIDCtl);
4011 TRACE("%p (%d, %s)\n", This, dwIDCtl, debugstr_w(pszText));
4012
4013 if(!ctrl || ctrl->type != IDLG_CCTRL_EDITBOX)
4014 return E_FAIL;
4015
4016 SendMessageW(ctrl->hwnd, WM_SETTEXT, 0, (LPARAM)pszText);
4017 return S_OK;
4018 }
4019
4020 static HRESULT WINAPI IFileDialogCustomize_fnGetCheckButtonState(IFileDialogCustomize *iface,
4021 DWORD dwIDCtl,
4022 BOOL *pbChecked)
4023 {
4024 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4025 customctrl *ctrl = get_cctrl(This, dwIDCtl);
4026 TRACE("%p (%d, %p)\n", This, dwIDCtl, pbChecked);
4027
4028 if(ctrl && ctrl->hwnd)
4029 *pbChecked = (SendMessageW(ctrl->hwnd, BM_GETCHECK, 0, 0) == BST_CHECKED);
4030
4031 return S_OK;
4032 }
4033
4034 static HRESULT WINAPI IFileDialogCustomize_fnSetCheckButtonState(IFileDialogCustomize *iface,
4035 DWORD dwIDCtl,
4036 BOOL bChecked)
4037 {
4038 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4039 customctrl *ctrl = get_cctrl(This, dwIDCtl);
4040 TRACE("%p (%d, %d)\n", This, dwIDCtl, bChecked);
4041
4042 if(ctrl && ctrl->hwnd)
4043 SendMessageW(ctrl->hwnd, BM_SETCHECK, bChecked ? BST_CHECKED:BST_UNCHECKED, 0);
4044
4045 return S_OK;
4046 }
4047
4048 static UINT get_combobox_index_from_id(HWND cb_hwnd, DWORD dwIDItem)
4049 {
4050 UINT count = SendMessageW(cb_hwnd, CB_GETCOUNT, 0, 0);
4051 UINT i;
4052 if(!count || (count == CB_ERR))
4053 return -1;
4054
4055 for(i = 0; i < count; i++)
4056 if(SendMessageW(cb_hwnd, CB_GETITEMDATA, i, 0) == dwIDItem)
4057 return i;
4058
4059 TRACE("Item with id %d not found in combobox %p (item count: %d)\n", dwIDItem, cb_hwnd, count);
4060 return -1;
4061 }
4062
4063 static HRESULT WINAPI IFileDialogCustomize_fnAddControlItem(IFileDialogCustomize *iface,
4064 DWORD dwIDCtl,
4065 DWORD dwIDItem,
4066 LPCWSTR pszLabel)
4067 {
4068 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4069 customctrl *ctrl = get_cctrl(This, dwIDCtl);
4070 HRESULT hr;
4071 TRACE("%p (%d, %d, %s)\n", This, dwIDCtl, dwIDItem, debugstr_w(pszLabel));
4072
4073 if(!ctrl) return E_FAIL;
4074
4075 switch(ctrl->type)
4076 {
4077 case IDLG_CCTRL_COMBOBOX:
4078 {
4079 UINT index;
4080 cctrl_item* item;
4081
4082 hr = add_item(ctrl, dwIDItem, pszLabel, &item);
4083
4084 if (FAILED(hr)) return hr;
4085
4086 index = SendMessageW(ctrl->hwnd, CB_ADDSTRING, 0, (LPARAM)pszLabel);
4087 SendMessageW(ctrl->hwnd, CB_SETITEMDATA, index, dwIDItem);
4088
4089 return S_OK;
4090 }
4091 case IDLG_CCTRL_MENU:
4092 case IDLG_CCTRL_OPENDROPDOWN:
4093 {
4094 cctrl_item* item;
4095 HMENU hmenu;
4096
4097 hr = add_item(ctrl, dwIDItem, pszLabel, &item);
4098
4099 if (FAILED(hr)) return hr;
4100
4101 if (ctrl->type == IDLG_CCTRL_MENU)
4102 {
4103 TBBUTTON tbb;
4104 SendMessageW(ctrl->hwnd, TB_GETBUTTON, 0, (LPARAM)&tbb);
4105 hmenu = (HMENU)tbb.dwData;
4106 }
4107 else /* ctrl->type == IDLG_CCTRL_OPENDROPDOWN */
4108 hmenu = This->hmenu_opendropdown;
4109
4110 AppendMenuW(hmenu, MF_STRING, dwIDItem, pszLabel);
4111 return S_OK;
4112 }
4113 case IDLG_CCTRL_RADIOBUTTONLIST:
4114 {
4115 cctrl_item* item;
4116
4117 hr = add_item(ctrl, dwIDItem, pszLabel, &item);
4118
4119 if (SUCCEEDED(hr))
4120 {
4121 item->hwnd = CreateWindowExW(0, WC_BUTTONW, pszLabel,
4122 WS_CHILD|WS_VISIBLE|WS_CLIPSIBLINGS|BS_RADIOBUTTON|BS_MULTILINE,
4123 0, 0, 0, 0, ctrl->hwnd, ULongToHandle(dwIDItem), COMDLG32_hInstance, 0);
4124
4125 if (!item->hwnd)
4126 {
4127 ERR("Failed to create radio button\n");
4128 list_remove(&item->entry);
4129 item_free(item);
4130 return E_FAIL;
4131 }
4132 }
4133
4134 return hr;
4135 }
4136 default:
4137 break;
4138 }
4139
4140 return E_NOINTERFACE; /* win7 */
4141 }
4142
4143 static HRESULT WINAPI IFileDialogCustomize_fnRemoveControlItem(IFileDialogCustomize *iface,
4144 DWORD dwIDCtl,
4145 DWORD dwIDItem)
4146 {
4147 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4148 customctrl *ctrl = get_cctrl(This, dwIDCtl);
4149 TRACE("%p (%d, %d)\n", This, dwIDCtl, dwIDItem);
4150
4151 if(!ctrl) return E_FAIL;
4152
4153 switch(ctrl->type)
4154 {
4155 case IDLG_CCTRL_COMBOBOX:
4156 {
4157 cctrl_item* item;
4158 DWORD position;
4159
4160 item = get_item(ctrl, dwIDItem, CDCS_VISIBLE|CDCS_ENABLED, &position);
4161
4162 if ((item->cdcstate & (CDCS_VISIBLE|CDCS_ENABLED)) == (CDCS_VISIBLE|CDCS_ENABLED))
4163 {
4164 if(SendMessageW(ctrl->hwnd, CB_DELETESTRING, position, 0) == CB_ERR)
4165 return E_FAIL;
4166 }
4167
4168 list_remove(&item->entry);
4169 item_free(item);
4170
4171 return S_OK;
4172 }
4173 case IDLG_CCTRL_MENU:
4174 case IDLG_CCTRL_OPENDROPDOWN:
4175 {
4176 HMENU hmenu;
4177 cctrl_item* item;
4178
4179 item = get_item(ctrl, dwIDItem, 0, NULL);
4180
4181 if (!item)
4182 return E_UNEXPECTED;
4183
4184 if (item->cdcstate & CDCS_VISIBLE)
4185 {
4186 if (ctrl->type == IDLG_CCTRL_MENU)
4187 {
4188 TBBUTTON tbb;
4189 SendMessageW(ctrl->hwnd, TB_GETBUTTON, 0, (LPARAM)&tbb);
4190 hmenu = (HMENU)tbb.dwData;
4191 }
4192 else /* ctrl->type == IDLG_CCTRL_OPENDROPDOWN */
4193 hmenu = This->hmenu_opendropdown;
4194
4195 if(!hmenu || !DeleteMenu(hmenu, dwIDItem, MF_BYCOMMAND))
4196 return E_UNEXPECTED;
4197 }
4198
4199 list_remove(&item->entry);
4200 item_free(item);
4201
4202 return S_OK;
4203 }
4204 case IDLG_CCTRL_RADIOBUTTONLIST:
4205 {
4206 cctrl_item* item;
4207
4208 item = get_item(ctrl, dwIDItem, 0, NULL);
4209
4210 if (!item)
4211 return E_UNEXPECTED;
4212
4213 list_remove(&item->entry);
4214 item_free(item);
4215
4216 return S_OK;
4217 }
4218 default:
4219 break;
4220 }
4221
4222 return E_FAIL;
4223 }
4224
4225 static HRESULT WINAPI IFileDialogCustomize_fnRemoveAllControlItems(IFileDialogCustomize *iface,
4226 DWORD dwIDCtl)
4227 {
4228 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4229 TRACE("%p (%d)\n", This, dwIDCtl);
4230
4231 /* Not implemented by native */
4232 return E_NOTIMPL;
4233 }
4234
4235 static HRESULT WINAPI IFileDialogCustomize_fnGetControlItemState(IFileDialogCustomize *iface,
4236 DWORD dwIDCtl,
4237 DWORD dwIDItem,
4238 CDCONTROLSTATEF *pdwState)
4239 {
4240 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4241 customctrl *ctrl = get_cctrl(This, dwIDCtl);
4242 TRACE("%p (%d, %d, %p)\n", This, dwIDCtl, dwIDItem, pdwState);
4243
4244 if(!ctrl) return E_FAIL;
4245
4246 switch(ctrl->type)
4247 {
4248 case IDLG_CCTRL_COMBOBOX:
4249 case IDLG_CCTRL_MENU:
4250 case IDLG_CCTRL_OPENDROPDOWN:
4251 case IDLG_CCTRL_RADIOBUTTONLIST:
4252 {
4253 cctrl_item* item;
4254
4255 item = get_item(ctrl, dwIDItem, 0, NULL);
4256
4257 if (!item)
4258 return E_UNEXPECTED;
4259
4260 *pdwState = item->cdcstate;
4261
4262 return S_OK;
4263 }
4264 default:
4265 break;
4266 }
4267
4268 return E_FAIL;
4269 }
4270
4271 static HRESULT WINAPI IFileDialogCustomize_fnSetControlItemState(IFileDialogCustomize *iface,
4272 DWORD dwIDCtl,
4273 DWORD dwIDItem,
4274 CDCONTROLSTATEF dwState)
4275 {
4276 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4277 customctrl *ctrl = get_cctrl(This, dwIDCtl);
4278 TRACE("%p (%d, %d, %x)\n", This, dwIDCtl, dwIDItem, dwState);
4279
4280 if(!ctrl) return E_FAIL;
4281
4282 switch(ctrl->type)
4283 {
4284 case IDLG_CCTRL_COMBOBOX:
4285 {
4286 cctrl_item* item;
4287 BOOL visible, was_visible;
4288 DWORD position;
4289
4290 item = get_item(ctrl, dwIDItem, CDCS_VISIBLE|CDCS_ENABLED, &position);
4291
4292 if (!item)
4293 return E_UNEXPECTED;
4294
4295 visible = ((dwState & (CDCS_VISIBLE|CDCS_ENABLED)) == (CDCS_VISIBLE|CDCS_ENABLED));
4296 was_visible = ((item->cdcstate & (CDCS_VISIBLE|CDCS_ENABLED)) == (CDCS_VISIBLE|CDCS_ENABLED));
4297
4298 if (visible && !was_visible)
4299 {
4300 SendMessageW(ctrl->hwnd, CB_INSERTSTRING, position, (LPARAM)item->label);
4301 SendMessageW(ctrl->hwnd, CB_SETITEMDATA, position, dwIDItem);
4302 }
4303 else if (!visible && was_visible)
4304 {
4305 SendMessageW(ctrl->hwnd, CB_DELETESTRING, position, 0);
4306 }
4307
4308 item->cdcstate = dwState;
4309
4310 return S_OK;
4311 }
4312 case IDLG_CCTRL_MENU:
4313 case IDLG_CCTRL_OPENDROPDOWN:
4314 {
4315 HMENU hmenu;
4316 cctrl_item* item;
4317 CDCONTROLSTATEF prev_state;
4318 DWORD position;
4319
4320 item = get_item(ctrl, dwIDItem, CDCS_VISIBLE, &position);
4321
4322 if (!item)
4323 return E_UNEXPECTED;
4324
4325 prev_state = item->cdcstate;
4326
4327 if (ctrl->type == IDLG_CCTRL_MENU)
4328 {
4329 TBBUTTON tbb;
4330 SendMessageW(ctrl->hwnd, TB_GETBUTTON, 0, (LPARAM)&tbb);
4331 hmenu = (HMENU)tbb.dwData;
4332 }
4333 else /* ctrl->type == IDLG_CCTRL_OPENDROPDOWN */
4334 hmenu = This->hmenu_opendropdown;
4335
4336 if (dwState & CDCS_VISIBLE)
4337 {
4338 if (prev_state & CDCS_VISIBLE)
4339 {
4340 /* change state */
4341 EnableMenuItem(hmenu, dwIDItem,
4342 MF_BYCOMMAND|((dwState & CDCS_ENABLED) ? MFS_ENABLED : MFS_DISABLED));
4343 }
4344 else
4345 {
4346 /* show item */
4347 MENUITEMINFOW mii;
4348
4349 mii.cbSize = sizeof(mii);
4350 mii.fMask = MIIM_ID|MIIM_STATE|MIIM_STRING;
4351 mii.fState = (dwState & CDCS_ENABLED) ? MFS_ENABLED : MFS_DISABLED;
4352 mii.wID = dwIDItem;
4353 mii.dwTypeData = item->label;
4354
4355 InsertMenuItemW(hmenu, position, TRUE, &mii);
4356 }
4357 }
4358 else if (prev_state & CDCS_VISIBLE)
4359 {
4360 /* hide item */
4361 DeleteMenu(hmenu, dwIDItem, MF_BYCOMMAND);
4362 }
4363
4364 item->cdcstate = dwState;
4365
4366 if (ctrl->type == IDLG_CCTRL_OPENDROPDOWN)
4367 {
4368 update_control_text(This);
4369 update_layout(This);
4370 }
4371
4372 return S_OK;
4373 }
4374 case IDLG_CCTRL_RADIOBUTTONLIST:
4375 {
4376 cctrl_item* item;
4377
4378 item = get_item(ctrl, dwIDItem, CDCS_VISIBLE, NULL);
4379
4380 if (!item)
4381 return E_UNEXPECTED;
4382
4383 /* Oddly, native allows setting this but doesn't seem to do anything with it. */
4384 item->cdcstate = dwState;
4385
4386 return S_OK;
4387 }
4388 default:
4389 break;
4390 }
4391
4392 return E_FAIL;
4393 }
4394
4395 static HRESULT WINAPI IFileDialogCustomize_fnGetSelectedControlItem(IFileDialogCustomize *iface,
4396 DWORD dwIDCtl,
4397 DWORD *pdwIDItem)
4398 {
4399 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4400 customctrl *ctrl = get_cctrl(This, dwIDCtl);
4401 TRACE("%p (%d, %p)\n", This, dwIDCtl, pdwIDItem);
4402
4403 if(!ctrl) return E_FAIL;
4404
4405 switch(ctrl->type)
4406 {
4407 case IDLG_CCTRL_COMBOBOX:
4408 {
4409 UINT index = SendMessageW(ctrl->hwnd, CB_GETCURSEL, 0, 0);
4410 if(index == CB_ERR)
4411 return E_FAIL;
4412
4413 *pdwIDItem = SendMessageW(ctrl->hwnd, CB_GETITEMDATA, index, 0);
4414 return S_OK;
4415 }
4416 case IDLG_CCTRL_OPENDROPDOWN:
4417 if (This->opendropdown_has_selection)
4418 {
4419 *pdwIDItem = This->opendropdown_selection;
4420 return S_OK;
4421 }
4422 else
4423 {
4424 /* Return first enabled item. */
4425 cctrl_item* item = get_first_item(ctrl);
4426
4427 if (item)
4428 {
4429 *pdwIDItem = item->id;
4430 return S_OK;
4431 }
4432
4433 WARN("no enabled items in open dropdown\n");
4434 return E_FAIL;
4435 }
4436 case IDLG_CCTRL_RADIOBUTTONLIST:
4437 {
4438 cctrl_item* item;
4439
4440 LIST_FOR_EACH_ENTRY(item, &ctrl->sub_items, cctrl_item, entry)
4441 {
4442 if (SendMessageW(item->hwnd, BM_GETCHECK, 0, 0) == BST_CHECKED)
4443 {
4444 *pdwIDItem = item->id;
4445 return S_OK;
4446 }
4447 }
4448
4449 WARN("no checked items in radio button list\n");
4450 return E_FAIL;
4451 }
4452 default:
4453 FIXME("Unsupported control type %d\n", ctrl->type);
4454 }
4455
4456 return E_NOTIMPL;
4457 }
4458
4459 static HRESULT WINAPI IFileDialogCustomize_fnSetSelectedControlItem(IFileDialogCustomize *iface,
4460 DWORD dwIDCtl,
4461 DWORD dwIDItem)
4462 {
4463 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4464 customctrl *ctrl = get_cctrl(This, dwIDCtl);
4465 TRACE("%p (%d, %d)\n", This, dwIDCtl, dwIDItem);
4466
4467 if(!ctrl) return E_INVALIDARG;
4468
4469 switch(ctrl->type)
4470 {
4471 case IDLG_CCTRL_COMBOBOX:
4472 {
4473 UINT index = get_combobox_index_from_id(ctrl->hwnd, dwIDItem);
4474
4475 if(index == -1)
4476 return E_INVALIDARG;
4477
4478 if(SendMessageW(ctrl->hwnd, CB_SETCURSEL, index, 0) == CB_ERR)
4479 return E_FAIL;
4480
4481 return S_OK;
4482 }
4483 case IDLG_CCTRL_RADIOBUTTONLIST:
4484 {
4485 cctrl_item* item;
4486
4487 item = get_item(ctrl, dwIDItem, 0, NULL);
4488
4489 if (item)
4490 {
4491 radiobuttonlist_set_selected_item(This, ctrl, item);
4492 return S_OK;
4493 }
4494
4495 return E_INVALIDARG;
4496 }
4497 default:
4498 FIXME("Unsupported control type %d\n", ctrl->type);
4499 }
4500
4501 return E_INVALIDARG;
4502 }
4503
4504 static HRESULT WINAPI IFileDialogCustomize_fnStartVisualGroup(IFileDialogCustomize *iface,
4505 DWORD dwIDCtl,
4506 LPCWSTR pszLabel)
4507 {
4508 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4509 customctrl *vg;
4510 HRESULT hr;
4511 TRACE("%p (%d, %s)\n", This, dwIDCtl, debugstr_w(pszLabel));
4512
4513 if(This->cctrl_active_vg)
4514 return E_UNEXPECTED;
4515
4516 hr = cctrl_create_new(This, dwIDCtl, pszLabel, WC_STATICW, 0, 0,
4517 This->cctrl_def_height, &vg);
4518 if(SUCCEEDED(hr))
4519 {
4520 vg->type = IDLG_CCTRL_VISUALGROUP;
4521 This->cctrl_active_vg = vg;
4522 }
4523
4524 return hr;
4525 }
4526
4527 static HRESULT WINAPI IFileDialogCustomize_fnEndVisualGroup(IFileDialogCustomize *iface)
4528 {
4529 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4530 TRACE("%p\n", This);
4531
4532 This->cctrl_active_vg = NULL;
4533
4534 return S_OK;
4535 }
4536
4537 static HRESULT WINAPI IFileDialogCustomize_fnMakeProminent(IFileDialogCustomize *iface,
4538 DWORD dwIDCtl)
4539 {
4540 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4541 FIXME("stub - %p (%d)\n", This, dwIDCtl);
4542 return S_OK;
4543 }
4544
4545 static HRESULT WINAPI IFileDialogCustomize_fnSetControlItemText(IFileDialogCustomize *iface,
4546 DWORD dwIDCtl,
4547 DWORD dwIDItem,
4548 LPCWSTR pszLabel)
4549 {
4550 FileDialogImpl *This = impl_from_IFileDialogCustomize(iface);
4551 FIXME("stub - %p (%d, %d, %s)\n", This, dwIDCtl, dwIDItem, debugstr_w(pszLabel));
4552 return E_NOTIMPL;
4553 }
4554
4555 static const IFileDialogCustomizeVtbl vt_IFileDialogCustomize = {
4556 IFileDialogCustomize_fnQueryInterface,
4557 IFileDialogCustomize_fnAddRef,
4558 IFileDialogCustomize_fnRelease,
4559 IFileDialogCustomize_fnEnableOpenDropDown,
4560 IFileDialogCustomize_fnAddMenu,
4561 IFileDialogCustomize_fnAddPushButton,
4562 IFileDialogCustomize_fnAddComboBox,
4563 IFileDialogCustomize_fnAddRadioButtonList,
4564 IFileDialogCustomize_fnAddCheckButton,
4565 IFileDialogCustomize_fnAddEditBox,
4566 IFileDialogCustomize_fnAddSeparator,
4567 IFileDialogCustomize_fnAddText,
4568 IFileDialogCustomize_fnSetControlLabel,
4569 IFileDialogCustomize_fnGetControlState,
4570 IFileDialogCustomize_fnSetControlState,
4571 IFileDialogCustomize_fnGetEditBoxText,
4572 IFileDialogCustomize_fnSetEditBoxText,
4573 IFileDialogCustomize_fnGetCheckButtonState,
4574 IFileDialogCustomize_fnSetCheckButtonState,
4575 IFileDialogCustomize_fnAddControlItem,
4576 IFileDialogCustomize_fnRemoveControlItem,
4577 IFileDialogCustomize_fnRemoveAllControlItems,
4578 IFileDialogCustomize_fnGetControlItemState,
4579 IFileDialogCustomize_fnSetControlItemState,
4580 IFileDialogCustomize_fnGetSelectedControlItem,
4581 IFileDialogCustomize_fnSetSelectedControlItem,
4582 IFileDialogCustomize_fnStartVisualGroup,
4583 IFileDialogCustomize_fnEndVisualGroup,
4584 IFileDialogCustomize_fnMakeProminent,
4585 IFileDialogCustomize_fnSetControlItemText
4586 };
4587
4588 static HRESULT FileDialog_constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv, enum ITEMDLG_TYPE type)
4589 {
4590 FileDialogImpl *fdimpl;
4591 HRESULT hr;
4592 IShellFolder *psf;
4593 TRACE("%p, %s, %p\n", pUnkOuter, debugstr_guid(riid), ppv);
4594
4595 if(!ppv)
4596 return E_POINTER;
4597 if(pUnkOuter)
4598 return CLASS_E_NOAGGREGATION;
4599
4600 fdimpl = HeapAlloc(GetProcessHeap(), 0, sizeof(FileDialogImpl));
4601 if(!fdimpl)
4602 return E_OUTOFMEMORY;
4603
4604 fdimpl->ref = 1;
4605 fdimpl->IFileDialog2_iface.lpVtbl = &vt_IFileDialog2;
4606 fdimpl->IExplorerBrowserEvents_iface.lpVtbl = &vt_IExplorerBrowserEvents;
4607 fdimpl->IServiceProvider_iface.lpVtbl = &vt_IServiceProvider;
4608 fdimpl->ICommDlgBrowser3_iface.lpVtbl = &vt_ICommDlgBrowser3;
4609 fdimpl->IOleWindow_iface.lpVtbl = &vt_IOleWindow;
4610 fdimpl->IFileDialogCustomize_iface.lpVtbl = &vt_IFileDialogCustomize;
4611
4612 if(type == ITEMDLG_TYPE_OPEN)
4613 {
4614 fdimpl->dlg_type = ITEMDLG_TYPE_OPEN;
4615 fdimpl->u.IFileOpenDialog_iface.lpVtbl = &vt_IFileOpenDialog;
4616 fdimpl->options = FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST | FOS_NOCHANGEDIR;
4617 fdimpl->custom_title = fdimpl->custom_okbutton = NULL;
4618 }
4619 else
4620 {
4621 WCHAR buf[16];
4622 fdimpl->dlg_type = ITEMDLG_TYPE_SAVE;
4623 fdimpl->u.IFileSaveDialog_iface.lpVtbl = &vt_IFileSaveDialog;
4624 fdimpl->options = FOS_OVERWRITEPROMPT | FOS_NOREADONLYRETURN | FOS_PATHMUSTEXIST | FOS_NOCHANGEDIR;
4625
4626 LoadStringW(COMDLG32_hInstance, IDS_SAVE, buf, sizeof(buf)/sizeof(WCHAR));
4627 fdimpl->custom_title = StrDupW(buf);
4628 fdimpl->custom_okbutton = StrDupW(buf);
4629 }
4630
4631 fdimpl->filterspecs = NULL;
4632 fdimpl->filterspec_count = 0;
4633 fdimpl->filetypeindex = 0;
4634
4635 fdimpl->psia_selection = fdimpl->psia_results = NULL;
4636 fdimpl->psi_setfolder = fdimpl->psi_folder = NULL;
4637
4638 list_init(&fdimpl->events_clients);
4639 fdimpl->events_next_cookie = 0;
4640
4641 fdimpl->dlg_hwnd = NULL;
4642 fdimpl->peb = NULL;
4643
4644 fdimpl->set_filename = NULL;
4645 fdimpl->default_ext = NULL;
4646 fdimpl->custom_cancelbutton = fdimpl->custom_filenamelabel = NULL;
4647
4648 fdimpl->client_guid = GUID_NULL;
4649
4650 fdimpl->hmenu_opendropdown = NULL;
4651 fdimpl->hfont_opendropdown = NULL;
4652
4653 /* FIXME: The default folder setting should be restored for the
4654 * application if it was previously set. */
4655 SHGetDesktopFolder(&psf);
4656 SHGetItemFromObject((IUnknown*)psf, &IID_IShellItem, (void**)&fdimpl->psi_defaultfolder);
4657 IShellFolder_Release(psf);
4658
4659 hr = init_custom_controls(fdimpl);
4660 if(FAILED(hr))
4661 {
4662 ERR("Failed to initialize custom controls (0x%08x).\n", hr);
4663 IFileDialog2_Release(&fdimpl->IFileDialog2_iface);
4664 return E_FAIL;
4665 }
4666
4667 hr = IFileDialog2_QueryInterface(&fdimpl->IFileDialog2_iface, riid, ppv);
4668 IFileDialog2_Release(&fdimpl->IFileDialog2_iface);
4669 return hr;
4670 }
4671
4672 HRESULT FileOpenDialog_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv)
4673 {
4674 return FileDialog_constructor(pUnkOuter, riid, ppv, ITEMDLG_TYPE_OPEN);
4675 }
4676
4677 HRESULT FileSaveDialog_Constructor(IUnknown *pUnkOuter, REFIID riid, void **ppv)
4678 {
4679 return FileDialog_constructor(pUnkOuter, riid, ppv, ITEMDLG_TYPE_SAVE);
4680 }
Windows API implementation