windows-xp/Source/XPSP1/NT/base/cluster/admin/common/atlbasewiz.cpp

/////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 1996-2000 Microsoft Corporation
//
//  Module Name:
//      AtlBaseWiz.cpp
//
//  Abstract:
//      Implementation of the CWizardWindow class.
//
//  Author:
//      David Potter (davidp)   December 2, 1997
//
//  Revision History:
//
//  Notes:
//
/////////////////////////////////////////////////////////////////////////////

#include "AtlBaseWiz.h"
#include "AtlBaseWizPage.h"
#include "AtlExtDll.h"
#include "StlUtils.h"
#include "ExcOper.h"
#include "AdmCommonRes.h"

/////////////////////////////////////////////////////////////////////////////
// Local Type Definitions
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//
//  class CAltExtWizardGuardPage
//
//  Purpose:
//      Guard page transferring control between the main wizard and the
//      alternate extension wizard.
//
/////////////////////////////////////////////////////////////////////////////

template < class T >
class CAltExtWizardGuardPage
    : public CExtensionWizardPageImpl< T >
{
    typedef CAltExtWizardGuardPage< T > thisClass;
    typedef CExtensionWizardPageImpl< T > baseClass;

public:
    //
    // Construction.
    //

    // Standard constructor
    CAltExtWizardGuardPage(
        DLGTEMPLATE * pdt
        )
        : m_pdt( pdt )
    {
        ATLASSERT( pdt != NULL );

    } //*** CAltExtWizardGuardPage()

    // Destructor
    ~CAltExtWizardGuardPage( void )
    {
        delete m_pdt;

    } //*** ~CAltExtWizardGuardPage()

    WIZARDPAGE_HEADERTITLEID( 0 )
    WIZARDPAGE_HEADERSUBTITLEID( 0 )

    enum { IDD = 0 };
    DECLARE_CLASS_NAME()

    // Return the help ID map
    static const DWORD * PidHelpMap( void )
    {
        static const DWORD s_aHelpIDs[] = { 0, 0 };
        return s_aHelpIDs;

    } //*** PidHelpMap()

    // Create the page
    DWORD ScCreatePage( void )
    {
        ATLASSERT( m_hpage == NULL );

        m_psp.dwFlags |= PSP_DLGINDIRECT;
        m_psp.pResource = m_pdt;

        m_hpage = CreatePropertySheetPage( &m_psp );
        if ( m_hpage == NULL )
        {
            return GetLastError();
        } // if:  error creating the page

        return ERROR_SUCCESS;

    } //*** ScCreatePage()

public:
    //
    // Message map.
    //
    BEGIN_MSG_MAP( thisClass )
        MESSAGE_HANDLER( WM_ACTIVATE, OnActivate )
        CHAIN_MSG_MAP( baseClass )
    END_MSG_MAP()

    //
    // Message handler functions.
    //

    // Handler for the WM_ACTIVATE message
    LRESULT OnActivate(
        UINT uMsg,
        WPARAM wParam,
        LPARAM lParam,
        BOOL & bHandled
        )
    {
        //
        // Don't allow us to be activated.
        //
        WORD fActive = LOWORD( wParam );
        HWND hwndPrevious = (HWND) lParam;
        if ( wParam != WA_INACTIVE )
        {
            ::SetActiveWindow( hwndPrevious );
        }
        return 0;

    } //*** OnActivate()

    //
    // Message handler override functions.
    //

protected:
    DLGTEMPLATE *   m_pdt;

}; //*** class CAltExtWizardGuardPage

/////////////////////////////////////////////////////////////////////////////
//
//  class CAltExtWizardPreLauncherPage
//
//  Purpose:
//      Extension launcher wizard page used to display Wizard97 pages in
//      a non-Wizard97 sheet or vice-versa.
//
/////////////////////////////////////////////////////////////////////////////

class CAltExtWizardPreLauncherPage
    : public CAltExtWizardGuardPage< CAltExtWizardPreLauncherPage >
{
    typedef CAltExtWizardGuardPage< CAltExtWizardPreLauncherPage > baseClass;

public:
    //
    // Construction.
    //

    // Standard constructor
    CAltExtWizardPreLauncherPage(
        DLGTEMPLATE * pdt
        )
        : baseClass( pdt )
    {
    } //*** CAltExtWizardPreLauncherPage()

    DECLARE_CLASS_NAME()

public:
    //
    // Message map.
    //
    //BEGIN_MSG_MAP( CAltExtWizardPreLauncherPage )
    //  CHAIN_MSG_MAP( baseClass )
    //END_MSG_MAP()

    //
    // Message handler functions.
    //

    //
    // Message handler overrides functions.
    //

    // Handler for PSN_SETACTIVE
    BOOL OnSetActive( void );

}; //*** class CAltExtWizardPreLauncherPage

/////////////////////////////////////////////////////////////////////////////
//
//  class CAltExtWizardPostLauncherPage
//
//  Purpose:
//      Page use to switch between the main wizard and the alternate
//      extension wizard when moving backwards.
//
/////////////////////////////////////////////////////////////////////////////

class CAltExtWizardPostLauncherPage
    : public CAltExtWizardGuardPage< CAltExtWizardPostLauncherPage >
{
    typedef CAltExtWizardGuardPage< CAltExtWizardPostLauncherPage > baseClass;

public:
    //
    // Construction.
    //

    // Standard constructor
    CAltExtWizardPostLauncherPage(
        DLGTEMPLATE * pdt
        )
        : baseClass( pdt )
    {
    } //*** CAltExtWizardPostLauncherPage()

    DECLARE_CLASS_NAME()

public:
    //
    // Message map.
    //
    //BEGIN_MSG_MAP( CAltExtWizardPostLauncherPage )
    //  CHAIN_MSG_MAP( baseClass )
    //END_MSG_MAP()

    //
    // Message handler functions.
    //

    //
    // Message handler override functions.
    //

    // Handler for PSN_SETACTIVE
    BOOL OnSetActive( void );

}; //*** class CAltExtWizardPostLauncherPage

/////////////////////////////////////////////////////////////////////////////
//
//  class CAltExtWizard
//
//  Purpose:
//      Dummy wizard to host pages that are not of the same type as the main
//      wizard, e.g. non-Wizard97 pages in a Wizard97 wizard.
//
/////////////////////////////////////////////////////////////////////////////

class CAltExtWizard : public CWizardImpl< CAltExtWizard >
{
    typedef CWizardImpl< CAltExtWizard > baseClass;

    friend class CWizardWindow;
    friend class CAltExtWizardPreLauncherPage;
    friend class CAltExtWizardPostLauncherPage;
    friend class CAltExtWizardPrefixPage;
    friend class CAltExtWizardPostfixPage;

public:
    //
    // Construction
    //

    // Standard constructor
    CAltExtWizard( void )
        : CWizardImpl< CAltExtWizard >( _T("") )
        , m_pwizMain( NULL )
        , m_bWindowMoved( FALSE )
        , m_bExitMsgLoop( FALSE )
        , m_nExitButton( 0 )
    {
    } //*** CExtensionAltWizard()

    // Initialize the sheet
    BOOL BInit( IN CWizardWindow * pwiz );

public:
    //
    // Message map.
    //
    BEGIN_MSG_MAP( CAltExtWizard )
        COMMAND_HANDLER( IDCANCEL, BN_CLICKED, OnCancel )
        CHAIN_MSG_MAP( baseClass )
    END_MSG_MAP()

