1 /*
2 * IQueryAssociations object and helper functions
3 *
4 * Copyright 2002 Jon Griffiths
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20 #include <stdarg.h>
21 #include <assert.h>
22
23 #define COBJMACROS
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winnls.h"
27 #include "winreg.h"
28 #include "objbase.h"
29 #include "shlguid.h"
30 #include "shlwapi.h"
31 #include "shobjidl.h"
32 #include "shell32_main.h"
33 #include "ver.h"
34 #include "wine/unicode.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(shell);
38
39 /**************************************************************************
40 * IQueryAssociations
41 *
42 * DESCRIPTION
43 * This object provides a layer of abstraction over the system registry in
44 * order to simplify the process of parsing associations between files.
45 * Associations in this context means the registry entries that link (for
46 * example) the extension of a file with its description, list of
47 * applications to open the file with, and actions that can be performed on it
48 * (the shell displays such information in the context menu of explorer
49 * when you right-click on a file).
50 *
51 * HELPERS
52 * You can use this object transparently by calling the helper functions
53 * AssocQueryKeyA(), AssocQueryStringA() and AssocQueryStringByKeyA(). These
54 * create an IQueryAssociations object, perform the requested actions
55 * and then dispose of the object. Alternatively, you can create an instance
56 * of the object using AssocCreate() and call the following methods on it:
57 *
58 * METHODS
59 */
60
61 typedef struct
62 {
63 IQueryAssociations IQueryAssociations_iface;
64 LONG ref;
65 HKEY hkeySource;
66 HKEY hkeyProgID;
67 } IQueryAssociationsImpl;
68
69 typedef struct
70 {
71 IApplicationAssociationRegistration IApplicationAssociationRegistration_iface;
72 LONG ref;
73 } IApplicationAssociationRegistrationImpl;
74
75
76 static inline IQueryAssociationsImpl *impl_from_IQueryAssociations(IQueryAssociations *iface)
77 {
78 return CONTAINING_RECORD(iface, IQueryAssociationsImpl, IQueryAssociations_iface);
79 }
80
81 /**************************************************************************
82 * IQueryAssociations_QueryInterface
83 *
84 * See IUnknown_QueryInterface.
85 */
86 static HRESULT WINAPI IQueryAssociations_fnQueryInterface(
87 IQueryAssociations* iface,
88 REFIID riid,
89 LPVOID *ppvObj)
90 {
91 IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
92
93 TRACE("(%p,%s,%p)\n",This, debugstr_guid(riid), ppvObj);
94
95 if (ppvObj == NULL)
96 return E_POINTER;
97
98 *ppvObj = NULL;
99
100 if (IsEqualIID(riid, &IID_IUnknown) ||
101 IsEqualIID(riid, &IID_IQueryAssociations))
102 {
103 *ppvObj = This;
104
105 IQueryAssociations_AddRef((IQueryAssociations*)*ppvObj);
106 TRACE("Returning IQueryAssociations (%p)\n", *ppvObj);
107 return S_OK;
108 }
109 TRACE("Returning E_NOINTERFACE\n");
110 return E_NOINTERFACE;
111 }
112
113 /**************************************************************************
114 * IQueryAssociations_AddRef
115 *
116 * See IUnknown_AddRef.
117 */
118 static ULONG WINAPI IQueryAssociations_fnAddRef(IQueryAssociations *iface)
119 {
120 IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
121 ULONG refCount = InterlockedIncrement(&This->ref);
122
123 TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
124
125 return refCount;
126 }
127
128 /**************************************************************************
129 * IQueryAssociations_Release
130 *
131 * See IUnknown_Release.
132 */
133 static ULONG WINAPI IQueryAssociations_fnRelease(IQueryAssociations *iface)
134 {
135 IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
136 ULONG refCount = InterlockedDecrement(&This->ref);
137
138 TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
139
140 if (!refCount)
141 {
142 TRACE("Destroying IQueryAssociations (%p)\n", This);
143 RegCloseKey(This->hkeySource);
144 RegCloseKey(This->hkeyProgID);
145 SHFree(This);
146 }
147
148 return refCount;
149 }
150
151 /**************************************************************************
152 * IQueryAssociations_Init
153 *
154 * Initialise an IQueryAssociations object.
155 *
156 * PARAMS
157 * iface [I] IQueryAssociations interface to initialise
158 * cfFlags [I] ASSOCF_ flags from "shlwapi.h"
159 * pszAssoc [I] String for the root key name, or NULL if hkeyProgid is given
160 * hkeyProgid [I] Handle for the root key, or NULL if pszAssoc is given
161 * hWnd [I] Reserved, must be NULL.
162 *
163 * RETURNS
164 * Success: S_OK. iface is initialised with the parameters given.
165 * Failure: An HRESULT error code indicating the error.
166 */
167 static HRESULT WINAPI IQueryAssociations_fnInit(
168 IQueryAssociations *iface,
169 ASSOCF cfFlags,
170 LPCWSTR pszAssoc,
171 HKEY hkeyProgid,
172 HWND hWnd)
173 {
174 static const WCHAR szProgID[] = {'P','r','o','g','I','D',0};
175 IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
176 LONG ret;
177
178 TRACE("(%p)->(%d,%s,%p,%p)\n", iface,
179 cfFlags,
180 debugstr_w(pszAssoc),
181 hkeyProgid,
182 hWnd);
183 if (hWnd != NULL)
184 FIXME("hwnd != NULL not supported\n");
185 if (cfFlags != 0)
186 FIXME("unsupported flags: %x\n", cfFlags);
187 if (pszAssoc != NULL)
188 {
189 ret = RegOpenKeyExW(HKEY_CLASSES_ROOT,
190 pszAssoc,
191 0,
192 KEY_READ,
193 &This->hkeySource);
194 if (ret != ERROR_SUCCESS)
195 return E_FAIL;
196 /* if this is not a prog id */
197 if ((*pszAssoc == '.') || (*pszAssoc == '{'))
198 {
199 RegOpenKeyExW(This->hkeySource,
200 szProgID,
201 0,
202 KEY_READ,
203 &This->hkeyProgID);
204 }
205 else
206 This->hkeyProgID = This->hkeySource;
207 return S_OK;
208 }
209 else if (hkeyProgid != NULL)
210 {
211 This->hkeyProgID = hkeyProgid;
212 return S_OK;
213 }
214 else
215 return E_INVALIDARG;
216 }
217
218 static HRESULT ASSOC_GetValue(HKEY hkey, const WCHAR *name, void **data, DWORD *data_size)
219 {
220 DWORD size;
221 LONG ret;
222
223 assert(data);
224 ret = RegQueryValueExW(hkey, name, 0, NULL, NULL, &size);
225 if (ret != ERROR_SUCCESS)
226 return HRESULT_FROM_WIN32(ret);
227 if (!size)
228 return E_FAIL;
229 *data = HeapAlloc(GetProcessHeap(), 0, size);
230 if (!*data)
231 return E_OUTOFMEMORY;
232 ret = RegQueryValueExW(hkey, name, 0, NULL, (LPBYTE)*data, &size);
233 if (ret != ERROR_SUCCESS)
234 {
235 HeapFree(GetProcessHeap(), 0, *data);
236 return HRESULT_FROM_WIN32(ret);
237 }
238 if(data_size)
239 *data_size = size;
240 return S_OK;
241 }
242
243 static HRESULT ASSOC_GetCommand(IQueryAssociationsImpl *This,
244 LPCWSTR pszExtra, WCHAR **ppszCommand)
245 {
246 HKEY hkeyCommand;
247 HKEY hkeyFile;
248 HKEY hkeyShell;
249 HKEY hkeyVerb;
250 HRESULT hr;
251 LONG ret;
252 WCHAR * pszExtraFromReg = NULL;
253 WCHAR * pszFileType;
254 static const WCHAR commandW[] = { 'c','o','m','m','a','n','d',0 };
255 static const WCHAR shellW[] = { 's','h','e','l','l',0 };
256
257 hr = ASSOC_GetValue(This->hkeySource, NULL, (void**)&pszFileType, NULL);
258 if (FAILED(hr))
259 return hr;
260 ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, pszFileType, 0, KEY_READ, &hkeyFile);
261 HeapFree(GetProcessHeap(), 0, pszFileType);
262 if (ret != ERROR_SUCCESS)
263 return HRESULT_FROM_WIN32(ret);
264
265 ret = RegOpenKeyExW(hkeyFile, shellW, 0, KEY_READ, &hkeyShell);
266 RegCloseKey(hkeyFile);
267 if (ret != ERROR_SUCCESS)
268 return HRESULT_FROM_WIN32(ret);
269
270 if (!pszExtra)
271 {
272 hr = ASSOC_GetValue(hkeyShell, NULL, (void**)&pszExtraFromReg, NULL);
273 /* if no default action */
274 if (hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
275 {
276 DWORD rlen;
277 ret = RegQueryInfoKeyW(hkeyShell, 0, 0, 0, 0, &rlen, 0, 0, 0, 0, 0, 0);
278 if (ret != ERROR_SUCCESS)
279 {
280 RegCloseKey(hkeyShell);
281 return HRESULT_FROM_WIN32(ret);
282 }
283 rlen++;
284 pszExtraFromReg = HeapAlloc(GetProcessHeap(), 0, rlen * sizeof(WCHAR));
285 if (!pszExtraFromReg)
286 {
287 RegCloseKey(hkeyShell);
288 return E_OUTOFMEMORY;
289 }
290 ret = RegEnumKeyExW(hkeyShell, 0, pszExtraFromReg, &rlen, 0, NULL, NULL, NULL);
291 if (ret != ERROR_SUCCESS)
292 {
293 RegCloseKey(hkeyShell);
294 return HRESULT_FROM_WIN32(ret);
295 }
296 }
297 else if (FAILED(hr))
298 {
299 RegCloseKey(hkeyShell);
300 return hr;
301 }
302 }
303
304 ret = RegOpenKeyExW(hkeyShell, pszExtra ? pszExtra : pszExtraFromReg, 0,
305 KEY_READ, &hkeyVerb);
306 HeapFree(GetProcessHeap(), 0, pszExtraFromReg);
307 RegCloseKey(hkeyShell);
308 if (ret != ERROR_SUCCESS)
309 return HRESULT_FROM_WIN32(ret);
310
311 ret = RegOpenKeyExW(hkeyVerb, commandW, 0, KEY_READ, &hkeyCommand);
312 RegCloseKey(hkeyVerb);
313 if (ret != ERROR_SUCCESS)
314 return HRESULT_FROM_WIN32(ret);
315 hr = ASSOC_GetValue(hkeyCommand, NULL, (void**)ppszCommand, NULL);
316 RegCloseKey(hkeyCommand);
317 return hr;
318 }
319
320 static HRESULT ASSOC_GetExecutable(IQueryAssociationsImpl *This,
321 LPCWSTR pszExtra, LPWSTR path,
322 DWORD pathlen, DWORD *len)
323 {
324 WCHAR *pszCommand;
325 WCHAR *pszStart;
326 WCHAR *pszEnd;
327 HRESULT hr;
328
329 assert(len);
330
331 hr = ASSOC_GetCommand(This, pszExtra, &pszCommand);
332 if (FAILED(hr))
333 return hr;
334
335 /* cleanup pszCommand */
336 if (pszCommand[0] == '"')
337 {
338 pszStart = pszCommand + 1;
339 pszEnd = strchrW(pszStart, '"');
340 if (pszEnd)
341 *pszEnd = 0;
342 *len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
343 }
344 else
345 {
346 pszStart = pszCommand;
347 for (pszEnd = pszStart; (pszEnd = strchrW(pszEnd, ' ')); pszEnd++)
348 {
349 WCHAR c = *pszEnd;
350 *pszEnd = 0;
351 if ((*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL)))
352 break;
353 *pszEnd = c;
354 }
355 if (!pszEnd)
356 *len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
357 }
358
359 HeapFree(GetProcessHeap(), 0, pszCommand);
360 if (!*len)
361 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
362 return S_OK;
363 }
364
365 static HRESULT ASSOC_ReturnData(void *out, DWORD *outlen, const void *data,
366 DWORD datalen)
367 {
368 assert(outlen);
369
370 if (out)
371 {
372 if (*outlen < datalen)
373 {
374 *outlen = datalen;
375 return E_POINTER;
376 }
377 *outlen = datalen;
378 memcpy(out, data, datalen);
379 return S_OK;
380 }
381 else
382 {
383 *outlen = datalen;
384 return S_FALSE;
385 }
386 }
387
388 static HRESULT ASSOC_ReturnString(LPWSTR out, DWORD *outlen, LPCWSTR data,
389 DWORD datalen)
390 {
391 HRESULT hres;
392
393 assert(outlen);
394
395 *outlen *= sizeof(WCHAR);
396 hres = ASSOC_ReturnData(out, outlen, data, datalen*sizeof(WCHAR));
397 *outlen /= sizeof(WCHAR);
398 return hres;
399 }
400
401 /**************************************************************************
402 * IQueryAssociations_GetString
403 *
404 * Get a file association string from the registry.
405 *
406 * PARAMS
407 * iface [I] IQueryAssociations interface to query
408 * cfFlags [I] ASSOCF_ flags from "shlwapi.h"
409 * str [I] Type of string to get (ASSOCSTR enum from "shlwapi.h")
410 * pszExtra [I] Extra information about the string location
411 * pszOut [O] Destination for the association string
412 * pcchOut [I/O] Length of pszOut
413 *
414 * RETURNS
415 * Success: S_OK. pszOut contains the string, pcchOut contains its length.
416 * Failure: An HRESULT error code indicating the error.
417 */
418 static HRESULT WINAPI IQueryAssociations_fnGetString(
419 IQueryAssociations *iface,
420 ASSOCF cfFlags,
421 ASSOCSTR str,
422 LPCWSTR pszExtra,
423 LPWSTR pszOut,
424 DWORD *pcchOut)
425 {
426 IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
427 const ASSOCF cfUnimplemented = ~(0);
428 DWORD len = 0;
429 HRESULT hr;
430 WCHAR path[MAX_PATH];
431
432 TRACE("(%p,0x%8x,0x%8x,%s,%p,%p)\n", This, cfFlags, str,
433 debugstr_w(pszExtra), pszOut, pcchOut);
434
435 if (cfFlags & cfUnimplemented)
436 FIXME("%08x: unimplemented flags!\n", cfFlags & cfUnimplemented);
437
438 if (!pcchOut)
439 return E_UNEXPECTED;
440
441 switch (str)
442 {
443 case ASSOCSTR_COMMAND:
444 {
445 WCHAR *command;
446 hr = ASSOC_GetCommand(This, pszExtra, &command);
447 if (SUCCEEDED(hr))
448 {
449 hr = ASSOC_ReturnString(pszOut, pcchOut, command, strlenW(command) + 1);
450 HeapFree(GetProcessHeap(), 0, command);
451 }
452 return hr;
453 }
454
455 case ASSOCSTR_EXECUTABLE:
456 {
457 hr = ASSOC_GetExecutable(This, pszExtra, path, MAX_PATH, &len);
458 if (FAILED(hr))
459 return hr;
460 len++;
461 return ASSOC_ReturnString(pszOut, pcchOut, path, len);
462 }
463
464 case ASSOCSTR_FRIENDLYDOCNAME:
465 {
466 WCHAR *pszFileType;
467 DWORD ret;
468 DWORD size;
469
470 hr = ASSOC_GetValue(This->hkeySource, NULL, (void**)&pszFileType, NULL);
471 if (FAILED(hr))
472 return hr;
473 size = 0;
474 ret = RegGetValueW(HKEY_CLASSES_ROOT, pszFileType, NULL, RRF_RT_REG_SZ, NULL, NULL, &size);
475 if (ret == ERROR_SUCCESS)
476 {
477 WCHAR *docName = HeapAlloc(GetProcessHeap(), 0, size);
478 if (docName)
479 {
480 ret = RegGetValueW(HKEY_CLASSES_ROOT, pszFileType, NULL, RRF_RT_REG_SZ, NULL, docName, &size);
481 if (ret == ERROR_SUCCESS)
482 hr = ASSOC_ReturnString(pszOut, pcchOut, docName, strlenW(docName) + 1);
483 else
484 hr = HRESULT_FROM_WIN32(ret);
485 HeapFree(GetProcessHeap(), 0, docName);
486 }
487 else
488 hr = E_OUTOFMEMORY;
489 }
490 else
491 hr = HRESULT_FROM_WIN32(ret);
492 HeapFree(GetProcessHeap(), 0, pszFileType);
493 return hr;
494 }
495
496 case ASSOCSTR_FRIENDLYAPPNAME:
497 {
498 PVOID verinfoW = NULL;
499 DWORD size, retval = 0;
500 UINT flen;
501 WCHAR *bufW;
502 static const WCHAR translationW[] = {
503 '\\','V','a','r','F','i','l','e','I','n','f','o',
504 '\\','T','r','a','n','s','l','a','t','i','o','n',0
505 };
506 static const WCHAR fileDescFmtW[] = {
507 '\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o',
508 '\\','%','','4','x','%','','4','x',
509 '\\','F','i','l','e','D','e','s','c','r','i','p','t','i','o','n',0
510 };
511 WCHAR fileDescW[41];
512
513 hr = ASSOC_GetExecutable(This, pszExtra, path, MAX_PATH, &len);
514 if (FAILED(hr))
515 return hr;
516
517 retval = GetFileVersionInfoSizeW(path, &size);
518 if (!retval)
519 goto get_friendly_name_fail;
520 verinfoW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, retval);
521 if (!verinfoW)
522 return E_OUTOFMEMORY;
523 if (!GetFileVersionInfoW(path, 0, retval, verinfoW))
524 goto get_friendly_name_fail;
525 if (VerQueryValueW(verinfoW, translationW, (LPVOID *)&bufW, &flen))
526 {
527 UINT i;
528 DWORD *langCodeDesc = (DWORD *)bufW;
529 for (i = 0; i < flen / sizeof(DWORD); i++)
530 {
531 sprintfW(fileDescW, fileDescFmtW, LOWORD(langCodeDesc[i]),
532 HIWORD(langCodeDesc[i]));
533 if (VerQueryValueW(verinfoW, fileDescW, (LPVOID *)&bufW, &flen))
534 {
535 /* Does strlenW(bufW) == 0 mean we use the filename? */
536 len = strlenW(bufW) + 1;
537 TRACE("found FileDescription: %s\n", debugstr_w(bufW));
538 hr = ASSOC_ReturnString(pszOut, pcchOut, bufW, len);
539 HeapFree(GetProcessHeap(), 0, verinfoW);
540 return hr;
541 }
542 }
543 }
544 get_friendly_name_fail:
545 PathRemoveExtensionW(path);
546 PathStripPathW(path);
547 TRACE("using filename: %s\n", debugstr_w(path));
548 hr = ASSOC_ReturnString(pszOut, pcchOut, path, strlenW(path) + 1);
549 HeapFree(GetProcessHeap(), 0, verinfoW);
550 return hr;
551 }
552
553 case ASSOCSTR_CONTENTTYPE:
554 {
555 static const WCHAR Content_TypeW[] = {'C','o','n','t','e','n','t',' ','T','y','p','e',0};
556 WCHAR *contentType;
557 DWORD ret;
558 DWORD size;
559
560 size = 0;
561 ret = RegGetValueW(This->hkeySource, NULL, Content_TypeW, RRF_RT_REG_SZ, NULL, NULL, &size);
562 if (ret != ERROR_SUCCESS)
563 return HRESULT_FROM_WIN32(ret);
564 contentType = HeapAlloc(GetProcessHeap(), 0, size);
565 if (contentType != NULL)
566 {
567 ret = RegGetValueW(This->hkeySource, NULL, Content_TypeW, RRF_RT_REG_SZ, NULL, contentType, &size);
568 if (ret == ERROR_SUCCESS)
569 hr = ASSOC_ReturnString(pszOut, pcchOut, contentType, strlenW(contentType) + 1);
570 else
571 hr = HRESULT_FROM_WIN32(ret);
572 HeapFree(GetProcessHeap(), 0, contentType);
573 }
574 else
575 hr = E_OUTOFMEMORY;
576 return hr;
577 }
578
579 case ASSOCSTR_DEFAULTICON:
580 {
581 static const WCHAR DefaultIconW[] = {'D','e','f','a','u','l','t','I','c','o','n',0};
582 WCHAR *pszFileType;
583 DWORD ret;
584 DWORD size;
585 HKEY hkeyFile;
586
587 hr = ASSOC_GetValue(This->hkeySource, NULL, (void**)&pszFileType, NULL);
588 if (FAILED(hr))
589 return hr;
590 ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, pszFileType, 0, KEY_READ, &hkeyFile);
591 if (ret == ERROR_SUCCESS)
592 {
593 size = 0;
594 ret = RegGetValueW(hkeyFile, DefaultIconW, NULL, RRF_RT_REG_SZ, NULL, NULL, &size);
595 if (ret == ERROR_SUCCESS)
596 {
597 WCHAR *icon = HeapAlloc(GetProcessHeap(), 0, size);
598 if (icon)
599 {
600 ret = RegGetValueW(hkeyFile, DefaultIconW, NULL, RRF_RT_REG_SZ, NULL, icon, &size);
601 if (ret == ERROR_SUCCESS)
602 hr = ASSOC_ReturnString(pszOut, pcchOut, icon, strlenW(icon) + 1);
603 else
604 hr = HRESULT_FROM_WIN32(ret);
605 HeapFree(GetProcessHeap(), 0, icon);
606 }
607 else
608 hr = E_OUTOFMEMORY;
609 }
610 else
611 hr = HRESULT_FROM_WIN32(ret);
612 RegCloseKey(hkeyFile);
613 }
614 else
615 hr = HRESULT_FROM_WIN32(ret);
616 HeapFree(GetProcessHeap(), 0, pszFileType);
617 return hr;
618 }
619
620 default:
621 FIXME("assocstr %d unimplemented!\n", str);
622 return E_NOTIMPL;
623 }
624 }
625
626 /**************************************************************************
627 * IQueryAssociations_GetKey
628 *
629 * Get a file association key from the registry.
630 *
631 * PARAMS
632 * iface [I] IQueryAssociations interface to query
633 * cfFlags [I] ASSOCF_ flags from "shlwapi.h"
634 * assockey [I] Type of key to get (ASSOCKEY enum from "shlwapi.h")
635 * pszExtra [I] Extra information about the key location
636 * phkeyOut [O] Destination for the association key
637 *
638 * RETURNS
639 * Success: S_OK. phkeyOut contains a handle to the key.
640 * Failure: An HRESULT error code indicating the error.
641 */
642 static HRESULT WINAPI IQueryAssociations_fnGetKey(
643 IQueryAssociations *iface,
644 ASSOCF cfFlags,
645 ASSOCKEY assockey,
646 LPCWSTR pszExtra,
647 HKEY *phkeyOut)
648 {
649 IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
650
651 FIXME("(%p,0x%8x,0x%8x,%s,%p)-stub!\n", This, cfFlags, assockey,
652 debugstr_w(pszExtra), phkeyOut);
653 return E_NOTIMPL;
654 }
655
656 /**************************************************************************
657 * IQueryAssociations_GetData
658 *
659 * Get the data for a file association key from the registry.
660 *
661 * PARAMS
662 * iface [I] IQueryAssociations interface to query
663 * cfFlags [I] ASSOCF_ flags from "shlwapi.h"
664 * assocdata [I] Type of data to get (ASSOCDATA enum from "shlwapi.h")
665 * pszExtra [I] Extra information about the data location
666 * pvOut [O] Destination for the association key
667 * pcbOut [I/O] Size of pvOut
668 *
669 * RETURNS
670 * Success: S_OK. pszOut contains the data, pcbOut contains its length.
671 * Failure: An HRESULT error code indicating the error.
672 */
673 static HRESULT WINAPI IQueryAssociations_fnGetData(IQueryAssociations *iface,
674 ASSOCF cfFlags, ASSOCDATA assocdata, LPCWSTR pszExtra, LPVOID pvOut,
675 DWORD *pcbOut)
676 {
677 static const WCHAR edit_flags[] = {'E','d','i','t','F','l','a','g','s',0};
678
679 IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
680 void *data;
681 DWORD size;
682 HRESULT hres;
683
684 TRACE("(%p,0x%8x,0x%8x,%s,%p,%p)\n", This, cfFlags, assocdata,
685 debugstr_w(pszExtra), pvOut, pcbOut);
686
687 if(cfFlags)
688 FIXME("Unsupported flags: %x\n", cfFlags);
689
690 switch(assocdata) {
691 case ASSOCDATA_EDITFLAGS:
692 if(!This->hkeyProgID)
693 return HRESULT_FROM_WIN32(ERROR_NO_ASSOCIATION);
694
695 hres = ASSOC_GetValue(This->hkeyProgID, edit_flags, &data, &size);
696 if(FAILED(hres) || !pcbOut)
697 return hres;
698
699 hres = ASSOC_ReturnData(pvOut, pcbOut, data, size);
700 HeapFree(GetProcessHeap(), 0, data);
701 return hres;
702 default:
703 FIXME("Unsupported ASSOCDATA value: %d\n", assocdata);
704 return E_NOTIMPL;
705 }
706 }
707
708 /**************************************************************************
709 * IQueryAssociations_GetEnum
710 *
711 * Not yet implemented in native Win32.
712 *
713 * PARAMS
714 * iface [I] IQueryAssociations interface to query
715 * cfFlags [I] ASSOCF_ flags from "shlwapi.h"
716 * assocenum [I] Type of enum to get (ASSOCENUM enum from "shlwapi.h")
717 * pszExtra [I] Extra information about the enum location
718 * riid [I] REFIID to look for
719 * ppvOut [O] Destination for the interface.
720 *
721 * RETURNS
722 * Success: S_OK.
723 * Failure: An HRESULT error code indicating the error.
724 *
725 * NOTES
726 * Presumably this function returns an enumerator object.
727 */
728 static HRESULT WINAPI IQueryAssociations_fnGetEnum(
729 IQueryAssociations *iface,
730 ASSOCF cfFlags,
731 ASSOCENUM assocenum,
732 LPCWSTR pszExtra,
733 REFIID riid,
734 LPVOID *ppvOut)
735 {
736 IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
737
738 FIXME("(%p,0x%8x,0x%8x,%s,%s,%p)-stub!\n", This, cfFlags, assocenum,
739 debugstr_w(pszExtra), debugstr_guid(riid), ppvOut);
740 return E_NOTIMPL;
741 }
742
743 static const IQueryAssociationsVtbl IQueryAssociations_vtbl =
744 {
745 IQueryAssociations_fnQueryInterface,
746 IQueryAssociations_fnAddRef,
747 IQueryAssociations_fnRelease,
748 IQueryAssociations_fnInit,
749 IQueryAssociations_fnGetString,
750 IQueryAssociations_fnGetKey,
751 IQueryAssociations_fnGetData,
752 IQueryAssociations_fnGetEnum
753 };
754
755 /**************************************************************************
756 * IApplicationAssociationRegistration implementation
757 */
758 static inline IApplicationAssociationRegistrationImpl *impl_from_IApplicationAssociationRegistration(IApplicationAssociationRegistration *iface)
759 {
760 return CONTAINING_RECORD(iface, IApplicationAssociationRegistrationImpl, IApplicationAssociationRegistration_iface);
761 }
762
763 static HRESULT WINAPI ApplicationAssociationRegistration_QueryInterface(
764 IApplicationAssociationRegistration* iface, REFIID riid, LPVOID *ppv)
765 {
766 IApplicationAssociationRegistrationImpl *This = impl_from_IApplicationAssociationRegistration(iface);
767
768 TRACE("(%p, %s, %p)\n",This, debugstr_guid(riid), ppv);
769
770 if (ppv == NULL)
771 return E_POINTER;
772
773 if (IsEqualGUID(&IID_IUnknown, riid) ||
774 IsEqualGUID(&IID_IApplicationAssociationRegistration, riid)) {
775 *ppv = &This->IApplicationAssociationRegistration_iface;
776 IUnknown_AddRef((IUnknown*)*ppv);
777 TRACE("returning IApplicationAssociationRegistration: %p\n", *ppv);
778 return S_OK;
779 }
780
781 *ppv = NULL;
782 FIXME("(%p)->(%s %p) interface not supported\n", This, debugstr_guid(riid), ppv);
783 return E_NOINTERFACE;
784 }
785
786 static ULONG WINAPI ApplicationAssociationRegistration_AddRef(IApplicationAssociationRegistration *iface)
787 {
788 IApplicationAssociationRegistrationImpl *This = impl_from_IApplicationAssociationRegistration(iface);
789 ULONG ref = InterlockedIncrement(&This->ref);
790
791 TRACE("(%p) ref=%d\n", This, ref);
792 return ref;
793 }
794
795 static ULONG WINAPI ApplicationAssociationRegistration_Release(IApplicationAssociationRegistration *iface)
796 {
797 IApplicationAssociationRegistrationImpl *This = impl_from_IApplicationAssociationRegistration(iface);
798 ULONG ref = InterlockedDecrement(&This->ref);
799
800 TRACE("(%p) ref=%d\n", This, ref);
801
802 if (!ref) {
803 SHFree(This);
804 }
805 return ref;
806 }
807
808 static HRESULT WINAPI ApplicationAssociationRegistration_QueryCurrentDefault(IApplicationAssociationRegistration* This, LPCWSTR query,
809 ASSOCIATIONTYPE type, ASSOCIATIONLEVEL level, LPWSTR *association)
810 {
811 FIXME("(%p)->(%s, %d, %d, %p)\n", This, debugstr_w(query), type, level, association);
812 return E_NOTIMPL;
813 }
814
815 static HRESULT WINAPI ApplicationAssociationRegistration_QueryAppIsDefault(IApplicationAssociationRegistration* This, LPCWSTR query,
816 ASSOCIATIONTYPE type, ASSOCIATIONLEVEL level, LPCWSTR appname, BOOL *is_default)
817 {
818 FIXME("(%p)->(%s, %d, %d, %s, %p)\n", This, debugstr_w(query), type, level, debugstr_w(appname), is_default);
819 return E_NOTIMPL;
820 }
821
822 static HRESULT WINAPI ApplicationAssociationRegistration_QueryAppIsDefaultAll(IApplicationAssociationRegistration* This, ASSOCIATIONLEVEL level,
823 LPCWSTR appname, BOOL *is_default)
824 {
825 FIXME("(%p)->(%d, %s, %p)\n", This, level, debugstr_w(appname), is_default);
826 return E_NOTIMPL;
827 }
828
829 static HRESULT WINAPI ApplicationAssociationRegistration_SetAppAsDefault(IApplicationAssociationRegistration* This, LPCWSTR appname,
830 LPCWSTR set, ASSOCIATIONTYPE set_type)
831 {
832 FIXME("(%p)->(%s, %s, %d)\n", This, debugstr_w(appname), debugstr_w(set), set_type);
833 return E_NOTIMPL;
834 }
835
836 static HRESULT WINAPI ApplicationAssociationRegistration_SetAppAsDefaultAll(IApplicationAssociationRegistration* This, LPCWSTR appname)
837 {
838 FIXME("(%p)->(%s)\n", This, debugstr_w(appname));
839 return E_NOTIMPL;
840 }
841
842
843 static HRESULT WINAPI ApplicationAssociationRegistration_ClearUserAssociations(IApplicationAssociationRegistration* This)
844 {
845 FIXME("(%p)\n", This);
846 return E_NOTIMPL;
847 }
848
849
850 static const IApplicationAssociationRegistrationVtbl IApplicationAssociationRegistration_vtbl =
851 {
852 ApplicationAssociationRegistration_QueryInterface,
853 ApplicationAssociationRegistration_AddRef,
854 ApplicationAssociationRegistration_Release,
855 ApplicationAssociationRegistration_QueryCurrentDefault,
856 ApplicationAssociationRegistration_QueryAppIsDefault,
857 ApplicationAssociationRegistration_QueryAppIsDefaultAll,
858 ApplicationAssociationRegistration_SetAppAsDefault,
859 ApplicationAssociationRegistration_SetAppAsDefaultAll,
860 ApplicationAssociationRegistration_ClearUserAssociations
861 };
862
863 /**************************************************************************
864 * IQueryAssociations_Constructor [internal]
865 *
866 * Construct a new IQueryAssociations object.
867 */
868 HRESULT WINAPI QueryAssociations_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppOutput)
869 {
870 IQueryAssociationsImpl* this;
871 HRESULT ret;
872
873 if (pUnkOuter) return CLASS_E_NOAGGREGATION;
874
875 if (!(this = SHAlloc(sizeof(*this)))) return E_OUTOFMEMORY;
876 this->IQueryAssociations_iface.lpVtbl = &IQueryAssociations_vtbl;
877 this->ref = 0;
878 this->hkeySource = 0;
879 this->hkeyProgID = 0;
880 if (FAILED(ret = IUnknown_QueryInterface((IUnknown *)this, riid, ppOutput))) SHFree( this );
881 TRACE("returning %p\n", *ppOutput);
882 return ret;
883 }
884
885 /**************************************************************************
886 * ApplicationAssociationRegistration_Constructor [internal]
887 *
888 * Construct a IApplicationAssociationRegistration object.
889 */
890 HRESULT WINAPI ApplicationAssociationRegistration_Constructor(IUnknown *outer, REFIID riid, LPVOID *ppv)
891 {
892 IApplicationAssociationRegistrationImpl *This;
893 HRESULT hr;
894
895 if (outer)
896 return CLASS_E_NOAGGREGATION;
897
898 if (!(This = SHAlloc(sizeof(*This))))
899 return E_OUTOFMEMORY;
900
901 This->IApplicationAssociationRegistration_iface.lpVtbl = &IApplicationAssociationRegistration_vtbl;
902 This->ref = 0;
903
904 hr = IUnknown_QueryInterface(&This->IApplicationAssociationRegistration_iface, riid, ppv);
905 if (FAILED(hr))
906 SHFree(This);
907
908 TRACE("returning 0x%x with %p\n", hr, *ppv);
909 return hr;
910 }
911
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.