windows-xp/Source/XPSP1/NT/shell/shell32/findfldr.cpp

#include "shellprv.h"
#pragma  hdrstop
#include <regstr.h>
#include <varutil.h>
#include "ids.h"        
#include "findhlp.h"    
#include "pidl.h"       
#include "shitemid.h"   
#include "defview.h"    
#include "fstreex.h"
#include "views.h"
#include "cowsite.h"
#include "exdisp.h"
#include "shguidp.h"
#include "prop.h"           // COLUMN_INFO
#include <limits.h>
#include "stgutil.h"
#include "netview.h"
#include "basefvcb.h"
#include "findfilter.h"
#include "defvphst.h"
#include "perhist.h"
#include "adoint.h"
#include "dspsprt.h"
#include "defcm.h"
#include "enumidlist.h"
#include "contextmenu.h"

// findband.cpp
STDAPI GetCIStatus(BOOL *pbRunning, BOOL *pbIndexed, BOOL *pbPermission);
STDAPI CatalogUptodate(LPCWSTR pszCatalog, LPCWSTR pszMachine);

class CFindFolder;

class CFindLVRange : public ILVRange
{
public:
    // IUnknown
    STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
    STDMETHODIMP_(ULONG) AddRef(void);
    STDMETHODIMP_(ULONG) Release(void);

    // ILVRange
    STDMETHODIMP IncludeRange(LONG iBegin, LONG iEnd);
    STDMETHODIMP ExcludeRange(LONG iBegin, LONG iEnd);    
    STDMETHODIMP InvertRange(LONG iBegin, LONG iEnd);
    STDMETHODIMP InsertItem(LONG iItem);
    STDMETHODIMP RemoveItem(LONG iItem);

    STDMETHODIMP Clear();
    STDMETHODIMP IsSelected(LONG iItem);
    STDMETHODIMP IsEmpty();
    STDMETHODIMP NextSelected(LONG iItem, LONG *piItem);
    STDMETHODIMP NextUnSelected(LONG iItem, LONG *piItem);
    STDMETHODIMP CountIncluded(LONG *pcIncluded);

    // Helperfunctions...
    void SetOwner(CFindFolder *pff, DWORD dwMask)
    {
        // don't AddRef -- we're a member variable of the object punk points to
        _pff = pff;
        _dwMask = dwMask;
        _cIncluded = 0;
    }
    void IncrementIncludedCount() {_cIncluded++;}
    void DecrementIncludedCount() {_cIncluded--;}
protected:
    CFindFolder *_pff;
    DWORD _dwMask;  // The mask we use to know which "selection" bit we are tracking...
    LONG _cIncluded;  // count included... (selected)
};

class CFindFolder : public IFindFolder,
                    public IShellFolder2,
                    public IShellIcon,
                    public IShellIconOverlay,
                    public IPersistFolder2
{
public:
    CFindFolder(IFindFilter *pff);
    
    // IUnknown
    STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
    STDMETHODIMP_(ULONG) AddRef(void);
    STDMETHODIMP_(ULONG) Release(void);
        
    // IShellFolder
    STDMETHODIMP ParseDisplayName(HWND hwnd, LPBC pbc, LPOLESTR pszDisplayName, ULONG * pchEaten, LPITEMIDLIST * ppidl, ULONG *pdwAttributes);
    STDMETHODIMP EnumObjects(THIS_ HWND hwnd, DWORD grfFlags, IEnumIDList **ppenumIDList);
    STDMETHODIMP BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv);
    STDMETHODIMP BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
        { return BindToObject(pidl, pbc, riid, ppv); }
    STDMETHODIMP CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
    STDMETHODIMP CreateViewObject(HWND hwnd, REFIID riid, void **ppv);
    STDMETHODIMP GetAttributesOf(UINT cidl, LPCITEMIDLIST * apidl, ULONG * rgfInOut);
    STDMETHODIMP GetUIObjectOf(HWND hwnd, UINT cidl, LPCITEMIDLIST * apidl, REFIID riid, UINT * prgfInOut, void **ppv);
    STDMETHODIMP GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD uFlags, STRRET *pName);
    STDMETHODIMP SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR pszName, DWORD uFlags, LPITEMIDLIST *ppidlOut);

    // IShellFolder2
    STDMETHODIMP GetDefaultSearchGUID(GUID *pGuid);
    STDMETHODIMP EnumSearches(LPENUMEXTRASEARCH *ppenum);
    STDMETHODIMP GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay);
    STDMETHODIMP GetDefaultColumnState(UINT iColumn, DWORD *pbState);
    STDMETHODIMP GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv);
    STDMETHODIMP GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pDetails);
    STDMETHODIMP MapColumnToSCID(UINT iCol, SHCOLUMNID *pscid);

    // IFindFolder
    STDMETHODIMP GetFindFilter(IFindFilter **pfilter);
    STDMETHODIMP AddPidl(int i, LPCITEMIDLIST pidl, DWORD dwItemID, FIND_ITEM **ppItem);
    STDMETHODIMP GetItem(int iItem, FIND_ITEM **ppItem);
    STDMETHODIMP DeleteItem(int iItem);
    STDMETHODIMP GetItemCount(INT *pcItems);
    STDMETHODIMP ValidateItems(IUnknown *punkView, int iItemFirst, int cItems, BOOL bSearchComplete);
    STDMETHODIMP GetFolderListItemCount(INT *pcCount);
    STDMETHODIMP GetFolderListItem(int iItem, FIND_FOLDER_ITEM **ppItem);
    STDMETHODIMP GetFolder(int iFolder, REFIID riid, void **ppv);
    STDMETHODIMP_(UINT) GetFolderIndex(LPCITEMIDLIST pidl);
    STDMETHODIMP SetItemsChangedSinceSort();
    STDMETHODIMP ClearItemList();
    STDMETHODIMP ClearFolderList();
    STDMETHODIMP AddFolder(LPITEMIDLIST pidl, BOOL fCheckForDup, int * piFolder);
    STDMETHODIMP SetAsyncEnum(IFindEnum *pfenum);
    STDMETHODIMP GetAsyncEnum(IFindEnum **ppfenum);
    STDMETHODIMP CacheAllAsyncItems();
    STDMETHODIMP_(BOOL) AllAsyncItemsCached();
    STDMETHODIMP SetAsyncCount(DBCOUNTITEM cCount);
    STDMETHODIMP ClearSaveStateList();
    STDMETHODIMP GetStateFromSaveStateList(DWORD dwItemID, DWORD *pdwState);
    STDMETHODIMP MapToSearchIDList(LPCITEMIDLIST pidl, BOOL fMapToReal, LPITEMIDLIST *ppidl);
    STDMETHODIMP GetParentsPIDL(LPCITEMIDLIST pidl, LPITEMIDLIST *ppidlParent);
    STDMETHODIMP SetControllerNotifyObject(IFindControllerNotify *pfcn);
    STDMETHODIMP GetControllerNotifyObject(IFindControllerNotify **ppfcn);
    STDMETHODIMP RememberSelectedItems();
    STDMETHODIMP SaveFolderList(IStream *pstm);
    STDMETHODIMP RestoreFolderList(IStream *pstm);
    STDMETHODIMP SaveItemList(IStream *pstm);
    STDMETHODIMP RestoreItemList(IStream *pstm, int *pcItems);
    STDMETHODIMP RestoreSearchFromSaveFile(LPCITEMIDLIST pidlSaveFile, IShellFolderView *psfv);

    STDMETHODIMP_(BOOL) HandleUpdateDir(LPCITEMIDLIST pidl, BOOL fCheckSubDirs);
    STDMETHODIMP_(void) HandleRMDir(IShellFolderView *psfv, LPCITEMIDLIST pidl);
    STDMETHODIMP_(void) UpdateOrMaybeAddPidl(IShellFolderView *psfv, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlOld);
    STDMETHODIMP_(void) Save(IFindFilter* pfilter, HWND hwnd, DFBSAVEINFO * pSaveInfo, IShellView* psv, IUnknown * pObject);
    STDMETHODIMP OpenContainingFolder(IUnknown *punkSite);
    STDMETHODIMP AddDataToIDList(LPCITEMIDLIST pidl, int iFolder, LPCITEMIDLIST pidlFolder, UINT uFlags, UINT uRow, DWORD dwItemID, ULONG ulRank, LPITEMIDLIST *ppidl);

    // IShellIcon
    STDMETHODIMP GetIconOf(LPCITEMIDLIST pidl, UINT flags, int *piIndex);

    // IShellIconOverlay
    STDMETHODIMP GetOverlayIndex(LPCITEMIDLIST pidl, int * pIndex);
    STDMETHODIMP GetOverlayIconIndex(LPCITEMIDLIST pidl, int * pIndex);
  
    // IPersist
    STDMETHODIMP GetClassID(CLSID *pClassID);

    // IPersistFolder
    STDMETHODIMP Initialize(LPCITEMIDLIST pidl);

    // IPersistFolder2
    STDMETHODIMP GetCurFolder(LPITEMIDLIST *ppidl);

    friend class CFindFolderViewCB;
    friend class CFindLVRange;

    HRESULT Init();

private:
    ~CFindFolder();
    HRESULT _CompareFolderIndexes(int iFolder1, int iFolder2);
    void _AddFIND_ITEMToSaveStateList(FIND_ITEM *pesfi);
    LPITEMIDLIST _GetFullPidlForItem(LPCITEMIDLIST pidl);
    HRESULT _UpdateItemList();

    static int CALLBACK _SortForDataObj(void *p1, void *p2, LPARAM lparam);
    static ULONG _Rank(LPCITEMIDLIST pidl);
    static DWORD _ItemID(LPCITEMIDLIST pidl);
    static PCHIDDENDOCFINDDATA _HiddenData(LPCITEMIDLIST pidl);
    FIND_FOLDER_ITEM *_FolderListItem(int iFolder);
    FIND_FOLDER_ITEM *_FolderListItem(LPCITEMIDLIST pidl);
    static BOOL _MapColIndex(UINT *piColumn);
    HRESULT _PrepareHIDA(UINT cidl, LPCITEMIDLIST *apidl, HDPA *phdpa);

    HRESULT _GetDetailsFolder();
    HRESULT _QueryItemShellFolder(LPCITEMIDLIST pidl, IShellFolder **ppsf);
    HRESULT _QueryItemInterface(LPCITEMIDLIST pidl, REFIID riid, void **ppv);
    HRESULT _Folder(FIND_FOLDER_ITEM *pffli, REFIID riid, void **ppv);
    HRESULT _FolderFromItem(LPCITEMIDLIST pidl, REFIID riid, void **ppv);

    HRESULT _GetFolderName(LPCITEMIDLIST pidl, DWORD gdnFlags, LPTSTR psz, UINT cch);
    int _CompareByCachedSCID(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
    int _CompareNames(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, DWORD dwFlags);
    HRESULT _GetItemDisplayName(LPCITEMIDLIST pidl, DWORD dwFlags, LPWSTR wzName, UINT cch);
    HRESULT _GetFolderIDList(int iFolder, LPITEMIDLIST *ppidlParent);

    LONG _cRef;

    CFindLVRange _dflvrSel; // manage selection and cut range information...
    CFindLVRange _dflvrCut;

    HDPA                _hdpaItems;             // all of the items in the results
    HDPA                _hdpaPidf;              // folders that the items came from
    IFindFilter         *_pfilter;
    BOOL                _fItemsChangedSinceSort;// Has the list changed since the last sort?
    BOOL                _fAllAsyncItemsCached;  // Have we already cached all of the items?
    BOOL                _fSearchComplete; 
    BOOL                _fInRefresh;            // true if received prerefresh callback but postrefresh

    LPITEMIDLIST        _pidl;
    IFindEnum           *_pDFEnumAsync;         // we have an async one, will need to call back for PIDLS and the like
    DBCOUNTITEM         _cAsyncItems;           // Count of async items
    int                 _iGetIDList;            // index of the last IDlist we retrieved in callback.
    HDSA                _hdsaSaveStateForIDs;   // Async - Remember which items are selected when we sort
    int                 _cSaveStateSelected;    // Number of items in selection list which are selected
    IFindControllerNotify *_pfcn;           // Sometimes need to let the "Controller" object know about things
    CRITICAL_SECTION    _csSearch;          
    int                 _iCompareFolderCache1, _iCompareFolderCache2, _iCompareFolderCacheResult;
    IShellFolder2       *_psfDetails;

    SHCOLUMNID          _scidCached;            // Cached SCID for sorting the columns
    UINT                _uiColumnCached;         // The index to the cached column for _scidCached

#if DEBUG
    DWORD               _GUIThreadID;           // Items can only be added to _hdpaItems on the UI thread.
#endif
};

class CFindFolderViewCB : public CBaseShellFolderViewCB
{
public:
    STDMETHODIMP RealMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
    HRESULT SetShellView(IShellView *psv);

    CFindFolderViewCB(CFindFolder* pff);

    //  IServiceProvider override
    STDMETHODIMP QueryService(REFGUID guidService, REFIID riid, void **ppv);

    // Web View Tasks
    static HRESULT _OnOpenContainingFolder(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc);

private:
    ~CFindFolderViewCB();

    HRESULT OnMergeMenu(DWORD pv, QCMINFO*lP);    
    HRESULT OnReArrange(DWORD pv, LPARAM lp);
    HRESULT OnGETWORKINGDIR(DWORD pv, UINT wP, LPTSTR lP);
    HRESULT OnINVOKECOMMAND(DWORD pv, UINT wP);
    HRESULT OnGETCOLSAVESTREAM(DWORD pv, WPARAM wP, IStream**lP);
    HRESULT OnGETITEMIDLIST(DWORD pv, WPARAM iItem, LPITEMIDLIST *ppidl);
    HRESULT OnGetItemIconIndex(DWORD pv, WPARAM iItem, int *piIcon);
    HRESULT OnSetItemIconOverlay(DWORD pv, WPARAM iItem, int dwOverlayState);
    HRESULT OnGetItemIconOverlay(DWORD pv, WPARAM iItem, int * pdwOverlayState);
    HRESULT OnSETITEMIDLIST(DWORD pv, WPARAM iItem, LPITEMIDLIST pidl);
    HRESULT OnGetIndexForItemIDList(DWORD pv, int * piItem, LPITEMIDLIST pidl);
    HRESULT OnDeleteItem(DWORD pv, LPCITEMIDLIST pidl);
    HRESULT OnODFindItem(DWORD pv, int * piItem, NM_FINDITEM* pnmfi);
    HRESULT OnODCacheHint(DWORD pv, NMLVCACHEHINT* pnmlvc);
    HRESULT OnSelChange(DWORD pv, UINT wPl, UINT wPh, SFVM_SELCHANGE_DATA*lP);
    HRESULT OnGetEmptyText(DWORD pv, UINT cchTextMax, LPTSTR pszText);
    HRESULT OnSetEmptyText(DWORD pv, UINT res, LPCTSTR pszText);
    HRESULT OnHwndMain(DWORD pv, HWND hwndMain);
    HRESULT OnIsOwnerData(DWORD pv, DWORD *pdwFlags);
    HRESULT OnSetISFV(DWORD pv, IShellFolderView* pisfv);
    HRESULT OnWindowCreated(DWORD pv, HWND hwnd);
    HRESULT OnWindowDestroy(DWORD pv, HWND wP);
    HRESULT OnGetODRangeObject(DWORD pv, WPARAM wWhich, ILVRange **pplvr);
    HRESULT OnDEFVIEWMODE(DWORD pv, FOLDERVIEWMODE*lP);
    HRESULT OnGetIPersistHistory(DWORD pv, IPersistHistory **ppph);
    HRESULT OnRefresh(DWORD pv, BOOL fPreRefresh);
    HRESULT OnGetHelpTopic(DWORD pv, SFVM_HELPTOPIC_DATA *shtd);
    HRESULT OnSortListData(DWORD pv, PFNLVCOMPARE pfnCompare, LPARAM lParamSort);
    HRESULT _ProfferService(BOOL bProffer);
    HRESULT OnGetWebViewLayout(DWORD pv, UINT uViewMode, SFVM_WEBVIEW_LAYOUT_DATA* pData);
    HRESULT OnGetWebViewContent(DWORD pv, SFVM_WEBVIEW_CONTENT_DATA* pData);
    HRESULT OnGetWebViewTasks(DWORD pv, SFVM_WEBVIEW_TASKSECTION_DATA* pTasks);
    HRESULT OnGetWebViewTheme(DWORD pv, SFVM_WEBVIEW_THEME_DATA* pTheme);

    CFindFolder*  _pff;
    UINT        _iColSort;         // Which column are we sorting by
    BOOL        _fIgnoreSelChange;      // Sort in process
    UINT        _iFocused;         // Which item has the focus?
    UINT        _cSelected;        // Count of items selected

    IProfferService* _pps;          // ProfferService site.
    DWORD _dwServiceCookie;         // ProfferService cookie.

    TCHAR _szEmptyText[128];        // empty results list text.

    friend class CFindLVRange;
};

// Class to save and restore find state on the travel log 
class CFindPersistHistory : public CDefViewPersistHistory
{
public:
    CFindPersistHistory();

    // IPersist
    STDMETHODIMP GetClassID(CLSID *pClassID);

    // IPersistHistory
    STDMETHODIMP LoadHistory(IStream *pStream, IBindCtx *pbc);
    STDMETHODIMP SaveHistory(IStream *pStream);

protected:
    IFindFolder* _GetDocFindFolder();
};


// {a5df1ea0-5702-11d1-83fa-00a0c90dc849}
const IID IID_IFindFolder = {0xa5df1ea0, 0x5702, 0x11d1, {0x83, 0xfa, 0x00, 0xa0, 0xc9, 0x0d, 0xc8, 0x49}};

// {5B8DCBF0-B096-11d1-9217-00403393B8F0}
const IID IID_IFindControllerNotify = {0x5b8dcbf0, 0xb096, 0x11d1, {0x92, 0x17, 0x0, 0x40, 0x33, 0x93, 0xb8, 0xf0}};

// Listview doesn't support more than 100000000 items, so if our
// client returns more than that, just stop after that point.
//
// Instead of 100000000, we use the next lower 64K boundary.  This keeps
// us away from strange boundary cases (where a +1 might push us over the
// top), and it keeps the Alpha happy.
//
#define MAX_LISTVIEWITEMS  (100000000 & ~0xFFFF)
#define SANE_ITEMCOUNT(c)  ((int)min(c, MAX_LISTVIEWITEMS))

// Unicode descriptor:
//
// Structure written at the end of NT-generated find stream serves dual purpose.
// 1. Contains an NT-specific signature to identify stream as NT-generated.
//    Appears as "NTFF" (NT Find File) in ASCII dump of file.
// 2. Contains an offset to the unicode-formatted criteria section.
//
// The following diagram shows the find criteria/results stream format including
// the NT-specific unicode criteria and descriptor.
//
//          +-----------------------------------------+ --------------
//          |         DFHEADER structure              |   .        .
//          +-----------------------------------------+   .        .
//          |      DF Criteria records (ANSI)         | Win95      .
//          +-----------------------------------------+   .        .
//          |      DF Results (PIDL) [optional]       |   .        NT
//          +-----------------------------------------+ -------    .
//   +----->| DF Criteria records (Unicode) [NT only] |            .
//   |      +-----------------------------------------+            .
//   |      | Unicode Descriptor |                                 .
//   |      +--------------------+  ----------------------------------
//   |     /                      \
//   |    /                         \
//   |   +-----------------+---------+
//   +---| Offset (64-bit) |  "NTFF" |
//       +-----------------+---------+
//
//

const DWORD c_NTsignature = 0x4646544E; // "NTFF" in ASCII file dump.

typedef struct
{
   ULARGE_INTEGER oUnicodeCriteria;  // Offset of unicode find criteria.
   DWORD NTsignature;               // Signature of NT-generated find file.
} DFC_UNICODE_DESC;


enum
{
    IDFCOL_NAME = 0,    // default col from guy we are delegating to
    IDFCOL_PATH,
    IDFCOL_RANK,
};

const COLUMN_INFO c_find_cols[] = 
{
    DEFINE_COL_STR_ENTRY(SCID_NAME,            30, IDS_NAME_COL),
    DEFINE_COL_STR_ENTRY(SCID_DIRECTORY,       30, IDS_PATH_COL),
    DEFINE_COL_STR_MENU_ENTRY(SCID_RANK,       10, IDS_RANK_COL),
};

class CFindMenuBase : public IContextMenuCB , public CObjectWithSite
{
public:
    CFindMenuBase();

    // IUnknown
    STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
    STDMETHODIMP_(ULONG) AddRef(void);
    STDMETHODIMP_(ULONG) Release(void);

    // IContextMenuCB
    STDMETHODIMP CallBack(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam) PURE;

protected:
    virtual ~CFindMenuBase();

private:
    LONG _cRef;
};

CFindMenuBase::CFindMenuBase() : _cRef(1)
{
}

CFindMenuBase::~CFindMenuBase()
{
}

STDMETHODIMP CFindMenuBase::QueryInterface(REFIID riid, void **ppv) 
{        
    static const QITAB qit[] = {
        QITABENT(CFindMenuBase, IContextMenuCB),           // IID_IContextMenuCB
        QITABENT(CFindMenuBase, IObjectWithSite),          // IID_IObjectWithSite
        { 0 },
    };
    return QISearch(this, qit, riid, ppv);
}

ULONG CFindMenuBase::AddRef() 
{
    return InterlockedIncrement(&_cRef);
}

ULONG CFindMenuBase::Release() 
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;

    delete this;
    return 0;
}


class CFindMenuCB : public CFindMenuBase
{
public:
    // IContextMenuCB
    STDMETHODIMP CallBack(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam);
};

STDMETHODIMP CFindMenuCB::CallBack(IShellFolder *psf, HWND hwnd,
                IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HRESULT hr = S_OK;

    switch (uMsg)
    {
    case DFM_MERGECONTEXTMENU:
        if (!(wParam & CMF_VERBSONLY))
        {
            LPQCMINFO pqcm = (LPQCMINFO)lParam;
            if (!pdtobj)
            {
                UINT idStart = pqcm->idCmdFirst;
                UINT idBGMain = 0, idBGPopup = 0;
                IFindFolder *pff;
                if (SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IFindFolder, &pff)))) 
                {
                    IFindFilter *pfilter;
                    if (SUCCEEDED(pff->GetFindFilter(&pfilter))) 
                    {
                        pfilter->GetFolderMergeMenuIndex(&idBGMain, &idBGPopup);
                        CDefFolderMenu_MergeMenu(HINST_THISDLL, idBGMain, idBGPopup, pqcm);

                        DeleteMenu(pqcm->hmenu, idStart+SFVIDM_EDIT_PASTE, MF_BYCOMMAND);
                        DeleteMenu(pqcm->hmenu, idStart+SFVIDM_EDIT_PASTELINK, MF_BYCOMMAND);
                        DeleteMenu(pqcm->hmenu, idStart+SFVIDM_MISC_REFRESH, MF_BYCOMMAND);

                        IFindControllerNotify *pdcn;
                        if (S_OK == pff->GetControllerNotifyObject(&pdcn))
                        {
                            pdcn->Release();
                        }
                        else
                        {
                            DeleteMenu(pqcm->hmenu, idStart+FSIDM_SAVESEARCH, MF_BYCOMMAND);
                        }
                        
                        pfilter->Release();
                    }
                    pff->Release();
                }
            }
        }
        break;

    case DFM_INVOKECOMMAND:
        {    
            // Check if this is from item context menu
            if (pdtobj)
            {
                switch(wParam)
                {
                case DFM_CMD_LINK:
                    hr = SHCreateLinks(hwnd, NULL, pdtobj, SHCL_USETEMPLATE | SHCL_USEDESKTOP | SHCL_CONFIRM, NULL);
                    break;
    
                case DFM_CMD_DELETE:
                    // convert to DFM_INVOKCOMMANDEX to get flags bits
                    hr = DeleteFilesInDataObject(hwnd, 0, pdtobj, 0);
                    break;

                case DFM_CMD_PROPERTIES:
                    // We need to pass an empty IDlist to combine with.
                    hr = SHLaunchPropSheet(CFSFolder_PropertiesThread, pdtobj,
                                      (LPCTSTR)lParam, NULL,  (void *)&c_idlDesktop);
                    break;

                default:
                    // Note: Fixing the working of Translator Key is not worth fixing. Hence Punted.
                    // if GetAttributesOf did not specify the SFGAO_ bit
                    // that corresponds to this default DFM_CMD, then we should
                    // fail it here instead of returning S_FALSE. Otherwise,
                    // accelerator keys (cut/copy/paste/etc) will get here, and
                    // defcm tries to do the command with mixed results.
                    // if GetAttributesOf did not specify SFGAO_CANLINK
                    // or SFGAO_CANDELETE or SFGAO_HASPROPERTIES, then the above
                    // implementations of these DFM_CMD commands are wrong...
                    // Let the defaults happen for this object
                    hr = S_FALSE;
                    break;
                }
            }
            else
            {
                switch (wParam)
                {
                case FSIDM_SAVESEARCH:
                    {
                        IFindFolder *pff;
                        if (SUCCEEDED(psf->QueryInterface(IID_PPV_ARG(IFindFolder, &pff))))
                        {
                            IFindControllerNotify *pdcn;
                            if (S_OK == pff->GetControllerNotifyObject(&pdcn))
                            {
                                pdcn->SaveSearch();
                                pdcn->Release();
                            }
                            pff->Release();
                        }
                    }
                    break;

                default:
                    hr = S_FALSE; // one of view menu items, use the default code.
                    break;
                }
            }
        }
        break;

    case DFM_GETHELPTEXT:  // ansi version
    case DFM_GETHELPTEXTW:
        {
            UINT id = LOWORD(wParam) + IDS_MH_FSIDM_FIRST;

            if (uMsg == DFM_GETHELPTEXTW)
                LoadStringW(HINST_THISDLL, id, (LPWSTR)lParam, HIWORD(wParam));
            else
                LoadStringA(HINST_THISDLL, id, (LPSTR)lParam, HIWORD(wParam));
        }
        break;
        
    default:
        hr = E_NOTIMPL;
        break;
    }
    return hr;
}


