394 lines
6.9 KiB
C++
394 lines
6.9 KiB
C++
//-----------------------------------------------------------------------------+
|
|
// 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;
|
|
}
|