pidlmgr.cpp

Windows资源浏览器外壳扩展右键菜单功能的实例程序

**************************************************************************/

BOOL CPidlMgr::IsSubKey(LPCITEMIDLIST pidl)
{
	LPPIDLDATA  pData = GetDataPointer(pidl);
	
	return (PT_SUBKEY == pData->type);
}

/**************************************************************************

  CPidlMgr::IsValue()
  
**************************************************************************/

BOOL CPidlMgr::IsValue(LPCITEMIDLIST pidl)
{
	LPPIDLDATA  pData = GetDataPointer(pidl);
	
	return (PT_VALUE == pData->type);
}

/**************************************************************************

  CPidlMgr::HasSubKeys()
  
**************************************************************************/

BOOL CPidlMgr::HasSubKeys(HKEY hKeyRoot, LPCTSTR pszSubKey, LPCITEMIDLIST pidl)
{
	HKEY     hKey;
	LONG     lResult = !ERROR_SUCCESS;
	FILETIME ft;
	LPTSTR   lpszTemp;
	
	if(!pszSubKey)
		pszSubKey = TEXT("");
	
	if(!hKeyRoot)
		GetRootKey(pidl, &hKeyRoot);
	
	DWORD dwSize = GetSubKeyText(pidl, NULL, 0) + lstrlen(pszSubKey) + 2;
	
	lpszTemp = new TCHAR[dwSize];
	if(!lpszTemp)
		return FALSE;
	
	lstrcpy(lpszTemp, pszSubKey);
	if(*lpszTemp)
		lstrcat(lpszTemp, TEXT("\\"));
	GetSubKeyText(pidl, lpszTemp + lstrlen(lpszTemp), dwSize - lstrlen(lpszTemp));
	
	//open the specified key
	lResult = RegOpenKeyEx( hKeyRoot,
		lpszTemp,
		0,
		KEY_ENUMERATE_SUB_KEYS,
		&hKey);
	
	if(ERROR_SUCCESS == lResult)
	{
		TCHAR szTemp[MAX_PATH];
		DWORD dwSize = sizeof(szTemp);
		
		//try to get the specified subkey
		lResult = RegEnumKeyEx( hKey,
			0,
			szTemp,
			&dwSize,
			NULL,
			NULL,
			NULL,
			&ft);
		
		RegCloseKey(hKey);
	}
	
	delete lpszTemp;
	
	return (BOOL)(ERROR_SUCCESS == lResult);
}

/**************************************************************************

  CPidlMgr::GetDataPointer()
  
**************************************************************************/

LPPIDLDATA CPidlMgr::GetDataPointer(LPCITEMIDLIST pidl)
{
	if(!pidl)
		return NULL;
	
	return (LPPIDLDATA)(pidl->mkid.abID);
}

/**************************************************************************

  CPidlMgr::GetValueType()
  
**************************************************************************/

BOOL CPidlMgr::GetValueType(  LPCITEMIDLIST pidlFQ, 
							LPDWORD pdwType)
{
	BOOL  bReturn;
	LPITEMIDLIST   pidlKey;
	LPITEMIDLIST   pidlValue;
	
	if(!SeparateKeyAndValue(pidlFQ, &pidlKey, &pidlValue))
		return 0;
	
	bReturn = GetValueType(pidlKey, pidlValue, pdwType);
	
	Delete(pidlKey);
	Delete(pidlValue);
	
	return bReturn;
}

/**************************************************************************

  CPidlMgr::GetValueType()
  
**************************************************************************/

BOOL CPidlMgr::GetValueType(  LPCITEMIDLIST pidlKey, 
							LPCITEMIDLIST pidlValue, 
							LPDWORD pdwType)
{
	if(!pidlKey)
		return FALSE;
	
	if(!pidlValue)
		return FALSE;
	
	if(!pdwType)
		return FALSE;
	
	HKEY     hKey,
		hRootKey;
	LPTSTR   lpszSubKey,
		lpszValueName;
	DWORD    dwNameSize;
	LONG     lResult;
	
	//get the root key
	GetRootKey(pidlKey, &hRootKey);
	
	//assemble the key string
	dwNameSize = GetSubKeyText(pidlKey, NULL, 0);
	lpszSubKey = new TCHAR[dwNameSize];
	if(!lpszSubKey)
		return FALSE;
	GetSubKeyText(pidlKey, lpszSubKey, dwNameSize);
	
	//assemble the value name
	dwNameSize = GetValueText(pidlValue, NULL, 0);
	lpszValueName = new TCHAR[dwNameSize];
	if(!lpszValueName)
	{
		delete lpszSubKey;
		return FALSE;
	}
	GetValueText(pidlValue, lpszValueName, dwNameSize);
	
	//open the key
	lResult = RegOpenKeyEx( hRootKey,
		lpszSubKey,
		0,
		KEY_QUERY_VALUE,
		&hKey);
	
	if(ERROR_SUCCESS != lResult)
		return FALSE;
	
	//get the value type
	lResult = RegQueryValueEx( hKey,
		lpszValueName,
		NULL,
		pdwType,
		NULL,
		NULL);
	
	RegCloseKey(hKey);
	
	delete lpszSubKey;
	
	delete lpszValueName;
	
	return TRUE;
}

