BOOL My_RegQueryInfoKeyW()
{
HKEY hKey=NULL;
LPWSTR lpClass=NULL;
LPDWORD lpcbClass=NULL;
LPDWORD lpReserved=NULL;
LPDWORD lpcSubKeys=NULL;
LPDWORD lpcbMaxSubKeyLen=NULL;
LPDWORD lpcbMaxClassLen=NULL;
LPDWORD lpcValues=NULL;
LPDWORD lpcbMaxValueNameLen=NULL;
LPDWORD lpcbMaxValueLen=NULL;
LPDWORD lpcbSecurityDescriptor=NULL;
PFILETIME lpftLastWriteTime=NULL;
LONG returnVal_Real = NULL;
LONG returnVal_Intercepted = NULL;
DWORD error_Real = 0;
DWORD error_Intercepted = 0;
disableInterception();
returnVal_Real = RegQueryInfoKeyW (hKey,lpClass,lpcbClass,lpReserved,lpcSubKeys,lpcbMaxSubKeyLen,lpcbMaxClassLen,lpcValues,lpcbMaxValueNameLen,lpcbMaxValueLen,lpcbSecurityDescriptor,lpftLastWriteTime);
error_Real = GetLastError();
enableInterception();
returnVal_Intercepted = RegQueryInfoKeyW (hKey,lpClass,lpcbClass,lpReserved,lpcSubKeys,lpcbMaxSubKeyLen,lpcbMaxClassLen,lpcValues,lpcbMaxValueNameLen,lpcbMaxValueLen,lpcbSecurityDescriptor,lpftLastWriteTime);
error_Intercepted = GetLastError();
return ((returnVal_Real == returnVal_Intercepted) && (error_Real == error_Intercepted));
}
// RegEnumKeyEx
// returns ERROR_NO_MORE_ITEMS or ERROR_SUCCESS
// if maxNameSize == 0, then we will compute it for you. Use it between calls on the same key for performance
inline LONG RegEnumKeyExX(HKEY hKey, DWORD dwIndex, std::wstring& outName, DWORD& maxNameSize)
{
FILETIME temp;
LONG ret;
std::vector<wchar_t> buf;
DWORD size;
outName.clear();
// get maximum subkey name length.
if(!maxNameSize)
{
if(ERROR_SUCCESS != (ret = RegQueryInfoKeyW(hKey, 0, 0, 0, 0, &maxNameSize, 0, 0, 0, 0, 0, 0)))
{
return ret;
}
maxNameSize += 2;// for safety
}
buf.resize(maxNameSize);
// make the call
size = static_cast<DWORD>(buf.size());
ret = RegEnumKeyExW(hKey, dwIndex, buf.data(), &size, 0, 0, 0, &temp);
if(ret == ERROR_SUCCESS)
{
outName = buf.data();
}
return ret;
}
static
BOOL
GetProfileCount(LPDWORD lpProfileCount)
{
HKEY hKey;
LONG lError;
*lpProfileCount = 0;
lError = RegOpenKeyExW(HKEY_LOCAL_MACHINE,
L"System\\CurrentControlSet\\Control\\IDConfigDB\\Hardware Profiles",
0,
KEY_READ,
&hKey);
if (lError != ERROR_SUCCESS)
return FALSE;
lError = RegQueryInfoKeyW(hKey, NULL, NULL, NULL, lpProfileCount,
NULL, NULL, NULL, NULL, NULL, NULL, NULL);
RegCloseKey(hKey);
if (lError != ERROR_SUCCESS)
return FALSE;
return TRUE;
}
LONG CRegistryKey::GetValueCount(DWORD& rdwValueCount)
{
if (!m_hKey)
return 0; // the root key abstraction has only subkeys (hives)
return RegQueryInfoKeyW(m_hKey,NULL,NULL,NULL,NULL,NULL,NULL,&rdwValueCount,NULL,NULL,NULL,NULL);
}
static void initialize_disabled_joysticks_list(HWND hwnd)
{
static const WCHAR disabled_str[] = {'d','i','s','a','b','l','e','d','\0'};
HKEY hkey, appkey;
DWORD values = 0;
HRESULT hr;
DWORD i;
SendDlgItemMessageW(hwnd, IDC_DISABLEDLIST, LB_RESETCONTENT, 0, 0);
/* Search for disabled joysticks */
get_app_key(&hkey, &appkey);
RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, &values, NULL, NULL, NULL, NULL);
for (i=0; i < values; i++)
{
DWORD name_len = MAX_PATH, data_len = MAX_PATH;
WCHAR buf_name[MAX_PATH + 9], buf_data[MAX_PATH];
hr = RegEnumValueW(hkey, i, buf_name, &name_len, NULL, NULL, (BYTE*) buf_data, &data_len);
if (SUCCEEDED(hr) && !lstrcmpW(disabled_str, buf_data))
SendDlgItemMessageW(hwnd, IDC_DISABLEDLIST, LB_ADDSTRING, 0, (LPARAM) buf_name);
}
if (hkey) RegCloseKey(hkey);
if (appkey) RegCloseKey(appkey);
}
void InitIconOverlays(void)
{
HKEY hKey;
DWORD dwIndex, dwResult, dwSize;
WCHAR szName[MAX_PATH];
WCHAR szValue[100];
CLSID clsid;
IShellIconOverlayIdentifier * Overlay;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\ShellIconOverlayIdentifiers", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
return;
if (RegQueryInfoKeyW(hKey, NULL, NULL, NULL, &dwResult, NULL, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
{
RegCloseKey(hKey);
return;
}
Handlers = (IShellIconOverlayIdentifier **)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dwResult * sizeof(IShellIconOverlayIdentifier*));
if (!Handlers)
{
RegCloseKey(hKey);
return;
}
dwIndex = 0;
CoInitialize(0);
do
{
dwSize = sizeof(szName) / sizeof(WCHAR);
dwResult = RegEnumKeyExW(hKey, dwIndex, szName, &dwSize, NULL, NULL, NULL, NULL);
if (dwResult == ERROR_NO_MORE_ITEMS)
break;
if (dwResult == ERROR_SUCCESS)
{
dwSize = sizeof(szValue) / sizeof(WCHAR);
if (RegGetValueW(hKey, szName, NULL, RRF_RT_REG_SZ, NULL, szValue, &dwSize) == ERROR_SUCCESS)
{
CLSIDFromString(szValue, &clsid);
dwResult = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER, IID_IUnknown, (LPVOID*)&Overlay);
if (dwResult == S_OK)
{
Handlers[NumIconOverlayHandlers] = Overlay;
NumIconOverlayHandlers++;
}
}
}
dwIndex++;
} while(1);
RegCloseKey(hKey);
}
/***********************************************************************
* MSACM_RegisterAllDrivers()
*/
void MSACM_RegisterAllDrivers(void)
{
static const WCHAR msacm32[] = {'m','s','a','c','m','3','2','.','d','l','l','\0'};
static const WCHAR msacmW[] = {'M','S','A','C','M','.'};
static const WCHAR drv32[] = {'d','r','i','v','e','r','s','3','2','\0'};
static const WCHAR sys[] = {'s','y','s','t','e','m','.','i','n','i','\0'};
static const WCHAR drvkey[] = {'S','o','f','t','w','a','r','e','\\',
'M','i','c','r','o','s','o','f','t','\\',
'W','i','n','d','o','w','s',' ','N','T','\\',
'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
'D','r','i','v','e','r','s','3','2','\0'};
DWORD i, cnt, bufLen, lRet, type;
WCHAR buf[2048], valname[64], *name, *s;
FILETIME lastWrite;
HKEY hKey;
/* FIXME: What if the user edits system.ini while the program is running?
* Does Windows handle that? */
if (MSACM_pFirstACMDriverID) return;
lRet = RegOpenKeyExW(HKEY_LOCAL_MACHINE, drvkey, 0, KEY_QUERY_VALUE, &hKey);
if (lRet == ERROR_SUCCESS) {
RegQueryInfoKeyW( hKey, 0, 0, 0, &cnt, 0, 0, 0, 0, 0, 0, 0);
for (i = 0; i < cnt; i++) {
bufLen = sizeof(buf) / sizeof(buf[0]);
lRet = RegEnumKeyExW(hKey, i, buf, &bufLen, 0, 0, 0, &lastWrite);
if (lRet != ERROR_SUCCESS) continue;
if (strncmpiW(buf, msacmW, sizeof(msacmW)/sizeof(msacmW[0]))) continue;
if (!(name = strchrW(buf, '='))) continue;
*name = 0;
MSACM_RegisterDriver(buf, name + 1, 0);
}
i = 0;
cnt = sizeof(valname) / sizeof(*valname);
bufLen = sizeof(buf);
while(RegEnumValueW(hKey, i, valname, &cnt, 0,
&type, (BYTE*)buf, &bufLen) == ERROR_SUCCESS){
if(!strncmpiW(valname, msacmW, sizeof(msacmW) / sizeof(*msacmW)))
MSACM_RegisterDriver(valname, buf, 0);
++i;
}
RegCloseKey( hKey );
}
if (GetPrivateProfileSectionW(drv32, buf, sizeof(buf)/sizeof(buf[0]), sys))
{
for(s = buf; *s; s += strlenW(s) + 1)
{
if (strncmpiW(s, msacmW, sizeof(msacmW)/sizeof(msacmW[0]))) continue;
if (!(name = strchrW(s, '='))) continue;
*name = 0;
MSACM_RegisterDriver(s, name + 1, 0);
*name = '=';
}
}
MSACM_ReorderDriversByPriority();
MSACM_RegisterDriver(msacm32, msacm32, 0);
}
LONG
Win32U_RegQueryInfoKey(HKEY keyName, // IN:
LPSTR className, // OUT:
LPDWORD classNameSize, // IN/OUT:
LPDWORD reserved, // IN: reserved
LPDWORD subKeysSize, // OUT:
LPDWORD maxSubKeyLen, // OUT:
LPDWORD maxClassLen, // OUT:
LPDWORD values, // OUT:
LPDWORD maxValueNameLen, // OUT:
LPDWORD maxValueLen, // OUT:
LPDWORD securityDescriptor, // OUT:
PFILETIME lpftLastWriteTime) // OUT:
{
LONG ret;
/* caller not interested in the actual data 'className' */
if (className == NULL) {
ret = RegQueryInfoKeyW(keyName, NULL, classNameSize, reserved,
subKeysSize, maxSubKeyLen, maxClassLen, values,
maxValueNameLen, maxValueLen, securityDescriptor,
lpftLastWriteTime);
} else {
// Receiving buffer for className.
utf16_t classNameW[REG_MAX_KEY_LEN] = { 0 };
DWORD classNameSizeW = ARRAYSIZE(classNameW);
ret = RegQueryInfoKeyW(keyName, classNameW, &classNameSizeW, reserved,
subKeysSize, maxSubKeyLen, maxClassLen, values,
maxValueNameLen, maxValueLen, securityDescriptor,
lpftLastWriteTime);
if (ret == ERROR_SUCCESS) {
if (!Win32UCodeSetUtf16leToUtf8(classNameW, classNameSizeW * 2,
className, classNameSize)) {
ret = ERROR_MORE_DATA;
}
}
}
return ret;
}
LONG CRegistryKey::GetMaxValueNameLength(DWORD& rdwMaxValueNameBuferSize)
{
rdwMaxValueNameBuferSize = 0;
if (!m_hKey)
return 0; // the root key abstraction has only subkeys (hives)
LONG nError = RegQueryInfoKeyW(m_hKey,NULL,NULL,NULL,NULL,NULL,NULL,NULL,&rdwMaxValueNameBuferSize,NULL,NULL,NULL);
rdwMaxValueNameBuferSize++;
return nError;
}
bool WinRegKey::QueryInfo(LPDWORD lpcSubkeys)
{
LONG lRes;
lRes = RegQueryInfoKeyW(m_hKey, NULL, 0, 0, lpcSubkeys, 0, 0, 0, 0, 0, 0, 0);
if (ERROR_SUCCESS != lRes) {
TRACE_WINREG_ERROR("RegQueryInfoKeyW()==0x%x\n", lRes);
return false;
}
return true;
} //bool QueryInfo(LPDWORD lpcSubkeys);
static HRESULT enum_values( HKEY root, const WCHAR *subkey, VARIANT *names, VARIANT *types, VARIANT *retval )
{
HKEY hkey = NULL;
HRESULT hr = S_OK;
BSTR *value_names = NULL;
DWORD count, buflen, len, *value_types = NULL;
LONG res, i = 0;
WCHAR *buf = NULL;
TRACE("%p, %s\n", root, debugstr_w(subkey));
if ((res = RegOpenKeyExW( root, subkey, 0, KEY_QUERY_VALUE, &hkey ))) goto done;
if ((res = RegQueryInfoKeyW( hkey, NULL, NULL, NULL, NULL, NULL, NULL, &count, &buflen, NULL, NULL, NULL )))
goto done;
hr = E_OUTOFMEMORY;
if (!(buf = heap_alloc( (buflen + 1) * sizeof(WCHAR) ))) goto done;
if (!(value_names = heap_alloc( count * sizeof(BSTR) ))) goto done;
if (!(value_types = heap_alloc( count * sizeof(DWORD) ))) goto done;
hr = S_OK;
for (;;)
{
len = buflen + 1;
res = RegEnumValueW( hkey, i, buf, &len, NULL, &value_types[i], NULL, NULL );
if (res == ERROR_NO_MORE_ITEMS)
{
if (i) res = ERROR_SUCCESS;
break;
}
if (res) break;
if (!(value_names[i] = SysAllocString( buf )))
{
for (i--; i >= 0; i--) SysFreeString( value_names[i] );
hr = ERROR_OUTOFMEMORY;
break;
}
i++;
}
if (hr == S_OK && !res)
{
hr = to_bstr_array( value_names, i, names );
if (hr == S_OK) hr = to_i4_array( value_types, i, types );
}
done:
set_variant( VT_UI4, res, NULL, retval );
RegCloseKey( hkey );
heap_free( value_names );
heap_free( value_types );
heap_free( buf );
return hr;
}
LONG CRegistryKey::GetLastWriteTime(SYSTEMTIME &st)
{
FILETIME ftLocal,ft;
LONG nError = RegQueryInfoKeyW(m_hKey,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,&ft);
if (nError == ERROR_SUCCESS)
{
FileTimeToLocalFileTime(&ft,&ftLocal);
FileTimeToSystemTime(&ftLocal,&st);
}
return nError;
}
NS_IMETHODIMP
nsWindowsRegKey::GetValueCount(PRUint32 *result)
{
NS_ENSURE_TRUE(mKey, NS_ERROR_NOT_INITIALIZED);
DWORD numValues;
LONG rv = RegQueryInfoKeyW(mKey, NULL, NULL, NULL, NULL, NULL, NULL,
&numValues, NULL, NULL, NULL, NULL);
NS_ENSURE_STATE(rv == ERROR_SUCCESS);
*result = numValues;
return NS_OK;
}
bool WinRegKey::QueryInfo(LPDWORD lpcSubkeys)
{
#if defined(MEDIASDK_USE_REGISTRY) || (!defined(MEDIASDK_UWP_LOADER) && !defined(MEDIASDK_UWP_PROCTABLE))
LONG lRes;
lRes = RegQueryInfoKeyW(m_hKey, NULL, 0, 0, lpcSubkeys, 0, 0, 0, 0, 0, 0, 0);
if (ERROR_SUCCESS != lRes) {
TRACE_WINREG_ERROR("RegQueryInfoKeyW()==0x%x\n", lRes);
return false;
}
return true;
#else
return false;
#endif
} //bool QueryInfo(LPDWORD lpcSubkeys);
JNIEXPORT jobjectArray JNICALL Java_org_netbeans_installer_utils_system_windows_WindowsRegistry_getValueNames0(JNIEnv *jEnv, jobject jObject, jint jMode, jint jSection, jstring jKey) {
HKEY hkey = 0;
unsigned short* key = getWideChars(jEnv, jKey);
DWORD valuesCount = 0;
int err = 0;
int index = 0;
unsigned short* buffer = (unsigned short*) MALLOC(sizeof(char) * MAX_LEN_VALUE_NAME);
jobjectArray result = NULL;
if (RegOpenKeyExW(getHKEY(jSection), key, 0, KEY_QUERY_VALUE | getMode(jMode), &hkey) == ERROR_SUCCESS) {
if (RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, &valuesCount, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
jclass stringClazz = (*jEnv)->FindClass(jEnv, "java/lang/String");
result = (*jEnv)->NewObjectArray(jEnv, valuesCount, stringClazz, NULL);
do {
DWORD size = MAX_LEN_VALUE_NAME;
buffer[0] = 0;
err = RegEnumValueW(hkey, index, buffer, &size, NULL, NULL, NULL, NULL);
if (err == ERROR_SUCCESS) {
(*jEnv)->SetObjectArrayElement(jEnv, result, index, getStringW(jEnv, buffer));
} else {
if (err != ERROR_NO_MORE_ITEMS) {
throwException(jEnv, "Cannot get value names");
}
}
index++;
} while (err == ERROR_SUCCESS);
} else {
throwException(jEnv, "Cannot read key data");
}
} else {
throwException(jEnv, "Cannot open key");
}
if (hkey != 0) {
RegCloseKey(hkey);
}
FREE(key);
FREE(buffer);
return result;
}
NS_IMETHODIMP
nsWindowsRegKey::GetValueCount(uint32_t* aResult)
{
if (NS_WARN_IF(!mKey)) {
return NS_ERROR_NOT_INITIALIZED;
}
DWORD numValues;
LONG rv = RegQueryInfoKeyW(mKey, nullptr, nullptr, nullptr, nullptr,
nullptr, nullptr, &numValues, nullptr, nullptr,
nullptr, nullptr);
if (rv != ERROR_SUCCESS) {
return NS_ERROR_FAILURE;
}
*aResult = numValues;
return NS_OK;
}
static HRESULT WINAPI DEVENUM_IEnumMoniker_Skip(IEnumMoniker *iface, ULONG celt)
{
EnumMonikerImpl *This = impl_from_IEnumMoniker(iface);
DWORD special_subkeys = 0;
TRACE("(%p)->(%d)\n", iface, celt);
/* Before incrementing, check if there are any more values to run through.
Some programs use the Skip() function to get the number of devices */
if(This->special_hkey)
RegQueryInfoKeyW(This->special_hkey, NULL, NULL, NULL, &special_subkeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
if((This->index + celt) >= This->subkey_cnt + special_subkeys)
{
return S_FALSE;
}
This->index += celt;
return S_OK;
}
int Key::numValues() const
{
HKEY hKey;
LONG lRtn = RegOpenKeyExW( m_hRootKey, m_wsPath.c_str(),
0, KEY_QUERY_VALUE, &hKey );
if (lRtn != ERROR_SUCCESS) {
BP_THROW( "RegOpenKeyExW(" + wideToUtf8(m_wsPath)
+ ") returned: " + bp::conv::toString( lRtn ) );
}
DWORD dwNumValues;
lRtn = RegQueryInfoKeyW( hKey, NULL, NULL, NULL, NULL, NULL, NULL,
&dwNumValues,
NULL, NULL, NULL, NULL );
if (lRtn != ERROR_SUCCESS) {
BP_THROW( "RegQueryInfoKeyW(" + wideToUtf8(m_wsPath)
+ ") returned: " + bp::conv::toString( lRtn ) );
}
return static_cast<int>( dwNumValues );
}
JNIEXPORT jint JNICALL Java_org_netbeans_installer_utils_system_windows_WindowsRegistry_countValues0(JNIEnv *jEnv, jobject jObject, jint jMode, jint jSection, jstring jKey) {
HKEY hkey = 0;
unsigned short* key = getWideChars(jEnv, jKey);
DWORD count = 0;
if (RegOpenKeyExW(getHKEY(jSection), key, 0, KEY_READ | getMode(jMode), &hkey) == ERROR_SUCCESS) {
if (RegQueryInfoKeyW(hkey, NULL, NULL, NULL, NULL, NULL, NULL, &count, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
throwException(jEnv, "Cannot read key data");
}
} else {
throwException(jEnv, "Cannot open key");
}
if (hkey != 0) {
RegCloseKey(hkey);
}
FREE(key);
return count;
}
static
VOID
TestKeyAccess_(
_In_ PCSTR File,
_In_ INT Line,
_In_ REGSAM DesiredAccess,
_In_ LONG ExpectedReturn,
_In_ BOOLEAN ExpectSd)
{
DWORD cbSd;
HKEY hKey;
LONG ret;
ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software", 0, DesiredAccess, &hKey);
ok_(File, Line)(ret == NO_ERROR, "RegOpenKeyEx returned %ld\n", ret);
if (ret == NO_ERROR)
{
cbSd = 0x55555555;
ret = RegQueryInfoKeyW(hKey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &cbSd, NULL);
ok_(File, Line)(ret == ExpectedReturn, "RegQueryInfoKeyW returned %ld\n", ret);
if (ExpectSd)
ok_(File, Line)(cbSd != 0 && cbSd != 0x55555555, "RegQueryInfoKeyW - cbSd = %lu\n", cbSd);
else
ok_(File, Line)(cbSd == 0, "RegQueryInfoKeyW - cbSd = %lu\n", cbSd);
cbSd = 0x55555555;
ret = RegQueryInfoKeyA(hKey, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, &cbSd, NULL);
ok_(File, Line)(ret == ExpectedReturn, "RegQueryInfoKeyA returned %ld\n", ret);
if (ExpectSd)
ok_(File, Line)(cbSd != 0 && cbSd != 0x55555555, "RegQueryInfoKeyA - cbSd = %lu\n", cbSd);
else
ok_(File, Line)(cbSd == 0, "RegQueryInfoKeyA - cbSd = %lu\n", cbSd);
ret = RegCloseKey(hKey);
ok_(File, Line)(ret == NO_ERROR, "RegCloseKey returned %ld\n", ret);
}
else
{
skip_(File, Line)("No key handle\n");
}
}
void UnregisterAllKFsAddedByThisTool(DWORD *pdwKFs)
{
*pdwKFs = 0;
HKEY hKey;
if (ERROR_SUCCESS == RegOpenKeyExW(HKEY_LOCAL_MACHINE, SZ_REG_PATH_HISTORY, 0, KEY_ALL_ACCESS, &hKey))
{
DWORD dwValues = 0;
DWORD cchMaxValueNameLen = 0;
if (ERROR_SUCCESS == RegQueryInfoKeyW(hKey, NULL, NULL, NULL, NULL, NULL, NULL, &dwValues, &cchMaxValueNameLen, NULL, NULL, NULL))
{
DWORD const cchValName = cchMaxValueNameLen + 1; // add 1 for trailing NULL
PWSTR pszValName = (PWSTR)CoTaskMemAlloc(sizeof(WCHAR) * cchValName);
if (pszValName)
{
for (DWORD dw = 0; dw < dwValues; ++dw)
{
DWORD cchValNameInOut = cchValName;
if (ERROR_SUCCESS == RegEnumValueW(hKey, dw, pszValName, &cchValNameInOut, NULL, NULL, NULL, NULL))
{
KNOWNFOLDERID kfid = GUID_NULL;
CLSIDFromString(pszValName, &kfid);
RemovePhysicalFolder(kfid);
HRESULT hr = UnregisterFolder(kfid);
if (SUCCEEDED(hr))
{
++*pdwKFs;
}
else
{
wprintf(L"Failed to UnregisterFolder %s hr=0x%x\n", pszValName, hr);
}
}
}
CoTaskMemFree(pszValName);
}
}
RegDeleteTree(hKey, NULL);
RegCloseKey(hKey);
}
}
/* Add an entry to the tree. Only give hKey for root nodes (HKEY_ constants) */
static HTREEITEM AddEntryToTree(HWND hwndTV, HTREEITEM hParent, LPWSTR label, HKEY hKey, DWORD dwChildren)
{
TVINSERTSTRUCTW tvins;
if (hKey) {
if (RegQueryInfoKeyW(hKey, 0, 0, 0, &dwChildren, 0, 0, 0, 0, 0, 0, 0) != ERROR_SUCCESS) {
dwChildren = 0;
}
}
tvins.u.item.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN | TVIF_PARAM;
tvins.u.item.pszText = label;
tvins.u.item.cchTextMax = lstrlenW(label);
tvins.u.item.iImage = Image_Closed;
tvins.u.item.iSelectedImage = Image_Open;
tvins.u.item.cChildren = dwChildren;
tvins.u.item.lParam = (LPARAM)hKey;
tvins.hInsertAfter = hKey ? TVI_LAST : TVI_SORT;
tvins.hParent = hParent;
return TreeView_InsertItemW(hwndTV, &tvins);
}
JNIEXPORT jboolean JNICALL
Java_net_rubygrapefruit_platform_internal_jni_WindowsRegistryFunctions_getValueNames(JNIEnv *env, jclass target, jint keyNum, jstring subkey, jobject names, jobject result) {
wchar_t* subkeyStr = java_to_wchar(env, subkey, result);
jclass names_class = env->GetObjectClass(names);
jmethodID method = env->GetMethodID(names_class, "add", "(Ljava/lang/Object;)Z");
HKEY key;
LONG retval = RegOpenKeyExW(get_key_from_ordinal(keyNum), subkeyStr, 0, KEY_READ, &key);
if (retval != ERROR_SUCCESS) {
free(subkeyStr);
if (retval != ERROR_FILE_NOT_FOUND) {
mark_failed_with_code(env, "could open registry key", retval, NULL, result);
}
return false;
}
DWORD valueCount;
DWORD maxValueNameLen;
retval = RegQueryInfoKeyW(key, NULL, NULL, NULL, NULL, NULL, NULL, &valueCount, &maxValueNameLen, NULL, NULL, NULL);
if (retval != ERROR_SUCCESS) {
mark_failed_with_code(env, "could query registry key", retval, NULL, result);
} else {
wchar_t* valueNameStr = (wchar_t*)malloc(sizeof(wchar_t) * (maxValueNameLen+1));
for (int i = 0; i < valueCount; i++) {
DWORD valueNameLen = maxValueNameLen + 1;
retval = RegEnumValueW(key, i, valueNameStr, &valueNameLen, NULL, NULL, NULL, NULL);
if (retval != ERROR_SUCCESS) {
mark_failed_with_code(env, "could enumerate registry value name", retval, NULL, result);
break;
}
env->CallVoidMethod(names, method, wchar_to_java(env, valueNameStr, wcslen(valueNameStr), result));
}
free(valueNameStr);
}
RegCloseKey(key);
free(subkeyStr);
return true;
}
HRESULT DEVENUM_IEnumMoniker_Construct(HKEY hkey, HKEY special_hkey, IEnumMoniker ** ppEnumMoniker)
{
EnumMonikerImpl * pEnumMoniker = CoTaskMemAlloc(sizeof(EnumMonikerImpl));
if (!pEnumMoniker)
return E_OUTOFMEMORY;
pEnumMoniker->IEnumMoniker_iface.lpVtbl = &IEnumMoniker_Vtbl;
pEnumMoniker->ref = 1;
pEnumMoniker->index = 0;
pEnumMoniker->hkey = hkey;
pEnumMoniker->special_hkey = special_hkey;
*ppEnumMoniker = &pEnumMoniker->IEnumMoniker_iface;
if(RegQueryInfoKeyW(pEnumMoniker->hkey, NULL, NULL, NULL, &pEnumMoniker->subkey_cnt, NULL, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
pEnumMoniker->subkey_cnt = 0;
DEVENUM_LockModule();
return S_OK;
}
static HRESULT WINAPI DEVENUM_IEnumMoniker_Skip(LPENUMMONIKER iface, ULONG celt)
{
EnumMonikerImpl *This = (EnumMonikerImpl *)iface;
DWORD subKeys;
TRACE("(%p)->(%d)\n", iface, celt);
/* Before incrementing, check if there are any more values to run thru.
Some programs use the Skip() function to get the amount of devices */
if(RegQueryInfoKeyW(This->hkey, NULL, NULL, NULL, &subKeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS)
{
return S_FALSE;
}
if((This->index + celt) >= subKeys)
{
return S_FALSE;
}
This->index += celt;
return S_OK;
}
void searchCurrentJavaRegistry(LauncherProperties * props, BOOL access64key) {
DWORD i=0;
WCHAR ** keys = JAVA_REGISTRY_KEYS;
DWORD k=0;
WCHAR * buffer = newpWCHAR(MAX_LEN_VALUE_NAME);
HKEY rootKeys [2] = {HKEY_LOCAL_MACHINE, HKEY_CURRENT_USER};
DWORD rootKeysNumber = sizeof(rootKeys)/sizeof(HKEY);
DWORD keysNumber = sizeof(JAVA_REGISTRY_KEYS)/sizeof(WCHAR*);
DWORD status = ERROR_OK;
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "Search java in CurrentVersion values...", 1);
for ( k = 0; k < rootKeysNumber; k++) {
for(i=0; i < keysNumber;i++) {
if(isTerminated(props)) {
return;
}
else {
WCHAR * value = getStringValue(rootKeys[k], keys[i], CURRENT_VERSION, access64key);
if(value!=NULL) {
WCHAR *javaHome = getStringValuePC(rootKeys[k], keys[i], value, JAVA_HOME, access64key);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "... ", 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, (rootKeys[k]==HKEY_LOCAL_MACHINE) ? "HKEY_LOCAL_MACHINE" : "HKEY_CURRENT_USER", 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "\\", 0);
writeMessageW(props, OUTPUT_LEVEL_NORMAL, 0, keys[i], 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "\\", 0);
writeMessageW(props, OUTPUT_LEVEL_NORMAL, 0, CURRENT_VERSION, 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "->", 0);
writeMessageW(props, OUTPUT_LEVEL_NORMAL, 0, value, 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "[", 0);
writeMessageW(props, OUTPUT_LEVEL_NORMAL, 0, JAVA_HOME, 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "] = ", 0);
writeMessageW(props, OUTPUT_LEVEL_NORMAL, 0, javaHome, 1);
FREE(value);
trySetCompatibleJava(javaHome, props);
FREE(javaHome);
if(props->java!=NULL) {
FREE(buffer);
return;
}
}
}
}
}
// we found no CurrentVersion java... just search for other possible keys
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "Search java in other values...", 1);
for(k=0;k<rootKeysNumber;k++) {
for(i=0;i<keysNumber;i++) {
HKEY hkey = 0;
DWORD index = 0 ;
if (RegOpenKeyExW(rootKeys[k], keys[i], 0, KEY_READ | ((access64key && IsWow64) ? KEY_WOW64_64KEY : 0), &hkey) == ERROR_SUCCESS) {
DWORD number = 0;
if (RegQueryInfoKeyW(hkey, NULL, NULL, NULL, &number, NULL, NULL, NULL, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
DWORD err = 0;
do {
DWORD size = MAX_LEN_VALUE_NAME;
buffer[0] = 0;
err = RegEnumKeyExW(hkey, index, buffer, &size, NULL, NULL, NULL, NULL);
if (err == ERROR_SUCCESS) {
WCHAR * javaHome = getJavaHomeValue(keys[i], buffer, access64key);
status = ERROR_OK;
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, (rootKeys[k]==HKEY_LOCAL_MACHINE) ? "HKEY_LOCAL_MACHINE" : "HKEY_CURRENT_USER", 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "\\", 0);
writeMessageW(props, OUTPUT_LEVEL_NORMAL, 0, keys[i], 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "\\", 0);
writeMessageW(props, OUTPUT_LEVEL_NORMAL, 0, buffer, 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "[", 0);
writeMessageW(props, OUTPUT_LEVEL_NORMAL, 0, JAVA_HOME, 0);
writeMessageA(props, OUTPUT_LEVEL_NORMAL, 0, "] = ", 0);
writeMessageW(props, OUTPUT_LEVEL_NORMAL, 0, javaHome, 1);
trySetCompatibleJava(javaHome, props);
FREE(javaHome);
if(props->java!=NULL) {
i = keysNumber; // to the end of cycles
k = rootKeysNumber;
break;
}
}
index++;
} while (err == ERROR_SUCCESS);
}
}
if (hkey != 0) {
RegCloseKey(hkey);
}
}
}
FREE(buffer);
return;
}
static HRESULT DEVENUM_RegisterLegacyAmFilters(void)
{
HKEY hkeyFilter = NULL;
DWORD dwFilterSubkeys, i;
LONG lRet;
IFilterMapper2 *pMapper = NULL;
HRESULT hr;
hr = CoCreateInstance(&CLSID_FilterMapper2, NULL, CLSCTX_INPROC,
&IID_IFilterMapper2, (void **) &pMapper);
if (SUCCEEDED(hr))
{
lRet = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszFilterKeyName, 0, KEY_READ, &hkeyFilter);
hr = HRESULT_FROM_WIN32(lRet);
}
if (SUCCEEDED(hr))
{
lRet = RegQueryInfoKeyW(hkeyFilter, NULL, NULL, NULL, &dwFilterSubkeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
hr = HRESULT_FROM_WIN32(lRet);
}
if (SUCCEEDED(hr))
{
for (i = 0; i < dwFilterSubkeys; i++)
{
WCHAR wszFilterSubkeyName[64];
DWORD cName = sizeof(wszFilterSubkeyName) / sizeof(WCHAR);
HKEY hkeyCategoryBaseKey;
WCHAR wszRegKey[MAX_PATH];
HKEY hkeyInstance = NULL;
if (RegEnumKeyExW(hkeyFilter, i, wszFilterSubkeyName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
hr = DEVENUM_GetCategoryKey(&CLSID_LegacyAmFilterCategory, &hkeyCategoryBaseKey, wszRegKey, MAX_PATH);
if (FAILED(hr)) continue;
strcatW(wszRegKey, wszRegSeparator);
strcatW(wszRegKey, wszFilterSubkeyName);
if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszRegKey, 0, KEY_READ, &hkeyInstance) == ERROR_SUCCESS)
{
RegCloseKey(hkeyInstance);
}
else
{
/* Filter is registered the IFilterMapper(1)-way in HKCR\Filter. Needs to be added to
* legacy am filter category. */
HKEY hkeyFilterClass = NULL;
REGFILTER2 rgf2;
CLSID clsidFilter;
WCHAR wszFilterName[MAX_PATH];
DWORD Type;
DWORD cbData;
HRESULT res;
IMoniker *pMoniker = NULL;
TRACE("Registering %s\n", debugstr_w(wszFilterSubkeyName));
strcpyW(wszRegKey, clsid_keyname);
strcatW(wszRegKey, wszRegSeparator);
strcatW(wszRegKey, wszFilterSubkeyName);
if (RegOpenKeyExW(HKEY_CLASSES_ROOT, wszRegKey, 0, KEY_READ, &hkeyFilterClass) != ERROR_SUCCESS)
continue;
rgf2.dwVersion = 1;
rgf2.dwMerit = 0;
rgf2.u.s.cPins = 0;
rgf2.u.s.rgPins = NULL;
cbData = sizeof(wszFilterName);
if (RegQueryValueExW(hkeyFilterClass, NULL, NULL, &Type, (LPBYTE)wszFilterName, &cbData) != ERROR_SUCCESS ||
Type != REG_SZ)
goto cleanup;
cbData = sizeof(rgf2.dwMerit);
if (RegQueryValueExW(hkeyFilterClass, wszMeritName, NULL, &Type, (LPBYTE)&rgf2.dwMerit, &cbData) != ERROR_SUCCESS ||
Type != REG_DWORD)
goto cleanup;
DEVENUM_ReadPins(hkeyFilterClass, &rgf2);
res = CLSIDFromString(wszFilterSubkeyName, &clsidFilter);
if (FAILED(res)) goto cleanup;
IFilterMapper2_RegisterFilter(pMapper, &clsidFilter, wszFilterName, &pMoniker, NULL, NULL, &rgf2);
if (pMoniker)
IMoniker_Release(pMoniker);
cleanup:
if (hkeyFilterClass) RegCloseKey(hkeyFilterClass);
if (rgf2.u.s.rgPins)
{
UINT iPin;
for (iPin = 0; iPin < rgf2.u.s.cPins; iPin++)
{
CoTaskMemFree(rgf2.u.s.rgPins[iPin].strName);
if (rgf2.u.s.rgPins[iPin].lpMediaType)
{
UINT iType;
for (iType = 0; iType < rgf2.u.s.rgPins[iPin].nMediaTypes; iType++)
{
CoTaskMemFree((void*)rgf2.u.s.rgPins[iPin].lpMediaType[iType].clsMajorType);
CoTaskMemFree((void*)rgf2.u.s.rgPins[iPin].lpMediaType[iType].clsMinorType);
}
CoTaskMemFree((void*)rgf2.u.s.rgPins[iPin].lpMediaType);
}
}
CoTaskMemFree((void*)rgf2.u.s.rgPins);
}
}
}
}
if (hkeyFilter) RegCloseKey(hkeyFilter);
if (pMapper)
IFilterMapper2_Release(pMapper);
return S_OK;
}
static void DEVENUM_ReadPinTypes(HKEY hkeyPinKey, REGFILTERPINS *rgPin)
{
HKEY hkeyTypes = NULL;
DWORD dwMajorTypes, i;
REGPINTYPES *lpMediaType = NULL;
DWORD dwMediaTypeSize = 0;
if (RegOpenKeyExW(hkeyPinKey, wszTypes, 0, KEY_READ, &hkeyTypes) != ERROR_SUCCESS)
return ;
if (RegQueryInfoKeyW(hkeyTypes, NULL, NULL, NULL, &dwMajorTypes, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
!= ERROR_SUCCESS)
{
RegCloseKey(hkeyTypes);
return ;
}
for (i = 0; i < dwMajorTypes; i++)
{
HKEY hkeyMajorType = NULL;
WCHAR wszMajorTypeName[64];
DWORD cName = sizeof(wszMajorTypeName) / sizeof(WCHAR);
DWORD dwMinorTypes, i1;
if (RegEnumKeyExW(hkeyTypes, i, wszMajorTypeName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
if (RegOpenKeyExW(hkeyTypes, wszMajorTypeName, 0, KEY_READ, &hkeyMajorType) != ERROR_SUCCESS) continue;
if (RegQueryInfoKeyW(hkeyMajorType, NULL, NULL, NULL, &dwMinorTypes, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
!= ERROR_SUCCESS)
{
RegCloseKey(hkeyMajorType);
continue;
}
for (i1 = 0; i1 < dwMinorTypes; i1++)
{
WCHAR wszMinorTypeName[64];
CLSID *clsMajorType = NULL, *clsMinorType = NULL;
HRESULT hr;
cName = sizeof(wszMinorTypeName) / sizeof(WCHAR);
if (RegEnumKeyExW(hkeyMajorType, i1, wszMinorTypeName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
clsMinorType = CoTaskMemAlloc(sizeof(CLSID));
if (!clsMinorType) continue;
clsMajorType = CoTaskMemAlloc(sizeof(CLSID));
if (!clsMajorType) goto error_cleanup_types;
hr = CLSIDFromString(wszMinorTypeName, clsMinorType);
if (FAILED(hr)) goto error_cleanup_types;
hr = CLSIDFromString(wszMajorTypeName, clsMajorType);
if (FAILED(hr)) goto error_cleanup_types;
if (rgPin->nMediaTypes == dwMediaTypeSize)
{
DWORD dwNewSize = dwMediaTypeSize + (dwMediaTypeSize < 2 ? 1 : dwMediaTypeSize / 2);
REGPINTYPES *lpNewMediaType;
lpNewMediaType = CoTaskMemRealloc(lpMediaType, sizeof(REGPINTYPES) * dwNewSize);
if (!lpNewMediaType) goto error_cleanup_types;
lpMediaType = lpNewMediaType;
dwMediaTypeSize = dwNewSize;
}
lpMediaType[rgPin->nMediaTypes].clsMajorType = clsMajorType;
lpMediaType[rgPin->nMediaTypes].clsMinorType = clsMinorType;
rgPin->nMediaTypes++;
continue;
error_cleanup_types:
if (clsMajorType) CoTaskMemFree(clsMajorType);
if (clsMinorType) CoTaskMemFree(clsMinorType);
}
RegCloseKey(hkeyMajorType);
}
RegCloseKey(hkeyTypes);
if (lpMediaType && !rgPin->nMediaTypes)
{
CoTaskMemFree(lpMediaType);
lpMediaType = NULL;
}
rgPin->lpMediaType = lpMediaType;
}
static void DEVENUM_ReadPins(HKEY hkeyFilterClass, REGFILTER2 *rgf2)
{
HKEY hkeyPins = NULL;
DWORD dwPinsSubkeys, i;
REGFILTERPINS *rgPins = NULL;
if (RegOpenKeyExW(hkeyFilterClass, wszPins, 0, KEY_READ, &hkeyPins) != ERROR_SUCCESS)
return ;
if (RegQueryInfoKeyW(hkeyPins, NULL, NULL, NULL, &dwPinsSubkeys, NULL, NULL, NULL, NULL, NULL, NULL, NULL)
!= ERROR_SUCCESS)
{
RegCloseKey(hkeyPins);
return ;
}
if (dwPinsSubkeys)
{
rgPins = CoTaskMemAlloc(sizeof(REGFILTERPINS) * dwPinsSubkeys);
if (!rgPins)
{
RegCloseKey(hkeyPins);
return ;
}
}
for (i = 0; i < dwPinsSubkeys; i++)
{
HKEY hkeyPinKey = NULL;
WCHAR wszPinName[MAX_PATH];
DWORD cName = sizeof(wszPinName) / sizeof(WCHAR);
DWORD Type, cbData;
REGFILTERPINS *rgPin = &rgPins[rgf2->u.s.cPins];
LONG lRet;
rgPin->strName = NULL;
rgPin->clsConnectsToFilter = &GUID_NULL;
rgPin->strConnectsToPin = NULL;
rgPin->nMediaTypes = 0;
rgPin->lpMediaType = NULL;
if (RegEnumKeyExW(hkeyPins, i, wszPinName, &cName, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) continue;
if (RegOpenKeyExW(hkeyPins, wszPinName, 0, KEY_READ, &hkeyPinKey) != ERROR_SUCCESS) continue;
rgPin->strName = CoTaskMemAlloc((strlenW(wszPinName) + 1) * sizeof(WCHAR));
if (!rgPin->strName) goto error_cleanup;
strcpyW(rgPin->strName, wszPinName);
cbData = sizeof(rgPin->bMany);
lRet = RegQueryValueExW(hkeyPinKey, wszAllowedMany, NULL, &Type, (LPBYTE)&rgPin->bMany, &cbData);
if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
goto error_cleanup;
cbData = sizeof(rgPin->bZero);
lRet = RegQueryValueExW(hkeyPinKey, wszAllowedZero, NULL, &Type, (LPBYTE)&rgPin->bZero, &cbData);
if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
goto error_cleanup;
cbData = sizeof(rgPin->bOutput);
lRet = RegQueryValueExW(hkeyPinKey, wszDirection, NULL, &Type, (LPBYTE)&rgPin->bOutput, &cbData);
if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
goto error_cleanup;
cbData = sizeof(rgPin->bRendered);
lRet = RegQueryValueExW(hkeyPinKey, wszIsRendered, NULL, &Type, (LPBYTE)&rgPin->bRendered, &cbData);
if (lRet != ERROR_SUCCESS || Type != REG_DWORD)
goto error_cleanup;
DEVENUM_ReadPinTypes(hkeyPinKey, rgPin);
++rgf2->u.s.cPins;
continue;
error_cleanup:
RegCloseKey(hkeyPinKey);
if (rgPin->strName) CoTaskMemFree(rgPin->strName);
}
RegCloseKey(hkeyPins);
if (rgPins && !rgf2->u.s.cPins)
{
CoTaskMemFree(rgPins);
rgPins = NULL;
}
rgf2->u.s.rgPins = rgPins;
}
// read font linking information from registry, and store in std::map
void initWindows(){
LONG l_ret;
const wchar_t *Fonts = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Fonts";
HKEY key_ft;
l_ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, Fonts, 0, KEY_QUERY_VALUE, &key_ft);
if (l_ret != ERROR_SUCCESS){
ofLogError("ofTrueTypeFont") << "initWindows(): couldn't find fonts registery key";
return;
}
DWORD value_count;
DWORD max_data_len;
wchar_t value_name[2048];
BYTE *value_data;
// get font_file_name -> font_face mapping from the "Fonts" registry key
l_ret = RegQueryInfoKeyW(key_ft, NULL, NULL, NULL, NULL, NULL, NULL, &value_count, NULL, &max_data_len, NULL, NULL);
if(l_ret != ERROR_SUCCESS){
ofLogError("ofTrueTypeFont") << "initWindows(): couldn't query registery for fonts";
return;
}
// no font installed
if (value_count == 0){
ofLogError("ofTrueTypeFont") << "initWindows(): couldn't find any fonts in registery";
return;
}
// max_data_len is in BYTE
value_data = static_cast<BYTE *>(HeapAlloc(GetProcessHeap(), HEAP_GENERATE_EXCEPTIONS, max_data_len));
if(value_data == NULL) return;
char value_name_char[2048];
char value_data_char[2048];
/*char ppidl[2048];
char fontsPath[2048];
SHGetKnownFolderIDList(FOLDERID_Fonts, 0, NULL, &ppidl);
SHGetPathFromIDList(ppidl,&fontsPath);*/
string fontsDir = getenv ("windir");
fontsDir += "\\Fonts\\";
for (DWORD i = 0; i < value_count; ++i)
{
DWORD name_len = 2048;
DWORD data_len = max_data_len;
l_ret = RegEnumValueW(key_ft, i, value_name, &name_len, NULL, NULL, value_data, &data_len);
if(l_ret != ERROR_SUCCESS){
ofLogError("ofTrueTypeFont") << "initWindows(): couldn't read registry key for font type";
continue;
}
wcstombs(value_name_char,value_name,2048);
wcstombs(value_data_char,reinterpret_cast<wchar_t *>(value_data),2048);
string curr_face = value_name_char;
string font_file = value_data_char;
curr_face = curr_face.substr(0, curr_face.find('(') - 1);
fonts_table[curr_face] = fontsDir + font_file;
}
HeapFree(GetProcessHeap(), 0, value_data);
l_ret = RegCloseKey(key_ft);
}
