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,
1254 (LPVOID *)&lpUnknown1)))
1255 return FALSE;
1256
1257 if (FAILED(IUnknown_QueryInterface(lpInt2, &IID_IUnknown,
1258 (LPVOID *)&lpUnknown2)))
1259 return FALSE;
1260
1261 if (lpUnknown1 == lpUnknown2)
1262 return TRUE;
1263
1264 return FALSE;
1265 }
1266
1267 /*************************************************************************
1268 * @ [SHLWAPI.172]
1269 *
1270 * Get the window handle of an object.
1271 *
1272 * PARAMS
1273 * lpUnknown [I] Object to get the window handle of
1274 * lphWnd [O] Destination for window handle
1275 *
1276 * RETURNS
1277 * Success: S_OK. lphWnd contains the objects window handle.
1278 * Failure: An HRESULT error code.
1279 *
1280 * NOTES
1281 * lpUnknown is expected to support one of the following interfaces:
1282 * IOleWindow(), IInternetSecurityMgrSite(), or IShellView().
1283 */
1284 HRESULT WINAPI IUnknown_GetWindow(IUnknown *lpUnknown, HWND *lphWnd)
1285 {
1286 IUnknown *lpOle;
1287 HRESULT hRet = E_FAIL;
1288
1289 TRACE("(%p,%p)\n", lpUnknown, lphWnd);
1290
1291 if (!lpUnknown)
1292 return hRet;
1293
1294 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleWindow, (void**)&lpOle);
1295
1296 if (FAILED(hRet))
1297 {
1298 hRet = IUnknown_QueryInterface(lpUnknown,&IID_IShellView, (void**)&lpOle);
1299
1300 if (FAILED(hRet))
1301 {
1302 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInternetSecurityMgrSite,
1303 (void**)&lpOle);
1304 }
1305 }
1306
1307 if (SUCCEEDED(hRet))
1308 {
1309 /* Lazyness here - Since GetWindow() is the first method for the above 3
1310 * interfaces, we use the same call for them all.
1311 */
1312 hRet = IOleWindow_GetWindow((IOleWindow*)lpOle, lphWnd);
1313 IUnknown_Release(lpOle);
1314 if (lphWnd)
1315 TRACE("Returning HWND=%p\n", *lphWnd);
1316 }
1317
1318 return hRet;
1319 }
1320
1321 /*************************************************************************
1322 * @ [SHLWAPI.173]
1323 *
1324 * Call a method on as as yet unidentified object.
1325 *
1326 * PARAMS
1327 * pUnk [I] Object supporting the unidentified interface,
1328 * arg [I] Argument for the call on the object.
1329 *
1330 * RETURNS
1331 * S_OK.
1332 */
1333 HRESULT WINAPI IUnknown_SetOwner(IUnknown *pUnk, ULONG arg)
1334 {
1335 static const GUID guid_173 = {
1336 0x5836fb00, 0x8187, 0x11cf, { 0xa1,0x2b,0x00,0xaa,0x00,0x4a,0xe8,0x37 }
1337 };
1338 IMalloc *pUnk2;
1339
1340 TRACE("(%p,%d)\n", pUnk, arg);
1341
1342 /* Note: arg may not be a ULONG and pUnk2 is for sure not an IMalloc -
1343 * We use this interface as its vtable entry is compatible with the
1344 * object in question.
1345 * FIXME: Find out what this object is and where it should be defined.
1346 */
1347 if (pUnk &&
1348 SUCCEEDED(IUnknown_QueryInterface(pUnk, &guid_173, (void**)&pUnk2)))
1349 {
1350 IMalloc_Alloc(pUnk2, arg); /* Faked call!! */
1351 IMalloc_Release(pUnk2);
1352 }
1353 return S_OK;
1354 }
1355
1356 /*************************************************************************
1357 * @ [SHLWAPI.174]
1358 *
1359 * Call either IObjectWithSite_SetSite() or IInternetSecurityManager_SetSecuritySite() on
1360 * an object.
1361 *
1362 */
1363 HRESULT WINAPI IUnknown_SetSite(
1364 IUnknown *obj, /* [in] OLE object */
1365 IUnknown *site) /* [in] Site interface */
1366 {
1367 HRESULT hr;
1368 IObjectWithSite *iobjwithsite;
1369 IInternetSecurityManager *isecmgr;
1370
1371 if (!obj) return E_FAIL;
1372
1373 hr = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (LPVOID *)&iobjwithsite);
1374 TRACE("IID_IObjectWithSite QI ret=%08x, %p\n", hr, iobjwithsite);
1375 if (SUCCEEDED(hr))
1376 {
1377 hr = IObjectWithSite_SetSite(iobjwithsite, site);
1378 TRACE("done IObjectWithSite_SetSite ret=%08x\n", hr);
1379 IUnknown_Release(iobjwithsite);
1380 }
1381 else
1382 {
1383 hr = IUnknown_QueryInterface(obj, &IID_IInternetSecurityManager, (LPVOID *)&isecmgr);
1384 TRACE("IID_IInternetSecurityManager QI ret=%08x, %p\n", hr, isecmgr);
1385 if (FAILED(hr)) return hr;
1386
1387 hr = IInternetSecurityManager_SetSecuritySite(isecmgr, (IInternetSecurityMgrSite *)site);
1388 TRACE("done IInternetSecurityManager_SetSecuritySite ret=%08x\n", hr);
1389 IUnknown_Release(isecmgr);
1390 }
1391 return hr;
1392 }
1393
1394 /*************************************************************************
1395 * @ [SHLWAPI.175]
1396 *
1397 * Call IPersist_GetClassID() on an object.
1398 *
1399 * PARAMS
1400 * lpUnknown [I] Object supporting the IPersist interface
1401 * lpClassId [O] Destination for Class Id
1402 *
1403 * RETURNS
1404 * Success: S_OK. lpClassId contains the Class Id requested.
1405 * Failure: E_FAIL, If lpUnknown is NULL,
1406 * E_NOINTERFACE If lpUnknown does not support IPersist,
1407 * Or an HRESULT error code.
1408 */
1409 HRESULT WINAPI IUnknown_GetClassID(IUnknown *lpUnknown, CLSID* lpClassId)
1410 {
1411 IPersist* lpPersist;
1412 HRESULT hRet = E_FAIL;
1413
1414 TRACE("(%p,%p)\n", lpUnknown, debugstr_guid(lpClassId));
1415
1416 if (lpUnknown)
1417 {
1418 hRet = IUnknown_QueryInterface(lpUnknown,&IID_IPersist,(void**)&lpPersist);
1419 if (SUCCEEDED(hRet))
1420 {
1421 IPersist_GetClassID(lpPersist, lpClassId);
1422 IPersist_Release(lpPersist);
1423 }
1424 }
1425 return hRet;
1426 }
1427
1428 /*************************************************************************
1429 * @ [SHLWAPI.176]
1430 *
1431 * Retrieve a Service Interface from an object.
1432 *
1433 * PARAMS
1434 * lpUnknown [I] Object to get an IServiceProvider interface from
1435 * sid [I] Service ID for IServiceProvider_QueryService() call
1436 * riid [I] Function requested for QueryService call
1437 * lppOut [O] Destination for the service interface pointer
1438 *
1439 * RETURNS
1440 * Success: S_OK. lppOut contains an object providing the requested service
1441 * Failure: An HRESULT error code
1442 *
1443 * NOTES
1444 * lpUnknown is expected to support the IServiceProvider interface.
1445 */
1446 HRESULT WINAPI IUnknown_QueryService(IUnknown* lpUnknown, REFGUID sid, REFIID riid,
1447 LPVOID *lppOut)
1448 {
1449 IServiceProvider* pService = NULL;
1450 HRESULT hRet;
1451
1452 if (!lppOut)
1453 return E_FAIL;
1454
1455 *lppOut = NULL;
1456
1457 if (!lpUnknown)
1458 return E_FAIL;
1459
1460 /* Get an IServiceProvider interface from the object */
1461 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IServiceProvider,
1462 (LPVOID*)&pService);
1463
1464 if (hRet == S_OK && pService)
1465 {
1466 TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService);
1467
1468 /* Get a Service interface from the object */
1469 hRet = IServiceProvider_QueryService(pService, sid, riid, lppOut);
1470
1471 TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService, *lppOut);
1472
1473 /* Release the IServiceProvider interface */
1474 IUnknown_Release(pService);
1475 }
1476 return hRet;
1477 }
1478
1479 /*************************************************************************
1480 * @ [SHLWAPI.177]
1481 *
1482 * Loads a popup menu.
1483 *
1484 * PARAMS
1485 * hInst [I] Instance handle
1486 * szName [I] Menu name
1487 *
1488 * RETURNS
1489 * Success: TRUE.
1490 * Failure: FALSE.
1491 */
1492 BOOL WINAPI SHLoadMenuPopup(HINSTANCE hInst, LPCWSTR szName)
1493 {
1494 HMENU hMenu;
1495
1496 if ((hMenu = LoadMenuW(hInst, szName)))
1497 {
1498 if (GetSubMenu(hMenu, 0))
1499 RemoveMenu(hMenu, 0, MF_BYPOSITION);
1500
1501 DestroyMenu(hMenu);
1502 return TRUE;
1503 }
1504 return FALSE;
1505 }
1506
1507 typedef struct _enumWndData
1508 {
1509 UINT uiMsgId;
1510 WPARAM wParam;
1511 LPARAM lParam;
1512 LRESULT (WINAPI *pfnPost)(HWND,UINT,WPARAM,LPARAM);
1513 } enumWndData;
1514
1515 /* Callback for SHLWAPI_178 */
1516 static BOOL CALLBACK SHLWAPI_EnumChildProc(HWND hWnd, LPARAM lParam)
1517 {
1518 enumWndData *data = (enumWndData *)lParam;
1519
1520 TRACE("(%p,%p)\n", hWnd, data);
1521 data->pfnPost(hWnd, data->uiMsgId, data->wParam, data->lParam);
1522 return TRUE;
1523 }
1524
1525 /*************************************************************************
1526 * @ [SHLWAPI.178]
1527 *
1528 * Send or post a message to every child of a window.
1529 *
1530 * PARAMS
1531 * hWnd [I] Window whose children will get the messages
1532 * uiMsgId [I] Message Id
1533 * wParam [I] WPARAM of message
1534 * lParam [I] LPARAM of message
1535 * bSend [I] TRUE = Use SendMessageA(), FALSE = Use PostMessageA()
1536 *
1537 * RETURNS
1538 * Nothing.
1539 *
1540 * NOTES
1541 * The appropriate ASCII or Unicode function is called for the window.
1542 */
1543 void WINAPI SHPropagateMessage(HWND hWnd, UINT uiMsgId, WPARAM wParam, LPARAM lParam, BOOL bSend)
1544 {
1545 enumWndData data;
1546
1547 TRACE("(%p,%u,%ld,%ld,%d)\n", hWnd, uiMsgId, wParam, lParam, bSend);
1548
1549 if(hWnd)
1550 {
1551 data.uiMsgId = uiMsgId;
1552 data.wParam = wParam;
1553 data.lParam = lParam;
1554
1555 if (bSend)
1556 data.pfnPost = IsWindowUnicode(hWnd) ? (void*)SendMessageW : (void*)SendMessageA;
1557 else
1558 data.pfnPost = IsWindowUnicode(hWnd) ? (void*)PostMessageW : (void*)PostMessageA;
1559
1560 EnumChildWindows(hWnd, SHLWAPI_EnumChildProc, (LPARAM)&data);
1561 }
1562 }
1563
1564 /*************************************************************************
1565 * @ [SHLWAPI.180]
1566 *
1567 * Remove all sub-menus from a menu.
1568 *
1569 * PARAMS
1570 * hMenu [I] Menu to remove sub-menus from
1571 *
1572 * RETURNS
1573 * Success: 0. All sub-menus under hMenu are removed
1574 * Failure: -1, if any parameter is invalid
1575 */
1576 DWORD WINAPI SHRemoveAllSubMenus(HMENU hMenu)
1577 {
1578 int iItemCount = GetMenuItemCount(hMenu) - 1;
1579 while (iItemCount >= 0)
1580 {
1581 HMENU hSubMenu = GetSubMenu(hMenu, iItemCount);
1582 if (hSubMenu)
1583 RemoveMenu(hMenu, iItemCount, MF_BYPOSITION);
1584 iItemCount--;
1585 }
1586 return iItemCount;
1587 }
1588
1589 /*************************************************************************
1590 * @ [SHLWAPI.181]
1591 *
1592 * Enable or disable a menu item.
1593 *
1594 * PARAMS
1595 * hMenu [I] Menu holding menu item
1596 * uID [I] ID of menu item to enable/disable
1597 * bEnable [I] Whether to enable (TRUE) or disable (FALSE) the item.
1598 *
1599 * RETURNS
1600 * The return code from EnableMenuItem.
1601 */
1602 UINT WINAPI SHEnableMenuItem(HMENU hMenu, UINT wItemID, BOOL bEnable)
1603 {
1604 return EnableMenuItem(hMenu, wItemID, bEnable ? MF_ENABLED : MF_GRAYED);
1605 }
1606
1607 /*************************************************************************
1608 * @ [SHLWAPI.182]
1609 *
1610 * Check or uncheck a menu item.
1611 *
1612 * PARAMS
1613 * hMenu [I] Menu holding menu item
1614 * uID [I] ID of menu item to check/uncheck
1615 * bCheck [I] Whether to check (TRUE) or uncheck (FALSE) the item.
1616 *
1617 * RETURNS
1618 * The return code from CheckMenuItem.
1619 */
1620 DWORD WINAPI SHCheckMenuItem(HMENU hMenu, UINT uID, BOOL bCheck)
1621 {
1622 return CheckMenuItem(hMenu, uID, bCheck ? MF_CHECKED : MF_UNCHECKED);
1623 }
1624
1625 /*************************************************************************
1626 * @ [SHLWAPI.183]
1627 *
1628 * Register a window class if it isn't already.
1629 *
1630 * PARAMS
1631 * lpWndClass [I] Window class to register
1632 *
1633 * RETURNS
1634 * The result of the RegisterClassA call.
1635 */
1636 DWORD WINAPI SHRegisterClassA(WNDCLASSA *wndclass)
1637 {
1638 WNDCLASSA wca;
1639 if (GetClassInfoA(wndclass->hInstance, wndclass->lpszClassName, &wca))
1640 return TRUE;
1641 return (DWORD)RegisterClassA(wndclass);
1642 }
1643
1644 /*************************************************************************
1645 * @ [SHLWAPI.186]
1646 */
1647 BOOL WINAPI SHSimulateDrop(IDropTarget *pDrop, IDataObject *pDataObj,
1648 DWORD grfKeyState, PPOINTL lpPt, DWORD* pdwEffect)
1649 {
1650 DWORD dwEffect = DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY;
1651 POINTL pt = { 0, 0 };
1652
1653 if (!lpPt)
1654 lpPt = &pt;
1655
1656 if (!pdwEffect)
1657 pdwEffect = &dwEffect;
1658
1659 IDropTarget_DragEnter(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1660
1661 if (*pdwEffect)
1662 return IDropTarget_Drop(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1663
1664 IDropTarget_DragLeave(pDrop);
1665 return TRUE;
1666 }
1667
1668 /*************************************************************************
1669 * @ [SHLWAPI.187]
1670 *
1671 * Call IPersistPropertyBag_Load() on an object.
1672 *
1673 * PARAMS
1674 * lpUnknown [I] Object supporting the IPersistPropertyBag interface
1675 * lpPropBag [O] Destination for loaded IPropertyBag
1676 *
1677 * RETURNS
1678 * Success: S_OK.
1679 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1680 */
1681 DWORD WINAPI SHLoadFromPropertyBag(IUnknown *lpUnknown, IPropertyBag* lpPropBag)
1682 {
1683 IPersistPropertyBag* lpPPBag;
1684 HRESULT hRet = E_FAIL;
1685
1686 TRACE("(%p,%p)\n", lpUnknown, lpPropBag);
1687
1688 if (lpUnknown)
1689 {
1690 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IPersistPropertyBag,
1691 (void**)&lpPPBag);
1692 if (SUCCEEDED(hRet) && lpPPBag)
1693 {
1694 hRet = IPersistPropertyBag_Load(lpPPBag, lpPropBag, NULL);
1695 IPersistPropertyBag_Release(lpPPBag);
1696 }
1697 }
1698 return hRet;
1699 }
1700
1701 /*************************************************************************
1702 * @ [SHLWAPI.188]
1703 *
1704 * Call IOleControlSite_TranslateAccelerator() on an object.
1705 *
1706 * PARAMS
1707 * lpUnknown [I] Object supporting the IOleControlSite interface.
1708 * lpMsg [I] Key message to be processed.
1709 * dwModifiers [I] Flags containing the state of the modifier keys.
1710 *
1711 * RETURNS
1712 * Success: S_OK.
1713 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
1714 */
1715 HRESULT WINAPI IUnknown_TranslateAcceleratorOCS(IUnknown *lpUnknown, LPMSG lpMsg, DWORD dwModifiers)
1716 {
1717 IOleControlSite* lpCSite = NULL;
1718 HRESULT hRet = E_INVALIDARG;
1719
1720 TRACE("(%p,%p,0x%08x)\n", lpUnknown, lpMsg, dwModifiers);
1721 if (lpUnknown)
1722 {
1723 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1724 (void**)&lpCSite);
1725 if (SUCCEEDED(hRet) && lpCSite)
1726 {
1727 hRet = IOleControlSite_TranslateAccelerator(lpCSite, lpMsg, dwModifiers);
1728 IOleControlSite_Release(lpCSite);
1729 }
1730 }
1731 return hRet;
1732 }
1733
1734
1735 /*************************************************************************
1736 * @ [SHLWAPI.189]
1737 *
1738 * Call IOleControlSite_OnFocus() on an object.
1739 *
1740 * PARAMS
1741 * lpUnknown [I] Object supporting the IOleControlSite interface.
1742 * fGotFocus [I] Whether focus was gained (TRUE) or lost (FALSE).
1743 *
1744 * RETURNS
1745 * Success: S_OK.
1746 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1747 */
1748 HRESULT WINAPI IUnknown_OnFocusOCS(IUnknown *lpUnknown, BOOL fGotFocus)
1749 {
1750 IOleControlSite* lpCSite = NULL;
1751 HRESULT hRet = E_FAIL;
1752
1753 TRACE("(%p,%s)\n", lpUnknown, fGotFocus ? "TRUE" : "FALSE");
1754 if (lpUnknown)
1755 {
1756 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1757 (void**)&lpCSite);
1758 if (SUCCEEDED(hRet) && lpCSite)
1759 {
1760 hRet = IOleControlSite_OnFocus(lpCSite, fGotFocus);
1761 IOleControlSite_Release(lpCSite);
1762 }
1763 }
1764 return hRet;
1765 }
1766
1767 /*************************************************************************
1768 * @ [SHLWAPI.190]
1769 */
1770 HRESULT WINAPI IUnknown_HandleIRestrict(LPUNKNOWN lpUnknown, PVOID lpArg1,
1771 PVOID lpArg2, PVOID lpArg3, PVOID lpArg4)
1772 {
1773 /* FIXME: {D12F26B2-D90A-11D0-830D-00AA005B4383} - What object does this represent? */
1774 static const DWORD service_id[] = { 0xd12f26b2, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1775 /* FIXME: {D12F26B1-D90A-11D0-830D-00AA005B4383} - Also Unknown/undocumented */
1776 static const DWORD function_id[] = { 0xd12f26b1, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1777 HRESULT hRet = E_INVALIDARG;
1778 LPUNKNOWN lpUnkInner = NULL; /* FIXME: Real type is unknown */
1779
1780 TRACE("(%p,%p,%p,%p,%p)\n", lpUnknown, lpArg1, lpArg2, lpArg3, lpArg4);
1781
1782 if (lpUnknown && lpArg4)
1783 {
1784 hRet = IUnknown_QueryService(lpUnknown, (REFGUID)service_id,
1785 (REFGUID)function_id, (void**)&lpUnkInner);
1786
1787 if (SUCCEEDED(hRet) && lpUnkInner)
1788 {
1789 /* FIXME: The type of service object requested is unknown, however
1790 * testing shows that its first method is called with 4 parameters.
1791 * Fake this by using IParseDisplayName_ParseDisplayName since the
1792 * signature and position in the vtable matches our unknown object type.
1793 */
1794 hRet = IParseDisplayName_ParseDisplayName((LPPARSEDISPLAYNAME)lpUnkInner,
1795 lpArg1, lpArg2, lpArg3, lpArg4);
1796 IUnknown_Release(lpUnkInner);
1797 }
1798 }
1799 return hRet;
1800 }
1801
1802 /*************************************************************************
1803 * @ [SHLWAPI.192]
1804 *
1805 * Get a sub-menu from a menu item.
1806 *
1807 * PARAMS
1808 * hMenu [I] Menu to get sub-menu from
1809 * uID [I] ID of menu item containing sub-menu
1810 *
1811 * RETURNS
1812 * The sub-menu of the item, or a NULL handle if any parameters are invalid.
1813 */
1814 HMENU WINAPI SHGetMenuFromID(HMENU hMenu, UINT uID)
1815 {
1816 MENUITEMINFOW mi;
1817
1818 TRACE("(%p,%u)\n", hMenu, uID);
1819
1820 mi.cbSize = sizeof(mi);
1821 mi.fMask = MIIM_SUBMENU;
1822
1823 if (!GetMenuItemInfoW(hMenu, uID, FALSE, &mi))
1824 return NULL;
1825
1826 return mi.hSubMenu;
1827 }
1828
1829 /*************************************************************************
1830 * @ [SHLWAPI.193]
1831 *
1832 * Get the color depth of the primary display.
1833 *
1834 * PARAMS
1835 * None.
1836 *
1837 * RETURNS
1838 * The color depth of the primary display.
1839 */
1840 DWORD WINAPI SHGetCurColorRes(void)
1841 {
1842 HDC hdc;
1843 DWORD ret;
1844
1845 TRACE("()\n");
1846
1847 hdc = GetDC(0);
1848 ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
1849 ReleaseDC(0, hdc);
1850 return ret;
1851 }
1852
1853 /*************************************************************************
1854 * @ [SHLWAPI.194]
1855 *
1856 * Wait for a message to arrive, with a timeout.
1857 *
1858 * PARAMS
1859 * hand [I] Handle to query
1860 * dwTimeout [I] Timeout in ticks or INFINITE to never timeout
1861 *
1862 * RETURNS
1863 * STATUS_TIMEOUT if no message is received before dwTimeout ticks passes.
1864 * Otherwise returns the value from MsgWaitForMultipleObjectsEx when a
1865 * message is available.
1866 */
1867 DWORD WINAPI SHWaitForSendMessageThread(HANDLE hand, DWORD dwTimeout)
1868 {
1869 DWORD dwEndTicks = GetTickCount() + dwTimeout;
1870 DWORD dwRet;
1871
1872 while ((dwRet = MsgWaitForMultipleObjectsEx(1, &hand, dwTimeout, QS_SENDMESSAGE, 0)) == 1)
1873 {
1874 MSG msg;
1875
1876 PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
1877
1878 if (dwTimeout != INFINITE)
1879 {
1880 if ((int)(dwTimeout = dwEndTicks - GetTickCount()) <= 0)
1881 return WAIT_TIMEOUT;
1882 }
1883 }
1884
1885 return dwRet;
1886 }
1887
1888 /*************************************************************************
1889 * @ [SHLWAPI.195]
1890 *
1891 * Determine if a shell folder can be expanded.
1892 *
1893 * PARAMS
1894 * lpFolder [I] Parent folder containing the object to test.
1895 * pidl [I] Id of the object to test.
1896 *
1897 * RETURNS
1898 * Success: S_OK, if the object is expandable, S_FALSE otherwise.
1899 * Failure: E_INVALIDARG, if any argument is invalid.
1900 *
1901 * NOTES
1902 * If the object to be tested does not expose the IQueryInfo() interface it
1903 * will not be identified as an expandable folder.
1904 */
1905 HRESULT WINAPI SHIsExpandableFolder(LPSHELLFOLDER lpFolder, LPCITEMIDLIST pidl)
1906 {
1907 HRESULT hRet = E_INVALIDARG;
1908 IQueryInfo *lpInfo;
1909
1910 if (lpFolder && pidl)
1911 {
1912 hRet = IShellFolder_GetUIObjectOf(lpFolder, NULL, 1, &pidl, &IID_IQueryInfo,
1913 NULL, (void**)&lpInfo);
1914 if (FAILED(hRet))
1915 hRet = S_FALSE; /* Doesn't expose IQueryInfo */
1916 else
1917 {
1918 DWORD dwFlags = 0;
1919
1920 /* MSDN states of IQueryInfo_GetInfoFlags() that "This method is not
1921 * currently used". Really? You wouldn't be holding out on me would you?
1922 */
1923 hRet = IQueryInfo_GetInfoFlags(lpInfo, &dwFlags);
1924
1925 if (SUCCEEDED(hRet))
1926 {
1927 /* 0x2 is an undocumented flag apparently indicating expandability */
1928 hRet = dwFlags & 0x2 ? S_OK : S_FALSE;
1929 }
1930
1931 IQueryInfo_Release(lpInfo);
1932 }
1933 }
1934 return hRet;
1935 }
1936
1937 /*************************************************************************
1938 * @ [SHLWAPI.197]
1939 *
1940 * Blank out a region of text by drawing the background only.
1941 *
1942 * PARAMS
1943 * hDC [I] Device context to draw in
1944 * pRect [I] Area to draw in
1945 * cRef [I] Color to draw in
1946 *
1947 * RETURNS
1948 * Nothing.
1949 */
1950 DWORD WINAPI SHFillRectClr(HDC hDC, LPCRECT pRect, COLORREF cRef)
1951 {
1952 COLORREF cOldColor = SetBkColor(hDC, cRef);
1953 ExtTextOutA(hDC, 0, 0, ETO_OPAQUE, pRect, 0, 0, 0);
1954 SetBkColor(hDC, cOldColor);
1955 return 0;
1956 }
1957
1958 /*************************************************************************
1959 * @ [SHLWAPI.198]
1960 *
1961 * Return the value associated with a key in a map.
1962 *
1963 * PARAMS
1964 * lpKeys [I] A list of keys of length iLen
1965 * lpValues [I] A list of values associated with lpKeys, of length iLen
1966 * iLen [I] Length of both lpKeys and lpValues
1967 * iKey [I] The key value to look up in lpKeys
1968 *
1969 * RETURNS
1970 * The value in lpValues associated with iKey, or -1 if iKey is not
1971 * found in lpKeys.
1972 *
1973 * NOTES
1974 * - If two elements in the map share the same key, this function returns
1975 * the value closest to the start of the map
1976 * - The native version of this function crashes if lpKeys or lpValues is NULL.
1977 */
1978 int WINAPI SHSearchMapInt(const int *lpKeys, const int *lpValues, int iLen, int iKey)
1979 {
1980 if (lpKeys && lpValues)
1981 {
1982 int i = 0;
1983
1984 while (i < iLen)
1985 {
1986 if (lpKeys[i] == iKey)
1987 return lpValues[i]; /* Found */
1988 i++;
1989 }
1990 }
1991 return -1; /* Not found */
1992 }
1993
1994
1995 /*************************************************************************
1996 * @ [SHLWAPI.199]
1997 *
1998 * Copy an interface pointer
1999 *
2000 * PARAMS
2001 * lppDest [O] Destination for copy
2002 * lpUnknown [I] Source for copy
2003 *
2004 * RETURNS
2005 * Nothing.
2006 */
2007 VOID WINAPI IUnknown_Set(IUnknown **lppDest, IUnknown *lpUnknown)
2008 {
2009 TRACE("(%p,%p)\n", lppDest, lpUnknown);
2010
2011 if (lppDest)
2012 IUnknown_AtomicRelease(lppDest); /* Release existing interface */
2013
2014 if (lpUnknown)
2015 {
2016 /* Copy */
2017 IUnknown_AddRef(lpUnknown);
2018 *lppDest = lpUnknown;
2019 }
2020 }
2021
2022 /*************************************************************************
2023 * @ [SHLWAPI.200]
2024 *
2025 */
2026 HRESULT WINAPI MayQSForward(IUnknown* lpUnknown, PVOID lpReserved,
2027 REFGUID riidCmdGrp, ULONG cCmds,
2028 OLECMD *prgCmds, OLECMDTEXT* pCmdText)
2029 {
2030 FIXME("(%p,%p,%p,%d,%p,%p) - stub\n",
2031 lpUnknown, lpReserved, riidCmdGrp, cCmds, prgCmds, pCmdText);
2032
2033 /* FIXME: Calls IsQSForward & IUnknown_QueryStatus */
2034 return DRAGDROP_E_NOTREGISTERED;
2035 }
2036
2037 /*************************************************************************
2038 * @ [SHLWAPI.201]
2039 *
2040 */
2041 HRESULT WINAPI MayExecForward(IUnknown* lpUnknown, INT iUnk, REFGUID pguidCmdGroup,
2042 DWORD nCmdID, DWORD nCmdexecopt, VARIANT* pvaIn,
2043 VARIANT* pvaOut)
2044 {
2045 FIXME("(%p,%d,%p,%d,%d,%p,%p) - stub!\n", lpUnknown, iUnk, pguidCmdGroup,
2046 nCmdID, nCmdexecopt, pvaIn, pvaOut);
2047 return DRAGDROP_E_NOTREGISTERED;
2048 }
2049
2050 /*************************************************************************
2051 * @ [SHLWAPI.202]
2052 *
2053 */
2054 HRESULT WINAPI IsQSForward(REFGUID pguidCmdGroup,ULONG cCmds, OLECMD *prgCmds)
2055 {
2056 FIXME("(%p,%d,%p) - stub!\n", pguidCmdGroup, cCmds, prgCmds);
2057 return DRAGDROP_E_NOTREGISTERED;
2058 }
2059
2060 /*************************************************************************
2061 * @ [SHLWAPI.204]
2062 *
2063 * Determine if a window is not a child of another window.
2064 *
2065 * PARAMS
2066 * hParent [I] Suspected parent window
2067 * hChild [I] Suspected child window
2068 *
2069 * RETURNS
2070 * TRUE: If hChild is a child window of hParent
2071 * FALSE: If hChild is not a child window of hParent, or they are equal
2072 */
2073 BOOL WINAPI SHIsChildOrSelf(HWND hParent, HWND hChild)
2074 {
2075 TRACE("(%p,%p)\n", hParent, hChild);
2076
2077 if (!hParent || !hChild)
2078 return TRUE;
2079 else if(hParent == hChild)
2080 return FALSE;
2081 return !IsChild(hParent, hChild);
2082 }
2083
2084 /*************************************************************************
2085 * FDSA functions. Manage a dynamic array of fixed size memory blocks.
2086 */
2087
2088 typedef struct
2089 {
2090 DWORD num_items; /* Number of elements inserted */
2091 void *mem; /* Ptr to array */
2092 DWORD blocks_alloced; /* Number of elements allocated */
2093 BYTE inc; /* Number of elements to grow by when we need to expand */
2094 BYTE block_size; /* Size in bytes of an element */
2095 BYTE flags; /* Flags */
2096 } FDSA_info;
2097
2098 #define FDSA_FLAG_INTERNAL_ALLOC 0x01 /* When set we have allocated mem internally */
2099
2100 /*************************************************************************
2101 * @ [SHLWAPI.208]
2102 *
2103 * Initialize an FDSA array.
2104 */
2105 BOOL WINAPI FDSA_Initialize(DWORD block_size, DWORD inc, FDSA_info *info, void *mem,
2106 DWORD init_blocks)
2107 {
2108 TRACE("(0x%08x 0x%08x %p %p 0x%08x)\n", block_size, inc, info, mem, init_blocks);
2109
2110 if(inc == 0)
2111 inc = 1;
2112
2113 if(mem)
2114 memset(mem, 0, block_size * init_blocks);
2115
2116 info->num_items = 0;
2117 info->inc = inc;
2118 info->mem = mem;
2119 info->blocks_alloced = init_blocks;
2120 info->block_size = block_size;
2121 info->flags = 0;
2122
2123 return TRUE;
2124 }
2125
2126 /*************************************************************************
2127 * @ [SHLWAPI.209]
2128 *
2129 * Destroy an FDSA array
2130 */
2131 BOOL WINAPI FDSA_Destroy(FDSA_info *info)
2132 {
2133 TRACE("(%p)\n", info);
2134
2135 if(info->flags & FDSA_FLAG_INTERNAL_ALLOC)
2136 {
2137 HeapFree(GetProcessHeap(), 0, info->mem);
2138 return FALSE;
2139 }
2140
2141 return TRUE;
2142 }
2143
2144 /*************************************************************************
2145 * @ [SHLWAPI.210]
2146 *
2147 * Insert element into an FDSA array
2148 */
2149 DWORD WINAPI FDSA_InsertItem(FDSA_info *info, DWORD where, const void *block)
2150 {
2151 TRACE("(%p 0x%08x %p)\n", info, where, block);
2152 if(where > info->num_items)
2153 where = info->num_items;
2154
2155 if(info->num_items >= info->blocks_alloced)
2156 {
2157 DWORD size = (info->blocks_alloced + info->inc) * info->block_size;
2158 if(info->flags & 0x1)
2159 info->mem = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->mem, size);
2160 else
2161 {
2162 void *old_mem = info->mem;
2163 info->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2164 memcpy(info->mem, old_mem, info->blocks_alloced * info->block_size);
2165 }
2166 info->blocks_alloced += info->inc;
2167 info->flags |= 0x1;
2168 }
2169
2170 if(where < info->num_items)
2171 {
2172 memmove((char*)info->mem + (where + 1) * info->block_size,
2173 (char*)info->mem + where * info->block_size,
2174 (info->num_items - where) * info->block_size);
2175 }
2176 memcpy((char*)info->mem + where * info->block_size, block, info->block_size);
2177
2178 info->num_items++;
2179 return where;
2180 }
2181
2182 /*************************************************************************
2183 * @ [SHLWAPI.211]
2184 *
2185 * Delete an element from an FDSA array.
2186 */
2187 BOOL WINAPI FDSA_DeleteItem(FDSA_info *info, DWORD where)
2188 {
2189 TRACE("(%p 0x%08x)\n", info, where);
2190
2191 if(where >= info->num_items)
2192 return FALSE;
2193
2194 if(where < info->num_items - 1)
2195 {
2196 memmove((char*)info->mem + where * info->block_size,
2197 (char*)info->mem + (where + 1) * info->block_size,
2198 (info->num_items - where - 1) * info->block_size);
2199 }
2200 memset((char*)info->mem + (info->num_items - 1) * info->block_size,
2201 0, info->block_size);
2202 info->num_items--;
2203 return TRUE;
2204 }
2205
2206
2207 typedef struct {
2208 REFIID refid;
2209 DWORD indx;
2210 } IFACE_INDEX_TBL;
2211
2212 /*************************************************************************
2213 * @ [SHLWAPI.219]
2214 *
2215 * Call IUnknown_QueryInterface() on a table of objects.
2216 *
2217 * RETURNS
2218 * Success: S_OK.
2219 * Failure: E_POINTER or E_NOINTERFACE.
2220 */
2221 HRESULT WINAPI QISearch(
2222 LPVOID w, /* [in] Table of interfaces */
2223 IFACE_INDEX_TBL *x, /* [in] Array of REFIIDs and indexes into the table */
2224 REFIID riid, /* [in] REFIID to get interface for */
2225 LPVOID *ppv) /* [out] Destination for interface pointer */
2226 {
2227 HRESULT ret;
2228 IUnknown *a_vtbl;
2229 IFACE_INDEX_TBL *xmove;
2230
2231 TRACE("(%p %p %s %p)\n", w,x,debugstr_guid(riid),ppv);
2232 if (ppv) {
2233 xmove = x;
2234 while (xmove->refid) {
2235 TRACE("trying (indx %d) %s\n", xmove->indx, debugstr_guid(xmove->refid));
2236 if (IsEqualIID(riid, xmove->refid)) {
2237 a_vtbl = (IUnknown*)(xmove->indx + (LPBYTE)w);
2238 TRACE("matched, returning (%p)\n", a_vtbl);
2239 *ppv = (LPVOID)a_vtbl;
2240 IUnknown_AddRef(a_vtbl);
2241 return S_OK;
2242 }
2243 xmove++;
2244 }
2245
2246 if (IsEqualIID(riid, &IID_IUnknown)) {
2247 a_vtbl = (IUnknown*)(x->indx + (LPBYTE)w);
2248 TRACE("returning first for IUnknown (%p)\n", a_vtbl);
2249 *ppv = (LPVOID)a_vtbl;
2250 IUnknown_AddRef(a_vtbl);
2251 return S_OK;
2252 }
2253 *ppv = 0;
2254 ret = E_NOINTERFACE;
2255 } else
2256 ret = E_POINTER;
2257
2258 TRACE("-- 0x%08x\n", ret);
2259 return ret;
2260 }
2261
2262 /*************************************************************************
2263 * @ [SHLWAPI.220]
2264 *
2265 * Set the Font for a window and the "PropDlgFont" property of the parent window.
2266 *
2267 * PARAMS
2268 * hWnd [I] Parent Window to set the property
2269 * id [I] Index of child Window to set the Font
2270 *
2271 * RETURNS
2272 * Success: S_OK
2273 *
2274 */
2275 HRESULT WINAPI SHSetDefaultDialogFont(HWND hWnd, INT id)
2276 {
2277 FIXME("(%p, %d) stub\n", hWnd, id);
2278 return S_OK;
2279 }
2280
2281 /*************************************************************************
2282 * @ [SHLWAPI.221]
2283 *
2284 * Remove the "PropDlgFont" property from a window.
2285 *
2286 * PARAMS
2287 * hWnd [I] Window to remove the property from
2288 *
2289 * RETURNS
2290 * A handle to the removed property, or NULL if it did not exist.
2291 */
2292 HANDLE WINAPI SHRemoveDefaultDialogFont(HWND hWnd)
2293 {
2294 HANDLE hProp;
2295
2296 TRACE("(%p)\n", hWnd);
2297
2298 hProp = GetPropA(hWnd, "PropDlgFont");
2299
2300 if(hProp)
2301 {
2302 DeleteObject(hProp);
2303 hProp = RemovePropA(hWnd, "PropDlgFont");
2304 }
2305 return hProp;
2306 }
2307
2308 /*************************************************************************
2309 * @ [SHLWAPI.236]
2310 *
2311 * Load the in-process server of a given GUID.
2312 *
2313 * PARAMS
2314 * refiid [I] GUID of the server to load.
2315 *
2316 * RETURNS
2317 * Success: A handle to the loaded server dll.
2318 * Failure: A NULL handle.
2319 */
2320 HMODULE WINAPI SHPinDllOfCLSID(REFIID refiid)
2321 {
2322 HKEY newkey;
2323 DWORD type, count;
2324 CHAR value[MAX_PATH], string[MAX_PATH];
2325
2326 strcpy(string, "CLSID\\");
2327 SHStringFromGUIDA(refiid, string + 6, sizeof(string)/sizeof(char) - 6);
2328 strcat(string, "\\InProcServer32");
2329
2330 count = MAX_PATH;
2331 RegOpenKeyExA(HKEY_CLASSES_ROOT, string, 0, 1, &newkey);
2332 RegQueryValueExA(newkey, 0, 0, &type, (PBYTE)value, &count);
2333 RegCloseKey(newkey);
2334 return LoadLibraryExA(value, 0, 0);
2335 }
2336
2337 /*************************************************************************
2338 * @ [SHLWAPI.237]
2339 *
2340 * Unicode version of SHLWAPI_183.
2341 */
2342 DWORD WINAPI SHRegisterClassW(WNDCLASSW * lpWndClass)
2343 {
2344 WNDCLASSW WndClass;
2345
2346 TRACE("(%p %s)\n",lpWndClass->hInstance, debugstr_w(lpWndClass->lpszClassName));
2347
2348 if (GetClassInfoW(lpWndClass->hInstance, lpWndClass->lpszClassName, &WndClass))
2349 return TRUE;
2350 return RegisterClassW(lpWndClass);
2351 }
2352
2353 /*************************************************************************
2354 * @ [SHLWAPI.238]
2355 *
2356 * Unregister a list of classes.
2357 *
2358 * PARAMS
2359 * hInst [I] Application instance that registered the classes
2360 * lppClasses [I] List of class names
2361 * iCount [I] Number of names in lppClasses
2362 *
2363 * RETURNS
2364 * Nothing.
2365 */
2366 void WINAPI SHUnregisterClassesA(HINSTANCE hInst, LPCSTR *lppClasses, INT iCount)
2367 {
2368 WNDCLASSA WndClass;
2369
2370 TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2371
2372 while (iCount > 0)
2373 {
2374 if (GetClassInfoA(hInst, *lppClasses, &WndClass))
2375 UnregisterClassA(*lppClasses, hInst);
2376 lppClasses++;
2377 iCount--;
2378 }
2379 }
2380
2381 /*************************************************************************
2382 * @ [SHLWAPI.239]
2383 *
2384 * Unicode version of SHUnregisterClassesA.
2385 */
2386 void WINAPI SHUnregisterClassesW(HINSTANCE hInst, LPCWSTR *lppClasses, INT iCount)
2387 {
2388 WNDCLASSW WndClass;
2389
2390 TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2391
2392 while (iCount > 0)
2393 {
2394 if (GetClassInfoW(hInst, *lppClasses, &WndClass))
2395 UnregisterClassW(*lppClasses, hInst);
2396 lppClasses++;
2397 iCount--;
2398 }
2399 }
2400
2401 /*************************************************************************
2402 * @ [SHLWAPI.240]
2403 *
2404 * Call The correct (Ascii/Unicode) default window procedure for a window.
2405 *
2406 * PARAMS
2407 * hWnd [I] Window to call the default procedure for
2408 * uMessage [I] Message ID
2409 * wParam [I] WPARAM of message
2410 * lParam [I] LPARAM of message
2411 *
2412 * RETURNS
2413 * The result of calling DefWindowProcA() or DefWindowProcW().
2414 */
2415 LRESULT CALLBACK SHDefWindowProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
2416 {
2417 if (IsWindowUnicode(hWnd))
2418 return DefWindowProcW(hWnd, uMessage, wParam, lParam);
2419 return DefWindowProcA(hWnd, uMessage, wParam, lParam);
2420 }
2421
2422 /*************************************************************************
2423 * @ [SHLWAPI.256]
2424 */
2425 HRESULT WINAPI IUnknown_GetSite(LPUNKNOWN lpUnknown, REFIID iid, PVOID *lppSite)
2426 {
2427 HRESULT hRet = E_INVALIDARG;
2428 LPOBJECTWITHSITE lpSite = NULL;
2429
2430 TRACE("(%p,%s,%p)\n", lpUnknown, debugstr_guid(iid), lppSite);
2431
2432 if (lpUnknown && iid && lppSite)
2433 {
2434 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IObjectWithSite,
2435 (void**)&lpSite);
2436 if (SUCCEEDED(hRet) && lpSite)
2437 {
2438 hRet = IObjectWithSite_GetSite(lpSite, iid, lppSite);
2439 IObjectWithSite_Release(lpSite);
2440 }
2441 }
2442 return hRet;
2443 }
2444
2445 /*************************************************************************
2446 * @ [SHLWAPI.257]
2447 *
2448 * Create a worker window using CreateWindowExA().
2449 *
2450 * PARAMS
2451 * wndProc [I] Window procedure
2452 * hWndParent [I] Parent window
2453 * dwExStyle [I] Extra style flags
2454 * dwStyle [I] Style flags
2455 * hMenu [I] Window menu
2456 * z [I] Unknown
2457 *
2458 * RETURNS
2459 * Success: The window handle of the newly created window.
2460 * Failure: 0.
2461 */
2462 HWND WINAPI SHCreateWorkerWindowA(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2463 DWORD dwStyle, HMENU hMenu, LONG z)
2464 {
2465 static const char szClass[] = "WorkerA";
2466 WNDCLASSA wc;
2467 HWND hWnd;
2468
2469 TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2470 wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2471
2472 /* Create Window class */
2473 wc.style = 0;
2474 wc.lpfnWndProc = DefWindowProcA;
2475 wc.cbClsExtra = 0;
2476 wc.cbWndExtra = 4;
2477 wc.hInstance = shlwapi_hInstance;
2478 wc.hIcon = NULL;
2479 wc.hCursor = LoadCursorA(NULL, (LPSTR)IDC_ARROW);
2480 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2481 wc.lpszMenuName = NULL;
2482 wc.lpszClassName = szClass;
2483
2484 SHRegisterClassA(&wc); /* Register class */
2485
2486 /* FIXME: Set extra bits in dwExStyle */
2487
2488 hWnd = CreateWindowExA(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2489 hWndParent, hMenu, shlwapi_hInstance, 0);
2490 if (hWnd)
2491 {
2492 SetWindowLongPtrW(hWnd, DWLP_MSGRESULT, z);
2493
2494 if (wndProc)
2495 SetWindowLongPtrA(hWnd, GWLP_WNDPROC, wndProc);
2496 }
2497 return hWnd;
2498 }
2499
2500 typedef struct tagPOLICYDATA
2501 {
2502 DWORD policy; /* flags value passed to SHRestricted */
2503 LPCWSTR appstr; /* application str such as "Explorer" */
2504 LPCWSTR keystr; /* name of the actual registry key / policy */
2505 } POLICYDATA, *LPPOLICYDATA;
2506
2507 #define SHELL_NO_POLICY 0xffffffff
2508
2509 /* default shell policy registry key */
2510 static const WCHAR strRegistryPolicyW[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o',
2511 's','o','f','t','\\','W','i','n','d','o','w','s','\\',
2512 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',
2513 '\\','P','o','l','i','c','i','e','s',0};
2514
2515 /*************************************************************************
2516 * @ [SHLWAPI.271]
2517 *
2518 * Retrieve a policy value from the registry.
2519 *
2520 * PARAMS
2521 * lpSubKey [I] registry key name
2522 * lpSubName [I] subname of registry key
2523 * lpValue [I] value name of registry value
2524 *
2525 * RETURNS
2526 * the value associated with the registry key or 0 if not found
2527 */
2528 DWORD WINAPI SHGetRestriction(LPCWSTR lpSubKey, LPCWSTR lpSubName, LPCWSTR lpValue)
2529 {
2530 DWORD retval, datsize = sizeof(retval);
2531 HKEY hKey;
2532
2533 if (!lpSubKey)
2534 lpSubKey = strRegistryPolicyW;
2535
2536 retval = RegOpenKeyW(HKEY_LOCAL_MACHINE, lpSubKey, &hKey);
2537 if (retval != ERROR_SUCCESS)
2538 retval = RegOpenKeyW(HKEY_CURRENT_USER, lpSubKey, &hKey);
2539 if (retval != ERROR_SUCCESS)
2540 return 0;
2541
2542 SHGetValueW(hKey, lpSubName, lpValue, NULL, (LPBYTE)&retval, &datsize);
2543 RegCloseKey(hKey);
2544 return retval;
2545 }
2546
2547 /*************************************************************************
2548 * @ [SHLWAPI.266]
2549 *
2550 * Helper function to retrieve the possibly cached value for a specific policy
2551 *
2552 * PARAMS
2553 * policy [I] The policy to look for
2554 * initial [I] Main registry key to open, if NULL use default
2555 * polTable [I] Table of known policies, 0 terminated
2556 * polArr [I] Cache array of policy values
2557 *
2558 * RETURNS
2559 * The retrieved policy value or 0 if not successful
2560 *
2561 * NOTES
2562 * This function is used by the native SHRestricted function to search for the
2563 * policy and cache it once retrieved. The current Wine implementation uses a
2564 * different POLICYDATA structure and implements a similar algorithm adapted to
2565 * that structure.
2566 */
2567 DWORD WINAPI SHRestrictionLookup(
2568 DWORD policy,
2569 LPCWSTR initial,
2570 LPPOLICYDATA polTable,
2571 LPDWORD polArr)
2572 {
2573 TRACE("(0x%08x %s %p %p)\n", policy, debugstr_w(initial), polTable, polArr);
2574
2575 if (!polTable || !polArr)
2576 return 0;
2577
2578 for (;polTable->policy; polTable++, polArr++)
2579 {
2580 if (policy == polTable->policy)
2581 {
2582 /* we have a known policy */
2583
2584 /* check if this policy has been cached */
2585 if (*polArr == SHELL_NO_POLICY)
2586 *polArr = SHGetRestriction(initial, polTable->appstr, polTable->keystr);
2587 return *polArr;
2588 }
2589 }
2590 /* we don't know this policy, return 0 */
2591 TRACE("unknown policy: (%08x)\n", policy);
2592 return 0;
2593 }
2594
2595 /*************************************************************************
2596 * @ [SHLWAPI.267]
2597 *
2598 * Get an interface from an object.
2599 *
2600 * RETURNS
2601 * Success: S_OK. ppv contains the requested interface.
2602 * Failure: An HRESULT error code.
2603 *
2604 * NOTES
2605 * This QueryInterface asks the inner object for an interface. In case
2606 * of aggregation this request would be forwarded by the inner to the
2607 * outer object. This function asks the inner object directly for the
2608 * interface circumventing the forwarding to the outer object.
2609 */
2610 HRESULT WINAPI SHWeakQueryInterface(
2611 IUnknown * pUnk, /* [in] Outer object */
2612 IUnknown * pInner, /* [in] Inner object */
2613 IID * riid, /* [in] Interface GUID to query for */
2614 LPVOID* ppv) /* [out] Destination for queried interface */
2615 {
2616 HRESULT hret = E_NOINTERFACE;
2617 TRACE("(pUnk=%p pInner=%p\n\tIID: %s %p)\n",pUnk,pInner,debugstr_guid(riid), ppv);
2618
2619 *ppv = NULL;
2620 if(pUnk && pInner) {
2621 hret = IUnknown_QueryInterface(pInner, riid, (LPVOID*)ppv);
2622 if (SUCCEEDED(hret)) IUnknown_Release(pUnk);
2623 }
2624 TRACE("-- 0x%08x\n", hret);
2625 return hret;
2626 }
2627
2628 /*************************************************************************
2629 * @ [SHLWAPI.268]
2630 *
2631 * Move a reference from one interface to another.
2632 *
2633 * PARAMS
2634 * lpDest [O] Destination to receive the reference
2635 * lppUnknown [O] Source to give up the reference to lpDest
2636 *
2637 * RETURNS
2638 * Nothing.
2639 */
2640 VOID WINAPI SHWeakReleaseInterface(IUnknown *lpDest, IUnknown **lppUnknown)
2641 {
2642 TRACE("(%p,%p)\n", lpDest, lppUnknown);
2643
2644 if (*lppUnknown)
2645 {
2646 /* Copy Reference*/
2647 IUnknown_AddRef(lpDest);
2648 IUnknown_AtomicRelease(lppUnknown); /* Release existing interface */
2649 }
2650 }
2651
2652 /*************************************************************************
2653 * @ [SHLWAPI.269]
2654 *
2655 * Convert an ASCII string of a CLSID into a CLSID.
2656 *
2657 * PARAMS
2658 * idstr [I] String representing a CLSID in registry format
2659 * id [O] Destination for the converted CLSID
2660 *
2661 * RETURNS
2662 * Success: TRUE. id contains the converted CLSID.
2663 * Failure: FALSE.
2664 */
2665 BOOL WINAPI GUIDFromStringA(LPCSTR idstr, CLSID *id)
2666 {
2667 WCHAR wClsid[40];
2668 MultiByteToWideChar(CP_ACP, 0, idstr, -1, wClsid, sizeof(wClsid)/sizeof(WCHAR));
2669 return SUCCEEDED(CLSIDFromString(wClsid, id));
2670 }
2671
2672 /*************************************************************************
2673 * @ [SHLWAPI.270]
2674 *
2675 * Unicode version of GUIDFromStringA.
2676 */
2677 BOOL WINAPI GUIDFromStringW(LPCWSTR idstr, CLSID *id)
2678 {
2679 return SUCCEEDED(CLSIDFromString((LPOLESTR)idstr, id));
2680 }
2681
2682 /*************************************************************************
2683 * @ [SHLWAPI.276]
2684 *
2685 * Determine if the browser is integrated into the shell, and set a registry
2686 * key accordingly.
2687 *
2688 * PARAMS
2689 * None.
2690 *
2691 * RETURNS
2692 * 1, If the browser is not integrated.
2693 * 2, If the browser is integrated.
2694 *
2695 * NOTES
2696 * The key "HKLM\Software\Microsoft\Internet Explorer\IntegratedBrowser" is
2697 * either set to TRUE, or removed depending on whether the browser is deemed
2698 * to be integrated.
2699 */
2700 DWORD WINAPI WhichPlatform(void)
2701 {
2702 static const char szIntegratedBrowser[] = "IntegratedBrowser";
2703 static DWORD dwState = 0;
2704 HKEY hKey;
2705 DWORD dwRet, dwData, dwSize;
2706 HMODULE hshell32;
2707
2708 if (dwState)
2709 return dwState;
2710
2711 /* If shell32 exports DllGetVersion(), the browser is integrated */
2712 dwState = 1;
2713 hshell32 = LoadLibraryA("shell32.dll");
2714 if (hshell32)
2715 {
2716 FARPROC pDllGetVersion;
2717 pDllGetVersion = GetProcAddress(hshell32, "DllGetVersion");
2718 dwState = pDllGetVersion ? 2 : 1;
2719 FreeLibrary(hshell32);
2720 }
2721
2722 /* Set or delete the key accordingly */
2723 dwRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2724 "Software\\Microsoft\\Internet Explorer", 0,
2725 KEY_ALL_ACCESS, &hKey);
2726 if (!dwRet)
2727 {
2728 dwRet = RegQueryValueExA(hKey, szIntegratedBrowser, 0, 0,
2729 (LPBYTE)&dwData, &dwSize);
2730
2731 if (!dwRet && dwState == 1)
2732 {
2733 /* Value exists but browser is not integrated */
2734 RegDeleteValueA(hKey, szIntegratedBrowser);
2735 }
2736 else if (dwRet && dwState == 2)
2737 {
2738 /* Browser is integrated but value does not exist */
2739 dwData = TRUE;
2740 RegSetValueExA(hKey, szIntegratedBrowser, 0, REG_DWORD,
2741 (LPBYTE)&dwData, sizeof(dwData));
2742 }
2743 RegCloseKey(hKey);
2744 }
2745 return dwState;
2746 }
2747
2748 /*************************************************************************
2749 * @ [SHLWAPI.278]
2750 *
2751 * Unicode version of SHCreateWorkerWindowA.
2752 */
2753 HWND WINAPI SHCreateWorkerWindowW(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2754 DWORD dwStyle, HMENU hMenu, LONG z)
2755 {
2756 static const WCHAR szClass[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', '\0' };
2757 WNDCLASSW wc;
2758 HWND hWnd;
2759
2760 TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2761 wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2762
2763 /* If our OS is natively ASCII, use the ASCII version */
2764 if (!(GetVersion() & 0x80000000)) /* NT */
2765 return SHCreateWorkerWindowA(wndProc, hWndParent, dwExStyle, dwStyle, hMenu, z);
2766
2767 /* Create Window class */
2768 wc.style = 0;
2769 wc.lpfnWndProc = DefWindowProcW;
2770 wc.cbClsExtra = 0;
2771 wc.cbWndExtra = 4;
2772 wc.hInstance = shlwapi_hInstance;
2773 wc.hIcon = NULL;
2774 wc.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
2775 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2776 wc.lpszMenuName = NULL;
2777 wc.lpszClassName = szClass;
2778
2779 SHRegisterClassW(&wc); /* Register class */
2780
2781 /* FIXME: Set extra bits in dwExStyle */
2782
2783 hWnd = CreateWindowExW(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2784 hWndParent, hMenu, shlwapi_hInstance, 0);
2785 if (hWnd)
2786 {
2787 SetWindowLongPtrW(hWnd, DWLP_MSGRESULT, z);
2788
2789 if (wndProc)
2790 SetWindowLongPtrW(hWnd, GWLP_WNDPROC, wndProc);
2791 }
2792 return hWnd;
2793 }
2794
2795 /*************************************************************************
2796 * @ [SHLWAPI.279]
2797 *
2798 * Get and show a context menu from a shell folder.
2799 *
2800 * PARAMS
2801 * hWnd [I] Window displaying the shell folder
2802 * lpFolder [I] IShellFolder interface
2803 * lpApidl [I] Id for the particular folder desired
2804 *
2805 * RETURNS
2806 * Success: S_OK.
2807 * Failure: An HRESULT error code indicating the error.
2808 */
2809 HRESULT WINAPI SHInvokeDefaultCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl)
2810 {
2811 return SHInvokeCommand(hWnd, lpFolder, lpApidl, FALSE);
2812 }
2813
2814 /*************************************************************************
2815 * @ [SHLWAPI.281]
2816 *
2817 * _SHPackDispParamsV
2818 */
2819 HRESULT WINAPI SHPackDispParamsV(DISPPARAMS *params, VARIANTARG *args, UINT cnt, va_list valist)
2820 {
2821 VARIANTARG *iter;
2822
2823 TRACE("(%p %p %u ...)\n", params, args, cnt);
2824
2825 params->rgvarg = args;
2826 params->rgdispidNamedArgs = NULL;
2827 params->cArgs = cnt;
2828 params->cNamedArgs = 0;
2829
2830 iter = args+cnt;
2831
2832 while(iter-- > args) {
2833 V_VT(iter) = va_arg(valist, enum VARENUM);
2834
2835 TRACE("vt=%d\n", V_VT(iter));
2836
2837 if(V_VT(iter) & VT_BYREF) {
2838 V_BYREF(iter) = va_arg(valist, LPVOID);
2839 } else {
2840 switch(V_VT(iter)) {
2841 case VT_I4:
2842 V_I4(iter) = va_arg(valist, LONG);
2843 break;
2844 case VT_BSTR:
2845 V_BSTR(iter) = va_arg(valist, BSTR);
2846 break;
2847 case VT_DISPATCH:
2848 V_DISPATCH(iter) = va_arg(valist, IDispatch*);
2849 break;
2850 case VT_BOOL:
2851 V_BOOL(iter) = va_arg(valist, int);
2852 break;
2853 case VT_UNKNOWN:
2854 V_UNKNOWN(iter) = va_arg(valist, IUnknown*);
2855 break;
2856 default:
2857 V_VT(iter) = VT_I4;
2858 V_I4(iter) = va_arg(valist, LONG);
2859 }
2860 }
2861 }
2862
2863 return S_OK;
2864 }
2865
2866 /*************************************************************************
2867 * @ [SHLWAPI.282]
2868 *
2869 * SHPackDispParams
2870 */
2871 HRESULT WINAPIV SHPackDispParams(DISPPARAMS *params, VARIANTARG *args, UINT cnt, ...)
2872 {
2873 va_list valist;
2874 HRESULT hres;
2875
2876 va_start(valist, cnt);
2877
2878 hres = SHPackDispParamsV(params, args, cnt, valist);
2879
2880 va_end(valist);
2881 return hres;
2882 }
2883
2884 /*************************************************************************
2885 * SHLWAPI_InvokeByIID
2886 *
2887 * This helper function calls IDispatch::Invoke for each sink
2888 * which implements given iid or IDispatch.
2889 *
2890 */
2891 static HRESULT SHLWAPI_InvokeByIID(
2892 IConnectionPoint* iCP,
2893 REFIID iid,
2894 DISPID dispId,
2895 DISPPARAMS* dispParams)
2896 {
2897 IEnumConnections *enumerator;
2898 CONNECTDATA rgcd;
2899
2900 HRESULT result = IConnectionPoint_EnumConnections(iCP, &enumerator);
2901 if (FAILED(result))
2902 return result;
2903
2904 while(IEnumConnections_Next(enumerator, 1, &rgcd, NULL)==S_OK)
2905 {
2906 IDispatch *dispIface;
2907 if (SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, iid, (LPVOID*)&dispIface)) ||
2908 SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, &IID_IDispatch, (LPVOID*)&dispIface)))
2909 {
2910 IDispatch_Invoke(dispIface, dispId, &IID_NULL, 0, DISPATCH_METHOD, dispParams, NULL, NULL, NULL);
2911 IDispatch_Release(dispIface);
2912 }
2913 }
2914
2915 IEnumConnections_Release(enumerator);
2916
2917 return S_OK;
2918 }
2919
2920 /*************************************************************************
2921 * @ [SHLWAPI.284]
2922 *
2923 * IConnectionPoint_SimpleInvoke
2924 */
2925 HRESULT WINAPI IConnectionPoint_SimpleInvoke(
2926 IConnectionPoint* iCP,
2927 DISPID dispId,
2928 DISPPARAMS* dispParams)
2929 {
2930 IID iid;
2931 HRESULT result;
2932
2933 TRACE("(%p)->(0x%x %p)\n",iCP,dispId,dispParams);
2934
2935 result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
2936 if (SUCCEEDED(result))
2937 result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
2938
2939 return result;
2940 }
2941
2942 /*************************************************************************
2943 * @ [SHLWAPI.285]
2944 *
2945 * Notify an IConnectionPoint object of changes.
2946 *
2947 * PARAMS
2948 * lpCP [I] Object to notify
2949 * dispID [I]
2950 *
2951 * RETURNS
2952 * Success: S_OK.
2953 * Failure: E_NOINTERFACE, if lpCP is NULL or does not support the
2954 * IConnectionPoint interface.
2955 */
2956 HRESULT WINAPI IConnectionPoint_OnChanged(IConnectionPoint* lpCP, DISPID dispID)
2957 {
2958 IEnumConnections *lpEnum;
2959 HRESULT hRet = E_NOINTERFACE;
2960
2961 TRACE("(%p,0x%8X)\n", lpCP, dispID);
2962
2963 /* Get an enumerator for the connections */
2964 if (lpCP)
2965 hRet = IConnectionPoint_EnumConnections(lpCP, &lpEnum);
2966
2967 if (SUCCEEDED(hRet))
2968 {
2969 IPropertyNotifySink *lpSink;
2970 CONNECTDATA connData;
2971 ULONG ulFetched;
2972
2973 /* Call OnChanged() for every notify sink in the connection point */
2974 while (IEnumConnections_Next(lpEnum, 1, &connData, &ulFetched) == S_OK)
2975 {
2976 if (SUCCEEDED(IUnknown_QueryInterface(connData.pUnk, &IID_IPropertyNotifySink, (void**)&lpSink)) &&
2977 lpSink)
2978 {
2979 IPropertyNotifySink_OnChanged(lpSink, dispID);
2980 IPropertyNotifySink_Release(lpSink);
2981 }
2982 IUnknown_Release(connData.pUnk);
2983 }
2984
2985 IEnumConnections_Release(lpEnum);
2986 }
2987 return hRet;
2988 }
2989
2990 /*************************************************************************
2991 * @ [SHLWAPI.286]
2992 *
2993 * IUnknown_CPContainerInvokeParam
2994 */
2995 HRESULT WINAPIV IUnknown_CPContainerInvokeParam(
2996 IUnknown *container,
2997 REFIID riid,
2998 DISPID dispId,
2999 VARIANTARG* buffer,
3000 DWORD cParams, ...)
3001 {
3002 HRESULT result;
3003 IConnectionPoint *iCP;
3004 IConnectionPointContainer *iCPC;
3005 DISPPARAMS dispParams = {buffer, NULL, cParams, 0};
3006 va_list valist;
3007
3008 if (!container)
3009 return E_NOINTERFACE;
3010
3011 result = IUnknown_QueryInterface(container, &IID_IConnectionPointContainer,(LPVOID*) &iCPC);
3012 if (FAILED(result))
3013 return result;
3014
3015 result = IConnectionPointContainer_FindConnectionPoint(iCPC, riid, &iCP);
3016 IConnectionPointContainer_Release(iCPC);
3017 if(FAILED(result))
3018 return result;
3019
3020 va_start(valist, cParams);
3021 SHPackDispParamsV(&dispParams, buffer, cParams, valist);
3022 va_end(valist);
3023
3024 result = SHLWAPI_InvokeByIID(iCP, riid, dispId, &dispParams);
3025 IConnectionPoint_Release(iCP);
3026
3027 return result;
3028 }
3029
3030 /*************************************************************************
3031 * @ [SHLWAPI.287]
3032 *
3033 * Notify an IConnectionPointContainer object of changes.
3034 *
3035 * PARAMS
3036 * lpUnknown [I] Object to notify
3037 * dispID [I]
3038 *
3039 * RETURNS
3040 * Success: S_OK.
3041 * Failure: E_NOINTERFACE, if lpUnknown is NULL or does not support the
3042 * IConnectionPointContainer interface.
3043 */
3044 HRESULT WINAPI IUnknown_CPContainerOnChanged(IUnknown *lpUnknown, DISPID dispID)
3045 {
3046 IConnectionPointContainer* lpCPC = NULL;
3047 HRESULT hRet = E_NOINTERFACE;
3048
3049 TRACE("(%p,0x%8X)\n", lpUnknown, dispID);
3050
3051 if (lpUnknown)
3052 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer, (void**)&lpCPC);
3053
3054 if (SUCCEEDED(hRet))
3055 {
3056 IConnectionPoint* lpCP;
3057
3058 hRet = IConnectionPointContainer_FindConnectionPoint(lpCPC, &IID_IPropertyNotifySink, &lpCP);
3059 IConnectionPointContainer_Release(lpCPC);
3060
3061 hRet = IConnectionPoint_OnChanged(lpCP, dispID);
3062 IConnectionPoint_Release(lpCP);
3063 }
3064 return hRet;
3065 }
3066
3067 /*************************************************************************
3068 * @ [SHLWAPI.289]
3069 *
3070 * See PlaySoundW.
3071 */
3072 BOOL WINAPI PlaySoundWrapW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
3073 {
3074 return PlaySoundW(pszSound, hmod, fdwSound);
3075 }
3076
3077 /*************************************************************************
3078 * @ [SHLWAPI.294]
3079 */
3080 BOOL WINAPI SHGetIniStringW(LPCWSTR str1, LPCWSTR str2, LPWSTR pStr, DWORD some_len, LPCWSTR lpStr2)
3081 {
3082 FIXME("(%s,%s,%p,%08x,%s): stub!\n", debugstr_w(str1), debugstr_w(str2),
3083 pStr, some_len, debugstr_w(lpStr2));
3084 return TRUE;
3085 }
3086
3087 /*************************************************************************
3088 * @ [SHLWAPI.295]
3089 *
3090 * Called by ICQ2000b install via SHDOCVW:
3091 * str1: "InternetShortcut"
3092 * x: some unknown pointer
3093 * str2: "http://free.aol.com/tryaolfree/index.adp?139269"
3094 * str3: "C:\\WINDOWS\\Desktop.new2\\Free AOL & Unlimited Internet.url"
3095 *
3096 * In short: this one maybe creates a desktop link :-)
3097 */
3098 BOOL WINAPI SHSetIniStringW(LPWSTR str1, LPVOID x, LPWSTR str2, LPWSTR str3)
3099 {
3100 FIXME("(%s, %p, %s, %s), stub.\n", debugstr_w(str1), x, debugstr_w(str2), debugstr_w(str3));
3101 return TRUE;
3102 }
3103
3104 /*************************************************************************
3105 * @ [SHLWAPI.313]
3106 *
3107 * See SHGetFileInfoW.
3108 */
3109 DWORD WINAPI SHGetFileInfoWrapW(LPCWSTR path, DWORD dwFileAttributes,
3110 SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags)
3111 {
3112 return SHGetFileInfoW(path, dwFileAttributes, psfi, sizeofpsfi, flags);
3113 }
3114
3115 /*************************************************************************
3116 * @ [SHLWAPI.318]
3117 *
3118 * See DragQueryFileW.
3119 */
3120 UINT WINAPI DragQueryFileWrapW(HDROP hDrop, UINT lFile, LPWSTR lpszFile, UINT lLength)
3121 {
3122 return DragQueryFileW(hDrop, lFile, lpszFile, lLength);
3123 }
3124
3125 /*************************************************************************
3126 * @ [SHLWAPI.333]
3127 *
3128 * See SHBrowseForFolderW.
3129 */
3130 LPITEMIDLIST WINAPI SHBrowseForFolderWrapW(LPBROWSEINFOW lpBi)
3131 {
3132 return SHBrowseForFolderW(lpBi);
3133 }
3134
3135 /*************************************************************************
3136 * @ [SHLWAPI.334]
3137 *
3138 * See SHGetPathFromIDListW.
3139 */
3140 BOOL WINAPI SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl,LPWSTR pszPath)
3141 {
3142 return SHGetPathFromIDListW(pidl, pszPath);
3143 }
3144
3145 /*************************************************************************
3146 * @ [SHLWAPI.335]
3147 *
3148 * See ShellExecuteExW.
3149 */
3150 BOOL WINAPI ShellExecuteExWrapW(LPSHELLEXECUTEINFOW lpExecInfo)
3151 {
3152 return ShellExecuteExW(lpExecInfo);
3153 }
3154
3155 /*************************************************************************
3156 * @ [SHLWAPI.336]
3157 *
3158 * See SHFileOperationW.
3159 */
3160 INT WINAPI SHFileOperationWrapW(LPSHFILEOPSTRUCTW lpFileOp)
3161 {
3162 return SHFileOperationW(lpFileOp);
3163 }
3164
3165 /*************************************************************************
3166 * @ [SHLWAPI.342]
3167 *
3168 */
3169 PVOID WINAPI SHInterlockedCompareExchange( PVOID *dest, PVOID xchg, PVOID compare )
3170 {
3171 return InterlockedCompareExchangePointer( dest, xchg, compare );
3172 }
3173
3174 /*************************************************************************
3175 * @ [SHLWAPI.350]
3176 *
3177 * See GetFileVersionInfoSizeW.
3178 */
3179 DWORD WINAPI GetFileVersionInfoSizeWrapW( LPCWSTR filename, LPDWORD handle )
3180 {
3181 return GetFileVersionInfoSizeW( filename, handle );
3182 }
3183
3184 /*************************************************************************
3185 * @ [SHLWAPI.351]
3186 *
3187 * See GetFileVersionInfoW.
3188 */
3189 BOOL WINAPI GetFileVersionInfoWrapW( LPCWSTR filename, DWORD handle,
3190 DWORD datasize, LPVOID data )
3191 {
3192 return GetFileVersionInfoW( filename, handle, datasize, data );
3193 }
3194
3195 /*************************************************************************
3196 * @ [SHLWAPI.352]
3197 *
3198 * See VerQueryValueW.
3199 */
3200 WORD WINAPI VerQueryValueWrapW( LPVOID pBlock, LPCWSTR lpSubBlock,
3201 LPVOID *lplpBuffer, UINT *puLen )
3202 {
3203 return VerQueryValueW( pBlock, lpSubBlock, lplpBuffer, puLen );
3204 }
3205
3206 #define IsIface(type) SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
3207 #define IShellBrowser_EnableModeless IShellBrowser_EnableModelessSB
3208 #define EnableModeless(type) type##_EnableModeless((type*)lpObj, bModeless)
3209
3210 /*************************************************************************
3211 * @ [SHLWAPI.355]
3212 *
3213 * Change the modality of a shell object.
3214 *
3215 * PARAMS
3216 * lpUnknown [I] Object to make modeless
3217 * bModeless [I] TRUE=Make modeless, FALSE=Make modal
3218 *
3219 * RETURNS
3220 * Success: S_OK. The modality lpUnknown is changed.
3221 * Failure: An HRESULT error code indicating the error.
3222 *
3223 * NOTES
3224 * lpUnknown must support the IOleInPlaceFrame interface, the
3225 * IInternetSecurityMgrSite interface, the IShellBrowser interface
3226 * the IDocHostUIHandler interface, or the IOleInPlaceActiveObject interface,
3227 * or this call will fail.
3228 */
3229 HRESULT WINAPI IUnknown_EnableModeless(IUnknown *lpUnknown, BOOL bModeless)
3230 {
3231 IUnknown *lpObj;
3232 HRESULT hRet;
3233
3234 TRACE("(%p,%d)\n", lpUnknown, bModeless);
3235
3236 if (!lpUnknown)
3237 return E_FAIL;
3238
3239 if (IsIface(IOleInPlaceActiveObject))
3240 EnableModeless(IOleInPlaceActiveObject);
3241 else if (IsIface(IOleInPlaceFrame))
3242 EnableModeless(IOleInPlaceFrame);
3243 else if (IsIface(IShellBrowser))
3244 EnableModeless(IShellBrowser);
3245 else if (IsIface(IInternetSecurityMgrSite))
3246 EnableModeless(IInternetSecurityMgrSite);
3247 else if (IsIface(IDocHostUIHandler))
3248 EnableModeless(IDocHostUIHandler);
3249 else
3250 return hRet;
3251
3252 IUnknown_Release(lpObj);
3253 return S_OK;
3254 }
3255
3256 /*************************************************************************
3257 * @ [SHLWAPI.357]
3258 *
3259 * See SHGetNewLinkInfoW.
3260 */
3261 BOOL WINAPI SHGetNewLinkInfoWrapW(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName,
3262 BOOL *pfMustCopy, UINT uFlags)
3263 {
3264 return SHGetNewLinkInfoW(pszLinkTo, pszDir, pszName, pfMustCopy, uFlags);
3265 }
3266
3267 /*************************************************************************
3268 * @ [SHLWAPI.358]
3269 *
3270 * See SHDefExtractIconW.
3271 */
3272 UINT WINAPI SHDefExtractIconWrapW(LPCWSTR pszIconFile, int iIndex, UINT uFlags, HICON* phiconLarge,
3273 HICON* phiconSmall, UINT nIconSize)
3274 {
3275 return SHDefExtractIconW(pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
3276 }
3277
3278 /*************************************************************************
3279 * @ [SHLWAPI.363]
3280 *
3281 * Get and show a context menu from a shell folder.
3282 *
3283 * PARAMS
3284 * hWnd [I] Window displaying the shell folder
3285 * lpFolder [I] IShellFolder interface
3286 * lpApidl [I] Id for the particular folder desired
3287 * bInvokeDefault [I] Whether to invoke the default menu item
3288 *
3289 * RETURNS
3290 * Success: S_OK. If bInvokeDefault is TRUE, the default menu action was
3291 * executed.
3292 * Failure: An HRESULT error code indicating the error.
3293 */
3294 HRESULT WINAPI SHInvokeCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl, BOOL bInvokeDefault)
3295 {
3296 IContextMenu *iContext;
3297 HRESULT hRet = E_FAIL;
3298
3299 TRACE("(%p,%p,%p,%d)\n", hWnd, lpFolder, lpApidl, bInvokeDefault);
3300
3301 if (!lpFolder)
3302 return hRet;
3303
3304 /* Get the context menu from the shell folder */
3305 hRet = IShellFolder_GetUIObjectOf(lpFolder, hWnd, 1, &lpApidl,
3306 &IID_IContextMenu, 0, (void**)&iContext);
3307 if (SUCCEEDED(hRet))
3308 {
3309 HMENU hMenu;
3310 if ((hMenu = CreatePopupMenu()))
3311 {
3312 HRESULT hQuery;
3313 DWORD dwDefaultId = 0;
3314
3315 /* Add the context menu entries to the popup */
3316 hQuery = IContextMenu_QueryContextMenu(iContext, hMenu, 0, 1, 0x7FFF,
3317 bInvokeDefault ? CMF_NORMAL : CMF_DEFAULTONLY);
3318
3319 if (SUCCEEDED(hQuery))
3320 {
3321 if (bInvokeDefault &&
3322 (dwDefaultId = GetMenuDefaultItem(hMenu, 0, 0)) != 0xFFFFFFFF)
3323 {
3324 CMINVOKECOMMANDINFO cmIci;
3325 /* Invoke the default item */
3326 memset(&cmIci,0,sizeof(cmIci));
3327 cmIci.cbSize = sizeof(cmIci);
3328 cmIci.fMask = CMIC_MASK_ASYNCOK;
3329 cmIci.hwnd = hWnd;
3330 cmIci.lpVerb = MAKEINTRESOURCEA(dwDefaultId);
3331 cmIci.nShow = SW_SCROLLCHILDREN;
3332
3333 hRet = IContextMenu_InvokeCommand(iContext, &cmIci);
3334 }
3335 }
3336 DestroyMenu(hMenu);
3337 }
3338 IContextMenu_Release(iContext);
3339 }
3340 return hRet;
3341 }
3342
3343 /*************************************************************************
3344 * @ [SHLWAPI.370]
3345 *
3346 * See ExtractIconW.
3347 */
3348 HICON WINAPI ExtractIconWrapW(HINSTANCE hInstance, LPCWSTR lpszExeFileName,
3349 UINT nIconIndex)
3350 {
3351 return ExtractIconW(hInstance, lpszExeFileName, nIconIndex);
3352 }
3353
3354 /*************************************************************************
3355 * @ [SHLWAPI.377]
3356 *
3357 * Load a library from the directory of a particular process.
3358 *
3359 * PARAMS
3360 * new_mod [I] Library name
3361 * inst_hwnd [I] Module whose directory is to be used
3362 * dwCrossCodePage [I] Should be FALSE (currently ignored)
3363 *
3364 * RETURNS
3365 * Success: A handle to the loaded module
3366 * Failure: A NULL handle.
3367 */
3368 HMODULE WINAPI MLLoadLibraryA(LPCSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3369 {
3370 /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
3371 * each call here.
3372 * FIXME: Native shows calls to:
3373 * SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
3374 * CheckVersion
3375 * RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
3376 * RegQueryValueExA for "LPKInstalled"
3377 * RegCloseKey
3378 * RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
3379 * RegQueryValueExA for "ResourceLocale"
3380 * RegCloseKey
3381 * RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
3382 * RegQueryValueExA for "Locale"
3383 * RegCloseKey
3384 * and then tests the Locale ("en" for me).
3385 * code below
3386 * after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
3387 */
3388 CHAR mod_path[2*MAX_PATH];
3389 LPSTR ptr;
3390 DWORD len;
3391
3392 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_a(new_mod), inst_hwnd, dwCrossCodePage);
3393 len = GetModuleFileNameA(inst_hwnd, mod_path, sizeof(mod_path));
3394 if (!len || len >= sizeof(mod_path)) return NULL;
3395
3396 ptr = strrchr(mod_path, '\\');
3397 if (ptr) {
3398 strcpy(ptr+1, new_mod);
3399 TRACE("loading %s\n", debugstr_a(mod_path));
3400 return LoadLibraryA(mod_path);
3401 }
3402 return NULL;
3403 }
3404
3405 /*************************************************************************
3406 * @ [SHLWAPI.378]
3407 *
3408 * Unicode version of MLLoadLibraryA.
3409 */
3410 HMODULE WINAPI MLLoadLibraryW(LPCWSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3411 {
3412 WCHAR mod_path[2*MAX_PATH];
3413 LPWSTR ptr;
3414 DWORD len;
3415
3416 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_w(new_mod), inst_hwnd, dwCrossCodePage);
3417 len = GetModuleFileNameW(inst_hwnd, mod_path, sizeof(mod_path) / sizeof(WCHAR));
3418 if (!len || len >= sizeof(mod_path) / sizeof(WCHAR)) return NULL;
3419
3420 ptr = strrchrW(mod_path, '\\');
3421 if (ptr) {
3422 strcpyW(ptr+1, new_mod);
3423 TRACE("loading %s\n", debugstr_w(mod_path));
3424 return LoadLibraryW(mod_path);
3425 }
3426 return NULL;
3427 }
3428
3429 /*************************************************************************
3430 * ColorAdjustLuma [SHLWAPI.@]
3431 *
3432 * Adjust the luminosity of a color
3433 *
3434 * PARAMS
3435 * cRGB [I] RGB value to convert
3436 * dwLuma [I] Luma adjustment
3437 * bUnknown [I] Unknown
3438 *
3439 * RETURNS
3440 * The adjusted RGB color.
3441 */
3442 COLORREF WINAPI ColorAdjustLuma(COLORREF cRGB, int dwLuma, BOOL bUnknown)
3443 {
3444 TRACE("(0x%8x,%d,%d)\n", cRGB, dwLuma, bUnknown);
3445
3446 if (dwLuma)
3447 {
3448 WORD wH, wL, wS;
3449
3450 ColorRGBToHLS(cRGB, &wH, &wL, &wS);
3451
3452 FIXME("Ignoring luma adjustment\n");
3453
3454 /* FIXME: The adjustment is not linear */
3455
3456 cRGB = ColorHLSToRGB(wH, wL, wS);
3457 }
3458 return cRGB;
3459 }
3460
3461 /*************************************************************************
3462 * @ [SHLWAPI.389]
3463 *
3464 * See GetSaveFileNameW.
3465 */
3466 BOOL WINAPI GetSaveFileNameWrapW(LPOPENFILENAMEW ofn)
3467 {
3468 return GetSaveFileNameW(ofn);
3469 }
3470
3471 /*************************************************************************
3472 * @ [SHLWAPI.390]
3473 *
3474 * See WNetRestoreConnectionW.
3475 */
3476 DWORD WINAPI WNetRestoreConnectionWrapW(HWND hwndOwner, LPWSTR lpszDevice)
3477 {
3478 return WNetRestoreConnectionW(hwndOwner, lpszDevice);
3479 }
3480
3481 /*************************************************************************
3482 * @ [SHLWAPI.391]
3483 *
3484 * See WNetGetLastErrorW.
3485 */
3486 DWORD WINAPI WNetGetLastErrorWrapW(LPDWORD lpError, LPWSTR lpErrorBuf, DWORD nErrorBufSize,
3487 LPWSTR lpNameBuf, DWORD nNameBufSize)
3488 {
3489 return WNetGetLastErrorW(lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize);
3490 }
3491
3492 /*************************************************************************
3493 * @ [SHLWAPI.401]
3494 *
3495 * See PageSetupDlgW.
3496 */
3497 BOOL WINAPI PageSetupDlgWrapW(LPPAGESETUPDLGW pagedlg)
3498 {
3499 return PageSetupDlgW(pagedlg);
3500 }
3501
3502 /*************************************************************************
3503 * @ [SHLWAPI.402]
3504 *
3505 * See PrintDlgW.
3506 */
3507 BOOL WINAPI PrintDlgWrapW(LPPRINTDLGW printdlg)
3508 {
3509 return PrintDlgW(printdlg);
3510 }
3511
3512 /*************************************************************************
3513 * @ [SHLWAPI.403]
3514 *
3515 * See GetOpenFileNameW.
3516 */
3517 BOOL WINAPI GetOpenFileNameWrapW(LPOPENFILENAMEW ofn)
3518 {
3519 return GetOpenFileNameW(ofn);
3520 }
3521
3522 /*************************************************************************
3523 * @ [SHLWAPI.404]
3524 */
3525 HRESULT WINAPI SHIShellFolder_EnumObjects(LPSHELLFOLDER lpFolder, HWND hwnd, SHCONTF flags, IEnumIDList **ppenum)
3526 {
3527 IPersist *persist;
3528 HRESULT hr;
3529
3530 hr = IShellFolder_QueryInterface(lpFolder, &IID_IPersist, (LPVOID)&persist);
3531 if(SUCCEEDED(hr))
3532 {
3533 CLSID clsid;
3534 hr = IPersist_GetClassID(persist, &clsid);
3535 if(SUCCEEDED(hr))
3536 {
3537 if(IsEqualCLSID(&clsid, &CLSID_ShellFSFolder))
3538 hr = IShellFolder_EnumObjects(lpFolder, hwnd, flags, ppenum);
3539 else
3540 hr = E_FAIL;
3541 }
3542 IPersist_Release(persist);
3543 }
3544 return hr;
3545 }
3546
3547 /* INTERNAL: Map from HLS color space to RGB */
3548 static WORD ConvertHue(int wHue, WORD wMid1, WORD wMid2)
3549 {
3550 wHue = wHue > 240 ? wHue - 240 : wHue < 0 ? wHue + 240 : wHue;
3551
3552 if (wHue > 160)
3553 return wMid1;
3554 else if (wHue > 120)
3555 wHue = 160 - wHue;
3556 else if (wHue > 40)
3557 return wMid2;
3558
3559 return ((wHue * (wMid2 - wMid1) + 20) / 40) + wMid1;
3560 }
3561
3562 /* Convert to RGB and scale into RGB range (0..255) */
3563 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
3564
3565 /*************************************************************************
3566 * ColorHLSToRGB [SHLWAPI.@]
3567 *
3568 * Convert from hls color space into an rgb COLORREF.
3569 *
3570 * PARAMS
3571 * wHue [I] Hue amount
3572 * wLuminosity [I] Luminosity amount
3573 * wSaturation [I] Saturation amount
3574 *
3575 * RETURNS
3576 * A COLORREF representing the converted color.
3577 *
3578 * NOTES
3579 * Input hls values are constrained to the range (0..240).
3580 */
3581 COLORREF WINAPI ColorHLSToRGB(WORD wHue, WORD wLuminosity, WORD wSaturation)
3582 {
3583 WORD wRed;
3584
3585 if (wSaturation)
3586 {
3587 WORD wGreen, wBlue, wMid1, wMid2;
3588
3589 if (wLuminosity > 120)
3590 wMid2 = wSaturation + wLuminosity - (wSaturation * wLuminosity + 120) / 240;
3591 else
3592 wMid2 = ((wSaturation + 240) * wLuminosity + 120) / 240;
3593
3594 wMid1 = wLuminosity * 2 - wMid2;
3595
3596 wRed = GET_RGB(wHue + 80);
3597 wGreen = GET_RGB(wHue);
3598 wBlue = GET_RGB(wHue - 80);
3599
3600 return RGB(wRed, wGreen, wBlue);
3601 }
3602
3603 wRed = wLuminosity * 255 / 240;
3604 return RGB(wRed, wRed, wRed);
3605 }
3606
3607 /*************************************************************************
3608 * @ [SHLWAPI.413]
3609 *
3610 * Get the current docking status of the system.
3611 *
3612 * PARAMS
3613 * dwFlags [I] DOCKINFO_ flags from "winbase.h", unused
3614 *
3615 * RETURNS
3616 * One of DOCKINFO_UNDOCKED, DOCKINFO_UNDOCKED, or 0 if the system is not
3617 * a notebook.
3618 */
3619 DWORD WINAPI SHGetMachineInfo(DWORD dwFlags)
3620 {
3621 HW_PROFILE_INFOA hwInfo;
3622
3623 TRACE("(0x%08x)\n", dwFlags);
3624
3625 GetCurrentHwProfileA(&hwInfo);
3626 switch (hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED))
3627 {
3628 case DOCKINFO_DOCKED:
3629 case DOCKINFO_UNDOCKED:
3630 return hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED);
3631 default:
3632 return 0;
3633 }
3634 }
3635
3636 /*************************************************************************
3637 * @ [SHLWAPI.418]
3638 *
3639 * Function seems to do FreeLibrary plus other things.
3640 *
3641 * FIXME native shows the following calls:
3642 * RtlEnterCriticalSection
3643 * LocalFree
3644 * GetProcAddress(Comctl32??, 150L)
3645 * DPA_DeletePtr
3646 * RtlLeaveCriticalSection
3647 * followed by the FreeLibrary.
3648 * The above code may be related to .377 above.
3649 */
3650 BOOL WINAPI MLFreeLibrary(HMODULE hModule)
3651 {
3652 FIXME("(%p) semi-stub\n", hModule);
3653 return FreeLibrary(hModule);
3654 }
3655
3656 /*************************************************************************
3657 * @ [SHLWAPI.419]
3658 */
3659 BOOL WINAPI SHFlushSFCacheWrap(void) {
3660 FIXME(": stub\n");
3661 return TRUE;
3662 }
3663
3664 /*************************************************************************
3665 * @ [SHLWAPI.429]
3666 * FIXME I have no idea what this function does or what its arguments are.
3667 */
3668 BOOL WINAPI MLIsMLHInstance(HINSTANCE hInst)
3669 {
3670 FIXME("(%p) stub\n", hInst);
3671 return FALSE;
3672 }
3673
3674
3675 /*************************************************************************
3676 * @ [SHLWAPI.430]
3677 */
3678 DWORD WINAPI MLSetMLHInstance(HINSTANCE hInst, HANDLE hHeap)
3679 {
3680 FIXME("(%p,%p) stub\n", hInst, hHeap);
3681 return E_FAIL; /* This is what is used if shlwapi not loaded */
3682 }
3683
3684 /*************************************************************************
3685 * @ [SHLWAPI.431]
3686 */
3687 DWORD WINAPI MLClearMLHInstance(DWORD x)
3688 {
3689 FIXME("(0x%08x)stub\n", x);
3690 return 0xabba1247;
3691 }
3692
3693 /*************************************************************************
3694 * @ [SHLWAPI.432]
3695 *
3696 * See SHSendMessageBroadcastW
3697 *
3698 */
3699 DWORD WINAPI SHSendMessageBroadcastA(UINT uMsg, WPARAM wParam, LPARAM lParam)
3700 {
3701 return SendMessageTimeoutA(HWND_BROADCAST, uMsg, wParam, lParam,
3702 SMTO_ABORTIFHUNG, 2000, NULL);
3703 }
3704
3705 /*************************************************************************
3706 * @ [SHLWAPI.433]
3707 *
3708 * A wrapper for sending Broadcast Messages to all top level Windows
3709 *
3710 */
3711 DWORD WINAPI SHSendMessageBroadcastW(UINT uMsg, WPARAM wParam, LPARAM lParam)
3712 {
3713 return SendMessageTimeoutW(HWND_BROADCAST, uMsg, wParam, lParam,
3714 SMTO_ABORTIFHUNG, 2000, NULL);
3715 }
3716
3717 /*************************************************************************
3718 * @ [SHLWAPI.436]
3719 *
3720 * Convert a Unicode string CLSID into a CLSID.
3721 *
3722 * PARAMS
3723 * idstr [I] string containing a CLSID in text form
3724 * id [O] CLSID extracted from the string
3725 *
3726 * RETURNS
3727 * S_OK on success or E_INVALIDARG on failure
3728 */
3729 HRESULT WINAPI CLSIDFromStringWrap(LPCWSTR idstr, CLSID *id)
3730 {
3731 return CLSIDFromString((LPOLESTR)idstr, id);
3732 }
3733
3734 /*************************************************************************
3735 * @ [SHLWAPI.437]
3736 *
3737 * Determine if the OS supports a given feature.
3738 *
3739 * PARAMS
3740 * dwFeature [I] Feature requested (undocumented)
3741 *
3742 * RETURNS
3743 * TRUE If the feature is available.
3744 * FALSE If the feature is not available.
3745 */
3746 BOOL WINAPI IsOS(DWORD feature)
3747 {
3748 OSVERSIONINFOA osvi;
3749 DWORD platform, majorv, minorv;
3750
3751 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
3752 if(!GetVersionExA(&osvi)) {
3753 ERR("GetVersionEx failed\n");
3754 return FALSE;
3755 }
3756
3757 majorv = osvi.dwMajorVersion;
3758 minorv = osvi.dwMinorVersion;
3759 platform = osvi.dwPlatformId;
3760
3761 #define ISOS_RETURN(x) \
3762 TRACE("(0x%x) ret=%d\n",feature,(x)); \
3763 return (x);
3764
3765 switch(feature) {
3766 case OS_WIN32SORGREATER:
3767 ISOS_RETURN(platform == VER_PLATFORM_WIN32s
3768 || platform == VER_PLATFORM_WIN32_WINDOWS)
3769 case OS_NT:
3770 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3771 case OS_WIN95ORGREATER: