windows-server-2003/admin/activec/nodemgr/task.cpp

/*--------------------------------------------------------------------------*
 *
 *  Microsoft Windows
 *  Copyright (C) Microsoft Corporation, 1992 - 1999
 *
 *  File:      task.cpp
 *
 *  Contents:  Implementation file for CConsoleTask
 *
 *  History:   05-Oct-98 jeffro     Created
 *
 *--------------------------------------------------------------------------*/

#include "stdafx.h"
#include "regutil.h"
#include "tasks.h"
#include "nodepath.h"
#include "conview.h"

#ifdef DBG
// Traces
CTraceTag tagCTPHTML(TEXT("Console Taskpads"), TEXT("Dump HTML"));
#endif

extern CEOTSymbol s_rgEOTSymbol[];

/*+-------------------------------------------------------------------------*
 *  class CGlobalConsoleTaskList
 *
 * PURPOSE: A global console task list that provides unique IDs for all console tasks
 *          When a task is instantiated, its constructor registers in the global task list,
 *          and obtains a globally unique ID. This ID is unique for the process and should
 *          not be persisted.
 *          The destructor of the task removes it from this list.
 *
 * USAGE:   Call CGlobalConsoleTaskList::GetConsoleTask to obtain a pointer to the  task
 *          that has a specified ID.
 *          Call CConsoleTask::GetUniqueID to get the unique ID for a task.
 *
 *          Thus, CGlobalConsoleTaskList::GetConsoleTask(pConsoleTask->GetUniqueID()) == pConsoleTask
 *          is always true.
 *+-------------------------------------------------------------------------*/
class CGlobalConsoleTaskList
{
private:
    typedef const CConsoleTask *              PCONSOLETASK;
    typedef std::map<PCONSOLETASK, DWORD>     t_taskIDmap;

public:
    static DWORD Advise(  PCONSOLETASK pConsoleTask)
    {
        DWORD dwOut = s_curTaskID++;
        s_map[pConsoleTask] = dwOut;
        return dwOut;
    }

    static void Unadvise(PCONSOLETASK pConsoleTask)
    {
        s_map.erase(pConsoleTask);
    }

    static CConsoleTask * GetConsoleTask(DWORD dwID)
    {
        t_taskIDmap::iterator iter;
        for(iter = s_map.begin(); iter != s_map.end(); iter ++)
        {
            if(iter->second == dwID)
                return const_cast<CConsoleTask *>(iter->first);
        }

        return NULL;
    }

private:
    CGlobalConsoleTaskList() {}// private, so that it cannot be instantiated

    static t_taskIDmap            s_map;
    static DWORD                  s_curTaskID;
};

CGlobalConsoleTaskList::t_taskIDmap            CGlobalConsoleTaskList::s_map;
DWORD                  CGlobalConsoleTaskList::s_curTaskID = 0;

//############################################################################
//############################################################################
//
//  Implementation of class CConsoleTask
//
//############################################################################
//############################################################################


/*+-------------------------------------------------------------------------*
 * CConsoleTask::CConsoleTask
 *
 *
 *--------------------------------------------------------------------------*/
DEBUG_DECLARE_INSTANCE_COUNTER(CConsoleTask);

CConsoleTask::CConsoleTask() :
    m_eConsoleTaskType (eTask_Result),
//  default ctor for m_strName
//  default ctor for m_strDescription
//  default ctor for m_strCommand
//  default ctor for m_strParameters
//  default ctor for m_strDirectory
    m_eWindowState     (eState_Restored),
//  default ctor for m_image
    m_dwFlags          (0),
    m_bmScopeNode      (false),
    m_fDirty           (false),
    m_pctpOwner        (NULL),
    m_dwUniqueID       (CGlobalConsoleTaskList::Advise(this)) // create a unique ID for this task
{
    DEBUG_INCREMENT_INSTANCE_COUNTER(CConsoleTask);
}

/*+-------------------------------------------------------------------------*
 * CConsoleTask::CConsoleTask(const CConsoleTask& other)
 *
 * PURPOSE: Copy ctor.
 *
 * PARAMETERS: const CConsoleTask& other
 *
 * NOTE: Calls operator=, cant use default copy ctor (see operator= imp.)
 *
/*+-------------------------------------------------------------------------*/
CConsoleTask::CConsoleTask (const CConsoleTask &rhs):
    m_dwUniqueID       (CGlobalConsoleTaskList::Advise(this))
{
    DEBUG_INCREMENT_INSTANCE_COUNTER(CConsoleTask);
    *this = rhs;
}

/*+-------------------------------------------------------------------------*
 *
 * CConsoleTask::GetConsoleTask
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *    DWORD  dwUniqueID :
 *
 * RETURNS:
 *    CConsoleTask *
 *
 *+-------------------------------------------------------------------------*/
CConsoleTask *
CConsoleTask::GetConsoleTask(DWORD dwUniqueID)
{
    return CGlobalConsoleTaskList::GetConsoleTask(dwUniqueID);
}


/*+-------------------------------------------------------------------------*
 *
 * ScReplaceString
 *
 * PURPOSE: Replaces all occurrences of the token by its replacement.
 *
 * PARAMETERS:
 *    CStr &   str :
 *    LPCTSTR  szToken :
 *    LPCTSTR  szReplacement :
 *
 * RETURNS:
 *    static SC
 *
 *+-------------------------------------------------------------------------*/
