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