brsfolder.c 38.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * Copyright 1999 Juergen Schmied
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 18 19
 *
 * FIXME:
 *  - many memory leaks
20
 *  - many flags unimplemented
21
 *    - implement editbox
22 23
 */

24 25 26
#include <stdlib.h>
#include <string.h>

27
#define COBJMACROS
28
#define NONAMELESSUNION
29

30
#include "wine/debug.h"
31
#include "undocshell.h"
32
#include "commoncontrols.h"
33 34
#include "pidl.h"
#include "shell32_main.h"
35
#include "shellapi.h"
36
#include "shresdef.h"
37
#include "shellfolder.h"
38

39
WINE_DEFAULT_DEBUG_CHANNEL(shell);
40

41 42
#define SHV_CHANGE_NOTIFY (WM_USER + 0x1111)

43 44 45 46 47 48 49
/* original margins and control size */
typedef struct tagLAYOUT_DATA
{
    LONG left, width, right;
    LONG top, height, bottom;
} LAYOUT_DATA;

50 51 52 53 54 55
typedef struct tagbrowse_info
{
    HWND          hWnd;
    HWND          hwndTreeView;
    LPBROWSEINFOW lpBrowseInfo;
    LPITEMIDLIST  pidlRet;
56 57
    LAYOUT_DATA  *layout;  /* filled by LayoutInit, used by LayoutUpdate */
    SIZE          szMin;
58
    ULONG         hNotify; /* change notification handle */
59
} browse_info;
60

61
typedef struct tagTV_ITEMDATA
62 63
{
   LPSHELLFOLDER lpsfParent; /* IShellFolder of the parent */
64
   LPITEMIDLIST  lpi;        /* PIDL relative to parent */
65 66 67 68
   LPITEMIDLIST  lpifq;      /* Fully qualified PIDL */
   IEnumIDList*  pEnumIL;    /* Children iterator */ 
} TV_ITEMDATA, *LPTV_ITEMDATA;

69 70 71 72 73 74 75 76 77 78 79 80
typedef struct tagLAYOUT_INFO
{
    int iItemId;          /* control id */
    DWORD dwAnchor;       /* BF_* flags specifying which margins should remain constant */
} LAYOUT_INFO;

static const LAYOUT_INFO g_layout_info[] =
{
    {IDD_TITLE,         BF_TOP|BF_LEFT|BF_RIGHT},
    {IDD_STATUS,        BF_TOP|BF_LEFT|BF_RIGHT},
    {IDD_FOLDER,        BF_TOP|BF_LEFT|BF_RIGHT},
    {IDD_TREEVIEW,      BF_TOP|BF_BOTTOM|BF_LEFT|BF_RIGHT},
81
    {IDD_FOLDER,        BF_BOTTOM|BF_LEFT},
82 83 84 85 86 87
    {IDD_FOLDERTEXT,    BF_BOTTOM|BF_LEFT|BF_RIGHT},
    {IDD_MAKENEWFOLDER, BF_BOTTOM|BF_LEFT},
    {IDOK,              BF_BOTTOM|BF_RIGHT},
    {IDCANCEL,          BF_BOTTOM|BF_RIGHT}
};

88 89 90 91
#define SUPPORTEDFLAGS (BIF_STATUSTEXT | \
                        BIF_BROWSEFORCOMPUTER | \
                        BIF_RETURNFSANCESTORS | \
                        BIF_RETURNONLYFSDIRS | \
92 93
                        BIF_NONEWFOLDERBUTTON | \
                        BIF_NEWDIALOGSTYLE | \
94 95
                        BIF_BROWSEINCLUDEFILES)

96 97 98 99 100
static void FillTreeView(browse_info*, LPSHELLFOLDER,
               LPITEMIDLIST, HTREEITEM, IEnumIDList*);
static HTREEITEM InsertTreeViewItem( browse_info*, IShellFolder *,
               LPCITEMIDLIST, LPCITEMIDLIST, IEnumIDList*, HTREEITEM);

101
static const WCHAR szBrowseFolderInfo[] = {
102 103 104 105 106
    '_','_','W','I','N','E','_',
    'B','R','S','F','O','L','D','E','R','D','L','G','_',
    'I','N','F','O',0
};

107 108 109 110
static inline DWORD BrowseFlagsToSHCONTF(UINT ulFlags)
{
    return SHCONTF_FOLDERS | (ulFlags & BIF_BROWSEINCLUDEFILES ? SHCONTF_NONFOLDERS : 0);
}
111

112 113 114 115 116
static void browsefolder_callback( LPBROWSEINFOW lpBrowseInfo, HWND hWnd,
                                   UINT msg, LPARAM param )
{
    if (!lpBrowseInfo->lpfn)
        return;
117
    lpBrowseInfo->lpfn( hWnd, msg, param, lpBrowseInfo->lParam );
118 119
}

120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
static LAYOUT_DATA *LayoutInit(HWND hwnd, const LAYOUT_INFO *layout_info, int layout_count)
{
    LAYOUT_DATA *data;
    RECT rcWnd;
    int i;

    GetClientRect(hwnd, &rcWnd);
    data = SHAlloc(sizeof(LAYOUT_DATA)*layout_count);
    for (i = 0; i < layout_count; i++)
    {
        RECT r;
        HWND hItem = GetDlgItem(hwnd, layout_info[i].iItemId);

        if (hItem == NULL)
            ERR("Item %d not found\n", i);
        GetWindowRect(hItem, &r);
        MapWindowPoints(HWND_DESKTOP, hwnd, (LPPOINT)&r, 2);

        data[i].left = r.left;
        data[i].right = rcWnd.right - r.right;
        data[i].width = r.right - r.left;

        data[i].top = r.top;
        data[i].bottom = rcWnd.bottom - r.bottom;
        data[i].height = r.bottom - r.top;
    }
    return data;
}

static void LayoutUpdate(HWND hwnd, LAYOUT_DATA *data, const LAYOUT_INFO *layout_info, int layout_count)
{
    RECT rcWnd;
    int i;

    GetClientRect(hwnd, &rcWnd);
    for (i = 0; i < layout_count; i++)
    {
        RECT r;
        HWND hItem = GetDlgItem(hwnd, layout_info[i].iItemId);

        GetWindowRect(hItem, &r);
        MapWindowPoints(HWND_DESKTOP, hwnd, (LPPOINT)&r, 2);

        if (layout_info[i].dwAnchor & BF_RIGHT)
        {
            r.right = rcWnd.right - data[i].right;
            if (!(layout_info[i].dwAnchor & BF_LEFT))
                r.left = r.right - data[i].width;
        }

        if (layout_info[i].dwAnchor & BF_BOTTOM)
        {
            r.bottom = rcWnd.bottom - data[i].bottom;
            if (!(layout_info[i].dwAnchor & BF_TOP))
                r.top = r.bottom - data[i].height;
        }

        SetWindowPos(hItem, NULL, r.left, r.top, r.right - r.left, r.bottom - r.top, SWP_NOZORDER);
    }
}


