mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2256 lines
62 KiB
2256 lines
62 KiB
/////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Copyright (c ) 1996-2000 Microsoft Corporation
|
|
//
|
|
// Module Name:
|
|
// ClusItem.cpp
|
|
//
|
|
// Description:
|
|
// Implementation of the CClusterItem class.
|
|
//
|
|
// Maintained By:
|
|
// David Potter (davidp ) May 6, 1996
|
|
//
|
|
// Revision History:
|
|
//
|
|
// Modified to fix bugs associated with open/close state of m_hkey.
|
|
// m_hkey will be closed upon destruction of CClusterItem.
|
|
// Roderick Sharper March 23, 1997.
|
|
//
|
|
// Notes:
|
|
//
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#include "stdafx.h"
|
|
#include "CluAdmin.h"
|
|
#include "ConstDef.h"
|
|
#include "ClusItem.h"
|
|
#include "ClusDoc.h"
|
|
#include "ExcOper.h"
|
|
#include "TraceTag.h"
|
|
#include "TreeItem.inl"
|
|
#include "PropList.h"
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Global Variables
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
#ifdef _DEBUG
|
|
CTraceTag g_tagClusItemCreate( _T("Create"), _T("CLUSTER ITEM CREATE"), 0 );
|
|
CTraceTag g_tagClusItemDelete( _T("Delete"), _T("CLUSTER ITEM DELETE"), 0 );
|
|
CTraceTag g_tagClusItemNotify( _T("Notify"), _T("CLUSTER ITEM NOTIFY"), 0 );
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusterItemList
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItemList::PciFromName
|
|
//
|
|
// Routine Description:
|
|
// Find a cluster item in the list by its name.
|
|
//
|
|
// Arguments:
|
|
// pszName [IN] Name of item to look for.
|
|
// ppos [OUT] Position of the item in the list.
|
|
//
|
|
// Return Value:
|
|
// pci Cluster item corresponding the the specified name.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CClusterItem * CClusterItemList::PciFromName(
|
|
IN LPCTSTR pszName,
|
|
OUT POSITION * ppos // = NULL
|
|
)
|
|
{
|
|
POSITION posPci;
|
|
POSITION posCurPci;
|
|
CClusterItem * pci = NULL;
|
|
|
|
ASSERT( pszName != NULL );
|
|
|
|
posPci = GetHeadPosition( );
|
|
while ( posPci != NULL )
|
|
{
|
|
posCurPci = posPci;
|
|
pci = GetNext( posPci );
|
|
ASSERT_VALID( pci );
|
|
|
|
if ( pci->StrName( ).CompareNoCase( pszName ) == 0 )
|
|
{
|
|
if ( ppos != NULL )
|
|
{
|
|
*ppos = posCurPci;
|
|
} // if
|
|
break;
|
|
} // if: found a match
|
|
|
|
pci = NULL;
|
|
} // while: more resources in the list
|
|
|
|
return pci;
|
|
|
|
} //*** CClusterItemList::PciFromName( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItemList::RemoveAll
|
|
//
|
|
// Routine Description:
|
|
// Remove all items from the list, decrementing the reference count
|
|
// on each one first.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Note:
|
|
// This routine is not virtual, so calls to the base class will
|
|
// not go through this routine. Also, it does not call the base
|
|
// class method.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#ifdef NEVER
|
|
void CClusterItemList::RemoveAll( void )
|
|
{
|
|
ASSERT_VALID( this );
|
|
|
|
// destroy elements
|
|
CNode * pNode;
|
|
for ( pNode = m_pNodeHead ; pNode != NULL ; pNode = pNode->pNext )
|
|
{
|
|
// ((CClusterItem *) pNode->data)->Release( );
|
|
DestructElements( (CClusterItem**) &pNode->data, 1 );
|
|
} // for: each node in the list
|
|
|
|
// Call the base class method.
|
|
CObList::RemoveAll( );
|
|
|
|
} //*** CClusterItemList::RemoveAll( )
|
|
#endif
|
|
|
|
|
|
//***************************************************************************
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CClusterItem
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
IMPLEMENT_DYNCREATE( CClusterItem, CBaseCmdTarget )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Message Maps
|
|
|
|
BEGIN_MESSAGE_MAP( CClusterItem, CBaseCmdTarget )
|
|
//{{AFX_MSG_MAP(CClusterItem)
|
|
ON_UPDATE_COMMAND_UI(ID_FILE_RENAME, OnUpdateRename)
|
|
ON_UPDATE_COMMAND_UI(ID_FILE_PROPERTIES, OnUpdateProperties)
|
|
ON_COMMAND(ID_FILE_PROPERTIES, OnCmdProperties)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::CClusterItem
|
|
//
|
|
// Routine Description:
|
|
// Default constructor.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CClusterItem::CClusterItem( void )
|
|
{
|
|
CommonConstruct( );
|
|
|
|
} //*** CClusterItem::CClusterItem( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::CClusterItem
|
|
//
|
|
// Routine Description:
|
|
// Constructor.
|
|
//
|
|
// Arguments:
|
|
// pstrName [IN] Name of the item.
|
|
// idsType [IN] Type ID of the item.
|
|
// pstrDescription [IN] Description of the item.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CClusterItem::CClusterItem(
|
|
IN const CString * pstrName,
|
|
IN IDS idsType,
|
|
IN const CString * pstrDescription
|
|
)
|
|
{
|
|
CommonConstruct( );
|
|
|
|
if ( pstrName != NULL )
|
|
{
|
|
m_strName = *pstrName;
|
|
} // if
|
|
|
|
if ( idsType == 0 )
|
|
{
|
|
idsType = IDS_ITEMTYPE_CONTAINER;
|
|
} // if
|
|
m_idsType = idsType;
|
|
m_strType.LoadString( IdsType( ) );
|
|
|
|
if ( pstrDescription != NULL )
|
|
{
|
|
m_strDescription = *pstrDescription;
|
|
} // if
|
|
|
|
Trace( g_tagClusItemCreate, _T("CClusterItem( ) - Creating '%s' (%s )"), m_strName, m_strType );
|
|
|
|
} //*** CClusterItem::CClusterItem( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::CommonConstruct
|
|
//
|
|
// Routine Description:
|
|
// Common construction.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::CommonConstruct( void )
|
|
{
|
|
m_hkey = NULL;
|
|
m_idsType = IDS_ITEMTYPE_CONTAINER;
|
|
m_strType.LoadString( IDS_ITEMTYPE_CONTAINER );
|
|
m_iimgObjectType = 0;
|
|
m_iimgState = GetClusterAdminApp( )->Iimg( IMGLI_FOLDER );
|
|
m_pdoc = NULL;
|
|
m_idmPopupMenu = 0;
|
|
m_bDocObj = TRUE;
|
|
m_bChanged = FALSE;
|
|
m_bReadOnly = FALSE;
|
|
m_pcnk = NULL;
|
|
|
|
} //*** CClusterItem::CommonConstruct( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::~CClusterItem
|
|
//
|
|
// Routine Description:
|
|
// Destructor.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CClusterItem::~CClusterItem( void )
|
|
{
|
|
Trace( g_tagClusItemDelete, _T("~CClusterItem( ) - Deleting cluster item '%s'"), StrName( ) );
|
|
|
|
// Empty the lists.
|
|
DeleteAllItemData( LptiBackPointers( ) );
|
|
DeleteAllItemData( LpliBackPointers( ) );
|
|
LptiBackPointers( ).RemoveAll( );
|
|
LpliBackPointers( ).RemoveAll( );
|
|
|
|
// Close the registry key.
|
|
if ( Hkey( ) != NULL )
|
|
{
|
|
ClusterRegCloseKey( Hkey( ) );
|
|
m_hkey = NULL;
|
|
} // if
|
|
|
|
// Remove the notification key and delete it.
|
|
if ( BDocObj( ) )
|
|
{
|
|
POSITION pos;
|
|
|
|
pos = GetClusterAdminApp( )->Cnkl( ).Find( m_pcnk );
|
|
if ( pos != NULL )
|
|
{
|
|
GetClusterAdminApp( )->Cnkl( ).RemoveAt( pos );
|
|
} // if
|
|
Trace( g_tagClusItemNotify, _T("~CClusterItem( ) - Deleting notification key (%08.8x ) for '%s'"), m_pcnk, StrName( ) );
|
|
delete m_pcnk;
|
|
m_pcnk = NULL;
|
|
} // if: object resides in the document
|
|
|
|
Trace( g_tagClusItemDelete, _T("~CClusterItem( ) - Done deleting cluster item '%s'"), StrName( ) );
|
|
|
|
} //*** CClusterItem::~CClusterItem( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::Delete
|
|
//
|
|
// Routine Description:
|
|
// Delete the item. If the item still has references, add it to the
|
|
// document's pending delete list.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::Delete( void )
|
|
{
|
|
// Add a reference so that we don't delete ourselves while
|
|
// still doing cleanup.
|
|
AddRef( );
|
|
|
|
// Cleanup this object.
|
|
Cleanup( );
|
|
|
|
// Remove the item from all lists and views.
|
|
CClusterItem::RemoveItem( );
|
|
|
|
// If there are still references to this object, add it to the delete
|
|
// pending list. Check for greater than 1 because we added a reference
|
|
// at the beginning of this method.
|
|
if ( ( Pdoc( ) != NULL ) && ( NReferenceCount( ) > 1 ) )
|
|
{
|
|
if ( Pdoc( )->LpciToBeDeleted( ).Find( this ) == NULL )
|
|
{
|
|
Pdoc( )->LpciToBeDeleted( ).AddTail( this );
|
|
} // if
|
|
} // if: object still has references to it
|
|
|
|
// Release the reference we added at the beginning. This will
|
|
// cause the object to be deleted if we were the last reference.
|
|
Release( );
|
|
|
|
} //*** CClusterItem::Delete( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::Init
|
|
//
|
|
// Routine Description:
|
|
// Initialize the item.
|
|
//
|
|
// Arguments:
|
|
// pdoc [IN OUT] Document to which this item belongs.
|
|
// lpszName [IN] Name of the item.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by CNotifyKey::new( ) or
|
|
// CNotifyKeyList::AddTail( ).
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::Init( IN OUT CClusterDoc * pdoc, IN LPCTSTR lpszName )
|
|
{
|
|
ASSERT_VALID( pdoc );
|
|
ASSERT( lpszName != NULL );
|
|
|
|
// Save parameters.
|
|
m_pdoc = pdoc;
|
|
m_strName = lpszName;
|
|
|
|
Trace( g_tagClusItemCreate, _T("Init( ) - Initializing '%s' (%s )"), m_strName, m_strType );
|
|
|
|
// Find the notification key for this item in the document's list.
|
|
// If one is not found, allocate one.
|
|
if ( BDocObj( ) )
|
|
{
|
|
POSITION pos;
|
|
CClusterNotifyKey * pcnk = NULL;
|
|
|
|
pos = GetClusterAdminApp( )->Cnkl( ).GetHeadPosition( );
|
|
while ( pos != NULL )
|
|
{
|
|
pcnk = GetClusterAdminApp( )->Cnkl( ).GetNext( pos );
|
|
if ( ( pcnk->m_cnkt == cnktClusterItem )
|
|
&& ( pcnk->m_pci == this )
|
|
)
|
|
break;
|
|
pcnk = NULL;
|
|
} // while: more items in the list
|
|
|
|
// If a key was not found, allocate a new one.
|
|
if ( pcnk == NULL )
|
|
{
|
|
pcnk = new CClusterNotifyKey( this, lpszName );
|
|
if ( pcnk == NULL )
|
|
{
|
|
ThrowStaticException( GetLastError( ) );
|
|
} // if: error allocating the notify key
|
|
try
|
|
{
|
|
GetClusterAdminApp( )->Cnkl( ).AddTail( pcnk );
|
|
Trace( g_tagClusItemNotify, _T("Init( ) - Creating notification key (%08.8x ) for '%s'"), pcnk, StrName( ) );
|
|
} // try
|
|
catch ( ... )
|
|
{
|
|
delete pcnk;
|
|
throw;
|
|
} // catch: anything
|
|
} // if: key wasn't found
|
|
|
|
m_pcnk = pcnk;
|
|
} // if: object resides in the document
|
|
|
|
} //*** CClusterItem::Init( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::PlstrExtensions
|
|
//
|
|
// Routine Description:
|
|
// Return the list of admin extensions.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// plstr List of extensions.
|
|
// NULL No extension associated with this object.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
const CStringList * CClusterItem::PlstrExtensions( void ) const
|
|
{
|
|
return NULL;
|
|
|
|
} //*** CClusterItem::PlstrExtensions( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::RemoveItem
|
|
//
|
|
// Routine Description:
|
|
// Remove the item from all lists and views.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::RemoveItem( void )
|
|
{
|
|
// Remove the item from each tree item.
|
|
{
|
|
POSITION posPti;
|
|
CTreeItem * pti;
|
|
|
|
posPti = LptiBackPointers( ).GetHeadPosition( );
|
|
while ( posPti != NULL )
|
|
{
|
|
pti = LptiBackPointers( ).GetNext( posPti );
|
|
ASSERT_VALID( pti );
|
|
ASSERT_VALID( pti->PtiParent( ) );
|
|
Trace( g_tagClusItemDelete, _T("RemoveItem( ) - Deleting tree item backptr from '%s' in '%s' - %d left"), StrName( ), pti->PtiParent( )->StrName( ), LptiBackPointers( ).GetCount( ) - 1 );
|
|
pti->RemoveItem( );
|
|
} // while: more items in the list
|
|
} // Remove the item from each tree item
|
|
|
|
// Remove the item from each list item.
|
|
{
|
|
POSITION posPli;
|
|
CListItem * pli;
|
|
|
|
posPli = LpliBackPointers( ).GetHeadPosition( );
|
|
while ( posPli != NULL )
|
|
{
|
|
pli = LpliBackPointers( ).GetNext( posPli );
|
|
ASSERT_VALID( pli );
|
|
ASSERT_VALID( pli->PtiParent( ) );
|
|
Trace( g_tagClusItemDelete, _T("RemoveItem( ) - Deleting list item backptr from '%s' in '%s' - %d left"), StrName( ), pli->PtiParent( )->StrName( ), LpliBackPointers( ).GetCount( ) - 1 );
|
|
pli->PtiParent( )->RemoveChild( pli->Pci( ) );
|
|
} // while: more items in the list
|
|
} // Remove the item from each tree item
|
|
|
|
} //*** CClusterItem::RemoveItem( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::WriteItem
|
|
//
|
|
// Routine Description:
|
|
// Write the item parameters to the cluster database.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by WriteItem( ).
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::WriteItem( void )
|
|
{
|
|
} //*** CClusterItem::WriteItem( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::DwParseProperties
|
|
//
|
|
// Routine Description:
|
|
// Parse the properties of the resource. This is in a separate function
|
|
// from BInit so that the optimizer can do a better job.
|
|
//
|
|
// Arguments:
|
|
// rcpl [IN] Cluster property list to parse.
|
|
//
|
|
// Return Value:
|
|
// ERROR_SUCCESS Properties were parsed successfully.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions from CString::operator=( ).
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD CClusterItem::DwParseProperties( IN const CClusPropList & rcpl )
|
|
{
|
|
DWORD cProps;
|
|
DWORD cprop;
|
|
DWORD cbProps;
|
|
const CObjectProperty * pprop;
|
|
CLUSPROP_BUFFER_HELPER props;
|
|
CLUSPROP_PROPERTY_NAME const * pName;
|
|
|
|
ASSERT( rcpl.PbPropList( ) != NULL );
|
|
|
|
props.pb = rcpl.PbPropList( );
|
|
cbProps = rcpl.CbPropList( );
|
|
|
|
// Loop through each property.
|
|
for ( cProps = *(props.pdw++ ) ; cProps > 0 ; cProps-- )
|
|
{
|
|
pName = props.pName;
|
|
ASSERT( pName->Syntax.dw == CLUSPROP_SYNTAX_NAME );
|
|
props.pb += sizeof( *pName ) + ALIGN_CLUSPROP( pName->cbLength );
|
|
|
|
// Decrement the counter by the size of the name.
|
|
ASSERT( cbProps > sizeof( *pName ) + ALIGN_CLUSPROP( pName->cbLength ) );
|
|
cbProps -= sizeof( *pName ) + ALIGN_CLUSPROP( pName->cbLength );
|
|
|
|
ASSERT( cbProps > sizeof( *props.pValue ) + ALIGN_CLUSPROP( props.pValue->cbLength ) );
|
|
|
|
// Parse known properties.
|
|
for ( pprop = Pprops( ), cprop = Cprops( ) ; cprop > 0 ; pprop++, cprop-- )
|
|
{
|
|
if ( lstrcmpiW( pName->sz, pprop->m_pwszName ) == 0 )
|
|
{
|
|
ASSERT( props.pSyntax->wFormat == pprop->m_propFormat );
|
|
switch ( pprop->m_propFormat )
|
|
{
|
|
case CLUSPROP_FORMAT_SZ:
|
|
ASSERT( ( props.pValue->cbLength == ( lstrlenW( props.pStringValue->sz ) + 1 ) * sizeof( WCHAR ) )
|
|
|| ( (props.pValue->cbLength == 0 ) && ( props.pStringValue->sz[ 0 ] == L'\0' ) ) );
|
|
*pprop->m_valuePrev.pstr = props.pStringValue->sz;
|
|
break;
|
|
case CLUSPROP_FORMAT_DWORD:
|
|
case CLUSPROP_FORMAT_LONG:
|
|
ASSERT( props.pValue->cbLength == sizeof( DWORD ) );
|
|
*pprop->m_valuePrev.pdw = props.pDwordValue->dw;
|
|
break;
|
|
case CLUSPROP_FORMAT_BINARY:
|
|
case CLUSPROP_FORMAT_MULTI_SZ:
|
|
*pprop->m_valuePrev.ppb = props.pBinaryValue->rgb;
|
|
*pprop->m_valuePrev.pcb = props.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 match
|
|
} // for: each property
|
|
|
|
// If the property wasn't known, ask the derived class to parse it.
|
|
if ( cprop == 0 )
|
|
{
|
|
DWORD dwStatus;
|
|
|
|
dwStatus = DwParseUnknownProperty( pName->sz, props, cbProps );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
return dwStatus;
|
|
} // if
|
|
} // if: property not parsed
|
|
|
|
// Advance the buffer pointer past the value in the value list.
|
|
while ( ( props.pSyntax->dw != CLUSPROP_SYNTAX_ENDMARK )
|
|
&& ( cbProps > 0 ) )
|
|
{
|
|
ASSERT( cbProps > sizeof( *props.pValue ) + ALIGN_CLUSPROP( props.pValue->cbLength ) );
|
|
cbProps -= sizeof( *props.pValue ) + ALIGN_CLUSPROP( props.pValue->cbLength );
|
|
props.pb += sizeof( *props.pValue ) + ALIGN_CLUSPROP( props.pValue->cbLength );
|
|
} // while: more values in the list
|
|
|
|
// Advance the buffer pointer past the value list endmark.
|
|
ASSERT( cbProps >= sizeof( *props.pSyntax ) );
|
|
cbProps -= sizeof( *props.pSyntax );
|
|
props.pb += sizeof( *props.pSyntax ); // endmark
|
|
} // for: each property
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
} //*** CClusterItem::DwParseProperties( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::SetCommonProperties
|
|
//
|
|
// Routine Description:
|
|
// Set the common properties for this object in the cluster database.
|
|
//
|
|
// Arguments:
|
|
// bValidateOnly [IN] Only validate the data.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by WriteItem( ).
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::SetCommonProperties( IN BOOL bValidateOnly )
|
|
{
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
|
CClusPropList cpl;
|
|
CWaitCursor wc;
|
|
|
|
// Save data.
|
|
{
|
|
// Build the property list and set the data.
|
|
try
|
|
{
|
|
BuildPropList( cpl );
|
|
dwStatus = DwSetCommonProperties( cpl, bValidateOnly );
|
|
} // try
|
|
catch ( CMemoryException * pme )
|
|
{
|
|
pme->Delete( );
|
|
dwStatus = ERROR_NOT_ENOUGH_MEMORY;
|
|
} // catch: CMemoryException
|
|
|
|
// Handle errors.
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
if ( dwStatus != ERROR_RESOURCE_PROPERTIES_STORED )
|
|
{
|
|
ThrowStaticException( dwStatus, IDS_APPLY_PARAM_CHANGES_ERROR );
|
|
} // if
|
|
} // if: error setting properties
|
|
|
|
if ( ! bValidateOnly && ( dwStatus == ERROR_SUCCESS ) )
|
|
{
|
|
DWORD cprop;
|
|
const CObjectProperty * pprop;
|
|
|
|
// Save new values as previous values.
|
|
|
|
for ( pprop = Pprops( ), cprop = Cprops( ) ; cprop > 0 ; pprop++, cprop-- )
|
|
{
|
|
switch ( pprop->m_propFormat )
|
|
{
|
|
case CLUSPROP_FORMAT_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:
|
|
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 ];
|
|
if ( *pprop->m_valuePrev.ppb == NULL )
|
|
{
|
|
ThrowStaticException( GetLastError( ) );
|
|
} // if: error allocating data buffer
|
|
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
|
|
} // if: not just validating and properties set successfully
|
|
|
|
if ( dwStatus == ERROR_RESOURCE_PROPERTIES_STORED )
|
|
{
|
|
ThrowStaticException( dwStatus );
|
|
} // if
|
|
} // Save data
|
|
|
|
} //*** CClusterItem::SetCommonProperties( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::BuildPropList
|
|
//
|
|
// Routine Description:
|
|
// Build the property list.
|
|
//
|
|
// Arguments:
|
|
// rcpl [IN OUT] Cluster property list.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// Any exceptions thrown by CClusPropList::ScAddProp( ).
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::BuildPropList(
|
|
IN OUT CClusPropList & rcpl
|
|
)
|
|
{
|
|
DWORD cprop;
|
|
const CObjectProperty * pprop;
|
|
|
|
for ( pprop = Pprops( ), cprop = Cprops( ) ; cprop > 0 ; pprop++, cprop-- )
|
|
{
|
|
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_DWORD:
|
|
rcpl.ScAddProp(
|
|
pprop->m_pwszName,
|
|
*pprop->m_value.pdw,
|
|
*pprop->m_valuePrev.pdw
|
|
);
|
|
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;
|
|
} // switch: property format
|
|
} // for: each property
|
|
|
|
} //*** CClusterItem::BuildPropList( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::UpdateState
|
|
//
|
|
// Routine Description:
|
|
// Update the current state of the item.
|
|
// Default implementation.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::UpdateState( void )
|
|
{
|
|
// Update the state of all the tree items pointing to us.
|
|
{
|
|
POSITION pos;
|
|
CTreeItem * pti;
|
|
|
|
pos = LptiBackPointers( ).GetHeadPosition( );
|
|
while ( pos != NULL )
|
|
{
|
|
pti = LptiBackPointers( ).GetNext( pos );
|
|
ASSERT_VALID( pti );
|
|
pti->UpdateUIState( );
|
|
} // while: more items in the list
|
|
} // Update the state of all the tree items pointing to us
|
|
|
|
// Update the state of all the list items pointing to us.
|
|
{
|
|
POSITION pos;
|
|
CListItem * pli;
|
|
|
|
pos = LpliBackPointers( ).GetHeadPosition( );
|
|
while ( pos != NULL )
|
|
{
|
|
pli = LpliBackPointers( ).GetNext( pos );
|
|
ASSERT_VALID( pli );
|
|
pli->UpdateUIState( );
|
|
} // while: more items in the list
|
|
} // Update the state of all the tree items pointing to us
|
|
|
|
} //*** CClusterItem::UpdateState( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::DwReadValue
|
|
//
|
|
// Routine Description:
|
|
// Read a REG_SZ value for this item.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to read.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// rstrValue [OUT] String in which to return the value.
|
|
//
|
|
// Return Value:
|
|
// dwStatus ERROR_SUCCESS = success, !0 = failure
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD CClusterItem::DwReadValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName,
|
|
OUT CString & rstrValue
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
LPWSTR pwszValue = NULL;
|
|
DWORD dwValueLen;
|
|
DWORD dwValueType;
|
|
HKEY hkey = NULL;
|
|
CWaitCursor wc;
|
|
|
|
ASSERT( pszValueName != NULL );
|
|
ASSERT( Hkey( ) != NULL );
|
|
|
|
rstrValue.Empty( );
|
|
|
|
try
|
|
{
|
|
// Open a new key if needed.
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
dwStatus = ClusterRegOpenKey( Hkey( ), pszKeyName, KEY_READ, &hkey );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
return dwStatus;
|
|
} // if
|
|
} // if: need to open a subkey
|
|
else
|
|
{
|
|
hkey = Hkey( );
|
|
} // else
|
|
|
|
// Get the size of the value.
|
|
dwValueLen = 0;
|
|
dwStatus = ClusterRegQueryValue(
|
|
hkey,
|
|
pszValueName,
|
|
&dwValueType,
|
|
NULL,
|
|
&dwValueLen
|
|
);
|
|
if ( ( dwStatus == ERROR_SUCCESS ) || ( dwStatus == ERROR_MORE_DATA ) )
|
|
{
|
|
ASSERT( dwValueType == REG_SZ );
|
|
|
|
// Allocate enough space for the data.
|
|
pwszValue = rstrValue.GetBuffer( dwValueLen / sizeof( WCHAR ) );
|
|
ASSERT( pwszValue != NULL );
|
|
dwValueLen += 1 * sizeof( WCHAR ); // Don't forget the final null-terminator.
|
|
|
|
// Read the value.
|
|
dwStatus = ClusterRegQueryValue(
|
|
hkey,
|
|
pszValueName,
|
|
&dwValueType,
|
|
(LPBYTE ) pwszValue,
|
|
&dwValueLen
|
|
);
|
|
if ( dwStatus == ERROR_SUCCESS )
|
|
{
|
|
ASSERT( dwValueType == REG_SZ );
|
|
} // if: value read successfully
|
|
rstrValue.ReleaseBuffer( );
|
|
} // if: got the size successfully
|
|
} // try
|
|
catch ( CMemoryException * pme )
|
|
{
|
|
pme->Delete( );
|
|
dwStatus = ERROR_NOT_ENOUGH_MEMORY;
|
|
} // catch: CMemoryException
|
|
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
|
|
return dwStatus;
|
|
|
|
} //*** CClusterItem::DwReadValue( LPCTSTR, CString& )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::DwReadValue
|
|
//
|
|
// Routine Description:
|
|
// Read a REG_MULTI_SZ value for this item.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to read.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// rlstrValue [OUT] String list in which to return the values.
|
|
//
|
|
// Return Value:
|
|
// dwStatus ERROR_SUCCESS = success, !0 = failure
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD CClusterItem::DwReadValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName,
|
|
OUT CStringList & rlstrValue
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
LPWSTR pwszValue = NULL;
|
|
LPWSTR pwszCurValue;
|
|
DWORD dwValueLen;
|
|
DWORD dwValueType;
|
|
HKEY hkey = NULL;
|
|
CWaitCursor wc;
|
|
|
|
ASSERT( pszValueName != NULL );
|
|
ASSERT( Hkey( ) != NULL );
|
|
|
|
rlstrValue.RemoveAll( );
|
|
|
|
try
|
|
{
|
|
// Open a new key if needed.
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
dwStatus = ClusterRegOpenKey( Hkey( ), pszKeyName, KEY_READ, &hkey );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
return dwStatus;
|
|
} // if
|
|
} // if: need to open a subkey
|
|
else
|
|
hkey = Hkey( );
|
|
|
|
// Get the size of the value.
|
|
dwValueLen = 0;
|
|
dwStatus = ClusterRegQueryValue(
|
|
hkey,
|
|
pszValueName,
|
|
&dwValueType,
|
|
NULL,
|
|
&dwValueLen
|
|
);
|
|
if ( ( dwStatus == ERROR_SUCCESS ) || ( dwStatus == ERROR_MORE_DATA ) )
|
|
{
|
|
ASSERT( dwValueType == REG_MULTI_SZ );
|
|
|
|
// Allocate enough space for the data.
|
|
dwValueLen += 1 * sizeof( WCHAR ); // Don't forget the final null-terminator.
|
|
pwszValue = new WCHAR[ dwValueLen / sizeof( WCHAR ) ];
|
|
if ( pwszValue == NULL )
|
|
{
|
|
AfxThrowMemoryException();
|
|
} // if: error allocating the value
|
|
|
|
// Read the value.
|
|
dwStatus = ClusterRegQueryValue(
|
|
hkey,
|
|
pszValueName,
|
|
&dwValueType,
|
|
(LPBYTE) pwszValue,
|
|
&dwValueLen
|
|
);
|
|
if ( dwStatus == ERROR_SUCCESS )
|
|
{
|
|
ASSERT( dwValueType == REG_MULTI_SZ );
|
|
|
|
// Add each string from the value into the string list.
|
|
for ( pwszCurValue = pwszValue
|
|
; *pwszCurValue != L'\0'
|
|
; pwszCurValue += lstrlenW( pwszCurValue ) + 1
|
|
)
|
|
{
|
|
rlstrValue.AddTail( pwszCurValue );
|
|
} // for
|
|
} // if: read the value successfully
|
|
} // if: got the size successfully
|
|
} // try
|
|
catch ( CMemoryException * pme )
|
|
{
|
|
pme->Delete( );
|
|
dwStatus = ERROR_NOT_ENOUGH_MEMORY;
|
|
} // catch: CMemoryException
|
|
|
|
delete [] pwszValue;
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
|
|
return dwStatus;
|
|
|
|
} //*** CClusterItem::DwReadValue( LPCTSTR, CStringList& )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::DwReadValue
|
|
//
|
|
// Routine Description:
|
|
// Read a REG_DWORD value for this item.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to read.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// pdwValue [OUT] DWORD in which to return the value.
|
|
//
|
|
// Return Value:
|
|
// dwStatus ERROR_SUCCESS = success, !0 = failure
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD CClusterItem::DwReadValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName,
|
|
OUT DWORD * pdwValue
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
DWORD dwValue;
|
|
DWORD dwValueLen;
|
|
DWORD dwValueType;
|
|
HKEY hkey;
|
|
CWaitCursor wc;
|
|
|
|
ASSERT( pszValueName != NULL );
|
|
ASSERT( pdwValue != NULL );
|
|
ASSERT( Hkey( ) != NULL );
|
|
|
|
// Open a new key if needed.
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
dwStatus = ClusterRegOpenKey( Hkey( ), pszKeyName, KEY_READ, &hkey );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
return dwStatus;
|
|
} // if
|
|
} // if: need to open a subkey
|
|
else
|
|
{
|
|
hkey = Hkey( );
|
|
} // else
|
|
|
|
// Read the value.
|
|
dwValueLen = sizeof( dwValue );
|
|
dwStatus = ClusterRegQueryValue(
|
|
hkey,
|
|
pszValueName,
|
|
&dwValueType,
|
|
(LPBYTE) &dwValue,
|
|
&dwValueLen
|
|
);
|
|
if ( dwStatus == ERROR_SUCCESS )
|
|
{
|
|
ASSERT( dwValueType == REG_DWORD );
|
|
ASSERT( dwValueLen == sizeof( dwValue ) );
|
|
*pdwValue = dwValue;
|
|
} // if: value read successfully
|
|
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
|
|
return dwStatus;
|
|
|
|
} //*** CClusterItem::DwReadValue( LPCTSTR, DWORD* )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::DwReadValue
|
|
//
|
|
// Routine Description:
|
|
// Read a REG_DWORD value for this item.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to read.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// pdwValue [OUT] DWORD in which to return the value.
|
|
// dwDefault [IN] Default value if parameter not set.
|
|
//
|
|
// Return Value:
|
|
// dwStatus ERROR_SUCCESS = success, !0 = failure
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD CClusterItem::DwReadValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName,
|
|
OUT DWORD * pdwValue,
|
|
IN DWORD dwDefault
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
CWaitCursor wc;
|
|
|
|
// Read the value.
|
|
dwStatus = DwReadValue( pszValueName, pszKeyName, pdwValue );
|
|
if ( dwStatus == ERROR_FILE_NOT_FOUND )
|
|
{
|
|
*pdwValue = dwDefault;
|
|
dwStatus = ERROR_SUCCESS;
|
|
} // if: value not set
|
|
|
|
return dwStatus;
|
|
|
|
} //*** CClusterItem::DwReadValue( LPCTSTR, DWORD*, DWORD )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::DwReadValue
|
|
//
|
|
// Routine Description:
|
|
// Read a REG_BINARY value for this item.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to read.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// ppbValue [OUT] Pointer in which to return the data. Caller
|
|
// is responsible for deallocating the data.
|
|
//
|
|
// Return Value:
|
|
// dwStatus ERROR_SUCCESS = success, !0 = failure
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
DWORD CClusterItem::DwReadValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName,
|
|
OUT LPBYTE * ppbValue
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
DWORD dwValueLen;
|
|
DWORD dwValueType;
|
|
LPBYTE pbValue = NULL;
|
|
HKEY hkey;
|
|
CWaitCursor wc;
|
|
|
|
ASSERT( pszValueName != NULL );
|
|
ASSERT( ppbValue != NULL );
|
|
ASSERT( Hkey( ) != NULL );
|
|
|
|
delete [] *ppbValue;
|
|
*ppbValue = NULL;
|
|
|
|
// Open a new key if needed.
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
dwStatus = ClusterRegOpenKey( Hkey( ), pszKeyName, KEY_READ, &hkey );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
return dwStatus;
|
|
} // if
|
|
} // if: need to open a subkey
|
|
else
|
|
{
|
|
hkey = Hkey( );
|
|
} // else
|
|
|
|
// Get the length of the value.
|
|
dwValueLen = 0;
|
|
dwStatus = ClusterRegQueryValue(
|
|
hkey,
|
|
pszValueName,
|
|
&dwValueType,
|
|
NULL,
|
|
&dwValueLen
|
|
);
|
|
if ( ( dwStatus != ERROR_SUCCESS )
|
|
&& ( dwStatus != ERROR_MORE_DATA ) )
|
|
{
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
return dwStatus;
|
|
} // if: error getting the length
|
|
|
|
ASSERT( dwValueType == REG_BINARY );
|
|
|
|
// Allocate a buffer,
|
|
try
|
|
{
|
|
pbValue = new BYTE[ dwValueLen ];
|
|
if ( pbValue == NULL )
|
|
{
|
|
AfxThrowMemoryException();
|
|
} // if: error allocating the buffer
|
|
} // try
|
|
catch ( CMemoryException * )
|
|
{
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
dwStatus = ERROR_NOT_ENOUGH_MEMORY;
|
|
return dwStatus;
|
|
} // catch: CMemoryException
|
|
|
|
// Read the value.
|
|
dwStatus = ClusterRegQueryValue(
|
|
hkey,
|
|
pszValueName,
|
|
&dwValueType,
|
|
pbValue,
|
|
&dwValueLen
|
|
);
|
|
if ( dwStatus == ERROR_SUCCESS )
|
|
{
|
|
*ppbValue = pbValue;
|
|
} // if
|
|
else
|
|
{
|
|
delete [] pbValue;
|
|
} // else
|
|
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
|
|
return dwStatus;
|
|
|
|
} //*** CClusterItem::DwReadValue( LPCTSTR, LPBYTE* )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::WriteValue
|
|
//
|
|
// Routine Description:
|
|
// Write a REG_SZ value for this item.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to write.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// rstrValue [IN] Value data.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException( dwStatus )
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::WriteValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName,
|
|
IN const CString & rstrValue
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
HKEY hkey;
|
|
CWaitCursor wc;
|
|
|
|
ASSERT( pszValueName != NULL );
|
|
ASSERT( Hkey( ) != NULL );
|
|
|
|
// Open a new key if needed.
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
dwStatus = ClusterRegOpenKey( Hkey( ), pszKeyName, KEY_ALL_ACCESS, &hkey );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
ThrowStaticException( dwStatus );
|
|
} // if
|
|
} // if: need to open a subkey
|
|
else
|
|
{
|
|
hkey = Hkey( );
|
|
} // else
|
|
|
|
// Write the value.
|
|
dwStatus = ClusterRegSetValue(
|
|
hkey,
|
|
pszValueName,
|
|
REG_SZ,
|
|
(CONST BYTE *) (LPCTSTR) rstrValue,
|
|
( rstrValue.GetLength( ) + 1 ) * sizeof( WCHAR )
|
|
);
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
ThrowStaticException( dwStatus );
|
|
} // if
|
|
|
|
} //*** CClusterItem::WriteValue( LPCTSTR, CString& )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::WriteValue
|
|
//
|
|
// Routine Description:
|
|
// Write a REG_MULTI_SZ value for this item.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to write.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// rlstrValue [IN] Value data.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException( dwStatus )
|
|
// Any exceptions thrown by new.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::WriteValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName,
|
|
IN const CStringList & rlstrValue
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
LPWSTR pwszValue = NULL;
|
|
LPWSTR pwszCurValue;
|
|
POSITION posStr;
|
|
DWORD cbValueLen;
|
|
HKEY hkey;
|
|
CWaitCursor wc;
|
|
|
|
ASSERT( pszValueName != NULL );
|
|
ASSERT( Hkey( ) != NULL );
|
|
|
|
// Get the size of the value.
|
|
posStr = rlstrValue.GetHeadPosition( );
|
|
cbValueLen = 0;
|
|
while ( posStr != NULL )
|
|
{
|
|
cbValueLen += ( rlstrValue.GetNext( posStr ).GetLength( ) + 1 ) * sizeof( TCHAR );
|
|
} // while: more items in the list
|
|
cbValueLen += 1 * sizeof( WCHAR ); // Extra NULL at the end.
|
|
|
|
// Allocate the value buffer.
|
|
pwszValue = new WCHAR[cbValueLen / sizeof( WCHAR )];
|
|
if ( pwszValue == NULL )
|
|
{
|
|
ThrowStaticException( GetLastError( ) );
|
|
} // if
|
|
|
|
// Copy the strings to the values.
|
|
posStr = rlstrValue.GetHeadPosition( );
|
|
for ( pwszCurValue = pwszValue ; posStr != NULL ; pwszCurValue += lstrlenW( pwszCurValue ) + 1 )
|
|
{
|
|
lstrcpyW( pwszCurValue, rlstrValue.GetNext( posStr ) );
|
|
} // for: each item in the list
|
|
pwszCurValue[0] = L'\0';
|
|
|
|
// Open a new key if needed.
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
dwStatus = ClusterRegOpenKey( Hkey( ), pszKeyName, KEY_ALL_ACCESS, &hkey );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
delete [] pwszValue;
|
|
ThrowStaticException( dwStatus );
|
|
} // if: error opening the key
|
|
} // if: need to open a subkey
|
|
else
|
|
{
|
|
hkey = Hkey( );
|
|
} // else
|
|
|
|
// Write the value.
|
|
dwStatus = ClusterRegSetValue(
|
|
hkey,
|
|
pszValueName,
|
|
REG_MULTI_SZ,
|
|
(CONST BYTE *) pwszValue,
|
|
cbValueLen - ( 1 * sizeof( WCHAR ) )
|
|
);
|
|
delete [] pwszValue;
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
ThrowStaticException( dwStatus );
|
|
} // if
|
|
|
|
} //*** CClusterItem::WriteValue( LPCTSTR, CStringList& )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::WriteValue
|
|
//
|
|
// Routine Description:
|
|
// Write a REG_DWORD value for this item.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to write.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// dwValue [IN] Value data.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException( dwStatus )
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::WriteValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName,
|
|
IN DWORD dwValue
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
HKEY hkey;
|
|
CWaitCursor wc;
|
|
|
|
ASSERT( pszValueName != NULL );
|
|
ASSERT( Hkey( ) != NULL );
|
|
|
|
// Open a new key if needed.
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
dwStatus = ClusterRegOpenKey( Hkey( ), pszKeyName, KEY_ALL_ACCESS, &hkey );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
ThrowStaticException( dwStatus );
|
|
} // if
|
|
} // if: need to open a subkey
|
|
else
|
|
hkey = Hkey( );
|
|
|
|
// Write the value.
|
|
dwStatus = ClusterRegSetValue(
|
|
hkey,
|
|
pszValueName,
|
|
REG_DWORD,
|
|
(CONST BYTE *) &dwValue,
|
|
sizeof( dwValue )
|
|
);
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
ThrowStaticException( dwStatus );
|
|
} // if
|
|
|
|
} //*** CClusterItem::WriteValue( LPCTSTR, DWORD )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::WriteValue
|
|
//
|
|
// Routine Description:
|
|
// Write a REG_BINARY value for this item if it hasn't changed.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to write.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// pbValue [IN] Value data.
|
|
// cbValue [IN] Size of value data.
|
|
// ppbPrevValue [IN OUT] Previous value.
|
|
// cbPrevValue [IN] Size of the previous data.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException( dwStatus )
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::WriteValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName,
|
|
IN const LPBYTE pbValue,
|
|
IN DWORD cbValue,
|
|
IN OUT LPBYTE * ppbPrevValue,
|
|
IN DWORD cbPrevValue
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
LPBYTE pbPrevValue = NULL;
|
|
HKEY hkey;
|
|
CWaitCursor wc;
|
|
|
|
ASSERT( pszValueName != NULL );
|
|
ASSERT( pbValue != NULL );
|
|
ASSERT( ppbPrevValue != NULL );
|
|
ASSERT( cbValue > 0 );
|
|
ASSERT( Hkey( ) != NULL );
|
|
|
|
// See if the data has changed.
|
|
if ( cbValue == cbPrevValue )
|
|
{
|
|
DWORD ib;
|
|
|
|
for ( ib = 0 ; ib < cbValue ; ib++ )
|
|
{
|
|
if ( pbValue[ ib ] != (*ppbPrevValue )[ ib ] )
|
|
{
|
|
break;
|
|
} // if
|
|
} // for: each byte in the value
|
|
if ( ib == cbValue )
|
|
{
|
|
return;
|
|
} // if
|
|
} // if: lengths are the same
|
|
|
|
// Allocate a new buffer for the previous data pointer.
|
|
pbPrevValue = new BYTE[ cbValue ];
|
|
if ( pbPrevValue == NULL )
|
|
{
|
|
ThrowStaticException( GetLastError( ) );
|
|
} // if: error allocating previous data buffer
|
|
CopyMemory( pbPrevValue, pbValue, cbValue );
|
|
|
|
// Open a new key if needed.
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
dwStatus = ClusterRegOpenKey( Hkey( ), pszKeyName, KEY_ALL_ACCESS, &hkey );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
delete [] pbPrevValue;
|
|
ThrowStaticException( dwStatus );
|
|
} // if: error opening the key
|
|
} // if: need to open a subkey
|
|
else
|
|
{
|
|
hkey = Hkey( );
|
|
} // else
|
|
|
|
// Write the value if it hasn't changed.
|
|
dwStatus = ClusterRegSetValue(
|
|
hkey,
|
|
pszValueName,
|
|
REG_BINARY,
|
|
pbValue,
|
|
cbValue
|
|
);
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
if ( dwStatus == ERROR_SUCCESS )
|
|
{
|
|
delete [] *ppbPrevValue;
|
|
*ppbPrevValue = pbPrevValue;
|
|
} // if: set was successful
|
|
else
|
|
{
|
|
delete [] pbPrevValue;
|
|
ThrowStaticException( dwStatus );
|
|
} // else: error setting the value
|
|
|
|
} //*** CClusterItem::WriteValue( LPCTSTR, const LPBYTE )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::DeleteValue
|
|
//
|
|
// Routine Description:
|
|
// Delete the value for this item.
|
|
//
|
|
// Arguments:
|
|
// pszValueName [IN] Name of the value to delete.
|
|
// pszKeyName [IN] Name of the key where the value resides.
|
|
// rstrValue [IN] Value data.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
// Exceptions Thrown:
|
|
// CNTException( dwStatus )
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::DeleteValue(
|
|
IN LPCTSTR pszValueName,
|
|
IN LPCTSTR pszKeyName
|
|
)
|
|
{
|
|
DWORD dwStatus;
|
|
HKEY hkey;
|
|
CWaitCursor wc;
|
|
|
|
ASSERT( pszValueName != NULL );
|
|
ASSERT( Hkey( ) != NULL );
|
|
|
|
// Open a new key if needed.
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
dwStatus = ClusterRegOpenKey( Hkey( ), pszKeyName, KEY_ALL_ACCESS, &hkey );
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
ThrowStaticException( dwStatus );
|
|
} // if
|
|
} // if: need to open a subkey
|
|
else
|
|
{
|
|
hkey = Hkey( );
|
|
} // else
|
|
|
|
// Delete the value.
|
|
dwStatus = ClusterRegDeleteValue( hkey, pszValueName );
|
|
if ( pszKeyName != NULL )
|
|
{
|
|
ClusterRegCloseKey( hkey );
|
|
} // if
|
|
if ( dwStatus != ERROR_SUCCESS )
|
|
{
|
|
ThrowStaticException( dwStatus );
|
|
} // if
|
|
|
|
} //*** CClusterItem::DeleteValue( LPCTSTR )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::BDifferent
|
|
//
|
|
// Routine Description:
|
|
// Compare two string lists.
|
|
//
|
|
// Arguments:
|
|
// rlstr1 [IN] First string list.
|
|
// rlstr2 [IN] Second string list.
|
|
//
|
|
// Return Value:
|
|
// TRUE Lists are different.
|
|
// FALSE Lists are the same.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CClusterItem::BDifferent(
|
|
IN const CStringList & rlstr1,
|
|
IN const CStringList & rlstr2
|
|
)
|
|
{
|
|
BOOL bDifferent;
|
|
|
|
if ( rlstr1.GetCount( ) == rlstr2.GetCount( ) )
|
|
{
|
|
POSITION posStr;
|
|
|
|
bDifferent = FALSE;
|
|
posStr = rlstr1.GetHeadPosition( );
|
|
while ( posStr != NULL )
|
|
{
|
|
if ( rlstr2.Find( rlstr1.GetNext( posStr ) ) == 0 )
|
|
{
|
|
bDifferent = TRUE;
|
|
break;
|
|
} // if: string wasn't found
|
|
} // while: more items in the list
|
|
} // if: lists are the same size
|
|
else
|
|
{
|
|
bDifferent = TRUE;
|
|
} // else
|
|
|
|
return bDifferent;
|
|
|
|
} //*** CClusterItem::BDifferent( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::BDifferentOrdered
|
|
//
|
|
// Routine Description:
|
|
// Compare two string lists.
|
|
//
|
|
// Arguments:
|
|
// rlstr1 [IN] First string list.
|
|
// rlstr2 [IN] Second string list.
|
|
//
|
|
// Return Value:
|
|
// TRUE Lists are different.
|
|
// FALSE Lists are the same.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CClusterItem::BDifferentOrdered(
|
|
IN const CStringList & rlstr1,
|
|
IN const CStringList & rlstr2
|
|
)
|
|
{
|
|
BOOL bDifferent;
|
|
|
|
if ( rlstr1.GetCount( ) == rlstr2.GetCount( ) )
|
|
{
|
|
POSITION posStr1;
|
|
POSITION posStr2;
|
|
|
|
bDifferent = FALSE;
|
|
posStr1 = rlstr1.GetHeadPosition( );
|
|
posStr2 = rlstr2.GetHeadPosition( );
|
|
while ( posStr1 != NULL )
|
|
{
|
|
if ( posStr2 == NULL )
|
|
{
|
|
bDifferent = TRUE;
|
|
break;
|
|
} // if: fewer strings in second list
|
|
if ( rlstr1.GetNext( posStr1 ) != rlstr2.GetNext( posStr2 ) )
|
|
{
|
|
bDifferent = TRUE;
|
|
break;
|
|
} // if: strings are different
|
|
} // while: more items in the list
|
|
if ( posStr2 != NULL )
|
|
{
|
|
bDifferent = TRUE;
|
|
} // if
|
|
} // if: lists are the same size
|
|
else
|
|
{
|
|
bDifferent = TRUE;
|
|
} // else
|
|
|
|
return bDifferent;
|
|
|
|
} //*** CClusterItem::BDifferentOrdered( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::BGetColumnData
|
|
//
|
|
// Routine Description:
|
|
// Returns a string with the column data for a
|
|
//
|
|
// Arguments:
|
|
// colid [IN] Column ID.
|
|
// rstrText [OUT] String in which to return the text for the column.
|
|
//
|
|
// Return Value:
|
|
// TRUE Column data returned.
|
|
// FALSE Column ID not recognized.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CClusterItem::BGetColumnData( IN COLID colid, OUT CString & rstrText )
|
|
{
|
|
BOOL bSuccess;
|
|
|
|
switch ( colid )
|
|
{
|
|
case IDS_COLTEXT_NAME:
|
|
rstrText = StrName( );
|
|
bSuccess = TRUE;
|
|
break;
|
|
case IDS_COLTEXT_TYPE:
|
|
rstrText = StrType( );
|
|
bSuccess = TRUE;
|
|
break;
|
|
case IDS_COLTEXT_DESCRIPTION:
|
|
rstrText = StrDescription( );
|
|
bSuccess = TRUE;
|
|
break;
|
|
default:
|
|
bSuccess = FALSE;
|
|
rstrText = _T("");
|
|
break;
|
|
} // switch: colid
|
|
|
|
return bSuccess;
|
|
|
|
} //*** CClusterItem::BGetColumnData( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::GetTreeName
|
|
//
|
|
// Routine Description:
|
|
// Returns a string to be used in a tree control.
|
|
//
|
|
// Arguments:
|
|
// rstrName [OUT] String in which to return the name.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
#ifdef _DISPLAY_STATE_TEXT_IN_TREE
|
|
void CClusterItem::GetTreeName( OUT CString & rstrName ) const
|
|
{
|
|
rstrName = StrName( );
|
|
|
|
} //*** CClusterItem::GetTreeName( )
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::PmenuPopup
|
|
//
|
|
// Routine Description:
|
|
// Returns a popup menu.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// pmenu A popup menu for the item.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
CMenu * CClusterItem::PmenuPopup( void )
|
|
{
|
|
CMenu * pmenu = NULL;
|
|
|
|
if ( IdmPopupMenu( ) != NULL )
|
|
{
|
|
// Update the state of the item before we construct its menu.
|
|
UpdateState( );
|
|
|
|
// Load the menu.
|
|
pmenu = new CMenu;
|
|
if ( pmenu == NULL )
|
|
{
|
|
return NULL;
|
|
} // if
|
|
if ( ! pmenu->LoadMenu( IdmPopupMenu( ) ) )
|
|
{
|
|
delete pmenu;
|
|
pmenu = NULL;
|
|
} // if: error loading the menu
|
|
} // if: there is a menu for this item
|
|
|
|
return pmenu;
|
|
|
|
} //*** CClusterItem::PmenuPopup( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::AddTreeItem
|
|
//
|
|
// Routine Description:
|
|
// Add a tree item to the list item back pointer list.
|
|
//
|
|
// Arguments:
|
|
// pti [IN] Tree item to add.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::AddTreeItem( CTreeItem * pti )
|
|
{
|
|
POSITION pos;
|
|
|
|
ASSERT_VALID( pti );
|
|
|
|
// Find the item in the list.
|
|
pos = LptiBackPointers( ).Find( pti );
|
|
|
|
// If it wasn't found, add it.
|
|
if ( pos == NULL )
|
|
{
|
|
LptiBackPointers( ).AddTail( pti );
|
|
Trace( g_tagClusItemCreate, _T("AddTreeItem( ) - Adding tree item backptr from '%s' in '%s' - %d in list"), StrName( ), ( pti->PtiParent( ) == NULL ? _T("<ROOT>") : pti->PtiParent( )->StrName( ) ), LptiBackPointers( ).GetCount( ) );
|
|
} // if: item found in list
|
|
|
|
} //*** CClusterItem::AddTreeItem( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::AddListItem
|
|
//
|
|
// Routine Description:
|
|
// Add a list item to the list item back pointer list.
|
|
//
|
|
// Arguments:
|
|
// pli [IN] List item to add.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::AddListItem( CListItem * pli )
|
|
{
|
|
POSITION pos;
|
|
|
|
ASSERT_VALID( pli );
|
|
|
|
// Find the item in the list.
|
|
pos = LpliBackPointers( ).Find( pli );
|
|
|
|
// If it wasn't found, add it.
|
|
if ( pos == NULL )
|
|
{
|
|
LpliBackPointers( ).AddTail( pli );
|
|
Trace( g_tagClusItemCreate, _T("AddListItem( ) - Adding list item backptr from '%s' in '%s' - %d in list"), StrName( ), ( pli->PtiParent( ) == NULL ? _T("<ROOT>") : pli->PtiParent( )->StrName( ) ), LpliBackPointers( ).GetCount( ) );
|
|
} // if: item found in list
|
|
|
|
} //*** CClusterItem::AddListItem( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::RemoveTreeItem
|
|
//
|
|
// Routine Description:
|
|
// Remove a tree item from the tree item back pointer list.
|
|
//
|
|
// Arguments:
|
|
// pti [IN] Tree item to remove.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::RemoveTreeItem( CTreeItem * pti )
|
|
{
|
|
POSITION pos;
|
|
|
|
ASSERT_VALID( pti );
|
|
|
|
// Find the item in the list.
|
|
pos = LptiBackPointers( ).Find( pti );
|
|
|
|
// If it was found, remove it.
|
|
if ( pos != NULL )
|
|
{
|
|
LptiBackPointers( ).RemoveAt( pos );
|
|
Trace( g_tagClusItemDelete, _T("RemoveTreeItem( ) - Deleting tree item backptr from '%s' in '%s' - %d left"), StrName( ), ( pti->PtiParent( ) == NULL ? _T("<ROOT>") : pti->PtiParent( )->StrName( ) ), LptiBackPointers( ).GetCount( ) );
|
|
} // if: item found in list
|
|
|
|
} //*** CClusterItem::RemoveTreeItem( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::RemoveListItem
|
|
//
|
|
// Routine Description:
|
|
// Remove a list item from the list item back pointer list.
|
|
//
|
|
// Arguments:
|
|
// pli [IN] List item to remove.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::RemoveListItem( CListItem * pli )
|
|
{
|
|
POSITION pos;
|
|
|
|
ASSERT_VALID( pli );
|
|
|
|
// Find the item in the list.
|
|
pos = LpliBackPointers( ).Find( pli );
|
|
|
|
// If it was found, remove it.
|
|
if ( pos != NULL )
|
|
{
|
|
LpliBackPointers( ).RemoveAt( pos );
|
|
Trace( g_tagClusItemDelete, _T("RemoveListItem( ) - Deleting list item backptr from '%s' in '%s' - %d left"), StrName( ), ( pli->PtiParent( ) == NULL ? _T("<ROOT>") : pli->PtiParent( )->StrName( ) ), LpliBackPointers( ).GetCount( ) );
|
|
} // if: item found in list
|
|
|
|
} //*** CClusterItem::RemoveListItem( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CResource::CClusterItem
|
|
//
|
|
// Routine Description:
|
|
// Determines whether menu items corresponding to ID_FILE_RENAME
|
|
// should be enabled or not.
|
|
//
|
|
// Arguments:
|
|
// pCmdUI [IN OUT] Command routing object.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::OnUpdateRename( CCmdUI * pCmdUI )
|
|
{
|
|
pCmdUI->Enable( BCanBeEdited( ) );
|
|
|
|
} //*** CClusterItem::OnUpdateRename( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::OnUpdateProperties
|
|
//
|
|
// Routine Description:
|
|
// Determines whether menu items corresponding to ID_FILE_PROPERTIES
|
|
// should be enabled or not.
|
|
//
|
|
// Arguments:
|
|
// pCmdUI [IN OUT] Command routing object.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::OnUpdateProperties( CCmdUI * pCmdUI )
|
|
{
|
|
pCmdUI->Enable( FALSE );
|
|
|
|
} //*** CClusterItem::OnUpdateProperties( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::OnCmdProperties
|
|
//
|
|
// Routine Description:
|
|
// Processes the ID_FILE_PROPERTIES menu command.
|
|
//
|
|
// Arguments:
|
|
// None.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void CClusterItem::OnCmdProperties( void )
|
|
{
|
|
BDisplayProperties( );
|
|
|
|
} //*** CClusterItem::OnCmdProperties( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::BDisplayProperties
|
|
//
|
|
// Routine Description:
|
|
// Display properties for the object.
|
|
//
|
|
// Arguments:
|
|
// bReadOnly [IN] Don't allow edits to the object properties.
|
|
//
|
|
// Return Value:
|
|
// TRUE OK pressed.
|
|
// FALSE OK not pressed.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
BOOL CClusterItem::BDisplayProperties( IN BOOL bReadOnly )
|
|
{
|
|
AfxMessageBox( TEXT("Properties are not available."), MB_OK | MB_ICONWARNING );
|
|
return FALSE;
|
|
|
|
} //*** CClusterItem::BDisplayProperties( )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// CClusterItem::OnClusterNotify
|
|
//
|
|
// Routine Description:
|
|
// Handler for the WM_CAM_CLUSTER_NOTIFY message.
|
|
// Processes cluster notifications for this object.
|
|
//
|
|
// Arguments:
|
|
// pnotify [IN OUT] Object describing the notification.
|
|
//
|
|
// Return Value:
|
|
// Value returned from the application method.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
LRESULT CClusterItem::OnClusterNotify( IN OUT CClusterNotify * pnotify )
|
|
{
|
|
return 0;
|
|
|
|
} //*** CClusterItem::OnClusterNotify( )
|
|
|
|
|
|
//*************************************************************************//
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Global Functions
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// DestructElements
|
|
//
|
|
// Routine Description:
|
|
// Destroys CClusterItem* elements.
|
|
//
|
|
// Arguments:
|
|
// pElements Array of pointers to elements to destruct.
|
|
// nCount Number of elements to destruct.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
extern void AFXAPI DestructElements( CClusterItem ** pElements, int nCount )
|
|
{
|
|
ASSERT( nCount == 0
|
|
|| AfxIsValidAddress( pElements, nCount * sizeof( CClusterItem * ) ) );
|
|
|
|
// call the destructor(s )
|
|
for ( ; nCount--; pElements++ )
|
|
{
|
|
ASSERT_VALID( *pElements );
|
|
(*pElements)->Release( );
|
|
} // for: each item in the array
|
|
|
|
} //*** DestructElements( CClusterItem** )
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
//++
|
|
//
|
|
// DeleteAllItemData
|
|
//
|
|
// Routine Description:
|
|
// Deletes all item data in a CList.
|
|
//
|
|
// Arguments:
|
|
// rlp [IN OUT] List whose data is to be deleted.
|
|
//
|
|
// Return Value:
|
|
// None.
|
|
//
|
|
//--
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
void DeleteAllItemData( IN OUT CClusterItemList & rlp )
|
|
{
|
|
POSITION pos;
|
|
CClusterItem * pci;
|
|
|
|
// Delete all the items in the Contained list.
|
|
pos = rlp.GetHeadPosition( );
|
|
while ( pos != NULL )
|
|
{
|
|
pci = rlp.GetNext( pos );
|
|
ASSERT_VALID( pci );
|
|
// Trace( g_tagClusItemDelete, _T("DeleteAllItemData(rlpci ) - Deleting cluster item '%s'"), pci->StrName( ) );
|
|
pci->Delete( );
|
|
} // while: more items in the list
|
|
|
|
} //*** DeleteAllItemData( )
|