windows-server-2003/shell/shell32/findfilter.cpp

#include "shellprv.h"
#include "ids.h"
#include "findhlp.h"
#include "fstreex.h"
#include "findfilter.h"
#include "prop.h"
#include "filtgrep.h"
#include "shstr.h"
#include "mtpt.h"
#include "idltree.h"
#include "enumidlist.h"

// Can't put this in varutil.cpp since a delay-load thunk for VariantTimeToDosDateTime
// pulls in the floating point init code, which pulls in _wWinMainCRTStartup which
// requires a _wWinMain which shlwapi does not have
//
STDAPI VariantToDosDateTime(VARIANT varIn, WORD *pwDate, WORD *pwTime)
{
    VARIANT varResult = {0};
    HRESULT hr = VariantChangeType(&varResult, &varIn, 0, VT_DATE);
    if (SUCCEEDED(hr))
    {
        VariantTimeToDosDateTime(varResult.date, pwDate, pwTime); 
    }
    return hr;
}

STDAPI InitVariantFromDosDateTime(VARIANT *pvar, WORD wDate, WORD wTime)
{
    pvar->vt = VT_DATE;
    return DosDateTimeToVariantTime(wDate, wTime, &pvar->date) ? S_OK : S_FALSE;
}

// {DBEC1000-6AB8-11d1-B758-00A0C90564FE}
const IID IID_IFindFilter = {0xdbec1000, 0x6ab8, 0x11d1, {0xb7, 0x58, 0x0, 0xa0, 0xc9, 0x5, 0x64, 0xfe}};

// constants to define types of date we are searching on
#define DFF_DATE_ALL        (IDD_MDATE_ALL-IDD_MDATE_ALL)
#define DFF_DATE_DAYS       (IDD_MDATE_DAYS-IDD_MDATE_ALL)
#define DFF_DATE_MONTHS     (IDD_MDATE_MONTHS-IDD_MDATE_ALL)
#define DFF_DATE_BETWEEN    (IDD_MDATE_BETWEEN-IDD_MDATE_ALL)
#define DFF_DATE_RANGEMASK  0x00ff

// Define new criteria to be saved in file...
#define DFSC_SEARCHFOR      0x5000

#define DFSLI_VER                   0
#define DFSLI_TYPE_PIDL             0   // Pidl is streamed after this
#define DFSLI_TYPE_STRING           1   // cb follows this for length then string...
// Document folders and children - Warning we assume the order of items after Document Folders
#define DFSLI_TYPE_DOCUMENTFOLDERS  0x10
#define DFSLI_TYPE_DESKTOP          0x11
#define DFSLI_TYPE_PERSONAL         0x12
// My computer and children...
#define DFSLI_TYPE_MYCOMPUTER       0x20
#define DFSLI_TYPE_LOCALDRIVES      0x21

#define DFPAGE_INIT     0x0001          /* This page has been initialized */
#define DFPAGE_CHANGE   0x0002          /*  The user has modified the page */

#define SFGAO_FS_SEARCH (SFGAO_FILESYSANCESTOR | SFGAO_FOLDER)

// Use same enum and string table between updatefield and getting the constraints
// back out...
typedef enum
{
    CDFFUFE_IndexedSearch = 0,
    CDFFUFE_LookIn,
    CDFFUFE_IncludeSubFolders,
    CDFFUFE_Named,
    CDFFUFE_ContainingText,
    CDFFUFE_FileType,
    CDFFUFE_WhichDate,
    CDFFUFE_DateLE,
    CDFFUFE_DateGE,
    CDFFUFE_DateNDays,
    CDFFUFE_DateNMonths,
    CDFFUFE_SizeLE,
    CDFFUFE_SizeGE,
    CDFFUFE_TextCaseSen,
    CDFFUFE_TextReg,
    CDFFUFE_SearchSlowFiles,
    CDFFUFE_QueryDialect,
    CDFFUFE_WarningFlags,
    CDFFUFE_StartItem,
    CDFFUFE_SearchSystemDirs,
    CDFFUFE_SearchHidden,
} CDFFUFE;

static const struct
{
    LPCWSTR     pwszField;
    int         cdffufe;
}
s_cdffuf[] = // Warning: index of fields is used below in case...
{
    {L"IndexedSearch",       CDFFUFE_IndexedSearch},
    {L"LookIn",              CDFFUFE_LookIn},           // VARIANT: pidl, string or IEnumIDList object
    {L"IncludeSubFolders",   CDFFUFE_IncludeSubFolders},
    {L"Named",               CDFFUFE_Named},
    {L"ContainingText",      CDFFUFE_ContainingText},
    {L"FileType",            CDFFUFE_FileType},
    {L"WhichDate",           CDFFUFE_WhichDate},
    {L"DateLE",              CDFFUFE_DateLE},
    {L"DateGE",              CDFFUFE_DateGE},
    {L"DateNDays",           CDFFUFE_DateNDays},
    {L"DateNMonths",         CDFFUFE_DateNMonths},
    {L"SizeLE",              CDFFUFE_SizeLE},
    {L"SizeGE",              CDFFUFE_SizeGE},
    {L"CaseSensitive",       CDFFUFE_TextCaseSen},
    {L"RegularExpressions",  CDFFUFE_TextReg},
    {L"SearchSlowFiles",     CDFFUFE_SearchSlowFiles},
    {L"QueryDialect",        CDFFUFE_QueryDialect},
    {L"WarningFlags",        CDFFUFE_WarningFlags}, /*DFW_xxx bits*/
    {L"StartItem",           CDFFUFE_LookIn},           // VARIANT: pidl, string or IEnumIDList object
    {L"SearchSystemDirs",    CDFFUFE_SearchSystemDirs},
    {L"SearchHidden",        CDFFUFE_SearchHidden},
};

// internal support functions
STDAPI_(BOOL) SetupWildCardingOnFileSpec(LPTSTR pszSpecIn, LPTSTR *ppszSpecOut);

// data filter object
class CFindFilter : public IFindFilter
{
public:
    CFindFilter();

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

    // IFindFilter
    STDMETHODIMP GetStatusMessageIndex(UINT uContext, UINT *puMsgIndex);
    STDMETHODIMP GetFolderMergeMenuIndex(UINT *puBGMainMergeMenu, UINT *puBGPopupMergeMenu);
    STDMETHODIMP FFilterChanged();
    STDMETHODIMP GenerateTitle(LPTSTR *ppszTile, BOOL fFileName);
    STDMETHODIMP PrepareToEnumObjects(HWND hwnd, DWORD * pdwFlags);
    STDMETHODIMP ClearSearchCriteria();
    STDMETHODIMP EnumObjects(IShellFolder *psf, LPCITEMIDLIST pidlStart, DWORD grfFlags, int iColSort, 
                             LPTSTR pszProgressText, IRowsetWatchNotify *prwn, IFindEnum **ppdfenum);
    STDMETHODIMP GetColumnsFolder(IShellFolder2 **ppsf);
    STDMETHODIMP_(BOOL) MatchFilter(IShellFolder *psf, LPCITEMIDLIST pidl);
    STDMETHODIMP SaveCriteria(IStream * pstm, WORD fCharType);   
    STDMETHODIMP RestoreCriteria(IStream * pstm, int cCriteria, WORD fCharType);
    STDMETHODIMP DeclareFSNotifyInterest(HWND hwnd, UINT uMsg);
    STDMETHODIMP GetColSaveStream(WPARAM wParam, LPSTREAM *ppstm);
    STDMETHODIMP GenerateQueryRestrictions(LPWSTR *ppwszQuery, DWORD *pdwGQRFlags);
    STDMETHODIMP ReleaseQuery();
    STDMETHODIMP UpdateField(LPCWSTR pszField, VARIANT vValue);
    STDMETHODIMP ResetFieldsToDefaults();
    STDMETHODIMP GetItemContextMenu(HWND hwndOwner, IFindFolder* pdfFolder, IContextMenu** ppcm);
    STDMETHODIMP GetDefaultSearchGUID(IShellFolder2 *psf2, LPGUID lpGuid);
    STDMETHODIMP EnumSearches(IShellFolder2 *psf2, LPENUMEXTRASEARCH *ppenum);
    STDMETHODIMP GetSearchFolderClassId(LPGUID lpGuid);
    STDMETHODIMP GetNextConstraint(VARIANT_BOOL fReset, BSTR *pName, VARIANT *pValue, VARIANT_BOOL *pfFound);
    STDMETHODIMP GetQueryLanguageDialect(ULONG * pulDialect);
    STDMETHODIMP GetWarningFlags(DWORD *pdwWarningFlags);

    STDMETHODIMP InitSelf(void);
    STDMETHODIMP_(BOOL) TopLevelOnly() const   { return _fTopLevelOnly; }

private:
    ~CFindFilter();
    HRESULT _GetDetailsFolder();
    void _GenerateQuery(LPWSTR pwszQuery, DWORD *pcchQuery);
    void _UpdateTypeField(const VARIANT *pvar);
    static int _SaveCriteriaItem(IStream * pstm, WORD wNum, LPCTSTR psz, WORD fCharType);
    DWORD _QueryDosDate(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, WORD wDate, BOOL bBefore);
    HRESULT _GetPropertyUI(IPropertyUI **pppui);
    DWORD _CIQuerySize(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, ULONGLONG ullSize, int iSizeType);
    DWORD _CIQueryFilePatterns(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, LPCWSTR pszFilePatterns);
    DWORD _CIQueryTextPatterns(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, LPWSTR pszText, BOOL bTextReg);
    DWORD _CIQueryShellSettings(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent);
    DWORD _CIQueryIndex(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, LPWSTR pszText);
    DWORD _AddToQuery(LPWSTR *ppszBuf, DWORD *pcchBuf, LPWSTR pszAdd);
    WORD _GetTodaysDosDateMinusNMonths(int nMonths);
    WORD _GetTodaysDosDateMinusNDays(int nDays);
    HRESULT _ScopeEnumerator(IEnumIDList **ppenum);
    void _ResetRoots();

    LONG                _cRef;
    IFindEnum           *_penumAsync; // Added support for Query results to be async...

    // Data associated with the file name.
    LPTSTR              _pszFileSpec;        // $$ the one we do compares with
    LPTSTR              _pszSpecs;           // same as pszFileSpec but with '\0's for ';'s
    LPTSTR *            _apszFileSpecs;      // pointers into pszSpecs for each token
    int                 _cFileSpecs;         // count of specs

    TCHAR               _szPath[MAX_URL_STRING];   // Location of where to start search from
    TCHAR               _szUserInputFileSpec[MAX_PATH];  // File pattern.
    TCHAR               _szText[128];        // Limit text to max editable size

    BOOL                _fTopLevelOnly;      // Search on top level only?
    BOOL                _fSearchHidden;      // $$ Should we show all files?
    BOOL                _fFilterChanged;     // Something in the filter changed.
    BOOL                _fWeRestoredSomeCriteria; // We need to initilize the pages...
    BOOL                _fANDSearch;         // Perform search using AND vs OR?

    // Fields associated with the file type
    BOOL                _fTypeChanged;       // Type changed;
    int                 _iType;              // Index of the type.
    TCHAR               _szTypeName[80];     // The display name for type
    SHSTR               _strTypeFilePatterns;// $$ The file patterns associated with type
    LPTSTR              _pszIndexedSearch;   // what to search for... (Maybe larger than MAX_PATH because it's a list of paths.
    ULONG               _ulQueryDialect;     // ISQLANG_V1 or ISQLANG_V2
    DWORD               _dwWarningFlags;     // Warning bits (DFW_xxx).

    CFilterGrep         _filtgrep;

    int                 _iSizeType;          // $$ What type of size 0 - none, 1 > 2 <
    ULONGLONG           _ullSize;            // $$ Size comparison
    WORD                _wDateType;          // $$ 0 - none, 1 days before, 2 months before...
    WORD                _wDateValue;         //  (Num of months or days)
    WORD                _dateModifiedBefore; // $$
    WORD                _dateModifiedAfter;  // $$
    BOOL                _fFoldersOnly;       // $$ Are we searching for folders?
    BOOL                _fTextCaseSen;       // $$ Case sensitive searching...
    BOOL                _fTextReg;           // $$ regular expressions.
    BOOL                _fSearchSlowFiles;   // && probably missleading as file over a 300baud modem is also slow
    BOOL                _fSearchSystemDirs;  //    Search system directories?
    int                 _iNextConstraint;    // which constraint to look at next...
    HWND                _hwnd;               // for enum UI
    SHCOLUMNID          _scidDate;           // which date property to operate on
    SHCOLUMNID          _scidSize;           // which numeric property to operate on
    IEnumIDList         *_penumRoots;        // idlist enumerator for search roots
    IPropertyUI         *_ppui;
};

//  Target folder queue.
class CFolderQueue
{
public:
    CFolderQueue() : _hdpa(NULL) {}
    ~CFolderQueue();

    HRESULT Add(IShellFolder *psf, LPCITEMIDLIST pidl);

    IShellFolder *Remove();

private:
    HRESULT _AddFolder(IShellFolder *psf);
    HDPA    _hdpa;
};