class CFindFolderContextMenuItemCB : public CFindMenuBase
{
public:
    // IContextMenuCB
    STDMETHODIMP CallBack(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam);

private:
    CFindFolderContextMenuItemCB(IFindFolder* pff);
    ~CFindFolderContextMenuItemCB();
    friend HRESULT CFindItem_Create(HWND hwnd, IFindFolder *pff, IContextMenu **ppcm);

    STDMETHODIMP _GetVerb(UINT_PTR idCmd, LPSTR pszName, UINT cchMax, BOOL bUnicode);

    IFindFolder *_pff;
};

CFindFolderContextMenuItemCB::CFindFolderContextMenuItemCB(IFindFolder* pff) : _pff(pff)
{
    _pff->AddRef();
}

CFindFolderContextMenuItemCB::~CFindFolderContextMenuItemCB()
{
    _pff->Release();
}

STDMETHODIMP CFindFolderContextMenuItemCB::_GetVerb(UINT_PTR idCmd, LPSTR pszName, UINT cchMax, BOOL bUnicode)
{
    HRESULT hr;
    if (idCmd == FSIDM_OPENCONTAININGFOLDER)
    {
        if (bUnicode)
            StrCpyNW((LPWSTR)pszName, L"OpenContainingFolder", cchMax);
        else
            StrCpyNA((LPSTR)pszName, "OpenContainingFolder", cchMax);
        hr = S_OK;
    }
    else
    {
        hr = E_NOTIMPL;
    }
    return hr;
}

STDMETHODIMP CFindFolderContextMenuItemCB::CallBack(IShellFolder *psf, HWND hwnd,
                IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    HRESULT hr = S_OK;

    switch (uMsg)
    {
    case DFM_MERGECONTEXTMENU:
        if (!(wParam & CMF_VERBSONLY))
        {
            LPQCMINFO pqcm = (LPQCMINFO)lParam;
            CDefFolderMenu_MergeMenu(HINST_THISDLL, POPUP_DOCFIND_ITEM_MERGE, 0, pqcm);
        }
        break;

    case DFM_INVOKECOMMAND:
        switch (wParam)
        {
        case FSIDM_OPENCONTAININGFOLDER:
            _pff->OpenContainingFolder(_punkSite);
            break;
        default:
            hr = E_FAIL; // not our command
            break;
        }
        break;

    case DFM_GETHELPTEXT:
    case DFM_GETHELPTEXTW:
        // probably need to implement these...
        
    case DFM_GETVERBA:
    case DFM_GETVERBW:
        hr = _GetVerb((UINT_PTR)(LOWORD(wParam)), (LPSTR)lParam, (UINT)(HIWORD(wParam)), uMsg == DFM_GETVERBW);
        break;

    default:
        hr = E_NOTIMPL;
        break;
    }
    
    return hr;
}

STDAPI CFindItem_Create(HWND hwnd, IFindFolder* pff, IContextMenu **ppcm)
{
    *ppcm = NULL;

    HRESULT hr;
    // We want a quick IContextMenu implementation -- an empty defcm looks easiest
    IContextMenuCB* pcmcb = new CFindFolderContextMenuItemCB(pff);
    if (pcmcb)
    {
        hr = CDefFolderMenu_CreateEx(NULL, hwnd, 0, NULL, NULL, pcmcb, NULL, NULL, ppcm);
        pcmcb->Release();
    }
    else
        hr = E_OUTOFMEMORY;
    return hr;
}

void cdecl DocFind_SetStatusText(HWND hwndStatus, int iField, UINT ids,...)
{
    TCHAR sz2[MAX_PATH+32];   // leave slop for message + max path name
    va_list ArgList;

    if (hwndStatus)
    {
        va_start(ArgList, ids);
        LPTSTR psz = _ConstructMessageString(HINST_THISDLL, MAKEINTRESOURCE(ids), &ArgList);
        if (psz)
        {
            StrCpyN(sz2, psz, ARRAYSIZE(sz2));
            LocalFree(psz);
        }
        else
        {
            sz2[0] = 0;
        }
        va_end(ArgList);

        if (iField < 0)
        {
            SendMessage(hwndStatus, SB_SETTEXT, SBT_NOBORDERS | 255, (LPARAM)(LPTSTR)sz2);
        }
        else
        {
            SendMessage(hwndStatus, SB_SETTEXT, iField, (LPARAM)(LPTSTR)sz2);
        }
            

        UpdateWindow(hwndStatus);
    }
}

HRESULT CFindFolder::AddFolder(LPITEMIDLIST pidl, BOOL fCheckForDup, int *piFolder)
{
    *piFolder = -1;

    if (fCheckForDup)
    {
        EnterCriticalSection(&_csSearch);
        for (int i = DPA_GetPtrCount(_hdpaPidf) - 1; i >= 0; i--)
        {
            FIND_FOLDER_ITEM *pffli = _FolderListItem(i);
            if (pffli && ILIsEqual(&pffli->idl, pidl))
            {
                LeaveCriticalSection(&_csSearch);
                *piFolder = i;
                return S_OK;
            }
        }
        LeaveCriticalSection(&_csSearch);
    }

    int cb = ILGetSize(pidl);
    FIND_FOLDER_ITEM *pffli;;
    HRESULT hr = SHLocalAlloc(sizeof(*pffli) - sizeof(pffli->idl) + cb, &pffli);
    if (SUCCEEDED(hr))
    {
        // pddfli->psf = NULL;
        // pffli->fUpdateDir = FALSE;
        memcpy(&pffli->idl, pidl, cb);

        EnterCriticalSection(&_csSearch);
        // Now add this item to our DPA...
        *piFolder = DPA_AppendPtr(_hdpaPidf, pffli);
        LeaveCriticalSection(&_csSearch);
    
        if (-1 != *piFolder)
        {
            // If this is a network ID list then register a path -> pidl mapping, therefore
            // avoiding having to create simple ID lists, which don't work correctly when
            // being compared against real ID lists.

            if (IsIDListInNameSpace(pidl, &CLSID_NetworkPlaces))
            {
                TCHAR szPath[ MAX_PATH ];
                SHGetPathFromIDList(pidl, szPath);
                NPTRegisterNameToPidlTranslation(szPath, _ILNext(pidl));  // skip the My Net Places entry
            }
        }
        else
        {
            LocalFree((HLOCAL)pffli);
            hr = E_OUTOFMEMORY;
        }
    }

    return hr;
}

typedef struct
{
    DWORD       dwState;    // State of the item;
    DWORD       dwItemID;   // Only used for Async support...
} FIND_ITEM_SAVE_STATE;


void CFindFolder::_AddFIND_ITEMToSaveStateList(FIND_ITEM *pesfi)
{
    FIND_ITEM_SAVE_STATE essi;
    essi.dwState = pesfi->dwState & CDFITEM_STATE_MASK;
    essi.dwItemID = _ItemID(&pesfi->idl);

    DSA_AppendItem(_hdsaSaveStateForIDs, (void *)&essi);
    if (essi.dwState & LVIS_SELECTED)
        _cSaveStateSelected++;
}


HRESULT CFindFolder::RememberSelectedItems()
{
    EnterCriticalSection(&_csSearch);
    // Currently has list of pidls...
    for (int i = DPA_GetPtrCount(_hdpaItems); i-- > 0;)
    {
        // Pidl at start of structure...
        FIND_ITEM *pesfi = (FIND_ITEM*)DPA_FastGetPtr(_hdpaItems, i);
        if (pesfi)
        {
            if (pesfi->dwState & (LVIS_SELECTED|LVIS_FOCUSED))
                _AddFIND_ITEMToSaveStateList(pesfi);
        }
    }
    LeaveCriticalSection(&_csSearch);
    return S_OK;
}

STDMETHODIMP CFindFolder::ClearItemList()
{
    // Clear out any async enumerators we may have
    SetAsyncEnum(NULL);
    _cAsyncItems = 0;       // clear out our count of items...
    _pfilter->ReleaseQuery();

    // Also tell the filter to release everything...
    EnterCriticalSection(&_csSearch);
    if (_hdpaItems)
    {
        // Currently has list of pidls...
        for (int i = DPA_GetPtrCount(_hdpaItems) - 1; i >= 0; i--)
        {
            // Pidl at start of structure...
            FIND_ITEM *pesfi = (FIND_ITEM*)DPA_FastGetPtr(_hdpaItems, i);
            if (pesfi)
                LocalFree((HLOCAL)pesfi);
        }

        _fSearchComplete = FALSE;
        DPA_DeleteAllPtrs(_hdpaItems);
    }
    LeaveCriticalSection(&_csSearch);
    return S_OK;
}

STDMETHODIMP CFindFolder::ClearFolderList()
{
    EnterCriticalSection(&_csSearch);
    if (_hdpaPidf)
    {
        for (int i = DPA_GetPtrCount(_hdpaPidf) - 1; i >= 0; i--)
        {
            FIND_FOLDER_ITEM *pffli = _FolderListItem(i);
            if (pffli)
            {
                // Release the IShellFolder if we have one
                if (pffli->psf)
                    pffli->psf->Release();

                // And delete the item
                LocalFree((HLOCAL)pffli);
            }
        }
        DPA_DeleteAllPtrs(_hdpaPidf);
    }
    LeaveCriticalSection(&_csSearch);
    
    return S_OK;
}

CFindFolder::CFindFolder(IFindFilter *pff) : _cRef(1), _iGetIDList(-1), _pfilter(pff), _iCompareFolderCache1(-1), _uiColumnCached(-1)
{
    ASSERT(_pidl == NULL);

    _pfilter->AddRef();

    // initialize our LV selection objects...
    _dflvrSel.SetOwner(this, LVIS_SELECTED);
    _dflvrCut.SetOwner(this, LVIS_CUT);

    InitializeCriticalSection(&_csSearch);

#if DEBUG
    _GUIThreadID = GetCurrentThreadId();
#endif
}

CFindFolder::~CFindFolder()
{
    ASSERT(_cRef==0);
    
    // We will need to call our function to Free our items in our
    // Folder list.  We will use the same function that we use to
    // clear it when we do a new search

    ClearItemList();
    ClearFolderList();
    ClearSaveStateList();

    EnterCriticalSection(&_csSearch);
    DPA_Destroy(_hdpaPidf);
    DPA_Destroy(_hdpaItems);
    _hdpaPidf = NULL;
    _hdpaItems = NULL;
    LeaveCriticalSection(&_csSearch);
    DSA_Destroy(_hdsaSaveStateForIDs);

    _pfilter->Release();

    if (_psfDetails)
        _psfDetails->Release();

    DeleteCriticalSection(&_csSearch);
}

HRESULT CFindFolder::Init()
{
    // Create the heap for the folder lists.
    _hdpaPidf = DPA_CreateEx(64, GetProcessHeap());

    // Create the DPA and DSA for the item list.
    _hdpaItems = DPA_CreateEx(64, GetProcessHeap());
    _hdsaSaveStateForIDs = DSA_Create(sizeof(FIND_ITEM_SAVE_STATE), 16);

    return _hdsaSaveStateForIDs && _hdpaItems && _hdpaPidf ? S_OK : E_OUTOFMEMORY;
}

STDMETHODIMP CFindFolder::AddDataToIDList(LPCITEMIDLIST pidl, int iFolder, LPCITEMIDLIST pidlFolder, UINT uFlags, UINT uRow, DWORD dwItemID, ULONG ulRank, LPITEMIDLIST *ppidl)
{
    HRESULT hr;
    LPITEMIDLIST pidlToFree;
    if (pidlFolder)
    {
        pidlToFree = NULL;
        hr = S_OK;
    }
    else
    {
         hr = _GetFolderIDList(iFolder, &pidlToFree);
         pidlFolder = pidlToFree;
    }

    if (SUCCEEDED(hr))
    {
        HIDDENDOCFINDDATA *phfd;
        int cb = ILGetSize(pidlFolder);
        int cbTotal = sizeof(*phfd) - sizeof(phfd->idlParent) + cb;
        hr = SHLocalAlloc(cbTotal, &phfd);
        if (SUCCEEDED(hr))
        {
            phfd->hid.cb = (WORD)cbTotal;
            phfd->hid.wVersion = 0;
            phfd->hid.id = IDLHID_DOCFINDDATA;
            phfd->iFolder = (WORD)iFolder;      // index to the folder DPA
            phfd->wFlags  = (WORD)uFlags;
            phfd->uRow = uRow;                  // Which row in the CI;
            phfd->dwItemID = dwItemID;          // Only used for Async support...
            phfd->ulRank = ulRank;              // The rank returned by CI...
            memcpy(&phfd->idlParent, pidlFolder, cb);
    
            hr = ILCloneWithHiddenID(pidl, &phfd->hid, ppidl);
            LocalFree(phfd);
        }
        ILFree(pidlToFree);
    }
    return hr;
}

HRESULT CreateFindWithFilter(IFindFilter *pff, REFIID riid, void **ppv)
{
    *ppv = NULL;
    HRESULT hr = E_OUTOFMEMORY;

    CFindFolder *pfindfldr = new CFindFolder(pff);
    if (pfindfldr)
    {
        hr = pfindfldr->Init();
        if (SUCCEEDED(hr))
            hr = pfindfldr->QueryInterface(riid, ppv);
        pfindfldr->Release();
    }

    return hr;
}

STDAPI CDocFindFolder_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv)
{
    *ppv = NULL;

    IFindFilter *pff;
    HRESULT hr = CreateNameSpaceFindFilter(&pff);
    if (SUCCEEDED(hr))
    {
        hr = CreateFindWithFilter(pff, riid, ppv);
        pff->Release();
    }

    return hr;    
}

STDAPI CComputerFindFolder_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv)
{
    *ppv = NULL;

    IFindFilter *pff;
    HRESULT hr = CreateDefaultComputerFindFilter(&pff);
    if (pff)
    {
        hr = CreateFindWithFilter(pff, riid, ppv);
        pff->Release();
    }
    return hr;    
}

HRESULT CFindFolder::MapToSearchIDList(LPCITEMIDLIST pidl, BOOL fMapToReal, LPITEMIDLIST *ppidl)
{
    *ppidl = NULL;
    
    LPITEMIDLIST pidlParent;
    LPCITEMIDLIST pidlChild;
    if (SUCCEEDED(SplitIDList(pidl, &pidlParent, &pidlChild)))
    {
        EnterCriticalSection(&_csSearch);

        // loop through our DPA list and see if we can find a matach
        for (int i = 0; i < DPA_GetPtrCount(_hdpaPidf); i++)
        {
            FIND_FOLDER_ITEM *pffli = _FolderListItem(i);
            if (pffli && ILIsEqual(pidlParent, &pffli->idl))
            {
                // We found the right one
                // so no lets transform the ID into one of our own
                // to return.  Note: we must catch the case where the
                // original one passed in was a simple pidl and do
                // the appropriate thing.
                //
                LPITEMIDLIST pidlToFree = NULL; // might need to cleanup in one case

                // If this is not a FS folder, just clone it.
                IShellFolder *psf;
                if (fMapToReal && SUCCEEDED(_Folder(pffli, IID_PPV_ARG(IShellFolder, &psf))))
                {
                    if (SUCCEEDED(SHGetRealIDL(psf, pidlChild, &pidlToFree)))
                    {
                        pidlChild = pidlToFree; // use this below... 
                    }
                    psf->Release();
                }

                // create the doc find version of the pidl witht the
                // extra hidden items embedded
                AddDataToIDList(pidlChild, i, pidlParent, DFDF_NONE, 0, 0, 0, ppidl);
                ILFree(pidlToFree); // may be NULL

                break;  // done with this loop
            }
        }
        LeaveCriticalSection(&_csSearch);

        ILFree(pidlParent);
    }
    
    return *ppidl ? S_OK : S_FALSE;
}


// Called before saving folder list.  Needed especially in Asynch search, 
// (CI).  We lazily pull item data from RowSet only when list view asks 
// for it.  When we are leaving the search folder, we pull all items
// creating all necessary folder lists.  This ensure when saving  folder
// list, all are included.   
// remark : Fix bug#338714.

HRESULT CFindFolder::_UpdateItemList()
{
    USHORT cb = 0;
    int cItems;
    if (SUCCEEDED(GetItemCount(&cItems))) 
    {
        for (int i = 0; i < cItems; i++) 
        {
            FIND_ITEM *pesfi;
            if (DB_S_ENDOFROWSET == GetItem(i, &pesfi))
                break;
        }
    }
    return S_OK;
}

// IFindFolder
HRESULT CFindFolder::SaveFolderList(IStream *pstm)
{
    // We First pull all the items from RowSet (in Asynch case)
    _UpdateItemList();

    EnterCriticalSection(&_csSearch);

    // Now loop through our DPA list and see if we can find a matach
    for (int i = 0; i < DPA_GetPtrCount(_hdpaPidf); i++)
    {
        FIND_FOLDER_ITEM *pffli = _FolderListItem(i);
        if (EVAL(pffli))
            ILSaveToStream(pstm, &pffli->idl);
        else
            break;
    }
    LeaveCriticalSection(&_csSearch);

    // Now out a zero size item..
    USHORT cb = 0;
    pstm->Write(&cb, sizeof(cb), NULL);

    return TRUE;
}

// IFindFolder, Restore results out to file.
HRESULT CFindFolder::RestoreFolderList(IStream *pstm)
{
    // loop through and all all of the folders to our list...
    LPITEMIDLIST pidl = NULL;
    HRESULT hr;

    for (;;)
    {
        hr = ILLoadFromStream(pstm, &pidl); // frees [in,out] pidl for us
        
        if (pidl == NULL)
            break;   // end of the list
        else
        {
            int i;
            AddFolder(pidl, FALSE, &i);
        }
    }
    
    ILFree(pidl); // don't forget to free last pidl

    return hr;
}

HRESULT CFindFolder::SaveItemList(IStream *pstm)
{
    // We First serialize all of our PIDLS for each item in our list
    int cItems;
    if (SUCCEEDED(GetItemCount(&cItems))) 
    {
        // And Save the items that are in the list
        for (int i = 0; i < cItems; i++) 
        {
            FIND_ITEM *pesfi;
            HRESULT hr = GetItem(i, &pesfi);
            
            if (hr == DB_S_ENDOFROWSET)
                break;
            if (SUCCEEDED(hr) && pesfi)
                ILSaveToStream(pstm, &pesfi->idl);
        }
    }
    
    USHORT cb = 0;
    pstm->Write(&cb, sizeof(cb), NULL); // a Trailing NULL size to say end of pidl list...
    
    return S_OK;
}

HRESULT CFindFolder::RestoreItemList(IStream *pstm, int *pcItems)
{
    // And the pidls that are associated with the object
    int cItems = 0;
    LPITEMIDLIST pidl = NULL;    // don't free previous one
    FIND_ITEM *pesfi;
    for (;;)
    {
        if (FAILED(ILLoadFromStream(pstm, &pidl)) || (pidl == NULL))
            break;
        
        if (FAILED(AddPidl(cItems, pidl, (UINT)-1, &pesfi)) || !pesfi)
            break;
        cItems++;
    }

    ILFree(pidl);       // Free the last one read in

    *pcItems = cItems;
    return S_OK;
}

HRESULT CFindFolder::_GetFolderIDList(int iFolder, LPITEMIDLIST *ppidlParent)
{
    *ppidlParent = NULL;

    HRESULT hr = E_FAIL;
    EnterCriticalSection(&_csSearch);
    FIND_FOLDER_ITEM *pffli = _FolderListItem(iFolder);
    if (pffli)
        hr = SHILClone(&pffli->idl, ppidlParent);
    LeaveCriticalSection(&_csSearch);

    return hr;
}

HRESULT CFindFolder::GetParentsPIDL(LPCITEMIDLIST pidl, LPITEMIDLIST *ppidlParent)
{
    return _GetFolderIDList(GetFolderIndex(pidl), ppidlParent);
}

HRESULT CFindFolder::SetControllerNotifyObject(IFindControllerNotify *pfcn)
{
    IUnknown_Set((IUnknown **)&_pfcn, pfcn);
    return S_OK;
}

HRESULT CFindFolder::GetControllerNotifyObject(IFindControllerNotify **ppfcn)
{
    *ppfcn = _pfcn;
    if (_pfcn)
        _pfcn->AddRef();
    return _pfcn ? S_OK : S_FALSE;
}

STDMETHODIMP_(ULONG) CFindFolder::AddRef()
{
    return InterlockedIncrement(&_cRef);
}

STDMETHODIMP_(ULONG) CFindFolder::Release()
{
    if (InterlockedDecrement(&_cRef))
       return _cRef;

    delete this;
    return 0;
}


STDMETHODIMP CFindFolder::ParseDisplayName(HWND hwnd, LPBC pbc, LPOLESTR pwzDisplayName,
    ULONG *pchEaten, LPITEMIDLIST *ppidl, ULONG *pdwAttributes)
{
    return E_NOTIMPL;
}

STDMETHODIMP CFindFolder::EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList **ppenum)
{
    // We do not want the def view to enumerate us, instead we
    // will tell defview to call us...
    *ppenum = NULL;     // No enumerator
    return S_FALSE;     // no enumerator (not error)
}

STDMETHODIMP CFindFolder::BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
{
    IShellFolder *psf;
    HRESULT hr = _QueryItemShellFolder(pidl, &psf);
    if (SUCCEEDED(hr))
    {
        hr = psf->BindToObject(pidl, pbc, riid, ppv);
        psf->Release();
    }
    return hr;
}


// Little helper function for bellow
HRESULT CFindFolder::_CompareFolderIndexes(int iFolder1, int iFolder2)
{
    HRESULT hr = E_INVALIDARG;

    EnterCriticalSection(&_csSearch);
    
    FIND_FOLDER_ITEM *pffli1 = _FolderListItem(iFolder1);
    FIND_FOLDER_ITEM *pffli2 = _FolderListItem(iFolder2);

    if (pffli1 && pffli2)
    {
        // Check our 1-level deep cache.  Since its is common for there to be multiple
        //  items in the same folder, during a sort operation, we often compare the
        //  same two folders repeatedly.
        if ((_iCompareFolderCache1 != iFolder1) || (_iCompareFolderCache2 != iFolder2))
        {
            TCHAR szPath1[MAX_PATH], szPath2[MAX_PATH];

            SHGetPathFromIDList(&pffli1->idl, szPath1);
            SHGetPathFromIDList(&pffli2->idl, szPath2);
            _iCompareFolderCacheResult = lstrcmpi(szPath1, szPath2);
            _iCompareFolderCache1 = iFolder1;
            _iCompareFolderCache2 = iFolder2;
        }
        hr = ResultFromShort(_iCompareFolderCacheResult);
    }

    LeaveCriticalSection(&_csSearch);
    return hr;
}

PCHIDDENDOCFINDDATA CFindFolder::_HiddenData(LPCITEMIDLIST pidl)
{
    return (PCHIDDENDOCFINDDATA)ILFindHiddenID(pidl, IDLHID_DOCFINDDATA);
}


UINT CFindFolder::GetFolderIndex(LPCITEMIDLIST pidl)
{
    PCHIDDENDOCFINDDATA phdfd = (PCHIDDENDOCFINDDATA)ILFindHiddenID(pidl, IDLHID_DOCFINDDATA);
    return phdfd ? phdfd->iFolder : -1;
}

