regview.h

windows ce5.0 注册表文件的读取

//======================================================================
// Header file
//
// Written for the book Programming Windows CE
// Copyright (C) 1998 Douglas Boling
//
//======================================================================
// Returns number of elements
#define dim(x) (sizeof(x) / sizeof(x[0]))   

//----------------------------------------------------------------------
// Generic defines and data types
//
struct decodeUINT {                             // Structure associates
    UINT Code;                                  // messages 
                                                // with a function.
    LRESULT (*Fxn)(HWND, UINT, WPARAM, LPARAM);
}; 
struct decodeCMD {                              // Structure associates
    UINT Code;                                  // control IDs with a 
    LRESULT (*Fxn)(HWND, WORD, HWND, WORD);     // function.
};
struct decodeNotify {                           // Structure associates
    UINT Code;                                  // control IDs with a 
    LRESULT (*Fxn)(HWND, WORD, HWND, LPNMHDR);  // notify handler.
};

//----------------------------------------------------------------------
// Generic defines used by application
#define  ID_ICON             1                  // App icon resource ID
#define  ID_BMPS             2                  // Bitmap resource ID

#define  IDC_CMDBAR          10                 // Command band ID
#define  ID_MENU             11                 // Main menu resource ID
#define  ID_TREEV            12                 // Tree view control ID
#define  ID_LISTV            13                 // List view control ID

// Menu item IDs
#define  IDM_EXIT            101                // File menu
#define IDM_EXPORT			 102
#define IDM_IMPORT			 103		
#define IDM_DELKEY			 104

#define  IDM_ABOUT           150                // Help menu

//----------------------------------------------------------------------
// Function prototypes
//
int InitApp (HINSTANCE);
HWND InitInstance (HINSTANCE, LPWSTR, int);
int TermInstance (HINSTANCE, int);

INT EnumChildren (HWND, HTREEITEM, HKEY, LPTSTR);
DWORD CountChildren (HKEY, LPTSTR, LPTSTR);
INT EnumValues (HWND, HKEY, LPTSTR);
INT DisplayValue (HWND, INT, LPTSTR, PBYTE, DWORD, DWORD);
INT GetTree (HWND, HTREEITEM, HKEY *, TCHAR *, INT);
HTREEITEM InsertTV (HWND, HTREEITEM, TCHAR *, LPARAM, DWORD);
INT InsertLV (HWND, INT, LPTSTR, LPTSTR);
HWND CreateLV (HWND, RECT *);
HWND CreateTV (HWND, RECT *);

// Window procedures
LRESULT CALLBACK MainWndProc (HWND, UINT, WPARAM, LPARAM);

// Message handlers
LRESULT DoCreateMain (HWND, UINT, WPARAM, LPARAM);
LRESULT DoSizeMain (HWND, UINT, WPARAM, LPARAM);
LRESULT DoNotifyMain (HWND, UINT, WPARAM, LPARAM);
LRESULT DoCommandMain (HWND, UINT, WPARAM, LPARAM);
LRESULT DoDestroyMain (HWND, UINT, WPARAM, LPARAM);

// Command functions
LPARAM DoMainCommandExit (HWND, WORD, HWND, WORD);
LPARAM DoMainCommandAbout (HWND, WORD, HWND, WORD);
LPARAM DoMainCommandExport (HWND, WORD, HWND, WORD);
LPARAM DoMainCommandImport (HWND, WORD, HWND, WORD);
LPARAM DoMainCommandDel (HWND, WORD, HWND, WORD);


// Notify functions
LPARAM DoMainNotifyListV (HWND, WORD, HWND, LPNMHDR);
LPARAM DoMainNotifyTreeV (HWND, WORD, HWND, LPNMHDR);

// Dialog procedures
BOOL CALLBACK AboutDlgProc (HWND, UINT, WPARAM, LPARAM);

#define REGITEMNAME_SIZE_MAX	100
#define REGKEYNAME_SIZE_MAX	    100
#define SZLENGTH_MAX		    2000
#define KEYBLOCK_SIZE_MAX		2000
#define KEYBLOCK_NUM_MAX		1000
#define CE_STEP					1
#define NT_STEP					2