    //
    // Message handler functions.
    //

    // Handler for BN_CLICKED on the Cancel button
    LRESULT OnCancel(
        WORD wNotifyCode,
        WORD idCtrl,
        HWND hwndCtrl,
        BOOL & bHandled
        )
    {
        //
        // Notify the main wizard that the user pressed the cancel button.
        //
        ExitMessageLoop( PSBTN_CANCEL );
        bHandled = FALSE;
        return 0;

    } //*** OnCancel()

    //
    // Message handler override functions.
    //

    // Handler for the final message after WM_DESTROY
    void OnFinalMessage( HWND hWnd )
    {
        PwizMain()->DeleteAlternateWizard();

    } //*** OnFinalMessage()

protected:
    CWizardWindow * m_pwizMain;     // Pointer to the main wizard.
    BOOL            m_bWindowMoved; // Indicates whether this window has been
                                    //   repositioned over main wizard or not.
    BOOL            m_bExitMsgLoop; // Indicates whether the message loop
                                    //   should be exited or not.
    DWORD           m_nExitButton;  // Button to press after exiting.

protected:
    // Return a pointer to the main wizard
    CWizardWindow * PwizMain( void ) { return m_pwizMain; }

    // Return whether the wizard has been moved yet
    BOOL BWindowMoved( void ) const { return m_bWindowMoved; }

    // Return whether the message loop should be exited or not
    BOOL BExitMessageLoop( void ) const { return m_bExitMsgLoop; }

    // Change whether the message loop should be exited or not
    void ExitMessageLoop( IN DWORD nButton )
    {
        ATLASSERT( (nButton == PSBTN_BACK) || (nButton == PSBTN_NEXT) || (nButton == PSBTN_CANCEL) );
        m_bExitMsgLoop = TRUE;
        m_nExitButton = nButton;

    } //*** ExitMessageLoop()

    // Return the button to press in the main wizard after exiting
    DWORD NExitButton( void ) const { return m_nExitButton; }

protected:
    // Add the prefix page
    BOOL BAddPrefixPage( IN WORD cx, IN WORD cy );

    // Add the postfix page
    BOOL BAddPostfixPage( IN WORD cx, IN WORD cy );

    // Display the alternate wizard
    void DisplayAlternateWizard( void );

    // Display the main wizard
    void DisplayMainWizard( void );

    // Destroy the alternate extension wizard
    void DestroyAlternateWizard( void );

    // Message loop for the modeless wizard
    void MessageLoop( void );

}; //*** class CAltExtWizard

/////////////////////////////////////////////////////////////////////////////
//
//  class CAltExtWizardPrefixPage
//
//  Purpose:
//      Wizard page which precedes the first alternate page.  This page
//      handles transferring control between the main wizard and the
//      alternate wizard.
//
/////////////////////////////////////////////////////////////////////////////

class CAltExtWizardPrefixPage
    : public CAltExtWizardGuardPage< CAltExtWizardPrefixPage >
{
    typedef CAltExtWizardGuardPage< CAltExtWizardPrefixPage > baseClass;

public:
    //
    // Construction.
    //

    // Standard constructor
    CAltExtWizardPrefixPage(
        DLGTEMPLATE * pdt
        )
        : baseClass( pdt )
    {
    } //*** CAltExtWizardPrefixPage()

    DECLARE_CLASS_NAME()

public:
    //
    // Message map.
    //
    //BEGIN_MSG_MAP( CAltExtWizardPrefixPage )
    //  CHAIN_MSG_MAP( baseClass )
    //END_MSG_MAP()

    //
    // Message handler functions.
    //

    //
    // Message handler override functions.
    //

    // Handler for PSN_SETACTIVE
    BOOL OnSetActive( void );

protected:
    // Return the alternate wizard object
    CAltExtWizard * PwizThis( void ) { return (CAltExtWizard *) Pwiz(); }

}; //*** class CAltExtWizardPrefixPage

/////////////////////////////////////////////////////////////////////////////
//
//  class CAltExtWizardPostfixPage
//
//  Purpose:
//      Wizard page which follows the last alternate page.  This page
//      handles transferring control between the main wizard and the
//      alternate wizard.
//
/////////////////////////////////////////////////////////////////////////////

