You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2295 lines
73 KiB
2295 lines
73 KiB
#include "shellprv.h"
|
|
#pragma hdrstop
|
|
|
|
#include "dspsprt.h"
|
|
#include "findfilter.h"
|
|
#include "cowsite.h"
|
|
#include "cobjsafe.h"
|
|
#include "cnctnpt.h"
|
|
#include "stdenum.h"
|
|
#include "exdisp.h"
|
|
#include "exdispid.h"
|
|
#include "shldisp.h"
|
|
#include "shdispid.h"
|
|
#include "dataprv.h"
|
|
#include "ids.h"
|
|
#include "views.h"
|
|
#include "findband.h"
|
|
|
|
#define WM_DF_SEARCHPROGRESS (WM_USER + 42)
|
|
#define WM_DF_ASYNCPROGRESS (WM_USER + 43)
|
|
#define WM_DF_SEARCHSTART (WM_USER + 44)
|
|
#define WM_DF_SEARCHCOMPLETE (WM_USER + 45)
|
|
#define WM_DF_FSNOTIFY (WM_USER + 46)
|
|
|
|
STDAPI CDocFindCommand_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv);
|
|
|
|
typedef struct
|
|
{
|
|
BSTR bstrName;
|
|
VARIANT vValue;
|
|
} CMD_CONSTRAINT;
|
|
|
|
typedef struct _foo_
|
|
{
|
|
LPTSTR pszDotType;
|
|
LPTSTR pszDefaultValueMatch;
|
|
LPTSTR pszGuid; // If NULL, patch either pszDefaultValueMatch, or pszDotType whichever you find
|
|
} TYPE_FIX_ENTRY;
|
|
|
|
class CFindCmd : public ISearchCommandExt,
|
|
public CImpIDispatch,
|
|
public CObjectWithSite,
|
|
public IConnectionPointContainer,
|
|
public IProvideClassInfo2,
|
|
public CSimpleData,
|
|
public IRowsetWatchNotify,
|
|
public IFindControllerNotify
|
|
{
|
|
public:
|
|
// IUnknown
|
|
STDMETHODIMP QueryInterface(REFIID riid, void **ppv);
|
|
STDMETHODIMP_(ULONG) AddRef();
|
|
STDMETHODIMP_(ULONG) Release();
|
|
|
|
// IDispatch
|
|
STDMETHOD(GetTypeInfoCount)(UINT * pctinfo);
|
|
STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo **pptinfo);
|
|
STDMETHOD(GetIDsOfNames)(REFIID riid, OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID * rgdispid);
|
|
STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr);
|
|
|
|
// IConnectionPointContainer
|
|
STDMETHOD(EnumConnectionPoints)(IEnumConnectionPoints **ppEnum);
|
|
STDMETHOD(FindConnectionPoint)(REFIID riid, IConnectionPoint **ppCP);
|
|
|
|
// IProvideClassInfo
|
|
STDMETHOD(GetClassInfo)(ITypeInfo **ppTI);
|
|
|
|
// IProvideClassInfo2
|
|
STDMETHOD(GetGUID)(DWORD dwGuidKind, GUID *pGUID);
|
|
|
|
// IObjectWithSite
|
|
STDMETHOD(SetSite)(IUnknown *punkSite);
|
|
|
|
// ISearchCommandExt
|
|
STDMETHOD(ClearResults)(void);
|
|
STDMETHOD(NavigateToSearchResults)(void);
|
|
STDMETHOD(get_ProgressText)(BSTR *pbs);
|
|
STDMETHOD(SaveSearch)(void);
|
|
STDMETHOD(RestoreSearch)(void);
|
|
STDMETHOD(GetErrorInfo)(BSTR *pbs, int *phr);
|
|
STDMETHOD(SearchFor)(int iFor);
|
|
STDMETHOD(GetScopeInfo)(BSTR bsScope, int *pdwScopeInfo);
|
|
STDMETHOD(RestoreSavedSearch)(VARIANT *pvarFile);
|
|
STDMETHOD(Execute)(VARIANT *RecordsAffected, VARIANT *Parameters, long Options);
|
|
STDMETHOD(AddConstraint)(BSTR Name, VARIANT Value);
|
|
STDMETHOD(GetNextConstraint)(VARIANT_BOOL fReset, DFConstraint **ppdfc);
|
|
|
|
// IRowsetWatchNotify
|
|
STDMETHODIMP OnChange(IRowset *prowset, DBWATCHNOTIFY eChangeReason);
|
|
|
|
// IFindControllerNotify
|
|
STDMETHODIMP DoSortOnColumn(UINT iCol, BOOL fSameCol);
|
|
STDMETHODIMP StopSearch(void);
|
|
STDMETHODIMP GetItemCount(UINT *pcItems);
|
|
STDMETHODIMP SetItemCount(UINT cItems);
|
|
STDMETHODIMP ViewDestroyed();
|
|
|
|
CFindCmd();
|
|
HRESULT Init(void);
|
|
|
|
int _CompareCallback(IShellFolder *psf, IFindFolder *pff, LPITEMIDLIST pidl1, LPITEMIDLIST pidl2);
|
|
static int _CompareCallbackStub(void *p1, void *p2, LPARAM lParam);
|
|
|
|
private:
|
|
~CFindCmd();
|
|
HRESULT _GetSearchIDList(LPITEMIDLIST *ppidl);
|
|
HRESULT _SetEmptyText(UINT nID);
|
|
HRESULT _Clear();
|
|
void _SelectResults();
|
|
HWND _GetWindow();
|
|
|
|
struct THREAD_PARAMS {
|
|
CFindCmd *pThis;
|
|
IFindEnum *penum;
|
|
IShellFolder *psf;
|
|
IFindFolder *pff;
|
|
IShellFolderView *psfv;
|
|
};
|
|
|
|
struct DEFER_UPDATE_DIR {
|
|
struct DEFER_UPDATE_DIR *pdudNext;
|
|
LPITEMIDLIST pidl;
|
|
BOOL fRecurse;
|
|
};
|
|
|
|
// Internal class to handle notifications from top level browser
|
|
class CWBEvents2: public DWebBrowserEvents, DWebBrowserEvents2
|
|
{
|
|
public:
|
|
STDMETHOD(QueryInterface) (REFIID riid, void **ppv);
|
|
STDMETHOD_(ULONG, AddRef)(void) { return _pcdfc->AddRef();}
|
|
STDMETHOD_(ULONG, Release)(void) { return _pcdfc->Release();}
|
|
|
|
// (DwebBrowserEvents)IDispatch
|
|
STDMETHOD(GetTypeInfoCount)(UINT * pctinfo) { return E_NOTIMPL;}
|
|
STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo **pptinfo) { return E_NOTIMPL;}
|
|
STDMETHOD(GetIDsOfNames)(REFIID riid, OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID * rgdispid) { return E_NOTIMPL;}
|
|
STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr);
|
|
|
|
// Some helper functions...
|
|
void SetOwner(CFindCmd *pcdfc) { _pcdfc = pcdfc; } // Don't addref as part of larger object... }
|
|
void SetWaiting(BOOL fWait) {_fWaitingForNavigate = fWait;}
|
|
|
|
protected:
|
|
// Internal variables...
|
|
CFindCmd *_pcdfc; // pointer to top object... could cast, but...
|
|
BOOL _fWaitingForNavigate; // Are we waiting for the navigate to search resluts?
|
|
};
|
|
|
|
friend class CWBEvents2;
|
|
CWBEvents2 _cwbe;
|
|
IConnectionPoint *_pcpBrowser; // hold onto browsers connection point;
|
|
ULONG _dwCookie; // Cookie returned by Advise
|
|
|
|
HRESULT _UpdateFilter(IFindFilter *pfilter);
|
|
void _ClearConstraints();
|
|
static DWORD CALLBACK _ThreadProc(void *pv);
|
|
void _DoSearch(IFindEnum *penum, IShellFolder *psf, IFindFolder *pff, IShellFolderView *psfv);
|
|
HRESULT _Start(BOOL fNavigateIfFail, int iCol, LPCITEMIDLIST pidlUpdate);
|
|
HRESULT _Cancel();
|
|
HRESULT _Init(THREAD_PARAMS **ppParams, int iCol, LPCITEMIDLIST pidlUpdate);
|
|
static HRESULT _FreeThreadParams(THREAD_PARAMS *ptp);
|
|
HRESULT _ExecData_Init();
|
|
HRESULT _EnsureResultsViewIsCurrent(IUnknown *punk);
|
|
HRESULT _ExecData_Release();
|
|
BOOL _SetupBrowserCP();
|
|
void cdecl _NotifyProgressText(UINT ids,...);
|
|
static LRESULT CALLBACK _WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
void _PTN_SearchProgress(void);
|
|
void _PTN_AsyncProgress(int nPercentComplete, DWORD cAsync);
|
|
void _PTN_SearchComplete(HRESULT hr, BOOL fAbort);
|
|
void _OnChangeNotify(LONG code, LPITEMIDLIST *ppidl);
|
|
void _DeferHandleUpdateDir(LPCITEMIDLIST pidl, BOOL bRecurse);
|
|
void _ClearDeferUpdateDirList();
|
|
void _ClearItemDPA(HDPA hdpa);
|
|
HRESULT _SetLastError(HRESULT hr);
|
|
void _SearchResultsCLSID(CLSID *pclsid) { *pclsid = _clsidResults; };
|
|
IUnknown* _GetObjectToPersist();
|
|
HRESULT _ForcedUnadvise(void);
|
|
void _PostMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
HRESULT _GetShellView(REFIID riid, void **ppv);
|
|
BOOL _FixPersistHandler(LPCTSTR pszBase, LPCTSTR pszDefaultHandler);
|
|
void _ProcessTypes(const TYPE_FIX_ENTRY *ptfeTypes, UINT cTypes, TCHAR *pszClass);
|
|
void _FixBrokenTypes(void);
|
|
|
|
// These are the things that the second thread will use during it's processing...
|
|
struct {
|
|
CRITICAL_SECTION csSearch;
|
|
BOOL fcsSearch;
|
|
HWND hwndThreadNotify;
|
|
HDPA hdpa;
|
|
DWORD dwTimeLastNotify;
|
|
BOOL fFilesAdded : 1;
|
|
BOOL fDirChanged : 1;
|
|
BOOL fUpdatePosted : 1;
|
|
} _updateParams; // Pass callback params through this object to avoid alloc/free cycle
|
|
|
|
struct {
|
|
IShellFolder *psf;
|
|
IShellFolderView *psfv;
|
|
IFindFolder *pff;
|
|
TCHAR szProgressText[MAX_PATH];
|
|
} _execData;
|
|
|
|
private:
|
|
LONG _cRef;
|
|
HDSA _hdsaConstraints;
|
|
DWORD _cExecInProgress;
|
|
BOOL _fAsyncNotifyReceived;
|
|
BOOL _fDeferRestore;
|
|
BOOL _fDeferRestoreTried;
|
|
BOOL _fContinue;
|
|
BOOL _fNew;
|
|
CConnectionPoint _cpEvents;
|
|
OLEDBSimpleProviderListener *_pListener;
|
|
HDPA _hdpaItemsToAdd1;
|
|
HDPA _hdpaItemsToAdd2;
|
|
TCHAR _szProgressText[MAX_PATH+40]; // progress text leave room for chars...
|
|
LPITEMIDLIST _pidlUpdate; // Are we processing an updatedir?
|
|
LPITEMIDLIST _pidlRestore; // pidl to do restore from...
|
|
struct DEFER_UPDATE_DIR *_pdudFirst; // Do we have any defered update dirs?
|
|
HRESULT _hrLastError; // the last error reported.
|
|
UINT _uStatusMsgIndex; // Files or computers found...
|
|
CRITICAL_SECTION _csThread;
|
|
BOOL _fcsThread;
|
|
DFBSAVEINFO _dfbsi;
|
|
CLSID _clsidResults;
|
|
};
|
|
|
|
|
|
class CFindConstraint: public DFConstraint, public CImpIDispatch
|
|
{
|
|
public:
|
|
// IUnknown
|
|
STDMETHOD(QueryInterface) (REFIID riid, void **ppv);
|
|
STDMETHOD_(ULONG, AddRef)(void);
|
|
STDMETHOD_(ULONG, Release)(void);
|
|
|
|
// IDispatch
|
|
STDMETHOD(GetTypeInfoCount)(UINT * pctinfo);
|
|
STDMETHOD(GetTypeInfo)(UINT itinfo, LCID lcid, ITypeInfo **pptinfo);
|
|
STDMETHOD(GetIDsOfNames)(REFIID riid, OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID * rgdispid);
|
|
STDMETHOD(Invoke)(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr);
|
|
|
|
// DFConstraint
|
|
STDMETHOD(get_Name)(BSTR *pbs);
|
|
STDMETHOD(get_Value)(VARIANT *pvar);
|
|
|
|
CFindConstraint(BSTR bstr, VARIANT var);
|
|
private:
|
|
~CFindConstraint();
|
|
LONG _cRef;
|
|
BSTR _bstr;
|
|
VARIANT _var;
|
|
};
|
|
|
|
CFindCmd::CFindCmd() : CImpIDispatch(LIBID_Shell32, 1, 0, IID_ISearchCommandExt), CSimpleData(&_pListener)
|
|
{
|
|
_cRef = 1;
|
|
_fAsyncNotifyReceived = 0;
|
|
_fContinue = TRUE;
|
|
ASSERT(NULL == _pidlRestore);
|
|
|
|
ASSERT(_cExecInProgress == 0);
|
|
|
|
_clsidResults = CLSID_DocFindFolder; // default
|
|
|
|
_cpEvents.SetOwner(SAFECAST(this, ISearchCommandExt *), &DIID_DSearchCommandEvents);
|
|
}
|
|
|
|
HRESULT CFindCmd::Init(void)
|
|
{
|
|
_hdsaConstraints = DSA_Create(sizeof(CMD_CONSTRAINT), 4);
|
|
if (!_hdsaConstraints)
|
|
return E_OUTOFMEMORY;
|
|
|
|
if (!_updateParams.fcsSearch)
|
|
{
|
|
if (!InitializeCriticalSectionAndSpinCount(&_updateParams.csSearch, 0))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
_updateParams.fcsSearch = TRUE;
|
|
}
|
|
|
|
if (!_fcsThread)
|
|
{
|
|
if (!InitializeCriticalSectionAndSpinCount(&_csThread,0))
|
|
{
|
|
return E_FAIL;
|
|
}
|
|
_fcsThread = TRUE;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
CFindCmd::~CFindCmd()
|
|
{
|
|
if (_updateParams.hwndThreadNotify)
|
|
{
|
|
// make sure no outstanding fsnotifies registered.
|
|
SHChangeNotifyDeregisterWindow(_updateParams.hwndThreadNotify);
|
|
DestroyWindow(_updateParams.hwndThreadNotify);
|
|
}
|
|
|
|
_ClearConstraints();
|
|
DSA_Destroy(_hdsaConstraints);
|
|
_ExecData_Release();
|
|
|
|
if (_updateParams.fcsSearch)
|
|
{
|
|
DeleteCriticalSection(&_updateParams.csSearch);
|
|
}
|
|
|
|
if (_fcsThread)
|
|
{
|
|
DeleteCriticalSection(&_csThread);
|
|
}
|
|
|
|
// Make sure we have removed all outstanding update dirs...
|
|
_ClearDeferUpdateDirList();
|
|
|
|
if (_hdpaItemsToAdd1)
|
|
DPA_Destroy(_hdpaItemsToAdd1);
|
|
|
|
if (_hdpaItemsToAdd2)
|
|
DPA_Destroy(_hdpaItemsToAdd2);
|
|
|
|
ILFree(_pidlRestore);
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CFindCmd, ISearchCommandExt),
|
|
QITABENTMULTI(CFindCmd, IDispatch, ISearchCommandExt),
|
|
QITABENT(CFindCmd, IProvideClassInfo2),
|
|
QITABENTMULTI(CFindCmd, IProvideClassInfo,IProvideClassInfo2),
|
|
QITABENT(CFindCmd, IObjectWithSite),
|
|
QITABENT(CFindCmd, IConnectionPointContainer),
|
|
QITABENT(CFindCmd, OLEDBSimpleProvider),
|
|
QITABENT(CFindCmd, IRowsetWatchNotify),
|
|
QITABENT(CFindCmd, IFindControllerNotify),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CFindCmd::AddRef()
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CFindCmd::Release()
|
|
{
|
|
ASSERT( 0 != _cRef );
|
|
ULONG cRef = InterlockedDecrement(&_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
// IDispatch implementation
|
|
|
|
STDMETHODIMP CFindCmd::GetTypeInfoCount(UINT * pctinfo)
|
|
{
|
|
return CImpIDispatch::GetTypeInfoCount(pctinfo);
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo **pptinfo)
|
|
{
|
|
return CImpIDispatch::GetTypeInfo(itinfo, lcid, pptinfo);
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::GetIDsOfNames(REFIID riid, OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID * rgdispid)
|
|
{
|
|
return CImpIDispatch::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid);
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr)
|
|
{
|
|
return CImpIDispatch::Invoke(dispidMember, riid, lcid, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
|
|
}
|
|
|
|
// ADOCommand implementation, dual interface method callable via script
|
|
|
|
STDMETHODIMP CFindCmd::AddConstraint(BSTR bstrName, VARIANT vValue)
|
|
{
|
|
HRESULT hr = E_OUTOFMEMORY;
|
|
|
|
CMD_CONSTRAINT dfcc = {0};
|
|
dfcc.bstrName = SysAllocString(bstrName);
|
|
if (dfcc.bstrName)
|
|
{
|
|
hr = VariantCopy(&dfcc.vValue, &vValue);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (DSA_ERR == DSA_InsertItem(_hdsaConstraints, DSA_APPEND, &dfcc))
|
|
{
|
|
SysFreeString(dfcc.bstrName);
|
|
VariantClear(&dfcc.vValue);
|
|
hr = E_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SysFreeString(dfcc.bstrName);
|
|
}
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::GetNextConstraint(VARIANT_BOOL fReset, DFConstraint **ppdfc)
|
|
{
|
|
*ppdfc = NULL;
|
|
|
|
IFindFilter *pfilter;
|
|
HRESULT hr = _execData.pff->GetFindFilter(&pfilter);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BSTR bName;
|
|
VARIANT var;
|
|
VARIANT_BOOL fFound;
|
|
hr = pfilter->GetNextConstraint(fReset, &bName, &var, &fFound);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (!fFound)
|
|
{
|
|
// need a simple way to signal end list, how about an empty name string?
|
|
bName = SysAllocString(L"");
|
|
}
|
|
CFindConstraint *pdfc = new CFindConstraint(bName, var);
|
|
if (pdfc)
|
|
{
|
|
hr = pdfc->QueryInterface(IID_PPV_ARG(DFConstraint, ppdfc));
|
|
pdfc->Release();
|
|
}
|
|
else
|
|
{
|
|
// error release stuff we allocated.
|
|
hr = E_OUTOFMEMORY;
|
|
SysFreeString(bName);
|
|
VariantClear(&var);
|
|
}
|
|
}
|
|
pfilter->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CFindCmd::_UpdateFilter(IFindFilter *pfilter)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
pfilter->ResetFieldsToDefaults();
|
|
|
|
int cNumParams = DSA_GetItemCount(_hdsaConstraints);
|
|
for (int iItem = 0; iItem < cNumParams; iItem++)
|
|
{
|
|
CMD_CONSTRAINT *pdfcc = (CMD_CONSTRAINT *)DSA_GetItemPtr(_hdsaConstraints, iItem);
|
|
if (pdfcc)
|
|
{
|
|
hr = pfilter->UpdateField(pdfcc->bstrName, pdfcc->vValue);
|
|
}
|
|
}
|
|
|
|
// And clear out the constraint list...
|
|
_ClearConstraints();
|
|
return hr;
|
|
}
|
|
|
|
void CFindCmd::_ClearConstraints()
|
|
{
|
|
int cNumParams = DSA_GetItemCount(_hdsaConstraints);
|
|
for (int iItem = 0; iItem < cNumParams; iItem++)
|
|
{
|
|
CMD_CONSTRAINT *pdfcc = (CMD_CONSTRAINT *)DSA_GetItemPtr(_hdsaConstraints, iItem);
|
|
if (pdfcc)
|
|
{
|
|
SysFreeString(pdfcc->bstrName);
|
|
VariantClear(&pdfcc->vValue);
|
|
}
|
|
}
|
|
DSA_DeleteAllItems(_hdsaConstraints);
|
|
}
|
|
|
|
void cdecl CFindCmd::_NotifyProgressText(UINT ids,...)
|
|
{
|
|
BOOL fOk = FALSE;
|
|
|
|
va_list ArgList;
|
|
va_start(ArgList, ids);
|
|
LPTSTR psz = _ConstructMessageString(HINST_THISDLL, MAKEINTRESOURCE(ids), &ArgList);
|
|
va_end(ArgList);
|
|
|
|
if (psz)
|
|
{
|
|
HRESULT hr = StringCchCopy(_szProgressText, ARRAYSIZE(_szProgressText), psz);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
fOk = TRUE;
|
|
}
|
|
|
|
LocalFree(psz);
|
|
}
|
|
|
|
if (!fOk)
|
|
{
|
|
_szProgressText[0] = 0;
|
|
}
|
|
|
|
_cpEvents.InvokeDispid(DISPID_SEARCHCOMMAND_PROGRESSTEXT);
|
|
}
|
|
|
|
STDAPI CDocFindCommand_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv)
|
|
{
|
|
*ppv = NULL;
|
|
|
|
HRESULT hr;
|
|
CFindCmd *pfc = new CFindCmd();
|
|
if (pfc)
|
|
{
|
|
hr = pfc->Init();
|
|
if (SUCCEEDED(hr))
|
|
hr = pfc->QueryInterface(riid, ppv);
|
|
pfc->Release();
|
|
}
|
|
else
|
|
hr = E_OUTOFMEMORY;
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
int CFindCmd::_CompareCallback(IShellFolder *psf, IFindFolder *pff, LPITEMIDLIST pidl1, LPITEMIDLIST pidl2)
|
|
{
|
|
int iResult = pff->GetFolderIndex(pidl1) - pff->GetFolderIndex(pidl2);
|
|
|
|
if (iResult == 0)
|
|
{
|
|
WCHAR szName1[MAX_PATH], szName2[MAX_PATH];
|
|
|
|
iResult = 1; // If we fail, at least return a non-equal indicator
|
|
|
|
// Get the name for 1 - We use SHGDN_FORADDRESSBAR for perf, if you
|
|
// check out the pff->GetDisplayNameOf you'll see that it tries to
|
|
// trink SHGDN_INFOLDER to ~SHGND_INFOLDER so that name comparisons
|
|
// use the full name. We've already distinguished folders above, so
|
|
// for speed we can avoid that with SHGDN_FORADDRESSBAR.
|
|
HRESULT hr = DisplayNameOf(psf, pidl1, SHGDN_INFOLDER | SHGDN_FORPARSING | SHGDN_FORADDRESSBAR, szName1, ARRAYSIZE(szName1));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Get the name for 2
|
|
hr = DisplayNameOf(psf, pidl2, SHGDN_INFOLDER | SHGDN_FORPARSING | SHGDN_FORADDRESSBAR, szName2, ARRAYSIZE(szName2));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Compare and set value
|
|
iResult = StrCmpICW(szName1, szName2);
|
|
}
|
|
}
|
|
}
|
|
return iResult;
|
|
}
|
|
|
|
typedef struct
|
|
{
|
|
CFindCmd *pthis;
|
|
IShellFolder *psf;
|
|
IFindFolder *pff;
|
|
} CFC_CALLBACK_INFO;
|
|
|
|
int CFindCmd::_CompareCallbackStub(void *p1, void *p2, LPARAM lParam)
|
|
{
|
|
CFC_CALLBACK_INFO *pcci = (CFC_CALLBACK_INFO *)lParam;
|
|
|
|
LPITEMIDLIST pidl1 = (LPITEMIDLIST)p1;
|
|
LPITEMIDLIST pidl2 = (LPITEMIDLIST)p2;
|
|
|
|
return pcci->pthis->_CompareCallback(pcci->psf, pcci->pff, pidl1, pidl2);
|
|
}
|
|
|
|
|
|
void CFindCmd::_PTN_SearchProgress(void)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
HDPA hdpa = _updateParams.hdpa;
|
|
if (hdpa)
|
|
{
|
|
// Ok lets swap things out from under other thread so that we can process it and still
|
|
// let the other thread run...
|
|
EnterCriticalSection(&_updateParams.csSearch);
|
|
|
|
if (_updateParams.hdpa == _hdpaItemsToAdd2)
|
|
_updateParams.hdpa = _hdpaItemsToAdd1;
|
|
else
|
|
_updateParams.hdpa = _hdpaItemsToAdd2;
|
|
|
|
// say that we don't have any thing here such that other thread will reset up...
|
|
_updateParams.fFilesAdded = FALSE;
|
|
BOOL fDirChanged = _updateParams.fDirChanged;
|
|
_updateParams.fDirChanged = FALSE;
|
|
|
|
LeaveCriticalSection(&_updateParams.csSearch);
|
|
|
|
int cItemsToAdd = DPA_GetPtrCount(hdpa);
|
|
|
|
if (!_execData.pff)
|
|
return;
|
|
|
|
int iItem;
|
|
_execData.pff->GetItemCount(&iItem);
|
|
int iItemStart = iItem + 1; // needed for notifies 1 based.
|
|
|
|
if (cItemsToAdd)
|
|
{
|
|
if (_fContinue)
|
|
{
|
|
// Are we in an updatedir? If so then need to do merge, else...
|
|
if (_pidlUpdate)
|
|
{
|
|
UINT iFolderIndexMin;
|
|
UINT iFolderIndexMax;
|
|
UINT iFolderIndex;
|
|
LPITEMIDLIST pidl;
|
|
int cItems = iItem;
|
|
CFC_CALLBACK_INFO cci;
|
|
|
|
cci.pthis = this;
|
|
cci.psf = _execData.psf; // these are weak references
|
|
cci.pff = _execData.pff; // these are weak references
|
|
|
|
pidl = (LPITEMIDLIST)DPA_FastGetPtr(hdpa, 0);
|
|
iFolderIndexMin = _execData.pff->GetFolderIndex(pidl);
|
|
pidl = (LPITEMIDLIST)DPA_FastGetPtr(hdpa, cItemsToAdd-1);
|
|
iFolderIndexMax = _execData.pff->GetFolderIndex(pidl);
|
|
|
|
int i;
|
|
for (int j = cItems - 1; j >= 0; j--)
|
|
{
|
|
FIND_ITEM *pfi;
|
|
_execData.pff->GetItem(j, &pfi);
|
|
|
|
if (pfi && (pfi->dwState & CDFITEM_STATE_MAYBEDELETE) != 0)
|
|
{
|
|
iFolderIndex = _execData.pff->GetFolderIndex(&pfi->idl);
|
|
|
|
if (iFolderIndex >= iFolderIndexMin && iFolderIndex <= iFolderIndexMax)
|
|
{
|
|
i = DPA_Search(hdpa, &pfi->idl, 0, _CompareCallbackStub, (LPARAM)&cci, DPAS_SORTED);
|
|
|
|
if (DPA_ERR != i)
|
|
{
|
|
pfi->dwState &= ~CDFITEM_STATE_MAYBEDELETE;
|
|
pidl = (LPITEMIDLIST)DPA_FastGetPtr(hdpa, i);
|
|
DPA_DeletePtr(hdpa, i);
|
|
ILFree(pidl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (i = DPA_GetPtrCount(hdpa) - 1; i >= 0; i--)
|
|
{
|
|
pidl = (LPITEMIDLIST)DPA_FastGetPtr(hdpa, i);
|
|
|
|
// Not already in the list so add it...
|
|
hr = _execData.pff->AddPidl(iItem, pidl, -1, NULL);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
iItem++;
|
|
}
|
|
|
|
DPA_DeletePtr(hdpa, i);
|
|
ILFree(pidl);
|
|
}
|
|
if (iItem && _execData.psfv)
|
|
{
|
|
hr = _execData.psfv->SetObjectCount(iItem, SFVSOC_NOSCROLL);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (_pListener)
|
|
_pListener->aboutToInsertRows(iItemStart, cItemsToAdd);
|
|
|
|
for (int i = 0; i < cItemsToAdd; i++)
|
|
{
|
|
LPITEMIDLIST pidl = (LPITEMIDLIST)DPA_FastGetPtr(hdpa, i);
|
|
hr = _execData.pff->AddPidl(iItem, pidl, -1, NULL);
|
|
if (SUCCEEDED(hr))
|
|
iItem++;
|
|
ILFree(pidl); // AddPidl makes a copy
|
|
}
|
|
|
|
if (iItem >= iItemStart)
|
|
{
|
|
if (_execData.psfv)
|
|
hr = _execData.psfv->SetObjectCount(iItem, SFVSOC_NOSCROLL);
|
|
|
|
_execData.pff->SetItemsChangedSinceSort();
|
|
_cpEvents.InvokeDispid(DISPID_SEARCHCOMMAND_UPDATE);
|
|
}
|
|
|
|
if (_pListener)
|
|
{
|
|
_pListener->insertedRows(iItemStart, cItemsToAdd);
|
|
_pListener->rowsAvailable(iItemStart, cItemsToAdd);
|
|
}
|
|
}
|
|
}
|
|
else // _fContinue
|
|
{
|
|
for (int i = 0; i < cItemsToAdd; i++)
|
|
{
|
|
ILFree((LPITEMIDLIST)DPA_FastGetPtr(hdpa, i));
|
|
}
|
|
}
|
|
DPA_DeleteAllPtrs(hdpa);
|
|
}
|
|
|
|
if (fDirChanged)
|
|
{
|
|
_NotifyProgressText(IDS_SEARCHING, _execData.szProgressText);
|
|
}
|
|
}
|
|
|
|
_updateParams.dwTimeLastNotify = GetTickCount();
|
|
_updateParams.fUpdatePosted = FALSE;
|
|
}
|
|
|
|
void CFindCmd::_PTN_AsyncProgress(int nPercentComplete, DWORD cAsync)
|
|
{
|
|
if (!_execData.pff)
|
|
return;
|
|
// Async case try just setting the count...
|
|
_execData.pff->SetAsyncCount(cAsync);
|
|
if (_execData.psfv)
|
|
{
|
|
// -1 for the first item means verify visible items only
|
|
_execData.pff->ValidateItems(_execData.psfv, -1, -1, FALSE);
|
|
_execData.psfv->SetObjectCount(cAsync, SFVSOC_NOSCROLL);
|
|
}
|
|
|
|
_execData.pff->SetItemsChangedSinceSort();
|
|
_cpEvents.InvokeDispid(DISPID_SEARCHCOMMAND_UPDATE);
|
|
_NotifyProgressText(IDS_SEARCHINGASYNC, cAsync, nPercentComplete);
|
|
}
|
|
|
|
void CFindCmd::_ClearItemDPA(HDPA hdpa)
|
|
{
|
|
if (hdpa)
|
|
{
|
|
EnterCriticalSection(&_updateParams.csSearch);
|
|
int cItems = DPA_GetPtrCount(hdpa);
|
|
for (int i = 0; i < cItems; i++)
|
|
{
|
|
ILFree((LPITEMIDLIST)DPA_GetPtr(hdpa, i));
|
|
}
|
|
DPA_DeleteAllPtrs(hdpa);
|
|
LeaveCriticalSection(&_updateParams.csSearch);
|
|
}
|
|
}
|
|
|
|
void CFindCmd::_PTN_SearchComplete(HRESULT hr, BOOL fAbort)
|
|
{
|
|
int iItem;
|
|
|
|
// someone clicked on new button -- cannot set no files found text in listview
|
|
// because we'll overwrite enter search criteria to begin
|
|
if (!_fNew)
|
|
_SetEmptyText(IDS_FINDVIEWEMPTY);
|
|
_SetLastError(hr);
|
|
|
|
// _execData.pff is NULL when Searh is complete by navigating away from the search page
|
|
if (!_execData.pff)
|
|
{
|
|
// do clean up of hdpaToItemsToadd1 and 2
|
|
// make sure all items in buffer 1 and 2 are empty
|
|
_ClearItemDPA(_hdpaItemsToAdd1);
|
|
_ClearItemDPA(_hdpaItemsToAdd2);
|
|
}
|
|
else
|
|
{
|
|
// if we have a _pidlUpdate are completing an update
|
|
if (_pidlUpdate)
|
|
{
|
|
int i, cPidf;
|
|
UINT uItem;
|
|
|
|
_execData.pff->GetItemCount(&i);
|
|
for (; i-- > 0;)
|
|
{
|
|
// Pidl at start of structure...
|
|
FIND_ITEM *pfi;
|
|
HRESULT hr = _execData.pff->GetItem(i, &pfi);
|
|
if (SUCCEEDED(hr) && pfi->dwState & CDFITEM_STATE_MAYBEDELETE)
|
|
{
|
|
_execData.psfv->RemoveObject(&pfi->idl, &uItem);
|
|
}
|
|
}
|
|
|
|
ILFree(_pidlUpdate);
|
|
_pidlUpdate = NULL;
|
|
|
|
// clear the update dir flags
|
|
_execData.pff->GetFolderListItemCount(&cPidf);
|
|
for (i = 0; i < cPidf; i++)
|
|
{
|
|
FIND_FOLDER_ITEM *pdffli;
|
|
|
|
if (SUCCEEDED(_execData.pff->GetFolderListItem(i, &pdffli)))
|
|
pdffli->fUpdateDir = FALSE;
|
|
}
|
|
}
|
|
|
|
// Release our reference count on the searching.
|
|
if (_cExecInProgress)
|
|
_cExecInProgress--;
|
|
|
|
// Tell everyone the final count and that we are done...
|
|
// But first check if there are any cached up Updatedirs to be processed...
|
|
if (_pdudFirst)
|
|
{
|
|
// first unlink the first one...
|
|
struct DEFER_UPDATE_DIR *pdud = _pdudFirst;
|
|
_pdudFirst = pdud->pdudNext;
|
|
|
|
if (_execData.pff->HandleUpdateDir(pdud->pidl, pdud->fRecurse))
|
|
{
|
|
// Need to spawn sub-search on this...
|
|
_Start(FALSE, -1, pdud->pidl);
|
|
}
|
|
ILFree(pdud->pidl);
|
|
LocalFree((HLOCAL)pdud);
|
|
}
|
|
else
|
|
{
|
|
if (_execData.psfv)
|
|
{
|
|
// validate all the items we pulled in already
|
|
_execData.pff->ValidateItems(_execData.psfv, 0, -1, TRUE);
|
|
}
|
|
_execData.pff->GetItemCount(&iItem);
|
|
_NotifyProgressText(_uStatusMsgIndex, iItem);
|
|
if (!fAbort)
|
|
_SelectResults();
|
|
}
|
|
}
|
|
|
|
// weird connection point corruption can happen here. somehow the number of sinks is 0 but
|
|
// some of the array entries are non null thus causing fault. this problem does not want to
|
|
// repro w/ manual testing or debug binaries, only sometimes after an automation run. when
|
|
// it happens it is too late to figure out what happened so just patch it here.
|
|
if (_cpEvents._HasSinks())
|
|
_cpEvents.InvokeDispid(fAbort ? DISPID_SEARCHCOMMAND_ABORT : DISPID_SEARCHCOMMAND_COMPLETE);
|
|
}
|
|
|
|
// see if we need to restart the search based on an update dir
|
|
|
|
BOOL ShouldRestartSearch(LPCITEMIDLIST pidl)
|
|
{
|
|
BOOL fRestart = TRUE; // assume we should, non file system pidls
|
|
|
|
WCHAR szPath[MAX_PATH];
|
|
if (SHGetPathFromIDList(pidl, szPath))
|
|
{
|
|
// Check if this is either a network drive or a remote drive:
|
|
if (PathIsRemote(szPath))
|
|
{
|
|
// If we can find the CI catalogs for the drive on the other machine, then we do
|
|
// not want to search.
|
|
|
|
WCHAR wszCatalog[MAX_PATH], wszMachine[32];
|
|
ULONG cchCatalog = ARRAYSIZE(wszCatalog), cchMachine = ARRAYSIZE(wszMachine);
|
|
|
|
fRestart = (S_OK != LocateCatalogsW(szPath, 0, wszMachine, &cchMachine, wszCatalog, &cchCatalog));
|
|
}
|
|
else if (-1 != PathGetDriveNumber(szPath))
|
|
{
|
|
// It is a local dirve...
|
|
// Is this machine running the content indexer (CI)?
|
|
|
|
BOOL fCiRunning, fCiIndexed, fCiPermission;
|
|
GetCIStatus(&fCiRunning, &fCiIndexed, &fCiPermission);
|
|
|
|
fRestart = !fCiRunning || !fCiIndexed; // restart if not running or not fully indexed
|
|
}
|
|
}
|
|
|
|
return fRestart;
|
|
}
|
|
|
|
void CFindCmd::_OnChangeNotify(LONG code, LPITEMIDLIST *ppidl)
|
|
{
|
|
LPITEMIDLIST pidlT;
|
|
UINT idsMsg;
|
|
UINT cItems;
|
|
|
|
if (!_execData.pff)
|
|
{
|
|
_ExecData_Init();
|
|
|
|
// If we are running async then for now ignore notifications...
|
|
// Unless we have cached all of the items...
|
|
if (!_execData.pff)
|
|
return; // we do not have anything to listen...
|
|
}
|
|
|
|
// see if we want to process the notificiation or not.
|
|
switch (code)
|
|
{
|
|
case SHCNE_RENAMEFOLDER: // With trashcan this is what we see...
|
|
case SHCNE_RENAMEITEM: // With trashcan this is what we see...
|
|
case SHCNE_DELETE:
|
|
case SHCNE_RMDIR:
|
|
case SHCNE_UPDATEITEM:
|
|
break;
|
|
|
|
case SHCNE_CREATE:
|
|
case SHCNE_MKDIR:
|
|
// Process this one out of place
|
|
_execData.pff->UpdateOrMaybeAddPidl(_execData.psfv, *ppidl, NULL);
|
|
break;
|
|
|
|
case SHCNE_UPDATEDIR:
|
|
TraceMsg(TF_DOCFIND, "DocFind got notify SHCNE_UPDATEDIR, pidl=0x%X",*ppidl);
|
|
if (ShouldRestartSearch(*ppidl))
|
|
{
|
|
BOOL bRecurse = (ppidl[1] != NULL);
|
|
if (_cExecInProgress)
|
|
{
|
|
_DeferHandleUpdateDir(*ppidl, bRecurse);
|
|
}
|
|
else
|
|
{
|
|
if (_execData.pff->HandleUpdateDir(*ppidl, bRecurse))
|
|
{
|
|
// Need to spawn sub-search on this...
|
|
_Start(FALSE, -1, *ppidl);
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
|
|
default:
|
|
return; // we are not interested in this event
|
|
}
|
|
|
|
//
|
|
// Now we need to see if the item might be in our list
|
|
// First we need to extract off the last part of the id list
|
|
// and see if the contained id entry is in our list. If so we
|
|
// need to see if can get the defview find the item and update it.
|
|
//
|
|
|
|
_execData.pff->MapToSearchIDList(*ppidl, FALSE, &pidlT);
|
|
|
|
switch (code)
|
|
{
|
|
case SHCNE_RMDIR:
|
|
TraceMsg(TF_DOCFIND, "DocFind got notify SHCNE_RMDIR, pidl=0x%X",*ppidl);
|
|
_execData.pff->HandleRMDir(_execData.psfv, *ppidl);
|
|
if (pidlT)
|
|
{
|
|
_execData.psfv->RemoveObject(pidlT, &idsMsg);
|
|
}
|
|
break;
|
|
|
|
case SHCNE_DELETE:
|
|
TraceMsg(TF_DOCFIND, "DocFind got notify SHCNE_DELETE, pidl=0x%X",*ppidl);
|
|
if (pidlT)
|
|
{
|
|
_execData.psfv->RemoveObject(pidlT, &idsMsg);
|
|
}
|
|
break;
|
|
|
|
case SHCNE_RENAMEFOLDER:
|
|
case SHCNE_RENAMEITEM:
|
|
if (pidlT)
|
|
{
|
|
// If the two items dont have the same parent, we will go ahead
|
|
// and remove it...
|
|
LPITEMIDLIST pidl1;
|
|
if (SUCCEEDED(_execData.pff->GetParentsPIDL(pidlT, &pidl1)))
|
|
{
|
|
LPITEMIDLIST pidl2 = ILClone(ppidl[1]);
|
|
if (pidl2)
|
|
{
|
|
ILRemoveLastID(pidl2);
|
|
if (!ILIsEqual(pidl1, pidl2))
|
|
{
|
|
_execData.psfv->RemoveObject(pidlT, &idsMsg);
|
|
|
|
// And maybe add it back to the end... of the list
|
|
_execData.pff->UpdateOrMaybeAddPidl(_execData.psfv, ppidl[1], NULL);
|
|
}
|
|
else
|
|
{
|
|
// The object is in same folder so must be rename...
|
|
// And maybe add it back to the end... of the list
|
|
_execData.pff->UpdateOrMaybeAddPidl(_execData.psfv, ppidl[1], pidlT);
|
|
}
|
|
ILFree(pidl2);
|
|
}
|
|
ILFree(pidl1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_execData.pff->UpdateOrMaybeAddPidl(_execData.psfv, ppidl[1], NULL);
|
|
}
|
|
break;
|
|
|
|
case SHCNE_UPDATEITEM:
|
|
TraceMsg(TF_DOCFIND, "DocFind got notify SHCNE_UPDATEITEM, pidl=0x%X",*ppidl);
|
|
if (pidlT)
|
|
_execData.pff->UpdateOrMaybeAddPidl(_execData.psfv, *ppidl, pidlT);
|
|
break;
|
|
}
|
|
|
|
// Update the count...
|
|
_execData.psfv->GetObjectCount(&cItems);
|
|
_NotifyProgressText(_uStatusMsgIndex, cItems);
|
|
|
|
ILFree(pidlT);
|
|
}
|
|
|
|
// Ok we need to add a defer
|
|
|
|
void CFindCmd::_DeferHandleUpdateDir(LPCITEMIDLIST pidl, BOOL bRecurse)
|
|
{
|
|
// See if we already have some items in the list which are lower down in the tree if so we
|
|
// can replace it. Or is there one that is higher up, in which case we can ignore it...
|
|
|
|
struct DEFER_UPDATE_DIR *pdudPrev = NULL;
|
|
struct DEFER_UPDATE_DIR *pdud = _pdudFirst;
|
|
while (pdud)
|
|
{
|
|
if (ILIsParent(pdud->pidl, pidl, FALSE))
|
|
return; // Already one in the list that will handle this one...
|
|
if (ILIsParent(pidl, pdud->pidl, FALSE))
|
|
break;
|
|
pdudPrev = pdud;
|
|
pdud = pdud->pdudNext;
|
|
}
|
|
|
|
// See if we found one that we can replace...
|
|
if (pdud)
|
|
{
|
|
LPITEMIDLIST pidlT = ILClone(pidl);
|
|
if (pidlT)
|
|
{
|
|
ILFree(pdud->pidl);
|
|
pdud->pidl = pidlT;
|
|
|
|
// See if there are others...
|
|
pdudPrev = pdud;
|
|
pdud = pdud->pdudNext;
|
|
while (pdud)
|
|
{
|
|
if (ILIsParent(pidl, pdud->pidl, FALSE))
|
|
{
|
|
// Yep lets trash this one.
|
|
ILFree(pdud->pidl);
|
|
pdudPrev->pdudNext = pdud->pdudNext;
|
|
pdud = pdudPrev; // Let it fall through to setup to look at next...
|
|
}
|
|
pdudPrev = pdud;
|
|
pdud = pdud->pdudNext;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Nope simply add us in to the start of the list.
|
|
pdud = (struct DEFER_UPDATE_DIR*)LocalAlloc(LPTR, sizeof(struct DEFER_UPDATE_DIR));
|
|
if (!pdud)
|
|
return; // Ooop could not alloc...
|
|
pdud->pidl = ILClone(pidl);
|
|
if (!pdud->pidl)
|
|
{
|
|
LocalFree((HLOCAL)pdud);
|
|
return;
|
|
}
|
|
pdud->fRecurse = bRecurse;
|
|
pdud->pdudNext = _pdudFirst;
|
|
_pdudFirst = pdud;
|
|
}
|
|
}
|
|
|
|
void CFindCmd::_ClearDeferUpdateDirList()
|
|
{
|
|
// Cancel any Pending updatedirs also.
|
|
while (_pdudFirst)
|
|
{
|
|
struct DEFER_UPDATE_DIR *pdud = _pdudFirst;
|
|
_pdudFirst = pdud->pdudNext;
|
|
ILFree(pdud->pidl);
|
|
LocalFree((HLOCAL)pdud);
|
|
}
|
|
}
|
|
|
|
LRESULT CALLBACK CFindCmd::_WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CFindCmd* pThis = (CFindCmd*)GetWindowLongPtr(hwnd, 0);
|
|
LRESULT lRes = 0;
|
|
switch (uMsg)
|
|
{
|
|
case WM_DESTROY:
|
|
SetWindowLong(hwnd, 0, 0); // make sure we don't deref pThis
|
|
break;
|
|
|
|
case WM_DF_FSNOTIFY:
|
|
{
|
|
LPITEMIDLIST *ppidl;
|
|
LONG lEvent;
|
|
LPSHChangeNotificationLock pshcnl = SHChangeNotification_Lock((HANDLE)wParam, (DWORD)lParam, &ppidl, &lEvent);
|
|
if (pshcnl)
|
|
{
|
|
if (pThis)
|
|
pThis->_OnChangeNotify(lEvent, ppidl);
|
|
SHChangeNotification_Unlock(pshcnl);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case WM_DF_SEARCHPROGRESS:
|
|
pThis->_PTN_SearchProgress();
|
|
pThis->Release();
|
|
break;
|
|
|
|
case WM_DF_ASYNCPROGRESS:
|
|
pThis->_PTN_AsyncProgress((int)wParam, (DWORD)lParam);
|
|
pThis->Release();
|
|
break;
|
|
|
|
case WM_DF_SEARCHSTART:
|
|
pThis->_cpEvents.InvokeDispid(DISPID_SEARCHCOMMAND_START);
|
|
pThis->_SetEmptyText(IDS_FINDVIEWEMPTYBUSY);
|
|
pThis->Release();
|
|
break;
|
|
|
|
case WM_DF_SEARCHCOMPLETE:
|
|
pThis->_PTN_SearchComplete((HRESULT)wParam, (BOOL)lParam);
|
|
pThis->Release();
|
|
break;
|
|
|
|
default:
|
|
lRes = ::DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
break;
|
|
}
|
|
return lRes;
|
|
}
|
|
|
|
// test to see if the view is in a mode where many items are displayed
|
|
BOOL LotsOfItemsInView(IUnknown *punkSite)
|
|
{
|
|
BOOL bLotsOfItemsInView = FALSE;
|
|
|
|
IFolderView * pfv;
|
|
HRESULT hr = IUnknown_QueryService(punkSite, SID_SFolderView, IID_PPV_ARG(IFolderView, &pfv));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
UINT uViewMode;
|
|
bLotsOfItemsInView = SUCCEEDED(pfv->GetCurrentViewMode(&uViewMode)) &&
|
|
((FVM_ICON == uViewMode) || (FVM_SMALLICON == uViewMode));
|
|
pfv->Release();
|
|
}
|
|
return bLotsOfItemsInView;
|
|
}
|
|
|
|
void CFindCmd::_DoSearch(IFindEnum *penum, IShellFolder *psf, IFindFolder *pff, IShellFolderView *psfv)
|
|
{
|
|
BOOL fAbort = FALSE;
|
|
CFC_CALLBACK_INFO cci;
|
|
|
|
cci.pthis = this;
|
|
cci.psf = psf; // these are weak references
|
|
cci.pff = pff; // these are weak references
|
|
|
|
BOOL bLotsOfItems = LotsOfItemsInView(psfv);
|
|
|
|
EnterCriticalSection(&_csThread);
|
|
|
|
// previous thread might have exited but we're still processing search complete message
|
|
if (_cExecInProgress > 1)
|
|
Sleep(1000); // give it a chance to finish
|
|
|
|
_updateParams.hdpa = NULL;
|
|
_updateParams.fFilesAdded = FALSE;
|
|
_updateParams.fDirChanged = FALSE;
|
|
_updateParams.fUpdatePosted = FALSE;
|
|
|
|
_PostMessage(WM_DF_SEARCHSTART, 0, 0);
|
|
|
|
// Now see if this is an Sync or an Async version of the search...
|
|
|
|
HRESULT hr = S_OK;
|
|
|
|
BOOL fQueryIsAsync = penum->FQueryIsAsync();
|
|
if (fQueryIsAsync)
|
|
{
|
|
DBCOUNTITEM dwTotalAsync;
|
|
BOOL fDone;
|
|
int nPercentComplete;
|
|
while (S_OK == (hr = penum->GetAsyncCount(&dwTotalAsync, &nPercentComplete, &fDone)))
|
|
{
|
|
if (!_fContinue)
|
|
{
|
|
fAbort = TRUE;
|
|
break;
|
|
}
|
|
|
|
_PostMessage(WM_DF_ASYNCPROGRESS, (WPARAM)nPercentComplete, (LPARAM)dwTotalAsync);
|
|
|
|
// If we are done we can simply let the ending callback tell of the new count...
|
|
if (fDone)
|
|
break;
|
|
|
|
// sleep .3 or 1.5 sec
|
|
Sleep(bLotsOfItems ? 1500 : 300); // wait between looking again...
|
|
}
|
|
}
|
|
|
|
if (!fQueryIsAsync || (fQueryIsAsync == DF_QUERYISMIXED))
|
|
{
|
|
int state, cItemsSearched = 0, cFoldersSearched = 0, cFoldersSearchedPrev = 0;
|
|
|
|
_updateParams.hdpa = _hdpaItemsToAdd1; // Assume first one now...
|
|
_updateParams.dwTimeLastNotify = GetTickCount();
|
|
|
|
LPITEMIDLIST pidl;
|
|
while (S_OK == (hr = penum->Next(&pidl, &cItemsSearched, &cFoldersSearched, &_fContinue, &state)))
|
|
{
|
|
if (state == GNF_DONE)
|
|
break; // no more
|
|
|
|
if (!_fContinue)
|
|
{
|
|
fAbort = TRUE;
|
|
break;
|
|
}
|
|
|
|
// See if we should abort
|
|
if (state == GNF_MATCH)
|
|
{
|
|
EnterCriticalSection(&_updateParams.csSearch);
|
|
DPA_AppendPtr(_updateParams.hdpa, pidl);
|
|
_updateParams.fFilesAdded = TRUE;
|
|
LeaveCriticalSection(&_updateParams.csSearch);
|
|
}
|
|
|
|
if (cFoldersSearchedPrev != cFoldersSearched)
|
|
{
|
|
_updateParams.fDirChanged = TRUE;
|
|
cFoldersSearchedPrev = cFoldersSearched;
|
|
}
|
|
|
|
if (!_updateParams.fUpdatePosted &&
|
|
(_updateParams.fDirChanged || _updateParams.fFilesAdded))
|
|
{
|
|
if ((GetTickCount() - _updateParams.dwTimeLastNotify) > 200)
|
|
{
|
|
DPA_Sort(_updateParams.hdpa, _CompareCallbackStub, (LPARAM)&cci);
|
|
_updateParams.fUpdatePosted = TRUE;
|
|
_PostMessage(WM_DF_SEARCHPROGRESS, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
DPA_Sort(_updateParams.hdpa, _CompareCallbackStub, (LPARAM)&cci);
|
|
|
|
_PostMessage(WM_DF_SEARCHPROGRESS, 0, 0);
|
|
}
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
fAbort = TRUE;
|
|
}
|
|
|
|
_PostMessage(WM_DF_SEARCHCOMPLETE, (WPARAM)hr, (LPARAM)fAbort);
|
|
|
|
LeaveCriticalSection(&_csThread);
|
|
}
|
|
|
|
DWORD CALLBACK CFindCmd::_ThreadProc(void *pv)
|
|
{
|
|
THREAD_PARAMS *pParams = (THREAD_PARAMS *)pv;
|
|
pParams->pThis->_DoSearch(pParams->penum, pParams->psf, pParams->pff, pParams->psfv);
|
|
_FreeThreadParams(pParams);
|
|
return 0;
|
|
}
|
|
|
|
HRESULT CFindCmd::_Cancel()
|
|
{
|
|
_ClearDeferUpdateDirList();
|
|
|
|
if (DSA_GetItemCount(_hdsaConstraints) == 0)
|
|
{
|
|
_fContinue = FALSE; // Cancel current query if we have a null paramter collection
|
|
return S_OK;
|
|
}
|
|
|
|
return E_FAIL;
|
|
}
|
|
|
|
HRESULT CFindCmd::_Init(THREAD_PARAMS **ppParams, int iCol, LPCITEMIDLIST pidlUpdate)
|
|
{
|
|
*ppParams = new THREAD_PARAMS;
|
|
if (NULL == *ppParams)
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Clear any previous registrations...
|
|
SHChangeNotifyDeregisterWindow(_updateParams.hwndThreadNotify);
|
|
|
|
// Prepare to execute the query
|
|
IFindFilter *pfilter;
|
|
HRESULT hr = _execData.pff->GetFindFilter(&pfilter);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// We do not need to update the filter if this is done as part of an FSNOTIFY or a Sort...
|
|
if ((iCol >= 0) || pidlUpdate || SUCCEEDED(hr = _UpdateFilter(pfilter)))
|
|
{
|
|
_execData.szProgressText[0] = 0;
|
|
|
|
pfilter->DeclareFSNotifyInterest(_updateParams.hwndThreadNotify, WM_DF_FSNOTIFY);
|
|
pfilter->GetStatusMessageIndex(0, &_uStatusMsgIndex);
|
|
|
|
DWORD dwFlags;
|
|
hr = pfilter->PrepareToEnumObjects(_GetWindow(), &dwFlags);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pfilter->EnumObjects(_execData.psf, pidlUpdate, dwFlags, iCol,
|
|
_execData.szProgressText, SAFECAST(this, IRowsetWatchNotify*), &(*ppParams)->penum);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
(*ppParams)->psf = _execData.psf;
|
|
_execData.psf->AddRef();
|
|
(*ppParams)->pff = _execData.pff;
|
|
_execData.pff->AddRef();
|
|
(*ppParams)->psfv = _execData.psfv;
|
|
_execData.psfv->AddRef();
|
|
}
|
|
}
|
|
}
|
|
pfilter->Release();
|
|
}
|
|
|
|
// Fill in the exec params
|
|
|
|
(*ppParams)->pThis = this;
|
|
AddRef(); // ExecParams_Free will release this interface addref...
|
|
|
|
if (FAILED(hr) || ((*ppParams)->penum == NULL))
|
|
{
|
|
_FreeThreadParams(*ppParams);
|
|
*ppParams = NULL;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CFindCmd::_FreeThreadParams(THREAD_PARAMS *pParams)
|
|
{
|
|
if (!pParams)
|
|
return S_OK;
|
|
|
|
// Don't use atomic release as this a pointer to a class not an interface.
|
|
CFindCmd *pThis = pParams->pThis;
|
|
pParams->pThis = NULL;
|
|
pThis->Release();
|
|
|
|
ATOMICRELEASE(pParams->penum);
|
|
ATOMICRELEASE(pParams->psf);
|
|
ATOMICRELEASE(pParams->pff);
|
|
ATOMICRELEASE(pParams->psfv);
|
|
|
|
delete pParams;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CFindCmd::_ExecData_Release()
|
|
{
|
|
ATOMICRELEASE(_execData.psf);
|
|
ATOMICRELEASE(_execData.psfv);
|
|
if (_execData.pff)
|
|
_execData.pff->SetControllerNotifyObject(NULL); // release back pointer to us...
|
|
ATOMICRELEASE(_execData.pff);
|
|
_cExecInProgress = 0; // we must be in process of shutting down at least...
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CFindCmd::_EnsureResultsViewIsCurrent(IUnknown *punk)
|
|
{
|
|
HRESULT hr = E_FAIL;
|
|
LPITEMIDLIST pidlFolder;
|
|
if (S_OK == SHGetIDListFromUnk(punk, &pidlFolder))
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
if (SUCCEEDED(_GetSearchIDList(&pidl)))
|
|
{
|
|
if (ILIsEqual(pidlFolder, pidl))
|
|
hr = S_OK;
|
|
ILFree(pidl);
|
|
}
|
|
ILFree(pidlFolder);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
// the search results view callback proffeerd itself and we can use that
|
|
// to get a hold of defview and can program it
|
|
|
|
HRESULT CFindCmd::_GetShellView(REFIID riid, void **ppv)
|
|
{
|
|
return IUnknown_QueryService(_punkSite, SID_DocFindFolder, riid, ppv);
|
|
}
|
|
|
|
HRESULT CFindCmd::_ExecData_Init()
|
|
{
|
|
_ExecData_Release();
|
|
|
|
IFolderView *pfv;
|
|
HRESULT hr = _GetShellView(IID_PPV_ARG(IFolderView, &pfv));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IShellFolder *psf;
|
|
hr = pfv->GetFolder(IID_PPV_ARG(IShellFolder, &psf));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IFindFolder *pff;
|
|
hr = psf->QueryInterface(IID_PPV_ARG(IFindFolder, &pff));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = _EnsureResultsViewIsCurrent(psf);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IShellFolderView *psfv;
|
|
hr = pfv->QueryInterface(IID_PPV_ARG(IShellFolderView, &psfv));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IUnknown_Set((IUnknown **)&_execData.pff, pff);
|
|
IUnknown_Set((IUnknown **)&_execData.psf, psf);
|
|
IUnknown_Set((IUnknown **)&_execData.psfv, psfv);
|
|
_execData.pff->SetControllerNotifyObject(SAFECAST(this, IFindControllerNotify*));
|
|
psfv->Release();
|
|
}
|
|
}
|
|
pff->Release();
|
|
}
|
|
psf->Release();
|
|
}
|
|
pfv->Release();
|
|
}
|
|
|
|
if (FAILED(hr))
|
|
_ExecData_Release();
|
|
else
|
|
SetShellFolder(_execData.psf);
|
|
|
|
return hr;
|
|
}
|
|
|
|
BOOL CFindCmd::_SetupBrowserCP()
|
|
{
|
|
if (!_dwCookie)
|
|
{
|
|
_cwbe.SetOwner(this); // make sure our owner is set...
|
|
|
|
// register ourself with the Defview to get any events that they may generate...
|
|
IServiceProvider *pspTLB;
|
|
HRESULT hr = IUnknown_QueryService(_punkSite, SID_STopLevelBrowser, IID_PPV_ARG(IServiceProvider, &pspTLB));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IConnectionPointContainer *pcpc;
|
|
hr = pspTLB->QueryService(IID_IExpDispSupport, IID_PPV_ARG(IConnectionPointContainer, &pcpc));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = ConnectToConnectionPoint(SAFECAST(&_cwbe, DWebBrowserEvents*), DIID_DWebBrowserEvents2,
|
|
TRUE, pcpc, &_dwCookie, &_pcpBrowser);
|
|
pcpc->Release();
|
|
}
|
|
pspTLB->Release();
|
|
}
|
|
}
|
|
|
|
if (_dwCookie)
|
|
_cwbe.SetWaiting(TRUE);
|
|
|
|
return _dwCookie ? TRUE : FALSE;
|
|
}
|
|
|
|
HRESULT CFindCmd::_Start(BOOL fNavigateIfFail, int iCol, LPCITEMIDLIST pidlUpdate)
|
|
{
|
|
if (_cExecInProgress)
|
|
return E_UNEXPECTED;
|
|
|
|
if (!_hdpaItemsToAdd1)
|
|
{
|
|
_hdpaItemsToAdd1 = DPA_CreateEx(64, GetProcessHeap());
|
|
if (!_hdpaItemsToAdd1)
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (!_hdpaItemsToAdd2)
|
|
{
|
|
_hdpaItemsToAdd2 = DPA_CreateEx(64, GetProcessHeap());
|
|
if (!_hdpaItemsToAdd2)
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
if (!_updateParams.hwndThreadNotify)
|
|
{
|
|
_updateParams.hwndThreadNotify = SHCreateWorkerWindow(_WndProc, NULL, 0, 0, 0, this);
|
|
if (!_updateParams.hwndThreadNotify)
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
HRESULT hr = _ExecData_Init();
|
|
if (FAILED(hr))
|
|
{
|
|
if (fNavigateIfFail)
|
|
{
|
|
if (_SetupBrowserCP())
|
|
NavigateToSearchResults();
|
|
}
|
|
// Return S_False so that when we check if this succeeded in finddlg, we wee that it
|
|
// did, and therefore let the animation run. If we return a failure code here, we
|
|
// will stop the animation. This will only hapen when we are navigating to the search
|
|
// results as well as starting the search.
|
|
return S_FALSE;
|
|
}
|
|
|
|
THREAD_PARAMS *ptp;
|
|
hr = _Init(&ptp, iCol, pidlUpdate);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// See if we should be saving away the selection...
|
|
if (iCol >= 0)
|
|
_execData.pff->RememberSelectedItems();
|
|
|
|
// If this is an update then we need to remember our IDList else clear list...
|
|
if (pidlUpdate)
|
|
{
|
|
_pidlUpdate = ILClone(pidlUpdate);
|
|
}
|
|
else
|
|
{
|
|
_Clear(); // tell defview to delete everything
|
|
}
|
|
|
|
if (ptp != NULL)
|
|
{
|
|
_execData.pff->SetAsyncEnum(ptp->penum);
|
|
|
|
// Start the query
|
|
_cExecInProgress++;
|
|
_fContinue = TRUE;
|
|
_fNew = FALSE;
|
|
|
|
if (SHCreateThread(_ThreadProc, ptp, CTF_COINIT, NULL))
|
|
{
|
|
hr = S_OK;
|
|
}
|
|
else
|
|
{
|
|
_cExecInProgress--;
|
|
_FreeThreadParams(ptp);
|
|
_SetEmptyText(IDS_FINDVIEWEMPTY);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
BOOL fAbort = FALSE;
|
|
|
|
_fContinue = TRUE;
|
|
_fNew = FALSE;
|
|
|
|
_PostMessage(WM_DF_SEARCHCOMPLETE, (WPARAM)hr, (LPARAM)fAbort);
|
|
|
|
_SetEmptyText(IDS_FINDVIEWEMPTY);
|
|
}
|
|
}
|
|
else
|
|
hr = _SetLastError(hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CFindCmd::_SetLastError(HRESULT hr)
|
|
{
|
|
if (HRESULT_FACILITY(hr) == FACILITY_SEARCHCOMMAND)
|
|
{
|
|
_hrLastError = hr;
|
|
hr = S_FALSE; // Don't error out script...
|
|
_cpEvents.InvokeDispid(DISPID_SEARCHCOMMAND_ERROR);
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::Execute(VARIANT *RecordsAffected, VARIANT *Parameters, long Options)
|
|
{
|
|
if (Options == 0)
|
|
return _Cancel();
|
|
|
|
_FixBrokenTypes();
|
|
|
|
return _Start(TRUE, -1, NULL);
|
|
}
|
|
|
|
// IConnectionPointContainer
|
|
|
|
STDMETHODIMP CFindCmd::EnumConnectionPoints(IEnumConnectionPoints **ppEnum)
|
|
{
|
|
return CreateInstance_IEnumConnectionPoints(ppEnum, 1, _cpEvents.CastToIConnectionPoint());
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::FindConnectionPoint(REFIID iid, IConnectionPoint **ppCP)
|
|
{
|
|
if (IsEqualIID(iid, DIID_DSearchCommandEvents) ||
|
|
IsEqualIID(iid, IID_IDispatch))
|
|
{
|
|
*ppCP = _cpEvents.CastToIConnectionPoint();
|
|
}
|
|
else
|
|
{
|
|
*ppCP = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
(*ppCP)->AddRef();
|
|
return S_OK;
|
|
}
|
|
|
|
// IProvideClassInfo2 methods
|
|
|
|
STDMETHODIMP CFindCmd::GetClassInfo(ITypeInfo **ppTI)
|
|
{
|
|
return GetTypeInfoFromLibId(0, LIBID_Shell32, 1, 0, CLSID_DocFindCommand, ppTI);
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::GetGUID(DWORD dwGuidKind, GUID *pGUID)
|
|
{
|
|
if (dwGuidKind == GUIDKIND_DEFAULT_SOURCE_DISP_IID)
|
|
{
|
|
*pGUID = DIID_DSearchCommandEvents;
|
|
return S_OK;
|
|
}
|
|
|
|
*pGUID = GUID_NULL;
|
|
return E_FAIL;
|
|
}
|
|
|
|
|
|
STDMETHODIMP CFindCmd::SetSite(IUnknown *punkSite)
|
|
{
|
|
if (!punkSite)
|
|
{
|
|
if (!_cExecInProgress)
|
|
{
|
|
_ExecData_Release();
|
|
}
|
|
_fContinue = FALSE; // Cancel existing queries
|
|
|
|
// See if we have a connection point... If so unadvise now...
|
|
if (_dwCookie)
|
|
{
|
|
_pcpBrowser->Unadvise(_dwCookie);
|
|
ATOMICRELEASE(_pcpBrowser);
|
|
_dwCookie = 0;
|
|
}
|
|
|
|
// Bug #199671
|
|
// Trident won't call UnAdvise and they except ActiveX Controls
|
|
// to use IOleControl::Close() to do their own UnAdvise, and hope
|
|
// nobody will need events after that. I don't impl IOleControl so
|
|
// we need to do the same thing during IObjectWithSite::SetSite(NULL)
|
|
// and hope someone won't want to reparent us. This is awkward but
|
|
// saves Trident some perf so we will tolerate it.
|
|
EVAL(SUCCEEDED(_cpEvents.UnadviseAll()));
|
|
}
|
|
|
|
return CObjectWithSite::SetSite(punkSite);
|
|
}
|
|
|
|
void CFindCmd::_SelectResults()
|
|
{
|
|
if (_execData.psfv)
|
|
{
|
|
// If there are any items...
|
|
UINT cItems = 0;
|
|
if (SUCCEEDED(_execData.psfv->GetObjectCount(&cItems)) && cItems > 0)
|
|
{
|
|
IShellView* psv;
|
|
if (SUCCEEDED(_execData.psfv->QueryInterface(IID_PPV_ARG(IShellView, &psv))))
|
|
{
|
|
// If none are selected (don't want to rip the user's selection out of his hand)...
|
|
UINT cSelected = 0;
|
|
if (SUCCEEDED(_execData.psfv->GetSelectedCount(&cSelected)) && cSelected == 0)
|
|
{
|
|
// Retrieve the pidl for the first item in the list...
|
|
LPITEMIDLIST pidlFirst = NULL;
|
|
if (SUCCEEDED(_execData.psfv->GetObject(&pidlFirst, 0)))
|
|
{
|
|
// Give it the focus
|
|
psv->SelectItem(pidlFirst, SVSI_FOCUSED | SVSI_ENSUREVISIBLE);
|
|
}
|
|
}
|
|
|
|
// Activate the view.
|
|
psv->UIActivate(SVUIA_ACTIVATE_FOCUS);
|
|
psv->Release();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::ClearResults(void)
|
|
{
|
|
HRESULT hr = _Clear();
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_fNew = TRUE;
|
|
_SetEmptyText(IDS_FINDVIEWEMPTYINIT);
|
|
}
|
|
|
|
return hr ;
|
|
}
|
|
|
|
HRESULT CFindCmd::_Clear()
|
|
{
|
|
// Tell defview to delete everything.
|
|
if (_execData.psfv)
|
|
{
|
|
UINT u;
|
|
_execData.psfv->RemoveObject(NULL, &u);
|
|
}
|
|
|
|
// And cleanup our folderList
|
|
if (_execData.pff)
|
|
{
|
|
_execData.pff->ClearItemList();
|
|
_execData.pff->ClearFolderList();
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
HRESULT CFindCmd::_SetEmptyText(UINT nIDEmptyText)
|
|
{
|
|
IShellFolderViewCB *psfvcb;
|
|
HRESULT hr = IUnknown_QueryService(_execData.psfv, SID_ShellFolderViewCB, IID_PPV_ARG(IShellFolderViewCB, &psfvcb));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
TCHAR szEmptyText[128];
|
|
LoadString(HINST_THISDLL, nIDEmptyText, szEmptyText, ARRAYSIZE(szEmptyText));
|
|
|
|
hr = psfvcb->MessageSFVCB(SFVM_SETEMPTYTEXT, 0, (LPARAM)szEmptyText);
|
|
psfvcb->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
HRESULT CFindCmd::_GetSearchIDList(LPITEMIDLIST *ppidl)
|
|
{
|
|
CLSID clsid;
|
|
_SearchResultsCLSID(&clsid);
|
|
return ILCreateFromCLSID(clsid, ppidl);
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::NavigateToSearchResults(void)
|
|
{
|
|
IShellBrowser *psb;
|
|
HRESULT hr = IUnknown_QueryService(_punkSite, SID_STopLevelBrowser, IID_PPV_ARG(IShellBrowser, &psb));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
hr = _GetSearchIDList(&pidl);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = psb->BrowseObject(pidl, SBSP_SAMEBROWSER | SBSP_ABSOLUTE | SBSP_WRITENOHISTORY);
|
|
ILFree(pidl);
|
|
}
|
|
psb->Release();
|
|
}
|
|
return hr;
|
|
}
|
|
|
|
IUnknown* CFindCmd::_GetObjectToPersist()
|
|
{
|
|
IOleObject *pole = NULL;
|
|
|
|
IShellView *psv;
|
|
HRESULT hr = _GetShellView(IID_PPV_ARG(IShellView, &psv));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
psv->GetItemObject(SVGIO_BACKGROUND, IID_PPV_ARG(IOleObject, &pole));
|
|
psv->Release();
|
|
}
|
|
|
|
return (IUnknown *)pole;
|
|
}
|
|
|
|
void CFindCmd::_PostMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
AddRef(); // to be released after processing of the message bellow
|
|
if (!PostMessage(_updateParams.hwndThreadNotify, uMsg, wParam, lParam))
|
|
{
|
|
Release();
|
|
}
|
|
}
|
|
|
|
HWND CFindCmd::_GetWindow()
|
|
{
|
|
HWND hwnd;
|
|
return SUCCEEDED(IUnknown_GetWindow(_punkSite, &hwnd)) ? hwnd : NULL;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::SaveSearch(void)
|
|
{
|
|
IFindFilter *pfilter;
|
|
HRESULT hr = _execData.pff->GetFindFilter(&pfilter);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IShellView *psv;
|
|
hr = _GetShellView(IID_PPV_ARG(IShellView, &psv));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IUnknown* punk = _GetObjectToPersist(); // NULL is OK
|
|
|
|
_execData.pff->Save(pfilter, _GetWindow(), &_dfbsi, psv, punk);
|
|
|
|
ATOMICRELEASE(punk);
|
|
|
|
psv->Release();
|
|
}
|
|
pfilter->Release();
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::RestoreSearch(void)
|
|
{
|
|
// let script know that a restore happened...
|
|
_cpEvents.InvokeDispid(DISPID_SEARCHCOMMAND_RESTORE);
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::StopSearch(void)
|
|
{
|
|
if (_cExecInProgress)
|
|
return _Cancel();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::GetItemCount(UINT *pcItems)
|
|
{
|
|
if (_execData.psfv)
|
|
{
|
|
return _execData.psfv->GetObjectCount(pcItems);
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::SetItemCount(UINT cItems)
|
|
{
|
|
if (_execData.psfv)
|
|
{
|
|
return _execData.psfv->SetObjectCount(cItems, SFVSOC_NOSCROLL);
|
|
}
|
|
return E_FAIL;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::ViewDestroyed()
|
|
{
|
|
_ExecData_Release();
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::get_ProgressText(BSTR *pbs)
|
|
{
|
|
|
|
*pbs = SysAllocStringT(_szProgressText);
|
|
return *pbs ? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
//------ error string mappings ------//
|
|
static const UINT error_strings[] =
|
|
{
|
|
SCEE_CONSTRAINT, IDS_DOCFIND_CONSTRAINT,
|
|
SCEE_PATHNOTFOUND, IDS_DOCFIND_PATHNOTFOUND,
|
|
SCEE_INDEXSEARCH, IDS_DOCFIND_SCOPEERROR,
|
|
SCEE_CASESENINDEX, IDS_DOCFIND_CI_NOT_CASE_SEN,
|
|
};
|
|
|
|
STDMETHODIMP CFindCmd::GetErrorInfo(BSTR *pbs, int *phr)
|
|
{
|
|
int nCode = HRESULT_CODE(_hrLastError);
|
|
UINT uSeverity = HRESULT_SEVERITY(_hrLastError);
|
|
|
|
if (phr)
|
|
*phr = nCode;
|
|
|
|
if (pbs)
|
|
{
|
|
UINT nIDString = 0;
|
|
*pbs = NULL;
|
|
|
|
for(int i = 0; i < ARRAYSIZE(error_strings); i += 2)
|
|
{
|
|
if (error_strings[i] == (UINT)nCode)
|
|
{
|
|
nIDString = error_strings[i+1];
|
|
break ;
|
|
}
|
|
}
|
|
|
|
if (nIDString)
|
|
{
|
|
WCHAR wszMsg[MAX_PATH];
|
|
EVAL(LoadStringW(HINST_THISDLL, nIDString, wszMsg, ARRAYSIZE(wszMsg)));
|
|
*pbs = SysAllocString(wszMsg);
|
|
}
|
|
else
|
|
*pbs = SysAllocString(L"");
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::SearchFor(int iFor)
|
|
{
|
|
if (SCE_SEARCHFORFILES == iFor)
|
|
{
|
|
_clsidResults = CLSID_DocFindFolder;
|
|
}
|
|
else if (SCE_SEARCHFORCOMPUTERS == iFor)
|
|
{
|
|
_clsidResults = CLSID_ComputerFindFolder;
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::GetScopeInfo(BSTR bsScope, int *pdwScopeInfo)
|
|
{
|
|
*pdwScopeInfo = 0;
|
|
return E_NOTIMPL;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::RestoreSavedSearch(VARIANT *pvarFile)
|
|
{
|
|
if (pvarFile && pvarFile->vt != VT_EMPTY)
|
|
{
|
|
LPITEMIDLIST pidl = VariantToIDList(pvarFile);
|
|
if (pidl)
|
|
{
|
|
ILFree(_pidlRestore);
|
|
_pidlRestore = pidl ;
|
|
}
|
|
}
|
|
|
|
if (_pidlRestore)
|
|
{
|
|
IShellView *psv;
|
|
HRESULT hr = _GetShellView(IID_PPV_ARG(IShellView, &psv));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
psv->Release();
|
|
|
|
if (SUCCEEDED(_ExecData_Init()))
|
|
{
|
|
_execData.pff->RestoreSearchFromSaveFile(_pidlRestore, _execData.psfv);
|
|
_cpEvents.InvokeDispid(DISPID_SEARCHCOMMAND_RESTORE);
|
|
ILFree(_pidlRestore);
|
|
_pidlRestore = NULL;
|
|
}
|
|
}
|
|
else if (!_fDeferRestoreTried)
|
|
{
|
|
// appears to be race condition to load
|
|
TraceMsg(TF_WARNING, "CFindCmd::MaybeRestoreSearch - _GetShellView failed...");
|
|
_fDeferRestore = TRUE;
|
|
if (!_SetupBrowserCP())
|
|
_fDeferRestore = FALSE;
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::OnChange(IRowset *prowset, DBWATCHNOTIFY eChangeReason)
|
|
{
|
|
_fAsyncNotifyReceived = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::DoSortOnColumn(UINT iCol, BOOL fSameCol)
|
|
{
|
|
IFindEnum *pdfEnumAsync;
|
|
|
|
if (S_OK == _execData.pff->GetAsyncEnum(&pdfEnumAsync))
|
|
{
|
|
// If the search is still running we will restart with the other column else we
|
|
// will make sure all of the items have been cached and let the default processing happen
|
|
if (!fSameCol && _cExecInProgress)
|
|
{
|
|
// We should try to sort on the right column...
|
|
_Start(FALSE, iCol, NULL);
|
|
return S_FALSE; // tell system to not do default processing.
|
|
}
|
|
|
|
_execData.pff->CacheAllAsyncItems();
|
|
}
|
|
return S_OK; // let it do default processing.
|
|
|
|
}
|
|
|
|
// Implemention of our IDispatch to hookup to the top level browsers connnection point...
|
|
STDMETHODIMP CFindCmd::CWBEvents2::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENTMULTI(CFindCmd::CWBEvents2, IDispatch, DWebBrowserEvents2),
|
|
QITABENTMULTI2(CFindCmd::CWBEvents2, DIID_DWebBrowserEvents2, DWebBrowserEvents2),
|
|
QITABENTMULTI2(CFindCmd::CWBEvents2, DIID_DWebBrowserEvents, DWebBrowserEvents),
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP CFindCmd::CWBEvents2::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr)
|
|
{
|
|
if (_fWaitingForNavigate)
|
|
{
|
|
if ((dispidMember == DISPID_NAVIGATECOMPLETE) ||
|
|
(dispidMember == DISPID_DOCUMENTCOMPLETE))
|
|
{
|
|
// Assume this is ours... Should maybe check parameters...
|
|
_fWaitingForNavigate = FALSE;
|
|
|
|
// Now see if it is a case where we are to restore the search...
|
|
if (_pcdfc->_fDeferRestore)
|
|
{
|
|
_pcdfc->_fDeferRestore = FALSE;
|
|
_pcdfc->_fDeferRestoreTried = TRUE;
|
|
_pcdfc->RestoreSavedSearch(NULL);
|
|
}
|
|
else
|
|
return _pcdfc->_Start(FALSE, -1, NULL);
|
|
}
|
|
}
|
|
return S_OK;
|
|
}
|
|
|
|
#define MAX_DEFAULT_VALUE 40 // Longest of all of the below pszDefaultValueMatch strings (plus slop)
|
|
#define MAX_KEY_PH_NAME 70 // "CLSID\{GUID}\PersistentHandler" (plus slop)
|
|
|
|
const TYPE_FIX_ENTRY g_tfeTextTypes[] =
|
|
{
|
|
{ TEXT(".rtf"), NULL, NULL },
|
|
};
|
|
|
|
const TYPE_FIX_ENTRY g_tfeNullTypes[] =
|
|
{
|
|
{ TEXT(".mdb"), TEXT("Access.Application.10"), TEXT("{73A4C9C1-D68D-11D0-98BF-00A0C90DC8D9}") },
|
|
{ TEXT(".msg"), TEXT("msgfile"), NULL },
|
|
{ TEXT(".sc2"), TEXT("SchedulePlus.Application.7"), TEXT("{0482E074-C5B7-101A-82E0-08002B36A333}") },
|
|
{ TEXT(".wll"), TEXT("Word.Addin.8"), NULL },
|
|
};
|
|
|
|
//
|
|
// rtf is listed twice, once above for TextTypes (to fix when office
|
|
// un-installed) and once here as an OfficeType (to fix when office
|
|
// is re-installed). Uninstalled = TextFilter, Reinstalled = OfficeFilter
|
|
//
|
|
const TYPE_FIX_ENTRY g_tfeOfficeTypes[] =
|
|
{
|
|
{ TEXT(".rtf"), TEXT("Word.RTF.8"), TEXT("{00020906-0000-0000-C000-000000000046}") },
|
|
{ TEXT(".doc"), TEXT("Word.Document.8"), TEXT("{00020906-0000-0000-C000-000000000046}") },
|
|
{ TEXT(".dot"), TEXT("Word.Template.8"), TEXT("{00020906-0000-0000-C000-000000000046}") },
|
|
{ TEXT(".pot"), TEXT("PowerPoint.Template.8"), TEXT("{64818D11-4F9B-11CF-86EA-00AA00B929E8}") },
|
|
{ TEXT(".pps"), TEXT("PowerPoint.SlideShow.8"), TEXT("{64818D10-4F9B-11CF-86EA-00AA00B929E8}") },
|
|
{ TEXT(".ppt"), TEXT("PowerPoint.Show.8"), TEXT("{64818D10-4F9B-11CF-86EA-00AA00B929E8}") },
|
|
{ TEXT(".rtf"), TEXT("Word.RTF.8"), TEXT("{00020906-0000-0000-C000-000000000046}") },
|
|
{ TEXT(".xlb"), TEXT("Excel.Sheet.8"), TEXT("{00020820-0000-0000-C000-000000000046}") },
|
|
{ TEXT(".xlc"), TEXT("Excel.Chart.8"), TEXT("{00020821-0000-0000-C000-000000000046}") },
|
|
{ TEXT(".xls"), TEXT("Excel.Sheet.8"), TEXT("{00020820-0000-0000-C000-000000000046}") },
|
|
{ TEXT(".xlt"), TEXT("Excel.Template"), TEXT("{00020820-0000-0000-C000-000000000046}") },
|
|
};
|
|
|
|
const TYPE_FIX_ENTRY g_tfeHtmlTypes[] =
|
|
{
|
|
{ TEXT(".asp"), TEXT("aspfile"), NULL },
|
|
{ TEXT(".htx"), TEXT("htxfile"), NULL },
|
|
};
|
|
|
|
BOOL CFindCmd::_FixPersistHandler(LPCTSTR pszBase, LPCTSTR pszDefaultHandler)
|
|
{
|
|
TCHAR szPHName[MAX_KEY_PH_NAME];
|
|
LONG lr;
|
|
HKEY hkeyPH;
|
|
HKEY hkeyBase;
|
|
HRESULT hr;
|
|
|
|
hr = StringCchPrintf(szPHName, ARRAYSIZE(szPHName), TEXT("%s\\PersistentHandler"), pszBase);
|
|
if (FAILED(hr))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
lr = RegOpenKeyEx(HKEY_CLASSES_ROOT, szPHName, NULL, KEY_QUERY_VALUE, &hkeyPH);
|
|
if (lr == ERROR_SUCCESS)
|
|
{
|
|
// We found an existing PersistHandler key, leave it alone
|
|
RegCloseKey(hkeyPH);
|
|
return TRUE;
|
|
}
|
|
|
|
lr = RegOpenKeyEx(HKEY_CLASSES_ROOT, pszBase, NULL, KEY_QUERY_VALUE, &hkeyBase);
|
|
if (lr != ERROR_SUCCESS)
|
|
{
|
|
// We didn't find the base key (normally "CLSID\\{GUID}"), get out
|
|
return FALSE;
|
|
}
|
|
RegCloseKey(hkeyBase);
|
|
|
|
lr = RegCreateKeyEx(HKEY_CLASSES_ROOT, szPHName, 0, NULL, 0, KEY_SET_VALUE, NULL, &hkeyPH, NULL);
|
|
if (lr != ERROR_SUCCESS)
|
|
{
|
|
// We couldn't create the ...\PersistHandler key, get out
|
|
return FALSE;
|
|
}
|
|
|
|
// Able to create the ...\PersistHandler key, write out the default handler
|
|
lr = RegSetValue(hkeyPH, NULL, REG_SZ, pszDefaultHandler, lstrlen(pszDefaultHandler));
|
|
RegCloseKey(hkeyPH);
|
|
|
|
// Success if write succeeded
|
|
return (lr == ERROR_SUCCESS);
|
|
}
|
|
|
|
void CFindCmd::_ProcessTypes(
|
|
const TYPE_FIX_ENTRY *ptfeTypes,
|
|
UINT cTypes,
|
|
TCHAR *pszClass)
|
|
{
|
|
UINT iType;
|
|
LONG lr;
|
|
HKEY hkeyType;
|
|
|
|
for (iType = 0; iType < cTypes; iType++)
|
|
{
|
|
lr = RegOpenKeyEx(HKEY_CLASSES_ROOT, ptfeTypes[iType].pszDotType, NULL, KEY_QUERY_VALUE, &hkeyType);
|
|
if (lr == ERROR_SUCCESS)
|
|
{
|
|
//
|
|
// If it has a default value to match, repair that (if it exists).
|
|
// If there is no default value to match, just repair the .foo type
|
|
//
|
|
if (ptfeTypes[iType].pszDefaultValueMatch)
|
|
{
|
|
TCHAR szDefaultValue[MAX_DEFAULT_VALUE];
|
|
lr = SHRegGetString(hkeyType, NULL, NULL, szDefaultValue, ARRAYSIZE(szDefaultValue));
|
|
if (lr == ERROR_SUCCESS)
|
|
{
|
|
if (lstrcmp(szDefaultValue,ptfeTypes[iType].pszDefaultValueMatch) == 0)
|
|
{
|
|
if (ptfeTypes[iType].pszGuid == NULL)
|
|
{
|
|
// Fix either the progid or the type, whichever we can
|
|
if (!_FixPersistHandler(ptfeTypes[iType].pszDefaultValueMatch,pszClass))
|
|
{
|
|
_FixPersistHandler(ptfeTypes[iType].pszDotType,pszClass);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fix the persist handler for the guid, since its specified
|
|
TCHAR szPHName[MAX_KEY_PH_NAME];
|
|
|
|
HRESULT hr = StringCchPrintf(szPHName, ARRAYSIZE(szPHName), TEXT("CLSID\\%s"), ptfeTypes[iType].pszGuid);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_FixPersistHandler(szPHName, pszClass);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_FixPersistHandler(ptfeTypes[iType].pszDotType, pszClass);
|
|
}
|
|
RegCloseKey(hkeyType);
|
|
}
|
|
else if (lr == ERROR_FILE_NOT_FOUND)
|
|
{
|
|
//
|
|
// .foo doesn't exist - this can happen because of bad un-install program
|
|
// Create .foo and .foo\PersistentHandler
|
|
//
|
|
lr = RegCreateKeyEx(HKEY_CLASSES_ROOT, ptfeTypes[iType].pszDotType, 0, NULL, 0, KEY_SET_VALUE, NULL, &hkeyType, NULL);
|
|
if (lr == ERROR_SUCCESS)
|
|
{
|
|
_FixPersistHandler(ptfeTypes[iType].pszDotType, pszClass);
|
|
RegCloseKey(hkeyType);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CFindCmd::_FixBrokenTypes(void)
|
|
{
|
|
_ProcessTypes(g_tfeNullTypes, ARRAYSIZE(g_tfeNullTypes), TEXT("{098f2470-bae0-11cd-b579-08002b30bfeb}"));
|
|
_ProcessTypes(g_tfeTextTypes, ARRAYSIZE(g_tfeTextTypes), TEXT("{5e941d80-bf96-11cd-b579-08002b30bfeb}"));
|
|
_ProcessTypes(g_tfeOfficeTypes, ARRAYSIZE(g_tfeOfficeTypes), TEXT("{98de59a0-d175-11cd-a7bd-00006b827d94}"));
|
|
_ProcessTypes(g_tfeHtmlTypes, ARRAYSIZE(g_tfeHtmlTypes), TEXT("{eec97550-47a9-11cf-b952-00aa0051fe20}"));
|
|
}
|
|
|
|
CFindConstraint::CFindConstraint(BSTR bstr, VARIANT var) : CImpIDispatch(LIBID_Shell32, 1, 0, IID_DFConstraint)
|
|
{
|
|
_cRef = 1;
|
|
_bstr = bstr;
|
|
_var = var;
|
|
}
|
|
|
|
CFindConstraint::~CFindConstraint()
|
|
{
|
|
SysFreeString(_bstr);
|
|
VariantClear(&_var);
|
|
}
|
|
|
|
STDMETHODIMP CFindConstraint::QueryInterface(REFIID riid, void **ppv)
|
|
{
|
|
static const QITAB qit[] = {
|
|
QITABENT(CFindConstraint, DFConstraint), // IID_DFConstraint
|
|
QITABENTMULTI(CFindConstraint, IDispatch, DFConstraint), // IID_IDispatch
|
|
{ 0 },
|
|
};
|
|
return QISearch(this, qit, riid, ppv);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CFindConstraint::AddRef()
|
|
{
|
|
return InterlockedIncrement(&_cRef);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) CFindConstraint::Release()
|
|
{
|
|
ASSERT( 0 != _cRef );
|
|
ULONG cRef = InterlockedDecrement(&_cRef);
|
|
if ( 0 == cRef )
|
|
{
|
|
delete this;
|
|
}
|
|
return cRef;
|
|
}
|
|
|
|
STDMETHODIMP CFindConstraint::GetTypeInfoCount(UINT * pctinfo)
|
|
{
|
|
return CImpIDispatch::GetTypeInfoCount(pctinfo);
|
|
}
|
|
|
|
STDMETHODIMP CFindConstraint::GetTypeInfo(UINT itinfo, LCID lcid, ITypeInfo **pptinfo)
|
|
{
|
|
return CImpIDispatch::GetTypeInfo(itinfo, lcid, pptinfo);
|
|
}
|
|
|
|
STDMETHODIMP CFindConstraint::GetIDsOfNames(REFIID riid, OLECHAR **rgszNames, UINT cNames, LCID lcid, DISPID * rgdispid)
|
|
{
|
|
return CImpIDispatch::GetIDsOfNames(riid, rgszNames, cNames, lcid, rgdispid);
|
|
}
|
|
|
|
STDMETHODIMP CFindConstraint::Invoke(DISPID dispidMember, REFIID riid, LCID lcid, WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo, UINT * puArgErr)
|
|
{
|
|
return CImpIDispatch::Invoke(dispidMember, riid, lcid, wFlags, pdispparams, pvarResult, pexcepinfo, puArgErr);
|
|
}
|
|
|
|
STDMETHODIMP CFindConstraint::get_Name(BSTR *pbs)
|
|
{
|
|
*pbs = SysAllocString(_bstr);
|
|
return *pbs? S_OK : E_OUTOFMEMORY;
|
|
}
|
|
|
|
STDMETHODIMP CFindConstraint::get_Value(VARIANT *pvar)
|
|
{
|
|
VariantInit(pvar);
|
|
return VariantCopy(pvar, &_var);
|
|
}
|