windows-xp/Source/XPSP1/NT/admin/activec/conui/amcdoc.cpp

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//
//  Copyright (C) Microsoft Corporation, 1999 - 1999
//
//  File:       amcdoc.cpp
//
//--------------------------------------------------------------------------

// AMCDoc.cpp : implementation of the CAMCDoc class
//


#include "stdafx.h"
#include "AMC.h"

#include "AMCDoc.h"
#include "AMCView.h"
#include "treectrl.h"
#include "mainfrm.h"
#include "cclvctl.h"
#include "props.h"
#include <algorithm>
#include <vector>
#include <list>

#include "amcmsgid.h"
#include "amcpriv.h"
#include "mmcutil.h"
#include "ndmgrp.h"
#include "strtable.h"
#include "stgio.h"
#include "comdbg.h"
#include "favorite.h"
#include "mscparser.h"
#include "scriptevents.h"
// helper
tstring GetCurrentFileVersionAsString();

//############################################################################
//############################################################################
//
//  Implementation of class CMMCDocument
//
//############################################################################
//############################################################################
/*+-------------------------------------------------------------------------*
 * class CMMCDocument
 *
 *
 * PURPOSE: The COM 0bject that exposes the Document interface.
 *
 *+-------------------------------------------------------------------------*/
class CMMCDocument :
    public CMMCIDispatchImpl<Document>,
    public CTiedComObject<CAMCDoc>
{
protected:
    typedef CAMCDoc CMyTiedObject;

public:
    BEGIN_MMC_COM_MAP(CMMCDocument)
    END_MMC_COM_MAP()

    //Document interface
public:
    MMC_METHOD0(Save);
    MMC_METHOD1(SaveAs,         BSTR /*bstrFilename*/);
    MMC_METHOD1(Close,          BOOL /*bSaveChanges*/);
    MMC_METHOD1(CreateProperties, PPPROPERTIES  /*ppProperties*/);

    // properties
    MMC_METHOD1(get_Views,      PPVIEWS   /*ppViews*/);
    MMC_METHOD1(get_SnapIns,    PPSNAPINS /*ppSnapIns*/);
    MMC_METHOD1(get_ActiveView, PPVIEW    /*ppView*/);
    MMC_METHOD1(get_Name,       PBSTR     /*pbstrName*/);
    MMC_METHOD1(put_Name,       BSTR      /*bstrName*/);
    MMC_METHOD1(get_Location,   PBSTR    /*pbstrLocation*/);
    MMC_METHOD1(get_IsSaved,    PBOOL    /*pBIsSaved*/);
    MMC_METHOD1(get_Mode,       PDOCUMENTMODE /*pMode*/);
    MMC_METHOD1(put_Mode,       DocumentMode /*mode*/);
    MMC_METHOD1(get_RootNode,   PPNODE     /*ppNode*/);
    MMC_METHOD1(get_ScopeNamespace, PPSCOPENAMESPACE  /*ppScopeNamespace*/);
    MMC_METHOD1(get_Application, PPAPPLICATION  /*ppApplication*/);
};

/*+-------------------------------------------------------------------------*
 * class CMMCViews
 *
 *
 * PURPOSE: The COM 0bject that exposes the Views interface.
 *
 *+-------------------------------------------------------------------------*/

// the real CMMCViews is typedef'd below.
class _CMMCViews :
    public CMMCIDispatchImpl<Views>, // the Views interface
    public CTiedComObject<CAMCDoc>
{
protected:

    typedef CAMCDoc CMyTiedObject;

public:
    BEGIN_MMC_COM_MAP(_CMMCViews)
    END_MMC_COM_MAP()

    // Views interface
public:
    MMC_METHOD1(get_Count,  PLONG /*pCount*/);
    MMC_METHOD2(Add,        PNODE /*pNode*/, ViewOptions /*fViewOptions*/);
    MMC_METHOD2(Item,       long  /*Index*/, PPVIEW /*ppView*/);
};

// this typedefs the real CMMCViews class. Implements get__NewEnum using CMMCEnumerator and a CAMCViewPosition object
typedef CMMCNewEnumImpl<_CMMCViews, CAMCViewPosition> CMMCViews;


//############################################################################
//############################################################################
//
//  Implementation of class CStringTableString
//
//############################################################################
//############################################################################

/*+-------------------------------------------------------------------------*
 * CStringTableString::GetStringTable
 *
 *
 *--------------------------------------------------------------------------*/
IStringTablePrivate* CStringTableString::GetStringTable () const
{
    return (CAMCDoc::GetDocument()->GetStringTable());
}

void ShowAdminToolsOnMenu(LPCTSTR lpszFilename);


enum ENodeType
{
    entRoot,
    entSelected,
};

//############################################################################
//############################################################################
//
//  Implementation of class CAMCDoc
//
//############################################################################
//############################################################################

IMPLEMENT_DYNCREATE(CAMCDoc, CDocument)

BEGIN_MESSAGE_MAP(CAMCDoc, CDocument)
    //{{AFX_MSG_MAP(CAMCDoc)
    ON_UPDATE_COMMAND_UI(ID_FILE_SAVE, OnUpdateFileSave)
    ON_COMMAND(ID_CONSOLE_ADDREMOVESNAPIN, OnConsoleAddremovesnapin)
    ON_UPDATE_COMMAND_UI(ID_CONSOLE_ADDREMOVESNAPIN, OnUpdateConsoleAddremovesnapin)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CAMCDoc construction/destruction

CAMCDoc* CAMCDoc::m_pDoc = NULL;

CAMCDoc::CAMCDoc()
    :   m_MTNodeIDForNewView(ROOTNODEID),
        m_ViewIDForNewView(0),
        m_lNewWindowOptions(MMC_NW_OPTION_NONE),
        m_bReadOnlyDoc(false),
        m_fFrameModified (false),
        m_eSaveStatus (eStat_Succeeded),
        m_pFavorites(NULL)
{
    TRACE_CONSTRUCTOR(CAMCDoc);
    DECLARE_SC (sc, TEXT("CAMCDoc::CAMCDoc"));

    CComObject<CMasterStringTable> * pStringTable;

    sc = CComObject<CMasterStringTable>::CreateInstance (&pStringTable);
    if(sc.IsError() || !pStringTable)
    {
        sc = E_OUTOFMEMORY;
        sc.FatalError();
    }

    m_spStringTable = pStringTable; // does the addref.
    if(m_spStringTable == NULL)
    {
        delete pStringTable;
        sc = E_UNEXPECTED;
        sc.FatalError();
    }

    m_pstrCustomTitle = new CStringTableString(m_spStringTable);
    if(!m_pstrCustomTitle)
    {
        sc = E_OUTOFMEMORY;
        sc.FatalError();
    }

    if (m_pDoc)
        m_pDoc->OnCloseDocument();

    // Set default version update dialog to one appropriate for explicit saves
    SetExplicitSave(true);
    m_pDoc = this;

    m_ConsoleData.m_pConsoleDocument = this;
}

CAMCDoc::~CAMCDoc()
{
    TRACE_DESTRUCTOR(CAMCDoc);

    if (m_pDoc == this)
        m_pDoc = NULL;

    if(m_pFavorites != NULL)
    {
        delete m_pFavorites;
        m_pFavorites = NULL;
    }

    delete m_pstrCustomTitle;

    // Tell the node manager to release it's reference on the scope tree
    IFramePrivatePtr spFrame;

    HRESULT hr = spFrame.CreateInstance(CLSID_NodeInit, NULL, MMC_CLSCTX_INPROC);

    if (hr == S_OK)
    {
        spFrame->SetScopeTree(NULL);
        ReleaseNodeManager();
    }

    /*
     * if we used a custom icon, revert to the default icon on the frame
     */
    if (m_CustomIcon)
    {
        CMainFrame* pMainFrame = AMCGetMainWnd();

        if (pMainFrame != NULL)
        {
            pMainFrame->SetIconEx (NULL, true);
            pMainFrame->SetIconEx (NULL, false);
        }
    }
}

void CAMCDoc::ReleaseNodeManager()
{
    m_spScopeTreePersist = NULL;
    m_spScopeTree = NULL;
    m_spStorage = NULL;
}


//############################################################################
//############################################################################
//
//  CAMCDoc Object model methods.
//
//############################################################################
//############################################################################

// Document interface

/*+-------------------------------------------------------------------------*
 * CAMCDoc::ScCreateProperties
 *
 * Creates an empty Properties collection.
 *
 * Returns:
 *      E_UNEXPECTED    scope tree wasn't available
 *      other           value returned by IScopeTree::CreateProperties
 *--------------------------------------------------------------------------*/

SC CAMCDoc::ScCreateProperties (Properties** ppProperties)
{
    DECLARE_SC (sc, _T("CAMCDoc::ScCreateProperties"));

    /*
     * insure we have a scope tree; ppProperties will be validated downstream
     */
    if (m_spScopeTree == NULL)
        return (sc = E_UNEXPECTED);

    /*
     * get the scope tree to create a Properties collection for us
     */
    sc = m_spScopeTree->CreateProperties (ppProperties);
    if (sc)
        return (sc);

    return (sc);
}

/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::ScEnumNext
 *
 * PURPOSE: Returns the next item in the enumeration sequence
 *
 * PARAMETERS:
 *    _Position & pos :
 *    PDISPATCH & pDispatch :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::ScEnumNext(CAMCViewPosition &pos, PDISPATCH & pDispatch)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScEnumNext"));

    CAMCView *pView = GetNextAMCView(pos);

    if(NULL ==pView) // ran out of elements
    {
        sc = S_FALSE;
        return sc;
    }

    // at this point, we have a valid CAMCView.
    ViewPtr spMMCView = NULL;

    sc = pView->ScGetMMCView(&spMMCView);
    if(sc)
        return sc;

    if(spMMCView == NULL)
    {
        sc = E_UNEXPECTED;  // should never happen.
        return sc;
    }

    /*
     * return the IDispatch for the object and leave a ref on it for the client
     */
    pDispatch = spMMCView.Detach();

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::ScEnumSkip
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *    unsigned   long :
 *    CAMCViewPosition & pos :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::ScEnumSkip(unsigned long celt, unsigned long& celtSkipped,
                    CAMCViewPosition &pos)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScEnumSkip"));

    // skip celt positions, don't check the last skip.
    for(celtSkipped=0; celtSkipped<celt; celtSkipped++)
    {
        if (pos == NULL)
        {
            sc = S_FALSE;
            return sc;
        }

        // go to the next view
        GetNextAMCView(pos);
    }

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::ScEnumReset
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *    CAMCViewPosition & pos :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::ScEnumReset(CAMCViewPosition &pos)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScEnumReset"));

    // reset the position to the first view.
    pos = GetFirstAMCViewPosition();

    return sc;
}


//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::ScSave
//
//  Synopsis:    Saves the document.
//
//  Arguments:   None
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::ScSave ()
{
    DECLARE_SC(sc, _T("CAMCDoc::ScSave"));

    // Return if there is no file name given.
    if (m_strPathName.IsEmpty())
        return sc = ScFromMMC(IDS_UnableToSaveDocumentMessage);

    // save the document (this function may produce UI, but we tried ^ to avoid it)
    if (!DoFileSave())
        return sc = ScFromMMC(IDS_UnableToSaveDocumentMessage);

    return (sc);
}


/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::ScSaveAs
 *
 * PURPOSE: Saves the console file, using the specified filename.
 *
 * PARAMETERS:
 *    BSTR  bstrFilename : The path to save the file to.
 *
 * RETURNS:
 *    STDMETHODIMP
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::ScSaveAs(BSTR bstrFilename)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScSaveAs"));

    USES_CONVERSION;

    LPCTSTR lpctstrName = OLE2T(bstrFilename);
    if(!OnSaveDocument(lpctstrName))
    {
        sc = ScFromMMC(IDS_UnableToSaveDocumentMessage);
        return sc;
    }
    else
    {
        DeleteHelpFile ();
        SetPathName(lpctstrName);
    }

    return sc;
}

