//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, SH Software Co. Ltd.
// = FileName	:   CXRegObject.cpp
// = Version	:   ver2.0
// = Author		:   zjq
// = CreateDate	:   2002-09-09
// = Description:   类的定义
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "RegObject.h"
#include "RegProperty.h"

bool CXRegObject::AttachValue ( int *pintValue, LPCTSTR pszName)
{
	bool bRet = FALSE;
	intEntry *p = new intEntry( pintValue , pszName );
	m_ArrInt.Add( p );
	bRet = TRUE;
	return bRet;
}

bool CXRegObject::AttachValue ( bool *pboolValue , LPCTSTR pszName )
{
	bool bRet = FALSE;
	boolEntry *p = new boolEntry( pboolValue , pszName );
	m_ArrBool.Add( p );
	bRet = TRUE;
	return bRet;
}

bool CXRegObject::AttachValue ( CString *pstrValue , LPCTSTR pszName )
{
	bool bRet = FALSE;
	CStringEntry *p = new CStringEntry( pstrValue , pszName );
	m_ArrCString.Add( p );
	bRet = TRUE;
	return bRet;
}

bool CXRegObject::AttachValue ( DWORD   *pdwValue  , LPCTSTR pszName )
{
	bool bRet = FALSE;
	DWORDEntry *p = new DWORDEntry( pdwValue , pszName );
	m_ArrDWORD.Add( p );
	bRet = TRUE;
	return bRet;
}

void CXRegObject::init ()
{
	m_pobjMaster    = NULL;

	m_Retcode       = 0;
	m_hkObject      = NULL;
	m_dwDisposition = 0;

	m_bOpen         = 0;
	m_bVersionized  = FALSE;

	m_pData         = NULL;
	m_DataType      = 0;
	m_DataSize      = 0;

	m_hKeyTopRoot = HKEY_CURRENT_USER;
}

void CXRegObject::clear ()
{
	delete [] m_pData; 
	m_pData = NULL;

	int i;
	for ( i = 0; i < m_ArrDWORD.GetSize(); i++ )
	{
		DWORDEntry *p = (DWORDEntry *)m_ArrDWORD[i];
		delete p;
	}

	for ( i = 0; i < m_ArrInt.GetSize(); i++ )
	{
		intEntry *p = (intEntry *)m_ArrInt[i];
		delete p;
	}

	for ( i = 0; i < m_ArrBool.GetSize(); i++ )
	{
		boolEntry *p = (boolEntry *)m_ArrBool[i];
		delete p;
	}

	for ( i = 0; i < m_ArrCString.GetSize(); i++ )
	{
		CStringEntry *p = (CStringEntry *)m_ArrCString[i];
		delete p;
	}
	
	if ( m_pobjMaster )
	{
		m_pobjMaster->Unregister ( this );
	}
}

CXRegObject::CXRegObject ()
{
	init ();
}

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

CXRegObject::CXRegObject ( LPCTSTR pszObjectKey, bool   bVersionized, LPCTSTR pszClassname , CRegProperty * pobjMaster, bool bDeleteByRegProperty)
{
	init ();

	m_bVersionized = bVersionized;
	SetObjectKey ( pszObjectKey );

	CString Classname;
	if ( !pszClassname )
	{
		Classname  = _T("Class");
		Classname += pszObjectKey;
	}
	else
	{
		Classname = pszClassname;
	}

	SetClassname ( Classname );
	SetMaster ( pobjMaster );

	m_bDeleteByRegProperty = bDeleteByRegProperty;

	if ( pobjMaster )
	{
		pobjMaster->Register ( this );
	}
}

CXRegObject::~CXRegObject ()
{
	Close();
	clear ();
}

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

		m_pobjMaster    = obj.m_pobjMaster;
		m_ObjectKey     = obj.m_ObjectKey;
		m_Classname     = obj.m_Classname;
		m_Retcode       = obj.m_Retcode;
		m_hkObject      = obj.m_hkObject;
		m_dwDisposition = obj.m_dwDisposition;
		m_bOpen         = obj.m_bOpen;
		m_bVersionized  = obj.m_bVersionized;
	}

	return *this;
}

bool CXRegObject::Init ()
{
	bool bRet = FALSE;

	if ( CheckExists() )
	{
		bRet = Read();
	}
	else
	{
		bRet = Store ();
	}

	return bRet;
}

