regmani.cpp

wince5.0 pb中pccard源码

                                    pKeyInfo->dwSize[uItemVa]);

        if(bRet == FALSE){
            NKMSG(_T("Can not set value item %s"), pKeyInfo->szValName[uItemVa]);
            RegCloseKey(hCurKey);
            return FALSE;
        }

        uItemVa ++;
        uBits = uBits >> 1;
    }

    RegCloseKey(hCurKey);

    return TRUE;
}

//---------------------------------------------------------------------------------------
//copy to a key in regsitry to another key
//---------------------------------------------------------------------------------------
BOOL 
CRegManipulate::CopyAKey(LPCTSTR szDestPath, LPCTSTR szSrcPath){
    if((szDestPath == NULL) || (szSrcPath == NULL))
        return FALSE;

    LPTSTR  szDestSubPath = NULL, szSrcSubPath = NULL;
    HKEY     hSrcKey= NULL;
    PREG_KEY_INFO pKeyInfo = NULL;

    //allocate mem for structures
    szDestSubPath = new TCHAR[REG_STRING_LENGTH];
    szSrcSubPath = new TCHAR[REG_STRING_LENGTH];
    if(szDestSubPath == NULL || szSrcSubPath == NULL){
        NKMSG(_T("Out of memory"));
        goto CLEANUP;	
    }
    pKeyInfo = new REG_KEY_INFO;
    if(pKeyInfo == NULL){
        NKMSG(_T("Out of memory"));
        goto CLEANUP;	
    }
    memset(pKeyInfo, 0, sizeof(REG_KEY_INFO));
	
    //open source key
    if(OpenKey(szSrcPath, &hSrcKey) == FALSE){
        NKMSG(_T("Can not open key %s!"), szSrcPath);
        return FALSE;
    }
	
    //enum subkeys
    DWORD   dwIndex = 0;
    LONG      lRet = ERROR_SUCCESS;
    TCHAR    szSubKeyName[REG_STRING_LENGTH];
    DWORD   cbKeyNameLen;

    //copy sub keys	
    while(lRet == ERROR_SUCCESS){
        cbKeyNameLen = REG_STRING_LENGTH;
        lRet = RegEnumKeyEx(hSrcKey, dwIndex,szSubKeyName, &cbKeyNameLen, NULL, NULL, NULL, NULL);
        if(lRet == ERROR_SUCCESS){
            //create subkey destination path
            wcscpy(szDestSubPath, szDestPath);
            wcscat(szDestSubPath, _T("\\"));
            wcscat(szDestSubPath, szSubKeyName);
            //create subkey source path
            wcscpy(szSrcSubPath, szSrcPath);
            wcscat(szSrcSubPath, _T("\\"));
            wcscat(szSrcSubPath, szSubKeyName);

            if(CopyAKey(szDestSubPath, szSrcSubPath) == FALSE){
                NKMSG(_T("Copy key from %s to %s failed!"), szSrcSubPath, szDestSubPath);
                RegCloseKey(hSrcKey);
                goto CLEANUP;
            }
            dwIndex ++;
        }
    }
    RegCloseKey(hSrcKey);

    //copy values
    wcscpy(pKeyInfo->szRegPath, szSrcPath);
    if(GetAKey(pKeyInfo) == FALSE){
    	NKMSG(_T("Can not retrieve values from %s"), szSrcPath);
    	goto CLEANUP;
    }

    wcscpy(pKeyInfo->szRegPath, szDestPath);
    if(SetAKey(pKeyInfo, FALSE) == FALSE){
    	NKMSG(_T("Can not set values to %s"), szDestPath);
    	goto CLEANUP;
    }

    delete[] szSrcSubPath;
    delete[] szDestSubPath;
    delete pKeyInfo;
    return TRUE;

CLEANUP:

    //sth. wrong, delete possible already-created destination key
    if(OpenKey(szDestPath, &hSrcKey) == TRUE){//destination key does exist
        RegCloseKey(hSrcKey);
        RegDeleteKey(m_hMainKey, szDestPath);
    }

    if(szSrcSubPath != NULL)
        delete[] szSrcSubPath;
    if(szDestSubPath != NULL)
        delete[] szDestSubPath;
    if(pKeyInfo != NULL)
        delete pKeyInfo;
    return FALSE;
	
}

//---------------------------------------------------------------------------------------
//delete a key
//---------------------------------------------------------------------------------------
BOOL 
CRegManipulate::DeleteAKey(LPCTSTR szPath){
    if(RegDeleteKey(m_hMainKey, szPath) != ERROR_SUCCESS)
        return FALSE;

    return TRUE;
}

//---------------------------------------------------------------------------------------
//modify a value item in the data structure
//---------------------------------------------------------------------------------------
BOOL 
CRegManipulate::ModifyKeyValue(PREG_KEY_INFO pKeyInfo, DWORD dwIndex, DWORD dwType, DWORD dwSize, U_ITEM u){

    if(pKeyInfo == NULL || dwIndex < 0 || dwIndex >= REG_ITEM_NUM)
        return FALSE;

    if(dwType == REG_SZ || dwType == REG_BINARY)
        pKeyInfo->dwSize[dwIndex] = dwSize;

    pKeyInfo->dwType[dwIndex] = dwType;
    memcpy((PBYTE)&(pKeyInfo->u[dwIndex]), (PBYTE)&u, sizeof(U_ITEM));
	
    return TRUE;
}