FIND_FOLDER_ITEM *CFindFolder::_FolderListItem(int iFolder)
{
    return (FIND_FOLDER_ITEM *)DPA_GetPtr(_hdpaPidf, iFolder);
}

FIND_FOLDER_ITEM *CFindFolder::_FolderListItem(LPCITEMIDLIST pidl)
{
    return _FolderListItem(GetFolderIndex(pidl));
}

ULONG CFindFolder::_Rank(LPCITEMIDLIST pidl)
{
    PCHIDDENDOCFINDDATA phdfd = _HiddenData(pidl);
    // Could be mixed if so put ones without rank at the end...
    return phdfd && (phdfd->wFlags & DFDF_EXTRADATA) ? phdfd->ulRank : 0;
}

DWORD CFindFolder::_ItemID(LPCITEMIDLIST pidl)
{
    PCHIDDENDOCFINDDATA phdfd = _HiddenData(pidl);
    return phdfd && (phdfd->wFlags & DFDF_EXTRADATA) ? phdfd->dwItemID : -1;
}

HRESULT CFindFolder::_GetItemDisplayName(LPCITEMIDLIST pidl, DWORD dwFlags, LPWSTR wzName, UINT cch)
{
    // Get the IShellFolder:
    IShellFolder *psf;
    HRESULT hr = _QueryItemShellFolder(pidl, &psf);
    if (SUCCEEDED(hr))
    {
        // Get the display name:
        hr = DisplayNameOf(psf, pidl, dwFlags, wzName, cch);
        psf->Release();
    }
    return hr;
}


// Given the 2 pidls, we extract the display name using DisplayNameOf and then
// if all goes well, we compare the two.
int CFindFolder::_CompareNames(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2, DWORD dwFlags)
{
    int iRetVal = 0;
    WCHAR szName1[MAX_PATH], szName2[MAX_PATH];

    // Get the name for 1
    HRESULT hr = _GetItemDisplayName(pidl1, dwFlags, szName1, ARRAYSIZE(szName1));
    if (SUCCEEDED(hr))
    {
        // Get the name for 2
        hr = _GetItemDisplayName(pidl2, dwFlags, szName2, ARRAYSIZE(szName2));
        if (SUCCEEDED(hr))
        {
            // Compare and set value
            iRetVal = StrCmpLogicalW(szName1, szName2);
        }
    }

    return iRetVal;
}

int CFindFolder::_CompareByCachedSCID(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
    int iRetVal = 0;
    
    // If sort on name, we will skip this and use the code below.
    if (!IsEqualSCID(_scidCached, SCID_NAME))
    {
        iRetVal = CompareBySCID(this, &_scidCached, pidl1, pidl2);
    }
    
    // If they are still the same, sort them alphabetically by the name:
    // When we want to sort by name (either becuase we are sorting the
    // name column, or because 2 items are identical in other regards) we 
    // want to display name vs the GetDetailsOf name for 2 reasons:
    //   1. Some folders like IE's History don't support GetDetailsEx.
    //   2. Recycle bin returns the file name, not the displayable name;
    //      so we would end up with "DC###..." instead of "New Folder".
    if (iRetVal == 0)
    {
        iRetVal = _CompareNames(pidl1, pidl2, SHGDN_INFOLDER | SHGDN_NORMAL);
        if (iRetVal == 0)  // the display names are the same, could they be in different folders?
        {
            iRetVal = _CompareNames(pidl1, pidl2, SHGDN_FORPARSING);
        }
    }

    return iRetVal;
}

STDMETHODIMP CFindFolder::CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
    HRESULT hr = E_INVALIDARG;

    ASSERT(pidl1 == ILFindLastID(pidl1));

    UINT iInputColumn = ((DWORD)lParam & SHCIDS_COLUMNMASK);
    UINT iMappedColumn = iInputColumn;

    if (_MapColIndex(&iMappedColumn))
    {
        if (IDFCOL_PATH == iMappedColumn)
        {
            UINT iFolder1 = GetFolderIndex(pidl1);
            UINT iFolder2 = GetFolderIndex(pidl2);

            if (iFolder1 != iFolder2)
                return _CompareFolderIndexes(iFolder1, iFolder2);
        }
        else
        {
            ASSERT(iMappedColumn == IDFCOL_RANK);

            ULONG ulRank1 = _Rank(pidl1);
            ULONG ulRank2 = _Rank(pidl2);
            if (ulRank1 < ulRank2)
                return ResultFromShort(-1);
            if (ulRank1 > ulRank2)
                return ResultFromShort(1);
        }
    }

    // Check the SCID cache and update it if necessary.
    if (_uiColumnCached != iInputColumn)
    {
        hr = MapColumnToSCID(iInputColumn, &_scidCached);
        if (SUCCEEDED(hr))
        {
            _uiColumnCached = iInputColumn;
        }
    }

    // Check if one is a folder and not the other. put folders before files.
    int iRes = CompareFolderness(this, pidl1, pidl2);
    if (iRes == 0)
    {
        iRes = _CompareByCachedSCID(pidl1, pidl2);
    }

    return ResultFromShort(iRes);
}

STDMETHODIMP CFindFolder::CreateViewObject(HWND hwnd, REFIID riid, void **ppv)
{
    *ppv = NULL;
    HRESULT hr = E_NOINTERFACE;

    if (IsEqualIID(riid, IID_IShellView))
    {
        IShellFolderViewCB* psfvcb = new CFindFolderViewCB(this);
        if (psfvcb)
        {
            SFV_CREATE sSFV = {0};
            sSFV.cbSize   = sizeof(sSFV);
            sSFV.pshf     = this;
            sSFV.psfvcb   = psfvcb;

            hr = SHCreateShellFolderView(&sSFV, (IShellView**)ppv);

            psfvcb->Release();
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }
    }
    else if (IsEqualIID(riid, IID_IContextMenu))
    {
        IContextMenuCB *pcmcb = new CFindMenuCB();
        if (pcmcb)
        {
            hr = CDefFolderMenu_CreateEx(NULL, hwnd,
                    0, NULL, this, pcmcb, NULL, NULL, (IContextMenu * *)ppv);
            pcmcb->Release();
        }
        else
            hr = E_OUTOFMEMORY;
    }
    return hr;
}

STDMETHODIMP CFindFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST *apidl, ULONG *prgfInOut)
{
    HRESULT hr;
    if (cidl == 0)
    {
        // defview asks to see if any items can be renamed this way, lame
        *prgfInOut = SFGAO_CANRENAME;
        hr = S_OK;
    }
    else
    {
        ASSERT(*apidl == ILFindLastID(*apidl))
        IShellFolder *psf;
        hr = _QueryItemShellFolder(apidl[0], &psf);
        if (SUCCEEDED(hr))
        {
            hr = psf->GetAttributesOf(cidl, apidl, prgfInOut);
            psf->Release();
        }
    }
    return hr;
}

//
// To be called back from within CDefFolderMenuE - Currently only used
//

// Some helper functions                
STDMETHODIMP CFindFolder::SetItemsChangedSinceSort()
{ 
    _fItemsChangedSinceSort = TRUE;
    _iCompareFolderCache1 = -1;     // an invalid folder index value
    return S_OK;
}

STDMETHODIMP CFindFolder::GetItemCount(INT *pcItems)
{ 
    ASSERT(pcItems);
    DBCOUNTITEM cItems = 0;

    EnterCriticalSection(&_csSearch);
    if (_hdpaItems)
        cItems = DPA_GetPtrCount(_hdpaItems);
    LeaveCriticalSection(&_csSearch);

    // If async, then we may not have grown our dpa yet... but in mixed case we have so take
    // max of the two...
    if (_pDFEnumAsync)
    {
        if (_cAsyncItems > cItems)
            cItems = _cAsyncItems;
    }

    *pcItems = SANE_ITEMCOUNT(cItems);
    return S_OK;
};


STDMETHODIMP CFindFolder::GetItem(int iItem, FIND_ITEM **ppItem)
{
    HRESULT  hr = E_FAIL; // just to init, use anything
    FIND_ITEM *pesfi;
    IFindEnum *pidfenum;

    GetAsyncEnum(&pidfenum);

    DWORD dwItemID = (UINT)-1;

    EnterCriticalSection(&_csSearch);
    int i = DPA_GetPtrCount(_hdpaItems);
    pesfi = (FIND_ITEM *) DPA_GetPtr(_hdpaItems, iItem);
    LeaveCriticalSection(&_csSearch);

    // Mondo hack to better handle Async searching (ROWSET), we are not sure if we
    // can trust the PIDL of the row as new rows may have been inserted...
    // Only do this if we are not looking at the previous item..

    if (pesfi && pidfenum && !_fSearchComplete && (iItem != _iGetIDList))
    {
        PCHIDDENDOCFINDDATA phdfd = _HiddenData(&pesfi->idl);

        // As we can now have mixed results only blow away if this is an async guy...
        if (phdfd && (phdfd->wFlags & DFDF_EXTRADATA))
        {
            pidfenum->GetItemID(iItem, &dwItemID);
            if (dwItemID != phdfd->dwItemID)
            {
                // Overload, pass NULL to ADDPIDL to tell system to free that item
                if (pesfi->dwState & (LVIS_SELECTED|LVIS_FOCUSED))
                    _AddFIND_ITEMToSaveStateList(pesfi);

                AddPidl(iItem, 0, NULL, NULL);
                pesfi = NULL;
            }
        }
    }
                                                                                   
    _iGetIDList = iItem;   // remember the last one we retrieved...

    if (!pesfi && (iItem >= 0))
    {
        // See if this is the async case
        if (pidfenum)
        {
            LPITEMIDLIST pidlT;

            hr = pidfenum->GetItemIDList(SANE_ITEMCOUNT(iItem), &pidlT);            
            if (SUCCEEDED(hr) && hr != DB_S_ENDOFROWSET)
            {
                AddPidl(iItem, pidlT, dwItemID, &pesfi);
                // See if this item should show up as selected...
                if (dwItemID == (UINT)-1)
                    pidfenum->GetItemID(iItem, &dwItemID);
                GetStateFromSaveStateList(dwItemID, &pesfi->dwState);
            }
        }
    }

    *ppItem = pesfi;

    if (hr != DB_S_ENDOFROWSET)
        hr = pesfi ? S_OK : E_FAIL;

    return hr;
}

STDMETHODIMP CFindFolder::DeleteItem(int iItem)
{
    HRESULT hr = E_FAIL;
    
    if (!_fInRefresh)
    {
        FIND_ITEM *pesfi;

        hr = E_INVALIDARG;
        // make sure the item is in dpa (if using cI)
        if (SUCCEEDED(GetItem(iItem, &pesfi)) && pesfi)
        {
            EnterCriticalSection(&_csSearch);
            DPA_DeletePtr(_hdpaItems, iItem);
            LeaveCriticalSection(&_csSearch);
            
            PCHIDDENDOCFINDDATA phdfd = _HiddenData(&pesfi->idl);

            if (phdfd && (phdfd->wFlags & DFDF_EXTRADATA))
            {
                //we are deleting async item...
                _cAsyncItems--;
            }
            
            if (pesfi->dwState &= LVIS_SELECTED)
            {
                // Need to update the count of items selected...
                _dflvrSel.DecrementIncludedCount();
            }
            LocalFree((HLOCAL)pesfi);

            hr = S_OK;
        }
    }
    return hr;
}

// evil window crawling code to get the listview from defview

HWND ListviewFromView(HWND hwnd)
{
    HWND hwndLV;

    do
    {
        hwndLV = FindWindowEx(hwnd, NULL, WC_LISTVIEW, NULL);
    }
    while ((hwndLV == NULL) && (hwnd = GetWindow(hwnd, GW_CHILD)));

    return hwndLV;
}

HWND ListviewFromViewUnk(IUnknown *punkView)
{
    HWND hwnd;
    if (SUCCEEDED(IUnknown_GetWindow(punkView, &hwnd)))
    {
        hwnd = ListviewFromView(hwnd);
    }
    return hwnd;
}

STDMETHODIMP CFindFolder::ValidateItems(IUnknown *punkView, int iItem, int cItems, BOOL bSearchComplete)
{
    IFindEnum *pidfenum;
    if (S_OK != GetAsyncEnum(&pidfenum) || _fAllAsyncItemsCached)
        return S_OK;    // nothing to validate.

    DWORD dwItemID = (UINT)-1;

    int cItemsInList;
    GetItemCount(&cItemsInList);

    // force reload of rows
    pidfenum->Reset();

    HWND hwndLV = ListviewFromViewUnk(punkView);

    int iLVFirst = ListView_GetTopIndex(hwndLV);
    int cLVItems = ListView_GetCountPerPage(hwndLV);

    if (iItem == -1)
    {
        iItem = iLVFirst;
        cItems = cLVItems;
    }

    // to avoid failing to update an item...
    if (bSearchComplete)
        _iGetIDList = -1;
        
    while ((iItem < cItemsInList) && cItems)
    {
        EnterCriticalSection(&_csSearch);
        FIND_ITEM *pesfi = (FIND_ITEM *) DPA_GetPtr(_hdpaItems, iItem);
        LeaveCriticalSection(&_csSearch);
        if (!pesfi)     // Assume that if we have not gotten this one we are in the clear...
            break;

        PCHIDDENDOCFINDDATA phdfd = _HiddenData(&pesfi->idl);

        if (phdfd && (phdfd->wFlags & DFDF_EXTRADATA))
        {
            pidfenum->GetItemID(iItem, &dwItemID);
            
            if (dwItemID != _ItemID(&pesfi->idl))
            {
                FIND_ITEM *pItem; // dummy to make GetItem happy
                // Oops don't match,
                if (InRange(iItem, iLVFirst, iLVFirst+cLVItems))
                {
                    if (SUCCEEDED(GetItem(iItem, &pItem)))
                    {
                        ListView_RedrawItems(hwndLV, iItem, iItem);
                    }
                }
                else
                {
                    AddPidl(iItem, NULL, 0, NULL);
                }
            }
        }
        else
        {
            break;  // stop after we reach first non ci item
        }
        iItem++;
        cItems--;
    }

    _fSearchComplete = bSearchComplete;

    return S_OK;
}

STDMETHODIMP CFindFolder::AddPidl(int i, LPCITEMIDLIST pidl, DWORD dwItemID, FIND_ITEM **ppcdfi)
{
    HRESULT hr = S_OK;

    ASSERT(GetCurrentThreadId() == _GUIThreadID);

    if (NULL == pidl)
    {
        EnterCriticalSection(&_csSearch);
        FIND_ITEM* pesfi = (FIND_ITEM*)DPA_GetPtr(_hdpaItems, i);
        if (pesfi)
        {
            LocalFree((HLOCAL)pesfi);
            DPA_SetPtr(_hdpaItems, i, NULL);
        }
        LeaveCriticalSection(&_csSearch);
        if (ppcdfi)
            *ppcdfi = NULL;
    }
    else
    {
        int cb = ILGetSize(pidl);
        FIND_ITEM *pesfi;
        hr = SHLocalAlloc(sizeof(*pesfi) - sizeof(pesfi->idl) + cb, &pesfi);
        if (SUCCEEDED(hr))
        {
            // pesfi->dwMask = 0;
            // pesfi->dwState = 0;
            pesfi->iIcon = -1;
            memcpy(&pesfi->idl, pidl, cb);

            EnterCriticalSection(&_csSearch);
            BOOL bRet = DPA_SetPtr(_hdpaItems, i, (void *)pesfi);
            LeaveCriticalSection(&_csSearch);

            if (bRet)
            {
                if (ppcdfi)
                    *ppcdfi = pesfi;
            }
            else
            {
                LocalFree((HLOCAL)pesfi);
                pesfi = NULL;
                hr = E_OUTOFMEMORY;
            }
        }
    }
    
    return hr;
}

STDMETHODIMP CFindFolder::SetAsyncEnum(IFindEnum *pdfEnumAsync)
{
    if (_pDFEnumAsync)
        _pDFEnumAsync->Release();

    _pDFEnumAsync = pdfEnumAsync;
    if (pdfEnumAsync)
        pdfEnumAsync->AddRef();
    return S_OK;
}

STDMETHODIMP CFindFolder::CacheAllAsyncItems()
{
    if (_fAllAsyncItemsCached)
        return S_OK;      // Allready done it...  

    IFindEnum *pidfenum;
    if (S_OK != GetAsyncEnum(&pidfenum))
        return S_FALSE; // nothing to do...

    // Probably the easiest thing to do is to simply walk through all of the items...
    int maxItems = SANE_ITEMCOUNT(_cAsyncItems);
    for (int i = 0; i < maxItems; i++)
    {
        FIND_ITEM *pesfi;
        GetItem(i, &pesfi);
    }

    _fAllAsyncItemsCached = TRUE;
    return S_OK;
}

BOOL CFindFolder::AllAsyncItemsCached()
{
    return _fAllAsyncItemsCached;
}

STDMETHODIMP CFindFolder::GetAsyncEnum(IFindEnum **ppdfEnumAsync)
{
    *ppdfEnumAsync = _pDFEnumAsync; // unreferecned!
    return *ppdfEnumAsync ? S_OK : S_FALSE;
}

STDMETHODIMP CFindFolder::SetAsyncCount(DBCOUNTITEM cCount)
{
    _cAsyncItems = cCount;
    _fAllAsyncItemsCached = FALSE;
    return S_OK;
}

STDMETHODIMP CFindFolder::ClearSaveStateList()
{
    DSA_DeleteAllItems(_hdsaSaveStateForIDs);
    _cSaveStateSelected = 0;
    return S_OK;
}

STDMETHODIMP CFindFolder::GetStateFromSaveStateList(DWORD dwItemID, DWORD *pdwState)
{
    for (int i = DSA_GetItemCount(_hdsaSaveStateForIDs); i-- > 0;)
    {
        // Pidl at start of structure...
        FIND_ITEM_SAVE_STATE *pessi = (FIND_ITEM_SAVE_STATE*)DSA_GetItemPtr(_hdsaSaveStateForIDs, i);
        if  (pessi->dwItemID == dwItemID)
        {    
            *pdwState = pessi->dwState;
            if (pessi->dwState & LVIS_SELECTED)
            {
                // Remember the counts of items that we have touched...
                _dflvrSel.IncrementIncludedCount();
                _cSaveStateSelected--;
            }

            // Any items we retrieve we can get rid of...
            DSA_DeleteItem(_hdsaSaveStateForIDs, i);
            return S_OK;
        }
    }
    return S_FALSE;
}

STDMETHODIMP CFindFolder::GetFolderListItemCount(INT *pcItemCount)
{ 
    *pcItemCount = 0;

    EnterCriticalSection(&_csSearch);
    if (_hdpaPidf)
        *pcItemCount = DPA_GetPtrCount(_hdpaPidf);
    LeaveCriticalSection(&_csSearch);
     
    return S_OK;
}

STDMETHODIMP CFindFolder::GetFolderListItem(int iItem, FIND_FOLDER_ITEM **ppdffi)
{ 
    EnterCriticalSection(&_csSearch);
    *ppdffi = (FIND_FOLDER_ITEM *)DPA_GetPtr(_hdpaPidf, iItem);
    LeaveCriticalSection(&_csSearch);
    return *ppdffi ? S_OK : E_FAIL;
}

class CFindMenuWrap : public CContextMenuForwarder
{
public:
    // IContextMenu overrides
    STDMETHODIMP InvokeCommand(LPCMINVOKECOMMANDINFO lpici);

protected:
    CFindMenuWrap(IDataObject* pdo, IContextMenu* pcmArray);
    ~CFindMenuWrap();
    friend HRESULT DFWrapIContextMenus(IDataObject* pdo, IContextMenu* pcm1, IContextMenu* pcm2, REFIID riid, void** ppv);

private:
    IDataObject *       _pdtobj;
};

CFindMenuWrap::CFindMenuWrap(IDataObject* pdo, IContextMenu* pcmArray) : CContextMenuForwarder(pcmArray)
{
    _pdtobj = pdo;
    _pdtobj->AddRef();
}

CFindMenuWrap::~CFindMenuWrap()
{
    _pdtobj->Release();
}

STDMETHODIMP CFindMenuWrap::InvokeCommand(LPCMINVOKECOMMANDINFO lpici)
{
    BOOL fIsLink = FALSE;

    // "link" has to create a link on the desktop, not in the folder (since we're not a real folder...)
    if (IS_INTRESOURCE(lpici->lpVerb))
    {
        WCHAR szCommandString[64];
        if (SUCCEEDED(ContextMenu_GetCommandStringVerb(_pcm, LOWORD((UINT_PTR)lpici->lpVerb), szCommandString, ARRAYSIZE(szCommandString))))
        {
            fIsLink = !StrCmpIW(szCommandString, L"link");
        }
    }
    else
    {
        fIsLink = !StrCmpIA(lpici->lpVerb, "link");
    }

    if (fIsLink)
    {
        // Note: old code used to check pdtobj, but we don't create this
        //       object unless we get one of them, so why check?
        ASSERT(_pdtobj);
        return SHCreateLinks(lpici->hwnd, NULL, _pdtobj,
                SHCL_USETEMPLATE | SHCL_USEDESKTOP | SHCL_CONFIRM, NULL);
    }

    return CContextMenuForwarder::InvokeCommand(lpici);
}

HRESULT DFWrapIContextMenu(HWND hwnd, IShellFolder *psf, LPCITEMIDLIST pidl,
                           IContextMenu* pcmExtra, void **ppvInOut)
{
    IContextMenu *pcmWrap = NULL;
    IContextMenu *pcmFree = (IContextMenu*)*ppvInOut;

    IDataObject* pdo;
    HRESULT hr = psf->GetUIObjectOf(hwnd, 1, &pidl, IID_X_PPV_ARG(IDataObject, NULL, &pdo));
    if (SUCCEEDED(hr))
    {
        hr = DFWrapIContextMenus(pdo, pcmFree, pcmExtra, IID_PPV_ARG(IContextMenu, &pcmWrap));
        pdo->Release();
    }

    pcmFree->Release();
    *ppvInOut = pcmWrap;
    
    return hr;
}

HRESULT DFWrapIContextMenus(IDataObject* pdo, IContextMenu* pcm1, IContextMenu* pcm2, REFIID riid, void** ppv)
{
    *ppv = NULL;

    IContextMenu * pcmArray;
    IContextMenu* rgpcm[2] = {pcm2, pcm1};
    HRESULT hr = Create_ContextMenuOnContextMenuArray(rgpcm, ARRAYSIZE(rgpcm), IID_PPV_ARG(IContextMenu, &pcmArray));
    if (SUCCEEDED(hr))
    {
        CFindMenuWrap * p = new CFindMenuWrap(pdo, pcmArray);
        if (p)
        {
            hr = p->QueryInterface(riid, ppv);
            p->Release();
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }

        pcmArray->Release();
    }

    return hr;
}


STDMETHODIMP CFindFolder::QueryInterface(REFIID riid, void **ppv)
{
    static const QITAB qit[] = {
        QITABENT(CFindFolder, IShellFolder2),          //IID_ISHELLFolder2
        QITABENTMULTI(CFindFolder, IShellFolder, IShellFolder2),   // IID_IShellFolder
        QITABENT(CFindFolder, IFindFolder),        //IID_IFindFolder
        QITABENT(CFindFolder, IShellIcon),            //IID_IShellIcon
        QITABENT(CFindFolder, IPersistFolder2),       //IID_IPersistFolder2
        QITABENTMULTI(CFindFolder, IPersistFolder, IPersistFolder2), //IID_IPersistFolder
        QITABENTMULTI(CFindFolder, IPersist, IPersistFolder2),      //IID_IPersist
        QITABENT(CFindFolder, IShellIconOverlay),     //IID_IShellIconOverlay
        { 0 },
    };
    return QISearch(this, qit, riid, ppv);
}
    
// IPersistFolder2 implementation
STDMETHODIMP CFindFolder::GetClassID(CLSID *pClassID)
{
    *pClassID = CLSID_DocFindFolder;
    return S_OK;
}

STDMETHODIMP CFindFolder::Initialize(LPCITEMIDLIST pidl)
{
    if (_pidl)
        ILFree(_pidl);

    return SHILClone(pidl, &_pidl);
}

STDMETHODIMP CFindFolder::GetCurFolder(LPITEMIDLIST *ppidl) 
{    
    return GetCurFolderImpl(_pidl, ppidl);
}