void BDataToSZ(PBYTE pbData,DWORD dwDSize, DWORD dwType,LPTSTR szData);
void SZToBData(LPTSTR szData,DWORD dwType,PBYTE &pbData,DWORD &dwDSize);

typedef struct _RegItem 
{
	TCHAR szName[REGITEMNAME_SIZE_MAX];
	DWORD wItemType;
	TCHAR szValue[SZLENGTH_MAX];
	_RegItem *next;
	void Init()
	{
		lstrcpy(szName,TEXT(""));
		lstrcpy(szValue,TEXT(""));
		wItemType=REG_SZ;
		next=NULL;
	}
	void ToSting(LPTSTR szOut)
	{
			TCHAR szPrefix[10]=TEXT("");
			TCHAR szSuffix[10]=TEXT("");
			TCHAR szItem[SZLENGTH_MAX]=TEXT("");
			switch(wItemType)
			{
			case REG_EXPAND_SZ:
			case REG_SZ:
				lstrcpy(szPrefix,TEXT("\""));
				lstrcpy(szSuffix,TEXT("\""));
				break;
			case REG_MULTI_SZ:
				lstrcpy(szPrefix,TEXT("hex(7):"));
				break;
			case REG_BINARY:
				lstrcpy(szPrefix,TEXT("hex:"));
				break;
			case REG_DWORD:
				lstrcpy(szPrefix,TEXT("dword:"));
				break;
			default:
				lstrcpy(szPrefix,TEXT(""));
				break;
			}
			wsprintf(szItem,TEXT("\"%s\"=%s%s%s\n"),szName,szPrefix,szValue,szSuffix);
			lstrcat(szOut,szItem);
	}
}RegItem,*PRegItem;