182 183 184 185 186 187 188 189 190
/******************************************************************************
 * InitializeTreeView [Internal]
 *
 * Called from WM_INITDIALOG handler.
 * 
 * PARAMS
 *  hwndParent [I] The BrowseForFolder dialog
 *  root       [I] ITEMIDLIST of the root shell folder
 */
191
static void InitializeTreeView( browse_info *info )
192
{
193 194 195 196 197
    LPITEMIDLIST pidlParent, pidlChild;
    HIMAGELIST hImageList;
    HRESULT hr;
    IShellFolder *lpsfParent, *lpsfRoot;
    IEnumIDList * pEnumChildren = NULL;
198 199 200
    HTREEITEM item;
    DWORD flags;
    LPCITEMIDLIST root = info->lpBrowseInfo->pidlRoot;
201

202
    TRACE("%p\n", info );
203
    
204
    Shell_GetImageLists(NULL, &hImageList);
205 206

    if (hImageList)
207
        SendMessageW( info->hwndTreeView, TVM_SETIMAGELIST, 0, (LPARAM)hImageList );
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229

    /* We want to call InsertTreeViewItem down the code, in order to insert
     * the root item of the treeview. Due to InsertTreeViewItem's signature, 
     * we need the following to do this:
     *
     * + An ITEMIDLIST corresponding to _the parent_ of root. 
     * + An ITEMIDLIST, which is a relative path from root's parent to root 
     *   (containing a single SHITEMID).
     * + An IShellFolder interface pointer of root's parent folder.
     *
     * If root is 'Desktop', then root's parent is also 'Desktop'.
     */

    pidlParent = ILClone(root);
    ILRemoveLastID(pidlParent);
    pidlChild = ILClone(ILFindLastID(root));
    
    if (_ILIsDesktop(pidlParent)) {
        hr = SHGetDesktopFolder(&lpsfParent);
    } else {
        IShellFolder *lpsfDesktop;
        hr = SHGetDesktopFolder(&lpsfDesktop);
230
        if (FAILED(hr)) {
231
            WARN("SHGetDesktopFolder failed! hr = %08x\n", hr);
232
            ILFree(pidlChild);
233
            ILFree(pidlParent);
234 235 236 237 238
            return;
        }
        hr = IShellFolder_BindToObject(lpsfDesktop, pidlParent, 0, &IID_IShellFolder, (LPVOID*)&lpsfParent);
        IShellFolder_Release(lpsfDesktop);
    }
239 240

    if (FAILED(hr)) {
241
        WARN("Could not bind to parent shell folder! hr = %08x\n", hr);
242
        ILFree(pidlChild);
243
        ILFree(pidlParent);
244 245 246
        return;
    }

247
    if (!_ILIsEmpty(pidlChild)) {
248 249 250 251 252
        hr = IShellFolder_BindToObject(lpsfParent, pidlChild, 0, &IID_IShellFolder, (LPVOID*)&lpsfRoot);
    } else {
        lpsfRoot = lpsfParent;
        hr = IShellFolder_AddRef(lpsfParent);
    }
253 254

    if (FAILED(hr)) {
255
        WARN("Could not bind to root shell folder! hr = %08x\n", hr);
256
        IShellFolder_Release(lpsfParent);
257
        ILFree(pidlChild);
258
        ILFree(pidlParent);
259 260 261
        return;
    }

262 263
    flags = BrowseFlagsToSHCONTF( info->lpBrowseInfo->ulFlags );
    hr = IShellFolder_EnumObjects( lpsfRoot, info->hWnd, flags, &pEnumChildren );
264
    if (FAILED(hr)) {
265
        WARN("Could not get child iterator! hr = %08x\n", hr);
266 267
        IShellFolder_Release(lpsfParent);
        IShellFolder_Release(lpsfRoot);
268
        ILFree(pidlChild);
269
        ILFree(pidlParent);
270 271 272
        return;
    }

273
    SendMessageW( info->hwndTreeView, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT );
274 275
    item = InsertTreeViewItem( info, lpsfParent, pidlChild,
                               pidlParent, pEnumChildren, TVI_ROOT );
276
    SendMessageW( info->hwndTreeView, TVM_EXPAND, TVE_EXPAND, (LPARAM)item );
277

278
    ILFree(pidlChild);
279
    ILFree(pidlParent);
280 281
    IShellFolder_Release(lpsfRoot);
    IShellFolder_Release(lpsfParent);
282 283
}

284
static int GetIcon(LPCITEMIDLIST lpi, UINT uFlags)
285
{
286
    SHFILEINFOW sfi;
287 288 289 290
    IImageList *list;

    list = (IImageList *)SHGetFileInfoW((LPCWSTR)lpi, 0 ,&sfi, sizeof(SHFILEINFOW), uFlags);
    if (list) IImageList_Release(list);
291
    return sfi.iIcon;
292 293
}

294
static void GetNormalAndSelectedIcons(LPITEMIDLIST lpifq, LPTVITEMW lpTV_ITEM)
295
{
296 297
    LPITEMIDLIST pidlDesktop = NULL;
    DWORD flags;
298

299
    TRACE("%p %p\n",lpifq, lpTV_ITEM);
300

301 302 303 304 305
    if (!lpifq)
    {
        pidlDesktop = _ILCreateDesktop();
        lpifq = pidlDesktop;
    }
306

307 308
    flags = SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON;
    lpTV_ITEM->iImage = GetIcon( lpifq, flags );
309

310 311
    flags = SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_OPENICON;
    lpTV_ITEM->iSelectedImage = GetIcon( lpifq, flags );
312

313 314
    if (pidlDesktop)
        ILFree( pidlDesktop );
315 316
}

317 318 319
/******************************************************************************
 * GetName [Internal]
 *
320
 * Query a shell folder for the display name of one of its children
321 322 323 324 325 326 327 328 329 330 331
 *
 * PARAMS
 *  lpsf           [I] IShellFolder interface of the folder to be queried.
 *  lpi            [I] ITEMIDLIST of the child, relative to parent
 *  dwFlags        [I] as in IShellFolder::GetDisplayNameOf
 *  lpFriendlyName [O] The desired display name in unicode
 *
 * RETURNS
 *  Success: TRUE
 *  Failure: FALSE
 */