static SC
ScReplaceString(CStr &str, LPCTSTR szToken, LPCTSTR szReplacement, bool bMustReplace = true)
{
    DECLARE_SC(sc, TEXT("ScReplaceString"));

    CStr strTemp = str;
    str = TEXT("");

    int i = strTemp.Find(szToken);
    if( (-1==i) && bMustReplace)
        return (sc = E_UNEXPECTED);

    while(-1!=i)
    {
        str += strTemp.Left(i);
        str += szReplacement;

        strTemp = strTemp.Mid(i+_tcslen(szToken)); // the remaining string

        i=strTemp.Find(szToken);
    }

    str += strTemp;

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * ScUseJavaScriptStringEntities
 *
 * PURPOSE: Use this to create a valid Javascript string. Replaces " by \" and
 *          \ by \\ in the string parameter.
 *
 * PARAMETERS:
 *    CStr & str :
 *
 * RETURNS:
 *    static SC
 *
 *+-------------------------------------------------------------------------*/
static SC
ScUseJavaScriptStringEntities(CStr &str)
{
    DECLARE_SC(sc, TEXT("ScUseJavaScriptStringEntities"));

    // NOTE: don't change the order of these string replacements

    sc = ScReplaceString(str, TEXT("\\"), TEXT("\\\\"), false);
    if(sc)
        return sc;

    sc = ScReplaceString(str, TEXT("\""), TEXT("\\\""), false);
    if(sc)
        return sc;

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * ScUseHTMLEntities
 *
 * PURPOSE:  Replaces " by &quot; < by &lt; and > by &gt; and & by &amp; in the string parameter.
 *
 * PARAMETERS:
 *    CStr & str :
 *
 * RETURNS:
 *    static SC
 *
 *+-------------------------------------------------------------------------*/
static SC
ScUseHTMLEntities(CStr &str)
{
    DECLARE_SC(sc, TEXT("ScUseHTMLEntities"));

    sc = ScReplaceString(str, TEXT("&"), TEXT("&amp;"), false);
    if(sc)
        return sc;

    sc = ScReplaceString(str, TEXT("\""), TEXT("&quot;"), false);
    if(sc)
        return sc;

    sc = ScReplaceString(str, TEXT("<"), TEXT("&lt;"), false);
    if(sc)
        return sc;

    sc = ScReplaceString(str, TEXT(">"), TEXT("&gt;"), false);
    if(sc)
        return sc;

    return sc;
}


/*+-------------------------------------------------------------------------*
 *
 * CConsoleTask::ScGetHTML
 *
 * PURPOSE: returns the HTML representation of the task.
 *
 * PARAMETERS:
 *    LPCTSTR  szFmtHTML :
 *    CStr &   strTaskHTML :
 *    bool     bUseLargeIcons :    Draw in the no-list (large icon) style
 *    bool     bUseTextDescriptions :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
CConsoleTask::ScGetHTML(LPCTSTR szFmtHTML, CStr &strTaskHTML, bool bUseLargeIcons, bool bUseTextDescriptions) const
{
    DECLARE_SC(sc, TEXT("CConsoleTask::ScGetHTML"));
    USES_CONVERSION;

    // the substitution parameters, in order
    CStr    strTableSpacing            = bUseLargeIcons ? TEXT("<BR />") : TEXT("");
    int     iconWidth                  = bUseLargeIcons ? 32: 20;
    int     iconHeight                 = bUseLargeIcons ? 32: 16;
    //      iconWidth and iconHeight repeated
    int     uniqueID                   = GetUniqueID();
    CStr    strSmall                   = bUseLargeIcons ? TEXT("0") : TEXT("1");
    CStr    strHref;
    CStr    strID;
    CStr    strParameter;
    CStr    strOptionalTitleTag;
    CStr    strOptionalTextDescription;
    CStr    strTaskName                = GetName().data();
    CStr    strDescription             = GetDescription().data();
    CStr    strCommand                 = GetCommand().data();

    // use entities for all strings
    sc = ScUseHTMLEntities(strTaskName);
    if(sc)
        return sc;

    sc = ScUseHTMLEntities(strDescription);
    if(sc)
        return sc;

    sc = ScUseJavaScriptStringEntities(strCommand);
    if(sc)
        return sc;

    //------
    if(bUseTextDescriptions)
    {
        strOptionalTextDescription =  TEXT("<BR />");
        strOptionalTextDescription += strDescription;
    }
    else
    {
        strOptionalTitleTag.Format(TEXT("title='%s'"), (LPCTSTR) strDescription);
    }

    switch(GetTaskType())
    {
    case eTask_Scope:
        {
            std::wstring strTemp;

            // get the bookmark of the scope node.
            sc = m_bmScopeNode.ScSaveToString(&strTemp);
            if(sc)
                return sc;

            CStr strScopeNodeBookmark = W2CT(strTemp.data()); // make sure that special characters have been converted
            sc = ScUseJavaScriptStringEntities(strScopeNodeBookmark);
            if(sc)
                return sc;

            strHref.Format(TEXT("external.ExecuteScopeNodeMenuItem(\"%s\", \"%s\");"), (LPCTSTR)strCommand, (LPCTSTR)strScopeNodeBookmark);
        }

        strID=L"ScopeTask";
        break;

    case eTask_Result:
        strHref.Format(TEXT("external.ExecuteSelectionMenuItem(\"%s\");"), (LPCTSTR)strCommand);
        strParameter = strCommand;
        strID        = TEXT("ResultTask");
        break;

    case eTask_CommandLine:
        {
            strParameter = GetParameters().data();
            sc = ScUseJavaScriptStringEntities(strParameter);
            if(sc)
                return sc;

            CStr strDirectory = GetDirectory().data();
            sc = ScUseJavaScriptStringEntities(strDirectory);
            if(sc)
                return sc;

            // get the window state
            CStr strWindowState;

            if(GetWindowState() ==eState_Restored)
                strWindowState = XML_ENUM_WINDOW_STATE_RESTORED;

            else if(GetWindowState() == eState_Minimized)
                strWindowState = XML_ENUM_WINDOW_STATE_MINIMIZED;

            else
                strWindowState = XML_ENUM_WINDOW_STATE_MAXIMIZED;

            strHref.Format(TEXT("external.ExecuteShellCommand(\"%s\", \"%s\", ParseParameters(\"%s\"), \"%s\");"),
                           (LPCTSTR)strCommand, (LPCTSTR)strDirectory, (LPCTSTR)strParameter, (LPCTSTR)strWindowState);
        }
        strID=L"CommandLineTask";

        break;

    case eTask_Target:
        strHref.Format(TEXT("external.ExecuteScopeNodeMenuItem(\"%s\");"), (LPCTSTR)strCommand);
        strParameter = strCommand;
        strID        = L"TargetTask";
        break;

    case eTask_Favorite:
        {
            std::wstring strTemp;
            // save the memento to a string
            sc = const_cast<CMemento *>(&m_memento)->ScSaveToString(&strTemp);
            if(sc)
                return sc;

            CStr strMemento = W2CT(strTemp.data());

            sc = ScUseJavaScriptStringEntities(strMemento);
            if(sc)
                return sc;

            strHref.Format(TEXT("external.ViewMemento(\"%s\");"), (LPCTSTR)strMemento);
        }
        strID=L"FavoriteTask";
        break;

    default:
        break;
    }


    strTaskHTML.Format(szFmtHTML, (LPCTSTR) strTableSpacing, iconWidth, iconHeight, uniqueID, iconWidth, iconHeight,
                       uniqueID, (LPCTSTR) strSmall, uniqueID, uniqueID, (LPCTSTR) strID, (LPCTSTR) strParameter,
                       (LPCTSTR) strOptionalTitleTag, (LPCTSTR)strTaskName, (LPCTSTR) strOptionalTextDescription,
                       uniqueID, uniqueID, uniqueID, (LPCTSTR) strHref);

    Trace(tagCTPHTML, TEXT("%s"), (LPCTSTR)strTaskHTML);

    return sc;
}


/*+-------------------------------------------------------------------------*
 *
 * CConsoleTask::IsDirty
 *
 * PURPOSE: Determines whether the task needs to be saved.
 *
 * RETURNS:
 *    bool
 *
 *+-------------------------------------------------------------------------*/
bool
CConsoleTask::IsDirty() const
{
    TraceDirtyFlag(TEXT("CConsoleTask"), m_fDirty);
    return (m_fDirty);
}

/*+-------------------------------------------------------------------------*
 * CConsoleTask::operator =
 *
 * PURPOSE: Assignment operator
 *
 * PARAMETERS: const CConsoleTask& rhs
 *
 * RETURNS:
 *      CConsoleTask &
 *
/*+-------------------------------------------------------------------------*/
CConsoleTask &
CConsoleTask::operator =(const CConsoleTask& rhs)
{
    if (this != &rhs)
    {
        m_eConsoleTaskType  = rhs.m_eConsoleTaskType;
        m_strName           = rhs.m_strName;
        m_strDescription    = rhs.m_strDescription;
        m_strCommand        = rhs.m_strCommand;
        m_strParameters     = rhs.m_strParameters;
        m_strDirectory      = rhs.m_strDirectory;
        m_eWindowState      = rhs.m_eWindowState;
        m_dwFlags           = rhs.m_dwFlags;
        m_bmScopeNode       = rhs.m_bmScopeNode;
        m_dwSymbol          = rhs.m_dwSymbol;
        m_smartIconCustomLarge  = rhs.m_smartIconCustomLarge;
        m_smartIconCustomSmall  = rhs.m_smartIconCustomSmall;
        m_memento           = rhs.m_memento;

        m_fDirty            = rhs.m_fDirty;
        m_pctpOwner         = rhs.m_pctpOwner;
        // m_dwUniqueID       = rhs.m_dwUniqueID; DO NOT copy this ID
    }

    return *this;
}

/*+-------------------------------------------------------------------------*
 *
 * CConsoleTask::operator ==
 *
 * PURPOSE: Equality operator. Checks that the command string is
 *          equal to the given menuitem's Path or Language Independent Path.
 *
 *+-------------------------------------------------------------------------*/
bool
CConsoleTask::operator==(const CMenuItem & menuItem) const
{
    // check that the command string matches either the path or the language independent path.

    if( (m_strCommand == menuItem.GetPath()) ||
        (m_strCommand == menuItem.GetLanguageIndependentPath() )
      )
        return true;

    return false;
}

/*+-------------------------------------------------------------------------*
 * CConsoleTask::~CConsoleTask
 *
 *
 *--------------------------------------------------------------------------*/

CConsoleTask::~CConsoleTask ()
{
    DEBUG_DECREMENT_INSTANCE_COUNTER(CConsoleTask);

    CGlobalConsoleTaskList::Unadvise(this); // remove this task from the list.
}


/*+-------------------------------------------------------------------------*
 *
 * CConsoleTask::HasCustomIcon
 *
 * PURPOSE: Returns whether the task has a custom icon
 *
 * RETURNS:
 *    bool
 *
 *+-------------------------------------------------------------------------*/
bool
CConsoleTask::HasCustomIcon()   const
{
    if((HICON)m_smartIconCustomLarge != NULL)
    {
        ASSERT((HICON)m_smartIconCustomSmall != NULL);
        return true;
    }

    return false;
}


/*+-------------------------------------------------------------------------*
 *
 * CConsoleTask::Reset
 *
 * PURPOSE:
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CConsoleTask::ResetUI()
{
    m_bmScopeNode.ResetUI();
}

/*+-------------------------------------------------------------------------*
 *
 * CConsoleTask::SetSymbol
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *    DWORD  dwSymbol :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CConsoleTask::SetSymbol(DWORD dwSymbol)
{
    m_dwSymbol = dwSymbol;
    m_smartIconCustomSmall.Release();
    m_smartIconCustomLarge.Release();
    SetDirty();
}

/*+-------------------------------------------------------------------------*
 *
 * CConsoleTask::SetCustomIcon
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *    CSmartIcon& iconSmall :
 *    CSmartIcon& iconLarge :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CConsoleTask::SetCustomIcon(CSmartIcon& iconSmall, CSmartIcon& iconLarge)
{
    m_smartIconCustomSmall = iconSmall;
    m_smartIconCustomLarge = iconLarge;
    SetDirty();
}


/*+-------------------------------------------------------------------------*
 * CConsoleTask::Enable
 *
 * Sets the enable state for a task.
 *--------------------------------------------------------------------------*/

void CConsoleTask::Enable (bool fEnable)
{
    if (fEnable)
        m_dwFlags &= ~eFlag_Disabled;
    else
        m_dwFlags |= eFlag_Disabled;

    SetDirty ();
}

void
CConsoleTask::Draw (HDC hdc, RECT *lpRect, bool bSmall) const  // Draw into a DC.
{
    if(HasCustomIcon())
    {
        DrawIconEx(hdc, lpRect->left, lpRect->top, bSmall ? m_smartIconCustomSmall : m_smartIconCustomLarge,
               bSmall? 16 : 32, bSmall? 16 : 32, 0, NULL, DI_NORMAL);
        return;
    }

    for(int i = 0; i< NUM_SYMBOLS; i++)
    {
        if(s_rgEOTSymbol[i].GetValue() == m_dwSymbol)
        {
            s_rgEOTSymbol[i].Draw(hdc, lpRect, bSmall);
            return;
        }
    }

	/*
	 * if we get here, we couldn't find the EOT symbol matching m_dwSymbol
	 */
	ASSERT (false);
}


/*+-------------------------------------------------------------------------*
 * CConsoleTask::SetName
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTask::SetName (const tstring& strName)
{
    if (m_strName != strName)
    {
        m_strName = strName;
        SetDirty ();
    }
}


/*+-------------------------------------------------------------------------*
 * CConsoleTask::SetDescription
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTask::SetDescription (const tstring& strDescription)
{
    if (m_strDescription != strDescription)
    {
        m_strDescription = strDescription;
        SetDirty ();
    }
}

/*+-------------------------------------------------------------------------*
 * CConsoleTask::SetCommand
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTask::SetCommand (const tstring& strCommand)
{
    if (m_strCommand != strCommand)
    {
        m_strCommand = strCommand;
        SetDirty ();
    }
}

/*+-------------------------------------------------------------------------*
 * CConsoleTask::SetParameters
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTask::SetParameters (const tstring& strParameters)
{
    if (m_strParameters != strParameters)
    {
        m_strParameters = strParameters;
        SetDirty ();
    }
}

/*+-------------------------------------------------------------------------*
 * CConsoleTask::SetDirectory
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTask::SetDirectory (const tstring& strDirectory)
{
    if (m_strDirectory != strDirectory)
    {
        m_strDirectory = strDirectory;
        SetDirty ();
    }
}


void CConsoleTask::SetMemento(const CMemento &memento)
{
    if( m_memento != memento)
    {
        m_memento = memento;
        SetDirty();
    }
}

/*+-------------------------------------------------------------------------*
 * CConsoleTask::SetWindowState
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTask::SetWindowState (eWindowState eNewState)
{
    if (m_eWindowState != eNewState)
    {
        m_eWindowState = eNewState;
        SetDirty ();
    }
}

/*+-------------------------------------------------------------------------*
 * CConsoleTask::RetargetScopeNode
 *
 * PURPOSE: Sets the target scope node for the task. Note: the task must be
 *           of type eTask_Scope.
 *
 * PARAMETERS:
 *      CNode *  pNewNode:
 *
 * RETURNS:
 *      bool
 */
/*+-------------------------------------------------------------------------*/
bool
CConsoleTask::RetargetScopeNode(CNode *pNewNode)
{
    bool fRet = TRUE;

    ASSERT(GetTaskType() == eTask_Scope);

    CMTNode* pMTNewNode = (pNewNode) ? pNewNode->GetMTNode() : NULL;

    m_bmScopeNode.ScRetarget(pMTNewNode, false /*bFastRetrievalOnly*/);

    SetDirty();
    return fRet;
}

/*+-------------------------------------------------------------------------*
 * CConsoleTask::GetScopeNode
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *      IScopeTree *  pScopeTree:
 *
 * RETURNS:
 *      CMTNode *
 *
/*+-------------------------------------------------------------------------*/
CMTNode *
CConsoleTask::GetScopeNode(IScopeTree *pScopeTree) const
{
    DECLARE_SC(sc, TEXT("CConsoleTask::GetScopeNode"));

    CMTNode *pMTNode = NULL;
    bool bExactMatchFound = false; // out value from ScGetMTNode, unused
    sc = m_bmScopeNode.ScGetMTNode(true /*bExactMatchRequired*/, &pMTNode, bExactMatchFound);
    if(sc.IsError())
        return NULL;

    return (pMTNode);
}



/*+-------------------------------------------------------------------------*
 * CConsoleTask::GetScopeNode
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *      CViewData *  pViewData:
 *
 * RETURNS:
 *      CNode *
/*+-------------------------------------------------------------------------*/
std::auto_ptr<CNode>
CConsoleTask::GetScopeNode(CViewData *pViewData) const
{
    return m_bmScopeNode.GetNode(pViewData);
}


/*+-------------------------------------------------------------------------*
 *
 * CConsoleTask::Persist
 *
 * PURPOSE: Persists the console task to the specified persistor.
 *
 *
 * PARAMETERS:
 *    CPersistor & persistor :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CConsoleTask::Persist(CPersistor &persistor)
{

    persistor.PersistString(XML_ATTR_TASK_NAME,         m_strName);

    // define the table to map enumeration values to strings
    static const EnumLiteral mappedTaskTypes[] =
    {
        { eTask_Scope,            XML_ENUM_TASK_TYPE_SCOPE },
        { eTask_Result,           XML_ENUM_TASK_TYPE_RESULT },
        { eTask_CommandLine,      XML_ENUM_TASK_TYPE_COMMANDLINE },
        { eTask_Target,           XML_ENUM_TASK_TYPE_TARGET },
        { eTask_Favorite,         XML_ENUM_TASK_TYPE_FAVORITE },
    };


    // create wrapper to persist flag values as strings
    CXMLEnumeration taskTypePersistor(m_eConsoleTaskType, mappedTaskTypes, countof(mappedTaskTypes));
    // persist the wrapper
    persistor.PersistAttribute(XML_ATTR_TASK_TYPE,      taskTypePersistor);

    persistor.PersistString(XML_ATTR_TASK_DESCRIPTION,  m_strDescription);

    {
        /* this section creates
            <ConsoleTask>
                <SYMBOL id = "">
                    <IMAGE name = "LargeIcon" ... />   NOTE: either the id or the images are present.
                    <IMAGE name = "SmallIcon" ... />
                </SYMBOL>
            </ConsoleTask>
         */

        // create a child element for the symbol
        CPersistor persistorSymbol(persistor, XML_TAG_EOT_SYMBOL_INFO);

        if(persistorSymbol.IsLoading())
        {
            m_dwSymbol = (DWORD)-1; // initialize
        }

        if(persistorSymbol.IsLoading() ||
           (persistorSymbol.IsStoring() && !HasCustomIcon() ) )
        {
            // save the "ID" attribute only if there is no icon
            persistorSymbol.PersistAttribute(XML_ATTR_EOT_SYMBOL_DW_SYMBOL,   m_dwSymbol, attr_optional);
        }

        if((persistorSymbol.IsStoring() && HasCustomIcon()) ||
           (persistorSymbol.IsLoading() && (m_dwSymbol == (DWORD) -1)  )
           )
        {
			persistorSymbol.Persist (m_smartIconCustomSmall, XML_NAME_ICON_SMALL);
			persistorSymbol.Persist (m_smartIconCustomLarge, XML_NAME_ICON_LARGE);
        }
    }

    persistor.PersistAttribute(XML_ATTR_TASK_COMMAND,   m_strCommand);

    // define the table to map enumeration values to strings
    static const EnumLiteral mappedTaskFlags[] =
    {
        { eFlag_Disabled, XML_BITFLAG_TASK_DISABLED },
    };

    // create wrapper to persist flag values as strings
    CXMLBitFlags taskFlagPersistor(m_dwFlags, mappedTaskFlags, countof(mappedTaskFlags));
    // persist the wrapper
    persistor.PersistAttribute(XML_ATTR_TASK_FLAGS, taskFlagPersistor);

    switch (m_eConsoleTaskType)
    {
        case eTask_Scope:
            persistor.Persist(m_bmScopeNode);
            break;

        case eTask_CommandLine:
        {
            CPersistor persistorCmd(persistor, XML_TAG_TASK_CMD_LINE);
            persistorCmd.PersistAttribute(XML_ATTR_TASK_CMD_LINE_DIR, m_strDirectory);

            // define the table to map enumeration values to strings
            static const EnumLiteral windowStates[] =
            {
                { eState_Restored,      XML_ENUM_WINDOW_STATE_RESTORED },
                { eState_Minimized,     XML_ENUM_WINDOW_STATE_MINIMIZED },
                { eState_Maximized,     XML_ENUM_WINDOW_STATE_MAXIMIZED },
            };

            // create wrapper to persist flag values as strings
            CXMLEnumeration windowStatePersistor(m_eWindowState, windowStates, countof(windowStates));
            // persist the wrapper
            persistorCmd.PersistAttribute(XML_ATTR_TASK_CMD_LINE_WIN_ST, windowStatePersistor);

            persistorCmd.PersistAttribute(XML_ATTR_TASK_CMD_LINE_PARAMS, m_strParameters);
            break;
        }

        case eTask_Favorite:
            persistor.Persist(m_memento);
            break;
    }

    // either read or saved - not dirty after the operation
    SetDirty(false);
}


