registerclass.cpp

这个程序主要是利用Explorer中右健菜单来Copy全文件

// RegisterClass.cpp
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "GetName.h"
#include "RegisterClass.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#define	GUID_CCH	39

LONG AFXAPI _RecursiveRegDeleteKey(HKEY hParentKey,LPCTSTR szKeyName);
//////////////////////////////////////////////////////////////////////
// 
//////////////////////////////////////////////////////////////////////

CRegisterClass::CRegisterClass(REFCLSID clsid,LPCTSTR pszTypeName,HKEY hKeyRoot)
{
	m_hKeyRoot = hKeyRoot;

	OLECHAR	szClassID[GUID_CCH];
	int cchGuid = ::StringFromGUID2(clsid,szClassID,GUID_CCH);

	CString strClassID(szClassID);

	ASSERT(cchGuid == GUID_CCH);
	if(cchGuid != GUID_CCH)
	{
		TRACE("StringFromGUID2 failed\n");
		return;
	}

	CString strPathName;
	TCHAR szLongPathName[MAX_PATH];
	::GetModuleFileName(AfxGetResourceHandle(),szLongPathName,MAX_PATH);
	::GetShortPathName(szLongPathName,
		strPathName.GetBuffer(MAX_PATH),MAX_PATH);
	strPathName.ReleaseBuffer();

	CString strTypeName(pszTypeName);

	m_symbols.Add(strClassID);
	m_symbols.Add(strTypeName);
	m_symbols.Add(strPathName);
}

CRegisterClass::~CRegisterClass()
{

}

void CRegisterClass::AddEntry(LPCTSTR key, LPCTSTR value, LPCTSTR valueName)
{

	ASSERT(AfxIsValidString(key));
	ASSERT(AfxIsValidString(value));
	ASSERT(valueName == NULL || AfxIsValidString(valueName));

	m_keys.Add(key);
	m_values.Add(value);
	m_valueNames.Add(valueName);
}

int CRegisterClass::AddSymbol(LPCTSTR symbol)
{
	return m_symbols.Add(symbol);
}

int CRegisterClass::AddSymbolAlias(LPCTSTR symbol, LPCTSTR alias)
{
//	TCHAR szValue[MAX_PATH];
//	LONG lSize = sizeof(szValue);

/*	if(RegQueryValue(HKEY_CLASSES_ROOT,symbol,szValue,&lSize)==ERROR_SUCCESS)
	{
		if(lSize>1)
			return AddSymbol(szValue);
	}
*/	
//	SetRegKey(symbol,alias);
	return AddSymbol(alias);

}

BOOL CRegisterClass::Register(BOOL bRegister)
{
	int nSymbols = m_symbols.GetSize();
	CString * pStrings = m_symbols.GetData();

	LPCTSTR* ppSymbols = new LPCTSTR[nSymbols];

	for (int i = 0; i<nSymbols;i++)
		ppSymbols[i] = (LPCTSTR)pStrings[i];

	
	BOOL bRet = Helper(bRegister,ppSymbols,nSymbols);

	delete ppSymbols;
	return bRet;
}

BOOL CRegisterClass::SetRegKey(LPCTSTR lpszKey, LPCTSTR lpszValue, LPCTSTR lpszValueName)
{
	if(lpszValueName == NULL || lstrlen(lpszValueName) == 0)
	{
		if(::RegSetValue(m_hKeyRoot,lpszKey,REG_SZ,lpszValue,
			lstrlen(lpszValue)) != ERROR_SUCCESS)
			return FALSE;
		return TRUE;
	}
	else
	{
		HKEY hKey;
		if(::RegCreateKey(m_hKeyRoot,lpszKey,&hKey) == ERROR_SUCCESS)
		{
			LONG lResult = ::RegSetValueEx(hKey,lpszValueName,0,REG_SZ,
				(CONST BYTE*)lpszValue,lstrlen(lpszValue) + sizeof(TCHAR));

			if(::RegCloseKey(hKey) == ERROR_SUCCESS && lResult == ERROR_SUCCESS)
				return TRUE;
		}
	}
	return TRUE;
}

BOOL CRegisterClass::DelRegKey(LPCTSTR lpszKey, LPCTSTR lpszValueName)
{
	if(lpszValueName == NULL || lstrlen(lpszValueName) == 0)
	{
		ASSERT(AfxIsValidString(lpszKey));
		return(::RegDeleteKey(m_hKeyRoot,lpszKey) == ERROR_SUCCESS);
	}
	else
	{
		HKEY hKey;

		if(::RegOpenKey(m_hKeyRoot,lpszKey,&hKey) == ERROR_SUCCESS)
		{
			LONG lResult = ::RegDeleteValue(hKey,lpszValueName);
			if(::RegCloseKey(hKey) == ERROR_SUCCESS && lResult == ERROR_SUCCESS)
				return TRUE;
		}
	}
	return FALSE;
}

BOOL CRegisterClass::RemoveKey(LPCTSTR key)
{
	CString	strKey;

	int nSymbols = m_symbols.GetSize();
	CString * pStrings = m_symbols.GetData();

	LPCTSTR* ppSymbols = new LPCTSTR[nSymbols];

	for (int i = 0; i<nSymbols;i++)
		ppSymbols[i] = (LPCTSTR)pStrings[i];

	AfxFormatStrings(strKey,key,ppSymbols,nSymbols);
	BOOL bRet = _RecursiveRegDeleteKey(m_hKeyRoot,strKey) == ERROR_SUCCESS;

	delete []ppSymbols;
	return bRet;
}

BOOL CRegisterClass::Helper(BOOL bRegister, LPCTSTR const * ppSymbols, int nSymbols)
{
	ASSERT(nSymbols !=0);

	CString strKey;
	CString strValue;
	CString strValueName;

	BOOL	bResult = TRUE;
	int nItems = m_keys.GetSize();

	for(int i = 0; i<nItems;i++)
	{
		AfxFormatStrings(strKey,m_keys[i],ppSymbols,nSymbols);
		AfxFormatStrings(strValue,m_values[i],ppSymbols,nSymbols);
		AfxFormatStrings(strValueName,m_valueNames[i],ppSymbols,nSymbols);

		if(strKey.IsEmpty())
			continue;

		if(bRegister)
		{
			if(!SetRegKey(strKey,strValue,strValueName))
			{
				bResult = FALSE;
				break;
			}
		}
		else
		{
			if(!DelRegKey(strKey,strValueName))
			{
				bResult = FALSE;
				break;
			}
		}
	}
	return bResult;
}

LONG AFXAPI _RecursiveRegDeleteKey(HKEY hParentKey,LPCTSTR szKeyName)
{
	DWORD dwIndex = 0L;
	TCHAR szSubKeyName[256];
	HKEY hCurrentKey;
	DWORD dwResult;

	if((dwResult = RegOpenKey(hParentKey,szKeyName,&hCurrentKey)) == ERROR_SUCCESS)
	{
		while((dwResult = RegEnumKey(hCurrentKey,0,szSubKeyName,255))== ERROR_SUCCESS)
		{
			if((dwResult = _RecursiveRegDeleteKey(hCurrentKey,szSubKeyName)) != ERROR_SUCCESS)
				break;
		}

		if((dwResult == ERROR_NO_MORE_ITEMS) || (dwResult == ERROR_BADKEY))
		{
			dwResult = RegDeleteKey(hParentKey,szKeyName);
		}
	}
	RegCloseKey(hCurrentKey);
	return dwResult;
}