332
static BOOL GetName(LPSHELLFOLDER lpsf, LPCITEMIDLIST lpi, DWORD dwFlags, LPWSTR lpFriendlyName)
333
{
334
	BOOL   bSuccess=TRUE;
335 336
	STRRET str;

337
	TRACE("%p %p %x %p\n", lpsf, lpi, dwFlags, lpFriendlyName);
338
	if (SUCCEEDED(IShellFolder_GetDisplayNameOf(lpsf, lpi, dwFlags, &str)))
339
          bSuccess = StrRetToStrNW(lpFriendlyName, MAX_PATH, &str, lpi);
340 341 342
	else
	  bSuccess = FALSE;

343
	TRACE("-- %s\n", debugstr_w(lpFriendlyName));
344 345 346
	return bSuccess;
}

347 348 349 350
/******************************************************************************
 * InsertTreeViewItem [Internal]
 *
 * PARAMS
351
 *  info       [I] data for the dialog
352
 *  lpsf       [I] IShellFolder interface of the item's parent shell folder 
353
 *  pidl       [I] ITEMIDLIST of the child to insert, relative to parent
354 355 356 357 358 359 360 361
 *  pidlParent [I] ITEMIDLIST of the parent shell folder
 *  pEnumIL    [I] Iterator for the children of the item to be inserted
 *  hParent    [I] The treeview-item that represents the parent shell folder
 *
 * RETURNS
 *  Success: Handle to the created and inserted treeview-item
 *  Failure: NULL
 */
362 363 364
static HTREEITEM InsertTreeViewItem( browse_info *info, IShellFolder * lpsf,
    LPCITEMIDLIST pidl, LPCITEMIDLIST pidlParent, IEnumIDList* pEnumIL,
    HTREEITEM hParent)
365
{
366 367 368
	TVITEMW 	tvi;
	TVINSERTSTRUCTW	tvins;
	WCHAR		szBuff[MAX_PATH];
369
	LPTV_ITEMDATA	lptvid=0;
370

371
	tvi.mask  = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
372

373 374
	tvi.cChildren= pEnumIL ? 1 : 0;
	tvi.mask |= TVIF_CHILDREN;
375

376
	if (!GetName(lpsf, pidl, SHGDN_NORMAL, szBuff))
377
	    return NULL;
378

379 380
	lptvid = SHAlloc( sizeof(TV_ITEMDATA) );
	if (!lptvid)
381
	    return NULL;
382

383 384 385
	tvi.pszText    = szBuff;
	tvi.cchTextMax = MAX_PATH;
	tvi.lParam = (LPARAM)lptvid;
386

387 388 389 390 391 392
	IShellFolder_AddRef(lpsf);
	lptvid->lpsfParent = lpsf;
	lptvid->lpi	= ILClone(pidl);
	lptvid->lpifq	= pidlParent ? ILCombine(pidlParent, pidl) : ILClone(pidl);
	lptvid->pEnumIL = pEnumIL;
	GetNormalAndSelectedIcons(lptvid->lpifq, &tvi);
393

394
	tvins.u.item       = tvi;
395 396
	tvins.hInsertAfter = NULL;
	tvins.hParent      = hParent;
397

398
	return TreeView_InsertItemW( info->hwndTreeView, &tvins );
399
}
400

401 402 403 404 405 406 407
/******************************************************************************
 * FillTreeView [Internal]
 *
 * For each child (given by lpe) of the parent shell folder, which is given by 
 * lpsf and whose PIDL is pidl, insert a treeview-item right under hParent
 *
 * PARAMS
408
 *  info    [I] data for the dialog
409 410 411 412 413
 *  lpsf    [I] IShellFolder interface of the parent shell folder
 *  pidl    [I] ITEMIDLIST of the parent shell folder
 *  hParent [I] The treeview item that represents the parent shell folder
 *  lpe     [I] An iterator for the children of the parent shell folder
 */
414 415
static void FillTreeView( browse_info *info, IShellFolder * lpsf,
                 LPITEMIDLIST  pidl, HTREEITEM hParent, IEnumIDList* lpe)
416
{
417
	LPITEMIDLIST	pidlTemp = 0;
418 419
	ULONG		ulFetched;
	HRESULT		hr;
420
	HWND		hwnd = GetParent( info->hwndTreeView );
421

Kevin Koltzau's avatar
Kevin Koltzau committed
422
	TRACE("%p %p %p %p\n",lpsf, pidl, hParent, lpe);
423 424 425 426

	/* No IEnumIDList -> No children */
	if (!lpe) return;
	
427 428
	SetCapture( hwnd );
	SetCursor( LoadCursorA( 0, (LPSTR)IDC_WAIT ) );
429

430
	while (S_OK == IEnumIDList_Next(lpe,1,&pidlTemp,&ulFetched))
431 432 433 434
	{
	    ULONG ulAttrs = SFGAO_HASSUBFOLDER | SFGAO_FOLDER;
	    IEnumIDList* pEnumIL = NULL;
	    IShellFolder* pSFChild = NULL;
435
	    IShellFolder_GetAttributesOf(lpsf, 1, (LPCITEMIDLIST*)&pidlTemp, &ulAttrs);
436 437 438 439
	    if (ulAttrs & SFGAO_FOLDER)
	    {
	        hr = IShellFolder_BindToObject(lpsf,pidlTemp,NULL,&IID_IShellFolder,(LPVOID*)&pSFChild);
	        if (SUCCEEDED(hr))
440
                {
441 442
	            DWORD flags = BrowseFlagsToSHCONTF(info->lpBrowseInfo->ulFlags);
	            hr = IShellFolder_EnumObjects(pSFChild, hwnd, flags, &pEnumIL);
443
                    if (hr == S_OK)
444
                    {
445 446
                        if ((IEnumIDList_Skip(pEnumIL, 1) != S_OK) ||
                             FAILED(IEnumIDList_Reset(pEnumIL)))
447 448 449 450 451 452 453
                        {
                            IEnumIDList_Release(pEnumIL);
                            pEnumIL = NULL;
                        }
                    }
                    IShellFolder_Release(pSFChild);
                }
454
	    }
455

456
	    if (!InsertTreeViewItem(info, lpsf, pidlTemp, pidl, pEnumIL, hParent))
457
	        goto done;
458
	    SHFree(pidlTemp);  /* Finally, free the pidl that the shell gave us... */
459
	    pidlTemp=NULL;
460 461
	}

462
done:
463
	ReleaseCapture();
464
	SetCursor(LoadCursorW(0, (LPWSTR)IDC_ARROW));
465
    SHFree(pidlTemp);
466 467
}

468 469 470 471 472 473 474 475
static inline BOOL PIDLIsType(LPCITEMIDLIST pidl, PIDLTYPE type)
{
    LPPIDLDATA data = _ILGetDataPointer(pidl);
    if (!data)
        return FALSE;
    return (data->type == type);
}

