//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, SH Software Co. Ltd.
// = FileName	:   CRegProperty.cpp
// = Version	:   ver2.0
// = Author		:   zjq
// = CreateDate	:   2002-09-09
// = Description:   ÀàµÄ¶¨Òå
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "RegProperty.h"

void CRegProperty::init()
{
	m_RegPropertyType = RegPTypeNONE;
	SetMaster( this );
}

void CRegProperty::clear()
{
	m_bDeleting = TRUE;

	int nSize = m_CRegObjectArray.GetSize();

	for ( int i = 0; i < nSize;  i++ )
	{
		CXRegObject * pobj  = (CXRegObject *)m_CRegObjectArray[i];

		if ( pobj->m_bDeleteByRegProperty )
		{
			delete pobj;
		}

	} 

	m_CRegObjectArray.RemoveAll();

	m_bDeleting = FALSE;

	return;

}

CRegProperty::CRegProperty()
{
	init();
}

CRegProperty::CRegProperty ( LPCTSTR pszRootKey , LPCTSTR pszObjKey )
: CXRegObject ( pszObjKey )
{
	init();

	SetRootKey ( pszRootKey , 0.0 );
}

CRegProperty::CRegProperty ( LPCTSTR pszRootKey ,  LPCTSTR pszObjKey, double dVersion)
: CXRegObject ( pszObjKey, (dVersion > 0) )
{
	init();

	SetRootKey ( pszRootKey , dVersion );
}

CRegProperty::CRegProperty ( const CRegProperty & obj )
{
	*this = obj;
}

CRegProperty & CRegProperty::operator = ( const CRegProperty & obj )
{
	if ( &obj != this )
	{
		clear();
		init();

		m_RootKey         = obj.m_RootKey       ;
		m_VersionKey      = obj.m_VersionKey     ;
		m_RegPropertyType = obj.m_RegPropertyType;

		int nSize = obj.m_CRegObjectArray.GetSize();

		m_CRegObjectArray.SetSize( nSize );

		for ( int i = 0; i < nSize;  i++ )
		{
			CXRegObject * pobj  = (CXRegObject *)m_CRegObjectArray[i];

			m_CRegObjectArray.Add( pobj );
		} 
	}
	return *this;
}

CRegProperty::~CRegProperty()
{
	clear();
}

void CRegProperty::Register  ( CXRegObject * pobj )
{
	if ( pobj != this )
	{
		m_CRegObjectArray.Add ( pobj );
	}
}

bool CRegProperty::LookUp ( CXRegObject * pobjLook , int *pIndex )
{
	bool bRet = FALSE;

	int nSize = m_CRegObjectArray.GetSize();

	for ( int i = 0; i < nSize;  i++ )
	{
		CXRegObject * pobj  = (CXRegObject *)m_CRegObjectArray[i];

		if ( pobjLook == pobj )
		{
			if ( pIndex )
			{
				*pIndex = i;
			}
			bRet = TRUE;
			break;
		} 
	} 

	ASSERT( bRet );

	return bRet;

}

CXRegObject * CRegProperty::LookUp ( PRPHANDLE hSubkey )
{
	CXRegObject * pCRegObject = NULL;
	CXRegObject * pObject     = (CXRegObject *)hSubkey;

	if ( LookUp( pObject ) )
	{
		pCRegObject = pObject;
	}
	return pCRegObject;
}

void CRegProperty::Unregister( CXRegObject * pobjUn )
{
	if ( !m_bDeleting )
	{
		int Index = 0;

		if ( pobjUn != this )
		{
			if ( LookUp ( pobjUn , &Index ) )
			{
				m_CRegObjectArray.RemoveAt( Index );
			}
		}
	}
} 

bool CRegProperty::Store()
{
	bool bRet = TRUE;

	int nSize = m_CRegObjectArray.GetSize();

	for ( int i = 0; i < nSize;  i++ )
	{
		CXRegObject * pobj  = (CXRegObject *)m_CRegObjectArray[i];

		if ( pobj )
		{
			bRet = pobj->Store();
		}

		ASSERT( bRet );

	}
	return bRet;
} 

bool CRegProperty::Read()
{
	bool bRet = TRUE;

	int nSize = m_CRegObjectArray.GetSize();

	for ( int i = 0; i < nSize;  i++ )
	{
		CXRegObject * pobj  = (CXRegObject *)m_CRegObjectArray[i];

		if ( pobj )
		{
			bRet = pobj->Read();
		}
		ASSERT( bRet );
	}
	return bRet;
}

bool CRegProperty::Init()
{
	bool bRet = TRUE;

	int nSize = m_CRegObjectArray.GetSize();

	for ( int i = 0; i < nSize;  i++ )
	{
		CXRegObject * pobj  = (CXRegObject *)m_CRegObjectArray[i];

		if ( pobj )
			bRet = pobj->Init();

		ASSERT( bRet );

	}
	return bRet;
}