class CAltExtWizardPostfixPage
    : public CAltExtWizardGuardPage< CAltExtWizardPostfixPage >
{
    typedef CAltExtWizardGuardPage< CAltExtWizardPostfixPage > baseClass;

public:
    //
    // Construction.
    //
    // Standard constructor
    CAltExtWizardPostfixPage(
        DLGTEMPLATE * pdt
        )
        : baseClass( pdt )
    {
    } //*** CAltExtWizardPostfixPage()

    DECLARE_CLASS_NAME()

public:
    //
    // Message map.
    //
    //BEGIN_MSG_MAP( CAltExtWizardPostfixPage )
    //  CHAIN_MSG_MAP( baseClass )
    //END_MSG_MAP()

    //
    // Message handler functions.
    //

    //
    // Message handler override functions.
    //

    // Handler for PSN_SETACTIVE
    BOOL OnSetActive( void );

protected:
    // Return the alternate wizard object
    CAltExtWizard * PwizThis( void ) { return (CAltExtWizard *) Pwiz(); }

}; //*** class CAltExtWizardPostfixPage


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// class CWizardWindow
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CWizardWindow::~CWizardWindow
//
//  Routine Description:
//      Destructor.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//  Exceptions Thrown:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CWizardWindow::~CWizardWindow( void )
{
    //
    // Delete the alternate wizard, if it exists.
    //
    if ( (PwizAlternate() != NULL) && (PwizAlternate()->m_hWnd != NULL) )
    {
        reinterpret_cast< CAltExtWizard * >( PwizAlternate() )->DestroyAlternateWizard();
    } // if:  alternate wizard exists

    //
    // Delete pages from the page list.
    //
    if ( m_plwpPages != NULL )
    {
        DeleteAllPtrListItems( m_plwpPages );
        delete m_plwpPages;
    } // if:  page array has been allocated

    if ( m_plewpNormal != NULL )
    {
        DeleteAllPtrListItems( m_plewpNormal );
        delete m_plewpNormal;
    } // if:  list already exists

    if ( m_plewpAlternate != NULL )
    {
        DeleteAllPtrListItems( m_plewpAlternate );
        delete m_plewpAlternate;
    } // if:  list already exists

} //*** CWizardWindow::~CWizardWindow()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CWizardWindow::BAddPage
//
//  Routine Description:
//      Add a page to the page list.  If it is the first page, it won't have
//      a BACK button.  If it isn't the first page, the last page will have
//      its FINISH button changed to a NEXT button and this page will have
//      both a FINISH button and a BACK button.
//
//  Arguments:
//      pwp     [IN] Wizard page to add.
//
//  Return Value:
//      TRUE    Page added successfully.
//      FALSE   Error adding page.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CWizardWindow::BAddPage( IN CWizardPageWindow * pwp )
{
    ATLASSERT( pwp != NULL );

    // Make sure specified page hasn't already been added.
    ATLASSERT( (m_plwpPages == NULL)
            || (std::find( PlwpPages()->begin(), PlwpPages()->end(), pwp ) == PlwpPages()->end()) );

    BOOL bSuccess = FALSE;
    ULONG fWizardButtons = PSWIZB_FINISH;
    ULONG fPrevWizardButtons;

    // Loop to avoid goto's.
    do
    {
        //
        // Allocate the page list if it doesn't exist yet.
        //
        if ( m_plwpPages == NULL )
        {
            m_plwpPages = new CWizardPageList;
            if ( m_plwpPages == NULL )
            {
                CNTException nte(
                                E_OUTOFMEMORY,
                                ADMC_IDS_ADD_FIRST_PAGE_TO_PROP_SHEET_ERROR,
                                NULL,   // pszOperArg1
                                NULL,   // pszOperArg2
                                FALSE   // bAutoDelete
                                );
                nte.ReportError();
                break;
            } // if:  error allocating page list
        } // if:  no page array yet

        //
        // If this is not the first page in the list, set the previous
        // page's wizard buttons to have a NEXT button instead of a
        // FINISH button and set this page to have a BACK button.
        //
        if ( PlwpPages()->size() > 0 )
        {
            //
            // Get the current last page.
            //
            CWizardPageList::iterator itFirst = PlwpPages()->begin();
            CWizardPageList::iterator itLast  = PlwpPages()->end();
            ATLASSERT( itFirst != itLast );
            CWizardPageWindow * pwpPrev = *(--PlwpPages()->end());
            ATLASSERT( pwpPrev != NULL );

            //
            // Set the wizard buttons on that page.
            //
            fPrevWizardButtons = pwpPrev->FWizardButtons();
            fPrevWizardButtons &= ~PSWIZB_FINISH;
            fPrevWizardButtons |= PSWIZB_NEXT;
            pwpPrev->SetDefaultWizardButtons( fPrevWizardButtons );

            fWizardButtons |= PSWIZB_BACK;
        } // if:  not the first page added

        pwp->SetDefaultWizardButtons( fWizardButtons );

        //
        // Insert the page at the end of the list.
        //
        PlwpPages()->insert( PlwpPages()->end(), pwp );

        //
        // Add the page to the sheet.  If the sheet hasn't been created yet,
        // add it to the sheet header list.  If the sheet has been created,
        // add it to the sheet dynamically.  Note that the page must not be a
        // static page.
        //
        if ( m_hWnd == NULL )
        {
            //
            // If this is a dynamic page, add it using its hpage.  Otherwise
            // it must be a static page.  Add it by its property sheet page header.
            //
            CDynamicWizardPageWindow * pdwp = dynamic_cast< CDynamicWizardPageWindow * >( pwp );
            if ( pdwp != NULL )
            {
                if ( pdwp->Hpage() != NULL )
                {
                    ATLASSERT( ! pdwp->BPageAddedToSheet() );
                    bSuccess = BAddPageToSheetHeader( pdwp->Hpage() );
                    if ( ! bSuccess )
                    {
                        CNTException nte(
                            GetLastError(),
                            ADMC_IDS_ADD_PAGE_TO_WIZARD_ERROR,
                            NULL,
                            NULL,
                            FALSE
                            );
                        nte.ReportError();
                        break;
                    } // if:  error adding the page to the sheet header
                    pdwp->SetPageAdded( TRUE );
                } // if:  page already created
            } // if:  dynamic page
            else
            {
                // Must be static page
                ATLASSERT( dynamic_cast< CStaticWizardPageWindow * >( pwp ) != NULL );

                //
                // Initialize the page.
                //
                bSuccess = pwp->BInit( this );
                if ( ! bSuccess )
                {
                    break;
                } // if:  error initializing the page

                //
                // Add the page.
                //
                bSuccess = AddPage( pwp->Ppsp() );
                if ( ! bSuccess )
                {
                    CNTException nte(
                        GetLastError(),
                        ADMC_IDS_ADD_PAGE_TO_WIZARD_ERROR,
                        NULL,
                        NULL,
                        FALSE
                        );
                    nte.ReportError();
                    break;
                } // if:  error adding the page
            } // else:  not dynamic page
        } // if:  sheet has been created
        else
        {
            // Can't be static page.  Must be dynamic page.
            ATLASSERT( dynamic_cast< CStaticWizardPageWindow * >( pwp ) == NULL );
            CDynamicWizardPageWindow * pdwp = dynamic_cast< CDynamicWizardPageWindow * >( pwp );
            ATLASSERT( pdwp != NULL );
            AddPage( pdwp->Hpage() );
            pdwp->SetPageAdded( TRUE );
        } // else:  sheet already created

        //
        // If we get to here we are successfully.
        //
        bSuccess = TRUE;
    } while ( 0 );
        
    return bSuccess;

} //*** CWizardWindow::BAddPage()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CWizardWindow::OnSheetInitialized
//
//  Routine Description:
//      Handler for PSCB_INITIALIZED.
//      Add pages that haven't been added yet, which will only be dynamic
//      pages.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//  Exceptions Thrown:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CWizardWindow::OnSheetInitialized( void )
{
    //
    // Remove the system menu.
    //
    ModifyStyle( WS_SYSMENU, 0 );

    //
    // Add dynamic pages, including extension pages, if not added yet.
    //
    {
        //
        // Get pointers to beginning and end of list.
        //
        CWizardPageList::iterator itCurrent = PlwpPages()->begin();
        CWizardPageList::iterator itLast = PlwpPages()->end();

        //
        // Loop through the list and add each dynamic page.
        //
        for ( ; itCurrent != itLast ; itCurrent++ )
        {
            CDynamicWizardPageWindow * pdwp = dynamic_cast< CDynamicWizardPageWindow * >( *itCurrent );
            if ( pdwp != NULL )
            {
                if ( ! pdwp->BPageAddedToSheet() && (pdwp->Hpage() != NULL) )
                {
                    AddPage( pdwp->Hpage() );
                    pdwp->SetPageAdded( TRUE );
                } // if:  page not added yet and page has already been created
            } // if:  dynamic page found
        } // for:  each item in the list

    } // Add dynamic pages, including extension pages

    //
    // Call the base class method.
    //
    CBaseSheetWindow::OnSheetInitialized();

} //*** CWizardWindow::OnSheetInitialized()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CWizardWindow::SetNextPage
//
//  Routine Description:
//      Set the next page to be displayed.
//
//  Arguments:
//      pwCurrentPage   [IN] Current page whose next page is to be enabled.
//      pszNextPage     [IN] Page ID.
//
//  Return Value:
//      pwizpg
//
//--
/////////////////////////////////////////////////////////////////////////////
void CWizardWindow::SetNextPage(
    IN CWizardPageWindow *  pwCurrentPage,
    IN LPCTSTR              pszNextPage
    )
{
    ATLASSERT( pwCurrentPage != NULL );
    ATLASSERT( pszNextPage != NULL );

    BOOL                        bFoundCurrent = FALSE;
    CWizardPageWindow *         pwPage;
    CWizardPageList::iterator   itCurrent = PlwpPages()->begin();
    CWizardPageList::iterator   itLast = PlwpPages()->end();

    //
    // Skip pages until the current page is found.
    //
    for ( ; itCurrent != itLast ; itCurrent++ )
    {
        pwPage = *itCurrent;
        if ( pwPage == pwCurrentPage )
        {
            bFoundCurrent = TRUE;
            break;
        } // if:  found the current page
    } // for:  each page in the list

    ATLASSERT( bFoundCurrent );

    //
    // Disable all succeeding pages until the desired next page
    // is found.  Enable that page and then exit.
    //
    for ( itCurrent++ ; itCurrent != itLast ; itCurrent++ )
    {
        if ( (*itCurrent)->Ppsp()->pszTemplate == pszNextPage )
        {
            (*itCurrent)->EnablePage( TRUE );
            break;
        } // if:  found the page
        (*itCurrent)->EnablePage( FALSE );
    } // for:  each page in the list

    ATLASSERT( itCurrent != itLast );

} //*** CWizardWindow::SetNextPage( pszNextPage )

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CWizardWindow::AddExtensionPages
//
//  Routine Description:
//      Add extension pages to the sheet.
//
//  Arguments:
//      hfont       [IN] Font to use for the extension pages.
//      hicon       [IN] Icon to use for the extension pages.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CWizardWindow::AddExtensionPages( IN HFONT hfont, IN HICON hicon )
{
    ATLASSERT( PcoObjectToExtend() != NULL );

    //
    // Add extension pages if there any extensions.
    //
    if (   (PcoObjectToExtend()->PlstrAdminExtensions() != NULL)
        && (PcoObjectToExtend()->PlstrAdminExtensions()->size() > 0) )
    {
        //
        // Get the currently selected page so we can reset it when we're done.
        //
        CTabCtrl tabc( GetTabControl() );
        int nCurPage = tabc.GetCurSel();

        //
        // Prepare to add extension pages.
        //
        CDynamicWizardPageList ldwp;
        PrepareToAddExtensionPages( ldwp );

        //
        // If no extensions object has been created yet, create it now.
        //
        if ( Pext() == NULL )
        {
            m_pext = new CCluAdmExtensions;
            ATLASSERT( m_pext != NULL );
            if ( m_pext == NULL )
            {
                return;
            } // if: error allocating the extension object
        } // if:  no extensions list yet

        //
        // Enclose the loading of the extension in a try/catch block so
        // that a failure to load the extension won't prevent all pages
        // from being displayed.
        //
        try
        {
            if ( BWizard97() )
            {
                Pext()->CreateWizard97Pages(
                        this,
                        *PcoObjectToExtend()->PlstrAdminExtensions(),
                        PcoObjectToExtend(),
                        hfont,
                        hicon
                        );
            } // if:  Wizard97 wizard
            else
            {
                Pext()->CreateWizardPages(
                        this,
                        *PcoObjectToExtend()->PlstrAdminExtensions(),
                        PcoObjectToExtend(),
                        hfont,
                        hicon
                        );
            } // else:  non-Wizard97 wizard
        } // try
        catch (...)
        {
        } // catch:  anything

        //
        // Complete the process of adding extension pages.
        //
        CompleteAddingExtensionPages( ldwp );

        //
        // Restore the current selection.
        // This has to be done because sometimes the above process causes
        // the current page to be set to the last page added, which prevents
        // the next page from being displayed.
        //
        SetActivePage( nCurPage );
    } // if:  object has extensions
    else
    {
        //
        // Remove extension pages.
        //
        RemoveAllExtensionPages();
    } // else:  object doesn't have extensions

}  //*** CWizardWindow::AddExtensionPages()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CWizardWindow::PrepareToAddExtensionPages
//
//  Routine Description:
//      Prepare to add extension pages by deleting existing extension
//      pages and removing dynamic pages.
//
//  Arguments:
//      rldwp       [IN OUT] List of dynamic wizard pages.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CWizardWindow::PrepareToAddExtensionPages(
    IN OUT CDynamicWizardPageList & rldwp
    )
{
    //
    // Delete all extension pages from this wizard.  This also
    // includes destroy the alternate wizard if it exists.
    //
    RemoveAllExtensionPages();

    //
    // Delete the lists of extension pages and make sure the lists exist.
    //
    if ( PlewpNormal() != NULL )
    {
        DeleteAllPtrListItems( PlewpNormal() );
    } // if:  list already exists
    else
    {
        m_plewpNormal = new CExtensionWizardPageList;
        if ( m_plewpNormal == NULL )
        {
            return;
        } // if: error allocating the page list
    } // else:  list doesn't exist yet
    if ( PlewpAlternate() != NULL )
    {
        DeleteAllPtrListItems( PlewpAlternate() );
    } // if:  list already exists
    else
    {
        m_plewpAlternate = new CExtensionWizardPageList;
        if ( m_plewpAlternate == NULL )
        {
            return;
        } // if: error allocating the page list
    } // else:  list doesn't exist yet

    //
    // Move all dynamic pages to the temporary list.
    //
    ATLASSERT( rldwp.size() == 0 );
    MovePtrListItems< CWizardPageWindow *, CDynamicWizardPageWindow * >( PlwpPages(), &rldwp );

    //
    // Remove all pages in the temporary list from the wizard.
    //
    {
        CDynamicWizardPageList::iterator itCurrent;
        CDynamicWizardPageList::iterator itLast;

        itCurrent = rldwp.begin();
        itLast = rldwp.end();
        for ( ; itCurrent != itLast ; itCurrent++ )
        {
            CDynamicWizardPageWindow * pdwp = *itCurrent;
            ATLASSERT( pdwp != NULL );
            if ( pdwp->Hpage() != NULL )
            {
                RemovePage( pdwp->Hpage() );
                pdwp->SetPageAdded( FALSE );
            } // if:  page already created
        } // for:  each page in the list
    } // Remove dynamic pages

} //*** CWizardWindow::PrepareToAddExtensionPages()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CWizardWindow::HrAddExtensionPage
//
//  Routine Description:
//      Add an extension page.
//
//  Arguments:
//      ppage       [IN] Page to be added.
//
//  Return Value:
//      S_OK        Page added successfully.
//      S_FALSE     Page not added.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CWizardWindow::HrAddExtensionPage( IN CBasePageWindow * ppage )
{
    ATLASSERT( ppage != NULL );

    HRESULT hr = S_OK;

    //
    // Make sure this is an extension wizard page object.
    //
    CExtensionWizardPageWindow * pewp = dynamic_cast< CExtensionWizardPageWindow * >( ppage );
    ATLASSERT( pewp != NULL );

    if (   (ppage == NULL)
        || (pewp == NULL ) )
    {
        return S_FALSE;
    } // if:  invalid arguments

    //
    // If the page is not the same as the type of wizard, add it to the
    // alternate list of extension pages and indicate we need a dummy sheet.
    // Otherwise, add it to the standard list of extension pages.
    //
    CExtensionWizard97PageWindow * pew97p = dynamic_cast< CExtensionWizard97PageWindow * >( ppage );
    if (   ((pew97p != NULL) && ! BWizard97())
        || ((pew97p == NULL) && BWizard97()) )
    {
        PlewpAlternate()->insert( PlewpAlternate()->end(), pewp );
    } // if:  trying to add the wrong type of page
    else
    {
        PlewpNormal()->insert( PlewpNormal()->end(), pewp );
    } // else:  adding page of matching type

    return hr;

}  //*** CWizardWindow::HrAddExtensionPage()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CWizardWindow::CompleteAddingExtensionPages
//
//  Routine Description:
//      Complete the process of adding extension pages to the wizard by
//      re-adding dynamic pages.
//
//  Arguments:
//      rldwp       [IN OUT] List of dynamic wizard pages.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CWizardWindow::CompleteAddingExtensionPages(
    IN OUT CDynamicWizardPageList & rldwp
    )
{
    //
    // If there are any normal pages, add them here.
    // There will be normal pages if pages of the same type as the wizard
    // were added.
    //
    if ( PlewpNormal()->size() > 0 )
    {
        //
        // Add pages to the sheet.
        //
        if ( m_hWnd != NULL )
        {
            CExtensionWizardPageList::iterator itCurrent = PlewpNormal()->begin();
            CExtensionWizardPageList::iterator itLast = PlewpNormal()->end();

            for ( ; itCurrent != itLast ; itCurrent++ )
            {
                CExtensionWizardPageWindow * pewp = *itCurrent;
                ATLASSERT( pewp != NULL );
                BAddPage( pewp );
            } // for:  each page in the list
        } // if:  sheet is currently being displayed
    } // if:  there are normal pages

    //
    // If there are any alternate pages, add a pre-extension launcher page
    // and a post-extension launcher page.  The pre-extension launcher page
    // will display an alternate wizard of the appropriate type and hide the
    // main wizard before displaying these pages.  After the final page it
    // will display the original sheet and hide the other sheet.  The
    // post-extension launcher page is used to transition between the main
    // wizard and the alternate wizard when moving backwards into the
    // alternate wizard.
    //
    if ( PlewpAlternate()->size() > 0 )
    {
        DLGTEMPLATE *                   pdt         = NULL;
        CAltExtWizardPreLauncherPage *  pelwpPre    = NULL;
        CAltExtWizardPostLauncherPage * pelwpPost   = NULL;

        // Loop to avoid goto's
        do
        {
            //
            // Add the pre-extension launcher page.
            //
            {
                //
                // Create the dialog template.
                //
                pdt = PdtCreateDummyPageDialogTemplate( 10, 10 );
                ATLASSERT( pdt != NULL );
                if ( pdt == NULL )
                {
                    break;
                } // if: error creating the dialog template

                //
                // Allocate and initialize the launcher page.
                //
                pelwpPre = new CAltExtWizardPreLauncherPage( pdt );
                ATLASSERT( pelwpPre != NULL );
                if ( pelwpPre == NULL )
                {
                    break;
                } // if: error allocating the page
                pdt = NULL;
                if ( ! pelwpPre->BInit( this ) )
                {
                    break;
                } // if:  error initializing the page

                //
                // Create the launcher page.
                //
                DWORD sc = pelwpPre->ScCreatePage();
                if ( sc != ERROR_SUCCESS )
                {
                    CNTException nte(
                        sc,
                        ADMC_IDS_INIT_EXT_PAGES_ERROR,
                        NULL,
                        NULL,
                        FALSE
                        );
                    nte.ReportError();
                    break;
                } // if:  error creating the page

                //
                // Add the launcher page to the wizard.
                //
                BAddPage( pelwpPre );
                pelwpPre = NULL;
            } // Add the pre-extension launcher page

            //
            // Add the post-extension launcher page
            //
            {
                //
                // Create the dialog template.
                //
                pdt = PdtCreateDummyPageDialogTemplate( 10, 10 );
                ATLASSERT( pdt != NULL );
                if ( pdt == NULL )
                {
                    break;
                } // if: error creating the dialog template

                //
                // Allocate and initialize the launcher page.
                //
                pelwpPost = new CAltExtWizardPostLauncherPage( pdt );
                ATLASSERT( pelwpPost != NULL );
                if ( pelwpPost == NULL )
                {
                    break;
                } // if: error allocating page
                pdt = NULL;
                if ( ! pelwpPost->BInit( this ) )
                {
                    break;
                } // if:  error initializing the page

                //
                // Create the launcher page.
                //
                DWORD sc = pelwpPost->ScCreatePage();
                if ( sc != ERROR_SUCCESS )
                {
                    CNTException nte(
                        sc,
                        ADMC_IDS_INIT_EXT_PAGES_ERROR,
                        NULL,
                        NULL,
                        FALSE
                        );
                    nte.ReportError();
                    break;
                } // if:  error creating the page

                //
                // Add the launcher page to the wizard.
                //
                BAddPage( pelwpPost );
                pelwpPost = NULL;
            } // Add the post-extension launcher page
        } while ( 0 );

        //
        // Cleanup;
        //
        delete pelwpPre;
        delete pelwpPost;
        delete pdt;
        
    } // if:  there are alternate pages

    //
    // Move all pages from the temporary list to the real list and
    // add them to the end of the wizard.
    //
    CDynamicWizardPageList::iterator itCurrent = rldwp.begin();
    CDynamicWizardPageList::iterator itLast = rldwp.end();
    while ( itCurrent != itLast )
    {
        CDynamicWizardPageWindow * pdwp = *itCurrent;
        ATLASSERT( pdwp != NULL );

        //
        // Create the page.
        //
        DWORD sc = pdwp->ScCreatePage();
        if ( sc != ERROR_SUCCESS )
        {
            CNTException nte(
                sc,
                ADMC_IDS_INIT_EXT_PAGES_ERROR,
                NULL,
                NULL,
                FALSE
                );
            delete pdwp;
            itCurrent = rldwp.erase( itCurrent );
            continue;
        } // if:  error creating the page

        //
        // Add the page to the wizard.
        // This adds it to the real page list as well.
        //
        BAddPage( pdwp );

        //
        // Remove the page from the temporary list.
        //
        itCurrent = rldwp.erase( itCurrent );
    } // while:  not at last page

} //*** CWizardWindow::CompleteAddingExtensionPages()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CWizardWindow::RemoveAllExtensionPages
//
//  Routine Description:
//      Remove all extension pages from the wizard.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CWizardWindow::RemoveAllExtensionPages( void )
{
    //
    // Delete the alternate extension wizard.
    //
    if ( PwizAlternate() != NULL )
    {
        reinterpret_cast< CAltExtWizard * >( PwizAlternate() )->DestroyAlternateWizard();
    } // if:  alternate wizard being displayed

    //
    // Remove the extension pages.
    //
    CExtensionWizardPageList lewp;
    MovePtrListItems< CWizardPageWindow *, CExtensionWizardPageWindow * >( PlwpPages(), &lewp );
    CExtensionWizardPageList::iterator itCurrent = lewp.begin();
    CExtensionWizardPageList::iterator itLast = lewp.end();
    for ( ; itCurrent != itLast ; itCurrent++ )
    {
        CExtensionWizardPageWindow * pewp = *itCurrent;
        ATLASSERT( pewp != NULL );
        if ( pewp->Hpage() != NULL )
        {
            RemovePage( pewp->Hpage() );
            pewp->SetPageAdded( FALSE );
        } // if:  page already created
    } // for:  each page in the list
    DeleteAllPtrListItems( &lewp );

} //*** CWizardWindow::RemoveAllExtensionPages()


