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