476
static void BrsFolder_CheckValidSelection( browse_info *info, LPTV_ITEMDATA lptvid )
477
{
478
    LPBROWSEINFOW lpBrowseInfo = info->lpBrowseInfo;
479 480 481
    LPCITEMIDLIST pidl = lptvid->lpi;
    BOOL bEnabled = TRUE;
    DWORD dwAttributes;
482 483
    HRESULT r;

484 485 486 487 488 489
    if ((lpBrowseInfo->ulFlags & BIF_BROWSEFORCOMPUTER) &&
        !PIDLIsType(pidl, PT_COMP))
        bEnabled = FALSE;
    if (lpBrowseInfo->ulFlags & BIF_RETURNFSANCESTORS)
    {
        dwAttributes = SFGAO_FILESYSANCESTOR | SFGAO_FILESYSTEM;
490 491
        r = IShellFolder_GetAttributesOf(lptvid->lpsfParent, 1,
                                (LPCITEMIDLIST*)&lptvid->lpi, &dwAttributes);
492
        if (FAILED(r) || !(dwAttributes & (SFGAO_FILESYSANCESTOR|SFGAO_FILESYSTEM)))
493 494
            bEnabled = FALSE;
    }
495 496 497 498 499

    dwAttributes = SFGAO_FOLDER | SFGAO_FILESYSTEM;
    r = IShellFolder_GetAttributesOf(lptvid->lpsfParent, 1,
            (LPCITEMIDLIST*)&lptvid->lpi, &dwAttributes);
    if (FAILED(r) ||
500
            ((dwAttributes & (SFGAO_FOLDER|SFGAO_FILESYSTEM)) != (SFGAO_FOLDER|SFGAO_FILESYSTEM)))
501 502
    {
        if (lpBrowseInfo->ulFlags & BIF_RETURNONLYFSDIRS)
503
            bEnabled = FALSE;
504
        EnableWindow(GetDlgItem(info->hWnd, IDD_MAKENEWFOLDER), FALSE);
505
    }
506 507 508
    else
        EnableWindow(GetDlgItem(info->hWnd, IDD_MAKENEWFOLDER), TRUE);

509
    SendMessageW(info->hWnd, BFFM_ENABLEOK, 0, bEnabled);
510 511
}

512
static LRESULT BrsFolder_Treeview_Delete( browse_info *info, NMTREEVIEWW *pnmtv )
513
{
514
    LPTV_ITEMDATA lptvid = (LPTV_ITEMDATA)pnmtv->itemOld.lParam;
515

516
    TRACE("TVN_DELETEITEMA/W %p\n", lptvid);
517

518 519 520 521 522 523 524 525
    IShellFolder_Release(lptvid->lpsfParent);
    if (lptvid->pEnumIL)
        IEnumIDList_Release(lptvid->pEnumIL);
    SHFree(lptvid->lpi);
    SHFree(lptvid->lpifq);
    SHFree(lptvid);
    return 0;
}
526

527
static LRESULT BrsFolder_Treeview_Expand( browse_info *info, NMTREEVIEWW *pnmtv )
528 529 530 531
{
    IShellFolder *lpsf2 = NULL;
    LPTV_ITEMDATA lptvid = (LPTV_ITEMDATA) pnmtv->itemNew.lParam;
    HRESULT r;
532

533 534 535 536 537
    TRACE("TVN_ITEMEXPANDINGA/W\n");

    if ((pnmtv->itemNew.state & TVIS_EXPANDEDONCE))
        return 0;

538
    if (!_ILIsEmpty(lptvid->lpi)) {
539
        r = IShellFolder_BindToObject( lptvid->lpsfParent, lptvid->lpi, 0,
540
                                       &IID_IShellFolder, (void**)&lpsf2 );
541 542
    } else {
        lpsf2 = lptvid->lpsfParent;
543 544
        IShellFolder_AddRef(lpsf2);
        r = S_OK;
545 546
    }

547
    if (SUCCEEDED(r))
548
    {
549
        FillTreeView( info, lpsf2, lptvid->lpifq, pnmtv->itemNew.hItem, lptvid->pEnumIL);
550 551
        IShellFolder_Release( lpsf2 );
    }
552

553 554 555
    /* My Computer is already sorted and trying to do a simple text
     * sort will only mess things up */
    if (!_ILIsMyComputer(lptvid->lpi))
556 557
        SendMessageW( info->hwndTreeView, TVM_SORTCHILDREN,
                      FALSE, (LPARAM)pnmtv->itemNew.hItem );
558 559

    return 0;
560 561
}

562
static HRESULT BrsFolder_Treeview_Changed( browse_info *info, NMTREEVIEWW *pnmtv )
563 564
{
    LPTV_ITEMDATA lptvid = (LPTV_ITEMDATA) pnmtv->itemNew.lParam;
565
    WCHAR name[MAX_PATH];
566

567 568
    ILFree(info->pidlRet);
    info->pidlRet = ILClone(lptvid->lpifq);
569 570 571 572

    if (GetName(lptvid->lpsfParent, lptvid->lpi, SHGDN_NORMAL, name))
            SetWindowTextW( GetDlgItem(info->hWnd, IDD_FOLDERTEXT), name );

573 574 575
    browsefolder_callback( info->lpBrowseInfo, info->hWnd, BFFM_SELCHANGED,
                           (LPARAM)info->pidlRet );
    BrsFolder_CheckValidSelection( info, lptvid );
576
    return S_OK;
577
}
578

579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618
static LRESULT BrsFolder_Treeview_Rename(browse_info *info, NMTVDISPINFOW *pnmtv)
{
    LPTV_ITEMDATA item_data;
    WCHAR old_path[MAX_PATH], new_path[MAX_PATH], *p;
    NMTREEVIEWW nmtv;
    TVITEMW item;

    if(!pnmtv->item.pszText)
        return 0;

    item.mask = TVIF_HANDLE|TVIF_PARAM;
    item.hItem = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_CARET, 0);
    SendMessageW(info->hwndTreeView, TVM_GETITEMW, 0, (LPARAM)&item);
    item_data = (LPTV_ITEMDATA)item.lParam;

    SHGetPathFromIDListW(item_data->lpifq, old_path);
    if(!(p = strrchrW(old_path, '\\')))
        return 0;
    p = new_path+(p-old_path+1);
    memcpy(new_path, old_path, (p-new_path)*sizeof(WCHAR));
    strcpyW(p, pnmtv->item.pszText);

    if(!MoveFileW(old_path, new_path))
        return 0;

    SHFree(item_data->lpifq);
    SHFree(item_data->lpi);
    item_data->lpifq = SHSimpleIDListFromPathW(new_path);
    IShellFolder_ParseDisplayName(item_data->lpsfParent, NULL, NULL,
            pnmtv->item.pszText, NULL, &item_data->lpi, NULL);

    item.mask = TVIF_HANDLE|TVIF_TEXT;
    item.pszText = pnmtv->item.pszText;
    SendMessageW(info->hwndTreeView, TVM_SETITEMW, 0, (LPARAM)&item);

    nmtv.itemNew.lParam = item.lParam;
    BrsFolder_Treeview_Changed(info, &nmtv);
    return 0;
}