/*+-------------------------------------------------------------------------*
 * CConsoleTask::ReadSerialObject
 *
 *
 *--------------------------------------------------------------------------*/
HRESULT
CConsoleTask::ReadSerialObject (IStream &stm, UINT nVersion /*,LARGE_INTEGER nBytes*/)
{
    HRESULT hr = S_FALSE;   // assume unknown version

    if (nVersion == 1)
    {
        try
        {
            // ugly hackery required to extract directly into an enum
            stm >> *((int *) &m_eConsoleTaskType);
            stm >> m_strName;
            stm >> m_strDescription;

            // legacy task symbol info
            {
                // this must be BOOL not bool to occupy the same amount of space as in legacy consoles
                // See Bug #101253
                BOOL bLegacyUseMMCSymbols = TRUE; // a now obsolete field, read for console file compatibility
                tstring strFileLegacy, strFontLegacy;

                stm >> m_dwSymbol;
                stm >> bLegacyUseMMCSymbols;
                stm >> strFileLegacy; // obsolete
                stm >> strFontLegacy; // obsolete
            }

            stm >> m_strCommand;
            stm >> m_dwFlags;

            switch (m_eConsoleTaskType)
            {
                case eTask_Scope:
                    stm >> m_bmScopeNode;
                    break;

                case eTask_CommandLine:
                    stm >> m_strDirectory;
                    // ugly hackery required to extract directly into an enum
                    stm >> *((int *) &m_eWindowState);
                    stm >> m_strParameters;
                    break;

                case eTask_Favorite:
                    hr = m_memento.Read(stm);
                    if(FAILED(hr))
                        return hr;
                    break;
            }

            hr = S_OK;
        }
        catch (_com_error& err)
        {
            hr = err.Error();
            ASSERT (false && "Caught _com_error");
        }
    }

    return (hr);
}