// helper function to sort the selected ID list by something that
// makes file operations work reasonably OK, when both an object and it's
// parent is in the list...
//
int CALLBACK CFindFolder::_SortForDataObj(void *p1, void *p2, LPARAM lparam)
{
    // Since I do recursion, If I get the Folder index number from the
    // last element of each and sort by them such that the higher numbers
    // come first, should solve the problem fine...
    LPITEMIDLIST pidl1 = (LPITEMIDLIST)ILFindLastID((LPITEMIDLIST)p1);
    LPITEMIDLIST pidl2 = (LPITEMIDLIST)ILFindLastID((LPITEMIDLIST)p2);
    CFindFolder *pff = (CFindFolder *)lparam;

    return pff->GetFolderIndex(pidl2) - pff->GetFolderIndex(pidl1);
}

LPITEMIDLIST CFindFolder::_GetFullPidlForItem(LPCITEMIDLIST pidl)
{
    LPITEMIDLIST pidlRet = NULL;
    LPITEMIDLIST pidlParent;
    if (S_OK == GetParentsPIDL(pidl, &pidlParent))
    {
        pidlRet = ILCombine(pidlParent, pidl);
        ILFree(pidlParent);
    }
    return pidlRet;
}

// we generate a non flat HIDA. this is so clients that
// use this HIDA will bind to the folder that the results came
// from instead of this folder that has runtime state that won't
// be present if we rebind

HRESULT CFindFolder::_PrepareHIDA(UINT cidl, LPCITEMIDLIST * apidl, HDPA *phdpa)
{
    HRESULT hr = E_OUTOFMEMORY;
    *phdpa = DPA_Create(0);
    if (*phdpa)
    {
        if (DPA_Grow(*phdpa, cidl))
        {
            for (UINT i = 0; i < cidl; i++)
            {
                LPITEMIDLIST pidl = _GetFullPidlForItem(apidl[i]);
                if (pidl)
                    DPA_InsertPtr(*phdpa, i, pidl);
            }

            // In order to make file manipulation functions work properly we
            // need to sort the elements to make sure if an element and one
            // of it's parents are in the list, that the element comes
            // before it's parents...
            DPA_Sort(*phdpa, _SortForDataObj, (LPARAM)this);
            hr = S_OK;
        }
    }
    return hr;
}

STDMETHODIMP CFindFolder::GetUIObjectOf(HWND hwnd, UINT cidl, LPCITEMIDLIST * apidl,
                                        REFIID riid, UINT * prgfInOut, void **ppv)
{
    HRESULT hr = E_INVALIDARG;

    *ppv = NULL;

    // if just one item we can deletate to real folder
    if (cidl == 1)
    {
        // Note we may have been passed in a complex item so find the last
        ASSERT(ILIsEmpty(_ILNext(*apidl)));  // should be a single level PIDL!

        IShellFolder *psf;
        hr = _QueryItemShellFolder(apidl[0], &psf);
        if (SUCCEEDED(hr))
        {
            hr = psf->GetUIObjectOf(hwnd, cidl, apidl, riid, prgfInOut, ppv);

            // if we are doing context menu, then we will wrap this
            // interface in a wrapper object, that we can then pick
            // off commands like link to process specially
            if (SUCCEEDED(hr))
            {
                if (IsEqualIID(riid, IID_IContextMenu))
                {
                    // we also let the net/file guy add in a context menu if they want to
                    IContextMenu* pcmExtra = NULL;
                    _pfilter->GetItemContextMenu(hwnd, SAFECAST(this, IFindFolder*), &pcmExtra);
                
                    hr = DFWrapIContextMenu(hwnd, psf, apidl[0], pcmExtra, ppv);

                    ATOMICRELEASE(pcmExtra);
                }
                else if (IsEqualIID(riid, IID_IQueryInfo)) // && SHGetAttributes(psf, apidl[0], SFGAO_FILESYSTEM))
                {
                    WrapInfotip(SAFECAST(this, IShellFolder2 *), apidl[0], &SCID_DIRECTORY, (IUnknown *)*ppv);
                }
            }
            psf->Release();
        }
    }
    else if (cidl > 1)
    {
        if (IsEqualIID(riid, IID_IContextMenu))
        {
            // Try to create a menu object that we process ourself
            // Yes, do context menu.
            HKEY ahkeys[MAX_ASSOC_KEYS] = {0};
            DWORD ckeys = 0;

            LPITEMIDLIST pidlFull = _GetFullPidlForItem(apidl[0]);
            if (pidlFull)
            {
                // Get the hkeyProgID and hkeyBaseProgID from the first item.
                ckeys = SHGetAssocKeysForIDList(pidlFull, ahkeys, ARRAYSIZE(ahkeys));
                ILFree(pidlFull);
            }

            IContextMenuCB *pcmcb = new CFindMenuCB();
            if (pcmcb)
            {
                hr = CDefFolderMenu_Create2Ex(NULL, hwnd,
                                cidl, apidl, this, pcmcb,
                                ckeys, ahkeys,
                                (IContextMenu **)ppv);
                pcmcb->Release();
            }

            SHRegCloseKeys(ahkeys, ckeys);
        }
        else if (IsEqualIID(riid, IID_IDataObject))
        {
            HDPA hdpa;
            hr = _PrepareHIDA(cidl, apidl, &hdpa);
            if (SUCCEEDED(hr))
            {
                hr = SHCreateFileDataObject(&c_idlDesktop, cidl, (LPCITEMIDLIST*)DPA_GetPtrPtr(hdpa),
                                            NULL, (IDataObject **)ppv);
                DPA_FreeIDArray(hdpa);
            }
        }
    }

    return hr;
}

STDMETHODIMP CFindFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD dwRes, LPSTRRET pStrRet)
{
    IShellFolder *psf;
    HRESULT hr = _QueryItemShellFolder(pidl, &psf);
    if (SUCCEEDED(hr))
    {
        if ((dwRes & SHGDN_INFOLDER) && (dwRes & SHGDN_FORPARSING) && !(dwRes & SHGDN_FORADDRESSBAR))
        {
            // The thumbnail cache uses this as a hit test... in search view we can have files with the same name.
            dwRes &= ~SHGDN_INFOLDER;
        }
        hr = psf->GetDisplayNameOf(pidl, dwRes, pStrRet);
        psf->Release();
    }
    return hr;
}

STDMETHODIMP CFindFolder::SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR pszName, 
                                    DWORD dwRes, LPITEMIDLIST *ppidlOut)
{
    if (ppidlOut)
        *ppidlOut = NULL;

    IShellFolder *psf;
    HRESULT hr = _QueryItemShellFolder(pidl, &psf);
    if (SUCCEEDED(hr))
    {
        LPITEMIDLIST pidlRenamed;
        hr = psf->SetNameOf(hwnd, pidl, PathFindFileName(pszName), dwRes, ppidlOut ? &pidlRenamed : NULL);
        if (SUCCEEDED(hr) && ppidlOut)
        {
            hr = AddDataToIDList(pidlRenamed, GetFolderIndex(pidl), NULL, DFDF_NONE, 0, 0, 0, ppidlOut);
            ILFree(pidlRenamed);
        }
        psf->Release();
    }
    return hr;
}

STDMETHODIMP CFindFolder::GetDefaultSearchGUID(GUID *pGuid)
{
    return _pfilter->GetDefaultSearchGUID(SAFECAST(this, IShellFolder2*), pGuid);
}

STDMETHODIMP CFindFolder::EnumSearches(LPENUMEXTRASEARCH *ppenum)
{
    return _pfilter->EnumSearches(SAFECAST(this, IShellFolder2*), ppenum);
}

HRESULT CFindFolder::_Folder(FIND_FOLDER_ITEM *pffli, REFIID riid, void **ppv)
{
    HRESULT hr;

    if (pffli->psf)
        hr = S_OK;
    else
        hr = SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, &pffli->idl, &pffli->psf));

    if (SUCCEEDED(hr))
        hr = pffli->psf->QueryInterface(riid, ppv);
    return hr;
}

HRESULT CFindFolder::GetFolder(int iFolder, REFIID riid, void **ppv)
{
    *ppv = NULL; 
    HRESULT hr = E_FAIL;

    EnterCriticalSection(&_csSearch);

    FIND_FOLDER_ITEM *pffli = _FolderListItem(iFolder);
    if (pffli)
        hr = _Folder(pffli, riid, ppv);

    LeaveCriticalSection(&_csSearch);

    return hr;
}

HRESULT CFindFolder::_FolderFromItem(LPCITEMIDLIST pidl, REFIID riid, void **ppv)
{
    *ppv = NULL; 
    HRESULT hr = E_FAIL;
    PCHIDDENDOCFINDDATA phdfd = _HiddenData(pidl);
    if (phdfd)
    {
        hr = SHBindToObject(NULL, riid, &phdfd->idlParent, ppv);
    }
    return hr;
}

HRESULT CFindFolder::_QueryItemShellFolder(LPCITEMIDLIST pidl, IShellFolder **ppsf)
{
    *ppsf = NULL;
    HRESULT hr = E_FAIL;

    EnterCriticalSection(&_csSearch);

    FIND_FOLDER_ITEM *pffli = _FolderListItem(pidl);
    if (pffli)
    {
        if (pffli->psf)
            hr = S_OK;
        else
            hr = SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, &pffli->idl, &pffli->psf));

        if (SUCCEEDED(hr))
        {
            *ppsf = pffli->psf;
            (*ppsf)->AddRef();
        }
    }

    LeaveCriticalSection(&_csSearch);

    if (FAILED(hr))
    {
        hr = _FolderFromItem(pidl, IID_PPV_ARG(IShellFolder, ppsf));
    }

    return hr;
}


HRESULT CFindFolder::_QueryItemInterface(LPCITEMIDLIST pidl, REFIID riid, void **ppv)
{
    *ppv = NULL;
    HRESULT hr = E_FAIL;

    EnterCriticalSection(&_csSearch);

    FIND_FOLDER_ITEM *pffli = _FolderListItem(pidl);
    if (pffli)
        hr = _Folder(pffli, riid, ppv);

    LeaveCriticalSection(&_csSearch);

    if (FAILED(hr))
    {
        hr = _FolderFromItem(pidl, riid, ppv);
    }

    return hr;
}

HRESULT CFindFolder::_GetDetailsFolder()
{
    HRESULT hr;
    if (_psfDetails)
        hr = S_OK;  // in cache
    else 
    {
        IFindFilter *pfilter;
        hr = GetFindFilter(&pfilter);
        if (SUCCEEDED(hr)) 
        {
            hr = pfilter->GetColumnsFolder(&_psfDetails);
            pfilter->Release();
        }
    }
    return hr;
}

STDMETHODIMP CFindFolder::GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
{
    HRESULT hr = _GetDetailsFolder();
    if (SUCCEEDED(hr))
        hr = _psfDetails->GetDefaultColumn(dwRes, pSort, pDisplay);
    return hr;
}

BOOL CFindFolder::_MapColIndex(UINT *piColumn)
{
    switch (*piColumn)
    {
    case IDFCOL_NAME:   // 0
        return FALSE;

    case IDFCOL_PATH:   // 1
    case IDFCOL_RANK:   // 2
        return TRUE;

    default:            // >= 3
        *piColumn -= IDFCOL_RANK;
        return FALSE;
    }
}

STDMETHODIMP CFindFolder::GetDefaultColumnState(UINT iColumn, DWORD *pdwState)
{
    HRESULT hr;
    
    if (_MapColIndex(&iColumn))
    {
        *pdwState = c_find_cols[iColumn].csFlags;
        hr = S_OK;
    }
    else
    {
        hr = _GetDetailsFolder();
        if (SUCCEEDED(hr))
        {
            hr = _psfDetails->GetDefaultColumnState(iColumn, pdwState);
            *pdwState &= ~SHCOLSTATE_SLOW;  // virtual lv and defview
        }
    }
    return hr;
}

HRESULT CFindFolder::_GetFolderName(LPCITEMIDLIST pidl, DWORD gdnFlags, LPTSTR psz, UINT cch)
{
    LPITEMIDLIST pidlFolder;
    HRESULT hr = GetParentsPIDL(pidl, &pidlFolder);
    if (SUCCEEDED(hr))
    { 
        hr = SHGetNameAndFlags(pidlFolder, gdnFlags, psz, cch, NULL);
        ILFree(pidlFolder);
    }
    return hr;
}

STDMETHODIMP CFindFolder::GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv)
{
    HRESULT hr;
    if (IsEqualSCID(*pscid, SCID_RANK))
    {
        hr = InitVariantFromUINT(pv, _Rank(pidl));
    }
    else
    {
        IShellFolder2 *psf;
        hr = _QueryItemInterface(pidl, IID_PPV_ARG(IShellFolder2, &psf));
        if (SUCCEEDED(hr))
        {
            hr = psf->GetDetailsEx(pidl, pscid, pv);
            psf->Release();
        }

        if (FAILED(hr))
        {
            if (IsEqualSCID(*pscid, SCID_DIRECTORY))
            {
                TCHAR szTemp[MAX_PATH];
                hr = _GetFolderName(pidl, SHGDN_FORADDRESSBAR | SHGDN_FORPARSING, szTemp, ARRAYSIZE(szTemp));
                if (SUCCEEDED(hr))
                {
                    hr = InitVariantFromStr(pv, szTemp);
                }
            }
        }
    }
    return hr;
}

//  Figure out what the correct column index is to match the scid we are given
//  where the returned index is relative to the folder passed in.
int MapSCIDToColumnForFolder(IShellFolder2 *psf, SHCOLUMNID scidIn)
{
    SHCOLUMNID scidNew;
    for (UINT i = 0; SUCCEEDED(psf->MapColumnToSCID(i, &scidNew)); i++)
    {
        if (IsEqualSCID(scidNew, scidIn))
        {
            return i;   // found
        }
    }
    return -1;  // not found
}

STDMETHODIMP CFindFolder::GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pdi)
{
    HRESULT hr;
    if (_MapColIndex(&iColumn))
    {
        if (pidl)
        {
            TCHAR szTemp[MAX_PATH];
            szTemp[0] = 0;
            if (IDFCOL_PATH == iColumn)   
            {
                _GetFolderName(pidl, SHGDN_FORADDRESSBAR | SHGDN_FORPARSING, szTemp, ARRAYSIZE(szTemp));
            }
            else
            {
                ASSERT(IDFCOL_RANK == iColumn);
                ULONG uRank = _Rank(pidl);
                if (uRank)
                    AddCommas(uRank, szTemp, ARRAYSIZE(szTemp));
            }
            hr = StringToStrRet(szTemp, &pdi->str);
        }
        else
        {
            hr = GetDetailsOfInfo(c_find_cols, ARRAYSIZE(c_find_cols), iColumn, pdi);
        }
    }
    else
    {
        if (pidl)
        {
            IShellFolder2 *psf;
            hr = _QueryItemInterface(pidl, IID_PPV_ARG(IShellFolder2, &psf));
            if (SUCCEEDED(hr))
            {
                //  We cannot simply ask for GetDetailsOf because some folders map different
                //  column numbers to differnt values.
                //  Translate the column index to the SHCOLUMNID relative to this folder.
                SHCOLUMNID colId;
                hr = _GetDetailsFolder();
                if (SUCCEEDED(hr))
                    hr = _psfDetails->MapColumnToSCID(iColumn, &colId);

                //  Use the SCID to get the correct column index...
                if (SUCCEEDED(hr))
                {
                    //  Get the column index for the SCID with respect to the other folder
                    int newIndex = MapSCIDToColumnForFolder(psf, colId);
                    if (newIndex != -1)
                    {
                        //  Found the correct column index, so use it to get the data
                        hr = psf->GetDetailsOf(pidl, newIndex, pdi);
                    }
                    else
                    {
                        //  Failed to find the correct column index.
                        hr = E_FAIL;
                    }
                }
                
                psf->Release();
            }
        }
        else
        {
            hr = _GetDetailsFolder();
            if (SUCCEEDED(hr))
                hr = _psfDetails->GetDetailsOf(NULL, iColumn, pdi);
        }
    }
    return hr;
}

STDMETHODIMP CFindFolder::MapColumnToSCID(UINT iColumn, SHCOLUMNID *pscid)
{
    HRESULT hr;
    if (_MapColIndex(&iColumn))
    {
        hr = MapColumnToSCIDImpl(c_find_cols, ARRAYSIZE(c_find_cols), iColumn, pscid);
    }
    else
    {
        hr = _GetDetailsFolder();
        if (SUCCEEDED(hr))
            hr = _psfDetails->MapColumnToSCID(iColumn, pscid);
    }
    return hr;
}

STDMETHODIMP CFindFolder::GetFindFilter(IFindFilter **ppfilter)
{
    return _pfilter->QueryInterface(IID_PPV_ARG(IFindFilter, ppfilter));
}

// IShellIcon::GetIconOf
STDMETHODIMP CFindFolder::GetIconOf(LPCITEMIDLIST pidl, UINT flags, int *piIndex)
{
    IShellIcon * psiItem;
    HRESULT hr = _QueryItemInterface(pidl, IID_PPV_ARG(IShellIcon, &psiItem));
    if (SUCCEEDED(hr))
    {
        hr = psiItem->GetIconOf(pidl, flags, piIndex);
        psiItem->Release();
    }
    return hr;
}

// IShellIconOverlay
STDMETHODIMP CFindFolder::GetOverlayIndex(LPCITEMIDLIST pidl, int * pIndex)
{
    IShellIconOverlay * psioItem;
    HRESULT hr = _QueryItemInterface(pidl, IID_PPV_ARG(IShellIconOverlay, &psioItem));
    if (SUCCEEDED(hr))
    {
        hr = psioItem->GetOverlayIndex(pidl, pIndex);
        psioItem->Release();
    }
    return hr;
}

STDMETHODIMP CFindFolder::GetOverlayIconIndex(LPCITEMIDLIST pidl, int * pIndex)
{
    return E_NOTIMPL;
}

STDMETHODIMP CFindFolder::RestoreSearchFromSaveFile(LPCITEMIDLIST pidlSaveFile, IShellFolderView *psfv)
{
    // See if we can restore most of the search from here...
    IStream *pstm;
    HRESULT hr = StgBindToObject(pidlSaveFile, STGM_READ | STGM_SHARE_DENY_WRITE, IID_PPV_ARG(IStream, &pstm));
    if (SUCCEEDED(hr))
    {
        ULONG cbRead;
        DFHEADER dfh;

        // Note: in theory I should test the size read by the size of the
        // smaller headers, but if the number of bytes read is smaller than
        // the few new things added then there is nothing to restore anyway...

        // Note: Win95/NT4 incorrectly failed newer versions of this structure.
        // Which is bogus since the struct was backward compatible (that's what
        // the offsets are for).  We fix for NT5 and beyond, but downlevel
        // systems are forever broken.  Hopefully this feature is rarely enough
        // used (and never mailed) that nobody will notice we're broken.

        if (SUCCEEDED(pstm->Read(&dfh, sizeof(dfh), &cbRead)) &&
            (sizeof(dfh) == cbRead) && (DOCFIND_SIG == dfh.wSig))
        {
            DFC_UNICODE_DESC desc;
            LARGE_INTEGER dlibMove = {0, 0};
            WORD fCharType = 0;

            // Check the stream's signature to see if it was generated by Win95 or NT.
            dlibMove.QuadPart = -(LONGLONG)sizeof(desc);
            pstm->Seek(dlibMove, STREAM_SEEK_END, NULL);
            pstm->Read(&desc, sizeof(desc), &cbRead);
            if (cbRead > 0 && desc.NTsignature == c_NTsignature)
            {
               // NT-generated stream.  Read in Unicode criteria.
               fCharType = DFC_FMT_UNICODE;
               dlibMove.QuadPart = desc.oUnicodeCriteria.QuadPart;
            }
            else
            {
               // Win95-generated stream.  Read in ANSI criteria.
               fCharType = DFC_FMT_ANSI;
               dlibMove.LowPart = dfh.oCriteria;
            }
            pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);
            _pfilter->RestoreCriteria(pstm, dfh.cCriteria, fCharType);

            // Now read in the results
            dlibMove.LowPart = dfh.oResults;
            pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);

            if (dfh.wVer > 1)
            {
                // only restore this way if version 2 data....
                // Now Restore away the folder list
                RestoreFolderList(pstm);
                int cItems = 0;
                RestoreItemList(pstm, &cItems);
                if (cItems > 0)
                    psfv->SetObjectCount(cItems, SFVSOC_NOSCROLL);
            }
        }
        else
            hr = E_FAIL;
        pstm->Release();
    }
    return hr;
}

// a form of this code is duplicated in browseui searchext.cpp
//
BOOL RealFindFiles(LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlSaveFile)
{
    // First create the top level browser...
    IWebBrowser2 *pwb2;
    HRESULT hr = CoCreateInstance(CLSID_ShellBrowserWindow, NULL, CLSCTX_LOCAL_SERVER, IID_PPV_ARG(IWebBrowser2, &pwb2));
    if (SUCCEEDED(hr))
    {
        VARIANT varClsid;
        hr = InitBSTRVariantFromGUID(&varClsid, CLSID_FileSearchBand);
        if (SUCCEEDED(hr))
        {
            VARIANT varEmpty = {0};

            // show a search bar
            hr = pwb2->ShowBrowserBar(&varClsid, &varEmpty, &varEmpty);
            if (SUCCEEDED(hr))
            {
                // Grab the band's IUnknown from browser property.
                VARIANT varFsb;
                hr = pwb2->GetProperty(varClsid.bstrVal, &varFsb);
                if (SUCCEEDED(hr))
                {
                    //  QI for IFileSearchBand, which we'll use to program the search band's
                    //  search type (files or folders), inititial scope, and/or saved query file.
                    IFileSearchBand* pfsb;
                    if (SUCCEEDED(QueryInterfaceVariant(varFsb, IID_PPV_ARG(IFileSearchBand, &pfsb))))
                    {
                        BSTR bstrSearch;
                        hr = BSTRFromCLSID(SRCID_SFileSearch, &bstrSearch);
                        if (SUCCEEDED(hr))
                        {
                            VARIANT varQueryFile = {0}, varScope = {0};

                            //  assign initial scope
                            if (pidlFolder)
                                InitVariantFromIDList(&varScope, pidlFolder);
                            //  assign query file from which to restore search
                            else if (pidlSaveFile)
                                InitVariantFromIDList(&varQueryFile, pidlSaveFile);

                            pfsb->SetSearchParameters(&bstrSearch, VARIANT_TRUE, &varScope, &varQueryFile);

                            VariantClear(&varScope);
                            VariantClear(&varQueryFile);

                            SysFreeString(bstrSearch);
                        }
                        pfsb->Release();
                    }
                    VariantClear(&varFsb);
                }

                if (SUCCEEDED(hr))
                    hr = pwb2->put_Visible(TRUE);
            }
            VariantClear(&varClsid); // frees bstrFileSearchBand too
        }
        pwb2->Release();
    }
    return hr;
}

HRESULT CFindFolder::OpenContainingFolder(IUnknown *punkSite)
{
    IFolderView *pfv;
    HRESULT hr = IUnknown_QueryService(punkSite, SID_SFolderView, IID_PPV_ARG(IFolderView, &pfv));
    if (SUCCEEDED(hr))
    {
        IEnumIDList *penum;
        hr = pfv->Items(SVGIO_SELECTION, IID_PPV_ARG(IEnumIDList, &penum));
        if (S_OK == hr)
        {
            LPITEMIDLIST pidl;
            ULONG c;
            while (S_OK == penum->Next(1, &pidl, &c))
            {
                // Now get the parent of it.
                LPITEMIDLIST pidlParent;
                if (SUCCEEDED(GetParentsPIDL(pidl, &pidlParent)))
                {
                    SHOpenFolderAndSelectItems(pidlParent, 1, (LPCITEMIDLIST *)&pidl, 0);
                    ILFree(pidlParent);
                }
                ILFree(pidl);
            }
            penum->Release();
        }
        pfv->Release();
    }
    return hr;
}