/***************************************************************************\
 *
 * METHOD:  CAMCDoc::ScClose
 *
 * PURPOSE: implements Document.Close for object model
 *
 * PARAMETERS:
 *    BOOL bSaveChanges - save changes before closing
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC
CAMCDoc::ScClose(BOOL bSaveChanges)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScClose"));

    if (bSaveChanges)
    {
        // cannot save ned document this way!
        if (m_strPathName.IsEmpty())
            return sc = ScFromMMC(IDS_UnableToSaveDocumentMessage);

        // check for property sheets open
        if (FArePropertySheetsOpen(NULL))
            return sc = ScFromMMC(IDS_ClosePropertyPagesBeforeClosingTheDoc);

        // save the document (this function may produce UI, but we tried ^ to avoid it)
        if (!DoFileSave())
            return sc = ScFromMMC(IDS_UnableToSaveDocumentMessage);
    }

    OnCloseDocument();

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::ScItem
 *
 * PURPOSE: Returns the view specified by the index.
 *
 * PARAMETERS:
 *    long    Index :
 *    View ** ppView :
 *
 * RETURNS:
 *    STDMETHOD
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::ScItem(long Index, PPVIEW ppView)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScItem"));

    // check parameters
    if( (Index <= 0) ||  (Index > GetNumberOfViews()) || (!ppView) )
    {
        sc = E_INVALIDARG;
        return sc;
    }

    // step to the appropriate view
    CAMCViewPosition pos = GetFirstAMCViewPosition();
    CAMCView *pView = NULL;

    for (int nCount = 0; (nCount< Index) && (pos != NULL); )
    {
        pView = GetNextAMCView(pos);
        VERIFY (++nCount);
    }

    // make sure we have a valid view.

    if( (nCount != Index) || (!pView) )
    {
        sc = E_UNEXPECTED;
        return sc;
    }

    sc = pView->ScGetMMCView(ppView);
    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * ScMapViewOptions
 *
 * PURPOSE: helper function maps ViewOptions to view creation flags
 *
 * PARAMETERS:
 *    pNode :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/

static SC ScMapViewOptions( ViewOptions fViewOptions, DWORD &value)
{
    DECLARE_SC(sc, TEXT("ScMapViewOptions"));

    value = MMC_NW_OPTION_NONE;

    // test to see if parameter is correct
    const DWORD mask = (ViewOption_ScopeTreeHidden |
                        ViewOption_NoToolBars |
                        ViewOption_NotPersistable
                       );

    if (fViewOptions & (~mask))
        sc = E_INVALIDARG;

    if (fViewOptions & ViewOption_ScopeTreeHidden)
        value |= MMC_NW_OPTION_NOSCOPEPANE;
    if (fViewOptions & ViewOption_NotPersistable)
        value |= MMC_NW_OPTION_NOPERSIST;
    if (fViewOptions & ViewOption_NoToolBars)
        value |= MMC_NW_OPTION_NOTOOLBARS;

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::ScAdd
 *
 * PURPOSE: Impelements Views.Add method
 *
 * PARAMETERS:
 *    pNode :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::ScAdd( PNODE pNode, ViewOptions fViewOptions )
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScAdd"));

    // lock AppEvents until this function is done
    LockComEventInterface(AppEvents);

    sc = ScCheckPointers(m_spScopeTree, E_POINTER);
    if (sc)
        return sc;

    DWORD dwOptions = 0;
    sc = ScMapViewOptions( fViewOptions, dwOptions );
    if (sc)
        return sc;

    MTNODEID id;
    sc = m_spScopeTree->GetNodeID(pNode, &id);
    if (sc)
        return sc;

    // Set the given node-id as the root.
    SetMTNodeIDForNewView(id);
    SetNewWindowOptions(dwOptions);
    CreateNewView( true );
    SetMTNodeIDForNewView(ROOTNODEID);

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::Scget_Views
 *
 * PURPOSE: Returns a pointer to the Views interface
 *          (which is implemented by the same object, but need not be)
 *
 * PARAMETERS:
 *    Views ** ppViews :
 *
 * RETURNS:
 *    STDMETHODIMP
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::Scget_Views(PPVIEWS ppViews)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::Scget_Views"));

    if(!ppViews)
    {
        sc = E_POINTER;
        return sc;
    }

    // init out parameter
    *ppViews = NULL;

    // create a Views if needed.
    sc = CTiedComObjectCreator<CMMCViews>::ScCreateAndConnect(*this, m_spViews);
    if(sc)
        return sc;

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

    // addref the pointer for the client.
    m_spViews->AddRef();
    *ppViews = m_spViews;

    return sc;
}

/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::Scget_SnapIns
 *
 * PURPOSE: returns a pointer to the SnapIns object.
 *
 * PARAMETERS:
 *    SnapIns ** ppSnapIns :
 *
 * RETURNS:
 *    STDMETHODIMP
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::Scget_SnapIns(PPSNAPINS ppSnapIns)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::Scget_SnapIns"));

    if((NULL==ppSnapIns) || (NULL == m_spScopeTree) )
    {
        sc = E_POINTER;
        return sc;
    }

    sc = m_spScopeTree->QuerySnapIns(ppSnapIns);

    return sc;
}


/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::Scget_ScopeNamespace
 *
 * PURPOSE: returns a pointer to the ScopeNamespace object.
 *
 * PARAMETERS:
 *    ScopeNamespace ** ppScopeNamespace :
 *
 * RETURNS:
 *    STDMETHODIMP
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::Scget_ScopeNamespace(PPSCOPENAMESPACE ppScopeNamespace)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::Scget_ScopeNamespace"));

    if((NULL==ppScopeNamespace) || (NULL == m_spScopeTree) )
    {
        sc = E_POINTER;
        return sc;
    }

    sc = m_spScopeTree->QueryScopeNamespace(ppScopeNamespace);

    return sc;
}


/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::Scget_Count
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *    long * pCount :
 *
 * RETURNS:
 *    STDMETHODIMP
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::Scget_Count(PLONG pCount)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::Scget_Count"));

    // check parameters
    if(!pCount)
    {
        sc = E_POINTER;
        return sc;
    }

    // this should *not* be GetNumberOfPersistedViews
    *pCount = GetNumberOfViews();

    return sc;
}

//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::Scget_Name
//
//  Synopsis:    Retrive the name of the current doc.
//
//  Arguments:   [pbstrName] - Ptr to the name to be returned.
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::Scget_Name (PBSTR pbstrName)
{
    DECLARE_SC(sc, _T("CAMCDoc::Scget_Name"));
    sc = ScCheckPointers(pbstrName);
    if (sc)
        return sc;

    CString strPath = GetPathName();

    *pbstrName = strPath.AllocSysString();

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::Scput_Name
//
//  Synopsis:    Sets the name of the current document.
//
//  Arguments:   [bstrName] - The new name.
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::Scput_Name(BSTR bstrName)
{
    DECLARE_SC(sc, _T("CAMCDoc::Scput_Name"));

    USES_CONVERSION;
    LPCTSTR lpszPath = OLE2CT(bstrName);

    SetPathName(lpszPath, FALSE /*Dont add to MRU*/);

    return (sc);
}


//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::Scget_Mode
//
//  Synopsis:    Retrieve the document mode.
//
//  Arguments:   [pMode] - Ptr to doc mode.
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::Scget_Mode (PDOCUMENTMODE pMode)
{
    DECLARE_SC(sc, _T("CAMCDoc::Scget_Mode"));
    sc = ScCheckPointers(pMode);
    if (sc)
        return sc;

    if (! GetDocumentMode(pMode))
        return (sc = E_FAIL);

    return (sc);
}


//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::Scput_Mode
//
//  Synopsis:    Modify the document mode.
//
//  Arguments:   [mode] - new mode for the document.
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::Scput_Mode (DocumentMode mode)
{
    DECLARE_SC(sc, _T("CAMCDoc::Scput_Mode"));

    // SetDocumentMode fails if document mode is invalid.
    if (! SetDocumentMode(mode))
        return (sc = E_INVALIDARG);

    return (sc);
}