/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::CConsoleTaskpad
 *
 *
 *--------------------------------------------------------------------------*/

CConsoleTaskpad::CConsoleTaskpad (CNode* pTargetNode /*=NULL*/) :
    m_listSize(eSize_Default),   // the default space given to a taskpad.
    m_guidNodeType(GUID_NULL),
    m_guidID(GUID_NULL),
    m_bmTargetNode(),
    m_pMTNodeTarget(NULL),
    m_bNodeSpecific(false),
    m_dwOrientation(TVO_VERTICAL), // the default is a vertical taskpad for consistency with the Extended view.
    m_bReplacesDefaultView(true) // taskpads do not show the normal tab by default.
{
    Retarget (pTargetNode);

    HRESULT hr = CoCreateGuid(&m_guidID);
    ASSERT(SUCCEEDED(hr));

    SetDirty (false);
}

bool
CConsoleTaskpad::IsValid(CNode *pNode) const
{
    ASSERT(pNode != NULL);

    if(!HasTarget())
        return true; // a taskpad without a target is valid for any node. $REVIEW

    if(!pNode)
        return false; // Cannot use a taskpad with a target.

    if(IsNodeSpecific())
    {
        // use this taskpad if it is targetted at the same node. $OPTIMIZE.
        return (*pNode->GetMTNode()->GetBookmark() == m_bmTargetNode);
    }
    else
    {
        GUID guid;
        HRESULT hr = pNode->GetNodeType(&guid);
        if(FAILED(hr))
            return false; // don't use this taskpad.

        return (MatchesNodeType(guid)); // use only if node types match.
    }


}

