windows-server-2003/base/cluster/resdll/clnetres/clnetresex/basepage.cpp

/////////////////////////////////////////////////////////////////////////////
//
//  Copyright (c) 1999-2002 Microsoft Corporation
//
//  Module Name:
//      BasePage.cpp
//
//  Description:
//      Implementation of the CBasePropertyPage class.
//
//  Author:
//      David Potter (DavidP)   March 24, 1999
//
//  Revision History:
//
//  Notes:
//
/////////////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ClNetResEx.h"
#include "ExtObj.h"
#include "BasePage.h"
#include "BasePage.inl"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CBasePropertyPage property page
/////////////////////////////////////////////////////////////////////////////

IMPLEMENT_DYNCREATE( CBasePropertyPage, CPropertyPage )

/////////////////////////////////////////////////////////////////////////////
// Message Maps

BEGIN_MESSAGE_MAP( CBasePropertyPage, CPropertyPage )
    //{{AFX_MSG_MAP(CBasePropertyPage)
    ON_WM_CREATE()
    ON_WM_DESTROY()
    ON_WM_HELPINFO()
    ON_WM_CONTEXTMENU()
    ON_MESSAGE(WM_COMMANDHELP, OnCommandHelp)
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::CBasePropertyPage
//
//  Description:
//      Default constructor.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CBasePropertyPage::CBasePropertyPage( void )
{
    CommonConstruct();

} //*** CBasePropertyPage::CBasePropertyPage()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::CBasePropertyPage
//
//  Routine Description:
//      Default constructor.
//
//  Arguments:
//      pdwHelpMap          [IN] Control-to-help ID map.
//      pdwWizardHelpMap    [IN] Control-to-help ID map if this is a wizard page.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CBasePropertyPage::CBasePropertyPage(
    IN const DWORD *    pdwHelpMap,
    IN const DWORD *    pdwWizardHelpMap
    )
    : m_dlghelp( pdwHelpMap, 0 )
{
    CommonConstruct();
    m_pdwWizardHelpMap = pdwWizardHelpMap;

} //*** CBasePropertyPage::CBasePropertyPage()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::CBasePropertyPage
//
//  Routine Description:
//      Default constructor.
//
//  Arguments:
//      idd                 [IN] Dialog template resource ID.
//      pdwHelpMap          [IN] Control-to-help ID map.
//      pdwWizardHelpMap    [IN] Control-to-help ID map if this is a wizard page.
//      nIDCaption          [IN] Caption string resource ID.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
CBasePropertyPage::CBasePropertyPage(
    IN UINT             idd,
    IN const DWORD *    pdwHelpMap,
    IN const DWORD *    pdwWizardHelpMap,
    IN UINT             nIDCaption
    )
    : CPropertyPage( idd, nIDCaption )
    , m_dlghelp( pdwHelpMap, idd )
{
    CommonConstruct();
    m_pdwWizardHelpMap = pdwWizardHelpMap;

} //*** CBasePropertyPage::CBasePropertyPage( UINT, UINT )

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::CommonConstruct
//
//  Description:
//      Common construction.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBasePropertyPage::CommonConstruct( void )
{
    //{{AFX_DATA_INIT(CBasePropertyPage)
    //}}AFX_DATA_INIT

    m_peo = NULL;
    m_hpage = NULL;
    m_bBackPressed = FALSE;
    m_bSaved = FALSE;

    m_iddPropertyPage = NULL;
    m_iddWizardPage = NULL;
    m_idsCaption = NULL;

    m_pdwWizardHelpMap = NULL;

    m_bDoDetach = FALSE;

} //*** CBasePropertyPage::CommonConstruct()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::HrInit
//
//  Description:
//      Initialize the page.
//
//  Arguments:
//      peo         [IN OUT] Pointer to the extension object.
//
//  Return Value:
//      S_OK        Page initialized successfully.
//      hr          Page failed to initialize.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CBasePropertyPage::HrInit( IN OUT CExtObject * peo )
{
    ASSERT( peo != NULL );

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    HRESULT         _hr = S_FALSE;
    CWaitCursor     _wc;
    DWORD           _sc = ERROR_SUCCESS;
    CClusPropList   _cpl;

    m_peo = peo;

    // Change the help map if this is a wizard page.
    if ( Peo()->BWizard() )
    {
        m_dlghelp.SetMap( m_pdwWizardHelpMap );
    } // if: in a wizard

    // Don't display a help button.
    m_psp.dwFlags &= ~PSP_HASHELP;

    // Construct the property page.
    if ( Peo()->BWizard() )
    {
        ASSERT( IddWizardPage() != NULL);
        Construct( IddWizardPage(), IdsCaption() );
        m_dlghelp.SetHelpMask( IddWizardPage() );
    } // if: adding page to wizard
    else
    {
        ASSERT( IddPropertyPage() != NULL );
        Construct( IddPropertyPage(), IdsCaption() );
        m_dlghelp.SetHelpMask( IddPropertyPage() );
    } // else: adding page to property sheet

    // Read the properties private to this resource and parse them.
    {
        ASSERT( Peo() != NULL );
        ASSERT( Peo()->PodObjData() );

        // Read the properties.
        switch ( Cot() )
        {
            case CLUADMEX_OT_NODE:
                ASSERT( Peo()->PndNodeData()->m_hnode != NULL );
                _sc = _cpl.ScGetNodeProperties(
                                        Peo()->PndNodeData()->m_hnode,
                                        CLUSCTL_NODE_GET_PRIVATE_PROPERTIES
                                        );
                break;

            case CLUADMEX_OT_GROUP:
                ASSERT( Peo()->PgdGroupData()->m_hgroup != NULL );
                _sc = _cpl.ScGetGroupProperties(
                                        Peo()->PgdGroupData()->m_hgroup,
                                        CLUSCTL_GROUP_GET_PRIVATE_PROPERTIES
                                        );
                break;

            case CLUADMEX_OT_RESOURCE:
                ASSERT( Peo()->PrdResData()->m_hresource != NULL );
                _sc = _cpl.ScGetResourceProperties(
                                        Peo()->PrdResData()->m_hresource,
                                        CLUSCTL_RESOURCE_GET_PRIVATE_PROPERTIES
                                        );
                break;

            case CLUADMEX_OT_RESOURCETYPE:
                ASSERT( Peo()->PodObjData()->m_strName.GetLength() > 0 );
                _sc = _cpl.ScGetResourceTypeProperties(
                                        Hcluster(),
                                        Peo()->PodObjData()->m_strName,
                                        CLUSCTL_RESOURCE_TYPE_GET_PRIVATE_PROPERTIES
                                        );
                break;

            case CLUADMEX_OT_NETWORK:
                ASSERT( Peo()->PndNetworkData()->m_hnetwork != NULL );
                _sc = _cpl.ScGetNetworkProperties(
                                        Peo()->PndNetworkData()->m_hnetwork,
                                        CLUSCTL_NETWORK_GET_PRIVATE_PROPERTIES
                                        );
                break;

            case CLUADMEX_OT_NETINTERFACE:
                ASSERT( Peo()->PndNetInterfaceData()->m_hnetinterface != NULL );
                _sc = _cpl.ScGetNetInterfaceProperties(
                                        Peo()->PndNetInterfaceData()->m_hnetinterface,
                                        CLUSCTL_NETINTERFACE_GET_PRIVATE_PROPERTIES
                                        );
                break;

            default:
                ASSERT( 0 );
        } // switch: object type

        // Parse the properties.
        if ( _sc == ERROR_SUCCESS )
        {
            // Parse the properties.
            try
            {
                _sc = ScParseProperties( _cpl );
            } // try
            catch ( CMemoryException * _pme )
            {
                _hr = E_OUTOFMEMORY;
                _pme->Delete();
            } // catch: CMemoryException
        } // if: properties read successfully

        if ( _sc != ERROR_SUCCESS )
        {
            _hr = HRESULT_FROM_WIN32( _sc );
            goto Cleanup;
        } // if: error parsing getting or parsing properties
    } // Read the properties private to this resource and parse them

Cleanup:

    return _hr;

} //*** CBasePropertyPage::HrInit()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::HrCreatePage
//
//  Description:
//      Create the page.
//
//  Arguments:
//      None.
//
//  Return Value:
//      S_OK        Page created successfully.
//      hr          Error creating the page.
//
//--
/////////////////////////////////////////////////////////////////////////////
HRESULT CBasePropertyPage::HrCreatePage( void )
{
    ASSERT( m_hpage == NULL );

    HRESULT _hr = S_OK;

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

    return _hr;

} //*** CBasePropertyPage::HrCreatePage()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::ScParseProperties
//
//  Description:
//      Parse the properties of the resource.  This is in a separate function
//      from HrInit so that the optimizer can do a better job.
//
//  Arguments:
//      rcpl            [IN] Cluster property list to parse.
//
//  Return Values:
//      ERROR_SUCCESS   Properties were parsed successfully.
//      Any error returns from ScParseUnknownProperty().
//
//  Exceptions Thrown:
//      Any exceptions from CString::operator=().
//
//--
/////////////////////////////////////////////////////////////////////////////
DWORD CBasePropertyPage::ScParseProperties( IN CClusPropList & rcpl )
{
    DWORD                   _sc;
    DWORD                   _cprop;
    const CObjectProperty * _pprop;

    ASSERT( rcpl.PbPropList() != NULL );

    _sc = rcpl.ScMoveToFirstProperty();
    while ( _sc == ERROR_SUCCESS )
    {
        //
        // Parse known properties.
        //
        for ( _pprop = Pprops(), _cprop = Cprops() ; _cprop > 0 ; _pprop++, _cprop-- )
        {
            if ( lstrcmpiW( rcpl.PszCurrentPropertyName(), _pprop->m_pwszName ) == 0 )
            {
                if ( rcpl.CpfCurrentValueFormat() == _pprop->m_propFormat )
                {
                    switch ( _pprop->m_propFormat )
                    {
                        case CLUSPROP_FORMAT_SZ:
                        case CLUSPROP_FORMAT_EXPAND_SZ:
                            ASSERT(     (rcpl.CbCurrentValueLength() == (lstrlenW( rcpl.CbhCurrentValue().pStringValue->sz ) + 1) * sizeof( WCHAR ))
                                    ||  (   (rcpl.CbCurrentValueLength() == 0)
                                        &&  (rcpl.CbhCurrentValue().pStringValue->sz[ 0 ] == L'\0') ) );
                            *_pprop->m_value.pstr = rcpl.CbhCurrentValue().pStringValue->sz;
                            *_pprop->m_valuePrev.pstr = rcpl.CbhCurrentValue().pStringValue->sz;

                            // See if we need to find an expanded version
                            if ( _pprop->m_valueEx.pstr != NULL )
                            {
                                // Copy the non-expanded one just in case there isn't an expanded version
                                *_pprop->m_valueEx.pstr = rcpl.CbhCurrentValue().pStringValue->sz;

                                // See if they included an expanded version
                                rcpl.ScMoveToNextPropertyValue( );
                                if ( rcpl.CpfCurrentValueFormat( ) == CLUSPROP_FORMAT_EXPANDED_SZ )
                                {
                                    *_pprop->m_valueEx.pstr = rcpl.CbhCurrentValue().pStringValue->sz;        
                                } // if: found expanded version

                            } // if: *_pprop->m_valueEx.pstr is present
                            break;
                        case CLUSPROP_FORMAT_EXPANDED_SZ:
                            ASSERT(     (rcpl.CbCurrentValueLength() == (lstrlenW( rcpl.CbhCurrentValue().pStringValue->sz ) + 1) * sizeof( WCHAR ))
                                    ||  (   (rcpl.CbCurrentValueLength() == 0)
                                        &&  (rcpl.CbhCurrentValue().pStringValue->sz[ 0 ] == L'\0') ) );
                            *_pprop->m_value.pstr = rcpl.CbhCurrentValue().pStringValue->sz;
                            *_pprop->m_valuePrev.pstr = rcpl.CbhCurrentValue().pStringValue->sz;

                            // See if we need to find an expanded version
                            if ( _pprop->m_valueEx.pstr != NULL )
                            {
                                // Copy the expanded version
                                *_pprop->m_valueEx.pstr = rcpl.CbhCurrentValue().pStringValue->sz;

                                // See if they included a non-expanded version
                                rcpl.ScMoveToNextPropertyValue( );
                                if ( rcpl.CpfCurrentValueFormat( ) == CLUSPROP_FORMAT_SZ )
                                {
                                    *_pprop->m_value.pstr = rcpl.CbhCurrentValue().pStringValue->sz;
                                    *_pprop->m_valuePrev.pstr = rcpl.CbhCurrentValue().pStringValue->sz;
                                } // if: found non-expanded version

                            } // if: *_pprop->m_valueEx.pstr is present
                            break;
                        case CLUSPROP_FORMAT_DWORD:
                        case CLUSPROP_FORMAT_LONG:
                            ASSERT( rcpl.CbCurrentValueLength() == sizeof( DWORD ) );
                            *_pprop->m_value.pdw = rcpl.CbhCurrentValue().pDwordValue->dw;
                            *_pprop->m_valuePrev.pdw = rcpl.CbhCurrentValue().pDwordValue->dw;
                            break;
                        case CLUSPROP_FORMAT_BINARY:
                        case CLUSPROP_FORMAT_MULTI_SZ:
                            *_pprop->m_value.ppb = rcpl.CbhCurrentValue().pBinaryValue->rgb;
                            *_pprop->m_value.pcb = rcpl.CbhCurrentValue().pBinaryValue->cbLength;
                            *_pprop->m_valuePrev.ppb = rcpl.CbhCurrentValue().pBinaryValue->rgb;
                            *_pprop->m_valuePrev.pcb = rcpl.CbhCurrentValue().pBinaryValue->cbLength;
                            break;
                        default:
                            ASSERT(0);  // don't know how to deal with this type
                    } // switch: property format

                    // Exit the loop since we found the parameter.
                    break;
                }// if: found a type match

            } // if: found a string match

        } // for: each property that we know about

        //
        // If the property wasn't known, ask the derived class to parse it.
        //
        if ( _cprop == 0 )
        {
            _sc = ScParseUnknownProperty(
                        rcpl.CbhCurrentPropertyName().pName->sz,
                        rcpl.CbhCurrentValue(),
                        static_cast< DWORD >( rcpl.RPvlPropertyValue().CbDataLeft() )
                        );
            if ( _sc != ERROR_SUCCESS )
            {
                return _sc;
            } // if: error parsing the unknown property
        } // if: property not parsed

        //
        // Advance the buffer pointer past the value in the value list.
        //
        _sc = rcpl.ScMoveToNextProperty();
    } // while: more properties to parse

    //
    // If we reached the end of the properties, fix the return code.
    //
    if ( _sc == ERROR_NO_MORE_ITEMS )
    {
        _sc = ERROR_SUCCESS;
    } // if: ended loop after parsing all properties

    return _sc;

} //*** CBasePropertyPage::ScParseProperties()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnCreate
//
//  Description:
//      Handler for the WM_CREATE message.
//
//  Arguments:
//      lpCreateStruct  [IN OUT] Window create structure.
//
//  Return Value:
//      -1      Error.
//      0       Success.
//
//--
/////////////////////////////////////////////////////////////////////////////
int CBasePropertyPage::OnCreate( LPCREATESTRUCT lpCreateStruct )
{
    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    // Attach the window to the property page structure.
    // This has been done once already in the main application, since the
    // main application owns the property sheet.  It needs to be done here
    // so that the window handle can be found in the DLL's handle map.
    if ( FromHandlePermanent( m_hWnd ) == NULL ) // is the window handle already in the handle map
    {
        HWND _hWnd = m_hWnd;
        m_hWnd = NULL;
        Attach( _hWnd );
        m_bDoDetach = TRUE;
    } // if: is the window handle in the handle map

    return CPropertyPage::OnCreate( lpCreateStruct );

} //*** CBasePropertyPage::OnCreate()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnDestroy
//
//  Description:
//      Handler for the WM_DESTROY message.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBasePropertyPage::OnDestroy( void )
{
    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    // Detach the window from the property page structure.
    // This will be done again by the main application, since it owns the
    // property sheet.  It needs to be done here so that the window handle
    // can be removed from the DLL's handle map.
    if ( m_bDoDetach )
    {
        if ( m_hWnd != NULL )
        {
            HWND _hWnd = m_hWnd;

            Detach();
            m_hWnd = _hWnd;
        } // if: do we have a window handle?
    } // if: do we need to balance the attach we did with a detach?

    CPropertyPage::OnDestroy();

} //*** CBasePropertyPage::OnDestroy()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::DoDataExchange
//
//  Description:
//      Do data exchange between the dialog and the class.
//
//  Arguments:
//      pDX     [IN OUT] Data exchange object
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBasePropertyPage::DoDataExchange( CDataExchange * pDX )
{
    if ( ! pDX->m_bSaveAndValidate || ! BSaved() )
    {
        AFX_MANAGE_STATE( AfxGetStaticModuleState() );

        //{{AFX_DATA_MAP(CBasePropertyPage)
            // NOTE: the ClassWizard will add DDX and DDV calls here
        //}}AFX_DATA_MAP
        DDX_Control( pDX, IDC_PP_ICON, m_staticIcon );
        DDX_Control( pDX, IDC_PP_TITLE, m_staticTitle );

        if ( pDX->m_bSaveAndValidate )
        {
            if ( ! BBackPressed() )
            {
                CWaitCursor _wc;

                // Validate the data.
                if ( ! BSetPrivateProps( TRUE /*bValidateOnly*/ ) )
                {
                    pDX->Fail();
                } // if: error setting private properties
            } // if: Back button not pressed
        } // if: saving data from dialog
        else
        {
            // Set the title.
            DDX_Text( pDX, IDC_PP_TITLE, m_strTitle );
        } // if: not saving data
    }  // if: not saving or haven't saved yet

    // Call the base class method.
    CPropertyPage::DoDataExchange( pDX );

} //*** CBasePropertyPage::DoDataExchange()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnInitDialog
//
//  Description:
//      Handler for the WM_INITDIALOG message.
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE        We need the focus to be set for us.
//      FALSE       We already set the focus to the proper control.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBasePropertyPage::OnInitDialog( void )
{
    ASSERT( Peo() != NULL );
    ASSERT( Peo()->PodObjData() != NULL );

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    // Set the title string.
    m_strTitle = Peo()->PodObjData()->m_strName;

    // Call the base class method.
    CPropertyPage::OnInitDialog();

    // Display an icon for the object.
    if ( Peo()->Hicon() != NULL )
    {
        m_staticIcon.SetIcon( Peo()->Hicon() );
    } // if: an icon was specified

    return TRUE;    // return TRUE unless you set the focus to a control
                    // EXCEPTION: OCX Property Pages should return FALSE

} //*** CBasePropertyPage::OnInitDialog()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnSetActive
//
//  Description:
//      Handler for the PSN_SETACTIVE message.
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE    Page successfully initialized.
//      FALSE   Page not initialized.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBasePropertyPage::OnSetActive( void )
{
    HRESULT     _hr;

    ASSERT( Peo() != NULL);
    ASSERT( Peo()->PodObjData() != NULL );

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    // Reread the data.
    _hr = Peo()->HrGetObjectInfo();
    if ( _hr != NOERROR )
    {
        return FALSE;
    } // if: error getting object info

    // Set the title string.
    m_strTitle = Peo()->PodObjData()->m_strName;

    m_bBackPressed = FALSE;
    m_bSaved = FALSE;
    return CPropertyPage::OnSetActive();

} //*** CBasePropertyPage::OnSetActive()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnApply
//
//  Description:
//      Handler for the PSM_APPLY message.
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE    Page successfully applied.
//      FALSE   Error applying page.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBasePropertyPage::OnApply( void )
{
    ASSERT( ! BWizard() );

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    CWaitCursor _wc;

    if ( ! BApplyChanges() )
    {
        return FALSE;
    } // if: error applying changes

    return CPropertyPage::OnApply();

} //*** CBasePropertyPage::OnApply()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnWizardBack
//
//  Description:
//      Handler for the PSN_WIZBACK message.
//
//  Arguments:
//      None.
//
//  Return Value:
//      -1      Don't change the page.
//      0       Change the page.
//
//--
/////////////////////////////////////////////////////////////////////////////
LRESULT CBasePropertyPage::OnWizardBack( void )
{
    LRESULT     _lResult;

    ASSERT( BWizard() );

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    _lResult = CPropertyPage::OnWizardBack();
    if ( _lResult != -1 )
    {
        m_bBackPressed = TRUE;
    } // if: no error occurred

    return _lResult;

} //*** CBasePropertyPage::OnWizardBack()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnWizardNext
//
//  Description:
//      Handler for the PSN_WIZNEXT message.
//
//  Arguments:
//      None.
//
//  Return Value:
//      -1      Don't change the page.
//      0       Change the page.
//
//--
/////////////////////////////////////////////////////////////////////////////
LRESULT CBasePropertyPage::OnWizardNext( void )
{
    ASSERT( BWizard() );

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    CWaitCursor _wc;

    // Update the data in the class from the page.
    // This necessary because, while OnKillActive() will call UpdateData(),
    // it is called after this method is called, and we need to be sure that
    // data has been saved before we apply them.
    if ( ! UpdateData( TRUE /*bSaveAndValidate*/ ) )
    {
        return -1;
    } // if: error updating data

    // Save the data in the sheet.
    if ( ! BApplyChanges() )
    {
        return -1;
    } // if: error applying changes

    // Create the object.

    return CPropertyPage::OnWizardNext();

} //*** CBasePropertyPage::OnWizardNext()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnWizardFinish
//
//  Description:
//      Handler for the PSN_WIZFINISH message.
//
//  Arguments:
//      None.
//
//  Return Value:
//      FALSE   Don't change the page.
//      TRUE    Change the page.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBasePropertyPage::OnWizardFinish( void )
{
    ASSERT( BWizard() );

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    CWaitCursor _wc;

    // BUG! There should be no need to call UpdateData in this function.
    // See BUG: Finish Button Fails Data Transfer from Page to Variables
    // KB Article ID: Q150349

    // Update the data in the class from the page.
    if ( ! UpdateData( TRUE /*bSaveAndValidate*/ ) )
    {
        return FALSE;
    } // if: error updating data

    // Save the data in the sheet.
    if ( ! BApplyChanges() )
    {
        return FALSE;
    } // if: error applying changes

    return CPropertyPage::OnWizardFinish();

} //*** CBasePropertyPage::OnWizardFinish()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnChangeCtrl
//
//  Description:
//      Handler for the messages sent when a control is changed.  This
//      method can be specified in a message map if all that needs to be
//      done is enable the Apply button.
//
//  Arguments:
//      None.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBasePropertyPage::OnChangeCtrl( void )
{
    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    SetModified( TRUE );

} //*** CBasePropertyPage::OnChangeCtrl()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::EnableNext
//
//  Description:
//      Enables or disables the NEXT or FINISH button.
//
//  Arguments:
//      bEnable     [IN] TRUE = enable the button, FALSE = disable the button.
//
//  Return Value:
//      None.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBasePropertyPage::EnableNext( IN BOOL bEnable /*TRUE*/ )
{
    ASSERT( BWizard() );
    ASSERT( PiWizardCallback() );

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    PiWizardCallback()->EnableNext( reinterpret_cast< LONG * >( Hpage() ), bEnable );

} //*** CBasePropertyPage::EnableNext()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::BApplyChanges
//
//  Description:
//      Apply changes made on the page.
//
//  Arguments:
//      None.
//
//  Return Value:
//      TRUE    Page successfully applied.
//      FALSE   Error applying page.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBasePropertyPage::BApplyChanges( void )
{
    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    CWaitCursor _wc;

    // Save data.
    return BSetPrivateProps();

} //*** CBasePropertyPage::BApplyChanges()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::BBuildPropList
//
//  Description:
//      Build the property list.
//
//  Arguments:
//      rcpl        [IN OUT] Cluster property list.
//      bNoNewProps [IN] TRUE = exclude properties marked with opfNew.
//
//  Return Value:
//      TRUE        Property list built successfully.
//      FALSE       Error building property list.
//
//  Exceptions Thrown:
//      Any exceptions thrown by CClusPropList::AddProp().
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBasePropertyPage::BBuildPropList(
    IN OUT CClusPropList &  rcpl,
    IN BOOL                 bNoNewProps     // = FALSE
    )
{
    BOOL                    _bNewPropsFound = FALSE;
    DWORD                   _cprop;
    const CObjectProperty * _pprop;

    for ( _pprop = Pprops(), _cprop = Cprops() ; _cprop > 0 ; _pprop++, _cprop-- )
    {
        if ( bNoNewProps && (_pprop->m_fFlags & CObjectProperty::opfNew) )
        {
            _bNewPropsFound = TRUE;
            continue;
        } // if: no new props allowed and this is a new property

        switch ( _pprop->m_propFormat )
        {
            case CLUSPROP_FORMAT_SZ:
                rcpl.ScAddProp(
                        _pprop->m_pwszName,
                        *_pprop->m_value.pstr,
                        *_pprop->m_valuePrev.pstr
                        );
                break;
            case CLUSPROP_FORMAT_EXPAND_SZ:
                rcpl.ScAddExpandSzProp(
                        _pprop->m_pwszName,
                        *_pprop->m_value.pstr,
                        *_pprop->m_valuePrev.pstr
                        );
                break;
            case CLUSPROP_FORMAT_DWORD:
                rcpl.ScAddProp(
                        _pprop->m_pwszName,
                        *_pprop->m_value.pdw,
                        *_pprop->m_valuePrev.pdw
                        );
                break;
            case CLUSPROP_FORMAT_LONG:
                rcpl.ScAddProp(
                        _pprop->m_pwszName,
                        *_pprop->m_value.pl,
                        *_pprop->m_valuePrev.pl
                        );
                break;
            case CLUSPROP_FORMAT_BINARY:
            case CLUSPROP_FORMAT_MULTI_SZ:
                rcpl.ScAddProp(
                        _pprop->m_pwszName,
                        *_pprop->m_value.ppb,
                        *_pprop->m_value.pcb,
                        *_pprop->m_valuePrev.ppb,
                        *_pprop->m_valuePrev.pcb
                        );
                break;
            default:
                ASSERT( 0 ); // don't know how to deal with this type
                return FALSE;
        } // switch: property format
    } // for: each property

    return ( ! bNoNewProps || _bNewPropsFound );

} //*** CBasePropertyPage::BBuildPropList()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::BSetPrivateProps
//
//  Description:
//      Set the private properties for this object.
//
//  Arguments:
//      bValidateOnly   [IN] TRUE = only validate the data.
//      bNoNewProps     [IN] TRUE = exclude properties marked with opfNew.
//
//  Return Value:
//      ERROR_SUCCESS   The operation was completed successfully.
//      !0              Failure.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBasePropertyPage::BSetPrivateProps(
    IN BOOL bValidateOnly,  // = FALSE
    IN BOOL bNoNewProps     // = FALSE
    )
{
    BOOL            _fSuccess   = TRUE;
    CClusPropList   _cpl( BWizard() /*bAlwaysAddProp*/ );

    ASSERT( Peo() != NULL );
    ASSERT( Peo()->PrdResData() );
    ASSERT( Peo()->PrdResData()->m_hresource );

    // Build the property list.
    try
    {
        _fSuccess = BBuildPropList( _cpl, bNoNewProps );
    } // try
    catch ( CException * pe )
    {
        pe->ReportError();
        pe->Delete();
        _fSuccess = FALSE;
    } // catch: CException

    // Set the data.
    if ( _fSuccess )
    {
        if ( (_cpl.PbPropList() != NULL) && (_cpl.CbPropList() > 0) )
        {
            DWORD       _sc = ERROR_SUCCESS;
            DWORD       _dwControlCode;
            DWORD       _cbProps;

            switch ( Cot() )
            {
                case CLUADMEX_OT_NODE:
                    ASSERT( Peo()->PndNodeData() != NULL );
                    ASSERT( Peo()->PndNodeData()->m_hnode != NULL );

                    // Determine which control code to use.
                    if ( bValidateOnly )
                    {
                        _dwControlCode = CLUSCTL_NODE_VALIDATE_PRIVATE_PROPERTIES;
                    } // if: only validating data
                    else
                    {
                        _dwControlCode = CLUSCTL_NODE_SET_PRIVATE_PROPERTIES;
                    } // else: setting data

                    // Set private properties.
                    _sc = ClusterNodeControl(
                                    Peo()->PndNodeData()->m_hnode,
                                    NULL,   // hNode
                                    _dwControlCode,
                                    _cpl.PbPropList(),
                                    static_cast< DWORD >( _cpl.CbPropList() ),
                                    NULL,   // lpOutBuffer
                                    0,      // nOutBufferSize
                                    &_cbProps
                                    );
                    break;
                case CLUADMEX_OT_GROUP:
                    ASSERT( Peo()->PgdGroupData() != NULL );
                    ASSERT( Peo()->PgdGroupData()->m_hgroup != NULL );

                    // Determine which control code to use.
                    if ( bValidateOnly )
                    {
                        _dwControlCode = CLUSCTL_GROUP_VALIDATE_PRIVATE_PROPERTIES;
                    } // if: only validating data
                    else
                    {
                        _dwControlCode = CLUSCTL_GROUP_SET_PRIVATE_PROPERTIES;
                    } // else: setting data

                    // Set private properties.
                    _sc = ClusterGroupControl(
                                    Peo()->PgdGroupData()->m_hgroup,
                                    NULL,   // hNode
                                    _dwControlCode,
                                    _cpl.PbPropList(),
                                    static_cast< DWORD >( _cpl.CbPropList() ),
                                    NULL,   // lpOutBuffer
                                    0,      // nOutBufferSize
                                    &_cbProps
                                    );
                    break;
                case CLUADMEX_OT_RESOURCE:
                    ASSERT( Peo()->PrdResData() != NULL );
                    ASSERT( Peo()->PrdResData()->m_hresource != NULL );

                    // Determine which control code to use.
                    if ( bValidateOnly )
                    {
                        _dwControlCode = CLUSCTL_RESOURCE_VALIDATE_PRIVATE_PROPERTIES;
                    } // if: only validating data
                    else
                    {
                        _dwControlCode = CLUSCTL_RESOURCE_SET_PRIVATE_PROPERTIES;
                    } // else: setting data

                    // Set private properties.
                    _sc = ClusterResourceControl(
                                    Peo()->PrdResData()->m_hresource,
                                    NULL,   // hNode
                                    _dwControlCode,
                                    _cpl.PbPropList(),
                                    static_cast< DWORD >( _cpl.CbPropList() ),
                                    NULL,   // lpOutBuffer
                                    0,      // nOutBufferSize
                                    &_cbProps
                                    );
                    break;
                case CLUADMEX_OT_RESOURCETYPE:
                    ASSERT( Peo()->PodObjData() != NULL );
                    ASSERT( Peo()->PodObjData()->m_strName.GetLength() > 0 );

                    // Determine which control code to use.
                    if ( bValidateOnly )
                    {
                        _dwControlCode = CLUSCTL_RESOURCE_TYPE_VALIDATE_PRIVATE_PROPERTIES;
                    } // if: only validating data
                    else
                    {
                        _dwControlCode = CLUSCTL_RESOURCE_TYPE_SET_PRIVATE_PROPERTIES;
                    } // else: setting data

                    // Set private properties.
                    _sc = ClusterResourceTypeControl(
                                    Hcluster(),
                                    Peo()->PodObjData()->m_strName,
                                    NULL,   // hNode
                                    _dwControlCode,
                                    _cpl.PbPropList(),
                                    static_cast< DWORD >( _cpl.CbPropList() ),
                                    NULL,   // lpOutBuffer
                                    0,      // nOutBufferSize
                                    &_cbProps
                                    );
                    break;
                case CLUADMEX_OT_NETWORK:
                    ASSERT( Peo()->PndNetworkData() != NULL );
                    ASSERT( Peo()->PndNetworkData()->m_hnetwork != NULL );

                    // Determine which control code to use.
                    if ( bValidateOnly )
                    {
                        _dwControlCode = CLUSCTL_NETWORK_VALIDATE_PRIVATE_PROPERTIES;
                    } // if: only validating data
                    else
                    {
                        _dwControlCode = CLUSCTL_NETWORK_SET_PRIVATE_PROPERTIES;
                    } // else: setting data

                    // Set private properties.
                    _sc = ClusterNetworkControl(
                                    Peo()->PndNetworkData()->m_hnetwork,
                                    NULL,   // hNode
                                    _dwControlCode,
                                    _cpl.PbPropList(),
                                    static_cast< DWORD >( _cpl.CbPropList() ),
                                    NULL,   // lpOutBuffer
                                    0,      // nOutBufferSize
                                    &_cbProps
                                    );
                    break;
                case CLUADMEX_OT_NETINTERFACE:
                    ASSERT( Peo()->PndNetInterfaceData() != NULL );
                    ASSERT( Peo()->PndNetInterfaceData()->m_hnetinterface != NULL );

                    // Determine which control code to use.
                    if ( bValidateOnly )
                    {
                        _dwControlCode = CLUSCTL_NETINTERFACE_VALIDATE_PRIVATE_PROPERTIES;
                    } // if: only validating data
                    else
                    {
                        _dwControlCode = CLUSCTL_NETINTERFACE_SET_PRIVATE_PROPERTIES;
                    } // else: setting data

                    // Set private properties.
                    _sc = ClusterNetInterfaceControl(
                                    Peo()->PndNetInterfaceData()->m_hnetinterface,
                                    NULL,   // hNode
                                    _dwControlCode,
                                    _cpl.PbPropList(),
                                    static_cast< DWORD >( _cpl.CbPropList() ),
                                    NULL,   // lpOutBuffer
                                    0,      // nOutBufferSize
                                    &_cbProps
                                    );
                    break;
                default:
                    ASSERT( 0 );
            } // switch: object type

            // Handle errors.
            if ( _sc != ERROR_SUCCESS )
            {
                if ( _sc == ERROR_INVALID_PARAMETER )
                {
                    if ( ! bNoNewProps )
                    {
                        _fSuccess = BSetPrivateProps( bValidateOnly, TRUE /*bNoNewProps*/ );
                    } // if: new props are allowed
                    else
                        _fSuccess = FALSE;
                } // if: invalid parameter error occurred
                else if (   bValidateOnly
                        ||  (_sc != ERROR_RESOURCE_PROPERTIES_STORED) )
                {
                    _fSuccess = FALSE;
                } // else if: only validating and error other than properties only stored

                //
                // If an error occurred, display an error message.
                //
                if ( ! _fSuccess )
                {
                    DisplaySetPropsError( _sc, bValidateOnly ? IDS_ERROR_VALIDATING_PROPERTIES : IDS_ERROR_SETTING_PROPERTIES );
                    if ( _sc == ERROR_RESOURCE_PROPERTIES_STORED )
                    {
                        _fSuccess = TRUE;
                    } // if: properties only stored
                } // if: error occurred
            } // if: error setting/validating data
        } // if: there is data to set
    } // if: no errors building the property list

    // Save data locally.
    if ( ! bValidateOnly && _fSuccess )
    {
        // Save new values as previous values.
        try
        {
            DWORD                   _cprop;
            const CObjectProperty * _pprop;

            for ( _pprop = Pprops(), _cprop = Cprops() ; _cprop > 0 ; _pprop++, _cprop-- )
            {
                switch ( _pprop->m_propFormat )
                {
                    case CLUSPROP_FORMAT_SZ:
                    case CLUSPROP_FORMAT_EXPAND_SZ:
                        ASSERT(_pprop->m_value.pstr != NULL);
                        ASSERT(_pprop->m_valuePrev.pstr != NULL);
                        *_pprop->m_valuePrev.pstr = *_pprop->m_value.pstr;
                        break;
                    case CLUSPROP_FORMAT_DWORD:
                    case CLUSPROP_FORMAT_LONG:
                        ASSERT( _pprop->m_value.pdw != NULL );
                        ASSERT( _pprop->m_valuePrev.pdw != NULL );
                        *_pprop->m_valuePrev.pdw = *_pprop->m_value.pdw;
                        break;
                    case CLUSPROP_FORMAT_BINARY:
                    case CLUSPROP_FORMAT_MULTI_SZ:
                        ASSERT( _pprop->m_value.ppb != NULL );
                        ASSERT( *_pprop->m_value.ppb != NULL );
                        ASSERT( _pprop->m_value.pcb != NULL );
                        ASSERT( _pprop->m_valuePrev.ppb != NULL );
                        ASSERT( *_pprop->m_valuePrev.ppb != NULL );
                        ASSERT( _pprop->m_valuePrev.pcb != NULL );
                        delete [] *_pprop->m_valuePrev.ppb;
                        *_pprop->m_valuePrev.ppb = new BYTE[ *_pprop->m_value.pcb ];
                        CopyMemory( *_pprop->m_valuePrev.ppb, *_pprop->m_value.ppb, *_pprop->m_value.pcb );
                        *_pprop->m_valuePrev.pcb = *_pprop->m_value.pcb;
                        break;
                    default:
                        ASSERT( 0 ); // don't know how to deal with this type
                } // switch: property format
            } // for: each property
        } // try
        catch ( CException * _pe )
        {
            _pe->ReportError();
            _pe->Delete();
            _fSuccess = FALSE;
        } // catch: CException
    } // if: not just validating and successful so far

    //
    // Indicate we successfully saved the properties.
    //
    if ( ! bValidateOnly && _fSuccess )
    {
        m_bSaved = TRUE;
    } // if: successfully saved data

    return _fSuccess;

} //*** CBasePropertyPage::BSetPrivateProps()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::DisplaySetPropsError
//
//  Routine Description:
//      Display an error caused by setting or validating properties.
//
//  Arguments:
//      sc      [IN] Status to display error on.
//      idsOper [IN] Operation message.
//
//  Return Value:
//      nStatus ERROR_SUCCESS = success, !0 = failure
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBasePropertyPage::DisplaySetPropsError(
    IN DWORD    sc,
    IN UINT     idsOper
    ) const
{
    CString _strErrorMsg;
    CString _strOperMsg;
    CString _strMsgIdFmt;
    CString _strMsgId;
    CString _strMsg;

    UNREFERENCED_PARAMETER( idsOper );

    _strOperMsg.LoadString( IDS_ERROR_SETTING_PROPERTIES );
    FormatError( _strErrorMsg, sc );
    _strMsgIdFmt.LoadString( IDS_ERROR_MSG_ID );
    _strMsgId.Format( _strMsgIdFmt, sc, sc );
    _strMsg.Format( _T("%s\n\n%s%s"), _strOperMsg, _strErrorMsg, _strMsgId );
    AfxMessageBox( _strMsg );

}  //*** CBasePropertyPage::DisplaySetPropsError()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnContextMenu
//
//  Routine Description:
//      Handler for the WM_CONTEXTMENU message.
//
//  Arguments:
//      pWnd    Window in which user clicked the right mouse button.
//      point   Position of the cursor, in screen coordinates.
//
//  Return Value:
//      TRUE    Help processed.
//      FALSE   Help not processed.
//
//--
/////////////////////////////////////////////////////////////////////////////
void CBasePropertyPage::OnContextMenu( CWnd * pWnd, CPoint point )
{
    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    m_dlghelp.OnContextMenu( pWnd, point );

}  //*** CBasePropertyPage::OnContextMenu()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnHelpInfo
//
//  Routine Description:
//      Handler for the WM_HELPINFO message.
//
//  Arguments:
//      pHelpInfo   Structure containing info about displaying help.
//
//  Return Value:
//      TRUE        Help processed.
//      FALSE       Help not processed.
//
//--
/////////////////////////////////////////////////////////////////////////////
BOOL CBasePropertyPage::OnHelpInfo( HELPINFO * pHelpInfo )
{
    BOOL    _bProcessed;

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    _bProcessed = m_dlghelp.OnHelpInfo( pHelpInfo );
    if ( ! _bProcessed )
    {
        _bProcessed = CPropertyPage::OnHelpInfo( pHelpInfo );
    } // if: message not processed yet
    return _bProcessed;

}  //*** CBasePropertyPage::OnHelpInfo()

/////////////////////////////////////////////////////////////////////////////
//++
//
//  CBasePropertyPage::OnCommandHelp
//
//  Routine Description:
//      Handler for the WM_COMMANDHELP message.
//
//  Arguments:
//      wParam      [IN] WPARAM.
//      lParam      [IN] LPARAM.
//
//  Return Value:
//      TRUE    Help processed.
//      FALSE   Help not processed.
//
//--
/////////////////////////////////////////////////////////////////////////////
LRESULT CBasePropertyPage::OnCommandHelp( WPARAM wParam, LPARAM lParam )
{
    LRESULT _bProcessed;

    AFX_MANAGE_STATE( AfxGetStaticModuleState() );

    _bProcessed = m_dlghelp.OnCommandHelp( wParam, lParam );
    if ( ! _bProcessed )
    {
        _bProcessed = CPropertyPage::OnCommandHelp( wParam, lParam );
    } // if: message not processed yet

    return _bProcessed;

}  //*** CBasePropertyPage::OnCommandHelp()