BOOL LoadLibrary(void)
{
HKEY hKey = NULL;
while ((m_hDll = ::LoadLibraryW(m_cfname)) == NULL)
{
/* Try picking path from the registry, if the codecs is registered in the system */
LONG size;
wchar_t subkey[61] = L"\\CLSID\\";
size = (sizeof(subkey) / 2) - 7;
if (StringFromGUID2(m_guid, subkey + 7, size) != 39)
break;
size -= 39;
wcsncat(subkey, L"\\InprocServer32", size);
if (RegOpenKeyW(HKEY_CLASSES_ROOT, subkey, &hKey) != ERROR_SUCCESS)
break;
if (RegQueryValueW(hKey, NULL, NULL, &size) != ERROR_SUCCESS)
break;
delete m_cfname;
m_cfname = new wchar_t[size];
if (RegQueryValueW(hKey, NULL, m_cfname, &size) == ERROR_SUCCESS)
m_hDll = ::LoadLibraryW(m_cfname);
break;
}
if (hKey) RegCloseKey(hKey);
return (m_hDll != NULL);
}
BOOL HCR_MapTypeToValueW(LPCWSTR szExtension, LPWSTR szFileType, LONG len, BOOL bPrependDot)
{
HKEY hkey;
WCHAR szTemp[MAX_EXTENSION_LENGTH + 2];
TRACE("%s %p\n", debugstr_w(szExtension), szFileType);
/* added because we do not want to have double dots */
if (szExtension[0] == '.')
bPrependDot = FALSE;
if (bPrependDot)
szTemp[0] = '.';
lstrcpynW(szTemp + (bPrependDot?1:0), szExtension, MAX_EXTENSION_LENGTH);
if (RegOpenKeyExW(HKEY_CLASSES_ROOT, szTemp, 0, KEY_READ, &hkey))
{
return FALSE;
}
if (RegQueryValueW(hkey, NULL, szFileType, &len))
{
RegCloseKey(hkey);
return FALSE;
}
RegCloseKey(hkey);
TRACE("--UE;\n} %s\n", debugstr_w(szFileType));
return TRUE;
}
static HRESULT WINAPI DEVENUM_IMediaCatMoniker_GetDisplayName(
LPMONIKER iface,
IBindCtx* pbc,
IMoniker* pmkToLeft,
LPOLESTR* ppszDisplayName)
{
MediaCatMoniker *This = (MediaCatMoniker *)iface;
WCHAR wszBuffer[MAX_PATH];
static const WCHAR wszFriendlyName[] = {'F','r','i','e','n','d','l','y','N','a','m','e',0};
LONG received = sizeof(wszFriendlyName);
TRACE("(%p)->(%p, %p, %p)\n", iface, pbc, pmkToLeft, ppszDisplayName);
*ppszDisplayName = NULL;
/* FIXME: should this be the weird stuff we have to parse in IParseDisplayName? */
if (RegQueryValueW(This->hkey, wszFriendlyName, wszBuffer, &received) == ERROR_SUCCESS)
{
*ppszDisplayName = CoTaskMemAlloc(received);
strcpyW(*ppszDisplayName, wszBuffer);
return S_OK;
}
return E_FAIL;
}
LONG QueryKey(LPCWSTR lpSubKey, LPWSTR lpData, PLONG lpSize)
const
{
if (!IsValidHandle())
return ERROR_INVALID_HANDLE;
return RegQueryValueW(hKey(), lpSubKey, lpData, lpSize);
}
/*************************************************************************
* SHRegQueryValueW [SHELL32.510] NT4.0
*
*/
HRESULT WINAPI SHRegQueryValueW(
HKEY hkey,
LPWSTR lpszSubKey,
LPWSTR lpszData,
LPDWORD lpcbData )
{
WARN("%p %s %p %p semi-stub\n",
hkey, debugstr_w(lpszSubKey), lpszData, lpcbData);
return RegQueryValueW( hkey, lpszSubKey, lpszData, (LONG*)lpcbData );
}
BOOL HCR_GetDefaultVerbW( HKEY hkeyClass, LPCWSTR szVerb, LPWSTR szDest, DWORD len )
{
WCHAR sTemp[MAX_PATH];
LONG size;
HKEY hkey;
TRACE("%p %s %p\n", hkeyClass, debugstr_w(szVerb), szDest);
if (szVerb && *szVerb)
{
lstrcpynW(szDest, szVerb, len);
return TRUE;
}
size=len;
*szDest='\0';
if (!RegQueryValueW(hkeyClass, swShell, szDest, &size) && *szDest)
{
/* The MSDN says to first try the default verb */
lstrcpyW(sTemp, swShell);
lstrcatW(sTemp, szDest);
lstrcatW(sTemp, swCommand);
if (!RegOpenKeyExW(hkeyClass, sTemp, 0, 0, &hkey))
{
RegCloseKey(hkey);
TRACE("default verb=%s\n", debugstr_w(szDest));
return TRUE;
}
}
/* then fallback to 'open' */
lstrcpyW(sTemp, swShell);
lstrcatW(sTemp, swOpen);
lstrcatW(sTemp, swCommand);
if (!RegOpenKeyExW(hkeyClass, sTemp, 0, 0, &hkey))
{
RegCloseKey(hkey);
lstrcpynW(szDest, swOpen, len);
TRACE("default verb=open\n");
return TRUE;
}
/* and then just use the first verb on Windows >= 2000 */
if (!RegEnumKeyW(hkeyClass, 0, szDest, len) && *szDest)
{
TRACE("default verb=first verb=%s\n", debugstr_w(szDest));
return TRUE;
}
TRACE("no default verb!\n");
return FALSE;
}
static BOOL get_engine_clsid(const WCHAR *ext, CLSID *clsid)
{
WCHAR fileid[64], progid[64];
DWORD res;
LONG size;
HKEY hkey;
HRESULT hres;
static const WCHAR script_engineW[] =
{'\\','S','c','r','i','p','t','E','n','g','i','n','e',0};
res = RegOpenKeyW(HKEY_CLASSES_ROOT, ext, &hkey);
if(res != ERROR_SUCCESS)
return FALSE;
size = sizeof(fileid)/sizeof(WCHAR);
res = RegQueryValueW(hkey, NULL, fileid, &size);
RegCloseKey(hkey);
if(res != ERROR_SUCCESS)
return FALSE;
WINE_TRACE("fileid is %s\n", wine_dbgstr_w(fileid));
strcatW(fileid, script_engineW);
res = RegOpenKeyW(HKEY_CLASSES_ROOT, fileid, &hkey);
if(res != ERROR_SUCCESS)
return FALSE;
size = sizeof(progid)/sizeof(WCHAR);
res = RegQueryValueW(hkey, NULL, progid, &size);
RegCloseKey(hkey);
if(res != ERROR_SUCCESS)
return FALSE;
WINE_TRACE("ProgID is %s\n", wine_dbgstr_w(progid));
hres = CLSIDFromProgID(progid, clsid);
return SUCCEEDED(hres);
}
static void AddComponentCategories(void)
{
TVINSERTSTRUCTW tvis;
HKEY hKey, hCurKey;
WCHAR keyName[MAX_LOAD_STRING];
WCHAR valName[MAX_LOAD_STRING];
WCHAR buffer[MAX_LOAD_STRING];
LONG lenBuffer;
DWORD lenBufferHlp;
DWORD lenValName;
int i=-1;
U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM|TVIF_CHILDREN;
U(tvis).item.cchTextMax = MAX_LOAD_STRING;
tvis.hInsertAfter = TVI_FIRST;
if(tree.hGBCC) tvis.hParent = tree.hGBCC;
else tvis.hParent = TVI_ROOT;
U(tvis).item.cChildren = 1;
if(RegOpenKeyW(HKEY_CLASSES_ROOT, wszComponentCategories, &hKey) != ERROR_SUCCESS)
return;
while(TRUE)
{
i++;
if(RegEnumKeyW(hKey, i, keyName, sizeof(keyName)/sizeof(keyName[0])) != ERROR_SUCCESS) break;
if(RegOpenKeyW(hKey, keyName, &hCurKey) != ERROR_SUCCESS) continue;
lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);
lenBufferHlp = sizeof(WCHAR[MAX_LOAD_STRING]);
lenValName = sizeof(WCHAR[MAX_LOAD_STRING]);
if(RegQueryValueW(hCurKey, NULL, buffer, &lenBuffer) == ERROR_SUCCESS && *buffer)
U(tvis).item.pszText = buffer;
else if(RegEnumValueW(hCurKey, 0, valName, &lenValName, NULL, NULL,
(LPBYTE)buffer, &lenBufferHlp) == ERROR_SUCCESS && *buffer)
U(tvis).item.pszText = buffer;
else continue;
RegCloseKey(hCurKey);
U(tvis).item.lParam = CreateITEM_INFO(REGTOP, keyName, keyName, NULL);
SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
}
RegCloseKey(hKey);
SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hGBCC);
}
static void AddInterfaces(void)
{
TVINSERTSTRUCTW tvis;
HKEY hKey, hCurKey;
WCHAR valName[MAX_LOAD_STRING];
WCHAR buffer[MAX_LOAD_STRING];
LONG lenBuffer;
int i=-1;
U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
U(tvis).item.cchTextMax = MAX_LOAD_STRING;
tvis.hInsertAfter = TVI_FIRST;
tvis.hParent = tree.hI;
if(RegOpenKeyW(HKEY_CLASSES_ROOT, wszInterface, &hKey) != ERROR_SUCCESS) return;
while(TRUE)
{
i++;
if(RegEnumKeyW(hKey, i, valName, sizeof(valName)/sizeof(valName[0])) != ERROR_SUCCESS) break;
if(RegOpenKeyW(hKey, valName, &hCurKey) != ERROR_SUCCESS) continue;
lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);
if(RegQueryValueW(hCurKey, NULL, buffer, &lenBuffer) == ERROR_SUCCESS && *buffer)
U(tvis).item.pszText = buffer;
else U(tvis).item.pszText = valName;
RegCloseKey(hCurKey);
U(tvis).item.lParam = CreateITEM_INFO(REGPATH|INTERFACE, valName, valName, NULL);
SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
}
RegCloseKey(hKey);
SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hI);
}
static int reg_add(WCHAR *key_name, WCHAR *value_name, BOOL value_empty,
WCHAR *type, WCHAR separator, WCHAR *data, BOOL force)
{
static const WCHAR stubW[] = {'A','D','D',' ','-',' ','%','s',
' ','%','s',' ','%','d',' ','%','s',' ','%','s',' ','%','d','\n',0
};
LPWSTR p;
HKEY root,subkey;
reg_printfW(stubW, key_name, value_name, value_empty, type, data, force);
if (key_name[0]=='\\' && key_name[1]=='\\')
{
reg_message(STRING_NO_REMOTE);
return 1;
}
p = strchrW(key_name,'\\');
if (!p)
{
reg_message(STRING_INVALID_KEY);
return 1;
}
p++;
root = get_rootkey(key_name);
if (!root)
{
reg_message(STRING_INVALID_KEY);
return 1;
}
if(RegCreateKeyW(root,p,&subkey)!=ERROR_SUCCESS)
{
reg_message(STRING_INVALID_KEY);
return 1;
}
if (value_name || data)
{
DWORD reg_type;
DWORD reg_count = 0;
BYTE* reg_data = NULL;
if (!force)
{
if (RegQueryValueW(subkey,value_name,NULL,NULL)==ERROR_SUCCESS)
{
/* FIXME: Prompt for overwrite */
}
}
reg_type = get_regtype(type);
if (reg_type == -1)
{
RegCloseKey(subkey);
reg_message(STRING_INVALID_CMDLINE);
return 1;
}
if (data)
reg_data = get_regdata(data,reg_type,separator,®_count);
RegSetValueExW(subkey,value_name,0,reg_type,reg_data,reg_count);
HeapFree(GetProcessHeap(),0,reg_data);
}
RegCloseKey(subkey);
reg_message(STRING_SUCCESS);
return 0;
}
/******************************************************************************
* IAutoComplete2_fnInit
*/
static HRESULT WINAPI IAutoComplete2_fnInit(
IAutoComplete2 * iface,
HWND hwndEdit,
IUnknown *punkACL,
LPCOLESTR pwzsRegKeyPath,
LPCOLESTR pwszQuickComplete)
{
IAutoCompleteImpl *This = (IAutoCompleteImpl *)iface;
TRACE("(%p)->(%p, %p, %s, %s)\n",
This, hwndEdit, punkACL, debugstr_w(pwzsRegKeyPath), debugstr_w(pwszQuickComplete));
if (This->options & ACO_SEARCH) FIXME(" ACO_SEARCH not supported\n");
if (This->options & ACO_FILTERPREFIXES) FIXME(" ACO_FILTERPREFIXES not supported\n");
if (This->options & ACO_USETAB) FIXME(" ACO_USETAB not supported\n");
if (This->options & ACO_RTLREADING) FIXME(" ACO_RTLREADING not supported\n");
if (!hwndEdit || !punkACL)
return E_INVALIDARG;
if (This->initialized)
{
WARN("Autocompletion object is already initialized\n");
/* This->hwndEdit is set to NULL when the edit window is destroyed. */
return This->hwndEdit ? E_FAIL : E_UNEXPECTED;
}
if (FAILED (IUnknown_QueryInterface (punkACL, &IID_IEnumString, (LPVOID*)&This->enumstr))) {
WARN("No IEnumString interface\n");
return E_NOINTERFACE;
}
This->initialized = TRUE;
This->hwndEdit = hwndEdit;
This->wpOrigEditProc = (WNDPROC) SetWindowLongPtrW( hwndEdit, GWLP_WNDPROC, (LONG_PTR) ACEditSubclassProc);
/* Keep at least one reference to the object until the edit window is destroyed. */
IAutoComplete2_AddRef((IAutoComplete2 *)This);
SetPropW( hwndEdit, autocomplete_propertyW, This );
if (This->options & ACO_AUTOSUGGEST)
create_listbox(This);
if (pwzsRegKeyPath) {
WCHAR *key;
WCHAR result[MAX_PATH];
WCHAR *value;
HKEY hKey = 0;
LONG res;
LONG len;
/* pwszRegKeyPath contains the key as well as the value, so we split */
key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwzsRegKeyPath)+1)*sizeof(WCHAR));
strcpyW(key, pwzsRegKeyPath);
value = strrchrW(key, '\\');
*value = 0;
value++;
/* Now value contains the value and buffer the key */
res = RegOpenKeyExW(HKEY_CURRENT_USER, key, 0, KEY_READ, &hKey);
if (res != ERROR_SUCCESS) {
/* if the key is not found, MSDN states we must seek in HKEY_LOCAL_MACHINE */
res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, key, 0, KEY_READ, &hKey);
}
if (res == ERROR_SUCCESS) {
res = RegQueryValueW(hKey, value, result, &len);
if (res == ERROR_SUCCESS) {
This->quickComplete = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
strcpyW(This->quickComplete, result);
}
RegCloseKey(hKey);
}
HeapFree(GetProcessHeap(), 0, key);
}
if ((pwszQuickComplete) && (!This->quickComplete)) {
This->quickComplete = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwszQuickComplete)+1)*sizeof(WCHAR));
lstrcpyW(This->quickComplete, pwszQuickComplete);
}
return S_OK;
}
/******************************************************************************
* IAutoComplete_fnInit
*/
static HRESULT WINAPI IAutoComplete_fnInit(
IAutoComplete * iface,
HWND hwndEdit,
IUnknown *punkACL,
LPCOLESTR pwzsRegKeyPath,
LPCOLESTR pwszQuickComplete)
{
IAutoCompleteImpl *This = (IAutoCompleteImpl *)iface;
static const WCHAR lbName[] = {'L','i','s','t','B','o','x',0};
TRACE("(%p)->(0x%08lx, %p, %s, %s)\n",
This, (long)hwndEdit, punkACL, debugstr_w(pwzsRegKeyPath), debugstr_w(pwszQuickComplete));
if (This->options & ACO_AUTOSUGGEST) TRACE(" ACO_AUTOSUGGEST\n");
if (This->options & ACO_AUTOAPPEND) TRACE(" ACO_AUTOAPPEND\n");
if (This->options & ACO_SEARCH) FIXME(" ACO_SEARCH not supported\n");
if (This->options & ACO_FILTERPREFIXES) FIXME(" ACO_FILTERPREFIXES not supported\n");
if (This->options & ACO_USETAB) FIXME(" ACO_USETAB not supported\n");
if (This->options & ACO_UPDOWNKEYDROPSLIST) TRACE(" ACO_UPDOWNKEYDROPSLIST\n");
if (This->options & ACO_RTLREADING) FIXME(" ACO_RTLREADING not supported\n");
This->hwndEdit = hwndEdit;
if (!SUCCEEDED (IUnknown_QueryInterface (punkACL, &IID_IEnumString, (LPVOID*)&This->enumstr))) {
TRACE("No IEnumString interface\n");
return E_NOINTERFACE;
}
This->wpOrigEditProc = (WNDPROC) SetWindowLongPtrW( hwndEdit, GWLP_WNDPROC, (LONG_PTR) ACEditSubclassProc);
SetWindowLongPtrW( hwndEdit, GWLP_USERDATA, (LONG_PTR)This);
if (This->options & ACO_AUTOSUGGEST) {
HWND hwndParent;
hwndParent = GetParent(This->hwndEdit);
/* FIXME : The listbox should be resizable with the mouse. WS_THICKFRAME looks ugly */
This->hwndListBox = CreateWindowExW(0, lbName, NULL,
WS_BORDER | WS_CHILD | WS_VSCROLL | LBS_HASSTRINGS | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hwndParent, NULL,
(HINSTANCE)GetWindowLongPtrW( hwndParent, GWLP_HINSTANCE ), NULL);
if (This->hwndListBox) {
This->wpOrigLBoxProc = (WNDPROC) SetWindowLongPtrW( This->hwndListBox, GWLP_WNDPROC, (LONG_PTR) ACLBoxSubclassProc);
SetWindowLongPtrW( This->hwndListBox, GWLP_USERDATA, (LONG_PTR)This);
}
}
if (pwzsRegKeyPath) {
WCHAR *key;
WCHAR result[MAX_PATH];
WCHAR *value;
HKEY hKey = 0;
LONG res;
LONG len;
/* pwszRegKeyPath contains the key as well as the value, so we split */
key = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwzsRegKeyPath)+1)*sizeof(WCHAR));
strcpyW(key, pwzsRegKeyPath);
value = strrchrW(key, '\\');
*value = 0;
value++;
/* Now value contains the value and buffer the key */
res = RegOpenKeyExW(HKEY_CURRENT_USER, key, 0, KEY_READ, &hKey);
if (res != ERROR_SUCCESS) {
/* if the key is not found, MSDN states we must seek in HKEY_LOCAL_MACHINE */
res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, key, 0, KEY_READ, &hKey);
}
if (res == ERROR_SUCCESS) {
res = RegQueryValueW(hKey, value, result, &len);
if (res == ERROR_SUCCESS) {
This->quickComplete = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
strcpyW(This->quickComplete, result);
}
RegCloseKey(hKey);
}
HeapFree(GetProcessHeap(), 0, key);
}
if ((pwszQuickComplete) && (!This->quickComplete)) {
This->quickComplete = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (lstrlenW(pwszQuickComplete)+1)*sizeof(WCHAR));
lstrcpyW(This->quickComplete, pwszQuickComplete);
}
return S_OK;
}
static void AddTypeLib(void)
{
TVINSERTSTRUCTW tvis;
HKEY hKey, hCurKey, hInfoKey, hPath;
WCHAR valName[MAX_LOAD_STRING];
WCHAR valParent[MAX_LOAD_STRING];
WCHAR buffer[MAX_LOAD_STRING];
WCHAR wszVer[MAX_LOAD_STRING];
WCHAR wszPath[MAX_LOAD_STRING];
const WCHAR wszFormat[] = { ' ','(','%','s',' ','%','s',')','\0' };
const WCHAR wszFormat2[] = { '%','s','\\','%','s','\0' };
LONG lenBuffer;
int i=-1, j;
U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
U(tvis).item.cchTextMax = MAX_LOAD_STRING;
tvis.hInsertAfter = TVI_FIRST;
tvis.hParent = tree.hTL;
if(RegOpenKeyW(HKEY_CLASSES_ROOT, wszTypeLib, &hKey) != ERROR_SUCCESS) return;
while(TRUE)
{
i++;
if(RegEnumKeyW(hKey, i, valParent, sizeof(valParent)/sizeof(valParent[0])) != ERROR_SUCCESS) break;
if(RegOpenKeyW(hKey, valParent, &hCurKey) != ERROR_SUCCESS) continue;
j = -1;
while(TRUE)
{
j++;
if(RegEnumKeyW(hCurKey, j, valName, sizeof(valName)/sizeof(valName[0])) != ERROR_SUCCESS) break;
if(RegOpenKeyW(hCurKey, valName, &hInfoKey) != ERROR_SUCCESS) continue;
lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);
if(RegQueryValueW(hInfoKey, NULL, buffer, &lenBuffer) == ERROR_SUCCESS
&& *buffer)
{
LoadStringW(globals.hMainInst, IDS_TL_VER, wszVer,
sizeof(wszVer)/sizeof(wszVer[0]));
wsprintfW(&buffer[lstrlenW(buffer)], wszFormat, wszVer, valName);
U(tvis).item.pszText = buffer;
lenBuffer = MAX_LOAD_STRING;
RegOpenKeyW(hInfoKey, wszGetPath, &hPath);
RegQueryValueW(hPath, NULL, wszPath, &lenBuffer);
RegCloseKey(hPath);
}
else U(tvis).item.pszText = valName;
RegCloseKey(hInfoKey);
wsprintfW(wszVer, wszFormat2, valParent, valName);
U(tvis).item.lParam = CreateITEM_INFO(REGPATH, wszVer, valParent, wszPath);
SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
}
RegCloseKey(hCurKey);
}
RegCloseKey(hKey);
SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hTL);
}
static void AddCOMandAll(void)
{
TVINSERTSTRUCTW tvis;
TVITEMW tvi;
HTREEITEM curSearch;
HKEY hKey, hCurKey, hInfo;
WCHAR valName[MAX_LOAD_STRING];
WCHAR buffer[MAX_LOAD_STRING];
WCHAR wszComp[MAX_LOAD_STRING];
LONG lenBuffer;
int i=-1;
memset(&tvi, 0, sizeof(TVITEMW));
U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM|TVIF_CHILDREN;
U(tvis).item.cchTextMax = MAX_LOAD_STRING;
U(tvis).item.cChildren = 1;
tvis.hInsertAfter = TVI_FIRST;
if(RegOpenKeyW(HKEY_CLASSES_ROOT, wszCLSID, &hKey) != ERROR_SUCCESS) return;
while(TRUE)
{
i++;
if(RegEnumKeyW(hKey, i, valName, sizeof(valName)/sizeof(valName[0])) != ERROR_SUCCESS) break;
if(RegOpenKeyW(hKey, valName, &hCurKey) != ERROR_SUCCESS) continue;
lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);
tvis.hParent = tree.hAO;
if(RegOpenKeyW(hCurKey, wszInProcServer32, &hInfo) == ERROR_SUCCESS)
{
if(RegQueryValueW(hInfo, NULL, buffer, &lenBuffer) == ERROR_SUCCESS
&& *buffer)
if(!memcmp(buffer, wszOle32dll, sizeof(WCHAR[9]))
||!memcmp(buffer, wszOleAut32dll, sizeof(WCHAR[12])))
tvis.hParent = tree.hCLO;
RegCloseKey(hInfo);
}
lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);
if(RegQueryValueW(hCurKey, NULL, buffer, &lenBuffer) == ERROR_SUCCESS && *buffer)
U(tvis).item.pszText = buffer;
else U(tvis).item.pszText = valName;
U(tvis).item.lParam = CreateITEM_INFO(REGPATH|SHOWALL, valName, valName, NULL);
if(tvis.hParent) SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
if(RegOpenKeyW(hCurKey, wszImplementedCategories, &hInfo) == ERROR_SUCCESS)
{
if(RegEnumKeyW(hInfo, 0, wszComp, sizeof(wszComp)/sizeof(wszComp[0])) != ERROR_SUCCESS) break;
RegCloseKey(hInfo);
if(tree.hGBCC) curSearch = (HTREEITEM)SendMessageW(globals.hTree,
TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)tree.hGBCC);
else curSearch = (HTREEITEM)SendMessageW(globals.hTree,
TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)TVI_ROOT);
while(curSearch)
{
tvi.hItem = curSearch;
if(!SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi)) break;
if(tvi.lParam && !lstrcmpW(((ITEM_INFO *)tvi.lParam)->info, wszComp))
{
tvis.hParent = curSearch;
memmove(&valName[6], valName, sizeof(WCHAR[MAX_LOAD_STRING-6]));
memmove(valName, wszCLSID, sizeof(WCHAR[6]));
U(tvis).item.lParam = CreateITEM_INFO(REGTOP|REGPATH|SHOWALL,
valName, &valName[6], NULL);
SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
break;
}
curSearch = (HTREEITEM)SendMessageW(globals.hTree,
TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)curSearch);
}
}
RegCloseKey(hCurKey);
}
RegCloseKey(hKey);
SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hCLO);
SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hAO);
}
/******************************************************************************
* IAutoComplete_fnInit
*/
HRESULT WINAPI CAutoComplete::Init(HWND hwndEdit, IUnknown *punkACL, LPCOLESTR pwzsRegKeyPath, LPCOLESTR pwszQuickComplete)
{
TRACE("(%p)->(0x%08lx, %p, %s, %s)\n",
this, hwndEdit, punkACL, debugstr_w(pwzsRegKeyPath), debugstr_w(pwszQuickComplete));
if (options & ACO_AUTOSUGGEST)
TRACE(" ACO_AUTOSUGGEST\n");
if (options & ACO_AUTOAPPEND)
TRACE(" ACO_AUTOAPPEND\n");
if (options & ACO_SEARCH)
FIXME(" ACO_SEARCH not supported\n");
if (options & ACO_FILTERPREFIXES)
FIXME(" ACO_FILTERPREFIXES not supported\n");
if (options & ACO_USETAB)
FIXME(" ACO_USETAB not supported\n");
if (options & ACO_UPDOWNKEYDROPSLIST)
TRACE(" ACO_UPDOWNKEYDROPSLIST\n");
if (options & ACO_RTLREADING)
FIXME(" ACO_RTLREADING not supported\n");
if (!hwndEdit || !punkACL)
return E_INVALIDARG;
if (this->initialized)
{
WARN("Autocompletion object is already initialized\n");
/* This->hwndEdit is set to NULL when the edit window is destroyed. */
return this->hwndEdit ? E_FAIL : E_UNEXPECTED;
}
if (!SUCCEEDED(punkACL->QueryInterface(IID_PPV_ARG(IEnumString,&enumstr))))
{
TRACE("No IEnumString interface\n");
return E_NOINTERFACE;
}
this->hwndEdit = hwndEdit;
this->initialized = TRUE;
this->wpOrigEditProc = (WNDPROC)SetWindowLongPtrW(hwndEdit, GWLP_WNDPROC, (LONG_PTR) ACEditSubclassProc);
/* Keep at least one reference to the object until the edit window is destroyed. */
this->AddRef();
SetPropW( this->hwndEdit, autocomplete_propertyW, (HANDLE)this );
if (options & ACO_AUTOSUGGEST)
{
this->CreateListbox();
}
if (pwzsRegKeyPath)
{
WCHAR *key;
WCHAR result[MAX_PATH];
WCHAR *value;
HKEY hKey = 0;
LONG res;
LONG len;
/* pwszRegKeyPath contains the key as well as the value, so we split */
key = (WCHAR *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (wcslen(pwzsRegKeyPath) + 1) * sizeof(WCHAR));
if (key)
{
wcscpy(key, pwzsRegKeyPath);
value = const_cast<WCHAR *>(wcsrchr(key, '\\'));
if (value)
{
*value = 0;
value++;
/* Now value contains the value and buffer the key */
res = RegOpenKeyExW(HKEY_CURRENT_USER, key, 0, KEY_READ, &hKey);
if (res != ERROR_SUCCESS)
{
/* if the key is not found, MSDN states we must seek in HKEY_LOCAL_MACHINE */
res = RegOpenKeyExW(HKEY_LOCAL_MACHINE, key, 0, KEY_READ, &hKey);
}
if (res == ERROR_SUCCESS)
{
len = sizeof(result);
res = RegQueryValueW(hKey, value, result, &len);
if (res == ERROR_SUCCESS)
{
quickComplete = (WCHAR *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR));
wcscpy(quickComplete, result);
}
RegCloseKey(hKey);
}
}
HeapFree(GetProcessHeap(), 0, key);
}
else
{
TRACE("HeapAlloc Failed when trying to alloca %d bytes\n", (wcslen(pwzsRegKeyPath) + 1) * sizeof(WCHAR));
return S_FALSE;
}
}
if ((pwszQuickComplete) && (!quickComplete))
{
quickComplete = (WCHAR *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (wcslen(pwszQuickComplete) + 1) * sizeof(WCHAR));
if (quickComplete)
{
wcscpy(quickComplete, pwszQuickComplete);
}
else
{
TRACE("HeapAlloc Failed when trying to alloca %d bytes\n", (wcslen(pwszQuickComplete) + 1) * sizeof(WCHAR));
return S_FALSE;
}
}
return S_OK;
}