class CNamespaceEnum : public IFindEnum
{
public:
    CNamespaceEnum(IFindFilter *pfilter, IShellFolder *psf, IFindEnum *pdfEnumAsync,
                   IEnumIDList *penumScopes, HWND hwnd, DWORD grfFlags, LPTSTR pszProgressText);

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

    // IFindEnum
    STDMETHODIMP Next(LPITEMIDLIST *ppidl, int *pcObjectSearched, int *pcFoldersSearched, BOOL *pfContinue, int *pState);
    STDMETHODIMP Skip(int celt) { return E_NOTIMPL; }
    STDMETHODIMP Reset() { return E_NOTIMPL; }
    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);

private:
    ~CNamespaceEnum();
    BOOL _ShouldPushItem(LPCITEMIDLIST pidl);
    BOOL _IsSystemFolderByCLSID(LPCITEMIDLIST pidlFull);
    IShellFolder *_NextRootScope();

    LONG            _cRef;
    IFindFilter     *_pfilter;          // parent filter object

    IFindFolder     *_pff;              // docfind folder interface over results
    HWND             _hwnd;             // for enum UI
    DWORD            _grfFlags;         // docfind enumeration flags (DFOO_xxx).

    // Recursion state...
    IShellFolder*    _psf;              // current shell folder
    LPITEMIDLIST     _pidlFolder;       // current shell folder, as pidl
    LPITEMIDLIST     _pidlCurrentRootScope; // the last scope pulled out of _penumScopes
    IEnumIDList      *_penum;           // current enumerator.
    int              _iFolder;          // index of current folder in docfind results' folder list.

    // filter info...
    LPTSTR           _pszProgressText;  // path buffer pointer; caller-owned (evil!)

    // enumeration state
    IEnumIDList      *_penumScopes;     // Queue of target folders passed as arguments.
    CFolderQueue      _queSubFolders;   // Queue of subfolders to search in next recursive pass.

    // tree to store the exclude items (i.e. already seached)
    CIDLTree         _treeExcludeFolders;

    // We may have an Async Enum that does some of the scopes...
    IFindEnum         *_penumAsync;
};

// Constants used to keep track of how/why an item was added to the
// exclude tree.
enum 
{
    EXCLUDE_SEARCHED  = 1,
    EXCLUDE_SYSTEMDIR = 2,
};
    

// Create the default filter for our find code...  They should be completly
// self contained...

STDAPI CreateNameSpaceFindFilter(IFindFilter **ppff)
{
    CFindFilter *pff;
    HRESULT hr = E_OUTOFMEMORY;

    pff = new CFindFilter();
    if (pff)
    {
        hr = pff->InitSelf();
        if (SUCCEEDED(hr))
        {
            *ppff = pff;
        }
        else
        {
            pff->Release();
        }
    }

    return hr;
}

HRESULT CFolderQueue::Add(IShellFolder *psf, LPCITEMIDLIST pidl)
{
    IShellFolder *psfNew;
    HRESULT hr = SHBindToObject(psf, IID_X_PPV_ARG(IShellFolder, pidl, &psfNew));
    if (SUCCEEDED(hr))
    {
        hr = _AddFolder(psfNew);
        psfNew->Release();
    }
    return hr;
}

HRESULT CFolderQueue::_AddFolder(IShellFolder *psf)
{
    HRESULT hr = E_OUTOFMEMORY;
    if (NULL == _hdpa)
    {
        _hdpa = DPA_Create(4);
    }

    if (_hdpa)
    {
        if (DPA_AppendPtr(_hdpa, psf) >= 0)
        {
            psf->AddRef();
            hr = S_OK;
        }
    }
    return hr;
}

// remove the folder from the queue
// give the caller the ownership of this folder
IShellFolder *CFolderQueue::Remove()
{
    IShellFolder *psf = NULL;
    if (_hdpa && DPA_GetPtrCount(_hdpa))
        psf = (IShellFolder *)DPA_DeletePtr(_hdpa, 0);
    return psf;
}

CFolderQueue::~CFolderQueue()
{ 
    if (_hdpa) 
    { 
        while (TRUE)
        {
            IShellFolder *psf = Remove();
            if (psf)
            {
                psf->Release();
            }
            else
            {
                break;
            }
        }
        DPA_Destroy(_hdpa); 
    } 
}

CFindFilter::CFindFilter() : _cRef(1), _wDateType(DFF_DATE_ALL), _ulQueryDialect(ISQLANG_V2)
{
}

CFindFilter::~CFindFilter()
{
    Str_SetPtr(&_pszFileSpec, NULL);
    Str_SetPtr(&_pszSpecs, NULL);
    LocalFree(_apszFileSpecs); // elements point to pszSpecs so no free for them
    
    Str_SetPtr(&_pszIndexedSearch, NULL);

    if (_ppui)
        _ppui->Release();

    if (_penumRoots)
        _penumRoots->Release();
}

STDMETHODIMP CFindFilter::InitSelf(void)
{
    return _filtgrep.InitSelf();
}


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

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

STDMETHODIMP_(ULONG) CFindFilter::Release()
{
    ASSERT( 0 != _cRef );
    ULONG cRef = InterlockedDecrement(&_cRef);
    if ( 0 == cRef )
    {
        delete this;
    }
    return cRef;
}

// Retrieves the string resource index number that is proper for the
// current type of search.
STDMETHODIMP CFindFilter::GetStatusMessageIndex(UINT uContext, UINT *puMsgIndex)
{
    // Currently context is not used
    *puMsgIndex = IDS_FILESFOUND;
    return S_OK;
}

// Retrieves which menu to load to merge for the folder
STDMETHODIMP CFindFilter::GetFolderMergeMenuIndex(UINT *puBGMainMergeMenu, UINT *puBGPopupMergeMenu)
{
    *puBGMainMergeMenu = POPUP_DOCFIND_MERGE;
    *puBGPopupMergeMenu = 0;
    return S_OK;
}

STDMETHODIMP CFindFilter::GetItemContextMenu(HWND hwndOwner, IFindFolder* pdfFolder, IContextMenu **ppcm)
{
    return CFindItem_Create(hwndOwner, pdfFolder, ppcm);
}

STDMETHODIMP CFindFilter::GetDefaultSearchGUID(IShellFolder2 *psf2, GUID *pGuid)
{
    return DefaultSearchGUID(pGuid);
}

STDMETHODIMP CFindFilter::EnumSearches(IShellFolder2 *psf2, IEnumExtraSearch **ppenum)
{
    *ppenum = NULL;
    return  E_NOTIMPL;
}

STDMETHODIMP CFindFilter::GetSearchFolderClassId(GUID *pGuid)
{
    *pGuid = CLSID_DocFindFolder;
    return S_OK;
}

// (returns S_OK if nothing changed.)
STDMETHODIMP CFindFilter::FFilterChanged()
{
    BOOL fFilterChanged = _fFilterChanged;
    this->_fFilterChanged = FALSE;
    return fFilterChanged ? S_FALSE : S_OK;
}

// Generates the title given the current search criteria.
STDMETHODIMP CFindFilter::GenerateTitle(LPTSTR *ppszTitle, BOOL fFileName)
{
    BOOL   fFilePattern;
    int    iRes;
    TCHAR  szFindName[80];    // German should not exceed this find: ->???
    LPTSTR pszFileSpec = _szUserInputFileSpec;
    LPTSTR pszText     = _szText;

    //
    // Lets generate a title for the search.  The title will depend on
    // the file patern(s), the type field and the containing text field
    // Complicate this a bit with the search for field...
    //

    fFilePattern = (pszFileSpec[0] != 0) &&
                (lstrcmp(pszFileSpec, c_szStarDotStar) != 0);

    if (!fFilePattern && (_penumAsync == NULL) && _pszIndexedSearch)
    {
        pszFileSpec = _pszIndexedSearch;
        fFilePattern = (pszFileSpec[0] != 0) &&
                    (lstrcmp(pszFileSpec, c_szStarDotStar) != 0);
    }

    if ((pszText[0] == 0) && (_penumAsync != NULL) && _pszIndexedSearch)
        pszText = _pszIndexedSearch;

    // First see if there is a type field
    if (_iType > 0)
    {
        // We have a type field no check for content...
        if (pszText[0] != 0)
        {
            // There is text!
            // Should now use type but...
            // else see if the name field is not NULL and not *.*
            if (fFilePattern)
                iRes = IDS_FIND_TITLE_TYPE_NAME_TEXT;
            else
                iRes = IDS_FIND_TITLE_TYPE_TEXT;
        }
        else
        {
            // No type or text, see if file pattern
            // Containing not found, first search for type then named
            if (fFilePattern)
                iRes = IDS_FIND_TITLE_TYPE_NAME;
            else
                iRes = IDS_FIND_TITLE_TYPE;
        }
    }
    else
    {
        // No Type field ...
        // first see if there is text to be searched for!
        if (pszText[0] != 0)
        {
            // There is text!
            // Should now use type but...
            // else see if the name field is not NULL and not *.*
            if (fFilePattern)
                iRes = IDS_FIND_TITLE_NAME_TEXT;
            else
                iRes = IDS_FIND_TITLE_TEXT;
        }
        else
        {
            // No type or text, see if file pattern
            // Containing not found, first search for type then named
            if (fFilePattern)
                iRes = IDS_FIND_TITLE_NAME;
            else
                iRes = IDS_FIND_TITLE_ALL;
        }
    }


    // We put : in for first spot for title bar.  For name creation
    // we remove it which will put the number at the end...
    if (!fFileName)
        LoadString(HINST_THISDLL, IDS_FIND_TITLE_FIND,
                szFindName, ARRAYSIZE(szFindName));
    *ppszTitle = ShellConstructMessageString(HINST_THISDLL,
            MAKEINTRESOURCE(iRes),
            fFileName? szNULL : szFindName,
            _szTypeName, pszFileSpec, pszText);

    return *ppszTitle ? S_OK : E_OUTOFMEMORY;
}

STDMETHODIMP CFindFilter::ClearSearchCriteria()
{
    // Also clear out a few other fields...
    _szUserInputFileSpec[0] = 0;
    _iType = 0;
    _szText[0] = 0;

    return S_OK;
}

STDMETHODIMP CFindFilter::PrepareToEnumObjects(HWND hwnd, DWORD *pdwFlags)
{
    *pdwFlags = 0;  // start out empty

    _hwnd = hwnd;   // used for the first enum so that can do UI (auth/insert media)

    // Update the flags and buffer strings
    if (!_fTopLevelOnly)
        *pdwFlags |= DFOO_INCLUDESUBDIRS;

    if (_fTextCaseSen)
        *pdwFlags |= DFOO_CASESEN;
        
    if (_fSearchSystemDirs)
        *pdwFlags |= DFOO_SEARCHSYSTEMDIRS;

    // Also get the shell state variables to see if we should show extensions and the like
    if (_fSearchHidden)
        *pdwFlags |= DFOO_SHOWALLOBJECTS;

    // Now lets generate the file patern we will ask the system to look for
    
    // Here is where we try to put some smarts into the file patterns stuff
    // It will go something like:
    // look between each; or , and see if there are any wild cards.  If not
    // do something like *patern*.
    // Also if there is no search pattern or if it is * or *.*, set the
    // filter to NULL as to speed it up.
    //

    _fANDSearch = SetupWildCardingOnFileSpec(_szUserInputFileSpec, &_pszFileSpec);

    _cFileSpecs = 0;
    if (_pszFileSpec && _pszFileSpec[0])
    {
        Str_SetPtr(&_pszSpecs, _pszFileSpec);

        if (_pszSpecs)
        {
            int cTokens = 0;
            LPTSTR pszToken = _pszSpecs;
            // Count number of file spces
            while (pszToken)
            {
                // let's walk pszFileSpec to see how many specs we have...
                pszToken = StrChr(pszToken, TEXT(';'));

                // If delimiter, then advance past for next iteration
                if (pszToken)
                    pszToken++;
                cTokens++;
            }

            if (cTokens)
            {
                // cleanup the previous search
                if (_apszFileSpecs)
                    LocalFree(_apszFileSpecs);
                _apszFileSpecs = (LPTSTR *)LocalAlloc(LPTR, cTokens * sizeof(LPTSTR *));
                if (_apszFileSpecs)
                {
                    _cFileSpecs = cTokens;
                    pszToken = _pszSpecs;
                    for (int i = 0; i < cTokens; i++)
                    {
                        _apszFileSpecs[i] = pszToken;
                        pszToken = StrChr(pszToken, TEXT(';'));
                        if (pszToken)
                            *pszToken++ = 0;
                    }
                }
            }
        }
    }

    _filtgrep.Reset();
    
    HRESULT hr = S_OK;
    if (_szText[0])
    {
        DWORD dwGrepFlags = FGIF_BLANKETGREP | FGIF_GREPFILENAME;
        if (*pdwFlags & DFOO_CASESEN)
            dwGrepFlags |= FGIF_CASESENSITIVE;

        hr = _filtgrep.Initialize(GetACP(), _szText, NULL, dwGrepFlags);
    }
    return hr;
}

STDMETHODIMP CFindFilter::GetColumnsFolder(IShellFolder2 **ppsf)
{
    *ppsf = NULL;
    LPITEMIDLIST pidl;
    HRESULT hr = SHGetFolderLocation(NULL, CSIDL_PERSONAL | CSIDL_FLAG_CREATE, NULL, 0, &pidl);
    if (SUCCEEDED(hr))
    {
        hr = SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder2, pidl, ppsf));
        ILFree(pidl);
    }
    return hr;
}