// Save away the current search to a file on the desktop.
// For now the name will be automatically generated.
//
void CFindFolder::Save(IFindFilter* pfilter, HWND hwnd, DFBSAVEINFO * pSaveInfo, IShellView* psv, IUnknown *pObject)
{
    TCHAR szFilePath[MAX_PATH];
    IStream * pstm;
    DFHEADER dfh;
    TCHAR szTemp[MAX_PATH];
    SHORT cb;
    LARGE_INTEGER dlibMove = {0, 0};
    ULARGE_INTEGER libCurPos;
    FOLDERSETTINGS fs;
    
    //
    // See if the search already has a file name associated with it.  If so
    // we will save it in it, else we will create a new file on the desktop
    if (pfilter->FFilterChanged() == S_FALSE)
    {
        // Lets blow away the save file
        ILFree(pSaveInfo->pidlSaveFile);
        pSaveInfo->pidlSaveFile = NULL;
    }
    
    // If it still looks like we want to continue to use a save file then
    // continue.
    if (pSaveInfo->pidlSaveFile)
    {
        SHGetPathFromIDList(pSaveInfo->pidlSaveFile, szFilePath);
    }
    else
    {
        // First get the path name to the Desktop.
        SHGetSpecialFolderPath(NULL, szFilePath, CSIDL_PERSONAL, TRUE);
        
        // and update the title
        // we now do this before getting a filename because we generate
        // the file name from the title
        
        LPTSTR pszTitle;
        pfilter->GenerateTitle(&pszTitle, TRUE);
        if (pszTitle)
        {
            // Now add on the extension.
            lstrcpyn(szTemp, pszTitle, MAX_PATH - (lstrlen(szFilePath) + 1 + 4 + 1+3));
            lstrcat(szTemp, TEXT(".fnd"));
            
            LocalFree(pszTitle);     // And free the title string.
        }
        else
        {
            szTemp[0] = 0;
        }
        
        
        // Now loop through and replace all of the invalid characters with _'s
        // we special case a few of the characters...
        for (LPTSTR lpsz = szTemp; *lpsz; lpsz = CharNext(lpsz))
        {
            if (PathGetCharType(*lpsz) & (GCT_INVALID|GCT_WILD|GCT_SEPARATOR))
            {
                switch (*lpsz) 
                {
                case TEXT(':'):
                    *lpsz = TEXT('-');
                    break;
                case TEXT('*'):
                    *lpsz = TEXT('@');
                    break;
                case TEXT('?'):
                    *lpsz = TEXT('!');
                    break;
                default:
                    *lpsz = TEXT('_');
                }
            }
        }
        
        TCHAR szShortName[12];
        LoadString(HINST_THISDLL, IDS_FIND_SHORT_NAME, szShortName, ARRAYSIZE(szShortName));
        if (!PathYetAnotherMakeUniqueName(szFilePath, szFilePath, szShortName, szTemp))
            return;
    }
    
    // Now lets bring up the save as dialog...
    TCHAR szFilter[MAX_PATH];
    TCHAR szTitle[MAX_PATH];
    TCHAR szFilename[MAX_PATH];
    OPENFILENAME ofn = { 0 };
    
    LoadString(g_hinst, IDS_FINDFILESFILTER, szFilter, ARRAYSIZE(szFilter));
    LoadString(g_hinst, IDS_FINDSAVERESULTSTITLE, szTitle, ARRAYSIZE(szTitle));
    
    //Strip out the # and make them Nulls for SaveAs Dialog
    LPTSTR psz = szFilter;
    while (*psz)
    {
        if (*psz == TEXT('#'))
            *psz = 0;
        psz++;
    }
    
    lstrcpy(szFilename, PathFindFileName(szFilePath));
    PathRemoveFileSpec(szFilePath);
    
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hwnd;
    ofn.hInstance = g_hinst;
    ofn.lpstrFilter = szFilter;
    ofn.lpstrFile = szFilename;
    ofn.nMaxFile = MAX_PATH;
    ofn.lpstrInitialDir = szFilePath;
    ofn.lpstrTitle = szTitle;
    ofn.lpstrDefExt = TEXT("fnd");
    ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_PATHMUSTEXIST | 
        OFN_OVERWRITEPROMPT | OFN_NOCHANGEDIR;
    ofn.lpTemplateName = NULL;
    ofn.lpfnHook= NULL;
    ofn.lCustData = NULL;
    
    if (!GetSaveFileName(&ofn))
        return;
    
    if (FAILED(SHCreateStreamOnFile(szFilename, STGM_CREATE | STGM_WRITE | STGM_SHARE_DENY_WRITE, &pstm)))
        return;
    
    // remember the file that we saved away to...
    ILFree(pSaveInfo->pidlSaveFile);
    SHParseDisplayName(szFilename, NULL, &pSaveInfo->pidlSaveFile, 0, NULL);
    
    // Now setup and write out header information
    ZeroMemory(&dfh, sizeof(dfh));
    dfh.wSig = DOCFIND_SIG;
    dfh.wVer = DF_CURFILEVER;
    dfh.dwFlags =  pSaveInfo->dwFlags;
    dfh.wSortOrder = (WORD)pSaveInfo->SortMode;
    dfh.wcbItem = sizeof(DFITEM);
    dfh.oCriteria = sizeof(dfh);
    // dfh.cCriteria = sizeof(s_aIndexes) / sizeof(SHORT);
    // dfh.oResults =;
    
    // Not used anymore...
    dfh.cResults = -1;
    
    // Note: Later we may convert this to DOCFILE where the
    // criteria is stored as properties.
    
    // Get the current Folder Settings
    if (SUCCEEDED(psv->GetCurrentInfo(&fs)))
        dfh.ViewMode = fs.ViewMode;
    else
        dfh.ViewMode = FVM_DETAILS;
    
    // Now call the filter object to save out his own set of criterias
    
    dlibMove.LowPart = dfh.oCriteria;
    pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);
    HRESULT hr = pfilter->SaveCriteria(pstm, DFC_FMT_ANSI);
    if (SUCCEEDED(hr))
        dfh.cCriteria = GetScode(hr);
    
    // Now setup to output the results
    dlibMove.LowPart = 0;
    pstm->Seek(dlibMove, STREAM_SEEK_CUR, &libCurPos); // Get current pos
    dfh.oResults = libCurPos.LowPart;
    //
    // Now Let our file folder serialize his results out here also...
    // But only if the option is set to do so...
    //
    cb = 0;
    
    // Write out a Trailing NULL for Folder list
    pstm->Write(&cb, sizeof(cb), NULL);
    // And item list.
    pstm->Write(&cb, sizeof(cb), NULL);
    
    // END of DFHEADER_WIN95 information
    // BEGIN of NT5 information:
    
    // Now setup to output the history stream
    if (pObject)
    {
        dlibMove.LowPart = 0;
        pstm->Seek(dlibMove, STREAM_SEEK_CUR, &libCurPos); // Get current pos
        dfh.oHistory = libCurPos.LowPart;
        
        if (FAILED(SavePersistHistory(pObject, pstm)))
        {
            // On failure we might as well just pretend we didn't save this bit of data.
            // Do we need an error message -- the ui won't be right when relaunched...
            //
            dfh.oHistory = 0;
            dlibMove.LowPart = libCurPos.LowPart;
            pstm->Seek(dlibMove, STREAM_SEEK_SET, NULL);
        }
    }
    
    // In NT the below was done AT THE END OF THE STREAM instead of
    // revving the DFHEADER struct.  (Okay, DFHEADEREX, since Win95
    // already broke DFHEADER back compat by in improper version check)
    // This could have been done by putting a propery signatured
    // DFHEADEREX that had proper versioning so we could add information
    // to.  Unfortunately another hardcoded struct was tacked on to
    // the end of the stream...   Next time, please fix the problem
    // instead of work around it.
    //
    // What this boils down to is we cannot put any information
    // after the DFC_UNICODE_DESC section, so might as well
    // always do this SaveCriteria section last...
    //
    // See comment at top of file for DFC_UNICODE_DESC.
    //
    DFC_UNICODE_DESC desc;
    
    //
    // Get the current location in stream.  This is the offset where
    // we'll write the unicode find criteria.  Save this
    // value (along with NT-specific signature) in the descriptor
    //
    dlibMove.LowPart = 0;
    pstm->Seek(dlibMove, STREAM_SEEK_CUR, &libCurPos);
    
    desc.oUnicodeCriteria.QuadPart = libCurPos.QuadPart;
    desc.NTsignature               = c_NTsignature;
    
    // Append the Unicode version of the find criteria.
    hr = pfilter->SaveCriteria(pstm, DFC_FMT_UNICODE);
    
    // Append the unicode criteria descriptor to the end of the file.
    pstm->Write(&desc, sizeof(desc), NULL);
    //
    // don't put any code between the above DFC_UNICDE_DESC section
    // and this back-patch of the dfh header...
    //
    // Finally output the header information at the start of the file
    // and close the file
    //
    pstm->Seek(g_li0, STREAM_SEEK_SET, NULL);
    pstm->Write(&dfh, sizeof(dfh), NULL);
    pstm->Release();
    
    SHChangeNotify(SHCNE_CREATE, SHCNF_IDLIST, pSaveInfo->pidlSaveFile, NULL);
    SHChangeNotify(SHCNE_FREESPACE, SHCNF_IDLIST, pSaveInfo->pidlSaveFile, NULL);
}

// Broke out from class to share with old and new code
BOOL CFindFolder::HandleUpdateDir(LPCITEMIDLIST pidl, BOOL fCheckSubDirs)
{
    // 1. Start walk through list of dirs.  Find list of directories effected
    //    and mark them
    // 2. Walk the list of items that we have and mark each of the items that
    //    that are in our list of directories and then do a search...
    BOOL fCurrentItemsMayBeImpacted = FALSE;
    FIND_FOLDER_ITEM *pffli;
    INT cPidf;

    // First see which directories are effected...
    GetFolderListItemCount(&cPidf);
    for (int iPidf = 0; iPidf < cPidf; iPidf++)
    {        
        if (SUCCEEDED(GetFolderListItem(iPidf, &pffli)) 
            && !pffli->fUpdateDir) // We may have already impacted these...
        {
            pffli->fUpdateDir = ILIsParent(pidl, &pffli->idl, FALSE);
            fCurrentItemsMayBeImpacted |= pffli->fUpdateDir;
        }
    }

    if (fCurrentItemsMayBeImpacted)
    {
        // Now we need to walk through the whole list and remove any entries
        // that are no longer there...
        //
        int iItem;
        if (SUCCEEDED(GetItemCount(&iItem))) 
        {
            for (--iItem; iItem >= 0; iItem--)
            {
                FIND_ITEM *pesfi;
                if (SUCCEEDED(GetItem(iItem, &pesfi)) && pesfi)
                {
                    UINT iFolder = GetFolderIndex(&pesfi->idl);
                
                    // See if item may be impacted...
                    if (SUCCEEDED(GetFolderListItem(iFolder, &pffli)) && pffli->fUpdateDir)
                        pesfi->dwState |= CDFITEM_STATE_MAYBEDELETE;
                }
            }
        }
    }

    return fCurrentItemsMayBeImpacted;
}

void CFindFolder::UpdateOrMaybeAddPidl(IShellFolderView *psfv, LPCITEMIDLIST pidl, LPCITEMIDLIST pidlOld)
{
    HRESULT hr;

    // First see if we should try to do an update...
    if (pidlOld)
    {
        LPITEMIDLIST pidlT;
        if (S_OK == MapToSearchIDList(pidl, TRUE, &pidlT))
        {
            SetItemsChangedSinceSort();
            UINT iItem;
            // cast needed for bad interface def
            hr = psfv->UpdateObject((LPITEMIDLIST)pidlOld, (LPITEMIDLIST)pidlT, &iItem);

            ILFree(pidlT);  // In either case simply blow away our generated pidl...
            if (SUCCEEDED(hr))
                return;
        }
    }

    IShellFolder *psf;
    LPCITEMIDLIST pidlChild;
    if (SUCCEEDED(SHBindToIDListParent(pidl, IID_PPV_ARG(IShellFolder, &psf), &pidlChild)))
    {
        BOOL fMatch = FALSE;
        // See if this item matches the filter...
        IFindFilter *pfilter;
        if (SUCCEEDED(GetFindFilter(&pfilter))) 
        {
            fMatch = pfilter->MatchFilter(psf, pidlChild) != 0;
            pfilter->Release();
        }

        psf->Release();

        if (fMatch)
        {
            LPITEMIDLIST pidlT;
            if (S_OK != MapToSearchIDList(pidl, TRUE, &pidlT))
            {
                fMatch = FALSE;

                // The folder has not been added before now...
                TCHAR szPath[MAX_PATH];
                SHGetPathFromIDList(pidl, szPath);
                if (!IsFileInBitBucket(szPath))
                {
                    PathRemoveFileSpec(szPath);

                    LPITEMIDLIST pidlFolder;
                    if (SUCCEEDED(SHParseDisplayName(szPath, NULL, &pidlFolder, 0, NULL)))
                    {
                        int iFolder;
                        hr = AddFolder(pidlFolder, TRUE, &iFolder);
                        if (SUCCEEDED(hr))
                        {
                            fMatch = (S_OK == MapToSearchIDList(pidl, TRUE, &pidlT));
                        }
                        ILFree(pidlFolder);
                    }
                }
            }

            if (fMatch)
            {
                // There are times we get notified twice.  To handle this
                // see if the item is already in our list.  If so punt...

                SetItemsChangedSinceSort();

                UINT iItem;
                if (FAILED(psfv->UpdateObject(pidlT, pidlT, &iItem)))
                {
                    // item not in the view yet... so we need to add it

                    if (SUCCEEDED(GetItemCount((INT *)&iItem))) 
                    {
                        // Normal case would be here to add the object
                        // We need to add this to our dpa and dsa...
                        FIND_ITEM *pesfi;
                        AddPidl(iItem, pidlT, (UINT)-1, &pesfi);
                        if (pesfi)
                            psfv->SetObjectCount(++iItem, SFVSOC_NOSCROLL);
                    }
                }
                ILFree(pidlT);
            }
            else
            {
                ASSERT(NULL == pidlT);
            }
        }
    }
}

void CFindFolder::HandleRMDir(IShellFolderView *psfv, LPCITEMIDLIST pidl)
{
    BOOL fCurrentItemsMayBeImpacted = FALSE;
    FIND_FOLDER_ITEM *pffli;
    INT cItems;
    FIND_ITEM *pesfi;

    // First see which directories are effected...
    GetFolderListItemCount(&cItems);
    for (int iItem = 0; iItem < cItems; iItem++)
    {         
        if (SUCCEEDED(GetFolderListItem(iItem, &pffli)))
        {
            pffli->fDeleteDir = ILIsParent(pidl, &pffli->idl, FALSE);
            fCurrentItemsMayBeImpacted |= pffli->fDeleteDir;
        }
        else 
        {
#ifdef DEBUG
            INT cItem;
            GetFolderListItemCount(&cItem);
            TraceMsg(TF_WARNING, "NULL pffli in _handleRMDir (iItem == %d, ItemCount()==%d)!!!", iItem, cItems);
#endif
        }
    }

    if (fCurrentItemsMayBeImpacted)
    {
        // Now we need to walk through the whole list and remove any entries
        // that are no longer there...
        if (SUCCEEDED(GetItemCount(&iItem))) 
        {
            for (--iItem; iItem >= 0; iItem--)
            {
                if (FAILED(GetItem(iItem, &pesfi)) || pesfi == NULL)
                    continue;

                // See if item may be impacted...
                UINT iFolder = GetFolderIndex(&pesfi->idl);
                if (SUCCEEDED(GetFolderListItem(iFolder, &pffli)) 
                    && pffli->fDeleteDir) 
                {
                    psfv->RemoveObject(&pesfi->idl, (UINT*)&cItems);
                }
            }
        }
    }
}

// export used for Start.Search-> cascade menu

STDAPI_(IContextMenu *) SHFind_InitMenuPopup(HMENU hmenu, HWND hwnd, UINT idCmdFirst, UINT idCmdLast)
{
    IContextMenu * pcm = NULL;
    HKEY hkFind = SHGetShellKey(SHELLKEY_HKLM_EXPLORER, TEXT("FindExtensions"), FALSE);
    if (hkFind) 
    {
        if (SUCCEEDED(CDefFolderMenu_CreateHKeyMenu(hwnd, hkFind, &pcm))) 
        {
            int iItems = GetMenuItemCount(hmenu);
            // nuke all old entries
            while (iItems--) 
            {
                DeleteMenu(hmenu, iItems, MF_BYPOSITION);
            }

            pcm->QueryContextMenu(hmenu, 0, idCmdFirst, idCmdLast, CMF_NODEFAULT|CMF_INCLUDESTATIC|CMF_FINDHACK);
            iItems = GetMenuItemCount(hmenu);
            if (!iItems) 
            {
                TraceMsg(TF_DOCFIND, "no menus in find extension, blowing away context menu");
                pcm->Release();
                pcm = NULL;
            }
        }
        RegCloseKey(hkFind);
    }
    return pcm;
}


void _SetObjectCount(IShellView *psv, int cItems, DWORD dwFlags)
{
    IShellFolderView *psfv;
    if (SUCCEEDED(psv->QueryInterface(IID_PPV_ARG(IShellFolderView, &psfv)))) 
    {
        psfv->SetObjectCount(cItems, dwFlags);
        psfv->Release();
    }
}

typedef struct
{
    PFNLVCOMPARE pfnCompare;
    LPARAM       lParamSort;
} FIND_SORT_INFO;

int CALLBACK _FindCompareItems(void *p1, void *p2, LPARAM lParam)
{
    FIND_SORT_INFO *pfsi = (FIND_SORT_INFO*)lParam;
    return pfsi->pfnCompare(PtrToInt(p1), PtrToInt(p2), pfsi->lParamSort);
}

HRESULT CFindFolderViewCB::OnSortListData(DWORD pv, PFNLVCOMPARE pfnCompare, LPARAM lParamSort)
{
    EnterCriticalSection(&_pff->_csSearch);

    // First mark the focused item in the list so we can find it later...
    FIND_ITEM *pesfi = (FIND_ITEM*)DPA_GetPtr(_pff->_hdpaItems, _iFocused);    // indirect
    if (pesfi)
        pesfi->dwState |= LVIS_FOCUSED;

    int cItems = DPA_GetPtrCount(_pff->_hdpaItems);
    HDPA hdpaForSorting = NULL;
    if (cItems)
    {
        hdpaForSorting = DPA_Create(cItems);
    }

    if (hdpaForSorting)
    {
        for (int i = 0; i< cItems; i++)
        {
            DPA_SetPtr(hdpaForSorting, i, IntToPtr(i));
        }
        // sort out items
        FIND_SORT_INFO fsi;
        fsi.pfnCompare = pfnCompare;
        fsi.lParamSort = lParamSort;

        DPA_Sort(hdpaForSorting, _FindCompareItems, (LPARAM)&fsi);
        for (i = 0; i < cItems; i++)
        {
            int iIndex = PtrToInt(DPA_FastGetPtr(hdpaForSorting, i));

            // Move the items from _hdpaItems to hdpaForSorting in sorted order
            DPA_SetPtr(hdpaForSorting, i, DPA_FastGetPtr(_pff->_hdpaItems, iIndex));
        }
        // Now switch the two HDPA to get the sorted list in the member variable
        DPA_Destroy(_pff->_hdpaItems);
        _pff->_hdpaItems = hdpaForSorting;
    }

    // Now find the focused item and scroll it into place...
    IShellView *psv;
    if (_punkSite && SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IShellView, &psv))))
    {
        int iFocused = -1;

        // Tell the view we need to reshuffle....
        // Gross, this one defaults to invalidate all which for this one is fine...
        _SetObjectCount(psv, cItems, SFVSOC_INVALIDATE_ALL); // Invalidate all

        for (int iEnd = cItems - 1; iEnd >= 0; iEnd--)
        {
            pesfi = (FIND_ITEM*)DPA_GetPtr(_pff->_hdpaItems, iEnd);    // indirect
            if (pesfi && pesfi->dwState & LVIS_FOCUSED)
                iFocused = iEnd;
        }
        // Now handle the focused item...
        if (iFocused != -1)
        {
            _pff->_iGetIDList = iFocused;   // remember the last one we retrieved...
            pesfi = (FIND_ITEM*)DPA_GetPtr(_pff->_hdpaItems, iFocused);    // indirect
            if (pesfi)
            {
                // flags depend on first one and also if selected?
                psv->SelectItem(&pesfi->idl, SVSI_FOCUSED | SVSI_ENSUREVISIBLE | SVSI_SELECT);
                pesfi->dwState &= ~LVIS_FOCUSED;    // don't keep it around to get lost later...
            }
        }

        _iFocused = iFocused;
        _fIgnoreSelChange = FALSE;
        psv->Release();
    }
    LeaveCriticalSection(&_pff->_csSearch);

    return S_OK;
}

HRESULT CFindFolderViewCB::OnMergeMenu(DWORD pv, QCMINFO*lP)
{
    DebugMsg(DM_TRACE, TEXT("sh TR - DF_FSNCallBack DVN_MERGEMENU"));

    UINT idCmdFirst = lP->idCmdFirst;

    UINT idBGMain = 0, idBGPopup = 0;
    _pff->_pfilter->GetFolderMergeMenuIndex(&idBGMain, &idBGPopup);
    CDefFolderMenu_MergeMenu(HINST_THISDLL, 0, idBGPopup, lP);

    // Lets remove some menu items that are not useful to us.
    HMENU hmenu = lP->hmenu;
    DeleteMenu(hmenu, idCmdFirst + SFVIDM_EDIT_PASTE, MF_BYCOMMAND);
    DeleteMenu(hmenu, idCmdFirst + SFVIDM_EDIT_PASTELINK, MF_BYCOMMAND);
    // DeleteMenu(hmenu, idCmdFirst + SFVIDM_EDIT_PASTESPECIAL, MF_BYCOMMAND);

    // This is sortof bogus but if after the merge one of the
    // menus has no items in it, remove the menu.

    for (int i = GetMenuItemCount(hmenu) - 1; i >= 0; i--)
    {
        HMENU hmenuSub = GetSubMenu(hmenu, i);

        if (hmenuSub && (GetMenuItemCount(hmenuSub) == 0))
        {
            DeleteMenu(hmenu, i, MF_BYPOSITION);
        }
    }
    return S_OK;
}

HRESULT CFindFolderViewCB::OnGETWORKINGDIR(DWORD pv, UINT wP, LPTSTR lP)
{
    HRESULT hr = E_FAIL;
    IShellFolderView *psfv;
    if (_punkSite && SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IShellFolderView, &psfv))))
    {   
        LPCITEMIDLIST *ppidls;      // pointer to a list of pidls.
        UINT cpidls = 0;            // Count of pidls that were returned.

        psfv->GetSelectedObjects(&ppidls, &cpidls);
        
        if (cpidls > 0)
        {
            LPITEMIDLIST pidl;
            if (SUCCEEDED(_pff->GetParentsPIDL(ppidls[0], &pidl)))
            {
                SHGetPathFromIDList(pidl, lP);
                ILFree(pidl);
            }
            LocalFree((void *)ppidls);  // const -> non const
            hr = S_OK;
        }
        else
        {
            hr = E_FAIL;
        }
        psfv->Release();
    }
    return hr;
}

HRESULT CFindFolderViewCB::OnGETCOLSAVESTREAM(DWORD pv, WPARAM wP, IStream **ppstm)
{
    return _pff->_pfilter->GetColSaveStream(wP, ppstm);
}

HRESULT CFindFolderViewCB::OnGETITEMIDLIST(DWORD pv, WPARAM iItem, LPITEMIDLIST *ppidl)
{
    FIND_ITEM *pesfi;

    if (SUCCEEDED(_pff->GetItem((int) iItem, &pesfi)) && pesfi)
    {
        *ppidl = &pesfi->idl;   // return alias!
        return S_OK;
    }

    *ppidl = NULL;
    return E_FAIL;
}

// in defviewx.c
STDAPI SHGetIconFromPIDL(IShellFolder *psf, IShellIcon *psi, LPCITEMIDLIST pidl, UINT flags, int *piImage);

HRESULT CFindFolderViewCB::OnGetItemIconIndex(DWORD pv, WPARAM iItem, int *piIcon)
{
    FIND_ITEM *pesfi;

    *piIcon = -1;
    
    if (SUCCEEDED(_pff->GetItem((int) iItem, &pesfi)) && pesfi)
    {
        if (pesfi->iIcon == -1)
        {
            IShellFolder* psf = (IShellFolder*)_pff;
            SHGetIconFromPIDL(psf, NULL, &pesfi->idl, 0, &pesfi->iIcon);
        }

        *piIcon = pesfi->iIcon;
        return S_OK;
    }

    return E_FAIL;
}


HRESULT CFindFolderViewCB::OnSetItemIconOverlay(DWORD pv, WPARAM iItem, int iOverlayIndex)
{
    HRESULT hr = E_FAIL;
    FIND_ITEM *pesfi;
    if (SUCCEEDED(_pff->GetItem((int) iItem, &pesfi)) && pesfi)
    {
        pesfi->dwMask |= ESFITEM_ICONOVERLAYSET;
        pesfi->dwState |= INDEXTOOVERLAYMASK(iOverlayIndex) & LVIS_OVERLAYMASK;
        hr = S_OK;
    }

    return hr;
}