bool CXRegObject::Exchange ( bool )
{
	return TRUE;
}

bool CXRegObject::Read ()
{
	bool bRet = FALSE;

	int i;

	for ( i = 0; i < m_ArrDWORD.GetSize(); i++ )
	{
		DWORDEntry *p = (DWORDEntry *)m_ArrDWORD[i];

		bRet = GetValue( p->GetName() , p->GetReference() ); ASSERT( bRet );

	}

	for ( i = 0; i < m_ArrInt.GetSize(); i++ )
	{
		intEntry *p = (intEntry *)m_ArrInt[i];

		bRet = GetValue( p->GetName() , p->GetReference() );
	}

	for ( i = 0; i < m_ArrBool.GetSize(); i++ )
	{
		boolEntry *p = (boolEntry *)m_ArrBool[i];
		bRet = GetValue( p->GetName() , p->GetReference() );
	} 

	for ( i = 0; i < m_ArrCString.GetSize(); i++ )
	{
		CStringEntry *p = (CStringEntry *)m_ArrCString[i];
		bRet = GetValue( p->GetName() , p->GetReference() );
	}

	return Exchange( FALSE );
}

bool CXRegObject::Store ()
{
	bool bRet = FALSE;

	int i;
	for ( i = 0; i < m_ArrDWORD.GetSize(); i++ )
	{
		DWORDEntry *p = (DWORDEntry *)m_ArrDWORD[i];
		bRet = SetValue( p->GetName() , p->GetValue() ); ASSERT( bRet );
	}

	for ( i = 0; i < m_ArrInt.GetSize(); i++ )
	{
		intEntry *p = (intEntry *)m_ArrInt[i];
		bRet = SetValue( p->GetName() , p->GetValue() ); ASSERT( bRet );
	}

	for ( i = 0; i < m_ArrBool.GetSize(); i++ )
	{
		boolEntry *p = (boolEntry *)m_ArrBool[i];
		bRet = SetValue( p->GetName() , p->GetValue() ); ASSERT( bRet );
	}

	for ( i = 0; i < m_ArrCString.GetSize(); i++ )
	{
		CStringEntry *p = (CStringEntry *)m_ArrCString[i];
		bRet = SetValue( p->GetName() , p->GetValue() ); ASSERT( bRet );
	}

	return Exchange( TRUE );
}

void  CXRegObject::SetMaster( CRegProperty * pobjMaster )
{
	m_pobjMaster = pobjMaster;
}

void CXRegObject::SetObjectKey ( LPCTSTR pszObjectKey )
{
	m_ObjectKey = pszObjectKey;
}

void CXRegObject::SetClassname ( LPCTSTR pszClassname )
{
	m_Classname = pszClassname;
}

bool CXRegObject::CheckExists ()
{
	Open (FALSE, KEY_READ);

	return (m_bOpen != 0);
}

bool CXRegObject::Open (bool bCreate, REGSAM samDesired)
{
	bool bRet = TRUE;

	ASSERT( m_ObjectKey.GetLength() );
	ASSERT( m_Classname.GetLength() );

	// 当前不是写权限的话，则关闭Key，重新打开 --wyg20090630
	if ((samDesired & (KEY_SET_VALUE)) && !(m_bOpen & (KEY_SET_VALUE))
		|| (samDesired & (KEY_CREATE_SUB_KEY)) && !(m_bOpen & (KEY_CREATE_SUB_KEY)))
	{
		Close();
	}

	if ( !m_bOpen )
	{
		CString Subkey  = GetMasterKey ();
		Subkey += "\\";
		Subkey += m_ObjectKey;
		DWORD   dwReserved = 0;

		if ( bCreate )
		{
			TCHAR Classname[1024];
			_tcscpy( Classname , m_Classname );

			m_Retcode = ::RegCreateKeyEx ( m_hKeyTopRoot, Subkey, dwReserved, Classname, 
				REG_OPTION_NON_VOLATILE, samDesired, NULL, &m_hkObject, &m_dwDisposition);

			m_Classname = Classname;
		}
		else
		{
			m_Retcode = ::RegOpenKeyEx ( m_hKeyTopRoot, Subkey, dwReserved, samDesired, &m_hkObject);
		} 

		if ( m_Retcode == ERROR_SUCCESS )
		{
			bRet = TRUE;
			m_bOpen = samDesired;
		}
		else
		{
			bRet  = FALSE;
			m_bOpen = 0;
		} 
	} 

	return bRet;
}