void FreePathArray(LPTSTR rgpszPaths[], UINT cPaths)
{
    for (UINT i = 0; i < cPaths; i++)
    {
        LocalFree((HLOCAL)rgpszPaths[i]);
        rgpszPaths[i] = NULL;
    }
}

HRESULT NamesFromEnumIDList(IEnumIDList *penum, LPTSTR rgpszPaths[], UINT sizePaths, UINT *pcPaths)
{
    *pcPaths = 0;
    ZeroMemory(rgpszPaths, sizeof(rgpszPaths[0]) * sizePaths);

    penum->Reset();

    LPITEMIDLIST pidl;
    while (S_OK == penum->Next(1, &pidl, NULL))
    {
        TCHAR szPath[MAX_PATH];

        if (SUCCEEDED(SHGetNameAndFlags(pidl, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), NULL)))
        {
            if ((*pcPaths) < sizePaths)
            {
                rgpszPaths[*pcPaths] = StrDup(szPath);
                if (rgpszPaths[*pcPaths])
                    (*pcPaths)++;
            }
        }
        ILFree(pidl);
    }
    return S_OK;
}

void ClearIDArray(LPITEMIDLIST rgItems[], UINT cItems)
{
    for (UINT i = 0; i < cItems; i++)
    {
        ILFree(rgItems[i]);
        rgItems[i] = NULL;
    }
}

#define MAX_ROOTS   32

HRESULT FilterEnumeratorByNames(const LPCTSTR rgpszNames[], UINT cNames, IEnumIDList **ppenum)
{
    LPITEMIDLIST rgItems[MAX_ROOTS] = {0};
    int cItems = 0;

    (*ppenum)->Reset();
    // capture all of the other pidls in the current enumerator
    LPITEMIDLIST pidl;
    while (S_OK == (*ppenum)->Next(1, &pidl, NULL))
    {
        TCHAR szPath[MAX_PATH];
        if (SUCCEEDED(SHGetNameAndFlags(pidl, SHGDN_FORPARSING, szPath, ARRAYSIZE(szPath), NULL)))
        {
            for (UINT i = 0; i < cNames; i++)
            {
                if (rgpszNames[i] &&
                    (cItems < ARRAYSIZE(rgItems)) &&
                    (0 == StrCmpIC(szPath, rgpszNames[i])))
                {
                    rgItems[cItems++] = pidl;
                    pidl = NULL;    // don't free below
                    break;
                }
            }
        }
        ILFree(pidl);   // may be NULL
    }

    IEnumIDList *penum;
    if (SUCCEEDED(CreateIEnumIDListOnIDLists(rgItems, cItems, &penum)))
    {
        (*ppenum)->Release();
        *ppenum = penum;
    }

    ClearIDArray(rgItems, cItems);

    return S_OK;
}

HRESULT CFindFilter::_ScopeEnumerator(IEnumIDList **ppenum)
{
    *ppenum = NULL;
    HRESULT hr = E_FAIL;
    if (_penumRoots)
    {
        hr = _penumRoots->Clone(ppenum);
        if (SUCCEEDED(hr))
            (*ppenum)->Reset(); // clone above will clone the index as well
    }
    return hr;
}

//==========================================================================
//add helper funtion to check if the Path is restricted (WinseBUG 20189)
//==========================================================================
BOOL PathIsRestricted(TCHAR * szPath, RESTRICTIONS iFlag)
{
      UINT driveNum, dwRest;

      if((driveNum = PathGetDriveNumber(szPath)) != -1){
        dwRest = SHRestricted(iFlag);
        if (dwRest & (1 << driveNum))
        {
            return TRUE;
        }
      }
      return FALSE;
}

void FilterNoViewDrives(LPTSTR rgpszNames[], UINT *pcNames)
{
    UINT cNames = *pcNames;
    UINT cNamesResult = 0;

    for (UINT iName = 0; iName < cNames; iName++)
    {
        if (PathIsRestricted(rgpszNames[iName], REST_NOVIEWONDRIVE))
        {
            LocalFree((HLOCAL)rgpszNames[iName]);
            rgpszNames[iName] = NULL;
        }
        else
        {
            rgpszNames[cNamesResult++] = rgpszNames[iName];
        }
    }
    *pcNames = cNamesResult;
}

// produce the find enumerator

STDMETHODIMP CFindFilter::EnumObjects(IShellFolder *psf, LPCITEMIDLIST pidlStart,
                                      DWORD grfFlags, int iColSort, LPTSTR pszProgressText,  
                                      IRowsetWatchNotify *prwn, IFindEnum **ppdfenum)
{
    *ppdfenum = NULL;

    HRESULT hr;
    IEnumIDList *penum;
    if (pidlStart)
    {
        hr = CreateIEnumIDListOnIDLists(&pidlStart, 1, &penum);
    }
    else
    {
        hr = _ScopeEnumerator(&penum);
    }
    if (SUCCEEDED(hr))
    {
        UINT cPaths;
        LPTSTR rgpszPaths[MAX_ROOTS];
        hr = NamesFromEnumIDList(penum, rgpszPaths, ARRAYSIZE(rgpszPaths), &cPaths);
        if (SUCCEEDED(hr)) 
        {
            FilterNoViewDrives(rgpszPaths, &cPaths);

            *ppdfenum = NULL;

            if (cPaths > 0)
            {
                hr = CreateOleDBEnum(this, psf, rgpszPaths, &cPaths, grfFlags, iColSort, pszProgressText, prwn, ppdfenum);
                if (S_OK == hr && *ppdfenum != NULL)
                {
                    _penumAsync = *ppdfenum;
                    _penumAsync->AddRef();
                }
                else
                {
                    _penumAsync = NULL;
                }

                // are their more paths to process?
                if (cPaths)
                {
                    // did user specified CI query that we can't grep for?
                    DWORD dwFlags;
                    if (FAILED(GenerateQueryRestrictions(NULL, &dwFlags)) ||
                        !(dwFlags & GQR_REQUIRES_CI))
                    {
                        FilterEnumeratorByNames(rgpszPaths, ARRAYSIZE(rgpszPaths), &penum);

                        IFindEnum *pdfenum = new CNamespaceEnum(
                            SAFECAST(this, IFindFilter *), psf, *ppdfenum,
                            penum, _hwnd, grfFlags, pszProgressText);
                        if (pdfenum)
                        {
                            // The rest of the fields should be zero/NULL
                            *ppdfenum = pdfenum;
                            hr = S_OK;
                        }
                        else
                        {
                            hr = E_OUTOFMEMORY;
                        }
                    }
                }
            }
            FreePathArray(rgpszPaths, cPaths);
        }
        penum->Release();
    }
    return hr;
}

// IFindFilter::MatchFilter

STDMETHODIMP_(BOOL) CFindFilter::MatchFilter(IShellFolder *psf, LPCITEMIDLIST pidl)
{
    BOOL bMatch = TRUE;
    TCHAR szName[MAX_PATH], szDisplayName[MAX_PATH];
    DWORD dwAttrib = SHGetAttributes(psf, pidl, SFGAO_HIDDEN | SFGAO_FOLDER | SFGAO_ISSLOW);
    
    if (SUCCEEDED(DisplayNameOf(psf, pidl, SHGDN_INFOLDER | SHGDN_FORPARSING, szName, ARRAYSIZE(szName))) &&
        SUCCEEDED(DisplayNameOf(psf, pidl, SHGDN_INFOLDER | SHGDN_NORMAL, szDisplayName, ARRAYSIZE(szDisplayName))))
    {
        IShellFolder2 *psf2;
        psf->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2)); // optional, may be NULL
        
        // First things we dont show hidden files
        // If show all is set then we should include hidden files also...
        
        if (!_fSearchHidden && (SFGAO_HIDDEN & dwAttrib))
            bMatch = FALSE;     // does not match
        
        if (bMatch && _fFoldersOnly && !(SFGAO_FOLDER & dwAttrib))
            bMatch = FALSE;     // does not match
        
        if (bMatch && _iSizeType)
        {
            ULONGLONG ullSize;
            if (psf2 && SUCCEEDED(GetLongProperty(psf2, pidl, &_scidSize, &ullSize)))
            {
                if (1 == _iSizeType)        // >
                {
                    if (!(ullSize > _ullSize))
                        bMatch = FALSE;     // does not match
                }
                else if (2 == _iSizeType)   // <
                {
                    if (!(ullSize < _ullSize))
                        bMatch = FALSE;     // does not match
                }
            }
            else
            {
                bMatch = FALSE;
            }
        }
        
        if (bMatch && (_scidDate.fmtid != CLSID_NULL))
        {
            FILETIME ft;
            if (psf2 && SUCCEEDED(GetDateProperty(psf2, pidl, &_scidDate, &ft)))
            {
                FILETIME ftLocal;
                FileTimeToLocalFileTime(&ft, &ftLocal);

                WORD wFileDate = 0, wFileTime = 0;
                FileTimeToDosDateTime(&ftLocal, &wFileDate, &wFileTime);
            
                if (_dateModifiedBefore && !(wFileDate <= _dateModifiedBefore))
                    bMatch = FALSE;     // does not match
            
                if (_dateModifiedAfter && !(wFileDate >= _dateModifiedAfter))
                    bMatch = FALSE;     // does not match
            }
            else
            {
                bMatch = FALSE;
            }
        }
        
        // Match file specificaitions.
        if (bMatch && _pszFileSpec && _pszFileSpec[0])
        {
            // if we have split up version of the specs we'll use it because PathMatchSpec
            // can take up to 5-6 hours for more than 10 wildcard specs
            if (_cFileSpecs)
            {
                // Only search the actual file system file name if the user specified 
                // an extention
                BOOL bHasExtension = (0 != *PathFindExtension(_pszFileSpec));
                if (bHasExtension)
                {
                    for (int i = 0; i < _cFileSpecs; i++)
                    {
                        bMatch = PathMatchSpec(szName, _apszFileSpecs[i]);
                        if (_fANDSearch)
                        {
                            // AND we quit on the first one that doesn't match
                            if (!bMatch)
                                break;
                        }
                        else
                        {
                            // OR we quit on the first one that does match
                            if (bMatch)
                                break;
                        }
                    }
                }
                
                // Compare the displayable name to the filter.
                // This is needed for searching the recylcle bin becuase the actual file names
                // are similar to "DC0.LNK" instead of "New Text Document.txt"
                if (!bMatch || !bHasExtension)
                {
                    for (int i = 0; i < _cFileSpecs; i++)
                    {
                        bMatch = PathMatchSpec(szDisplayName, _apszFileSpecs[i]);
                        if (_fANDSearch)
                        {
                            // AND we quit on the first one that doesn't match
                            if (!bMatch)
                                break;
                        }
                        else
                        {
                            // OR we quit on the first one that does match
                            if (bMatch)
                                break;
                        }
                    }
                }
            }
            else if (!PathMatchSpec(szName, _pszFileSpec) 
                && !PathMatchSpec(szDisplayName, _pszFileSpec))
            {
                bMatch = FALSE;     // does not match
            }
        }
        
        if (bMatch && _strTypeFilePatterns[0])
        {
            // if looking for folders only and file pattern is all folders then no need to check
            // if folder name matches the pattern -- we know it is the folder, otherwise we
            // would have bailed out earlier in the function
            if (!(_fFoldersOnly && lstrcmp(_strTypeFilePatterns, TEXT(".")) == 0))
            {
                if (!PathMatchSpec(szName, _strTypeFilePatterns))
                    bMatch = FALSE;     // does not match
            }
        }
        
        // See if we need to do a grep of the file
        if (bMatch && (SFGAO_ISSLOW & dwAttrib) && !_fSearchSlowFiles)
            bMatch = FALSE;     // does not match
        
        if (bMatch && 
            (S_OK == _filtgrep.GetMatchTokens(NULL, 0) || 
             S_OK == _filtgrep.GetExcludeTokens(NULL, 0)))
        {
            bMatch = (S_OK == _filtgrep.Grep(psf, pidl, szName));
        }
        
        if (psf2)
            psf2->Release();
    }
    else
        bMatch = FALSE;
    return bMatch;    // return TRUE -> yes, a match!
}

// date ordinal mapper helpers to deal with old way to refer to dates

BOOL MapValueToDateSCID(UINT i, SHCOLUMNID *pscid)
{
    ZeroMemory(pscid, sizeof(*pscid));

    switch (i)
    {
    case 1:
        *pscid = SCID_WRITETIME;
        break;
    case 2:
        *pscid = SCID_CREATETIME;
        break;
    case 3:
        *pscid = SCID_ACCESSTIME;
        break;

    default:
        return FALSE;
    }
    return TRUE;
}

// returns 0 as invalid ordinal

int MapDateSCIDToValue(const SHCOLUMNID *pscid)
{
    int i = 0;  // 0 invalid scid

    if (IsEqualSCID(*pscid, SCID_WRITETIME))
    {
        i = 1;
    }
    else if (IsEqualSCID(*pscid, SCID_CREATETIME))
    {
        i = 2;
    }
    else if (IsEqualSCID(*pscid, SCID_ACCESSTIME))
    {
        i = 3;
    }
    return i;
}