619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640
static HRESULT BrsFolder_Rename(browse_info *info, HTREEITEM rename)
{
    SendMessageW(info->hwndTreeView, TVM_SELECTITEM, TVGN_CARET, (LPARAM)rename);
    SendMessageW(info->hwndTreeView, TVM_EDITLABELW, 0, (LPARAM)rename);
    return S_OK;
}

static LRESULT BrsFolder_Treeview_Keydown(browse_info *info, LPNMTVKEYDOWN keydown)
{
    HTREEITEM selected_item;

    /* Old dialog doesn't support those advanced features */
    if (!(info->lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE))
        return 0;

    selected_item = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_CARET, 0);

    switch (keydown->wVKey)
    {
    case VK_F2:
        BrsFolder_Rename(info, selected_item);
        break;
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
    case VK_DELETE:
        {
            const ITEMIDLIST *item_id;
            ISFHelper *psfhlp;
            HRESULT hr;
            TVITEMW item;
            TV_ITEMDATA *item_data;

            item.mask  = TVIF_PARAM;
            item.hItem = selected_item;
            SendMessageW(info->hwndTreeView, TVM_GETITEMW, 0, (LPARAM)&item);
            item_data = (TV_ITEMDATA *)item.lParam;
            item_id = item_data->lpi;

            hr = IShellFolder_QueryInterface(item_data->lpsfParent, &IID_ISFHelper, (void**)&psfhlp);
            if(FAILED(hr))
                return 0;

            /* perform the item deletion - tree view gets updated over shell notification */
            ISFHelper_DeleteItems(psfhlp, 1, &item_id);
            ISFHelper_Release(psfhlp);
        }
        break;
664 665 666 667
    }
    return 0;
}

668
static LRESULT BrsFolder_OnNotify( browse_info *info, UINT CtlID, LPNMHDR lpnmh )
669
{
670
    NMTREEVIEWW *pnmtv = (NMTREEVIEWW *)lpnmh;
671

672
    TRACE("%p %x %p msg=%x\n", info, CtlID, lpnmh, pnmtv->hdr.code);
673

674 675
    if (pnmtv->hdr.idFrom != IDD_TREEVIEW)
        return 0;
676

677 678 679 680
    switch (pnmtv->hdr.code)
    {
    case TVN_DELETEITEMA:
    case TVN_DELETEITEMW:
681
        return BrsFolder_Treeview_Delete( info, pnmtv );
682

683 684
    case TVN_ITEMEXPANDINGA:
    case TVN_ITEMEXPANDINGW:
685
        return BrsFolder_Treeview_Expand( info, pnmtv );
686

687 688
    case TVN_SELCHANGEDA:
    case TVN_SELCHANGEDW:
689
        return BrsFolder_Treeview_Changed( info, pnmtv );
690

691 692 693 694
    case TVN_ENDLABELEDITA:
    case TVN_ENDLABELEDITW:
        return BrsFolder_Treeview_Rename( info, (LPNMTVDISPINFOW)pnmtv );

695 696 697
    case TVN_KEYDOWN:
        return BrsFolder_Treeview_Keydown( info, (LPNMTVKEYDOWN)pnmtv );

698 699 700 701 702 703 704 705 706
    default:
        WARN("unhandled (%d)\n", pnmtv->hdr.code);
        break;
    }

    return 0;
}


707
static BOOL BrsFolder_OnCreate( HWND hWnd, browse_info *info )
708
{
709 710
    LPITEMIDLIST computer_pidl;
    SHChangeNotifyEntry ntreg;
711 712 713 714
    LPBROWSEINFOW lpBrowseInfo = info->lpBrowseInfo;

    info->hWnd = hWnd;
    SetPropW( hWnd, szBrowseFolderInfo, info );
715

716 717
    if (lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE)
        FIXME("flags BIF_NEWDIALOGSTYLE partially implemented\n");
718 719 720
    if (lpBrowseInfo->ulFlags & ~SUPPORTEDFLAGS)
	FIXME("flags %x not implemented\n", lpBrowseInfo->ulFlags & ~SUPPORTEDFLAGS);

721 722 723 724
    if (lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE)
    {
        RECT rcWnd;

725
        info->layout = LayoutInit(hWnd, g_layout_info, ARRAY_SIZE(g_layout_info));
726 727 728 729 730 731

        /* TODO: Windows allows shrinking the windows a bit */
        GetWindowRect(hWnd, &rcWnd);
        info->szMin.cx = rcWnd.right - rcWnd.left;
        info->szMin.cy = rcWnd.bottom - rcWnd.top;
    }
732 733 734 735
    else
    {
        info->layout = NULL;
    }
736

737 738 739 740 741
    if (lpBrowseInfo->lpszTitle)
	SetWindowTextW( GetDlgItem(hWnd, IDD_TITLE), lpBrowseInfo->lpszTitle );
    else
	ShowWindow( GetDlgItem(hWnd, IDD_TITLE), SW_HIDE );

742 743
    if (!(lpBrowseInfo->ulFlags & BIF_STATUSTEXT)
        || (lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE))
744 745
	ShowWindow( GetDlgItem(hWnd, IDD_STATUS), SW_HIDE );

746 747 748 749 750 751 752 753 754 755 756 757
    /* Hide "Make New Folder" Button? */
    if ((lpBrowseInfo->ulFlags & BIF_NONEWFOLDERBUTTON)
        || !(lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE))
        ShowWindow( GetDlgItem(hWnd, IDD_MAKENEWFOLDER), SW_HIDE );

    /* Hide the editbox? */
    if (!(lpBrowseInfo->ulFlags & BIF_EDITBOX))
    {
        ShowWindow( GetDlgItem(hWnd, IDD_FOLDER), SW_HIDE );
        ShowWindow( GetDlgItem(hWnd, IDD_FOLDERTEXT), SW_HIDE );
    }

758 759
    info->hwndTreeView = GetDlgItem( hWnd, IDD_TREEVIEW );
    if (info->hwndTreeView)
760
    {
761
        InitializeTreeView( info );
762 763 764 765 766 767 768 769 770 771 772

        /* Resize the treeview if there's not editbox */
        if ((lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE)
            && !(lpBrowseInfo->ulFlags & BIF_EDITBOX))
        {
            RECT rc;
            GetClientRect(info->hwndTreeView, &rc);
            SetWindowPos(info->hwndTreeView, HWND_TOP, 0, 0,
                         rc.right, rc.bottom + 40, SWP_NOMOVE);
        }
    }
773 774
    else
        ERR("treeview control missing!\n");
775

776 777 778 779 780 781 782 783
    /* Register for change notifications */
    SHGetFolderLocation(NULL, CSIDL_DESKTOP, NULL, 0, &computer_pidl);

    ntreg.pidl = computer_pidl;
    ntreg.fRecursive = TRUE;

    info->hNotify = SHChangeNotifyRegister(hWnd, SHCNRF_InterruptLevel, SHCNE_ALLEVENTS, SHV_CHANGE_NOTIFY, 1, &ntreg);

784
    browsefolder_callback( info->lpBrowseInfo, hWnd, BFFM_INITIALIZED, 0 );
785

786 787
    ILFree(computer_pidl);

788 789 790
    return TRUE;
}

