registry.cpp

一个快捷面板,可以将自己常用的程序放在其中!

// Registry.cpp : implementation file
//

#include "stdafx.h"
#include "Registry.h"

/////////////////////////////////////////////////////////////////////////////
// CRegistry

CRegistry::CRegistry(HKEY hKey)
{
	m_hKey = hKey;
}

CRegistry::~CRegistry()
{
	Close();
}

/////////////////////////////////////////////////////////////////////////////
// CRegistry Functions

BOOL CRegistry::CreateKey(LPCTSTR lpSubKey)
{
	ASSERT(m_hKey);
	ASSERT(lpSubKey);

	HKEY hKey;
	DWORD dw;
	long lReturn = RegCreateKeyEx(m_hKey, lpSubKey, 0L, NULL, REG_OPTION_VOLATILE,
		KEY_ALL_ACCESS, NULL, &hKey, &dw);
    
	if(lReturn == ERROR_SUCCESS)
	{
		m_hKey = hKey;
		return TRUE;
	}
	
	return FALSE;
	
}

BOOL CRegistry::Open(LPCTSTR lpSubKey)
{
	ASSERT(m_hKey);
	ASSERT(lpSubKey);
    
	HKEY hKey;
	long lReturn = RegOpenKeyEx(m_hKey, lpSubKey, 0L, KEY_ALL_ACCESS, &hKey);
    
	if(lReturn == ERROR_SUCCESS)
	{
        m_hKey = hKey;
		return TRUE;
	}
	return FALSE;
	
}

BOOL CRegistry::Close()
{
	BOOL bReturn = TRUE;
	if(m_hKey)
	{
		if(ERROR_SUCCESS != RegCloseKey(m_hKey))
			bReturn = FALSE;

		m_hKey = NULL;
	}
	return bReturn;
	
}

BOOL CRegistry::DeleteValue(LPCTSTR lpValueName)
{
	ASSERT(m_hKey);
	ASSERT(lpValueName);
	
	long lReturn = RegDeleteValue(m_hKey, lpValueName);
	
	if(lReturn == ERROR_SUCCESS)
		return TRUE;
	return FALSE;
	
}

BOOL CRegistry::DeleteKey(HKEY hKey, LPCTSTR lpSubKey)
{
	ASSERT(hKey);
	ASSERT(lpSubKey);
	
	long lReturn = RegDeleteValue(hKey, lpSubKey);
	
	if(lReturn == ERROR_SUCCESS)
		return TRUE;
	return FALSE;
	
}

BOOL CRegistry::Write(LPCTSTR lpSubKey, int nVal)
{
	ASSERT(m_hKey);
	ASSERT(lpSubKey);
	
	DWORD dwValue;
	dwValue = (DWORD)nVal;
	
	long lReturn = RegSetValueEx(m_hKey, lpSubKey, 0L, REG_DWORD,(const BYTE *)&dwValue, sizeof(DWORD));
	
   	if(lReturn==ERROR_SUCCESS)
		return TRUE;
	
	return FALSE;
	
}

BOOL CRegistry::Write(LPCTSTR lpSubKey, DWORD dwVal)
{
	ASSERT(m_hKey);
	ASSERT(lpSubKey);
	
	long lReturn = RegSetValueEx(m_hKey, lpSubKey, 0L, REG_DWORD,(const BYTE *)&dwVal, sizeof(DWORD));
	
   	if(lReturn == ERROR_SUCCESS)
		return TRUE;
	
	return FALSE;
	
}

BOOL CRegistry::Write(LPCTSTR lpSubKey, LPCTSTR lpValue)
{
	ASSERT(m_hKey);
	ASSERT(lpSubKey);
	ASSERT(lpValue);	

	long lReturn = RegSetValueEx(m_hKey, lpSubKey, 0L, REG_SZ, (const BYTE *)lpValue, (DWORD)strlen(lpValue)+1);
	
   	if(lReturn == ERROR_SUCCESS)
		return TRUE;
	
	return FALSE;
	
}

BOOL CRegistry::Write(LPCTSTR lpValueName,	const BYTE* lpDate, DWORD cdData)
{
	ASSERT(m_hKey);
	ASSERT(lpValueName);
	ASSERT(lpDate);	

	long lReturn = RegSetValueEx(m_hKey, lpValueName, 0L, REG_BINARY, (const BYTE *)lpDate, cdData);

	if(lReturn == ERROR_SUCCESS)
		return TRUE;

	return FALSE;

}

// 写结构
BOOL CRegistry::WriteFont(LPCTSTR lpValueName, CFont *pFont)
{
	BOOL bSuccess = TRUE;
	LOGFONT lf;
	pFont->GetLogFont(&lf);
	if(ERROR_SUCCESS != ::RegSetValueEx(m_hKey, lpValueName, 0, 
		REG_BINARY, (LPBYTE)&lf, sizeof(lf)))
		bSuccess = FALSE;

	return bSuccess;
}
BOOL CRegistry::WritePoint(LPCTSTR lpValueName, CPoint *pPoint)
{
	BOOL bSuccess = TRUE;
	if(ERROR_SUCCESS != ::RegSetValueEx(m_hKey, lpValueName, 0, 
		REG_BINARY, (LPBYTE)pPoint, sizeof(CPoint)))
		bSuccess = FALSE;

	return bSuccess;
}
BOOL CRegistry::WriteSize(LPCTSTR lpValueName, CSize *pSize)
{
	BOOL bSuccess = TRUE;
	if(ERROR_SUCCESS != ::RegSetValueEx(m_hKey, lpValueName, 0, 
		REG_BINARY, (LPBYTE)pSize, sizeof(CSize)))
		bSuccess = FALSE;

	return bSuccess;
}
BOOL CRegistry::WriteRect(LPCTSTR lpValueName, CRect *pRect)
{
	BOOL bSuccess = TRUE;
	if(ERROR_SUCCESS != ::RegSetValueEx(m_hKey, lpValueName, 0, 
		REG_BINARY, (LPBYTE)pRect, sizeof(CRect)))
		bSuccess = FALSE;

	return bSuccess;
}