// IFindFilter::SaveCriteria

// util.cpp
STDAPI_(int) Int64ToString(LONGLONG n, LPTSTR szOutStr, UINT nSize, BOOL bFormat,
                           NUMBERFMT *pFmt, DWORD dwNumFmtFlags);
#define MAX_ULONGLONG_LEN 20+1 // "18446744073709551616"

STDMETHODIMP CFindFilter::SaveCriteria(IStream * pstm, WORD fCharType)
{
    TCHAR szTemp[40];    // some random size

    // The caller should have already validated the stuff and updated
    // everything for the current filter information.

    // we need to walk through and check each of the items to see if we
    // have a criteria to save away. this includes:
    //      (Name, Path, Type, Contents, size, modification dates)
    int cCriteria = _SaveCriteriaItem(pstm, IDD_FILESPEC, _szUserInputFileSpec, fCharType);

    cCriteria += _SaveCriteriaItem(pstm, IDD_PATH, _szPath, fCharType);

    cCriteria += _SaveCriteriaItem(pstm, DFSC_SEARCHFOR, _pszIndexedSearch, fCharType);
    cCriteria += _SaveCriteriaItem(pstm, IDD_TYPECOMBO, _strTypeFilePatterns, fCharType);
    cCriteria += _SaveCriteriaItem(pstm, IDD_CONTAINS, _szText, fCharType);
    
    // Also save away the state of the top level only
    wsprintf(szTemp, TEXT("%d"), _fTopLevelOnly);
    cCriteria += _SaveCriteriaItem(pstm, IDD_TOPLEVELONLY, szTemp, fCharType);

    // The Size field is little more fun!
    if (_iSizeType != 0)
    {
        WCHAR szNum[MAX_ULONGLONG_LEN];
        Int64ToString(_ullSize, szNum, ARRAYSIZE(szNum), FALSE, NULL, 0);
        wsprintf(szTemp, TEXT("%d %ws"), _iSizeType, szNum);
        cCriteria += _SaveCriteriaItem(pstm, IDD_SIZECOMP, szTemp, fCharType);
    }

    // Likewise for the dates, should be fun as we need to save it depending on
    // how the date was specified
    switch (_wDateType & DFF_DATE_RANGEMASK)
    {
    case DFF_DATE_ALL:
        // nothing to store
        break;
    case DFF_DATE_DAYS:
        wsprintf(szTemp, TEXT("%d"), _wDateValue);
        cCriteria += _SaveCriteriaItem(pstm, IDD_MDATE_NUMDAYS, szTemp, fCharType);
        break;
    case DFF_DATE_MONTHS:
        wsprintf(szTemp, TEXT("%d"), _wDateValue);
        cCriteria += _SaveCriteriaItem(pstm, IDD_MDATE_NUMMONTHS, szTemp, fCharType);
        break;
    case DFF_DATE_BETWEEN:
        if (_dateModifiedAfter)
        {
            wsprintf(szTemp, TEXT("%d"), _dateModifiedAfter);
            cCriteria += _SaveCriteriaItem(pstm, IDD_MDATE_FROM, szTemp, fCharType);
        }

        if (_dateModifiedBefore)
        {
            wsprintf(szTemp, TEXT("%d"), _dateModifiedBefore);
            cCriteria += _SaveCriteriaItem(pstm, IDD_MDATE_TO, szTemp, fCharType);
        }
        break;
    }

    if ((_wDateType & DFF_DATE_RANGEMASK) != DFF_DATE_ALL)
    {
        int i = MapDateSCIDToValue(&_scidDate);
        if (i)
        {
            // strangly we write a 0 based version of this ordinal out
            wsprintf(szTemp, TEXT("%d"), i - 1);
            cCriteria += _SaveCriteriaItem(pstm, IDD_MDATE_TYPE, szTemp, fCharType);
        }
    }

    if (_fTextCaseSen)
    {
        wsprintf(szTemp, TEXT("%d"), _fTextCaseSen);
        cCriteria += _SaveCriteriaItem(pstm, IDD_TEXTCASESEN, szTemp, fCharType);
    }

    if (_fTextReg)
    {
        wsprintf(szTemp, TEXT("%d"), _fTextReg);
        cCriteria += _SaveCriteriaItem(pstm, IDD_TEXTREG, szTemp, fCharType);
    }

    if (_fSearchSlowFiles)
    {
        wsprintf(szTemp, TEXT("%d"), _fSearchSlowFiles);
        cCriteria += _SaveCriteriaItem(pstm, IDD_SEARCHSLOWFILES, szTemp, fCharType);
    }

    //  Save value for searching system directories.
    if (_fSearchSystemDirs)
    {
        wsprintf(szTemp, TEXT("%d"), _fSearchSystemDirs);
        cCriteria += _SaveCriteriaItem(pstm, IDD_SEARCHSYSTEMDIRS, szTemp, fCharType);
    }

    if (_fSearchHidden)
    {
        wsprintf(szTemp, TEXT("%d"), _fSearchHidden);
        cCriteria += _SaveCriteriaItem(pstm, IDD_SEARCHHIDDEN, szTemp, fCharType);
    }

    return MAKE_SCODE(0, 0, cCriteria);
}


// Helper function for save criteria that will output the string and
// and id to the specified file.  it will also test for NULL and the like

int CFindFilter::_SaveCriteriaItem(IStream *pstm, WORD wNum, LPCTSTR psz, WORD fCharType)
{
    if ((psz == NULL) || (*psz == 0))
        return 0;
    else
    {
        const void *pszText = (const void *)psz; // Ptr to output text. Defaults to source.
        // These are required to support ANSI-unicode conversions.
        LPSTR pszAnsi  = NULL; // For unicode-to-ansi conversion.
        LPWSTR pszWide = NULL; // For ansi-to-unicode conversion.
        DFCRITERIA dfc;
        dfc.wNum = wNum;
        
        // Note: Problem if string is longer than 64K
        dfc.cbText = (WORD) ((lstrlen(psz) + 1) * sizeof(TCHAR));
        
        // Source string is Unicode but caller wants to save as ANSI.
        //
        if (DFC_FMT_ANSI == fCharType)
        {
            // Convert to ansi and write ansi.
            dfc.cbText = (WORD) WideCharToMultiByte(CP_ACP, 0L, psz, -1, pszAnsi, 0, NULL, NULL);
            
            pszAnsi = (LPSTR)LocalAlloc(LMEM_FIXED, dfc.cbText);
            if (pszAnsi)
            {
                WideCharToMultiByte(CP_ACP, 0L, psz, -1, pszAnsi, dfc.cbText / sizeof(pszAnsi[0]), NULL, NULL);
                pszText = (void *)pszAnsi;
            }
        }
        
        pstm->Write(&dfc, sizeof(dfc), NULL);       // Output index
        pstm->Write(pszText, dfc.cbText, NULL);     // output string + NULL
        
        // Free up conversion buffers if any were created.
        if (pszAnsi)
            LocalFree(pszAnsi);
        if (pszWide)
            LocalFree(pszWide);
    }
    
    return 1;
}

// IFindFilter::RestoreCriteria
STDMETHODIMP CFindFilter::RestoreCriteria(IStream *pstm, int cCriteria, WORD fCharType)
{
    SHSTR strTemp;
    SHSTRA strTempA;

    if (cCriteria > 0)
        _fWeRestoredSomeCriteria = TRUE;

    while (cCriteria--)
    {
        DFCRITERIA dfc;
        DWORD cb;

        if (FAILED(pstm->Read(&dfc, sizeof(dfc), &cb)) || cb != sizeof(dfc))
            break;

        if (DFC_FMT_UNICODE == fCharType)
        {
           // Destination is Unicode and we're reading Unicode data from stream.
           // No conversion required.
           if (FAILED(strTemp.SetSize(dfc.cbText / sizeof(TCHAR))) ||
               FAILED(pstm->Read(strTemp.GetInplaceStr(), dfc.cbText, &cb))
                   || (cb != dfc.cbText))
               break;
        }
        else
        {
           // Destination is Unicode but we're reading ANSI data from stream.
           // Read ansi.  Convert to unicode.
           if (FAILED(strTempA.SetSize(dfc.cbText / sizeof(CHAR))) ||
               FAILED(pstm->Read(strTempA.GetInplaceStr(), dfc.cbText, &cb))
                   || (cb != dfc.cbText))
               break;

           strTemp.SetStr(strTempA);
        }

        switch (dfc.wNum)
        {
        case IDD_FILESPEC:
            lstrcpyn(_szUserInputFileSpec, strTemp, ARRAYSIZE(_szUserInputFileSpec));
            break;

        case DFSC_SEARCHFOR:
            Str_SetPtr(&_pszIndexedSearch, strTemp);
            break;

        case IDD_PATH:
            _ResetRoots();
            lstrcpyn(_szPath, strTemp, ARRAYSIZE(_szPath));
            CreateIEnumIDListPaths(_szPath, &_penumRoots);
            break;

        case IDD_TOPLEVELONLY:
            _fTopLevelOnly = StrToInt(strTemp);
            break;

        case IDD_TYPECOMBO:
            _strTypeFilePatterns.SetStr(strTemp);
            break;

        case IDD_CONTAINS:
            lstrcpyn(_szText, strTemp, ARRAYSIZE(_szText));
            break;

        case IDD_SIZECOMP:
            // we need to extract off the two parts, the type and
            // the value

            _iSizeType = strTemp[0] - TEXT('0');
            StrToInt64Ex(&(strTemp.GetStr())[2], STIF_DEFAULT, (LONGLONG*)&_ullSize);
            break;

        case IDD_MDATE_NUMDAYS:
            _wDateType = DFF_DATE_DAYS;
            _wDateValue = (WORD) StrToInt(strTemp);
            break;

        case IDD_MDATE_NUMMONTHS:
            _wDateType = DFF_DATE_MONTHS;
            _wDateValue = (WORD) StrToInt(strTemp);
            break;

        case IDD_MDATE_FROM:
            _wDateType = DFF_DATE_BETWEEN;
            _dateModifiedAfter = (WORD) StrToInt(strTemp);
            break;

        case IDD_MDATE_TO:
            _wDateType = DFF_DATE_BETWEEN;
            _dateModifiedBefore = (WORD) StrToInt(strTemp);
            break;

        case IDD_MDATE_TYPE:
            // persisted value is zero based, adjust that by adding 1
            MapValueToDateSCID(StrToInt(strTemp) + 1, &_scidDate);
            break;

        case IDD_TEXTCASESEN:
            _fTextCaseSen = StrToInt(strTemp);
            break;

        case IDD_TEXTREG:
            _fTextReg = StrToInt(strTemp);
            break;

        case IDD_SEARCHSLOWFILES:
            _fSearchSlowFiles = StrToInt(strTemp);
            break;
            
        case IDD_SEARCHSYSTEMDIRS:
            _fSearchSystemDirs = StrToInt(strTemp);
            break;
        }
    }
    return S_OK;
}

// IFindFilter::GetColSaveStream

STDMETHODIMP CFindFilter::GetColSaveStream(WPARAM wParam, IStream **ppstm)
{
    *ppstm = OpenRegStream(HKEY_CURRENT_USER, REGSTR_PATH_EXPLORER, TEXT("DocFindColsX"), (DWORD) wParam);
    return *ppstm ? S_OK : E_FAIL;
}