bool CXRegObject::SetValue ( LPCTSTR pszName , LPCTSTR pszValue , bool bUnExanded )
{
	bool bRet = Open(TRUE, KEY_READ | KEY_WRITE);

	if ( bRet )
	{
		DWORD dwReserved = 0;
		DWORD dwType = bUnExanded ? REG_EXPAND_SZ : REG_SZ;

		m_Retcode = ::RegSetValueEx( m_hkObject, pszName, dwReserved, dwType, (BYTE *)pszValue, 
					(_tcslen( pszValue ) + 1) * sizeof(TCHAR));

		bRet = ( m_Retcode == ERROR_SUCCESS ) ? TRUE  : FALSE;
	}

	return bRet;
}

bool CXRegObject::SetValue ( LPCTSTR pszName , BYTE * pValue , DWORD size )
{
	bool bRet = Open(TRUE, KEY_READ | KEY_WRITE);

	if ( bRet )
	{
		DWORD dwReserved = 0;

		m_Retcode = ::RegSetValueEx( m_hkObject, pszName, dwReserved, REG_BINARY,
						pValue, size);

		bRet = ( m_Retcode == ERROR_SUCCESS ) ? TRUE  : FALSE;
	}

	return bRet;
}

bool CXRegObject::SetValue ( LPCTSTR pszName , bool bValue )
{
	return SetValue ( pszName , (BYTE *)&bValue , 1 );
}

bool CXRegObject::SetValue ( LPCTSTR pszName , DWORD dwValue )
{
	bool bRet = Open(TRUE, KEY_READ | KEY_WRITE);

	if ( bRet )
	{
		DWORD dwReserved = 0;
		m_Retcode = ::RegSetValueEx( m_hkObject, pszName, dwReserved, REG_DWORD,
							(BYTE *)&dwValue, sizeof( DWORD ));

		bRet = ( m_Retcode == ERROR_SUCCESS ) ? TRUE  : FALSE;
	}

	return bRet;
}

bool CXRegObject::SetValue ( LPCTSTR pszName , int nValue )
{
	return SetValue ( pszName , (DWORD) nValue );
}

bool CXRegObject::SetValue ( LPCTSTR pszName , LPCTSTR *pszValue )
{
	bool bRet = Open(TRUE, KEY_READ | KEY_WRITE);

	if ( bRet )
	{
		DWORD dwReserved = 0;
		DWORD dwSize     = 0;

		for ( const TCHAR ** ppc = pszValue; *(*ppc + 1) ; ppc++ )
		{
			dwSize += _tcslen( *ppc ) + 1;
		}

		m_Retcode = ::RegSetValueEx( m_hkObject, pszName, dwReserved,
							REG_MULTI_SZ, (BYTE *)pszValue, dwSize*sizeof(TCHAR));

		bRet = ( m_Retcode == ERROR_SUCCESS ) ? TRUE  : FALSE;
	}

	return bRet;
}

bool CXRegObject::SetValue ( LPCTSTR pszName , double dValue )
{
	CString csValue;
	csValue.Format(_T("%g"), dValue);

	return SetValue(pszName, csValue);
}

bool CXRegObject::GetValue ( LPCTSTR pszName )
{
	bool bRet = Open(TRUE, KEY_READ);

	if ( bRet )
	{
		DWORD dwReserved = 0;

		m_Retcode = RegQueryValueEx( m_hkObject, pszName, NULL, NULL, NULL, &m_DataSize);

		bRet = ( m_Retcode == ERROR_SUCCESS ) && m_DataSize ? TRUE  : FALSE;

		if ( bRet )
		{
			delete [] m_pData;
			m_pData = NULL;
			m_pData = new BYTE[ m_DataSize + 1 ];

			m_Retcode = RegQueryValueEx( m_hkObject, pszName, NULL, &m_DataType, m_pData, &m_DataSize);

			bRet = ( m_Retcode == ERROR_SUCCESS ) && m_DataSize ? TRUE  : FALSE;
		}
	} 

	return bRet;
}