typedef struct _RegKey 
{
	TCHAR szName[REGKEYNAME_SIZE_MAX];
	RegItem *pItemListHead;
	_RegKey *pChildListHead;
	_RegKey *next;

	void Init(LPTSTR szKeyName)
	{
		lstrcpy(szName,szKeyName);
		pItemListHead=NULL;
		pChildListHead=NULL;
	}

	void Init()
	{
		lstrcpy(szName,TEXT(""));
		pItemListHead=NULL;
		pChildListHead=NULL;
	}

	void AddItem(LPTSTR szItemName,LPTSTR szItemValue,DWORD wItemType)
	{
		PRegItem pRegItem;
		pRegItem=(RegItem *)malloc(sizeof(RegItem));
		lstrcpy(pRegItem->szName,szItemName);
		pRegItem->wItemType=wItemType;
		lstrcpy(pRegItem->szValue,szItemValue);

		if (pItemListHead==NULL)
			pRegItem->next=NULL;
		else
			pRegItem->next=pItemListHead;

		pItemListHead=pRegItem;	
	}

	void AddChild(_RegKey regKey)
	{
		_RegKey *pNewKey;
		pNewKey=(_RegKey *)malloc(sizeof(_RegKey));
		(*pNewKey)=regKey;
		//memcpy(pNewKey,&regKey,sizeof(regKey));
		if (pChildListHead==NULL)
			pNewKey->next=NULL;
		else
			pNewKey->next=pChildListHead;

		pChildListHead=pNewKey;	
	}

	void ToString(LPTSTR szOut)
	{
		//_RegKey *child;
		RegItem *item;
		
	
		//键名
		wsprintf(szOut,TEXT("%s\n\n[%s]\n"),szOut,szName);


		//值
		//lstrcat(szOut,TEXT("Items:"));
		item=pItemListHead;	
		while (item!=NULL)
		{
			TCHAR szItem[SZLENGTH_MAX]=TEXT("");
			item->ToSting(szItem);
			lstrcat(szOut,szItem);
			item=item->next;
		}

		/*
		//子键（项）
		//lstrcat(szOut,TEXT("Children:"));
		child=pChildListHead;
		while (child!=NULL)
		{
			child->ToString(szOut);
			child=child->next;
		}
		*/
	}

	void FromString(LPTSTR szIn)
	{
		
	}
	HKEY GetRoot()
	{
		HKEY hRoot=HKEY_LOCAL_MACHINE;
		TCHAR *pPos;
		TCHAR szNameCopy[REGKEYNAME_SIZE_MAX]=TEXT("");
		lstrcpy(szNameCopy,szName);
		pPos=wcschr(szNameCopy,(TCHAR)'\\');
		(*pPos)=0;
	
		if (lstrcmp(szNameCopy,TEXT("HKEY_CLASSES_ROOT"))==0)
		{
			hRoot=HKEY_CLASSES_ROOT;
		}
		else if (lstrcmp(szNameCopy,TEXT("HKEY_CURRENT_USER"))==0)
		{
			hRoot=HKEY_CURRENT_USER;
		}
		else if (lstrcmp(szNameCopy,TEXT("HKEY_LOCAL_MACHINE"))==0)
		{
			hRoot=HKEY_LOCAL_MACHINE;
		}
		else if (lstrcmp(szNameCopy,TEXT("HKEY_USERS"))==0)
		{
			hRoot=HKEY_USERS;
		}
		return hRoot;
	}

	void GetSubKey(LPTSTR szSubKeyName)
	{
		TCHAR *pPos;
		TCHAR szNameCopy[REGKEYNAME_SIZE_MAX]=TEXT("");
		lstrcpy(szNameCopy,szName);
		pPos=wcschr(szNameCopy,(TCHAR)'\\');
		lstrcpy(szSubKeyName,pPos);
	}

	void WriteToReg()
	{
		HKEY hkey;
		
		TCHAR szSubKeyName[REGKEYNAME_SIZE_MAX]=TEXT("");
		GetSubKey(szSubKeyName);
		
		if(ERROR_SUCCESS!=RegCreateKeyEx(GetRoot(),szSubKeyName,0,NULL,0,NULL,NULL,&hkey,NULL))
			return;

		RegItem *pRegItem;
		pRegItem=pItemListHead;
		while (pRegItem!=NULL)
		{	
			BYTE *bData;
			DWORD cbData=0;
			SZToBData(pRegItem->szValue,pRegItem->wItemType,bData,cbData);
			RegSetValueEx(hkey,pRegItem->szName,0,pRegItem->wItemType,bData,cbData);
			pRegItem=pRegItem->next;
		}

		RegCloseKey(hkey);
	}
	void free()
	{
		RegItem *pRegItem;
		RegKey *pChild;
		RegKey *pNext;

		pRegItem=pItemListHead;
		while (pRegItem!=NULL)
		{	
			::free(pRegItem);
			pRegItem=pRegItem->next;
		}

		pChild=pChildListHead;
		while (pChild!=NULL)
		{
			pNext=pChild->next;
			pChild->free();
			pChild=pNext;
		}
	}
}RegKey,*PRegKey;

LRESULT Export(HKEY hRoot,LPTSTR pszKey);
void Export(HKEY hRoot,LPTSTR pszKey,HANDLE hFile);

LRESULT Import();
LRESULT Import(LPTSTR szFilename);

void ProcessKeyBlock(LPTSTR pKeyBlock,RegKey *regKey);
void ProcessItemLine(LPTSTR pItemLine,RegItem &regItem);
void ProcessItemName(LPTSTR pItemname);
void ProcessItemValue(LPTSTR pItemValue,LPTSTR pRealValue,DWORD &wType);
void ProcessItemRealValue(LPTSTR pRealValue);

LRESULT GetValues (HKEY hRoot,LPTSTR pszKey,PRegKey pRegKey);
LRESULT GetChildren (HKEY hRoot,LPTSTR pszKey,PRegKey pRegKey,BOOL boolJustname);


void GetFullPath(HKEY hRoot,LPTSTR szKey,LPTSTR szFullpath);
void HRootToSZ(HKEY hRoot,LPTSTR szRoot);

INT GetFileName (HWND hWnd, LPTSTR szFileName, INT nMax);
DWORD ReadBlock(HANDLE hFile,DWORD iStartPos,TCHAR sep,LPTSTR szBlock,BOOL boolSepStart);