//*************************************************************************//


////////////////////////////////////////////////////////////////////////////
// class CAltExtWizardPreLauncherPage
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizardPreLauncherPage::OnSetActive
//
//  Routine Description:
//      Handler for PSN_SETACTIVE.
//      This page will be displayed if there are pages that are not of the
//      same type as the wizard (e.g. non-Wizard97 pages in a Wizard97
//      wizard).
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE        Page activated successfully.
//      FALSE       Error activating page.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAltExtWizardPreLauncherPage::OnSetActive( void )
{
    UINT            idsReturn = ID_WIZNEXT;
    CAltExtWizard * pwizAlt;

    //
    // When moving forward, create the alternate extension wizard and return
    // TRUE so that the main wizard will wait here.  The alternate wizard
    // will cause the proper button to be pressed so we can do the proper
    // thing when we're done.
    //
    // When moving backward, just return FALSE so we won't be displayed.
    //

    //
    // Create the alternate wizard if moving forward.
    //
    if ( Pwiz()->BNextPressed() )
    {
        // We could have got here by pressing 'Back' on the alternate wizard,
        // and then pressing 'Next' on the normal wizard. So, first check if
        // the alternate wizard has already been created.
        if ( Pwiz()->PwizAlternate() == NULL )
        {
            //
            // Create the alternate extension wizard.
            // It is expected that the wizard doesn't exist yet and that there are
            // alternate extension pages to be displayed.
            //
            ATLASSERT( Pwiz()->PlewpAlternate()->size() > 0 );
            pwizAlt = new CAltExtWizard;
            ATLASSERT( pwizAlt != NULL );
            if ( pwizAlt == NULL )
            {
                return FALSE;
            } // if: error allocating the alternate wizard
            Pwiz()->SetAlternateWizard( pwizAlt );

            //
            // Initialize the alternate extension wizard.
            //
            if ( pwizAlt->BInit( Pwiz() ) )
            {
                //
                // Display the alternate extension wizard.
                // The alternate extension wizard is being displayed as a modeless
                // wizard so that when the user presses the Next button in the
                // wizard and then presses the Back button on the next main wizard
                // page we need the wizard to still exist.
                //
                pwizAlt->Create( GetActiveWindow() );

                //
                // Execute the alternate wizard message loop.
                // This required so that tabs and accelerator keys will work.
                //
                pwizAlt->MessageLoop();
            } // if:  wizard initialized successfully

            return TRUE;
        } // if:    alternate wizard does not exist
        else
        {
            //
            // Display the existing alternate wizard.
            // Press the alternate wizard's Next button because it is waiting at 
            // the prefix page.
            //
            CAltExtWizard * pwizAlt = reinterpret_cast< CAltExtWizard * >( Pwiz()->PwizAlternate() );
            pwizAlt->PressButton( PSBTN_NEXT );
            pwizAlt->DisplayAlternateWizard();

            //
            // Execute the alternate wizard message loop.
            // This required so that tabs and accelerator keys will work.
            //
            pwizAlt->MessageLoop();

            return TRUE;
        } // else: alternate wizard exists already
    } // if:  next button pressed
    else
    {
        ATLASSERT( Pwiz()->BBackPressed() );
        return FALSE;
    } // else:  back button pressed

} //*** CAltExtWizardPreLauncherPage::OnSetActive()


