|
|
#include "pch.h"
#include "stddef.h"
#include <atlbase.h>
#pragma hdrstop
// class that implements the query UI
class CDsQuery : public IQueryHandler, IQueryForm, IObjectWithSite, IDsQueryHandler, IShellFolder { public: CDsQuery(); ~CDsQuery();
// IUnknown
STDMETHOD(QueryInterface)(REFIID riid, void **ppvObject); STDMETHOD_(ULONG, AddRef)(); STDMETHOD_(ULONG, Release)();
// IQueryForms
STDMETHOD(Initialize)(HKEY hkForm); STDMETHOD(AddForms)(LPCQADDFORMSPROC pAddFormsProc, LPARAM lParam); STDMETHOD(AddPages)(LPCQADDPAGESPROC pAddPagesProc, LPARAM lParam);
// IQueryHandler
STDMETHOD(Initialize)(IQueryFrame* pQueryFrame, DWORD dwOQWFlags, LPVOID pParameters); STDMETHOD(GetViewInfo)(LPCQVIEWINFO pViewInfo); STDMETHOD(AddScopes)(); STDMETHOD(BrowseForScope)(HWND hwndParent, LPCQSCOPE pCurrentScope, LPCQSCOPE* ppScope); STDMETHOD(CreateResultView)(HWND hwndParent, HWND* phWndView); STDMETHOD(ActivateView)(UINT uState, WPARAM wParam, LPARAM lParam); STDMETHOD(InvokeCommand)(HWND hwndParent, UINT uID); STDMETHOD(GetCommandString)(UINT uID, DWORD dwFlags, LPTSTR pBuffer, INT cchBuffer); STDMETHOD(IssueQuery)(LPCQPARAMS pQueryParams); STDMETHOD(StopQuery)(); STDMETHOD(GetViewObject)(UINT uScope, REFIID riid, void **ppvOut); STDMETHOD(LoadQuery)(IPersistQuery* pPersistQuery); STDMETHOD(SaveQuery)(IPersistQuery* pPersistQuery, LPCQSCOPE pScope);
// IObjectWithSite
STDMETHODIMP SetSite(IUnknown* punk); STDMETHODIMP GetSite(REFIID riid, void **ppv);
// IDsQueryHandler
STDMETHOD(UpdateView)(DWORD dwType, LPDSOBJECTNAMES pdon);
// IShellFolder
STDMETHOD(ParseDisplayName)(HWND hwnd, LPBC pbc, LPOLESTR pszName, ULONG * pchEaten, LPITEMIDLIST * ppidl, ULONG *pdwAttributes) { return E_NOTIMPL; } STDMETHOD(EnumObjects)(HWND hwndOwner, DWORD grfFlags, LPENUMIDLIST * ppEnumIDList) { return E_NOTIMPL; } STDMETHOD(BindToObject)(LPCITEMIDLIST pidl, LPBC pbcReserved, REFIID riid, void **ppv) { return E_NOTIMPL; } STDMETHOD(BindToStorage)(LPCITEMIDLIST pidl, LPBC pbcReserved, REFIID riid, void **ppv) { return E_NOTIMPL; } STDMETHOD(CompareIDs)(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2) { return E_NOTIMPL; } STDMETHOD(CreateViewObject)(HWND hwndOwner, REFIID riid, void **ppv) { return E_NOTIMPL; } STDMETHOD(GetAttributesOf)(UINT cidl, LPCITEMIDLIST * apidl, ULONG * rgfInOut) { *rgfInOut &= SFGAO_HASPROPSHEET; return S_OK; } STDMETHOD(GetUIObjectOf)(HWND hwndOwner, UINT cidl, LPCITEMIDLIST * apidl, REFIID riid, UINT * prgfInOut, void **ppv) { return GetViewObject(0x0, riid, ppv); } STDMETHOD(GetDisplayNameOf)(LPCITEMIDLIST pidl, DWORD uFlags, LPSTRRET pName) { return E_NOTIMPL; } STDMETHOD(SetNameOf)(HWND hwndOwner, LPCITEMIDLIST pidl, LPCOLESTR pszName, DWORD uFlags, LPITEMIDLIST* ppidlOut) { return E_NOTIMPL; } private: LRESULT OnSize(INT cx, INT cy); LRESULT OnNotify(HWND hWnd, WPARAM wParam, LPARAM lParam); HRESULT OnAddResults(DWORD dwQueryReference, HDPA hdpaResults); LRESULT OnContextMenu(HWND hwndMenu, LPARAM lParam); HRESULT OnFileProperties(VOID); HRESULT OnFileSaveQuery(VOID); HRESULT OnEditSelectAll(VOID); HRESULT OnEditInvertSelection(VOID); HRESULT OnPickColumns(HWND hwndParent);
static int s_BrowseForScopeCB(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData); static LRESULT s_ResultViewWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); static LRESULT s_BannerWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
HRESULT _SetDataObjectData(IDataObject* pDataObject, UINT cf, LPVOID pData, DWORD cbSize); HRESULT _SetDispSpecOptions(IDataObject *pdo); HRESULT _InitNewQuery(LPDSQUERYPARAMS pDsQueryParams, BOOL fRefreshColumnTable); HRESULT _GetFilterValue(INT iColumn, HD_ITEM* pitem); HRESULT _FilterView(BOOL fCheck); HRESULT _PopulateView(INT iFirstItem, INT iLast); VOID _FreeResults(VOID); DWORD _SetViewMode(INT uID); VOID _SortResults(INT iColumn); VOID _SetFilter(BOOL fFilter); VOID _ShowBanner(UINT flags, UINT idPrompt); VOID _InitViewMenuItems(HMENU hMenu); HRESULT _GetQueryFormKey(REFCLSID clsidForm, HKEY* phKey); HRESULT _GetColumnTable(REFCLSID clsidForm, LPDSQUERYPARAMS pDsQueryParams, HDSA* pHDSA, BOOL fSetInView); VOID _SaveColumnTable(VOID); HRESULT _SaveColumnTable(REFCLSID clsidForm, HDSA hdsaColumns); HRESULT _AddResultToDataObject(HDSA hdsa, INT i); HRESULT _GetDataObjectFromSelection(BOOL fGetAll, IDataObject **pdo); HRESULT _GetContextMenu(); VOID _GetContextMenuVerbs(HMENU hMenu, DWORD dwFlags); HRESULT _CopyCredentials(LPWSTR *ppszUserName, LPWSTR *ppszPassword, LPWSTR *ppszServer); VOID _DeleteViewItems(LPDSOBJECTNAMES pdon);
private: LONG _cRef; // lifetime
IQueryFrame* _pqf; // our parent window
IUnknown* _punkSite; // site object
IContextMenu* _pcm; // Curerntly displayed context menu / == NULL if none
DWORD _dwOQWFlags; // flags passed to OpenQueryWindow
DWORD _dwFlags; // flags as part of the ds query parameters
LPWSTR _pDefaultScope; // default scope passed
LPWSTR _pDefaultSaveLocation; // directory to save queries into by default
LPTSTR _pDefaultSaveName; // default save name (from the query form)
LPWSTR _pServer; // server to target
LPWSTR _pUserName; // user name and password to authenticate with
LPWSTR _pPassword;
BOOL _fNoSelection:1; // the IContextMenu was from no selection
BOOL _fColumnsModified:1; // settings of the view modified
BOOL _fSortDescending:1; // sort the results descending
BOOL _fFilter:1; // filter enabled
BOOL _fFilterSupported:1; // is the filter available, eg: comctl32 > 5.0
INT _idViewMode; // default view mode
INT _iSortColumn; // sort column
HWND _hwnd; // container window
HWND _hwndView; // listview window (child of parent)
HWND _hwndBanner; // banner window which is a child of the list view
DWORD _dwQueryReference; // reference value passed to query
HANDLE _hThread; // worker thread handle
DWORD _dwThreadId; // thread ID for the Query processing thread
CLSID _clsidForm; // form being used for column table
HDSA _hdsaColumns; // column information (size, filters, etc)
HDPA _hdpaResults; // results for tr the query we have issued
LPTSTR _pFilter; // current filter
HMENU _hFrameMenuBar; // stored frame menu bar, stored from activate
HMENU _hFileMenu; // added to the frames view menu
HMENU _hEditMenu; // inserted into the menu bar
HMENU _hViewMenu; // inserted into the menu bar
HMENU _hHelpMenu; // inserted into the menu bar
};
//
// Window classes we create to show the results
//
#define VIEW_CLASS TEXT("ActiveDsQueryView")
#define BANNER_CLASS TEXT("ActiveDsQueryBanner")
//
// Registry values used for the settings
//
#define VIEW_SETTINGS_VALUE TEXT("ViewSettings")
#define ADMIN_VIEW_SETTINGS_VALUE TEXT("AdminViewSettings");
//
// When filtering we populate the view using PostMessage, doing so many items
// at a time
//
#define FILTER_UPDATE_COUNT 128
//
// All items within the list view contain the following LPARAM structure used
// for storing the magic properties we are interested in.
//
#define ENABLE_MENU_ITEM(hMenu, id, fEnabled) \
EnableMenuItem(hMenu, id, (fEnabled) ? (MF_BYCOMMAND|MF_ENABLED):(MF_BYCOMMAND|MF_GRAYED))
//
// Persisted column data, this is stored in the registry under the CLSID for the
// form we are interested in.
//
typedef struct { DWORD cbSize; // offset to the next column / == 0 if none
DWORD dwFlags; // flags
DWORD offsetProperty; // offset to property name (UNICODE)
DWORD offsetHeading; // offset to column heading
INT cx; // pixel width of the column
INT fmt; // format of the column
} SAVEDCOLUMN, * LPSAVEDCOLUMN;
//
// Table to map property types to useful information
//
struct { LPCTSTR pMenuName; INT idOperator; INT hdft; }
// NTRAID#NTBUG9-618605-2002/09/17-lucios
// Added the entry for PROPERTY_ISDNSTRING
property_type_table[] = { 0, 0, 0, MAKEINTRESOURCE(IDR_OP_STRING), FILTER_CONTAINS, HDFT_ISSTRING, MAKEINTRESOURCE(IDR_OP_STRING), FILTER_CONTAINS, HDFT_ISSTRING, MAKEINTRESOURCE(IDR_OP_NUMBER), FILTER_IS, HDFT_ISNUMBER, MAKEINTRESOURCE(IDR_OP_NUMBER), FILTER_IS, HDFT_ISNUMBER, // PROPERTY_ISBOOL
MAKEINTRESOURCE(IDR_OP_STRING), FILTER_CONTAINS, HDFT_ISSTRING, // PROPERTY_ISDNSTRING
};
//
// Help information for the frame and the control
//
static DWORD const aHelpIDs[] = { CQID_LOOKFORLABEL, IDH_FIND, CQID_LOOKFOR, IDH_FIND, CQID_LOOKINLABEL, IDH_IN, CQID_LOOKIN, IDH_IN, CQID_BROWSE, IDH_BROWSE, CQID_FINDNOW, IDH_FIND_NOW, CQID_STOP, IDH_STOP, CQID_CLEARALL, IDH_CLEAR_ALL, IDC_RESULTS, IDH_RESULTS, IDC_STATUS, IDH_NO_HELP, 0, 0, };
static DWORD const aBrowseHelpIDs[] = { DSBID_BANNER, (DWORD)-1, DSBID_CONTAINERLIST, IDH_BROWSE_CONTAINER, 0, 0, };
// Query object
CDsQuery::CDsQuery() : _cRef(1), _fNoSelection(TRUE), _iSortColumn(-1), _idViewMode(DSQH_VIEW_DETAILS) { if (CheckDsPolicy(NULL, c_szEnableFilter)) { TraceMsg("QuickFilter enabled in policy"); _fFilter = TRUE; } DllAddRef(); }
CDsQuery::~CDsQuery() { // persist the column information if we need to
if (_hdsaColumns) { if (_fColumnsModified) { _SaveColumnTable(_clsidForm, _hdsaColumns); _fColumnsModified = FALSE; } _SaveColumnTable(); }
// discard all the other random state we have
LocalFreeStringW(&_pDefaultScope); LocalFreeStringW(&_pDefaultSaveLocation); LocalFreeString(&_pDefaultSaveName);
SecureLocalFreeStringW(&_pUserName); SecureLocalFreeStringW(&_pPassword); SecureLocalFreeStringW(&_pServer);
if (IsWindow(_hwnd)) DestroyWindow(_hwnd);
if (IsMenu(_hFileMenu)) DestroyMenu(_hFileMenu); if (IsMenu(_hEditMenu)) DestroyMenu(_hEditMenu); if (IsMenu(_hViewMenu)) DestroyMenu(_hViewMenu); if (IsMenu(_hHelpMenu)) DestroyMenu(_hHelpMenu);
// tell the thread its time to die
if (_hThread) { PostThreadMessage(_dwThreadId, RVTM_STOPQUERY, 0, 0); PostThreadMessage(_dwThreadId, WM_QUIT, 0, 0); CloseHandle(_hThread); }
DoRelease(_pqf); DoRelease(_punkSite); DoRelease(_pcm);
DllRelease(); }
// IUnknown bits
ULONG CDsQuery::AddRef() { return InterlockedIncrement(&_cRef); }
ULONG CDsQuery::Release() { TraceAssert( 0 != _cRef ); ULONG cRef = InterlockedDecrement(&_cRef); if ( 0 == cRef ) { delete this; } return cRef; }
HRESULT CDsQuery::QueryInterface(REFIID riid, void **ppv) { static const QITAB qit[] = { QITABENT(CDsQuery, IQueryForm), // IID_IQueryForm
QITABENT(CDsQuery, IQueryHandler), // IID_IQueryHandler
QITABENT(CDsQuery, IObjectWithSite), // IID_IObjectWIthSite
QITABENT(CDsQuery, IDsQueryHandler), // IID_IDsQueryHandler
QITABENT(CDsQuery, IShellFolder), // IID_IShellFolder
{0, 0 }, }; return QISearch(this, qit, riid, ppv); }
//
// Handle creating an instance of CLSID_DsQuery
//
STDAPI CDsQuery_CreateInstance(IUnknown* punkOuter, IUnknown** ppunk, LPCOBJECTINFO poi) { CDsQuery *pdq = new CDsQuery(); if (!pdq) return E_OUTOFMEMORY;
HRESULT hr = pdq->QueryInterface(IID_IUnknown, (void **)ppunk); pdq->Release(); return hr; }
/// IQueryForm
STDMETHODIMP CDsQuery::Initialize(HKEY hkForm) { return S_OK; }
// query forms exposed from this object
struct { CLSID const * clsidForm; INT idsTitle; DWORD dwFlags; } forms[] = { &CLSID_DsFindPeople, IDS_FINDUSER, 0, &CLSID_DsFindComputer, IDS_FINDCOMPUTER, 0, &CLSID_DsFindPrinter, IDS_FINDPRINTERS, 0, &CLSID_DsFindVolume, IDS_FINDSHAREDFOLDERS, 0, &CLSID_DsFindContainer, IDS_FINDOU, 0, &CLSID_DsFindAdvanced, IDS_CUSTOMSEARCH, CQFF_NOGLOBALPAGES,
&CLSID_DsFindDomainController, IDS_FINDDOMCTL, CQFF_ISNEVERLISTED|CQFF_NOGLOBALPAGES, &CLSID_DsFindFrsMembers, IDS_FINDFRSMEMBER, CQFF_ISNEVERLISTED|CQFF_NOGLOBALPAGES, };
STDMETHODIMP CDsQuery::AddForms(LPCQADDFORMSPROC pAddFormsProc, LPARAM lParam) { HRESULT hr; TCHAR szBuffer[MAX_PATH]; INT i;
TraceEnter(TRACE_FORMS, "CDsQuery::AddForms");
if (!pAddFormsProc) ExitGracefully(hr, E_INVALIDARG, "No AddFormsProc");
for (i = 0; i < ARRAYSIZE(forms); i++) { CQFORM qf = { 0 };
qf.cbStruct = SIZEOF(qf); qf.dwFlags = forms[i].dwFlags; qf.clsid = *forms[i].clsidForm; qf.pszTitle = szBuffer;
LoadString(GLOBAL_HINSTANCE, forms[i].idsTitle, szBuffer, ARRAYSIZE(szBuffer));
hr = (*pAddFormsProc)(lParam, &qf); FailGracefully(hr, "Failed to add form (calling pAddFormsFunc)"); }
hr = S_OK; // success
exit_gracefully:
TraceLeaveResult(hr); }
// page information for this object
struct { CLSID const * clisdForm; LPCQPAGEPROC pPageProc; DLGPROC pDlgProc; INT idPageTemplate; INT idPageName; DWORD dwFlags; } pages[] = { //
// Page list for the default forms that we add
//
&CLSID_DsFindPeople, PageProc_User, DlgProc_User, IDD_FINDUSER, IDS_FINDUSER, 0, &CLSID_DsFindComputer, PageProc_Computer, DlgProc_Computer, IDD_FINDCOMPUTER, IDS_FINDCOMPUTER, 0, &CLSID_DsFindPrinter, PageProc_Printers, DlgProc_Printers, IDD_FINDPRINT1, IDS_FINDPRINTERS, 0, &CLSID_DsFindPrinter, PageProc_PrintersMore, DlgProc_PrintersMore, IDD_FINDPRINT2, IDS_MORECHOICES, 0, &CLSID_DsFindVolume, PageProc_Volume, DlgProc_Volume, IDD_FINDVOLUME, IDS_FINDSHAREDFOLDERS, 0, &CLSID_DsFindContainer, PageProc_Container, DlgProc_Container, IDD_FINDCONTAINER, IDS_FINDOU, 0, &CLSID_DsFindAdvanced, PageProc_PropertyWell, DlgProc_PropertyWell, IDD_PROPERTYWELL, IDS_CUSTOMSEARCH, 0, &CLSID_DsFindAdvanced, PageProc_RawLDAP, DlgProc_RawLDAP, IDD_FINDUSINGLDAP, IDS_ADVANCED, 0, &CLSID_DsFindDomainController, PageProc_DomainController, DlgProc_DomainController, IDD_FINDDOMCTL, IDS_FINDDOMCTL, 0, &CLSID_DsFindFrsMembers, PageProc_FrsMember, DlgProc_FrsMember, IDD_FINDFRSMEMBER, IDS_FINDFRSMEMBER, 0,
//
// Make the property well available on all pages (using the magic CQPF_ADDTOALLFORMS bit)
//
&CLSID_DsFindAdvanced, PageProc_PropertyWell, DlgProc_PropertyWell, IDD_PROPERTYWELL, IDS_ADVANCED, CQPF_ISGLOBAL, };
STDMETHODIMP CDsQuery::AddPages(LPCQADDPAGESPROC pAddPagesProc, LPARAM lParam) { HRESULT hr; INT i;
TraceEnter(TRACE_FORMS, "CDsQuery::AddPages");
if (!pAddPagesProc) ExitGracefully(hr, E_INVALIDARG, "No AddPagesProc");
for (i = 0 ; i < ARRAYSIZE(pages) ; i++) { CQPAGE qp = { 0 };
qp.cbStruct = SIZEOF(qp); qp.dwFlags = pages[i].dwFlags; qp.pPageProc = pages[i].pPageProc; qp.hInstance = GLOBAL_HINSTANCE; qp.idPageName = pages[i].idPageName; qp.idPageTemplate = pages[i].idPageTemplate; qp.pDlgProc = pages[i].pDlgProc;
hr = (*pAddPagesProc)(lParam, *pages[i].clisdForm, &qp); FailGracefully(hr, "Failed to add page (calling pAddPagesFunc)"); }
hr = S_OK;
exit_gracefully:
TraceLeaveResult(S_OK); }
// IQueryHandler
STDMETHODIMP CDsQuery::Initialize(IQueryFrame* pQueryFrame, DWORD dwOQWFlags, LPVOID pParameters) { HRESULT hr; LPDSQUERYINITPARAMS pDsQueryInitParams = (LPDSQUERYINITPARAMS)pParameters; TCHAR szGUID[GUIDSTR_MAX]; TCHAR szBuffer[MAX_PATH]; HINSTANCE hInstanceComCtl32 = NULL; TraceEnter(TRACE_HANDLER, "CDsQuery::Initialize");
// Keep the IQueryFrame interface, we need it for menu negotiation and other
// view -> frame interactions.
_pqf = pQueryFrame; _pqf->AddRef();
_dwOQWFlags = dwOQWFlags;
// If we have a parameter block then lets take copies of the interesting
// fields from there.
if (pDsQueryInitParams) { _dwFlags = pDsQueryInitParams->dwFlags;
// did the user specify a default scope?
if (pDsQueryInitParams->pDefaultScope && pDsQueryInitParams->pDefaultScope[0]) { Trace(TEXT("Default scope:"), pDsQueryInitParams->pDefaultScope); hr = LocalAllocStringW(&_pDefaultScope, pDsQueryInitParams->pDefaultScope); FailGracefully(hr, "Failed to cope default scope"); }
// default save location?
if ((_dwFlags & DSQPF_SAVELOCATION) && pDsQueryInitParams->pDefaultSaveLocation) { Trace(TEXT("Default save location:"), pDsQueryInitParams->pDefaultSaveLocation); hr = LocalAllocStringW(&_pDefaultSaveLocation, pDsQueryInitParams->pDefaultSaveLocation); FailGracefully(hr, "Failed to copy save location"); }
// do we have credential information?
if (_dwFlags & DSQPF_HASCREDENTIALS) { TraceMsg("Copying credential/server information from init params");
if (pDsQueryInitParams->pUserName) { hr = LocalAllocStringW(&_pUserName, pDsQueryInitParams->pUserName); FailGracefully(hr, "Failed to copy user name"); }
if (pDsQueryInitParams->pPassword) { hr = LocalAllocStringW(&_pPassword, pDsQueryInitParams->pPassword); FailGracefully(hr, "Failed to copy password"); }
if (pDsQueryInitParams->pServer) { hr = LocalAllocStringW(&_pServer, pDsQueryInitParams->pServer); FailGracefully(hr, "Failed to copy server"); }
Trace(TEXT("_pUserName : %s"), _pUserName ? _pUserName:TEXT("<not specified>")); Trace(TEXT("_pPassword : %s"), _pPassword ? _pPassword:TEXT("<not specified>")); Trace(TEXT("_pServer : %s"), _pServer ? _pServer:TEXT("<not specified>")); } }
// Finally load the must structures that we are going to use, then modify them
// based on the flags that the caller gave us.
//
// NB: removes the last two items from the file menu assumed to be the
// "save" and its seperator
_hFileMenu = LoadMenu(GLOBAL_HINSTANCE, MAKEINTRESOURCE(IDR_MENU_FILE)); _hEditMenu = LoadMenu(GLOBAL_HINSTANCE, MAKEINTRESOURCE(IDR_MENU_EDIT)); _hViewMenu = LoadMenu(GLOBAL_HINSTANCE, MAKEINTRESOURCE(IDR_MENU_VIEW)); _hHelpMenu = LoadMenu(GLOBAL_HINSTANCE, MAKEINTRESOURCE(IDR_MENU_HELP));
if (!_hFileMenu || !_hEditMenu || !_hViewMenu || !_hHelpMenu) ExitGracefully(hr, E_FAIL, "Failed to load resources for menus");
if (_dwFlags & DSQPF_NOSAVE) { HMENU hFileMenu = GetSubMenu(_hFileMenu, 0); INT i = GetMenuItemCount(hFileMenu);
DeleteMenu(hFileMenu, i-1, MF_BYPOSITION); DeleteMenu(hFileMenu, i-2, MF_BYPOSITION); }
// Init ComCtl32, including checking to see if we can use the filter control or not,
// the filter control was added to the WC_HEADER32 in IE5, so check the DLL version
// to see which we are using.
InitCommonControls();
hInstanceComCtl32 = GetModuleHandle(TEXT("comctl32")); TraceAssert(hInstanceComCtl32);
if (hInstanceComCtl32) { DLLVERSIONINFO dllVersionInfo = { 0 }; DLLGETVERSIONPROC pfnDllGetVersion = (DLLGETVERSIONPROC)GetProcAddress(hInstanceComCtl32, "DllGetVersion"); TraceAssert(pfnDllGetVersion);
dllVersionInfo.cbSize = SIZEOF(dllVersionInfo);
if (pfnDllGetVersion && SUCCEEDED(pfnDllGetVersion(&dllVersionInfo))) { Trace(TEXT("DllGetVersion succeeded on ComCtl32, dwMajorVersion %08x"), dllVersionInfo.dwMajorVersion); _fFilterSupported = dllVersionInfo.dwMajorVersion >= 5; } } Trace(TEXT("_fFilterSupported is %d"), _fFilterSupported);
hr = S_OK; // success
exit_gracefully:
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
STDMETHODIMP CDsQuery::GetViewInfo(LPCQVIEWINFO pViewInfo) { HICON hIcon;
TraceEnter(TRACE_HANDLER, "CDsQuery::GetViewInfo");
pViewInfo->dwFlags = 0; pViewInfo->hInstance = GLOBAL_HINSTANCE; pViewInfo->idLargeIcon = IDI_FINDDS; pViewInfo->idSmallIcon = IDI_FINDDS; pViewInfo->idTitle = IDS_WINDOWTITLE; pViewInfo->idAnimation = IDR_DSFINDANIMATION;
TraceLeaveResult(S_OK); }
/*---------------------------------------------------------------------------*/
STDMETHODIMP CDsQuery::AddScopes() { HRESULT hr; DWORD dwThreadId; HANDLE hThread; LPSCOPETHREADDATA pstd = NULL;
TraceEnter(TRACE_HANDLER, "CDsQuery::AddScopes");
// Enumerate the rest of the scopes on a seperate thread to gather the
// scopes we are interested in.
pstd = (LPSCOPETHREADDATA)LocalAlloc(LPTR, SIZEOF(SCOPETHREADDATA)); TraceAssert(pstd);
if (!pstd) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate scope data structure");
_pqf->GetWindow(&pstd->hwndFrame); // pstd->pDefaultScope = NULL;
// pstd->pServer = NULL; // no credential stuff currently
// pstd->pUserName = NULL;
// pstd->pPassword = NULL;
if (_pDefaultScope) { hr = LocalAllocStringW(&pstd->pDefaultScope, _pDefaultScope); FailGracefully(hr, "Failed to copy the default scope"); }
hr = _CopyCredentials(&pstd->pUserName, &pstd->pPassword, &pstd->pServer); FailGracefully(hr, "Failed to copy credentails");
DllAddRef();
hThread = CreateThread(NULL, 0, AddScopesThread, pstd, 0, &dwThreadId); TraceAssert(hThread);
if (!hThread) { DllRelease(); ExitGracefully(hr, E_FAIL, "Failed to create background thread to enum scopes - BAD!"); }
CloseHandle(hThread);
hr = S_OK;
exit_gracefully:
if (FAILED(hr) && pstd) { LocalFreeStringW(&pstd->pDefaultScope); LocalFree((HLOCAL)pstd); }
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
typedef struct { IADsPathname *padp; WCHAR szGcPath[MAX_PATH]; } BROWSEFORSCOPE;
int CALLBACK CDsQuery::s_BrowseForScopeCB(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData) { HRESULT hr; INT iResult = 0; BROWSEFORSCOPE *pbfs = (BROWSEFORSCOPE*)lpData; LPTSTR pDirectoryName = NULL;
TraceEnter(TRACE_HANDLER, "CDsQuery::s_BrowseForScopeCB");
switch (uMsg) { case DSBM_QUERYINSERT: { PDSBITEM pItem = (PDSBITEM)lParam; TraceAssert(pItem);
// We are interested in modifying the root item of the tree, therefore
// lets check for that being inserted, if it is then we change the
// display name and the icon being shown.
if (pItem->dwState & DSBS_ROOT) { GetModuleFileName(GLOBAL_HINSTANCE, pItem->szIconLocation, ARRAYSIZE(pItem->szIconLocation)); pItem->iIconResID = -IDI_GLOBALCATALOG;
if (SUCCEEDED(FormatDirectoryName(&pDirectoryName, GLOBAL_HINSTANCE, IDS_GLOBALCATALOG))) { StrCpyN(pItem->szDisplayName, pDirectoryName, ARRAYSIZE(pItem->szDisplayName)); LocalFreeString(&pDirectoryName); }
pItem->dwMask |= DSBF_DISPLAYNAME|DSBF_ICONLOCATION; iResult = TRUE; }
break; }
case BFFM_SELCHANGED: { BOOL fEnableOK = TRUE; LPWSTR pszPath = (LPWSTR)lParam; LONG nElements = 0;
// The user changes the selection in the browse dialog, therefore
// lets see if we should be enabling the OK button. If the user
// selects GC, but we don't have a GC then we disable it.
if (SUCCEEDED(pbfs->padp->Set(CComBSTR(pszPath), ADS_SETTYPE_FULL))) { pbfs->padp->GetNumElements(&nElements); Trace(TEXT("nElements on exit from GetNumElements %d"), nElements); }
if (!nElements && !pbfs->szGcPath[0]) { TraceMsg("'entire directory' selected with NO GC!"); fEnableOK = FALSE; }
SendMessage(hwnd, BFFM_ENABLEOK, (WPARAM)fEnableOK, 0L); break; }
case DSBM_HELP: { WinHelp((HWND)((LPHELPINFO)lParam)->hItemHandle, DSQUERY_HELPFILE, HELP_WM_HELP, (DWORD_PTR)aBrowseHelpIDs); break; }
case DSBM_CONTEXTMENU: { WinHelp((HWND)lParam, DSQUERY_HELPFILE, HELP_CONTEXTMENU, (DWORD_PTR)aBrowseHelpIDs); break; } }
TraceLeaveValue(iResult); }
STDMETHODIMP CDsQuery::BrowseForScope(HWND hwndParent, LPCQSCOPE pCurrentScope, LPCQSCOPE* ppScope) { HRESULT hr; LPDSQUERYSCOPE pDsQueryScope = (LPDSQUERYSCOPE)pCurrentScope; BROWSEFORSCOPE bfs = { 0 }; DSBROWSEINFO dsbi = { 0 }; INT iResult; WCHAR szPath[2048]; WCHAR szRoot[MAX_PATH+10]; // LDAP://
WCHAR szObjectClass[64]; TraceEnter(TRACE_HANDLER, "CDsQuery::BrowseForScope"); Trace(TEXT("hwndParent %08x, pCurrentScope %08x, ppScope %08x"), hwndParent, pCurrentScope, ppScope);
*ppScope = NULL; // nothing yet!
if (SUCCEEDED(GetGlobalCatalogPath(_pServer, bfs.szGcPath, ARRAYSIZE(bfs.szGcPath)))) Trace(TEXT("GC path is: %s"), bfs.szGcPath);
hr = CoCreateInstance(CLSID_Pathname, NULL, CLSCTX_INPROC_SERVER, IID_IADsPathname, (void **)&bfs.padp); FailGracefully(hr, "Failed to get the IADsPathname interface");
// Fill out the browse info structure to display the object picker, if we have
// enabled admin features then lets make all objects visible, otherwise
// just the standard features.
dsbi.cbStruct = SIZEOF(dsbi); dsbi.hwndOwner = hwndParent; dsbi.pszRoot = szRoot; dsbi.pszPath = szPath; dsbi.cchPath = ARRAYSIZE(szPath); dsbi.dwFlags = (DSBI_RETURNOBJECTCLASS|DSBI_EXPANDONOPEN|DSBI_ENTIREDIRECTORY) & ~DSBI_NOROOT; dsbi.pfnCallback = s_BrowseForScopeCB; dsbi.lParam = (LPARAM)&bfs; dsbi.pszObjectClass = szObjectClass; dsbi.cchObjectClass = ARRAYSIZE(szObjectClass);
if (_dwFlags & DSQPF_SHOWHIDDENOBJECTS) dsbi.dwFlags |= DSBI_INCLUDEHIDDEN;
FormatMsgResource((LPTSTR*)&dsbi.pszTitle, GLOBAL_HINSTANCE, IDS_BROWSEPROMPT);
// NTRAID#NTBUG9-554905-2002/02/20-lucios. Pending fix.
StrCpyW(szRoot, c_szLDAP);
if (_pServer) { if (lstrlenW(_pServer) > MAX_PATH) ExitGracefully(hr, E_INVALIDARG, "_pServer is too big"); // NTRAID#NTBUG9-554905-2002/02/20-lucios. Pending fix.
StrCatW(szRoot, L"//"); StrCatW(szRoot, _pServer); }
if (pDsQueryScope) { //REVIEWED-2002-02-25-lucios.
StrCpyNW(szPath, OBJECT_NAME_FROM_SCOPE(pDsQueryScope), ARRAYSIZE(szPath)); Trace(TEXT("pDsQueryScope: %s"), szPath); }
// copy the credential information if needed
if (_dwFlags & DSQPF_HASCREDENTIALS) { TraceMsg("Setting credentails information"); dsbi.pUserName = _pUserName; dsbi.pPassword = _pPassword; dsbi.dwFlags |= DSBI_HASCREDENTIALS; }
iResult = DsBrowseForContainer(&dsbi); Trace(TEXT("DsBrowseForContainer returns %d"), iResult);
// iResult == IDOK if something was selected (szPath),
// if it is -VE if the call failed and we should error
if (iResult == IDOK) { LPWSTR pszScope = szPath; LPWSTR pszObjectClass = szObjectClass; LONG nElements = 0;
Trace(TEXT("Path on exit from DsBrowseForContainer: %s"), szPath);
// does this look like the GC? If so then default to it, as DsBrowseForContainer
// will return us iffy looking information
if (SUCCEEDED(bfs.padp->Set(CComBSTR(szPath), ADS_SETTYPE_FULL))) { bfs.padp->GetNumElements(&nElements); Trace(TEXT("nElements on exit from GetNumElements %d"), nElements); }
if (!nElements) { TraceMsg("nElements = 0, so defaulting to GC"); pszScope = bfs.szGcPath; pszObjectClass = GC_OBJECTCLASS; }
Trace(TEXT("Scope selected is: %s, Object class: %s"), pszScope, pszObjectClass);
hr = AllocScope(ppScope, 0, pszScope, pszObjectClass); FailGracefully(hr, "Failed converting the DS path to a scope"); } else if (iResult == IDCANCEL) { hr = S_FALSE; // nothing selected, returning S_FALSE;
} else if (iResult < 0) { ExitGracefully(hr, E_FAIL, "DsBrowseForContainer failed"); }
exit_gracefully:
LocalFreeString((LPTSTR*)&dsbi.pszTitle); Trace(TEXT("*ppScope == %08x"), *ppScope);
DoRelease(bfs.padp);
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
//
// WndProc for the banner window
//
LRESULT CALLBACK CDsQuery::s_BannerWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { LRESULT lResult = 0;
switch (uMsg) { case WM_SIZE: InvalidateRect(hwnd, NULL, FALSE); break;
case WM_ERASEBKGND: break;
case WM_PAINT: { TCHAR szBuffer[MAX_PATH]; HFONT hFont, hOldFont; SIZE szText; RECT rcClient; INT len; PAINTSTRUCT paint; COLORREF oldFgColor, oldBkColor; BeginPaint(hwnd, &paint);
hFont = (HFONT)SendMessage(GetParent(hwnd), WM_GETFONT, 0, 0L); hOldFont = (HFONT)SelectObject(paint.hdc, hFont);
if (hOldFont) { oldFgColor = SetTextColor(paint.hdc, GetSysColor(COLOR_WINDOWTEXT)); oldBkColor = SetBkColor(paint.hdc, ListView_GetBkColor(GetParent(hwnd)));
len = GetWindowText(hwnd, szBuffer, ARRAYSIZE(szBuffer));
GetTextExtentPoint32(paint.hdc, szBuffer, len, &szText); GetClientRect(GetParent(hwnd), &rcClient); ExtTextOut(paint.hdc, (rcClient.right - szText.cx) / 2, GetSystemMetrics(SM_CYBORDER)*4, ETO_CLIPPED|ETO_OPAQUE, &rcClient, szBuffer, len, NULL);
SetTextColor(paint.hdc, oldFgColor); SetBkColor(paint.hdc, oldBkColor);
SelectObject(paint.hdc, hOldFont); }
EndPaint(hwnd, &paint);
break; }
case WM_SETTEXT: { InvalidateRect(hwnd, NULL, FALSE); //break; // deliberate drop through..
}
default: lResult = DefWindowProc(hwnd, uMsg, wParam, lParam); break; }
return lResult; }
//
// WndProc for the bg window (lives behind list view, used by rest of the world)
//
LRESULT CALLBACK CDsQuery::s_ResultViewWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { LRESULT lResult = 0; CDsQuery* pDsQuery = NULL;
if (uMsg == WM_CREATE) { pDsQuery = (CDsQuery*)((LPCREATESTRUCT)lParam)->lpCreateParams; SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pDsQuery); } else { pDsQuery = (CDsQuery*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
switch (uMsg) { case WM_SIZE: pDsQuery->OnSize(LOWORD(lParam), HIWORD(lParam)); return(0);
case WM_DESTROY: pDsQuery->_hwndView = NULL; // view is gone!
break;
case WM_NOTIFY: return(pDsQuery->OnNotify(hwnd, wParam, lParam));
case WM_SETFOCUS: SetFocus(pDsQuery->_hwndView); break;
case WM_GETDLGCODE: return ((LRESULT)(DLGC_WANTARROWS | DLGC_WANTCHARS));
case WM_CONTEXTMENU: pDsQuery->OnContextMenu(NULL, lParam); return TRUE; case DSQVM_ADDRESULTS: return SUCCEEDED(pDsQuery->OnAddResults((DWORD)wParam, (HDPA)lParam)); case DSQVM_FINISHED: if ((DWORD)wParam == pDsQuery->_dwQueryReference) { // the references match so lets finish the query, and display
// the "too many results" prompt if the user did a really
// big query and we chopped them off
pDsQuery->StopQuery();
if (lParam) // == 0 then we are OK!
{ HWND hwndFrame; pDsQuery->_pqf->GetWindow(&hwndFrame); FormatMsgBox(GetParent(hwndFrame), GLOBAL_HINSTANCE, IDS_WINDOWTITLE, IDS_ERR_MAXRESULT, MB_OK|MB_ICONERROR); } } SetFocus(pDsQuery->_hwndView); return(1); } }
return DefWindowProc(hwnd, uMsg, wParam, lParam); }
STDMETHODIMP CDsQuery::CreateResultView(HWND hwndParent, HWND* phWndView) { HRESULT hr; WNDCLASS wc; HWND hwndFilter, hwndFilterOld; HIMAGELIST himlSmall, himlLarge; DWORD dwLVStyle = LVS_AUTOARRANGE|LVS_SHAREIMAGELISTS|LVS_SHOWSELALWAYS|LVS_REPORT; RECT rc;
TraceEnter(TRACE_HANDLER, "CDsQuery::CreateResultView");
if (IsWindow(_hwnd)) ExitGracefully(hr, E_FAIL, "Can only create one view at a time");
// Create our result viewer, this is the parent window to the ListView
// that we attach when we issue the query.
ZeroMemory(&wc, SIZEOF(wc)); wc.lpfnWndProc = s_ResultViewWndProc; wc.hInstance = GLOBAL_HINSTANCE; wc.lpszClassName = VIEW_CLASS; RegisterClass(&wc);
_hwnd = CreateWindow(VIEW_CLASS, NULL, WS_TABSTOP|WS_CLIPCHILDREN|WS_CHILD|WS_VISIBLE, 0, 0, 0, 0, hwndParent, NULL, GLOBAL_HINSTANCE, this); if (!_hwnd) ExitGracefully(hr, E_FAIL, "Failed to create view parent window");
// Now register the window classes we are using.
ZeroMemory(&wc, SIZEOF(wc)); wc.lpfnWndProc = s_BannerWndProc; wc.hInstance = GLOBAL_HINSTANCE; wc.lpszClassName = BANNER_CLASS; RegisterClass(&wc);
if (_dwOQWFlags & OQWF_SINGLESELECT) dwLVStyle |= LVS_SINGLESEL;
GetClientRect(_hwnd, &rc); _hwndView = CreateWindowEx(WS_EX_CLIENTEDGE, WC_LISTVIEW, NULL, WS_TABSTOP|WS_CLIPCHILDREN|WS_CHILD|WS_VISIBLE|dwLVStyle, 0, 0, rc.right, rc.bottom, _hwnd, (HMENU)IDC_RESULTS, GLOBAL_HINSTANCE, NULL); if (!_hwndView) ExitGracefully(hr, E_FAIL, "Failed to create the view window");
ListView_SetExtendedListViewStyle(_hwndView, LVS_EX_FULLROWSELECT|LVS_EX_LABELTIP); Shell_GetImageLists(&himlLarge, &himlSmall); ListView_SetImageList(_hwndView, himlLarge, LVSIL_NORMAL); ListView_SetImageList(_hwndView, himlSmall, LVSIL_SMALL); // Create the banner window, this is a child of the ListView, it is used to display
// information about the query being issued
_hwndBanner = CreateWindow(BANNER_CLASS, NULL, WS_CHILD, 0, 0, 0, 0, // nb: size fixed later
_hwndView, (HMENU)IDC_STATUS, GLOBAL_HINSTANCE, NULL); if (!_hwndBanner) ExitGracefully(hr, E_FAIL, "Failed to create the static banner window");
_SetFilter(_fFilter); _SetViewMode(_idViewMode); _ShowBanner(SWP_SHOWWINDOW, IDS_INITALIZING);
hr = S_OK; // success
exit_gracefully: if (SUCCEEDED(hr)) *phWndView = _hwnd;
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
#define MGW_EDIT 2
STDMETHODIMP CDsQuery::ActivateView(UINT uState, WPARAM wParam, LPARAM lParam) { HRESULT hr; HWND hwnd; INT i; TraceEnter(TRACE_HANDLER, "CDsQuery::ActivateView");
switch (uState) { case CQRVA_ACTIVATE: { HMENU hMenu; OLEMENUGROUPWIDTHS omgw = { 0, 0, 0, 0, 0, 0 };
// Allow the cframe to merge its menus into our menu bar before we
// add ours to it.
if (!(hMenu = CreateMenu())) ExitGracefully(hr, E_FAIL, "Failed to create a base menu bar to be used");
hr = _pqf->InsertMenus(hMenu, &omgw); FailGracefully(hr, "Failed when calling CQueryFrame::InsertMenus");
Shell_MergeMenus(GetSubMenu(hMenu, 0), GetSubMenu(_hFileMenu, 0), 0x0, 0x0, 0x7fff, 0);
MergeMenu(hMenu, _hEditMenu, omgw.width[0]); MergeMenu(hMenu, _hViewMenu, omgw.width[0]+1); MergeMenu(hMenu, _hHelpMenu, omgw.width[0]+MGW_EDIT+omgw.width[2]+omgw.width[4]);
if (_dwOQWFlags & OQWF_SINGLESELECT) { ENABLE_MENU_ITEM(hMenu, DSQH_EDIT_SELECTALL, FALSE); ENABLE_MENU_ITEM(hMenu, DSQH_EDIT_INVERTSELECTION, FALSE); }
hr = _pqf->SetMenu(hMenu, NULL); // set the frames menu bar
FailGracefully(hr, "Failed when calling CQueryFrame::SetMenu");
break; }
case CQRVA_INITMENUBAR: { // we recieve a CQRVA_INITMENUBAR before the popup so that we can store the
// menu bar information, and invalidate an interface pointers we maybe holding
// onto.
Trace(TEXT("Received an CQRVA_INITMENUBAR, hMenu %08x"), wParam);
_hFrameMenuBar = (HMENU)wParam; DoRelease(_pcm);
break; }
case CQRVA_INITMENUBARPOPUP: { HMENU hFileMenu; BOOL fDeleteItems = FALSE;
TraceMsg("Received an CQRVA_INITMENUBARPOPUP");
hFileMenu = GetSubMenu(_hFrameMenuBar, 0);
// if we have a view then lets try and collect the selection from it,
// having done that we can merge the verbs for that selection into the
// views "File" menu.
if ((hFileMenu == (HMENU)wParam) && !_pcm) { _fNoSelection = TRUE; // no selection currenlty
if (IsWindow(_hwndView)) { for (i = GetMenuItemCount(hFileMenu) - 1; i >= 0 ; i--) { if (!fDeleteItems && (GetMenuItemID(hFileMenu, i) == DSQH_FILE_PROPERTIES)) { Trace(TEXT("Setting fDeleteItems true on index %d"), i); fDeleteItems = TRUE; } else { if (fDeleteItems) DeleteMenu(hFileMenu, i, MF_BYPOSITION); } }
// Collect the selection, and using that construct an IContextMenu interface, if that works
// then we can merge in the verbs that relate to this object.
hr = _GetContextMenu(); FailGracefully(hr, "Failed when calling _GetAndViewObject");
if (ListView_GetSelectedCount(_hwndView) > 0) { _GetContextMenuVerbs(hFileMenu, CMF_VERBSONLY); _fNoSelection = FALSE; } }
}
// 211991 11/6/00 JonN and DavidDv
// choose columns is disabled if there are no columns to show/the user has marked for disabled
ENABLE_MENU_ITEM(_hFrameMenuBar, DSQH_VIEW_PICKCOLUMNS, IsWindow(_hwndView) && _hdsaColumns && (!(_dwFlags & DSQPF_NOCHOOSECOLUMNS)));
ENABLE_MENU_ITEM(_hFrameMenuBar, DSQH_VIEW_REFRESH, IsWindow(_hwndView) && _dwThreadId); _InitViewMenuItems(_hFrameMenuBar); break; }
case CQRVA_FORMCHANGED: { // we receieve a form change, we store the form name as we will use it
// as the default name for saved queries authored by the user.
Trace(TEXT("Form '%s' selected"), (LPTSTR)lParam);
LocalFreeString(&_pDefaultSaveName); hr = LocalAllocString(&_pDefaultSaveName, (LPCTSTR)lParam); FailGracefully(hr, "Failed to set the default save name");
break; }
case CQRVA_STARTQUERY: { Trace(TEXT("Query is: %s"), wParam ? TEXT("starting"):TEXT("stopping")); break; }
case CQRVA_HELP: { LPHELPINFO pHelpInfo = (LPHELPINFO)lParam; TraceAssert(pHelpInfo)
TraceMsg("Invoking help on the objects in the windows"); WinHelp((HWND)pHelpInfo->hItemHandle, DSQUERY_HELPFILE, HELP_WM_HELP, (DWORD_PTR)aHelpIDs);
break; }
case CQRVA_CONTEXTMENU: { HWND hwndForHelp = (HWND)wParam; Trace(TEXT("CQRVA_CONTEXTMENU recieved on the bg of the frame %d"), GetDlgCtrlID(hwndForHelp)); WinHelp(hwndForHelp, DSQUERY_HELPFILE, HELP_CONTEXTMENU, (DWORD_PTR)aHelpIDs); break; } } hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
STDMETHODIMP CDsQuery::InvokeCommand(HWND hwndParent, UINT uID) { HRESULT hr = S_OK; HWND hwndFrame; DECLAREWAITCURSOR;
TraceEnter(TRACE_HANDLER, "CDsQuery::InvokeCommand"); Trace(TEXT("hwndParent %08x, uID %d"), hwndParent, uID);
SetWaitCursor();
switch (uID) { case DSQH_BG_SELECT: SendMessage(hwndParent, WM_COMMAND, IDOK, 0); break;
case DSQH_FILE_PROPERTIES: hr = OnFileProperties(); break;
case DSQH_FILE_SAVEQUERY: hr = OnFileSaveQuery(); break;
case DSQH_EDIT_SELECTALL: hr = OnEditSelectAll(); break;
case DSQH_EDIT_INVERTSELECTION: hr = OnEditInvertSelection(); break;
case DSQH_VIEW_FILTER: _SetFilter(!_fFilter); break;
case DSQH_VIEW_LARGEICONS: case DSQH_VIEW_SMALLICONS: case DSQH_VIEW_LIST: case DSQH_VIEW_DETAILS: _SetViewMode(uID); break; case DSQH_VIEW_REFRESH: { if (IsWindow(_hwndView) && _dwThreadId) { _InitNewQuery(NULL, FALSE); PostThreadMessage(_dwThreadId, RVTM_REFRESH, _dwQueryReference, 0L); } break; }
case DSQH_VIEW_PICKCOLUMNS: { TraceAssert(_hdsaColumns); OnPickColumns(hwndParent); break; }
case DSQH_HELP_CONTENTS: { TraceMsg("Calling for to display help topics"); _pqf->GetWindow(&hwndFrame); _pqf->CallForm(NULL, DSQPM_HELPTOPICS, 0, (LPARAM)hwndFrame); break; }
case DSQH_HELP_WHATISTHIS: _pqf->GetWindow(&hwndFrame); SendMessage(hwndFrame, WM_SYSCOMMAND, SC_CONTEXTHELP, MAKELPARAM(0,0)); break; default: { // if it looks like a sort request then lets handle it, otherwise attempt
// to send to the context menu handler we may have at htis poiunt.
if ((uID >= DSQH_VIEW_ARRANGEFIRST) && (uID < DSQH_VIEW_ARRANGELAST)) { TraceAssert(_hdsaColumns); if (_hdsaColumns) { Trace(TEXT("Calling _SortResults for column %d"), uID - DSQH_VIEW_ARRANGEFIRST); _SortResults(uID - DSQH_VIEW_ARRANGEFIRST); } } else if (_pcm) { CMINVOKECOMMANDINFO ici;
ici.cbSize = SIZEOF(ici); ici.fMask = 0; _pqf->GetWindow(&ici.hwnd); ici.lpVerb = (LPCSTR)IntToPtr(uID - DSQH_FILE_CONTEXT_FIRST); ici.lpParameters = NULL; ici.lpDirectory = NULL; ici.nShow = SW_NORMAL; ici.dwHotKey = 0; ici.hIcon = NULL;
hr = _pcm->InvokeCommand(&ici); FailGracefully(hr, "Failed when calling IContextMenu::InvokeCommand");
DoRelease(_pcm); // no longer needed
}
break; } }
exit_gracefully:
ResetWaitCursor();
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
STDMETHODIMP CDsQuery::GetCommandString(UINT uID, DWORD dwFlags, LPTSTR pBuffer, INT cchBuffer) { HRESULT hr; TCHAR szBuffer[MAX_PATH];
TraceEnter(TRACE_HANDLER, "CDsQuery::GetCommandString"); Trace(TEXT("uID %08x, dwFlags %08x, pBuffer %08x, cchBuffer %d"), uID, dwFlags, pBuffer, cchBuffer);
if ((uID >= DSQH_FILE_CONTEXT_FIRST) && (uID < DSQH_FILE_CONTEXT_LAST)) { if (_pcm) { TraceMsg("Trying the IContextMenu::GetCommandString");
hr = _pcm->GetCommandString((uID - DSQH_FILE_CONTEXT_FIRST), GCS_HELPTEXT, NULL, (LPSTR)pBuffer, cchBuffer); FailGracefully(hr, "Failed when asking for help text from IContextMenu iface"); } } else { if ((uID >= DSQH_VIEW_ARRANGEFIRST) && (uID < DSQH_VIEW_ARRANGELAST)) { INT iColumn = uID-DSQH_VIEW_ARRANGEFIRST; TCHAR szFmt[MAX_PATH];
Trace(TEXT("Get command text for column %d"), iColumn);
if (_hdsaColumns && (iColumn < DSA_GetItemCount(_hdsaColumns))) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(_hdsaColumns, iColumn); TraceAssert(pColumn);
LoadString(GLOBAL_HINSTANCE, IDS_ARRANGEBY_HELP, szFmt, ARRAYSIZE(szFmt)); // NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(pBuffer, szFmt, pColumn->pHeading);
Trace(TEXT("Resulting string is: %s"), pBuffer); } } else { if (!LoadString(GLOBAL_HINSTANCE, uID, pBuffer, cchBuffer)) ExitGracefully(hr, E_FAIL, "Failed to load the command text for this verb"); } }
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
STDMETHODIMP CDsQuery::IssueQuery(LPCQPARAMS pQueryParams) { HRESULT hr; LPTHREADINITDATA ptid = NULL; LPDSQUERYSCOPE pDsQueryScope = (LPDSQUERYSCOPE)pQueryParams->pQueryScope; LPDSQUERYPARAMS pDsQueryParams = (LPDSQUERYPARAMS)pQueryParams->pQueryParameters; LPTSTR pBuffer = NULL; MSG msg;
TraceEnter(TRACE_HANDLER, "CDsQuery::IssueQuery"); Trace(TEXT("pQueryParams %08x, pDsQueryScope %08x, pDsQueryParams %08x"), pQueryParams, pDsQueryScope, pDsQueryParams);
// Persist the existing column information if there was some, then
// get the new column table initialized and the columns added to the
// view
if (_hdsaColumns) { if (_fColumnsModified) { _SaveColumnTable(_clsidForm, _hdsaColumns); _fColumnsModified = FALSE; }
_SaveColumnTable(); }
// Initialize the view with items
_clsidForm = pQueryParams->clsidForm; // keep the form ID (for persistance)
hr = _InitNewQuery(pDsQueryParams, TRUE); FailGracefully(hr, "Failed to initialize the new query");
// Now build the thread information needed to get the thread
// up and running.
ptid = (LPTHREADINITDATA)LocalAlloc(LPTR, SIZEOF(THREADINITDATA)); TraceAssert(ptid);
if (!ptid) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate THREADINITDATA");
ptid->dwReference = _dwQueryReference; //ptid->hwndView = NULL;
//ptid->pQuery = NULL;
//ptid->pScope = NULL;
//ptid->hdsaColumns = NULL;
//ptid->fShowHidden = FALSE;
//ptid->pServer = NULL;
//ptid->pUserName = NULL;
//ptid->pPassword = NULL;
Trace(TEXT("_dwFlags %08x (& DSQPF_SHOWHIDDENOBJECTS)"), _dwFlags, _dwFlags & DSQPF_SHOWHIDDENOBJECTS);
ptid->fShowHidden = (_dwFlags & DSQPF_SHOWHIDDENOBJECTS) ? 1:0; ptid->hwndView = _hwndView;
hr = _GetColumnTable(_clsidForm, pDsQueryParams, &ptid->hdsaColumns, FALSE); FailGracefully(hr, "Failed to create column DSA");
hr = LocalAllocStringW(&ptid->pQuery, (LPWSTR)ByteOffset(pDsQueryParams, pDsQueryParams->offsetQuery)); FailGracefully(hr, "Failed to copy query filter string");
hr = LocalAllocStringW(&ptid->pScope, OBJECT_NAME_FROM_SCOPE(pDsQueryScope)); FailGracefully(hr, "Failed to copy scope to thread init data");
hr = _CopyCredentials(&ptid->pUserName, &ptid->pPassword, &ptid->pServer); FailGracefully(hr, "Failed to copy credentails");
// now create the thread that is going to perform the query, this includes
// telling the previous one that it needs to close down
if (_hThread && _dwThreadId) { Trace(TEXT("Killing old query thread %08x, ID %d"), _hThread, _dwThreadId);
PostThreadMessage(_dwThreadId, RVTM_STOPQUERY, 0, 0); PostThreadMessage(_dwThreadId, WM_QUIT, 0, 0);
CloseHandle(_hThread);
_hThread = NULL; _dwThreadId = 0; }
DllAddRef();
_hThread = CreateThread(NULL, 0, QueryThread, ptid, 0, &_dwThreadId); TraceAssert(_hThread);
if (!_hThread) { DllRelease(); ExitGracefully(hr, E_FAIL, "Failed to create background thread - BAD!"); }
hr = S_OK; // success
exit_gracefully:
if (SUCCEEDED(hr) && IsWindow(_hwndView)) SetFocus(_hwndView);
if (FAILED(hr)) { QueryThread_FreeThreadInitData(&ptid); _pqf->StartQuery(FALSE); }
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
STDMETHODIMP CDsQuery::StopQuery() { HRESULT hr; INT cResults = _hdpaResults ? DPA_GetPtrCount(_hdpaResults):0; LPTSTR pBuffer;
TraceEnter(TRACE_HANDLER, "CDsQuery::StopQuery");
if (!IsWindow(_hwndView)) ExitGracefully(hr, E_FAIL, "View not initalized yet");
// we are stopping the query, we are going to tidy up the UI now
// and we just want the thread to closedown cleanly, therefore lets
// do so, increasing our query reference
_pqf->StartQuery(FALSE); _dwQueryReference++;
_PopulateView(-1, -1); // update status bar etc
if (_dwThreadId) PostThreadMessage(_dwThreadId, RVTM_STOPQUERY, 0, 0);
hr = S_OK; // success
exit_gracefully:
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
HRESULT CDsQuery::_SetDataObjectData(IDataObject* pDataObject, UINT cf, LPVOID pData, DWORD cbSize) { FORMATETC fmte = {(CLIPFORMAT)cf, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; STGMEDIUM medium = { TYMED_NULL, NULL, NULL }; LPVOID pAlloc;
HRESULT hr = AllocStorageMedium(&fmte, &medium, cbSize, &pAlloc); if (SUCCEEDED(hr)) { CopyMemory(pAlloc, pData, cbSize); hr = pDataObject->SetData(&fmte, &medium, TRUE); ReleaseStgMedium(&medium); // were done, so release the storage medium
}
return hr; }
HRESULT CDsQuery::_SetDispSpecOptions(IDataObject *pdo) { CLIPFORMAT cfDsDispSpecOptions = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_DSDISPLAYSPECOPTIONS); FORMATETC fmte = {cfDsDispSpecOptions, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; STGMEDIUM medium = { TYMED_NULL, NULL, NULL }; DSDISPLAYSPECOPTIONS *pddso; LPWSTR pAttribPrefix = DS_PROP_SHELL_PREFIX;
// are we in admin mode? if so then lets fix the property prefix for reading things
// from the display specifiers
if (_dwFlags & DSQPF_ENABLEADMINFEATURES) pAttribPrefix = DS_PROP_ADMIN_PREFIX;
// include all the string data into the allocation size (these are stored after the
// structure)
DWORD cbStruct = SIZEOF(DSDISPLAYSPECOPTIONS); cbStruct += StringByteSizeW(pAttribPrefix); cbStruct += StringByteSizeW(_pUserName); cbStruct += StringByteSizeW(_pPassword); cbStruct += StringByteSizeW(_pServer);
// allocate and fill...
HRESULT hr = AllocStorageMedium(&fmte, &medium, cbStruct, (void **)&pddso); if (SUCCEEDED(hr)) { DWORD offsetStrings = SIZEOF(DSDISPLAYSPECOPTIONS);
pddso->dwSize = SIZEOF(DSDISPLAYSPECOPTIONS); pddso->dwFlags = DSDSOF_HASUSERANDSERVERINFO|DSDSOF_DSAVAILABLE;
//pddso->offsetAttribPrefix = 0x0;
//pddso->offsetUserName = 0x0;
//pddso->offsetPassword = 0x0;
//pddso->offsetServer = 0x0;
//pddso->offsetServerConfigPath = 0x0;
pddso->offsetAttribPrefix = offsetStrings; StringByteCopyW(pddso, offsetStrings, pAttribPrefix); offsetStrings += StringByteSizeW(pAttribPrefix);
if (_pUserName) { pddso->offsetUserName = offsetStrings; StringByteCopyW(pddso, offsetStrings, _pUserName); offsetStrings += StringByteSizeW(_pUserName); }
if (_pPassword) { pddso->offsetPassword = offsetStrings; StringByteCopyW(pddso, offsetStrings, _pPassword); offsetStrings += StringByteSizeW(_pPassword); }
if (_pServer) { pddso->offsetServer = offsetStrings; StringByteCopyW(pddso, offsetStrings, _pServer); offsetStrings += StringByteSizeW(_pServer); }
// lets set into the IDataObject
hr = pdo->SetData(&fmte, &medium, TRUE); ReleaseStgMedium(&medium); }
return hr; }
STDMETHODIMP CDsQuery::GetViewObject(UINT uScope, REFIID riid, void **ppvOut) { HRESULT hr; IDataObject* pDataObject = NULL; LPDSQUERYPARAMS pDsQueryParams = NULL; LPDSQUERYSCOPE pDsQueryScope = NULL; UINT cfDsQueryParams = RegisterClipboardFormat(CFSTR_DSQUERYPARAMS); UINT cfDsQueryScope = RegisterClipboardFormat(CFSTR_DSQUERYSCOPE); BOOL fJustSelection = !(_dwFlags & DSQPF_RETURNALLRESULTS);
TraceEnter(TRACE_HANDLER, "CDsQuery::GetViewObject");
// We only support returning the selection as an IDataObject
DECLAREWAITCURSOR; SetWaitCursor();
if (!ppvOut && ((uScope & CQRVS_MASK) != CQRVS_SELECTION)) ExitGracefully(hr, E_INVALIDARG, "Bad arguments to GetViewObject");
if (!IsEqualIID(riid, IID_IDataObject)) ExitGracefully(hr, E_NOINTERFACE, "Object IID supported");
//
// write the extra data we have into the IDataObject:
//
// - query parameters (filter)
// - scope
// - attribute prefix information
//
hr = _GetDataObjectFromSelection(fJustSelection, &pDataObject); FailGracefully(hr, "Failed to get the IDataObject from the namespace");
if (SUCCEEDED(_pqf->CallForm(NULL, CQPM_GETPARAMETERS, 0, (LPARAM)&pDsQueryParams))) { if (pDsQueryParams) { hr = _SetDataObjectData(pDataObject, cfDsQueryParams, pDsQueryParams, pDsQueryParams->cbStruct); FailGracefully(hr, "Failed set the DSQUERYPARAMS into the data object"); } }
if (SUCCEEDED(_pqf->GetScope((LPCQSCOPE*)&pDsQueryScope))) { if (pDsQueryScope) { LPWSTR pScope = OBJECT_NAME_FROM_SCOPE(pDsQueryScope); TraceAssert(pScope);
hr = _SetDataObjectData(pDataObject, cfDsQueryScope, pScope, StringByteSizeW(pScope)); FailGracefully(hr, "Failed set the DSQUERYSCOPE into the data object"); } }
// success, so lets pass out the IDataObject.
pDataObject->AddRef(); *ppvOut = (LPVOID)pDataObject;
hr = S_OK;
exit_gracefully:
DoRelease(pDataObject); if (pDsQueryParams) CoTaskMemFree(pDsQueryParams);
if (pDsQueryScope) CoTaskMemFree(pDsQueryScope);
ResetWaitCursor();
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
STDMETHODIMP CDsQuery::LoadQuery(IPersistQuery* pPersistQuery) { HRESULT hr; WCHAR szBuffer[MAX_PATH]; IADs *pDsObject = NULL; BSTR bstrObjectClass = NULL; INT iFilter; LPCQSCOPE pScope = NULL; INT cbScope;
TraceEnter(TRACE_HANDLER, "CDsQuery::LoadQuery"); if (!pPersistQuery) ExitGracefully(hr, E_INVALIDARG, "No IPersistQuery object");
if (SUCCEEDED(pPersistQuery->ReadInt(c_szDsQuery, c_szScopeSize, &cbScope)) && (cbScope < SIZEOF(szBuffer)) && SUCCEEDED(pPersistQuery->ReadStruct(c_szDsQuery, c_szScope, szBuffer, cbScope))) { Trace(TEXT("Selected scope from file is %s"), szBuffer);
// get the object class from the file - this should be written to the file
hr = AdminToolsOpenObject(szBuffer, _pUserName, _pPassword, ADS_SECURE_AUTHENTICATION, IID_IADs, (void **)&pDsObject); FailGracefully(hr, "Failed to bind to the specified object");
hr = pDsObject->get_Class(&bstrObjectClass); FailGracefully(hr, "Failed to get the object class");
// allocate a new scope
if (SUCCEEDED(AllocScope(&pScope, 0, szBuffer, bstrObjectClass))) { hr = _pqf->AddScope(pScope, 0x0, TRUE); FailGracefully(hr, "Failed to add scope to list"); } }
// Read the remainder of the view state
if (SUCCEEDED(pPersistQuery->ReadInt(c_szDsQuery, c_szViewMode, &_idViewMode))) { Trace(TEXT("View mode is: %0x8"), _idViewMode); _SetViewMode(_idViewMode); }
if (SUCCEEDED(pPersistQuery->ReadInt(c_szDsQuery, c_szEnableFilter, &iFilter))) { Trace(TEXT("Filter mode set to %d"), _fFilter); _SetFilter(iFilter); }
hr = S_OK;
exit_gracefully:
if (pScope) CoTaskMemFree(pScope);
DoRelease(pDsObject); SysFreeString(bstrObjectClass);
TraceLeaveResult(hr); }
/*---------------------------------------------------------------------------*/
STDMETHODIMP CDsQuery::SaveQuery(IPersistQuery* pPersistQuery, LPCQSCOPE pScope) { HRESULT hr; LPDSQUERYSCOPE pDsQueryScope = (LPDSQUERYSCOPE)pScope; LPWSTR pScopePath = OBJECT_NAME_FROM_SCOPE(pDsQueryScope); WCHAR szGcPath[MAX_PATH]; TraceEnter(TRACE_HANDLER, "CDsQuery::SaveQuery");
if (!pPersistQuery || !pScope) ExitGracefully(hr, E_INVALIDARG, "No IPersistQuery/pScope object");
if (SUCCEEDED(GetGlobalCatalogPath(_pServer, szGcPath, ARRAYSIZE(szGcPath))) && StrCmpW(pScopePath, szGcPath)) { // if this is not the GC then persist
TraceMsg("GC path differs from scope, so persisting");
hr = pPersistQuery->WriteInt(c_szDsQuery, c_szScopeSize, StringByteSizeW(pScopePath)); FailGracefully(hr, "Failed to write the scope size");
hr = pPersistQuery->WriteStruct(c_szDsQuery, c_szScope, pScopePath, StringByteSizeW(pScopePath)); FailGracefully(hr, "Failed to write scope"); }
hr = pPersistQuery->WriteInt(c_szDsQuery, c_szViewMode, _idViewMode); FailGracefully(hr, "Failed to write view mode");
hr = pPersistQuery->WriteInt(c_szDsQuery, c_szEnableFilter, _fFilter); FailGracefully(hr, "Failed to write filter state");
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
/*----------------------------------------------------------------------------
/ IObjectWithSite /----------------------------------------------------------------------------*/
STDMETHODIMP CDsQuery::SetSite(IUnknown* punk) { HRESULT hr = S_OK;
TraceEnter(TRACE_HANDLER, "CDsQuery::SetSite");
DoRelease(_punkSite);
if (punk) { TraceMsg("QIing for IUnknown from the site object");
hr = punk->QueryInterface(IID_IUnknown, (void **)&_punkSite); FailGracefully(hr, "Failed to get IUnknown from the site object"); }
exit_gracefully:
TraceLeaveResult(hr); }
STDMETHODIMP CDsQuery::GetSite(REFIID riid, void **ppv) { HRESULT hr; TraceEnter(TRACE_HANDLER, "CDsQuery::GetSite");
if (!_punkSite) ExitGracefully(hr, E_NOINTERFACE, "No site to QI from");
hr = _punkSite->QueryInterface(riid, ppv); FailGracefully(hr, "QI failed on the site unknown object");
exit_gracefully:
TraceLeaveResult(hr); }
/*----------------------------------------------------------------------------
/ IDsQueryHandler /----------------------------------------------------------------------------*/
VOID CDsQuery::_DeleteViewItems(LPDSOBJECTNAMES pdon) { INT iResult; DWORD iItem;
TraceEnter(TRACE_HANDLER, "CDsQuery::_DeleteObjectNames");
if (pdon->cItems) { // walk through all the items in the view deleting as required.
for (iItem = 0 ; iItem != pdon->cItems ; iItem++) { // do we have an item to delete?
if (pdon->aObjects[iItem].offsetName) { LPCWSTR pwszName = (LPCWSTR)ByteOffset(pdon, pdon->aObjects[iItem].offsetName); Trace(TEXT("pwszName to delete: %s"), pwszName);
// walk all the results in the view deleting them as we go.
for (iResult = 0 ; iResult < DPA_GetPtrCount(_hdpaResults); iResult++) { LPQUERYRESULT pResult = (LPQUERYRESULT)DPA_GetPtr(_hdpaResults, iResult); TraceAssert(pResult);
// if we match the item we want to delete then remove it, if the view
// is not filtered then remove ite from the list, otherwise leave the
// view update until we have finished deleting
if (!StrCmpW(pwszName, pResult->pPath)) { Trace(TEXT("Item maps to result %d in the list"), iResult); FreeQueryResult(pResult, DSA_GetItemCount(_hdsaColumns)); DPA_DeletePtr(_hdpaResults, iResult); if (!_fFilter) { TraceMsg("Deleting the item from the view"); ListView_DeleteItem(_hwndView, iResult); } } } } }
// the view was filtered, so lets repopulate with the items
if (_fFilter) { TraceMsg("View is filter, therefore just forcing a refresh"); _FilterView(FALSE); } }
TraceLeave(); }
STDMETHODIMP CDsQuery::UpdateView(DWORD dwType, LPDSOBJECTNAMES pdon) { HRESULT hr;
TraceEnter(TRACE_HANDLER, "CDsQuery::UpdateView");
switch (dwType & DSQRVF_OPMASK) { case DSQRVF_ITEMSDELETED: { if (!pdon) ExitGracefully(hr, E_INVALIDARG, "Invlaidate pdon specified for refresh");
_DeleteViewItems(pdon); break; }
default: ExitGracefully(hr, E_INVALIDARG, "Invalidate refresh type speciifed"); }
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ Message/Command Handlers /----------------------------------------------------------------------------*/
/*-----------------------------------------------------------------------------
/ CDsQuery::OnSize / ---------------- / Result viewer is being sized, so ensure that our children have their / sizes correctly addjusted. / / In: / cx, cy = new size of the parent window / / Out: / - /----------------------------------------------------------------------------*/ LRESULT CDsQuery::OnSize(INT cx, INT cy) { TraceEnter(TRACE_VIEW, "CDsQuery::OnSize");
SetWindowPos(_hwndView, NULL, 0, 0, cx, cy, SWP_NOZORDER|SWP_NOMOVE); _ShowBanner(0, 0);
TraceLeaveValue(0); }
/*-----------------------------------------------------------------------------
/ CDsQuery::OnNotify / ------------------ / Notify message being recieved by the view, so try and handle it as best / we can. / / In: / hWnd = window handle of the notify / wParam, lParam = parameters for the notify event / / Out: / LRESULT /----------------------------------------------------------------------------*/ LRESULT CDsQuery::OnNotify(HWND hWnd, WPARAM wParam, LPARAM lParam) { HRESULT hr; LRESULT lr = 0; DECLAREWAITCURSOR = GetCursor();
TraceEnter(TRACE_VIEW, "CDsQuery::OnNotify");
switch (((LPNMHDR)lParam)->code) { case HDN_FILTERCHANGE: _FilterView(TRUE); break;
case HDN_FILTERBTNCLICK: { NMHDFILTERBTNCLICK* pNotify = (NMHDFILTERBTNCLICK*)lParam; HMENU hMenu; POINT pt; HD_ITEM hdi; UINT uID; if (_hdsaColumns && (pNotify->iItem < DSA_GetItemCount(_hdsaColumns))) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(_hdsaColumns, pNotify->iItem);
if (pColumn) { hMenu = LoadMenu(GLOBAL_HINSTANCE, property_type_table[pColumn->iPropertyType].pMenuName); TraceAssert(hMenu);
if (hMenu) { pt.x = pNotify->rc.right; pt.y = pNotify->rc.bottom; MapWindowPoints(pNotify->hdr.hwndFrom, NULL, &pt, 1);
CheckMenuRadioItem(GetSubMenu(hMenu, 0), FILTER_FIRST, FILTER_LAST, pColumn->idOperator, MF_BYCOMMAND);
uID = TrackPopupMenu(GetSubMenu(hMenu, 0), TPM_RIGHTALIGN|TPM_RETURNCMD, pt.x, pt.y, 0, pNotify->hdr.hwndFrom, NULL); switch (uID) { case DSQH_CLEARFILTER: Header_ClearFilter(ListView_GetHeader(_hwndView), pNotify->iItem); break;
case DSQH_CLEARALLFILTERS: Header_ClearAllFilters(ListView_GetHeader(_hwndView)); break; default: { if (uID && (uID != pColumn->idOperator)) { // update the filter string based on the new operator
pColumn->idOperator = uID; _GetFilterValue(pNotify->iItem, NULL); lr = TRUE; } break; } }
DestroyMenu(hMenu); } } }
break; }
case HDN_ITEMCHANGED: { HD_NOTIFY* pNotify = (HD_NOTIFY*)lParam; HD_ITEM* pitem = (HD_ITEM*)pNotify->pitem; if (_hdsaColumns && (pNotify->iItem < DSA_GetItemCount(_hdsaColumns))) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(_hdsaColumns, pNotify->iItem); TraceAssert(pColumn);
// store the new column width information in the column structure and
// mark the column table as dirty
if (pitem->mask & HDI_WIDTH) { Trace(TEXT("Column %d, cx %d (marking state as dirty)"), pNotify->iItem, pitem->cxy); pColumn->cx = pitem->cxy; _fColumnsModified = TRUE; } if (pitem->mask & HDI_FILTER) { Trace(TEXT("Filter for column %d has been changed"), pNotify->iItem); _GetFilterValue(pNotify->iItem, pitem); } }
break; }
case LVN_GETDISPINFO: { LV_DISPINFO* pNotify = (LV_DISPINFO*)lParam; TraceAssert(pNotify);
if (pNotify && (pNotify->item.mask & LVIF_TEXT) && pNotify->item.lParam) { LPQUERYRESULT pResult = (LPQUERYRESULT)pNotify->item.lParam; INT iColumn = pNotify->item.iSubItem;
pNotify->item.pszText[0] = TEXT('\0'); // nothing to display yet
switch (pResult->aColumn[iColumn].iPropertyType) { case PROPERTY_ISUNDEFINED: break;
case PROPERTY_ISUNKNOWN: case PROPERTY_ISSTRING: case PROPERTY_ISDNSTRING: { if (pResult->aColumn[iColumn].pszText) StrCpyN(pNotify->item.pszText, pResult->aColumn[iColumn].pszText, pNotify->item.cchTextMax);
break; } case PROPERTY_ISNUMBER: case PROPERTY_ISBOOL: // NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(pNotify->item.pszText, TEXT("%d"), pResult->aColumn[iColumn].iValue); break; }
lr = TRUE; // we formatted a value
}
break; }
case LVN_ITEMACTIVATE: { LPNMHDR pNotify = (LPNMHDR)lParam; DWORD dwFlags = CMF_NORMAL; HWND hwndFrame; HMENU hMenu; UINT uID;
// convert the current selection to IDLITs and an IContextMenu interface
// that we can then get the default verb from.
SetWaitCursor();
hr = _GetContextMenu(); FailGracefully(hr, "Failed when calling _GetContextMenu");
_fNoSelection = !ListView_GetSelectedCount(_hwndView);
if (!_fNoSelection) { // create a popup menu pickup the context menu for the current selection
// and then pass it down to the invoke command handler.
hMenu = CreatePopupMenu(); TraceAssert(hMenu);
if (hMenu) { if (GetKeyState(VK_SHIFT) < 0) dwFlags |= CMF_EXPLORE; // SHIFT + dblclick does a Explore by default
_GetContextMenuVerbs(hMenu, dwFlags);
uID = GetMenuDefaultItem(hMenu, MF_BYCOMMAND, 0); Trace(TEXT("Default uID after double click %08x"), uID);
if (uID != -1) { _pqf->GetWindow(&hwndFrame); InvokeCommand(hwndFrame, uID); }
DoRelease(_pcm); // no longer needed
DestroyMenu(hMenu); } }
break; }
case LVN_COLUMNCLICK: { NM_LISTVIEW* pNotify = (NM_LISTVIEW*)lParam; TraceAssert(pNotify); _SortResults(pNotify->iSubItem); break; }
default: lr = DefWindowProc(hWnd, WM_NOTIFY, wParam, lParam); break; }
exit_gracefully:
ResetWaitCursor();
TraceLeaveValue(lr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::OnAddResults / ---------------------- / The background thread has sent us some results, so lets add them to / the DPA of results, discarding the ones we don't add because we cannot / grow the DPA. / / dwQueryReference conatins the reference ID for this query, only add / results where these match. / / In: / dwQueryReference = reference that this block is for / hdpaResults = DPA containing the results to add / / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::OnAddResults(DWORD dwQueryReference, HDPA hdpaResults) { HRESULT hr; INT i, iPopulateFrom;
TraceEnter(TRACE_VIEW, "CDsQuery::OnAddResults");
if ((dwQueryReference != _dwQueryReference) || !hdpaResults) ExitGracefully(hr, E_FAIL, "Failed to add results, bad DPA/reference ID");
// the caller gives us a DPA then we add them to our result DPA, we then
// update the view populating from the first item we added.
iPopulateFrom = DPA_GetPtrCount(_hdpaResults);
for (i = DPA_GetPtrCount(hdpaResults); --i >= 0 ; ) { LPQUERYRESULT pResult = (LPQUERYRESULT)DPA_GetPtr(hdpaResults, i); TraceAssert(pResult);
// add the result to the main DPA, if that fails then ensure we nuke
// this result blob!
if (-1 == DPA_AppendPtr(_hdpaResults, pResult)) FreeQueryResult(pResult, DSA_GetItemCount(_hdsaColumns));
DPA_DeletePtr(hdpaResults, i); // remove from result DPA
}
_PopulateView(iPopulateFrom, DPA_GetPtrCount(_hdpaResults));
TraceAssert(DPA_GetPtrCount(hdpaResults) == 0); DPA_Destroy(hdpaResults);
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::OnContextMenu / ----------------------- / The user has right clicked in the result view, therefore we must attempt / to display the context menu for those objects / / In: / hwndMenu = window that that the user menued over / pt = point to show the context menu / / Out: / - /----------------------------------------------------------------------------*/ LRESULT CDsQuery::OnContextMenu(HWND hwndMenu, LPARAM lParam) { HRESULT hr; HMENU hMenu = NULL; POINT pt = { 0, 0 }; INT i; RECT rc; HWND hwndFrame;
TraceEnter(TRACE_VIEW, "CDsQuery::OnContextMenu");
// Collect the selection, obtaining a IContextMenu interface pointer, or a HR == S_FALSE
// if there is no selection for us to be using.
hr = _GetContextMenu(); FailGracefully(hr, "Failed when calling _GetContextMenu()");
_fNoSelection = !ListView_GetSelectedCount(_hwndView);
if (!(hMenu = CreatePopupMenu())) ExitGracefully(hr, E_FAIL, "Failed to create the popup menu");
if (!_fNoSelection) { // pick up the context menu that maps to the current selection, including fixing
// the "select" verb if we need one.
_GetContextMenuVerbs(hMenu, CMF_NORMAL); } else { // There is no selection so lets pick up the view bg menu, this contains
// some useful helpers for modifying the view state.
HMENU hBgMenu = LoadMenu(GLOBAL_HINSTANCE, MAKEINTRESOURCE(IDR_VIEWBACKGROUND));
if (!hBgMenu) ExitGracefully(hr, E_FAIL, "Failed to load pop-up menu for the background");
Shell_MergeMenus(hMenu, GetSubMenu(hBgMenu, 0), 0, 0, CQID_MAXHANDLERMENUID, 0x0); DestroyMenu(hBgMenu);
_InitViewMenuItems(hMenu); }
// if lParam == -1 then we know that the user hit the "context menu" key
// so lets set the co-ordinates of the item.
if (lParam == (DWORD)-1) { i = ListView_GetNextItem(_hwndView, -1, LVNI_FOCUSED|LVNI_SELECTED); Trace(TEXT("Item with focus + selection: %d"), i);
if (i == -1) { i = ListView_GetNextItem(_hwndView, -1, LVNI_SELECTED); Trace(TEXT("1st selected item: %D"), i); }
if (i != -1) { TraceMsg("We have an item, so getting bounds of the icon for position"); ListView_GetItemRect(_hwndView, i, &rc, LVIR_ICON); pt.x = (rc.left+rc.right)/2; pt.y = (rc.top+rc.bottom)/2; }
MapWindowPoints(_hwndView, HWND_DESKTOP, &pt, 1); // they are in client co-ordinates
} else { pt.x = GET_X_LPARAM(lParam); pt.y = GET_Y_LPARAM(lParam); } // we have the position so lets use it
_pqf->GetWindow(&hwndFrame); TrackPopupMenu(hMenu, TPM_LEFTALIGN, pt.x, pt.y, 0, hwndFrame, NULL);
exit_gracefully:
if (hMenu) DestroyMenu(hMenu);
TraceLeaveValue(0); }
/*-----------------------------------------------------------------------------
/ CDsQuery::OnFileProperties / -------------------------- / Show properties for the given selection. To do this we CoCreate / IDsFolderProperties on the IDsFolder implementation and that / we can invoke properties using. / / In: / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::OnFileProperties(VOID) { HRESULT hr; IDataObject* pDataObject = NULL; IDsFolderProperties* pDsFolderProperties = NULL;
TraceEnter(TRACE_VIEW, "CDsQuery::OnFileProperties");
hr = GetViewObject(CQRVS_SELECTION, IID_IDataObject, (void **)&pDataObject); FailGracefully(hr, "Failed to get IDataObject for shortcut creation");
hr = CoCreateInstance(CLSID_DsFolderProperties, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARG(IDsFolderProperties, &pDsFolderProperties)); FailGracefully(hr, "Failed to get IDsFolderProperties for the desktop object");
hr = pDsFolderProperties->ShowProperties(_hwnd, pDataObject); FailGracefully(hr, "Failed to invoke property UI for the given selection");
// hr = S_OK; // success
exit_gracefully: DoRelease(pDataObject); DoRelease(pDsFolderProperties);
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::OnFileSaveQuery / ------------------------- / Allow the user to choose a location to save the query (initial directory / is nethood). Having done that we then start the save process by passing / the frame object a IQueryIO object that allows them to persist the / query into. / / In: / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::OnFileSaveQuery(VOID) { HRESULT hr; OPENFILENAME ofn; TCHAR szFilename[MAX_PATH]; TCHAR szDirectory[MAX_PATH]; TCHAR szFilter[64]; TCHAR szTitle[64]; LPTSTR pFilter; IPersistQuery *ppq = NULL;
TraceEnter(TRACE_VIEW, "CDsQuery::OnFileSaveQuery");
// Load the default strings and fix up the filter string as it needs
// NULL's seperating the various resource sections.
LoadString(GLOBAL_HINSTANCE, IDS_SAVETITLE, szTitle, ARRAYSIZE(szTitle)); // NTRAID#NTBUG9-554905-2002/02/20-lucios. Pending fix.
StrCpy(szFilename, _pDefaultSaveName); LoadString(GLOBAL_HINSTANCE, IDS_SAVEFILTER, szFilter, ARRAYSIZE(szFilter));
for (pFilter = szFilter ; *pFilter ; pFilter++) { if (*pFilter == TEXT('\n')) *pFilter = TEXT('\0'); }
// fix the open filename structure ready to do our save....
ZeroMemory(&ofn, SIZEOF(ofn));
ofn.lStructSize = SIZEOF(ofn); _pqf->GetWindow(&ofn.hwndOwner); ofn.hInstance = GLOBAL_HINSTANCE; ofn.lpstrFilter = szFilter; ofn.lpstrFile = szFilename; ofn.nMaxFile = ARRAYSIZE(szFilename);
if (_pDefaultSaveLocation) { Trace(TEXT("Saving into: %s"), _pDefaultSaveLocation); // NTRAID#NTBUG9-554905-2002/02/20-lucios. Pending fix.
StrCpy(szDirectory, _pDefaultSaveLocation); ofn.lpstrInitialDir = szDirectory; }
ofn.lpstrTitle = szTitle; ofn.Flags = OFN_EXPLORER|OFN_NOCHANGEDIR|OFN_OVERWRITEPROMPT|OFN_PATHMUSTEXIST|OFN_HIDEREADONLY; ofn.lpstrDefExt = TEXT("dsq");
// If we get a save filename then lets ensure that we delete the previous
// query saved there (if there is one) and then we can create an IPersistQuery
// object that will save to that location.
if (GetSaveFileName(&ofn)) { Trace(TEXT("Saving query as: %s"), szFilename);
if (!DeleteFile(szFilename) && (GetLastError() != ERROR_FILE_NOT_FOUND)) ExitGracefully(hr, E_FAIL, "Failed to delete previous query");
hr = CPersistQuery_CreateInstance(szFilename, &ppq); FailGracefully(hr, "Failed to create the peristance object");
hr = _pqf->SaveQuery(ppq); FailGracefully(hr, "Failed when calling IQueryFrame::SaveSearch"); }
hr = S_OK;
exit_gracefully:
DoRelease(ppq);
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::OnEditSelectAll / ------------------------- / Walk all the items in the view setting their selected state. / / In: / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::OnEditSelectAll(VOID) { TraceEnter(TRACE_VIEW, "CDsQuery::OnEditSelectAll");
for (INT i = ListView_GetItemCount(_hwndView) ; --i >= 0 ;) { ListView_SetItemState(_hwndView, i, LVIS_SELECTED, LVIS_SELECTED); }
TraceLeaveResult(S_OK); }
/*-----------------------------------------------------------------------------
/ CDsQuery::OnEditInvertSelection / ------------------------------- / Walk all the items in the view and invert their selected state. / / In: / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::OnEditInvertSelection(VOID) { TraceEnter(TRACE_VIEW, "CDsQuery::OnEditInvertSelection");
for (INT i = ListView_GetItemCount(_hwndView) ; --i >= 0 ;) { DWORD dwState = ListView_GetItemState(_hwndView, i, LVIS_SELECTED); ListView_SetItemState(_hwndView, i, dwState ^ LVIS_SELECTED, LVIS_SELECTED); }
TraceLeaveResult(S_OK); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_InitNewQuery / ---------------------- / Initialize the view ready for a new query, including setting the frame / into a query running state. / / In: / pDsQueryParams = DSQUERYPARAMs structure used to issue the query. / fRefreshColumnTable = re-read the column table from the params/registry etc / / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::_InitNewQuery(LPDSQUERYPARAMS pDsQueryParams, BOOL fRefreshColumnTable) { HRESULT hr; LPTSTR pBuffer;
TraceEnter(TRACE_VIEW, "CDsQuery::_InitNewQuery");
hr = _pqf->StartQuery(TRUE); TraceAssert(SUCCEEDED(hr));
// Claim the cached DS object for this window
// if refreshing the column table then _GetColumnTable handles this all for us,
// otherwise lets just nuke the result set ourselves.
if (fRefreshColumnTable) { _SaveColumnTable();
hr = _GetColumnTable(_clsidForm, pDsQueryParams, &_hdsaColumns, TRUE); FailGracefully(hr, "Failed to create column DSA"); } else { _FreeResults(); }
// initialize the view to start the query running, display the prompt banner and
// initialize the result DPA.
_ShowBanner(SWP_SHOWWINDOW, IDS_SEARCHING); // we are now searching
if (SUCCEEDED(FormatMsgResource(&pBuffer, GLOBAL_HINSTANCE, IDS_SEARCHING))) { _pqf->SetStatusText(pBuffer); LocalFreeString(&pBuffer); }
TraceAssert(_hdpaResults==NULL); // should never catch
_hdpaResults = DPA_Create(16); TraceAssert(_hdpaResults);
if (!_hdpaResults) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate result DPA");
_dwQueryReference++;
exit_gracefully:
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_GetFilterValue / ------------------------ / Given a column index collect the filter value from it, note that / when doing this / / In: / i = column to retrieve / pitem -> HD_ITEM structure for the current filter / == NULL then read from header / / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::_GetFilterValue(INT i, HD_ITEM* pitem) { HRESULT hr; HD_ITEM hdi; HD_TEXTFILTER textFilter; TCHAR szBuffer[MAX_PATH]; INT iValue; UINT cchFilter = 0; LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(_hdsaColumns, i);
if (!pColumn) ExitGracefully(hr, E_FAIL, "Failed to get the column");
TraceEnter(TRACE_VIEW, "CDsQuery::_GetFilterValue");
// if pitem == NULL then lets pick up the filter value from the
// header control, using the stored property type (the filter one
// has already been nuked) to defined which filter we want.
if (!pitem) { hdi.mask = HDI_FILTER;
switch (pColumn->iPropertyType) { case PROPERTY_ISUNKNOWN: case PROPERTY_ISSTRING: case PROPERTY_ISDNSTRING: { hdi.type = HDFT_ISSTRING; hdi.pvFilter = &textFilter; textFilter.pszText = szBuffer; textFilter.cchTextMax = ARRAYSIZE(szBuffer); break; }
case PROPERTY_ISNUMBER: case PROPERTY_ISBOOL: { hdi.type = HDFT_ISNUMBER; hdi.pvFilter = &iValue; break; } }
if (!Header_GetItem(ListView_GetHeader(_hwndView), i, &hdi)) ExitGracefully(hr, E_FAIL, "Failed to get the filter string");
pitem = &hdi; }
// discard the previous filter value and lets read from the
// structure the information we need to cache our filter information
FreeColumnValue(&pColumn->filter);
if (!(pitem->type & HDFT_HASNOVALUE) && pitem->pvFilter) { switch (pitem->type & HDFT_ISMASK) { case HDFT_ISSTRING: { LPHD_TEXTFILTER ptextFilter = (LPHD_TEXTFILTER)pitem->pvFilter; TraceAssert(ptextFilter);
pColumn->filter.iPropertyType = PROPERTY_ISSTRING;
// text filters are stored in their wildcarded state, therefore
// filtering doesn't require converting from the text form
// to something more elobrate each pass through. the down
// side is when the operator changes we must rebuild the
// filter string for that column (small price)
GetPatternString(NULL, &cchFilter, pColumn->idOperator, ptextFilter->pszText); TraceAssert(cchFilter != 0);
if (cchFilter) { hr = LocalAllocStringLen(&pColumn->filter.pszText, cchFilter); FailGracefully(hr, "Failed to allocate buffer to read string into");
GetPatternString(pColumn->filter.pszText, &cchFilter, pColumn->idOperator, ptextFilter->pszText); Trace(TEXT("Filter (with pattern info): %s"), pColumn->filter.pszText);
LCMapString(0x0, LCMAP_UPPERCASE, pColumn->filter.pszText, -1, pColumn->filter.pszText, cchFilter+1); Trace(TEXT("After converting to uppercase (LCMapString): %s"), pColumn->filter.pszText); }
break; }
case HDFT_ISNUMBER: { INT* piFilter = (INT*)pitem->pvFilter; TraceAssert(piFilter);
pColumn->filter.iPropertyType = PROPERTY_ISNUMBER; pColumn->filter.iValue = *piFilter; Trace(TEXT("Filter: %d"), pColumn->filter.iValue);
break; } } }
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_FilterView / -------------------- / Filter the result set populating the view again with the changes / / In: / fCheck / / Out: / HRESULT /----------------------------------------------------------------------------*/
UINT _GetFilter(HDSA hdsaColumns, LPTSTR pBuffer, UINT* pcchBuffer) { INT i; TCHAR szBuffer[MAX_PATH];
TraceEnter(TRACE_VIEW, "_GetFilter"); TraceAssert(hdsaColumns && pcchBuffer);
*pcchBuffer = 0;
// form the string containin [operatorID]value pairs for each of the
// filter columns that is defined.
for (i = 0 ; i < DSA_GetItemCount(hdsaColumns); i++) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(hdsaColumns, i); TraceAssert(pColumn);
if (pColumn->filter.iPropertyType != PROPERTY_ISUNDEFINED) { // NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(szBuffer, TEXT("[%d]"), pColumn->idOperator); PutStringElement(pBuffer, pcchBuffer, szBuffer);
switch (pColumn->filter.iPropertyType) { case PROPERTY_ISUNDEFINED: break;
case PROPERTY_ISUNKNOWN: case PROPERTY_ISSTRING: case PROPERTY_ISDNSTRING: PutStringElement(pBuffer, pcchBuffer, pColumn->filter.pszText); break;
case PROPERTY_ISNUMBER: case PROPERTY_ISBOOL: // NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(szBuffer, TEXT("%d"), pColumn->filter.iValue); PutStringElement(pBuffer, pcchBuffer, szBuffer); break; } } }
Trace(TEXT("pBuffer contains: %s (%d)"), pBuffer ? pBuffer:TEXT("<NULL>"), *pcchBuffer);
TraceLeaveValue(*pcchBuffer); }
HRESULT CDsQuery::_FilterView(BOOL fCheck) { HRESULT hr = S_OK; LPTSTR pFilter = NULL; UINT cchFilter; BOOL fSetCursor = FALSE;
TraceEnter(TRACE_VIEW, "CDsQuery::_FilterView"); if (!_hdpaResults) ExitGracefully(hr, S_OK, "FitlerView bailing, no results");
DECLAREWAITCURSOR; SetWaitCursor(); // this could take some time
fSetCursor = TRUE; // get the current filter string, this consists of the filter
// information from all the columns
if (_GetFilter(_hdsaColumns, NULL, &cchFilter)) { hr = LocalAllocStringLen(&pFilter, cchFilter); FailGracefully(hr, "Failed to allocate filter string");
_GetFilter(_hdsaColumns, pFilter, &cchFilter); }
// if the filters don't match then re-populate the view,
// as the criteria for the results has changed
if (!fCheck || (!pFilter || !_pFilter) || (pFilter && _pFilter && StrCmpI(pFilter, _pFilter))) { LPTSTR pBuffer;
TraceMsg("Filtering the view, filters differ");
ListView_DeleteAllItems(_hwndView); _ShowBanner(SWP_SHOWWINDOW, IDS_FILTERING);
if (SUCCEEDED(FormatMsgResource(&pBuffer, GLOBAL_HINSTANCE, IDS_FILTERING))) { _pqf->SetStatusText(pBuffer); LocalFreeString(&pBuffer); } _PopulateView(0, DPA_GetPtrCount(_hdpaResults)); }
// ensure we hang onto the new filter, discarding the previous one
LocalFreeString(&_pFilter); _pFilter = pFilter;
exit_gracefully:
if (fSetCursor) ResetWaitCursor();
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_PopulateView / ---------------------- / Add items from the result DPA to the view filtering as required. The / caller gives us the start index (0 if all) and we walk the results / adding them to the view. / / In: / iItem = first item to add / == 0 first / == -1 then add none, just update status / iLast = last item to be updated / / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::_PopulateView(INT iItem, INT iLast) { HRESULT hr; BOOL fBannerShown = IsWindowVisible(_hwndBanner); LPTSTR pBuffer = NULL; LV_ITEM lvi; INT iColumn, i; INT iVisible = 0; INT iHidden = 0; BOOL fIncludeItem; MSG msg;
TraceEnter(TRACE_VIEW, "CDsQuery::_PopulateView"); Trace(TEXT("Range %d to %d"), iItem, iLast);
if (iItem > -1) { Trace(TEXT("Adding items %d to %d"), iItem, DPA_GetPtrCount(_hdpaResults));
lvi.mask = LVIF_TEXT|LVIF_PARAM|LVIF_IMAGE; lvi.iItem = 0x7fffffff; lvi.iSubItem = 0; lvi.pszText = LPSTR_TEXTCALLBACK;
// Walk the results in the range we need to add and add them to the view
// applying the filter to remove items we are not interested in.
for (i = 0; iItem < iLast ; i++, iItem++) { LPQUERYRESULT pResult = (LPQUERYRESULT)DPA_GetPtr(_hdpaResults, iItem);
if (!pResult) continue;
fIncludeItem = TRUE; // new items always get included
// if the filter is visilbe then lets walk it removing items from the list
// of results. fIncludeItem starts as TRUE and after the filter
// loop should become either TRUE/FALSE. All columns are ANDed together
// therefore the logic is quite simple.
if (_fFilter) { for (iColumn = 0 ; fIncludeItem && (iColumn < DSA_GetItemCount(_hdsaColumns)); iColumn++) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(_hdsaColumns, iColumn); TraceAssert(pColumn);
// if the column has a filter defined (!PROPERTY_ISUNDEFINED) then
// check that the properties match, if they don't then skip the
// itmer otherwise lets try applying the filter based on
// the type.
if (pColumn->filter.iPropertyType == PROPERTY_ISUNDEFINED) continue;
if (pResult->aColumn[iColumn].iPropertyType == PROPERTY_ISUNDEFINED) { // column is undefined therefore lets ignore it, it won't
// match the criteria
fIncludeItem = FALSE; } else { switch (pColumn->filter.iPropertyType) { case PROPERTY_ISUNDEFINED: break;
case PROPERTY_ISUNKNOWN: case PROPERTY_ISSTRING: case PROPERTY_ISDNSTRING: { TCHAR szBuffer[MAX_PATH]; LPTSTR pszBuffer = NULL; LPTSTR pszValue = pResult->aColumn[iColumn].pszText; INT cchValue = lstrlen(pszValue); LPTSTR pszValueUC = szBuffer;
// the filter value is stored in uppercase, so to ensure we are case insensitive
// we must convert the string to uppercase. We have a buffer we will use,
// however, if the value is too large we will allocate a buffer we can use.
if (cchValue > ARRAYSIZE(szBuffer)) { TraceMsg("Value too big for our static buffer, so allocating"); if (FAILED(LocalAllocStringLen(&pszBuffer, cchValue))) { TraceMsg("Failed to allocate a buffer for the string, so ignoring it!"); fIncludeItem = FALSE; break; }
pszValueUC = pszBuffer; // fix the pointer to the new string
}
LCMapString(0x0, LCMAP_UPPERCASE, pszValue, -1, pszValueUC, cchValue+1); Trace(TEXT("After converting to uppercase (LCMapString): %s"), pszValueUC);
// string properties need to be compared using the match filter
// function, this code is given the filter and the result
// and we must compare, in return we get TRUE/FALSE, therefore
// catch the NOT cases specificly.
switch (pColumn->idOperator) { case FILTER_CONTAINS: case FILTER_STARTSWITH: case FILTER_ENDSWITH: case FILTER_IS: fIncludeItem = MatchPattern(pszValueUC, pColumn->filter.pszText); break;
case FILTER_NOTCONTAINS: case FILTER_ISNOT: fIncludeItem = !MatchPattern(pszValueUC, pColumn->filter.pszText); break; }
LocalFreeString(&pszBuffer); // ensure we don't leak, in thise case it would be costly!
break; }
case PROPERTY_ISBOOL: case PROPERTY_ISNUMBER: { // numeric properties are handled only as ints, therefore
// lets compare the numeric value we have
switch (pColumn->idOperator) { case FILTER_IS: fIncludeItem = (pColumn->filter.iValue == pResult->aColumn[iColumn].iValue); break;
case FILTER_ISNOT: fIncludeItem = (pColumn->filter.iValue != pResult->aColumn[iColumn].iValue); break;
case FILTER_GREATEREQUAL: fIncludeItem = (pColumn->filter.iValue <= pResult->aColumn[iColumn].iValue); break;
case FILTER_LESSEQUAL: fIncludeItem = (pColumn->filter.iValue >= pResult->aColumn[iColumn].iValue); break; }
break; } } } } } Trace(TEXT("fInclude item is %d"), fIncludeItem);
if (fIncludeItem) { // we are going to add the item to the view, so lets hide the banner
// if it is shown, then add a list view item. The list view
// item has text-callback and the lParam -> pResult structure
// we are using.
//
// also, if the view hasn't had the image list set then lets
// take care of that now
if (fBannerShown) { TraceMsg("Adding an item and banner visible, therefore hiding"); _ShowBanner(SWP_HIDEWINDOW, 0); // hide the banner
fBannerShown = FALSE; }
lvi.lParam = (LPARAM)pResult; lvi.iImage = pResult->iImage; ListView_InsertItem(_hwndView, &lvi);
if (i % FILTER_UPDATE_COUNT) UpdateWindow(_hwndView); } } }
// lets update the status bar to reflect the world around us
TraceAssert(_hdpaResults);
if (_hdpaResults) { iVisible = ListView_GetItemCount(_hwndView); iHidden = DPA_GetPtrCount(_hdpaResults)-iVisible; }
if (iVisible <= 0) { _ShowBanner(SWP_SHOWWINDOW, IDS_NOTHINGFOUND); } else { // ensure that at least one item in the view has focus
if (-1 == ListView_GetNextItem(_hwndView, -1, LVNI_FOCUSED)) ListView_SetItemState(_hwndView, 0, LVIS_FOCUSED, LVIS_FOCUSED); } if (SUCCEEDED(FormatMsgResource(&pBuffer, GLOBAL_HINSTANCE, iHidden ? IDS_FOUNDITEMSHIDDEN:IDS_FOUNDITEMS, iVisible, iHidden))) { Trace(TEXT("Setting status text to: %s"), pBuffer); _pqf->SetStatusText(pBuffer); LocalFreeString(&pBuffer); }
_iSortColumn = -1; // sort is no longer valid!
TraceLeaveResult(S_OK); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_FreeResults / --------------------- / Do the tidy up to release the results from the view. This includes / destroying the DPA and removing the items from the list view. / / In: / Out: / - /----------------------------------------------------------------------------*/ VOID CDsQuery::_FreeResults(VOID) { TraceEnter(TRACE_VIEW, "CDsQuery::_FreeResults");
if (IsWindow(_hwndView)) ListView_DeleteAllItems(_hwndView);
if (_hdpaResults) { DPA_DestroyCallback(_hdpaResults, FreeQueryResultCB, IntToPtr(DSA_GetItemCount(_hdsaColumns))); _hdpaResults = NULL; }
LocalFreeString(&_pFilter);
TraceLeave(); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_SetViewMode / --------------------- / Convert the command ID of the view mode into a LVS_ style bit that can / then we applied to the view. / / In: / uID = view mode to be selected / / Out: / DWORD = LVS_ style for this view mode /----------------------------------------------------------------------------*/ DWORD CDsQuery::_SetViewMode(INT uID) { const DWORD dwIdToStyle[] = { LVS_ICON, LVS_SMALLICON, LVS_LIST, LVS_REPORT }; DWORD dwResult = 0; DWORD dwStyle; TraceEnter(TRACE_HANDLER|TRACE_VIEW, "CDsQuery::_SetViewMode"); Trace(TEXT("Setting view mode to %08x"), uID);
_idViewMode = uID; uID -= DSQH_VIEW_LARGEICONS;
if (uID < ARRAYSIZE(dwIdToStyle)) { dwResult = dwIdToStyle[uID];
if (IsWindow(_hwndView)) { dwStyle = GetWindowLong(_hwndView, GWL_STYLE);
if ((dwStyle & LVS_TYPEMASK) != dwResult) { TraceMsg("Changing view style to reflect new mode"); SetWindowLong(_hwndView, GWL_STYLE, (dwStyle & ~LVS_TYPEMASK)|dwResult); } } }
_ShowBanner(0, 0);
TraceLeaveValue(dwResult); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_SetFilter / ------------------- / Sets the visible state of the filter, refreshing the view as required. / / NB: To ensure that the ListView correctly refrehes its contents we first / remove the header from the view, then toggle the filter state / and re-enable the banner. / In: / fFilter = flag indicating the filter state / / Out: / VOID /----------------------------------------------------------------------------*/ VOID CDsQuery::_SetFilter(BOOL fFilter) { TraceEnter(TRACE_HANDLER|TRACE_VIEW, "CDsQuery::_SetFilter");
_fFilter = fFilter; // store the new filter value
if (IsWindow(_hwndView)) { HWND hwndHeader = ListView_GetHeader(_hwndView); DWORD dwStyle = GetWindowLong(hwndHeader, GWL_STYLE) & ~(HDS_FILTERBAR|WS_TABSTOP);
SetWindowLong(_hwndView, GWL_STYLE, GetWindowLong(_hwndView, GWL_STYLE) | LVS_NOCOLUMNHEADER);
if (_fFilter) dwStyle |= HDS_FILTERBAR|WS_TABSTOP;
SetWindowLong(hwndHeader, GWL_STYLE, dwStyle); SetWindowLong(_hwndView, GWL_STYLE, GetWindowLong(_hwndView, GWL_STYLE) & ~LVS_NOCOLUMNHEADER);
_ShowBanner(0, 0);
if (_hdpaResults) { if ((_fFilter && _pFilter) || (!_fFilter && (DPA_GetPtrCount(_hdpaResults) != ListView_GetItemCount(_hwndView)))) { _FilterView(FALSE); } } } TraceLeave(); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_SortResults / --------------------- / Sort the view given a column, handles either being clicked or / invoked on from an API. / / In: / iColumn = column to sort on / / Out: / - /----------------------------------------------------------------------------*/
INT _ResultSortCB(LPARAM lParam1, LPARAM lParam2, LPARAM lParam) { LPQUERYRESULT pResult1, pResult2; INT iColumn = LOWORD(lParam);
// if lParam != 0 then we are reverse sorting, therefore swap
// over the object pointers
if (!HIWORD(lParam)) { pResult1 = (LPQUERYRESULT)lParam1; pResult2 = (LPQUERYRESULT)lParam2; } else { pResult2 = (LPQUERYRESULT)lParam1; pResult1 = (LPQUERYRESULT)lParam2; }
if (pResult1 && pResult2) { LPCOLUMNVALUE pColumn1 = (LPCOLUMNVALUE)&pResult1->aColumn[iColumn]; LPCOLUMNVALUE pColumn2 = (LPCOLUMNVALUE)&pResult2->aColumn[iColumn]; BOOL fHasColumn1 = pColumn1->iPropertyType != PROPERTY_ISUNDEFINED; BOOL fHasColumn2 = pColumn2->iPropertyType != PROPERTY_ISUNDEFINED;
// check that both properties are defined, if they are not then return the
// comparison based on that field. then we check that the properties
// are the same type, if that matches then lets compare based on the
// type.
if (!fHasColumn1 || !fHasColumn2) { return fHasColumn1 ? -1:+1; } else { TraceAssert(pColumn1->iPropertyType == pColumn2->iPropertyType);
switch (pColumn1->iPropertyType) { case PROPERTY_ISUNDEFINED: break;
case PROPERTY_ISUNKNOWN: case PROPERTY_ISSTRING: case PROPERTY_ISDNSTRING: return StrCmpI(pColumn1->pszText, pColumn2->pszText);
case PROPERTY_ISBOOL: case PROPERTY_ISNUMBER: return pColumn1->iValue - pColumn2->iValue; } } } return 0; }
VOID CDsQuery::_SortResults(INT iColumn) { DECLAREWAITCURSOR; TraceEnter(TRACE_VIEW, "CDsQuery::_SortResults"); Trace(TEXT("iColumn %d"), iColumn);
if ((iColumn >= 0) && (iColumn < DSA_GetItemCount(_hdsaColumns))) { // if we have already hit the column then lets invert the sort order,
// there is no indicator to worry about so this should just work out
// fine. if we haven't used this column before then default oto
// ascending, then do the sort!
//
// ensure that the focused item is visible when the sort has completed
if (_iSortColumn == iColumn) _fSortDescending = !_fSortDescending; else _fSortDescending = FALSE;
_iSortColumn = iColumn;
Trace(TEXT("Sorting on column %d, %s"), _iSortColumn, _fSortDescending ? TEXT("(descending)"):TEXT("(ascending)"));
SetWaitCursor(); ListView_SortItems(_hwndView, _ResultSortCB, MAKELPARAM(_iSortColumn, _fSortDescending)); ResetWaitCursor(); }
TraceLeave(); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_ShowBanner / -------------------- / Show the views banner, including sizing it to obscure only the top section / of the window. / / In: / uFlags = flags to combine when calling SetWindowPos / idPrompt = resource ID of prompt text ot be displayed / / Out: / - /----------------------------------------------------------------------------*/ VOID CDsQuery::_ShowBanner(UINT uFlags, UINT idPrompt) { HRESULT hr; WINDOWPOS wpos; RECT rcClient; HD_LAYOUT hdl; TCHAR szBuffer[MAX_PATH];
TraceEnter(TRACE_VIEW, "CDsQuery::_ShowBanner");
// if we have a resource id then lets load the string and
// set the window text to have it
if (idPrompt) { LoadString(GLOBAL_HINSTANCE, idPrompt, szBuffer, ARRAYSIZE(szBuffer)); SetWindowText(_hwndBanner, szBuffer); }
// now position the window back to real location, this we need to
// talk to the listview/header control to work out exactly where it
// should be living
GetClientRect(_hwndView, &rcClient);
if ((GetWindowLong(_hwndView, GWL_STYLE) & LVS_TYPEMASK) == LVS_REPORT) { TraceMsg("Calling header for layout information");
wpos.hwnd = ListView_GetHeader(_hwndView); wpos.hwndInsertAfter = NULL; wpos.x = 0; wpos.y = 0; wpos.cx = rcClient.right; wpos.cy = rcClient.bottom; wpos.flags = SWP_NOZORDER;
hdl.prc = &rcClient; hdl.pwpos = &wpos;
if (!Header_Layout(wpos.hwnd, &hdl)) ExitGracefully(hr, E_FAIL, "Failed to get the layout information (HDM_LAYOUT)"); }
SetWindowPos(_hwndBanner, HWND_TOP, rcClient.left, rcClient.top, rcClient.right - rcClient.left, 100, uFlags);
exit_gracefully:
TraceLeave(); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_InitViewMenuItems / --------------------------- / Setup the view menu based on the given view mode and the filter state, enabled / disable the items as required. / / In: / hMenu = menu to set the menu items on / / Out: / - /----------------------------------------------------------------------------*/ VOID CDsQuery::_InitViewMenuItems(HMENU hMenu) { MENUITEMINFO mii; HMENU hArrangeMenu; BOOL fHaveView = IsWindow(_hwndView); INT i;
TraceEnter(TRACE_HANDLER|TRACE_VIEW, "CDsQuery::_InitViewMenuItems");
CheckMenuItem(hMenu, DSQH_VIEW_FILTER, MF_BYCOMMAND| (_fFilter ? MF_CHECKED:0)); ENABLE_MENU_ITEM(hMenu, DSQH_VIEW_FILTER, fHaveView && _fFilterSupported && (_idViewMode == DSQH_VIEW_DETAILS));
CheckMenuRadioItem(hMenu, DSQH_VIEW_LARGEICONS, DSQH_VIEW_DETAILS, _idViewMode, MF_BYCOMMAND);
// construct the arrange menu, add it to the view menu that we have been given.
hArrangeMenu = CreatePopupMenu(); TraceAssert(hArrangeMenu);
if (_hdsaColumns && DSA_GetItemCount(_hdsaColumns)) { TCHAR szFmt[32]; TCHAR szBuffer[MAX_PATH]; hArrangeMenu = CreatePopupMenu(); TraceAssert(hArrangeMenu);
LoadString(GLOBAL_HINSTANCE, IDS_ARRANGEBY, szFmt, ARRAYSIZE(szFmt));
if (hArrangeMenu) { for (i = 0 ; i < DSA_GetItemCount(_hdsaColumns); i++) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(_hdsaColumns, i); TraceAssert(pColumn); // NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(szBuffer, szFmt, pColumn->pHeading); InsertMenu(hArrangeMenu, i, MF_STRING|MF_BYPOSITION, DSQH_VIEW_ARRANGEFIRST+i, szBuffer); }
} }
// now place the arrange menu into the view and ungrey as required.
ZeroMemory(&mii, SIZEOF(mii)); mii.cbSize = SIZEOF(mii); mii.fMask = MIIM_SUBMENU|MIIM_ID; mii.hSubMenu = hArrangeMenu; mii.wID = DSQH_VIEW_ARRANGEICONS; if (SetMenuItemInfo(hMenu, DSQH_VIEW_ARRANGEICONS, FALSE, &mii)) { ENABLE_MENU_ITEM(hMenu, DSQH_VIEW_ARRANGEICONS, fHaveView && GetMenuItemCount(hArrangeMenu)); hArrangeMenu = NULL; }
if (hArrangeMenu) DestroyMenu(hArrangeMenu);
TraceLeave(); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_GetQueryFormKey / -------------------------- / Given the CLSID for the query form we are interested in, get the / forms key for it, note that these settings are stored per-user. / / In: / clsidForm = CLSID of form to pick up / phKey -> recevies the HKEY of the form we are intersted in. / / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::_GetQueryFormKey(REFCLSID clsidForm, HKEY* phKey) { HRESULT hr; TCHAR szGUID[GUIDSTR_MAX]; TCHAR szBuffer[MAX_PATH];
TraceEnter(TRACE_VIEW, "CDsQuery::_GetQueryFormKey");
GetStringFromGUID(clsidForm, szGUID, ARRAYSIZE(szGUID)); // NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(szBuffer, TEXT("Software\\Microsoft\\Windows\\CurrentVersion\\Directory UI\\QueryForms\\%s"), szGUID); Trace(TEXT("Settings key is: %s"), szBuffer);
if (ERROR_SUCCESS != RegCreateKey(HKEY_CURRENT_USER, szBuffer, phKey)) ExitGracefully(hr, E_FAIL, "Failed to open settings key");
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_GetColumnTable / ------------------------ / Build the column table for the view we are about to display. The column / table is constructed from either the query parameters or the persisted / column settings stored in the registry. / / In: / clsidForm = clisd of the form to be used / pDsQueryParams -> query parameter structure to be used / pHDSA -> DSA to recieve the column table (sorted by visible order) / fSetInView = Set the columns into the view / / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::_GetColumnTable(REFCLSID clsidForm, LPDSQUERYPARAMS pDsQueryParams, HDSA* pHDSA, BOOL fSetInView) { HRESULT hr; HKEY hKey = NULL; BOOL fDefaultSettings = TRUE; LPSAVEDCOLUMN aSavedColumn = NULL; LPTSTR pSettingsValue = VIEW_SETTINGS_VALUE; BOOL fHaveSizeInfo = FALSE; LPWSTR pPropertyG; DWORD dwType, cbSize; LV_COLUMN lvc; SIZE sz; INT i, iNewColumn; HD_ITEM hdi; IDsDisplaySpecifier *pdds = NULL;
TraceEnter(TRACE_VIEW, "CDsQuery::_GetColumnTable"); TraceGUID("clsidForm ", clsidForm); Trace(TEXT("pDsQueryParams %08x, pHDSA %08x"), pDsQueryParams, pHDSA);
DECLAREWAITCURSOR; SetWaitCursor();
if (!pHDSA) ExitGracefully(hr, E_INVALIDARG, "Bad pDsQueryParams / pHDSA");
// construct the column DSA then attempt to look up the view settings stored in
// the registry for the current form.
*pHDSA = DSA_Create(SIZEOF(COLUMN), 16); TraceAssert(*pHDSA);
if (!*pHDSA) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to construct the column DSA");
// If invoked for admin UI then we look at the admin view settings, this way
// the admin can have one set of columns, and the user can have another.
if (_dwFlags & DSQPF_ENABLEADMINFEATURES) pSettingsValue = ADMIN_VIEW_SETTINGS_VALUE;
Trace(TEXT("View settings value: %s"), pSettingsValue);
if (SUCCEEDED(_GetQueryFormKey(clsidForm, &hKey))) { // we have the handle to the forms sub-key table, now lets check and
// see what size the view settings stream is.
if ((ERROR_SUCCESS == RegQueryValueEx(hKey, pSettingsValue, NULL, &dwType, NULL, &cbSize)) && (dwType == REG_BINARY) && (cbSize > SIZEOF(SAVEDCOLUMN))) { Trace(TEXT("Reading view settings from registry (size %d)"), cbSize); aSavedColumn = (LPSAVEDCOLUMN)LocalAlloc(LPTR, cbSize); TraceAssert(aSavedColumn);
if (aSavedColumn && (ERROR_SUCCESS == RegQueryValueEx(hKey, pSettingsValue, NULL, NULL, (LPBYTE)aSavedColumn, &cbSize))) { // compute the size of the table from the values that we have
// read from the registry and now lets allocate a table for it
for (i = 0; aSavedColumn[i].cbSize; i++) { COLUMN column = { 0 }; LPCWSTR pPropertyL = (LPCWSTR)ByteOffset(aSavedColumn, aSavedColumn[i].offsetProperty); LPCTSTR pHeading = (LPCTSTR)ByteOffset(aSavedColumn, aSavedColumn[i].offsetHeading);
hr = LocalAllocStringW(&column.pProperty, pPropertyL); FailGracefully(hr, "Failed to allocate property name");
hr = LocalAllocString(&column.pHeading, pHeading); FailGracefully(hr, "Failed to allocate column heading");
//column.fHasColumnProvider = FALSE;
column.cx = aSavedColumn[i].cx; column.fmt = aSavedColumn[i].fmt; column.iPropertyType = PROPERTY_ISUNKNOWN; //column.idOperator = 0;
//column.clsidColumnHandler = { 0 };
//column.pColumnHandler = NULL;
ZeroMemory(&column.filter, SIZEOF(column.filter)); column.filter.iPropertyType = PROPERTY_ISUNDEFINED;
Trace(TEXT("pProperty: '%s', pHeading: '%s', cx %d, fmt %08x"), column.pProperty, column.pHeading, column.cx, column.fmt);
if (-1 == DSA_AppendItem(*pHDSA, &column)) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to add column to the DSA"); }
fDefaultSettings = FALSE; // success we have a table
} } }
if (fDefaultSettings) { // unable to read the settings from the registy, therefore defaulting to
// those defined in the query parameters block.
if (!pDsQueryParams) ExitGracefully(hr, E_INVALIDARG, "No DSQUERYPARAMs to default using");
for (i = 0 ; i < pDsQueryParams->iColumns; i++) { COLUMN column = { 0 };
switch (pDsQueryParams->aColumns[i].offsetProperty) { case DSCOLUMNPROP_ADSPATH: pPropertyG = c_szADsPathCH; break; case DSCOLUMNPROP_OBJECTCLASS: pPropertyG = c_szObjectClassCH; break;
default: pPropertyG = (LPWSTR)ByteOffset(pDsQueryParams, pDsQueryParams->aColumns[i].offsetProperty); break; }
hr = LocalAllocStringW(&column.pProperty, pPropertyG); FailGracefully(hr, "Failed to allocate property name");
hr = FormatMsgResource(&column.pHeading, pDsQueryParams->hInstance, pDsQueryParams->aColumns[i].idsName); FailGracefully(hr, "Failed to allocate column heading");
//column.fHasColumnProvider = FALSE;
column.cx = pDsQueryParams->aColumns[i].cx; column.fmt = pDsQueryParams->aColumns[i].fmt; column.iPropertyType = PROPERTY_ISUNKNOWN; //column.idOperator = 0;
//column.clsidColumnHandler = { 0 };
//column.pColumnHandler = NULL;
ZeroMemory(&column.filter, SIZEOF(column.filter)); column.filter.iPropertyType = PROPERTY_ISUNDEFINED;
// Now fix the width of the column we are about to specify, this
// value has the following meaning:
//
// == 0 => use default width
// > 0 => user 'n' magic characters
// < 0 => pixel width
// FEATURE: -ve should be % of the view
if (column.cx < 0) { TraceMsg("Column width specified in pixels"); column.cx = -column.cx; } else { // Default the size if it is == 0, then having done this
// lets grab the font we want to use before moving on
// to create a DC and measure the character we need.
if (!column.cx) column.cx = DEFAULT_WIDTH;
sz.cx = 10; // random default value.
if (!fHaveSizeInfo) { HDC hDC; LOGFONT lf; HFONT hFont, hOldFont;
SystemParametersInfo(SPI_GETICONTITLELOGFONT, SIZEOF(lf), &lf, FALSE);
hFont = CreateFontIndirect(&lf); // icon title font
if (hFont) { hDC = CreateCompatibleDC(NULL); // screen compatible DC
if (hDC) { hOldFont = (HFONT)SelectObject(hDC, hFont); GetTextExtentPoint(hDC, TEXT("0"), 1, &sz); SelectObject(hDC, hOldFont); DeleteDC(hDC); } DeleteFont(hFont); }
fHaveSizeInfo = TRUE; }
column.cx = column.cx*sz.cx; // n chars width
}
Trace(TEXT("pProperty: '%s', pHeading: '%s', cx %d, fmt %08x"), column.pProperty, column.pHeading, column.cx, column.fmt);
if (-1 == DSA_AppendItem(*pHDSA, &column)) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to add column to the DSA"); } }
// Scan the column list getting both the property name and the CLSID for the
// column handler (if there is one).
hr = CoCreateInstance(CLSID_DsDisplaySpecifier, NULL, CLSCTX_INPROC_SERVER, IID_IDsDisplaySpecifier, (void **)&pdds); FailGracefully(hr, "Failed to get the IDsDisplaySpecifier interface");
if ( _dwFlags & DSQPF_HASCREDENTIALS) { hr = pdds->SetServer(_pServer, _pUserName, _pPassword, DSSSF_DSAVAILABLE); FailGracefully(hr, "Failed to server information"); }
for (i = 0 ; i < DSA_GetItemCount(*pHDSA) ; i++) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(*pHDSA, i); TraceAssert(pColumn);
Trace(TEXT("Property for column %d, %s"), i, pColumn->pProperty);
// lets get the property type, column handler and the default operator for it.
hr = GetColumnHandlerFromProperty(pColumn, NULL); FailGracefully(hr, "Failed to get the column handler from property string");
if (pColumn->fHasColumnHandler) { TraceMsg("Has a column handler, therefore property is now a string"); pColumn->iPropertyType = PROPERTY_ISSTRING; } else { pColumn->iPropertyType = PropertyIsFromAttribute(pColumn->pProperty, pdds); }
pColumn->idOperator = property_type_table[pColumn->iPropertyType].idOperator; }
// Set the columns up in the view (remove all items first) to allow us
// to add/remove columns as required.
if (fSetInView) { for (i = Header_GetItemCount(ListView_GetHeader(_hwndView)); --i >= 0 ;) ListView_DeleteColumn(_hwndView, i);
// add the columns to the view, then having done that set
// the type of the filter to reflect the property being
// shown.
for (i = 0 ; i < DSA_GetItemCount(_hdsaColumns); i++) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(_hdsaColumns, i); TraceAssert(pColumn); lvc.mask = LVCF_TEXT|LVCF_WIDTH|LVCF_FMT; lvc.fmt = pColumn->fmt; lvc.cx = pColumn->cx; lvc.pszText = pColumn->pHeading; iNewColumn = ListView_InsertColumn(_hwndView, i, &lvc); TraceAssert(iNewColumn != -1);
if (iNewColumn != i) ExitGracefully(hr, E_FAIL, "Failed to add the column to the view");
hdi.mask = HDI_FILTER; hdi.type = property_type_table[pColumn->iPropertyType].hdft|HDFT_HASNOVALUE; hdi.pvFilter = NULL;
Trace(TEXT("iPropertyType %d, hdi.type %08x"), pColumn->iPropertyType, hdi.type);
if (!Header_SetItem(ListView_GetHeader(_hwndView), iNewColumn, &hdi)) ExitGracefully(hr, E_FAIL, "Failed to set the filter type into the view"); } }
hr = S_OK; // success
exit_gracefully:
if (hKey) RegCloseKey(hKey);
if (aSavedColumn) LocalFree((HLOCAL)aSavedColumn);
DoRelease(pdds); ResetWaitCursor();
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_SaveColumnTable / ------------------------- / Free the column table stored in a DSA. This code released all the / allocated memory stored with the table. / / In: / Out: / - /----------------------------------------------------------------------------*/ VOID CDsQuery::_SaveColumnTable(VOID) { TraceEnter(TRACE_VIEW, "CDsQuery::_SaveColumnTable");
_FreeResults();
if (_hdsaColumns) { DSA_DestroyCallback(_hdsaColumns, FreeColumnCB, NULL); _hdsaColumns = NULL; }
_iSortColumn = -1; _fSortDescending = FALSE;
TraceLeave(); }
/*-----------------------------------------------------------------------------
/ CDsQuery::_SaveColumnTable / ------------------------- / Save the current column table from the DPA into the registry so / we can restore it the next time the user uses this query form. / / In: / clsidForm = form ID to store it under / hdsaColumns -> DSA to destory / / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::_SaveColumnTable(REFCLSID clsidForm, HDSA hdsaColumns) { HRESULT hr; LPWSTR pProperty; LPSAVEDCOLUMN aSavedColumn = NULL; DWORD cbData, offset; HKEY hKey = NULL; LPTSTR pSettingsValue = VIEW_SETTINGS_VALUE; INT i; TraceEnter(TRACE_VIEW, "CDsQuery::_SaveColumnTable"); TraceGUID("clsidForm ", clsidForm); if (!hdsaColumns) ExitGracefully(hr, E_FAIL, "No column data to save");
// first compute the size of the blob we are going to store into
// the registry, whilst doing this compute the offset to
// the start of the string data.
offset = SIZEOF(SAVEDCOLUMN); cbData = SIZEOF(SAVEDCOLUMN);
for (i = 0 ; i < DSA_GetItemCount(hdsaColumns); i++) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(hdsaColumns, i); TraceAssert(pColumn);
offset += SIZEOF(SAVEDCOLUMN); cbData += SIZEOF(SAVEDCOLUMN); cbData += StringByteSizeW(pColumn->pProperty);
// this is a potential problem, must be kept in sync with GetPropertyFromColumn
if (pColumn->fHasColumnHandler) cbData += SIZEOF(WCHAR)*(GUIDSTR_MAX + 1); // nb+1 for seperator (,} + string is UNICODE
cbData += StringByteSize(pColumn->pHeading); }
Trace(TEXT("offset %d, cbData %d"), offset, cbData);
// Allocate the structure and lets place all the data into it,
// again running over the data blocks, append the string data
// to the end of the blob in a single go.
aSavedColumn = (LPSAVEDCOLUMN)LocalAlloc(LPTR, cbData); TraceAssert(aSavedColumn);
if (!aSavedColumn) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate settings data");
Trace(TEXT("Building data blob at %08x"), aSavedColumn);
for (i = 0 ; i < DSA_GetItemCount(hdsaColumns); i++) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(hdsaColumns, i); TraceAssert(pColumn); hr = GetPropertyFromColumn(&pProperty, pColumn); FailGracefully(hr, "Failed to allocate property from column");
aSavedColumn[i].cbSize = SIZEOF(SAVEDCOLUMN); aSavedColumn[i].dwFlags = 0; aSavedColumn[i].offsetProperty = offset; aSavedColumn[i].offsetHeading = offset + StringByteSizeW(pProperty); aSavedColumn[i].cx = pColumn->cx; aSavedColumn[i].fmt = pColumn->fmt; StringByteCopyW(aSavedColumn, aSavedColumn[i].offsetProperty, pProperty); offset += StringByteSizeW(pProperty);
StringByteCopy(aSavedColumn, aSavedColumn[i].offsetHeading, pColumn->pHeading); offset += StringByteSize(pColumn->pHeading);
LocalFreeStringW(&pProperty); }
aSavedColumn[i].cbSize = 0; // terminate the list of columns with a NULL
Trace(TEXT("offset %d, cbData %d"), offset, cbData); TraceAssert(offset == cbData);
// now put the data into the registry filed under the key for the query for that
// it maps to.
hr = _GetQueryFormKey(clsidForm, &hKey); FailGracefully(hr, "Failed to get settings sub-key");
// If invoked for admin UI then we look at the admin view settings, this way
// the admin can have one set of columns, and the user can have another.
if (_dwFlags & DSQPF_ENABLEADMINFEATURES) pSettingsValue = ADMIN_VIEW_SETTINGS_VALUE;
Trace(TEXT("View settings value: %s"), pSettingsValue);
if (ERROR_SUCCESS != RegSetValueEx(hKey, pSettingsValue, 0, REG_BINARY, (LPBYTE)aSavedColumn, cbData)) ExitGracefully(hr, E_FAIL, "Failed to write setting into the view");
hr = S_OK;
exit_gracefully:
if (aSavedColumn) LocalFree((HLOCAL)aSavedColumn);
if (hKey) RegCloseKey(hKey);
TraceLeaveResult(hr); }
// retrieve the context menu object
HRESULT _FolderCFMCallback(LPSHELLFOLDER psf, HWND hwndView, LPDATAOBJECT pDataObject, UINT uMsg, WPARAM wParam, LPARAM lParam) { Trace(TEXT("uMsg %d, wParam %08x, lParam %08x"), uMsg, wParam, lParam); switch (uMsg) { case DFM_MERGECONTEXTMENU: return S_OK;
case DFM_INVOKECOMMAND: switch (wParam) { case (WPARAM)DFM_CMD_PROPERTIES: TraceMsg("ShowProperties"); return ShowObjectProperties(hwndView, pDataObject);
default: return S_FALSE; } break;
case DFM_GETDEFSTATICID: *((WPARAM*)lParam) = (WPARAM)DFM_CMD_PROPERTIES; return NOERROR; } return E_NOTIMPL; }
HRESULT CDsQuery::_GetContextMenu() { ITEMIDLIST idl = {0}; LPITEMIDLIST *aidl = NULL; HKEY aKeys[UIKEY_MAX] = { 0 };
int cItems = ListView_GetSelectedCount(_hwndView); if (cItems != 0) { // try to get the selected item (there is one, so first we try the focused, then the selected)
int i = ListView_GetNextItem(_hwndView, -1, LVNI_FOCUSED|LVNI_SELECTED); if (i == -1) i = ListView_GetNextItem(_hwndView, -1, LVNI_SELECTED);
// given the item lets get the result object so that we can create the menu based on
// the right class information
LV_ITEM lvi = { 0 }; lvi.mask = LVIF_PARAM; lvi.iItem = i;
if (ListView_GetItem(_hwndView, &lvi)) { LPQUERYRESULT pResult = (LPQUERYRESULT)lvi.lParam; GetKeysForClass(pResult->pObjectClass, pResult->fIsContainer, ARRAYSIZE(aKeys), aKeys); } aidl = (LPITEMIDLIST*)LocalAlloc(LPTR, sizeof(LPITEMIDLIST)*cItems); }
// given that we probably have the keys we are interested in,
// lets now create the context menu.
DoRelease(_pcm); // release the previous context menu
HRESULT hr = E_OUTOFMEMORY; if (!cItems|| (cItems && aidl)) { // fake up the array of IDLISTs so that they can be cloned correctly from
// the view.
for (int i= 0 ; i < cItems ; i++) aidl[i] = &idl;
hr = CDefFolderMenu_Create2(&idl, _hwnd, cItems, (LPCITEMIDLIST*)aidl, this, _FolderCFMCallback, ARRAYSIZE(aKeys), aKeys, &_pcm); }
if (aidl) LocalFree(aidl);
if (FAILED(hr)) TidyKeys(ARRAYSIZE(aKeys), aKeys);
return hr; }
/*-----------------------------------------------------------------------------
/ CDsQuery::_GetContextMenuVerbs / ----------------------------- / Do the query context menu handling the case where we have been invoked / modally. / / In: / hMenu = menu handle to merge into / dwFlags = flags for QueryContextMenu / / Out: / VOID /----------------------------------------------------------------------------*/ VOID CDsQuery::_GetContextMenuVerbs(HMENU hMenu, DWORD dwFlags) { TCHAR szBuffer[MAX_PATH];
TraceEnter(TRACE_VIEW, "CDsQuery::_GetContextMenuVerbs");
_pcm->QueryContextMenu(hMenu, 0, DSQH_FILE_CONTEXT_FIRST, DSQH_FILE_CONTEXT_LAST, dwFlags); Trace(TEXT("Menu item count after QueryContextMenu %d (%08x)"), GetMenuItemCount(hMenu), hMenu);
if ((_dwOQWFlags & OQWF_OKCANCEL) && LoadString(GLOBAL_HINSTANCE, IDS_SELECT, szBuffer, ARRAYSIZE(szBuffer))) { InsertMenu(hMenu, 0, MF_BYPOSITION|MF_STRING, DSQH_BG_SELECT, szBuffer); InsertMenu(hMenu, 1, MF_BYPOSITION|MF_SEPARATOR, 0, NULL); SetMenuDefaultItem(hMenu, DSQH_BG_SELECT, FALSE); }
// NTRAID#NTBUG9-598730-2002/05/23-artm
// Disable property pages when multiple items are selected.
BOOL enableProperties = ListView_GetSelectedCount(_hwndView) == 1;
ENABLE_MENU_ITEM(hMenu, DSQH_FILE_PROPERTIES, enableProperties); ENABLE_MENU_ITEM(hMenu, DSQH_FILE_CONTEXT_FIRST + SHARED_FILE_PROPERTIES, enableProperties);
TraceLeave(); }
// get the items in the view into a IDataObject, the caller can request either the
// selection or all the items
HRESULT CDsQuery::_AddResultToDataObject(HDSA hdsa, INT i) { LV_ITEM lvi = { 0 }; lvi.mask = LVIF_PARAM; lvi.iItem = i;
HRESULT hr = E_FAIL; if (ListView_GetItem(_hwndView, &lvi)) { QUERYRESULT *pResult = (QUERYRESULT*)lvi.lParam; DATAOBJECTITEM doi = {0}; // copy the strings for the item into the structure
hr = LocalAllocStringW(&doi.pszPath, pResult->pPath); if (SUCCEEDED(hr) && pResult->pObjectClass) hr = LocalAllocStringW(&doi.pszObjectClass, pResult->pObjectClass);
// copy the rest of the state
doi.fIsContainer = pResult->fIsContainer;
// append to the DSA.
if (SUCCEEDED(hr)) { if (-1 == DSA_AppendItem(hdsa, &doi)) { LocalFreeStringW(&doi.pszPath); LocalFreeStringW(&doi.pszObjectClass); hr = E_OUTOFMEMORY; } else { hr = S_OK; } } }
return hr; }
HRESULT CDsQuery::_GetDataObjectFromSelection(BOOL fGetAll, IDataObject **ppdo) { HRESULT hr = S_OK;
HDSA hdsa = DSA_Create(SIZEOF(DATAOBJECTITEM), 16); if (hdsa) { // focused item always come first (primary selection rulz).
int iFocused = ListView_GetNextItem(_hwndView, -1, LVNI_ALL|LVNI_SELECTED|LVNI_FOCUSED); if (iFocused > -1) { hr = _AddResultToDataObject(hdsa, iFocused); }
// now walk all the items in the view collecting the selection and adding
// those items to the DPA - we must skip the item which is focused as we
// have already added it.
if (SUCCEEDED(hr)) { int i = -1; do { i = ListView_GetNextItem(_hwndView, i, LVNI_ALL|LVNI_SELECTED); if ((i >= 0) && (i != iFocused)) { hr = _AddResultToDataObject(hdsa, i); } } while (SUCCEEDED(hr) && (i != -1)); }
// given the DPA lets build an IDataObject using it.
hr = CDataObject_CreateInstance(hdsa, (_dwFlags & DSQPF_ENABLEADVANCEDFEATURES), IID_IDataObject, (void**)ppdo); if (SUCCEEDED(hr)) hr = _SetDispSpecOptions(*ppdo); } else { hr = E_OUTOFMEMORY; }
if (FAILED(hr) && hdsa) FreeDataObjectDSA(hdsa); // data object failed to construct, lets kill the DSA
return hr; }
/*-----------------------------------------------------------------------------
/ CDsQuery::_CopyCredentials / -------------------------- / Copy the user name, password and server as required. / / In: / ppszUserName, psszPassword & ppszServer => destinations / / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT CDsQuery::_CopyCredentials(LPWSTR *ppszUserName, LPWSTR *ppszPassword, LPWSTR *ppszServer) { HRESULT hr;
TraceEnter(TRACE_VIEW, "CDsQuery::_CopyCredentials");
hr = LocalAllocStringW(ppszUserName, _pUserName); FailGracefully(hr, "Failed to copy the user name");
hr = LocalAllocStringW(ppszPassword, _pPassword); FailGracefully(hr, "Failed to copy the password");
hr = LocalAllocStringW(ppszServer, _pServer); FailGracefully(hr, "Failed to copy the server name");
exit_gracefully:
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ CDsQuery::OnPickColumns /----------------------------------------------------------------------------*/
typedef struct { LPWSTR pProperty; LPTSTR pHeading; BOOL fIsColumn; // item is column and added to column list box on init
INT cx; // pixel width of column
INT fmt; // formatting information of column
} PICKERITEM, * LPPICKERITEM;
typedef struct { HDPA hdpaItems; // all the items in the view
HDSA hdsaColumns; // column table generated by this dialog
HWND hwndProperties; // hwnd's for the columns/property tables
HWND hwndColumns; } PICKERSTATE, * LPPICKERSTATE;
VOID _PickerMoveColumn(HWND hwndDest, HWND hwndSrc, BOOL fInsert); HRESULT _Picker_GetColumnTable(HWND hwndColumns, HDSA* pHDSA); INT_PTR _PickerDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); INT _PickerItemFreeCB(LPVOID pData, LPVOID lParam); INT _PickerItemCmpCB(LPVOID p1, LPVOID p2, LPARAM lParam);
//
// Help ID mappings
//
static DWORD const aPickColumnsHelpIDs[] = { IDC_LBPROPERTIES, IDH_COLUMNS_AVAILABLE, IDC_LBCOLUMNS, IDH_COLUMNS_SHOWN, IDC_ADD, IDH_ADD_COLUMNS, IDC_REMOVE, IDH_REMOVE_COLUMNS, 0, 0 };
/*-----------------------------------------------------------------------------
/ _PickerMoveColumn / ----------------- / Move the selected item in one list box to another, we assume that the / item data points to a PICKERITEM structure, we transfer the selection / and / / In: / hwndSrc, hwndState = windows to move selection within / fInsert = insert at selection point in destionation, or add the string (sorted) / / Out: / VOID /----------------------------------------------------------------------------*/ VOID _PickerMoveColumn(HWND hwndDest, HWND hwndSrc, BOOL fInsert) { INT iSelection, i;
TraceEnter(TRACE_FIELDCHOOSER, "_PickerMoveColumn");
iSelection = ListBox_GetCurSel(hwndSrc); TraceAssert(iSelection >= 0);
if (iSelection >= 0) { LPPICKERITEM pItem = (LPPICKERITEM)ListBox_GetItemData(hwndSrc, iSelection); TraceAssert(pItem); TraceAssert(pItem->pHeading);
// Add the new item to the view (if this it the properties)
// then this will result in the list being sorted and select
// it to allow the user to remove/add another
if (fInsert) { Trace(TEXT("Inserting the item at index %d"), ListBox_GetCurSel(hwndDest)+1); i = ListBox_InsertString(hwndDest, ListBox_GetCurSel(hwndDest)+1, pItem->pHeading); } else { TraceMsg("Adding string to listbox"); i = ListBox_AddString(hwndDest, pItem->pHeading); }
TraceAssert(i != -1);
ListBox_SetItemData(hwndDest, i, (LPARAM)pItem); ListBox_SetCurSel(hwndDest, i);
// remove the item from the source, ensuring that the
// selection stays visually at the same place (nb
// cope with removing the last item).
ListBox_DeleteString(hwndSrc, iSelection);
if (iSelection >= ListBox_GetCount(hwndSrc)) iSelection = ListBox_GetCount(hwndSrc)-1; if (iSelection >= 0) ListBox_SetCurSel(hwndSrc, iSelection); }
TraceLeave(); }
/*-----------------------------------------------------------------------------
/ _Picker_GetColumnTable / --------------------- / The user has hit OK, therefore we must build a new column table, this / code walks the items in the columns ListBox and generates the / column DSA that we should be using. / / In: / hwndColumns -> ListBox containing the columns / pHDSA -> DSA to receive the columnt able / / Out: / HRESULT /----------------------------------------------------------------------------*/ HRESULT _Picker_GetColumnTable(HWND hwndColumns, HDSA* pHDSA) { HRESULT hr; HDSA hdsaColumns = NULL; INT i; INT cxColumn = 0;
TraceEnter(TRACE_FIELDCHOOSER, "_Picker_GetColumnTable");
// Construct a DSA to store the column table in
hdsaColumns = DSA_Create(SIZEOF(COLUMN), 4); TraceAssert(hdsaColumns);
if (!hdsaColumns) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to create the column DSA");
// For each entry in the ListBox add an item to the DSA that contains
// the relevant column information
for (i = 0 ; i < ListBox_GetCount(hwndColumns) ; i++) { COLUMN column = { 0 }; LPPICKERITEM pItem = (LPPICKERITEM)ListBox_GetItemData(hwndColumns, i); TraceAssert(pItem);
// column.fHasColumnHandler = FALSE;
column.pProperty = NULL; column.pHeading = NULL; //column.cx = 0;
//column.fmt = 0;
column.iPropertyType = PROPERTY_ISUNKNOWN; column.idOperator = 0; // column.clsidColumnHandler = { 0 };
// column.pColumnHandler = NULL;
// fIsColumn indicates that the entry was originally a column therefore
// has extra state information, ensure that we copy this over, otherwise
// just pick sensible defaults. Having done that we can allocate the
// strings, add the item and continue...
if (pItem->fIsColumn) { column.cx = pItem->cx; column.fmt = pItem->fmt; } else { // Have we cached the column width yet? If not then lets do
// so and apply it to all the columns which are using the
// default width (as they have not yet been sized)
if (!cxColumn) { HDC hDC; LOGFONT lf; HFONT hFont, hOldFont; SIZE sz;
sz.cx = 10; // random default value.
SystemParametersInfo(SPI_GETICONTITLELOGFONT, SIZEOF(lf), &lf, FALSE);
hFont = CreateFontIndirect(&lf); // icon title font
if (hFont) { hDC = CreateCompatibleDC(NULL); // screen compatible DC
if (hDC) { hOldFont = (HFONT)SelectObject(hDC, hFont); GetTextExtentPoint(hDC, TEXT("0"), 1, &sz); SelectObject(hDC, hOldFont); DeleteDC(hDC); } DeleteObject(hFont); }
cxColumn = DEFAULT_WIDTH * sz.cx; }
column.cx = cxColumn; column.fmt = 0; }
if (FAILED(GetColumnHandlerFromProperty(&column, pItem->pProperty)) || FAILED(LocalAllocString(&column.pHeading, pItem->pHeading)) || (-1 == DSA_AppendItem(hdsaColumns, &column))) { LocalFreeStringW(&column.pProperty); LocalFreeString(&column.pHeading); ExitGracefully(hr, E_OUTOFMEMORY, "Failed to construct the column entry"); } }
Trace(TEXT("New column table contains %d items"), DSA_GetItemCount(hdsaColumns)); hr = S_OK;
exit_gracefully:
if (FAILED(hr) && hdsaColumns) { DSA_DestroyCallback(hdsaColumns, FreeColumnCB, NULL); hdsaColumns = NULL; }
*pHDSA = hdsaColumns;
TraceLeaveResult(hr); }
/*-----------------------------------------------------------------------------
/ _PickerDlgProc / -------------- / Dialog proc for handling the dialog messages (there is a suprise) / / In: / hwnd, uMsg, wParam, lParam = message information / DWL_USER => LPPICKERSTATE structure / / Out: / INT_PTR /----------------------------------------------------------------------------*/
#define SET_BTN_STYLE(hwnd, idc, style) \
SendDlgItemMessage(hwnd, idc, BM_SETSTYLE, MAKEWPARAM(style, 0), MAKELPARAM(TRUE, 0));
INT_PTR _PickerDlgProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { INT_PTR fResult = FALSE; LPPICKERSTATE pState = NULL; BOOL fUpdateButtonState = TRUE; PICKERITEM item; INT i, j;
if (uMsg == WM_INITDIALOG) { pState = (LPPICKERSTATE)lParam; TraceAssert(pState);
SetWindowLongPtr(hwnd, DWLP_USER, lParam);
pState->hwndProperties = GetDlgItem(hwnd, IDC_LBPROPERTIES); pState->hwndColumns = GetDlgItem(hwnd, IDC_LBCOLUMNS);
// pState->hdsaColumns contains the currently visible column table, this is
// the table being used by the current view, therefore we must not modify
// it, just treat it as read only. Add the columns to the ListBox
// marking the visible items in the properties DPA, then add those
// items not already shown to the properties list box.
for (i = 0 ; i < DSA_GetItemCount(pState->hdsaColumns) ; i++) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(pState->hdsaColumns, i); TraceAssert(pColumn);
if (SUCCEEDED(GetPropertyFromColumn(&item.pProperty, pColumn))) { j = DPA_Search(pState->hdpaItems, &item, 0, _PickerItemCmpCB, NULL, DPAS_SORTED);
Trace(TEXT("Searching for %s yielded %d"), item.pProperty, j);
if (j >= 0) { LPPICKERITEM pItem = (LPPICKERITEM)DPA_GetPtr(pState->hdpaItems, j); TraceAssert(pItem);
ListBox_SetItemData(pState->hwndColumns, ListBox_AddString(pState->hwndColumns, pItem->pHeading), (LPARAM)pItem); } LocalFreeStringW(&item.pProperty); } }
for (i = 0 ; i < DPA_GetPtrCount(pState->hdpaItems) ; i++) { LPPICKERITEM pItem = (LPPICKERITEM)DPA_GetPtr(pState->hdpaItems, i); TraceAssert(pItem && pItem->pHeading);
if (!pItem->fIsColumn) { ListBox_SetItemData(pState->hwndProperties, ListBox_AddString(pState->hwndProperties, pItem->pHeading), (LPARAM)pItem); } }
// Ensure we default select the top items of each list
ListBox_SetCurSel(pState->hwndProperties, 0); ListBox_SetCurSel(pState->hwndColumns, 0); } else { pState = (LPPICKERSTATE)GetWindowLongPtr(hwnd, DWLP_USER); TraceAssert(pState);
switch (uMsg) { case WM_HELP: { LPHELPINFO pHelpInfo = (LPHELPINFO)lParam; WinHelp((HWND)pHelpInfo->hItemHandle, DSQUERY_HELPFILE, HELP_WM_HELP, (DWORD_PTR)aPickColumnsHelpIDs); break; }
case WM_CONTEXTMENU: WinHelp((HWND)wParam, DSQUERY_HELPFILE, HELP_CONTEXTMENU, (DWORD_PTR)aPickColumnsHelpIDs); fResult = TRUE; break;
case WM_COMMAND: { switch (LOWORD(wParam)) { case IDOK: { _Picker_GetColumnTable(pState->hwndColumns, &pState->hdsaColumns); EndDialog(hwnd, IDOK); break; }
case IDCANCEL: EndDialog(hwnd, IDCANCEL); break;
case IDC_ADD: _PickerMoveColumn(pState->hwndColumns, pState->hwndProperties, TRUE); break;
case IDC_REMOVE: _PickerMoveColumn(pState->hwndProperties, pState->hwndColumns, FALSE); break;
case IDC_LBPROPERTIES: { if (ListBox_GetCount(pState->hwndProperties) > 0) { if (HIWORD(wParam) == LBN_DBLCLK) _PickerMoveColumn(pState->hwndColumns, pState->hwndProperties, TRUE); }
break; }
case IDC_LBCOLUMNS: { if (ListBox_GetCount(pState->hwndColumns) > 1) { if (HIWORD(wParam) == LBN_DBLCLK) _PickerMoveColumn(pState->hwndProperties, pState->hwndColumns, FALSE); }
break; }
default: fUpdateButtonState = FALSE; break; }
break; }
default: fUpdateButtonState = FALSE; break; }
}
// if the selections state change, or something which would cause
// us to refresh the add/remove buttons state then lets do it.
// each button is enabled only if there is a selection and the
// number of items is > the min value.
if (pState && fUpdateButtonState) { BOOL fEnableAdd = FALSE; BOOL fEnableRemove = FALSE; DWORD dwButtonStyle;
if ((ListBox_GetCount(pState->hwndProperties) > 0)) { fEnableAdd = TRUE; }
if ((ListBox_GetCount(pState->hwndColumns) > 1)) { fEnableRemove = TRUE; }
// Make sure the DefButton is an enabled button
// FEATURE: Need to add an SHSetDefID() export to shlwapi
// which is simply a SetDefID that "does the right thing"
// wrt disabled buttons.
if ((!fEnableRemove) && (!fEnableAdd)) { SET_BTN_STYLE(hwnd, IDC_ADD, BS_PUSHBUTTON); SET_BTN_STYLE(hwnd, IDC_REMOVE, BS_PUSHBUTTON);
SendMessage(hwnd, DM_SETDEFID, IDOK, 0); SET_BTN_STYLE(hwnd, IDOK, BS_DEFPUSHBUTTON); SendMessage(hwnd,WM_NEXTDLGCTL,(WPARAM)GetDlgItem(hwnd, IDOK),TRUE); SetFocus(GetDlgItem(hwnd, IDOK)); } else if (!fEnableAdd) { dwButtonStyle = (DWORD)GetWindowLong(GetDlgItem(hwnd, IDC_ADD), GWL_STYLE); if (dwButtonStyle & BS_DEFPUSHBUTTON) { SET_BTN_STYLE(hwnd, IDC_ADD, BS_PUSHBUTTON); SendMessage(hwnd, DM_SETDEFID, IDC_REMOVE, 0);
SET_BTN_STYLE(hwnd, IDC_REMOVE, BS_DEFPUSHBUTTON); SendMessage(hwnd,WM_NEXTDLGCTL,(WPARAM)GetDlgItem(hwnd, IDC_REMOVE),TRUE); SetFocus(GetDlgItem(hwnd, IDC_REMOVE)); } } else if (!fEnableRemove) { dwButtonStyle = (DWORD) GetWindowLong(GetDlgItem(hwnd, IDC_REMOVE), GWL_STYLE); if (dwButtonStyle & BS_DEFPUSHBUTTON) { SET_BTN_STYLE(hwnd, IDC_REMOVE, BS_PUSHBUTTON); SendMessage(hwnd, DM_SETDEFID, IDC_ADD, 0); SET_BTN_STYLE(hwnd, IDC_ADD, BS_DEFPUSHBUTTON); SendMessage(hwnd,WM_NEXTDLGCTL,(WPARAM)GetDlgItem(hwnd, IDC_ADD),TRUE); SetFocus(GetDlgItem(hwnd, IDC_ADD)); } }
Button_Enable(GetDlgItem(hwnd, IDC_ADD), fEnableAdd); Button_Enable(GetDlgItem(hwnd, IDC_REMOVE), fEnableRemove);
}
return fResult; }
/*-----------------------------------------------------------------------------
/ CDsQuery::OnPickColumns / ----------------------- / Handle picking the columns that should be displayed in the result view, / if the user selects new columns and hits OK then we refresh the / view and the internal table of visible columns. / / In: / hwndParent = parent for the dialog / / Out: / HRESULT /----------------------------------------------------------------------------*/
INT _PickerItemFreeCB(LPVOID pData, LPVOID lParam) { LPPICKERITEM pItem = (LPPICKERITEM)pData; LocalFreeStringW(&pItem->pProperty); LocalFreeString(&pItem->pHeading); LocalFree(pItem); return 1; }
INT _PickerItemCmpCB(LPVOID p1, LPVOID p2, LPARAM lParam) { LPPICKERITEM pEntry1 = (LPPICKERITEM)p1; LPPICKERITEM pEntry2 = (LPPICKERITEM)p2; INT nResult = -1; if (pEntry1 && pEntry2) nResult = StrCmpW(pEntry1->pProperty, pEntry2->pProperty);
return nResult; }
typedef struct { PICKERSTATE *pps; HDPA hdpaProperties; // attributes to be appeneded.
} PICKERENUMATTRIB;
HRESULT CALLBACK _PickerEnumAttribCB(LPARAM lParam, LPCWSTR pAttributeName, LPCWSTR pDisplayName, DWORD dwFlags) { HRESULT hr; PICKERENUMATTRIB *ppea = (PICKERENUMATTRIB*)lParam; PICKERITEM item; INT j;
TraceEnter(TRACE_FIELDCHOOSER, "_PickerEnumAttribCB");
// fix casting
item.pProperty = (LPWSTR)pAttributeName;
j = DPA_Search(ppea->pps->hdpaItems, &item, 0, _PickerItemCmpCB, NULL, DPAS_SORTED); if (j == -1) { Trace(TEXT("Property not already in list: %s"), pAttributeName);
hr = StringDPA_AppendStringW(ppea->hdpaProperties, pAttributeName, NULL); FailGracefully(hr, "Failed to add unique property to DPA"); }
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
HRESULT CDsQuery::OnPickColumns(HWND hwndParent) { HRESULT hr; HDPA hdpaProperties = NULL; PICKERSTATE state; PICKERENUMATTRIB pea = { 0 }; INT i, j, iProperty, iColumn; LPDSQUERYCLASSLIST pDsQueryClassList = NULL; IDsDisplaySpecifier* pdds = NULL;
TraceEnter(TRACE_FIELDCHOOSER, "CDsQuery::OnPickColumns"); Trace(TEXT("Column count %d"), DSA_GetItemCount(_hdsaColumns));
state.hdpaItems = NULL; state.hdsaColumns = _hdsaColumns; state.hwndProperties = NULL; state.hwndColumns = NULL;
// Build a list of unique properties sorted and remove the ones
// which match the currently displayed property set.
state.hdpaItems = DPA_Create(16); TraceAssert(state.hdpaItems);
if (!state.hdpaItems) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to create property DPA");
//
// attempt to get the IDsDisplaySpecifier object
//
hr = CoCreateInstance(CLSID_DsDisplaySpecifier, NULL, CLSCTX_INPROC_SERVER, IID_IDsDisplaySpecifier, (void **)&pdds); FailGracefully(hr, "Failed to get the IDsDisplaySpecifier interface");
hr = pdds->SetServer(_pServer, _pUserName, _pPassword, DSSSF_DSAVAILABLE); FailGracefully(hr, "Failed to server information");
// add the columns properties to the the list, marking them as active columns
// storing their size and other information.
for (i = 0 ; i < DPA_GetPtrCount(_hdsaColumns); i++) { LPCOLUMN pColumn = (LPCOLUMN)DSA_GetItemPtr(_hdsaColumns, i); TraceAssert(pColumn);
LPPICKERITEM pItem = (LPPICKERITEM)LocalAlloc(LPTR, SIZEOF(PICKERITEM)); TraceAssert(pItem);
if (pItem) { pItem->pProperty = NULL; pItem->pHeading = NULL; pItem->fIsColumn = TRUE; pItem->cx = pColumn->cx; pItem->fmt = pColumn->fmt;
hr = GetPropertyFromColumn(&pItem->pProperty, pColumn); TraceAssert(SUCCEEDED(hr));
if (SUCCEEDED(hr)) { hr = LocalAllocString(&pItem->pHeading, pColumn->pHeading); TraceAssert(SUCCEEDED(hr)); }
Trace(TEXT("Adding column %d, with property %s"), i, pItem->pProperty);
if (FAILED(hr) || (-1 == DPA_AppendPtr(state.hdpaItems, pItem))) { TraceMsg("Failed to add property to the DPA"); hr = E_FAIL; } if (FAILED(hr)) _PickerItemFreeCB(pItem, NULL); } }
DPA_Sort(state.hdpaItems, _PickerItemCmpCB, NULL); // sort the DPA now we have all the elements
// for all the classes we have loop through and build the unique
// list, sorted as we go.
hr = _pqf->CallForm(&_clsidForm, DSQPM_GETCLASSLIST, 0, (LPARAM)&pDsQueryClassList); FailGracefully(hr, "Failed to get the class list");
if (!pDsQueryClassList) ExitGracefully(hr, E_FAIL, "Failed to get the class list");
Trace(TEXT("Classes returned from DSQPM_GETCLASSLIST %d"), pDsQueryClassList->cClasses);
for (i = 0 ; i < pDsQueryClassList->cClasses ; i++) { LPWSTR pObjectClass = (LPWSTR)ByteOffset(pDsQueryClassList, pDsQueryClassList->offsetClass[i]); TraceAssert(pObjectClass);
Trace(TEXT("Adding class '%s' to the property DPA"), pObjectClass);
// allocate a DPA to be filed with items
StringDPA_Destroy(&pea.hdpaProperties);
pea.pps = &state; pea.hdpaProperties = DPA_Create(16);
if (!pea.hdpaProperties) ExitGracefully(hr, E_OUTOFMEMORY, "Failed to allocate string DPA");
if (SUCCEEDED(EnumClassAttributes(pdds, pObjectClass, _PickerEnumAttribCB, (LPARAM)&pea))) { Trace(TEXT("Unique property list has %d entries"), DPA_GetPtrCount(pea.hdpaProperties));
// Having constructed the unique list of properties for this class lets now
// add them to the item data list and allocate real structures for them.
for (iProperty = 0 ; iProperty < DPA_GetPtrCount(pea.hdpaProperties); iProperty++) { LPWSTR pProperty = StringDPA_GetStringW(pea.hdpaProperties, iProperty); TraceAssert(pProperty != NULL);
LPPICKERITEM pItem = (LPPICKERITEM)LocalAlloc(LPTR, SIZEOF(PICKERITEM)); TraceAssert(pItem);
if (pItem) { WCHAR szBuffer[MAX_PATH];
GetFriendlyAttributeName(pdds, pObjectClass, pProperty, szBuffer, ARRAYSIZE(szBuffer));
pItem->pProperty = NULL; pItem->pHeading = NULL; pItem->fIsColumn = FALSE; pItem->cx = 0; pItem->fmt = 0; hr = LocalAllocStringW(&pItem->pProperty, pProperty); TraceAssert(SUCCEEDED(hr));
if (SUCCEEDED(hr)) { hr = LocalAllocStringW(&pItem->pHeading, szBuffer); TraceAssert(SUCCEEDED(hr)); }
if (FAILED(hr) || (-1 == DPA_AppendPtr(state.hdpaItems, pItem))) { TraceMsg("Failed to add property to the DPA"); hr = E_FAIL; } if (FAILED(hr)) _PickerItemFreeCB(pItem, NULL); }
DPA_Sort(state.hdpaItems, _PickerItemCmpCB, NULL); // sort the DPA now we have all the elements
} } }
Trace(TEXT("Property table is %d items in size"), DPA_GetPtrCount(state.hdpaItems));
// If the user selects OK then the DlgProc will have generated a new column
// table stored in the PICKERSTATE structure, we should persist this, then
// load it ready to refresh the result viewer.
i = (int)DialogBoxParam(GLOBAL_HINSTANCE, MAKEINTRESOURCE(IDD_PICKCOLUMNS), hwndParent, _PickerDlgProc, (LPARAM)&state); if (i == IDOK) { hr = _SaveColumnTable(_clsidForm, state.hdsaColumns); FailGracefully(hr, "Failed to write column table");
hr = _InitNewQuery(NULL, TRUE); // initialize the view
FailGracefully(hr, "Failed when starting new query");
TraceAssert(_dwThreadId); PostThreadMessage(_dwThreadId, RVTM_SETCOLUMNTABLE, _dwQueryReference, (LPARAM)state.hdsaColumns);
_fColumnsModified = FALSE; } hr = S_OK;
exit_gracefully:
StringDPA_Destroy(&pea.hdpaProperties);
if (state.hdpaItems) DPA_DestroyCallback(state.hdpaItems, _PickerItemFreeCB, NULL);
if (pDsQueryClassList) CoTaskMemFree(pDsQueryClassList);
DoRelease(pdds);
TraceLeaveValue(hr); }
// persistance object
class CDsPersistQuery : public IPersistQuery { private: LONG _cRef; TCHAR m_szFilename[MAX_PATH];
public: CDsPersistQuery(LPCTSTR pFilename);; ~CDsPersistQuery();
// IUnknown
STDMETHOD(QueryInterface)(REFIID riid, LPVOID* ppvObject); STDMETHOD_(ULONG, AddRef)(); STDMETHOD_(ULONG, Release)();
// IPersist
STDMETHOD(GetClassID)(CLSID* pClassID) { return E_NOTIMPL; }
// IPersistQuery
STDMETHOD(WriteString)(LPCTSTR pSection, LPCTSTR pValueName, LPCTSTR pValue); STDMETHOD(ReadString)(LPCTSTR pSection, LPCTSTR pValueName, LPTSTR pBuffer, INT cchBuffer); STDMETHOD(WriteInt)(LPCTSTR pSection, LPCTSTR pValueName, INT value); STDMETHOD(ReadInt)(LPCTSTR pSection, LPCTSTR pValueName, LPINT pValue); STDMETHOD(WriteStruct)(LPCTSTR pSection, LPCTSTR pValueName, LPVOID pStruct, DWORD cbStruct); STDMETHOD(ReadStruct)(LPCTSTR pSection, LPCTSTR pValueName, LPVOID pStruct, DWORD cbStruct); STDMETHOD(Clear)() { return S_OK; } };
#define STRING_SIZE TEXT("%sLength")
#define STRING_VALUE TEXT("%sValue")
CDsPersistQuery::CDsPersistQuery(LPCTSTR pFilename) : _cRef(1) { // NTRAID#NTBUG9-554905-2002/02/20-lucios. Pending fix.
StrCpy(m_szFilename, pFilename); // copy the filename
DllAddRef(); }
CDsPersistQuery::~CDsPersistQuery() { DllRelease(); }
// IUnknown
ULONG CDsPersistQuery::AddRef() { return InterlockedIncrement(&_cRef); }
ULONG CDsPersistQuery::Release() { TraceAssert( 0 != _cRef ); ULONG cRef = InterlockedDecrement(&_cRef); if ( 0 == cRef ) { delete this; } return cRef; }
HRESULT CDsPersistQuery::QueryInterface(REFIID riid, void **ppv) { static const QITAB qit[] = { QITABENTMULTI(CDsPersistQuery, IPersist, IPersistQuery), // IID_IPersist
QITABENT(CDsPersistQuery, IPersistQuery), // IID_IPersistQuery
{0, 0 }, }; return QISearch(this, qit, riid, ppv); }
STDAPI CPersistQuery_CreateInstance(LPTSTR pszPath, IPersistQuery **pppq) { CDsPersistQuery *ppq = new CDsPersistQuery(pszPath); if (!ppq) return E_OUTOFMEMORY;
HRESULT hr = ppq->QueryInterface(IID_IPersistQuery, (void **)pppq); ppq->Release(); return hr; }
// IPersistQuery
STDMETHODIMP CDsPersistQuery::WriteString(LPCTSTR pSection, LPCTSTR pKey, LPCTSTR pValue) { HRESULT hr = S_OK; TCHAR szBuffer[MAX_PATH];
if (!pSection || !pKey || !pValue) return E_INVALIDARG;
// Write the string into the stream as a UNICODE string. If we are built for UNICODE
// then we can simply WriteProfileStruct, otherwise we must attempt to convert it
// from a multi-byte string.
// Write the string size
// NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(szBuffer, STRING_SIZE, pKey);
INT cchValue = 1+lstrlen(pValue); if (!WritePrivateProfileStruct(pSection, szBuffer, &cchValue, SIZEOF(cchValue), m_szFilename)) ExitGracefully(hr, E_FAIL, "Failed to write string size to stream");
// NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(szBuffer, STRING_VALUE, pKey); if (!WritePrivateProfileStruct(pSection, szBuffer, (LPVOID)pValue, SIZEOF(WCHAR)*cchValue, m_szFilename)) ExitGracefully(hr, E_FAIL, "Failed to write string to stream");
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
STDMETHODIMP CDsPersistQuery::ReadString(LPCTSTR pSection, LPCTSTR pKey, LPTSTR pBuffer, INT cchBuffer) { HRESULT hr; TCHAR szBuffer[MAX_PATH]; INT cchValue;
TraceEnter(TRACE_IO, "CDsPersistQuery::ReadString");
if (!pSection || !pKey || !pBuffer) ExitGracefully(hr, E_INVALIDARG, "Nothing to read (or into)");
pBuffer[0] = TEXT('\0'); // terminate the buffer
Trace(TEXT("pSection: %s, pKey: %s"), pSection, pKey);
// Read the length of the string, checking to see if its fits in the the buffer
// we have, if it does then read and convert as requried.
// NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(szBuffer, STRING_SIZE, pKey); // <key name>Length
Trace(TEXT("Opening key: %s"), szBuffer); if (!GetPrivateProfileStruct(pSection, szBuffer, &cchValue, SIZEOF(cchValue), m_szFilename)) ExitGracefully(hr, E_FAIL, "Failed to read string size");
Trace(TEXT("cchValue %d"), cchValue);
if (cchValue > cchBuffer) ExitGracefully(hr, E_FAIL, "Buffer too small for string in stream");
if (cchValue > 0) { // NTRAID#NTBUG9-554458-2002/02/20-lucios. Pending fix.
wsprintf(szBuffer, STRING_VALUE, pKey); if (!GetPrivateProfileStruct(pSection, szBuffer, pBuffer, SIZEOF(WCHAR)*cchValue, m_szFilename)) ExitGracefully(hr, E_FAIL, "Failed to read string data"); }
Trace(TEXT("Value is: %s"), pBuffer); hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
STDMETHODIMP CDsPersistQuery::WriteInt(LPCTSTR pSection, LPCTSTR pKey, INT value) { HRESULT hr;
TraceEnter(TRACE_IO, "CDsPersistQuery::WriteInt");
if (!pSection || !pKey) ExitGracefully(hr, E_INVALIDARG, "Nothing to write");
Trace(TEXT("pSection: %s, pKey: %s, value: %d"), pSection, pKey, value);
if (!WritePrivateProfileStruct(pSection, pKey, &value, SIZEOF(value), m_szFilename)) ExitGracefully(hr, E_FAIL, "Failed to write value");
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
STDMETHODIMP CDsPersistQuery::ReadInt(LPCTSTR pSection, LPCTSTR pKey, LPINT pValue) { HRESULT hr;
TraceEnter(TRACE_IO, "CDsPersistQuery::ReadInt");
if (!pSection || !pKey || !pValue) ExitGracefully(hr, E_INVALIDARG, "Nothing to read");
Trace(TEXT("pSection: %s, pKey: %s, pValue: %08x"), pSection, pKey, pValue);
if (!GetPrivateProfileStruct(pSection, pKey, pValue, SIZEOF(*pValue), m_szFilename)) ExitGracefully(hr, E_FAIL, "Failed to read value");
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
STDMETHODIMP CDsPersistQuery::WriteStruct(LPCTSTR pSection, LPCTSTR pKey, LPVOID pStruct, DWORD cbStruct) { HRESULT hr;
TraceEnter(TRACE_IO, "CDsPersistQuery::WriteStruct");
if (!pSection || !pKey || !pStruct) ExitGracefully(hr, E_INVALIDARG, "Nothing to write");
Trace(TEXT("pSection: %s, pKey: %s, pStruct: %08x, cbStruct: %d"), pSection, pKey, pStruct, cbStruct);
if (!WritePrivateProfileStruct(pSection, pKey, pStruct, cbStruct, m_szFilename)) ExitGracefully(hr, E_FAIL, "Failed to write struct");
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
STDMETHODIMP CDsPersistQuery::ReadStruct(LPCTSTR pSection, LPCTSTR pKey, LPVOID pStruct, DWORD cbStruct) { HRESULT hr;
TraceEnter(TRACE_IO, "CDsPersistQuery::ReadStruct");
if (!pSection || !pKey || !pStruct) ExitGracefully(hr, E_INVALIDARG, "Nothing to read");
Trace(TEXT("pSection: %s, pKey: %s, pStruct: %08x, cbStruct: %d"), pSection, pKey, pStruct, cbStruct);
if (!GetPrivateProfileStruct(pSection, pKey, pStruct, cbStruct, m_szFilename)) ExitGracefully(hr, E_FAIL, "Failed to read struct");
hr = S_OK;
exit_gracefully:
TraceLeaveResult(hr); }
|