791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
static HRESULT BrsFolder_NewFolder(browse_info *info)
{
    DWORD flags = BrowseFlagsToSHCONTF(info->lpBrowseInfo->ulFlags);
    IShellFolder *desktop, *cur;
    ISFHelper *sfhelper;
    WCHAR name[MAX_PATH];
    HTREEITEM parent, added;
    LPTV_ITEMDATA item_data;
    LPITEMIDLIST new_item;
    TVITEMW item;
    HRESULT hr;
    int len;

    if(!info->pidlRet) {
        ERR("Make new folder button should be disabled\n");
        return E_FAIL;
    }

    /* Create new directory */
    hr = SHGetDesktopFolder(&desktop);
    if(FAILED(hr))
        return hr;
    hr = IShellFolder_BindToObject(desktop, info->pidlRet, 0, &IID_IShellFolder, (void**)&cur);
    IShellFolder_Release(desktop);
    if(FAILED(hr))
        return hr;

    hr = IShellFolder_QueryInterface(cur, &IID_ISFHelper, (void**)&sfhelper);
    if(FAILED(hr))
        return hr;

822 823
    if(!SHGetPathFromIDListW(info->pidlRet, name)) {
        hr = E_FAIL;
824
        goto cleanup;
825
    }
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882

    len = strlenW(name);
    if(len<MAX_PATH)
        name[len++] = '\\';
    hr = ISFHelper_GetUniqueName(sfhelper, &name[len], MAX_PATH-len);
    ISFHelper_Release(sfhelper);
    if(FAILED(hr))
        goto cleanup;

    hr = E_FAIL;
    if(!CreateDirectoryW(name, NULL))
        goto cleanup;

    /* Update parent of newly created directory */
    parent = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_CARET, 0);
    if(!parent)
        goto cleanup;

    SendMessageW(info->hwndTreeView, TVM_EXPAND, TVE_EXPAND, (LPARAM)parent);

    memset(&item, 0, sizeof(TVITEMW));
    item.mask = TVIF_PARAM|TVIF_STATE;
    item.hItem = parent;
    SendMessageW(info->hwndTreeView, TVM_GETITEMW, 0, (LPARAM)&item);
    item_data = (LPTV_ITEMDATA)item.lParam;
    if(!item_data)
        goto cleanup;

    if(item_data->pEnumIL)
        IEnumIDList_Release(item_data->pEnumIL);
    hr = IShellFolder_EnumObjects(cur, info->hwndTreeView, flags, &item_data->pEnumIL);
    if(FAILED(hr))
        goto cleanup;

    /* Update treeview */
    if(!(item.state&TVIS_EXPANDEDONCE)) {
        item.mask = TVIF_STATE;
        item.state = TVIS_EXPANDEDONCE;
        item.stateMask = TVIS_EXPANDEDONCE;
        SendMessageW(info->hwndTreeView, TVM_SETITEMW, 0, (LPARAM)&item);
    }

    hr = IShellFolder_ParseDisplayName(cur, NULL, NULL, name+len, NULL, &new_item, NULL);
    if(FAILED(hr))
        goto cleanup;

    added = InsertTreeViewItem(info, cur, new_item, item_data->lpifq, NULL, parent);
    IShellFolder_Release(cur);
    SHFree(new_item);

    SendMessageW(info->hwndTreeView, TVM_SORTCHILDREN, FALSE, (LPARAM)parent);
    return BrsFolder_Rename(info, added);

cleanup:
    return hr;
}

883
static BOOL BrsFolder_OnCommand( browse_info *info, UINT id )
884
{
885 886
    LPBROWSEINFOW lpBrowseInfo = info->lpBrowseInfo;

887 888 889
    switch (id)
    {
    case IDOK:
890 891
        if (info->pidlRet == NULL) /* A null pidl would mean a cancel */
            info->pidlRet = _ILCreateDesktop();
892
        pdump( info->pidlRet );
893
        if (lpBrowseInfo->pszDisplayName)
894 895
            SHGetPathFromIDListW( info->pidlRet, lpBrowseInfo->pszDisplayName );
        EndDialog( info->hWnd, 1 );
896 897 898
        return TRUE;

    case IDCANCEL:
899
        EndDialog( info->hWnd, 0 );
900
        return TRUE;
901 902

    case IDD_MAKENEWFOLDER:
903
        BrsFolder_NewFolder(info);
904
        return TRUE;
905 906 907 908
    }
    return FALSE;
}

909 910 911
static BOOL BrsFolder_OnSetExpanded(browse_info *info, LPVOID selection, 
    BOOL is_str, HTREEITEM *pItem)
{
912
    LPITEMIDLIST pidlSelection = selection;
913 914 915
    LPCITEMIDLIST pidlCurrent, pidlRoot;
    TVITEMEXW item;
    BOOL bResult = FALSE;
916 917 918

    memset(&item, 0, sizeof(item));

919 920 921 922 923 924 925 926 927 928
    /* If 'selection' is a string, convert to a Shell ID List. */ 
    if (is_str) {
        IShellFolder *psfDesktop;
        HRESULT hr;

        hr = SHGetDesktopFolder(&psfDesktop);
        if (FAILED(hr))
            goto done;

        hr = IShellFolder_ParseDisplayName(psfDesktop, NULL, NULL, 
929
                     selection, NULL, &pidlSelection, NULL);
930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
        IShellFolder_Release(psfDesktop);
        if (FAILED(hr)) 
            goto done;
    }

    /* Move pidlCurrent behind the SHITEMIDs in pidlSelection, which are the root of
     * the sub-tree currently displayed. */
    pidlRoot = info->lpBrowseInfo->pidlRoot;
    pidlCurrent = pidlSelection;
    while (!_ILIsEmpty(pidlRoot) && _ILIsEqualSimple(pidlRoot, pidlCurrent)) {
        pidlRoot = ILGetNext(pidlRoot);
        pidlCurrent = ILGetNext(pidlCurrent);
    }

    /* The given ID List is not part of the SHBrowseForFolder's current sub-tree. */
    if (!_ILIsEmpty(pidlRoot))
        goto done;

    /* Initialize item to point to the first child of the root folder. */
    item.mask = TVIF_PARAM;
950 951 952 953 954
    item.hItem = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_ROOT, 0);

    if (item.hItem)
        item.hItem = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_CHILD,
                                             (LPARAM)item.hItem);