//*************************************************************************//


////////////////////////////////////////////////////////////////////////////
// class CAltExtWizardPostLauncherPage
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizardPostLauncherPage::OnSetActive
//
//  Routine Description:
//      Handler for PSN_SETACTIVE.
//      This page will be displayed if there are pages that are not of the
//      same type as the wizard (e.g. non-Wizard97 pages in a Wizard97
//      wizard).
//             
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE        Page activated successfully.
//      FALSE       Error activating page.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAltExtWizardPostLauncherPage::OnSetActive( void )
{
    //
    // When moving forward just return FALSE so that we won't be displayed.
    //
    // When moving backward, display the alternate extension wizard and
    // return TRUE so that we will be waiting for the alternate wizard to
    // move us to the right place.  Press the alternate wizard's Back button
    // because it is waiting at the postfix page.
    //

    if ( Pwiz()->BNextPressed() )
    {
        return FALSE;
    } // if:  moving forward
    else
    {
        ATLASSERT( Pwiz()->BBackPressed() );

        //
        // Display the alternate wizard.
        //
        CAltExtWizard * pwizAlt = reinterpret_cast< CAltExtWizard * >( Pwiz()->PwizAlternate() );
        pwizAlt->PressButton( PSBTN_BACK );
        pwizAlt->DisplayAlternateWizard();

        //
        // Execute the alternate wizard message loop.
        // This required so that tabs and accelerator keys will work.
        //
        pwizAlt->MessageLoop();

        return TRUE;
    } // else:  moving backward

} //*** CAltExtWizardPostLauncherPage::OnSetActive()