/**************************************************************************

  CPidlMgr::GetDataText()
  
**************************************************************************/

DWORD CPidlMgr::GetDataText(  LPCITEMIDLIST pidlFQ, 
							LPTSTR lpszOut, 
							DWORD dwOutSize)
{
	DWORD dwReturn;
	LPITEMIDLIST   pidlKey;
	LPITEMIDLIST   pidlValue;
	
	if(!SeparateKeyAndValue(pidlFQ, &pidlKey, &pidlValue))
		return 0;
	
	dwReturn = GetDataText(pidlKey, pidlValue, lpszOut, dwOutSize);
	
	Delete(pidlKey);
	Delete(pidlValue);
	
	return dwReturn;
}

/**************************************************************************

  CPidlMgr::GetDataText()
  
**************************************************************************/

DWORD CPidlMgr::GetDataText(  LPCITEMIDLIST pidlKey, 
							LPCITEMIDLIST pidlValue, 
							LPTSTR lpszOut, 
							DWORD dwOutSize)
{
	HKEY     hKey,
		hRootKey;
	LPTSTR   lpszSubKey,
		lpszValueName;
	DWORD    dwNameSize,
		dwType,
		dwSize,
		dwReturn = 0;
	LONG     lResult;
	TCHAR    szData[MAX_PATH];
	
	if(!lpszOut)
		return dwReturn;
	
	if(!pidlKey)
		return dwReturn;
	
	if(!pidlValue)
		return dwReturn;
	
	//get the root key
	GetRootKey(pidlKey, &hRootKey);
	
	//assemble the key string
	dwNameSize = GetSubKeyText(pidlKey, NULL, 0);
	lpszSubKey = new TCHAR[dwNameSize];
	if(!lpszSubKey)
		return dwReturn;
	GetSubKeyText(pidlKey, lpszSubKey, dwNameSize);
	
	//assemble the value name
	dwNameSize = GetValueText(pidlValue, NULL, 0);
	lpszValueName = new TCHAR[dwNameSize];
	if(!lpszValueName)
	{
		delete lpszSubKey;
		return dwReturn;
	}
	GetValueText(pidlValue, lpszValueName, dwNameSize);
	
	//open the key
	lResult = RegOpenKeyEx( hRootKey,
		lpszSubKey,
		0,
		KEY_QUERY_VALUE,
		&hKey);
	
	if(ERROR_SUCCESS != lResult)
		return 0;
	
	//get the value
	dwSize = sizeof(szData);
	lResult = RegQueryValueEx( hKey,
		lpszValueName,
		NULL,
		&dwType,
		(LPBYTE)szData,
		&dwSize);
	
		/*
		If this fails, then there is no default value set, so go ahead and add the 
		empty default value.
	*/
	if(ERROR_SUCCESS == lResult)
	{
		//format the data
		switch(dwType)
		{
		case REG_BINARY:
		case REG_DWORD:
		case REG_DWORD_BIG_ENDIAN:
			{
				LPTSTR   lpszBuffer,
					lpszTemp;
				LPBYTE   pData = (LPBYTE)szData;
				
				lpszBuffer = lpszTemp = new TCHAR[dwSize * sizeof(TCHAR) * 3 + sizeof(TCHAR)];
				
				if(lpszTemp)
				{
					DWORD dwTemp;
					
					for(dwTemp = 0; dwTemp < dwSize; dwTemp++)
					{
						wsprintf(lpszTemp, TEXT("%02x"), *(pData + dwTemp));
						lstrcat(lpszTemp, TEXT(" "));
						lpszTemp = lpszBuffer + lstrlen(lpszBuffer);
					}
					
					lstrcpyn(lpszOut, lpszBuffer, dwOutSize);
					
					delete lpszBuffer;
				}
			}
			break;
			
		default:
			lstrcpyn(lpszOut, szData, dwOutSize);
			break;
		}
		dwReturn = lstrlen(lpszOut);
	}
	
	RegCloseKey(hKey);
	
	delete lpszSubKey;
	
	delete lpszValueName;
	
	return dwReturn;
}

