You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
344 lines
12 KiB
344 lines
12 KiB
#ifndef __MRU_H_INCLUDED
|
|
#define __MRU_H_INCLUDED
|
|
|
|
#include <windows.h>
|
|
#include <shlobj.h>
|
|
#include <wiacrc32.h>
|
|
#include "simstr.h"
|
|
#include "simidlst.h"
|
|
#include "destdata.h"
|
|
|
|
#define CURRENT_REGISTRY_DATA_FORMAT_VERSION 3
|
|
|
|
class CMruStringList : public CSimpleLinkedList<CSimpleString>
|
|
{
|
|
private:
|
|
int m_nNumToWrite;
|
|
enum
|
|
{
|
|
DefaultNumToWrite=20
|
|
};
|
|
private:
|
|
CMruStringList( const CMruStringList & );
|
|
CMruStringList &operator=( const CMruStringList & );
|
|
public:
|
|
CMruStringList( int nNumToWrite=DefaultNumToWrite )
|
|
: m_nNumToWrite(nNumToWrite)
|
|
{
|
|
}
|
|
bool Read( HKEY hRoot, LPCTSTR pszKey, LPCTSTR pszValueName )
|
|
{
|
|
CSimpleReg reg( hRoot, pszKey, false, KEY_READ );
|
|
if (reg.OK())
|
|
{
|
|
if (REG_MULTI_SZ==reg.Type(pszValueName))
|
|
{
|
|
int nSize = reg.Size(pszValueName);
|
|
if (nSize)
|
|
{
|
|
PBYTE pData = new BYTE[nSize];
|
|
if (pData)
|
|
{
|
|
if (reg.QueryBin( pszValueName, pData, nSize ))
|
|
{
|
|
for (LPTSTR pszCurr=reinterpret_cast<LPTSTR>(pData);*pszCurr;pszCurr+=lstrlen(pszCurr)+1)
|
|
{
|
|
Append( pszCurr );
|
|
}
|
|
}
|
|
delete[] pData;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return(true);
|
|
}
|
|
bool Write( HKEY hRoot, LPCTSTR pszKey, LPCTSTR pszValueName )
|
|
{
|
|
CSimpleReg reg( hRoot, pszKey, true, KEY_WRITE );
|
|
if (reg.OK())
|
|
{
|
|
int nLengthInChars = 0, nCount;
|
|
Iterator i;
|
|
for (i=Begin(),nCount=0;i != End() && nCount < m_nNumToWrite;++i,++nCount)
|
|
nLengthInChars += (*i).Length() + 1;
|
|
if (nLengthInChars)
|
|
{
|
|
++nLengthInChars;
|
|
LPTSTR pszMultiStr = new TCHAR[nLengthInChars];
|
|
if (pszMultiStr)
|
|
{
|
|
LPTSTR pszCurr = pszMultiStr;
|
|
for (i = Begin(), nCount=0;i != End() && nCount < m_nNumToWrite;++i,++nCount)
|
|
{
|
|
lstrcpy(pszCurr,(*i).String());
|
|
pszCurr += (*i).Length() + 1;
|
|
}
|
|
*pszCurr = TEXT('\0');
|
|
reg.SetBin( pszValueName, reinterpret_cast<PBYTE>(pszMultiStr), nLengthInChars*sizeof(TCHAR), REG_MULTI_SZ );
|
|
delete[] pszMultiStr;
|
|
}
|
|
}
|
|
}
|
|
return(true);
|
|
}
|
|
void Add( CSimpleString str )
|
|
{
|
|
if (str.Length())
|
|
{
|
|
Remove(str);
|
|
Prepend(str);
|
|
}
|
|
}
|
|
void PopulateComboBox( HWND hWnd )
|
|
{
|
|
SendMessage( hWnd, CB_RESETCONTENT, 0, 0 );
|
|
for (Iterator i = Begin();i != End();++i)
|
|
{
|
|
SendMessage( hWnd, CB_ADDSTRING, 0, (LPARAM)((*i).String()));
|
|
}
|
|
}
|
|
};
|
|
|
|
|
|
class CMruDestinationData : public CSimpleLinkedList<CDestinationData>
|
|
{
|
|
private:
|
|
int m_nNumToWrite;
|
|
enum
|
|
{
|
|
DefaultNumToWrite=20
|
|
};
|
|
struct REGISTRY_SIGNATURE
|
|
{
|
|
DWORD dwSize;
|
|
DWORD dwVersion;
|
|
DWORD dwCount;
|
|
DWORD dwCrc;
|
|
};
|
|
private:
|
|
CMruDestinationData( const CMruDestinationData & );
|
|
CMruDestinationData &operator=( const CMruDestinationData & );
|
|
public:
|
|
CMruDestinationData( int nNumToWrite=DefaultNumToWrite )
|
|
: m_nNumToWrite(nNumToWrite)
|
|
{
|
|
}
|
|
bool Read( HKEY hRoot, LPCTSTR pszKey, LPCTSTR pszValueName )
|
|
{
|
|
//
|
|
// Open the registry
|
|
//
|
|
CSimpleReg reg( hRoot, pszKey, false, KEY_READ );
|
|
if (reg.OK())
|
|
{
|
|
//
|
|
// Make sure the type is correct
|
|
//
|
|
if (REG_BINARY==reg.Type(pszValueName))
|
|
{
|
|
//
|
|
// Get the size and make sure it is at least as large as the signature structure
|
|
//
|
|
DWORD nSize = reg.Size(pszValueName);
|
|
if (nSize >= sizeof(REGISTRY_SIGNATURE))
|
|
{
|
|
//
|
|
// Allocate a block to hold the data
|
|
//
|
|
PBYTE pData = new BYTE[nSize];
|
|
if (pData)
|
|
{
|
|
//
|
|
// Get the data
|
|
//
|
|
if (reg.QueryBin( pszValueName, pData, nSize ))
|
|
{
|
|
//
|
|
// Copy the blob to a registry signature structure
|
|
//
|
|
REGISTRY_SIGNATURE RegistrySignature = {0};
|
|
CopyMemory( &RegistrySignature, pData, sizeof(REGISTRY_SIGNATURE) );
|
|
|
|
//
|
|
// Make sure the version and struct size are correct, and the count is non-zero. Just ignore it if it isn't.
|
|
//
|
|
if (RegistrySignature.dwSize == sizeof(REGISTRY_SIGNATURE) && RegistrySignature.dwVersion == CURRENT_REGISTRY_DATA_FORMAT_VERSION && RegistrySignature.dwCount)
|
|
{
|
|
//
|
|
// Raw data starts at the end of the structure
|
|
//
|
|
PBYTE pCurr = pData + sizeof(REGISTRY_SIGNATURE);
|
|
|
|
//
|
|
// Get the CRC for this blob and make sure it matches
|
|
//
|
|
DWORD dwCrc = WiaCrc32::GenerateCrc32( nSize - sizeof(REGISTRY_SIGNATURE), pCurr );
|
|
if (dwCrc == RegistrySignature.dwCrc)
|
|
{
|
|
//
|
|
// Loop through all of the entries
|
|
//
|
|
for (int i=0;i<static_cast<int>(RegistrySignature.dwCount);i++)
|
|
{
|
|
//
|
|
// Copy the item size
|
|
//
|
|
DWORD dwItemSize = 0;
|
|
CopyMemory( &dwItemSize, pCurr, sizeof(DWORD) );
|
|
|
|
//
|
|
// Increment the current pointer beyond the size
|
|
//
|
|
pCurr += sizeof(DWORD);
|
|
|
|
//
|
|
// Make sure the item size is non-zero
|
|
//
|
|
if (dwItemSize)
|
|
{
|
|
//
|
|
// Create a CDestinationData with this blob
|
|
//
|
|
CDestinationData DestinationData;
|
|
DestinationData.SetRegistryData(pCurr,dwItemSize);
|
|
|
|
//
|
|
// Add it to the list
|
|
//
|
|
Append( DestinationData );
|
|
}
|
|
|
|
//
|
|
// Increment the current pointer to the end of the blob
|
|
//
|
|
pCurr += dwItemSize;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Delete the registry data blob
|
|
//
|
|
delete[] pData;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
bool Write( HKEY hRoot, LPCTSTR pszKey, LPCTSTR pszValueName )
|
|
{
|
|
CSimpleReg reg( hRoot, pszKey, true, KEY_WRITE );
|
|
if (reg.OK())
|
|
{
|
|
//
|
|
// Find the size needed for the data. Initialize to the size of the registry signature struct.
|
|
//
|
|
DWORD nLengthInBytes = sizeof(REGISTRY_SIGNATURE);
|
|
DWORD dwCount=0;
|
|
|
|
//
|
|
// Loop through each item and add up the number of bytes required to store it as a blob
|
|
//
|
|
Iterator ListIter=Begin();
|
|
while (ListIter != End() && dwCount < static_cast<DWORD>(m_nNumToWrite))
|
|
{
|
|
nLengthInBytes += (*ListIter).RegistryDataSize() + sizeof(DWORD);
|
|
++dwCount;
|
|
++ListIter;
|
|
}
|
|
|
|
//
|
|
// Allocate some memory to hold the blob
|
|
//
|
|
PBYTE pItems = new BYTE[nLengthInBytes];
|
|
if (pItems)
|
|
{
|
|
//
|
|
// Start at the end of the registry signature struct
|
|
//
|
|
PBYTE pCurr = pItems + sizeof(REGISTRY_SIGNATURE);
|
|
|
|
//
|
|
// Initialize the length remaining to the total length minus the size of the registry signature struct
|
|
//
|
|
DWORD nLengthRemaining = nLengthInBytes - sizeof(REGISTRY_SIGNATURE);
|
|
|
|
//
|
|
// Loop through the list, stopping when we get to the max number of items to write
|
|
//
|
|
ListIter=Begin();
|
|
DWORD dwCurr = 0;
|
|
while (ListIter != End() && dwCurr < dwCount)
|
|
{
|
|
//
|
|
// Get the size of this blob
|
|
//
|
|
DWORD dwSize = (*ListIter).RegistryDataSize();
|
|
if (dwSize)
|
|
{
|
|
//
|
|
// Copy the size to our buffer, and increment the current pointer
|
|
//
|
|
CopyMemory( pCurr, &dwSize, sizeof(DWORD) );
|
|
pCurr += sizeof(DWORD);
|
|
|
|
//
|
|
// Get the blob for this item
|
|
//
|
|
(*ListIter).GetRegistryData( pCurr, nLengthRemaining );
|
|
|
|
//
|
|
// Increment the current pointer
|
|
//
|
|
pCurr += (*ListIter).RegistryDataSize();
|
|
}
|
|
|
|
++dwCurr;
|
|
++ListIter;
|
|
}
|
|
|
|
//
|
|
// Initialize the registry signature struct
|
|
//
|
|
REGISTRY_SIGNATURE RegistrySignature = {0};
|
|
RegistrySignature.dwSize = sizeof(REGISTRY_SIGNATURE);
|
|
RegistrySignature.dwVersion = CURRENT_REGISTRY_DATA_FORMAT_VERSION;
|
|
RegistrySignature.dwCount = dwCount;
|
|
RegistrySignature.dwCrc = WiaCrc32::GenerateCrc32( nLengthInBytes - sizeof(REGISTRY_SIGNATURE), pItems + sizeof(REGISTRY_SIGNATURE) );
|
|
|
|
//
|
|
// Copy the registry signature struct to the buffer
|
|
//
|
|
CopyMemory( pItems, &RegistrySignature, sizeof(REGISTRY_SIGNATURE) );
|
|
|
|
//
|
|
// Save the data to the registry
|
|
//
|
|
reg.SetBin( pszValueName, pItems, nLengthInBytes, REG_BINARY );
|
|
|
|
//
|
|
// Free the temp buffer
|
|
//
|
|
delete[] pItems;
|
|
}
|
|
}
|
|
return(true);
|
|
}
|
|
Iterator Add( CDestinationData item )
|
|
{
|
|
if (item.IsValid())
|
|
{
|
|
Remove(item);
|
|
return Prepend(item);
|
|
}
|
|
return End();
|
|
}
|
|
};
|
|
|
|
|
|
#endif //__MRU_H_INCLUDED
|
|
|