//*************************************************************************//


////////////////////////////////////////////////////////////////////////////
// class CAltExtWizard
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizard::BInit
//
//  Routine Description:
//      Initialize the wizard.
//      This wizard is used to display extension pages that are different
//      than the type of the main wizard, e.g. displaying non-Wizard97 pages
//      in a Wizard97 wizard.  This wizard will have a dummy prefix page
//      and a dummy postfix page, which are only here to handle entering and
//      exiting the wizard.  This routine will add the prefix page, add the
//      alternate extension pages from the main wizard, then add the postfix
//      page.
//
//  Arguments:
//      pwizMain    [IN] Main wizard.
//
//  Return Value:
//      TRUE        Wizard initialized successfully.
//      FALSE       Error initializing wizard.  Error already displayed.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAltExtWizard::BInit( IN CWizardWindow * pwizMain )
{
    ATLASSERT( pwizMain != NULL );
    ATLASSERT( m_pwizMain == NULL );

    BOOL bSuccess;

    m_pwizMain = pwizMain;

    //
    // Setup the type of wizard to be the opposite of the main wizard.
    //
    m_psh.dwFlags &= ~PSH_PROPSHEETPAGE; // Using HPROPSHEETPAGEs.
    if ( ! PwizMain()->BWizard97() )
    {
        // Don't add a watermark since we don't have a watermark bitmap.
        m_psh.dwFlags &= ~(PSH_WIZARD
                            | PSH_WATERMARK
                            );
        m_psh.dwFlags |= (PSH_WIZARD97
                            | PSH_HEADER
                            );
    } // if:  Wizard97 wizard
    else
    {
        m_psh.dwFlags |= PSH_WIZARD;
        m_psh.dwFlags &= ~(PSH_WIZARD97
                            | PSH_WATERMARK
                            | PSH_HEADER
                            );
    } // else:  non-Wizard97 wizard

    // Loop to avoid goto's
    do
    {
        //
        // Get the first page in the main wizard.
        //
        HWND hwndChild = PwizMain()->GetWindow( GW_CHILD );
        ATLASSERT( hwndChild != NULL );

        //
        // Get the current width and height of the child window.
        //
        CRect rect;
        bSuccess = ::GetClientRect( hwndChild, &rect );

        if ( ! bSuccess )
        {
            CNTException nte(
                GetLastError(),
                ADMC_IDS_INIT_EXT_PAGES_ERROR,
                NULL,
                NULL,
                FALSE
                );
            nte.ReportError();
            break;
        } // if:  error getting client rectangle

        //
        // Add a prefix page.
        //
        bSuccess = BAddPrefixPage( (WORD)rect.Width(), (WORD)rect.Height() );

        if ( ! bSuccess )
        {
            break;
        } // if:  error adding the prefix page

        //
        // Add alternate pages from the main wizard to the wizard page list.
        // They will be added to the wizard at sheet initialization time.
        //
        CExtensionWizardPageList::iterator itCurrent = PwizMain()->PlewpAlternate()->begin();
        CExtensionWizardPageList::iterator itLast = PwizMain()->PlewpAlternate()->end();

        while ( itCurrent != itLast )
        {
            CExtensionWizardPageWindow * pewp = *itCurrent;
            ATLASSERT( pewp != NULL );
            PlwpPages()->insert( PlwpPages()->end(), pewp );
            PwizMain()->PlewpAlternate()->erase( itCurrent );
            itCurrent = PwizMain()->PlewpAlternate()->begin();
        } // for:  each page in the list

        //
        // Add a postfix page.
        //
        bSuccess = BAddPostfixPage( (WORD) rect.Width(), (WORD) rect.Height() );
        if ( ! bSuccess )
        {
            break;
        } // if:  error adding the postfix page
    } while ( 0 );

    //
    // Call the base class.
    //
    if ( ! baseClass::BInit() )
    {
        return FALSE;
    } // if:  error initializing the base class

    return bSuccess;

} //*** CAltExtWizard::BInit()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizard::BAddPrefixPage
//
//  Routine Description:
//      Add a prefix page to the wizard.
//
//  Arguments:
//      cx          [IN] Width of the page.
//      cy          [IN] Height of the page.
//
//  Return Value:
//      TRUE        Page added successfully.
//      FALSE       Error adding the page.  Error already displayed.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAltExtWizard::BAddPrefixPage( IN WORD cx, IN WORD cy )
{
    ATLASSERT( cx > 0 );
    ATLASSERT( cy > 0 );

    BOOL                        bSuccess;
    DLGTEMPLATE *               pdt = NULL;
    CAltExtWizardPrefixPage *   pwp = NULL;

    // Loop to avoid goto's
    do
    {
        //
        // Create the dialog template for the page.
        //
        pdt = PdtCreateDummyPageDialogTemplate( cx, cy );
        ATLASSERT( pdt != NULL );
        if ( pdt == NULL )
        {
            bSuccess = FALSE;
            break;
        } // if: error creating the dialog template

        //
        // Adjust the page size so that we will be creating the same size
        // wizard as the main wizard.  Non-Wizard97 wizards add padding
        // (7 DLUs on each side) whereas Wizard97 wizards add no padding
        // to the first page, which is where we are expecting these
        // dimensions to come from.
        //
        if ( BWizard97() )
        {
            pdt->cx += 7 * 2;
            pdt->cy += 7 * 2;
        } // if:  Wizard97 wizard
        else
        {
            pdt->cx -= 7 * 2;
            pdt->cy -= 7 * 2;
        } // else:  non-Wizard97 wizard

        //
        // Allocate and initialize the page.
        //
        pwp = new CAltExtWizardPrefixPage( pdt );
        ATLASSERT( pwp != NULL );
        if ( pwp == NULL )
        {
            bSuccess = FALSE;
            break;
        } // if: error allocating the page
        pdt = NULL;
        bSuccess = pwp->BInit( this );
        if ( ! bSuccess )
        {
            break;
        } // if:  error initializing the page

        //
        // Create the page.
        //
        DWORD sc = pwp->ScCreatePage();
        if ( sc != ERROR_SUCCESS )
        {
            CNTException nte(
                sc,
                ADMC_IDS_INIT_EXT_PAGES_ERROR,
                NULL,
                NULL,
                FALSE
                );
            nte.ReportError();
            bSuccess = FALSE;
            break;
        } // if:  error creating the page

        //
        // Add the page to the wizard.
        //
        bSuccess = BAddPage( pwp );
        pwp = NULL;
    } while ( 0 );

    delete pwp;
    delete pdt;

    return bSuccess;

} //*** CAltExtWizard::BAddPrefixPage()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizard::BAddPostfixPage
//
//  Routine Description:
//      Add a postfix page to the wizard.
//
//  Arguments:
//      cx          [IN] Width of the page.
//      cy          [IN] Height of the page.
//
//  Return Value:
//      TRUE        Page added successfully.
//      FALSE       Error adding the page.  Error already displayed.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAltExtWizard::BAddPostfixPage( IN WORD cx, IN WORD cy )
{
    ATLASSERT( cx > 0 );
    ATLASSERT( cy > 0 );

    BOOL                        bSuccess;
    DLGTEMPLATE *               pdt = NULL;
    CAltExtWizardPostfixPage *  pwp = NULL;

    // Loop to avoid goto's
    do
    {
        //
        // Create the dialog template for the page.
        //
        pdt = PdtCreateDummyPageDialogTemplate( cx, cy );
        ATLASSERT( pdt != NULL );
        if ( pdt == NULL )
        {
            bSuccess = FALSE;
            break;
        } // if: error creating the dialog template

        //
        // Adjust the page size so that we will be creating the same size
        // wizard as the main wizard.  Non-Wizard97 wizards add padding
        // (7 DLUs on each side) whereas Wizard97 wizards add no padding
        // to the first page, which is where we are expecting these
        // dimensions to come from.
        //
        if ( BWizard97() )
        {
            pdt->cx += 7 * 2;
            pdt->cy += 7 * 2;
        } // if:  Wizard97 wizard
        else
        {
            pdt->cx -= 7 * 2;
            pdt->cy -= 7 * 2;
        } // else:  non-Wizard97 wizard

        //
        // Allocate and initialize the page.
        //
        pwp = new CAltExtWizardPostfixPage( pdt );
        ATLASSERT( pwp != NULL );
        if ( pwp == NULL )
        {
            bSuccess = FALSE;
            break;
        } // if: error allocating the page
        pdt = NULL;
        bSuccess = pwp->BInit( this );
        if ( ! bSuccess )
        {
            break;
        } // if:  error initializing the page

        //
        // Create the page.
        //
        DWORD sc = pwp->ScCreatePage();
        if ( sc != ERROR_SUCCESS )
        {
            CNTException nte(
                sc,
                ADMC_IDS_INIT_EXT_PAGES_ERROR,
                NULL,
                NULL,
                FALSE
                );
            nte.ReportError();
            bSuccess = FALSE;
            break;
        } // if:  error creating the page

        //
        // Add the page to the page list.  It will be added to the wizard
        // at sheet initialization time.
        //
        PlwpPages()->insert( PlwpPages()->end(), pwp );
        pwp = NULL;

        bSuccess = TRUE;
    } while ( 0 );

    delete pwp;
    delete pdt;

    return bSuccess;

} //*** CAltExtWizard::BAddPostfixPage()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizard::DisplayAlternateWizard
//
//  Routine Description:
//      Display the alternate wizard.  This involved the following steps:
//      -- Move the alternate wizard to the position of the main wizard.
//      -- Show the alternate wizard.
//      -- Hide the main wizard.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//  Exceptions Thrown:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CAltExtWizard::DisplayAlternateWizard( void )
{
    //
    // Move the alternate wizard to where the main wizard is positioned.
    //
    CRect rectMain;
    CRect rectAlt;
    CRect rectNew;
    if ( PwizMain()->GetWindowRect( &rectMain ) )
    {
        if ( GetWindowRect( &rectAlt ) )
        {
            //ATLTRACE( _T("CAltExtWizard::DisplayAlternateWizard() - Main = (%d,%d) (%d,%d) Alt = (%d,%d) (%d,%d)\n"),
            //  rectMain.left, rectMain.right, rectMain.top, rectMain.bottom,
            //  rectAlt.left, rectAlt.right, rectAlt.top, rectAlt.bottom );
            rectNew.left = rectMain.left;
            rectNew.top = rectMain.top;
            rectNew.right = rectNew.left + rectAlt.Width();
            rectNew.bottom = rectNew.top + rectAlt.Height();
            MoveWindow( &rectNew );
        } // if:  got the alternate wizard's window rectangle successfully
    } // if:  got the main wizard's window rectangle successfully

    //
    // Show the alternate wizard and hide the main wizard.
    //
    ShowWindow( SW_SHOW );
    PwizMain()->ShowWindow( SW_HIDE );
    SetActiveWindow();
    PwizMain()->SetCurrentWizard( this );

} //*** CAltExtWizard::DisplayAlternateWizard()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizard::DisplayMainWizard
//
//  Routine Description:
//      Display the main wizard.  This involved the following steps:
//      -- Move the main wizard to the position of the alternate wizard.
//      -- Show the main wizard.
//      -- Hide the alternate wizard.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//  Exceptions Thrown:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CAltExtWizard::DisplayMainWizard( void )
{
    //
    // Move the main wizard to where the alternate wizard is positioned.
    //
    CRect rectMain;
    CRect rectAlt;
    CRect rectNew;
    if ( PwizMain()->GetWindowRect( &rectMain ) )
    {
        if ( GetWindowRect( &rectAlt ) )
        {
            //ATLTRACE( _T("CAltExtWizard::DisplayMainWizard() - Main = (%d,%d) (%d,%d) Alt = (%d,%d) (%d,%d)\n"),
            //  rectMain.left, rectMain.right, rectMain.top, rectMain.bottom,
            //  rectAlt.left, rectAlt.right, rectAlt.top, rectAlt.bottom );
            rectNew.left = rectAlt.left;
            rectNew.top = rectAlt.top;
            rectNew.right = rectNew.left + rectMain.Width();
            rectNew.bottom = rectNew.top + rectMain.Height();
            PwizMain()->MoveWindow( &rectNew );
        } // if:  got the alternate wizard's window rectangle successfully
    } // if:  got the main wizard's window rectangle successfully

    //
    // Show the main wizard and hide the alternate wizard.
    //
    PwizMain()->ShowWindow( SW_SHOW );
    PwizMain()->SetActiveWindow();
    ShowWindow( SW_HIDE );
    PwizMain()->SetCurrentWizard( PwizMain() );

} //*** CAltExtWizard::DisplayMainWizard()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizard::DestroyAlternateWizard
//
//  Routine Description:
//      Destroy the alternate extension wizard.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CAltExtWizard::DestroyAlternateWizard( void )
{
    ATLASSERT( m_hWnd != NULL );

    //
    // Press the Cancel button on the alternate wizard.
    //
    PressButton( PSBTN_CANCEL );

    //
    // Destroy the wizard.
    //
    DestroyWindow();

} //*** CAltExtWizard::DestroyAlternateWizard()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizard::MessageLoop
//
//  Routine Description:
//      Message loop for this wizard as a modeless wizard.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CAltExtWizard::MessageLoop( void )
{
    MSG     msg;

    m_bExitMsgLoop = FALSE;
    while (    (GetActivePage() != NULL)
            && GetMessage( &msg, NULL, 0, 0 ) )
    {
        //
        // Ask the wizard if it wants to process it.  If not, go ahead
        // and translate it and dispatch it.
        //
        if ( ! IsDialogMessage( &msg ) )
        {
            TranslateMessage( &msg );
            DispatchMessage( &msg );
        } // if:  not a property sheet dialog message

        //
        // If the dialog is done, exit this loop.
        //
        if ( BExitMessageLoop() )
        {
            DisplayMainWizard();
            PwizMain()->PostMessage( PSM_PRESSBUTTON, NExitButton(), 0 );
            break;
        } // if:  exiting the wizard
    } // while:  active page and not quitting

} //*** CAltExtWizard::MessageLoop()