static CStr g_szTaskpadCommonHTMLTemplate;
static CStr g_szVerticalTaskpadHTMLTemplate;
static CStr g_szHorizontalTaskpadHTMLTemplate;
static CStr g_szNoResultsTaskpadHTMLTemplate;
static CStr g_szTaskHTMLTemplate;
/*+-------------------------------------------------------------------------*
 *
 * ScLoadHTMLTemplate
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *    HINSTANCE  hinstLibrary :
 *    LPCTSTR    szHTMLTemplateResourceName :
 *    CStr&      str :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
ScLoadHTMLTemplate(HINSTANCE hinstLibrary, LPCTSTR szHTMLTemplateResourceName, CStr& str)
{
    DECLARE_SC(sc, TEXT("ScLoadHTMLTemplate"));

    sc = ScCheckPointers(hinstLibrary, szHTMLTemplateResourceName);
    if(sc)
        return sc;

    HRSRC hFindRes = ::FindResource(hinstLibrary, szHTMLTemplateResourceName, RT_HTML);
    if(!hFindRes)
        return (sc = E_UNEXPECTED);

    DWORD dwResSize = ::SizeofResource(hinstLibrary, hFindRes);
    if(!dwResSize)
        return (sc = E_UNEXPECTED);

    HGLOBAL hRes = ::LoadResource(hinstLibrary, hFindRes);
    ASSERT(hRes);

    char *pvRes = (char *)::LockResource(hRes);  // no need to Unlock the resource - see the SDK entry for LockResource
    sc = ScCheckPointers(pvRes);
    if(sc)
        return sc;

    std::string strTemp; // initially create an ANSI string
    strTemp.assign(pvRes, dwResSize);
    strTemp+="\0"; // null terminate it

    USES_CONVERSION;
    str = A2CT(strTemp.data());

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * ScLoadHTMLTemplates
 *
 * PURPOSE:
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
ScLoadHTMLTemplates()
{
    DECLARE_SC(sc, TEXT("ScLoadHTMLTemplates"));

    static BOOL bInitialized = false;
    if(bInitialized)
        return sc;

    // load the library into memory.
    TCHAR szBuffer[MAX_PATH];

    DWORD cchSize = countof(szBuffer);
    DWORD dwRet = ::GetModuleFileName(_Module.GetModuleInstance(), szBuffer, cchSize);
    if(0==dwRet)
        return (sc = E_UNEXPECTED);

    // NTRAID#NTBUG9-616478-2002/05/07-ronmart-prefast  warning 53: Call to 'GetModuleFileNameW' may not zero-terminate string
    szBuffer[cchSize - 1] = 0;

    HINSTANCE hinstLibrary = ::LoadLibraryEx(szBuffer, 0, LOAD_LIBRARY_AS_DATAFILE);
    if(!hinstLibrary)
        return (sc = E_UNEXPECTED);

    sc = ScLoadHTMLTemplate(hinstLibrary, TEXT("CTPCOMMON.HTM"), g_szTaskpadCommonHTMLTemplate);
    if(sc)
        goto Error;

    sc = ScLoadHTMLTemplate(hinstLibrary, TEXT("CTPVERT.HTM"), g_szVerticalTaskpadHTMLTemplate);
    if(sc)
        goto Error;

    sc = ScLoadHTMLTemplate(hinstLibrary, TEXT("CTPHORIZ.HTM"), g_szHorizontalTaskpadHTMLTemplate);
    if(sc)
        goto Error;

    sc = ScLoadHTMLTemplate(hinstLibrary, TEXT("CTPNORESULTS.HTM"), g_szNoResultsTaskpadHTMLTemplate);
    if(sc)
        goto Error;

    sc = ScLoadHTMLTemplate(hinstLibrary, TEXT("CTPTASK.HTM"), g_szTaskHTMLTemplate);
    if(sc)
        goto Error;

    bInitialized = true;

Cleanup:
    FreeLibrary(hinstLibrary);
    return sc;
Error:
    sc = E_UNEXPECTED;
    goto Cleanup;

}

/*+-------------------------------------------------------------------------*
 *
 * CConsoleTaskpad::ScGetHTML
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *    CStr & strTaskpadHTML :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
CConsoleTaskpad::ScGetHTML(CStr &strTaskpadHTML) const
{
    DECLARE_SC(sc, TEXT("CConsoleTaskpad::ScGetHTML"));

    sc = ScLoadHTMLTemplates();
    if(sc)
        return sc;


    CStr strTasksHTML;

    // get the HTML for all the tasks
    for (TaskConstIter it = m_Tasks.begin(); it != m_Tasks.end(); ++it)
    {
        CStr strTemp;
        sc = it->ScGetHTML(g_szTaskHTMLTemplate, strTemp, GetOrientation() & TVO_NO_RESULTS /*bUseLargeIcons*/, GetOrientation() & TVO_DESCRIPTIONS_AS_TEXT);
        if(sc)
            return sc;

        strTasksHTML += strTemp;
    }

    strTaskpadHTML = g_szTaskpadCommonHTMLTemplate;

    // append the orientation-specific portion
    CStr *pstrOrientationSpecificHTML = NULL;

    if(GetOrientation() & TVO_HORIZONTAL)
        pstrOrientationSpecificHTML = &g_szHorizontalTaskpadHTMLTemplate;

    else if (GetOrientation() & TVO_VERTICAL)
        pstrOrientationSpecificHTML = &g_szVerticalTaskpadHTMLTemplate;

    else
        pstrOrientationSpecificHTML = &g_szNoResultsTaskpadHTMLTemplate;

    sc = ScCheckPointers(pstrOrientationSpecificHTML, E_UNEXPECTED);
    if(sc)
        return sc;

    // this replacement must be done first
    sc = ScReplaceString(strTaskpadHTML, TEXT("@@ORIENTATIONSPECIFICHTML@@"), *pstrOrientationSpecificHTML);
    if(sc)
        return sc;

    sc = ScReplaceString(strTaskpadHTML, TEXT("@@TASKS@@"), strTasksHTML);
    if(sc)
        return sc;

    sc = ScReplaceString(strTaskpadHTML, TEXT("@@TASKWIDTH@@"), GetOrientation() & TVO_VERTICAL ? TEXT("100%") : TEXT("30%")); // only one task per row for vertical taskpads
    if(sc)
        return sc;

    CStr strName = GetName().data();
    sc = ScUseHTMLEntities(strName);
    if(sc)
        return sc;

    CStr strDescription = GetDescription().data();
    sc = ScUseHTMLEntities(strDescription);
    if(sc)
        return sc;

    sc = ScReplaceString(strTaskpadHTML, TEXT("@@CONSOLETASKPADNAME@@"), strName);
    if(sc)
        return sc;

    sc = ScReplaceString(strTaskpadHTML, TEXT("@@CONSOLETASKPADDESCRIPTION@@"), strDescription);
    if(sc)
        return sc;

    if (GetOrientation() & TVO_VERTICAL)
    {
        // small, medium and large list sizes correspond to taskpad areas of 262, 212, and 166 pixels respectively
        CStr strLeftPaneWidth;
        if(GetListSize()==eSize_Small)
            strLeftPaneWidth=TEXT("262");
        if(GetListSize()==eSize_Medium)
            strLeftPaneWidth=TEXT("212");
        if(GetListSize()==eSize_Large)
            strLeftPaneWidth=TEXT("166");

        sc = ScReplaceString(strTaskpadHTML, TEXT("@@LEFTPANEWIDTH@@"), strLeftPaneWidth);
        if(sc)
            return sc;
    }
    else if (GetOrientation() & TVO_HORIZONTAL)
    {
        // small, medium and large list sizes correspond to taskpad heights of 200, 150, and 100 pixels respectively
        CStr strBottomPaneHeight;

        if(GetListSize()==eSize_Small)
            strBottomPaneHeight=TEXT("200");
        if(GetListSize()==eSize_Medium)
            strBottomPaneHeight=TEXT("150");
        if(GetListSize()==eSize_Large)
            strBottomPaneHeight=TEXT("100");

        sc = ScReplaceString(strTaskpadHTML, TEXT("@@BOTTOMPANEHEIGHT@@"), strBottomPaneHeight);
        if(sc)
            return sc;
    }

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * CConsoleTaskpad::Reset
 *
 * PURPOSE:
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CConsoleTaskpad::ResetUI()
{
    // reset all the contained tasks.
    for (TaskIter iter = BeginTask(); iter!=EndTask(); ++iter)
    {
        iter->ResetUI();
    }

    // reset the member bookmark
    m_bmTargetNode.ResetUI();
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::Retarget
 *
 *
 *--------------------------------------------------------------------------*/

bool CConsoleTaskpad::Retarget (CMTNode* pMTNewNode, bool fReset)
{
    /*
     * if we were given a new node...
     */
    if (pMTNewNode != NULL)
    {
        // Ensure the  MTNode is initialized.
        if (!pMTNewNode->IsInitialized())
        {
            HRESULT hr = pMTNewNode->Init();
            ASSERT(SUCCEEDED(hr));
        }

        /*
         * ...if we've already been targeted to a particular node
         * type, prevent retargeting to a different node type
         */
        if ( (!fReset) && (m_guidNodeType != GUID_NULL))
        {
            GUID guidNewNodeType;
            pMTNewNode->GetNodeType (&guidNewNodeType);

            if (guidNewNodeType != m_guidNodeType)
                return (false);
        }

        /*
         * otherwise, this is the first non-NULL node we've been
         * targeted to; get its node type
         */
        else
            pMTNewNode->GetNodeType (&m_guidNodeType);

        /*
         * If this is a new taskpad, default the taskpad's name
         * to the target node's display name.  The taskpad
         * description and tooltip default to empty.
         */
        if (m_strName.str().empty() || fReset)
        {
            m_strName = pMTNewNode->GetDisplayName();
            ASSERT (m_strDescription.str().empty());
            ASSERT (m_strTooltip.str().empty());
        }
    }

    m_bmTargetNode.ScRetarget(pMTNewNode, false /*bFastRetrievalOnly*/);
    m_pMTNodeTarget = pMTNewNode;

    SetDirty ();
    return (true);
}

bool CConsoleTaskpad::Retarget (CNode* pNewNode)
{
    CMTNode* pMTNewNode = (pNewNode != NULL) ? pNewNode->GetMTNode() : NULL;

    return (Retarget (pMTNewNode));
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::SetName
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTaskpad::SetName (const tstring& strName)
{
    SetStringMember (m_strName, strName);
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::SetDescription
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTaskpad::SetDescription (const tstring& strDescription)
{
    SetStringMember (m_strDescription, strDescription);
}


void CConsoleTaskpad::SetListSize(const ListSize listSize)
{
    m_listSize = listSize;
    SetDirty();
}

/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::SetToolTip
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTaskpad::SetToolTip (const tstring& strTooltip)
{
    SetStringMember (m_strTooltip, strTooltip);
}


void
CConsoleTaskpad::SetNodeSpecific  (bool bNodeSpecific)
{
    m_bNodeSpecific = bNodeSpecific;
    SetDirty();
}

void
CConsoleTaskpad::SetReplacesDefaultView(bool bReplacesDefaultView)
{
    m_bReplacesDefaultView = bReplacesDefaultView;
    SetDirty();
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::SetStringMember
 *
 * Changes the value of a string member variable, and marks the taskpad
 * dirty, if and only if the new value is different than the old value.
 *--------------------------------------------------------------------------*/

void CConsoleTaskpad::SetStringMember (
    CStringTableString& strMember,
    const tstring&      strNewValue)
{
    if (strMember != strNewValue)
    {
        strMember = strNewValue;
        SetDirty ();
    }
}

/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::AddTask
 *
 *
 *--------------------------------------------------------------------------*/

CConsoleTaskpad::TaskIter
CConsoleTaskpad::AddTask (const CConsoleTask& task)
{
    return (InsertTask (m_Tasks.end(), task));
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::InsertTask
 *
 *
 *--------------------------------------------------------------------------*/

CConsoleTaskpad::TaskIter
CConsoleTaskpad::InsertTask (
    TaskIter            itTaskBeforeWhichToInsert,
    const CConsoleTask& task)
{
    TaskIter itInserted = m_Tasks.insert (itTaskBeforeWhichToInsert, task);
    SetDirty ();

    return (itInserted);
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::EraseTask
 *
 *
 *--------------------------------------------------------------------------*/

CConsoleTaskpad::TaskIter
CConsoleTaskpad::EraseTask (
    TaskIter itErase)
{
    SetDirty ();
    return (m_Tasks.erase (itErase));
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::EraseTasks
 *
 *
 *--------------------------------------------------------------------------*/

CConsoleTaskpad::TaskIter
CConsoleTaskpad::EraseTasks (
    TaskIter itFirst,
    TaskIter itLast)
{
    SetDirty ();
    return (m_Tasks.erase (itFirst, itLast));
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::ClearTasks
 *
 *
 *--------------------------------------------------------------------------*/

void CConsoleTaskpad::ClearTasks ()
{
    SetDirty ();
    m_Tasks.clear ();
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::IsDirty
 *
 * Determines if this taskpad or any of its contained tasks is are dirty.
 *--------------------------------------------------------------------------*/

bool CConsoleTaskpad::IsDirty () const
{
    /*
     * if the taskpad is dirty, short out
     */
    if (m_fDirty)
    {
        TraceDirtyFlag(TEXT("CConsoleTaskpad"), true);
        return (true);
    }

    /*
     * the taskpad is clean, check each task
     */
    for (TaskConstIter it = m_Tasks.begin(); it != m_Tasks.end(); ++it)
    {
        if (it->IsDirty())
        {
            TraceDirtyFlag(TEXT("CConsoleTaskpad"), true);
            return (true);
        }
    }

    TraceDirtyFlag(TEXT("CConsoleTaskpad"), false);
    return (false);
}


/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::GetTargetMTNode
 *
 *
 *--------------------------------------------------------------------------*/

CMTNode* CConsoleTaskpad::GetTargetMTNode (IScopeTree* pScopeTree)
{
    DECLARE_SC(sc, TEXT("CConsoleTaskpad::GetTargetMTNode"));

    if(!HasTarget())
        return NULL;

    if(!m_pMTNodeTarget)
    {
        CMTNode *pMTNode = NULL;
        bool bExactMatchFound = false; // out value from ScGetMTNode, unused
        sc = m_bmTargetNode.ScGetMTNode(true /*bExactMatchRequired*/, &pMTNode, bExactMatchFound);
        if(sc.IsError() || !pMTNode)
            return NULL;


        m_pMTNodeTarget = pMTNode;
    }

    return (m_pMTNodeTarget);
}

/*+-------------------------------------------------------------------------*
 *
 * CConsoleTaskpad::Persist
 *
 * PURPOSE: Persists the console taskpad to the specified persistor.
 *
 * PARAMETERS:
 *    CPersistor & persistor :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void
CConsoleTaskpad::Persist(CPersistor &persistor)
{
    persistor.PersistString(XML_ATTR_TASKPAD_NAME,              m_strName);
    persistor.PersistString(XML_ATTR_TASKPAD_DESCRIPTION,       m_strDescription);
    persistor.PersistString(XML_ATTR_TASKPAD_TOOLTIP,           m_strTooltip);

    // define the table to map enumeration values to strings
    static const EnumLiteral mappedSize[] =
    {
        { eSize_Large,  XML_ENUM_LIST_SIZE_LARGE },
        { eSize_Medium, XML_ENUM_LIST_SIZE_MEDIUM },
        { eSize_None,   XML_ENUM_LIST_SIZE_NONE },
        { eSize_Small,  XML_ENUM_LIST_SIZE_SMALL },
    };

    // create wrapper to persist flag values as strings
    CXMLEnumeration listSizePersistor(m_listSize, mappedSize, countof(mappedSize));

    // initialize the value suitably
    if(persistor.IsLoading())
        m_listSize = eSize_Default;

    // persist the wrapper
    persistor.PersistAttribute(XML_ATTR_TASKPAD_LIST_SIZE,  listSizePersistor, attr_optional); // optional because this was introduced late

    persistor.PersistAttribute(XML_ATTR_TASKPAD_NODE_SPECIFIC,    CXMLBoolean(m_bNodeSpecific));
    persistor.PersistAttribute(XML_ATTR_REPLACES_DEFAULT_VIEW,    CXMLBoolean(m_bReplacesDefaultView), attr_optional);


    // define the table to map enumeration values to strings
    static const EnumLiteral mappedOrientation[] =
    {
        { TVO_HORIZONTAL,               XML_BITFLAG_TASK_ORIENT_HORIZONTAL },
        { TVO_VERTICAL,                 XML_BITFLAG_TASK_ORIENT_VERTICAL },
        { TVO_NO_RESULTS,               XML_BITFLAG_TASK_ORIENT_NO_RESULTS },
        { TVO_DESCRIPTIONS_AS_TEXT,     XML_BITFLAG_TASK_ORIENT_DESCRIPTIONS_AS_TEXT },
    };

    // create wrapper to persist flag values as strings
    CXMLBitFlags orientationPersistor(m_dwOrientation, mappedOrientation, countof(mappedOrientation));
    // persist the wrapper
    persistor.PersistAttribute(XML_ATTR_TASKPAD_ORIENTATION, orientationPersistor );

    persistor.Persist(m_Tasks);
    persistor.PersistAttribute(XML_ATTR_TASKPAD_NODE_TYPE,        m_guidNodeType);
    persistor.PersistAttribute(XML_ATTR_TASKPAD_ID,               m_guidID);

    persistor.Persist(m_bmTargetNode, XML_NAME_TARGET_NODE);

    // either read or saved - not dirty after the operation
    SetDirty(false);
}

/*+-------------------------------------------------------------------------*
 * CConsoleTaskpad::ReadSerialObject
 *
 *
 *--------------------------------------------------------------------------*/

HRESULT
CConsoleTaskpad::ReadSerialObject (IStream &stm, UINT nVersion)
{
    HRESULT hr = S_FALSE;   // assume unknown version


    if(nVersion==1)
    {
        try
        {
            do  // not a loop
            {
                bool fLegacyHasTarget = true; // an unused field
                UINT visualPercent    = 25;   // replaced by m_listSize

                stm >> m_strName;
                stm >> m_strDescription;
                stm >> m_strTooltip;
                stm >> visualPercent;

                m_listSize = eSize_Medium;
                if(visualPercent==25)
                    m_listSize = eSize_Large;
                else if(visualPercent==75)
                    m_listSize = eSize_Small;

                stm >> m_bNodeSpecific;
                m_bReplacesDefaultView = false; // this was introduced in mmc2.0.
                stm >> m_dwOrientation;

                hr = ::Read(stm, m_Tasks);
                BREAK_ON_FAIL (hr);

                stm >> m_guidNodeType;
                stm >> m_guidID;
                stm >> fLegacyHasTarget;
                stm >> m_bmTargetNode;

                // legacy task symbol info
                {
                    BOOL bLegacyUseMMCSymbols = TRUE; // a now obsolete field, read for console file compatibility
                    tstring strFileLegacy, strFontLegacy;
                    DWORD   dwSymbol = 0;

                    stm >> dwSymbol;
                    stm >> bLegacyUseMMCSymbols;
                    stm >> strFileLegacy; // obsolete
                    stm >> strFontLegacy; // obsolete
                }



                hr = S_OK;      // success!

            } while (false);
        }
        catch (_com_error& err)
        {
            hr = err.Error();
            ASSERT (false && "Caught _com_error");
        }
    }

    return (hr);
}


//############################################################################
//############################################################################
//
//  Implementation of class CConsoleTaskpadList
//
//############################################################################
//############################################################################
/*+-------------------------------------------------------------------------*
 *
 * CConsoleTaskpadList::ScGetTaskpadList
 *
 * PURPOSE: Returns the list of all taskpads that are appropriate for the current node.
 *
 * PARAMETERS:
 *    CNode *                       pNode :
 *    CConsoleTaskpadFilteredList & filteredList : [OUT]: The list of taskpads
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
CConsoleTaskpadList::ScGetTaskpadList(CNode *pNode, CConsoleTaskpadFilteredList &filteredList)
{
    DECLARE_SC(sc, TEXT("CConsoleTaskpadList::ScGetTaskpadList"));

    sc = ScCheckPointers(pNode);
    if(sc)
        return sc;

    // 1. add all built- in taskpads

    for(iterator iter = begin(); iter != end(); ++iter)
    {
        CConsoleTaskpad *pConsoleTaskpad = &*iter;
        if(pConsoleTaskpad->IsValid(pNode))
        {
            filteredList.push_back(pConsoleTaskpad);
        }
    }

    return sc;
}

HRESULT
CConsoleTaskpadList::ReadSerialObject (IStream &stm, UINT nVersion)
{
    HRESULT hr = S_FALSE;       // assume unknown version

    clear();

    if(nVersion == 1)
    {
        try
        {
            DWORD cItems;
            stm >> cItems;

            for(int i=0; i< cItems; i++)
            {
                CConsoleTaskpad taskpad;
                hr = taskpad.Read(stm);
                BREAK_ON_FAIL (hr);
                push_back(taskpad);
            }
        }
        catch (_com_error& err)
        {
            hr = err.Error();
            ASSERT (false && "Caught _com_error");
        }
    }

    return hr;
}

//############################################################################
//############################################################################
//
//  Implementation of class CDefaultTaskpadList
//
//############################################################################
//############################################################################
HRESULT
CDefaultTaskpadList::ReadSerialObject (IStream &stm, UINT nVersion)
{
    HRESULT hr = S_FALSE;       // assume unknown version

    clear();

    if(nVersion == 1)
    {
        try
        {
            /*
             * TODO: investigate using template operator>> for a map (stgio.h)
             */

            DWORD cItems;
            stm >> cItems;

            for(int i=0; i< cItems; i++)
            {
                GUID guidNodetype, guidTaskpad;
                stm >> guidNodetype;
                stm >> guidTaskpad;
                operator[](guidNodetype) = guidTaskpad;
            }

            hr = S_OK;
        }
        catch (_com_error& err)
        {
            hr = err.Error();
            ASSERT (false && "Caught _com_error");
        }
    }

    return hr;
}