636 lines
12 KiB
C++
636 lines
12 KiB
C++
//-----------------------------------------------------------------------------+
|
|
// 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;
|
|
}
|
|
|