windows-xp/Source/XPSP1/NT/shell/ext/dsui/dsquery/query.cpp

#include "pch.h"
#include "stddef.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;
}
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
};


//
// 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);

    LocalFreeStringW(&_pUserName);
    LocalFreeStringW(&_pPassword);
    LocalFreeStringW(&_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()
{
    if (InterlockedDecrement(&_cRef))
        return _cRef;

    delete this;
    return 0;
}

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 hres = pdq->QueryInterface(IID_IUnknown, (void **)ppunk);
    pdq->Release();
    return hres;
}


/// 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 hres;
    TCHAR szBuffer[MAX_PATH];
    INT i;

    TraceEnter(TRACE_FORMS, "CDsQuery::AddForms");

    if ( !pAddFormsProc )
        ExitGracefully(hres, 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));

        hres = (*pAddFormsProc)(lParam, &qf);
        FailGracefully(hres, "Failed to add form (calling pAddFormsFunc)");        
    }

    hres = S_OK;                  // success

exit_gracefully:

    TraceLeaveResult(hres);
}


// 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 hres;
    INT i;

    TraceEnter(TRACE_FORMS, "CDsQuery::AddPages");

    if ( !pAddPagesProc )
        ExitGracefully(hres, 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;        

        hres = (*pAddPagesProc)(lParam, *pages[i].clisdForm, &qp);
        FailGracefully(hres, "Failed to add page (calling pAddPagesFunc)");        
    }

    hres = S_OK;

exit_gracefully:

    TraceLeaveResult(S_OK);
}


// IQueryHandler