//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::Scget_ActiveView
//
//  Synopsis:    Retrieve the Active View object.
//
//  Arguments:   [ppView] - Ptr to a ptr of View object.
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::Scget_ActiveView (PPVIEW ppView)
{
    DECLARE_SC(sc, _T("CAMCDoc::Scget_ActiveView"));
    sc = ScCheckPointers(ppView);
    if (sc)
        return sc;

    *ppView = NULL;

    CMainFrame* pMainFrame = AMCGetMainWnd();
    sc = ScCheckPointers(pMainFrame, E_UNEXPECTED);
    if (sc)
        return sc;

    CAMCView *pView = pMainFrame->GetActiveAMCView();
    if (! pView)
    {
        return (sc = ScFromMMC(IDS_NoActiveView)); // There are no active views.
    }

    // at this point, we have a valid CAMCView.
    ViewPtr spMMCView = NULL;

    sc = pView->ScGetMMCView(&spMMCView);
    if(sc)
        return sc;

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

    /*
     * return the object and leave a ref on it for the client
     */
    *ppView = spMMCView.Detach();

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::Scget_IsSaved
//
//  Synopsis:    Returns whether the file was saved. If not,
//               it is dirty and needs to be saved.
//
//  Arguments:   [pBIsSaved] - Ptr to BOOL (IsSaved info).
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::Scget_IsSaved (PBOOL pBIsSaved)
{
    DECLARE_SC(sc, _T("CAMCDoc::Scget_IsSaved"));
    sc = ScCheckPointers(pBIsSaved);
    if (sc)
        return sc;

    *pBIsSaved = (IsModified() == FALSE);

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::Scget_Location
//
//  Synopsis:    Gets the location of the current document.
//
//  Arguments:   [pbstrLocation] - Ptr to BSTR string in which result is returned.
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::Scget_Location (PBSTR    pbstrLocation)
{
    DECLARE_SC(sc, _T("CAMCDoc::Scget_Location"));
    sc = ScCheckPointers(pbstrLocation);
    if (sc)
        return sc;

    CString strFullPath = GetPathName();

    // Even if path is empty below code will return empty string.
    int nSlashLoc = strFullPath.ReverseFind(_T('\\'));
    CString strLocation = strFullPath.Left(nSlashLoc);

    *pbstrLocation = strLocation.AllocSysString();

    return (sc);
}

//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::Scget_RootNode
//
//  Synopsis:    Returns the console root node.
//
//  Arguments:   [ppNode] - Ptr to ptr to root node obj.
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::Scget_RootNode (PPNODE     ppNode)
{
    DECLARE_SC(sc, _T("CAMCDoc::Scget_RootNode"));
    sc = ScCheckPointers(ppNode);
    if (sc)
        return sc;

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

    sc = m_spScopeTree->QueryRootNode(ppNode);

    return (sc);
}


/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::ScGetMMCDocument
 *
 * PURPOSE: Creates, AddRef's, and returns a pointer to the tied COM object.
 *
 * PARAMETERS:
 *    Document ** ppDocument :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::ScGetMMCDocument(Document **ppDocument)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScGetMMCDocument"));

    // parameter check
    sc = ScCheckPointers(ppDocument);
    if (sc)
        return sc;

    // init out parameter
    *ppDocument = NULL;

    // create a CAMCDoc if needed.
    sc = CTiedComObjectCreator<CMMCDocument>::ScCreateAndConnect(*this, m_sp_Document);
    if(sc)
        return sc;

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

    // addref the pointer for the client.
    m_sp_Document->AddRef();
    *ppDocument = m_sp_Document;

    return sc;
}


/*+-------------------------------------------------------------------------*
 *
 * GetFirstAMCViewPosition
 *
 * PURPOSE: Returns the CAMCViewPosition of the first AMCView, or NULL if there is
 *          no AMCView.
 *
 * RETURNS:
 *    CAMCViewPosition
 *
 *+-------------------------------------------------------------------------*/
CAMCViewPosition
CAMCDoc::GetFirstAMCViewPosition()     const
{
    CAMCViewPosition vpos;
    POSITION pos = GetFirstViewPosition();

    while(pos != NULL)
    {
        POSITION posTemp = pos;         // hold this value.

        CAMCView *pView = dynamic_cast<CAMCView *>(GetNextView(pos));
        if(pView != NULL)                // found the AMCView
        {
            vpos.SetPosition(posTemp); // NOT pos!
            break;
        }
    }

    return (vpos);
}



/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::GetNextAMCView
 *
 * PURPOSE: Returns the next AMCView, starting at pos (inclusive)
 *
 * PARAMETERS:
 *    CAMCViewPosition & pos :  incremented to the next AMCView, NOT the next View.
 *
 * RETURNS:
 *    CAMCView *
 *
 *+-------------------------------------------------------------------------*/

CAMCView *
CAMCDoc::GetNextAMCView(CAMCViewPosition &pos) const
{
    CAMCView *pView = NULL;

    // check parameters
    if (pos == NULL)
        return NULL;

    // pos is non-NULL at this point. Loop until we have a CAMCView.
    // Note that unless there's a bug in GetFirstAMCViewPosition or
    // GetNextAMCView, we'll only go through this loop once, since a
    // non-NULL CAMCViewPosition should always refer to a CAMCView.
    while( (NULL == pView) && (pos != NULL) )
    {
        CView *pV = GetNextView(pos.GetPosition());
        pView = dynamic_cast<CAMCView *>(pV);
    }

    // at this point, pView is the correct return value, and it had better
    // not be NULL, or we never should have had a non-NULL pos
    ASSERT (pView != NULL);

    // bump pos to the next CAMCView
    // NOTE: This is NOT redundant. Must point to a CAMCView so that
    // NULL position tests can be done.
    while(pos != NULL)
    {
        /*
         * use temporary POSITION so we won't increment the POSITION
         * inside pos until we know pos doesn't refer to a CAMCView
         */
        POSITION posT = pos.GetPosition();

        if(dynamic_cast<CAMCView *>(GetNextView(posT)) != NULL) // found a CAMCView at pos
            break;

        /*
         * update the CAMCViewPosition with the position incremented
         * by GetNextView only if we didn't find a CAMCView at its
         * previous location
         */
        pos.SetPosition (posT);
    }

#ifdef DBG
    /*
     * if we're returning a non-NULL, it'd better point to a CAMCView
     */
    if (pos != NULL)
    {
        POSITION posT = pos.GetPosition();
        ASSERT (dynamic_cast<CAMCView *>(GetNextView(posT)) != NULL);
    }
#endif

    return pView;
}



/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::InitNodeManager
 *
 * PURPOSE:
 *
 * RETURNS:
 *    HRESULT
 *
 *+-------------------------------------------------------------------------*/
HRESULT CAMCDoc::InitNodeManager()
{
    DECLARE_SC(sc, TEXT("CAMCDoc::InitNodeManager"));

    TRACE_METHOD(CAMCDoc, InitNodeManager);

    // Should not be currently initialized
    ASSERT(m_spScopeTree == NULL && m_spScopeTreePersist == NULL);
    ASSERT(m_spStorage == NULL);

    // The string table should have been created by now
    sc = ScCheckPointers(m_spStringTable, E_FAIL);
    if(sc)
        return sc.ToHr();

    // create the favorites at this stage
    ASSERT(m_pFavorites == NULL);
    m_pFavorites = new CFavorites;
    sc = ScCheckPointers(m_pFavorites, E_OUTOFMEMORY);
    if(sc)
        return sc.ToHr();


    // Create the initial private frame
    IFramePrivatePtr spFrame;
    sc = spFrame.CreateInstance(CLSID_NodeInit, NULL, MMC_CLSCTX_INPROC);
    if (sc)
        return sc.ToHr();

    // recheck teh pointer
    sc = ScCheckPointers( spFrame, E_UNEXPECTED );
    if (sc)
        return sc.ToHr();


    // Create the scope tree
    sc = m_spScopeTree.CreateInstance(CLSID_ScopeTree, NULL, MMC_CLSCTX_INPROC);
    if (sc)
    {
        ReleaseNodeManager();
        return sc.ToHr();
    }

    // recheck the pointer
    sc = ScCheckPointers( m_spScopeTree, E_UNEXPECTED );
    if (sc)
    {
        ReleaseNodeManager();
        return sc.ToHr();
    }

    // link frame and scope tree
    sc = spFrame->SetScopeTree(m_spScopeTree);
    if(sc)
    {
        ReleaseNodeManager();
        return sc.ToHr();
    }

    // Initialize the tree
    sc = m_spScopeTree->Initialize(AfxGetMainWnd()->m_hWnd, m_spStringTable);
    if (sc)
    {
        ReleaseNodeManager();
        return sc.ToHr();
    }

    // Get the IPersistStorage interface from the scope tree
    m_spScopeTreePersist = m_spScopeTree; // query for IPersistStorage
    ASSERT(m_spScopeTreePersist != NULL);

    m_ConsoleData.SetScopeTree (m_spScopeTree);

    CMainFrame* pFrame = AMCGetMainWnd();
    m_ConsoleData.m_hwndMainFrame = pFrame->GetSafeHwnd();
    m_ConsoleData.m_pConsoleFrame = pFrame;

    return sc.ToHr();
}

BOOL CAMCDoc::OnNewDocument()
{
    TRACE_METHOD(CAMCDoc, OnNewDocument);

    USES_CONVERSION;

    // Initialize the document and scope view ...
    if (!CDocument::OnNewDocument())
        return FALSE;

    // A new file can't be read-only
    SetPhysicalReadOnlyFlag (false);

    // use latest file version
    m_ConsoleData.m_eFileVer = FileVer_Current;
    ASSERT (IsValidFileVersion (m_ConsoleData.m_eFileVer));

    // Init help doc info times to current time by default
    // Will update when file is first saved
    ::GetSystemTimeAsFileTime(&GetHelpDocInfo()->m_ftimeCreate);
    GetHelpDocInfo()->m_ftimeModify = GetHelpDocInfo()->m_ftimeCreate;

    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////
// CAMCDoc diagnostics

#ifdef _DEBUG
void CAMCDoc::AssertValid() const
{
    CDocument::AssertValid();
}

void CAMCDoc::Dump(CDumpContext& dc) const
{
    CDocument::Dump(dc);
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CAMCDoc commands
inline bool UnableToSaveDocument()
{
    if (AMCGetApp()->GetMode() == eMode_Author)
        MMCMessageBox(IDS_UnableToSaveDocumentMessage);

    return false;
}

static const wchar_t* AMCViewDataStreamName     = L"ViewData";
static const wchar_t* AMCFrameDataStreamName    = L"FrameData";
static const wchar_t* AMCStringTableStorageName = L"String Table";
static const wchar_t* AMCFavoritesStreamName    = L"FavoritesStream";
static const wchar_t* AMCCustomTitleStreamName  = L"Title";
static const wchar_t* AMCColumnDataStreamName   = L"ColumnData";
static const wchar_t* AMCViewSettingDataStreamName = L"ViewSettingData"; // View settings data stream

#pragma warning( disable : 4800 )

struct FrameState
{
    WINDOWPLACEMENT windowPlacement;
    BOOL fShowStatusBarInUserMode;
    BOOL fShowToolbarInAuthorMode;
}; // struct FrameState


struct FrameState2
{
    UINT            cbSize;
    WINDOWPLACEMENT wndplFrame;
    ProgramMode     eMode;
    DWORD           dwFlags;
    // NOT USED - SIZE PRESERVED FOR COMPATIBILITY
    // DWORD           dwHelpDocIndex;
    // DWORD           dwHelpDocTime[2];
    DWORD           dwUnused;
    DWORD           dwUnused2[2];

    FrameState2 (ProgramMode eMode_   = eMode_Author,
                 DWORD       dwFlags_ = eFlag_Default) :
        cbSize         (sizeof (FrameState2)),
        eMode          (eMode_),
        dwFlags        (dwFlags_),
        // NOT USED - SIZE PRESERVED FOR COMPATIBILITY
        dwUnused(0)
        // dwHelpDocIndex (0)
    {
        // NOT USED - SIZE PRESERVED FOR COMPATIBILITY
        // ZeroMemory (dwHelpDocTime, sizeof (dwHelpDocTime));
        ZeroMemory (dwUnused2, sizeof (dwUnused2));

        ZeroMemory (&wndplFrame, sizeof (wndplFrame));
        wndplFrame.length = sizeof (wndplFrame);
    }

};  // struct FrameState2

/*+-------------------------------------------------------------------------*
 * CFrameState
 *
 * class is designated to be used instead of FrameState2 in Persist methods.
 * It implements functionality of CXMLObject while containing the same data as FrameState2
 * The original struct cannot be extended because many methods do relay on its size.
 *
 *--------------------------------------------------------------------------*/
class CFrameState : public CXMLObject, public FrameState2
{
public:
    CFrameState(ProgramMode eMode_, DWORD dwFlags_) : FrameState2 (eMode_,dwFlags_) {}
protected:
    DEFINE_XML_TYPE (XML_TAG_FRAME_STATE);
    virtual void Persist(CPersistor &persistor)
    {
        persistor.Persist(CXMLWindowPlacement(wndplFrame));

        // define the table to map enumeration values to strings
        static const EnumLiteral frameStateFlags[] =
        {
            { eFlag_ShowStatusBar,                  XML_ENUM_FSTATE_SHOWSTATUSBAR },
            { eFlag_HelpDocInvalid,                 XML_ENUM_FSTATE_HELPDOCINVALID },
            { eFlag_LogicalReadOnly,                XML_ENUM_FSTATE_LOGICALREADONLY },
            { eFlag_PreventViewCustomization,       XML_ENUM_FSTATE_PREVENTVIEWCUSTOMIZATION },
        };

        // create wrapper to persist enumeration values as strings
        CXMLBitFlags flagPersistor(dwFlags, frameStateFlags, countof(frameStateFlags));
        // persist the wrapper
        persistor.PersistAttribute(XML_ATTR_FRAME_STATE_FLAGS, flagPersistor);
    }
};

// what is the size of the Version 1.1 definition of FrameState2?
const int cbFrameState2_v11 = SIZEOF_STRUCT (FrameState2, dwUnused2 /*dwHelpDocTime*/ );


/*+-------------------------------------------------------------------------*
 * AdjustRect
 *
 * Adjusts pInnerRect so that it is completely contained within pOuterRect
 *
 * If AR_MOVE is specified, the origin of pInnerRect is moved enough (if
 * necessary) so that the right and/or bottom edges of pInnerRect coincide
 * with those of pOuterRect.  pInnerRect's origin is never moved above or to
 * the left of pOuterRect's origin.
 *
 * If AR_SIZE is specified, the right and/or bottom edges of pInnerRect are
 * moved to that they coincide with those of pOuterRect.
 *--------------------------------------------------------------------------*/

#define AR_MOVE     0x0000001
#define AR_SIZE     0x0000002

void AdjustRect (LPCRECT pOuterRect, LPRECT pInnerRect, DWORD dwFlags)
{
    /*
     * if the inner rectangle is completely within
     * the outer, there's nothing to do
     */
    if ((pInnerRect->left   >= pOuterRect->left  ) &&
        (pInnerRect->right  <= pOuterRect->right ) &&
        (pInnerRect->top    >= pOuterRect->top   ) &&
        (pInnerRect->bottom <= pOuterRect->bottom))
        return;


    /*
     * handle movement
     */
    if (dwFlags & AR_MOVE)
    {
        int dx = 0;

        /*
         * shift inner rect right?
         */
        if (pInnerRect->left < pOuterRect->left)
            dx = pOuterRect->left - pInnerRect->left;

        /*
         * shift inner rect left? (make sure we don't shift it past the
         * left of the outer rect)
         */
        else if (pInnerRect->right > pOuterRect->right)
            dx = std::_MAX (pOuterRect->right - pInnerRect->right,
                            pOuterRect->left  - pInnerRect->left);


        /*
         * make sure things are right in the vertical
         */
        int dy = 0;

        /*
         * shift inner rect down?
         */
        if (pInnerRect->top < pOuterRect->top)
            dy = pOuterRect->top - pInnerRect->top;

        /*
         * shift inner rect up? (make sure we don't shift it past the
         * top of the outer rect)
         */
        else if (pInnerRect->bottom > pOuterRect->bottom)
            dy = std::_MAX (pOuterRect->bottom - pInnerRect->bottom,
                            pOuterRect->top    - pInnerRect->top);


        /*
         * if we need to shift the inner rect, do it now
         */
        if ((dx != 0) || (dy != 0))
        {
            ASSERT (dwFlags & AR_MOVE);
            OffsetRect (pInnerRect, dx, dy);
        }
    }


    /*
     * handle sizing
     */
    if (dwFlags & AR_SIZE)
    {
        if (pInnerRect->right  > pOuterRect->right)
            pInnerRect->right  = pOuterRect->right;

        if (pInnerRect->bottom > pOuterRect->bottom)
            pInnerRect->bottom = pOuterRect->bottom;
    }
}


/*+-------------------------------------------------------------------------*
 * InsurePlacementIsOnScreen
 *
 * This function insures that the window will appear on the virtual screen,
 * and if the whole window can't be located there, that at least the most
 * interesting part is visible.
 *--------------------------------------------------------------------------*/

void InsurePlacementIsOnScreen (WINDOWPLACEMENT& wndpl)
{
    /*
     * find the monitor containing the window origin
     */
    HMONITOR hmon = MonitorFromPoint (CPoint (wndpl.rcNormalPosition.left,
                                              wndpl.rcNormalPosition.top),
                                      MONITOR_DEFAULTTONEAREST);

    MONITORINFO mi = { sizeof (mi) };
    CRect rectBounds;

    /*
     * if we could get the info for the monitor containing the window origin,
     * use it's workarea as the bounding rectangle; otherwise get the workarea
     * for the default monitor; if that failed as well, default to 640x480
     */
    if (GetMonitorInfo (hmon, &mi))
        rectBounds = mi.rcWork;
    else if (!SystemParametersInfo (SPI_GETWORKAREA, 0, &rectBounds, false))
        rectBounds.SetRect (0, 0, 639, 479);

    /*
     * position the window rectangle within the bounding rectangle
     */
    AdjustRect (rectBounds, &wndpl.rcNormalPosition, AR_MOVE | AR_SIZE);
}


//+-------------------------------------------------------------------
//
//  Member:     LoadFrame
//
//  Synopsis:   Load the Frame Data.
//
//  Note:       The app mode was already read by LoadAppMode.
//              The child frames are created so call UpdateFrameWindow.
//
//  Arguments:  None
//
//  Returns:    bool. TRUE if success.
//
//--------------------------------------------------------------------
bool CAMCDoc::LoadFrame()
// The caller is resposible for calling DeleteContents() and display a message
// to the user when this function return false.
{
    TRACE_METHOD(CAMCDoc, LoadFrame);

    // This assertion shouldn't fail until the definition of FrameState2 changes
    // in a version after 1.1.  At that time, add another cbFrameState2_vXX
    // with the new version's FrameState2 size.
    ASSERT (cbFrameState2_v11 == sizeof (FrameState2));

    if (!AssertNodeManagerIsLoaded())
        return false;

    // Open the stream containing data for the app and frame
    IStreamPtr spStream;
    HRESULT     hr;

    hr = OpenDebugStream (m_spStorage, AMCFrameDataStreamName,
                                  STGM_SHARE_EXCLUSIVE | STGM_READ,
                                  &spStream);

    ASSERT(SUCCEEDED(hr) && spStream != NULL);
    if (FAILED(hr))
        return false;


    FrameState2 fs2;
    ULONG cbRead;
    ASSERT (IsValidFileVersion (m_ConsoleData.m_eFileVer));

    // V1.0 file? Migrate it forward
    if (m_ConsoleData.m_eFileVer == FileVer_0100)
    {
        FrameState fs;
        hr = spStream->Read (&fs, sizeof(fs), &cbRead);

        // if we can't read the FrameState, the file is corrupt
        if (FAILED(hr) || (cbRead != sizeof(fs)))
            return (false);

        // migrate FrameState into FrameState2
        fs2.wndplFrame = fs.windowPlacement;

        if (fs.fShowStatusBarInUserMode)
            fs2.dwFlags |=  eFlag_ShowStatusBar;
        else
            fs2.dwFlags &= ~eFlag_ShowStatusBar;
    }

    // otherwise, current file
    else
    {
        hr = spStream->Read (&fs2, sizeof(fs2), &cbRead);

        // if we can't read the rest of the FrameState, the file is corrupt
        if (FAILED(hr) || (cbRead != sizeof(fs2)))
            return (false);
    }


    // Set the windows size and location and state
    CMainFrame* pMainFrame = AMCGetMainWnd ();
    ASSERT(pMainFrame != NULL);
    if (pMainFrame == NULL)
        return false;


    CAMCApp*    pApp = AMCGetApp();
    pApp->UpdateFrameWindow(true);
    pMainFrame->UpdateChildSystemMenus();

    // the status bar is on the child frame now
//  pMainFrame->ShowStatusBar ((fs2.dwFlags & eFlag_ShowStatusBar) != 0);


    // save the data from the file into the console data
    m_ConsoleData.m_eAppMode     = pApp->GetMode();
    m_ConsoleData.m_eConsoleMode = fs2.eMode;
    m_ConsoleData.m_dwFlags      = fs2.dwFlags;

    InsurePlacementIsOnScreen (fs2.wndplFrame);


    // if we're initializing, defer the actual show until initialization is complete
    // same if script is under control and MMC is hidden
    if (pApp->IsInitializing()
     || ( !pApp->IsUnderUserControl() && !pMainFrame->IsWindowVisible() ) )
    {
        pApp->m_nCmdShow = fs2.wndplFrame.showCmd;
        fs2.wndplFrame.showCmd = SW_HIDE;
    }

    return (pMainFrame->SetWindowPlacement (&fs2.wndplFrame));
}

//+-------------------------------------------------------------------
//
//  Member:     LoadAppMode
//
//  Synopsis:   Read the app mode from the frame and store it in CAMCApp.
//              This is needed during CAMCView::Load.
//
//  Arguments:  None
//
//  Returns:    bool. TRUE if success.
//
//--------------------------------------------------------------------
bool CAMCDoc::LoadAppMode()
{
    TRACE_METHOD(CAMCDoc, LoadAppMode);

    // Just load the application mode from frame data.
    // This assertion shouldn't fail until the definition of FrameState2 changes
    // in a version after 1.1.  At that time, add another cbFrameState2_vXX
    // with the new version's FrameState2 size.
    ASSERT (cbFrameState2_v11 == sizeof (FrameState2));

    if (!AssertNodeManagerIsLoaded())
        return false;

    // Open the stream containing data for the app and frame
    IStreamPtr spStream;
    HRESULT     hr;

    hr = OpenDebugStream (m_spStorage, AMCFrameDataStreamName,
                                  STGM_SHARE_EXCLUSIVE | STGM_READ,
                                  &spStream);

    ASSERT(SUCCEEDED(hr) && spStream != NULL);
    if (FAILED(hr))
        return false;


    FrameState2 fs2;
    ULONG cbRead;
    ASSERT (IsValidFileVersion (m_ConsoleData.m_eFileVer));

    // V1.0 file? Migrate it forward
    if (m_ConsoleData.m_eFileVer == FileVer_0100)
    {
        FrameState fs;
        hr = spStream->Read (&fs, sizeof(fs), &cbRead);

        // if we can't read the FrameState, the file is corrupt
        if (FAILED(hr) || (cbRead != sizeof(fs)))
            return (false);

        // migrate FrameState into FrameState2
        fs2.wndplFrame = fs.windowPlacement;

        if (fs.fShowStatusBarInUserMode)
            fs2.dwFlags |=  eFlag_ShowStatusBar;
        else
            fs2.dwFlags &= ~eFlag_ShowStatusBar;
    }

    // otherwise, current file
    else
    {
        hr = spStream->Read (&fs2, sizeof(fs2), &cbRead);

        // if we can't read the rest of the FrameState, the file is corrupt
        if (FAILED(hr) || (cbRead != sizeof(fs2)))
            return (false);
    }

    CAMCApp*    pApp = AMCGetApp();
    pApp->SetMode (fs2.eMode);

    return true;
}

bool CAMCDoc::LoadViews()
// Caller is resposible for calling DeleteContents() and displaying failure
// message if false is returned.
{
    TRACE_METHOD(CAMCDoc, LoadViews);

    if (!AssertNodeManagerIsLoaded())
        return false;

    // Open the tree data stream
    IStreamPtr spStream;
    HRESULT hr = OpenDebugStream(m_spStorage, AMCViewDataStreamName,
        STGM_SHARE_EXCLUSIVE | STGM_READ, &spStream);

    ASSERT(SUCCEEDED(hr) && spStream != NULL);
    if (FAILED(hr))
        return false;

    // Read the number of views persisted
    unsigned short numberOfViews;
    unsigned long bytesRead;
    hr = spStream->Read(&numberOfViews, sizeof(numberOfViews), &bytesRead);
    ASSERT(SUCCEEDED(hr) && bytesRead == sizeof(numberOfViews));
    if (FAILED(hr) || bytesRead != sizeof(numberOfViews))
        return false;

    // Loop thru and create each view
    int failedCount = 0;
    while (numberOfViews--)
    {
        // Read the node id for the root node of the view being created.
        m_MTNodeIDForNewView = 0;
        bool bRet = m_spScopeTree->GetNodeIDFromStream(spStream, &m_MTNodeIDForNewView);

        // Read the node id for the selected node of the view being created.
        ULONG idSel = 0;
        bRet = m_spScopeTree->GetNodeIDFromStream(spStream, &idSel);

        // Read the view id of the view being created.
        hr = spStream->Read(&m_ViewIDForNewView,
                                   sizeof(m_ViewIDForNewView), &bytesRead);
        ASSERT(SUCCEEDED(hr) && bytesRead == sizeof(m_ViewIDForNewView));
        if (FAILED(hr) || bytesRead != sizeof(m_ViewIDForNewView))
            return false;

        if (bRet || m_MTNodeIDForNewView != 0)
        {
            // Create the new view and load its data
            CAMCView* const v = CreateNewView(true);
            m_ViewIDForNewView = 0;
            ASSERT(v != NULL);
            if (v == NULL)
            {
                ++failedCount;
                continue;
            }
            if (!v->Load(*spStream))
                return false;

            v->ScSelectNode(idSel);
            v->SaveStartingSelectedNode();
            v->SetDirty (false);
            //v->GetHistoryList()->Clear();
        }
    }

    // Reset the node ID for future view creation
    m_MTNodeIDForNewView = ROOTNODEID;

    SetModifiedFlag(FALSE);
    return (failedCount == 0);
}

SC CAMCDoc::ScCreateAndLoadView(CPersistor& persistor, int nViewID, const CBookmark& rootNode)
// Caller is resposible for calling DeleteContents() and displaying failure
// message if false is returned.
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScCreateAndLoadView"));

    // Read the node id for the root node of the view being created.
    m_MTNodeIDForNewView = 0;

    MTNODEID idTemp = 0;
    bool bExactMatchFound = false; // out value from GetNodeIDFromBookmark, unused
    sc = m_spScopeTree->GetNodeIDFromBookmark(rootNode, &idTemp, bExactMatchFound);
    if(sc)
        return sc;

    m_MTNodeIDForNewView = idTemp;

    if (m_MTNodeIDForNewView != 0)
    {
        // Read the view id of the view being created.
        m_ViewIDForNewView = nViewID;
        // Create the new view and load its data
        CAMCView* const v = CreateNewView(true);
        m_ViewIDForNewView = 0;

        sc = ScCheckPointers(v, E_FAIL);
        if (sc)
            return sc;

        v->Persist(persistor);

        v->SaveStartingSelectedNode();
        v->SetDirty (false);
        //v->GetHistoryList()->Clear();
    }
    else
    {
        return sc = SC(E_UNEXPECTED);
    }

    // Reset the node ID for future view creation
    m_MTNodeIDForNewView = ROOTNODEID;
    SetModifiedFlag(FALSE);
    return sc;
}


/*+-------------------------------------------------------------------------*
 * ShowIncompatibleFileMessage
 *
 *
 *--------------------------------------------------------------------------*/

static void ShowIncompatibleFileMessage (
    LPCTSTR             pszFilename,
    ConsoleFileVersion  eFileVer)
{
    TCHAR szFileVersion[16];

    wsprintf (szFileVersion, _T("%d.%d%x"),
              GetConsoleFileMajorVersion    (eFileVer),
              GetConsoleFileMinorVersion    (eFileVer),
              GetConsoleFileMinorSubversion (eFileVer));

    CString strMessage;
    FormatString2 (strMessage, IDS_NewerVersionRequired, pszFilename, szFileVersion);

    MMCMessageBox (strMessage);
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::OnOpenDocument
 *
 * WM_OPENDOCUMENT handler for CAMCDoc.
 *--------------------------------------------------------------------------*/

BOOL CAMCDoc::OnOpenDocument(LPCTSTR lpszPathName)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::OnOpenDocument"));

    sc = ScOnOpenDocument(lpszPathName);
    if(sc) // found an error
    {
        DisplayFileOpenError (sc, lpszPathName);
        return false;
    }

    sc = ScFireEvent(CAMCDocumentObserver::ScDocumentLoadCompleted, this);
    if (sc)
		return false;

	/*
	 * Success!  We shouldn't think that a freshly opened console file is
	 * dirty.  If we do, someone's dirty bit processing is bogus.
	 */
	ASSERT (!IsFrameModified());

	/*
	 * Too many snap-ins leave themselves dirty after a load to leave this
	 * assert in, so we'll trace instead.  Note that this trace doesn't
	 * always indicate a snap-in problem, but it frequently does.
	 */
#ifdef DBG
//	ASSERT (!IsModified());
	if (IsModified())
		TraceErrorMsg (_T("CAMCDoc::IsModified returns true after opening"));
#endif


    return true;
}


/*+-------------------------------------------------------------------------*
 * DisplayFileOpenError
 *
 * Displays an error message if we couldn't open a console file.
 *--------------------------------------------------------------------------*/

int DisplayFileOpenError (SC sc, LPCTSTR pszFilename)
{
    // if it is any of the known errors, use a friendly string.

    if (sc == SC(STG_E_FILENOTFOUND) || sc == ScFromWin32(ERROR_FILE_NOT_FOUND))
        (sc = ScFromMMC(IDS_FileNotFound));
    else if (sc == ScFromMMC(MMC_E_INVALID_FILE))
        (sc = ScFromMMC(IDS_InvalidVersion));
    else if (sc == SC(STG_E_MEDIUMFULL))
        (sc = ScFromMMC(IDS_DiskFull));
    else
    {
        CString strError;
        AfxFormatString1(strError, IDS_UnableToOpenDocumentMessage, pszFilename);
        return (MMCErrorBox(strError));
    }

    return (MMCErrorBox(sc));
}


/*+-------------------------------------------------------------------------*
 * ScGetFileProperties
 *
 * Returns the read-only state of the given file, as well as the creation,
 * last access, and last write times (all optional).
 *
 * We determine if the file is read-only by trying to open the file for
 * writing rather than checking for FILE_ATTRIBUTE_READONLY.  We do this
 * because it will catch more read-only conditions, like the file living
 * on a read-only share or NTFS permissions preventing a write.
 *--------------------------------------------------------------------------*/

static SC ScGetFileProperties (
    LPCTSTR     lpszPathName,           /* I:name of file to check          */
    bool*       pfReadOnly,             /* O:is file read-only?             */
    FILETIME*   pftCreate,              /* O:creation time    (optional)    */
    FILETIME*   pftLastAccess,          /* O:last access time (optional)    */
    FILETIME*   pftLastWrite)           /* O:last write time  (optional)    */
{
    DECLARE_SC (sc, _T("ScGetFileProperties"));

    /*
     * validate inputs (pftCreate, pftLastAccess, and pftLastWrite are optional)
     */
    sc = ScCheckPointers (lpszPathName, pfReadOnly);
    if (sc)
        return (sc);

    /*
     * try to open the file for write; if we can't, the file is read-only
     */
    HANDLE hFile = CreateFile (lpszPathName, GENERIC_WRITE, 0, NULL,
                               OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

    *pfReadOnly = (hFile == INVALID_HANDLE_VALUE);

    /*
     * if read-only then open in read mode so we'll have a handle to pass
     * to GetFileTime
     */
    if (hFile == INVALID_HANDLE_VALUE)
    {
        hFile = CreateFile (lpszPathName, 0, 0, NULL,
                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);

        if (hFile == INVALID_HANDLE_VALUE)
        {
            sc.FromLastError();
            return (sc);
        }
    }

    /*
     * get the timestamps on the file
     */
    if (!GetFileTime (hFile, pftCreate, pftLastAccess, pftLastWrite))
        sc.FromLastError();

    CloseHandle (hFile);
    return (sc);
}

/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::ScOnOpenDocument
 *
 * PURPOSE: Opens the specified document.
 *
 * PARAMETERS:
 *    LPCTSTR  lpszPathName :
 *
 * RETURNS:
 *    SC
 *
 *+-------------------------------------------------------------------------*/
SC
CAMCDoc::ScOnOpenDocument(LPCTSTR lpszPathName)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScOnOpenDocument"));

    // lock AppEvents until this function is done
    LockComEventInterface(AppEvents);

    #define VIVEKJ
    #ifdef VIVEKJ

    // upgrade the console file to the XML version.
    CConsoleFile  consoleFile;
    consoleFile.ScUpgrade(lpszPathName);
    #endif


    USES_CONVERSION;

    // check inputs
    if (lpszPathName == NULL || *lpszPathName == 0)
        return (sc = E_UNEXPECTED);

    if (IsModified())
    {
        TRACE0("Warning: OnOpenDocument replaces an unsaved document.\n");
    }

    if (!AssertNodeManagerIsInitialized())
        return (sc = E_UNEXPECTED);

    /*
     * get the times for the file, as well as its read-only state
     */
    HELPDOCINFO* phdi = GetHelpDocInfo();
    sc = ScCheckPointers (phdi, E_UNEXPECTED);
    if (sc)
        return (sc);

    bool fReadOnly;
    sc = ScGetFileProperties (lpszPathName, &fReadOnly,
                              &phdi->m_ftimeCreate, NULL, &phdi->m_ftimeModify);
    if (sc)
        return (sc);

    // load the document using method from the base class (CConsoleFilePersistor)
    bool bXmlBased = false;
    CXMLDocument xmlDocument;
    IStoragePtr spStorage;
    sc = ScLoadConsole(lpszPathName, bXmlBased, xmlDocument, &spStorage);
    if (sc)
        return (sc);

    if ( bXmlBased )
    {
      // load as XML document
      sc = ScLoadFromDocument(xmlDocument);
      if(sc)
          return sc;
    }
    else
    {
        sc = ScCheckPointers(m_spScopeTree, E_UNEXPECTED);
        if (sc)
            return sc;

        // get the console file's version
        ASSERT (sizeof(m_ConsoleData.m_eFileVer) == sizeof(int));
        sc = m_spScopeTree->GetFileVersion(spStorage, (int*)&m_ConsoleData.m_eFileVer);
        if (sc)
            return sc;

        /*
         * check to see if this file is from a newer MMC
         */
        if (m_ConsoleData.m_eFileVer > FileVer_Current)
        {
            ShowIncompatibleFileMessage (lpszPathName, m_ConsoleData.m_eFileVer);
            return (sc = E_UNEXPECTED);
        }

        // Previous storage should have been closed and released
        ASSERT(m_spStorage == NULL);

        /*
         * Load the string table.
         */
        if (!LoadStringTable (spStorage))
            return (sc = E_UNEXPECTED);

        // Load column settings.
        do
        {
            IStreamPtr spStream;
            sc = OpenDebugStream (spStorage, AMCColumnDataStreamName,
                                  STGM_SHARE_EXCLUSIVE | STGM_READ,
                                  &spStream);
            if(sc)
                break;

            if (NULL != m_ConsoleData.m_spPersistStreamColumnData)
                sc = m_ConsoleData.m_spPersistStreamColumnData->Load(spStream);

            ASSERT(NULL != m_ConsoleData.m_spPersistStreamColumnData);

            if (sc.IsError() || (NULL == m_ConsoleData.m_spPersistStreamColumnData) )
                return (sc = E_UNEXPECTED);

        } while ( FALSE );

        // Load view settings.
        do
        {
            IStreamPtr spStream;
            sc = OpenDebugStream (spStorage, AMCViewSettingDataStreamName,
                                  STGM_SHARE_EXCLUSIVE | STGM_READ,
                                  &spStream);

            if (sc)
                break;

            IPersistStreamPtr spIPeristStreamViewSettings;
            SC sc = ScGetViewSettingsPersistorStream(&spIPeristStreamViewSettings);
            if (sc)
                break;

            sc = ScCheckPointers(spIPeristStreamViewSettings, E_UNEXPECTED);
            if (sc)
                break;

            sc = spIPeristStreamViewSettings->Load(spStream);
            if (sc)
                break;

        } while ( FALSE );


        // Load the tree
        sc = m_spScopeTreePersist->Load(spStorage);
        if (sc)
        {
            ReleaseNodeManager();
            return sc;
        }

        // Save the new storage
        m_spStorage = spStorage;

        /*
         * make sure the tree expansion happens synchronously
         */
        bool fSyncExpandWasRequired = m_spScopeTree->IsSynchronousExpansionRequired() == S_OK;
        m_spScopeTree->RequireSynchronousExpansion (true);

        // Load the favorites data before loading views and frames,
        // so that when frame/view is created the favorite data is ready.
        if (!LoadFavorites())
        {
            // bhanlon        ReleaseNodeManager();
            m_spScopeTree->RequireSynchronousExpansion (fSyncExpandWasRequired);
            return (sc = E_UNEXPECTED);
        }


        /*
         * Load string table, custom data, views and frame.  Load the
         * custom data (including the icon) before loading the views so
         * the proper icon will be used for the views as they're created.
         */
        /*
         * The LoadAppMode, LoadViews and LoadFrame should be called in that
         * order due to following reason.
         * LoadAppMode reads mode from frame-data and saves it in CAMCApp.
         * The mode is used during LoadViews (in CAMCView::Load) to set the view.
         * LoadFrame again reads the frame-data and calls CAMCApp::UpdateFrameWindow
         * to set toolbar/menus according to the mode.
         */
        if (!LoadCustomData  (m_spStorage) || !LoadAppMode() || !LoadViews() || !LoadFrame())
        {
            // bhanlon        ReleaseNodeManager();
            m_spScopeTree->RequireSynchronousExpansion (fSyncExpandWasRequired);
            return (sc = E_UNEXPECTED);
        }

        m_spScopeTree->RequireSynchronousExpansion (fSyncExpandWasRequired);
    }

    SetModifiedFlag      (false);
    SetFrameModifiedFlag (false);

    SetPhysicalReadOnlyFlag (fReadOnly);

    ASSERT (IsValidFileVersion (m_ConsoleData.m_eFileVer));
    return sc;
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::OnSaveDocument
 *
 * WM_SAVEDOCUMENT handler for CAMCDoc.
 *--------------------------------------------------------------------------*/

BOOL CAMCDoc::OnSaveDocument(LPCTSTR lpszFilename)
{
    DECLARE_SC(sc, _T("CAMCDoc::OnSaveDocument"));

    USES_CONVERSION;

    m_eSaveStatus = eStat_Succeeded;

    // Check for a valid filename
    ASSERT(lpszFilename != NULL && *lpszFilename != 0);
    if (lpszFilename == NULL || *lpszFilename == 0)
    {
        return UnableToSaveDocument();
    }

    // Ask the each view to save any data into its data
    // structures (memory) before calling IPersist*::Save.
    CAMCViewPosition pos = GetFirstAMCViewPosition();
    while (pos != NULL)
    {
        CAMCView* const pAMCView = GetNextAMCView(pos);
        sc = ScCheckPointers(pAMCView, E_UNEXPECTED);
        if (sc)
            return UnableToSaveDocument();
    }

    if (!IsCurrentFileVersion (m_ConsoleData.m_eFileVer))
    {
        // If we've arrived at this point then the user is attempting to save the file
        // from an old format into a new one and we will check to see if the user really
        // wants to do this.

        CString strMessage;

        LPCTSTR pszPathName = m_strPathName;

        // A YES/NO/(CANCEL) dialog asking if the user wants to save the file in the new format
        int nResult;

        /*
         * Bug 277586:  we don't ever want non-authors to see this dialog
         */
        if (AMCGetApp()->GetMode() != eMode_Author)
        {
            // non-authors are only saving console settings,
            // which are always in the current version
            // no need to ask for conversion - original console is not converted anyway.
            nResult = IDYES;
        }
        else if (IsExplicitSave())
        {
            // 2 button YES/NO dialog appears if this is an explicit save
            tstring strVersion = GetCurrentFileVersionAsString();
            FormatString2 (strMessage, IDS_CONVERT_FILE_FORMAT,
                           pszPathName, strVersion.c_str());

            nResult = MMCMessageBox (strMessage, MB_YESNO | MB_DEFBUTTON2);
        }
        else
        {
            // 3 button YES/NO/CANCEL appears if this dialog appears when the program
            // prompts to save changes when the user closes the document
            tstring strVersion = GetCurrentFileVersionAsString();
            FormatString2 (strMessage, IDS_CONVERT_FILE_FORMAT_CLOSE,
                           pszPathName, strVersion.c_str());

            nResult = MMCMessageBox (strMessage, MB_YESNOCANCEL | MB_DEFBUTTON3);
        }

        // If we cancel out
        if ((nResult == IDCANCEL) || ((nResult == IDNO) && IsExplicitSave()))
        {
            // Must set this variable otherwise MMC will delete the file
            m_eSaveStatus = eStat_Cancelled;
            return (false);
        }

        // If this will result in us exiting without saving
        if ((nResult == IDNO) && !IsExplicitSave())
            return (true);
    }

    // if we have more than one view, and we'll force SDI in user mode, prompt
    if ((GetNumberOfPersistedViews() > 1) &&
        (m_ConsoleData.m_eConsoleMode == eMode_User_SDI) &&
        (AMCGetApp()->GetMode()       == eMode_Author))
    {
        switch (MMCMessageBox (IDS_FORCE_SDI_PROMPT, MB_YESNOCANCEL))
        {
            case IDYES:
                /* do nothing */
                break;

            case IDNO:
                m_ConsoleData.m_eConsoleMode = eMode_User_MDI;
                break;

            case IDCANCEL:
                m_eSaveStatus = eStat_Cancelled;
                return (false);
        }
    }

    // save contents to xml document
    CXMLDocument xmlDocument;
    sc = ScSaveToDocument( xmlDocument );
    if (sc)
        return UnableToSaveDocument();

    // save xml document to file
    bool bAuthor = (AMCGetApp()->GetMode() == eMode_Author);
    sc = ScSaveConsole( lpszFilename, bAuthor, xmlDocument);
    if (sc)
        return UnableToSaveDocument();

    SetModifiedFlag      (false);
    SetFrameModifiedFlag (false);

	/*
	 * We shouldn't think that a freshly saved console file is
	 * dirty.  If we do, someone's dirty bit processing is bogus.
	 */
	ASSERT (!IsFrameModified());

	/*
	 * Too many snap-ins leave themselves dirty after a load to leave this
	 * assert in, so we'll trace instead.  Note that this trace doesn't
	 * always indicate a snap-in problem, but it frequently does.
	 */
#ifdef DBG
//	ASSERT (!IsModified());
	if (IsModified())
		TraceErrorMsg (_T("CAMCDoc::IsModified returns true after saving"));
#endif

    // if a save was just done, this can't be read-only

    // NOTE: if MMC adds support for "Save Copy As" we have
    // to determine whether a "Save As" or "Save Copy As"
    // was done before clearing the read-only status
    SetPhysicalReadOnlyFlag (false);
    m_ConsoleData.m_eFileVer = FileVer_Current;

    // Show admin tools on start menu if necessary
    ShowAdminToolsOnMenu(lpszFilename);

    return TRUE;
}



int CAMCDoc::GetNumberOfViews()
{
    TRACE_METHOD(CAMCDoc, GetNumberOfViews);

    CAMCViewPosition pos = GetFirstAMCViewPosition();
    int count = 0;

    while (pos != NULL)
    {
        GetNextAMCView(pos);
        VERIFY (++count);
    }

    return (count);
}


int CAMCDoc::GetNumberOfPersistedViews()
{
    unsigned short cPersistedViews = 0;

    CAMCViewPosition pos = GetFirstAMCViewPosition();

    while (pos != NULL)
    {
        CAMCView* v = GetNextAMCView(pos);

        if (v && v->IsPersisted())
            ++cPersistedViews;
    }

    return (cPersistedViews);
}


CAMCView* CAMCDoc::CreateNewView(bool fVisible, bool bEmitScriptEvents /*= true*/)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::CreateNewView"));
    TRACE_FUNCTION(CAMCDoc::CreateNewView);

    CDocTemplate* pTemplate = GetDocTemplate();
    ASSERT(pTemplate != NULL);

    CChildFrame* pFrame = (CChildFrame*) pTemplate->CreateNewFrame(this, NULL);
    ASSERT_KINDOF (CChildFrame, pFrame);

    if (pFrame == NULL)
    {
        TRACE(_T("Warning: failed to create new frame.\n"));
        return NULL;     // command failed
    }

    bool fOldCreateVisibleState;

    /*
     * If we're going to create the frame invisibly, set a flag in the frame.
     * When this flag is set, the frame will show itself with the
     * SW_SHOWMINNOACTIVE flag instead of the default flag.  Doing this will
     * avoid the side effect of restoring the currently active child frame
     * if it is maximized at the time the new frame is created invisibly.
     */
    // The SW_SHOWMINNOACTIVE was changed to SW_SHOWNOACTIVATE.
    // It does preserve the active window from mentioned side effect,
    // plus it also allows scripts (using Object Moded) to create invisible views,
    // position and then show them as normal (not minimized) windows,
    // thus providing same result as creating visible and then hiding the view.
    // While minimized window must be restored first in order to change their position.
    if (!fVisible)
    {
        fOldCreateVisibleState = pFrame->SetCreateVisible (false);
    }

    /*
     * update the frame as if it is to be visible; we'll hide the frame
     * later if necessary
     */
    // setting visibility to 'true' is required option for MFC to pass control
    // to OnInitialUpdate of child windows.
    pTemplate->InitialUpdateFrame (pFrame, this, true /*fVisible*/);

    if (fVisible)
    {
        // Force drawing of frame and view windows now in case a slow OCX in the result
        // pane delays the initial window update
        pFrame->RedrawWindow();
    }
    else
    {
        pFrame->SetCreateVisible (fOldCreateVisibleState);
        pFrame->ShowWindow (SW_HIDE);

        /*
         * InitialUpdateFrame will update the frame counts.  When it executes
         * the new, to-be-invisible frame will be visible, so it'll be included
         * in the count.  If the new window is the second frame, then the first
         * frame will have "1:" prepended to its title.  This is ugly, so we'll
         * update the frame counts again after the new frame has been hidden
         * to fix all of the existing frames' titles.
         */
        UpdateFrameCounts();
    }

    CAMCView* const v = pFrame->GetAMCView();

    if (!(MMC_NW_OPTION_NOPERSIST & GetNewWindowOptions()))
        SetModifiedFlag();

    ASSERT(v);

	if (!v)
		return v;

	AddObserver(static_cast<CAMCDocumentObserver&>(*v));

    // fire the event to the script
    if (bEmitScriptEvents)
    {
        CAMCApp*  pApp = AMCGetApp();

        // check
        sc = ScCheckPointers(pApp, E_UNEXPECTED);
        if (sc)
            return v;

        // forward
        sc = pApp->ScOnNewView(v);
        if (sc)
            return v;
    }

    return v;
}


void DeletePropertyPages(void)
{
    HWND hWnd = NULL;
    DWORD dwPid = 0;        // Process Id
    DWORD dwTid = 0;        // Thread Id

    while (TRUE)
    {
        USES_CONVERSION;

        // Note: No need to localize this string
        hWnd = ::FindWindowEx(NULL, hWnd, W2T( DATAWINDOW_CLASS_NAME ), NULL);
        if (hWnd == NULL)
            return; // No more windows
        ASSERT(IsWindow(hWnd));

        // Check if the window belongs to the current process
        dwTid = ::GetWindowThreadProcessId(hWnd, &dwPid);
        if (dwPid != ::GetCurrentProcessId())
            continue;

        DataWindowData* pData = GetDataWindowData (hWnd);
        ASSERT (pData != NULL);
        ASSERT (IsWindow (pData->hDlg));

        if (SendMessage(pData->hDlg, WM_COMMAND, IDCANCEL, 0L) != 0)
        {
            DBG_OUT_LASTERROR;
        }

        // Note: For some reason, the send message stays stuck in the threads
        // msg queue causing the sheet not to dismiss itself.  By posting a another
        // message( it could be anything), it kick starts the queue and the send message
        // goes through.
        ::PostMessage(pData->hDlg, WM_COMMAND, IDCANCEL, 0L);
    }
}


void CAMCDoc::DeleteContents()
{
    TRACE_METHOD(CAMCDoc, DeleteContents);

    CDocument::DeleteContents();
}


void CAMCDoc::DeleteHelpFile ()
{
    /*
     *  Delete the help file on closing a console file
     */

    // Get a node callback interface
    ASSERT(m_spScopeTree != NULL);
    // If this asserts - the document is in invalid state.
    // Most probably it's because our "Load" procedures did not perform proper
    // cleanup when we failed to load the document
    INodeCallbackPtr spNodeCallback;

    if (m_spScopeTree != NULL)
    {
        m_spScopeTree->QueryNodeCallback(&spNodeCallback);
        ASSERT(spNodeCallback != NULL);
    }

    // fill in file name and send the delete request

    if (spNodeCallback != NULL)
    {
        USES_CONVERSION;
        GetHelpDocInfo()->m_pszFileName = T2COLE(GetPathName());
        spNodeCallback->Notify(NULL, NCLBK_DELETEHELPDOC, (LPARAM)GetHelpDocInfo(), NULL);
    }
}


void CAMCDoc::OnCloseDocument()
{
    DECLARE_SC(sc, TEXT("CAMCDoc::OnCloseDocument"));

    TRACE_METHOD(CAMCDoc, OnCloseDocument);

    // Inform nodemgr about doc-closing (should change this to observer object)
    do
    {
        sc = ScCheckPointers(m_spScopeTree, E_UNEXPECTED);
        if (sc)
            break;

        INodeCallbackPtr spNodeCallback;
        sc = m_spScopeTree->QueryNodeCallback(&spNodeCallback);
        if (sc)
            break;

        sc = ScCheckPointers(spNodeCallback, E_UNEXPECTED);
        if (sc)
            break;

        sc = spNodeCallback->DocumentClosing();
        if (sc)
            break;

    } while ( FALSE );

    if (sc)
        sc.TraceAndClear();

    CAMCApp*  pApp = AMCGetApp();

    // check
    sc = ScCheckPointers(pApp, E_UNEXPECTED);
    if (sc)
        sc.TraceAndClear();
    else
    {
        // forward
        sc = pApp->ScOnCloseDocument(this);
        if (sc)
            sc.TraceAndClear();
    }

    // If we are not instantiated as OLESERVER check for open property sheets.
    if (! pApp->IsMMCRunningAsOLEServer() && FArePropertySheetsOpen(NULL))
    {
        CString strMsg, strTitle;

        if (strMsg.LoadString(IDS_MMCWillCancelPropertySheets) &&
            strTitle.LoadString(IDS_WARNING))
            ::MessageBox(NULL, strMsg, strTitle, MB_OK | MB_ICONWARNING);
    }

    DeletePropertyPages();
    DeleteHelpFile ();

    CDocument::OnCloseDocument();
}


BOOL CAMCDoc::SaveModified()
{
    BOOL    fDocModified   = IsModified();
    BOOL    fFrameModified = IsFrameModified();

    // if the file is not read-only and it is modified
    if (!IsReadOnly() && (fDocModified || fFrameModified))
    {
        int idResponse;
        bool fUserMode = (AMCGetApp()->GetMode() != eMode_Author);
        bool fSaveByUserDecision = false;

        // silent saves for the various flavors of user mode
        if (fUserMode)
            idResponse = IDYES;

        // silent saves if the frame was modified but the document wasn't...
        else if (fFrameModified && !fDocModified)
        {
            /*
             * ...unless the console wasn't modified.  This will happen
             * if the user ran MMC without opening an existing console file
             * and then moved the frame window.
             */
            // ...unless the console wasn't modified.
            if (m_strPathName.IsEmpty())
                idResponse = IDNO;
            else
                idResponse = IDYES;
        }

        // otherwise, prompt
        else
        {
            CString prompt;
            FormatString1(prompt, IDS_ASK_TO_SAVE, m_strTitle);
            idResponse = AfxMessageBox(prompt, MB_YESNOCANCEL, AFX_IDP_ASK_TO_SAVE); // dont change to MMCMessageBox - different signature.
            fSaveByUserDecision = true;
        }

        switch (idResponse)
        {
            case IDCANCEL:
                return FALSE;       // don't continue

            case IDYES:
                // If so, either Save or Update, as appropriate
                // (ignore failures in User mode)

                // This save is not explicit and shows up when the user closes a modified
                // document. Set it as such. This will result in a different dialog
                // a few functions in.
                SetExplicitSave(false);
                if (!DoFileSave() && fSaveByUserDecision)
                {
                    // Restore to the default explicit save
                    SetExplicitSave(true);
                    return FALSE;       // don't continue
                }

                // Restore to the default explicit save
                SetExplicitSave(true);
                break;

            case IDNO:
                // If not saving changes, revert the document
                break;

            default:
                ASSERT(FALSE);
                break;
        }

    }

    // At this point we are committed to closing, so give each AMCView
    // a chance to do its clean-up work
    CAMCViewPosition pos = GetFirstAMCViewPosition();
    while (pos != NULL)
    {
        CAMCView* const pView = GetNextAMCView(pos);

        if (pView != NULL)
            pView->CloseView();
    }

    return TRUE;    // keep going
}



#if (_MFC_VER > 0x0600)
#error CAMCDoc::DoSave was copied from CDocument::DoSave from MFC 6.0.
#error The MFC version has changed.  See if CAMCDoc::DoSave needs to be updated.
#endif

BOOL CAMCDoc::DoSave(LPCTSTR lpszPathName, BOOL bReplace)
    // Save the document data to a file
    // lpszPathName = path name where to save document file
    // if lpszPathName is NULL then the user will be prompted (SaveAs)
    // note: lpszPathName can be different than 'm_strPathName'
    // if 'bReplace' is TRUE will change file name if successful (SaveAs)
    // if 'bReplace' is FALSE will not change path name (SaveCopyAs)
{
    CString newName = lpszPathName;
    if (newName.IsEmpty())
    {
        CDocTemplate* pTemplate = GetDocTemplate();
        ASSERT(pTemplate != NULL);

        newName = m_strPathName;
        if (bReplace && newName.IsEmpty())
        {
            newName = m_strTitle;
#ifndef _MAC
            // check for dubious filename
            int iBad = newName.FindOneOf(_T(" #%;/\\"));
#else
            int iBad = newName.FindOneOf(_T(":"));
#endif
            if (iBad != -1)
                newName.ReleaseBuffer(iBad);

#ifndef _MAC
            // append the default suffix if there is one
            CString strExt;
            if (pTemplate->GetDocString(strExt, CDocTemplate::filterExt) &&
              !strExt.IsEmpty())
            {
                ASSERT(strExt[0] == '.');
                newName += strExt;
            }
#endif
        }

        if (!AfxGetApp()->DoPromptFileName(newName,
          bReplace ? AFX_IDS_SAVEFILE : AFX_IDS_SAVEFILECOPY,
          OFN_HIDEREADONLY | OFN_PATHMUSTEXIST, FALSE, pTemplate))
            return FALSE;       // don't even attempt to save
    }

    CWaitCursor wait;

    if (!OnSaveDocument(newName))
    {
        // This is the modified MMC implementation
#ifdef MMC_DELETE_EXISTING_FILE     // See bug 395006
        if ((lpszPathName == NULL) && (m_eSaveStatus != eStat_Cancelled))
        {
            // be sure to delete the file
            try
            {
                CFile::Remove(newName);
            }
            catch (CException* pe)
            {
                TRACE0("Warning: failed to delete file after failed SaveAs.\n");
                pe->Delete();
            }
        }
#endif
        return FALSE;
    }

    // if changing the name of the open document
    if (bReplace)
    {
        /*
         *  Delete the help file for this console file before
         *  changing its name, because the help file can't be
         *  located once the old name is lost.
         */
        DeleteHelpFile ();

        // reset the title and change the document name
        SetPathName(newName);
    }

    return TRUE;        // success
}


BOOL CAMCDoc::IsModified()
{
    TRACE_METHOD(CAMCDoc, IsModified);

    BOOL const bModified = /*CDocument::IsModified() || */
                  (m_spScopeTreePersist != NULL && m_spScopeTreePersist->IsDirty() != S_FALSE);
    if (bModified)
        return TRUE;

    // Loop thru and save each view
    CAMCViewPosition pos = GetFirstAMCViewPosition();
    while (pos != NULL)
    {
        // Get the view and skip if its the active view
        CAMCView* const v = GetNextAMCView(pos);

        if (v && v->IsDirty())
            return TRUE;
    }

    // The views should be asked about dirty before
    // asking the columns.
    if ( (NULL != m_ConsoleData.m_spPersistStreamColumnData) &&
         (S_OK == m_ConsoleData.m_spPersistStreamColumnData->IsDirty()) )
        return TRUE;

    // View data.
    IPersistStreamPtr spIPeristStreamViewSettings;
    SC sc = ScGetViewSettingsPersistorStream(&spIPeristStreamViewSettings);
    if ( (! sc.IsError()) &&
         (spIPeristStreamViewSettings != NULL) )
    {
        sc = spIPeristStreamViewSettings->IsDirty();
        if (sc == S_OK)
            return TRUE;

        sc.TraceAndClear();
    }

    return CDocument::IsModified();
}

void CAMCDoc::OnUpdateFileSave(CCmdUI* pCmdUI)
{
    pCmdUI->Enable (!IsReadOnly());
}


void CAMCDoc::OnConsoleAddremovesnapin()
{
    ASSERT(m_spScopeTree != NULL);

    // Can't run snap-in manager with active property sheets
    CString strMsg;
    LoadString(strMsg, IDS_SNAPINMGR_CLOSEPROPSHEET);
    if (FArePropertySheetsOpen(&strMsg))
        return;

    m_spScopeTree->RunSnapIn(AfxGetMainWnd()->m_hWnd);

    ::CoFreeUnusedLibraries();
}

void CAMCDoc::OnUpdateConsoleAddremovesnapin(CCmdUI* pCmdUI)
{
    pCmdUI->Enable (m_spScopeTree != NULL);
}



/*--------------------------------------------------------------------------*
 * CAMCDoc::SetMode
 *
 *
 *--------------------------------------------------------------------------*/

void CAMCDoc::SetMode (ProgramMode eMode)
{
    /*
     * only set the modified flag if something actually changed
     */
    if (m_ConsoleData.m_eConsoleMode != eMode)
    {
        // should only be able to get here in author mode
        ASSERT (AMCGetApp()->GetMode() == eMode_Author);
        ASSERT (IsValidProgramMode (eMode));

        m_ConsoleData.m_eConsoleMode = eMode;
        SetModifiedFlag ();
    }
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::SetConsoleFlag
 *
 *
 *--------------------------------------------------------------------------*/

void CAMCDoc::SetConsoleFlag (ConsoleFlags eFlag, bool fSet)
{
    DWORD dwFlags = m_ConsoleData.m_dwFlags;

    if (fSet)
        dwFlags |=  eFlag;
    else
        dwFlags &= ~eFlag;

    /*
     * only set the modified flag if something actually changed
     */
    if (m_ConsoleData.m_dwFlags != dwFlags)
    {
        m_ConsoleData.m_dwFlags = dwFlags;
        SetModifiedFlag ();
    }
}

/*+-------------------------------------------------------------------------*
 *
 * mappedModes
 *
 * PURPOSE: provides map to be used when persisting ProgramMode enumeration
 *
 * NOTE:    do not remove/ change items unless you're sure no console
 *          files will be broken
 *
 *+-------------------------------------------------------------------------*/
static const EnumLiteral mappedModes[] =
{
    { eMode_Author,     XML_ENUM_PROGRAM_MODE_AUTHOR   } ,
    { eMode_User,       XML_ENUM_PROGRAM_MODE_USER     } ,
    { eMode_User_MDI,   XML_ENUM_PROGRAM_MODE_USER_MDI } ,
    { eMode_User_SDI,   XML_ENUM_PROGRAM_MODE_USER_SDI } ,
};

/*+-------------------------------------------------------------------------*
 *
 * CAMCDoc::Persist
 *
 * PURPOSE:
 *
 * PARAMETERS:
 *    CPersistor& persistor :
 *
 * RETURNS:
 *    void
 *
 *+-------------------------------------------------------------------------*/
void CAMCDoc::Persist(CPersistor& persistor)
{
    DECLARE_SC (sc, _T("CAMCDoc::Persist"));

    CAMCApp*    pApp = AMCGetApp();

    // check required pointers before going any further
    sc = ScCheckPointers(m_spStringTable ? pApp : NULL, // + workaround to check more pointers
                         m_ConsoleData.m_pXMLPersistColumnData,
                         m_spScopeTree ?   GetFavorites() : NULL, // + same workaround ^
                         E_POINTER);
    if (sc)
        sc.Throw();

    // persist version of the document
    CStr strFileVer = 0.;
    if (persistor.IsStoring())
    {
        strFileVer = GetCurrentFileVersionAsString().c_str();

        GUID  guidConsoleId;
        sc = CoCreateGuid(&guidConsoleId);
        if (sc)
            sc.Throw();

        // this parameter is also updated in IDocConfig implementation
        // update that code when changing following lines
        CPersistor persistorGuid(persistor, XML_TAG_CONSOLE_FILE_UID);
        persistorGuid.PersistContents(guidConsoleId);
    }
    persistor.PersistAttribute(XML_ATTR_CONSOLE_VERSION, strFileVer);
    if (persistor.IsLoading())
    {
        // 'decode' the version
        LPCTSTR pstrStart = strFileVer;
        LPTSTR  pstrStop =  const_cast<LPTSTR>(pstrStart);

        UINT uiMajorVer = _tcstol(pstrStart, &pstrStop, 10) ;

        UINT uiMinorVer = 0;
        if (pstrStop != pstrStart && *pstrStop == '.')
        {
            pstrStart = pstrStop + 1;
            uiMinorVer = _tcstol(pstrStart, &pstrStop, 10) ;
        }

        UINT uiMinorSubVer = 0;
        if (pstrStop != pstrStart && *pstrStop == '.')
        {
            pstrStart = pstrStop + 1;
            uiMinorVer = _tcstol(pstrStart, &pstrStop, 10) ;
        }

        ConsoleFileVersion eVersion = (ConsoleFileVersion)MakeConsoleFileVer_(uiMajorVer,
                                                                              uiMinorVer,
                                                                              uiMinorSubVer);

        m_ConsoleData.m_eFileVer = eVersion;

        // BUGBUG: this needs to be changed when we implement 'dynamic' SC messages
        if (eVersion != FileVer_Current)
            sc.Throw(E_UNEXPECTED);
    }


    // Create a storage for binaries
    // This will create "detached" XML element which may be used by persistor's
    // childs to store binary informatio.
    // (The element is attached to XML document by calling "CommitBinaryStorage()" )
    if (persistor.IsStoring())
        persistor.GetDocument().CreateBinaryStorage();
    else
        persistor.GetDocument().LocateBinaryStorage();

    /*
     * make sure the tree expansion happens synchronously
     */
    bool fSyncExpandWasRequired = m_spScopeTree->IsSynchronousExpansionRequired() == S_OK;
    m_spScopeTree->RequireSynchronousExpansion (true);

    // historically both loading and saving is to be done in certain order
    // steps are ordered by storing order
    const int STEP_FRAME        = 1;
    const int STEP_VIEWS        = 2;
    const int STEP_APP_MODE     = 3;
    const int STEP_CUST_DATA    = 4;
    const int STEP_FAVORITES    = 5;
    const int STEP_SCOPE_TREE   = 6;
    const int STEP_VIEW_DATA    = 7;
    const int STEP_COLUMN_DATA  = 8;
    const int STEP_STRING_TABLE = 9;
    const int MIN_STEP = 1;
    const int MAX_STEP = 9;
    for (int iStep = persistor.IsStoring() ? MIN_STEP : MAX_STEP;
         persistor.IsStoring() ? (iStep <= MAX_STEP) : (iStep >= MIN_STEP);
         persistor.IsStoring() ? ++iStep : --iStep
        )
    {
        switch(iStep)
        {
        case STEP_FRAME:
            PersistFrame(persistor);
            break;
        case STEP_VIEWS:
            PersistViews(persistor);
            break;
        case STEP_APP_MODE:
            if (persistor.IsLoading())
            {
                // restore proper application mode
                ProgramMode eMode;

                // create wrapper to persist enumeration values as strings
                CXMLEnumeration modeValuePersistor(eMode, mappedModes, countof(mappedModes));

                // persist the wrapper
                persistor.PersistAttribute(XML_ATTR_APPLICATION_MODE, modeValuePersistor);

                pApp->SetMode(eMode);
            }
            break;
        case STEP_CUST_DATA:
            PersistCustomData (persistor);
            break;
        case STEP_FAVORITES:
            persistor.Persist(*GetFavorites());
            break;
        case STEP_SCOPE_TREE:
            // IDocConfig relies on tree to be under the document.
            // revisit that code if you do the change here
            sc = m_spScopeTree->Persist(reinterpret_cast<HPERSISTOR>(&persistor));
            if (sc)
                sc.Throw();
            break;
        case STEP_VIEW_DATA:
            {
               INodeCallbackPtr spNodeCallback;
               sc = m_spScopeTree->QueryNodeCallback(&spNodeCallback);
               if (sc)
                   sc.Throw();

               sc = ScCheckPointers(spNodeCallback, E_UNEXPECTED);
               if (sc)
                   sc.Throw();

               CXMLObject *pXMLViewSettings = NULL;
               sc = spNodeCallback->QueryViewSettingsPersistor(&pXMLViewSettings);
               if (sc)
                   sc.Throw();

               sc = ScCheckPointers(pXMLViewSettings, E_UNEXPECTED);
               if (sc)
                   sc.Throw();

                persistor.Persist(*pXMLViewSettings);
            }
            break;
        case STEP_COLUMN_DATA:
            persistor.Persist(*m_ConsoleData.m_pXMLPersistColumnData);
            break;
        case STEP_STRING_TABLE:
            CMasterStringTable *pMasterStringTable = dynamic_cast<CMasterStringTable *>((IStringTablePrivate *)m_spStringTable);
            if(!pMasterStringTable)
            {
                sc = E_UNEXPECTED;
                sc.Throw();
            }
            persistor.Persist(*pMasterStringTable);
            break;
        }
    }

    m_spScopeTree->RequireSynchronousExpansion (fSyncExpandWasRequired);
    SetModifiedFlag      (false);
    SetFrameModifiedFlag (false);

	/*
	 * We shouldn't think that a freshly saved console file is
	 * dirty.  If we do, someone's dirty bit processing is bogus.
	 */
	ASSERT (!IsFrameModified());

	/*
	 * Too many snap-ins leave themselves dirty after a load to leave this
	 * assert in, so we'll trace instead.  Note that this trace doesn't
	 * always indicate a snap-in problem, but it frequently does.
	 */
#ifdef DBG
//	ASSERT (!IsModified());
	if (IsModified())
		TraceErrorMsg (_T("CAMCDoc::IsModified returns true after %s"),
					   persistor.IsLoading() ? _T("opening") : _T("saving"));
#endif

    // The element used to gather binary information is attached to XML document here
    // Physically it will reside after all elements already added to persistor
    if (persistor.IsStoring())
        persistor.GetDocument().CommitBinaryStorage();
}

void CAMCDoc::PersistViews(CPersistor& persistor)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::PersistViews"));

    if (persistor.IsLoading())
    {
        // Read templates for new views
        CViewTemplateList view_list(XML_TAG_VIEW_LIST);
        persistor.Persist(view_list);

        // Get the means for enumerating loaded collection
        CViewTemplateList::List_Type &rList = view_list.GetList();
        CViewTemplateList::List_Type::iterator it;

        // Enumerate all the views to be created
        // Create them one-by-one
        for (it = rList.begin(); it != rList.end(); ++it)
        {
            // extract information for the new view
            int iViewID = it->first;
            const CBookmark& pbm = it->second.first;
            CPersistor& v_persistor = it->second.second;

            // create it!
            sc = ScCreateAndLoadView(v_persistor, iViewID, pbm);
            if (sc)
                sc.Throw();
        }
    }
    else // if (persistor.IsStoring())
    {
        CPersistor persistorViews(persistor, XML_TAG_VIEW_LIST);

		/*
		 * Bug 3504: enumerate views in z-order (bottom-to-top) so the
		 * z-order will be restored correctly on reload
		 */
		CMainFrame* pMainFrame = AMCGetMainWnd();
		sc = ScCheckPointers (pMainFrame, E_UNEXPECTED);
		if (sc)
			sc.Throw();

		/*
		 * get the top-most MDI child
		 */
		CWnd* pwndMDIChild = pMainFrame->MDIGetActive();
		sc = ScCheckPointers (pwndMDIChild, E_UNEXPECTED);
		if (sc)
			sc.Throw();

		/*
		 * iterate through each of the MDI children
		 */
		for (pwndMDIChild  = pwndMDIChild->GetWindow (GW_HWNDLAST);
			 pwndMDIChild != NULL;
			 pwndMDIChild  = pwndMDIChild->GetNextWindow (GW_HWNDPREV))
		{
			/*
			 * turn the generic CMDIChildWnd into a CChildFrame
			 */
			CChildFrame* pChildFrame = dynamic_cast<CChildFrame*>(pwndMDIChild);
			sc = ScCheckPointers (pChildFrame, E_UNEXPECTED);
			if (sc)
				sc.Throw();

			/*
			 * get the view for this child frame
			 */
			CAMCView* pwndView = pChildFrame->GetAMCView();
			sc = ScCheckPointers (pwndView, E_UNEXPECTED);
			if (sc)
				sc.Throw();

            // skip those not persistible
            if ( !pwndView->IsPersisted() )
                continue;

			/*
			 * persist the view
			 */
			persistorViews.Persist (*pwndView);
		}
    }
}


void CAMCDoc::PersistFrame(CPersistor& persistor)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::PersistFrame"));

    CFrameState fs2 (m_ConsoleData.m_eConsoleMode, m_ConsoleData.m_dwFlags);
    ASSERT (fs2.wndplFrame.length == sizeof (WINDOWPLACEMENT));

    CMainFrame* pMainFrame = AMCGetMainWnd();
    sc = ScCheckPointers (pMainFrame, E_UNEXPECTED);
    if (sc)
        sc.Throw();

    if (persistor.IsStoring())
    {
        // Get the attributes of the window.
        if (!pMainFrame->GetWindowPlacement (&fs2.wndplFrame))
            sc.Throw(E_FAIL);

        if (fs2.wndplFrame.showCmd == SW_SHOWMINIMIZED)
            fs2.wndplFrame.showCmd =  SW_SHOWNORMAL;
    }

    persistor.Persist(fs2);

    // this application setting (AppMode) is resored in AMCDoc::Persist, but saved/loaded here
    // create wrapper to persist enumeration values as strings
    CXMLEnumeration modeValuePersistor(m_ConsoleData.m_eConsoleMode, mappedModes, countof(mappedModes));
    // persist the wrapper
    persistor.PersistAttribute(XML_ATTR_APPLICATION_MODE, modeValuePersistor);

    if (persistor.IsLoading())
    {
        // Set the windows size and location and state
        CAMCApp*    pApp = AMCGetApp();
        pApp->UpdateFrameWindow(true);
        pMainFrame->UpdateChildSystemMenus();

        // the status bar is on the child frame now
        //  pMainFrame->ShowStatusBar ((fs2.dwFlags & eFlag_ShowStatusBar) != 0);

        // save the data from the file into the console data
        m_ConsoleData.m_eAppMode     = pApp->GetMode();
        m_ConsoleData.m_dwFlags      = fs2.dwFlags;

        InsurePlacementIsOnScreen (fs2.wndplFrame);

        // if we're initializing, defer the actual show until initialization is complete
        // same if script is under control and MMC is hidden
        if (pApp->IsInitializing()
         || ( !pApp->IsUnderUserControl() && !pMainFrame->IsWindowVisible() ) )
        {
            pApp->m_nCmdShow = fs2.wndplFrame.showCmd;
            fs2.wndplFrame.showCmd = SW_HIDE;
        }

        if (!pMainFrame->SetWindowPlacement (&fs2.wndplFrame))
            sc.Throw(E_FAIL);
    }
}

/*--------------------------------------------------------------------------*
 * CDocument::DoFileSave
 *
 * This is almost identical to CDocument::DoFileSave.  We just override it
 * here because we want to display a message for a read-only file before
 * throwing up the Save As dialog.
 *--------------------------------------------------------------------------*/

BOOL CAMCDoc::DoFileSave()
{
    DWORD dwAttrib = GetFileAttributes(m_strPathName);

    // attributes does not matter for user modes - it does not
    // save to the original console file anyway
    if ((AMCGetApp()->GetMode() == eMode_Author) &&
        (dwAttrib != 0xFFFFFFFF) &&
        (dwAttrib & FILE_ATTRIBUTE_READONLY))
    {
        CString strMessage;
        FormatString1 (strMessage, IDS_CONSOLE_READONLY, m_strPathName);
        MMCMessageBox (strMessage);

        // we do not have read-write access or the file does not (now) exist
        if (!DoSave(NULL))
        {
            TRACE0("Warning: File save with new name failed.\n");
            return FALSE;
        }
    }
    else
    {
        if (!DoSave(m_strPathName))
        {
            TRACE0("Warning: File save failed.\n");
            return FALSE;
        }
    }
    return TRUE;
}



/*--------------------------------------------------------------------------*
 * CAMCDoc::GetDefaultMenu
 *
 *
 *--------------------------------------------------------------------------*/

HMENU CAMCDoc::GetDefaultMenu()
{
    return (AMCGetApp()->GetMenu ());
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::GetCustomIcon
 *
 * Returns the small or large custom icon for the console.  Ownership of and
 * deletion responsibility for the icon is retained by CAMCDoc.
 *--------------------------------------------------------------------------*/

HICON CAMCDoc::GetCustomIcon (bool fLarge, CString* pstrIconFile, int* pnIconIndex) const
{
	DECLARE_SC (sc, _T("CAMCDoc::ScGetCustomIcon"));

    /*
     * if caller wants either the icon filename or index returned, get them
     */
    if ((pstrIconFile != NULL) || (pnIconIndex != NULL))
    {
        CPersistableIconData IconData;
        m_CustomIcon.GetData (IconData);

        if (pstrIconFile != NULL)
            *pstrIconFile = IconData.m_strIconFile.data();

        if (pnIconIndex != NULL)
            *pnIconIndex = IconData.m_nIndex;
    }

    /*
     * return the icon (m_CustomIcon will hold the reference for the
	 * caller)
     */
	CSmartIcon icon;
	sc = m_CustomIcon.GetIcon ((fLarge) ? 32 : 16, icon);
	if (sc)
		return (NULL);

	return (icon);
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::SetCustomIcon
 *
 *
 *--------------------------------------------------------------------------*/

void CAMCDoc::SetCustomIcon (LPCTSTR pszIconFile, int nIconIndex)
{
    DECLARE_SC (sc, _T("CAMCDoc::SetCustomIcon"));

    CPersistableIconData IconData (pszIconFile, nIconIndex) ;

    /*
     * if there's no change, bail
     */
    if (m_CustomIcon == IconData)
        return;

    m_CustomIcon = IconData;

    HICON 		hLargeIcon = GetCustomIcon (true  /*fLarge*/);
    HICON		hSmallIcon = GetCustomIcon (false /*fLarge*/);
    CMainFrame* pMainFrame = AMCGetMainWnd();

    sc = ScCheckPointers (hLargeIcon, hSmallIcon, pMainFrame, E_UNEXPECTED);
    if (sc)
        return;

    /*
     * change the icon on the frame
     */
    pMainFrame->SetIconEx (hLargeIcon, true);
    pMainFrame->SetIconEx (hSmallIcon, false);

    /*
     * change the icon on each MDI window
     */
    CWnd* pMDIChild = pMainFrame->MDIGetActive();

    while (pMDIChild != NULL)
    {
        ASSERT_KINDOF (CMDIChildWnd, pMDIChild);
        pMDIChild->SetIcon (hLargeIcon, true);
        pMDIChild->SetIcon (hSmallIcon, false);
        pMDIChild = pMDIChild->GetWindow (GW_HWNDNEXT);
    }

    SetModifiedFlag();
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::LoadCustomData
 *
 *
 *--------------------------------------------------------------------------*/

bool CAMCDoc::LoadCustomData (IStorage* pStorage)
{
    HRESULT hr;
    IStoragePtr spCustomDataStorage;
    hr = OpenDebugStorage (pStorage, g_pszCustomDataStorage,
                                STGM_SHARE_EXCLUSIVE | STGM_READ,
                                &spCustomDataStorage);


    if (FAILED (hr))
        return (true);

    LoadCustomIconData  (spCustomDataStorage);
    LoadCustomTitleData (spCustomDataStorage);

    return (true);
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::LoadCustomIconData
 *
 *
 *--------------------------------------------------------------------------*/

bool CAMCDoc::LoadCustomIconData (IStorage* pStorage)
{
    HRESULT hr = m_CustomIcon.Load (pStorage);

    if (FAILED (hr))
        return (false);

    /*
     * If we get here, we have a custom icon.  The view windows
     * (MDI children) haven't been created yet -- they'll get the
     * right icons automatically.  The main frame, however, already
     * exists, so we have to explicitly set its icon here.
     */
    CWnd* pMainWnd = AfxGetMainWnd();
    pMainWnd->SetIcon (GetCustomIcon (true),  true);
    pMainWnd->SetIcon (GetCustomIcon (false), false);

    return (true);
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::LoadCustomTitleData
 *
 *
 *--------------------------------------------------------------------------*/

bool CAMCDoc::LoadCustomTitleData (IStorage* pStorage)
{
    do  // not a loop
    {
        /*
         * Open the custom title data stream.  It may not exist, and
         * that's OK if it doesn't.  It just means we don't have a
         * custom title.
         */
        USES_CONVERSION;
        HRESULT hr;
        IStreamPtr spStream;
        hr = OpenDebugStream (pStorage, AMCCustomTitleStreamName,
                                   STGM_SHARE_EXCLUSIVE | STGM_READ,
                                   &spStream);

        BREAK_ON_FAIL (hr);

        try
        {
            /*
             * Read the stream version
             */
            DWORD dwVersion;
            *spStream >> dwVersion;

            /*
             * if this is the beta custom title format, migrate it forward
             */
            switch (dwVersion)
            {
                case 0:
                {
                    /*
                     * Read the length (in bytes) of the title
                     */
                    WORD cbTitle;
                    *spStream >> cbTitle;
                    const WORD cchTitle = cbTitle / sizeof (WCHAR);

                    /*
                     * Read the title
                     */
                    std::auto_ptr<WCHAR> spwzWideTitle (new WCHAR[cchTitle + 1]);
                    LPWSTR pwzWideTitle = spwzWideTitle.get();

                    DWORD cbRead;
                    hr = spStream->Read (pwzWideTitle, cbTitle, &cbRead);
                    BREAK_ON_FAIL (hr);

                    if (cbRead != cbTitle)
                        break;

                    /*
                     * terminate and convert the title string
                     */
                    pwzWideTitle[cchTitle] = 0;
                    if (m_pstrCustomTitle != NULL)
                        *m_pstrCustomTitle = W2T (pwzWideTitle);
                    break;
                }

                case 1:
                    if (m_pstrCustomTitle != NULL)
                        *spStream >> (*m_pstrCustomTitle);
                    break;

                default:
                    ASSERT (false);
                    break;
            }
        }
        catch (_com_error& err)
        {
            hr = err.Error();
            ASSERT (false && "Caught _com_error");
            break;
        }
        catch (CMemoryException* pe)
        {
            pe->Delete();
            _com_issue_error (E_OUTOFMEMORY);
        }
    } while (false);

    return (true);
}



bool CAMCDoc::HasCustomTitle () const
{
    if(!m_pstrCustomTitle)
        return false;

    return (!m_pstrCustomTitle->str().empty());

}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::LoadStringTable
 *
 *
 *--------------------------------------------------------------------------*/

bool CAMCDoc::LoadStringTable (IStorage* pStorage)
{
    DECLARE_SC (sc, _T("CAMCDoc::LoadStringTable"));

    /*
     * open the string table storage
     */
    IStoragePtr spStringTableStg;
    HRESULT hr = OpenDebugStorage (pStorage, AMCStringTableStorageName,
                                        STGM_SHARE_EXCLUSIVE | STGM_READ,
                                        &spStringTableStg);


    /*
     * If there's no string table, things are OK.  We allow this so
     * we can continue to open older console files.
     */
    if (hr == STG_E_FILENOTFOUND)
        return (true);

    if (SUCCEEDED (hr))
    {
        /*
         * read the string table from the storage
         */
        try
        {
            CMasterStringTable *pMasterStringTable = dynamic_cast<CMasterStringTable *>((IStringTablePrivate *)m_spStringTable);
            if(!pMasterStringTable)
            {
                sc = E_UNEXPECTED;
                sc.Throw();
            }

            *spStringTableStg >> *pMasterStringTable;
        }
        catch (_com_error& err)
        {
            hr = err.Error();
            ASSERT (false && "Caught _com_error");
        }
    }

    return (SUCCEEDED (hr));
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::SetCustomTitle
 *
 *
 *--------------------------------------------------------------------------*/

void CAMCDoc::SetCustomTitle (CString strNewTitle)
{
    DECLARE_SC (sc, _T("CAMCDoc::SetCustomTitle"));

    if(!m_pstrCustomTitle)
        return;

    /*
     * if there's no change, just short out
     */
    if ((*m_pstrCustomTitle) == strNewTitle)
        return;

    /*
     * copy the new custom title
     */
    (*m_pstrCustomTitle) = strNewTitle;

    /*
     * force the frame to update
     */
    CMainFrame* pMainFrame = AMCGetMainWnd();
    sc = ScCheckPointers (pMainFrame, E_UNEXPECTED);
    if (sc)
        return;

    pMainFrame->OnUpdateFrameTitle (false);

    SetModifiedFlag();
}


/*+-------------------------------------------------------------------------*
 * CAMCDoc::GetCustomTitle
 *
 *
 *--------------------------------------------------------------------------*/

CString CAMCDoc::GetCustomTitle() const
{
    if (HasCustomTitle())
        return (m_pstrCustomTitle->data());

    CString strTitle = GetTitle();

    /*
     * strip the extension (extensions, including a separator,
     * are 4 characters or less)
     */
    int nExtSeparator = strTitle.ReverseFind (_T('.'));

    if ((nExtSeparator != -1) && ((strTitle.GetLength()-nExtSeparator) <= 4))
        strTitle = strTitle.Left (nExtSeparator);

    return (strTitle);
}

/*+-------------------------------------------------------------------------*
 * CAMCDoc::GetStringTable
 *
 *
 *--------------------------------------------------------------------------*/

IStringTablePrivate* CAMCDoc::GetStringTable() const
{
    return m_spStringTable;
}

/*+-------------------------------------------------------------------------*
 * CAMCDoc::LoadFavorites
 *
 *
 *--------------------------------------------------------------------------*/

bool CAMCDoc::LoadFavorites ()
{
    ASSERT(m_spStorage != NULL);

    // Open the stream for the cache
    IStreamPtr spStream;
    HRESULT hr = OpenDebugStream(m_spStorage, AMCFavoritesStreamName,
                     STGM_SHARE_EXCLUSIVE | STGM_READWRITE, L"FavoritesStream", &spStream);
    if (FAILED(hr)) // did not find the stream - could be an older version.
        return hr;

    hr = GetFavorites()->Read(spStream);

    return (SUCCEEDED (hr));
}


void ShowAdminToolsOnMenu(LPCTSTR lpszFilename)
{
    static const TCHAR szAdminKey[] = _T("Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced");
    static const TCHAR szAdminValue[] = _T("StartMenuAdminTools");
    static const TCHAR szBroadcastParam[] = _T("ShellMenu");
    static const TCHAR szYes[] = _T("YES");

    CString strPath(lpszFilename);
    int nLastSepIndex = strPath.ReverseFind (_T('\\'));

    if (nLastSepIndex != -1)
    {
        // if we got "d:\filename", make sure to include the trailing separator
        if (nLastSepIndex < 3)
            nLastSepIndex++;

        // Form full path name (accounting for current directory info)
        TCHAR   szFullPathName[MAX_PATH];
        GetFullPathName (strPath.Left(nLastSepIndex), countof(szFullPathName),
                         szFullPathName, NULL);

        // if saving to admin tools
        if (AMCGetApp()->GetDefaultDirectory() == szFullPathName)
        {
            // set reg key to add admin tools to start menu
            HKEY hkey;
            long r = RegOpenKeyEx (HKEY_CURRENT_USER, szAdminKey, 0, KEY_ALL_ACCESS, &hkey);
            ASSERT(r == ERROR_SUCCESS);

            if (r == ERROR_SUCCESS)
            {
                // get current value
                TCHAR szBuffer[4];
                DWORD dwType = REG_SZ;
                DWORD dwCount = sizeof(szBuffer);
                r = RegQueryValueEx (hkey, szAdminValue, NULL, &dwType,(LPBYTE)szBuffer, &dwCount);

                // if value isn't "YES" then change it, and broadcast change message
                if (r != ERROR_SUCCESS || dwType != REG_SZ || lstrcmpi(szBuffer, szYes) != 0)
                {
                    r = RegSetValueEx (hkey, szAdminValue, NULL, REG_SZ, (CONST BYTE *)szYes, sizeof(szYes));
                    ASSERT(r == ERROR_SUCCESS);

                    ULONG_PTR dwRes;
                    SendMessageTimeout(HWND_BROADCAST, WM_SETTINGCHANGE, (WPARAM)0,
                                        (LPARAM)szBroadcastParam, SMTO_ABORTIFHUNG|SMTO_NORMAL, 100, &dwRes);
                }

                RegCloseKey(hkey);
            }
        }
    }
}


void CAMCDoc::PersistCustomData (CPersistor &persistor)
{
    CPersistor persistorCustom(persistor, XML_TAG_CUSTOM_DATA);
    // persist custom title
    // It may not exist, and that's OK if it doesn't.
    // It just means we don't have a custom title.
    if ((persistorCustom.IsLoading()
         && persistorCustom.HasElement(XML_TAG_STRING_TABLE_STRING, XML_ATTR_CUSTOM_TITLE))
     || (persistorCustom.IsStoring() && HasCustomTitle()))
    {
        if(m_pstrCustomTitle)
            persistorCustom.PersistString(XML_ATTR_CUSTOM_TITLE, *m_pstrCustomTitle);
    }

    // persist custom icon
    CXMLPersistableIcon persIcon(m_CustomIcon);

    bool bHasIcon = persistorCustom.IsLoading() && persistorCustom.HasElement(persIcon.GetXMLType(), NULL);
    bHasIcon = bHasIcon || persistorCustom.IsStoring() && HasCustomIcon();

    if (!bHasIcon)
        return;

    persistorCustom.Persist(persIcon);

    if (persistorCustom.IsLoading())
    {
        CWnd* pMainWnd = AfxGetMainWnd();
        pMainWnd->SetIcon (GetCustomIcon (true),  true);
        pMainWnd->SetIcon (GetCustomIcon (false), false);
    }
}



/***************************************************************************\
 *
 * METHOD:  GetCurrentFileVersionAsString
 *
 * PURPOSE: formats current file version and returns a string
 *
 * PARAMETERS:
 *
 * RETURNS:
 *    CString    - resulting string
 *
\***************************************************************************/
tstring GetCurrentFileVersionAsString()
{
    TCHAR szFileVersion[16];

    // get file version data
    UINT uiMajorVer =    GetConsoleFileMajorVersion(FileVer_Current);
    UINT uiMinorVer =    GetConsoleFileMinorVersion(FileVer_Current);
    UINT uiMinorSubVer = GetConsoleFileMinorSubversion(FileVer_Current);

    if (uiMinorSubVer)
        wsprintf (szFileVersion, _T("%d.%d.%d"),  uiMajorVer,  uiMinorVer, uiMinorSubVer);
    else
        wsprintf (szFileVersion, _T("%d.%d"),  uiMajorVer,  uiMinorVer);

    return szFileVersion;
}

/***************************************************************************\
 *
 * METHOD:  CAMCDoc::ScOnSnapinAdded
 *
 * PURPOSE: Script event firing helper. Implements interface accessible from
 *          node manager
 *
 * PARAMETERS:
 *    PSNAPIN pSnapIn [in] - snapin added to the console
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CAMCDoc::ScOnSnapinAdded(PSNAPIN pSnapIn)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScOnSnapinAdded"));

    CAMCApp*  pApp = AMCGetApp();

    // check
    sc = ScCheckPointers(pApp, E_UNEXPECTED);
    if (sc)
        return sc;

    // forward
    sc = pApp->ScOnSnapinAdded(this, pSnapIn);
    if (sc)
        return sc;


    return sc;
}

/***************************************************************************\
 *
 * METHOD:  CAMCDoc::ScOnSnapinRemoved
 *
 * PURPOSE: Script event firing helper. Implements interface accessible from
 *          node manager
 *
 * PARAMETERS:
 *    PSNAPIN pSnapIn [in] - snapin removed from console
 *
 * RETURNS:
 *    SC    - result code
 *
\***************************************************************************/
SC CAMCDoc::ScOnSnapinRemoved(PSNAPIN pSnapIn)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::ScOnSnapinRemoved"));

    CAMCApp*  pApp = AMCGetApp();

    // check
    sc = ScCheckPointers(pApp, E_UNEXPECTED);
    if (sc)
        return sc;

    // forward
    sc = pApp->ScOnSnapinRemoved(this, pSnapIn);
    if (sc)
        return sc;

    return sc;
}

//+-------------------------------------------------------------------
//
//  Member:      CAMCDoc::ScSetHelpCollectionInvalid
//
//  Synopsis:    A snapin is added/removed or extension is
//               enabled/disabled therefore help collection
//               no longer reflects current console file.
//
//  Arguments:
//
//  Returns:     SC
//
//--------------------------------------------------------------------
SC CAMCDoc::ScSetHelpCollectionInvalid ()
{
    DECLARE_SC(sc, _T("CAMCDoc::ScSetHelpCollectionInvalid"));

    HELPDOCINFO *pHelpDocInfo = GetHelpDocInfo();
    sc = ScCheckPointers(pHelpDocInfo, E_UNEXPECTED);
    if (sc)
        return sc;

    // console file modify time has to be updated for help collection.
    GetSystemTimeAsFileTime(&pHelpDocInfo->m_ftimeModify);

    return (sc);
}



SC CAMCDoc::Scget_Application(PPAPPLICATION  ppApplication)
{
    DECLARE_SC(sc, TEXT("CAMCDoc::Scget_Application"));

    // parameter check
    sc = ScCheckPointers(ppApplication, E_UNEXPECTED);
    if (sc)
        return sc;

    // initialization
    *ppApplication = NULL;

    CAMCApp*  pApp = AMCGetApp();

    // check
    sc = ScCheckPointers(pApp, E_UNEXPECTED);
    if (sc)
        return sc;

    sc = pApp->ScGet_Application(ppApplication);
    if (sc)
        return sc;

    return sc;
}