//---------------------------------------------------------------------------------------
//add a value item to the data structure
//---------------------------------------------------------------------------------------
BOOL 
CRegManipulate::AddKeyValue(PREG_KEY_INFO pKeyInfo,  LPCTSTR szValName, DWORD dwType, DWORD dwSize, U_ITEM u){

    if(pKeyInfo == NULL)
        return FALSE;

    DWORD 	dwIndex;
    UINT	uBitMap = pKeyInfo->uBitmap;


    if(pKeyInfo->uItems >=  REG_ITEM_NUM){
        NKMSG(_T("Can not add any more items!"));
        return FALSE;
    }

    if(wcslen(szValName) > REG_STRING_LENGTH){
        NKMSG(_T("Value name too long!"));
        return FALSE;
    }

    //find the first empty entry
    dwIndex = 0;
    while((uBitMap & 1)){
        uBitMap = uBitMap >> 1;
        dwIndex ++;
    }

    //make this entry valid
    pKeyInfo->uBitmap |= (1<<dwIndex);

    //copy the name
    wcscpy(pKeyInfo->szValName[dwIndex], szValName);

    //set type
    if(dwType == REG_SZ || dwType == REG_BINARY)
        pKeyInfo->dwSize[dwIndex] = dwSize;

    //copy item value
    pKeyInfo->dwType[dwIndex] = dwType;
    memcpy((PBYTE)&(pKeyInfo->u[dwIndex]),(PBYTE)&u, sizeof(U_ITEM));

    //increase item
    pKeyInfo->uItems ++;

    return TRUE;
}

//---------------------------------------------------------------------------------------
//delete a value item in the data structure
//---------------------------------------------------------------------------------------
BOOL 
CRegManipulate::DeleteKeyValue(PREG_KEY_INFO pKeyInfo, DWORD dwIndex){

    if(pKeyInfo == NULL || dwIndex < 0 || dwIndex >= REG_ITEM_NUM)
        return FALSE;

    pKeyInfo->uItems --;

    //invalid this entry
    UINT mask = (~0) ^ (1<<dwIndex);
    pKeyInfo->uBitmap &= mask;
    	
    return TRUE;
}

//---------------------------------------------------------------------------------------
//find a value item to the data structure according to the value name
//---------------------------------------------------------------------------------------
DWORD
CRegManipulate::FindKeyValue(PREG_KEY_INFO pKeyInfo, LPCTSTR szValName){

    if(pKeyInfo == NULL)
        return (DWORD)-1;

    DWORD dwIndex = 0;
    UINT	uMask, i;

    uMask = pKeyInfo->uBitmap;
    for(i = 0; i < pKeyInfo->uItems; i ++){
        while(!(uMask & 1)){
            uMask = uMask >> 1;
            dwIndex ++;
            if(dwIndex >= REG_ITEM_NUM){
            	NKMSG(_T("Bit map is not correct!"));
            	return (DWORD)-1;
            }
        }

        if(!wcscmp(pKeyInfo->szValName[dwIndex], szValName))//find it
        	break;
        uMask = uMask >> 1;
        dwIndex ++;
    }

    //not found
    if(i == (UINT)(pKeyInfo->uItems))
        return (DWORD)-1;
        
    return dwIndex;

}

//---------------------------------------------------------------------------------------
//set a dword type item to registry
//---------------------------------------------------------------------------------------
BOOL 
CRegManipulate::SetSingleVal(HKEY hKey, LPCTSTR szValName, DWORD dwData){

    if(hKey == NULL || szValName == NULL)
        return FALSE;

    DWORD   dwTemp = dwData;

    if(RegSetValueEx(hKey, szValName, 0, REG_DWORD, (PBYTE)&dwTemp, sizeof(DWORD)) != ERROR_SUCCESS)
        return FALSE;

    return TRUE;
}

//---------------------------------------------------------------------------------------
//convert dword list to multi_sz and add the item to registry
//---------------------------------------------------------------------------------------
BOOL 
CRegManipulate::SetValList(HKEY hKey, LPCTSTR szValName, DWORD dwNum, PDWORD dwDataList){

    if(hKey == NULL || szValName == NULL ||dwNum > REG_MULTIPLE_DATA_NUM || dwNum < 2 || dwDataList == NULL)
        return FALSE;


    WCHAR   ValList[2*REG_STRING_LENGTH];
    DWORD   dwSubSize = 0, dwTotalSize = 0;
    WCHAR   SubItem[11];
    PWCHAR  pw = ValList;

    //conver each dword value
    for(DWORD i = 0; i < dwNum; i++){
        _ultow(dwDataList[i], SubItem, 16);
        dwSubSize = wcslen(SubItem) + 1;
        if((dwTotalSize + dwSubSize + 1) > 2*REG_STRING_LENGTH){
            NKMSG(_T("DWORD list too long!"));
            return FALSE;
        }

        wcscpy(pw, SubItem);
        pw += dwSubSize;
        dwTotalSize += dwSubSize;
    }

    *pw = (WCHAR)'\0';
    dwTotalSize ++;

    if(RegSetValueEx(hKey, szValName, 0, REG_MULTI_SZ, (PBYTE)ValList, dwTotalSize * sizeof(WCHAR)) != ERROR_SUCCESS)
        return FALSE;

    return TRUE;
	
}