1 /*
2 * SHLWAPI ordinal functions
3 *
4 * Copyright 1997 Marcus Meissner
5 * 1998 Jürgen Schmied
6 * 2001-2003 Jon Griffiths
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <string.h>
29
30 #define COBJMACROS
31 #define NONAMELESSUNION
32 #define NONAMELESSSTRUCT
33
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winnls.h"
37 #include "winreg.h"
38 #include "wingdi.h"
39 #include "winuser.h"
40 #include "winver.h"
41 #include "winnetwk.h"
42 #include "mmsystem.h"
43 #include "objbase.h"
44 #include "exdisp.h"
45 #include "shlobj.h"
46 #include "shlwapi.h"
47 #include "shellapi.h"
48 #include "commdlg.h"
49 #include "mshtmhst.h"
50 #include "wine/unicode.h"
51 #include "wine/debug.h"
52
53
54 WINE_DEFAULT_DEBUG_CHANNEL(shell);
55
56 /* DLL handles for late bound calls */
57 extern HINSTANCE shlwapi_hInstance;
58 extern DWORD SHLWAPI_ThreadRef_index;
59
60 HRESULT WINAPI IUnknown_QueryService(IUnknown*,REFGUID,REFIID,LPVOID*);
61 HRESULT WINAPI SHInvokeCommand(HWND,IShellFolder*,LPCITEMIDLIST,BOOL);
62 BOOL WINAPI SHAboutInfoW(LPWSTR,DWORD);
63
64 /*
65 NOTES: Most functions exported by ordinal seem to be superfluous.
66 The reason for these functions to be there is to provide a wrapper
67 for unicode functions to provide these functions on systems without
68 unicode functions eg. win95/win98. Since we have such functions we just
69 call these. If running Wine with native DLLs, some late bound calls may
70 fail. However, it is better to implement the functions in the forward DLL
71 and recommend the builtin rather than reimplementing the calls here!
72 */
73
74 /*************************************************************************
75 * SHLWAPI_DupSharedHandle
76 *
77 * Internal implemetation of SHLWAPI_11.
78 */
79 static HANDLE SHLWAPI_DupSharedHandle(HANDLE hShared, DWORD dwDstProcId,
80 DWORD dwSrcProcId, DWORD dwAccess,
81 DWORD dwOptions)
82 {
83 HANDLE hDst, hSrc;
84 DWORD dwMyProcId = GetCurrentProcessId();
85 HANDLE hRet = NULL;
86
87 TRACE("(%p,%d,%d,%08x,%08x)\n", hShared, dwDstProcId, dwSrcProcId,
88 dwAccess, dwOptions);
89
90 /* Get dest process handle */
91 if (dwDstProcId == dwMyProcId)
92 hDst = GetCurrentProcess();
93 else
94 hDst = OpenProcess(PROCESS_DUP_HANDLE, 0, dwDstProcId);
95
96 if (hDst)
97 {
98 /* Get src process handle */
99 if (dwSrcProcId == dwMyProcId)
100 hSrc = GetCurrentProcess();
101 else
102 hSrc = OpenProcess(PROCESS_DUP_HANDLE, 0, dwSrcProcId);
103
104 if (hSrc)
105 {
106 /* Make handle available to dest process */
107 if (!DuplicateHandle(hDst, hShared, hSrc, &hRet,
108 dwAccess, 0, dwOptions | DUPLICATE_SAME_ACCESS))
109 hRet = NULL;
110
111 if (dwSrcProcId != dwMyProcId)
112 CloseHandle(hSrc);
113 }
114
115 if (dwDstProcId != dwMyProcId)
116 CloseHandle(hDst);
117 }
118
119 TRACE("Returning handle %p\n", hRet);
120 return hRet;
121 }
122
123 /*************************************************************************
124 * @ [SHLWAPI.7]
125 *
126 * Create a block of sharable memory and initialise it with data.
127 *
128 * PARAMS
129 * lpvData [I] Pointer to data to write
130 * dwSize [I] Size of data
131 * dwProcId [I] ID of process owning data
132 *
133 * RETURNS
134 * Success: A shared memory handle
135 * Failure: NULL
136 *
137 * NOTES
138 * Ordinals 7-11 provide a set of calls to create shared memory between a
139 * group of processes. The shared memory is treated opaquely in that its size
140 * is not exposed to clients who map it. This is accomplished by storing
141 * the size of the map as the first DWORD of mapped data, and then offsetting
142 * the view pointer returned by this size.
143 *
144 */
145 HANDLE WINAPI SHAllocShared(LPCVOID lpvData, DWORD dwSize, DWORD dwProcId)
146 {
147 HANDLE hMap;
148 LPVOID pMapped;
149 HANDLE hRet = NULL;
150
151 TRACE("(%p,%d,%d)\n", lpvData, dwSize, dwProcId);
152
153 /* Create file mapping of the correct length */
154 hMap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, FILE_MAP_READ, 0,
155 dwSize + sizeof(dwSize), NULL);
156 if (!hMap)
157 return hRet;
158
159 /* Get a view in our process address space */
160 pMapped = MapViewOfFile(hMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
161
162 if (pMapped)
163 {
164 /* Write size of data, followed by the data, to the view */
165 *((DWORD*)pMapped) = dwSize;
166 if (lpvData)
167 memcpy((char *) pMapped + sizeof(dwSize), lpvData, dwSize);
168
169 /* Release view. All further views mapped will be opaque */
170 UnmapViewOfFile(pMapped);
171 hRet = SHLWAPI_DupSharedHandle(hMap, dwProcId,
172 GetCurrentProcessId(), FILE_MAP_ALL_ACCESS,
173 DUPLICATE_SAME_ACCESS);
174 }
175
176 CloseHandle(hMap);
177 return hRet;
178 }
179
180 /*************************************************************************
181 * @ [SHLWAPI.8]
182 *
183 * Get a pointer to a block of shared memory from a shared memory handle.
184 *
185 * PARAMS
186 * hShared [I] Shared memory handle
187 * dwProcId [I] ID of process owning hShared
188 *
189 * RETURNS
190 * Success: A pointer to the shared memory
191 * Failure: NULL
192 *
193 */
194 PVOID WINAPI SHLockShared(HANDLE hShared, DWORD dwProcId)
195 {
196 HANDLE hDup;
197 LPVOID pMapped;
198
199 TRACE("(%p %d)\n", hShared, dwProcId);
200
201 /* Get handle to shared memory for current process */
202 hDup = SHLWAPI_DupSharedHandle(hShared, dwProcId, GetCurrentProcessId(),
203 FILE_MAP_ALL_ACCESS, 0);
204 /* Get View */
205 pMapped = MapViewOfFile(hDup, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
206 CloseHandle(hDup);
207
208 if (pMapped)
209 return (char *) pMapped + sizeof(DWORD); /* Hide size */
210 return NULL;
211 }
212
213 /*************************************************************************
214 * @ [SHLWAPI.9]
215 *
216 * Release a pointer to a block of shared memory.
217 *
218 * PARAMS
219 * lpView [I] Shared memory pointer
220 *
221 * RETURNS
222 * Success: TRUE
223 * Failure: FALSE
224 *
225 */
226 BOOL WINAPI SHUnlockShared(LPVOID lpView)
227 {
228 TRACE("(%p)\n", lpView);
229 return UnmapViewOfFile((char *) lpView - sizeof(DWORD)); /* Include size */
230 }
231
232 /*************************************************************************
233 * @ [SHLWAPI.10]
234 *
235 * Destroy a block of sharable memory.
236 *
237 * PARAMS
238 * hShared [I] Shared memory handle
239 * dwProcId [I] ID of process owning hShared
240 *
241 * RETURNS
242 * Success: TRUE
243 * Failure: FALSE
244 *
245 */
246 BOOL WINAPI SHFreeShared(HANDLE hShared, DWORD dwProcId)
247 {
248 HANDLE hClose;
249
250 TRACE("(%p %d)\n", hShared, dwProcId);
251
252 /* Get a copy of the handle for our process, closing the source handle */
253 hClose = SHLWAPI_DupSharedHandle(hShared, dwProcId, GetCurrentProcessId(),
254 FILE_MAP_ALL_ACCESS,DUPLICATE_CLOSE_SOURCE);
255 /* Close local copy */
256 return CloseHandle(hClose);
257 }
258
259 /*************************************************************************
260 * @ [SHLWAPI.11]
261 *
262 * Copy a sharable memory handle from one process to another.
263 *
264 * PARAMS
265 * hShared [I] Shared memory handle to duplicate
266 * dwDstProcId [I] ID of the process wanting the duplicated handle
267 * dwSrcProcId [I] ID of the process owning hShared
268 * dwAccess [I] Desired DuplicateHandle() access
269 * dwOptions [I] Desired DuplicateHandle() options
270 *
271 * RETURNS
272 * Success: A handle suitable for use by the dwDstProcId process.
273 * Failure: A NULL handle.
274 *
275 */
276 HANDLE WINAPI SHMapHandle(HANDLE hShared, DWORD dwDstProcId, DWORD dwSrcProcId,
277 DWORD dwAccess, DWORD dwOptions)
278 {
279 HANDLE hRet;
280
281 hRet = SHLWAPI_DupSharedHandle(hShared, dwDstProcId, dwSrcProcId,
282 dwAccess, dwOptions);
283 return hRet;
284 }
285
286 /*************************************************************************
287 * @ [SHLWAPI.13]
288 *
289 * Create and register a clipboard enumerator for a web browser.
290 *
291 * PARAMS
292 * lpBC [I] Binding context
293 * lpUnknown [I] An object exposing the IWebBrowserApp interface
294 *
295 * RETURNS
296 * Success: S_OK.
297 * Failure: An HRESULT error code.
298 *
299 * NOTES
300 * The enumerator is stored as a property of the web browser. If it does not
301 * yet exist, it is created and set before being registered.
302 */
303 HRESULT WINAPI RegisterDefaultAcceptHeaders(LPBC lpBC, IUnknown *lpUnknown)
304 {
305 static const WCHAR szProperty[] = { '{','D','','F','C','A','4','2','',
306 '-','D','3','F','5','-','1','1','C','F', '-','B','2','1','1','-','',
307 '','A','A','','','4','A','E','8','3','7','}','\0' };
308 BSTR property;
309 IEnumFORMATETC* pIEnumFormatEtc = NULL;
310 VARIANTARG var;
311 HRESULT hRet;
312 IWebBrowserApp* pBrowser = NULL;
313
314 TRACE("(%p, %p)\n", lpBC, lpUnknown);
315
316 /* Get An IWebBrowserApp interface from lpUnknown */
317 hRet = IUnknown_QueryService(lpUnknown, &IID_IWebBrowserApp, &IID_IWebBrowserApp, (PVOID)&pBrowser);
318 if (FAILED(hRet) || !pBrowser)
319 return E_NOINTERFACE;
320
321 V_VT(&var) = VT_EMPTY;
322
323 /* The property we get is the browsers clipboard enumerator */
324 property = SysAllocString(szProperty);
325 hRet = IWebBrowserApp_GetProperty(pBrowser, property, &var);
326 SysFreeString(property);
327 if (FAILED(hRet))
328 return hRet;
329
330 if (V_VT(&var) == VT_EMPTY)
331 {
332 /* Iterate through accepted documents and RegisterClipBoardFormatA() them */
333 char szKeyBuff[128], szValueBuff[128];
334 DWORD dwKeySize, dwValueSize, dwRet = 0, dwCount = 0, dwNumValues, dwType;
335 FORMATETC* formatList, *format;
336 HKEY hDocs;
337
338 TRACE("Registering formats and creating IEnumFORMATETC instance\n");
339
340 if (!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\Current"
341 "Version\\Internet Settings\\Accepted Documents", &hDocs))
342 return E_FAIL;
343
344 /* Get count of values in key */
345 while (!dwRet)
346 {
347 dwKeySize = sizeof(szKeyBuff);
348 dwRet = RegEnumValueA(hDocs,dwCount,szKeyBuff,&dwKeySize,0,&dwType,0,0);
349 dwCount++;
350 }
351
352 dwNumValues = dwCount;
353
354 /* Note: dwCount = number of items + 1; The extra item is the end node */
355 format = formatList = HeapAlloc(GetProcessHeap(), 0, dwCount * sizeof(FORMATETC));
356 if (!formatList)
357 return E_OUTOFMEMORY;
358
359 if (dwNumValues > 1)
360 {
361 dwRet = 0;
362 dwCount = 0;
363
364 dwNumValues--;
365
366 /* Register clipboard formats for the values and populate format list */
367 while(!dwRet && dwCount < dwNumValues)
368 {
369 dwKeySize = sizeof(szKeyBuff);
370 dwValueSize = sizeof(szValueBuff);
371 dwRet = RegEnumValueA(hDocs, dwCount, szKeyBuff, &dwKeySize, 0, &dwType,
372 (PBYTE)szValueBuff, &dwValueSize);
373 if (!dwRet)
374 return E_FAIL;
375
376 format->cfFormat = RegisterClipboardFormatA(szValueBuff);
377 format->ptd = NULL;
378 format->dwAspect = 1;
379 format->lindex = 4;
380 format->tymed = -1;
381
382 format++;
383 dwCount++;
384 }
385 }
386
387 /* Terminate the (maybe empty) list, last entry has a cfFormat of 0 */
388 format->cfFormat = 0;
389 format->ptd = NULL;
390 format->dwAspect = 1;
391 format->lindex = 4;
392 format->tymed = -1;
393
394 /* Create a clipboard enumerator */
395 hRet = CreateFormatEnumerator(dwNumValues, formatList, &pIEnumFormatEtc);
396
397 if (FAILED(hRet) || !pIEnumFormatEtc)
398 return hRet;
399
400 /* Set our enumerator as the browsers property */
401 V_VT(&var) = VT_UNKNOWN;
402 V_UNKNOWN(&var) = (IUnknown*)pIEnumFormatEtc;
403
404 hRet = IWebBrowserApp_PutProperty(pBrowser, (BSTR)szProperty, var);
405 if (FAILED(hRet))
406 {
407 IEnumFORMATETC_Release(pIEnumFormatEtc);
408 goto RegisterDefaultAcceptHeaders_Exit;
409 }
410 }
411
412 if (V_VT(&var) == VT_UNKNOWN)
413 {
414 /* Our variant is holding the clipboard enumerator */
415 IUnknown* pIUnknown = V_UNKNOWN(&var);
416 IEnumFORMATETC* pClone = NULL;
417
418 TRACE("Retrieved IEnumFORMATETC property\n");
419
420 /* Get an IEnumFormatEtc interface from the variants value */
421 pIEnumFormatEtc = NULL;
422 hRet = IUnknown_QueryInterface(pIUnknown, &IID_IEnumFORMATETC,
423 (PVOID)&pIEnumFormatEtc);
424 if (hRet == S_OK && pIEnumFormatEtc)
425 {
426 /* Clone and register the enumerator */
427 hRet = IEnumFORMATETC_Clone(pIEnumFormatEtc, &pClone);
428 if (hRet == S_OK && pClone)
429 {
430 RegisterFormatEnumerator(lpBC, pClone, 0);
431
432 IEnumFORMATETC_Release(pClone);
433 }
434
435 /* Release the IEnumFormatEtc interface */
436 IEnumFORMATETC_Release(pIUnknown);
437 }
438 IUnknown_Release(V_UNKNOWN(&var));
439 }
440
441 RegisterDefaultAcceptHeaders_Exit:
442 IWebBrowserApp_Release(pBrowser);
443 return hRet;
444 }
445
446 /*************************************************************************
447 * @ [SHLWAPI.15]
448 *
449 * Get Explorers "AcceptLanguage" setting.
450 *
451 * PARAMS
452 * langbuf [O] Destination for language string
453 * buflen [I] Length of langbuf
454 * [0] Success: used length of langbuf
455 *
456 * RETURNS
457 * Success: S_OK. langbuf is set to the language string found.
458 * Failure: E_FAIL, If any arguments are invalid, error occurred, or Explorer
459 * does not contain the setting.
460 * E_INVALIDARG, If the buffer is not big enough
461 */
462 HRESULT WINAPI GetAcceptLanguagesW( LPWSTR langbuf, LPDWORD buflen)
463 {
464 static const WCHAR szkeyW[] = {
465 'S','o','f','t','w','a','r','e','\\',
466 'M','i','c','r','o','s','o','f','t','\\',
467 'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
468 'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
469 static const WCHAR valueW[] = {
470 'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
471 static const WCHAR enusW[] = {'e','n','-','u','s',0};
472 DWORD mystrlen, mytype;
473 HKEY mykey;
474 HRESULT retval;
475 LCID mylcid;
476 WCHAR *mystr;
477
478 if(!langbuf || !buflen || !*buflen)
479 return E_FAIL;
480
481 mystrlen = (*buflen > 20) ? *buflen : 20 ;
482 mystr = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * mystrlen);
483 RegOpenKeyW(HKEY_CURRENT_USER, szkeyW, &mykey);
484 if(RegQueryValueExW(mykey, valueW, 0, &mytype, (PBYTE)mystr, &mystrlen)) {
485 /* Did not find value */
486 mylcid = GetUserDefaultLCID();
487 /* somehow the mylcid translates into "en-us"
488 * this is similar to "LOCALE_SABBREVLANGNAME"
489 * which could be gotten via GetLocaleInfo.
490 * The only problem is LOCALE_SABBREVLANGUAGE" is
491 * a 3 char string (first 2 are country code and third is
492 * letter for "sublanguage", which does not come close to
493 * "en-us"
494 */
495 lstrcpyW(mystr, enusW);
496 mystrlen = lstrlenW(mystr);
497 } else {
498 /* handle returned string */
499 FIXME("missing code\n");
500 }
501 memcpy( langbuf, mystr, min(*buflen,strlenW(mystr)+1)*sizeof(WCHAR) );
502
503 if(*buflen > strlenW(mystr)) {
504 *buflen = strlenW(mystr);
505 retval = S_OK;
506 } else {
507 *buflen = 0;
508 retval = E_INVALIDARG;
509 SetLastError(ERROR_INSUFFICIENT_BUFFER);
510 }
511 RegCloseKey(mykey);
512 HeapFree(GetProcessHeap(), 0, mystr);
513 return retval;
514 }
515
516 /*************************************************************************
517 * @ [SHLWAPI.14]
518 *
519 * Ascii version of GetAcceptLanguagesW.
520 */
521 HRESULT WINAPI GetAcceptLanguagesA( LPSTR langbuf, LPDWORD buflen)
522 {
523 WCHAR *langbufW;
524 DWORD buflenW, convlen;
525 HRESULT retval;
526
527 if(!langbuf || !buflen || !*buflen) return E_FAIL;
528
529 buflenW = *buflen;
530 langbufW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * buflenW);
531 retval = GetAcceptLanguagesW(langbufW, &buflenW);
532
533 if (retval == S_OK)
534 {
535 convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, -1, langbuf, *buflen, NULL, NULL);
536 }
537 else /* copy partial string anyway */
538 {
539 convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, *buflen, langbuf, *buflen, NULL, NULL);
540 if (convlen < *buflen) langbuf[convlen] = 0;
541 }
542 *buflen = buflenW ? convlen : 0;
543
544 HeapFree(GetProcessHeap(), 0, langbufW);
545 return retval;
546 }
547
548 /*************************************************************************
549 * @ [SHLWAPI.23]
550 *
551 * Convert a GUID to a string.
552 *
553 * PARAMS
554 * guid [I] GUID to convert
555 * lpszDest [O] Destination for string
556 * cchMax [I] Length of output buffer
557 *
558 * RETURNS
559 * The length of the string created.
560 */
561 INT WINAPI SHStringFromGUIDA(REFGUID guid, LPSTR lpszDest, INT cchMax)
562 {
563 char xguid[40];
564 INT iLen;
565
566 TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
567
568 sprintf(xguid, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
569 guid->Data1, guid->Data2, guid->Data3,
570 guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
571 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
572
573 iLen = strlen(xguid) + 1;
574
575 if (iLen > cchMax)
576 return 0;
577 memcpy(lpszDest, xguid, iLen);
578 return iLen;
579 }
580
581 /*************************************************************************
582 * @ [SHLWAPI.24]
583 *
584 * Convert a GUID to a string.
585 *
586 * PARAMS
587 * guid [I] GUID to convert
588 * str [O] Destination for string
589 * cmax [I] Length of output buffer
590 *
591 * RETURNS
592 * The length of the string created.
593 */
594 INT WINAPI SHStringFromGUIDW(REFGUID guid, LPWSTR lpszDest, INT cchMax)
595 {
596 WCHAR xguid[40];
597 INT iLen;
598 static const WCHAR wszFormat[] = {'{','%','','8','l','X','-','%','','4','X','-','%','','4','X','-',
599 '%','','2','X','%','','2','X','-','%','','2','X','%','','2','X','%','','2','X','%','','2',
600 'X','%','','2','X','%','','2','X','}',0};
601
602 TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
603
604 sprintfW(xguid, wszFormat, guid->Data1, guid->Data2, guid->Data3,
605 guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
606 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
607
608 iLen = strlenW(xguid) + 1;
609
610 if (iLen > cchMax)
611 return 0;
612 memcpy(lpszDest, xguid, iLen*sizeof(WCHAR));
613 return iLen;
614 }
615
616 /*************************************************************************
617 * @ [SHLWAPI.29]
618 *
619 * Determine if a Unicode character is a space.
620 *
621 * PARAMS
622 * wc [I] Character to check.
623 *
624 * RETURNS
625 * TRUE, if wc is a space,
626 * FALSE otherwise.
627 */
628 BOOL WINAPI IsCharSpaceW(WCHAR wc)
629 {
630 WORD CharType;
631
632 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_SPACE);
633 }
634
635 /*************************************************************************
636 * @ [SHLWAPI.30]
637 *
638 * Determine if a Unicode character is a blank.
639 *
640 * PARAMS
641 * wc [I] Character to check.
642 *
643 * RETURNS
644 * TRUE, if wc is a blank,
645 * FALSE otherwise.
646 *
647 */
648 BOOL WINAPI IsCharBlankW(WCHAR wc)
649 {
650 WORD CharType;
651
652 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_BLANK);
653 }
654
655 /*************************************************************************
656 * @ [SHLWAPI.31]
657 *
658 * Determine if a Unicode character is punctuation.
659 *
660 * PARAMS
661 * wc [I] Character to check.
662 *
663 * RETURNS
664 * TRUE, if wc is punctuation,
665 * FALSE otherwise.
666 */
667 BOOL WINAPI IsCharPunctW(WCHAR wc)
668 {
669 WORD CharType;
670
671 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_PUNCT);
672 }
673
674 /*************************************************************************
675 * @ [SHLWAPI.32]
676 *
677 * Determine if a Unicode character is a control character.
678 *
679 * PARAMS
680 * wc [I] Character to check.
681 *
682 * RETURNS
683 * TRUE, if wc is a control character,
684 * FALSE otherwise.
685 */
686 BOOL WINAPI IsCharCntrlW(WCHAR wc)
687 {
688 WORD CharType;
689
690 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_CNTRL);
691 }
692
693 /*************************************************************************
694 * @ [SHLWAPI.33]
695 *
696 * Determine if a Unicode character is a digit.
697 *
698 * PARAMS
699 * wc [I] Character to check.
700 *
701 * RETURNS
702 * TRUE, if wc is a digit,
703 * FALSE otherwise.
704 */
705 BOOL WINAPI IsCharDigitW(WCHAR wc)
706 {
707 WORD CharType;
708
709 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_DIGIT);
710 }
711
712 /*************************************************************************
713 * @ [SHLWAPI.34]
714 *
715 * Determine if a Unicode character is a hex digit.
716 *
717 * PARAMS
718 * wc [I] Character to check.
719 *
720 * RETURNS
721 * TRUE, if wc is a hex digit,
722 * FALSE otherwise.
723 */
724 BOOL WINAPI IsCharXDigitW(WCHAR wc)
725 {
726 WORD CharType;
727
728 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_XDIGIT);
729 }
730
731 /*************************************************************************
732 * @ [SHLWAPI.35]
733 *
734 */
735 BOOL WINAPI GetStringType3ExW(LPWSTR src, INT count, LPWORD type)
736 {
737 return GetStringTypeW(CT_CTYPE3, src, count, type);
738 }
739
740 /*************************************************************************
741 * @ [SHLWAPI.151]
742 *
743 * Compare two Ascii strings up to a given length.
744 *
745 * PARAMS
746 * lpszSrc [I] Source string
747 * lpszCmp [I] String to compare to lpszSrc
748 * len [I] Maximum length
749 *
750 * RETURNS
751 * A number greater than, less than or equal to 0 depending on whether
752 * lpszSrc is greater than, less than or equal to lpszCmp.
753 */
754 DWORD WINAPI StrCmpNCA(LPCSTR lpszSrc, LPCSTR lpszCmp, INT len)
755 {
756 return StrCmpNA(lpszSrc, lpszCmp, len);
757 }
758
759 /*************************************************************************
760 * @ [SHLWAPI.152]
761 *
762 * Unicode version of StrCmpNCA.
763 */
764 DWORD WINAPI StrCmpNCW(LPCWSTR lpszSrc, LPCWSTR lpszCmp, INT len)
765 {
766 return StrCmpNW(lpszSrc, lpszCmp, len);
767 }
768
769 /*************************************************************************
770 * @ [SHLWAPI.153]
771 *
772 * Compare two Ascii strings up to a given length, ignoring case.
773 *
774 * PARAMS
775 * lpszSrc [I] Source string
776 * lpszCmp [I] String to compare to lpszSrc
777 * len [I] Maximum length
778 *
779 * RETURNS
780 * A number greater than, less than or equal to 0 depending on whether
781 * lpszSrc is greater than, less than or equal to lpszCmp.
782 */
783 DWORD WINAPI StrCmpNICA(LPCSTR lpszSrc, LPCSTR lpszCmp, DWORD len)
784 {
785 return StrCmpNIA(lpszSrc, lpszCmp, len);
786 }
787
788 /*************************************************************************
789 * @ [SHLWAPI.154]
790 *
791 * Unicode version of StrCmpNICA.
792 */
793 DWORD WINAPI StrCmpNICW(LPCWSTR lpszSrc, LPCWSTR lpszCmp, DWORD len)
794 {
795 return StrCmpNIW(lpszSrc, lpszCmp, len);
796 }
797
798 /*************************************************************************
799 * @ [SHLWAPI.155]
800 *
801 * Compare two Ascii strings.
802 *
803 * PARAMS
804 * lpszSrc [I] Source string
805 * lpszCmp [I] String to compare to lpszSrc
806 *
807 * RETURNS
808 * A number greater than, less than or equal to 0 depending on whether
809 * lpszSrc is greater than, less than or equal to lpszCmp.
810 */
811 DWORD WINAPI StrCmpCA(LPCSTR lpszSrc, LPCSTR lpszCmp)
812 {
813 return lstrcmpA(lpszSrc, lpszCmp);
814 }
815
816 /*************************************************************************
817 * @ [SHLWAPI.156]
818 *
819 * Unicode version of StrCmpCA.
820 */
821 DWORD WINAPI StrCmpCW(LPCWSTR lpszSrc, LPCWSTR lpszCmp)
822 {
823 return lstrcmpW(lpszSrc, lpszCmp);
824 }
825
826 /*************************************************************************
827 * @ [SHLWAPI.157]
828 *
829 * Compare two Ascii strings, ignoring case.
830 *
831 * PARAMS
832 * lpszSrc [I] Source string
833 * lpszCmp [I] String to compare to lpszSrc
834 *
835 * RETURNS
836 * A number greater than, less than or equal to 0 depending on whether
837 * lpszSrc is greater than, less than or equal to lpszCmp.
838 */
839 DWORD WINAPI StrCmpICA(LPCSTR lpszSrc, LPCSTR lpszCmp)
840 {
841 return lstrcmpiA(lpszSrc, lpszCmp);
842 }
843
844 /*************************************************************************
845 * @ [SHLWAPI.158]
846 *
847 * Unicode version of StrCmpICA.
848 */
849 DWORD WINAPI StrCmpICW(LPCWSTR lpszSrc, LPCWSTR lpszCmp)
850 {
851 return lstrcmpiW(lpszSrc, lpszCmp);
852 }
853
854 /*************************************************************************
855 * @ [SHLWAPI.160]
856 *
857 * Get an identification string for the OS and explorer.
858 *
859 * PARAMS
860 * lpszDest [O] Destination for Id string
861 * dwDestLen [I] Length of lpszDest
862 *
863 * RETURNS
864 * TRUE, If the string was created successfully
865 * FALSE, Otherwise
866 */
867 BOOL WINAPI SHAboutInfoA(LPSTR lpszDest, DWORD dwDestLen)
868 {
869 WCHAR buff[2084];
870
871 TRACE("(%p,%d)\n", lpszDest, dwDestLen);
872
873 if (lpszDest && SHAboutInfoW(buff, dwDestLen))
874 {
875 WideCharToMultiByte(CP_ACP, 0, buff, -1, lpszDest, dwDestLen, NULL, NULL);
876 return TRUE;
877 }
878 return FALSE;
879 }
880
881 /*************************************************************************
882 * @ [SHLWAPI.161]
883 *
884 * Unicode version of SHAboutInfoA.
885 */
886 BOOL WINAPI SHAboutInfoW(LPWSTR lpszDest, DWORD dwDestLen)
887 {
888 static const WCHAR szIEKey[] = { 'S','O','F','T','W','A','R','E','\\',
889 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
890 ' ','E','x','p','l','o','r','e','r','\0' };
891 static const WCHAR szWinNtKey[] = { 'S','O','F','T','W','A','R','E','\\',
892 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ',
893 'N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
894 static const WCHAR szWinKey[] = { 'S','O','F','T','W','A','R','E','\\',
895 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
896 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
897 static const WCHAR szRegKey[] = { 'S','O','F','T','W','A','R','E','\\',
898 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
899 ' ','E','x','p','l','o','r','e','r','\\',
900 'R','e','g','i','s','t','r','a','t','i','o','n','\0' };
901 static const WCHAR szVersion[] = { 'V','e','r','s','i','o','n','\0' };
902 static const WCHAR szCustomized[] = { 'C','u','s','t','o','m','i','z','e','d',
903 'V','e','r','s','i','o','n','\0' };
904 static const WCHAR szOwner[] = { 'R','e','g','i','s','t','e','r','e','d',
905 'O','w','n','e','r','\0' };
906 static const WCHAR szOrg[] = { 'R','e','g','i','s','t','e','r','e','d',
907 'O','r','g','a','n','i','z','a','t','i','o','n','\0' };
908 static const WCHAR szProduct[] = { 'P','r','o','d','u','c','t','I','d','\0' };
909 static const WCHAR szUpdate[] = { 'I','E','A','K',
910 'U','p','d','a','t','e','U','r','l','\0' };
911 static const WCHAR szHelp[] = { 'I','E','A','K',
912 'H','e','l','p','S','t','r','i','n','g','\0' };
913 WCHAR buff[2084];
914 HKEY hReg;
915 DWORD dwType, dwLen;
916
917 TRACE("(%p,%d)\n", lpszDest, dwDestLen);
918
919 if (!lpszDest)
920 return FALSE;
921
922 *lpszDest = '\0';
923
924 /* Try the NT key first, followed by 95/98 key */
925 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinNtKey, 0, KEY_READ, &hReg) &&
926 RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinKey, 0, KEY_READ, &hReg))
927 return FALSE;
928
929 /* OS Version */
930 buff[0] = '\0';
931 dwLen = 30;
932 if (!SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey, szVersion, &dwType, buff, &dwLen))
933 {
934 DWORD dwStrLen = strlenW(buff);
935 dwLen = 30 - dwStrLen;
936 SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey,
937 szCustomized, &dwType, buff+dwStrLen, &dwLen);
938 }
939 StrCatBuffW(lpszDest, buff, dwDestLen);
940
941 /* ~Registered Owner */
942 buff[0] = '~';
943 dwLen = 256;
944 if (SHGetValueW(hReg, szOwner, 0, &dwType, buff+1, &dwLen))
945 buff[1] = '\0';
946 StrCatBuffW(lpszDest, buff, dwDestLen);
947
948 /* ~Registered Organization */
949 dwLen = 256;
950 if (SHGetValueW(hReg, szOrg, 0, &dwType, buff+1, &dwLen))
951 buff[1] = '\0';
952 StrCatBuffW(lpszDest, buff, dwDestLen);
953
954 /* FIXME: Not sure where this number comes from */
955 buff[0] = '~';
956 buff[1] = '';
957 buff[2] = '\0';
958 StrCatBuffW(lpszDest, buff, dwDestLen);
959
960 /* ~Product Id */
961 dwLen = 256;
962 if (SHGetValueW(HKEY_LOCAL_MACHINE, szRegKey, szProduct, &dwType, buff+1, &dwLen))
963 buff[1] = '\0';
964 StrCatBuffW(lpszDest, buff, dwDestLen);
965
966 /* ~IE Update Url */
967 dwLen = 2048;
968 if(SHGetValueW(HKEY_LOCAL_MACHINE, szWinKey, szUpdate, &dwType, buff+1, &dwLen))
969 buff[1] = '\0';
970 StrCatBuffW(lpszDest, buff, dwDestLen);
971
972 /* ~IE Help String */
973 dwLen = 256;
974 if(SHGetValueW(hReg, szHelp, 0, &dwType, buff+1, &dwLen))
975 buff[1] = '\0';
976 StrCatBuffW(lpszDest, buff, dwDestLen);
977
978 RegCloseKey(hReg);
979 return TRUE;
980 }
981
982 /*************************************************************************
983 * @ [SHLWAPI.163]
984 *
985 * Call IOleCommandTarget_QueryStatus() on an object.
986 *
987 * PARAMS
988 * lpUnknown [I] Object supporting the IOleCommandTarget interface
989 * pguidCmdGroup [I] GUID for the command group
990 * cCmds [I]
991 * prgCmds [O] Commands
992 * pCmdText [O] Command text
993 *
994 * RETURNS
995 * Success: S_OK.
996 * Failure: E_FAIL, if lpUnknown is NULL.
997 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
998 * Otherwise, an error code from IOleCommandTarget_QueryStatus().
999 */
1000 HRESULT WINAPI IUnknown_QueryStatus(IUnknown* lpUnknown, REFGUID pguidCmdGroup,
1001 ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT* pCmdText)
1002 {
1003 HRESULT hRet = E_FAIL;
1004
1005 TRACE("(%p,%p,%d,%p,%p)\n",lpUnknown, pguidCmdGroup, cCmds, prgCmds, pCmdText);
1006
1007 if (lpUnknown)
1008 {
1009 IOleCommandTarget* lpOle;
1010
1011 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleCommandTarget,
1012 (void**)&lpOle);
1013
1014 if (SUCCEEDED(hRet) && lpOle)
1015 {
1016 hRet = IOleCommandTarget_QueryStatus(lpOle, pguidCmdGroup, cCmds,
1017 prgCmds, pCmdText);
1018 IOleCommandTarget_Release(lpOle);
1019 }
1020 }
1021 return hRet;
1022 }
1023
1024 /*************************************************************************
1025 * @ [SHLWAPI.164]
1026 *
1027 * Call IOleCommandTarget_Exec() on an object.
1028 *
1029 * PARAMS
1030 * lpUnknown [I] Object supporting the IOleCommandTarget interface
1031 * pguidCmdGroup [I] GUID for the command group
1032 *
1033 * RETURNS
1034 * Success: S_OK.
1035 * Failure: E_FAIL, if lpUnknown is NULL.
1036 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
1037 * Otherwise, an error code from IOleCommandTarget_Exec().
1038 */
1039 HRESULT WINAPI IUnknown_Exec(IUnknown* lpUnknown, REFGUID pguidCmdGroup,
1040 DWORD nCmdID, DWORD nCmdexecopt, VARIANT* pvaIn,
1041 VARIANT* pvaOut)
1042 {
1043 HRESULT hRet = E_FAIL;
1044
1045 TRACE("(%p,%p,%d,%d,%p,%p)\n",lpUnknown, pguidCmdGroup, nCmdID,
1046 nCmdexecopt, pvaIn, pvaOut);
1047
1048 if (lpUnknown)
1049 {
1050 IOleCommandTarget* lpOle;
1051
1052 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleCommandTarget,
1053 (void**)&lpOle);
1054 if (SUCCEEDED(hRet) && lpOle)
1055 {
1056 hRet = IOleCommandTarget_Exec(lpOle, pguidCmdGroup, nCmdID,
1057 nCmdexecopt, pvaIn, pvaOut);
1058 IOleCommandTarget_Release(lpOle);
1059 }
1060 }
1061 return hRet;
1062 }
1063
1064 /*************************************************************************
1065 * @ [SHLWAPI.165]
1066 *
1067 * Retrieve, modify, and re-set a value from a window.
1068 *
1069 * PARAMS
1070 * hWnd [I] Window to get value from
1071 * offset [I] Offset of value
1072 * wMask [I] Mask for uiFlags
1073 * wFlags [I] Bits to set in window value
1074 *
1075 * RETURNS
1076 * The new value as it was set, or 0 if any parameter is invalid.
1077 *
1078 * NOTES
1079 * Any bits set in uiMask are cleared from the value, then any bits set in
1080 * uiFlags are set in the value.
1081 */
1082 LONG WINAPI SHSetWindowBits(HWND hwnd, INT offset, UINT wMask, UINT wFlags)
1083 {
1084 LONG ret = GetWindowLongA(hwnd, offset);
1085 LONG newFlags = (wFlags & wMask) | (ret & ~wFlags);
1086
1087 if (newFlags != ret)
1088 ret = SetWindowLongA(hwnd, offset, newFlags);
1089 return ret;
1090 }
1091
1092 /*************************************************************************
1093 * @ [SHLWAPI.167]
1094 *
1095 * Change a window's parent.
1096 *
1097 * PARAMS
1098 * hWnd [I] Window to change parent of
1099 * hWndParent [I] New parent window
1100 *
1101 * RETURNS
1102 * The old parent of hWnd.
1103 *
1104 * NOTES
1105 * If hWndParent is NULL (desktop), the window style is changed to WS_POPUP.
1106 * If hWndParent is NOT NULL then we set the WS_CHILD style.
1107 */
1108 HWND WINAPI SHSetParentHwnd(HWND hWnd, HWND hWndParent)
1109 {
1110 TRACE("%p, %p\n", hWnd, hWndParent);
1111
1112 if(GetParent(hWnd) == hWndParent)
1113 return 0;
1114
1115 if(hWndParent)
1116 SHSetWindowBits(hWnd, GWL_STYLE, WS_CHILD, WS_CHILD);
1117 else
1118 SHSetWindowBits(hWnd, GWL_STYLE, WS_POPUP, WS_POPUP);
1119
1120 return SetParent(hWnd, hWndParent);
1121 }
1122
1123 /*************************************************************************
1124 * @ [SHLWAPI.168]
1125 *
1126 * Locate and advise a connection point in an IConnectionPointContainer object.
1127 *
1128 * PARAMS
1129 * lpUnkSink [I] Sink for the connection point advise call
1130 * riid [I] REFIID of connection point to advise
1131 * bAdviseOnly [I] TRUE = Advise only, FALSE = Unadvise first
1132 * lpUnknown [I] Object supporting the IConnectionPointContainer interface
1133 * lpCookie [O] Pointer to connection point cookie
1134 * lppCP [O] Destination for the IConnectionPoint found
1135 *
1136 * RETURNS
1137 * Success: S_OK. If lppCP is non-NULL, it is filled with the IConnectionPoint
1138 * that was advised. The caller is responsible for releasing it.
1139 * Failure: E_FAIL, if any arguments are invalid.
1140 * E_NOINTERFACE, if lpUnknown isn't an IConnectionPointContainer,
1141 * Or an HRESULT error code if any call fails.
1142 */
1143 HRESULT WINAPI ConnectToConnectionPoint(IUnknown* lpUnkSink, REFIID riid, BOOL bAdviseOnly,
1144 IUnknown* lpUnknown, LPDWORD lpCookie,
1145 IConnectionPoint **lppCP)
1146 {
1147 HRESULT hRet;
1148 IConnectionPointContainer* lpContainer;
1149 IConnectionPoint *lpCP;
1150
1151 if(!lpUnknown || (bAdviseOnly && !lpUnkSink))
1152 return E_FAIL;
1153
1154 if(lppCP)
1155 *lppCP = NULL;
1156
1157 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer,
1158 (void**)&lpContainer);
1159 if (SUCCEEDED(hRet))
1160 {
1161 hRet = IConnectionPointContainer_FindConnectionPoint(lpContainer, riid, &lpCP);
1162
1163 if (SUCCEEDED(hRet))
1164 {
1165 if(!bAdviseOnly)
1166 hRet = IConnectionPoint_Unadvise(lpCP, *lpCookie);
1167 hRet = IConnectionPoint_Advise(lpCP, lpUnkSink, lpCookie);
1168
1169 if (FAILED(hRet))
1170 *lpCookie = 0;
1171
1172 if (lppCP && SUCCEEDED(hRet))
1173 *lppCP = lpCP; /* Caller keeps the interface */
1174 else
1175 IConnectionPoint_Release(lpCP); /* Release it */
1176 }
1177
1178 IUnknown_Release(lpContainer);
1179 }
1180 return hRet;
1181 }
1182
1183 /*************************************************************************
1184 * @ [SHLWAPI.169]
1185 *
1186 * Release an interface.
1187 *
1188 * PARAMS
1189 * lpUnknown [I] Object to release
1190 *
1191 * RETURNS
1192 * Nothing.
1193 */
1194 DWORD WINAPI IUnknown_AtomicRelease(IUnknown ** lpUnknown)
1195 {
1196 IUnknown *temp;
1197
1198 TRACE("(%p)\n",lpUnknown);
1199
1200 if(!lpUnknown || !*((LPDWORD)lpUnknown)) return 0;
1201 temp = *lpUnknown;
1202 *lpUnknown = NULL;
1203
1204 TRACE("doing Release\n");
1205
1206 return IUnknown_Release(temp);
1207 }
1208
1209 /*************************************************************************
1210 * @ [SHLWAPI.170]
1211 *
1212 * Skip '//' if present in a string.
1213 *
1214 * PARAMS
1215 * lpszSrc [I] String to check for '//'
1216 *
1217 * RETURNS
1218 * Success: The next character after the '//' or the string if not present
1219 * Failure: NULL, if lpszStr is NULL.
1220 */
1221 LPCSTR WINAPI PathSkipLeadingSlashesA(LPCSTR lpszSrc)
1222 {
1223 if (lpszSrc && lpszSrc[0] == '/' && lpszSrc[1] == '/')
1224 lpszSrc += 2;
1225 return lpszSrc;
1226 }
1227
1228 /*************************************************************************
1229 * @ [SHLWAPI.171]
1230 *
1231 * Check if two interfaces come from the same object.
1232 *
1233 * PARAMS
1234 * lpInt1 [I] Interface to check against lpInt2.
1235 * lpInt2 [I] Interface to check against lpInt1.
1236 *
1237 * RETURNS
1238 * TRUE, If the interfaces come from the same object.
1239 * FALSE Otherwise.
1240 */
1241 BOOL WINAPI SHIsSameObject(IUnknown* lpInt1, IUnknown* lpInt2)
1242 {
1243 LPVOID lpUnknown1, lpUnknown2;
1244
1245 TRACE("%p %p\n", lpInt1, lpInt2);
1246
1247 if (!lpInt1 || !lpInt2)
1248 return FALSE;
1249
1250 if (lpInt1 == lpInt2)
1251 return TRUE;
1252
1253 if (FAILED(IUnknown_QueryInterface(lpInt1, &IID_IUnknown, &lpUnknown1)))
1254 return FALSE;
1255
1256 if (FAILED(IUnknown_QueryInterface(lpInt2, &IID_IUnknown, &lpUnknown2)))
1257 return FALSE;
1258
1259 if (lpUnknown1 == lpUnknown2)
1260 return TRUE;
1261
1262 return FALSE;
1263 }
1264
1265 /*************************************************************************
1266 * @ [SHLWAPI.172]
1267 *
1268 * Get the window handle of an object.
1269 *
1270 * PARAMS
1271 * lpUnknown [I] Object to get the window handle of
1272 * lphWnd [O] Destination for window handle
1273 *
1274 * RETURNS
1275 * Success: S_OK. lphWnd contains the objects window handle.
1276 * Failure: An HRESULT error code.
1277 *
1278 * NOTES
1279 * lpUnknown is expected to support one of the following interfaces:
1280 * IOleWindow(), IInternetSecurityMgrSite(), or IShellView().
1281 */
1282 HRESULT WINAPI IUnknown_GetWindow(IUnknown *lpUnknown, HWND *lphWnd)
1283 {
1284 IUnknown *lpOle;
1285 HRESULT hRet = E_FAIL;
1286
1287 TRACE("(%p,%p)\n", lpUnknown, lphWnd);
1288
1289 if (!lpUnknown)
1290 return hRet;
1291
1292 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleWindow, (void**)&lpOle);
1293
1294 if (FAILED(hRet))
1295 {
1296 hRet = IUnknown_QueryInterface(lpUnknown,&IID_IShellView, (void**)&lpOle);
1297
1298 if (FAILED(hRet))
1299 {
1300 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInternetSecurityMgrSite,
1301 (void**)&lpOle);
1302 }
1303 }
1304
1305 if (SUCCEEDED(hRet))
1306 {
1307 /* Lazyness here - Since GetWindow() is the first method for the above 3
1308 * interfaces, we use the same call for them all.
1309 */
1310 hRet = IOleWindow_GetWindow((IOleWindow*)lpOle, lphWnd);
1311 IUnknown_Release(lpOle);
1312 if (lphWnd)
1313 TRACE("Returning HWND=%p\n", *lphWnd);
1314 }
1315
1316 return hRet;
1317 }
1318
1319 /*************************************************************************
1320 * @ [SHLWAPI.173]
1321 *
1322 * Call a method on as as yet unidentified object.
1323 *
1324 * PARAMS
1325 * pUnk [I] Object supporting the unidentified interface,
1326 * arg [I] Argument for the call on the object.
1327 *
1328 * RETURNS
1329 * S_OK.
1330 */
1331 HRESULT WINAPI IUnknown_SetOwner(IUnknown *pUnk, ULONG arg)
1332 {
1333 static const GUID guid_173 = {
1334 0x5836fb00, 0x8187, 0x11cf, { 0xa1,0x2b,0x00,0xaa,0x00,0x4a,0xe8,0x37 }
1335 };
1336 IMalloc *pUnk2;
1337
1338 TRACE("(%p,%d)\n", pUnk, arg);
1339
1340 /* Note: arg may not be a ULONG and pUnk2 is for sure not an IMalloc -
1341 * We use this interface as its vtable entry is compatible with the
1342 * object in question.
1343 * FIXME: Find out what this object is and where it should be defined.
1344 */
1345 if (pUnk &&
1346 SUCCEEDED(IUnknown_QueryInterface(pUnk, &guid_173, (void**)&pUnk2)))
1347 {
1348 IMalloc_Alloc(pUnk2, arg); /* Faked call!! */
1349 IMalloc_Release(pUnk2);
1350 }
1351 return S_OK;
1352 }
1353
1354 /*************************************************************************
1355 * @ [SHLWAPI.174]
1356 *
1357 * Call either IObjectWithSite_SetSite() or IInternetSecurityManager_SetSecuritySite() on
1358 * an object.
1359 *
1360 */
1361 HRESULT WINAPI IUnknown_SetSite(
1362 IUnknown *obj, /* [in] OLE object */
1363 IUnknown *site) /* [in] Site interface */
1364 {
1365 HRESULT hr;
1366 IObjectWithSite *iobjwithsite;
1367 IInternetSecurityManager *isecmgr;
1368
1369 if (!obj) return E_FAIL;
1370
1371 hr = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (LPVOID *)&iobjwithsite);
1372 TRACE("IID_IObjectWithSite QI ret=%08x, %p\n", hr, iobjwithsite);
1373 if (SUCCEEDED(hr))
1374 {
1375 hr = IObjectWithSite_SetSite(iobjwithsite, site);
1376 TRACE("done IObjectWithSite_SetSite ret=%08x\n", hr);
1377 IUnknown_Release(iobjwithsite);
1378 }
1379 else
1380 {
1381 hr = IUnknown_QueryInterface(obj, &IID_IInternetSecurityManager, (LPVOID *)&isecmgr);
1382 TRACE("IID_IInternetSecurityManager QI ret=%08x, %p\n", hr, isecmgr);
1383 if (FAILED(hr)) return hr;
1384
1385 hr = IInternetSecurityManager_SetSecuritySite(isecmgr, (IInternetSecurityMgrSite *)site);
1386 TRACE("done IInternetSecurityManager_SetSecuritySite ret=%08x\n", hr);
1387 IUnknown_Release(isecmgr);
1388 }
1389 return hr;
1390 }
1391
1392 /*************************************************************************
1393 * @ [SHLWAPI.175]
1394 *
1395 * Call IPersist_GetClassID() on an object.
1396 *
1397 * PARAMS
1398 * lpUnknown [I] Object supporting the IPersist interface
1399 * lpClassId [O] Destination for Class Id
1400 *
1401 * RETURNS
1402 * Success: S_OK. lpClassId contains the Class Id requested.
1403 * Failure: E_FAIL, If lpUnknown is NULL,
1404 * E_NOINTERFACE If lpUnknown does not support IPersist,
1405 * Or an HRESULT error code.
1406 */
1407 HRESULT WINAPI IUnknown_GetClassID(IUnknown *lpUnknown, CLSID* lpClassId)
1408 {
1409 IPersist* lpPersist;
1410 HRESULT hRet = E_FAIL;
1411
1412 TRACE("(%p,%p)\n", lpUnknown, debugstr_guid(lpClassId));
1413
1414 if (lpUnknown)
1415 {
1416 hRet = IUnknown_QueryInterface(lpUnknown,&IID_IPersist,(void**)&lpPersist);
1417 if (SUCCEEDED(hRet))
1418 {
1419 IPersist_GetClassID(lpPersist, lpClassId);
1420 IPersist_Release(lpPersist);
1421 }
1422 }
1423 return hRet;
1424 }
1425
1426 /*************************************************************************
1427 * @ [SHLWAPI.176]
1428 *
1429 * Retrieve a Service Interface from an object.
1430 *
1431 * PARAMS
1432 * lpUnknown [I] Object to get an IServiceProvider interface from
1433 * sid [I] Service ID for IServiceProvider_QueryService() call
1434 * riid [I] Function requested for QueryService call
1435 * lppOut [O] Destination for the service interface pointer
1436 *
1437 * RETURNS
1438 * Success: S_OK. lppOut contains an object providing the requested service
1439 * Failure: An HRESULT error code
1440 *
1441 * NOTES
1442 * lpUnknown is expected to support the IServiceProvider interface.
1443 */
1444 HRESULT WINAPI IUnknown_QueryService(IUnknown* lpUnknown, REFGUID sid, REFIID riid,
1445 LPVOID *lppOut)
1446 {
1447 IServiceProvider* pService = NULL;
1448 HRESULT hRet;
1449
1450 if (!lppOut)
1451 return E_FAIL;
1452
1453 *lppOut = NULL;
1454
1455 if (!lpUnknown)
1456 return E_FAIL;
1457
1458 /* Get an IServiceProvider interface from the object */
1459 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IServiceProvider,
1460 (LPVOID*)&pService);
1461
1462 if (hRet == S_OK && pService)
1463 {
1464 TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService);
1465
1466 /* Get a Service interface from the object */
1467 hRet = IServiceProvider_QueryService(pService, sid, riid, lppOut);
1468
1469 TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService, *lppOut);
1470
1471 /* Release the IServiceProvider interface */
1472 IUnknown_Release(pService);
1473 }
1474 return hRet;
1475 }
1476
1477 /*************************************************************************
1478 * @ [SHLWAPI.479]
1479 *
1480 * Call an object's UIActivateIO method.
1481 *
1482 * PARAMS
1483 * unknown [I] Object to call the UIActivateIO method on
1484 * activate [I] Parameter for UIActivateIO call
1485 * msg [I] Parameter for UIActivateIO call
1486 *
1487 * RETURNS
1488 * Success: Value of UI_ActivateIO call
1489 * Failure: An HRESULT error code
1490 *
1491 * NOTES
1492 * unknown is expected to support the IInputObject interface.
1493 */
1494 HRESULT WINAPI IUnknown_UIActivateIO(IUnknown *unknown, BOOL activate, LPMSG msg)
1495 {
1496 IInputObject* object = NULL;
1497 HRESULT ret;
1498
1499 if (!unknown)
1500 return E_FAIL;
1501
1502 /* Get an IInputObject interface from the object */
1503 ret = IUnknown_QueryInterface(unknown, &IID_IInputObject, (LPVOID*) &object);
1504
1505 if (ret == S_OK)
1506 {
1507 ret = IInputObject_UIActivateIO(object, activate, msg);
1508 IUnknown_Release(object);
1509 }
1510
1511 return ret;
1512 }
1513
1514 /*************************************************************************
1515 * @ [SHLWAPI.177]
1516 *
1517 * Loads a popup menu.
1518 *
1519 * PARAMS
1520 * hInst [I] Instance handle
1521 * szName [I] Menu name
1522 *
1523 * RETURNS
1524 * Success: TRUE.
1525 * Failure: FALSE.
1526 */
1527 BOOL WINAPI SHLoadMenuPopup(HINSTANCE hInst, LPCWSTR szName)
1528 {
1529 HMENU hMenu;
1530
1531 if ((hMenu = LoadMenuW(hInst, szName)))
1532 {
1533 if (GetSubMenu(hMenu, 0))
1534 RemoveMenu(hMenu, 0, MF_BYPOSITION);
1535
1536 DestroyMenu(hMenu);
1537 return TRUE;
1538 }
1539 return FALSE;
1540 }
1541
1542 typedef struct _enumWndData
1543 {
1544 UINT uiMsgId;
1545 WPARAM wParam;
1546 LPARAM lParam;
1547 LRESULT (WINAPI *pfnPost)(HWND,UINT,WPARAM,LPARAM);
1548 } enumWndData;
1549
1550 /* Callback for SHLWAPI_178 */
1551 static BOOL CALLBACK SHLWAPI_EnumChildProc(HWND hWnd, LPARAM lParam)
1552 {
1553 enumWndData *data = (enumWndData *)lParam;
1554
1555 TRACE("(%p,%p)\n", hWnd, data);
1556 data->pfnPost(hWnd, data->uiMsgId, data->wParam, data->lParam);
1557 return TRUE;
1558 }
1559
1560 /*************************************************************************
1561 * @ [SHLWAPI.178]
1562 *
1563 * Send or post a message to every child of a window.
1564 *
1565 * PARAMS
1566 * hWnd [I] Window whose children will get the messages
1567 * uiMsgId [I] Message Id
1568 * wParam [I] WPARAM of message
1569 * lParam [I] LPARAM of message
1570 * bSend [I] TRUE = Use SendMessageA(), FALSE = Use PostMessageA()
1571 *
1572 * RETURNS
1573 * Nothing.
1574 *
1575 * NOTES
1576 * The appropriate ASCII or Unicode function is called for the window.
1577 */
1578 void WINAPI SHPropagateMessage(HWND hWnd, UINT uiMsgId, WPARAM wParam, LPARAM lParam, BOOL bSend)
1579 {
1580 enumWndData data;
1581
1582 TRACE("(%p,%u,%ld,%ld,%d)\n", hWnd, uiMsgId, wParam, lParam, bSend);
1583
1584 if(hWnd)
1585 {
1586 data.uiMsgId = uiMsgId;
1587 data.wParam = wParam;
1588 data.lParam = lParam;
1589
1590 if (bSend)
1591 data.pfnPost = IsWindowUnicode(hWnd) ? (void*)SendMessageW : (void*)SendMessageA;
1592 else
1593 data.pfnPost = IsWindowUnicode(hWnd) ? (void*)PostMessageW : (void*)PostMessageA;
1594
1595 EnumChildWindows(hWnd, SHLWAPI_EnumChildProc, (LPARAM)&data);
1596 }
1597 }
1598
1599 /*************************************************************************
1600 * @ [SHLWAPI.180]
1601 *
1602 * Remove all sub-menus from a menu.
1603 *
1604 * PARAMS
1605 * hMenu [I] Menu to remove sub-menus from
1606 *
1607 * RETURNS
1608 * Success: 0. All sub-menus under hMenu are removed
1609 * Failure: -1, if any parameter is invalid
1610 */
1611 DWORD WINAPI SHRemoveAllSubMenus(HMENU hMenu)
1612 {
1613 int iItemCount = GetMenuItemCount(hMenu) - 1;
1614 while (iItemCount >= 0)
1615 {
1616 HMENU hSubMenu = GetSubMenu(hMenu, iItemCount);
1617 if (hSubMenu)
1618 RemoveMenu(hMenu, iItemCount, MF_BYPOSITION);
1619 iItemCount--;
1620 }
1621 return iItemCount;
1622 }
1623
1624 /*************************************************************************
1625 * @ [SHLWAPI.181]
1626 *
1627 * Enable or disable a menu item.
1628 *
1629 * PARAMS
1630 * hMenu [I] Menu holding menu item
1631 * uID [I] ID of menu item to enable/disable
1632 * bEnable [I] Whether to enable (TRUE) or disable (FALSE) the item.
1633 *
1634 * RETURNS
1635 * The return code from EnableMenuItem.
1636 */
1637 UINT WINAPI SHEnableMenuItem(HMENU hMenu, UINT wItemID, BOOL bEnable)
1638 {
1639 return EnableMenuItem(hMenu, wItemID, bEnable ? MF_ENABLED : MF_GRAYED);
1640 }
1641
1642 /*************************************************************************
1643 * @ [SHLWAPI.182]
1644 *
1645 * Check or uncheck a menu item.
1646 *
1647 * PARAMS
1648 * hMenu [I] Menu holding menu item
1649 * uID [I] ID of menu item to check/uncheck
1650 * bCheck [I] Whether to check (TRUE) or uncheck (FALSE) the item.
1651 *
1652 * RETURNS
1653 * The return code from CheckMenuItem.
1654 */
1655 DWORD WINAPI SHCheckMenuItem(HMENU hMenu, UINT uID, BOOL bCheck)
1656 {
1657 return CheckMenuItem(hMenu, uID, bCheck ? MF_CHECKED : MF_UNCHECKED);
1658 }
1659
1660 /*************************************************************************
1661 * @ [SHLWAPI.183]
1662 *
1663 * Register a window class if it isn't already.
1664 *
1665 * PARAMS
1666 * lpWndClass [I] Window class to register
1667 *
1668 * RETURNS
1669 * The result of the RegisterClassA call.
1670 */
1671 DWORD WINAPI SHRegisterClassA(WNDCLASSA *wndclass)
1672 {
1673 WNDCLASSA wca;
1674 if (GetClassInfoA(wndclass->hInstance, wndclass->lpszClassName, &wca))
1675 return TRUE;
1676 return (DWORD)RegisterClassA(wndclass);
1677 }
1678
1679 /*************************************************************************
1680 * @ [SHLWAPI.186]
1681 */
1682 BOOL WINAPI SHSimulateDrop(IDropTarget *pDrop, IDataObject *pDataObj,
1683 DWORD grfKeyState, PPOINTL lpPt, DWORD* pdwEffect)
1684 {
1685 DWORD dwEffect = DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY;
1686 POINTL pt = { 0, 0 };
1687
1688 if (!lpPt)
1689 lpPt = &pt;
1690
1691 if (!pdwEffect)
1692 pdwEffect = &dwEffect;
1693
1694 IDropTarget_DragEnter(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1695
1696 if (*pdwEffect)
1697 return IDropTarget_Drop(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1698
1699 IDropTarget_DragLeave(pDrop);
1700 return TRUE;
1701 }
1702
1703 /*************************************************************************
1704 * @ [SHLWAPI.187]
1705 *
1706 * Call IPersistPropertyBag_Load() on an object.
1707 *
1708 * PARAMS
1709 * lpUnknown [I] Object supporting the IPersistPropertyBag interface
1710 * lpPropBag [O] Destination for loaded IPropertyBag
1711 *
1712 * RETURNS
1713 * Success: S_OK.
1714 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1715 */
1716 DWORD WINAPI SHLoadFromPropertyBag(IUnknown *lpUnknown, IPropertyBag* lpPropBag)
1717 {
1718 IPersistPropertyBag* lpPPBag;
1719 HRESULT hRet = E_FAIL;
1720
1721 TRACE("(%p,%p)\n", lpUnknown, lpPropBag);
1722
1723 if (lpUnknown)
1724 {
1725 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IPersistPropertyBag,
1726 (void**)&lpPPBag);
1727 if (SUCCEEDED(hRet) && lpPPBag)
1728 {
1729 hRet = IPersistPropertyBag_Load(lpPPBag, lpPropBag, NULL);
1730 IPersistPropertyBag_Release(lpPPBag);
1731 }
1732 }
1733 return hRet;
1734 }
1735
1736 /*************************************************************************
1737 * @ [SHLWAPI.188]
1738 *
1739 * Call IOleControlSite_TranslateAccelerator() on an object.
1740 *
1741 * PARAMS
1742 * lpUnknown [I] Object supporting the IOleControlSite interface.
1743 * lpMsg [I] Key message to be processed.
1744 * dwModifiers [I] Flags containing the state of the modifier keys.
1745 *
1746 * RETURNS
1747 * Success: S_OK.
1748 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
1749 */
1750 HRESULT WINAPI IUnknown_TranslateAcceleratorOCS(IUnknown *lpUnknown, LPMSG lpMsg, DWORD dwModifiers)
1751 {
1752 IOleControlSite* lpCSite = NULL;
1753 HRESULT hRet = E_INVALIDARG;
1754
1755 TRACE("(%p,%p,0x%08x)\n", lpUnknown, lpMsg, dwModifiers);
1756 if (lpUnknown)
1757 {
1758 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1759 (void**)&lpCSite);
1760 if (SUCCEEDED(hRet) && lpCSite)
1761 {
1762 hRet = IOleControlSite_TranslateAccelerator(lpCSite, lpMsg, dwModifiers);
1763 IOleControlSite_Release(lpCSite);
1764 }
1765 }
1766 return hRet;
1767 }
1768
1769
1770 /*************************************************************************
1771 * @ [SHLWAPI.189]
1772 *
1773 * Call IOleControlSite_OnFocus() on an object.
1774 *
1775 * PARAMS
1776 * lpUnknown [I] Object supporting the IOleControlSite interface.
1777 * fGotFocus [I] Whether focus was gained (TRUE) or lost (FALSE).
1778 *
1779 * RETURNS
1780 * Success: S_OK.
1781 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1782 */
1783 HRESULT WINAPI IUnknown_OnFocusOCS(IUnknown *lpUnknown, BOOL fGotFocus)
1784 {
1785 IOleControlSite* lpCSite = NULL;
1786 HRESULT hRet = E_FAIL;
1787
1788 TRACE("(%p,%s)\n", lpUnknown, fGotFocus ? "TRUE" : "FALSE");
1789 if (lpUnknown)
1790 {
1791 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1792 (void**)&lpCSite);
1793 if (SUCCEEDED(hRet) && lpCSite)
1794 {
1795 hRet = IOleControlSite_OnFocus(lpCSite, fGotFocus);
1796 IOleControlSite_Release(lpCSite);
1797 }
1798 }
1799 return hRet;
1800 }
1801
1802 /*************************************************************************
1803 * @ [SHLWAPI.190]
1804 */
1805 HRESULT WINAPI IUnknown_HandleIRestrict(LPUNKNOWN lpUnknown, PVOID lpArg1,
1806 PVOID lpArg2, PVOID lpArg3, PVOID lpArg4)
1807 {
1808 /* FIXME: {D12F26B2-D90A-11D0-830D-00AA005B4383} - What object does this represent? */
1809 static const DWORD service_id[] = { 0xd12f26b2, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1810 /* FIXME: {D12F26B1-D90A-11D0-830D-00AA005B4383} - Also Unknown/undocumented */
1811 static const DWORD function_id[] = { 0xd12f26b1, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1812 HRESULT hRet = E_INVALIDARG;
1813 LPUNKNOWN lpUnkInner = NULL; /* FIXME: Real type is unknown */
1814
1815 TRACE("(%p,%p,%p,%p,%p)\n", lpUnknown, lpArg1, lpArg2, lpArg3, lpArg4);
1816
1817 if (lpUnknown && lpArg4)
1818 {
1819 hRet = IUnknown_QueryService(lpUnknown, (REFGUID)service_id,
1820 (REFGUID)function_id, (void**)&lpUnkInner);
1821
1822 if (SUCCEEDED(hRet) && lpUnkInner)
1823 {
1824 /* FIXME: The type of service object requested is unknown, however
1825 * testing shows that its first method is called with 4 parameters.
1826 * Fake this by using IParseDisplayName_ParseDisplayName since the
1827 * signature and position in the vtable matches our unknown object type.
1828 */
1829 hRet = IParseDisplayName_ParseDisplayName((LPPARSEDISPLAYNAME)lpUnkInner,
1830 lpArg1, lpArg2, lpArg3, lpArg4);
1831 IUnknown_Release(lpUnkInner);
1832 }
1833 }
1834 return hRet;
1835 }
1836
1837 /*************************************************************************
1838 * @ [SHLWAPI.192]
1839 *
1840 * Get a sub-menu from a menu item.
1841 *
1842 * PARAMS
1843 * hMenu [I] Menu to get sub-menu from
1844 * uID [I] ID of menu item containing sub-menu
1845 *
1846 * RETURNS
1847 * The sub-menu of the item, or a NULL handle if any parameters are invalid.
1848 */
1849 HMENU WINAPI SHGetMenuFromID(HMENU hMenu, UINT uID)
1850 {
1851 MENUITEMINFOW mi;
1852
1853 TRACE("(%p,%u)\n", hMenu, uID);
1854
1855 mi.cbSize = sizeof(mi);
1856 mi.fMask = MIIM_SUBMENU;
1857
1858 if (!GetMenuItemInfoW(hMenu, uID, FALSE, &mi))
1859 return NULL;
1860
1861 return mi.hSubMenu;
1862 }
1863
1864 /*************************************************************************
1865 * @ [SHLWAPI.193]
1866 *
1867 * Get the color depth of the primary display.
1868 *
1869 * PARAMS
1870 * None.
1871 *
1872 * RETURNS
1873 * The color depth of the primary display.
1874 */
1875 DWORD WINAPI SHGetCurColorRes(void)
1876 {
1877 HDC hdc;
1878 DWORD ret;
1879
1880 TRACE("()\n");
1881
1882 hdc = GetDC(0);
1883 ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
1884 ReleaseDC(0, hdc);
1885 return ret;
1886 }
1887
1888 /*************************************************************************
1889 * @ [SHLWAPI.194]
1890 *
1891 * Wait for a message to arrive, with a timeout.
1892 *
1893 * PARAMS
1894 * hand [I] Handle to query
1895 * dwTimeout [I] Timeout in ticks or INFINITE to never timeout
1896 *
1897 * RETURNS
1898 * STATUS_TIMEOUT if no message is received before dwTimeout ticks passes.
1899 * Otherwise returns the value from MsgWaitForMultipleObjectsEx when a
1900 * message is available.
1901 */
1902 DWORD WINAPI SHWaitForSendMessageThread(HANDLE hand, DWORD dwTimeout)
1903 {
1904 DWORD dwEndTicks = GetTickCount() + dwTimeout;
1905 DWORD dwRet;
1906
1907 while ((dwRet = MsgWaitForMultipleObjectsEx(1, &hand, dwTimeout, QS_SENDMESSAGE, 0)) == 1)
1908 {
1909 MSG msg;
1910
1911 PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
1912
1913 if (dwTimeout != INFINITE)
1914 {
1915 if ((int)(dwTimeout = dwEndTicks - GetTickCount()) <= 0)
1916 return WAIT_TIMEOUT;
1917 }
1918 }
1919
1920 return dwRet;
1921 }
1922
1923 /*************************************************************************
1924 * @ [SHLWAPI.195]
1925 *
1926 * Determine if a shell folder can be expanded.
1927 *
1928 * PARAMS
1929 * lpFolder [I] Parent folder containing the object to test.
1930 * pidl [I] Id of the object to test.
1931 *
1932 * RETURNS
1933 * Success: S_OK, if the object is expandable, S_FALSE otherwise.
1934 * Failure: E_INVALIDARG, if any argument is invalid.
1935 *
1936 * NOTES
1937 * If the object to be tested does not expose the IQueryInfo() interface it
1938 * will not be identified as an expandable folder.
1939 */
1940 HRESULT WINAPI SHIsExpandableFolder(LPSHELLFOLDER lpFolder, LPCITEMIDLIST pidl)
1941 {
1942 HRESULT hRet = E_INVALIDARG;
1943 IQueryInfo *lpInfo;
1944
1945 if (lpFolder && pidl)
1946 {
1947 hRet = IShellFolder_GetUIObjectOf(lpFolder, NULL, 1, &pidl, &IID_IQueryInfo,
1948 NULL, (void**)&lpInfo);
1949 if (FAILED(hRet))
1950 hRet = S_FALSE; /* Doesn't expose IQueryInfo */
1951 else
1952 {
1953 DWORD dwFlags = 0;
1954
1955 /* MSDN states of IQueryInfo_GetInfoFlags() that "This method is not
1956 * currently used". Really? You wouldn't be holding out on me would you?
1957 */
1958 hRet = IQueryInfo_GetInfoFlags(lpInfo, &dwFlags);
1959
1960 if (SUCCEEDED(hRet))
1961 {
1962 /* 0x2 is an undocumented flag apparently indicating expandability */
1963 hRet = dwFlags & 0x2 ? S_OK : S_FALSE;
1964 }
1965
1966 IQueryInfo_Release(lpInfo);
1967 }
1968 }
1969 return hRet;
1970 }
1971
1972 /*************************************************************************
1973 * @ [SHLWAPI.197]
1974 *
1975 * Blank out a region of text by drawing the background only.
1976 *
1977 * PARAMS
1978 * hDC [I] Device context to draw in
1979 * pRect [I] Area to draw in
1980 * cRef [I] Color to draw in
1981 *
1982 * RETURNS
1983 * Nothing.
1984 */
1985 DWORD WINAPI SHFillRectClr(HDC hDC, LPCRECT pRect, COLORREF cRef)
1986 {
1987 COLORREF cOldColor = SetBkColor(hDC, cRef);
1988 ExtTextOutA(hDC, 0, 0, ETO_OPAQUE, pRect, 0, 0, 0);
1989 SetBkColor(hDC, cOldColor);
1990 return 0;
1991 }
1992
1993 /*************************************************************************
1994 * @ [SHLWAPI.198]
1995 *
1996 * Return the value associated with a key in a map.
1997 *
1998 * PARAMS
1999 * lpKeys [I] A list of keys of length iLen
2000 * lpValues [I] A list of values associated with lpKeys, of length iLen
2001 * iLen [I] Length of both lpKeys and lpValues
2002 * iKey [I] The key value to look up in lpKeys
2003 *
2004 * RETURNS
2005 * The value in lpValues associated with iKey, or -1 if iKey is not
2006 * found in lpKeys.
2007 *
2008 * NOTES
2009 * - If two elements in the map share the same key, this function returns
2010 * the value closest to the start of the map
2011 * - The native version of this function crashes if lpKeys or lpValues is NULL.
2012 */
2013 int WINAPI SHSearchMapInt(const int *lpKeys, const int *lpValues, int iLen, int iKey)
2014 {
2015 if (lpKeys && lpValues)
2016 {
2017 int i = 0;
2018
2019 while (i < iLen)
2020 {
2021 if (lpKeys[i] == iKey)
2022 return lpValues[i]; /* Found */
2023 i++;
2024 }
2025 }
2026 return -1; /* Not found */
2027 }
2028
2029
2030 /*************************************************************************
2031 * @ [SHLWAPI.199]
2032 *
2033 * Copy an interface pointer
2034 *
2035 * PARAMS
2036 * lppDest [O] Destination for copy
2037 * lpUnknown [I] Source for copy
2038 *
2039 * RETURNS
2040 * Nothing.
2041 */
2042 VOID WINAPI IUnknown_Set(IUnknown **lppDest, IUnknown *lpUnknown)
2043 {
2044 TRACE("(%p,%p)\n", lppDest, lpUnknown);
2045
2046 if (lppDest)
2047 IUnknown_AtomicRelease(lppDest); /* Release existing interface */
2048
2049 if (lpUnknown)
2050 {
2051 /* Copy */
2052 IUnknown_AddRef(lpUnknown);
2053 *lppDest = lpUnknown;
2054 }
2055 }
2056
2057 /*************************************************************************
2058 * @ [SHLWAPI.200]
2059 *
2060 */
2061 HRESULT WINAPI MayQSForward(IUnknown* lpUnknown, PVOID lpReserved,
2062 REFGUID riidCmdGrp, ULONG cCmds,
2063 OLECMD *prgCmds, OLECMDTEXT* pCmdText)
2064 {
2065 FIXME("(%p,%p,%p,%d,%p,%p) - stub\n",
2066 lpUnknown, lpReserved, riidCmdGrp, cCmds, prgCmds, pCmdText);
2067
2068 /* FIXME: Calls IsQSForward & IUnknown_QueryStatus */
2069 return DRAGDROP_E_NOTREGISTERED;
2070 }
2071
2072 /*************************************************************************
2073 * @ [SHLWAPI.201]
2074 *
2075 */
2076 HRESULT WINAPI MayExecForward(IUnknown* lpUnknown, INT iUnk, REFGUID pguidCmdGroup,
2077 DWORD nCmdID, DWORD nCmdexecopt, VARIANT* pvaIn,
2078 VARIANT* pvaOut)
2079 {
2080 FIXME("(%p,%d,%p,%d,%d,%p,%p) - stub!\n", lpUnknown, iUnk, pguidCmdGroup,
2081 nCmdID, nCmdexecopt, pvaIn, pvaOut);
2082 return DRAGDROP_E_NOTREGISTERED;
2083 }
2084
2085 /*************************************************************************
2086 * @ [SHLWAPI.202]
2087 *
2088 */
2089 HRESULT WINAPI IsQSForward(REFGUID pguidCmdGroup,ULONG cCmds, OLECMD *prgCmds)
2090 {
2091 FIXME("(%p,%d,%p) - stub!\n", pguidCmdGroup, cCmds, prgCmds);
2092 return DRAGDROP_E_NOTREGISTERED;
2093 }
2094
2095 /*************************************************************************
2096 * @ [SHLWAPI.204]
2097 *
2098 * Determine if a window is not a child of another window.
2099 *
2100 * PARAMS
2101 * hParent [I] Suspected parent window
2102 * hChild [I] Suspected child window
2103 *
2104 * RETURNS
2105 * TRUE: If hChild is a child window of hParent
2106 * FALSE: If hChild is not a child window of hParent, or they are equal
2107 */
2108 BOOL WINAPI SHIsChildOrSelf(HWND hParent, HWND hChild)
2109 {
2110 TRACE("(%p,%p)\n", hParent, hChild);
2111
2112 if (!hParent || !hChild)
2113 return TRUE;
2114 else if(hParent == hChild)
2115 return FALSE;
2116 return !IsChild(hParent, hChild);
2117 }
2118
2119 /*************************************************************************
2120 * FDSA functions. Manage a dynamic array of fixed size memory blocks.
2121 */
2122
2123 typedef struct
2124 {
2125 DWORD num_items; /* Number of elements inserted */
2126 void *mem; /* Ptr to array */
2127 DWORD blocks_alloced; /* Number of elements allocated */
2128 BYTE inc; /* Number of elements to grow by when we need to expand */
2129 BYTE block_size; /* Size in bytes of an element */
2130 BYTE flags; /* Flags */
2131 } FDSA_info;
2132
2133 #define FDSA_FLAG_INTERNAL_ALLOC 0x01 /* When set we have allocated mem internally */
2134
2135 /*************************************************************************
2136 * @ [SHLWAPI.208]
2137 *
2138 * Initialize an FDSA array.
2139 */
2140 BOOL WINAPI FDSA_Initialize(DWORD block_size, DWORD inc, FDSA_info *info, void *mem,
2141 DWORD init_blocks)
2142 {
2143 TRACE("(0x%08x 0x%08x %p %p 0x%08x)\n", block_size, inc, info, mem, init_blocks);
2144
2145 if(inc == 0)
2146 inc = 1;
2147
2148 if(mem)
2149 memset(mem, 0, block_size * init_blocks);
2150
2151 info->num_items = 0;
2152 info->inc = inc;
2153 info->mem = mem;
2154 info->blocks_alloced = init_blocks;
2155 info->block_size = block_size;
2156 info->flags = 0;
2157
2158 return TRUE;
2159 }
2160
2161 /*************************************************************************
2162 * @ [SHLWAPI.209]
2163 *
2164 * Destroy an FDSA array
2165 */
2166 BOOL WINAPI FDSA_Destroy(FDSA_info *info)
2167 {
2168 TRACE("(%p)\n", info);
2169
2170 if(info->flags & FDSA_FLAG_INTERNAL_ALLOC)
2171 {
2172 HeapFree(GetProcessHeap(), 0, info->mem);
2173 return FALSE;
2174 }
2175
2176 return TRUE;
2177 }
2178
2179 /*************************************************************************
2180 * @ [SHLWAPI.210]
2181 *
2182 * Insert element into an FDSA array
2183 */
2184 DWORD WINAPI FDSA_InsertItem(FDSA_info *info, DWORD where, const void *block)
2185 {
2186 TRACE("(%p 0x%08x %p)\n", info, where, block);
2187 if(where > info->num_items)
2188 where = info->num_items;
2189
2190 if(info->num_items >= info->blocks_alloced)
2191 {
2192 DWORD size = (info->blocks_alloced + info->inc) * info->block_size;
2193 if(info->flags & 0x1)
2194 info->mem = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->mem, size);
2195 else
2196 {
2197 void *old_mem = info->mem;
2198 info->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2199 memcpy(info->mem, old_mem, info->blocks_alloced * info->block_size);
2200 }
2201 info->blocks_alloced += info->inc;
2202 info->flags |= 0x1;
2203 }
2204
2205 if(where < info->num_items)
2206 {
2207 memmove((char*)info->mem + (where + 1) * info->block_size,
2208 (char*)info->mem + where * info->block_size,
2209 (info->num_items - where) * info->block_size);
2210 }
2211 memcpy((char*)info->mem + where * info->block_size, block, info->block_size);
2212
2213 info->num_items++;
2214 return where;
2215 }
2216
2217 /*************************************************************************
2218 * @ [SHLWAPI.211]
2219 *
2220 * Delete an element from an FDSA array.
2221 */
2222 BOOL WINAPI FDSA_DeleteItem(FDSA_info *info, DWORD where)
2223 {
2224 TRACE("(%p 0x%08x)\n", info, where);
2225
2226 if(where >= info->num_items)
2227 return FALSE;
2228
2229 if(where < info->num_items - 1)
2230 {
2231 memmove((char*)info->mem + where * info->block_size,
2232 (char*)info->mem + (where + 1) * info->block_size,
2233 (info->num_items - where - 1) * info->block_size);
2234 }
2235 memset((char*)info->mem + (info->num_items - 1) * info->block_size,
2236 0, info->block_size);
2237 info->num_items--;
2238 return TRUE;
2239 }
2240
2241
2242 typedef struct {
2243 REFIID refid;
2244 DWORD indx;
2245 } IFACE_INDEX_TBL;
2246
2247 /*************************************************************************
2248 * @ [SHLWAPI.219]
2249 *
2250 * Call IUnknown_QueryInterface() on a table of objects.
2251 *
2252 * RETURNS
2253 * Success: S_OK.
2254 * Failure: E_POINTER or E_NOINTERFACE.
2255 */
2256 HRESULT WINAPI QISearch(
2257 LPVOID w, /* [in] Table of interfaces */
2258 IFACE_INDEX_TBL *x, /* [in] Array of REFIIDs and indexes into the table */
2259 REFIID riid, /* [in] REFIID to get interface for */
2260 LPVOID *ppv) /* [out] Destination for interface pointer */
2261 {
2262 HRESULT ret;
2263 IUnknown *a_vtbl;
2264 IFACE_INDEX_TBL *xmove;
2265
2266 TRACE("(%p %p %s %p)\n", w,x,debugstr_guid(riid),ppv);
2267 if (ppv) {
2268 xmove = x;
2269 while (xmove->refid) {
2270 TRACE("trying (indx %d) %s\n", xmove->indx, debugstr_guid(xmove->refid));
2271 if (IsEqualIID(riid, xmove->refid)) {
2272 a_vtbl = (IUnknown*)(xmove->indx + (LPBYTE)w);
2273 TRACE("matched, returning (%p)\n", a_vtbl);
2274 *ppv = a_vtbl;
2275 IUnknown_AddRef(a_vtbl);
2276 return S_OK;
2277 }
2278 xmove++;
2279 }
2280
2281 if (IsEqualIID(riid, &IID_IUnknown)) {
2282 a_vtbl = (IUnknown*)(x->indx + (LPBYTE)w);
2283 TRACE("returning first for IUnknown (%p)\n", a_vtbl);
2284 *ppv = a_vtbl;
2285 IUnknown_AddRef(a_vtbl);
2286 return S_OK;
2287 }
2288 *ppv = 0;
2289 ret = E_NOINTERFACE;
2290 } else
2291 ret = E_POINTER;
2292
2293 TRACE("-- 0x%08x\n", ret);
2294 return ret;
2295 }
2296
2297 /*************************************************************************
2298 * @ [SHLWAPI.220]
2299 *
2300 * Set the Font for a window and the "PropDlgFont" property of the parent window.
2301 *
2302 * PARAMS
2303 * hWnd [I] Parent Window to set the property
2304 * id [I] Index of child Window to set the Font
2305 *
2306 * RETURNS
2307 * Success: S_OK
2308 *
2309 */
2310 HRESULT WINAPI SHSetDefaultDialogFont(HWND hWnd, INT id)
2311 {
2312 FIXME("(%p, %d) stub\n", hWnd, id);
2313 return S_OK;
2314 }
2315
2316 /*************************************************************************
2317 * @ [SHLWAPI.221]
2318 *
2319 * Remove the "PropDlgFont" property from a window.
2320 *
2321 * PARAMS
2322 * hWnd [I] Window to remove the property from
2323 *
2324 * RETURNS
2325 * A handle to the removed property, or NULL if it did not exist.
2326 */
2327 HANDLE WINAPI SHRemoveDefaultDialogFont(HWND hWnd)
2328 {
2329 HANDLE hProp;
2330
2331 TRACE("(%p)\n", hWnd);
2332
2333 hProp = GetPropA(hWnd, "PropDlgFont");
2334
2335 if(hProp)
2336 {
2337 DeleteObject(hProp);
2338 hProp = RemovePropA(hWnd, "PropDlgFont");
2339 }
2340 return hProp;
2341 }
2342
2343 /*************************************************************************
2344 * @ [SHLWAPI.236]
2345 *
2346 * Load the in-process server of a given GUID.
2347 *
2348 * PARAMS
2349 * refiid [I] GUID of the server to load.
2350 *
2351 * RETURNS
2352 * Success: A handle to the loaded server dll.
2353 * Failure: A NULL handle.
2354 */
2355 HMODULE WINAPI SHPinDllOfCLSID(REFIID refiid)
2356 {
2357 HKEY newkey;
2358 DWORD type, count;
2359 CHAR value[MAX_PATH], string[MAX_PATH];
2360
2361 strcpy(string, "CLSID\\");
2362 SHStringFromGUIDA(refiid, string + 6, sizeof(string)/sizeof(char) - 6);
2363 strcat(string, "\\InProcServer32");
2364
2365 count = MAX_PATH;
2366 RegOpenKeyExA(HKEY_CLASSES_ROOT, string, 0, 1, &newkey);
2367 RegQueryValueExA(newkey, 0, 0, &type, (PBYTE)value, &count);
2368 RegCloseKey(newkey);
2369 return LoadLibraryExA(value, 0, 0);
2370 }
2371
2372 /*************************************************************************
2373 * @ [SHLWAPI.237]
2374 *
2375 * Unicode version of SHLWAPI_183.
2376 */
2377 DWORD WINAPI SHRegisterClassW(WNDCLASSW * lpWndClass)
2378 {
2379 WNDCLASSW WndClass;
2380
2381 TRACE("(%p %s)\n",lpWndClass->hInstance, debugstr_w(lpWndClass->lpszClassName));
2382
2383 if (GetClassInfoW(lpWndClass->hInstance, lpWndClass->lpszClassName, &WndClass))
2384 return TRUE;
2385 return RegisterClassW(lpWndClass);
2386 }
2387
2388 /*************************************************************************
2389 * @ [SHLWAPI.238]
2390 *
2391 * Unregister a list of classes.
2392 *
2393 * PARAMS
2394 * hInst [I] Application instance that registered the classes
2395 * lppClasses [I] List of class names
2396 * iCount [I] Number of names in lppClasses
2397 *
2398 * RETURNS
2399 * Nothing.
2400 */
2401 void WINAPI SHUnregisterClassesA(HINSTANCE hInst, LPCSTR *lppClasses, INT iCount)
2402 {
2403 WNDCLASSA WndClass;
2404
2405 TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2406
2407 while (iCount > 0)
2408 {
2409 if (GetClassInfoA(hInst, *lppClasses, &WndClass))
2410 UnregisterClassA(*lppClasses, hInst);
2411 lppClasses++;
2412 iCount--;
2413 }
2414 }
2415
2416 /*************************************************************************
2417 * @ [SHLWAPI.239]
2418 *
2419 * Unicode version of SHUnregisterClassesA.
2420 */
2421 void WINAPI SHUnregisterClassesW(HINSTANCE hInst, LPCWSTR *lppClasses, INT iCount)
2422 {
2423 WNDCLASSW WndClass;
2424
2425 TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2426
2427 while (iCount > 0)
2428 {
2429 if (GetClassInfoW(hInst, *lppClasses, &WndClass))
2430 UnregisterClassW(*lppClasses, hInst);
2431 lppClasses++;
2432 iCount--;
2433 }
2434 }
2435
2436 /*************************************************************************
2437 * @ [SHLWAPI.240]
2438 *
2439 * Call The correct (Ascii/Unicode) default window procedure for a window.
2440 *
2441 * PARAMS
2442 * hWnd [I] Window to call the default procedure for
2443 * uMessage [I] Message ID
2444 * wParam [I] WPARAM of message
2445 * lParam [I] LPARAM of message
2446 *
2447 * RETURNS
2448 * The result of calling DefWindowProcA() or DefWindowProcW().
2449 */
2450 LRESULT CALLBACK SHDefWindowProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
2451 {
2452 if (IsWindowUnicode(hWnd))
2453 return DefWindowProcW(hWnd, uMessage, wParam, lParam);
2454 return DefWindowProcA(hWnd, uMessage, wParam, lParam);
2455 }
2456
2457 /*************************************************************************
2458 * @ [SHLWAPI.256]
2459 */
2460 HRESULT WINAPI IUnknown_GetSite(LPUNKNOWN lpUnknown, REFIID iid, PVOID *lppSite)
2461 {
2462 HRESULT hRet = E_INVALIDARG;
2463 LPOBJECTWITHSITE lpSite = NULL;
2464
2465 TRACE("(%p,%s,%p)\n", lpUnknown, debugstr_guid(iid), lppSite);
2466
2467 if (lpUnknown && iid && lppSite)
2468 {
2469 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IObjectWithSite,
2470 (void**)&lpSite);
2471 if (SUCCEEDED(hRet) && lpSite)
2472 {
2473 hRet = IObjectWithSite_GetSite(lpSite, iid, lppSite);
2474 IObjectWithSite_Release(lpSite);
2475 }
2476 }
2477 return hRet;
2478 }
2479
2480 /*************************************************************************
2481 * @ [SHLWAPI.257]
2482 *
2483 * Create a worker window using CreateWindowExA().
2484 *
2485 * PARAMS
2486 * wndProc [I] Window procedure
2487 * hWndParent [I] Parent window
2488 * dwExStyle [I] Extra style flags
2489 * dwStyle [I] Style flags
2490 * hMenu [I] Window menu
2491 * z [I] Unknown
2492 *
2493 * RETURNS
2494 * Success: The window handle of the newly created window.
2495 * Failure: 0.
2496 */
2497 HWND WINAPI SHCreateWorkerWindowA(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2498 DWORD dwStyle, HMENU hMenu, LONG z)
2499 {
2500 static const char szClass[] = "WorkerA";
2501 WNDCLASSA wc;
2502 HWND hWnd;
2503
2504 TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2505 wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2506
2507 /* Create Window class */
2508 wc.style = 0;
2509 wc.lpfnWndProc = DefWindowProcA;
2510 wc.cbClsExtra = 0;
2511 wc.cbWndExtra = 4;
2512 wc.hInstance = shlwapi_hInstance;
2513 wc.hIcon = NULL;
2514 wc.hCursor = LoadCursorA(NULL, (LPSTR)IDC_ARROW);
2515 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2516 wc.lpszMenuName = NULL;
2517 wc.lpszClassName = szClass;
2518
2519 SHRegisterClassA(&wc); /* Register class */
2520
2521 /* FIXME: Set extra bits in dwExStyle */
2522
2523 hWnd = CreateWindowExA(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2524 hWndParent, hMenu, shlwapi_hInstance, 0);
2525 if (hWnd)
2526 {
2527 SetWindowLongPtrW(hWnd, DWLP_MSGRESULT, z);
2528
2529 if (wndProc)
2530 SetWindowLongPtrA(hWnd, GWLP_WNDPROC, wndProc);
2531 }
2532 return hWnd;
2533 }
2534
2535 typedef struct tagPOLICYDATA
2536 {
2537 DWORD policy; /* flags value passed to SHRestricted */
2538 LPCWSTR appstr; /* application str such as "Explorer" */
2539 LPCWSTR keystr; /* name of the actual registry key / policy */
2540 } POLICYDATA, *LPPOLICYDATA;
2541
2542 #define SHELL_NO_POLICY 0xffffffff
2543
2544 /* default shell policy registry key */
2545 static const WCHAR strRegistryPolicyW[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o',
2546 's','o','f','t','\\','W','i','n','d','o','w','s','\\',
2547 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',
2548 '\\','P','o','l','i','c','i','e','s',0};
2549
2550 /*************************************************************************
2551 * @ [SHLWAPI.271]
2552 *
2553 * Retrieve a policy value from the registry.
2554 *
2555 * PARAMS
2556 * lpSubKey [I] registry key name
2557 * lpSubName [I] subname of registry key
2558 * lpValue [I] value name of registry value
2559 *
2560 * RETURNS
2561 * the value associated with the registry key or 0 if not found
2562 */
2563 DWORD WINAPI SHGetRestriction(LPCWSTR lpSubKey, LPCWSTR lpSubName, LPCWSTR lpValue)
2564 {
2565 DWORD retval, datsize = sizeof(retval);
2566 HKEY hKey;
2567
2568 if (!lpSubKey)
2569 lpSubKey = strRegistryPolicyW;
2570
2571 retval = RegOpenKeyW(HKEY_LOCAL_MACHINE, lpSubKey, &hKey);
2572 if (retval != ERROR_SUCCESS)
2573 retval = RegOpenKeyW(HKEY_CURRENT_USER, lpSubKey, &hKey);
2574 if (retval != ERROR_SUCCESS)
2575 return 0;
2576
2577 SHGetValueW(hKey, lpSubName, lpValue, NULL, &retval, &datsize);
2578 RegCloseKey(hKey);
2579 return retval;
2580 }
2581
2582 /*************************************************************************
2583 * @ [SHLWAPI.266]
2584 *
2585 * Helper function to retrieve the possibly cached value for a specific policy
2586 *
2587 * PARAMS
2588 * policy [I] The policy to look for
2589 * initial [I] Main registry key to open, if NULL use default
2590 * polTable [I] Table of known policies, 0 terminated
2591 * polArr [I] Cache array of policy values
2592 *
2593 * RETURNS
2594 * The retrieved policy value or 0 if not successful
2595 *
2596 * NOTES
2597 * This function is used by the native SHRestricted function to search for the
2598 * policy and cache it once retrieved. The current Wine implementation uses a
2599 * different POLICYDATA structure and implements a similar algorithm adapted to
2600 * that structure.
2601 */
2602 DWORD WINAPI SHRestrictionLookup(
2603 DWORD policy,
2604 LPCWSTR initial,
2605 LPPOLICYDATA polTable,
2606 LPDWORD polArr)
2607 {
2608 TRACE("(0x%08x %s %p %p)\n", policy, debugstr_w(initial), polTable, polArr);
2609
2610 if (!polTable || !polArr)
2611 return 0;
2612
2613 for (;polTable->policy; polTable++, polArr++)
2614 {
2615 if (policy == polTable->policy)
2616 {
2617 /* we have a known policy */
2618
2619 /* check if this policy has been cached */
2620 if (*polArr == SHELL_NO_POLICY)
2621 *polArr = SHGetRestriction(initial, polTable->appstr, polTable->keystr);
2622 return *polArr;
2623 }
2624 }
2625 /* we don't know this policy, return 0 */
2626 TRACE("unknown policy: (%08x)\n", policy);
2627 return 0;
2628 }
2629
2630 /*************************************************************************
2631 * @ [SHLWAPI.267]
2632 *
2633 * Get an interface from an object.
2634 *
2635 * RETURNS
2636 * Success: S_OK. ppv contains the requested interface.
2637 * Failure: An HRESULT error code.
2638 *
2639 * NOTES
2640 * This QueryInterface asks the inner object for an interface. In case
2641 * of aggregation this request would be forwarded by the inner to the
2642 * outer object. This function asks the inner object directly for the
2643 * interface circumventing the forwarding to the outer object.
2644 */
2645 HRESULT WINAPI SHWeakQueryInterface(
2646 IUnknown * pUnk, /* [in] Outer object */
2647 IUnknown * pInner, /* [in] Inner object */
2648 IID * riid, /* [in] Interface GUID to query for */
2649 LPVOID* ppv) /* [out] Destination for queried interface */
2650 {
2651 HRESULT hret = E_NOINTERFACE;
2652 TRACE("(pUnk=%p pInner=%p\n\tIID: %s %p)\n",pUnk,pInner,debugstr_guid(riid), ppv);
2653
2654 *ppv = NULL;
2655 if(pUnk && pInner) {
2656 hret = IUnknown_QueryInterface(pInner, riid, ppv);
2657 if (SUCCEEDED(hret)) IUnknown_Release(pUnk);
2658 }
2659 TRACE("-- 0x%08x\n", hret);
2660 return hret;
2661 }
2662
2663 /*************************************************************************
2664 * @ [SHLWAPI.268]
2665 *
2666 * Move a reference from one interface to another.
2667 *
2668 * PARAMS
2669 * lpDest [O] Destination to receive the reference
2670 * lppUnknown [O] Source to give up the reference to lpDest
2671 *
2672 * RETURNS
2673 * Nothing.
2674 */
2675 VOID WINAPI SHWeakReleaseInterface(IUnknown *lpDest, IUnknown **lppUnknown)
2676 {
2677 TRACE("(%p,%p)\n", lpDest, lppUnknown);
2678
2679 if (*lppUnknown)
2680 {
2681 /* Copy Reference*/
2682 IUnknown_AddRef(lpDest);
2683 IUnknown_AtomicRelease(lppUnknown); /* Release existing interface */
2684 }
2685 }
2686
2687 /*************************************************************************
2688 * @ [SHLWAPI.269]
2689 *
2690 * Convert an ASCII string of a CLSID into a CLSID.
2691 *
2692 * PARAMS
2693 * idstr [I] String representing a CLSID in registry format
2694 * id [O] Destination for the converted CLSID
2695 *
2696 * RETURNS
2697 * Success: TRUE. id contains the converted CLSID.
2698 * Failure: FALSE.
2699 */
2700 BOOL WINAPI GUIDFromStringA(LPCSTR idstr, CLSID *id)
2701 {
2702 WCHAR wClsid[40];
2703 MultiByteToWideChar(CP_ACP, 0, idstr, -1, wClsid, sizeof(wClsid)/sizeof(WCHAR));
2704 return SUCCEEDED(CLSIDFromString(wClsid, id));
2705 }
2706
2707 /*************************************************************************
2708 * @ [SHLWAPI.270]
2709 *
2710 * Unicode version of GUIDFromStringA.
2711 */
2712 BOOL WINAPI GUIDFromStringW(LPCWSTR idstr, CLSID *id)
2713 {
2714 return SUCCEEDED(CLSIDFromString((LPOLESTR)idstr, id));
2715 }
2716
2717 /*************************************************************************
2718 * @ [SHLWAPI.276]
2719 *
2720 * Determine if the browser is integrated into the shell, and set a registry
2721 * key accordingly.
2722 *
2723 * PARAMS
2724 * None.
2725 *
2726 * RETURNS
2727 * 1, If the browser is not integrated.
2728 * 2, If the browser is integrated.
2729 *
2730 * NOTES
2731 * The key "HKLM\Software\Microsoft\Internet Explorer\IntegratedBrowser" is
2732 * either set to TRUE, or removed depending on whether the browser is deemed
2733 * to be integrated.
2734 */
2735 DWORD WINAPI WhichPlatform(void)
2736 {
2737 static const char szIntegratedBrowser[] = "IntegratedBrowser";
2738 static DWORD dwState = 0;
2739 HKEY hKey;
2740 DWORD dwRet, dwData, dwSize;
2741 HMODULE hshell32;
2742
2743 if (dwState)
2744 return dwState;
2745
2746 /* If shell32 exports DllGetVersion(), the browser is integrated */
2747 dwState = 1;
2748 hshell32 = LoadLibraryA("shell32.dll");
2749 if (hshell32)
2750 {
2751 FARPROC pDllGetVersion;
2752 pDllGetVersion = GetProcAddress(hshell32, "DllGetVersion");
2753 dwState = pDllGetVersion ? 2 : 1;
2754 FreeLibrary(hshell32);
2755 }
2756
2757 /* Set or delete the key accordingly */
2758 dwRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2759 "Software\\Microsoft\\Internet Explorer", 0,
2760 KEY_ALL_ACCESS, &hKey);
2761 if (!dwRet)
2762 {
2763 dwRet = RegQueryValueExA(hKey, szIntegratedBrowser, 0, 0,
2764 (LPBYTE)&dwData, &dwSize);
2765
2766 if (!dwRet && dwState == 1)
2767 {
2768 /* Value exists but browser is not integrated */
2769 RegDeleteValueA(hKey, szIntegratedBrowser);
2770 }
2771 else if (dwRet && dwState == 2)
2772 {
2773 /* Browser is integrated but value does not exist */
2774 dwData = TRUE;
2775 RegSetValueExA(hKey, szIntegratedBrowser, 0, REG_DWORD,
2776 (LPBYTE)&dwData, sizeof(dwData));
2777 }
2778 RegCloseKey(hKey);
2779 }
2780 return dwState;
2781 }
2782
2783 /*************************************************************************
2784 * @ [SHLWAPI.278]
2785 *
2786 * Unicode version of SHCreateWorkerWindowA.
2787 */
2788 HWND WINAPI SHCreateWorkerWindowW(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2789 DWORD dwStyle, HMENU hMenu, LONG z)
2790 {
2791 static const WCHAR szClass[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', '\0' };
2792 WNDCLASSW wc;
2793 HWND hWnd;
2794
2795 TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2796 wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2797
2798 /* If our OS is natively ASCII, use the ASCII version */
2799 if (!(GetVersion() & 0x80000000)) /* NT */
2800 return SHCreateWorkerWindowA(wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2801
2802 /* Create Window class */
2803 wc.style = 0;
2804 wc.lpfnWndProc = DefWindowProcW;
2805 wc.cbClsExtra = 0;
2806 wc.cbWndExtra = 4;
2807 wc.hInstance = shlwapi_hInstance;
2808 wc.hIcon = NULL;
2809 wc.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
2810 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2811 wc.lpszMenuName = NULL;
2812 wc.lpszClassName = szClass;
2813
2814 SHRegisterClassW(&wc); /* Register class */
2815
2816 /* FIXME: Set extra bits in dwExStyle */
2817
2818 hWnd = CreateWindowExW(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2819 hWndParent, hMenu, shlwapi_hInstance, 0);
2820 if (hWnd)
2821 {
2822 SetWindowLongPtrW(hWnd, DWLP_MSGRESULT, z);
2823
2824 if (wndProc)
2825 SetWindowLongPtrW(hWnd, GWLP_WNDPROC, wndProc);
2826 }
2827 return hWnd;
2828 }
2829
2830 /*************************************************************************
2831 * @ [SHLWAPI.279]
2832 *
2833 * Get and show a context menu from a shell folder.
2834 *
2835 * PARAMS
2836 * hWnd [I] Window displaying the shell folder
2837 * lpFolder [I] IShellFolder interface
2838 * lpApidl [I] Id for the particular folder desired
2839 *
2840 * RETURNS
2841 * Success: S_OK.
2842 * Failure: An HRESULT error code indicating the error.
2843 */
2844 HRESULT WINAPI SHInvokeDefaultCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl)
2845 {
2846 return SHInvokeCommand(hWnd, lpFolder, lpApidl, FALSE);
2847 }
2848
2849 /*************************************************************************
2850 * @ [SHLWAPI.281]
2851 *
2852 * _SHPackDispParamsV
2853 */
2854 HRESULT WINAPI SHPackDispParamsV(DISPPARAMS *params, VARIANTARG *args, UINT cnt, __ms_va_list valist)
2855 {
2856 VARIANTARG *iter;
2857
2858 TRACE("(%p %p %u ...)\n", params, args, cnt);
2859
2860 params->rgvarg = args;
2861 params->rgdispidNamedArgs = NULL;
2862 params->cArgs = cnt;
2863 params->cNamedArgs = 0;
2864
2865 iter = args+cnt;
2866
2867 while(iter-- > args) {
2868 V_VT(iter) = va_arg(valist, enum VARENUM);
2869
2870 TRACE("vt=%d\n", V_VT(iter));
2871
2872 if(V_VT(iter) & VT_BYREF) {
2873 V_BYREF(iter) = va_arg(valist, LPVOID);
2874 } else {
2875 switch(V_VT(iter)) {
2876 case VT_I4:
2877 V_I4(iter) = va_arg(valist, LONG);
2878 break;
2879 case VT_BSTR:
2880 V_BSTR(iter) = va_arg(valist, BSTR);
2881 break;
2882 case VT_DISPATCH:
2883 V_DISPATCH(iter) = va_arg(valist, IDispatch*);
2884 break;
2885 case VT_BOOL:
2886 V_BOOL(iter) = va_arg(valist, int);
2887 break;
2888 case VT_UNKNOWN:
2889 V_UNKNOWN(iter) = va_arg(valist, IUnknown*);
2890 break;
2891 default:
2892 V_VT(iter) = VT_I4;
2893 V_I4(iter) = va_arg(valist, LONG);
2894 }
2895 }
2896 }
2897
2898 return S_OK;
2899 }
2900
2901 /*************************************************************************
2902 * @ [SHLWAPI.282]
2903 *
2904 * SHPackDispParams
2905 */
2906 HRESULT WINAPIV SHPackDispParams(DISPPARAMS *params, VARIANTARG *args, UINT cnt, ...)
2907 {
2908 __ms_va_list valist;
2909 HRESULT hres;
2910
2911 __ms_va_start(valist, cnt);
2912 hres = SHPackDispParamsV(params, args, cnt, valist);
2913 __ms_va_end(valist);
2914 return hres;
2915 }
2916
2917 /*************************************************************************
2918 * SHLWAPI_InvokeByIID
2919 *
2920 * This helper function calls IDispatch::Invoke for each sink
2921 * which implements given iid or IDispatch.
2922 *
2923 */
2924 static HRESULT SHLWAPI_InvokeByIID(
2925 IConnectionPoint* iCP,
2926 REFIID iid,
2927 DISPID dispId,
2928 DISPPARAMS* dispParams)
2929 {
2930 IEnumConnections *enumerator;
2931 CONNECTDATA rgcd;
2932
2933 HRESULT result = IConnectionPoint_EnumConnections(iCP, &enumerator);
2934 if (FAILED(result))
2935 return result;
2936
2937 while(IEnumConnections_Next(enumerator, 1, &rgcd, NULL)==S_OK)
2938 {
2939 IDispatch *dispIface;
2940 if (SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, iid, (LPVOID*)&dispIface)) ||
2941 SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, &IID_IDispatch, (LPVOID*)&dispIface)))
2942 {
2943 IDispatch_Invoke(dispIface, dispId, &IID_NULL, 0, DISPATCH_METHOD, dispParams, NULL, NULL, NULL);
2944 IDispatch_Release(dispIface);
2945 }
2946 }
2947
2948 IEnumConnections_Release(enumerator);
2949
2950 return S_OK;
2951 }
2952
2953 /*************************************************************************
2954 * IConnectionPoint_InvokeWithCancel [SHLWAPI.283]
2955 */
2956 HRESULT WINAPI IConnectionPoint_InvokeWithCancel( IConnectionPoint* iCP,
2957 DISPID dispId, DISPPARAMS* dispParams,
2958 DWORD unknown1, DWORD unknown2 )
2959 {
2960 IID iid;
2961 HRESULT result;
2962
2963 FIXME("(%p)->(0x%x %p %x %x) partial stub\n", iCP, dispId, dispParams, unknown1, unknown2);
2964
2965 result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
2966 if (SUCCEEDED(result))
2967 result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
2968
2969 return result;
2970 }
2971
2972
2973 /*************************************************************************
2974 * @ [SHLWAPI.284]
2975 *
2976 * IConnectionPoint_SimpleInvoke
2977 */
2978 HRESULT WINAPI IConnectionPoint_SimpleInvoke(
2979 IConnectionPoint* iCP,
2980 DISPID dispId,
2981 DISPPARAMS* dispParams)
2982 {
2983 IID iid;
2984 HRESULT result;
2985
2986 TRACE("(%p)->(0x%x %p)\n",iCP,dispId,dispParams);
2987
2988 result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
2989 if (SUCCEEDED(result))
2990 result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
2991
2992 return result;
2993 }
2994
2995 /*************************************************************************
2996 * @ [SHLWAPI.285]
2997 *
2998 * Notify an IConnectionPoint object of changes.
2999 *
3000 * PARAMS
3001 * lpCP [I] Object to notify
3002 * dispID [I]
3003 *
3004 * RETURNS
3005 * Success: S_OK.
3006 * Failure: E_NOINTERFACE, if lpCP is NULL or does not support the
3007 * IConnectionPoint interface.
3008 */
3009 HRESULT WINAPI IConnectionPoint_OnChanged(IConnectionPoint* lpCP, DISPID dispID)
3010 {
3011 IEnumConnections *lpEnum;
3012 HRESULT hRet = E_NOINTERFACE;
3013
3014 TRACE("(%p,0x%8X)\n", lpCP, dispID);
3015
3016 /* Get an enumerator for the connections */
3017 if (lpCP)
3018 hRet = IConnectionPoint_EnumConnections(lpCP, &lpEnum);
3019
3020 if (SUCCEEDED(hRet))
3021 {
3022 IPropertyNotifySink *lpSink;
3023 CONNECTDATA connData;
3024 ULONG ulFetched;
3025
3026 /* Call OnChanged() for every notify sink in the connection point */
3027 while (IEnumConnections_Next(lpEnum, 1, &connData, &ulFetched) == S_OK)
3028 {
3029 if (SUCCEEDED(IUnknown_QueryInterface(connData.pUnk, &IID_IPropertyNotifySink, (void**)&lpSink)) &&
3030 lpSink)
3031 {
3032 IPropertyNotifySink_OnChanged(lpSink, dispID);
3033 IPropertyNotifySink_Release(lpSink);
3034 }
3035 IUnknown_Release(connData.pUnk);
3036 }
3037
3038 IEnumConnections_Release(lpEnum);
3039 }
3040 return hRet;
3041 }
3042
3043 /*************************************************************************
3044 * @ [SHLWAPI.286]
3045 *
3046 * IUnknown_CPContainerInvokeParam
3047 */
3048 HRESULT WINAPIV IUnknown_CPContainerInvokeParam(
3049 IUnknown *container,
3050 REFIID riid,
3051 DISPID dispId,
3052 VARIANTARG* buffer,
3053 DWORD cParams, ...)
3054 {
3055 HRESULT result;
3056 IConnectionPoint *iCP;
3057 IConnectionPointContainer *iCPC;
3058 DISPPARAMS dispParams = {buffer, NULL, cParams, 0};
3059 __ms_va_list valist;
3060
3061 if (!container)
3062 return E_NOINTERFACE;
3063
3064 result = IUnknown_QueryInterface(container, &IID_IConnectionPointContainer,(LPVOID*) &iCPC);
3065 if (FAILED(result))
3066 return result;
3067
3068 result = IConnectionPointContainer_FindConnectionPoint(iCPC, riid, &iCP);
3069 IConnectionPointContainer_Release(iCPC);
3070 if(FAILED(result))
3071 return result;
3072
3073 __ms_va_start(valist, cParams);
3074 SHPackDispParamsV(&dispParams, buffer, cParams, valist);
3075 __ms_va_end(valist);
3076
3077 result = SHLWAPI_InvokeByIID(iCP, riid, dispId, &dispParams);
3078 IConnectionPoint_Release(iCP);
3079
3080 return result;
3081 }
3082
3083 /*************************************************************************
3084 * @ [SHLWAPI.287]
3085 *
3086 * Notify an IConnectionPointContainer object of changes.
3087 *
3088 * PARAMS
3089 * lpUnknown [I] Object to notify
3090 * dispID [I]
3091 *
3092 * RETURNS
3093 * Success: S_OK.
3094 * Failure: E_NOINTERFACE, if lpUnknown is NULL or does not support the
3095 * IConnectionPointContainer interface.
3096 */
3097 HRESULT WINAPI IUnknown_CPContainerOnChanged(IUnknown *lpUnknown, DISPID dispID)
3098 {
3099 IConnectionPointContainer* lpCPC = NULL;
3100 HRESULT hRet = E_NOINTERFACE;
3101
3102 TRACE("(%p,0x%8X)\n", lpUnknown, dispID);
3103
3104 if (lpUnknown)
3105 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer, (void**)&lpCPC);
3106
3107 if (SUCCEEDED(hRet))
3108 {
3109 IConnectionPoint* lpCP;
3110
3111 hRet = IConnectionPointContainer_FindConnectionPoint(lpCPC, &IID_IPropertyNotifySink, &lpCP);
3112 IConnectionPointContainer_Release(lpCPC);
3113
3114 hRet = IConnectionPoint_OnChanged(lpCP, dispID);
3115 IConnectionPoint_Release(lpCP);
3116 }
3117 return hRet;
3118 }
3119
3120 /*************************************************************************
3121 * @ [SHLWAPI.289]
3122 *
3123 * See PlaySoundW.
3124 */
3125 BOOL WINAPI PlaySoundWrapW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
3126 {
3127 return PlaySoundW(pszSound, hmod, fdwSound);
3128 }
3129
3130 /*************************************************************************
3131 * @ [SHLWAPI.294]
3132 */
3133 BOOL WINAPI SHGetIniStringW(LPCWSTR str1, LPCWSTR str2, LPWSTR pStr, DWORD some_len, LPCWSTR lpStr2)
3134 {
3135 FIXME("(%s,%s,%p,%08x,%s): stub!\n", debugstr_w(str1), debugstr_w(str2),
3136 pStr, some_len, debugstr_w(lpStr2));
3137 return TRUE;
3138 }
3139
3140 /*************************************************************************
3141 * @ [SHLWAPI.295]
3142 *
3143 * Called by ICQ2000b install via SHDOCVW:
3144 * str1: "InternetShortcut"
3145 * x: some unknown pointer
3146 * str2: "http://free.aol.com/tryaolfree/index.adp?139269"
3147 * str3: "C:\\WINDOWS\\Desktop.new2\\Free AOL & Unlimited Internet.url"
3148 *
3149 * In short: this one maybe creates a desktop link :-)
3150 */
3151 BOOL WINAPI SHSetIniStringW(LPWSTR str1, LPVOID x, LPWSTR str2, LPWSTR str3)
3152 {
3153 FIXME("(%s, %p, %s, %s), stub.\n", debugstr_w(str1), x, debugstr_w(str2), debugstr_w(str3));
3154 return TRUE;
3155 }
3156
3157 /*************************************************************************
3158 * @ [SHLWAPI.313]
3159 *
3160 * See SHGetFileInfoW.
3161 */
3162 DWORD WINAPI SHGetFileInfoWrapW(LPCWSTR path, DWORD dwFileAttributes,
3163 SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags)
3164 {
3165 return SHGetFileInfoW(path, dwFileAttributes, psfi, sizeofpsfi, flags);
3166 }
3167
3168 /*************************************************************************
3169 * @ [SHLWAPI.318]
3170 *
3171 * See DragQueryFileW.
3172 */
3173 UINT WINAPI DragQueryFileWrapW(HDROP hDrop, UINT lFile, LPWSTR lpszFile, UINT lLength)
3174 {
3175 return DragQueryFileW(hDrop, lFile, lpszFile, lLength);
3176 }
3177
3178 /*************************************************************************
3179 * @ [SHLWAPI.333]
3180 *
3181 * See SHBrowseForFolderW.
3182 */
3183 LPITEMIDLIST WINAPI SHBrowseForFolderWrapW(LPBROWSEINFOW lpBi)
3184 {
3185 return SHBrowseForFolderW(lpBi);
3186 }
3187
3188 /*************************************************************************
3189 * @ [SHLWAPI.334]
3190 *
3191 * See SHGetPathFromIDListW.
3192 */
3193 BOOL WINAPI SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl,LPWSTR pszPath)
3194 {
3195 return SHGetPathFromIDListW(pidl, pszPath);
3196 }
3197
3198 /*************************************************************************
3199 * @ [SHLWAPI.335]
3200 *
3201 * See ShellExecuteExW.
3202 */
3203 BOOL WINAPI ShellExecuteExWrapW(LPSHELLEXECUTEINFOW lpExecInfo)
3204 {
3205 return ShellExecuteExW(lpExecInfo);
3206 }
3207
3208 /*************************************************************************
3209 * @ [SHLWAPI.336]
3210 *
3211 * See SHFileOperationW.
3212 */
3213 INT WINAPI SHFileOperationWrapW(LPSHFILEOPSTRUCTW lpFileOp)
3214 {
3215 return SHFileOperationW(lpFileOp);
3216 }
3217
3218 /*************************************************************************
3219 * @ [SHLWAPI.342]
3220 *
3221 */
3222 PVOID WINAPI SHInterlockedCompareExchange( PVOID *dest, PVOID xchg, PVOID compare )
3223 {
3224 return InterlockedCompareExchangePointer( dest, xchg, compare );
3225 }
3226
3227 /*************************************************************************
3228 * @ [SHLWAPI.350]
3229 *
3230 * See GetFileVersionInfoSizeW.
3231 */
3232 DWORD WINAPI GetFileVersionInfoSizeWrapW( LPCWSTR filename, LPDWORD handle )
3233 {
3234 return GetFileVersionInfoSizeW( filename, handle );
3235 }
3236
3237 /*************************************************************************
3238 * @ [SHLWAPI.351]
3239 *
3240 * See GetFileVersionInfoW.
3241 */
3242 BOOL WINAPI GetFileVersionInfoWrapW( LPCWSTR filename, DWORD handle,
3243 DWORD datasize, LPVOID data )
3244 {
3245 return GetFileVersionInfoW( filename, handle, datasize, data );
3246 }
3247
3248 /*************************************************************************
3249 * @ [SHLWAPI.352]
3250 *
3251 * See VerQueryValueW.
3252 */
3253 WORD WINAPI VerQueryValueWrapW( LPVOID pBlock, LPCWSTR lpSubBlock,
3254 LPVOID *lplpBuffer, UINT *puLen )
3255 {
3256 return VerQueryValueW( pBlock, lpSubBlock, lplpBuffer, puLen );
3257 }
3258
3259 #define IsIface(type) SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
3260 #define IShellBrowser_EnableModeless IShellBrowser_EnableModelessSB
3261 #define EnableModeless(type) type##_EnableModeless((type*)lpObj, bModeless)
3262
3263 /*************************************************************************
3264 * @ [SHLWAPI.355]
3265 *
3266 * Change the modality of a shell object.
3267 *
3268 * PARAMS
3269 * lpUnknown [I] Object to make modeless
3270 * bModeless [I] TRUE=Make modeless, FALSE=Make modal
3271 *
3272 * RETURNS
3273 * Success: S_OK. The modality lpUnknown is changed.
3274 * Failure: An HRESULT error code indicating the error.
3275 *
3276 * NOTES
3277 * lpUnknown must support the IOleInPlaceFrame interface, the
3278 * IInternetSecurityMgrSite interface, the IShellBrowser interface
3279 * the IDocHostUIHandler interface, or the IOleInPlaceActiveObject interface,
3280 * or this call will fail.
3281 */
3282 HRESULT WINAPI IUnknown_EnableModeless(IUnknown *lpUnknown, BOOL bModeless)
3283 {
3284 IUnknown *lpObj;
3285 HRESULT hRet;
3286
3287 TRACE("(%p,%d)\n", lpUnknown, bModeless);
3288
3289 if (!lpUnknown)
3290 return E_FAIL;
3291
3292 if (IsIface(IOleInPlaceActiveObject))
3293 EnableModeless(IOleInPlaceActiveObject);
3294 else if (IsIface(IOleInPlaceFrame))
3295 EnableModeless(IOleInPlaceFrame);
3296 else if (IsIface(IShellBrowser))
3297 EnableModeless(IShellBrowser);
3298 else if (IsIface(IInternetSecurityMgrSite))
3299 EnableModeless(IInternetSecurityMgrSite);
3300 else if (IsIface(IDocHostUIHandler))
3301 EnableModeless(IDocHostUIHandler);
3302 else
3303 return hRet;
3304
3305 IUnknown_Release(lpObj);
3306 return S_OK;
3307 }
3308
3309 /*************************************************************************
3310 * @ [SHLWAPI.357]
3311 *
3312 * See SHGetNewLinkInfoW.
3313 */
3314 BOOL WINAPI SHGetNewLinkInfoWrapW(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName,
3315 BOOL *pfMustCopy, UINT uFlags)
3316 {
3317 return SHGetNewLinkInfoW(pszLinkTo, pszDir, pszName, pfMustCopy, uFlags);
3318 }
3319
3320 /*************************************************************************
3321 * @ [SHLWAPI.358]
3322 *
3323 * See SHDefExtractIconW.
3324 */
3325 UINT WINAPI SHDefExtractIconWrapW(LPCWSTR pszIconFile, int iIndex, UINT uFlags, HICON* phiconLarge,
3326 HICON* phiconSmall, UINT nIconSize)
3327 {
3328 return SHDefExtractIconW(pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
3329 }
3330
3331 /*************************************************************************
3332 * @ [SHLWAPI.363]
3333 *
3334 * Get and show a context menu from a shell folder.
3335 *
3336 * PARAMS
3337 * hWnd [I] Window displaying the shell folder
3338 * lpFolder [I] IShellFolder interface
3339 * lpApidl [I] Id for the particular folder desired
3340 * bInvokeDefault [I] Whether to invoke the default menu item
3341 *
3342 * RETURNS
3343 * Success: S_OK. If bInvokeDefault is TRUE, the default menu action was
3344 * executed.
3345 * Failure: An HRESULT error code indicating the error.
3346 */
3347 HRESULT WINAPI SHInvokeCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl, BOOL bInvokeDefault)
3348 {
3349 IContextMenu *iContext;
3350 HRESULT hRet = E_FAIL;
3351
3352 TRACE("(%p,%p,%p,%d)\n", hWnd, lpFolder, lpApidl, bInvokeDefault);
3353
3354 if (!lpFolder)
3355 return hRet;
3356
3357 /* Get the context menu from the shell folder */
3358 hRet = IShellFolder_GetUIObjectOf(lpFolder, hWnd, 1, &lpApidl,
3359 &IID_IContextMenu, 0, (void**)&iContext);
3360 if (SUCCEEDED(hRet))
3361 {
3362 HMENU hMenu;
3363 if ((hMenu = CreatePopupMenu()))
3364 {
3365 HRESULT hQuery;
3366 DWORD dwDefaultId = 0;
3367
3368 /* Add the context menu entries to the popup */
3369 hQuery = IContextMenu_QueryContextMenu(iContext, hMenu, 0, 1, 0x7FFF,
3370 bInvokeDefault ? CMF_NORMAL : CMF_DEFAULTONLY);
3371
3372 if (SUCCEEDED(hQuery))
3373 {
3374 if (bInvokeDefault &&
3375 (dwDefaultId = GetMenuDefaultItem(hMenu, 0, 0)) != 0xFFFFFFFF)
3376 {
3377 CMINVOKECOMMANDINFO cmIci;
3378 /* Invoke the default item */
3379 memset(&cmIci,0,sizeof(cmIci));
3380 cmIci.cbSize = sizeof(cmIci);
3381 cmIci.fMask = CMIC_MASK_ASYNCOK;
3382 cmIci.hwnd = hWnd;
3383 cmIci.lpVerb = MAKEINTRESOURCEA(dwDefaultId);
3384 cmIci.nShow = SW_SCROLLCHILDREN;
3385
3386 hRet = IContextMenu_InvokeCommand(iContext, &cmIci);
3387 }
3388 }
3389 DestroyMenu(hMenu);
3390 }
3391 IContextMenu_Release(iContext);
3392 }
3393 return hRet;
3394 }
3395
3396 /*************************************************************************
3397 * @ [SHLWAPI.370]
3398 *
3399 * See ExtractIconW.
3400 */
3401 HICON WINAPI ExtractIconWrapW(HINSTANCE hInstance, LPCWSTR lpszExeFileName,
3402 UINT nIconIndex)
3403 {
3404 return ExtractIconW(hInstance, lpszExeFileName, nIconIndex);
3405 }
3406
3407 /*************************************************************************
3408 * @ [SHLWAPI.377]
3409 *
3410 * Load a library from the directory of a particular process.
3411 *
3412 * PARAMS
3413 * new_mod [I] Library name
3414 * inst_hwnd [I] Module whose directory is to be used
3415 * dwCrossCodePage [I] Should be FALSE (currently ignored)
3416 *
3417 * RETURNS
3418 * Success: A handle to the loaded module
3419 * Failure: A NULL handle.
3420 */
3421 HMODULE WINAPI MLLoadLibraryA(LPCSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3422 {
3423 /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
3424 * each call here.
3425 * FIXME: Native shows calls to:
3426 * SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
3427 * CheckVersion
3428 * RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
3429 * RegQueryValueExA for "LPKInstalled"
3430 * RegCloseKey
3431 * RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
3432 * RegQueryValueExA for "ResourceLocale"
3433 * RegCloseKey
3434 * RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
3435 * RegQueryValueExA for "Locale"
3436 * RegCloseKey
3437 * and then tests the Locale ("en" for me).
3438 * code below
3439 * after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
3440 */
3441 CHAR mod_path[2*MAX_PATH];
3442 LPSTR ptr;
3443 DWORD len;
3444
3445 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_a(new_mod), inst_hwnd, dwCrossCodePage);
3446 len = GetModuleFileNameA(inst_hwnd, mod_path, sizeof(mod_path));
3447 if (!len || len >= sizeof(mod_path)) return NULL;
3448
3449 ptr = strrchr(mod_path, '\\');
3450 if (ptr) {
3451 strcpy(ptr+1, new_mod);
3452 TRACE("loading %s\n", debugstr_a(mod_path));
3453 return LoadLibraryA(mod_path);
3454 }
3455 return NULL;
3456 }
3457
3458 /*************************************************************************
3459 * @ [SHLWAPI.378]
3460 *
3461 * Unicode version of MLLoadLibraryA.
3462 */
3463 HMODULE WINAPI MLLoadLibraryW(LPCWSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3464 {
3465 WCHAR mod_path[2*MAX_PATH];
3466 LPWSTR ptr;
3467 DWORD len;
3468
3469 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_w(new_mod), inst_hwnd, dwCrossCodePage);
3470 len = GetModuleFileNameW(inst_hwnd, mod_path, sizeof(mod_path) / sizeof(WCHAR));
3471 if (!len || len >= sizeof(mod_path) / sizeof(WCHAR)) return NULL;
3472
3473 ptr = strrchrW(mod_path, '\\');
3474 if (ptr) {
3475 strcpyW(ptr+1, new_mod);
3476 TRACE("loading %s\n", debugstr_w(mod_path));
3477 return LoadLibraryW(mod_path);
3478 }
3479 return NULL;
3480 }
3481
3482 /*************************************************************************
3483 * ColorAdjustLuma [SHLWAPI.@]
3484 *
3485 * Adjust the luminosity of a color
3486 *
3487 * PARAMS
3488 * cRGB [I] RGB value to convert
3489 * dwLuma [I] Luma adjustment
3490 * bUnknown [I] Unknown
3491 *
3492 * RETURNS
3493 * The adjusted RGB color.
3494 */
3495 COLORREF WINAPI ColorAdjustLuma(COLORREF cRGB, int dwLuma, BOOL bUnknown)
3496 {
3497 TRACE("(0x%8x,%d,%d)\n", cRGB, dwLuma, bUnknown);
3498
3499 if (dwLuma)
3500 {
3501 WORD wH, wL, wS;
3502
3503 ColorRGBToHLS(cRGB, &wH, &wL, &wS);
3504
3505 FIXME("Ignoring luma adjustment\n");
3506
3507 /* FIXME: The adjustment is not linear */
3508
3509 cRGB = ColorHLSToRGB(wH, wL, wS);
3510 }
3511 return cRGB;
3512 }
3513
3514 /*************************************************************************
3515 * @ [SHLWAPI.389]
3516 *
3517 * See GetSaveFileNameW.
3518 */
3519 BOOL WINAPI GetSaveFileNameWrapW(LPOPENFILENAMEW ofn)
3520 {
3521 return GetSaveFileNameW(ofn);
3522 }
3523
3524 /*************************************************************************
3525 * @ [SHLWAPI.390]
3526 *
3527 * See WNetRestoreConnectionW.
3528 */
3529 DWORD WINAPI WNetRestoreConnectionWrapW(HWND hwndOwner, LPWSTR lpszDevice)
3530 {
3531 return WNetRestoreConnectionW(hwndOwner, lpszDevice);
3532 }
3533
3534 /*************************************************************************
3535 * @ [SHLWAPI.391]
3536 *
3537 * See WNetGetLastErrorW.
3538 */
3539 DWORD WINAPI WNetGetLastErrorWrapW(LPDWORD lpError, LPWSTR lpErrorBuf, DWORD nErrorBufSize,
3540 LPWSTR lpNameBuf, DWORD nNameBufSize)
3541 {
3542 return WNetGetLastErrorW(lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize);
3543 }
3544
3545 /*************************************************************************
3546 * @ [SHLWAPI.401]
3547 *
3548 * See PageSetupDlgW.
3549 */
3550 BOOL WINAPI PageSetupDlgWrapW(LPPAGESETUPDLGW pagedlg)
3551 {
3552 return PageSetupDlgW(pagedlg);
3553 }
3554
3555 /*************************************************************************
3556 * @ [SHLWAPI.402]
3557 *
3558 * See PrintDlgW.
3559 */
3560 BOOL WINAPI PrintDlgWrapW(LPPRINTDLGW printdlg)
3561 {
3562 return PrintDlgW(printdlg);
3563 }
3564
3565 /*************************************************************************
3566 * @ [SHLWAPI.403]
3567 *
3568 * See GetOpenFileNameW.
3569 */
3570 BOOL WINAPI GetOpenFileNameWrapW(LPOPENFILENAMEW ofn)
3571 {
3572 return GetOpenFileNameW(ofn);
3573 }
3574
3575 /*************************************************************************
3576 * @ [SHLWAPI.404]
3577 */
3578 HRESULT WINAPI SHIShellFolder_EnumObjects(LPSHELLFOLDER lpFolder, HWND hwnd, SHCONTF flags, IEnumIDList **ppenum)
3579 {
3580 IPersist *persist;
3581 HRESULT hr;
3582
3583 hr = IShellFolder_QueryInterface(lpFolder, &IID_IPersist, (LPVOID)&persist);
3584 if(SUCCEEDED(hr))
3585 {
3586 CLSID clsid;
3587 hr = IPersist_GetClassID(persist, &clsid);
3588 if(SUCCEEDED(hr))
3589 {
3590 if(IsEqualCLSID(&clsid, &CLSID_ShellFSFolder))
3591 hr = IShellFolder_EnumObjects(lpFolder, hwnd, flags, ppenum);
3592 else
3593 hr = E_FAIL;
3594 }
3595 IPersist_Release(persist);
3596 }
3597 return hr;
3598 }
3599
3600 /* INTERNAL: Map from HLS color space to RGB */
3601 static WORD ConvertHue(int wHue, WORD wMid1, WORD wMid2)
3602 {
3603 wHue = wHue > 240 ? wHue - 240 : wHue < 0 ? wHue + 240 : wHue;
3604
3605 if (wHue > 160)
3606 return wMid1;
3607 else if (wHue > 120)
3608 wHue = 160 - wHue;
3609 else if (wHue > 40)
3610 return wMid2;
3611
3612 return ((wHue * (wMid2 - wMid1) + 20) / 40) + wMid1;
3613 }
3614
3615 /* Convert to RGB and scale into RGB range (0..255) */
3616 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
3617
3618 /*************************************************************************
3619 * ColorHLSToRGB [SHLWAPI.@]
3620 *
3621 * Convert from hls color space into an rgb COLORREF.
3622 *
3623 * PARAMS
3624 * wHue [I] Hue amount
3625 * wLuminosity [I] Luminosity amount
3626 * wSaturation [I] Saturation amount
3627 *
3628 * RETURNS
3629 * A COLORREF representing the converted color.
3630 *
3631 * NOTES
3632 * Input hls values are constrained to the range (0..240).
3633 */
3634 COLORREF WINAPI ColorHLSToRGB(WORD wHue, WORD wLuminosity, WORD wSaturation)
3635 {
3636 WORD wRed;
3637
3638 if (wSaturation)
3639 {
3640 WORD wGreen, wBlue, wMid1, wMid2;
3641
3642 if (wLuminosity > 120)
3643 wMid2 = wSaturation + wLuminosity - (wSaturation * wLuminosity + 120) / 240;
3644 else
3645 wMid2 = ((wSaturation + 240) * wLuminosity + 120) / 240;
3646
3647 wMid1 = wLuminosity * 2 - wMid2;
3648
3649 wRed = GET_RGB(wHue + 80);
3650 wGreen = GET_RGB(wHue);
3651 wBlue = GET_RGB(wHue - 80);
3652
3653 return RGB(wRed, wGreen, wBlue);
3654 }
3655
3656 wRed = wLuminosity * 255 / 240;
3657 return RGB(wRed, wRed, wRed);
3658 }
3659
3660 /*************************************************************************
3661 * @ [SHLWAPI.413]
3662 *
3663 * Get the current docking status of the system.
3664 *
3665 * PARAMS
3666 * dwFlags [I] DOCKINFO_ flags from "winbase.h", unused
3667 *
3668 * RETURNS
3669 * One of DOCKINFO_UNDOCKED, DOCKINFO_UNDOCKED, or 0 if the system is not
3670 * a notebook.
3671 */
3672 DWORD WINAPI SHGetMachineInfo(DWORD dwFlags)
3673 {
3674 HW_PROFILE_INFOA hwInfo;
3675
3676 TRACE("(0x%08x)\n", dwFlags);
3677
3678 GetCurrentHwProfileA(&hwInfo);
3679 switch (hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED))
3680 {
3681 case DOCKINFO_DOCKED:
3682 case DOCKINFO_UNDOCKED:
3683 return hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED);
3684 default:
3685 return 0;
3686 }
3687 }
3688
3689 /*************************************************************************
3690 * @ [SHLWAPI.418]
3691 *
3692 * Function seems to do FreeLibrary plus other things.
3693 *
3694 * FIXME native shows the following calls:
3695 * RtlEnterCriticalSection
3696 * LocalFree
3697 * GetProcAddress(Comctl32??, 150L)
3698 * DPA_DeletePtr
3699 * RtlLeaveCriticalSection
3700 * followed by the FreeLibrary.
3701 * The above code may be related to .377 above.
3702 */
3703 BOOL WINAPI MLFreeLibrary(HMODULE hModule)
3704 {
3705 FIXME("(%p) semi-stub\n", hModule);
3706 return FreeLibrary(hModule);
3707 }
3708
3709 /*************************************************************************
3710 * @ [SHLWAPI.419]
3711 */
3712 BOOL WINAPI SHFlushSFCacheWrap(void) {
3713 FIXME(": stub\n");
3714 return TRUE;
3715 }
3716
3717 /*************************************************************************
3718 * @ [SHLWAPI.429]
3719 * FIXME I have no idea what this function does or what its arguments are.
3720 */
3721 BOOL WINAPI MLIsMLHInstance(HINSTANCE hInst)
3722 {
3723 FIXME("(%p) stub\n", hInst);
3724 return FALSE;
3725 }
3726
3727
3728 /*************************************************************************
3729 * @ [SHLWAPI.430]
3730 */
3731 DWORD WINAPI MLSetMLHInstance(HINSTANCE hInst, HANDLE hHeap)
3732 {
3733 FIXME("(%p,%p) stub\n", hInst, hHeap);
3734 return E_FAIL; /* This is what is used if shlwapi not loaded */
3735 }
3736
3737 /*************************************************************************
3738 * @ [SHLWAPI.431]
3739 */
3740 DWORD WINAPI MLClearMLHInstance(DWORD x)
3741 {
3742 FIXME("(0x%08x)stub\n", x);
3743 return 0xabba1247;
3744 }
3745
3746 /*************************************************************************
3747 * @ [SHLWAPI.432]
3748 *
3749 * See SHSendMessageBroadcastW
3750 *
3751 */
3752 DWORD WINAPI