dlls/comdlg32/itemdlg.c

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