HRESULT CFindFolderViewCB::OnGetItemIconOverlay(DWORD pv, WPARAM iItem, int * piOverlayIndex)
{
    HRESULT hr = E_FAIL;
    *piOverlayIndex = SFV_ICONOVERLAY_DEFAULT;
    FIND_ITEM *pesfi;
    if (SUCCEEDED(_pff->GetItem((int) iItem, &pesfi)) && pesfi)
    {
        if (pesfi->dwMask & ESFITEM_ICONOVERLAYSET)
        {
            *piOverlayIndex = OVERLAYMASKTO1BASEDINDEX(pesfi->dwState & LVIS_OVERLAYMASK);
        }
        else
            *piOverlayIndex = SFV_ICONOVERLAY_UNSET;
        hr = S_OK;
    }

    return hr;
}


HRESULT CFindFolderViewCB::OnSETITEMIDLIST(DWORD pv, WPARAM iItem, LPITEMIDLIST pidl)
{
    FIND_ITEM *pesfi;

    _pff->_iGetIDList = (int) iItem;   // remember the last one we retrieved...    

    if (SUCCEEDED(_pff->GetItem((int) iItem, &pesfi)) && pesfi)
    {
        FIND_ITEM *pesfiNew;
        
        if (SUCCEEDED(_pff->AddPidl((int) iItem, pidl, 0, &pesfiNew) && pesfiNew)) 
        {
            pesfiNew->dwState = pesfi->dwState;
            LocalFree((HLOCAL)pesfi);   // Free the old one...
        }
        return S_OK;
    }

    return E_FAIL;
}

BOOL DF_ILIsEqual(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
{
    BOOL bRet = (pidl1 == pidl2);

    if (!bRet)
    {
        PCHIDDENDOCFINDDATA phdfd1 = (PCHIDDENDOCFINDDATA) ILFindHiddenID(pidl1, IDLHID_DOCFINDDATA);
        PCHIDDENDOCFINDDATA phdfd2 = (PCHIDDENDOCFINDDATA) ILFindHiddenID(pidl2, IDLHID_DOCFINDDATA);

        if (phdfd1 && phdfd2)
            bRet = (phdfd1->iFolder == phdfd2->iFolder) && ILIsEqual(pidl1, pidl2);
    }
    return bRet;
}

HRESULT CFindFolderViewCB::OnGetIndexForItemIDList(DWORD pv, int * piItem, LPITEMIDLIST pidl)
{
    int cItems;

    // Try to short circuit searching for pidls...
    if (SUCCEEDED(_pff->GetItemCount(&cItems)) && _pff->_iGetIDList < cItems)
    {
        FIND_ITEM *pesfi;
                
        if (SUCCEEDED(_pff->GetItem(_pff->_iGetIDList, &pesfi)) && pesfi)
        {
            if (DF_ILIsEqual(&pesfi->idl, pidl))
            {
                // Yep it was ours so return the index quickly..
                *piItem = _pff->_iGetIDList;
                return S_OK;
            }
        }
    }

    // Otherwise let it search the old fashion way...
    return E_FAIL;
}

HRESULT CFindFolderViewCB::OnDeleteItem(DWORD pv, LPCITEMIDLIST pidl)
{
    // We simply need to remove this item from our list.  The
    // underlying listview will decrement the count on their end...
    FIND_ITEM *pesfi;
    int iItem;
    int cItems;
    BOOL bFound;

    if (!pidl)
    {
        _pff->SetAsyncEnum(NULL);
        return S_OK;     // special case telling us all items deleted...
    }

    bFound = FALSE;
    
    if (SUCCEEDED(_pff->GetItem(_pff->_iGetIDList, &pesfi)) 
        && pesfi
        && (DF_ILIsEqual(&pesfi->idl, pidl)))
    {
        iItem = _pff->_iGetIDList;
        bFound = TRUE;
    }
    else
    {
        if (SUCCEEDED(_pff->GetItemCount(&cItems))) 
        {
            for (iItem = 0; iItem < cItems; iItem++)
            {                
                if (SUCCEEDED(_pff->GetItem(iItem, &pesfi)) && pesfi && (DF_ILIsEqual(&pesfi->idl, pidl)))
                {
                    bFound = TRUE;
                    break;
                }
            }
        }
    }

    if (bFound)
    {
        _pff->DeleteItem(iItem);
    }

    return S_OK;
}

HRESULT CFindFolderViewCB::OnODFindItem(DWORD pv, int * piItem, NM_FINDITEM* pnmfi)
{
    // We have to do the subsearch ourself to find the correct item...
    // As the listview has no information saved in it...

    int iItem = pnmfi->iStart;
    int cItem;
    UINT flags = pnmfi->lvfi.flags;

    if (FAILED(_pff->GetItemCount(&cItem))) 
        return E_FAIL;

    if ((flags & LVFI_STRING) == 0)
        return E_FAIL;      // Not sure what type of search this is...

    int cbString = lstrlen(pnmfi->lvfi.psz);

    for (int j = cItem; j-- != 0;)
    {
        if (iItem >= cItem)
        {
            if (flags & LVFI_WRAP)
                iItem = 0;
            else
                break;
        }

        // Now we need to get the Display name for this item...
        FIND_ITEM *pesfi;
        TCHAR szPath[MAX_PATH];
        IShellFolder* psf = (IShellFolder*)_pff;

        if (SUCCEEDED(_pff->GetItem(iItem, &pesfi)) && pesfi && 
            SUCCEEDED(DisplayNameOf(psf, &pesfi->idl, NULL, szPath, ARRAYSIZE(szPath))))
        {
            if (flags & (LVFI_PARTIAL|LVFI_SUBSTRING))
            {
                if (CompareString(LOCALE_SYSTEM_DEFAULT, NORM_IGNORECASE,
                        pnmfi->lvfi.psz, cbString, szPath, cbString) == 2)
                {
                    *piItem = iItem;
                    return S_OK;
                }
            }
            else if (lstrcmpi(pnmfi->lvfi.psz, szPath) == 0)
            {
                *piItem = iItem;
                return S_OK;
            }
        }

        ++iItem;
    }
    return E_FAIL;
}

HRESULT CFindFolderViewCB::OnSelChange(DWORD pv, UINT wPl, UINT wPh, SFVM_SELCHANGE_DATA *lP)
{
    // Try to remember which item is focused...
    if (lP->uNewState & LVIS_FOCUSED)
        _iFocused = wPh;

    return S_OK;
}

HRESULT CFindFolderViewCB::OnSetEmptyText(DWORD pv, UINT res, LPCTSTR pszText)
{
    if (pszText && 0 == lstrcmp(_szEmptyText, pszText))
        return S_OK;

    lstrcpyn(_szEmptyText, pszText ? pszText : TEXT(""), ARRAYSIZE(_szEmptyText));

    HWND hwndLV = ListviewFromViewUnk(_punkSite);
    if (hwndLV)
        SendMessage(hwndLV, LVM_RESETEMPTYTEXT, 0, 0);
    return S_OK;
}

HRESULT CFindFolderViewCB::OnGetEmptyText(DWORD pv, UINT cchTextMax, LPTSTR pszText)
{
    if (_szEmptyText[0])
    {
        lstrcpyn(pszText, _szEmptyText, cchTextMax);
    }
    else
    {
        LoadString(HINST_THISDLL, IDS_FINDVIEWEMPTYINIT, pszText, cchTextMax);
    }
    return S_OK;
}

HRESULT CFindFolderViewCB::OnReArrange(DWORD pv, LPARAM lparam)
{   
    UINT nCol = (UINT)lparam;

    // See if there is any controller object registered that may want to take over this...
    // if we are in a mixed query and we have already fetched the async items, simply sort
    // the dpa's...
    IFindEnum *pidfenum;
    if (S_OK == _pff->GetAsyncEnum(&pidfenum))
    {
        if (!((pidfenum->FQueryIsAsync() == DF_QUERYISMIXED) && _pff->_fAllAsyncItemsCached))
        {
            if (_pff->_pfcn)
            {
                // if they return S_FALSE it implies that they handled it and they do not
                // want the default processing to happen...
                if (_pff->_pfcn->DoSortOnColumn(nCol, _iColSort == nCol) == S_FALSE)
                {
                    _iColSort = nCol;
                    return S_OK;
                }
            }
            else 
            {
                // If we are running in the ROWSET way, we may want to have the ROWSET do the work...
                // pass one we spawn off a new search with the right column sorted
                if (_iColSort != nCol)
                {
                    _iColSort = nCol;      
                }
    
                // Warning the call above may release our AsyncEnum and generate a new one so
                // Don't rely on it's existence here...
                return S_OK;
            }
        }

        // we must pull in all the results from ci
        if (pidfenum->FQueryIsAsync() && !_pff->_fAllAsyncItemsCached)
            _pff->CacheAllAsyncItems();

#ifdef DEBUG
#define MAX_LISTVIEWITEMS  (100000000 & ~0xFFFF)
#define SANE_ITEMCOUNT(c)  ((int)min(c, MAX_LISTVIEWITEMS))
        if (pidfenum->FQueryIsAsync())
        {
            ASSERT(DPA_GetPtrCount(_pff->_hdpaItems) >= SANE_ITEMCOUNT(_pff->_cAsyncItems));
            for (int i = 0; i < SANE_ITEMCOUNT(_pff->_cAsyncItems); i++)
            {
                FIND_ITEM *pesfi = (FIND_ITEM *)DPA_GetPtr(_pff->_hdpaItems, i);

                ASSERT(pesfi);
                if (!pesfi)
                {
                    ASSERT(SUCCEEDED(_pff->GetItem(i, &pesfi)));
                }
            }
        }
#endif
    }

    // Use the common sort.
    return E_FAIL;
}

HRESULT CFindFolderViewCB::OnWindowCreated(DWORD pv, HWND hwnd)
{
    _ProfferService(TRUE);  // register our service w/ top level container
    return S_OK;
}

HRESULT CFindFolderViewCB::_ProfferService(BOOL bProffer)
{
    HRESULT hr = E_FAIL;

    if (bProffer)
    {
        //  shouldn't be redundantly registering our service
        ASSERT(NULL == _pps);
        ASSERT(-1 == _dwServiceCookie);
            
        IProfferService* pps;
        hr = IUnknown_QueryService(_punkSite, SID_STopLevelBrowser, IID_PPV_ARG(IProfferService, &pps));
        if (SUCCEEDED(hr))
        {
            hr = pps->ProfferService(SID_DocFindFolder, this, &_dwServiceCookie);
            if (SUCCEEDED(hr))
            {
                pps->AddRef();
                _pps = pps;
            }
            pps->Release();
        }
    }
    else
    {
        if (NULL == _pps)
        {
            hr = S_OK;
        }
        else
        {
            hr = _pps->RevokeService(_dwServiceCookie);
            if (SUCCEEDED(hr))
            {
                ATOMICRELEASE(_pps);
                _dwServiceCookie = -1;
            }
        }
    }
    return hr;
}

HRESULT CFindFolderViewCB::OnWindowDestroy(DWORD pv, HWND wP)
{
    _ProfferService(FALSE); // unregister our service w/ top level container

    if (_pff->_pfcn)
        _pff->_pfcn->StopSearch();

    // The search may have a circular set of pointers.  So call the 
    // delete items and folders here to remove these back references...
    _pff->ClearItemList();
    _pff->ClearFolderList();

    IFindControllerNotify *pfcn;
    if (_pff->GetControllerNotifyObject(&pfcn) == S_OK)
    {
        pfcn->ViewDestroyed();
        pfcn->Release();
    }
    return S_OK;
}

HRESULT CFindFolderViewCB::OnIsOwnerData(DWORD pv, DWORD *pdwFlags)
{
    *pdwFlags |= FWF_OWNERDATA; // we want virtual defview support
    return S_OK;
}

HRESULT CFindFolderViewCB::OnGetODRangeObject(DWORD pv, WPARAM wWhich, ILVRange **plvr)
{
    HRESULT hr = E_FAIL;
    switch (wWhich)
    {
    case LVSR_SELECTION:
        hr = _pff->_dflvrSel.QueryInterface(IID_PPV_ARG(ILVRange, plvr));
        break;
    case LVSR_CUT:
        hr = _pff->_dflvrCut.QueryInterface(IID_PPV_ARG(ILVRange, plvr));
        break;
    }
    return hr;
}

HRESULT CFindFolderViewCB::OnODCacheHint(DWORD pv, NMLVCACHEHINT* pnmlvc)
{
    // The listview is giving us a hint of the items it is about to do something in a range
    // so make sure we have pidls for each of the items in the range...
    int iTo;
    
    _pff->GetItemCount(&iTo);
    if (iTo >= pnmlvc->iTo)
        iTo = pnmlvc->iTo;
    else
        iTo--;

    for (int i = pnmlvc->iFrom; i <= iTo; i++)
    {
        FIND_ITEM *pesfi;
        if (FAILED(_pff->GetItem(i, &pesfi)))
            break;
    }

    return S_OK;
}

HRESULT CFindFolderViewCB::OnDEFVIEWMODE(DWORD pv, FOLDERVIEWMODE*lP)
{
    *lP = FVM_DETAILS;  // match the advanced mode of SC (+ Win2K parity)
    return S_OK;
}

HRESULT CFindFolderViewCB::OnGetWebViewLayout(DWORD pv, UINT uViewMode, SFVM_WEBVIEW_LAYOUT_DATA* pData)
{
    ZeroMemory(pData, sizeof(*pData));
    pData->dwLayout = SFVMWVL_DETAILS | SFVMWVL_FILES;
    return S_OK;
}

HRESULT CFindFolderViewCB::_OnOpenContainingFolder(IUnknown* pv, IShellItemArray *psiItemArray, IBindCtx *pbc)
{
    CFindFolderViewCB* pThis = (CFindFolderViewCB*)(void*)pv;
    return pThis->_pff->OpenContainingFolder(pThis->_punkSite);
}

const WVTASKITEM c_FindTaskHeader = WVTI_HEADER(L"shell32.dll", IDS_HEADER_SEARCH, IDS_HEADER_FIND_TT);
const WVTASKITEM c_FindTaskList[] =
{
    WVTI_ENTRY_TITLE(CLSID_NULL, L"shell32.dll", IDS_TASK_OPENCONTAININGFOLDER, IDS_TASK_OPENCONTAININGFOLDER, 0, IDS_TASK_OPENCONTAININGFOLDER_TT, IDI_TASK_OPENCONTAININGFOLDER, NULL, CFindFolderViewCB::_OnOpenContainingFolder),
};

HRESULT CFindFolderViewCB::OnGetWebViewContent(DWORD pv, SFVM_WEBVIEW_CONTENT_DATA* pData)
{
    ZeroMemory(pData, sizeof(*pData));

    Create_IUIElement(&c_FindTaskHeader, &(pData->pSpecialTaskHeader));

    LPCTSTR rgCSIDLs[] = { MAKEINTRESOURCE(CSIDL_DRIVES), MAKEINTRESOURCE(CSIDL_PERSONAL), MAKEINTRESOURCE(CSIDL_COMMON_DOCUMENTS), MAKEINTRESOURCE(CSIDL_NETWORK) };
    CreateIEnumIDListOnCSIDLs(_pidl, rgCSIDLs, ARRAYSIZE(rgCSIDLs), &pData->penumOtherPlaces);
    return S_OK;
}

HRESULT CFindFolderViewCB::OnGetWebViewTasks(DWORD pv, SFVM_WEBVIEW_TASKSECTION_DATA* pTasks)
{
    ZeroMemory(pTasks, sizeof(*pTasks));

    Create_IEnumUICommand((IUnknown*)(void*)this, c_FindTaskList, ARRAYSIZE(c_FindTaskList), &pTasks->penumSpecialTasks);

    return S_OK;
}

HRESULT CFindFolderViewCB::OnGetWebViewTheme(DWORD pv, SFVM_WEBVIEW_THEME_DATA* pTheme)
{
    ZeroMemory(pTheme, sizeof(*pTheme));

    pTheme->pszThemeID = L"search";
    
    return S_OK;
}

HRESULT CFindFolderViewCB::OnGetIPersistHistory(DWORD pv, IPersistHistory **ppph)
{
    // If they call us with ppph == NULL they simply want to know if we support
    // the history so return S_OK;
    if (ppph == NULL)
        return S_OK;

    // get the persist history from us and we hold folder and view objects
    *ppph = NULL;

    CFindPersistHistory *pdfph = new CFindPersistHistory();
    if (!pdfph)
        return E_OUTOFMEMORY;

    HRESULT hr = pdfph->QueryInterface(IID_PPV_ARG(IPersistHistory, ppph));
    pdfph->Release();
    return hr;
}

HRESULT CFindFolderViewCB::OnRefresh(DWORD pv, BOOL fPreRefresh)
{
    EnterCriticalSection(&_pff->_csSearch);

    _pff->_fInRefresh = BOOLIFY(fPreRefresh);
    // If we have old results tell defview the new count now...
    if (!fPreRefresh && _pff->_hdpaItems)
    {
        IShellFolderView *psfv;
        UINT cItems = DPA_GetPtrCount(_pff->_hdpaItems);
        if (cItems && _punkSite && SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IShellFolderView, &psfv))))
        {   
            psfv->SetObjectCount(cItems, SFVSOC_NOSCROLL);
            psfv->Release();
        }
    }
    LeaveCriticalSection(&_pff->_csSearch);
    return S_OK;
}

HRESULT CFindFolderViewCB::OnGetHelpTopic(DWORD pv, SFVM_HELPTOPIC_DATA *phtd)
{
    if (IsOS(OS_ANYSERVER))
    {
        StrCpyW(phtd->wszHelpFile, L"find.chm");
    }
    else
    {
        StrCpyW(phtd->wszHelpTopic, L"hcp://services/subsite?node=Unmapped/Search");
    }
    return S_OK;
}

STDMETHODIMP CFindFolderViewCB::RealMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    HANDLE_MSG(0, SFVM_MERGEMENU, OnMergeMenu);
    HANDLE_MSG(0, SFVM_GETWORKINGDIR, OnGETWORKINGDIR);
    HANDLE_MSG(0, SFVM_GETCOLSAVESTREAM, OnGETCOLSAVESTREAM);
    HANDLE_MSG(0, SFVM_GETITEMIDLIST, OnGETITEMIDLIST);
    HANDLE_MSG(0, SFVM_SETITEMIDLIST, OnSETITEMIDLIST);
    HANDLE_MSG(0, SFVM_SELCHANGE, OnSelChange);
    HANDLE_MSG(0, SFVM_INDEXOFITEMIDLIST, OnGetIndexForItemIDList);
    HANDLE_MSG(0, SFVM_DELETEITEM, OnDeleteItem);
    HANDLE_MSG(0, SFVM_ODFINDITEM, OnODFindItem);
    HANDLE_MSG(0, SFVM_ARRANGE, OnReArrange);
    HANDLE_MSG(0, SFVM_GETEMPTYTEXT, OnGetEmptyText);
    HANDLE_MSG(0, SFVM_SETEMPTYTEXT, OnSetEmptyText);
    HANDLE_MSG(0, SFVM_GETITEMICONINDEX, OnGetItemIconIndex);
    HANDLE_MSG(0, SFVM_SETICONOVERLAY, OnSetItemIconOverlay);
    HANDLE_MSG(0, SFVM_GETICONOVERLAY, OnGetItemIconOverlay);
    HANDLE_MSG(0, SFVM_FOLDERSETTINGSFLAGS, OnIsOwnerData);
    HANDLE_MSG(0, SFVM_WINDOWCREATED, OnWindowCreated);
    HANDLE_MSG(0, SFVM_WINDOWDESTROY, OnWindowDestroy);
    HANDLE_MSG(0, SFVM_GETODRANGEOBJECT, OnGetODRangeObject);
    HANDLE_MSG(0, SFVM_ODCACHEHINT, OnODCacheHint);
    HANDLE_MSG(0, SFVM_DEFVIEWMODE, OnDEFVIEWMODE);
    HANDLE_MSG(0, SFVM_GETWEBVIEWLAYOUT, OnGetWebViewLayout);
    HANDLE_MSG(0, SFVM_GETWEBVIEWCONTENT, OnGetWebViewContent);
    HANDLE_MSG(0, SFVM_GETWEBVIEWTASKS, OnGetWebViewTasks);
    HANDLE_MSG(0, SFVM_GETWEBVIEWTHEME, OnGetWebViewTheme);
    HANDLE_MSG(0, SFVM_GETIPERSISTHISTORY, OnGetIPersistHistory);
    HANDLE_MSG(0, SFVM_REFRESH, OnRefresh);
    HANDLE_MSG(0, SFVM_GETHELPTOPIC, OnGetHelpTopic);
    HANDLE_MSG(0, SFVM_SORTLISTDATA, OnSortListData);

    default:
        return E_FAIL;
    }

    return S_OK;
}

CFindFolderViewCB::CFindFolderViewCB(CFindFolder* pff) : 
    CBaseShellFolderViewCB(pff->_pidl, 0), _pff(pff), _fIgnoreSelChange(FALSE),
    _iColSort((UINT)-1), _iFocused((UINT)-1), _cSelected(0), _pps(NULL), _dwServiceCookie(-1)
{
    _pff->AddRef();
}

CFindFolderViewCB::~CFindFolderViewCB()
{
    _pff->Release();
    ASSERT(NULL == _pps);
    ASSERT(_dwServiceCookie == -1);
}

// give the find command code access to defview via this QS that we proffered

HRESULT CFindFolderViewCB::QueryService(REFGUID guidService, REFIID riid, void **ppv) 
{ 
    HRESULT hr = E_NOTIMPL;
    *ppv = NULL;
    if (guidService == SID_DocFindFolder)
    {
        hr = IUnknown_QueryService(_punkSite, SID_DefView, riid, ppv);
    }
    return hr;
}

CFindPersistHistory::CFindPersistHistory()
{
}

STDAPI CFindPersistHistory_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv)
{
    HRESULT hr;
    CFindPersistHistory *pdfph = new CFindPersistHistory();
    if (pdfph)
    {
        hr = pdfph->QueryInterface(riid, ppv);
        pdfph->Release();
    }
    else
    {
        *ppv = NULL;
        hr = E_OUTOFMEMORY;
    }
    return hr;    
}


// Functions to support persisting the document into the history stream...
STDMETHODIMP CFindPersistHistory::GetClassID(CLSID *pClassID)
{
    *pClassID = CLSID_DocFindPersistHistory;
    return S_OK;
}

IFindFolder *CFindPersistHistory::_GetDocFindFolder()
{
    IFindFolder *pdff = NULL;

    // the _punksite is to the defview so we can simply QI for frame...
    IFolderView *pfv;
    if (SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IFolderView, &pfv)))) 
    {
        pfv->GetFolder(IID_PPV_ARG(IFindFolder, &pdff));
        pfv->Release();
    }

    return pdff;
}

STDMETHODIMP CFindPersistHistory::LoadHistory(IStream *pstm, IBindCtx *pbc)
{
    int cItems = 0;
    IFindFolder *pdff = _GetDocFindFolder();
    if (pdff)
    {
        pdff->RestoreFolderList(pstm);
        pdff->RestoreItemList(pstm, &cItems);
        pdff->Release();
    }

    IShellFolderView *psfv;
    if (_punkSite && SUCCEEDED(_punkSite->QueryInterface(IID_PPV_ARG(IShellFolderView, &psfv))))
    {   
        psfv->SetObjectCount(cItems, SFVSOC_NOSCROLL);
        psfv->Release();
    }

    // call our base class to allow it to restore it's stuff as well.
    return CDefViewPersistHistory::LoadHistory(pstm, pbc);
}


STDMETHODIMP CFindPersistHistory::SaveHistory(IStream *pstm)
{
    IFindFolder *pdff = _GetDocFindFolder();
    if (pdff)
    {
        pdff->SaveFolderList(pstm);       
        pdff->SaveItemList(pstm);       
        pdff->Release();
    }
    // Let base class save out as well
    return CDefViewPersistHistory::SaveHistory(pstm);
}

// use to manage the selection states for an owner data listview...

STDMETHODIMP_(ULONG) CFindLVRange::AddRef()
{
    return _pff->AddRef();
}
STDMETHODIMP_(ULONG) CFindLVRange::Release()
{ 
    return _pff->Release();
}

STDMETHODIMP CFindLVRange::QueryInterface(REFIID riid, void **ppv)
{
    static const QITAB qit[] = {
        QITABENT(CFindLVRange, ILVRange),          // IID_ILVRange
        { 0 },
    };
    return QISearch(this, qit, riid, ppv);
}