void CFindFilter::_GenerateQuery(LPWSTR pwszQuery, DWORD *pcchQuery)
{
    DWORD cchNeeded = 0, cchLeft = *pcchQuery;
    LPWSTR pszCurrent = pwszQuery;
    BOOL bFirst = TRUE; // first property

    if (_pszFileSpec && _pszFileSpec[0])
    {
        cchNeeded += _CIQueryFilePatterns(&bFirst, &cchLeft, &pszCurrent, _pszFileSpec);
    }

    // fFoldersOnly = TRUE implies szTypeFilePatterns = "."
    // we cannot pass "." to CI because they won't understand it as give me the folder types
    // we could check for @attrib ^a FILE_ATTRIBUTE_DIRECTORY (0x10) but ci doesn't index the 
    // folder names by default so we normally won't get any results...

    if (!_fFoldersOnly && _strTypeFilePatterns[0])
    {
        cchNeeded += _CIQueryFilePatterns(&bFirst, &cchLeft, &pszCurrent, _strTypeFilePatterns);
    }
    
    // Date:
    if (_dateModifiedBefore)
    {           
        cchNeeded += _QueryDosDate(&bFirst, &cchLeft, &pszCurrent, _dateModifiedBefore, TRUE);
    }
    
    if (_dateModifiedAfter)
    {
        cchNeeded += _QueryDosDate(&bFirst, &cchLeft, &pszCurrent, _dateModifiedAfter, FALSE);
    }

    if (_iSizeType)
    {
        cchNeeded += _CIQuerySize(&bFirst, &cchLeft, &pszCurrent, _ullSize, _iSizeType);
    }

    // Indexed Search: raw query
    if (_pszIndexedSearch && _pszIndexedSearch[0])
    {
        // HACK Alert if first Char is ! then we assume Raw and pass it through directly to CI...
        // Likewise if it starts with @ or # pass through, but remember the @...
        cchNeeded += _CIQueryIndex(&bFirst, &cchLeft, &pszCurrent, _pszIndexedSearch);
    }

    // Containing Text:
    if (_szText[0])
    {
        // Try not to quote the strings unless we need to.  This allows more flexability to do the
        // searching for example: "cat near dog" is different than: cat near dog
        cchNeeded += _CIQueryTextPatterns(&bFirst, &cchLeft, &pszCurrent, _szText, _fTextReg);
    }

    cchNeeded += _CIQueryShellSettings(&bFirst, &cchLeft, &pszCurrent);

    IEnumIDList *penum;
    if (SUCCEEDED(_ScopeEnumerator(&penum)))
    {
        TCHAR szPath[MAX_PATH];

        LPITEMIDLIST pidl;
        while (S_OK == penum->Next(1, &pidl, NULL))
        {
            if (SHGetPathFromIDList(pidl, szPath) && PathStripToRoot(szPath))
            {
                // don't search recycle bin folder. we add both nt4's recycled 
                // and nt5's recycler for every drive we search.
                static const LPCTSTR s_rgszRecycleBins[] = 
                { 
                    TEXT("Recycled\\*"), 
                    TEXT("Recycler\\*"), 
                };

                for (int iBin = 0; iBin < ARRAYSIZE(s_rgszRecycleBins); iBin++)
                {
                    TCHAR szExclude[MAX_PATH];
                    if (PathCombine(szExclude, szPath, s_rgszRecycleBins[iBin]))
                    {
                        DWORD cchSize = lstrlen(szExclude) + ARRAYSIZE(TEXT(" & !#PATH "));

                        // don't bail out early if we are asked for size of query
                        if (pwszQuery && cchSize > cchLeft)
                            break;

                        cchNeeded += _AddToQuery(&pszCurrent, &cchLeft, TEXT(" & !#PATH "));
                        cchNeeded += _AddToQuery(&pszCurrent, &cchLeft, szExclude);
                    }
                }
            }
            ILFree(pidl);
        }
        penum->Release();
    }

    // we must exclude the special folders from the results or ci will find items that 
    // we cannot get pidls for.
    HKEY hkey;
    if (RegOpenKeyEx(HKEY_CURRENT_USER, CI_SPECIAL_FOLDERS, 0, KEY_READ, &hkey) == ERROR_SUCCESS)
    {
        DWORD cValues = 0; // init to zero in case query info bellow fails
    
        RegQueryInfoKey(hkey, NULL, NULL, NULL, NULL, NULL, NULL, &cValues, NULL, NULL, NULL, NULL);
        for (DWORD i = 0; i < cValues; i++)
        {
            TCHAR szExcludePath[MAX_PATH];
            DWORD cb = sizeof(szExcludePath);

            TCHAR szName[10];
            wsprintf(szName, TEXT("%d"), i);
            if (RegQueryValueEx(hkey, szName, NULL, NULL, (BYTE *)szExcludePath, &cb) == ERROR_SUCCESS)
            {
                // this is in the query (or a drive letter of the query)

                DWORD cchSize = lstrlen(szExcludePath) + ARRAYSIZE(TEXT(" & !#PATH "));

                // don't bail out early if we are asked for size of query
                if (pwszQuery && cchSize > cchLeft)
                    break;

                cchNeeded += _AddToQuery(&pszCurrent, &cchLeft, TEXT(" & !#PATH "));
                cchNeeded += _AddToQuery(&pszCurrent, &cchLeft, szExcludePath);
            }
        }
        RegCloseKey(hkey);
    }

    // we need at least some constraints so give a query of "all files"

    if (pwszQuery && pszCurrent == pwszQuery)
        _CIQueryFilePatterns(&bFirst, &cchLeft, &pszCurrent, L"*.*");

    if (pszCurrent)
    {
        // Make sure we terminate the string at the end...
        *pszCurrent = 0;
    }

    if (!pwszQuery)
    {
        *pcchQuery = cchNeeded;
    }
    else
    {
        ASSERT(*pcchQuery > cchNeeded);
    }
}

// Create a query command string out of the search criteria

STDMETHODIMP CFindFilter::GenerateQueryRestrictions(LPWSTR *ppwszQuery, DWORD *pdwQueryRestrictions)
{
    // we should be able to make use of ci no matter what (exceptions at the end of the function)
    DWORD dwQueryRestrictions = GQR_MAKES_USE_OF_CI; 
    HRESULT hr = S_OK;

#ifdef DEBUG
    if (GetKeyState(VK_SHIFT) < 0)
    {
        dwQueryRestrictions |= GQR_REQUIRES_CI;
    }
#endif

    if (ppwszQuery)
    {
        DWORD cchNeeded = 0;
        _GenerateQuery(NULL, &cchNeeded);
        cchNeeded++;  // for \0
        
        *ppwszQuery = (LPWSTR)LocalAlloc(LPTR, cchNeeded * sizeof(**ppwszQuery));
        if (*ppwszQuery)
        {
            _GenerateQuery(*ppwszQuery, &cchNeeded);
        }
        else
        {
            hr = E_OUTOFMEMORY;
        }
    }

    if (SUCCEEDED(hr))
    {
        if (_pszIndexedSearch && _pszIndexedSearch[0])
            dwQueryRestrictions |= GQR_REQUIRES_CI;

        // ci is not case sensitive, so if user wanted case sensitive search we cannot use ci
        // also ci doesn't index folder names by default so to be safe we just default to our
        // disk traversal algorithm...
        if (_fTextCaseSen || _fFoldersOnly)
        {    
            if ((dwQueryRestrictions & GQR_REQUIRES_CI) && _fTextCaseSen)
                hr = MAKE_HRESULT(3, FACILITY_SEARCHCOMMAND, SCEE_CASESENINDEX);
            else if (dwQueryRestrictions & GQR_MAKES_USE_OF_CI)
                dwQueryRestrictions &= ~GQR_MAKES_USE_OF_CI;
        }
    }
    *pdwQueryRestrictions = dwQueryRestrictions;  // return calculated Flags...
    return hr;
}

STDMETHODIMP CFindFilter::ReleaseQuery()
{
    ATOMICRELEASE(_penumAsync);
    return S_OK;
}

STDMETHODIMP CFindFilter::GetQueryLanguageDialect(ULONG* pulDialect)
{
    *pulDialect = _ulQueryDialect;
    return S_OK;
}

STDMETHODIMP CFindFilter::GetWarningFlags(DWORD* pdwWarningFlags)
{
    *pdwWarningFlags = _dwWarningFlags;
    return S_OK;
}

// Registering our interest in FS change notifications.
//
// In:
//   hwnd = window handle of the find dialog
//   uMsg = message to be sent to window when informing of notify

STDMETHODIMP CFindFilter::DeclareFSNotifyInterest(HWND hwnd, UINT uMsg)
{
    HDPA hdpa = DPA_Create(10);     // Used to manage list of pidls to add
    if (hdpa)
    {
        IEnumIDList *penum;
        if (SUCCEEDED(_ScopeEnumerator(&penum)))
        {
            LPITEMIDLIST pidl;
            while (S_OK == penum->Next(1, &pidl, NULL))
            {
                if (-1 == DPA_AppendPtr(hdpa, pidl))
                {
                    // Failed to add it, so free it.
                    ILFree(pidl);
                }
            }
            penum->Release();
        }
        // Eliminate any pidls in the hdpa that are children of other pidls.  
        // this is needed to prevent receiving the multiple updates for one change.
        // For example, if searching My Documents and C:\, then we will get 2 updates
        // for a change in My Documents if My Documents is on the C:\.            
        int cItems = DPA_GetPtrCount(hdpa);
        for (int iOuterLoop = 0; iOuterLoop < cItems - 1; iOuterLoop++)
        {
            LPITEMIDLIST pidlOuter = (LPITEMIDLIST) DPA_GetPtr(hdpa, iOuterLoop);
            for (int iInnerLoop = iOuterLoop + 1; 
                 pidlOuter && iInnerLoop < cItems; 
                 iInnerLoop++)
            {
                LPITEMIDLIST pidlInner = (LPITEMIDLIST) DPA_GetPtr(hdpa, iInnerLoop);
                if (pidlInner)
                {
                    if (ILIsParent(pidlInner, pidlOuter, FALSE))
                    {
                        // Since pidlInner is pidlOuter's parent, free pidlOuter and 
                        // don't register for events on it.
                        ILFree(pidlOuter);
                        pidlOuter = NULL;
                        DPA_SetPtr(hdpa, iOuterLoop, NULL);
                    } 
                    else if (ILIsParent(pidlOuter, pidlInner, FALSE))
                    {
                        // Since pidlOuter is pidlInner's parent, free pidlInner and 
                        // don't register for events on it.
                        ILFree(pidlInner);
                        pidlInner = NULL;
                        DPA_SetPtr(hdpa, iInnerLoop, NULL);
                    }
                }
            }
        }
        // Declare that we are interested in events on remaining pidls
        for (int iRegIndex = 0; iRegIndex < cItems; iRegIndex++)
        {
            SHChangeNotifyEntry fsne = {0};
            fsne.fRecursive = TRUE;

            fsne.pidl = (LPITEMIDLIST)DPA_GetPtr(hdpa, iRegIndex);
            if (fsne.pidl)
            {
                SHChangeNotifyRegister(hwnd, 
                                       SHCNRF_NewDelivery | SHCNRF_ShellLevel | SHCNRF_InterruptLevel,
                                       SHCNE_DISKEVENTS, uMsg, 1, &fsne);
                ILFree((LPITEMIDLIST)fsne.pidl);
            }
        }

        DPA_Destroy(hdpa);
    }
    return S_OK;
}

void CFindFilter::_UpdateTypeField(const VARIANT *pvar)
{
    LPCWSTR pszValue = VariantToStrCast(pvar);  // input needs to be a BSTR
    if (pszValue)
    {
        if (StrStr(pszValue, TEXT(".Folder;.")))
        {
            // Special searching for folders...
            _fFoldersOnly = TRUE;
            _strTypeFilePatterns.SetStr(TEXT("."));
        }
        else
        {
            // Assume if the first one is wildcarded than all are,...
            if (*pszValue == TEXT('*'))
                _strTypeFilePatterns.SetStr(pszValue);
            else
            {
                TCHAR szNextPattern[MAX_PATH];  // overkill in size
                BOOL fFirst = TRUE;
                LPCTSTR pszNextPattern = pszValue;
                while ((pszNextPattern = NextPath(pszNextPattern, szNextPattern, ARRAYSIZE(szNextPattern))) != NULL)
                {
                    if (!fFirst)
                        _strTypeFilePatterns.Append(TEXT(";"));
                    fFirst = FALSE;

                    if (szNextPattern[0] != TEXT('*'))
                        _strTypeFilePatterns.Append(TEXT("*"));
                    _strTypeFilePatterns.Append(szNextPattern);
                }
            }
        }
    }
}

int _MapConstraint(LPCWSTR pszField)
{
    for (int i = 0; i < ARRAYSIZE(s_cdffuf); i++)
    {
        if (StrCmpIW(pszField, s_cdffuf[i].pwszField) == 0)
        {
            return i;
        }
    }
    return -1;
}

HRESULT CFindFilter::_GetPropertyUI(IPropertyUI **pppui)
{
    if (!_ppui)
        SHCoCreateInstance(NULL, &CLSID_PropertiesUI, NULL, IID_PPV_ARG(IPropertyUI, &_ppui));

    return _ppui ? _ppui->QueryInterface(IID_PPV_ARG(IPropertyUI, pppui)) : E_NOTIMPL;
}