955 956 957 958 959

    /* Walk the tree along the nodes corresponding to the remaining ITEMIDLIST */
    while (item.hItem && !_ILIsEmpty(pidlCurrent)) {
        LPTV_ITEMDATA pItemData;

960
        SendMessageW(info->hwndTreeView, TVM_GETITEMW, 0, (LPARAM)&item);
961 962 963 964 965
        pItemData = (LPTV_ITEMDATA)item.lParam;

        if (_ILIsEqualSimple(pItemData->lpi, pidlCurrent)) {
            pidlCurrent = ILGetNext(pidlCurrent);
            if (!_ILIsEmpty(pidlCurrent)) {
966
                /* Only expand current node and move on to its first child,
967
                 * if we didn't already reach the last SHITEMID */
968
                SendMessageW(info->hwndTreeView, TVM_EXPAND, TVE_EXPAND, (LPARAM)item.hItem);
969 970
                item.hItem = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_CHILD,
                                             (LPARAM)item.hItem);
971 972
            }
        } else {
973 974
            item.hItem = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_NEXT,
                                             (LPARAM)item.hItem);
975 976 977 978 979 980 981
        }
    }

    if (_ILIsEmpty(pidlCurrent) && item.hItem) 
        bResult = TRUE;

done:
982
    if (pidlSelection && pidlSelection != selection)
983 984 985 986 987 988 989 990 991 992 993 994
        ILFree(pidlSelection);

    if (pItem) 
        *pItem = item.hItem;
    
    return bResult;
}

static BOOL BrsFolder_OnSetSelectionW(browse_info *info, LPVOID selection, BOOL is_str) {
    HTREEITEM hItem;
    BOOL bResult;

995 996
    if (!selection) return FALSE;

997 998
    bResult = BrsFolder_OnSetExpanded(info, selection, is_str, &hItem);
    if (bResult)
999
        SendMessageW(info->hwndTreeView, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hItem );
1000 1001 1002 1003 1004 1005 1006 1007 1008 1009
    return bResult;
}

static BOOL BrsFolder_OnSetSelectionA(browse_info *info, LPVOID selection, BOOL is_str) {
    LPWSTR selectionW = NULL;
    BOOL result = FALSE;
    int length;
    
    if (!is_str)
        return BrsFolder_OnSetSelectionW(info, selection, is_str);
1010 1011

    if ((length = MultiByteToWideChar(CP_ACP, 0, selection, -1, NULL, 0)) &&
1012
        (selectionW = heap_alloc(length * sizeof(WCHAR))) &&
1013
        MultiByteToWideChar(CP_ACP, 0, selection, -1, selectionW, length))
1014 1015 1016 1017
    {
        result = BrsFolder_OnSetSelectionW(info, selectionW, is_str);
    }

1018
    heap_free(selectionW);
1019 1020 1021
    return result;
}

1022
static LRESULT BrsFolder_OnWindowPosChanging(browse_info *info, WINDOWPOS *pos)
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033
{
    if ((info->lpBrowseInfo->ulFlags & BIF_NEWDIALOGSTYLE) && !(pos->flags & SWP_NOSIZE))
    {
        if (pos->cx < info->szMin.cx)
            pos->cx = info->szMin.cx;
        if (pos->cy < info->szMin.cy)
            pos->cy = info->szMin.cy;
    }
    return 0;
}

1034 1035 1036 1037 1038 1039 1040 1041
static INT BrsFolder_OnDestroy(browse_info *info)
{
    if (info->layout)
    {
        SHFree(info->layout);
        info->layout = NULL;
    }

1042 1043
    SHChangeNotifyDeregister(info->hNotify);

1044 1045 1046
    return 0;
}

1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
/* Find a treeview node by recursively walking the treeview */
static HTREEITEM BrsFolder_FindItemByPidl(browse_info *info, LPCITEMIDLIST pidl, HTREEITEM hItem)
{
    TV_ITEMW item;
    TV_ITEMDATA *item_data;
    HRESULT hr;

    item.mask = TVIF_HANDLE | TVIF_PARAM;
    item.hItem = hItem;
    SendMessageW(info->hwndTreeView, TVM_GETITEMW, 0, (LPARAM)&item);
    item_data = (TV_ITEMDATA *)item.lParam;

    hr = IShellFolder_CompareIDs(item_data->lpsfParent, 0, item_data->lpifq, pidl);
    if(SUCCEEDED(hr) && !HRESULT_CODE(hr))
        return hItem;

    hItem = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)hItem);

    while (hItem)
    {
        HTREEITEM newItem = BrsFolder_FindItemByPidl(info, pidl, hItem);
        if (newItem)
            return newItem;
        hItem = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)hItem);
    }
    return NULL;
}

static LRESULT BrsFolder_OnChange(browse_info *info, const LPCITEMIDLIST *pidls, LONG event)
{
    BOOL ret = TRUE;

    TRACE("(%p)->(%p, %p, 0x%08x)\n", info, pidls[0], pidls[1], event);

    switch (event)
    {
        case SHCNE_RMDIR:
        case SHCNE_DELETE:
        {
            HTREEITEM handle_root = (HTREEITEM)SendMessageW(info->hwndTreeView, TVM_GETNEXTITEM, TVGN_ROOT, 0);
            HTREEITEM handle_item = BrsFolder_FindItemByPidl(info, pidls[0], handle_root);

            if (handle_item)
                SendMessageW(info->hwndTreeView, TVM_DELETEITEM, 0, (LPARAM)handle_item);

            break;
        }
    }
    return ret;
}

1098 1099 1100 1101 1102 1103
/*************************************************************************
 *             BrsFolderDlgProc32  (not an exported API function)
 */