bool CXRegObject::GetValue ( LPCTSTR pszName , LPTSTR pszValue , DWORD size , bool * pbUnExanded )
{
	bool bRet = FALSE;

	bRet = GetValue ( pszName );

	if ( bRet )
	{
		bRet = FALSE;
		ASSERT( m_DataType == REG_EXPAND_SZ	|| m_DataType == REG_SZ	);

		if ( pbUnExanded )
		{
			*pbUnExanded = m_DataType == REG_EXPAND_SZ;
		}

		if ( m_DataType == REG_EXPAND_SZ || m_DataType == REG_SZ)
		{
			ASSERT( m_DataSize <= size );

			_tcsncpy ( pszValue , (const TCHAR*)m_pData , min( m_DataSize / sizeof(TCHAR) , size ));

			delete [] m_pData; 
			m_pData = NULL;
			m_DataSize = m_DataType = 0;

			bRet = TRUE;
		}
	}

	return bRet;
}

bool CXRegObject::GetValue ( LPCTSTR pszName , CString & Value , bool * pbUnExanded )
{
	bool bRet = FALSE;
	bRet = GetValue ( pszName );

	if ( bRet )
	{
		bRet = FALSE;
		ASSERT( m_DataType == REG_EXPAND_SZ	|| m_DataType == REG_SZ	);

		if ( pbUnExanded )
		{
			*pbUnExanded = m_DataType == REG_EXPAND_SZ;
		}

		if ( m_DataType == REG_EXPAND_SZ || m_DataType == REG_SZ)
		{
			Value = (const TCHAR*)m_pData;

			delete [] m_pData;
			m_pData = NULL;
			m_DataSize = m_DataType = 0;

			bRet = TRUE;
		} 
	}

	return bRet;
}

bool CXRegObject::GetValue ( LPCTSTR pszName , BYTE * pValue , DWORD size )
{
	bool bRet = FALSE;
	bRet = GetValue ( pszName );

	if ( bRet )
	{
		bRet = FALSE;
		ASSERT( m_DataType == REG_BINARY );

		if ( m_DataType == REG_BINARY )
		{
			ASSERT( m_DataSize <= size );
			memcpy ( pValue , m_pData , min( m_DataSize , size ));

			delete [] m_pData; 
			m_pData = NULL; 
			m_DataSize = m_DataType = 0;

			bRet = TRUE;
		}
	}

	return bRet;
}

bool CXRegObject::GetValue ( LPCTSTR pszName , DWORD &dwValue )
{
	bool bRet = FALSE;
	dwValue = 0;
	bRet = GetValue ( pszName );

	if ( bRet )
	{
		bRet = FALSE;
		ASSERT( m_DataType == REG_DWORD );

		if ( m_DataType == REG_DWORD )
		{
			dwValue = *(DWORD *)m_pData;

			delete [] m_pData;
			m_pData = NULL; 
			m_DataSize = m_DataType = 0;

			bRet = TRUE;
		}
	}

	return bRet;
}

bool CXRegObject::GetValue ( LPCTSTR pszName , int & nValue )
{
	bool bRet = FALSE;
	DWORD dwValue = 0;

	bRet = GetValue ( pszName , dwValue );

	if (bRet) 
	{
		nValue = (int) dwValue;
	}

	return bRet;
}

bool CXRegObject::GetValue ( LPCTSTR pszName , bool & bValue )
{
	bool bRet = FALSE;
	BYTE Value = 0;
	bRet = GetValue ( pszName , &Value , 1 );

	if (bRet)
	{
		bValue = Value != 0;
	}

	return bRet;
}

bool CXRegObject::GetValue ( LPCTSTR pszName , double &dValue )
{
	CString csValue;
	if (!GetValue(pszName, csValue))
	{
		return false;
	}

	dValue = _tstof(csValue);
	
	return true;
}

void CXRegObject::Close ()
{
	if ( m_bOpen )
	{
		::RegCloseKey( m_hkObject );

		m_bOpen    = 0;
		m_hkObject = NULL ;
	}
}

CString CXRegObject::GetKey () const
{
	return m_ObjectKey;
}

CString CXRegObject::GetMasterKey () const
{
	ASSERT( m_pobjMaster ); 

	return m_pobjMaster->GetRootKey( m_bVersionized );
}

void CXRegObject::SetTopRootKey(HKEY hKey)
{
	m_hKeyTopRoot = hKey;
}