HRESULT CFindFilter::UpdateField(LPCWSTR pszField, VARIANT vValue)
{
    _fFilterChanged = TRUE;    // force rebuilding name of files...

    USHORT uDosTime;

    switch (_MapConstraint(pszField))
    {
    case CDFFUFE_IndexedSearch:
        Str_SetPtr(&_pszIndexedSearch, NULL);   // zero this out
        _pszIndexedSearch = VariantToStr(&vValue, NULL, 0);
        break;

    case CDFFUFE_LookIn:
        _ResetRoots();

        if (FAILED(QueryInterfaceVariant(vValue, IID_PPV_ARG(IEnumIDList, &_penumRoots))))
        {
            if (vValue.vt == VT_BSTR)
            {
                VariantToStr(&vValue, _szPath, ARRAYSIZE(_szPath));
                CreateIEnumIDListPaths(_szPath, &_penumRoots);
            }
            else
            {
                LPITEMIDLIST pidl = VariantToIDList(&vValue);
                if (pidl)
                {
                    CreateIEnumIDListOnIDLists(&pidl, 1, &_penumRoots);
                    ILFree(pidl);
                }
            }
        }
        break;

    case CDFFUFE_IncludeSubFolders:
        _fTopLevelOnly = !VariantToBOOL(vValue);   // invert sense
        break;

    case CDFFUFE_Named:
        VariantToStr(&vValue, _szUserInputFileSpec, ARRAYSIZE(_szUserInputFileSpec));
        break;

    case CDFFUFE_ContainingText:
        ZeroMemory(_szText, sizeof(_szText));   // special zero init whole buffer
        VariantToStr(&vValue, _szText, ARRAYSIZE(_szText));
        break;

    case CDFFUFE_FileType:
        _UpdateTypeField(&vValue);
        break;

    case CDFFUFE_WhichDate:
        if (vValue.vt == VT_BSTR)
        {
            IPropertyUI *ppui;
            if (SUCCEEDED(_GetPropertyUI(&ppui)))
            {
                ULONG cch = 0;  // in/out
                ppui->ParsePropertyName(vValue.bstrVal, &_scidDate.fmtid, &_scidDate.pid, &cch);
                ppui->Release();
            }
        }
        else
        {
            MapValueToDateSCID(VariantToInt(vValue), &_scidDate);
        }
        break;

    case CDFFUFE_DateLE:
        _wDateType |= DFF_DATE_BETWEEN;
        VariantToDosDateTime(vValue, &_dateModifiedBefore, &uDosTime); 
        if (_dateModifiedAfter && _dateModifiedBefore)
        {
            if (_dateModifiedAfter > _dateModifiedBefore)
            {
                WORD wTemp = _dateModifiedAfter;
                _dateModifiedAfter = _dateModifiedBefore;
                _dateModifiedBefore = wTemp;
            }
        }
        break;

    case CDFFUFE_DateGE:
        _wDateType |= DFF_DATE_BETWEEN;
        VariantToDosDateTime(vValue, &_dateModifiedAfter, &uDosTime); 
        if (_dateModifiedAfter && _dateModifiedBefore)
        {
            if (_dateModifiedAfter > _dateModifiedBefore)
            {
                WORD wTemp = _dateModifiedAfter;
                _dateModifiedAfter = _dateModifiedBefore;
                _dateModifiedBefore = wTemp;
            }
        }
        break;

    case CDFFUFE_DateNDays:
        _wDateType |= DFF_DATE_DAYS;
        _wDateValue = (WORD)VariantToInt(vValue);
        _dateModifiedAfter = _GetTodaysDosDateMinusNDays(_wDateValue);
        break;

    case CDFFUFE_DateNMonths:
        _wDateType |= DFF_DATE_MONTHS;
        _wDateValue = (WORD)VariantToInt(vValue);
        _dateModifiedAfter = _GetTodaysDosDateMinusNMonths(_wDateValue);
        break;

    case CDFFUFE_SizeLE:
        _iSizeType = 2;
        _ullSize = VariantToULONGLONG(vValue);
        break;

    case CDFFUFE_SizeGE:
        _iSizeType = 1;
        _ullSize = VariantToULONGLONG(vValue);
        break;

    case CDFFUFE_TextCaseSen:
        _fTextCaseSen = VariantToBOOL(vValue);
        break;

    case CDFFUFE_TextReg:
        _fTextReg = VariantToBOOL(vValue);
        break;

    case CDFFUFE_SearchSlowFiles:
        _fSearchSlowFiles = VariantToBOOL(vValue);
        break;

    case CDFFUFE_QueryDialect:
        _ulQueryDialect = VariantToUINT(vValue);
        break;

    case CDFFUFE_WarningFlags:
        _dwWarningFlags = VariantToUINT(vValue);
        break;

    case CDFFUFE_SearchSystemDirs:
        _fSearchSystemDirs = VariantToBOOL(vValue);
        break;

    case CDFFUFE_SearchHidden:
        _fSearchHidden = VariantToBOOL(vValue);
        break;
    }
    return S_OK;
}

void CFindFilter::_ResetRoots()
{
    _szPath[0] = 0;
    ATOMICRELEASE(_penumRoots);
}

HRESULT CFindFilter::ResetFieldsToDefaults()
{
    // Try to reset everything that our UpdateFields may touch to make sure next search gets all

    _ResetRoots();

    _fTopLevelOnly = FALSE;
    _szUserInputFileSpec[0] = 0;
    _szText[0] = 0;
    if (_pszIndexedSearch)
        *_pszIndexedSearch = 0;
    _strTypeFilePatterns.Reset();

    ZeroMemory(&_scidDate, sizeof(_scidDate));
    _scidSize = SCID_SIZE;

    _fFoldersOnly = FALSE;
    _wDateType = 0;
    _dateModifiedBefore = 0;
    _dateModifiedAfter = 0;
    _iSizeType = 0;
    _ullSize = 0;
    _fTextCaseSen = FALSE;
    _fTextReg = FALSE;
    _fSearchSlowFiles = FALSE;
    _ulQueryDialect = ISQLANG_V2;
    _dwWarningFlags = DFW_DEFAULT;
    _fSearchSystemDirs = FALSE;

    // the search UI will usually override this, but if that us has not been updated
    // we need to set out state the same was as before here
    SHELLSTATE ss;
    SHGetSetSettings(&ss, SSF_SHOWALLOBJECTS, FALSE);
    _fSearchHidden = ss.fShowAllObjects;
    return S_OK;
}

HRESULT CFindFilter::GetNextConstraint(VARIANT_BOOL fReset, BSTR *pName, VARIANT *pValue, VARIANT_BOOL *pfFound)
{
    *pName = NULL;
    VariantClear(pValue);                            
    *pfFound = FALSE;

    if (fReset)
        _iNextConstraint = 0;

    HRESULT hr = S_FALSE;    // not found

    // we don't go to array size as the last entry is an empty item...
    while (_iNextConstraint < ARRAYSIZE(s_cdffuf))
    {
        switch (s_cdffuf[_iNextConstraint].cdffufe)
        {
        case CDFFUFE_IndexedSearch:
            hr = InitVariantFromStr(pValue, _pszIndexedSearch);
            break;
    
        case CDFFUFE_LookIn:
            hr = InitVariantFromStr(pValue, _szPath);
            break;
    
        case CDFFUFE_IncludeSubFolders:
            hr = InitVariantFromInt(pValue, _fTopLevelOnly ? 0 : 1);
            break;
    
        case CDFFUFE_Named:
            hr = InitVariantFromStr(pValue, _szUserInputFileSpec);
            break;
    
        case CDFFUFE_ContainingText:
            hr = InitVariantFromStr(pValue, _szText);
            break;
    
        case CDFFUFE_FileType:
            hr = InitVariantFromStr(pValue, _strTypeFilePatterns);
            break;

        case CDFFUFE_WhichDate:
            pValue->lVal = MapDateSCIDToValue(&_scidDate);
            if (pValue->lVal)
                hr = InitVariantFromInt(pValue, pValue->lVal);
            break;

        case CDFFUFE_DateLE:
            if ((_wDateType & DFF_DATE_RANGEMASK) == DFF_DATE_BETWEEN)
                hr = InitVariantFromDosDateTime(pValue, _dateModifiedBefore, 0);
            break;

        case CDFFUFE_DateGE:
            if ((_wDateType & DFF_DATE_RANGEMASK) == DFF_DATE_BETWEEN)
                hr = InitVariantFromDosDateTime(pValue, _dateModifiedAfter, 0); 
            break;

        case CDFFUFE_DateNDays:
            if ((_wDateType & DFF_DATE_RANGEMASK) == DFF_DATE_DAYS)
                hr = InitVariantFromInt(pValue, _wDateValue);
            break;

        case CDFFUFE_DateNMonths:
            if ((_wDateType & DFF_DATE_RANGEMASK) == DFF_DATE_MONTHS)
                hr = InitVariantFromInt(pValue, _wDateValue);
            break;

        case CDFFUFE_SizeLE:
            if (_iSizeType == 2)
                hr = InitVariantFromULONGLONG(pValue, _ullSize);
            break;

        case CDFFUFE_SizeGE:
            if (_iSizeType == 1)
                hr = InitVariantFromULONGLONG(pValue, _ullSize);
            break;

        case CDFFUFE_TextCaseSen:
            hr = InitVariantFromInt(pValue, _fTextCaseSen ? 1 : 0);
            break;

        case CDFFUFE_TextReg:
            hr = InitVariantFromInt(pValue, _fTextReg ? 1 : 0);
            break;

        case CDFFUFE_SearchSlowFiles:
            hr = InitVariantFromInt(pValue, _fSearchSlowFiles ? 1 : 0);
            break;

        case CDFFUFE_QueryDialect:
            hr = InitVariantFromUINT(pValue, _ulQueryDialect);
            break;

        case CDFFUFE_WarningFlags:
            hr = InitVariantFromUINT(pValue, _dwWarningFlags);
            break;

        case CDFFUFE_SearchSystemDirs:
            hr = InitVariantFromUINT(pValue, _fSearchSystemDirs ? 1 : 0);
            break;

        case CDFFUFE_SearchHidden:
            hr = InitVariantFromUINT(pValue, _fSearchHidden ? 1 : 0);
            break;
        }

        if (S_OK == hr)
            break;

        if (SUCCEEDED(hr))
            VariantClear(pValue);

        _iNextConstraint += 1;
    }

    if (S_OK == hr)
    {
        *pName = SysAllocString(s_cdffuf[_iNextConstraint].pwszField);
        if (NULL == *pName)
        {
            VariantClear(pValue);                            
            hr = E_OUTOFMEMORY;
        }
        else
            *pfFound = TRUE;

        _iNextConstraint += 1; // for the next call here
    }
    return hr;    // no error let script use the found field...
}


DWORD CFindFilter::_AddToQuery(LPWSTR *ppszBuf, DWORD *pcchBuf, LPWSTR pszAdd)
{
    DWORD cchAdd = lstrlenW(pszAdd);

    if (*ppszBuf && *pcchBuf > cchAdd)
    {
        StrCpyNW(*ppszBuf, pszAdd, *pcchBuf);
        *pcchBuf -= cchAdd;
        *ppszBuf += cchAdd;
    }
    return cchAdd;
}


DWORD AddQuerySep(DWORD *pcchBuf, LPWSTR *ppszCurrent, WCHAR  bSep)
{
    LPWSTR pszCurrent = *ppszCurrent;
    // make sure we have room for us plus terminator...
    if (*ppszCurrent && *pcchBuf >= 4)
    {
        *pszCurrent++ = L' ';
        *pszCurrent++ = bSep;
        *pszCurrent++ = L' ';

        *ppszCurrent = pszCurrent;
        *pcchBuf -= 3;
    }
    return 3; // size necessary
}


DWORD PrepareQueryParam(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent)
{
    if (*pbFirst)
    {
        *pbFirst = FALSE;
        return 0;  // no size necessary
    }
        
    // we're not the first property
    return AddQuerySep(pcchBuf, ppszCurrent, L'&');
}

// pick the longest date query so we can avoid checking the buffer size each time we
// add something to the string
#define LONGEST_DATE  50 //lstrlen(TEXT("{prop name=access} <= 2000/12/31 23:59:59{/prop}"))+2

DWORD CFindFilter::_QueryDosDate(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, WORD wDate, BOOL bBefore)
{
    LPWSTR pszCurrent = *ppszCurrent;
    DWORD cchNeeded = PrepareQueryParam(pbFirst, pcchBuf, &pszCurrent);
    
    if (pszCurrent && *pcchBuf > LONGEST_DATE)
    {
        FILETIME ftLocal;
        DosDateTimeToFileTime(wDate, 0, &ftLocal);
        FILETIME ftGMT;
        LocalFileTimeToFileTime(&ftLocal, &ftGMT);
        SYSTEMTIME st;
        FileTimeToSystemTime(&ftGMT, &st);

        IPropertyUI *ppui;
        if (SUCCEEDED(_GetPropertyUI(&ppui)))
        {
            WCHAR szName[128];
            if (SUCCEEDED(ppui->GetCannonicalName(_scidDate.fmtid, _scidDate.pid, szName, ARRAYSIZE(szName))))
            {
                 wnsprintfW(pszCurrent, *pcchBuf, L"{prop name=%s} ", szName);
                 // the date syntax we use is V2, so force this dialect
                _ulQueryDialect = ISQLANG_V2;
            }
            ppui->Release();
        }

        pszCurrent += lstrlenW(pszCurrent);
        if (bBefore)
        {
            *pszCurrent++ = L'<';
            // if you ask for a range like: 2/20/98 - 2/20/98 then we get no time at all
            // So for before, convert H:m:ss to 23:59:59...
            st.wHour = 23;
            st.wMinute = 59; 
            st.wSecond = 59;
        }
        else
        {
            *pszCurrent++ = L'>';
        }
        
        *pszCurrent++ = L'=';

        wnsprintfW(pszCurrent, *pcchBuf, L" %d/%d/%d %d:%d:%d{/prop}", st.wYear, st.wMonth, st.wDay,
            st.wHour, st.wMinute, st.wSecond);
        pszCurrent += lstrlenW(pszCurrent);
        
        *ppszCurrent = pszCurrent;
        *pcchBuf -= LONGEST_DATE;
    }
    return cchNeeded + LONGEST_DATE;
}

DWORD CFindFilter::_CIQueryFilePatterns(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, LPCWSTR pszFilePatterns)
{
    WCHAR szNextPattern[MAX_PATH];  // overkill in size
    BOOL fFirst = TRUE;
    LPCWSTR pszNextPattern = pszFilePatterns;
    DWORD cchNeeded = PrepareQueryParam(pbFirst, pcchBuf, ppszCurrent);

    // Currently will have to long hand the query, may try to find shorter format once bugs
    // are fixed...
    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, L"(");
    while ((pszNextPattern = NextPathW(pszNextPattern, szNextPattern, ARRAYSIZE(szNextPattern))) != NULL)
    {
        if (!fFirst)
        {
            cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, L" | ");
        }
        fFirst = FALSE;
        cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, L"#filename ");
        cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, szNextPattern);
    }
    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, L")");
    return cchNeeded;
}


