gdiplus: Add test for ImageLockModeUserInputBuf.
[wine] / dlls / shell32 / assoc.c
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 "shell32_main.h"
32 #include "ver.h"
33 #include "wine/unicode.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(shell);
37
38 /**************************************************************************
39  *  IQueryAssociations {SHELL32}
40  *
41  * DESCRIPTION
42  *  This object provides a layer of abstraction over the system registry in
43  *  order to simplify the process of parsing associations between files.
44  *  Associations in this context means the registry entries that link (for
45  *  example) the extension of a file with its description, list of
46  *  applications to open the file with, and actions that can be performed on it
47  *  (the shell displays such information in the context menu of explorer
48  *  when you right-click on a file).
49  *
50  * HELPERS
51  * You can use this object transparently by calling the helper functions
52  * AssocQueryKeyA(), AssocQueryStringA() and AssocQueryStringByKeyA(). These
53  * create an IQueryAssociations object, perform the requested actions
54  * and then dispose of the object. Alternatively, you can create an instance
55  * of the object using AssocCreate() and call the following methods on it:
56  *
57  * METHODS
58  */
59
60 typedef struct
61 {
62   IQueryAssociations IQueryAssociations_iface;
63   LONG ref;
64   HKEY hkeySource;
65   HKEY hkeyProgID;
66 } IQueryAssociationsImpl;
67
68 static inline IQueryAssociationsImpl *impl_from_IQueryAssociations(IQueryAssociations *iface)
69 {
70   return CONTAINING_RECORD(iface, IQueryAssociationsImpl, IQueryAssociations_iface);
71 }
72
73 /**************************************************************************
74  *  IQueryAssociations_QueryInterface {SHLWAPI}
75  *
76  * See IUnknown_QueryInterface.
77  */
78 static HRESULT WINAPI IQueryAssociations_fnQueryInterface(
79   IQueryAssociations* iface,
80   REFIID riid,
81   LPVOID *ppvObj)
82 {
83   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
84
85   TRACE("(%p,%s,%p)\n",This, debugstr_guid(riid), ppvObj);
86
87   *ppvObj = NULL;
88
89   if (IsEqualIID(riid, &IID_IUnknown) ||
90       IsEqualIID(riid, &IID_IQueryAssociations))
91   {
92     *ppvObj = This;
93
94     IQueryAssociations_AddRef((IQueryAssociations*)*ppvObj);
95     TRACE("Returning IQueryAssociations (%p)\n", *ppvObj);
96     return S_OK;
97   }
98   TRACE("Returning E_NOINTERFACE\n");
99   return E_NOINTERFACE;
100 }
101
102 /**************************************************************************
103  *  IQueryAssociations_AddRef {SHLWAPI}
104  *
105  * See IUnknown_AddRef.
106  */
107 static ULONG WINAPI IQueryAssociations_fnAddRef(IQueryAssociations *iface)
108 {
109   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
110   ULONG refCount = InterlockedIncrement(&This->ref);
111
112   TRACE("(%p)->(ref before=%u)\n",This, refCount - 1);
113
114   return refCount;
115 }
116
117 /**************************************************************************
118  *  IQueryAssociations_Release {SHLWAPI}
119  *
120  * See IUnknown_Release.
121  */
122 static ULONG WINAPI IQueryAssociations_fnRelease(IQueryAssociations *iface)
123 {
124   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
125   ULONG refCount = InterlockedDecrement(&This->ref);
126
127   TRACE("(%p)->(ref before=%u)\n",This, refCount + 1);
128
129   if (!refCount)
130   {
131     TRACE("Destroying IQueryAssociations (%p)\n", This);
132     RegCloseKey(This->hkeySource);
133     RegCloseKey(This->hkeyProgID);
134     HeapFree(GetProcessHeap(), 0, This);
135   }
136
137   return refCount;
138 }
139
140 /**************************************************************************
141  *  IQueryAssociations_Init {SHLWAPI}
142  *
143  * Initialise an IQueryAssociations object.
144  *
145  * PARAMS
146  *  iface      [I] IQueryAssociations interface to initialise
147  *  cfFlags    [I] ASSOCF_ flags from "shlwapi.h"
148  *  pszAssoc   [I] String for the root key name, or NULL if hkeyProgid is given
149  *  hkeyProgid [I] Handle for the root key, or NULL if pszAssoc is given
150  *  hWnd       [I] Reserved, must be NULL.
151  *
152  * RETURNS
153  *  Success: S_OK. iface is initialised with the parameters given.
154  *  Failure: An HRESULT error code indicating the error.
155  */
156 static HRESULT WINAPI IQueryAssociations_fnInit(
157   IQueryAssociations *iface,
158   ASSOCF cfFlags,
159   LPCWSTR pszAssoc,
160   HKEY hkeyProgid,
161   HWND hWnd)
162 {
163     static const WCHAR szProgID[] = {'P','r','o','g','I','D',0};
164     IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
165     LONG ret;
166
167     TRACE("(%p)->(%d,%s,%p,%p)\n", iface,
168                                     cfFlags,
169                                     debugstr_w(pszAssoc),
170                                     hkeyProgid,
171                                     hWnd);
172     if (hWnd != NULL)
173         FIXME("hwnd != NULL not supported\n");
174     if (cfFlags != 0)
175         FIXME("unsupported flags: %x\n", cfFlags);
176     if (pszAssoc != NULL)
177     {
178         ret = RegOpenKeyExW(HKEY_CLASSES_ROOT,
179                             pszAssoc,
180                             0,
181                             KEY_READ,
182                             &This->hkeySource);
183         if (ret != ERROR_SUCCESS)
184             return E_FAIL;
185         /* if this is not a prog id */
186         if ((*pszAssoc == '.') || (*pszAssoc == '{'))
187         {
188             RegOpenKeyExW(This->hkeySource,
189                           szProgID,
190                           0,
191                           KEY_READ,
192                           &This->hkeyProgID);
193         }
194         else
195             This->hkeyProgID = This->hkeySource;
196         return S_OK;
197     }
198     else if (hkeyProgid != NULL)
199     {
200         This->hkeyProgID = hkeyProgid;
201         return S_OK;
202     }
203     else
204         return E_INVALIDARG;
205 }
206
207 static HRESULT ASSOC_GetValue(HKEY hkey, WCHAR ** pszText)
208 {
209   DWORD len;
210   LONG ret;
211
212   assert(pszText);
213   ret = RegQueryValueExW(hkey, NULL, 0, NULL, NULL, &len);
214   if (ret != ERROR_SUCCESS)
215     return HRESULT_FROM_WIN32(ret);
216   if (!len)
217     return E_FAIL;
218   *pszText = HeapAlloc(GetProcessHeap(), 0, len);
219   if (!*pszText)
220     return E_OUTOFMEMORY;
221   ret = RegQueryValueExW(hkey, NULL, 0, NULL, (LPBYTE)*pszText,
222                          &len);
223   if (ret != ERROR_SUCCESS)
224   {
225     HeapFree(GetProcessHeap(), 0, *pszText);
226     return HRESULT_FROM_WIN32(ret);
227   }
228   return S_OK;
229 }
230
231 static HRESULT ASSOC_GetCommand(IQueryAssociationsImpl *This,
232                                 LPCWSTR pszExtra, WCHAR **ppszCommand)
233 {
234   HKEY hkeyCommand;
235   HKEY hkeyFile;
236   HKEY hkeyShell;
237   HKEY hkeyVerb;
238   HRESULT hr;
239   LONG ret;
240   WCHAR * pszExtraFromReg = NULL;
241   WCHAR * pszFileType;
242   static const WCHAR commandW[] = { 'c','o','m','m','a','n','d',0 };
243   static const WCHAR shellW[] = { 's','h','e','l','l',0 };
244
245   hr = ASSOC_GetValue(This->hkeySource, &pszFileType);
246   if (FAILED(hr))
247     return hr;
248   ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, pszFileType, 0, KEY_READ, &hkeyFile);
249   HeapFree(GetProcessHeap(), 0, pszFileType);
250   if (ret != ERROR_SUCCESS)
251     return HRESULT_FROM_WIN32(ret);
252
253   ret = RegOpenKeyExW(hkeyFile, shellW, 0, KEY_READ, &hkeyShell);
254   RegCloseKey(hkeyFile);
255   if (ret != ERROR_SUCCESS)
256     return HRESULT_FROM_WIN32(ret);
257
258   if (!pszExtra)
259   {
260     hr = ASSOC_GetValue(hkeyShell, &pszExtraFromReg);
261     /* if no default action */
262     if (hr == E_FAIL || hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND))
263     {
264       DWORD rlen;
265       ret = RegQueryInfoKeyW(hkeyShell, 0, 0, 0, 0, &rlen, 0, 0, 0, 0, 0, 0);
266       if (ret != ERROR_SUCCESS)
267       {
268         RegCloseKey(hkeyShell);
269         return HRESULT_FROM_WIN32(ret);
270       }
271       rlen++;
272       pszExtraFromReg = HeapAlloc(GetProcessHeap(), 0, rlen * sizeof(WCHAR));
273       if (!pszExtraFromReg)
274       {
275         RegCloseKey(hkeyShell);
276         return E_OUTOFMEMORY;
277       }
278       ret = RegEnumKeyExW(hkeyShell, 0, pszExtraFromReg, &rlen, 0, NULL, NULL, NULL);
279       if (ret != ERROR_SUCCESS)
280       {
281         RegCloseKey(hkeyShell);
282         return HRESULT_FROM_WIN32(ret);
283       }
284     }
285     else if (FAILED(hr))
286     {
287       RegCloseKey(hkeyShell);
288       return hr;
289     }
290   }
291
292   ret = RegOpenKeyExW(hkeyShell, pszExtra ? pszExtra : pszExtraFromReg, 0,
293                       KEY_READ, &hkeyVerb);
294   HeapFree(GetProcessHeap(), 0, pszExtraFromReg);
295   RegCloseKey(hkeyShell);
296   if (ret != ERROR_SUCCESS)
297     return HRESULT_FROM_WIN32(ret);
298
299   ret = RegOpenKeyExW(hkeyVerb, commandW, 0, KEY_READ, &hkeyCommand);
300   RegCloseKey(hkeyVerb);
301   if (ret != ERROR_SUCCESS)
302     return HRESULT_FROM_WIN32(ret);
303   hr = ASSOC_GetValue(hkeyCommand, ppszCommand);
304   RegCloseKey(hkeyCommand);
305   return hr;
306 }
307
308 static HRESULT ASSOC_GetExecutable(IQueryAssociationsImpl *This,
309                                    LPCWSTR pszExtra, LPWSTR path,
310                                    DWORD pathlen, DWORD *len)
311 {
312   WCHAR *pszCommand;
313   WCHAR *pszStart;
314   WCHAR *pszEnd;
315   HRESULT hr;
316
317   assert(len);
318
319   hr = ASSOC_GetCommand(This, pszExtra, &pszCommand);
320   if (FAILED(hr))
321     return hr;
322
323   /* cleanup pszCommand */
324   if (pszCommand[0] == '"')
325   {
326     pszStart = pszCommand + 1;
327     pszEnd = strchrW(pszStart, '"');
328     if (pszEnd)
329       *pszEnd = 0;
330     *len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
331   }
332   else
333   {
334     pszStart = pszCommand;
335     for (pszEnd = pszStart; (pszEnd = strchrW(pszEnd, ' ')); pszEnd++)
336     {
337       WCHAR c = *pszEnd;
338       *pszEnd = 0;
339       if ((*len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL)))
340         break;
341       *pszEnd = c;
342     }
343     if (!pszEnd)
344       *len = SearchPathW(NULL, pszStart, NULL, pathlen, path, NULL);
345   }
346
347   HeapFree(GetProcessHeap(), 0, pszCommand);
348   if (!*len)
349     return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
350   return S_OK;
351 }
352
353 static HRESULT ASSOC_ReturnData(LPWSTR out, DWORD *outlen, LPCWSTR data,
354                                 DWORD datalen)
355 {
356   assert(outlen);
357
358   if (out)
359   {
360     if (*outlen < datalen)
361     {
362       *outlen = datalen;
363       return E_POINTER;
364     }
365     *outlen = datalen;
366     lstrcpynW(out, data, datalen);
367     return S_OK;
368   }
369   else
370   {
371     *outlen = datalen;
372     return S_FALSE;
373   }
374 }
375
376 /**************************************************************************
377  *  IQueryAssociations_GetString {SHLWAPI}
378  *
379  * Get a file association string from the registry.
380  *
381  * PARAMS
382  *  iface    [I]   IQueryAssociations interface to query
383  *  cfFlags  [I]   ASSOCF_ flags from "shlwapi.h"
384  *  str      [I]   Type of string to get (ASSOCSTR enum from "shlwapi.h")
385  *  pszExtra [I]   Extra information about the string location
386  *  pszOut   [O]   Destination for the association string
387  *  pcchOut  [I/O] Length of pszOut
388  *
389  * RETURNS
390  *  Success: S_OK. pszOut contains the string, pcchOut contains its length.
391  *  Failure: An HRESULT error code indicating the error.
392  */
393 static HRESULT WINAPI IQueryAssociations_fnGetString(
394   IQueryAssociations *iface,
395   ASSOCF cfFlags,
396   ASSOCSTR str,
397   LPCWSTR pszExtra,
398   LPWSTR pszOut,
399   DWORD *pcchOut)
400 {
401   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
402   const ASSOCF cfUnimplemented = ~(0);
403   DWORD len = 0;
404   HRESULT hr;
405   WCHAR path[MAX_PATH];
406
407   TRACE("(%p,0x%8x,0x%8x,%s,%p,%p)\n", This, cfFlags, str,
408         debugstr_w(pszExtra), pszOut, pcchOut);
409
410   if (cfFlags & cfUnimplemented)
411     FIXME("%08x: unimplemented flags!\n", cfFlags & cfUnimplemented);
412
413   if (!pcchOut)
414     return E_UNEXPECTED;
415
416   switch (str)
417   {
418     case ASSOCSTR_COMMAND:
419     {
420       WCHAR *command;
421       hr = ASSOC_GetCommand(This, pszExtra, &command);
422       if (SUCCEEDED(hr))
423       {
424         hr = ASSOC_ReturnData(pszOut, pcchOut, command, strlenW(command) + 1);
425         HeapFree(GetProcessHeap(), 0, command);
426       }
427       return hr;
428     }
429
430     case ASSOCSTR_EXECUTABLE:
431     {
432       hr = ASSOC_GetExecutable(This, pszExtra, path, MAX_PATH, &len);
433       if (FAILED(hr))
434         return hr;
435       len++;
436       return ASSOC_ReturnData(pszOut, pcchOut, path, len);
437     }
438
439     case ASSOCSTR_FRIENDLYDOCNAME:
440     {
441       WCHAR *pszFileType;
442       DWORD ret;
443       DWORD size;
444
445       hr = ASSOC_GetValue(This->hkeySource, &pszFileType);
446       if (FAILED(hr))
447         return hr;
448       size = 0;
449       ret = RegGetValueW(HKEY_CLASSES_ROOT, pszFileType, NULL, RRF_RT_REG_SZ, NULL, NULL, &size);
450       if (ret == ERROR_SUCCESS)
451       {
452         WCHAR *docName = HeapAlloc(GetProcessHeap(), 0, size);
453         if (docName)
454         {
455           ret = RegGetValueW(HKEY_CLASSES_ROOT, pszFileType, NULL, RRF_RT_REG_SZ, NULL, docName, &size);
456           if (ret == ERROR_SUCCESS)
457             hr = ASSOC_ReturnData(pszOut, pcchOut, docName, strlenW(docName) + 1);
458           else
459             hr = HRESULT_FROM_WIN32(ret);
460           HeapFree(GetProcessHeap(), 0, docName);
461         }
462         else
463           hr = E_OUTOFMEMORY;
464       }
465       else
466         hr = HRESULT_FROM_WIN32(ret);
467       HeapFree(GetProcessHeap(), 0, pszFileType);
468       return hr;
469     }
470
471     case ASSOCSTR_FRIENDLYAPPNAME:
472     {
473       PVOID verinfoW = NULL;
474       DWORD size, retval = 0;
475       UINT flen;
476       WCHAR *bufW;
477       static const WCHAR translationW[] = {
478         '\\','V','a','r','F','i','l','e','I','n','f','o',
479         '\\','T','r','a','n','s','l','a','t','i','o','n',0
480       };
481       static const WCHAR fileDescFmtW[] = {
482         '\\','S','t','r','i','n','g','F','i','l','e','I','n','f','o',
483         '\\','%','0','4','x','%','0','4','x',
484         '\\','F','i','l','e','D','e','s','c','r','i','p','t','i','o','n',0
485       };
486       WCHAR fileDescW[41];
487
488       hr = ASSOC_GetExecutable(This, pszExtra, path, MAX_PATH, &len);
489       if (FAILED(hr))
490         return hr;
491
492       retval = GetFileVersionInfoSizeW(path, &size);
493       if (!retval)
494         goto get_friendly_name_fail;
495       verinfoW = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, retval);
496       if (!verinfoW)
497         return E_OUTOFMEMORY;
498       if (!GetFileVersionInfoW(path, 0, retval, verinfoW))
499         goto get_friendly_name_fail;
500       if (VerQueryValueW(verinfoW, translationW, (LPVOID *)&bufW, &flen))
501       {
502         UINT i;
503         DWORD *langCodeDesc = (DWORD *)bufW;
504         for (i = 0; i < flen / sizeof(DWORD); i++)
505         {
506           sprintfW(fileDescW, fileDescFmtW, LOWORD(langCodeDesc[i]),
507                    HIWORD(langCodeDesc[i]));
508           if (VerQueryValueW(verinfoW, fileDescW, (LPVOID *)&bufW, &flen))
509           {
510             /* Does strlenW(bufW) == 0 mean we use the filename? */
511             len = strlenW(bufW) + 1;
512             TRACE("found FileDescription: %s\n", debugstr_w(bufW));
513             hr = ASSOC_ReturnData(pszOut, pcchOut, bufW, len);
514             HeapFree(GetProcessHeap(), 0, verinfoW);
515             return hr;
516           }
517         }
518       }
519 get_friendly_name_fail:
520       PathRemoveExtensionW(path);
521       PathStripPathW(path);
522       TRACE("using filename: %s\n", debugstr_w(path));
523       hr = ASSOC_ReturnData(pszOut, pcchOut, path, strlenW(path) + 1);
524       HeapFree(GetProcessHeap(), 0, verinfoW);
525       return hr;
526     }
527
528     case ASSOCSTR_CONTENTTYPE:
529     {
530       static const WCHAR Content_TypeW[] = {'C','o','n','t','e','n','t',' ','T','y','p','e',0};
531       WCHAR *contentType;
532       DWORD ret;
533       DWORD size;
534
535       size = 0;
536       ret = RegGetValueW(This->hkeySource, NULL, Content_TypeW, RRF_RT_REG_SZ, NULL, NULL, &size);
537       if (ret != ERROR_SUCCESS)
538         return HRESULT_FROM_WIN32(ret);
539       contentType = HeapAlloc(GetProcessHeap(), 0, size);
540       if (contentType != NULL)
541       {
542         ret = RegGetValueW(This->hkeySource, NULL, Content_TypeW, RRF_RT_REG_SZ, NULL, contentType, &size);
543         if (ret == ERROR_SUCCESS)
544           hr = ASSOC_ReturnData(pszOut, pcchOut, contentType, strlenW(contentType) + 1);
545         else
546           hr = HRESULT_FROM_WIN32(ret);
547         HeapFree(GetProcessHeap(), 0, contentType);
548       }
549       else
550         hr = E_OUTOFMEMORY;
551       return hr;
552     }
553
554     case ASSOCSTR_DEFAULTICON:
555     {
556       static const WCHAR DefaultIconW[] = {'D','e','f','a','u','l','t','I','c','o','n',0};
557       WCHAR *pszFileType;
558       DWORD ret;
559       DWORD size;
560       HKEY hkeyFile;
561
562       hr = ASSOC_GetValue(This->hkeySource, &pszFileType);
563       if (FAILED(hr))
564         return hr;
565       ret = RegOpenKeyExW(HKEY_CLASSES_ROOT, pszFileType, 0, KEY_READ, &hkeyFile);
566       if (ret == ERROR_SUCCESS)
567       {
568         size = 0;
569         ret = RegGetValueW(hkeyFile, DefaultIconW, NULL, RRF_RT_REG_SZ, NULL, NULL, &size);
570         if (ret == ERROR_SUCCESS)
571         {
572           WCHAR *icon = HeapAlloc(GetProcessHeap(), 0, size);
573           if (icon)
574           {
575             ret = RegGetValueW(hkeyFile, DefaultIconW, NULL, RRF_RT_REG_SZ, NULL, icon, &size);
576             if (ret == ERROR_SUCCESS)
577               hr = ASSOC_ReturnData(pszOut, pcchOut, icon, strlenW(icon) + 1);
578             else
579               hr = HRESULT_FROM_WIN32(ret);
580             HeapFree(GetProcessHeap(), 0, icon);
581           }
582           else
583             hr = E_OUTOFMEMORY;
584         }
585         else
586           hr = HRESULT_FROM_WIN32(ret);
587         RegCloseKey(hkeyFile);
588       }
589       else
590         hr = HRESULT_FROM_WIN32(ret);
591       HeapFree(GetProcessHeap(), 0, pszFileType);
592       return hr;
593     }
594
595     default:
596       FIXME("assocstr %d unimplemented!\n", str);
597       return E_NOTIMPL;
598   }
599 }
600
601 /**************************************************************************
602  *  IQueryAssociations_GetKey {SHLWAPI}
603  *
604  * Get a file association key from the registry.
605  *
606  * PARAMS
607  *  iface    [I] IQueryAssociations interface to query
608  *  cfFlags  [I] ASSOCF_ flags from "shlwapi.h"
609  *  assockey [I] Type of key to get (ASSOCKEY enum from "shlwapi.h")
610  *  pszExtra [I] Extra information about the key location
611  *  phkeyOut [O] Destination for the association key
612  *
613  * RETURNS
614  *  Success: S_OK. phkeyOut contains a handle to the key.
615  *  Failure: An HRESULT error code indicating the error.
616  */
617 static HRESULT WINAPI IQueryAssociations_fnGetKey(
618   IQueryAssociations *iface,
619   ASSOCF cfFlags,
620   ASSOCKEY assockey,
621   LPCWSTR pszExtra,
622   HKEY *phkeyOut)
623 {
624   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
625
626   FIXME("(%p,0x%8x,0x%8x,%s,%p)-stub!\n", This, cfFlags, assockey,
627         debugstr_w(pszExtra), phkeyOut);
628   return E_NOTIMPL;
629 }
630
631 /**************************************************************************
632  *  IQueryAssociations_GetData {SHLWAPI}
633  *
634  * Get the data for a file association key from the registry.
635  *
636  * PARAMS
637  *  iface     [I]   IQueryAssociations interface to query
638  *  cfFlags   [I]   ASSOCF_ flags from "shlwapi.h"
639  *  assocdata [I]   Type of data to get (ASSOCDATA enum from "shlwapi.h")
640  *  pszExtra  [I]   Extra information about the data location
641  *  pvOut     [O]   Destination for the association key
642  *  pcbOut    [I/O] Size of pvOut
643  *
644  * RETURNS
645  *  Success: S_OK. pszOut contains the data, pcbOut contains its length.
646  *  Failure: An HRESULT error code indicating the error.
647  */
648 static HRESULT WINAPI IQueryAssociations_fnGetData(
649   IQueryAssociations *iface,
650   ASSOCF cfFlags,
651   ASSOCDATA assocdata,
652   LPCWSTR pszExtra,
653   LPVOID pvOut,
654   DWORD *pcbOut)
655 {
656   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
657
658   FIXME("(%p,0x%8x,0x%8x,%s,%p,%p)-stub!\n", This, cfFlags, assocdata,
659         debugstr_w(pszExtra), pvOut, pcbOut);
660   return E_NOTIMPL;
661 }
662
663 /**************************************************************************
664  *  IQueryAssociations_GetEnum {SHLWAPI}
665  *
666  * Not yet implemented in native Win32.
667  *
668  * PARAMS
669  *  iface     [I] IQueryAssociations interface to query
670  *  cfFlags   [I] ASSOCF_ flags from "shlwapi.h"
671  *  assocenum [I] Type of enum to get (ASSOCENUM enum from "shlwapi.h")
672  *  pszExtra  [I] Extra information about the enum location
673  *  riid      [I] REFIID to look for
674  *  ppvOut    [O] Destination for the interface.
675  *
676  * RETURNS
677  *  Success: S_OK.
678  *  Failure: An HRESULT error code indicating the error.
679  *
680  * NOTES
681  *  Presumably this function returns an enumerator object.
682  */
683 static HRESULT WINAPI IQueryAssociations_fnGetEnum(
684   IQueryAssociations *iface,
685   ASSOCF cfFlags,
686   ASSOCENUM assocenum,
687   LPCWSTR pszExtra,
688   REFIID riid,
689   LPVOID *ppvOut)
690 {
691   IQueryAssociationsImpl *This = impl_from_IQueryAssociations(iface);
692
693   FIXME("(%p,0x%8x,0x%8x,%s,%s,%p)-stub!\n", This, cfFlags, assocenum,
694         debugstr_w(pszExtra), debugstr_guid(riid), ppvOut);
695   return E_NOTIMPL;
696 }
697
698 static const IQueryAssociationsVtbl IQueryAssociations_vtbl =
699 {
700   IQueryAssociations_fnQueryInterface,
701   IQueryAssociations_fnAddRef,
702   IQueryAssociations_fnRelease,
703   IQueryAssociations_fnInit,
704   IQueryAssociations_fnGetString,
705   IQueryAssociations_fnGetKey,
706   IQueryAssociations_fnGetData,
707   IQueryAssociations_fnGetEnum
708 };
709
710 /**************************************************************************
711  *  IQueryAssociations_Constructor [internal]
712  *
713  * Construct a new IQueryAssociations object.
714  */
715 HRESULT WINAPI QueryAssociations_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppOutput)
716 {
717     IQueryAssociationsImpl* this;
718     HRESULT ret;
719
720     if (pUnkOuter) return CLASS_E_NOAGGREGATION;
721
722     if (!(this = SHAlloc(sizeof(*this)))) return E_OUTOFMEMORY;
723     this->IQueryAssociations_iface.lpVtbl = &IQueryAssociations_vtbl;
724     this->ref = 0;
725     this->hkeySource = 0;
726     this->hkeyProgID = 0;
727     if (FAILED(ret = IUnknown_QueryInterface((IUnknown *)this, riid, ppOutput))) SHFree( this );
728     TRACE("returning %p\n", *ppOutput);
729     return ret;
730 }