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

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 2000
//
//  File:       cpview.cpp
//
//  This module provides the Control Panel user interface information 
//  to the shell through the ICplView interface.  The ICplView implementation
//  instantiates a CCplNamespace object through which it obtains the
//  display information on demand.  CCplView then takes that information 
//  and either makes it available to the shell for display in the webview 
//  left-hand pane or generates a DUI element hierarchy for display in the 
//  right-hand pane.
//
//  The majority of the code is associated with building Direct UI content.
// 
//--------------------------------------------------------------------------
#include "shellprv.h"
#include "cpviewp.h"
#include "cpduihlp.h"
#include "cpguids.h"
#include "cplnkele.h"
#include "cpnamespc.h"
#include "cputil.h"
#include "ids.h"
#include "shstyle.h"
#include <uxtheme.h>

namespace CPL {


class CCplView : public CObjectWithSite,
                 public ICplView,
                 public IServiceProvider
{
    public:
        ~CCplView(void);

        //
        // IUnknown
        //
        STDMETHOD(QueryInterface)(REFIID riid, void **ppv);
        STDMETHOD_(ULONG, AddRef)(void);
        STDMETHOD_(ULONG, Release)(void);
        //
        // ICplView
        //
        STDMETHOD(EnumClassicWebViewInfo)(DWORD dwFlags, IEnumCplWebViewInfo **ppenum);
        STDMETHOD(EnumCategoryChoiceWebViewInfo)(DWORD dwFlags, IEnumCplWebViewInfo **ppenum);
        STDMETHOD(EnumCategoryWebViewInfo)(DWORD dwFlags, eCPCAT eCategory, IEnumCplWebViewInfo **ppenum);
        STDMETHOD(CreateCategoryChoiceElement)(DUI::Element **ppe);
        STDMETHOD(CreateCategoryElement)(eCPCAT eCategory, DUI::Element **ppe);
        STDMETHOD(GetCategoryHelpURL)(eCPCAT eCategory, LPWSTR pszURL, UINT cchURL);
        STDMETHOD(RefreshIDs)(IEnumIDList *penumIDs);
        //
        // IServiceProvider
        //
        STDMETHOD(QueryService)(REFGUID guidService, REFIID riid, void **ppv);

        static HRESULT CreateInstance(IEnumIDList *penumIDs, IUnknown *punkSite, REFIID riid, void **ppvOut);

    private:
        LONG              m_cRef;
        ICplNamespace    *m_pns;
        CSafeServiceSite *m_psss;
        ATOM              m_idDirective;
        ATOM              m_idDirective2;
        ATOM              m_idTitle;
        ATOM              m_idIcon;
        ATOM              m_idCategoryList;
        ATOM              m_idCategoryTaskList;
        ATOM              m_idAppletList;
        ATOM              m_idBanner;
        ATOM              m_idBarricadeTitle;
        ATOM              m_idBarricadeMsg;
        ATOM              m_idContainer;

        CCplView::CCplView(void);

        HRESULT _Initialize(IEnumIDList *penumIDs, IUnknown *punkSite);
        HRESULT _CreateCategoryChoiceElement(DUI::Element **ppe);
        HRESULT _CreateCategoryElement(ICplCategory *pCategory, DUI::Element **ppe);
        HRESULT _BuildCategoryBanner(ICplCategory *pCategory, DUI::Element *pePrimaryPane);
        HRESULT _BuildCategoryBarricade(DUI::Element *peRoot);
        HRESULT _BuildCategoryTaskList(DUI::Parser *pParser, ICplCategory *pCategory, DUI::Element *pePrimaryPane, int *pcTasks);
        HRESULT _BuildCategoryAppletList(DUI::Parser *pParser, ICplCategory *pCategory, DUI::Element *pePrimaryPane, int *pcApplets);
        HRESULT _CreateWatermark(DUI::Element *peRoot);
        HRESULT _CreateAndAddListItem(DUI::Parser *pParser, DUI::Element *peList, LPCWSTR pszItemTemplate, DUI::Value *pvSsListItem, IUICommand *puic, eCPIMGSIZE eIconSize);
        HRESULT _IncludeCategory(ICplCategory *pCategory) const;
        HRESULT _AddOrDeleteAtoms(bool bAdd);
        HRESULT _GetStyleModuleAndResId(HINSTANCE *phInstance, UINT *pidStyle);
        HRESULT _LoadUiFileFromResources(HINSTANCE hInstance, int idResource, char **ppUIFile);
        HRESULT _BuildUiFile(char **ppUIFile, int *piCharCount, HINSTANCE *phInstance);
        HRESULT _CreateUiFileParser(DUI::Parser **ppParser);
        eCPCAT _DisplayIndexToCategoryIndex(int iCategory) const;

        //
        // Prevent copy.
        //
        CCplView(const CCplView& rhs);
        CCplView& operator = (const CCplView& rhs);
};



CCplView::CCplView(
    void
    ) : m_cRef(1),
        m_pns(NULL),
        m_idDirective(0),
        m_idDirective2(0),
        m_idTitle(0),
        m_idIcon(0),
        m_idCategoryList(0),
        m_idCategoryTaskList(0),
        m_idAppletList(0),
        m_idBanner(0),
        m_idBarricadeTitle(0),
        m_idBarricadeMsg(0),
        m_idContainer(0),
        m_psss(NULL)
{
    TraceMsg(TF_LIFE, "CCplView::CCplView, this = 0x%x", this);
}


CCplView::~CCplView(
    void
    )
{
    TraceMsg(TF_LIFE, "CCplView::~CCplView, this = 0x%x", this);

    if (NULL != m_psss)
    {
        m_psss->SetProviderWeakRef(NULL);
        m_psss->Release();
    }

    if (NULL != m_pns)
    {
        IUnknown_SetSite(m_pns, NULL);
        m_pns->Release();
    }
    _AddOrDeleteAtoms(false);
}



HRESULT
CCplView::CreateInstance( // [static]
    IEnumIDList *penumIDs, 
    IUnknown *punkSite,
    REFIID riid,
    void **ppvOut
    )
{
    ASSERT(NULL != penumIDs);
    ASSERT(NULL != ppvOut);
    ASSERT(!IsBadWritePtr(ppvOut, sizeof(*ppvOut)));

    *ppvOut = NULL;

    HRESULT hr = E_OUTOFMEMORY;
    CCplView* pv = new CCplView();
    if (NULL != pv)
    {
        hr = pv->_Initialize(penumIDs, punkSite);
        if (SUCCEEDED(hr))
        {
            hr = pv->QueryInterface(riid, ppvOut);
            if (SUCCEEDED(hr))
            {
                //
                // Set the site of the view to the site passed into the
                // instance generator.  This is most likely the site of
                // the Control Panel folder view callback.
                //
                hr = IUnknown_SetSite(static_cast<IUnknown *>(*ppvOut), punkSite);
            }
        }
        pv->Release();
    }
    return THR(hr);
}



STDMETHODIMP
CCplView::QueryInterface(
    REFIID riid,
    void **ppv
    )
{
    ASSERT(NULL != ppv);
    ASSERT(!IsBadWritePtr(ppv, sizeof(*ppv)));

    static const QITAB qit[] = {
        QITABENT(CCplView, ICplView),
        QITABENT(CCplView, IObjectWithSite),
        QITABENT(CCplView, IServiceProvider),
        { 0 },
    };
    HRESULT hr = QISearch(this, qit, riid, ppv);

    return E_NOINTERFACE == hr ? hr : THR(hr);
}



STDMETHODIMP_(ULONG)
CCplView::AddRef(
    void
    )
{
    ULONG cRef = InterlockedIncrement(&m_cRef);
    TraceMsg(TF_LIFE, "CCplView::AddRef %d->%d", cRef - 1, cRef);
    return cRef;
}



STDMETHODIMP_(ULONG)
CCplView::Release(
    void
    )
{
    ASSERT( 0 != m_cRef );
    ULONG cRef = InterlockedDecrement(&m_cRef);
    TraceMsg(TF_LIFE, "CCplView::Release %d<-%d", cRef, cRef+1);
    if ( 0 == cRef )
    {
        delete this;
    }
    return cRef;
}



STDMETHODIMP
CCplView::QueryService(
    REFGUID guidService, 
    REFIID riid, 
    void **ppv
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::QueryService");

    HRESULT hr = E_NOINTERFACE;
    if (SID_SControlPanelView == guidService)
    {
        TraceMsg(TF_CPANEL, "SID_SControlPanelView service requested");
        if (IID_ICplNamespace == riid)
        {
            TraceMsg(TF_CPANEL, "SID_SControlPanelView::IID_ICplNamespace requested");
            ASSERT(NULL != m_pns);
            hr = m_pns->QueryInterface(IID_ICplNamespace, ppv);
        }
        else if (IID_ICplView == riid)
        {
            TraceMsg(TF_CPANEL, "SID_SControlPanelView::IID_ICplView requested");
            ASSERT(NULL != m_pns);
            hr = this->QueryInterface(IID_ICplView, ppv);
        }
    }
    else
    {
        //
        // Most likely a command object requesting SID_STopLevelBrowser.
        //
        TraceMsg(TF_CPANEL, "Handing service request to view's site.");
        ASSERT(NULL != _punkSite);
        hr = IUnknown_QueryService(_punkSite, guidService, riid, ppv);
    }

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::QueryService", hr);
    return THR(hr);
}



STDMETHODIMP
CCplView::EnumClassicWebViewInfo(
    DWORD dwFlags,
    IEnumCplWebViewInfo **ppenum
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::EnumClassicWebViewInfo");

    ASSERT(NULL != ppenum);
    ASSERT(!IsBadWritePtr(ppenum, sizeof(*ppenum)));
    ASSERT(NULL != m_pns);

    HRESULT hr = m_pns->EnumClassicWebViewInfo(dwFlags, ppenum);

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::EnumClassicWebViewInfo", hr);
    return THR(hr);
}


//
// Returns an enumerator for webview info associated with
// the category 'choice' page.
//
STDMETHODIMP
CCplView::EnumCategoryChoiceWebViewInfo(
    DWORD dwFlags,
    IEnumCplWebViewInfo **ppenum
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::EnumCategoryChoiceWebViewInfo");

    ASSERT(NULL != ppenum);
    ASSERT(!IsBadWritePtr(ppenum, sizeof(*ppenum)));
    ASSERT(NULL != m_pns);

    HRESULT hr = m_pns->EnumWebViewInfo(dwFlags, ppenum);

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::EnumCategoryChoiceWebViewInfo", hr);
    return THR(hr);
}


//
// Returns an enumerator for webview info associated with
// a given category page.
//
STDMETHODIMP
CCplView::EnumCategoryWebViewInfo(
    DWORD dwFlags,
    eCPCAT eCategory, 
    IEnumCplWebViewInfo **ppenum
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::EnumCategoryWebViewInfo");

    ASSERT(NULL != ppenum);
    ASSERT(!IsBadWritePtr(ppenum, sizeof(*ppenum)));
    ASSERT(NULL != m_pns);

    ICplCategory *pCategory;
    HRESULT hr = m_pns->GetCategory(eCategory, &pCategory);
    if (SUCCEEDED(hr))
    {
        hr = pCategory->EnumWebViewInfo(dwFlags, ppenum);
        ATOMICRELEASE(pCategory);
    }

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::EnumCategoryWebViewInfo", hr);
    return THR(hr);
}


//
// Creates the DUI element tree for the category 'choice'
// page.  Returns the root of the tree.
//
STDMETHODIMP
CCplView::CreateCategoryChoiceElement(
    DUI::Element **ppe
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::CreateCategoryChoiceElement");

    ASSERT(NULL != ppe);
    ASSERT(!IsBadWritePtr(ppe, sizeof(*ppe)));

    HRESULT hr = _CreateCategoryChoiceElement(ppe);

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::CreateCategoryChoiceElement", hr);
    return THR(hr);
}



//
// Creates the DUI element tree for a given category page.
// Returns the root of the tree.
//
STDMETHODIMP
CCplView::CreateCategoryElement(
    eCPCAT eCategory, 
    DUI::Element **ppe
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::CreateCategoryElement");
    TraceMsg(TF_CPANEL, "Category ID = %d", eCategory);

    ASSERT(NULL != ppe);
    ASSERT(!IsBadWritePtr(ppe, sizeof(*ppe)));
    ASSERT(NULL != m_pns);

    ICplCategory *pCategory;
    HRESULT hr = m_pns->GetCategory(eCategory, &pCategory);
    if (SUCCEEDED(hr))
    {
        hr = _CreateCategoryElement(pCategory, ppe);
        ATOMICRELEASE(pCategory);
    }

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::CreateCategoryElement", hr);
    return THR(hr);
}


STDMETHODIMP
CCplView::GetCategoryHelpURL(
    CPL::eCPCAT eCategory,
    LPWSTR pszURL,
    UINT cchURL
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::GetCategoryHelpURL");

    ASSERT(NULL != pszURL);
    ASSERT(!IsBadWritePtr(pszURL, cchURL * sizeof(*pszURL)));
    
    ICplCategory *pCategory;
    HRESULT hr = m_pns->GetCategory(eCategory, &pCategory);
    if (SUCCEEDED(hr))
    {
        hr = pCategory->GetHelpURL(pszURL, cchURL);
        ATOMICRELEASE(pCategory);
    }
    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::GetCategoryHelpURL", hr);
    return THR(hr);
}


STDMETHODIMP
CCplView::RefreshIDs(
    IEnumIDList *penumIDs
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::RefreshIDs");

    ASSERT(NULL != m_pns);
    //
    // This will cause the namespace object to reset it's internal
    // list of item IDs.  This results in a re-categorization of 
    // applets such that all information returned by the namespace
    // will now reflect the new set of folder items.
    //
    HRESULT hr = m_pns->RefreshIDs(penumIDs);

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::RefreshIDs", hr);
    return THR(hr);
}


HRESULT
CCplView::_Initialize(
    IEnumIDList *penumIDs,
    IUnknown *punkSite
    )
{
    ASSERT(NULL == m_pns);
    ASSERT(NULL != penumIDs);

    HRESULT hr = E_OUTOFMEMORY;

    //
    // We use this weak-reference implementation of IServiceProvider
    // as described by ZekeL in shell\inc\cowsite.h.  A strong reference
    // would create a circular reference cycle between children of the
    // view and the view itself, preventing the view's destruction.
    // This weak-reference implementation is designed specifically
    // for this case.
    //
    ASSERT(NULL == m_psss);
    m_psss = new CSafeServiceSite();
    if (NULL != m_psss)
    {
        hr = m_psss->SetProviderWeakRef(this);
        if (SUCCEEDED(hr))
        {
            hr = CplNamespace_CreateInstance(penumIDs, CPL::IID_ICplNamespace, (void **)&m_pns);
            if (SUCCEEDED(hr))
            {
                IUnknown *punkSafeSite;
                hr = m_psss->QueryInterface(IID_IUnknown, (void **)&punkSafeSite);
                if (SUCCEEDED(hr))
                {
                    //
                    // Site the namespace object to the view.
                    // By doing this, all command objects created by the namespace will
                    // QueryService on the view object.  If the view doesn't support
                    // the requested service, it will query it's site.
                    // We use this so that command objects can query the view for
                    // IID_ICplNamespace and gather information on the namespace
                    // if necessary.  
                    //
                    hr = IUnknown_SetSite(m_pns, punkSafeSite);
                    if (SUCCEEDED(hr))
                    {
                        hr = _AddOrDeleteAtoms(true);
                    }
                    punkSafeSite->Release();
                }
            }
        }
    }
    return THR(hr);
}



HRESULT
CCplView::_AddOrDeleteAtoms(
    bool bAdd
    )
{
    struct CPL::ATOMINFO rgAtomInfo[] = {
        { L"directive",        &m_idDirective        },
        { L"directive2",       &m_idDirective2       },
        { L"title",            &m_idTitle            },
        { L"icon",             &m_idIcon             },
        { L"categorylist",     &m_idCategoryList     },
        { L"categorytasklist", &m_idCategoryTaskList },
        { L"appletlist",       &m_idAppletList       },
        { L"banner",           &m_idBanner           },
        { L"barricadetitle",   &m_idBarricadeTitle   },
        { L"barricademsg",     &m_idBarricadeMsg     },
        { L"container",        &m_idContainer        }
        };

    HRESULT hr = Dui_AddOrDeleteAtoms(rgAtomInfo, ARRAYSIZE(rgAtomInfo), bAdd);
    return THR(hr);
}


//
// Creates the DUI element tree for the category 'choice' page.
// Returns the root element.
//
HRESULT
CCplView::_CreateCategoryChoiceElement(
    DUI::Element **ppe
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_CreateCategoryChoiceElement");

    ASSERT(NULL != ppe);
    ASSERT(!IsBadWritePtr(ppe, sizeof(*ppe)));
    ASSERT(NULL != m_pns);

    DUI::Element *peRoot = NULL;
    DUI::Parser *pParser;
    HRESULT hr = _CreateUiFileParser(&pParser);
    if (SUCCEEDED(hr))
    {
        hr = Dui_CreateElement(pParser, L"CategoryList", NULL, &peRoot);
        if (SUCCEEDED(hr))
        {
            hr = _CreateWatermark(peRoot);
            if (SUCCEEDED(hr))
            {
                CDuiValuePtr pvSsCategoryListItem;
                hr = Dui_GetStyleSheet(pParser, L"CategoryListItemSS", &pvSsCategoryListItem);
                if (SUCCEEDED(hr))
                {
                    //
                    // Set the "Pick a category..." title.
                    //
                    hr = Dui_SetDescendentElementText(peRoot,
                                                      L"directive",
                                                      MAKEINTRESOURCEW(IDS_CP_PICKCATEGORY));
                    if (SUCCEEDED(hr))
                    {
                        //
                        // Build the list of categories.
                        //
                        DUI::Element *peCategoryList;
                        hr = Dui_FindDescendent(peRoot, L"categorylist", &peCategoryList);
                        if (SUCCEEDED(hr))
                        {
                            for (int i = 0; SUCCEEDED(hr) && i < int(eCPCAT_NUMCATEGORIES); i++)
                            {
                                ICplCategory *pCategory;
                                hr = m_pns->GetCategory(_DisplayIndexToCategoryIndex(i), &pCategory);
                                if (SUCCEEDED(hr))
                                {
                                    if (S_OK == _IncludeCategory(pCategory))
                                    {
                                        IUICommand *puic;
                                        hr = pCategory->GetUiCommand(&puic);
                                        if (SUCCEEDED(hr))
                                        {
                                            hr = _CreateAndAddListItem(pParser,
                                                                       peCategoryList, 
                                                                       L"CategoryLink", 
                                                                       pvSsCategoryListItem, 
                                                                       puic,
                                                                       eCPIMGSIZE_CATEGORY);
                                            ATOMICRELEASE(puic);
                                        }
                                    }
                                    ATOMICRELEASE(pCategory);
                                }
                            }
                        }
                    }
                }
            }
        }
        pParser->Destroy();
    }
    *ppe = peRoot;

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_CreateCategoryChoiceElement", hr);
    return THR(hr);
}


//
// Creates the DUI element tree for a given category page.
// Returns the root element.
//
HRESULT
CCplView::_CreateCategoryElement(
    ICplCategory *pCategory,
    DUI::Element **ppe
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_CreateCategoryElement");

    ASSERT(NULL != pCategory);
    ASSERT(NULL != ppe);
    ASSERT(!IsBadWritePtr(ppe, sizeof(*ppe)));
    ASSERT(NULL != m_pns);

    DUI::Element *peRoot = NULL;
    DUI::Parser *pParser;
    HRESULT hr = _CreateUiFileParser(&pParser);
    if (SUCCEEDED(hr))
    {
        hr = Dui_CreateElement(pParser, L"CategoryView", NULL, &peRoot);
        if (SUCCEEDED(hr))
        {
            hr = _CreateWatermark(peRoot);
            if (SUCCEEDED(hr))
            {
                int cTasks   = 0;
                int cApplets = 0;
                hr = _BuildCategoryBanner(pCategory, peRoot);
                if (SUCCEEDED(hr))
                {
                    hr = _BuildCategoryTaskList(pParser, pCategory, peRoot, &cTasks);
                    if (SUCCEEDED(hr))
                    {
                        hr = _BuildCategoryAppletList(pParser, pCategory, peRoot, &cApplets);
                    }
                }
                if (SUCCEEDED(hr))
                {
                    if (0 == cTasks && 0 == cApplets)
                    {
                        //
                        // No tasks or applets.  Display a message explaining
                        // that the content has been made unavailable by the system
                        // administrator.
                        //
                        hr = _BuildCategoryBarricade(peRoot);
                    }
                    else
                    {
                        //
                        // Delete the barricade DUI elements.  They're unused.
                        //
                        THR(Dui_DestroyDescendentElement(peRoot, L"barricadetitle"));
                        THR(Dui_DestroyDescendentElement(peRoot, L"barricademsg"));
                        //
                        // Set the text in the 'directive' text elements.
                        //
                        if (0 < cTasks)
                        {
                            //
                            // We've displayed a list of tasks.
                            // Set the "Pick a task..." title.
                            //
                            hr = Dui_SetDescendentElementText(peRoot,
                                                              L"directive",
                                                              MAKEINTRESOURCEW(IDS_CP_PICKTASK));
                        }

                        if (SUCCEEDED(hr))
                        {
                            if (0 < cApplets)
                            {
                                //
                                // We've displayed a list of applets.  Display one of the
                                // following directives based on the existance of a task 
                                // list above.
                                //
                                // Task list?    Directive
                                // ------------- ---------------------------
                                // Yes           "or pick a Control Panel icon"
                                // No            "Pick a Control Panel icon"
                                //
                                UINT idsDirective2 = IDS_CP_PICKICON;
                                if (0 < cTasks)
                                {
                                    idsDirective2 = IDS_CP_ORPICKICON;
                                }
                                hr = Dui_SetDescendentElementText(peRoot,
                                                                  L"directive2",
                                                                  MAKEINTRESOURCEW(idsDirective2));
                            }
                        }
                    }
                }
            }
        }
        pParser->Destroy();
    }
    *ppe = peRoot;

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_CreateCategoryElement", hr);
    return THR(hr);
}


//
// Builds the 'barricade' that is displayed when a category has no
// tasks or CPL applets to show.
//
HRESULT
CCplView::_BuildCategoryBarricade(
    DUI::Element *peRoot
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_BuildCategoryBarricade");
    HRESULT hr = Dui_SetDescendentElementText(peRoot,
                                              L"barricadetitle",
                                              MAKEINTRESOURCE(IDS_CP_CATEGORY_BARRICADE_TITLE));
    if (SUCCEEDED(hr))
    {
        hr = Dui_SetDescendentElementText(peRoot, 
                                          L"barricademsg",
                                          MAKEINTRESOURCE(IDS_CP_CATEGORY_BARRICADE_MSG));
    }
    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_BuildCategoryBarricade", hr);
    return THR(hr);
}


//
// Add the background watermark to the view if user is using a non-classic
// theme.
//
HRESULT
CCplView::_CreateWatermark(
    DUI::Element *peRoot
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_CreateWatermark");

    ASSERT(NULL != peRoot);

    HINSTANCE hStyleModule;
    UINT idStyle;
    HRESULT hr = _GetStyleModuleAndResId(&hStyleModule, &idStyle);
    if (SUCCEEDED(hr))
    {
        HBITMAP hWatermark = (HBITMAP) LoadImage (hStyleModule, MAKEINTRESOURCE(IDB_CPANEL_WATERMARK),
                                                  IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);

        if (NULL != hWatermark)
        {
            //
            // Set watermark only on non-classic themes.
            //
            DUI::Element *peWatermark;
            hr = Dui_FindDescendent(peRoot, L"watermark", &peWatermark);
            if (SUCCEEDED(hr))
            {
                CDuiValuePtr ptrValue = DUI::Value::CreateGraphic(hWatermark,
                                                                  GRAPHIC_TransColor,
                                                                  255);

                if (!ptrValue.IsNULL())
                {
                    hr = Dui_SetElementProperty(peWatermark, ContentProp, ptrValue);
                         peWatermark->SetContentAlign(CA_BottomRight);
                }
                else
                {
                    hr = E_OUTOFMEMORY;
                    DeleteObject (hWatermark);
                }
            }
            else
            {
                DeleteObject (hWatermark);
            }

            FreeLibrary(hStyleModule);
        }
        else
        {
            //
            // If 'classic' theme, do nothing.
            //
            hr = S_FALSE;
        }
    }
    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_CreateWatermark", hr);
    return THR(hr);
}



//
// Builds the banner for a category page.
//
HRESULT
CCplView::_BuildCategoryBanner(
    ICplCategory *pCategory,
    DUI::Element *pePrimaryPane
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_BuildCategoryBanner");

    ASSERT(NULL != pCategory);
    ASSERT(NULL != pePrimaryPane);

    IUICommand *puic;
    HRESULT hr = pCategory->GetUiCommand(&puic);
    if (SUCCEEDED(hr))
    {
        ICpUiElementInfo *pei;
        hr = puic->QueryInterface(IID_ICpUiElementInfo, (void **)&pei);
        if (SUCCEEDED(hr))
        {
            DUI::Element *peBanner;
            hr = Dui_FindDescendent(pePrimaryPane, L"banner", &peBanner);
            if (SUCCEEDED(hr))
            {
                //
                // Create the title text.
                //
                LPWSTR pszTitle;
                hr = pei->LoadName(&pszTitle);
                if (SUCCEEDED(hr))
                {
                    hr = Dui_SetDescendentElementText(peBanner, L"title", pszTitle);
                    CoTaskMemFree(pszTitle);
                }
                if (SUCCEEDED(hr))
                {
                    //
                    // Create the icon.
                    //
                    HICON hIcon;
                    hr = pei->LoadIcon(eCPIMGSIZE_BANNER, &hIcon);
                    if (SUCCEEDED(hr))
                    {
                        hr = Dui_SetDescendentElementIcon(peBanner, L"icon", hIcon);
                        if (FAILED(hr))
                        {
                            DestroyIcon(hIcon);
                        }
                    }
                }
            }
            ATOMICRELEASE(pei);
        }
        ATOMICRELEASE(puic);
    }

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_BuildCategoryBanner", hr);
    return THR(hr);
}



//
// Builds the list of tasks for a category page.
//
HRESULT
CCplView::_BuildCategoryTaskList(
    DUI::Parser *pParser,
    ICplCategory *pCategory,
    DUI::Element *pePrimaryPane,
    int *pcTasks
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_BuildCategoryTaskList");

    ASSERT(NULL != pCategory);
    ASSERT(NULL != pePrimaryPane);
    ASSERT(NULL != m_pns);
    ASSERT(NULL != pParser);

    int cTasks = 0;
    DUI::Element *peCategoryTaskList;
    HRESULT hr = Dui_FindDescendent(pePrimaryPane, L"categorytasklist", &peCategoryTaskList);
    if (SUCCEEDED(hr))
    {
        CDuiValuePtr pvStyleSheet;
        hr = Dui_GetStyleSheet(pParser, L"CategoryTaskListItemSS", &pvStyleSheet);
        if (SUCCEEDED(hr))
        {
            IEnumUICommand *peuic;
            hr = pCategory->EnumTasks(&peuic);
            if (SUCCEEDED(hr))
            {
                IUICommand *puic;
                while(S_OK == (hr = peuic->Next(1, &puic, NULL)))
                {
                    hr = _CreateAndAddListItem(pParser,
                                               peCategoryTaskList, 
                                               L"TaskLink", 
                                               pvStyleSheet, 
                                               puic,
                                               eCPIMGSIZE_TASK);
                    if (SUCCEEDED(hr))
                    {
                        cTasks++;
                    }
                    ATOMICRELEASE(puic);
                }
                ATOMICRELEASE(peuic);
            }
        }
    }
    if (NULL != pcTasks)
    {
        ASSERT(!IsBadWritePtr(pcTasks, sizeof(*pcTasks)));
        *pcTasks = cTasks;
    }

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_BuildCategoryTaskList", hr);
    return THR(hr);
}


//
// Builds the list of CPL applets for a category page.
//
HRESULT
CCplView::_BuildCategoryAppletList(
    DUI::Parser *pParser,
    ICplCategory *pCategory,
    DUI::Element *pePrimaryPane,
    int *pcApplets
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_BuildCategoryAppletList");

    ASSERT(NULL != pCategory);
    ASSERT(NULL != pePrimaryPane);
    ASSERT(NULL != pParser);

    int cApplets = 0;

    DUI::Element *peAppletList;
    HRESULT hr = Dui_FindDescendent(pePrimaryPane, L"appletlist", &peAppletList);
    if (SUCCEEDED(hr))
    {
        CDuiValuePtr pvStyleSheet;
        hr = Dui_GetStyleSheet(pParser, L"CategoryTaskListItemSS", &pvStyleSheet);
        if (SUCCEEDED(hr))
        {
            IEnumUICommand *peuicApplets;
            hr = pCategory->EnumCplApplets(&peuicApplets);
            if (SUCCEEDED(hr))
            {
                IUICommand *puicApplet;
                while(S_OK == (hr = peuicApplets->Next(1, &puicApplet, NULL)))
                {
                    hr = _CreateAndAddListItem(pParser,
                                               peAppletList, 
                                               L"AppletLink", 
                                               pvStyleSheet, 
                                               puicApplet,
                                               eCPIMGSIZE_APPLET);
                    if (SUCCEEDED(hr))
                    {
                        cApplets++;
                    }
                    ATOMICRELEASE(puicApplet);
                }
                ATOMICRELEASE(peuicApplets);
            }
        }
    }
    if (NULL != pcApplets)
    {
        ASSERT(!IsBadWritePtr(pcApplets, sizeof(*pcApplets)));
        *pcApplets = cApplets;
    }

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_BuildCategoryAppletList", hr);
    return THR(hr);
}


//
// Helper for adding link element to the view.
//
HRESULT
CCplView::_CreateAndAddListItem(
    DUI::Parser *pParser,
    DUI::Element *peList,     // List inserting into.
    LPCWSTR pszItemTemplate,  // Name of template in UI file.
    DUI::Value *pvSsListItem, // Style sheet for new list item
    IUICommand *puic,         // The new item's link object.
    eCPIMGSIZE eIconSize      // Desired size of item icon.
    )
{    
    DBG_ENTER(FTF_CPANEL, "CCplView::_CreateAndAddListItem");

    ASSERT(NULL != pParser);
    ASSERT(NULL != peList);
    ASSERT(NULL != pvSsListItem);
    ASSERT(NULL != puic);
    ASSERT(NULL != pszItemTemplate);

    DUI::Element *peListItem;
    HRESULT hr = Dui_CreateElement(pParser, pszItemTemplate, NULL, &peListItem);
    if (SUCCEEDED(hr))
    {
        if (NULL != pvSsListItem)
        {
            hr = Dui_SetElementStyleSheet(peListItem, pvSsListItem);
        }
        if (SUCCEEDED(hr))
        {
            ASSERTMSG(peListItem->GetClassInfo() == CLinkElement::Class, "CCplView::_CreateAndAddListItem didn't get a CLinkElement::Class object (%s)", peListItem->GetClassInfo()->GetName());
            CLinkElement *pLinkEle = static_cast<CLinkElement *>(peListItem);
            hr = pLinkEle->Initialize(puic, eIconSize);
            if (SUCCEEDED(hr))
            {
                if (SUCCEEDED(hr))
                {
                    hr = peList->Add(peListItem);
                    if (SUCCEEDED(hr))
                    {
                        peListItem = NULL;
                    }
                }
            }
            if (NULL != peListItem)
            {
                peListItem->Destroy();
            }
        }
    }
    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_CreateAndAddListItem", hr);
    return THR(hr);
}



//
// Determine if a given category item should be shown in the UI.
//
// Returns:
//      S_OK    - Include the item.
//      S_FALSE - Do not include the item.
//      Error   - Cannot determine.
//
HRESULT
CCplView::_IncludeCategory(
    ICplCategory *pCategory
    ) const
{
    HRESULT hr = S_OK;  // Assume it's included.
    
    //
    // If a category link invokes a restricted operation,
    // hide it from the UI.
    //
    IUICommand *puic;
    hr = pCategory->GetUiCommand(&puic);
    if (SUCCEEDED(hr))
    {
        UISTATE uis;
        hr = puic->get_State(NULL, TRUE, &uis);
        if (SUCCEEDED(hr))
        {
            if (UIS_HIDDEN == uis)
            {
                hr = S_FALSE;
            }
        }
        ATOMICRELEASE(puic);
    }
    return THR(hr);
}


//
// Map a category display index to a category index in the
// namespace.  Categories in the namespace are ordered to match up 
// with the various category IDs.  The view may be (and is) ordered
// differently and is subject to change based on usability feedback.
//
eCPCAT
CCplView::_DisplayIndexToCategoryIndex(
    int iCategory
    ) const
{
    //
    // This array determins the order the categories are displayed
    // in the category selection view.  To change the display order,
    // simply reorder these entries.
    //
    static const eCPCAT rgMap[] = { // Position in DUI grid control
        eCPCAT_APPEARANCE,          // Row 0, Col 0
        eCPCAT_HARDWARE,            // Row 0, Col 1
        eCPCAT_NETWORK,             // Row 1, Col 0
        eCPCAT_ACCOUNTS,            // Row 1, Col 1
        eCPCAT_ARP,                 // Row 2, Col 0
        eCPCAT_REGIONAL,            // Row 2, Col 1
        eCPCAT_SOUND,               // Row 3, Col 0
        eCPCAT_ACCESSIBILITY,       // Row 3, Col 1
        eCPCAT_PERFMAINT,           // Row 4, Col 0
        eCPCAT_OTHER                // Row 4, Col 1
        };

    ASSERT(ARRAYSIZE(rgMap) == eCPCAT_NUMCATEGORIES);
    ASSERT(iCategory >= 0 && iCategory < ARRAYSIZE(rgMap));
    return rgMap[iCategory];
}


HRESULT
CCplView::_CreateUiFileParser(
    DUI::Parser **ppParser
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_CreateUiFileParser");

    ASSERT(NULL != ppParser);
    ASSERT(!IsBadWritePtr(ppParser, sizeof(*ppParser)));

    char *pszUiFile;
    int cchUiFile;
    HINSTANCE hInstance; // Instance containing resources referenced in UI file.

    HRESULT hr = _BuildUiFile(&pszUiFile, &cchUiFile, &hInstance);
    if (SUCCEEDED(hr))
    {
        hr = Dui_CreateParser(pszUiFile, cchUiFile, hInstance, ppParser);   
        LocalFree(pszUiFile);
        if (HINST_THISDLL != hInstance)
        {
            ASSERT(NULL != hInstance);
            FreeLibrary(hInstance);
        }
    }

    DBG_EXIT(FTF_CPANEL, "CCplView::_CreateUiFileParser");
    return THR(hr);
}


//
//  Builds the UI file for this view from the
//  appropriate base template + style sheet
//
//  pUIFile receives a pointer to the ui file in memory
//  piCharCount receives the size of the file
//
HRESULT 
CCplView::_BuildUiFile(
    char **ppUIFile, 
    int *piCharCount,
    HINSTANCE *phInstance
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_BuildUiFile");

    ASSERT(NULL != ppUIFile);
    ASSERT(!IsBadWritePtr(ppUIFile, sizeof(*ppUIFile)));
    ASSERT(NULL != phInstance);
    ASSERT(!IsBadWritePtr(phInstance, sizeof(*phInstance)));

    *phInstance = NULL;

    //
    // Load the 'structure' UI file
    //
    char *pStructure;
    HRESULT hr = _LoadUiFileFromResources(HINST_THISDLL, IDR_DUI_CPVIEW, &pStructure);
    if (SUCCEEDED(hr))
    {
        HINSTANCE hStyleModule;
        UINT idStyle;
        hr = _GetStyleModuleAndResId(&hStyleModule, &idStyle);
        if (SUCCEEDED(hr))
        {
            //
            // Load the style sheet.  First, check if the current theme has a style sheet,
            // if not, use the default style sheet in the resources.
            //
            char *pStyle;
            hr = _LoadUiFileFromResources(hStyleModule, idStyle, &pStyle);
            if (SUCCEEDED(hr))
            {
                const int cbStyle      = lstrlenA(pStyle);
                const int cbStructure  = lstrlenA(pStructure);
                char *pResult = (char *)LocalAlloc(LPTR, cbStyle + cbStructure + 1);
                if (pResult)
                {
                    //
                    // Put the resouces together (style + structure)
                    //
                    CopyMemory(pResult, pStyle, cbStyle);
                    CopyMemory(pResult + cbStyle, pStructure, cbStructure);

                    ASSERT(cbStructure + cbStyle == lstrlenA(pResult));
                    *ppUIFile = pResult;
                    //
                    // This count is ANSI chars so we can use byte counts
                    // directly.
                    //
                    *piCharCount = cbStructure + cbStyle;
                    *phInstance  = hStyleModule;
                    //
                    // Indicate that HINSTANCE is being returned to caller.
                    //
                    hStyleModule = NULL;
                }
                else
                {
                    hr = E_OUTOFMEMORY;
                }
                LocalFree(pStyle);
            }
            if (NULL != hStyleModule && HINST_THISDLL != hStyleModule)
            {
                //
                // Something failed.  Need to free style module
                // if it's not shell32.dll.
                //
                FreeLibrary(hStyleModule);
            }
        }
        LocalFree(pStructure);
    }
    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_BuildUiFile", hr);
    return THR(hr);
}



HRESULT
CCplView::_GetStyleModuleAndResId(
    HINSTANCE *phInstance,
    UINT *pidStyle
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_GetStyleModuleAndResId");

    ASSERT(NULL != phInstance);
    ASSERT(!IsBadWritePtr(phInstance, sizeof(*phInstance)));
    ASSERT(NULL != pidStyle);
    ASSERT(!IsBadWritePtr(pidStyle, sizeof(*pidStyle)));

    HRESULT hr = S_OK;
    *phInstance = NULL;
    
    HINSTANCE hThemeModule = SHGetShellStyleHInstance();
    if (NULL != hThemeModule)
    {
        *pidStyle = IDR_DUI_CPSTYLE;
        *phInstance = hThemeModule;
    }
    else
    {
        TraceMsg(TF_CPANEL, "Error %d loading theme file", GetLastError());
        hr = ResultFromLastError();
    }

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_GetStyleModuleAndResId", hr);
    return THR(hr);
}



//
//  Loads the requested UI file from a module's resources.
//
//  iID         - UI file id
//  pUIFile     - receives a pointer to the UI file
//
HRESULT 
CCplView::_LoadUiFileFromResources(
    HINSTANCE hInstance, 
    int idResource, 
    char **ppUIFile
    )
{
    DBG_ENTER(FTF_CPANEL, "CCplView::_LoadUiFileFromResources");

    ASSERT(NULL != ppUIFile);
    ASSERT(!IsBadWritePtr(ppUIFile, sizeof(*ppUIFile)));

    HRESULT hr = E_FAIL;

    *ppUIFile = NULL;

    HRSRC hFile = FindResourceW(hInstance, MAKEINTRESOURCEW(idResource), L"UIFILE");
    if (hFile)
    {
        HGLOBAL hResource = LoadResource(hInstance, hFile);
        if (hResource)
        {
            char *pFile = (char *)LockResource(hResource);
            if (pFile)
            {
                DWORD dwSize = SizeofResource(hInstance, hFile);
                //
                // Include one extra byte for a terminating nul character.
                // We're loading text and want it to be nul-terminated.
                //
                *ppUIFile = (char *)LocalAlloc(LPTR, dwSize + 1);
                if (NULL != *ppUIFile)
                {
                    CopyMemory(*ppUIFile, pFile, dwSize);
                    hr = S_OK;
                }
                else
                {
                    hr = E_OUTOFMEMORY;
                }
            }
            else
            {
                hr = ResultFromLastError();
            }
        }
        else
        {
            hr = ResultFromLastError();
        }
    }
    else
    {
        hr = ResultFromLastError();
    }

    DBG_EXIT_HRES(FTF_CPANEL, "CCplView::_LoadUiFileFromResources", hr);
    return THR(hr);
}




HRESULT 
CPL::CplView_CreateInstance(
    IEnumIDList *penumIDs, 
    IUnknown *punkSite,
    REFIID riid,
    void **ppvOut
    )
{
    HRESULT hr = CCplView::CreateInstance(penumIDs, punkSite, riid, ppvOut);
    return THR(hr);
}


HRESULT 
CplView_GetCategoryTitle(
    eCPCAT eCategory, 
    LPWSTR pszTitle, 
    UINT cchTitle
    )
{
    ASSERT(NULL != pszTitle);
    ASSERT(!IsBadWritePtr(pszTitle, cchTitle * sizeof(*pszTitle)));

    //
    // These must remain in the same order as the eCPCAT_XXXXX enumeration.
    //
    static const UINT rgid[] = {
        IDS_CPCAT_OTHERCPLS_TITLE,
        IDS_CPCAT_APPEARANCE_TITLE,
        IDS_CPCAT_HARDWARE_TITLE,
        IDS_CPCAT_NETWORK_TITLE,
        IDS_CPCAT_SOUNDS_TITLE,
        IDS_CPCAT_PERFMAINT_TITLE,
        IDS_CPCAT_REGIONAL_TITLE,
        IDS_CPCAT_ACCESSIBILITY_TITLE,
        IDS_CPCAT_ARP_TITLE,
        IDS_CPCAT_ACCOUNTS_TITLE
        };

    HRESULT hr = S_OK;
    ASSERT(eCategory >= 0 && eCategory < eCPCAT_NUMCATEGORIES);
    if (0 == LoadString(HINST_THISDLL, rgid[int(eCategory)], pszTitle, cchTitle))
    {
        hr = ResultFromLastError();
    }
    return THR(hr);
}

} // namespace CPL

HRESULT InitializeCPClasses()
{
    HRESULT hr;

    hr = CPL::CLinkElement::Register();
    if (FAILED(hr))
        goto Failure;

    return S_OK;

Failure:

    return hr;
}