DWORD CFindFilter::_CIQueryTextPatterns(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, LPWSTR pszText, BOOL bTextReg)
{
    DWORD cchNeeded = PrepareQueryParam(pbFirst, pcchBuf, ppszCurrent);

    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, L"{prop name=all}");
    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, bTextReg? L"{regex}" : L"{phrase}");
    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, pszText);
    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, bTextReg? L"{/regex}{/prop}" : L"{/phrase}{/prop}");

    return cchNeeded;
}

DWORD CFindFilter::_CIQuerySize(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, ULONGLONG ullSize, int iSizeType)
{
    WCHAR szSize[MAX_ULONGLONG_LEN+8]; // +8 for " {/prop}"
    DWORD cchNeeded = PrepareQueryParam(pbFirst, pcchBuf, ppszCurrent);

    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, L"{prop name=size} ");
    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, iSizeType == 1? L">" : L"<");
            
    WCHAR szNum[MAX_ULONGLONG_LEN];
    Int64ToString(ullSize, szNum, ARRAYSIZE(szNum), FALSE, NULL, 0);
    wnsprintfW(szSize, *pcchBuf, L" %ws{/prop}", szNum);
    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, szSize);

    return cchNeeded;
}

DWORD CFindFilter::_CIQueryIndex(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent, LPWSTR pszText)
{
    DWORD cchNeeded = PrepareQueryParam(pbFirst, pcchBuf, ppszCurrent);

    cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, pszText);
    return cchNeeded;
}

DWORD CFindFilter::_CIQueryShellSettings(BOOL *pbFirst, DWORD *pcchBuf, LPWSTR *ppszCurrent)
{
    DWORD cchNeeded = 0;
    
    if (!ShowSuperHidden())
    {
        cchNeeded += PrepareQueryParam(pbFirst, pcchBuf, ppszCurrent);
        cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, L"NOT @attrib ^a 0x6 ");// don't show files w/ hidden and system bit on
    }

    SHELLSTATE ss;
    SHGetSetSettings(&ss, SSF_SHOWALLOBJECTS, FALSE);
    if (!ss.fShowAllObjects)
    {
        cchNeeded += PrepareQueryParam(pbFirst, pcchBuf, ppszCurrent);
        cchNeeded += _AddToQuery(ppszCurrent, pcchBuf, L"NOT @attrib ^a 0x2 "); // don't show files w/ hidden bit on
    }
    return cchNeeded;
}


//  Helper function to add the PIDL from theCsidl to the exclude tree.
void _AddSystemDirCSIDLToPidlTree(int csidl, CIDLTree *ppidlTree)
{
    LPITEMIDLIST pidl = SHCloneSpecialIDList(NULL, csidl, TRUE);
    if (pidl)
    {
        ppidlTree->AddData(IDLDATAF_MATCH_RECURSIVE, pidl, EXCLUDE_SYSTEMDIR);
        ILFree(pidl);
    }
}


CNamespaceEnum::CNamespaceEnum(IFindFilter *pfilter, IShellFolder* psf, 
                               IFindEnum *penumAsync, IEnumIDList *penumScopes, 
                               HWND hwnd, DWORD grfFlags, LPTSTR pszProgressText) :   
    _cRef(1), _pfilter(pfilter), _iFolder(-1), _hwnd(hwnd), _grfFlags(grfFlags), 
    _pszProgressText(pszProgressText), _penumAsync(penumAsync)
{
    ASSERT(NULL == _psf);
    ASSERT(NULL == _pidlFolder);
    ASSERT(NULL == _pidlCurrentRootScope);
    ASSERT(NULL == _penum);

    if (penumScopes)
        penumScopes->Clone(&_penumScopes);

    _pfilter->AddRef();
    psf->QueryInterface(IID_PPV_ARG(IFindFolder, &_pff));
    ASSERT(_pff);

    if (_penumAsync) 
        _penumAsync->AddRef();

    // Setup the exclude system directories:
    if (!(_grfFlags & DFOO_SEARCHSYSTEMDIRS))
    {
        // IE History and cache are excluded based on the CLSID.
        _AddSystemDirCSIDLToPidlTree(CSIDL_WINDOWS, &_treeExcludeFolders);
        _AddSystemDirCSIDLToPidlTree(CSIDL_PROGRAM_FILES, &_treeExcludeFolders);

        //  Exclude Temp folder
        TCHAR szPath[MAX_PATH];
        if (GetTempPath(ARRAYSIZE(szPath), szPath))
        {
            LPITEMIDLIST pidl = ILCreateFromPath(szPath);
            if (pidl)
            {   
                _treeExcludeFolders.AddData(IDLDATAF_MATCH_RECURSIVE, pidl, EXCLUDE_SYSTEMDIR);
                ILFree(pidl);
            }
        }
    }
}

CNamespaceEnum::~CNamespaceEnum()
{
    ATOMICRELEASE(_penumScopes);

    ATOMICRELEASE(_pfilter);
    ATOMICRELEASE(_psf);
    ATOMICRELEASE(_penumAsync);
    ATOMICRELEASE(_pff);

    ILFree(_pidlFolder);    // accepts NULL
    ILFree(_pidlCurrentRootScope);
}

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

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

STDMETHODIMP_(ULONG) CNamespaceEnum::Release()
{
    ASSERT( 0 != _cRef );
    ULONG cRef = InterlockedDecrement(&_cRef);
    if ( 0 == cRef )
    {
        delete this;
    }
    return cRef;
}

// Check if the relative pidl passed is to a folder that we are going 
// skip based on its CLSID:
// This will be used to skip IE History and IE Cache.
BOOL CNamespaceEnum::_IsSystemFolderByCLSID(LPCITEMIDLIST pidl)
{
    BOOL bRetVal = FALSE;
    IShellFolder2 *psf2;
    if (_psf && SUCCEEDED(_psf->QueryInterface(IID_PPV_ARG(IShellFolder2, &psf2))))
    {
        CLSID clsid;
        if (SUCCEEDED(GetItemCLSID(psf2, pidl, &clsid)))
        {
            if (IsEqualCLSID(clsid, CLSID_CacheFolder) ||
                IsEqualCLSID(clsid, CLSID_CacheFolder2) ||
                IsEqualCLSID(clsid, CLSID_HistFolder))
            {
                bRetVal = TRUE;
            }
        }  
        psf2->Release();
    }
    return bRetVal;
}

// given the fact that a file is a directory, is this one we should search???

BOOL CNamespaceEnum::_ShouldPushItem(LPCITEMIDLIST pidl)
{
    BOOL bShouldPush = FALSE;
    TCHAR szName[MAX_PATH];

    // folders only, not folder shortcuts (note, this includes SFGAO_STREAM objects, .zip/.cab files)
    // skip all folders that start with '?'. these are folders that the names got trashed in some
    // ansi/unicode round trip. this avoids problems in the web folders name space

    if (SFGAO_FOLDER == SHGetAttributes(_psf, pidl, SFGAO_FOLDER | SFGAO_LINK) &&
        SUCCEEDED(DisplayNameOf(_psf, pidl, SHGDN_INFOLDER | SHGDN_FORPARSING, szName, ARRAYSIZE(szName))) &&
        (TEXT('?') != szName[0]))
    {
        LPITEMIDLIST pidlFull = ILCombine(_pidlFolder, pidl);
        if (pidlFull)
        {
            INT_PTR i = 0;
            
            // Check if the folder is in the exclude list because it has been searched
            HRESULT hr = _treeExcludeFolders.MatchOne(IDLDATAF_MATCH_RECURSIVE, pidlFull, &i, NULL);

            if (FAILED(hr))
            {
                // see if an alias version of this pidl is exists
                LPITEMIDLIST pidlAlias = SHLogILFromFSIL(pidlFull);
                if (pidlAlias)
                {
                    hr = _treeExcludeFolders.MatchOne(IDLDATAF_MATCH_RECURSIVE, pidlAlias, &i, NULL);
                    ILFree(pidlAlias);
                }
            }

            if (FAILED(hr))
            {
                // If we still think it should be added, check if we can reject it based
                // on its CSILD.  We will only exclude system folders this way.
                bShouldPush = (_grfFlags & DFOO_SEARCHSYSTEMDIRS) || 
                              (!_IsSystemFolderByCLSID(pidl));
            }
            else if (i == EXCLUDE_SYSTEMDIR)
            {
                //  If it is under a system directory exclude, check to see if it is the 
                //  directory or a sub directory.  We want to exclude the exact directory
                //  so that we don't add a system directory to the list of things to search.
                //  Since we may have specified the directory in the list of places to search
                //  and therefore want to search it, we don't want to exclude sub directories 
                //  that way.
                hr = _treeExcludeFolders.MatchOne(IDLDATAF_MATCH_EXACT, pidlFull, &i, NULL);
                if (FAILED(hr))
                {
                    //  If we get here, it means that pidlFull is a sub directory of a 
                    //  system directory which was searched because it was explicitly
                    //  specified in the list of scopes to search.  Therefore we want
                    //  to continue to search the sub directories.
                    bShouldPush = TRUE;
                }
            } 
            else
            {
                // It matched an item in the tree and was not EXCLUDE_SYSTEMDIR:
                ASSERT(i == EXCLUDE_SEARCHED);
            }
            
            ILFree(pidlFull);
        }
    }

    return bShouldPush;
}

IShellFolder *CNamespaceEnum::_NextRootScope()
{
    IShellFolder *psf = NULL;

    if (_penumScopes)
    {
        LPITEMIDLIST pidl;
        if (S_OK == _penumScopes->Next(1, &pidl, NULL))
        {
            SHBindToObject(NULL, IID_X_PPV_ARG(IShellFolder, pidl, &psf));
            ILFree(pidl);
        }
    }
    return psf;
}

STDMETHODIMP CNamespaceEnum::Next(LPITEMIDLIST *ppidl, int *pcObjectSearched, 
                                  int *pcFoldersSearched, BOOL *pfContinue, int *piState)
{
    *ppidl = NULL;
    *piState = GNF_NOMATCH;
    HRESULT hrRet = S_FALSE;
    
    while (S_OK != hrRet && *pfContinue)
    {
        // Retrieve an enumerator if we don't already have one.
        while (NULL == _penum)
        {
            // Indicates that we have taken scope from _penumScopes
            BOOL fUseRootScope = FALSE;

            ASSERT(NULL == _psf);

            // first try popping subdirs off folder stack

            _psf = _queSubFolders.Remove();

            // If there are no folders pushed, then try to get on from the caller.. (root scopes)
            if (NULL == _psf) 
            {
                // Since we are getting a new root scope, add old one to exclude list
                if (_pidlCurrentRootScope)
                {                
                    // Add to exclude List.
                    if (_grfFlags & DFOO_INCLUDESUBDIRS)
                    {
                        // Since all sub directories will be search, don't search again.
                        _treeExcludeFolders.AddData(IDLDATAF_MATCH_RECURSIVE, _pidlCurrentRootScope, EXCLUDE_SEARCHED);
                    }
                    else
                    {
                        // Since sub directories have not been search, allow them to be searched.
                        _treeExcludeFolders.AddData(IDLDATAF_MATCH_EXACT, _pidlCurrentRootScope, EXCLUDE_SEARCHED);
                    }

                    ILFree(_pidlCurrentRootScope);
                    _pidlCurrentRootScope = NULL;
                }
            
                // Get scope from list passed in from caller (root scopes)
                _psf = _NextRootScope();

                fUseRootScope = TRUE;
            }
            
            if (_psf)
            {
                HRESULT hrT = SHGetIDListFromUnk(_psf, &_pidlFolder);

                if (SUCCEEDED(hrT) && fUseRootScope)
                {
                    // Check if the pidl is in the tree
                    INT_PTR i = 0;
                    HRESULT hrMatch = _treeExcludeFolders.MatchOne(IDLDATAF_MATCH_RECURSIVE, _pidlFolder, &i, NULL);
  
                    // If we have a new root scope, set that up as current root scope pidl:
                    // We only want to skip pidls from the queue of "root" search scopes
                    // if they have already been searched.  We do not want to exclude a directory
                    // (from exclude system directories) if it is an explicit search scope.
                    if (FAILED(hrMatch) || i == EXCLUDE_SYSTEMDIR)
                    {
                        ASSERT(_pidlCurrentRootScope == NULL);
                        _pidlCurrentRootScope = ILClone(_pidlFolder);
                    }
                    else
                    {
                        // Since the PIDL is in the exclude tree, we do not want to search it.
                        hrT = E_FAIL;
                    }
                }

                if (SUCCEEDED(hrT))
                {
                    //  Check that we have a pidl, that it is not to be excluded, and that it can
                    //  be enumerated.

                    SHCONTF contf = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
                    if (_grfFlags & DFOO_SHOWALLOBJECTS) 
                        contf |= SHCONTF_INCLUDEHIDDEN;
                    hrT = _psf->EnumObjects(_hwnd, contf, &_penum);

                    // only do UI on the first enum, all others are silent
                    // this makes doing search on A:\ produce the insert media
                    // prompt, but searching MyComputer does not prompt for all
                    // empty media
                    _hwnd = NULL;   

                    if (S_OK == hrT)
                    {
                        SHGetNameAndFlags(_pidlFolder, SHGDN_FORPARSING | SHGDN_FORADDRESSBAR, _pszProgressText, MAX_PATH, NULL);
                        (*pcFoldersSearched)++;
                    }
                }

                // Check for cleaning up...
                if (hrT != S_OK)
                {
                    ASSERT(NULL == _penum);
                    ATOMICRELEASE(_psf);    // and continue...
                    ILFree(_pidlFolder);
                    _pidlFolder = NULL;
                }
            }
            else // no scope
            {
                *piState = GNF_DONE;
                return hrRet;
            }
        }

        // Retrieve item
        LPITEMIDLIST pidl;
        HRESULT hrEnum = S_FALSE;

        while ((S_OK != hrRet) && *pfContinue && (S_OK == (hrEnum = _penum->Next(1, &pidl, NULL))))
        {
            (*pcObjectSearched)++;

            //  Determine if this is a subfolder that should be recursively searched.
            if (_grfFlags & DFOO_INCLUDESUBDIRS)
            {
                if (_ShouldPushItem(pidl))
                {
                    // queue folder to stack of subfolders to be searched in the next round.
                    _queSubFolders.Add(_psf, pidl);
                }
            }

            //  Test item against search criteria:
            if (_pfilter->MatchFilter(_psf, pidl))
            {
                // folder has not been registered with docfind folder?
                if (_iFolder < 0)
                {
                    // add folder to folder list.
                    _pff->AddFolder(_pidlFolder, TRUE, &_iFolder);
                    ASSERT(_iFolder >= 0);
                }
                
                // add docfind goo to pidl
                hrRet = _pff->AddDataToIDList(pidl, _iFolder, _pidlFolder, DFDF_NONE, 0, 0, 0, ppidl);
                if (SUCCEEDED(hrRet))
                    *piState = GNF_MATCH;
            }
            else
            {
                ASSERT(GNF_NOMATCH == *piState);
                hrRet = S_OK;   // exit loop, without a match
            }
            ILFree(pidl);
        }


        if (!*pfContinue)
        {
            *piState = GNF_DONE;
            hrEnum = S_FALSE;
        }
        
        if (S_OK != hrEnum)
        {
            // Done enumerating this folder - clean up for next iteration; or..
            // Failed miserably - clean up prior to bail.
            ATOMICRELEASE(_penum);
            ATOMICRELEASE(_psf);
            ILFree(_pidlFolder);
            _pidlFolder = NULL;
            _iFolder = -1;
        }
    }
    return hrRet;
}