//*************************************************************************//


////////////////////////////////////////////////////////////////////////////
// class CAltExtWizardPrefixPage
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizardPrefixPage::OnSetActive
//
//  Routine Description:
//      Handler for PSN_SETACTIVE.
//      This page manages the transfer of control between the main wizard
//      and the first page of the alternate wizard.
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE        Page activated successfully.
//      FALSE       Error activating page.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAltExtWizardPrefixPage::OnSetActive( void )
{
    //
    // When moving forward, display the alternate wizard and return FALSE
    // so that this page won't be displayed.
    //
    // When moving backward, display the main wizard and return TRUE so that
    // we'll be waiting for the main wizard to do something with us.
    //

    if ( Pwiz()->BBackPressed() )
    {
        PwizThis()->ExitMessageLoop( PSBTN_BACK );
        return TRUE;
    } // if:  moving backward
    else
    {
        PwizThis()->DisplayAlternateWizard();
        return FALSE;
    } // if:  moving forward

} //*** CAltExtWizardPrefixPage::OnSetActive()


//*************************************************************************//


////////////////////////////////////////////////////////////////////////////
// class CAltExtWizardPostfixPage
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CAltExtWizardPostfixPage::OnSetActive
//
//  Routine Description:
//      Handler for PSN_SETACTIVE.
//      This page manages the transfer of control between the main wizard
//      and the last page of the alternate wizard.
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE        Page activated successfully.
//      FALSE       Error activating page.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CAltExtWizardPostfixPage::OnSetActive( void )
{
    //
    // When moving forward display the main wizard and return TRUE so that
    // we'll be waiting for the main wizard to tell us what to do next.
    //
    // This routine should never be called when moving backward.
    //

    ATLASSERT( Pwiz()->BNextPressed() );

    //
    // Display the main wizard.
    //
    PwizThis()->ExitMessageLoop( PSBTN_NEXT );
    return TRUE;

} //*** CAltExtWizardPostfixPage::OnSetActive()