static INT_PTR CALLBACK BrsFolderDlgProc( HWND hWnd, UINT msg, WPARAM wParam,
				          LPARAM lParam )
{
1104 1105
    browse_info *info;

1106
    TRACE("hwnd=%p msg=%04x 0x%08lx 0x%08lx\n", hWnd, msg, wParam, lParam );
1107 1108

    if (msg == WM_INITDIALOG)
1109 1110
        return BrsFolder_OnCreate( hWnd, (browse_info*) lParam );

1111
    info = GetPropW( hWnd, szBrowseFolderInfo );
1112 1113
    if (!info)
        return FALSE;
1114 1115 1116 1117

    switch (msg)
    {
    case WM_NOTIFY:
1118
        return BrsFolder_OnNotify( info, (UINT)wParam, (LPNMHDR)lParam);
1119 1120

    case WM_COMMAND:
1121
        return BrsFolder_OnCommand( info, wParam );
1122

1123 1124 1125 1126 1127
    case WM_WINDOWPOSCHANGING:
        return BrsFolder_OnWindowPosChanging( info, (WINDOWPOS *)lParam);

    case WM_SIZE:
        if (info->layout)  /* new style dialogs */
1128
            LayoutUpdate(hWnd, info->layout, g_layout_info, ARRAY_SIZE(g_layout_info));
1129 1130
        return 0;

1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
    case BFFM_SETSTATUSTEXTA:
        TRACE("Set status %s\n", debugstr_a((LPSTR)lParam));
        SetWindowTextA(GetDlgItem(hWnd, IDD_STATUS), (LPSTR)lParam);
        break;

    case BFFM_SETSTATUSTEXTW:
        TRACE("Set status %s\n", debugstr_w((LPWSTR)lParam));
        SetWindowTextW(GetDlgItem(hWnd, IDD_STATUS), (LPWSTR)lParam);
        break;

    case BFFM_ENABLEOK:
        TRACE("Enable %ld\n", lParam);
1143
        EnableWindow(GetDlgItem(hWnd, 1), lParam != 0);
1144 1145 1146
        break;

    case BFFM_SETOKTEXT: /* unicode only */
1147 1148
        TRACE("Set OK text %s\n", debugstr_w((LPWSTR)lParam));
        SetWindowTextW(GetDlgItem(hWnd, 1), (LPWSTR)lParam);
1149 1150 1151
        break;

    case BFFM_SETSELECTIONA:
1152
        return BrsFolder_OnSetSelectionA(info, (LPVOID)lParam, (BOOL)wParam);
1153 1154

    case BFFM_SETSELECTIONW:
1155
        return BrsFolder_OnSetSelectionW(info, (LPVOID)lParam, (BOOL)wParam);
1156 1157

    case BFFM_SETEXPANDED: /* unicode only */
1158
        return BrsFolder_OnSetExpanded(info, (LPVOID)lParam, (BOOL)wParam, NULL);
1159

1160 1161 1162
    case SHV_CHANGE_NOTIFY:
        return BrsFolder_OnChange(info, (const LPCITEMIDLIST*)wParam, (LONG)lParam);

1163 1164
    case WM_DESTROY:
        return BrsFolder_OnDestroy(info);
1165 1166
    }
    return FALSE;
1167 1168
}

1169
static const WCHAR swBrowseTemplateName[] = {
1170
    'S','H','B','R','S','F','O','R','F','O','L','D','E','R','_','M','S','G','B','O','X',0};
1171 1172
static const WCHAR swNewBrowseTemplateName[] = {
    'S','H','N','E','W','B','R','S','F','O','R','F','O','L','D','E','R','_','M','S','G','B','O','X',0};
1173

1174
/*************************************************************************
1175
 * SHBrowseForFolderA [SHELL32.@]
Patrik Stridvall's avatar
Patrik Stridvall committed
1176
 * SHBrowseForFolder  [SHELL32.@]
1177
 */
1178
LPITEMIDLIST WINAPI SHBrowseForFolderA (LPBROWSEINFOA lpbi)
1179
{
1180 1181 1182
    BROWSEINFOW bi;
    LPITEMIDLIST lpid;
    INT len;
1183 1184
    LPWSTR title;

1185
    TRACE("%p\n", lpbi);
1186

1187 1188 1189
    bi.hwndOwner = lpbi->hwndOwner;
    bi.pidlRoot = lpbi->pidlRoot;
    if (lpbi->pszDisplayName)
1190
        bi.pszDisplayName = heap_alloc( MAX_PATH * sizeof(WCHAR) );
1191 1192
    else
        bi.pszDisplayName = NULL;
1193

1194 1195 1196
    if (lpbi->lpszTitle)
    {
        len = MultiByteToWideChar( CP_ACP, 0, lpbi->lpszTitle, -1, NULL, 0 );
1197
        title = heap_alloc( len * sizeof(WCHAR) );
1198
        MultiByteToWideChar( CP_ACP, 0, lpbi->lpszTitle, -1, title, len );
1199 1200
    }
    else
1201
        title = NULL;
1202

1203
    bi.lpszTitle = title;
1204 1205 1206 1207 1208 1209 1210 1211 1212
    bi.ulFlags = lpbi->ulFlags;
    bi.lpfn = lpbi->lpfn;
    bi.lParam = lpbi->lParam;
    bi.iImage = lpbi->iImage;
    lpid = SHBrowseForFolderW( &bi );
    if (bi.pszDisplayName)
    {
        WideCharToMultiByte( CP_ACP, 0, bi.pszDisplayName, -1,
                             lpbi->pszDisplayName, MAX_PATH, 0, NULL);
1213
        heap_free( bi.pszDisplayName );
1214
    }
1215
    heap_free(title);
1216 1217
    lpbi->iImage = bi.iImage;
    return lpid;
1218
}
1219

1220

1221 1222
/*************************************************************************
 * SHBrowseForFolderW [SHELL32.@]
1223
 *
1224
 * NOTES
1225
 *  crashes when passed a null pointer
1226 1227 1228
 */
LPITEMIDLIST WINAPI SHBrowseForFolderW (LPBROWSEINFOW lpbi)
{
1229 1230
    browse_info info;
    DWORD r;
1231
    HRESULT hr;
1232
    const WCHAR * templateName;
1233
    INITCOMMONCONTROLSEX icex;
1234 1235 1236 1237 1238

    info.hWnd = 0;
    info.pidlRet = NULL;
    info.lpBrowseInfo = lpbi;
    info.hwndTreeView = NULL;
1239

1240 1241 1242 1243
    icex.dwSize = sizeof( icex );
    icex.dwICC = ICC_TREEVIEW_CLASSES;
    InitCommonControlsEx( &icex );

1244
    hr = OleInitialize(NULL);
1245 1246 1247 1248 1249 1250

    if (lpbi->ulFlags & BIF_NEWDIALOGSTYLE)
        templateName = swNewBrowseTemplateName;
    else
        templateName = swBrowseTemplateName;
    r = DialogBoxParamW( shell32_hInstance, templateName, lpbi->hwndOwner,
1251
	                 BrsFolderDlgProc, (LPARAM)&info );
1252
    if (SUCCEEDED(hr)) 
1253
        OleUninitialize();
1254
    if (!r)
1255 1256
    {
        ILFree(info.pidlRet);
1257
        return NULL;
1258
    }
1259

1260
    return info.pidlRet;
1261
}