STDMETHODIMP CNamespaceEnum::StopSearch()
{
    if (_penumAsync)
        return _penumAsync->StopSearch();
    return E_NOTIMPL;
}

STDMETHODIMP_(BOOL) CNamespaceEnum::FQueryIsAsync()
{
    if (_penumAsync)
        return DF_QUERYISMIXED;    // non-zero special number to say both...
    return FALSE;
}

STDMETHODIMP CNamespaceEnum::GetAsyncCount(DBCOUNTITEM *pdwTotalAsync, int *pnPercentComplete, BOOL *pfQueryDone)
{
    if (_penumAsync)
        return _penumAsync->GetAsyncCount(pdwTotalAsync, pnPercentComplete, pfQueryDone);

    *pdwTotalAsync = 0;
    return E_NOTIMPL;
}

STDMETHODIMP CNamespaceEnum::GetItemIDList(UINT iItem, LPITEMIDLIST *ppidl)
{
    if (_penumAsync)
        return _penumAsync->GetItemIDList(iItem, ppidl);

    *ppidl = NULL;
    return E_NOTIMPL;
}

STDMETHODIMP CNamespaceEnum::GetItemID(UINT iItem, DWORD *puWorkID)
{
    if (_penumAsync)
        return _penumAsync->GetItemID(iItem, puWorkID);

    *puWorkID = (UINT)-1;
    return E_NOTIMPL;
}

STDMETHODIMP CNamespaceEnum::SortOnColumn(UINT iCol, BOOL fAscending)
{
    if (_penumAsync)
        return _penumAsync->SortOnColumn(iCol, fAscending);

    return E_NOTIMPL;
}


// Masks used to indicate which search operation we are doing.
#define AND_MASK            0x01
#define OR_MASK             0x02
#define SEMICOLON_MASK      0x04
#define COMMA_MASK          0x08
#define EXTENSION_MASK      0x10

// Both "*" and "?" are treated as wildcards.

BOOL SetupWildCardingOnFileSpec(LPTSTR pszSpecIn, LPTSTR *ppszSpecOut)
{
    LPTSTR pszIn = pszSpecIn;
    BOOL fQuote;
    TCHAR szSpecOut[3*MAX_PATH];   // Rather large...

    // Read in localized versions of AND/OR used for searching
    TCHAR szAND[20];
    LoadString(HINST_THISDLL, IDS_FIND_AND, szAND, ARRAYSIZE(szAND));
    TCHAR szOR[20];
    LoadString(HINST_THISDLL, IDS_FIND_OR, szOR, ARRAYSIZE(szOR));

    // Masks and variable to indicate what operation we are going to perform.
    UINT iOperation  = 0;      // Bitmask to store which operation we have selected.

    // allocate a buffer that should be able to hold the resultant
    // string.  When all is said and done we'll re-allocate to the
    // correct size.

    LPTSTR pszOut = szSpecOut;
    while (*pszIn != 0)
    {
        TCHAR  c;                       // The delimiter.
        LPTSTR pszT;
        int    ich;

        // Strip in leading spaces out of there
        while (*pszIn == TEXT(' '))
            pszIn++;

        if (*pszIn == 0)
            break;

        // If we are beyond the first item, add a seperator between the tokens
        if (pszOut != szSpecOut)
            *pszOut++ = TEXT(';');
        
        fQuote = (*pszIn == TEXT('"'));
        if (fQuote)
        {
            // The user asked for something litteral.
           pszT = pszIn = CharNext(pszIn);
           while (*pszT && (*pszT != TEXT('"')))
               pszT = CharNext(pszT);
        }
        else
        {
            pszT = pszIn + (ich = StrCSpn(pszIn, TEXT(",; \""))); // Find end of token
        }

        c = *pszT;       // Save away the seperator character that was found
        *pszT = 0;       // Add null so string functions will work and only extract the token

        // Put in a couple of tests for * and *.*
        if ((lstrcmp(pszIn, c_szStar) == 0) ||
            (lstrcmp(pszIn, c_szStarDotStar) == 0))
        {
            // Complete wild card so set a null criteria
            *pszT = c;              // Restore char;
            pszOut = szSpecOut;     // Set to start of string
            break;
        }
        
        if (fQuote)
        {
            lstrcpy(pszOut, pszIn);
            pszOut += lstrlen(pszIn);
        }
        else if (lstrcmpi(pszIn, szAND) == 0)
        {
            iOperation |= AND_MASK;
            // If we don't move back one character, then "New and folder" will give:
            // "*New*;;*folder*"
            if (pszOut != szSpecOut)
                --pszOut;
        }
        else if (lstrcmpi(pszIn, szOR) == 0)
        {
            iOperation |= OR_MASK;
            // If we don't move back one character, then "New or folder" will give:
            // "*New*;;*folder*"
            if (pszOut != szSpecOut)
                --pszOut;
        }
        else if (*pszIn == 0)
        {
            // If we don't move back one character, then "New ; folder" will give:
            // "*New*;**;*folder*"
            if (pszOut != szSpecOut)
                --pszOut;

            // Check what the seperator is.  This handles instances like
            // ("abba" ; "abba2") where we want an OR search.
            if (c == TEXT(','))
            {
                iOperation |= COMMA_MASK;
            }
            else if (c == TEXT(';'))
            {
                iOperation |= SEMICOLON_MASK;
            }
        }
        else
        {
            // Check what the seperator is:
            if (c == TEXT(','))
            {
                iOperation |= COMMA_MASK;
            }
            else if (c == TEXT(';'))
            {
                iOperation |= SEMICOLON_MASK;
            }
        
            // both "*" and "?" are wildcards.  When checking for wildcards check
            // for both before we conclude there are no wildcards.  If a search
            // string contains both "*" and "?" then we need for pszStar to point
            // to the last occorance of either one (this is assumed in the code
            // below which will add a ".*" when pszStar is the last character).
            // NOTE: I wish there was a StrRPBrk function to do this for me.
            LPTSTR pszStar = StrRChr(pszIn, NULL, TEXT('*'));
            LPTSTR pszAnyC = StrRChr(pszIn, NULL, TEXT('?'));
            if (pszAnyC > pszStar)
                pszStar = pszAnyC;
            if (pszStar == NULL)
            {
                // No wildcards were used:
                *pszOut++ = TEXT('*');
                lstrcpy(pszOut, pszIn);
                pszOut += ich;
                *pszOut++ = TEXT('*');
            }
            else
            {
                // Includes wild cards
                lstrcpy(pszOut, pszIn);
                pszOut += ich;

                pszAnyC = StrRChr(pszIn, NULL, TEXT('.'));
                if (pszAnyC)
                {
                    // extension present, that implies OR search
                    iOperation |= EXTENSION_MASK;
                }
                else
                {
                    // No extension is given
                    if ((*(pszStar+1) == 0) && (*pszStar == TEXT('*')))
                    {
                        // The last character is an "*" so this single string will
                        // match everything you would expect.
                    }
                    else
                    {
                        // Before, given "a*a" we searched for "a*a" as well
                        // as "a*a.*".  We can no longer do that because if we are
                        // doing an AND search, it will exclude any item that does not
                        // match both of the criterial.  For example, "abba" mattches
                        // "a*a" but not "a*a.*" and "abba.txt" matches "a*a.*" but
                        // not "a*a".  Therefore, we append an * to get "a*a*".  This 
                        // will match files like "abba2.wav" which wouldn't previously
                        // have been matched, but it is a small price to pay.
                        *pszOut++ = TEXT('*');  
                    }
                }
            }
        }

        *pszT = c;  // Restore char;
        if (c == 0)
            break;

        // Skip the seperator except if we weren't quoting and the seperator is 
        // a '"' then we found something like (blah"next tag")
        if (*pszT != 0 && !(*pszT == TEXT('"') && !fQuote))
            pszT++;
            
        pszIn = pszT;   // setup for the next item
    }
    
    // Ensure the string is terminated
    *pszOut++ = 0;

    // re-alloc the buffer down to the actual size of the string...
    Str_SetPtr(ppszSpecOut, szSpecOut);
    
    //  Precidence rules to be applied in order:
    //  1. ;        -> OR search
    //  2. AND      -> AND search 
    //  3. , or OR  -> OR search
    //  4. none & explict file extensions -> OR search (files can only have one extension)
    //  5. none     -> AND search
    //  
    //
    // AND   OR  ;   ,   | AND Search
    //  X    X   1   X   |     0
    //  1    X   0   X   |     1
    //  0    \   0   \   |     0    Where one if the '\'s is 1
    //  0    0   0   0   |     1
    return (!(iOperation & SEMICOLON_MASK) && (iOperation & AND_MASK)) || iOperation == 0;
}

WORD CFindFilter::_GetTodaysDosDateMinusNDays(int nDays)
{
    SYSTEMTIME st;
    union
    {
        FILETIME ft;
        LARGE_INTEGER li;
    }ftli;

    WORD FatTime = 0, FatDate = 0;

    // Now we need to
    GetSystemTime(&st);
    SystemTimeToFileTime(&st, &ftli.ft);
    FileTimeToLocalFileTime(&ftli.ft, &ftli.ft);

    // Now decrement the file time by the count of days * the number of
    // 100NS time units per day.  Assume that nDays is positive.
    if (nDays > 0)
    {
        #define NANO_SECONDS_PER_DAY 864000000000
        ftli.li.QuadPart = ftli.li.QuadPart - ((__int64)nDays * NANO_SECONDS_PER_DAY);
    }

    FileTimeToDosDateTime(&ftli.ft, &FatDate, &FatTime);
    DebugMsg(DM_TRACE, TEXT("DocFind %d days = %x"), nDays, FatDate);
    return FatDate;
}

WORD CFindFilter::_GetTodaysDosDateMinusNMonths(int nMonths)
{
    SYSTEMTIME st;
    FILETIME ft;
    WORD FatTime, FatDate;

    GetSystemTime(&st);
    st.wYear -= (WORD) nMonths / 12;
    nMonths = nMonths % 12;
    if (nMonths < st.wMonth)
        st.wMonth -= (WORD) nMonths;
    else
    {
        st.wYear--;
        st.wMonth = (WORD)(12 - (nMonths - st.wMonth));
    }

    // Now normalize back to a valid date.
    while (!SystemTimeToFileTime(&st, &ft))
    {
        st.wDay--;  // must not be valid date for month...
    }

    if (!FileTimeToLocalFileTime(&ft, &ft) || !FileTimeToDosDateTime(&ft, &FatDate,&FatTime))
        FatDate = 0; //search for all the files from beginning of time (better to find more than less)
        
    DebugMsg(DM_TRACE, TEXT("DocFind %d months = %x"), nMonths, FatDate);
    return FatDate;
}