STDMETHODIMP CDsQuery::Initialize(IQueryFrame* pQueryFrame, DWORD dwOQWFlags, LPVOID pParameters)
{
    HRESULT hres;
    LPDSQUERYINITPARAMS pDsQueryInitParams = (LPDSQUERYINITPARAMS)pParameters;
    TCHAR szGUID[GUIDSTR_MAX];
    TCHAR szBuffer[MAX_PATH];
    HINSTANCE hInstanceComCtl32 = NULL;
    USES_CONVERSION;
  
    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:"), W2T(pDsQueryInitParams->pDefaultScope));
            hres = LocalAllocStringW(&_pDefaultScope, pDsQueryInitParams->pDefaultScope);
            FailGracefully(hres, "Failed to cope default scope");
        }

        // default save location?

        if ( (_dwFlags & DSQPF_SAVELOCATION) && pDsQueryInitParams->pDefaultSaveLocation )
        {
            Trace(TEXT("Default save location:"), W2T(pDsQueryInitParams->pDefaultSaveLocation));
            hres = LocalAllocStringW(&_pDefaultSaveLocation, pDsQueryInitParams->pDefaultSaveLocation);
            FailGracefully(hres, "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 )
            {
                hres = LocalAllocStringW(&_pUserName, pDsQueryInitParams->pUserName);
                FailGracefully(hres, "Failed to copy user name");
            }

            if ( pDsQueryInitParams->pPassword )
            {
                hres = LocalAllocStringW(&_pPassword, pDsQueryInitParams->pPassword);
                FailGracefully(hres, "Failed to copy password");
            }

            if ( pDsQueryInitParams->pServer )
            {
                hres = LocalAllocStringW(&_pServer, pDsQueryInitParams->pServer);
                FailGracefully(hres, "Failed to copy server");
            }

            Trace(TEXT("_pUserName : %s"), _pUserName ? W2T(_pUserName):TEXT("<not specified>"));
            Trace(TEXT("_pPassword : %s"), _pPassword ? W2T(_pPassword):TEXT("<not specified>"));
            Trace(TEXT("_pServer : %s"), _pServer ? W2T(_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(hres, 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);

    hres = S_OK;                  // success

exit_gracefully:

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

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 hres;
    DWORD dwThreadId;
    HANDLE hThread;
    LPSCOPETHREADDATA pstd = NULL;
    USES_CONVERSION;

    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(hres, 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 )
    {
        hres = LocalAllocStringW(&pstd->pDefaultScope, _pDefaultScope);
        FailGracefully(hres, "Failed to copy the default scope");
    }

    hres = _CopyCredentials(&pstd->pUserName, &pstd->pPassword, &pstd->pServer);
    FailGracefully(hres, "Failed to copy credentails");

    DllAddRef();

    hThread = CreateThread(NULL, 0, AddScopesThread, pstd, 0, &dwThreadId);
    TraceAssert(hThread);

    if ( !hThread )
    {
        DllRelease();
        ExitGracefully(hres, E_FAIL, "Failed to create background thread to enum scopes - BAD!");
    }

    CloseHandle(hThread);

    hres = S_OK;

exit_gracefully:

    if ( FAILED(hres) && pstd )
    {
        LocalFreeStringW(&pstd->pDefaultScope);
        LocalFree((HLOCAL)pstd);
    }

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

typedef struct
{
    IADsPathname *padp;
    WCHAR szGcPath[MAX_PATH];
} BROWSEFORSCOPE;

int CALLBACK CDsQuery::s_BrowseForScopeCB(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
{
    HRESULT hres;
    INT iResult = 0;
    BROWSEFORSCOPE *pbfs = (BROWSEFORSCOPE*)lpData;
    LPTSTR pDirectoryName = NULL;
    USES_CONVERSION;

    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, DSB_MAX_DISPLAYNAME_CHARS);
                    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(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 hres;
    LPDSQUERYSCOPE pDsQueryScope = (LPDSQUERYSCOPE)pCurrentScope;
    BROWSEFORSCOPE bfs = { 0 };
    DSBROWSEINFO dsbi = { 0 };
    INT iResult;
    WCHAR szPath[2048];
    WCHAR szRoot[MAX_PATH+10];      // LDAP://
    WCHAR szObjectClass[64];
    LONG nElements;
    USES_CONVERSION;
    
    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"), W2T(bfs.szGcPath));

    hres = CoCreateInstance(CLSID_Pathname, NULL, CLSCTX_INPROC_SERVER, IID_IADsPathname, (void **)&bfs.padp);
    FailGracefully(hres, "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);

    StrCpyW(szRoot, c_szLDAP);

    if ( _pServer )
    {
        if ( lstrlenW(_pServer) > MAX_PATH )
            ExitGracefully(hres, E_INVALIDARG, "_pServer is too big");

        StrCatW(szRoot, L"//");
        StrCatW(szRoot, _pServer);
    }

    if ( pDsQueryScope )
    {
        StrCpyNW(szPath, OBJECT_NAME_FROM_SCOPE(pDsQueryScope), ARRAYSIZE(szPath));
        Trace(TEXT("pDsQueryScope: %s"), W2T(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"), W2T(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(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"), W2T(pszScope), W2T(pszObjectClass));

        hres = AllocScope(ppScope, 0, pszScope, pszObjectClass);
        FailGracefully(hres, "Failed converting the DS path to a scope");
    }
    else if ( iResult == IDCANCEL )
    {
        hres = S_FALSE;               // nothing selected, returning S_FALSE;
    }
    else if ( iResult < 0 )
    {
        ExitGracefully(hres, E_FAIL, "DsBrowseForContainer failed");
    }

exit_gracefully:

    LocalFreeString((LPTSTR*)&dsbi.pszTitle);
    Trace(TEXT("*ppScope == %08x"), *ppScope);

    DoRelease(bfs.padp);

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

//
// 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 hres;
    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(hres, 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(hres, 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(hres, 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(hres, E_FAIL, "Failed to create the static banner window");

    _SetFilter(_fFilter);
    _SetViewMode(_idViewMode);
    _ShowBanner(SWP_SHOWWINDOW, IDS_INITALIZING);                

    hres = S_OK;                      // success

exit_gracefully:
    
    if ( SUCCEEDED(hres) )
        *phWndView = _hwnd;

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

#define MGW_EDIT 2

STDMETHODIMP CDsQuery::ActivateView(UINT uState, WPARAM wParam, LPARAM lParam)
{
    HRESULT hres;
    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(hres, E_FAIL, "Failed to create a base menu bar to be used");

            hres = _pqf->InsertMenus(hMenu, &omgw);
            FailGracefully(hres, "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);
            }

            hres = _pqf->SetMenu(hMenu, NULL);                           // set the frames menu bar
            FailGracefully(hres, "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.

                    hres = _GetContextMenu();
                    FailGracefully(hres, "Failed when calling _GetAndViewObject");

                    if ( ListView_GetSelectedCount(_hwndView) > 0 )
                    {
                        _GetContextMenuVerbs(hFileMenu, CMF_VERBSONLY);
                        _fNoSelection = FALSE;
                    }
                }

                ENABLE_MENU_ITEM(hFileMenu, DSQH_FILE_PROPERTIES,     !_fNoSelection);
            }

            // 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);
            hres = LocalAllocString(&_pDefaultSaveName, (LPCTSTR)lParam);
            FailGracefully(hres, "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;
        }
    }
    
    hres = S_OK;

exit_gracefully:

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

STDMETHODIMP CDsQuery::InvokeCommand(HWND hwndParent, UINT uID)
{
    HRESULT hres = 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:
            hres = OnFileProperties();
            break;

        case DSQH_FILE_SAVEQUERY:
            hres = OnFileSaveQuery();
            break;

        case DSQH_EDIT_SELECTALL:
            hres = OnEditSelectAll();
            break;

        case DSQH_EDIT_INVERTSELECTION:
            hres = 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;

                hres = _pcm->InvokeCommand(&ici);
                FailGracefully(hres, "Failed when calling IContextMenu::InvokeCommand");

                DoRelease(_pcm);                  // no longer needed
            }

            break;
        }
    }

exit_gracefully:

    ResetWaitCursor();

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

STDMETHODIMP CDsQuery::GetCommandString(UINT uID, DWORD dwFlags, LPTSTR pBuffer, INT cchBuffer)
{
    HRESULT hres;
    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");

            hres = _pcm->GetCommandString((uID - DSQH_FILE_CONTEXT_FIRST), GCS_HELPTEXT, NULL, (LPSTR)pBuffer, cchBuffer);
#if UNICODE
            // we build UNICODE, therefore if we failed then try and pick up the ANSI string from
            // the handler, if that works then we convert the multi-byte string to UNICODE 
            // and hand that back to the caller.

            if ( FAILED(hres) )
            {
                CHAR szBuffer[MAX_PATH];
                
                hres = _pcm->GetCommandString((uID - DSQH_FILE_CONTEXT_FIRST), GCS_HELPTEXTA, NULL, szBuffer, ARRAYSIZE(szBuffer));

                if ( SUCCEEDED(hres) )
                {
                    TraceMsg("Handler provided an ANSI string");
                    MultiByteToWideChar(CP_ACP, 0, szBuffer, -1, pBuffer, cchBuffer);
                }
            }
#endif
            FailGracefully(hres, "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));
                wsprintf(pBuffer, szFmt, pColumn->pHeading);

                Trace(TEXT("Resulting string is: %s"), pBuffer);
            }
        }
        else
        {
            if ( !LoadString(GLOBAL_HINSTANCE, uID, pBuffer, cchBuffer) )
                ExitGracefully(hres, E_FAIL, "Failed to load the command text for this verb");
        }
    }

    hres = S_OK;

exit_gracefully:

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

STDMETHODIMP CDsQuery::IssueQuery(LPCQPARAMS pQueryParams)
{
    HRESULT hres;
    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)

    hres = _InitNewQuery(pDsQueryParams, TRUE);
    FailGracefully(hres, "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(hres, 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;

    hres = _GetColumnTable(_clsidForm, pDsQueryParams, &ptid->hdsaColumns, FALSE);
    FailGracefully(hres, "Failed to create column DSA");

    hres = LocalAllocStringW(&ptid->pQuery, (LPWSTR)ByteOffset(pDsQueryParams, pDsQueryParams->offsetQuery));
    FailGracefully(hres, "Failed to copy query filter string");

    hres = LocalAllocStringW(&ptid->pScope, OBJECT_NAME_FROM_SCOPE(pDsQueryScope));
    FailGracefully(hres, "Failed to copy scope to thread init data");

    hres = _CopyCredentials(&ptid->pUserName, &ptid->pPassword, &ptid->pServer);
    FailGracefully(hres, "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(hres, E_FAIL, "Failed to create background thread - BAD!");
    }

    hres = S_OK;                      // success

exit_gracefully:

    if ( SUCCEEDED(hres) && IsWindow(_hwndView) )
        SetFocus(_hwndView);

    if ( FAILED(hres) )
    {
        QueryThread_FreeThreadInitData(&ptid);
        _pqf->StartQuery(FALSE);
    }

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

STDMETHODIMP CDsQuery::StopQuery()
{
    HRESULT hres;
    INT cResults = _hdpaResults ? DPA_GetPtrCount(_hdpaResults):0;
    LPTSTR pBuffer;

    TraceEnter(TRACE_HANDLER, "CDsQuery::StopQuery");

    if ( !IsWindow(_hwndView) )
        ExitGracefully(hres, 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);

    hres = S_OK;              // success

exit_gracefully:

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

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 hres;
    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(hres, E_INVALIDARG, "Bad arguments to GetViewObject");

    if ( !IsEqualIID(riid, IID_IDataObject) )
        ExitGracefully(hres, E_NOINTERFACE, "Object IID supported");

    //
    // write the extra data we have into the IDataObject:
    //
    //  - query parameters (filter)
    //  - scope
    //  - attribute prefix information
    //

    hres = _GetDataObjectFromSelection(fJustSelection, &pDataObject);
    FailGracefully(hres, "Failed to get the IDataObject from the namespace");

    if ( SUCCEEDED(_pqf->CallForm(NULL, CQPM_GETPARAMETERS, 0, (LPARAM)&pDsQueryParams)) )
    {
        if ( pDsQueryParams )
        {
            hres = _SetDataObjectData(pDataObject, cfDsQueryParams, pDsQueryParams, pDsQueryParams->cbStruct);
            FailGracefully(hres, "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);

            hres = _SetDataObjectData(pDataObject, cfDsQueryScope, pScope, StringByteSizeW(pScope));
            FailGracefully(hres, "Failed set the DSQUERYSCOPE into the data object");
        }
    }

    // success, so lets pass out the IDataObject.

    pDataObject->AddRef();
    *ppvOut = (LPVOID)pDataObject;

    hres = S_OK;

exit_gracefully:

    DoRelease(pDataObject);
    
    if ( pDsQueryParams )
        CoTaskMemFree(pDsQueryParams);

    if ( pDsQueryScope )
        CoTaskMemFree(pDsQueryScope);

    ResetWaitCursor();

    TraceLeaveResult(hres);
}   

/*---------------------------------------------------------------------------*/

STDMETHODIMP CDsQuery::LoadQuery(IPersistQuery* pPersistQuery)
{
    HRESULT hres;
    WCHAR szBuffer[MAX_PATH];
    IADs *pDsObject = NULL;
    BSTR bstrObjectClass = NULL;
    INT iFilter;
    LPCQSCOPE pScope = NULL;
    INT cbScope;
    USES_CONVERSION;

    TraceEnter(TRACE_HANDLER, "CDsQuery::LoadQuery");
    
    if ( !pPersistQuery )
        ExitGracefully(hres, 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"), W2T(szBuffer));

        // get the object class from the file - this should be written to the file

        hres = ADsOpenObject(szBuffer, _pUserName, _pPassword, ADS_SECURE_AUTHENTICATION, IID_IADs, (void **)&pDsObject);
        FailGracefully(hres, "Failed to bind to the specified object");

        hres = pDsObject->get_Class(&bstrObjectClass);
        FailGracefully(hres, "Failed to get the object class");

        // allocate a new scope

        if ( SUCCEEDED(AllocScope(&pScope, 0, szBuffer, bstrObjectClass)) )
        {
            hres = _pqf->AddScope(pScope, 0x0, TRUE);
            FailGracefully(hres, "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);
    }

    hres = S_OK;

exit_gracefully:

    if ( pScope )
        CoTaskMemFree(pScope);

    DoRelease(pDsObject);
    SysFreeString(bstrObjectClass);

    TraceLeaveResult(hres);
}

/*---------------------------------------------------------------------------*/

STDMETHODIMP CDsQuery::SaveQuery(IPersistQuery* pPersistQuery, LPCQSCOPE pScope)
{
    HRESULT hres;
    LPDSQUERYSCOPE pDsQueryScope = (LPDSQUERYSCOPE)pScope;
    LPWSTR pScopePath = OBJECT_NAME_FROM_SCOPE(pDsQueryScope);
    WCHAR szGcPath[MAX_PATH];
    
    TraceEnter(TRACE_HANDLER, "CDsQuery::SaveQuery");

    if ( !pPersistQuery || !pScope )
        ExitGracefully(hres, 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");

        hres = pPersistQuery->WriteInt(c_szDsQuery, c_szScopeSize, StringByteSizeW(pScopePath));
        FailGracefully(hres, "Failed to write the scope size");

        hres = pPersistQuery->WriteStruct(c_szDsQuery, c_szScope, pScopePath, StringByteSizeW(pScopePath));
        FailGracefully(hres, "Failed to write scope");
    }

    hres = pPersistQuery->WriteInt(c_szDsQuery, c_szViewMode, _idViewMode);
    FailGracefully(hres, "Failed to write view mode");

    hres = pPersistQuery->WriteInt(c_szDsQuery, c_szEnableFilter, _fFilter);
    FailGracefully(hres, "Failed to write filter state");

    hres = S_OK;

exit_gracefully:

    TraceLeaveResult(hres);
}


/*----------------------------------------------------------------------------
/ IObjectWithSite
/----------------------------------------------------------------------------*/

STDMETHODIMP CDsQuery::SetSite(IUnknown* punk)
{
    HRESULT hres = S_OK;

    TraceEnter(TRACE_HANDLER, "CDsQuery::SetSite");

    DoRelease(_punkSite);

    if ( punk )
    {
        TraceMsg("QIing for IUnknown from the site object");

        hres = punk->QueryInterface(IID_IUnknown, (void **)&_punkSite);
        FailGracefully(hres, "Failed to get IUnknown from the site object");
    }

exit_gracefully:

    TraceLeaveResult(hres);
}

STDMETHODIMP CDsQuery::GetSite(REFIID riid, void **ppv)
{
    HRESULT hres;
    
    TraceEnter(TRACE_HANDLER, "CDsQuery::GetSite");

    if ( !_punkSite )
        ExitGracefully(hres, E_NOINTERFACE, "No site to QI from");

    hres = _punkSite->QueryInterface(riid, ppv);
    FailGracefully(hres, "QI failed on the site unknown object");

exit_gracefully:

    TraceLeaveResult(hres);
}


/*----------------------------------------------------------------------------
/ IDsQueryHandler
/----------------------------------------------------------------------------*/

VOID CDsQuery::_DeleteViewItems(LPDSOBJECTNAMES pdon)
{
    INT iResult;
    DWORD iItem;
    USES_CONVERSION;

    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"), W2CT(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 hres;

    TraceEnter(TRACE_HANDLER, "CDsQuery::UpdateView");

    switch ( dwType & DSQRVF_OPMASK )
    {
        case DSQRVF_ITEMSDELETED:
        {
            if ( !pdon )
                ExitGracefully(hres, E_INVALIDARG, "Invlaidate pdon specified for refresh");

            _DeleteViewItems(pdon);
            break;
        }

        default:
            ExitGracefully(hres, E_INVALIDARG, "Invalidate refresh type speciifed");
    }

    hres = S_OK;

exit_gracefully:

    TraceLeaveResult(hres);
}


/*-----------------------------------------------------------------------------
/ 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 hres;
    LRESULT lr = 0;
    DECLAREWAITCURSOR = GetCursor();
    USES_CONVERSION;

    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:
                    {
                        if ( pResult->aColumn[iColumn].pszText )
                            StrCpyN(pNotify->item.pszText, pResult->aColumn[iColumn].pszText, pNotify->item.cchTextMax);

                        break;
                    }
                        
                    case PROPERTY_ISNUMBER:
                    case PROPERTY_ISBOOL:
                        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();

            hres = _GetContextMenu();
            FailGracefully(hres, "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 hres;
    INT i, iPopulateFrom;

    TraceEnter(TRACE_VIEW, "CDsQuery::OnAddResults");

    if ( (dwQueryReference != _dwQueryReference) || !hdpaResults )
        ExitGracefully(hres, 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);

    hres = S_OK;

exit_gracefully:

    TraceLeaveResult(hres);
}


/*-----------------------------------------------------------------------------
/ 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 hres;
    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.

    hres = _GetContextMenu();
    FailGracefully(hres, "Failed when calling _GetContextMenu()");  

    _fNoSelection = !ListView_GetSelectedCount(_hwndView);

    if ( !(hMenu = CreatePopupMenu()) )
        ExitGracefully(hres, E_FAIL, "Failed to create the popup menu");

    if ( !_fNoSelection )
    {
        // pick up the context menu that maps tot he 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(hres, 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 hres;
    IDataObject* pDataObject = NULL;
    IDsFolderProperties* pDsFolderProperties = NULL;

    TraceEnter(TRACE_VIEW, "CDsQuery::OnFileProperties");

    hres = GetViewObject(CQRVS_SELECTION, IID_IDataObject, (void **)&pDataObject);
    FailGracefully(hres, "Failed to get IDataObject for shortcut creation");

    hres = CoCreateInstance(CLSID_DsFolderProperties, NULL, CLSCTX_INPROC_SERVER, IID_IDsFolderProperties, (void **)&pDsFolderProperties);
    FailGracefully(hres, "Failed to get IDsFolderProperties for the desktop object");

    hres = pDsFolderProperties->ShowProperties(_hwnd, pDataObject);
    FailGracefully(hres, "Failed to invoke property UI for the given selection");

    // hres = S_OK;                  // success

exit_gracefully:
    
    DoRelease(pDataObject);
    DoRelease(pDsFolderProperties);

    TraceLeaveResult(hres);
}


/*-----------------------------------------------------------------------------
/ 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 hres;
    OPENFILENAME ofn;
    TCHAR szFilename[MAX_PATH];
    TCHAR szDirectory[MAX_PATH];
    TCHAR szFilter[64];
    TCHAR szTitle[64];
    LPTSTR pFilter;
    IPersistQuery *ppq = NULL;
    USES_CONVERSION;

    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));
    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"), W2T(_pDefaultSaveLocation));
        StrCpy(szDirectory, W2T(_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(hres, E_FAIL, "Failed to delete previous query");

        hres = CPersistQuery_CreateInstance(szFilename, &ppq);
        FailGracefully(hres, "Failed to create the peristance object");

        hres = _pqf->SaveQuery(ppq);
        FailGracefully(hres, "Failed when calling IQueryFrame::SaveSearch");
    }   

    hres = S_OK;

exit_gracefully:

    DoRelease(ppq);

    TraceLeaveResult(hres);
}


/*-----------------------------------------------------------------------------
/ 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 hres;
    LPTSTR pBuffer;

    TraceEnter(TRACE_VIEW, "CDsQuery::_InitNewQuery");

    hres = _pqf->StartQuery(TRUE);
    TraceAssert(SUCCEEDED(hres));

    // 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();

        hres = _GetColumnTable(_clsidForm, pDsQueryParams, &_hdsaColumns, TRUE);
        FailGracefully(hres, "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(hres, E_OUTOFMEMORY, "Failed to allocate result DPA");

    _dwQueryReference++;

exit_gracefully:

    TraceLeaveResult(hres);
}


/*-----------------------------------------------------------------------------
/ 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 hres;
    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(hres, 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:
            {
                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(hres, 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 )
                {
                    hres = LocalAllocStringLen(&pColumn->filter.pszText, cchFilter);
                    FailGracefully(hres, "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;
            }
        }
    }

    hres = S_OK;

exit_gracefully:

    TraceLeaveResult(hres);
}


/*-----------------------------------------------------------------------------
/ 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 )
        {
            wsprintf(szBuffer, TEXT("[%d]"), pColumn->idOperator);
            PutStringElement(pBuffer, pcchBuffer, szBuffer);

            switch ( pColumn->filter.iPropertyType )
            {
                case PROPERTY_ISUNDEFINED:
                    break;

                case PROPERTY_ISUNKNOWN:
                case PROPERTY_ISSTRING:
                    PutStringElement(pBuffer, pcchBuffer, pColumn->filter.pszText);
                    break;

                case PROPERTY_ISNUMBER:
                case PROPERTY_ISBOOL:
                    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 hres = S_OK;
    LPTSTR pFilter = NULL;
    UINT cchFilter;
    BOOL fSetCursor = FALSE;

    TraceEnter(TRACE_VIEW, "CDsQuery::_FilterView");
    
    if ( !_hdpaResults )
        ExitGracefully(hres, 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) )
    {
        hres = LocalAllocStringLen(&pFilter, cchFilter);
        FailGracefully(hres, "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(hres);
}


/*-----------------------------------------------------------------------------
/ 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 hres;
    BOOL fBannerShown = IsWindowVisible(_hwndBanner);
    LPTSTR pBuffer = NULL;
    LV_ITEM lvi;
    INT iColumn, i;
    INT iVisible = 0;
    INT iHidden = 0;
    BOOL fIncludeItem;
    MSG msg;
    USES_CONVERSION;

    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:
                            {
                                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:
                    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 hres;
    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(hres, 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);

                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 hres;
    TCHAR szGUID[GUIDSTR_MAX];
    TCHAR szBuffer[MAX_PATH];

    TraceEnter(TRACE_VIEW, "CDsQuery::_GetQueryFormKey");

    GetStringFromGUID(clsidForm, szGUID, ARRAYSIZE(szGUID));
    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(hres, E_FAIL, "Failed to open settings key");

    hres = S_OK;

exit_gracefully:

    TraceLeaveResult(hres); 
}


/*-----------------------------------------------------------------------------
/ 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 hres;
    HKEY hKey = NULL;
    BOOL fDefaultSettings = TRUE;
    LPSAVEDCOLUMN aSavedColumn = NULL;
    LPTSTR pSettingsValue = VIEW_SETTINGS_VALUE;
    BOOL fHaveSizeInfo = FALSE;
    LPWSTR pProperty;
    DWORD dwType, cbSize;
    LV_COLUMN lvc;
    SIZE sz;
    INT i, iNewColumn;
    HD_ITEM hdi;
    IDsDisplaySpecifier *pdds = NULL;
    USES_CONVERSION;

    TraceEnter(TRACE_VIEW, "CDsQuery::_GetColumnTable");
    TraceGUID("clsidForm ", clsidForm);
    Trace(TEXT("pDsQueryParams %08x, pHDSA %08x"), pDsQueryParams, pHDSA);

    DECLAREWAITCURSOR;
    SetWaitCursor();

    if ( !pHDSA )
        ExitGracefully(hres, 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(hres, 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 pProperty = (LPCWSTR)ByteOffset(aSavedColumn, aSavedColumn[i].offsetProperty);
                    LPCTSTR pHeading = (LPCTSTR)ByteOffset(aSavedColumn, aSavedColumn[i].offsetHeading);

                    hres = LocalAllocStringW(&column.pProperty, pProperty);
                    FailGracefully(hres, "Failed to allocate property name");

                    hres = LocalAllocString(&column.pHeading, pHeading);
                    FailGracefully(hres, "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"), 
                                            W2T(column.pProperty), column.pHeading, column.cx, column.fmt);

                    if ( -1 == DSA_AppendItem(*pHDSA, &column) )
                        ExitGracefully(hres, 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(hres, 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:
                    pProperty = c_szADsPathCH;
                    break;
            
                case DSCOLUMNPROP_OBJECTCLASS:
                    pProperty = c_szObjectClassCH;
                    break;

                default:
                    pProperty = (LPWSTR)ByteOffset(pDsQueryParams, pDsQueryParams->aColumns[i].offsetProperty);
                    break;
            }

            hres = LocalAllocStringW(&column.pProperty, pProperty);
            FailGracefully(hres, "Failed to allocate property name");

            hres = FormatMsgResource(&column.pHeading, pDsQueryParams->hInstance, pDsQueryParams->aColumns[i].idsName);
            FailGracefully(hres, "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"), 
                                    W2T(column.pProperty), column.pHeading, column.cx, column.fmt);

            if ( -1 == DSA_AppendItem(*pHDSA, &column) )
                ExitGracefully(hres, 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).

    hres = CoCreateInstance(CLSID_DsDisplaySpecifier, NULL, CLSCTX_INPROC_SERVER, IID_IDsDisplaySpecifier, (void **)&pdds);
    FailGracefully(hres, "Failed to get the IDsDisplaySpecifier interface");

    if (  _dwFlags & DSQPF_HASCREDENTIALS )
    {
        hres = pdds->SetServer(_pServer, _pUserName, _pPassword, DSSSF_DSAVAILABLE);
        FailGracefully(hres, "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, W2T(pColumn->pProperty));

        // lets get the property type, column handler and the default operator for it.

        hres = GetColumnHandlerFromProperty(pColumn, NULL);
        FailGracefully(hres, "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(hres, 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(hres, E_FAIL, "Failed to set the filter type into the view");
        }
    }

    hres = S_OK;                  // success

exit_gracefully:

    if ( hKey )
        RegCloseKey(hKey);

    if ( aSavedColumn )
        LocalFree((HLOCAL)aSavedColumn);

    DoRelease(pdds);
    ResetWaitCursor();

    TraceLeaveResult(hres);
}


/*-----------------------------------------------------------------------------
/ 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 hres;
    LPWSTR pProperty;
    LPSAVEDCOLUMN aSavedColumn = NULL;
    DWORD cbData, offset;
    HKEY hKey = NULL;
    LPTSTR pSettingsValue = VIEW_SETTINGS_VALUE;
    INT i;
    USES_CONVERSION;
    
    TraceEnter(TRACE_VIEW, "CDsQuery::_SaveColumnTable");
    TraceGUID("clsidForm ", clsidForm);
    
    if ( !hdsaColumns )
        ExitGracefully(hres, 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(hres, 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);
       
        hres = GetPropertyFromColumn(&pProperty, pColumn);
        FailGracefully(hres, "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.

    hres = _GetQueryFormKey(clsidForm, &hKey);
    FailGracefully(hres, "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(hres, E_FAIL, "Failed to write setting into the view");

    hres = S_OK;

exit_gracefully:

    if ( aSavedColumn )
        LocalFree((HLOCAL)aSavedColumn);

    if ( hKey )
        RegCloseKey(hKey);

    TraceLeaveResult(hres);
}


// 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);
    }

    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 hres;

    TraceEnter(TRACE_VIEW, "CDsQuery::_CopyCredentials");

    hres = LocalAllocStringW(ppszUserName, _pUserName);
    FailGracefully(hres, "Failed to copy the user name");

    hres = LocalAllocStringW(ppszPassword, _pPassword);
    FailGracefully(hres, "Failed to copy the password");

    hres = LocalAllocStringW(ppszServer, _pServer);
    FailGracefully(hres, "Failed to copy the server name");

exit_gracefully:

    TraceLeaveResult(hres);
}



/*-----------------------------------------------------------------------------
/ 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;
    LPPICKERITEM pItem;
    USES_CONVERSION;

    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 hres;
    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(hres, 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(hres, E_OUTOFMEMORY, "Failed to construct the column entry");
        }
    }

    Trace(TEXT("New column table contains %d items"), DSA_GetItemCount(hdsaColumns));
    hres = S_OK;

exit_gracefully:

    if ( FAILED(hres) && hdsaColumns )
    {
        DSA_DestroyCallback(hdsaColumns, FreeColumnCB, NULL);
        hdsaColumns = NULL;
    }

    *pHDSA = hdsaColumns;

    TraceLeaveResult(hres);
}


/*-----------------------------------------------------------------------------
/ _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)
{
    USES_CONVERSION;
    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"), W2T(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);
            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);
                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);
                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)
{
    USES_CONVERSION;
    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 hres;
    PICKERENUMATTRIB *ppea = (PICKERENUMATTRIB*)lParam;
    PICKERITEM item;
    INT j;
    USES_CONVERSION;

    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"), W2CT(pAttributeName));

        hres = StringDPA_AppendStringW(ppea->hdpaProperties, pAttributeName, NULL);
        FailGracefully(hres, "Failed to add unique property to DPA");
    }

    hres = S_OK;

exit_gracefully:

    TraceLeaveResult(hres);
}

HRESULT CDsQuery::OnPickColumns(HWND hwndParent)
{
    USES_CONVERSION;
    HRESULT hres;
    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(hres, E_OUTOFMEMORY, "Failed to create property DPA");

    //
    // attempt to get the IDsDisplaySpecifier object
    //

    hres = CoCreateInstance(CLSID_DsDisplaySpecifier, NULL, CLSCTX_INPROC_SERVER, IID_IDsDisplaySpecifier, (void **)&pdds);
    FailGracefully(hres, "Failed to get the IDsDisplaySpecifier interface");

    hres = pdds->SetServer(_pServer, _pUserName, _pPassword, DSSSF_DSAVAILABLE);
    FailGracefully(hres, "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;

            hres = GetPropertyFromColumn(&pItem->pProperty, pColumn);
            TraceAssert(SUCCEEDED(hres));

            if ( SUCCEEDED(hres) )
            {
                hres = LocalAllocString(&pItem->pHeading, pColumn->pHeading);
                TraceAssert(SUCCEEDED(hres));
            }

            Trace(TEXT("Adding column %d, with property %s"), i, W2T(pItem->pProperty));

            if ( FAILED(hres) || (-1 == DPA_AppendPtr(state.hdpaItems, pItem)) )
            {
                TraceMsg("Failed to add property to the DPA");
                hres = E_FAIL;
            }
        
            if ( FAILED(hres) )
                _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.

    hres = _pqf->CallForm(&_clsidForm, DSQPM_GETCLASSLIST, 0, (LPARAM)&pDsQueryClassList);
    FailGracefully(hres, "Failed to get the class list");

    if ( !pDsQueryClassList )
        ExitGracefully(hres, 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"), W2T(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(hres, 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;
    
                    hres = LocalAllocStringW(&pItem->pProperty, pProperty);
                    TraceAssert(SUCCEEDED(hres));

                    if ( SUCCEEDED(hres) )
                    {
                        hres = LocalAllocStringW2T(&pItem->pHeading, szBuffer);
                        TraceAssert(SUCCEEDED(hres));
                    }

                    if ( FAILED(hres) || (-1 == DPA_AppendPtr(state.hdpaItems, pItem)) )
                    {
                        TraceMsg("Failed to add property to the DPA");
                        hres = E_FAIL;
                    }
                    
                    if ( FAILED(hres) )
                        _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 )
    {
        hres = _SaveColumnTable(_clsidForm, state.hdsaColumns);
        FailGracefully(hres, "Failed to write column table");

        hres = _InitNewQuery(NULL, TRUE);             // initialize the view
        FailGracefully(hres, "Failed when starting new query");

        TraceAssert(_dwThreadId);
        PostThreadMessage(_dwThreadId, RVTM_SETCOLUMNTABLE, _dwQueryReference, (LPARAM)state.hdsaColumns);

        _fColumnsModified = FALSE;
    }
   
    hres = S_OK;

exit_gracefully:

    StringDPA_Destroy(&pea.hdpaProperties);

    if ( state.hdpaItems )
        DPA_DestroyCallback(state.hdpaItems, _PickerItemFreeCB, NULL);

    if ( pDsQueryClassList )
        CoTaskMemFree(pDsQueryClassList);

    DoRelease(pdds);

    TraceLeaveValue(hres);
}


// 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)
{
    StrCpy(m_szFilename, pFilename);               // copy the filename
    DllAddRef();
}

CDsPersistQuery::~CDsPersistQuery()
{
    DllRelease();
}


// IUnknown 

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

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

    delete this;
    return 0;
}

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

    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");

    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.

    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 )
    {
        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);
}