//*************************************************************************//


/////////////////////////////////////////////////////////////////////////////
// Global Functions
/////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////////////////////////////////////
//++
//
//  PdtCreateDummyPageDialogTemplate
//
//  Routine Description:
//      Create a dialog template in memory for use on a dummy page.
//
//  Arguments:
//      cx              [IN] Width of the dialog in pixels.
//      cy              [IN] Height of the dialog in pixels.
//
//  Return Value:
//      ppDlgTemplate   Dialog template.
//
//--
/////////////////////////////////////////////////////////////////////////////
DLGTEMPLATE * PdtCreateDummyPageDialogTemplate( IN WORD cx, IN WORD cy )
{
    static const WCHAR s_szFontName[] = L"MS Shell Dlg";
    struct FULLDLGTEMPLATE : public DLGTEMPLATE
    {
        WORD        nMenuID;
        WORD        nClassID;
        WORD        nTitle;
        WORD        nFontSize;
        WCHAR       szFontName[sizeof(s_szFontName) / sizeof(WCHAR)];
    };

    FULLDLGTEMPLATE * pDlgTemplate = new FULLDLGTEMPLATE;
    ATLASSERT( pDlgTemplate != NULL );
    if ( pDlgTemplate != NULL )
    {
        pDlgTemplate->style = WS_CHILD | WS_DISABLED | WS_SYSMENU | DS_SETFONT;
        pDlgTemplate->dwExtendedStyle = 0;
        pDlgTemplate->cdit = 0;
        pDlgTemplate->x = 0;
        pDlgTemplate->y = 0;
        pDlgTemplate->cx = ((cx * 2) + (3 / 2)) / 3; // round off
        pDlgTemplate->cy = ((cy * 8) + (13 / 2)) / 13; // round off
        pDlgTemplate->nMenuID = 0;
        pDlgTemplate->nClassID = 0;
        pDlgTemplate->nTitle = 0;
        pDlgTemplate->nFontSize = 8;
        lstrcpyW( pDlgTemplate->szFontName, s_szFontName );
    } // if: dialog template allocated successfully

    return pDlgTemplate;

} //*** PdtCreateDummyPageDialogTemplate()