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