// ILVRange methods
STDMETHODIMP CFindLVRange::IncludeRange(LONG iBegin, LONG iEnd)
{
    // Including the range must load the elements as we need the object ptr...
    FIND_ITEM *pesfi;
    int  iTotal;

    _pff->GetItemCount(&iTotal);
    if (iEnd > iTotal)
        iEnd = iTotal-1;
        
    for (long i = iBegin; i <= iEnd;i++)
    {
        if (SUCCEEDED(_pff->GetItem(i, &pesfi)) && pesfi)
        {
            if ((pesfi->dwState & _dwMask) == 0)
            {
                _cIncluded++;
                pesfi->dwState |= _dwMask;
            }
        }
    }

    return S_OK;
}

STDMETHODIMP CFindLVRange::ExcludeRange(LONG iBegin, LONG iEnd)    
{
    // Excluding the range is OK to not load the elements as this would be to deslect all...

    EnterCriticalSection(&_pff->_csSearch);
    if (iEnd >= DPA_GetPtrCount(_pff->_hdpaItems))
        iEnd = DPA_GetPtrCount(_pff->_hdpaItems) - 1;

    for (long i = iBegin; i <= iEnd; i++)
    {
        FIND_ITEM *pesfi = (FIND_ITEM*)DPA_FastGetPtr(_pff->_hdpaItems, i);
        if (pesfi)
        {
            if (pesfi->dwState & _dwMask)
            {
                _cIncluded--;
                pesfi->dwState &= ~_dwMask;
            }
        }
    }
    LeaveCriticalSection(&_pff->_csSearch);

    return S_OK;
}

STDMETHODIMP CFindLVRange::InvertRange(LONG iBegin, LONG iEnd)
{
    // Including the range must load the elements as we need the object ptr...
    int iTotal;

    _pff->GetItemCount(&iTotal);
    if (iEnd > iTotal)
        iEnd = iTotal-1;

    for (long i = iBegin; i <= iEnd;i++)
    {
        FIND_ITEM *pesfi;
        if (SUCCEEDED(_pff->GetItem(i, &pesfi)) && pesfi)
        {
            if ((pesfi->dwState & _dwMask) == 0)
            {
                _cIncluded++;
                pesfi->dwState |= _dwMask;
            }
            else
            {
                _cIncluded--;
                pesfi->dwState &= ~_dwMask;
            }
        }
    }

    return S_OK;
}

STDMETHODIMP CFindLVRange::InsertItem(LONG iItem)
{
    // We already maintain the list anyway...
    return S_OK;
}

STDMETHODIMP CFindLVRange::RemoveItem(LONG iItem)
{
    // We maintain the list so don't do anything...
    return S_OK;
}

STDMETHODIMP CFindLVRange::Clear()
{
    // If there are things selected, need to unselect them now...
    if (_cIncluded)
        ExcludeRange(0, LONG_MAX);

    _cIncluded = 0;
    _pff->ClearSaveStateList();
    return S_OK;
}

STDMETHODIMP CFindLVRange::IsSelected(LONG iItem)
{
    // Don't force the items to be generated if they were not before...
    HRESULT hr = S_FALSE;

    EnterCriticalSection(&_pff->_csSearch);
    FIND_ITEM *pesfi = (FIND_ITEM*)DPA_GetPtr(_pff->_hdpaItems, iItem);
    if (pesfi)
        hr = pesfi->dwState & _dwMask ? S_OK : S_FALSE;
    LeaveCriticalSection(&_pff->_csSearch);

    // Assume not selected if we don't have the item yet...
    return hr;
}

STDMETHODIMP CFindLVRange::IsEmpty()
{
    return _cIncluded ? S_FALSE : S_OK;
}

STDMETHODIMP CFindLVRange::NextSelected(LONG iItem, LONG *piItem)
{
    EnterCriticalSection(&_pff->_csSearch);
    LONG cItems = DPA_GetPtrCount(_pff->_hdpaItems);

    while (iItem < cItems)
    {
        FIND_ITEM *pesfi = (FIND_ITEM*)DPA_GetPtr(_pff->_hdpaItems, iItem);
        if (pesfi && (pesfi->dwState & _dwMask))
        {
            *piItem = iItem;
            LeaveCriticalSection(&_pff->_csSearch);
            return S_OK;
        }
        iItem++;
    }
    LeaveCriticalSection(&_pff->_csSearch);
    *piItem = -1;
    return S_FALSE;
}

STDMETHODIMP CFindLVRange::NextUnSelected(LONG iItem, LONG *piItem)
{
    EnterCriticalSection(&_pff->_csSearch);
    LONG cItems = DPA_GetPtrCount(_pff->_hdpaItems);

    while (iItem < cItems)
    {
        FIND_ITEM *pesfi = (FIND_ITEM*)DPA_GetPtr(_pff->_hdpaItems, iItem);
        if (!pesfi || ((pesfi->dwState & _dwMask) == 0))
        {
            *piItem = iItem;
            LeaveCriticalSection(&_pff->_csSearch);
            return S_OK;
        }
        iItem++;
    }
    LeaveCriticalSection(&_pff->_csSearch);
    *piItem = -1;
    return S_FALSE;
}

STDMETHODIMP CFindLVRange::CountIncluded(LONG *pcIncluded)
{
    *pcIncluded = _cIncluded;

    // Sortof Gross, but if looking at selection then also include the list of items
    // that are selected in our save list...
    if (_dwMask & LVIS_SELECTED)
        *pcIncluded += _pff->_cSaveStateSelected;
    return S_OK;
}


// Define OleDBEnum translation structure...
typedef struct _dfodbet         // DFET for short
{
    struct _dfodbet *pdfetNext;
    LPWSTR  pwszFrom;
    int     cbFrom;
    LPWSTR  pwszTo;
} DFODBET;


class CContentIndexEnum : public IFindEnum, public IShellService
{
public:
    // IUnknown
    STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
    STDMETHODIMP_(ULONG) AddRef(void);
    STDMETHODIMP_(ULONG) Release(void);

    // IFindEnum
    STDMETHODIMP Next(LPITEMIDLIST *ppidl, int *pcObjectSearched, int *pcFoldersSearched, BOOL *pfContinue, int *pState);
    STDMETHODIMP Skip(int celt);
    STDMETHODIMP Reset();
    STDMETHODIMP StopSearch();
    STDMETHODIMP_(BOOL) FQueryIsAsync();
    STDMETHODIMP GetAsyncCount(DBCOUNTITEM *pdwTotalAsync, int *pnPercentComplete, BOOL *pfQueryDone);
    STDMETHODIMP GetItemIDList(UINT iItem, LPITEMIDLIST *ppidl);
    STDMETHODIMP GetItemID(UINT iItem, DWORD *puWorkID);
    STDMETHODIMP SortOnColumn(UINT iCOl, BOOL fAscending);

    // IShellService
    STDMETHODIMP SetOwner(IUnknown* punkOwner);
    
    CContentIndexEnum(IFindFilter *pfilter, IFindFolder *pff, DWORD grfFlags, 
                      int iColSort,  LPTSTR pszProgressText, IRowsetWatchNotify *prwn);

    HRESULT DoQuery(LPWSTR *apwszPaths, UINT *pcPaths);

private:
    ~CContentIndexEnum();

    void HandleWatchNotify(DBWATCHNOTIFY eChangeReason);
    HRESULT _BuildAndSetCommandTree(int iCol, BOOL fReverse);
    HRESULT _SetCmdProp(ICommand *pCommand);
    HRESULT _MapColumns(IUnknown *punk, DBORDINAL cCols, DBBINDING *pBindings, const DBID * pDbCols, HACCESSOR &hAccessor);
    void _ReleaseAccessor();
    HRESULT _CacheRowSet(UINT iItem);
    BOOL _TranslateFolder(LPCWSTR pszParent, LPWSTR pszResult);
    void _ClearFolderState();

    LONG _cRef;
    IFindFilter *_pfilter;
    IRowsetWatchNotify *_prwn;
    IFindFolder *_pff;
    int _iColSort; 
    DWORD _grfFlags;
    DWORD _grfWarnings;
    LPTSTR _pszProgressText;

    TCHAR _szCurrentDir[MAX_PATH];
    IShellFolder *_psfCurrentDir;
    LPITEMIDLIST _pidlFolder;
    int _iFolder;

    HRESULT _hrCurrent;
    ICommand *_pCommand;
    IRowsetLocate *_pRowset;
    IRowsetAsynch *_pRowsetAsync;
    HACCESSOR   _hAccessor;
    HACCESSOR   _hAccessorWorkID;
    HROW        _ahrow[100];            // Cache 100 hrows out for now
    UINT        _ihrowFirst;            // The index of which row is cached out first
    DBCOUNTITEM _cRows;                 // number of hrows in _ahrow
    DFODBET     *_pdfetFirst;           // Name translation list.
};

STDAPI CreateOleDBEnum(IFindFilter *pfilter, IShellFolder *psf,
    LPWSTR *apwszPaths, UINT *pcPaths, DWORD grfFlags, int iColSort,
    LPTSTR pszProgressText, IRowsetWatchNotify *prwn, IFindEnum **ppdfenum)
{
    *ppdfenum = NULL;
    HRESULT hr = E_OUTOFMEMORY;

    IFindFolder *pff;
    psf->QueryInterface(IID_PPV_ARG(IFindFolder, &pff));

    CContentIndexEnum* pdfenum = new CContentIndexEnum(pfilter, pff, grfFlags, iColSort, pszProgressText, prwn);

    if (pdfenum)
    {
        hr = pdfenum->DoQuery(apwszPaths, pcPaths);
        if (hr == S_OK)       // We only continue to use this if query returne S_OK...
            *ppdfenum = (IFindEnum*)pdfenum;
        else
        {
            pdfenum->Release();     // release the memory we allocated
        }
    }

    if (pff)
        pff->Release();
    
    return hr;
}

const DBID c_aDbCols[] =
{
    {{PSGUID_STORAGE}, DBKIND_GUID_PROPID, {(LPOLESTR)(ULONG_PTR)(ULONG)PID_STG_NAME}},
    {{PSGUID_STORAGE}, DBKIND_GUID_PROPID, {(LPOLESTR)(ULONG_PTR)(ULONG)PID_STG_PATH}},
    {{PSGUID_STORAGE}, DBKIND_GUID_PROPID, {(LPOLESTR)(ULONG_PTR)(ULONG)PID_STG_ATTRIBUTES}},
    {{PSGUID_STORAGE}, DBKIND_GUID_PROPID, {(LPOLESTR)(ULONG_PTR)(ULONG)PID_STG_SIZE}},
    {{PSGUID_STORAGE}, DBKIND_GUID_PROPID, {(LPOLESTR)(ULONG_PTR)(ULONG)PID_STG_WRITETIME}},
    {{PSGUID_QUERY_D}, DBKIND_GUID_PROPID, {(LPOLESTR)                  PROPID_QUERY_RANK}},
};

const DBID c_aDbWorkIDCols[] =
{
    {{PSGUID_QUERY_D}, DBKIND_GUID_PROPID, {(LPOLESTR)PROPID_QUERY_WORKID}}
};

const LPCWSTR c_awszColSortNames[] = {
    L"FileName[a],Path[a]", 
    L"Path[a],FileName[a]", 
    L"Size[a]", 
    NULL, 
    L"Write[a]", 
    L"Rank[d]"
};

const ULONG c_cDbCols = ARRAYSIZE(c_aDbCols);
const DBID c_dbcolNull = { {0,0,0,{0,0,0,0,0,0,0,0}},DBKIND_GUID_PROPID,0};
const GUID c_guidQueryExt = DBPROPSET_QUERYEXT;
const GUID c_guidRowsetProps = {0xc8b522be,0x5cf3,0x11ce,{0xad,0xe5,0x00,0xaa,0x00,0x44,0x77,0x3d}}; 

CContentIndexEnum::CContentIndexEnum(IFindFilter *pfilter, IFindFolder *pff,
    DWORD grfFlags, int iColSort,  LPTSTR pszProgressText, IRowsetWatchNotify *prwn) :
    _cRef(1), _ihrowFirst((UINT)-1), _pfilter(pfilter),
    _pff(pff), _prwn(prwn), _grfFlags(grfFlags),
    _grfWarnings(DFW_DEFAULT), _iColSort(iColSort), _pszProgressText(pszProgressText)
{
    _szCurrentDir[0] = 0;

    ASSERT(_pRowset == 0);
    ASSERT(_pRowsetAsync == 0);
    ASSERT(_pCommand == 0);
    ASSERT(_hAccessor == 0);
    ASSERT(_hAccessorWorkID ==0);
    ASSERT(_cRows == 0);

    if (_pfilter)
    {
        _pfilter->AddRef();
        _pfilter->GetWarningFlags(&_grfWarnings);
    }
        
    if (_pff)              
        _pff->AddRef();

    if (_prwn)
        _prwn->AddRef();
}

void CContentIndexEnum::_ClearFolderState()
{
    ATOMICRELEASE(_psfCurrentDir);
    ILFree(_pidlFolder);
    _pidlFolder = NULL;
    _iFolder = -1;
    _szCurrentDir[0] = 0;
}

CContentIndexEnum::~CContentIndexEnum()
{
    ATOMICRELEASE(_pfilter);
    ATOMICRELEASE(_pff);
    ATOMICRELEASE(_prwn);

    _ClearFolderState();
        
    if (_pRowset)
    {
        ATOMICRELEASE(_pRowsetAsync);

        // Release any cached rows.
       _CacheRowSet((UINT)-1);
          
        if (_hAccessor || _hAccessorWorkID)
            _ReleaseAccessor();

        _pRowset->Release();
    }

    ATOMICRELEASE(_pCommand);

    // Release any name translations we may have allocated.
    DFODBET *pdfet = _pdfetFirst;
    while (pdfet)
    {
        DFODBET *pdfetT = pdfet;
        pdfet = pdfet->pdfetNext;      // First setup to look at the next item before we free stuff...
        LocalFree((HLOCAL)pdfetT->pwszFrom);
        LocalFree((HLOCAL)pdfetT->pwszTo);
        LocalFree((HLOCAL)pdfetT);
    }
}

HRESULT CContentIndexEnum::QueryInterface(REFIID riid, void **ppv)
{
    static const QITAB qit[] = {
        QITABENTMULTI(CContentIndexEnum, IUnknown, IFindEnum), // IID_IUNKNOWN
        QITABENT(CContentIndexEnum, IShellService),          // IID_IShellService
        { 0 },
    };
    return QISearch(this, qit, riid, ppv);
}

ULONG CContentIndexEnum::AddRef()
{
    return InterlockedIncrement(&_cRef);
}

ULONG CContentIndexEnum::Release()
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;

    delete this;
    return 0;
}

HRESULT CContentIndexEnum::Next(LPITEMIDLIST *ppidl, int *pcObjectSearched, int *pcFoldersSearched, BOOL *pfContinue, int *pState)
{
    return E_PENDING;       // as good a return as any to say that we are async...
}

HRESULT CContentIndexEnum::Skip(int celt)
{
    return E_NOTIMPL;
}

HRESULT CContentIndexEnum::Reset()
{
    // overload Reset to mean dump the rowset cache!!!
    _CacheRowSet(-1);    
    // still return failiure
    return E_NOTIMPL;
}

HRESULT CContentIndexEnum::StopSearch()
{
    // Lets see if we can find one that works...
    HRESULT hr = _pCommand->Cancel();
    if (FAILED(hr))
        hr = _pRowsetAsync->Stop();
    if (FAILED(hr))
    {
        IDBAsynchStatus *pdbas;
        if (SUCCEEDED(_pRowset->QueryInterface(IID_PPV_ARG(IDBAsynchStatus, &pdbas))))
        {
            hr = pdbas->Abort(DB_NULL_HCHAPTER, DBASYNCHOP_OPEN);
            pdbas->Release();
        }
    }
    return hr; 
}

BOOL CContentIndexEnum::FQueryIsAsync()
{
    return TRUE;
}

HRESULT CContentIndexEnum::GetAsyncCount(DBCOUNTITEM *pdwTotalAsync, int *pnPercentComplete, BOOL *pfQueryDone)
{
    if (!_pRowsetAsync)
        return E_FAIL;

    BOOL fMore;
    DBCOUNTITEM dwDen, dwNum;
    HRESULT hr = _pRowsetAsync->RatioFinished(&dwDen, &dwNum, pdwTotalAsync, &fMore);
    if (SUCCEEDED(hr))
    {
        *pfQueryDone = dwDen == dwNum;
        *pnPercentComplete = dwDen ? (int)((dwNum * 100) / dwDen) : 100;
    }
    else
        *pfQueryDone = TRUE;    // in case that is all they are looking at...
    return hr;
}

// modify pszPath until you can parse it, return result in *ppidl

HRESULT _StripToParseableName(LPTSTR pszPath, LPITEMIDLIST *ppidl)
{
    *ppidl = NULL;
    HRESULT hr = E_FAIL;

    PathRemoveBackslash(pszPath);
    while (PathRemoveFileSpec(pszPath) && FAILED(hr))
    {
        hr = SHParseDisplayName(pszPath, NULL, ppidl, 0, NULL);
    }
    return hr;
}

// we could not get pidl for this item for some reason.  we have to put 
// it in the list of bad items so that we can tell ci not to give it to
// us the next time we do search
void _ExcludeFromFutureSearch(LPCTSTR pszParent)
{
    HKEY hkey;

    TCHAR szParent[MAX_PATH];
    StrCpyN(szParent, pszParent, ARRAYSIZE(szParent));

    if (RegCreateKeyExW(HKEY_CURRENT_USER, CI_SPECIAL_FOLDERS, 0, L"", 0, KEY_WRITE | KEY_QUERY_VALUE, NULL, &hkey, NULL) == ERROR_SUCCESS)
    {
        LPITEMIDLIST pidlT;
        if (SUCCEEDED(_StripToParseableName(szParent, &pidlT)))
        {
            ILFree(pidlT);
        
            DWORD dwInsert = 0; // init to zero in case query info bellow fails
            int iEnd;
            TCHAR sz[MAX_PATH], szName[10];
            RegQueryInfoKey(hkey, NULL, NULL, NULL, NULL, NULL, NULL, &dwInsert, NULL, NULL, NULL, NULL);
            // start from the end as there is a high chance we added this at the end
            for (int i = dwInsert - 1; i >= 0; i--)
            {                        
                DWORD cb = sizeof(sz);
            
                wsprintf(szName, L"%d", i);
                if (RegQueryValueEx(hkey, szName, NULL, NULL, (BYTE *)sz, &cb) == ERROR_SUCCESS)
                {
                    LPTSTR pszTemp = StrStrI(sz + 1, szParent); // +1 to pass " that's at the beginning of the string
                    if (pszTemp && pszTemp == sz + 1)
                    {
                        dwInsert = i; // overwrite this value
                        break;
                    }
                    else
                    {
                        iEnd = lstrlen(sz);
                        if (EVAL(iEnd > 1))
                        {
                            int iBackslash = iEnd - 3;
                            ASSERT(sz[iBackslash] == L'\\');
                            sz[iBackslash] = L'\0';
                            pszTemp = StrStrI(szParent, sz + 1);
                            sz[iBackslash] = L'\\';
                            if (pszTemp && pszTemp == szParent)
                            {
                                dwInsert = -1;
                                break;
                            }
                        }
                    }
                }
            }

            if (dwInsert != -1)
            {
                wsprintf(szName, L"%d", dwInsert);

                PathAppend(szParent, TEXT("*"));
                PathQuoteSpaces(szParent);
                RegSetValueEx(hkey, szName, 0, REG_SZ, (BYTE *)szParent, (lstrlen(szParent) + 1) * sizeof(szParent[0]));
            }
        }
        RegCloseKey(hkey);
    }
}

// If it is a UNC it might be one we need to translate, to handle the case that 
// content index does not support redirected drives.

BOOL CContentIndexEnum::_TranslateFolder(LPCTSTR pszParent, LPTSTR pszResult)
{
    BOOL fTranslated = FALSE;
    StrCpyW(pszResult, pszParent);  // default to the same
    if (PathIsUNC(pszParent))
    {
        for (DFODBET *pdfet = _pdfetFirst; pdfet; pdfet = pdfet->pdfetNext)
        {
            if ((StrCmpNIW(pszParent, pdfet->pwszFrom, pdfet->cbFrom) == 0)
                    && (pszParent[pdfet->cbFrom] == L'\\'))
            {
                // Ok we have a translation to use.
                fTranslated = TRUE;
                StrCpyW(pszResult, pdfet->pwszTo);
                // need + 1 here or we'll get something like w:\\winnt! bogus path, that is.
                StrCatW(pszResult, &pszParent[pdfet->cbFrom + 1]);
            }
        }
    }
    return fTranslated;
}

HRESULT CContentIndexEnum::GetItemIDList(UINT iItem, LPITEMIDLIST *ppidl)
{
    *ppidl = NULL;

    HRESULT hr = _CacheRowSet(iItem);
    if (S_OK != hr)
    {
        return E_FAIL;    // we could not get the item someone asked for, so error...
    }

    PROPVARIANT* data[c_cDbCols];
    
    hr = _pRowset->GetData(_ahrow[iItem - _ihrowFirst], _hAccessor, &data);
    if (S_OK == hr)
    {
        // data[0].pwszVal is the file name
        // data[1].pwszVal is the full path (including file name)
        // data[2].ulVal is the attribute
        // data[3].ulVal is the size in byte
        // data[4].filetime is the last write time in UTC
        // data[5].ulVal is the rank of the item...

        WIN32_FIND_DATA fd = {0};

        fd.dwFileAttributes = data[2]->ulVal;
        fd.nFileSizeLow = data[3]->ulVal;
        fd.ftLastWriteTime = data[4]->filetime;

        ASSERT(ShowSuperHidden() || !IsSuperHidden(fd.dwFileAttributes));   // query should exclude these
        
        StrCpyW(fd.cFileName, data[0]->pwszVal);

        WCHAR szParent[MAX_PATH];
        StrCpyW(szParent, data[1]->pwszVal);    // full path
        PathRemoveFileSpec(szParent);           // strip to parent folder path
       
        WCHAR szTranslatedParent[MAX_PATH];
        BOOL fTranslated = _TranslateFolder(szParent, szTranslatedParent);
        
        if (lstrcmp(szParent, _szCurrentDir) != 0)
        {
            _ClearFolderState();    // our previous "current folder" state is now invalid

            hr = SHParseDisplayName(szTranslatedParent, NULL, &_pidlFolder, 0, NULL);
            if (SUCCEEDED(hr))
            { 
                hr = _pff->AddFolder(_pidlFolder, TRUE, &_iFolder);
                if (SUCCEEDED(hr))
                {
                    hr = _pff->GetFolder(_iFolder, IID_PPV_ARG(IShellFolder, &_psfCurrentDir));
                    if (SUCCEEDED(hr))
                    {
                        // on succesful init of this folder save the cache key
                        lstrcpy(_szCurrentDir, szParent);
                    }
                }
            }
            else if (hr != E_OUTOFMEMORY && !fTranslated)
            {
                _ExcludeFromFutureSearch(szParent);
            }
            _hrCurrent = hr;    // save error state for next time around

            if (FAILED(hr))
                _ClearFolderState();
        }
        else
        {
            hr = _hrCurrent;
        }

        if (SUCCEEDED(hr))
        {
            // success implies the state of these variables
            ASSERT((NULL != _psfCurrentDir) && (NULL != _pidlFolder) && (_iFolder > 0));

            DWORD dwItemID;
            GetItemID(iItem, &dwItemID);

            LPITEMIDLIST pidl;
            hr = SHSimpleIDListFromFindData2(_psfCurrentDir, &fd, &pidl);
            if (SUCCEEDED(hr))
            {
                hr = _pff->AddDataToIDList(pidl, _iFolder, _pidlFolder, DFDF_EXTRADATA, iItem, dwItemID, data[5]->ulVal, ppidl);
                ILFree(pidl);
            }
        }
        else 
        {
            // failure implies these should be clear
            ASSERT((NULL == _psfCurrentDir) && (NULL == _pidlFolder));

            LPITEMIDLIST pidlFull;
            if (SUCCEEDED(_StripToParseableName(szTranslatedParent, &pidlFull)))
            {
                LPCITEMIDLIST pidlChild;
                if (SUCCEEDED(SplitIDList(pidlFull, &_pidlFolder, &pidlChild)))
                {
                    hr = _pff->AddFolder(_pidlFolder, TRUE, &_iFolder);
                    if (SUCCEEDED(hr))
                    {
                        hr = _pff->GetFolder(_iFolder, IID_PPV_ARG(IShellFolder, &_psfCurrentDir));
                        if (SUCCEEDED(hr))
                        {
                            hr = _pff->AddDataToIDList(pidlChild, _iFolder, _pidlFolder, DFDF_NONE, 0, 0, 0, ppidl);
                            if (SUCCEEDED(hr))
                            {
                                // on succesful init of this folder save the cache key
                                lstrcpy(_szCurrentDir, szTranslatedParent);
                                PathRemoveFileSpec(_szCurrentDir);
                            }
                        }
                    }
                }
                ILFree(pidlFull);

                if (FAILED(hr))
                    _ClearFolderState();
            }
        }
    }

    return hr;
}

