UltraEdit() { installed_ = false; HKEY key; LPCWSTR szUltraEditHive = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\uedit32.exe"; LONG lRet = RegOpenKeyW(HKEY_LOCAL_MACHINE, szUltraEditHive, &key); if( lRet == ERROR_SUCCESS ) { DWORD dwType = REG_SZ; DWORD dwSize = sizeof(szPath_); lRet = RegQueryValueExW(key, L"Path", NULL, &dwType, (LPBYTE)szPath_, &dwSize); if( lRet == ERROR_SUCCESS ) installed_ = true; } }
/*********************************************************************** * FindMimeFromData (URLMON.@) * * Determines the Multipurpose Internet Mail Extensions (MIME) type from the data provided. */ HRESULT WINAPI FindMimeFromData(LPBC pBC, LPCWSTR pwzUrl, LPVOID pBuffer, DWORD cbSize, LPCWSTR pwzMimeProposed, DWORD dwMimeFlags, LPWSTR* ppwzMimeOut, DWORD dwReserved) { TRACE("(%p,%s,%p,%d,%s,0x%x,%p,0x%x)\n", pBC, debugstr_w(pwzUrl), pBuffer, cbSize, debugstr_w(pwzMimeProposed), dwMimeFlags, ppwzMimeOut, dwReserved); if(dwMimeFlags) WARN("dwMimeFlags=%08x\n", dwMimeFlags); if(dwReserved) WARN("dwReserved=%d\n", dwReserved); /* pBC seams to not be used */ if(!ppwzMimeOut || (!pwzUrl && !pBuffer)) return E_INVALIDARG; if(pwzMimeProposed || pBuffer) return find_mime_from_buffer(pBuffer, cbSize, pwzMimeProposed, ppwzMimeOut); if(pwzUrl) { HKEY hkey; DWORD res, size; LPCWSTR ptr; WCHAR mime[64]; static const WCHAR wszContentType[] = {'C','o','n','t','e','n','t',' ','T','y','p','e','\0'}; ptr = strrchrW(pwzUrl, '.'); if(!ptr) return E_FAIL; res = RegOpenKeyW(HKEY_CLASSES_ROOT, ptr, &hkey); if(res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res); size = sizeof(mime); res = RegQueryValueExW(hkey, wszContentType, NULL, NULL, (LPBYTE)mime, &size); RegCloseKey(hkey); if(res != ERROR_SUCCESS) return HRESULT_FROM_WIN32(res); *ppwzMimeOut = CoTaskMemAlloc(size); memcpy(*ppwzMimeOut, mime, size); return S_OK; } return E_FAIL; }
EditPlus() { installed_ = false; HKEY key; LPCWSTR szEditPlusHive = L"Software\\ES-Computing\\EditPlus 3\\Install"; LONG lRet = RegOpenKeyW(HKEY_CURRENT_USER, szEditPlusHive, &key); if( lRet == ERROR_SUCCESS ) { DWORD dwType = REG_SZ; DWORD dwSize = sizeof(szPath_); lRet = RegQueryValueExW(key, L"Path", NULL, &dwType, (LPBYTE)szPath_, &dwSize); if( lRet == ERROR_SUCCESS ) installed_ = true; } }
static HKEY GetKeyW(LPCWSTR appname, BOOL * closekey, BOOL fCreate) { HKEY key = 0; WCHAR achName[MAX_PATH]; #if !MMPROFILECACHE *closekey = TRUE; #else UINT n; ATOM atm; *closekey = FALSE; // // See if we have already used this key // atm = FindAtomW(appname); if (atm != 0) { // Atom exists... search the table for it. for (n=0; n<keyscached; ++n) { if (akeyatoms[n] == atm) { DPF2(("(W)Found existing key for %ls\n", appname)); return ahkey[n]; } } } DPF2(("(W)No key found for %ls\n", appname)); #endif lstrcpyW(achName, KEYNAME ); lstrcatW(achName, appname); if ((!fCreate && RegOpenKeyW(ROOTKEY, achName, &key) == ERROR_SUCCESS) || (fCreate && RegCreateKeyW(ROOTKEY, achName, &key) == ERROR_SUCCESS)) { #if MMPROFILECACHE if (keyscached < KEYSCACHED && (atm = AddAtomW(appname))) { // Add this key to the cache array akeyatoms[keyscached] = atm; ahkey[keyscached] = key; DPF1(("Adding key %ls to cache array in position %d\n", appname, keyscached)); ++keyscached; } else { DPF2(("Not adding key to cache array\n")); *closekey = TRUE; } #endif } return(key); }
NotepadPlusPlus() { installed_ = false; HKEY key; LPCWSTR szNotepadPlusPlusHive = L"SOFTWARE\\Notepad++"; LONG lRet = RegOpenKeyW(HKEY_LOCAL_MACHINE, szNotepadPlusPlusHive, &key); if( lRet == ERROR_SUCCESS ) { DWORD dwType = REG_SZ; DWORD dwSize = sizeof(szPath_); lRet = RegQueryValueExW(key, NULL, NULL, &dwType, (LPBYTE)szPath_, &dwSize); if( lRet == ERROR_SUCCESS ) installed_ = true; } }
/* retrieve a map of drives that should be displayed */ static DWORD get_drive_map(void) { static const WCHAR policiesW[] = {'S','o','f','t','w','a','r','e','\\', 'M','i','c','r','o','s','o','f','t','\\', 'W','i','n','d','o','w','s','\\', 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', 'P','o','l','i','c','i','e','s','\\', 'E','x','p','l','o','r','e','r',0}; static const WCHAR nodrivesW[] = {'N','o','D','r','i','v','e','s',0}; static DWORD drive_mask; static BOOL init_done = FALSE; if (!init_done) { DWORD type, size, data, mask = 0; HKEY hkey; if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, policiesW, &hkey )) { size = sizeof(data); if (!RegQueryValueExW( hkey, nodrivesW, NULL, &type, (LPBYTE)&data, &size ) && type == REG_DWORD) mask |= data; RegCloseKey( hkey ); } if (!RegOpenKeyW( HKEY_CURRENT_USER, policiesW, &hkey )) { size = sizeof(data); if (!RegQueryValueExW( hkey, nodrivesW, NULL, &type, (LPBYTE)&data, &size ) && type == REG_DWORD) mask |= data; RegCloseKey( hkey ); } drive_mask = mask; init_done = TRUE; } return GetLogicalDrives() & ~drive_mask; }
static HRESULT WINAPI DEVENUM_IEnumMoniker_Next(IEnumMoniker *iface, ULONG celt, IMoniker **rgelt, ULONG *pceltFetched) { EnumMonikerImpl *This = impl_from_IEnumMoniker(iface); WCHAR buffer[MAX_PATH + 1]; LONG res; ULONG fetched = 0; MediaCatMoniker * pMoniker; TRACE("(%p)->(%d, %p, %p)\n", iface, celt, rgelt, pceltFetched); while (fetched < celt) { if(This->index+fetched < This->subkey_cnt) res = RegEnumKeyW(This->hkey, This->index+fetched, buffer, sizeof(buffer) / sizeof(WCHAR)); else if(This->special_hkey) res = RegEnumKeyW(This->special_hkey, This->index+fetched-This->subkey_cnt, buffer, sizeof(buffer) / sizeof(WCHAR)); else break; if (res != ERROR_SUCCESS) { break; } pMoniker = DEVENUM_IMediaCatMoniker_Construct(); if (!pMoniker) return E_OUTOFMEMORY; if (RegOpenKeyW(This->index+fetched < This->subkey_cnt ? This->hkey : This->special_hkey, buffer, &pMoniker->hkey) != ERROR_SUCCESS) { IMoniker_Release(&pMoniker->IMoniker_iface); break; } rgelt[fetched] = &pMoniker->IMoniker_iface; fetched++; } This->index += fetched; TRACE("-- fetched %d\n", fetched); if (pceltFetched) *pceltFetched = fetched; if (fetched != celt) return S_FALSE; else return S_OK; }
void CVstPluginManager::EnumerateDirectXDMOs() //-------------------------------------------- { HKEY hkEnum; WCHAR keyname[128]; LONG cr = RegOpenKeyEx(HKEY_LOCAL_MACHINE, "software\\classes\\DirectShow\\MediaObjects\\Categories\\f3602b3f-0592-48df-a4cd-674721e7ebeb", 0, KEY_READ, &hkEnum); DWORD index = 0; while (cr == ERROR_SUCCESS) { if ((cr = RegEnumKeyW(hkEnum, index, keyname, CountOf(keyname))) == ERROR_SUCCESS) { CLSID clsid; std::wstring formattedKey = std::wstring(L"{") + std::wstring(keyname) + std::wstring(L"}"); if(Util::StringToCLSID(formattedKey, clsid)) { HKEY hksub; formattedKey = std::wstring(L"software\\classes\\DirectShow\\MediaObjects\\") + std::wstring(keyname); if (RegOpenKeyW(HKEY_LOCAL_MACHINE, formattedKey.c_str(), &hksub) == ERROR_SUCCESS) { WCHAR name[64]; DWORD datatype = REG_SZ; DWORD datasize = sizeof(name); if(ERROR_SUCCESS == RegQueryValueExW(hksub, nullptr, 0, &datatype, (LPBYTE)name, &datasize)) { mpt::String::SetNullTerminator(name); StringFromGUID2(clsid, keyname, 100); VSTPluginLib *plug = new (std::nothrow) VSTPluginLib(mpt::PathString::FromNative(keyname), mpt::PathString::FromNative(name)); if(plug != nullptr) { pluginList.push_back(plug); plug->pluginId1 = kDmoMagic; plug->pluginId2 = clsid.Data1; plug->category = VSTPluginLib::catDMO; #ifdef DMO_LOG Log(mpt::String::PrintW(L"Found \"%1\" clsid=%2\n", plug->libraryName, plug->dllPath)); #endif } } RegCloseKey(hksub); } } } index++; } if (hkEnum) RegCloseKey(hkEnum); }
UINT MSIREG_OpenUninstallKey(LPCWSTR szProduct, HKEY* key, BOOL create) { UINT rc; WCHAR keypath[0x200]; TRACE("%s\n",debugstr_w(szProduct)); sprintfW(keypath,szUninstall_fmt,szProduct); if (create) rc = RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key); else rc = RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key); return rc; }
/* removes the requested value from the registry, however, does not * remove the section if empty. Returns S_OK (0) on success. */ static HRESULT remove_value(HKEY root, const WCHAR *subkey, const WCHAR *name) { HRESULT hr; HKEY key; WINE_TRACE("subkey=%s, name=%s\n", wine_dbgstr_w(subkey), wine_dbgstr_w(name)); hr = RegOpenKeyW(root, subkey, &key); if (hr != S_OK) return hr; hr = RegDeleteValueW(key, name); if (hr != ERROR_SUCCESS) return hr; return S_OK; }
NTSTATUS RegOpenKey( IN PHANDLE hKey, IN PWCHAR szKeyName ) { UNICODE_STRING usKeyName; RtlInitUnicodeString(&usKeyName, szKeyName); return RegOpenKeyW( hKey, &usKeyName ); }
/************************************************************************** * UrlMkGetSessionOption (URLMON.@) */ static BOOL get_url_encoding(HKEY root, DWORD *encoding) { DWORD size = sizeof(DWORD), res, type; HKEY hkey; static const WCHAR wszUrlEncoding[] = {'U','r','l','E','n','c','o','d','i','n','g',0}; res = RegOpenKeyW(root, internet_settings_keyW, &hkey); if(res != ERROR_SUCCESS) return FALSE; res = RegQueryValueExW(hkey, wszUrlEncoding, NULL, &type, (LPBYTE)encoding, &size); RegCloseKey(hkey); return res == ERROR_SUCCESS; }
static HKEY open_config_key(void) { HKEY hkey, ret; DWORD res; static const WCHAR wine_keyW[] = {'S','o','f','t','w','a','r','e','\\','W','i','n','e',0}; /* @@ Wine registry key: HKCU\Software\Wine\$config_key */ res = RegOpenKeyW(HKEY_CURRENT_USER, wine_keyW, &hkey); if(res != ERROR_SUCCESS) return NULL; res = RegOpenKeyA(hkey, addon->config_key, &ret); RegCloseKey(hkey); return res == ERROR_SUCCESS ? ret : NULL; }
/** * get_config_key: Retrieves a configuration value from the registry * * char *subkey : the name of the config section * char *name : the name of the config value * char *default : if the key isn't found, return this value instead * * Returns a buffer holding the value if successful, NULL if * not. Caller is responsible for releasing the result. * */ static WCHAR *get_config_key (HKEY root, const WCHAR *subkey, const WCHAR *name, const WCHAR *def) { LPWSTR buffer = NULL; DWORD len; HKEY hSubKey = NULL; DWORD res; WINE_TRACE("subkey=%s, name=%s, def=%s\n", wine_dbgstr_w(subkey), wine_dbgstr_w(name), wine_dbgstr_w(def)); res = RegOpenKeyW(root, subkey, &hSubKey); if (res != ERROR_SUCCESS) { if (res == ERROR_FILE_NOT_FOUND) { WINE_TRACE("Section key not present - using default\n"); return def ? strdupW(def) : NULL; } else { WINE_ERR("RegOpenKey failed on wine config key (res=%d)\n", res); } goto end; } res = RegQueryValueExW(hSubKey, name, NULL, NULL, NULL, &len); if (res == ERROR_FILE_NOT_FOUND) { WINE_TRACE("Value not present - using default\n"); buffer = def ? strdupW(def) : NULL; goto end; } else if (res != ERROR_SUCCESS) { WINE_ERR("Couldn't query value's length (res=%d)\n", res); goto end; } buffer = HeapAlloc(GetProcessHeap(), 0, len + sizeof(WCHAR)); RegQueryValueExW(hSubKey, name, NULL, NULL, (LPBYTE) buffer, &len); WINE_TRACE("buffer=%s\n", wine_dbgstr_w(buffer)); end: if (hSubKey && hSubKey != root) RegCloseKey(hSubKey); return buffer; }
static HRESULT get_protocol_cf(LPCWSTR schema, DWORD schema_len, CLSID *pclsid, IClassFactory **ret) { WCHAR str_clsid[64]; HKEY hkey = NULL; DWORD res, type, size; CLSID clsid; LPWSTR wszKey; HRESULT hres; static const WCHAR wszProtocolsKey[] = {'P','R','O','T','O','C','O','L','S','\\','H','a','n','d','l','e','r','\\'}; static const WCHAR wszCLSID[] = {'C','L','S','I','D',0}; wszKey = heap_alloc(sizeof(wszProtocolsKey)+(schema_len+1)*sizeof(WCHAR)); memcpy(wszKey, wszProtocolsKey, sizeof(wszProtocolsKey)); memcpy(wszKey + sizeof(wszProtocolsKey)/sizeof(WCHAR), schema, (schema_len+1)*sizeof(WCHAR)); res = RegOpenKeyW(HKEY_CLASSES_ROOT, wszKey, &hkey); heap_free(wszKey); if(res != ERROR_SUCCESS) { TRACE("Could not open protocol handler key\n"); return MK_E_SYNTAX; } size = sizeof(str_clsid); res = RegQueryValueExW(hkey, wszCLSID, NULL, &type, (LPBYTE)str_clsid, &size); RegCloseKey(hkey); if(res != ERROR_SUCCESS || type != REG_SZ) { WARN("Could not get protocol CLSID res=%d\n", res); return MK_E_SYNTAX; } hres = CLSIDFromString(str_clsid, &clsid); if(FAILED(hres)) { WARN("CLSIDFromString failed: %08x\n", hres); return hres; } if(pclsid) *pclsid = clsid; if(!ret) return S_OK; hres = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IClassFactory, (void**)ret); return SUCCEEDED(hres) ? S_OK : MK_E_SYNTAX; }
/// <summary> /// Fill minimal required driver registry entry /// </summary> /// <param name="svcName">Driver service name</param> /// <param name="path">Driver path</param> /// <returns>Status code</returns> LSTATUS DriverControl::PrepareDriverRegEntry( const std::wstring& svcName, const std::wstring& path ) { HKEY key1, key2; DWORD dwType = 1; LSTATUS status = 0; WCHAR wszLocalPath[MAX_PATH] = { 0 }; swprintf_s( wszLocalPath, ARRAYSIZE( wszLocalPath ), L"\\??\\%s", path.c_str() ); status = RegOpenKeyW( HKEY_LOCAL_MACHINE, L"system\\CurrentControlSet\\Services", &key1 ); if (status) return status; status = RegCreateKeyW( key1, svcName.c_str(), &key2 ); if (status) { RegCloseKey( key1 ); return status; } status = RegSetValueExW( key2, L"ImagePath", 0, REG_SZ, reinterpret_cast<const BYTE*>(wszLocalPath), static_cast<DWORD>(sizeof( WCHAR )* (wcslen( wszLocalPath ) + 1)) ); if (status) { RegCloseKey( key2 ); RegCloseKey( key1 ); return status; } status = RegSetValueExW( key2, L"Type", 0, REG_DWORD, reinterpret_cast<const BYTE*>(&dwType), sizeof( dwType ) ); if (status) { RegCloseKey( key2 ); RegCloseKey( key1 ); return status; } RegCloseKey( key2 ); RegCloseKey( key1 ); return status; }
LONG WINAPI RegOpenKeyA( IN HKEY hKey, IN LPCSTR lpSubKey, OUT PHKEY phkResult) { PWSTR lpSubKeyW; LONG rc; lpSubKeyW = MultiByteToWideChar(lpSubKey); if (!lpSubKeyW) return ERROR_OUTOFMEMORY; rc = RegOpenKeyW(hKey, lpSubKeyW, phkResult); free(lpSubKeyW); return rc; }
JNIEXPORT void JNICALL Java_org_gudy_azureus2_platform_win32_access_impl_AEWin32AccessInterface_deleteKeyW( JNIEnv *env, jclass cla, jint _type, jstring _subkey_name, jboolean _recursive ) { HKEY key; HKEY subkey; WCHAR subkey_name[1024]; jstring result = NULL; key = mapHKEY( env, _type ); if ( key == NULL ){ return; } if ( !jstringToCharsW( env, _subkey_name, subkey_name, sizeof( subkey_name ))){ return; } if ( RegOpenKeyW( key, subkey_name, &subkey ) == ERROR_SUCCESS ){ RegCloseKey(subkey); if ( _recursive ){ if ( SHDeleteKeyW( key, subkey_name ) != ERROR_SUCCESS ){ throwException( env, "deleteKey", "SHDeleteKey failed" ); } }else{ if ( RegDeleteKeyW( key, subkey_name ) != ERROR_SUCCESS ){ throwException( env, "deleteKey", "RegDeleteKey failed" ); } } } }
static void test_SHCreateSessionKey(void) { static const WCHAR session_format[] = { 'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\', 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\', 'E','x','p','l','o','r','e','r','\\','S','e','s','s','i','o','n','I','n','f','o','\\','%','u',0}; HKEY hkey, hkey2; HRESULT hr; DWORD session; WCHAR sessionW[ARRAY_SIZE(session_format) + 16]; LONG ret; if (!pSHCreateSessionKey) { win_skip("SHCreateSessionKey is not implemented\n"); return; } if (0) /* crashes on native */ hr = pSHCreateSessionKey(KEY_READ, NULL); hkey = (HKEY)0xdeadbeef; hr = pSHCreateSessionKey(0, &hkey); ok(hr == E_ACCESSDENIED, "got 0x%08x\n", hr); ok(hkey == NULL, "got %p\n", hkey); hr = pSHCreateSessionKey(KEY_READ, &hkey); ok(hr == S_OK, "got 0x%08x\n", hr); hr = pSHCreateSessionKey(KEY_READ, &hkey2); ok(hr == S_OK, "got 0x%08x\n", hr); ok(hkey != hkey2, "got %p, %p\n", hkey, hkey2); RegCloseKey(hkey); RegCloseKey(hkey2); /* check the registry */ ProcessIdToSessionId( GetCurrentProcessId(), &session); if (session) { wsprintfW(sessionW, session_format, session); ret = RegOpenKeyW(HKEY_CURRENT_USER, sessionW, &hkey); ok(!ret, "key not found\n"); RegCloseKey(hkey); } }
static HMODULE load_desktop_driver( HWND hwnd ) { static const WCHAR display_device_guid_propW[] = { '_','_','w','i','n','e','_','d','i','s','p','l','a','y','_', 'd','e','v','i','c','e','_','g','u','i','d',0 }; static const WCHAR key_pathW[] = { 'S','y','s','t','e','m','\\', 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\', 'C','o','n','t','r','o','l','\\', 'V','i','d','e','o','\\','{',0}; static const WCHAR displayW[] = {'}','\\','0','0','0','0',0}; static const WCHAR driverW[] = {'G','r','a','p','h','i','c','s','D','r','i','v','e','r',0}; HMODULE ret = 0; HKEY hkey; DWORD size; WCHAR path[MAX_PATH]; WCHAR key[(sizeof(key_pathW) + sizeof(displayW)) / sizeof(WCHAR) + 40]; UINT guid_atom = HandleToULong( GetPropW( hwnd, display_device_guid_propW )); USER_CheckNotLock(); strcpy( driver_load_error, "The explorer process failed to start." ); /* default error */ if (!guid_atom) { SendMessageW( hwnd, WM_NULL, 0, 0 ); /* wait for the desktop process to be ready */ guid_atom = HandleToULong( GetPropW( hwnd, display_device_guid_propW )); } memcpy( key, key_pathW, sizeof(key_pathW) ); if (!GlobalGetAtomNameW( guid_atom, key + strlenW(key), 40 )) return 0; strcatW( key, displayW ); if (RegOpenKeyW( HKEY_LOCAL_MACHINE, key, &hkey )) return 0; size = sizeof(path); if (!RegQueryValueExW( hkey, driverW, NULL, NULL, (BYTE *)path, &size )) { if (!(ret = LoadLibraryW( path ))) ERR( "failed to load %s\n", debugstr_w(path) ); TRACE( "%s %p\n", debugstr_w(path), ret ); } else { size = sizeof(driver_load_error); RegQueryValueExA( hkey, "DriverError", NULL, NULL, (BYTE *)driver_load_error, &size ); } RegCloseKey( hkey ); return ret; }
static LPWSTR get_mime_clsid(LPCWSTR mime, CLSID *clsid) { LPWSTR key_name, ret; DWORD res, type, size; HKEY hkey; int len; HRESULT hres; static const WCHAR mime_keyW[] = { 'M','I','M','E','\\','D','a','t','a','b','a','s','e','\\', 'C','o','n','t','e','n','t',' ','T','y','p','e','\\' }; static const WCHAR clsidW[] = {'C','L','S','I','D',0}; len = strlenW(mime)+1; key_name = heap_alloc(sizeof(mime_keyW) + len*sizeof(WCHAR)); memcpy(key_name, mime_keyW, sizeof(mime_keyW)); strcpyW(key_name + sizeof(mime_keyW)/sizeof(WCHAR), mime); res = RegOpenKeyW(HKEY_CLASSES_ROOT, key_name, &hkey); heap_free(key_name); if(res != ERROR_SUCCESS) { WARN("Could not open MIME key: %x\n", res); return NULL; } size = 50*sizeof(WCHAR); ret = heap_alloc(size); res = RegQueryValueExW(hkey, clsidW, NULL, &type, (LPBYTE)ret, &size); RegCloseKey(hkey); if(res != ERROR_SUCCESS) { WARN("Could not get CLSID: %08x\n", res); heap_free(ret); return NULL; } hres = CLSIDFromString(ret, clsid); if(FAILED(hres)) { WARN("Could not parse CLSID: %08x\n", hres); heap_free(ret); return NULL; } return ret; }
static void load_settings(HTMLDocumentObj *doc) { nsIMarkupDocumentViewer *markup_document_viewer; nsIContentViewer *content_viewer; nsIDocShell *doc_shell; HKEY settings_key; DWORD val, size; LONG res; nsresult nsres; static const WCHAR ie_keyW[] = { 'S','O','F','T','W','A','R','E','\\', 'M','i','c','r','o','s','o','f','t','\\', 'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r',0}; static const WCHAR zoomW[] = {'Z','o','o','m',0}; static const WCHAR zoom_factorW[] = {'Z','o','o','m','F','a','c','t','o','r',0}; res = RegOpenKeyW(HKEY_CURRENT_USER, ie_keyW, &settings_key); if(res != ERROR_SUCCESS) return; size = sizeof(val); res = RegGetValueW(settings_key, zoomW, zoom_factorW, RRF_RT_REG_DWORD, NULL, &val, &size); RegCloseKey(settings_key); if(res != ERROR_SUCCESS) return; TRACE("Setting ZoomFactor to %u\n", val); nsres = get_nsinterface((nsISupports*)doc->nscontainer->navigation, &IID_nsIDocShell, (void**)&doc_shell); assert(nsres == NS_OK); nsres = nsIDocShell_GetContentViewer(doc_shell, &content_viewer); assert(nsres == NS_OK && content_viewer); nsres = nsISupports_QueryInterface(content_viewer, &IID_nsIMarkupDocumentViewer, (void**)&markup_document_viewer); nsISupports_Release(content_viewer); assert(nsres == NS_OK); nsres = nsIMarkupDocumentViewer_SetFullZoom(markup_document_viewer, (float)val/100000); if(NS_FAILED(nsres)) ERR("SetFullZoom failed: %08x\n", nsres); nsIDocShell_Release(doc_shell); }
static HRESULT open_zone_key(HKEY parent_key, DWORD zone, HKEY *hkey) { static const WCHAR wszFormat[] = {'%','s','%','u',0}; WCHAR key_name[sizeof(wszZonesKey)/sizeof(WCHAR)+12]; DWORD res; wsprintfW(key_name, wszFormat, wszZonesKey, zone); res = RegOpenKeyW(parent_key, key_name, hkey); if(res != ERROR_SUCCESS) { WARN("RegOpenKey failed\n"); return E_INVALIDARG; } return S_OK; }
static HRESULT WINAPI UniformResourceLocatorW_InvokeCommand(IUniformResourceLocatorW *url, PURLINVOKECOMMANDINFOW pCommandInfo) { InternetShortcut *This = impl_from_IUniformResourceLocatorW(url); WCHAR app[64]; HKEY hkey; static const WCHAR wszURLProtocol[] = {'U','R','L',' ','P','r','o','t','o','c','o','l',0}; SHELLEXECUTEINFOW sei; DWORD res, type; HRESULT hres; TRACE("%p %p\n", This, pCommandInfo ); if (pCommandInfo->dwcbSize < sizeof (URLINVOKECOMMANDINFOW)) return E_INVALIDARG; if (pCommandInfo->dwFlags != IURL_INVOKECOMMAND_FL_USE_DEFAULT_VERB) { FIXME("(%p, %p): non-default verbs not implemented\n", url, pCommandInfo); return E_NOTIMPL; } hres = CoInternetParseUrl(This->url, PARSE_SCHEMA, 0, app, sizeof(app)/sizeof(WCHAR), NULL, 0); if(FAILED(hres)) return E_FAIL; res = RegOpenKeyW(HKEY_CLASSES_ROOT, app, &hkey); if(res != ERROR_SUCCESS) return E_FAIL; res = RegQueryValueExW(hkey, wszURLProtocol, NULL, &type, NULL, NULL); RegCloseKey(hkey); if(res != ERROR_SUCCESS || type != REG_SZ) return E_FAIL; memset(&sei, 0, sizeof(sei)); sei.cbSize = sizeof(sei); sei.lpFile = This->url; sei.nShow = SW_SHOW; if( ShellExecuteExW(&sei) ) return S_OK; else return E_FAIL; }
UINT MSIREG_OpenUserUpgradeCodesKey(LPCWSTR szUpgradeCode, HKEY* key, BOOL create) { UINT rc; WCHAR squished_pc[GUID_SIZE]; WCHAR keypath[0x200]; TRACE("%s\n",debugstr_w(szUpgradeCode)); squash_guid(szUpgradeCode,squished_pc); TRACE("squished (%s)\n", debugstr_w(squished_pc)); sprintfW(keypath,szInstaller_UserUpgradeCodes_fmt,squished_pc); if (create) rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key); else rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key); return rc; }
UINT MSIREG_OpenUserComponentsKey(LPCWSTR szComponent, HKEY* key, BOOL create) { UINT rc; WCHAR squished_cc[GUID_SIZE]; WCHAR keypath[0x200]; TRACE("%s\n",debugstr_w(szComponent)); squash_guid(szComponent,squished_cc); TRACE("squished (%s)\n", debugstr_w(squished_cc)); sprintfW(keypath,szUser_Components_fmt,squished_cc); if (create) rc = RegCreateKeyW(HKEY_CURRENT_USER,keypath,key); else rc = RegOpenKeyW(HKEY_CURRENT_USER,keypath,key); return rc; }
UINT MSIREG_OpenProductsKey(LPCWSTR szProduct, HKEY* key, BOOL create) { UINT rc; WCHAR squished_pc[GUID_SIZE]; WCHAR keypath[0x200]; TRACE("%s\n",debugstr_w(szProduct)); squash_guid(szProduct,squished_pc); TRACE("squished (%s)\n", debugstr_w(squished_pc)); sprintfW(keypath,szInstaller_Products_fmt,squished_pc); if (create) rc = RegCreateKeyW(HKEY_LOCAL_MACHINE,keypath,key); else rc = RegOpenKeyW(HKEY_LOCAL_MACHINE,keypath,key); return rc; }
UINT MSIREG_OpenLocalClassesProductKey(LPCWSTR szProductCode, HKEY *key, BOOL create) { WCHAR squished_pc[GUID_SIZE]; WCHAR keypath[0x200]; TRACE("%s\n", debugstr_w(szProductCode)); if (!squash_guid(szProductCode, squished_pc)) return ERROR_FUNCTION_FAILED; TRACE("squished (%s)\n", debugstr_w(squished_pc)); sprintfW(keypath, szInstaller_LocalClassesProd_fmt, squished_pc); if (create) return RegCreateKeyW(HKEY_LOCAL_MACHINE, keypath, key); return RegOpenKeyW(HKEY_LOCAL_MACHINE, keypath, key); }
/****************************************************************************** * get_dpi * * get the dpi from the registry */ static DWORD get_dpi( void ) { DWORD dpi = 96; HKEY hkey; if (RegOpenKeyW(HKEY_CURRENT_CONFIG, dpi_key_name, &hkey) == ERROR_SUCCESS) { DWORD type, size, new_dpi; size = sizeof(new_dpi); if(RegQueryValueExW(hkey, dpi_value_name, NULL, &type, (void *)&new_dpi, &size) == ERROR_SUCCESS) { if(type == REG_DWORD && new_dpi != 0) dpi = new_dpi; } RegCloseKey(hkey); } return dpi; }
static LPWSTR get_url(void) { HKEY hkey; DWORD res, type; DWORD size = INTERNET_MAX_URL_LENGTH*sizeof(WCHAR); DWORD returned_size; LPWSTR url; static const WCHAR wszGeckoUrl[] = {'G','e','c','k','o','U','r','l',0}; static const WCHAR httpW[] = {'h','t','t','p'}; static const WCHAR arch_formatW[] = {'?','a','r','c','h','='}; static const WCHAR v_formatW[] = {'&','v','='}; /* @@ Wine registry key: HKCU\Software\Wine\MSHTML */ res = RegOpenKeyW(HKEY_CURRENT_USER, mshtml_keyW, &hkey); if(res != ERROR_SUCCESS) return NULL; url = heap_alloc(size); returned_size = size; res = RegQueryValueExW(hkey, wszGeckoUrl, NULL, &type, (LPBYTE)url, &returned_size); RegCloseKey(hkey); if(res != ERROR_SUCCESS || type != REG_SZ) { heap_free(url); return NULL; } if(returned_size > sizeof(httpW) && !memcmp(url, httpW, sizeof(httpW))) { DWORD len; len = strlenW(url); memcpy(url+len, arch_formatW, sizeof(arch_formatW)); len += sizeof(arch_formatW)/sizeof(WCHAR); len += MultiByteToWideChar(CP_ACP, 0, ARCH_STRING, sizeof(ARCH_STRING), url+len, size/sizeof(WCHAR)-len)-1; memcpy(url+len, v_formatW, sizeof(v_formatW)); len += sizeof(v_formatW)/sizeof(WCHAR); MultiByteToWideChar(CP_ACP, 0, GECKO_VERSION, -1, url+len, size/sizeof(WCHAR)-len); } TRACE("Got URL %s\n", debugstr_w(url)); return url; }