BOOL CRegistry::Read(LPCTSTR lpValueName, int* pnVal)
{
	ASSERT(m_hKey);
	ASSERT(lpValueName);
	ASSERT(pnVal);
	
	DWORD dwType;
	DWORD dwSize = sizeof(DWORD);
	int   nDest = 0;
	long lReturn = RegQueryValueEx(m_hKey, lpValueName, NULL, &dwType, (BYTE *)&nDest, &dwSize);
	
	if(lReturn == ERROR_SUCCESS)
	{
		*pnVal = (int)nDest;
		return TRUE;
	}
	return FALSE;
	
}

BOOL CRegistry::Read(LPCTSTR lpValueName, DWORD* pdwVal)
{
	ASSERT(m_hKey);
	ASSERT(lpValueName);
	ASSERT(pdwVal);
	
	DWORD dwType;
	DWORD dwSize = sizeof(DWORD);
	DWORD dwDest;
	long lReturn = RegQueryValueEx(m_hKey, lpValueName, NULL, &dwType, (BYTE *)&dwDest, &dwSize);
	
	if(lReturn == ERROR_SUCCESS)
	{
		*pdwVal = dwDest;
		return TRUE;
	}
	return FALSE;
	
}

BOOL CRegistry::Read(LPCTSTR lpValueName, BYTE *lpData, DWORD cbData)
{
	ASSERT(m_hKey);
	ASSERT(lpValueName);
	ASSERT(lpData);

	DWORD dwType = REG_BINARY;

	long lReturn = RegQueryValueEx(m_hKey, lpValueName, NULL, &dwType, (BYTE *)&lpData, &cbData);

	if(lReturn == ERROR_SUCCESS)
	{
		return TRUE;
	}
	return FALSE;

}
// // 读取结构
BOOL CRegistry::Read(LPCTSTR lpValueName, CFont *pFont)
{
	DWORD dwType = REG_BINARY, dwSize = sizeof(CFont);
	BOOL  bSuccess = TRUE;
	LOGFONT lf;
	if(::RegQueryValueEx(m_hKey, lpValueName, NULL, &dwType, (LPBYTE)&lf, &dwSize) != ERROR_SUCCESS)
		bSuccess = FALSE;

	return bSuccess;
}

BOOL CRegistry::Read(LPCTSTR lpValueName, CPoint *pPoint)
{
	DWORD dwType = REG_BINARY, dwSize = sizeof(CPoint);
	BOOL  bSuccess = TRUE;
	if(::RegQueryValueEx(m_hKey, lpValueName, NULL, &dwType, (LPBYTE)pPoint, &dwSize) != ERROR_SUCCESS)
		bSuccess = FALSE;

	return bSuccess;
}

BOOL CRegistry::Read(LPCTSTR lpValueName, CSize *pSize)
{
	DWORD dwType = REG_BINARY, dwSize = sizeof(CFont);
	BOOL  bSuccess = TRUE;
	if(::RegQueryValueEx(m_hKey, lpValueName, NULL, &dwType, (LPBYTE)pSize, &dwSize) != ERROR_SUCCESS)
		bSuccess = FALSE;

	return bSuccess;
}

BOOL CRegistry::Read(LPCTSTR lpValueName, CRect *pRect)
{
	DWORD dwType = REG_BINARY, dwSize = sizeof(CFont);
	BOOL  bSuccess = TRUE;
	if(::RegQueryValueEx(m_hKey, lpValueName, NULL, &dwType, (LPBYTE)pRect, &dwSize) != ERROR_SUCCESS)
	{
		DWORD dwError = GetLastError();
		bSuccess = FALSE;
	}
	return bSuccess;
}


BOOL CRegistry::RestoreKey(LPCTSTR lpFileName)
{
	ASSERT(m_hKey);
	ASSERT(lpFileName);
	
	long lReturn = RegRestoreKey(m_hKey, lpFileName, REG_WHOLE_HIVE_VOLATILE);
	
	if(lReturn == ERROR_SUCCESS)
		return TRUE;
	
	return FALSE;
}

BOOL CRegistry::SaveKey(LPCTSTR lpFileName)
{
	ASSERT(m_hKey);
	ASSERT(lpFileName);
	
	long lReturn = RegSaveKey(m_hKey, lpFileName, NULL);
	
	if(lReturn == ERROR_SUCCESS)
		return TRUE;
	
	return FALSE;
}


BOOL CRegistry::Read(LPCTSTR lpValueName, CString* lpVal)
{
	ASSERT(m_hKey);
	ASSERT(lpValueName);
	ASSERT(lpVal);
	
	DWORD dwType;
	DWORD dwSize = 200;
	char szString[2550];
	
	long lReturn = RegQueryValueEx(m_hKey, lpValueName, NULL, &dwType, (BYTE *)szString, &dwSize);
	
	if(lReturn == ERROR_SUCCESS)
	{
		*lpVal = szString;
		return TRUE;
	}
	return FALSE;
	
}