CString CRegProperty::GetRootKey ( bool bVersionized ) const
{
	return bVersionized ? m_VersionKey : m_CommonKey;
}

CString CRegProperty::GetVersion() const
{
	return m_Version;
}

void CRegProperty::SetRootKey ( LPCTSTR pszRootKey , double dVersion )
{
	m_RootKey = pszRootKey;

	m_Version.Format( _T("%lf") , dVersion );  

	m_VersionKey = m_RootKey; 
	m_VersionKey += '\\'; 
	m_VersionKey += m_Version;
	m_CommonKey  = m_RootKey;

}

PRPHANDLE CRegProperty::CreateSubKey ( LPCTSTR pszSubkey , bool bVersionized , LPCTSTR pszClassname )
{
	PRPHANDLE hSubkey = 0;

	CString Classname;

	if ( pszClassname )
	{
		Classname = pszClassname;
	}
	else
	{
		Classname  = "Class";
		Classname += pszSubkey;

	}

	CXRegObject * pCRegObject = new CXRegObject( pszSubkey , bVersionized , Classname , this , TRUE );

	hSubkey = (DWORD)pCRegObject;

	return hSubkey;

} 

CXRegObject * CRegProperty::GeCRegObject ( PRPHANDLE Handle )
{
	ASSERT( Handle );

	return (CXRegObject *)Handle; 

}

bool CRegProperty::AttachValue ( PRPHANDLE hSubkey , int *pintValue , LPCTSTR pszName )
{
	bool bRet = FALSE;

	CXRegObject * pRegObject = LookUp ( hSubkey );

	if ( pRegObject )
	{
		bRet = pRegObject->AttachValue ( pintValue , pszName );
	}
	return bRet;
} 

bool CRegProperty::AttachValue ( PRPHANDLE hSubkey , bool *pboolValue , LPCTSTR pszName )
{
	bool bRet = FALSE;

	CXRegObject * pRegObject = LookUp ( hSubkey );

	if ( pRegObject )
	{
		bRet = pRegObject->AttachValue ( pboolValue , pszName );
	}

	return bRet;

}

bool CRegProperty::AttachValue ( PRPHANDLE hSubkey , DWORD *pDWORDValue , LPCTSTR pszName )
{
	bool bRet = FALSE;

	CXRegObject * pRegObject = LookUp ( hSubkey );

	if ( pRegObject )
	{
		bRet = pRegObject->AttachValue ( pDWORDValue , pszName );
	}
	return bRet;
}

bool CRegProperty::AttachValue ( PRPHANDLE hSubkey , long *plongValue , LPCTSTR pszName )
{
	return AttachValue ( hSubkey , (DWORD *)plongValue , pszName );
}

bool CRegProperty::AttachValue ( PRPHANDLE hSubkey , CString *pCStringValue , LPCTSTR pszName )
{
	bool bRet = FALSE;

	CXRegObject * pRegObject = LookUp ( hSubkey );

	if ( pRegObject )
	{
		bRet = pRegObject->AttachValue ( pCStringValue , pszName );
	}

	return bRet;
}

bool CRegProperty::ReadValue ( HKEY key
							   , const TCHAR * pszKey
							   , const TCHAR * pszValuename
							   , BYTE  * pBuffer
							   , DWORD    BufferSize )
{
	bool bRet = FALSE;

	DWORD dwReserved = 0;
	HKEY  hkObject   = NULL;

	LONG  Retcode = ::RegOpenKeyEx  ( HKEY_CURRENT_USER  // handle of an open key
									, pszKey
									, dwReserved         // reserved
									, KEY_QUERY_VALUE	 // desired security access
									, &hkObject          // address of buffer for opened handle
									);
	if ( Retcode == ERROR_SUCCESS )
	{
		DWORD DataSize = 0;

		Retcode = RegQueryValueEx ( hkObject     // query size
									, pszValuename
									, NULL // &dwReserved
									, NULL
									, NULL
									, &DataSize
									);
		ASSERT( DataSize <= BufferSize );

		if ( Retcode == ERROR_SUCCESS && DataSize <= BufferSize )
		{
			Retcode = RegQueryValueEx ( hkObject     // get value
										, pszValuename
										, NULL		// &dwReserved
										, NULL
										, pBuffer
										, &DataSize
										);

			if ( Retcode == ERROR_SUCCESS )
			{
				bRet = TRUE;
			}
		} 

	}

	if ( Retcode != ERROR_SUCCESS )
	{
		AfxMessageBox(_T("Reg Fail"));
	}
	::RegCloseKey( hkObject );
	return bRet;
}