/**************************************************************************

  CPidlMgr::GetPidlPath()
  
	Create a string that includes the root key name, the sub key text and 
	the value text.
	
	  **************************************************************************/
	  
	  DWORD CPidlMgr::GetPidlPath(LPCITEMIDLIST pidl, LPTSTR lpszOut, DWORD dwOutSize)
	  {
		  LPTSTR   lpszTemp;
		  
		  if(!lpszOut)
			  return 0;
		  
		  *lpszOut = 0;
		  lpszTemp = lpszOut;
		  
		  //add the root key text if necessary
		  if(IsRootKey(pidl))
		  {
			  HKEY  hKey;
			  
			  GetRootKey(pidl, &hKey);
			  dwOutSize -= GetRootKeyText(hKey, lpszOut, dwOutSize);
		  }
		  
		  //add a backslash if necessary
		  AddBackslash(lpszOut);
		  
		  lpszTemp = lpszOut + lstrlen(lpszOut);
		  
		  //add the subkey string
		  dwOutSize -= GetSubKeyText(pidl, lpszTemp, dwOutSize);
		  
		  //add a backslash if necessary
		  AddBackslash(lpszOut);
		  
		  lpszTemp = lpszOut + lstrlen(lpszOut);
		  
		  //add the value string
		  GetValueText(pidl, lpszTemp, dwOutSize);
		  
		  //remove the last backslash if necessary
		  if(*(lpszOut + lstrlen(lpszOut) - 1) == '\\')
		  {
			  *(lpszOut + lstrlen(lpszOut) - 1) = 0;
		  }
		  
		  return lstrlen(lpszOut);
	  }
	  
	  /**************************************************************************
	  
		CPidlMgr::Concatenate()
		
		  Create a new PIDL by combining two existing PIDLs.
		  
	  **************************************************************************/
	  
	  LPITEMIDLIST CPidlMgr::Concatenate(LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
	  {
		  LPITEMIDLIST   pidlNew;
		  UINT           cb1 = 0, 
			  cb2 = 0;
		  
		  //are both of these NULL?
		  if(!pidl1 && !pidl2)
			  return NULL;
		  
		  //if pidl1 is NULL, just return a copy of pidl2
		  if(!pidl1)
		  {
			  pidlNew = Copy(pidl2);
			  
			  return pidlNew;
		  }
		  
		  //if pidl2 is NULL, just return a copy of pidl1
		  if(!pidl2)
		  {
			  pidlNew = Copy(pidl1);
			  
			  return pidlNew;
		  }
		  
		  cb1 = GetSize(pidl1) - sizeof(ITEMIDLIST);
		  
		  cb2 = GetSize(pidl2);
		  
		  //create the new PIDL
		  pidlNew = (LPITEMIDLIST)m_pMalloc->Alloc(cb1 + cb2);
		  
		  if(pidlNew)
		  {
			  //copy the first PIDL
			  CopyMemory(pidlNew, pidl1, cb1);
			  
			  //copy the second PIDL
			  CopyMemory(((LPBYTE)pidlNew) + cb1, pidl2, cb2);
		  }
		  
		  return pidlNew;
	  }
	  
	  /**************************************************************************
	  
		CPidlMgr::SeparateKeyAndValue()
		
		  Creates a separate key and value PIDL from a fully qualified PIDL.
		  
	  **************************************************************************/
	  
	  BOOL CPidlMgr::SeparateKeyAndValue( LPCITEMIDLIST pidlFQ, 
		  LPITEMIDLIST *ppidlKey, 
		  LPITEMIDLIST*ppidlValue)
	  {
		  if(!pidlFQ)
			  return FALSE;
		  
		  *ppidlValue = GetLastItem(pidlFQ);
		  if(!IsValue(*ppidlValue))
			  return FALSE;
		  
		  //make a copy of the value pidl
		  *ppidlValue = Copy(*ppidlValue);
		  
		  //make a copy of the fully qualified PIDL
		  *ppidlKey = Copy(pidlFQ);
		  
		  //truncate the last item of the key PIDL
		  LPITEMIDLIST   pidlTemp = GetLastItem(*ppidlKey);
		  pidlTemp->mkid.cb = 0;
		  pidlTemp->mkid.abID[0] = 0;
		  
		  return TRUE;
	  }