HRESULT CContentIndexEnum::GetItemID(UINT iItem, DWORD *puItemID)
{
    *puItemID = (UINT)-1;
    HRESULT hr = _CacheRowSet(iItem);
    if (S_OK == hr)
    {
        PROPVARIANT* data[1];
        hr = _pRowset->GetData(_ahrow[iItem - _ihrowFirst], _hAccessorWorkID, &data);
        if (S_OK == hr)
        {
            // Only one data column so this is easy...
            // The ULVal is the thing we are after...
            *puItemID = data[0]->ulVal;
        }
    }
    return hr;
}

HRESULT CContentIndexEnum::SortOnColumn(UINT iCol, BOOL fAscending)
{
    // Ok We need to generate the Sort String... 
    return _BuildAndSetCommandTree(iCol, fAscending);             
}

HRESULT CContentIndexEnum::SetOwner(IUnknown* punkOwner)
{
    // Used to set the docfind folder and from that the filter.
    ATOMICRELEASE(_pfilter);
    ATOMICRELEASE(_pff);

    if (punkOwner)
    {
        punkOwner->QueryInterface(IID_PPV_ARG(IFindFolder, &_pff));
        if (_pff)
            _pff->GetFindFilter(&_pfilter);
    }
    return S_OK;
}

HRESULT CContentIndexEnum::_MapColumns(IUnknown *punk, DBORDINAL cCols,
                                  DBBINDING *pBindings, const DBID *pDbCols,
                                  HACCESSOR &hAccessor)
{
    DBORDINAL aMappedColumnIDs[c_cDbCols];

    IColumnsInfo *pColumnsInfo;
    HRESULT hr = punk->QueryInterface(IID_PPV_ARG(IColumnsInfo, &pColumnsInfo));
    if (SUCCEEDED(hr))
    {
        hr = pColumnsInfo->MapColumnIDs(cCols, pDbCols, aMappedColumnIDs);
        if (SUCCEEDED(hr))
        {
            for (ULONG i = 0; i < cCols; i++)
                pBindings[i].iOrdinal = aMappedColumnIDs[i];

            IAccessor *pIAccessor;
            hr = punk->QueryInterface(IID_PPV_ARG(IAccessor, &pIAccessor));
            if (SUCCEEDED(hr))
            {
                hAccessor = 0;
                hr = pIAccessor->CreateAccessor(DBACCESSOR_ROWDATA, cCols, pBindings, 0, &hAccessor, 0);
                pIAccessor->Release();
            }
        }
        pColumnsInfo->Release();
    }

    return hr;
}

void CContentIndexEnum::_ReleaseAccessor()
{
    IAccessor *pIAccessor;
    HRESULT hr = _pRowset->QueryInterface(IID_PPV_ARG(IAccessor, &pIAccessor));
    if (SUCCEEDED(hr))
    {
        if (_hAccessor)
            pIAccessor->ReleaseAccessor(_hAccessor, 0);
        if (_hAccessorWorkID)
            pIAccessor->ReleaseAccessor(_hAccessorWorkID, 0);

        pIAccessor->Release();
    }
}

HRESULT CContentIndexEnum::_CacheRowSet(UINT iItem)
{
    HRESULT hr = S_OK;

    if (!_pRowset)
        return E_FAIL;
    
    if (!_cRows || !InRange(iItem, _ihrowFirst, _ihrowFirst+(UINT)_cRows-1) || (iItem == (UINT)-1))
    {
        // Release the last cached element we had.
        if (_cRows != 0)
            _pRowset->ReleaseRows(ARRAYSIZE(_ahrow), _ahrow, 0, 0, 0);

        // See if we are simply releasing our cached data...
        _cRows = 0;
        _ihrowFirst = (UINT)-1;
        if (iItem == (UINT)-1)
            return S_OK;

        // Ok try to read in the next on...
        BYTE bBookMark = (BYTE) DBBMK_FIRST;
        HROW *rghRows = (HROW *)_ahrow;

        // change this to fetch 100 or so rows at the time -- huge perf improvment
        hr = _pRowset->GetRowsAt(0, 0, sizeof(bBookMark), &bBookMark, iItem, ARRAYSIZE(_ahrow), &_cRows, &rghRows);
        if (FAILED(hr))
            return hr;
            
        _ihrowFirst = iItem;

        if ((DB_S_ENDOFROWSET == hr) || (_cRows == 0))
        {
            if (_cRows == 0)
                _ihrowFirst = -1;
            else
                hr = S_OK;  // we got some items and caller expects S_OK so change DB_S_ENDOFROWSET to noerror
        }
    }

    return hr;
}

void CContentIndexEnum::HandleWatchNotify(DBWATCHNOTIFY eChangeReason)
{
    // For now we will simply Acknoledge the change...
    if (_prwn)
        _prwn->OnChange(NULL, eChangeReason);
}

HRESULT CContentIndexEnum::_SetCmdProp(ICommand *pCommand)
{
#define MAX_PROPS 8

    DBPROPSET aPropSet[MAX_PROPS];
    DBPROP aProp[MAX_PROPS];
    ULONG cProps = 0;
    HRESULT hr;

    // asynchronous query

    aProp[cProps].dwPropertyID = DBPROP_IRowsetAsynch;
    aProp[cProps].dwOptions = 0;
    aProp[cProps].dwStatus = 0;
    aProp[cProps].colid = c_dbcolNull;
    aProp[cProps].vValue.vt = VT_BOOL;
    aProp[cProps].vValue.boolVal = VARIANT_TRUE;

    aPropSet[cProps].rgProperties = &aProp[cProps];
    aPropSet[cProps].cProperties = 1;
    aPropSet[cProps].guidPropertySet = c_guidRowsetProps;

    cProps++;

    // don't timeout queries

    aProp[cProps].dwPropertyID = DBPROP_COMMANDTIMEOUT;
    aProp[cProps].dwOptions = DBPROPOPTIONS_SETIFCHEAP;
    aProp[cProps].dwStatus = 0;
    aProp[cProps].colid = c_dbcolNull;
    aProp[cProps].vValue.vt = VT_I4;
    aProp[cProps].vValue.lVal = 0;

    aPropSet[cProps].rgProperties = &aProp[cProps];
    aPropSet[cProps].cProperties = 1;
    aPropSet[cProps].guidPropertySet = c_guidRowsetProps;

    cProps++;

    // We can handle PROPVARIANTs

    aProp[cProps].dwPropertyID = DBPROP_USEEXTENDEDDBTYPES;
    aProp[cProps].dwOptions = DBPROPOPTIONS_SETIFCHEAP;
    aProp[cProps].dwStatus = 0;
    aProp[cProps].colid = c_dbcolNull;
    aProp[cProps].vValue.vt = VT_BOOL;
    aProp[cProps].vValue.boolVal = VARIANT_TRUE;

    aPropSet[cProps].rgProperties = &aProp[cProps];
    aPropSet[cProps].cProperties = 1;
    aPropSet[cProps].guidPropertySet = c_guidQueryExt;

    cProps++;

    ICommandProperties * pCmdProp = 0;
    hr = pCommand->QueryInterface(IID_PPV_ARG(ICommandProperties, &pCmdProp));
    if (SUCCEEDED(hr))
    {
        hr = pCmdProp->SetProperties(cProps, aPropSet);
        pCmdProp->Release();
    }

    return hr;
}

// create the query command string

HRESULT CContentIndexEnum::_BuildAndSetCommandTree(int iCol, BOOL fReverse)
{
    LPWSTR pwszRestrictions = NULL;
    DWORD  dwGQRFlags;
    HRESULT hr = _pfilter->GenerateQueryRestrictions(&pwszRestrictions, &dwGQRFlags);
    if (SUCCEEDED(hr))
    {
        ULONG ulDialect;
        hr = _pfilter->GetQueryLanguageDialect(&ulDialect);
        if (SUCCEEDED(hr))
        {
            // NOTE: hard coded to our current list of columns
            WCHAR wszSort[80];      // use this to sort by different columns...
            wszSort[0] = 0;

            if ((iCol >= 0) && (iCol < ARRAYSIZE(c_awszColSortNames)) && c_awszColSortNames[iCol])
            {
                // Sort order is hardcoded for ascending.
                StrCpyW(wszSort, c_awszColSortNames[iCol]); 
                StrCatW(wszSort, L",Path[a],FileName[a]");
            }
        
            DBCOMMANDTREE *pTree = NULL;
            hr = CITextToFullTreeEx(pwszRestrictions, ulDialect, 
                L"FileName,Path,Attrib,Size,Write,Rank,WorkID",
                wszSort[0] ? wszSort : NULL, 0, &pTree, 0, 0, LOCALE_USER_DEFAULT);
            if (FAILED(hr)) 
            {
                // Map this to one that I know about
                // Note: We will only do this if we require CI else we will try to fallback to old search...
                // Note we are running into problems where CI says we are contained in a Catalog even if
                // CI process is not running... So try to avoid this if possible
                if (dwGQRFlags & GQR_REQUIRES_CI)
                    hr = MAKE_HRESULT(3, FACILITY_SEARCHCOMMAND, SCEE_CONSTRAINT);
            }

            if (SUCCEEDED(hr))
            {
                ICommandTree *pCmdTree;
                hr = _pCommand->QueryInterface(IID_PPV_ARG(ICommandTree, &pCmdTree));
                if (SUCCEEDED(hr))
                {    
                    hr = pCmdTree->SetCommandTree(&pTree, DBCOMMANDREUSE_NONE, FALSE);
                    pCmdTree->Release();
                }
            }
        }
    }
    LocalFree((HLOCAL)pwszRestrictions);
    return hr;
}

#define cbP (sizeof (PROPVARIANT *))

// [in, out] apwszPaths this is modified
// [in, out] pcPaths

HRESULT CContentIndexEnum::DoQuery(LPWSTR *apwszPaths, UINT *pcPaths)
{
    UINT nPaths = *pcPaths;
    WCHAR** aScopes = NULL;
    WCHAR** aScopesOrig = NULL;
    ULONG* aDepths = NULL;
    WCHAR** aCatalogs = NULL;
    WCHAR** aMachines = NULL;
    WCHAR wszPath[MAX_PATH];
    LPWSTR pwszPath = wszPath;
    LPWSTR pszMachineAlloc = NULL, pszCatalogAlloc = NULL;
    LPWSTR pwszMachine, pwszCatalog;
    UINT i, iPath = 0;
    DWORD dwQueryRestrictions;

    // Initiailize all of our query values back to unused 
    _hAccessor = NULL;
    _hAccessorWorkID = NULL;
    _pRowset = NULL;
    _pRowsetAsync = NULL;
    _pCommand = NULL;

    // Get array of search paths...
#define MAX_MACHINE_NAME_LEN    32

    BOOL fIsCIRunning, fCiIndexed, fCiPermission;
    GetCIStatus(&fIsCIRunning, &fCiIndexed, &fCiPermission);

    // First pass see if we have anything that make use at all of CI if not lets simply bail and let
    // old code walk the list...
    HRESULT hr = _pfilter->GenerateQueryRestrictions(NULL, &dwQueryRestrictions);
    if (FAILED(hr))
        goto Abort;

    if ((dwQueryRestrictions & GQR_MAKES_USE_OF_CI) == 0)
    {
        hr = S_FALSE;
        goto Abort;
    }

    // allocate the arrays that we need to pass to CIMakeICommand and
    // the buffers needed for the machine name and catalog name
    aDepths = (ULONG*)LocalAlloc(LPTR, nPaths * sizeof(ULONG));
    aScopes = (WCHAR**)LocalAlloc(LPTR, nPaths * sizeof(WCHAR*));
    aScopesOrig = (WCHAR**)LocalAlloc(LPTR, nPaths * sizeof(WCHAR*));
    aCatalogs = (WCHAR**)LocalAlloc(LPTR, nPaths * sizeof(WCHAR*));
    aMachines = (WCHAR**)LocalAlloc(LPTR, nPaths * sizeof(WCHAR*));
    pszMachineAlloc = pwszMachine = (LPWSTR)LocalAlloc(LPTR, nPaths * MAX_MACHINE_NAME_LEN * sizeof(WCHAR));
    pszCatalogAlloc = pwszCatalog = (LPWSTR)LocalAlloc(LPTR, nPaths * MAX_PATH * sizeof(WCHAR));

    if (!aDepths || !aScopes || !aScopesOrig || !aCatalogs ||
        !aMachines || !pszMachineAlloc || !pszCatalogAlloc)
    {
        hr = E_OUTOFMEMORY;
        goto Abort;
    }

    // This following loop does two things,
    //  1. Check if all the scopes are indexed, if any one scope is not,
    //      fail the call and we'll do the win32 find.
    //  2. Prepare the arrays of parameters that we need to pass to
    //      CIMakeICommand().
    //
    // NOTE: Reinerf says this code looks busted for nPaths > 1.  See bug 199254 for comments.
    for (i = 0; i < nPaths; i++)
    {
        ULONG cchMachine = MAX_MACHINE_NAME_LEN;
        ULONG cchCatalog = MAX_PATH;
        WCHAR wszUNCPath[MAX_PATH];
        BOOL fRemapped = FALSE;

        // if CI is not running we can still do ci queries on a remote drive (if it is  indexed)
        // so we cannot just bail if ci is not running on user's machine
        if (!fIsCIRunning && !PathIsRemote(apwszPaths[i]))
            continue;  // do grep on this one

        hr = LocateCatalogsW(apwszPaths[i], 0, pwszMachine, &cchMachine, pwszCatalog, &cchCatalog);
        if (hr != S_OK)
        {
            // see if by chance this is a network redirected drive.  If so we CI does not handle
            // these.  See if we can remap to UNC path to ask again...
            if (!PathIsUNC(apwszPaths[i]))
            {
                DWORD nLength = ARRAYSIZE(wszUNCPath);
                // this api takes TCHAR, but we only compile this part for WINNT...
                DWORD dwType = SHWNetGetConnection(apwszPaths[i], wszUNCPath, &nLength);
                if ((dwType == NO_ERROR) || (dwType == ERROR_CONNECTION_UNAVAIL))
                {
                    fRemapped = TRUE;
                    LPWSTR pwsz = PathSkipRootW(apwszPaths[i]);
                    if (pwsz)
                        PathAppendW(wszUNCPath, pwsz);

                    cchMachine = MAX_MACHINE_NAME_LEN;  // reset in params
                    cchCatalog = MAX_PATH;

                    hr = LocateCatalogsW(wszUNCPath, 0, pwszMachine, &cchMachine, pwszCatalog, &cchCatalog);
                }
            }
        }
        if (hr != S_OK)
        {
            continue;   // this one is not indexed.
        }

        if (S_FALSE == CatalogUptodate(pwszCatalog, pwszMachine))
        {
            // not up todate
            if (dwQueryRestrictions & GQR_REQUIRES_CI)
            {
                // ci not up to date and we must use it..
                // inform the user that results may not be complete
                if (!(_grfWarnings & DFW_IGNORE_INDEXNOTCOMPLETE))
                {
                    hr = MAKE_HRESULT(3, FACILITY_SEARCHCOMMAND, SCEE_INDEXNOTCOMPLETE);
                    goto Abort;
                }
                //else use ci although index is not complete
            }
            else
            {
                // ci is not upto date so just use grep for this drive so user can get
                // complete results
                pwszCatalog[0] = 0; 
                pwszMachine[0] = 0;
                continue;
            }
        }

        aDepths[iPath] = (_grfFlags & DFOO_INCLUDESUBDIRS) ? QUERY_DEEP : QUERY_SHALLOW;
        aScopesOrig[iPath] = apwszPaths[i];
        if (fRemapped)
        {
            aScopes[iPath] = StrDupW(wszUNCPath);
            if (aScopes[iPath] == NULL)
            {
                hr = E_OUTOFMEMORY;
                goto Abort;
            }
        }
        else
        {
            aScopes[iPath] = apwszPaths[i];
        }

        aCatalogs[iPath] = pwszCatalog;
        aMachines[iPath] = pwszMachine;
        
        pwszCatalog += MAX_PATH;    // advance the catalog and machine name buffer
        pwszMachine += MAX_MACHINE_NAME_LEN;
        iPath++;    // next item in this list
    }

    if (iPath == 0) 
    {
        // no catalogs found;  - We should check to see if by chance the user specified a query that
        // is CI based if so error apapropriately...
        hr = (dwQueryRestrictions & GQR_REQUIRES_CI) ? MAKE_HRESULT(3, FACILITY_SEARCHCOMMAND, SCEE_INDEXSEARCH) : S_FALSE;
        goto Abort;
    }

    // Get ICommand.
    hr = CIMakeICommand(&_pCommand, iPath, aDepths, aScopes, aCatalogs, aMachines);
    if (SUCCEEDED(hr))
    {
        // create the query command string - Assume default sort...
        hr = _BuildAndSetCommandTree(_iColSort, FALSE);
        if (SUCCEEDED(hr))
        {
            if ((dwQueryRestrictions & GQR_REQUIRES_CI) && (nPaths != iPath))
            {
                // check warning flags to see if we should ignore and continue
                if (0 == (_grfWarnings & DFW_IGNORE_CISCOPEMISMATCH))
                {
                    hr = MAKE_HRESULT(3, FACILITY_SEARCHCOMMAND, SCEE_SCOPEMISMATCH);
                }
            }

            if (SUCCEEDED(hr))
            {
                // Get IRowset.
                _SetCmdProp(_pCommand);
                hr = _pCommand->Execute(0, IID_IRowsetLocate, 0, 0, (IUnknown **)&_pRowset);
                if (SUCCEEDED(hr))
                {
                    // we have the IRowset.
                    // Real work to get the Accessor
                    DBBINDING aPropMainCols[c_cDbCols] =
                    {
                        { 0,cbP*0,0,0,0,0,0, DBPART_VALUE, DBMEMOWNER_PROVIDEROWNED, DBPARAMIO_NOTPARAM, 0, 0,  DBTYPE_VARIANT|DBTYPE_BYREF, 0, 0 },
                        { 0,cbP*1,0,0,0,0,0, DBPART_VALUE, DBMEMOWNER_PROVIDEROWNED, DBPARAMIO_NOTPARAM, 0, 0,  DBTYPE_VARIANT|DBTYPE_BYREF, 0, 0 },
                        { 0,cbP*2,0,0,0,0,0, DBPART_VALUE, DBMEMOWNER_PROVIDEROWNED, DBPARAMIO_NOTPARAM, 0, 0,  DBTYPE_VARIANT|DBTYPE_BYREF, 0, 0 },
                        { 0,cbP*3,0,0,0,0,0, DBPART_VALUE, DBMEMOWNER_PROVIDEROWNED, DBPARAMIO_NOTPARAM, 0, 0,  DBTYPE_VARIANT|DBTYPE_BYREF, 0, 0 },
                        { 0,cbP*4,0,0,0,0,0, DBPART_VALUE, DBMEMOWNER_PROVIDEROWNED, DBPARAMIO_NOTPARAM, 0, 0,  DBTYPE_VARIANT|DBTYPE_BYREF, 0, 0 },
                        { 0,cbP*5,0,0,0,0,0, DBPART_VALUE, DBMEMOWNER_PROVIDEROWNED, DBPARAMIO_NOTPARAM, 0, 0,  DBTYPE_VARIANT|DBTYPE_BYREF, 0, 0 }
                    };

                    hr = _MapColumns(_pRowset, c_cDbCols, aPropMainCols, c_aDbCols, _hAccessor);
                    if (SUCCEEDED(hr))
                    {
                        // OK lets also get the accessor for the WorkID...
                        hr = _MapColumns(_pRowset, ARRAYSIZE(c_aDbWorkIDCols), aPropMainCols, c_aDbWorkIDCols, _hAccessorWorkID);
                        if (SUCCEEDED(hr))
                        {
                            hr = _pRowset->QueryInterface(IID_PPV_ARG(IRowsetAsynch, &_pRowsetAsync));
                        }
                    }
                }
            }
        }
    }

    if (FAILED(hr))
        goto Abort;

    // If we got here than at least some of our paths are indexed
    // we may need to compress the list down of the ones we did not handle...
    *pcPaths = (nPaths - iPath);  // Let caller know how many we did not process

    // need to move all the ones we did not process to the start of the list...
    // we always process this list here as we may need to allocate translation lists to be used to
    // translate the some UNCS back to the mapped drive the user passed in.

    UINT j = 0, iInsert = 0;
    iPath--;    // make it easy to detect 
    for (i = 0; i < nPaths; i++) 
    {
        if (aScopesOrig[j] == apwszPaths[i])
        {
            if (aScopesOrig[j] != aScopes[j])
            {
                // There is a translation in place.
                DFODBET *pdfet = (DFODBET*)LocalAlloc(LPTR, sizeof(*pdfet));
                if (pdfet)
                {
                    pdfet->pdfetNext = _pdfetFirst;
                    _pdfetFirst = pdfet;
                    pdfet->pwszFrom = aScopes[j];
                    pdfet->cbFrom = lstrlenW(pdfet->pwszFrom);
                    pdfet->pwszTo = aScopesOrig[j];
                    aScopes[j] = aScopesOrig[j];    // Make sure loop below does not delete pwszFrom
                    apwszPaths[i] = NULL;           // Likewise for pswsTo...
                }

            }
            if (apwszPaths[i])
            {
                LocalFree((HLOCAL)apwszPaths[i]);
                apwszPaths[i] = NULL;
            }

            if (j < iPath)
                j++;
        }
        else
        {
            apwszPaths[iInsert++] = apwszPaths[i]; // move to right place
        }
    }
    iPath++;    // setup to go through cleanupcode...

     // Fall through to cleanup code...

Abort:                
    // Warning... Since a failure return from this function will
    // release this class, most all of the allocated items up till the failure should
    // be released...   Also cleanup any paths we may have allocated...
    for (i = 0; i < iPath; i++) 
    {
        if (aScopesOrig[i] != aScopes[i])
            LocalFree(aScopes[i]);
    }

    if (aDepths)
        LocalFree(aDepths);

    if (aScopes)
        LocalFree(aScopes);

    if (aScopesOrig)
        LocalFree(aScopesOrig);
    
    if (aCatalogs)
        LocalFree(aCatalogs);

    if (aMachines)
        LocalFree(aMachines);

    if (pszMachineAlloc)
        LocalFree(pszMachineAlloc);

    if (pszCatalogAlloc)
        LocalFree(pszCatalogAlloc);

    return hr;
}

// This is the main external entry point to start a search.  This will
// create a new thread to process the 
STDAPI_(BOOL) SHFindComputer(LPCITEMIDLIST, LPCITEMIDLIST)
{
    IContextMenu *pcm;
    HRESULT hr = CoCreateInstance(CLSID_ShellSearchExt, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IContextMenu, &pcm));
    if (SUCCEEDED(hr))
    {
        CMINVOKECOMMANDINFO ici = {0};

        ici.cbSize = sizeof(ici);
        ici.lpParameters = "{996E1EB1-B524-11d1-9120-00A0C98BA67D}"; // Search Guid of Find Computers
        ici.nShow  = SW_NORMAL;

        hr = pcm->InvokeCommand(&ici);

        pcm->Release();
    }
    return SUCCEEDED(hr);
}

BOOL _IsComputerPidl(LPCITEMIDLIST pidl)
{
    CLSID clsid;
    if (SUCCEEDED(GetCLSIDFromIDList(pidl, &clsid)))
    {
        return (IsEqualCLSID(clsid, CLSID_NetworkPlaces) 
             || IsEqualCLSID(clsid, CLSID_NetworkRoot)
             || IsEqualCLSID(clsid, CLSID_NetworkDomain));
    }
    return FALSE;
}

// This is the main external entry point to start a search.  This will
// create a new thread to process the
//
STDAPI_(BOOL) SHFindFiles(LPCITEMIDLIST pidlFolder, LPCITEMIDLIST pidlSaveFile)
{
    // are we allowed?
    if (SHRestricted(REST_NOFIND))
        return FALSE;
        
    // We Need a hack to allow Find to work for cases like
    // Rest of network and workgroups to map to find computer instead
    // This is rather gross, but what the heck.  It is also assumed that
    // the pidl is of the type that we know about (either File or network)
    if (pidlFolder && _IsComputerPidl(pidlFolder))    
    {
        return SHFindComputer(pidlFolder, pidlSaveFile);
    }

    return RealFindFiles(pidlFolder, pidlSaveFile);
}