shlwapi: SHFreeShared returns TRUE when passed NULL handle.
[wine.git] / dlls / shlwapi / ordinal.c
blob699fcc64f28cd6316c4198e49803ff008860e1fc
1 /*
2 * SHLWAPI ordinal functions
4 * Copyright 1997 Marcus Meissner
5 * 1998 Jürgen Schmied
6 * 2001-2003 Jon Griffiths
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.
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.
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
23 #include "config.h"
24 #include "wine/port.h"
26 #include <stdarg.h>
27 #include <stdio.h>
28 #include <string.h>
30 #define COBJMACROS
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winnls.h"
35 #include "winreg.h"
36 #include "wingdi.h"
37 #include "winuser.h"
38 #include "winver.h"
39 #include "winnetwk.h"
40 #include "mmsystem.h"
41 #include "objbase.h"
42 #include "exdisp.h"
43 #include "shdeprecated.h"
44 #include "shlobj.h"
45 #include "shlwapi.h"
46 #include "shellapi.h"
47 #include "commdlg.h"
48 #include "mlang.h"
49 #include "mshtmhst.h"
50 #include "wine/unicode.h"
51 #include "wine/debug.h"
54 WINE_DEFAULT_DEBUG_CHANNEL(shell);
56 /* DLL handles for late bound calls */
57 extern HINSTANCE shlwapi_hInstance;
58 extern DWORD SHLWAPI_ThreadRef_index;
60 HRESULT WINAPI IUnknown_QueryService(IUnknown*,REFGUID,REFIID,LPVOID*);
61 HRESULT WINAPI SHInvokeCommand(HWND,IShellFolder*,LPCITEMIDLIST,DWORD);
62 BOOL WINAPI SHAboutInfoW(LPWSTR,DWORD);
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!
74 /*************************************************************************
75 * @ [SHLWAPI.11]
77 * Copy a sharable memory handle from one process to another.
79 * PARAMS
80 * hShared [I] Shared memory handle to duplicate
81 * dwSrcProcId [I] ID of the process owning hShared
82 * dwDstProcId [I] ID of the process wanting the duplicated handle
83 * dwAccess [I] Desired DuplicateHandle() access
84 * dwOptions [I] Desired DuplicateHandle() options
86 * RETURNS
87 * Success: A handle suitable for use by the dwDstProcId process.
88 * Failure: A NULL handle.
91 HANDLE WINAPI SHMapHandle(HANDLE hShared, DWORD dwSrcProcId, DWORD dwDstProcId,
92 DWORD dwAccess, DWORD dwOptions)
94 HANDLE hDst, hSrc;
95 DWORD dwMyProcId = GetCurrentProcessId();
96 HANDLE hRet = NULL;
98 TRACE("(%p,%d,%d,%08x,%08x)\n", hShared, dwDstProcId, dwSrcProcId,
99 dwAccess, dwOptions);
101 /* Get dest process handle */
102 if (dwDstProcId == dwMyProcId)
103 hDst = GetCurrentProcess();
104 else
105 hDst = OpenProcess(PROCESS_DUP_HANDLE, 0, dwDstProcId);
107 if (hDst)
109 /* Get src process handle */
110 if (dwSrcProcId == dwMyProcId)
111 hSrc = GetCurrentProcess();
112 else
113 hSrc = OpenProcess(PROCESS_DUP_HANDLE, 0, dwSrcProcId);
115 if (hSrc)
117 /* Make handle available to dest process */
118 if (!DuplicateHandle(hSrc, hShared, hDst, &hRet,
119 dwAccess, 0, dwOptions | DUPLICATE_SAME_ACCESS))
120 hRet = NULL;
122 if (dwSrcProcId != dwMyProcId)
123 CloseHandle(hSrc);
126 if (dwDstProcId != dwMyProcId)
127 CloseHandle(hDst);
130 TRACE("Returning handle %p\n", hRet);
131 return hRet;
134 /*************************************************************************
135 * @ [SHLWAPI.7]
137 * Create a block of sharable memory and initialise it with data.
139 * PARAMS
140 * lpvData [I] Pointer to data to write
141 * dwSize [I] Size of data
142 * dwProcId [I] ID of process owning data
144 * RETURNS
145 * Success: A shared memory handle
146 * Failure: NULL
148 * NOTES
149 * Ordinals 7-11 provide a set of calls to create shared memory between a
150 * group of processes. The shared memory is treated opaquely in that its size
151 * is not exposed to clients who map it. This is accomplished by storing
152 * the size of the map as the first DWORD of mapped data, and then offsetting
153 * the view pointer returned by this size.
156 HANDLE WINAPI SHAllocShared(LPCVOID lpvData, DWORD dwSize, DWORD dwProcId)
158 HANDLE hMap;
159 LPVOID pMapped;
160 HANDLE hRet = NULL;
162 TRACE("(%p,%d,%d)\n", lpvData, dwSize, dwProcId);
164 /* Create file mapping of the correct length */
165 hMap = CreateFileMappingA(INVALID_HANDLE_VALUE, NULL, FILE_MAP_READ, 0,
166 dwSize + sizeof(dwSize), NULL);
167 if (!hMap)
168 return hRet;
170 /* Get a view in our process address space */
171 pMapped = MapViewOfFile(hMap, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
173 if (pMapped)
175 /* Write size of data, followed by the data, to the view */
176 *((DWORD*)pMapped) = dwSize;
177 if (lpvData)
178 memcpy((char *) pMapped + sizeof(dwSize), lpvData, dwSize);
180 /* Release view. All further views mapped will be opaque */
181 UnmapViewOfFile(pMapped);
182 hRet = SHMapHandle(hMap, GetCurrentProcessId(), dwProcId,
183 FILE_MAP_ALL_ACCESS, DUPLICATE_SAME_ACCESS);
186 CloseHandle(hMap);
187 return hRet;
190 /*************************************************************************
191 * @ [SHLWAPI.8]
193 * Get a pointer to a block of shared memory from a shared memory handle.
195 * PARAMS
196 * hShared [I] Shared memory handle
197 * dwProcId [I] ID of process owning hShared
199 * RETURNS
200 * Success: A pointer to the shared memory
201 * Failure: NULL
204 PVOID WINAPI SHLockShared(HANDLE hShared, DWORD dwProcId)
206 HANDLE hDup;
207 LPVOID pMapped;
209 TRACE("(%p %d)\n", hShared, dwProcId);
211 /* Get handle to shared memory for current process */
212 hDup = SHMapHandle(hShared, dwProcId, GetCurrentProcessId(), FILE_MAP_ALL_ACCESS, 0);
214 /* Get View */
215 pMapped = MapViewOfFile(hDup, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, 0);
216 CloseHandle(hDup);
218 if (pMapped)
219 return (char *) pMapped + sizeof(DWORD); /* Hide size */
220 return NULL;
223 /*************************************************************************
224 * @ [SHLWAPI.9]
226 * Release a pointer to a block of shared memory.
228 * PARAMS
229 * lpView [I] Shared memory pointer
231 * RETURNS
232 * Success: TRUE
233 * Failure: FALSE
236 BOOL WINAPI SHUnlockShared(LPVOID lpView)
238 TRACE("(%p)\n", lpView);
239 return UnmapViewOfFile((char *) lpView - sizeof(DWORD)); /* Include size */
242 /*************************************************************************
243 * @ [SHLWAPI.10]
245 * Destroy a block of sharable memory.
247 * PARAMS
248 * hShared [I] Shared memory handle
249 * dwProcId [I] ID of process owning hShared
251 * RETURNS
252 * Success: TRUE
253 * Failure: FALSE
256 BOOL WINAPI SHFreeShared(HANDLE hShared, DWORD dwProcId)
258 HANDLE hClose;
260 TRACE("(%p %d)\n", hShared, dwProcId);
262 if (!hShared)
263 return TRUE;
265 /* Get a copy of the handle for our process, closing the source handle */
266 hClose = SHMapHandle(hShared, dwProcId, GetCurrentProcessId(),
267 FILE_MAP_ALL_ACCESS,DUPLICATE_CLOSE_SOURCE);
268 /* Close local copy */
269 return CloseHandle(hClose);
272 /*************************************************************************
273 * @ [SHLWAPI.13]
275 * Create and register a clipboard enumerator for a web browser.
277 * PARAMS
278 * lpBC [I] Binding context
279 * lpUnknown [I] An object exposing the IWebBrowserApp interface
281 * RETURNS
282 * Success: S_OK.
283 * Failure: An HRESULT error code.
285 * NOTES
286 * The enumerator is stored as a property of the web browser. If it does not
287 * yet exist, it is created and set before being registered.
289 HRESULT WINAPI RegisterDefaultAcceptHeaders(LPBC lpBC, IUnknown *lpUnknown)
291 static const WCHAR szProperty[] = { '{','D','0','F','C','A','4','2','0',
292 '-','D','3','F','5','-','1','1','C','F', '-','B','2','1','1','-','0',
293 '0','A','A','0','0','4','A','E','8','3','7','}','\0' };
294 BSTR property;
295 IEnumFORMATETC* pIEnumFormatEtc = NULL;
296 VARIANTARG var;
297 HRESULT hr;
298 IWebBrowserApp* pBrowser;
300 TRACE("(%p, %p)\n", lpBC, lpUnknown);
302 hr = IUnknown_QueryService(lpUnknown, &IID_IWebBrowserApp, &IID_IWebBrowserApp, (void**)&pBrowser);
303 if (FAILED(hr))
304 return hr;
306 V_VT(&var) = VT_EMPTY;
308 /* The property we get is the browsers clipboard enumerator */
309 property = SysAllocString(szProperty);
310 hr = IWebBrowserApp_GetProperty(pBrowser, property, &var);
311 SysFreeString(property);
312 if (FAILED(hr)) goto exit;
314 if (V_VT(&var) == VT_EMPTY)
316 /* Iterate through accepted documents and RegisterClipBoardFormatA() them */
317 char szKeyBuff[128], szValueBuff[128];
318 DWORD dwKeySize, dwValueSize, dwRet = 0, dwCount = 0, dwNumValues, dwType;
319 FORMATETC* formatList, *format;
320 HKEY hDocs;
322 TRACE("Registering formats and creating IEnumFORMATETC instance\n");
324 if (!RegOpenKeyA(HKEY_LOCAL_MACHINE, "Software\\Microsoft\\Windows\\Current"
325 "Version\\Internet Settings\\Accepted Documents", &hDocs))
327 hr = E_FAIL;
328 goto exit;
331 /* Get count of values in key */
332 while (!dwRet)
334 dwKeySize = sizeof(szKeyBuff);
335 dwRet = RegEnumValueA(hDocs,dwCount,szKeyBuff,&dwKeySize,0,&dwType,0,0);
336 dwCount++;
339 dwNumValues = dwCount;
341 /* Note: dwCount = number of items + 1; The extra item is the end node */
342 format = formatList = HeapAlloc(GetProcessHeap(), 0, dwCount * sizeof(FORMATETC));
343 if (!formatList)
345 RegCloseKey(hDocs);
346 hr = E_OUTOFMEMORY;
347 goto exit;
350 if (dwNumValues > 1)
352 dwRet = 0;
353 dwCount = 0;
355 dwNumValues--;
357 /* Register clipboard formats for the values and populate format list */
358 while(!dwRet && dwCount < dwNumValues)
360 dwKeySize = sizeof(szKeyBuff);
361 dwValueSize = sizeof(szValueBuff);
362 dwRet = RegEnumValueA(hDocs, dwCount, szKeyBuff, &dwKeySize, 0, &dwType,
363 (PBYTE)szValueBuff, &dwValueSize);
364 if (!dwRet)
366 HeapFree(GetProcessHeap(), 0, formatList);
367 RegCloseKey(hDocs);
368 hr = E_FAIL;
369 goto exit;
372 format->cfFormat = RegisterClipboardFormatA(szValueBuff);
373 format->ptd = NULL;
374 format->dwAspect = 1;
375 format->lindex = 4;
376 format->tymed = -1;
378 format++;
379 dwCount++;
383 RegCloseKey(hDocs);
385 /* Terminate the (maybe empty) list, last entry has a cfFormat of 0 */
386 format->cfFormat = 0;
387 format->ptd = NULL;
388 format->dwAspect = 1;
389 format->lindex = 4;
390 format->tymed = -1;
392 /* Create a clipboard enumerator */
393 hr = CreateFormatEnumerator(dwNumValues, formatList, &pIEnumFormatEtc);
394 HeapFree(GetProcessHeap(), 0, formatList);
395 if (FAILED(hr)) goto exit;
397 /* Set our enumerator as the browsers property */
398 V_VT(&var) = VT_UNKNOWN;
399 V_UNKNOWN(&var) = (IUnknown*)pIEnumFormatEtc;
401 property = SysAllocString(szProperty);
402 hr = IWebBrowserApp_PutProperty(pBrowser, property, var);
403 SysFreeString(property);
404 if (FAILED(hr))
406 IEnumFORMATETC_Release(pIEnumFormatEtc);
407 goto exit;
411 if (V_VT(&var) == VT_UNKNOWN)
413 /* Our variant is holding the clipboard enumerator */
414 IUnknown* pIUnknown = V_UNKNOWN(&var);
415 IEnumFORMATETC* pClone = NULL;
417 TRACE("Retrieved IEnumFORMATETC property\n");
419 /* Get an IEnumFormatEtc interface from the variants value */
420 pIEnumFormatEtc = NULL;
421 hr = IUnknown_QueryInterface(pIUnknown, &IID_IEnumFORMATETC, (void**)&pIEnumFormatEtc);
422 if (hr == S_OK && pIEnumFormatEtc)
424 /* Clone and register the enumerator */
425 hr = IEnumFORMATETC_Clone(pIEnumFormatEtc, &pClone);
426 if (hr == S_OK && pClone)
428 RegisterFormatEnumerator(lpBC, pClone, 0);
430 IEnumFORMATETC_Release(pClone);
433 IUnknown_Release(pIUnknown);
435 IUnknown_Release(V_UNKNOWN(&var));
438 exit:
439 IWebBrowserApp_Release(pBrowser);
440 return hr;
443 /*************************************************************************
444 * @ [SHLWAPI.15]
446 * Get Explorers "AcceptLanguage" setting.
448 * PARAMS
449 * langbuf [O] Destination for language string
450 * buflen [I] Length of langbuf in characters
451 * [0] Success: used length of langbuf
453 * RETURNS
454 * Success: S_OK. langbuf is set to the language string found.
455 * Failure: E_FAIL, If any arguments are invalid, error occurred, or Explorer
456 * does not contain the setting.
457 * E_NOT_SUFFICIENT_BUFFER, If the buffer is not big enough
459 HRESULT WINAPI GetAcceptLanguagesW( LPWSTR langbuf, LPDWORD buflen)
461 static const WCHAR szkeyW[] = {
462 'S','o','f','t','w','a','r','e','\\',
463 'M','i','c','r','o','s','o','f','t','\\',
464 'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
465 'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
466 static const WCHAR valueW[] = {
467 'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
468 DWORD mystrlen, mytype;
469 DWORD len;
470 HKEY mykey;
471 LCID mylcid;
472 WCHAR *mystr;
473 LONG lres;
475 TRACE("(%p, %p) *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
477 if(!langbuf || !buflen || !*buflen)
478 return E_FAIL;
480 mystrlen = (*buflen > 20) ? *buflen : 20 ;
481 len = mystrlen * sizeof(WCHAR);
482 mystr = HeapAlloc(GetProcessHeap(), 0, len);
483 mystr[0] = 0;
484 RegOpenKeyW(HKEY_CURRENT_USER, szkeyW, &mykey);
485 lres = RegQueryValueExW(mykey, valueW, 0, &mytype, (PBYTE)mystr, &len);
486 RegCloseKey(mykey);
487 len = lstrlenW(mystr);
489 if (!lres && (*buflen > len)) {
490 lstrcpyW(langbuf, mystr);
491 *buflen = len;
492 HeapFree(GetProcessHeap(), 0, mystr);
493 return S_OK;
496 /* Did not find a value in the registry or the user buffer is too small */
497 mylcid = GetUserDefaultLCID();
498 LcidToRfc1766W(mylcid, mystr, mystrlen);
499 len = lstrlenW(mystr);
501 memcpy( langbuf, mystr, min(*buflen, len+1)*sizeof(WCHAR) );
502 HeapFree(GetProcessHeap(), 0, mystr);
504 if (*buflen > len) {
505 *buflen = len;
506 return S_OK;
509 *buflen = 0;
510 return E_NOT_SUFFICIENT_BUFFER;
513 /*************************************************************************
514 * @ [SHLWAPI.14]
516 * Ascii version of GetAcceptLanguagesW.
518 HRESULT WINAPI GetAcceptLanguagesA( LPSTR langbuf, LPDWORD buflen)
520 WCHAR *langbufW;
521 DWORD buflenW, convlen;
522 HRESULT retval;
524 TRACE("(%p, %p) *%p: %d\n", langbuf, buflen, buflen, buflen ? *buflen : -1);
526 if(!langbuf || !buflen || !*buflen) return E_FAIL;
528 buflenW = *buflen;
529 langbufW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * buflenW);
530 retval = GetAcceptLanguagesW(langbufW, &buflenW);
532 if (retval == S_OK)
534 convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, -1, langbuf, *buflen, NULL, NULL);
535 convlen--; /* do not count the terminating 0 */
537 else /* copy partial string anyway */
539 convlen = WideCharToMultiByte(CP_ACP, 0, langbufW, *buflen, langbuf, *buflen, NULL, NULL);
540 if (convlen < *buflen)
542 langbuf[convlen] = 0;
543 convlen--; /* do not count the terminating 0 */
545 else
547 convlen = *buflen;
550 *buflen = buflenW ? convlen : 0;
552 HeapFree(GetProcessHeap(), 0, langbufW);
553 return retval;
556 /*************************************************************************
557 * @ [SHLWAPI.23]
559 * Convert a GUID to a string.
561 * PARAMS
562 * guid [I] GUID to convert
563 * lpszDest [O] Destination for string
564 * cchMax [I] Length of output buffer
566 * RETURNS
567 * The length of the string created.
569 INT WINAPI SHStringFromGUIDA(REFGUID guid, LPSTR lpszDest, INT cchMax)
571 char xguid[40];
572 INT iLen;
574 TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
576 sprintf(xguid, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
577 guid->Data1, guid->Data2, guid->Data3,
578 guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
579 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
581 iLen = strlen(xguid) + 1;
583 if (iLen > cchMax)
584 return 0;
585 memcpy(lpszDest, xguid, iLen);
586 return iLen;
589 /*************************************************************************
590 * @ [SHLWAPI.24]
592 * Convert a GUID to a string.
594 * PARAMS
595 * guid [I] GUID to convert
596 * str [O] Destination for string
597 * cmax [I] Length of output buffer
599 * RETURNS
600 * The length of the string created.
602 INT WINAPI SHStringFromGUIDW(REFGUID guid, LPWSTR lpszDest, INT cchMax)
604 WCHAR xguid[40];
605 INT iLen;
606 static const WCHAR wszFormat[] = {'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
607 '%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
608 'X','%','0','2','X','%','0','2','X','}',0};
610 TRACE("(%s,%p,%d)\n", debugstr_guid(guid), lpszDest, cchMax);
612 sprintfW(xguid, wszFormat, guid->Data1, guid->Data2, guid->Data3,
613 guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
614 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
616 iLen = strlenW(xguid) + 1;
618 if (iLen > cchMax)
619 return 0;
620 memcpy(lpszDest, xguid, iLen*sizeof(WCHAR));
621 return iLen;
624 /*************************************************************************
625 * @ [SHLWAPI.30]
627 * Determine if a Unicode character is a blank.
629 * PARAMS
630 * wc [I] Character to check.
632 * RETURNS
633 * TRUE, if wc is a blank,
634 * FALSE otherwise.
637 BOOL WINAPI IsCharBlankW(WCHAR wc)
639 WORD CharType;
641 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_BLANK);
644 /*************************************************************************
645 * @ [SHLWAPI.31]
647 * Determine if a Unicode character is punctuation.
649 * PARAMS
650 * wc [I] Character to check.
652 * RETURNS
653 * TRUE, if wc is punctuation,
654 * FALSE otherwise.
656 BOOL WINAPI IsCharPunctW(WCHAR wc)
658 WORD CharType;
660 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_PUNCT);
663 /*************************************************************************
664 * @ [SHLWAPI.32]
666 * Determine if a Unicode character is a control character.
668 * PARAMS
669 * wc [I] Character to check.
671 * RETURNS
672 * TRUE, if wc is a control character,
673 * FALSE otherwise.
675 BOOL WINAPI IsCharCntrlW(WCHAR wc)
677 WORD CharType;
679 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_CNTRL);
682 /*************************************************************************
683 * @ [SHLWAPI.33]
685 * Determine if a Unicode character is a digit.
687 * PARAMS
688 * wc [I] Character to check.
690 * RETURNS
691 * TRUE, if wc is a digit,
692 * FALSE otherwise.
694 BOOL WINAPI IsCharDigitW(WCHAR wc)
696 WORD CharType;
698 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_DIGIT);
701 /*************************************************************************
702 * @ [SHLWAPI.34]
704 * Determine if a Unicode character is a hex digit.
706 * PARAMS
707 * wc [I] Character to check.
709 * RETURNS
710 * TRUE, if wc is a hex digit,
711 * FALSE otherwise.
713 BOOL WINAPI IsCharXDigitW(WCHAR wc)
715 WORD CharType;
717 return GetStringTypeW(CT_CTYPE1, &wc, 1, &CharType) && (CharType & C1_XDIGIT);
720 /*************************************************************************
721 * @ [SHLWAPI.35]
724 BOOL WINAPI GetStringType3ExW(LPWSTR src, INT count, LPWORD type)
726 return GetStringTypeW(CT_CTYPE3, src, count, type);
729 /*************************************************************************
730 * @ [SHLWAPI.151]
732 * Compare two Ascii strings up to a given length.
734 * PARAMS
735 * lpszSrc [I] Source string
736 * lpszCmp [I] String to compare to lpszSrc
737 * len [I] Maximum length
739 * RETURNS
740 * A number greater than, less than or equal to 0 depending on whether
741 * lpszSrc is greater than, less than or equal to lpszCmp.
743 DWORD WINAPI StrCmpNCA(LPCSTR lpszSrc, LPCSTR lpszCmp, INT len)
745 return StrCmpNA(lpszSrc, lpszCmp, len);
748 /*************************************************************************
749 * @ [SHLWAPI.152]
751 * Unicode version of StrCmpNCA.
753 DWORD WINAPI StrCmpNCW(LPCWSTR lpszSrc, LPCWSTR lpszCmp, INT len)
755 return StrCmpNW(lpszSrc, lpszCmp, len);
758 /*************************************************************************
759 * @ [SHLWAPI.153]
761 * Compare two Ascii strings up to a given length, ignoring case.
763 * PARAMS
764 * lpszSrc [I] Source string
765 * lpszCmp [I] String to compare to lpszSrc
766 * len [I] Maximum length
768 * RETURNS
769 * A number greater than, less than or equal to 0 depending on whether
770 * lpszSrc is greater than, less than or equal to lpszCmp.
772 DWORD WINAPI StrCmpNICA(LPCSTR lpszSrc, LPCSTR lpszCmp, DWORD len)
774 return StrCmpNIA(lpszSrc, lpszCmp, len);
777 /*************************************************************************
778 * @ [SHLWAPI.154]
780 * Unicode version of StrCmpNICA.
782 DWORD WINAPI StrCmpNICW(LPCWSTR lpszSrc, LPCWSTR lpszCmp, DWORD len)
784 return StrCmpNIW(lpszSrc, lpszCmp, len);
787 /*************************************************************************
788 * @ [SHLWAPI.155]
790 * Compare two Ascii strings.
792 * PARAMS
793 * lpszSrc [I] Source string
794 * lpszCmp [I] String to compare to lpszSrc
796 * RETURNS
797 * A number greater than, less than or equal to 0 depending on whether
798 * lpszSrc is greater than, less than or equal to lpszCmp.
800 DWORD WINAPI StrCmpCA(LPCSTR lpszSrc, LPCSTR lpszCmp)
802 return lstrcmpA(lpszSrc, lpszCmp);
805 /*************************************************************************
806 * @ [SHLWAPI.156]
808 * Unicode version of StrCmpCA.
810 DWORD WINAPI StrCmpCW(LPCWSTR lpszSrc, LPCWSTR lpszCmp)
812 return lstrcmpW(lpszSrc, lpszCmp);
815 /*************************************************************************
816 * @ [SHLWAPI.157]
818 * Compare two Ascii strings, ignoring case.
820 * PARAMS
821 * lpszSrc [I] Source string
822 * lpszCmp [I] String to compare to lpszSrc
824 * RETURNS
825 * A number greater than, less than or equal to 0 depending on whether
826 * lpszSrc is greater than, less than or equal to lpszCmp.
828 DWORD WINAPI StrCmpICA(LPCSTR lpszSrc, LPCSTR lpszCmp)
830 return lstrcmpiA(lpszSrc, lpszCmp);
833 /*************************************************************************
834 * @ [SHLWAPI.158]
836 * Unicode version of StrCmpICA.
838 DWORD WINAPI StrCmpICW(LPCWSTR lpszSrc, LPCWSTR lpszCmp)
840 return lstrcmpiW(lpszSrc, lpszCmp);
843 /*************************************************************************
844 * @ [SHLWAPI.160]
846 * Get an identification string for the OS and explorer.
848 * PARAMS
849 * lpszDest [O] Destination for Id string
850 * dwDestLen [I] Length of lpszDest
852 * RETURNS
853 * TRUE, If the string was created successfully
854 * FALSE, Otherwise
856 BOOL WINAPI SHAboutInfoA(LPSTR lpszDest, DWORD dwDestLen)
858 WCHAR buff[2084];
860 TRACE("(%p,%d)\n", lpszDest, dwDestLen);
862 if (lpszDest && SHAboutInfoW(buff, dwDestLen))
864 WideCharToMultiByte(CP_ACP, 0, buff, -1, lpszDest, dwDestLen, NULL, NULL);
865 return TRUE;
867 return FALSE;
870 /*************************************************************************
871 * @ [SHLWAPI.161]
873 * Unicode version of SHAboutInfoA.
875 BOOL WINAPI SHAboutInfoW(LPWSTR lpszDest, DWORD dwDestLen)
877 static const WCHAR szIEKey[] = { 'S','O','F','T','W','A','R','E','\\',
878 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
879 ' ','E','x','p','l','o','r','e','r','\0' };
880 static const WCHAR szWinNtKey[] = { 'S','O','F','T','W','A','R','E','\\',
881 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ',
882 'N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
883 static const WCHAR szWinKey[] = { 'S','O','F','T','W','A','R','E','\\',
884 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
885 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
886 static const WCHAR szRegKey[] = { 'S','O','F','T','W','A','R','E','\\',
887 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
888 ' ','E','x','p','l','o','r','e','r','\\',
889 'R','e','g','i','s','t','r','a','t','i','o','n','\0' };
890 static const WCHAR szVersion[] = { 'V','e','r','s','i','o','n','\0' };
891 static const WCHAR szCustomized[] = { 'C','u','s','t','o','m','i','z','e','d',
892 'V','e','r','s','i','o','n','\0' };
893 static const WCHAR szOwner[] = { 'R','e','g','i','s','t','e','r','e','d',
894 'O','w','n','e','r','\0' };
895 static const WCHAR szOrg[] = { 'R','e','g','i','s','t','e','r','e','d',
896 'O','r','g','a','n','i','z','a','t','i','o','n','\0' };
897 static const WCHAR szProduct[] = { 'P','r','o','d','u','c','t','I','d','\0' };
898 static const WCHAR szUpdate[] = { 'I','E','A','K',
899 'U','p','d','a','t','e','U','r','l','\0' };
900 static const WCHAR szHelp[] = { 'I','E','A','K',
901 'H','e','l','p','S','t','r','i','n','g','\0' };
902 WCHAR buff[2084];
903 HKEY hReg;
904 DWORD dwType, dwLen;
906 TRACE("(%p,%d)\n", lpszDest, dwDestLen);
908 if (!lpszDest)
909 return FALSE;
911 *lpszDest = '\0';
913 /* Try the NT key first, followed by 95/98 key */
914 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinNtKey, 0, KEY_READ, &hReg) &&
915 RegOpenKeyExW(HKEY_LOCAL_MACHINE, szWinKey, 0, KEY_READ, &hReg))
916 return FALSE;
918 /* OS Version */
919 buff[0] = '\0';
920 dwLen = 30;
921 if (!SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey, szVersion, &dwType, buff, &dwLen))
923 DWORD dwStrLen = strlenW(buff);
924 dwLen = 30 - dwStrLen;
925 SHGetValueW(HKEY_LOCAL_MACHINE, szIEKey,
926 szCustomized, &dwType, buff+dwStrLen, &dwLen);
928 StrCatBuffW(lpszDest, buff, dwDestLen);
930 /* ~Registered Owner */
931 buff[0] = '~';
932 dwLen = 256;
933 if (SHGetValueW(hReg, szOwner, 0, &dwType, buff+1, &dwLen))
934 buff[1] = '\0';
935 StrCatBuffW(lpszDest, buff, dwDestLen);
937 /* ~Registered Organization */
938 dwLen = 256;
939 if (SHGetValueW(hReg, szOrg, 0, &dwType, buff+1, &dwLen))
940 buff[1] = '\0';
941 StrCatBuffW(lpszDest, buff, dwDestLen);
943 /* FIXME: Not sure where this number comes from */
944 buff[0] = '~';
945 buff[1] = '0';
946 buff[2] = '\0';
947 StrCatBuffW(lpszDest, buff, dwDestLen);
949 /* ~Product Id */
950 dwLen = 256;
951 if (SHGetValueW(HKEY_LOCAL_MACHINE, szRegKey, szProduct, &dwType, buff+1, &dwLen))
952 buff[1] = '\0';
953 StrCatBuffW(lpszDest, buff, dwDestLen);
955 /* ~IE Update Url */
956 dwLen = 2048;
957 if(SHGetValueW(HKEY_LOCAL_MACHINE, szWinKey, szUpdate, &dwType, buff+1, &dwLen))
958 buff[1] = '\0';
959 StrCatBuffW(lpszDest, buff, dwDestLen);
961 /* ~IE Help String */
962 dwLen = 256;
963 if(SHGetValueW(hReg, szHelp, 0, &dwType, buff+1, &dwLen))
964 buff[1] = '\0';
965 StrCatBuffW(lpszDest, buff, dwDestLen);
967 RegCloseKey(hReg);
968 return TRUE;
971 /*************************************************************************
972 * @ [SHLWAPI.163]
974 * Call IOleCommandTarget_QueryStatus() on an object.
976 * PARAMS
977 * lpUnknown [I] Object supporting the IOleCommandTarget interface
978 * pguidCmdGroup [I] GUID for the command group
979 * cCmds [I]
980 * prgCmds [O] Commands
981 * pCmdText [O] Command text
983 * RETURNS
984 * Success: S_OK.
985 * Failure: E_FAIL, if lpUnknown is NULL.
986 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
987 * Otherwise, an error code from IOleCommandTarget_QueryStatus().
989 HRESULT WINAPI IUnknown_QueryStatus(IUnknown* lpUnknown, REFGUID pguidCmdGroup,
990 ULONG cCmds, OLECMD *prgCmds, OLECMDTEXT* pCmdText)
992 HRESULT hRet = E_FAIL;
994 TRACE("(%p,%p,%d,%p,%p)\n",lpUnknown, pguidCmdGroup, cCmds, prgCmds, pCmdText);
996 if (lpUnknown)
998 IOleCommandTarget* lpOle;
1000 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleCommandTarget,
1001 (void**)&lpOle);
1003 if (SUCCEEDED(hRet) && lpOle)
1005 hRet = IOleCommandTarget_QueryStatus(lpOle, pguidCmdGroup, cCmds,
1006 prgCmds, pCmdText);
1007 IOleCommandTarget_Release(lpOle);
1010 return hRet;
1013 /*************************************************************************
1014 * @ [SHLWAPI.164]
1016 * Call IOleCommandTarget_Exec() on an object.
1018 * PARAMS
1019 * lpUnknown [I] Object supporting the IOleCommandTarget interface
1020 * pguidCmdGroup [I] GUID for the command group
1022 * RETURNS
1023 * Success: S_OK.
1024 * Failure: E_FAIL, if lpUnknown is NULL.
1025 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
1026 * Otherwise, an error code from IOleCommandTarget_Exec().
1028 HRESULT WINAPI IUnknown_Exec(IUnknown* lpUnknown, REFGUID pguidCmdGroup,
1029 DWORD nCmdID, DWORD nCmdexecopt, VARIANT* pvaIn,
1030 VARIANT* pvaOut)
1032 HRESULT hRet = E_FAIL;
1034 TRACE("(%p,%p,%d,%d,%p,%p)\n",lpUnknown, pguidCmdGroup, nCmdID,
1035 nCmdexecopt, pvaIn, pvaOut);
1037 if (lpUnknown)
1039 IOleCommandTarget* lpOle;
1041 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleCommandTarget,
1042 (void**)&lpOle);
1043 if (SUCCEEDED(hRet) && lpOle)
1045 hRet = IOleCommandTarget_Exec(lpOle, pguidCmdGroup, nCmdID,
1046 nCmdexecopt, pvaIn, pvaOut);
1047 IOleCommandTarget_Release(lpOle);
1050 return hRet;
1053 /*************************************************************************
1054 * @ [SHLWAPI.165]
1056 * Retrieve, modify, and re-set a value from a window.
1058 * PARAMS
1059 * hWnd [I] Window to get value from
1060 * offset [I] Offset of value
1061 * mask [I] Mask for flags
1062 * flags [I] Bits to set in window value
1064 * RETURNS
1065 * The new value as it was set, or 0 if any parameter is invalid.
1067 * NOTES
1068 * Only bits specified in mask are affected - set if present in flags and
1069 * reset otherwise.
1071 LONG WINAPI SHSetWindowBits(HWND hwnd, INT offset, UINT mask, UINT flags)
1073 LONG ret = GetWindowLongW(hwnd, offset);
1074 LONG new_flags = (flags & mask) | (ret & ~mask);
1076 TRACE("%p %d %x %x\n", hwnd, offset, mask, flags);
1078 if (new_flags != ret)
1079 ret = SetWindowLongW(hwnd, offset, new_flags);
1080 return ret;
1083 /*************************************************************************
1084 * @ [SHLWAPI.167]
1086 * Change a window's parent.
1088 * PARAMS
1089 * hWnd [I] Window to change parent of
1090 * hWndParent [I] New parent window
1092 * RETURNS
1093 * The old parent of hWnd.
1095 * NOTES
1096 * If hWndParent is NULL (desktop), the window style is changed to WS_POPUP.
1097 * If hWndParent is NOT NULL then we set the WS_CHILD style.
1099 HWND WINAPI SHSetParentHwnd(HWND hWnd, HWND hWndParent)
1101 TRACE("%p, %p\n", hWnd, hWndParent);
1103 if(GetParent(hWnd) == hWndParent)
1104 return NULL;
1106 if(hWndParent)
1107 SHSetWindowBits(hWnd, GWL_STYLE, WS_CHILD | WS_POPUP, WS_CHILD);
1108 else
1109 SHSetWindowBits(hWnd, GWL_STYLE, WS_CHILD | WS_POPUP, WS_POPUP);
1111 return hWndParent ? SetParent(hWnd, hWndParent) : NULL;
1114 /*************************************************************************
1115 * @ [SHLWAPI.168]
1117 * Locate and advise a connection point in an IConnectionPointContainer object.
1119 * PARAMS
1120 * lpUnkSink [I] Sink for the connection point advise call
1121 * riid [I] REFIID of connection point to advise
1122 * fConnect [I] TRUE = Connection being establisted, FALSE = broken
1123 * lpUnknown [I] Object supporting the IConnectionPointContainer interface
1124 * lpCookie [O] Pointer to connection point cookie
1125 * lppCP [O] Destination for the IConnectionPoint found
1127 * RETURNS
1128 * Success: S_OK. If lppCP is non-NULL, it is filled with the IConnectionPoint
1129 * that was advised. The caller is responsible for releasing it.
1130 * Failure: E_FAIL, if any arguments are invalid.
1131 * E_NOINTERFACE, if lpUnknown isn't an IConnectionPointContainer,
1132 * Or an HRESULT error code if any call fails.
1134 HRESULT WINAPI ConnectToConnectionPoint(IUnknown* lpUnkSink, REFIID riid, BOOL fConnect,
1135 IUnknown* lpUnknown, LPDWORD lpCookie,
1136 IConnectionPoint **lppCP)
1138 HRESULT hRet;
1139 IConnectionPointContainer* lpContainer;
1140 IConnectionPoint *lpCP;
1142 if(!lpUnknown || (fConnect && !lpUnkSink))
1143 return E_FAIL;
1145 if(lppCP)
1146 *lppCP = NULL;
1148 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer,
1149 (void**)&lpContainer);
1150 if (SUCCEEDED(hRet))
1152 hRet = IConnectionPointContainer_FindConnectionPoint(lpContainer, riid, &lpCP);
1154 if (SUCCEEDED(hRet))
1156 if(!fConnect)
1157 hRet = IConnectionPoint_Unadvise(lpCP, *lpCookie);
1158 else
1159 hRet = IConnectionPoint_Advise(lpCP, lpUnkSink, lpCookie);
1161 if (FAILED(hRet))
1162 *lpCookie = 0;
1164 if (lppCP && SUCCEEDED(hRet))
1165 *lppCP = lpCP; /* Caller keeps the interface */
1166 else
1167 IConnectionPoint_Release(lpCP); /* Release it */
1170 IConnectionPointContainer_Release(lpContainer);
1172 return hRet;
1175 /*************************************************************************
1176 * @ [SHLWAPI.169]
1178 * Release an interface and zero a supplied pointer.
1180 * PARAMS
1181 * lpUnknown [I] Object to release
1183 * RETURNS
1184 * Nothing.
1186 void WINAPI IUnknown_AtomicRelease(IUnknown ** lpUnknown)
1188 TRACE("(%p)\n", lpUnknown);
1190 if(!lpUnknown || !*lpUnknown) return;
1192 TRACE("doing Release\n");
1194 IUnknown_Release(*lpUnknown);
1195 *lpUnknown = NULL;
1198 /*************************************************************************
1199 * @ [SHLWAPI.170]
1201 * Skip '//' if present in a string.
1203 * PARAMS
1204 * lpszSrc [I] String to check for '//'
1206 * RETURNS
1207 * Success: The next character after the '//' or the string if not present
1208 * Failure: NULL, if lpszStr is NULL.
1210 LPCSTR WINAPI PathSkipLeadingSlashesA(LPCSTR lpszSrc)
1212 if (lpszSrc && lpszSrc[0] == '/' && lpszSrc[1] == '/')
1213 lpszSrc += 2;
1214 return lpszSrc;
1217 /*************************************************************************
1218 * @ [SHLWAPI.171]
1220 * Check if two interfaces come from the same object.
1222 * PARAMS
1223 * lpInt1 [I] Interface to check against lpInt2.
1224 * lpInt2 [I] Interface to check against lpInt1.
1226 * RETURNS
1227 * TRUE, If the interfaces come from the same object.
1228 * FALSE Otherwise.
1230 BOOL WINAPI SHIsSameObject(IUnknown* lpInt1, IUnknown* lpInt2)
1232 IUnknown *lpUnknown1, *lpUnknown2;
1233 BOOL ret;
1235 TRACE("(%p %p)\n", lpInt1, lpInt2);
1237 if (!lpInt1 || !lpInt2)
1238 return FALSE;
1240 if (lpInt1 == lpInt2)
1241 return TRUE;
1243 if (IUnknown_QueryInterface(lpInt1, &IID_IUnknown, (void**)&lpUnknown1) != S_OK)
1244 return FALSE;
1246 if (IUnknown_QueryInterface(lpInt2, &IID_IUnknown, (void**)&lpUnknown2) != S_OK)
1248 IUnknown_Release(lpUnknown1);
1249 return FALSE;
1252 ret = lpUnknown1 == lpUnknown2;
1254 IUnknown_Release(lpUnknown1);
1255 IUnknown_Release(lpUnknown2);
1257 return ret;
1260 /*************************************************************************
1261 * @ [SHLWAPI.172]
1263 * Get the window handle of an object.
1265 * PARAMS
1266 * lpUnknown [I] Object to get the window handle of
1267 * lphWnd [O] Destination for window handle
1269 * RETURNS
1270 * Success: S_OK. lphWnd contains the objects window handle.
1271 * Failure: An HRESULT error code.
1273 * NOTES
1274 * lpUnknown is expected to support one of the following interfaces:
1275 * IOleWindow(), IInternetSecurityMgrSite(), or IShellView().
1277 HRESULT WINAPI IUnknown_GetWindow(IUnknown *lpUnknown, HWND *lphWnd)
1279 IUnknown *lpOle;
1280 HRESULT hRet = E_FAIL;
1282 TRACE("(%p,%p)\n", lpUnknown, lphWnd);
1284 if (!lpUnknown)
1285 return hRet;
1287 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleWindow, (void**)&lpOle);
1289 if (FAILED(hRet))
1291 hRet = IUnknown_QueryInterface(lpUnknown,&IID_IShellView, (void**)&lpOle);
1293 if (FAILED(hRet))
1295 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInternetSecurityMgrSite,
1296 (void**)&lpOle);
1300 if (SUCCEEDED(hRet))
1302 /* Laziness here - Since GetWindow() is the first method for the above 3
1303 * interfaces, we use the same call for them all.
1305 hRet = IOleWindow_GetWindow((IOleWindow*)lpOle, lphWnd);
1306 IUnknown_Release(lpOle);
1307 if (lphWnd)
1308 TRACE("Returning HWND=%p\n", *lphWnd);
1311 return hRet;
1314 /*************************************************************************
1315 * @ [SHLWAPI.173]
1317 * Call a SetOwner method of IShellService from specified object.
1319 * PARAMS
1320 * iface [I] Object that supports IShellService
1321 * pUnk [I] Argument for the SetOwner call
1323 * RETURNS
1324 * Corresponding return value from last call or E_FAIL for null input
1326 HRESULT WINAPI IUnknown_SetOwner(IUnknown *iface, IUnknown *pUnk)
1328 IShellService *service;
1329 HRESULT hr;
1331 TRACE("(%p, %p)\n", iface, pUnk);
1333 if (!iface) return E_FAIL;
1335 hr = IUnknown_QueryInterface(iface, &IID_IShellService, (void**)&service);
1336 if (hr == S_OK)
1338 hr = IShellService_SetOwner(service, pUnk);
1339 IShellService_Release(service);
1342 return hr;
1345 /*************************************************************************
1346 * @ [SHLWAPI.174]
1348 * Call either IObjectWithSite_SetSite() or IInternetSecurityManager_SetSecuritySite() on
1349 * an object.
1352 HRESULT WINAPI IUnknown_SetSite(
1353 IUnknown *obj, /* [in] OLE object */
1354 IUnknown *site) /* [in] Site interface */
1356 HRESULT hr;
1357 IObjectWithSite *iobjwithsite;
1358 IInternetSecurityManager *isecmgr;
1360 if (!obj) return E_FAIL;
1362 hr = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (LPVOID *)&iobjwithsite);
1363 TRACE("IID_IObjectWithSite QI ret=%08x, %p\n", hr, iobjwithsite);
1364 if (SUCCEEDED(hr))
1366 hr = IObjectWithSite_SetSite(iobjwithsite, site);
1367 TRACE("done IObjectWithSite_SetSite ret=%08x\n", hr);
1368 IObjectWithSite_Release(iobjwithsite);
1370 else
1372 hr = IUnknown_QueryInterface(obj, &IID_IInternetSecurityManager, (LPVOID *)&isecmgr);
1373 TRACE("IID_IInternetSecurityManager QI ret=%08x, %p\n", hr, isecmgr);
1374 if (FAILED(hr)) return hr;
1376 hr = IInternetSecurityManager_SetSecuritySite(isecmgr, (IInternetSecurityMgrSite *)site);
1377 TRACE("done IInternetSecurityManager_SetSecuritySite ret=%08x\n", hr);
1378 IInternetSecurityManager_Release(isecmgr);
1380 return hr;
1383 /*************************************************************************
1384 * @ [SHLWAPI.175]
1386 * Call IPersist_GetClassID() on an object.
1388 * PARAMS
1389 * lpUnknown [I] Object supporting the IPersist interface
1390 * clsid [O] Destination for Class Id
1392 * RETURNS
1393 * Success: S_OK. lpClassId contains the Class Id requested.
1394 * Failure: E_FAIL, If lpUnknown is NULL,
1395 * E_NOINTERFACE If lpUnknown does not support IPersist,
1396 * Or an HRESULT error code.
1398 HRESULT WINAPI IUnknown_GetClassID(IUnknown *lpUnknown, CLSID *clsid)
1400 IPersist *persist;
1401 HRESULT hr;
1403 TRACE("(%p, %p)\n", lpUnknown, clsid);
1405 if (!lpUnknown)
1407 memset(clsid, 0, sizeof(*clsid));
1408 return E_FAIL;
1411 hr = IUnknown_QueryInterface(lpUnknown, &IID_IPersist, (void**)&persist);
1412 if (hr != S_OK)
1414 hr = IUnknown_QueryInterface(lpUnknown, &IID_IPersistFolder, (void**)&persist);
1415 if (hr != S_OK)
1416 return hr;
1419 hr = IPersist_GetClassID(persist, clsid);
1420 IPersist_Release(persist);
1421 return hr;
1424 /*************************************************************************
1425 * @ [SHLWAPI.176]
1427 * Retrieve a Service Interface from an object.
1429 * PARAMS
1430 * lpUnknown [I] Object to get an IServiceProvider interface from
1431 * sid [I] Service ID for IServiceProvider_QueryService() call
1432 * riid [I] Function requested for QueryService call
1433 * lppOut [O] Destination for the service interface pointer
1435 * RETURNS
1436 * Success: S_OK. lppOut contains an object providing the requested service
1437 * Failure: An HRESULT error code
1439 * NOTES
1440 * lpUnknown is expected to support the IServiceProvider interface.
1442 HRESULT WINAPI IUnknown_QueryService(IUnknown* lpUnknown, REFGUID sid, REFIID riid,
1443 LPVOID *lppOut)
1445 IServiceProvider* pService = NULL;
1446 HRESULT hRet;
1448 if (!lppOut)
1449 return E_FAIL;
1451 *lppOut = NULL;
1453 if (!lpUnknown)
1454 return E_FAIL;
1456 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IServiceProvider,
1457 (LPVOID*)&pService);
1459 if (hRet == S_OK && pService)
1461 TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService);
1463 /* Get a Service interface from the object */
1464 hRet = IServiceProvider_QueryService(pService, sid, riid, lppOut);
1466 TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService, *lppOut);
1468 IServiceProvider_Release(pService);
1470 return hRet;
1473 /*************************************************************************
1474 * @ [SHLWAPI.484]
1476 * Calls IOleCommandTarget::Exec() for specified service object.
1478 * PARAMS
1479 * lpUnknown [I] Object to get an IServiceProvider interface from
1480 * service [I] Service ID for IServiceProvider_QueryService() call
1481 * group [I] Group ID for IOleCommandTarget::Exec() call
1482 * cmdId [I] Command ID for IOleCommandTarget::Exec() call
1483 * cmdOpt [I] Options flags for command
1484 * pIn [I] Input arguments for command
1485 * pOut [O] Output arguments for command
1487 * RETURNS
1488 * Success: S_OK. lppOut contains an object providing the requested service
1489 * Failure: An HRESULT error code
1491 * NOTES
1492 * lpUnknown is expected to support the IServiceProvider interface.
1494 HRESULT WINAPI IUnknown_QueryServiceExec(IUnknown *lpUnknown, REFIID service,
1495 const GUID *group, DWORD cmdId, DWORD cmdOpt, VARIANT *pIn, VARIANT *pOut)
1497 IOleCommandTarget *target;
1498 HRESULT hr;
1500 TRACE("%p %s %s %d %08x %p %p\n", lpUnknown, debugstr_guid(service),
1501 debugstr_guid(group), cmdId, cmdOpt, pIn, pOut);
1503 hr = IUnknown_QueryService(lpUnknown, service, &IID_IOleCommandTarget, (void**)&target);
1504 if (hr == S_OK)
1506 hr = IOleCommandTarget_Exec(target, group, cmdId, cmdOpt, pIn, pOut);
1507 IOleCommandTarget_Release(target);
1510 TRACE("<-- hr=0x%08x\n", hr);
1512 return hr;
1515 /*************************************************************************
1516 * @ [SHLWAPI.514]
1518 * Calls IProfferService methods to proffer/revoke specified service.
1520 * PARAMS
1521 * lpUnknown [I] Object to get an IServiceProvider interface from
1522 * service [I] Service ID for IProfferService::Proffer/Revoke calls
1523 * pService [I] Service to proffer. If NULL ::Revoke is called
1524 * pCookie [IO] Group ID for IOleCommandTarget::Exec() call
1526 * RETURNS
1527 * Success: S_OK. IProffer method returns S_OK
1528 * Failure: An HRESULT error code
1530 * NOTES
1531 * lpUnknown is expected to support the IServiceProvider interface.
1533 HRESULT WINAPI IUnknown_ProfferService(IUnknown *lpUnknown, REFGUID service, IServiceProvider *pService, DWORD *pCookie)
1535 IProfferService *proffer;
1536 HRESULT hr;
1538 TRACE("%p %s %p %p\n", lpUnknown, debugstr_guid(service), pService, pCookie);
1540 hr = IUnknown_QueryService(lpUnknown, &IID_IProfferService, &IID_IProfferService, (void**)&proffer);
1541 if (hr == S_OK)
1543 if (pService)
1544 hr = IProfferService_ProfferService(proffer, service, pService, pCookie);
1545 else
1547 hr = IProfferService_RevokeService(proffer, *pCookie);
1548 *pCookie = 0;
1551 IProfferService_Release(proffer);
1554 return hr;
1557 /*************************************************************************
1558 * @ [SHLWAPI.479]
1560 * Call an object's UIActivateIO method.
1562 * PARAMS
1563 * unknown [I] Object to call the UIActivateIO method on
1564 * activate [I] Parameter for UIActivateIO call
1565 * msg [I] Parameter for UIActivateIO call
1567 * RETURNS
1568 * Success: Value of UI_ActivateIO call
1569 * Failure: An HRESULT error code
1571 * NOTES
1572 * unknown is expected to support the IInputObject interface.
1574 HRESULT WINAPI IUnknown_UIActivateIO(IUnknown *unknown, BOOL activate, LPMSG msg)
1576 IInputObject* object = NULL;
1577 HRESULT ret;
1579 if (!unknown)
1580 return E_FAIL;
1582 /* Get an IInputObject interface from the object */
1583 ret = IUnknown_QueryInterface(unknown, &IID_IInputObject, (LPVOID*) &object);
1585 if (ret == S_OK)
1587 ret = IInputObject_UIActivateIO(object, activate, msg);
1588 IInputObject_Release(object);
1591 return ret;
1594 /*************************************************************************
1595 * @ [SHLWAPI.177]
1597 * Loads a popup menu.
1599 * PARAMS
1600 * hInst [I] Instance handle
1601 * szName [I] Menu name
1603 * RETURNS
1604 * Success: TRUE.
1605 * Failure: FALSE.
1607 BOOL WINAPI SHLoadMenuPopup(HINSTANCE hInst, LPCWSTR szName)
1609 HMENU hMenu;
1611 TRACE("%p %s\n", hInst, debugstr_w(szName));
1613 if ((hMenu = LoadMenuW(hInst, szName)))
1615 if (GetSubMenu(hMenu, 0))
1616 RemoveMenu(hMenu, 0, MF_BYPOSITION);
1618 DestroyMenu(hMenu);
1619 return TRUE;
1621 return FALSE;
1624 typedef struct _enumWndData
1626 UINT uiMsgId;
1627 WPARAM wParam;
1628 LPARAM lParam;
1629 LRESULT (WINAPI *pfnPost)(HWND,UINT,WPARAM,LPARAM);
1630 } enumWndData;
1632 /* Callback for SHLWAPI_178 */
1633 static BOOL CALLBACK SHLWAPI_EnumChildProc(HWND hWnd, LPARAM lParam)
1635 enumWndData *data = (enumWndData *)lParam;
1637 TRACE("(%p,%p)\n", hWnd, data);
1638 data->pfnPost(hWnd, data->uiMsgId, data->wParam, data->lParam);
1639 return TRUE;
1642 /*************************************************************************
1643 * @ [SHLWAPI.178]
1645 * Send or post a message to every child of a window.
1647 * PARAMS
1648 * hWnd [I] Window whose children will get the messages
1649 * uiMsgId [I] Message Id
1650 * wParam [I] WPARAM of message
1651 * lParam [I] LPARAM of message
1652 * bSend [I] TRUE = Use SendMessageA(), FALSE = Use PostMessageA()
1654 * RETURNS
1655 * Nothing.
1657 * NOTES
1658 * The appropriate ASCII or Unicode function is called for the window.
1660 void WINAPI SHPropagateMessage(HWND hWnd, UINT uiMsgId, WPARAM wParam, LPARAM lParam, BOOL bSend)
1662 enumWndData data;
1664 TRACE("(%p,%u,%ld,%ld,%d)\n", hWnd, uiMsgId, wParam, lParam, bSend);
1666 if(hWnd)
1668 data.uiMsgId = uiMsgId;
1669 data.wParam = wParam;
1670 data.lParam = lParam;
1672 if (bSend)
1673 data.pfnPost = IsWindowUnicode(hWnd) ? (void*)SendMessageW : (void*)SendMessageA;
1674 else
1675 data.pfnPost = IsWindowUnicode(hWnd) ? (void*)PostMessageW : (void*)PostMessageA;
1677 EnumChildWindows(hWnd, SHLWAPI_EnumChildProc, (LPARAM)&data);
1681 /*************************************************************************
1682 * @ [SHLWAPI.180]
1684 * Remove all sub-menus from a menu.
1686 * PARAMS
1687 * hMenu [I] Menu to remove sub-menus from
1689 * RETURNS
1690 * Success: 0. All sub-menus under hMenu are removed
1691 * Failure: -1, if any parameter is invalid
1693 DWORD WINAPI SHRemoveAllSubMenus(HMENU hMenu)
1695 int iItemCount = GetMenuItemCount(hMenu) - 1;
1697 TRACE("%p\n", hMenu);
1699 while (iItemCount >= 0)
1701 HMENU hSubMenu = GetSubMenu(hMenu, iItemCount);
1702 if (hSubMenu)
1703 RemoveMenu(hMenu, iItemCount, MF_BYPOSITION);
1704 iItemCount--;
1706 return iItemCount;
1709 /*************************************************************************
1710 * @ [SHLWAPI.181]
1712 * Enable or disable a menu item.
1714 * PARAMS
1715 * hMenu [I] Menu holding menu item
1716 * uID [I] ID of menu item to enable/disable
1717 * bEnable [I] Whether to enable (TRUE) or disable (FALSE) the item.
1719 * RETURNS
1720 * The return code from EnableMenuItem.
1722 UINT WINAPI SHEnableMenuItem(HMENU hMenu, UINT wItemID, BOOL bEnable)
1724 TRACE("%p, %u, %d\n", hMenu, wItemID, bEnable);
1725 return EnableMenuItem(hMenu, wItemID, bEnable ? MF_ENABLED : MF_GRAYED);
1728 /*************************************************************************
1729 * @ [SHLWAPI.182]
1731 * Check or uncheck a menu item.
1733 * PARAMS
1734 * hMenu [I] Menu holding menu item
1735 * uID [I] ID of menu item to check/uncheck
1736 * bCheck [I] Whether to check (TRUE) or uncheck (FALSE) the item.
1738 * RETURNS
1739 * The return code from CheckMenuItem.
1741 DWORD WINAPI SHCheckMenuItem(HMENU hMenu, UINT uID, BOOL bCheck)
1743 TRACE("%p, %u, %d\n", hMenu, uID, bCheck);
1744 return CheckMenuItem(hMenu, uID, bCheck ? MF_CHECKED : MF_UNCHECKED);
1747 /*************************************************************************
1748 * @ [SHLWAPI.183]
1750 * Register a window class if it isn't already.
1752 * PARAMS
1753 * lpWndClass [I] Window class to register
1755 * RETURNS
1756 * The result of the RegisterClassA call.
1758 DWORD WINAPI SHRegisterClassA(WNDCLASSA *wndclass)
1760 WNDCLASSA wca;
1761 if (GetClassInfoA(wndclass->hInstance, wndclass->lpszClassName, &wca))
1762 return TRUE;
1763 return (DWORD)RegisterClassA(wndclass);
1766 /*************************************************************************
1767 * @ [SHLWAPI.186]
1769 BOOL WINAPI SHSimulateDrop(IDropTarget *pDrop, IDataObject *pDataObj,
1770 DWORD grfKeyState, PPOINTL lpPt, DWORD* pdwEffect)
1772 DWORD dwEffect = DROPEFFECT_LINK | DROPEFFECT_MOVE | DROPEFFECT_COPY;
1773 POINTL pt = { 0, 0 };
1775 TRACE("%p %p 0x%08x %p %p\n", pDrop, pDataObj, grfKeyState, lpPt, pdwEffect);
1777 if (!lpPt)
1778 lpPt = &pt;
1780 if (!pdwEffect)
1781 pdwEffect = &dwEffect;
1783 IDropTarget_DragEnter(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1785 if (*pdwEffect != DROPEFFECT_NONE)
1786 return IDropTarget_Drop(pDrop, pDataObj, grfKeyState, *lpPt, pdwEffect);
1788 IDropTarget_DragLeave(pDrop);
1789 return TRUE;
1792 /*************************************************************************
1793 * @ [SHLWAPI.187]
1795 * Call IPersistPropertyBag_Load() on an object.
1797 * PARAMS
1798 * lpUnknown [I] Object supporting the IPersistPropertyBag interface
1799 * lpPropBag [O] Destination for loaded IPropertyBag
1801 * RETURNS
1802 * Success: S_OK.
1803 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1805 DWORD WINAPI SHLoadFromPropertyBag(IUnknown *lpUnknown, IPropertyBag* lpPropBag)
1807 IPersistPropertyBag* lpPPBag;
1808 HRESULT hRet = E_FAIL;
1810 TRACE("(%p,%p)\n", lpUnknown, lpPropBag);
1812 if (lpUnknown)
1814 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IPersistPropertyBag,
1815 (void**)&lpPPBag);
1816 if (SUCCEEDED(hRet) && lpPPBag)
1818 hRet = IPersistPropertyBag_Load(lpPPBag, lpPropBag, NULL);
1819 IPersistPropertyBag_Release(lpPPBag);
1822 return hRet;
1825 /*************************************************************************
1826 * @ [SHLWAPI.188]
1828 * Call IOleControlSite_TranslateAccelerator() on an object.
1830 * PARAMS
1831 * lpUnknown [I] Object supporting the IOleControlSite interface.
1832 * lpMsg [I] Key message to be processed.
1833 * dwModifiers [I] Flags containing the state of the modifier keys.
1835 * RETURNS
1836 * Success: S_OK.
1837 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
1839 HRESULT WINAPI IUnknown_TranslateAcceleratorOCS(IUnknown *lpUnknown, LPMSG lpMsg, DWORD dwModifiers)
1841 IOleControlSite* lpCSite = NULL;
1842 HRESULT hRet = E_INVALIDARG;
1844 TRACE("(%p,%p,0x%08x)\n", lpUnknown, lpMsg, dwModifiers);
1845 if (lpUnknown)
1847 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1848 (void**)&lpCSite);
1849 if (SUCCEEDED(hRet) && lpCSite)
1851 hRet = IOleControlSite_TranslateAccelerator(lpCSite, lpMsg, dwModifiers);
1852 IOleControlSite_Release(lpCSite);
1855 return hRet;
1859 /*************************************************************************
1860 * @ [SHLWAPI.189]
1862 * Call IOleControlSite_OnFocus() on an object.
1864 * PARAMS
1865 * lpUnknown [I] Object supporting the IOleControlSite interface.
1866 * fGotFocus [I] Whether focus was gained (TRUE) or lost (FALSE).
1868 * RETURNS
1869 * Success: S_OK.
1870 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1872 HRESULT WINAPI IUnknown_OnFocusOCS(IUnknown *lpUnknown, BOOL fGotFocus)
1874 IOleControlSite* lpCSite = NULL;
1875 HRESULT hRet = E_FAIL;
1877 TRACE("(%p, %d)\n", lpUnknown, fGotFocus);
1878 if (lpUnknown)
1880 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IOleControlSite,
1881 (void**)&lpCSite);
1882 if (SUCCEEDED(hRet) && lpCSite)
1884 hRet = IOleControlSite_OnFocus(lpCSite, fGotFocus);
1885 IOleControlSite_Release(lpCSite);
1888 return hRet;
1891 /*************************************************************************
1892 * @ [SHLWAPI.190]
1894 HRESULT WINAPI IUnknown_HandleIRestrict(LPUNKNOWN lpUnknown, PVOID lpArg1,
1895 PVOID lpArg2, PVOID lpArg3, PVOID lpArg4)
1897 /* FIXME: {D12F26B2-D90A-11D0-830D-00AA005B4383} - What object does this represent? */
1898 static const DWORD service_id[] = { 0xd12f26b2, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1899 /* FIXME: {D12F26B1-D90A-11D0-830D-00AA005B4383} - Also Unknown/undocumented */
1900 static const DWORD function_id[] = { 0xd12f26b1, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1901 HRESULT hRet = E_INVALIDARG;
1902 LPUNKNOWN lpUnkInner = NULL; /* FIXME: Real type is unknown */
1904 TRACE("(%p,%p,%p,%p,%p)\n", lpUnknown, lpArg1, lpArg2, lpArg3, lpArg4);
1906 if (lpUnknown && lpArg4)
1908 hRet = IUnknown_QueryService(lpUnknown, (REFGUID)service_id,
1909 (REFGUID)function_id, (void**)&lpUnkInner);
1911 if (SUCCEEDED(hRet) && lpUnkInner)
1913 /* FIXME: The type of service object requested is unknown, however
1914 * testing shows that its first method is called with 4 parameters.
1915 * Fake this by using IParseDisplayName_ParseDisplayName since the
1916 * signature and position in the vtable matches our unknown object type.
1918 hRet = IParseDisplayName_ParseDisplayName((LPPARSEDISPLAYNAME)lpUnkInner,
1919 lpArg1, lpArg2, lpArg3, lpArg4);
1920 IUnknown_Release(lpUnkInner);
1923 return hRet;
1926 /*************************************************************************
1927 * @ [SHLWAPI.192]
1929 * Get a sub-menu from a menu item.
1931 * PARAMS
1932 * hMenu [I] Menu to get sub-menu from
1933 * uID [I] ID of menu item containing sub-menu
1935 * RETURNS
1936 * The sub-menu of the item, or a NULL handle if any parameters are invalid.
1938 HMENU WINAPI SHGetMenuFromID(HMENU hMenu, UINT uID)
1940 MENUITEMINFOW mi;
1942 TRACE("(%p,%u)\n", hMenu, uID);
1944 mi.cbSize = sizeof(mi);
1945 mi.fMask = MIIM_SUBMENU;
1947 if (!GetMenuItemInfoW(hMenu, uID, FALSE, &mi))
1948 return NULL;
1950 return mi.hSubMenu;
1953 /*************************************************************************
1954 * @ [SHLWAPI.193]
1956 * Get the color depth of the primary display.
1958 * PARAMS
1959 * None.
1961 * RETURNS
1962 * The color depth of the primary display.
1964 DWORD WINAPI SHGetCurColorRes(void)
1966 HDC hdc;
1967 DWORD ret;
1969 TRACE("()\n");
1971 hdc = GetDC(0);
1972 ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
1973 ReleaseDC(0, hdc);
1974 return ret;
1977 /*************************************************************************
1978 * @ [SHLWAPI.194]
1980 * Wait for a message to arrive, with a timeout.
1982 * PARAMS
1983 * hand [I] Handle to query
1984 * dwTimeout [I] Timeout in ticks or INFINITE to never timeout
1986 * RETURNS
1987 * STATUS_TIMEOUT if no message is received before dwTimeout ticks passes.
1988 * Otherwise returns the value from MsgWaitForMultipleObjectsEx when a
1989 * message is available.
1991 DWORD WINAPI SHWaitForSendMessageThread(HANDLE hand, DWORD dwTimeout)
1993 DWORD dwEndTicks = GetTickCount() + dwTimeout;
1994 DWORD dwRet;
1996 while ((dwRet = MsgWaitForMultipleObjectsEx(1, &hand, dwTimeout, QS_SENDMESSAGE, 0)) == 1)
1998 MSG msg;
2000 PeekMessageW(&msg, NULL, 0, 0, PM_NOREMOVE);
2002 if (dwTimeout != INFINITE)
2004 if ((int)(dwTimeout = dwEndTicks - GetTickCount()) <= 0)
2005 return WAIT_TIMEOUT;
2009 return dwRet;
2012 /*************************************************************************
2013 * @ [SHLWAPI.195]
2015 * Determine if a shell folder can be expanded.
2017 * PARAMS
2018 * lpFolder [I] Parent folder containing the object to test.
2019 * pidl [I] Id of the object to test.
2021 * RETURNS
2022 * Success: S_OK, if the object is expandable, S_FALSE otherwise.
2023 * Failure: E_INVALIDARG, if any argument is invalid.
2025 * NOTES
2026 * If the object to be tested does not expose the IQueryInfo() interface it
2027 * will not be identified as an expandable folder.
2029 HRESULT WINAPI SHIsExpandableFolder(LPSHELLFOLDER lpFolder, LPCITEMIDLIST pidl)
2031 HRESULT hRet = E_INVALIDARG;
2032 IQueryInfo *lpInfo;
2034 if (lpFolder && pidl)
2036 hRet = IShellFolder_GetUIObjectOf(lpFolder, NULL, 1, &pidl, &IID_IQueryInfo,
2037 NULL, (void**)&lpInfo);
2038 if (FAILED(hRet))
2039 hRet = S_FALSE; /* Doesn't expose IQueryInfo */
2040 else
2042 DWORD dwFlags = 0;
2044 /* MSDN states of IQueryInfo_GetInfoFlags() that "This method is not
2045 * currently used". Really? You wouldn't be holding out on me would you?
2047 hRet = IQueryInfo_GetInfoFlags(lpInfo, &dwFlags);
2049 if (SUCCEEDED(hRet))
2051 /* 0x2 is an undocumented flag apparently indicating expandability */
2052 hRet = dwFlags & 0x2 ? S_OK : S_FALSE;
2055 IQueryInfo_Release(lpInfo);
2058 return hRet;
2061 /*************************************************************************
2062 * @ [SHLWAPI.197]
2064 * Blank out a region of text by drawing the background only.
2066 * PARAMS
2067 * hDC [I] Device context to draw in
2068 * pRect [I] Area to draw in
2069 * cRef [I] Color to draw in
2071 * RETURNS
2072 * Nothing.
2074 DWORD WINAPI SHFillRectClr(HDC hDC, LPCRECT pRect, COLORREF cRef)
2076 COLORREF cOldColor = SetBkColor(hDC, cRef);
2077 ExtTextOutA(hDC, 0, 0, ETO_OPAQUE, pRect, 0, 0, 0);
2078 SetBkColor(hDC, cOldColor);
2079 return 0;
2082 /*************************************************************************
2083 * @ [SHLWAPI.198]
2085 * Return the value associated with a key in a map.
2087 * PARAMS
2088 * lpKeys [I] A list of keys of length iLen
2089 * lpValues [I] A list of values associated with lpKeys, of length iLen
2090 * iLen [I] Length of both lpKeys and lpValues
2091 * iKey [I] The key value to look up in lpKeys
2093 * RETURNS
2094 * The value in lpValues associated with iKey, or -1 if iKey is not
2095 * found in lpKeys.
2097 * NOTES
2098 * - If two elements in the map share the same key, this function returns
2099 * the value closest to the start of the map
2100 * - The native version of this function crashes if lpKeys or lpValues is NULL.
2102 int WINAPI SHSearchMapInt(const int *lpKeys, const int *lpValues, int iLen, int iKey)
2104 if (lpKeys && lpValues)
2106 int i = 0;
2108 while (i < iLen)
2110 if (lpKeys[i] == iKey)
2111 return lpValues[i]; /* Found */
2112 i++;
2115 return -1; /* Not found */
2119 /*************************************************************************
2120 * @ [SHLWAPI.199]
2122 * Copy an interface pointer
2124 * PARAMS
2125 * lppDest [O] Destination for copy
2126 * lpUnknown [I] Source for copy
2128 * RETURNS
2129 * Nothing.
2131 VOID WINAPI IUnknown_Set(IUnknown **lppDest, IUnknown *lpUnknown)
2133 TRACE("(%p,%p)\n", lppDest, lpUnknown);
2135 IUnknown_AtomicRelease(lppDest);
2137 if (lpUnknown)
2139 IUnknown_AddRef(lpUnknown);
2140 *lppDest = lpUnknown;
2144 /*************************************************************************
2145 * @ [SHLWAPI.200]
2148 HRESULT WINAPI MayQSForward(IUnknown* lpUnknown, PVOID lpReserved,
2149 REFGUID riidCmdGrp, ULONG cCmds,
2150 OLECMD *prgCmds, OLECMDTEXT* pCmdText)
2152 FIXME("(%p,%p,%p,%d,%p,%p) - stub\n",
2153 lpUnknown, lpReserved, riidCmdGrp, cCmds, prgCmds, pCmdText);
2155 /* FIXME: Calls IsQSForward & IUnknown_QueryStatus */
2156 return DRAGDROP_E_NOTREGISTERED;
2159 /*************************************************************************
2160 * @ [SHLWAPI.201]
2163 HRESULT WINAPI MayExecForward(IUnknown* lpUnknown, INT iUnk, REFGUID pguidCmdGroup,
2164 DWORD nCmdID, DWORD nCmdexecopt, VARIANT* pvaIn,
2165 VARIANT* pvaOut)
2167 FIXME("(%p,%d,%p,%d,%d,%p,%p) - stub!\n", lpUnknown, iUnk, pguidCmdGroup,
2168 nCmdID, nCmdexecopt, pvaIn, pvaOut);
2169 return DRAGDROP_E_NOTREGISTERED;
2172 /*************************************************************************
2173 * @ [SHLWAPI.202]
2176 HRESULT WINAPI IsQSForward(REFGUID pguidCmdGroup,ULONG cCmds, OLECMD *prgCmds)
2178 FIXME("(%p,%d,%p) - stub!\n", pguidCmdGroup, cCmds, prgCmds);
2179 return DRAGDROP_E_NOTREGISTERED;
2182 /*************************************************************************
2183 * @ [SHLWAPI.204]
2185 * Determine if a window is not a child of another window.
2187 * PARAMS
2188 * hParent [I] Suspected parent window
2189 * hChild [I] Suspected child window
2191 * RETURNS
2192 * TRUE: If hChild is a child window of hParent
2193 * FALSE: If hChild is not a child window of hParent, or they are equal
2195 BOOL WINAPI SHIsChildOrSelf(HWND hParent, HWND hChild)
2197 TRACE("(%p,%p)\n", hParent, hChild);
2199 if (!hParent || !hChild)
2200 return TRUE;
2201 else if(hParent == hChild)
2202 return FALSE;
2203 return !IsChild(hParent, hChild);
2206 /*************************************************************************
2207 * FDSA functions. Manage a dynamic array of fixed size memory blocks.
2210 typedef struct
2212 DWORD num_items; /* Number of elements inserted */
2213 void *mem; /* Ptr to array */
2214 DWORD blocks_alloced; /* Number of elements allocated */
2215 BYTE inc; /* Number of elements to grow by when we need to expand */
2216 BYTE block_size; /* Size in bytes of an element */
2217 BYTE flags; /* Flags */
2218 } FDSA_info;
2220 #define FDSA_FLAG_INTERNAL_ALLOC 0x01 /* When set we have allocated mem internally */
2222 /*************************************************************************
2223 * @ [SHLWAPI.208]
2225 * Initialize an FDSA array.
2227 BOOL WINAPI FDSA_Initialize(DWORD block_size, DWORD inc, FDSA_info *info, void *mem,
2228 DWORD init_blocks)
2230 TRACE("(0x%08x 0x%08x %p %p 0x%08x)\n", block_size, inc, info, mem, init_blocks);
2232 if(inc == 0)
2233 inc = 1;
2235 if(mem)
2236 memset(mem, 0, block_size * init_blocks);
2238 info->num_items = 0;
2239 info->inc = inc;
2240 info->mem = mem;
2241 info->blocks_alloced = init_blocks;
2242 info->block_size = block_size;
2243 info->flags = 0;
2245 return TRUE;
2248 /*************************************************************************
2249 * @ [SHLWAPI.209]
2251 * Destroy an FDSA array
2253 BOOL WINAPI FDSA_Destroy(FDSA_info *info)
2255 TRACE("(%p)\n", info);
2257 if(info->flags & FDSA_FLAG_INTERNAL_ALLOC)
2259 HeapFree(GetProcessHeap(), 0, info->mem);
2260 return FALSE;
2263 return TRUE;
2266 /*************************************************************************
2267 * @ [SHLWAPI.210]
2269 * Insert element into an FDSA array
2271 DWORD WINAPI FDSA_InsertItem(FDSA_info *info, DWORD where, const void *block)
2273 TRACE("(%p 0x%08x %p)\n", info, where, block);
2274 if(where > info->num_items)
2275 where = info->num_items;
2277 if(info->num_items >= info->blocks_alloced)
2279 DWORD size = (info->blocks_alloced + info->inc) * info->block_size;
2280 if(info->flags & 0x1)
2281 info->mem = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->mem, size);
2282 else
2284 void *old_mem = info->mem;
2285 info->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
2286 memcpy(info->mem, old_mem, info->blocks_alloced * info->block_size);
2288 info->blocks_alloced += info->inc;
2289 info->flags |= 0x1;
2292 if(where < info->num_items)
2294 memmove((char*)info->mem + (where + 1) * info->block_size,
2295 (char*)info->mem + where * info->block_size,
2296 (info->num_items - where) * info->block_size);
2298 memcpy((char*)info->mem + where * info->block_size, block, info->block_size);
2300 info->num_items++;
2301 return where;
2304 /*************************************************************************
2305 * @ [SHLWAPI.211]
2307 * Delete an element from an FDSA array.
2309 BOOL WINAPI FDSA_DeleteItem(FDSA_info *info, DWORD where)
2311 TRACE("(%p 0x%08x)\n", info, where);
2313 if(where >= info->num_items)
2314 return FALSE;
2316 if(where < info->num_items - 1)
2318 memmove((char*)info->mem + where * info->block_size,
2319 (char*)info->mem + (where + 1) * info->block_size,
2320 (info->num_items - where - 1) * info->block_size);
2322 memset((char*)info->mem + (info->num_items - 1) * info->block_size,
2323 0, info->block_size);
2324 info->num_items--;
2325 return TRUE;
2328 /*************************************************************************
2329 * @ [SHLWAPI.219]
2331 * Call IUnknown_QueryInterface() on a table of objects.
2333 * RETURNS
2334 * Success: S_OK.
2335 * Failure: E_POINTER or E_NOINTERFACE.
2337 HRESULT WINAPI QISearch(
2338 void *base, /* [in] Table of interfaces */
2339 const QITAB *table, /* [in] Array of REFIIDs and indexes into the table */
2340 REFIID riid, /* [in] REFIID to get interface for */
2341 void **ppv) /* [out] Destination for interface pointer */
2343 HRESULT ret;
2344 IUnknown *a_vtbl;
2345 const QITAB *xmove;
2347 TRACE("(%p %p %s %p)\n", base, table, debugstr_guid(riid), ppv);
2348 if (ppv) {
2349 xmove = table;
2350 while (xmove->piid) {
2351 TRACE("trying (offset %d) %s\n", xmove->dwOffset, debugstr_guid(xmove->piid));
2352 if (IsEqualIID(riid, xmove->piid)) {
2353 a_vtbl = (IUnknown*)(xmove->dwOffset + (LPBYTE)base);
2354 TRACE("matched, returning (%p)\n", a_vtbl);
2355 *ppv = a_vtbl;
2356 IUnknown_AddRef(a_vtbl);
2357 return S_OK;
2359 xmove++;
2362 if (IsEqualIID(riid, &IID_IUnknown)) {
2363 a_vtbl = (IUnknown*)(table->dwOffset + (LPBYTE)base);
2364 TRACE("returning first for IUnknown (%p)\n", a_vtbl);
2365 *ppv = a_vtbl;
2366 IUnknown_AddRef(a_vtbl);
2367 return S_OK;
2369 *ppv = 0;
2370 ret = E_NOINTERFACE;
2371 } else
2372 ret = E_POINTER;
2374 TRACE("-- 0x%08x\n", ret);
2375 return ret;
2378 /*************************************************************************
2379 * @ [SHLWAPI.220]
2381 * Set the Font for a window and the "PropDlgFont" property of the parent window.
2383 * PARAMS
2384 * hWnd [I] Parent Window to set the property
2385 * id [I] Index of child Window to set the Font
2387 * RETURNS
2388 * Success: S_OK
2391 HRESULT WINAPI SHSetDefaultDialogFont(HWND hWnd, INT id)
2393 FIXME("(%p, %d) stub\n", hWnd, id);
2394 return S_OK;
2397 /*************************************************************************
2398 * @ [SHLWAPI.221]
2400 * Remove the "PropDlgFont" property from a window.
2402 * PARAMS
2403 * hWnd [I] Window to remove the property from
2405 * RETURNS
2406 * A handle to the removed property, or NULL if it did not exist.
2408 HANDLE WINAPI SHRemoveDefaultDialogFont(HWND hWnd)
2410 HANDLE hProp;
2412 TRACE("(%p)\n", hWnd);
2414 hProp = GetPropA(hWnd, "PropDlgFont");
2416 if(hProp)
2418 DeleteObject(hProp);
2419 hProp = RemovePropA(hWnd, "PropDlgFont");
2421 return hProp;
2424 /*************************************************************************
2425 * @ [SHLWAPI.236]
2427 * Load the in-process server of a given GUID.
2429 * PARAMS
2430 * refiid [I] GUID of the server to load.
2432 * RETURNS
2433 * Success: A handle to the loaded server dll.
2434 * Failure: A NULL handle.
2436 HMODULE WINAPI SHPinDllOfCLSID(REFIID refiid)
2438 HKEY newkey;
2439 DWORD type, count;
2440 CHAR value[MAX_PATH], string[MAX_PATH];
2442 strcpy(string, "CLSID\\");
2443 SHStringFromGUIDA(refiid, string + 6, sizeof(string)/sizeof(char) - 6);
2444 strcat(string, "\\InProcServer32");
2446 count = MAX_PATH;
2447 RegOpenKeyExA(HKEY_CLASSES_ROOT, string, 0, 1, &newkey);
2448 RegQueryValueExA(newkey, 0, 0, &type, (PBYTE)value, &count);
2449 RegCloseKey(newkey);
2450 return LoadLibraryExA(value, 0, 0);
2453 /*************************************************************************
2454 * @ [SHLWAPI.237]
2456 * Unicode version of SHLWAPI_183.
2458 DWORD WINAPI SHRegisterClassW(WNDCLASSW * lpWndClass)
2460 WNDCLASSW WndClass;
2462 TRACE("(%p %s)\n",lpWndClass->hInstance, debugstr_w(lpWndClass->lpszClassName));
2464 if (GetClassInfoW(lpWndClass->hInstance, lpWndClass->lpszClassName, &WndClass))
2465 return TRUE;
2466 return RegisterClassW(lpWndClass);
2469 /*************************************************************************
2470 * @ [SHLWAPI.238]
2472 * Unregister a list of classes.
2474 * PARAMS
2475 * hInst [I] Application instance that registered the classes
2476 * lppClasses [I] List of class names
2477 * iCount [I] Number of names in lppClasses
2479 * RETURNS
2480 * Nothing.
2482 void WINAPI SHUnregisterClassesA(HINSTANCE hInst, LPCSTR *lppClasses, INT iCount)
2484 WNDCLASSA WndClass;
2486 TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2488 while (iCount > 0)
2490 if (GetClassInfoA(hInst, *lppClasses, &WndClass))
2491 UnregisterClassA(*lppClasses, hInst);
2492 lppClasses++;
2493 iCount--;
2497 /*************************************************************************
2498 * @ [SHLWAPI.239]
2500 * Unicode version of SHUnregisterClassesA.
2502 void WINAPI SHUnregisterClassesW(HINSTANCE hInst, LPCWSTR *lppClasses, INT iCount)
2504 WNDCLASSW WndClass;
2506 TRACE("(%p,%p,%d)\n", hInst, lppClasses, iCount);
2508 while (iCount > 0)
2510 if (GetClassInfoW(hInst, *lppClasses, &WndClass))
2511 UnregisterClassW(*lppClasses, hInst);
2512 lppClasses++;
2513 iCount--;
2517 /*************************************************************************
2518 * @ [SHLWAPI.240]
2520 * Call The correct (Ascii/Unicode) default window procedure for a window.
2522 * PARAMS
2523 * hWnd [I] Window to call the default procedure for
2524 * uMessage [I] Message ID
2525 * wParam [I] WPARAM of message
2526 * lParam [I] LPARAM of message
2528 * RETURNS
2529 * The result of calling DefWindowProcA() or DefWindowProcW().
2531 LRESULT CALLBACK SHDefWindowProc(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
2533 if (IsWindowUnicode(hWnd))
2534 return DefWindowProcW(hWnd, uMessage, wParam, lParam);
2535 return DefWindowProcA(hWnd, uMessage, wParam, lParam);
2538 /*************************************************************************
2539 * @ [SHLWAPI.256]
2541 HRESULT WINAPI IUnknown_GetSite(LPUNKNOWN lpUnknown, REFIID iid, PVOID *lppSite)
2543 HRESULT hRet = E_INVALIDARG;
2544 LPOBJECTWITHSITE lpSite = NULL;
2546 TRACE("(%p,%s,%p)\n", lpUnknown, debugstr_guid(iid), lppSite);
2548 if (lpUnknown && iid && lppSite)
2550 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IObjectWithSite,
2551 (void**)&lpSite);
2552 if (SUCCEEDED(hRet) && lpSite)
2554 hRet = IObjectWithSite_GetSite(lpSite, iid, lppSite);
2555 IObjectWithSite_Release(lpSite);
2558 return hRet;
2561 /*************************************************************************
2562 * @ [SHLWAPI.257]
2564 * Create a worker window using CreateWindowExA().
2566 * PARAMS
2567 * wndProc [I] Window procedure
2568 * hWndParent [I] Parent window
2569 * dwExStyle [I] Extra style flags
2570 * dwStyle [I] Style flags
2571 * hMenu [I] Window menu
2572 * wnd_extra [I] Window extra bytes value
2574 * RETURNS
2575 * Success: The window handle of the newly created window.
2576 * Failure: 0.
2578 HWND WINAPI SHCreateWorkerWindowA(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2579 DWORD dwStyle, HMENU hMenu, LONG_PTR wnd_extra)
2581 static const char szClass[] = "WorkerA";
2582 WNDCLASSA wc;
2583 HWND hWnd;
2585 TRACE("(0x%08x, %p, 0x%08x, 0x%08x, %p, 0x%08lx)\n",
2586 wndProc, hWndParent, dwExStyle, dwStyle, hMenu, wnd_extra);
2588 /* Create Window class */
2589 wc.style = 0;
2590 wc.lpfnWndProc = DefWindowProcA;
2591 wc.cbClsExtra = 0;
2592 wc.cbWndExtra = sizeof(LONG_PTR);
2593 wc.hInstance = shlwapi_hInstance;
2594 wc.hIcon = NULL;
2595 wc.hCursor = LoadCursorA(NULL, (LPSTR)IDC_ARROW);
2596 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2597 wc.lpszMenuName = NULL;
2598 wc.lpszClassName = szClass;
2600 SHRegisterClassA(&wc);
2602 hWnd = CreateWindowExA(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2603 hWndParent, hMenu, shlwapi_hInstance, 0);
2604 if (hWnd)
2606 SetWindowLongPtrW(hWnd, 0, wnd_extra);
2608 if (wndProc) SetWindowLongPtrA(hWnd, GWLP_WNDPROC, wndProc);
2611 return hWnd;
2614 typedef struct tagPOLICYDATA
2616 DWORD policy; /* flags value passed to SHRestricted */
2617 LPCWSTR appstr; /* application str such as "Explorer" */
2618 LPCWSTR keystr; /* name of the actual registry key / policy */
2619 } POLICYDATA, *LPPOLICYDATA;
2621 #define SHELL_NO_POLICY 0xffffffff
2623 /* default shell policy registry key */
2624 static const WCHAR strRegistryPolicyW[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o',
2625 's','o','f','t','\\','W','i','n','d','o','w','s','\\',
2626 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',
2627 '\\','P','o','l','i','c','i','e','s',0};
2629 /*************************************************************************
2630 * @ [SHLWAPI.271]
2632 * Retrieve a policy value from the registry.
2634 * PARAMS
2635 * lpSubKey [I] registry key name
2636 * lpSubName [I] subname of registry key
2637 * lpValue [I] value name of registry value
2639 * RETURNS
2640 * the value associated with the registry key or 0 if not found
2642 DWORD WINAPI SHGetRestriction(LPCWSTR lpSubKey, LPCWSTR lpSubName, LPCWSTR lpValue)
2644 DWORD retval, datsize = sizeof(retval);
2645 HKEY hKey;
2647 if (!lpSubKey)
2648 lpSubKey = strRegistryPolicyW;
2650 retval = RegOpenKeyW(HKEY_LOCAL_MACHINE, lpSubKey, &hKey);
2651 if (retval != ERROR_SUCCESS)
2652 retval = RegOpenKeyW(HKEY_CURRENT_USER, lpSubKey, &hKey);
2653 if (retval != ERROR_SUCCESS)
2654 return 0;
2656 SHGetValueW(hKey, lpSubName, lpValue, NULL, &retval, &datsize);
2657 RegCloseKey(hKey);
2658 return retval;
2661 /*************************************************************************
2662 * @ [SHLWAPI.266]
2664 * Helper function to retrieve the possibly cached value for a specific policy
2666 * PARAMS
2667 * policy [I] The policy to look for
2668 * initial [I] Main registry key to open, if NULL use default
2669 * polTable [I] Table of known policies, 0 terminated
2670 * polArr [I] Cache array of policy values
2672 * RETURNS
2673 * The retrieved policy value or 0 if not successful
2675 * NOTES
2676 * This function is used by the native SHRestricted function to search for the
2677 * policy and cache it once retrieved. The current Wine implementation uses a
2678 * different POLICYDATA structure and implements a similar algorithm adapted to
2679 * that structure.
2681 DWORD WINAPI SHRestrictionLookup(
2682 DWORD policy,
2683 LPCWSTR initial,
2684 LPPOLICYDATA polTable,
2685 LPDWORD polArr)
2687 TRACE("(0x%08x %s %p %p)\n", policy, debugstr_w(initial), polTable, polArr);
2689 if (!polTable || !polArr)
2690 return 0;
2692 for (;polTable->policy; polTable++, polArr++)
2694 if (policy == polTable->policy)
2696 /* we have a known policy */
2698 /* check if this policy has been cached */
2699 if (*polArr == SHELL_NO_POLICY)
2700 *polArr = SHGetRestriction(initial, polTable->appstr, polTable->keystr);
2701 return *polArr;
2704 /* we don't know this policy, return 0 */
2705 TRACE("unknown policy: (%08x)\n", policy);
2706 return 0;
2709 /*************************************************************************
2710 * @ [SHLWAPI.267]
2712 * Get an interface from an object.
2714 * RETURNS
2715 * Success: S_OK. ppv contains the requested interface.
2716 * Failure: An HRESULT error code.
2718 * NOTES
2719 * This QueryInterface asks the inner object for an interface. In case
2720 * of aggregation this request would be forwarded by the inner to the
2721 * outer object. This function asks the inner object directly for the
2722 * interface circumventing the forwarding to the outer object.
2724 HRESULT WINAPI SHWeakQueryInterface(
2725 IUnknown * pUnk, /* [in] Outer object */
2726 IUnknown * pInner, /* [in] Inner object */
2727 IID * riid, /* [in] Interface GUID to query for */
2728 LPVOID* ppv) /* [out] Destination for queried interface */
2730 HRESULT hret = E_NOINTERFACE;
2731 TRACE("(pUnk=%p pInner=%p\n\tIID: %s %p)\n",pUnk,pInner,debugstr_guid(riid), ppv);
2733 *ppv = NULL;
2734 if(pUnk && pInner) {
2735 hret = IUnknown_QueryInterface(pInner, riid, ppv);
2736 if (SUCCEEDED(hret)) IUnknown_Release(pUnk);
2738 TRACE("-- 0x%08x\n", hret);
2739 return hret;
2742 /*************************************************************************
2743 * @ [SHLWAPI.268]
2745 * Move a reference from one interface to another.
2747 * PARAMS
2748 * lpDest [O] Destination to receive the reference
2749 * lppUnknown [O] Source to give up the reference to lpDest
2751 * RETURNS
2752 * Nothing.
2754 VOID WINAPI SHWeakReleaseInterface(IUnknown *lpDest, IUnknown **lppUnknown)
2756 TRACE("(%p,%p)\n", lpDest, lppUnknown);
2758 if (*lppUnknown)
2760 /* Copy Reference*/
2761 IUnknown_AddRef(lpDest);
2762 IUnknown_AtomicRelease(lppUnknown); /* Release existing interface */
2766 /*************************************************************************
2767 * @ [SHLWAPI.269]
2769 * Convert an ASCII string of a CLSID into a CLSID.
2771 * PARAMS
2772 * idstr [I] String representing a CLSID in registry format
2773 * id [O] Destination for the converted CLSID
2775 * RETURNS
2776 * Success: TRUE. id contains the converted CLSID.
2777 * Failure: FALSE.
2779 BOOL WINAPI GUIDFromStringA(LPCSTR idstr, CLSID *id)
2781 WCHAR wClsid[40];
2782 MultiByteToWideChar(CP_ACP, 0, idstr, -1, wClsid, sizeof(wClsid)/sizeof(WCHAR));
2783 return SUCCEEDED(CLSIDFromString(wClsid, id));
2786 /*************************************************************************
2787 * @ [SHLWAPI.270]
2789 * Unicode version of GUIDFromStringA.
2791 BOOL WINAPI GUIDFromStringW(LPCWSTR idstr, CLSID *id)
2793 return SUCCEEDED(CLSIDFromString((LPCOLESTR)idstr, id));
2796 /*************************************************************************
2797 * @ [SHLWAPI.276]
2799 * Determine if the browser is integrated into the shell, and set a registry
2800 * key accordingly.
2802 * PARAMS
2803 * None.
2805 * RETURNS
2806 * 1, If the browser is not integrated.
2807 * 2, If the browser is integrated.
2809 * NOTES
2810 * The key "HKLM\Software\Microsoft\Internet Explorer\IntegratedBrowser" is
2811 * either set to TRUE, or removed depending on whether the browser is deemed
2812 * to be integrated.
2814 DWORD WINAPI WhichPlatform(void)
2816 static const char szIntegratedBrowser[] = "IntegratedBrowser";
2817 static DWORD dwState = 0;
2818 HKEY hKey;
2819 DWORD dwRet, dwData, dwSize;
2820 HMODULE hshell32;
2822 if (dwState)
2823 return dwState;
2825 /* If shell32 exports DllGetVersion(), the browser is integrated */
2826 dwState = 1;
2827 hshell32 = LoadLibraryA("shell32.dll");
2828 if (hshell32)
2830 FARPROC pDllGetVersion;
2831 pDllGetVersion = GetProcAddress(hshell32, "DllGetVersion");
2832 dwState = pDllGetVersion ? 2 : 1;
2833 FreeLibrary(hshell32);
2836 /* Set or delete the key accordingly */
2837 dwRet = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
2838 "Software\\Microsoft\\Internet Explorer", 0,
2839 KEY_ALL_ACCESS, &hKey);
2840 if (!dwRet)
2842 dwRet = RegQueryValueExA(hKey, szIntegratedBrowser, 0, 0,
2843 (LPBYTE)&dwData, &dwSize);
2845 if (!dwRet && dwState == 1)
2847 /* Value exists but browser is not integrated */
2848 RegDeleteValueA(hKey, szIntegratedBrowser);
2850 else if (dwRet && dwState == 2)
2852 /* Browser is integrated but value does not exist */
2853 dwData = TRUE;
2854 RegSetValueExA(hKey, szIntegratedBrowser, 0, REG_DWORD,
2855 (LPBYTE)&dwData, sizeof(dwData));
2857 RegCloseKey(hKey);
2859 return dwState;
2862 /*************************************************************************
2863 * @ [SHLWAPI.278]
2865 * Unicode version of SHCreateWorkerWindowA.
2867 HWND WINAPI SHCreateWorkerWindowW(LONG wndProc, HWND hWndParent, DWORD dwExStyle,
2868 DWORD dwStyle, HMENU hMenu, LONG msg_result)
2870 static const WCHAR szClass[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', 0 };
2871 WNDCLASSW wc;
2872 HWND hWnd;
2874 TRACE("(0x%08x, %p, 0x%08x, 0x%08x, %p, 0x%08x)\n",
2875 wndProc, hWndParent, dwExStyle, dwStyle, hMenu, msg_result);
2877 /* If our OS is natively ANSI, use the ANSI version */
2878 if (GetVersion() & 0x80000000) /* not NT */
2880 TRACE("fallback to ANSI, ver 0x%08x\n", GetVersion());
2881 return SHCreateWorkerWindowA(wndProc, hWndParent, dwExStyle, dwStyle, hMenu, msg_result);
2884 /* Create Window class */
2885 wc.style = 0;
2886 wc.lpfnWndProc = DefWindowProcW;
2887 wc.cbClsExtra = 0;
2888 wc.cbWndExtra = 4;
2889 wc.hInstance = shlwapi_hInstance;
2890 wc.hIcon = NULL;
2891 wc.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
2892 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
2893 wc.lpszMenuName = NULL;
2894 wc.lpszClassName = szClass;
2896 SHRegisterClassW(&wc);
2898 hWnd = CreateWindowExW(dwExStyle, szClass, 0, dwStyle, 0, 0, 0, 0,
2899 hWndParent, hMenu, shlwapi_hInstance, 0);
2900 if (hWnd)
2902 SetWindowLongPtrW(hWnd, DWLP_MSGRESULT, msg_result);
2904 if (wndProc) SetWindowLongPtrW(hWnd, GWLP_WNDPROC, wndProc);
2907 return hWnd;
2910 /*************************************************************************
2911 * @ [SHLWAPI.279]
2913 * Get and show a context menu from a shell folder.
2915 * PARAMS
2916 * hWnd [I] Window displaying the shell folder
2917 * lpFolder [I] IShellFolder interface
2918 * lpApidl [I] Id for the particular folder desired
2920 * RETURNS
2921 * Success: S_OK.
2922 * Failure: An HRESULT error code indicating the error.
2924 HRESULT WINAPI SHInvokeDefaultCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl)
2926 TRACE("%p %p %p\n", hWnd, lpFolder, lpApidl);
2927 return SHInvokeCommand(hWnd, lpFolder, lpApidl, 0);
2930 /*************************************************************************
2931 * @ [SHLWAPI.281]
2933 * _SHPackDispParamsV
2935 HRESULT WINAPI SHPackDispParamsV(DISPPARAMS *params, VARIANTARG *args, UINT cnt, __ms_va_list valist)
2937 VARIANTARG *iter;
2939 TRACE("(%p %p %u ...)\n", params, args, cnt);
2941 params->rgvarg = args;
2942 params->rgdispidNamedArgs = NULL;
2943 params->cArgs = cnt;
2944 params->cNamedArgs = 0;
2946 iter = args+cnt;
2948 while(iter-- > args) {
2949 V_VT(iter) = va_arg(valist, enum VARENUM);
2951 TRACE("vt=%d\n", V_VT(iter));
2953 if(V_VT(iter) & VT_BYREF) {
2954 V_BYREF(iter) = va_arg(valist, LPVOID);
2955 } else {
2956 switch(V_VT(iter)) {
2957 case VT_I4:
2958 V_I4(iter) = va_arg(valist, LONG);
2959 break;
2960 case VT_BSTR:
2961 V_BSTR(iter) = va_arg(valist, BSTR);
2962 break;
2963 case VT_DISPATCH:
2964 V_DISPATCH(iter) = va_arg(valist, IDispatch*);
2965 break;
2966 case VT_BOOL:
2967 V_BOOL(iter) = va_arg(valist, int);
2968 break;
2969 case VT_UNKNOWN:
2970 V_UNKNOWN(iter) = va_arg(valist, IUnknown*);
2971 break;
2972 default:
2973 V_VT(iter) = VT_I4;
2974 V_I4(iter) = va_arg(valist, LONG);
2979 return S_OK;
2982 /*************************************************************************
2983 * @ [SHLWAPI.282]
2985 * SHPackDispParams
2987 HRESULT WINAPIV SHPackDispParams(DISPPARAMS *params, VARIANTARG *args, UINT cnt, ...)
2989 __ms_va_list valist;
2990 HRESULT hres;
2992 __ms_va_start(valist, cnt);
2993 hres = SHPackDispParamsV(params, args, cnt, valist);
2994 __ms_va_end(valist);
2995 return hres;
2998 /*************************************************************************
2999 * SHLWAPI_InvokeByIID
3001 * This helper function calls IDispatch::Invoke for each sink
3002 * which implements given iid or IDispatch.
3005 static HRESULT SHLWAPI_InvokeByIID(
3006 IConnectionPoint* iCP,
3007 REFIID iid,
3008 DISPID dispId,
3009 DISPPARAMS* dispParams)
3011 IEnumConnections *enumerator;
3012 CONNECTDATA rgcd;
3013 static DISPPARAMS empty = {NULL, NULL, 0, 0};
3014 DISPPARAMS* params = dispParams;
3016 HRESULT result = IConnectionPoint_EnumConnections(iCP, &enumerator);
3017 if (FAILED(result))
3018 return result;
3020 /* Invoke is never happening with an NULL dispParams */
3021 if (!params)
3022 params = &empty;
3024 while(IEnumConnections_Next(enumerator, 1, &rgcd, NULL)==S_OK)
3026 IDispatch *dispIface;
3027 if ((iid && SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, iid, (LPVOID*)&dispIface))) ||
3028 SUCCEEDED(IUnknown_QueryInterface(rgcd.pUnk, &IID_IDispatch, (LPVOID*)&dispIface)))
3030 IDispatch_Invoke(dispIface, dispId, &IID_NULL, 0, DISPATCH_METHOD, params, NULL, NULL, NULL);
3031 IDispatch_Release(dispIface);
3033 IUnknown_Release(rgcd.pUnk);
3036 IEnumConnections_Release(enumerator);
3038 return S_OK;
3041 /*************************************************************************
3042 * IConnectionPoint_InvokeWithCancel [SHLWAPI.283]
3044 HRESULT WINAPI IConnectionPoint_InvokeWithCancel( IConnectionPoint* iCP,
3045 DISPID dispId, DISPPARAMS* dispParams,
3046 DWORD unknown1, DWORD unknown2 )
3048 IID iid;
3049 HRESULT result;
3051 FIXME("(%p)->(0x%x %p %x %x) partial stub\n", iCP, dispId, dispParams, unknown1, unknown2);
3053 result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
3054 if (SUCCEEDED(result))
3055 result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
3056 else
3057 result = SHLWAPI_InvokeByIID(iCP, NULL, dispId, dispParams);
3059 return result;
3063 /*************************************************************************
3064 * @ [SHLWAPI.284]
3066 * IConnectionPoint_SimpleInvoke
3068 HRESULT WINAPI IConnectionPoint_SimpleInvoke(
3069 IConnectionPoint* iCP,
3070 DISPID dispId,
3071 DISPPARAMS* dispParams)
3073 IID iid;
3074 HRESULT result;
3076 TRACE("(%p)->(0x%x %p)\n",iCP,dispId,dispParams);
3078 result = IConnectionPoint_GetConnectionInterface(iCP, &iid);
3079 if (SUCCEEDED(result))
3080 result = SHLWAPI_InvokeByIID(iCP, &iid, dispId, dispParams);
3081 else
3082 result = SHLWAPI_InvokeByIID(iCP, NULL, dispId, dispParams);
3084 return result;
3087 /*************************************************************************
3088 * @ [SHLWAPI.285]
3090 * Notify an IConnectionPoint object of changes.
3092 * PARAMS
3093 * lpCP [I] Object to notify
3094 * dispID [I]
3096 * RETURNS
3097 * Success: S_OK.
3098 * Failure: E_NOINTERFACE, if lpCP is NULL or does not support the
3099 * IConnectionPoint interface.
3101 HRESULT WINAPI IConnectionPoint_OnChanged(IConnectionPoint* lpCP, DISPID dispID)
3103 IEnumConnections *lpEnum;
3104 HRESULT hRet = E_NOINTERFACE;
3106 TRACE("(%p,0x%8X)\n", lpCP, dispID);
3108 /* Get an enumerator for the connections */
3109 if (lpCP)
3110 hRet = IConnectionPoint_EnumConnections(lpCP, &lpEnum);
3112 if (SUCCEEDED(hRet))
3114 IPropertyNotifySink *lpSink;
3115 CONNECTDATA connData;
3116 ULONG ulFetched;
3118 /* Call OnChanged() for every notify sink in the connection point */
3119 while (IEnumConnections_Next(lpEnum, 1, &connData, &ulFetched) == S_OK)
3121 if (SUCCEEDED(IUnknown_QueryInterface(connData.pUnk, &IID_IPropertyNotifySink, (void**)&lpSink)) &&
3122 lpSink)
3124 IPropertyNotifySink_OnChanged(lpSink, dispID);
3125 IPropertyNotifySink_Release(lpSink);
3127 IUnknown_Release(connData.pUnk);
3130 IEnumConnections_Release(lpEnum);
3132 return hRet;
3135 /*************************************************************************
3136 * @ [SHLWAPI.286]
3138 * IUnknown_CPContainerInvokeParam
3140 HRESULT WINAPIV IUnknown_CPContainerInvokeParam(
3141 IUnknown *container,
3142 REFIID riid,
3143 DISPID dispId,
3144 VARIANTARG* buffer,
3145 DWORD cParams, ...)
3147 HRESULT result;
3148 IConnectionPoint *iCP;
3149 IConnectionPointContainer *iCPC;
3150 DISPPARAMS dispParams = {buffer, NULL, cParams, 0};
3151 __ms_va_list valist;
3153 if (!container)
3154 return E_NOINTERFACE;
3156 result = IUnknown_QueryInterface(container, &IID_IConnectionPointContainer,(LPVOID*) &iCPC);
3157 if (FAILED(result))
3158 return result;
3160 result = IConnectionPointContainer_FindConnectionPoint(iCPC, riid, &iCP);
3161 IConnectionPointContainer_Release(iCPC);
3162 if(FAILED(result))
3163 return result;
3165 __ms_va_start(valist, cParams);
3166 SHPackDispParamsV(&dispParams, buffer, cParams, valist);
3167 __ms_va_end(valist);
3169 result = SHLWAPI_InvokeByIID(iCP, riid, dispId, &dispParams);
3170 IConnectionPoint_Release(iCP);
3172 return result;
3175 /*************************************************************************
3176 * @ [SHLWAPI.287]
3178 * Notify an IConnectionPointContainer object of changes.
3180 * PARAMS
3181 * lpUnknown [I] Object to notify
3182 * dispID [I]
3184 * RETURNS
3185 * Success: S_OK.
3186 * Failure: E_NOINTERFACE, if lpUnknown is NULL or does not support the
3187 * IConnectionPointContainer interface.
3189 HRESULT WINAPI IUnknown_CPContainerOnChanged(IUnknown *lpUnknown, DISPID dispID)
3191 IConnectionPointContainer* lpCPC = NULL;
3192 HRESULT hRet = E_NOINTERFACE;
3194 TRACE("(%p,0x%8X)\n", lpUnknown, dispID);
3196 if (lpUnknown)
3197 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IConnectionPointContainer, (void**)&lpCPC);
3199 if (SUCCEEDED(hRet))
3201 IConnectionPoint* lpCP;
3203 hRet = IConnectionPointContainer_FindConnectionPoint(lpCPC, &IID_IPropertyNotifySink, &lpCP);
3204 IConnectionPointContainer_Release(lpCPC);
3206 hRet = IConnectionPoint_OnChanged(lpCP, dispID);
3207 IConnectionPoint_Release(lpCP);
3209 return hRet;
3212 /*************************************************************************
3213 * @ [SHLWAPI.289]
3215 * See PlaySoundW.
3217 BOOL WINAPI PlaySoundWrapW(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
3219 return PlaySoundW(pszSound, hmod, fdwSound);
3222 /*************************************************************************
3223 * @ [SHLWAPI.294]
3225 * Retrieve a key value from an INI file. See GetPrivateProfileString for
3226 * more information.
3228 * PARAMS
3229 * appName [I] The section in the INI file that contains the key
3230 * keyName [I] The key to be retrieved
3231 * out [O] The buffer into which the key's value will be copied
3232 * outLen [I] The length of the `out' buffer
3233 * filename [I] The location of the INI file
3235 * RETURNS
3236 * Length of string copied into `out'.
3238 DWORD WINAPI SHGetIniStringW(LPCWSTR appName, LPCWSTR keyName, LPWSTR out,
3239 DWORD outLen, LPCWSTR filename)
3241 INT ret;
3242 WCHAR *buf;
3244 TRACE("(%s,%s,%p,%08x,%s)\n", debugstr_w(appName), debugstr_w(keyName),
3245 out, outLen, debugstr_w(filename));
3247 if(outLen == 0)
3248 return 0;
3250 buf = HeapAlloc(GetProcessHeap(), 0, outLen * sizeof(WCHAR));
3251 if(!buf){
3252 *out = 0;
3253 return 0;
3256 ret = GetPrivateProfileStringW(appName, keyName, NULL, buf, outLen, filename);
3257 if(ret)
3258 strcpyW(out, buf);
3259 else
3260 *out = 0;
3262 HeapFree(GetProcessHeap(), 0, buf);
3264 return strlenW(out);
3267 /*************************************************************************
3268 * @ [SHLWAPI.295]
3270 * Set a key value in an INI file. See WritePrivateProfileString for
3271 * more information.
3273 * PARAMS
3274 * appName [I] The section in the INI file that contains the key
3275 * keyName [I] The key to be set
3276 * str [O] The value of the key
3277 * filename [I] The location of the INI file
3279 * RETURNS
3280 * Success: TRUE
3281 * Failure: FALSE
3283 BOOL WINAPI SHSetIniStringW(LPCWSTR appName, LPCWSTR keyName, LPCWSTR str,
3284 LPCWSTR filename)
3286 TRACE("(%s, %p, %s, %s)\n", debugstr_w(appName), keyName, debugstr_w(str),
3287 debugstr_w(filename));
3289 return WritePrivateProfileStringW(appName, keyName, str, filename);
3292 /*************************************************************************
3293 * @ [SHLWAPI.313]
3295 * See SHGetFileInfoW.
3297 DWORD WINAPI SHGetFileInfoWrapW(LPCWSTR path, DWORD dwFileAttributes,
3298 SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags)
3300 return SHGetFileInfoW(path, dwFileAttributes, psfi, sizeofpsfi, flags);
3303 /*************************************************************************
3304 * @ [SHLWAPI.318]
3306 * See DragQueryFileW.
3308 UINT WINAPI DragQueryFileWrapW(HDROP hDrop, UINT lFile, LPWSTR lpszFile, UINT lLength)
3310 return DragQueryFileW(hDrop, lFile, lpszFile, lLength);
3313 /*************************************************************************
3314 * @ [SHLWAPI.333]
3316 * See SHBrowseForFolderW.
3318 LPITEMIDLIST WINAPI SHBrowseForFolderWrapW(LPBROWSEINFOW lpBi)
3320 return SHBrowseForFolderW(lpBi);
3323 /*************************************************************************
3324 * @ [SHLWAPI.334]
3326 * See SHGetPathFromIDListW.
3328 BOOL WINAPI SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl,LPWSTR pszPath)
3330 return SHGetPathFromIDListW(pidl, pszPath);
3333 /*************************************************************************
3334 * @ [SHLWAPI.335]
3336 * See ShellExecuteExW.
3338 BOOL WINAPI ShellExecuteExWrapW(LPSHELLEXECUTEINFOW lpExecInfo)
3340 return ShellExecuteExW(lpExecInfo);
3343 /*************************************************************************
3344 * @ [SHLWAPI.336]
3346 * See SHFileOperationW.
3348 INT WINAPI SHFileOperationWrapW(LPSHFILEOPSTRUCTW lpFileOp)
3350 return SHFileOperationW(lpFileOp);
3353 /*************************************************************************
3354 * @ [SHLWAPI.342]
3357 PVOID WINAPI SHInterlockedCompareExchange( PVOID *dest, PVOID xchg, PVOID compare )
3359 return InterlockedCompareExchangePointer( dest, xchg, compare );
3362 /*************************************************************************
3363 * @ [SHLWAPI.350]
3365 * See GetFileVersionInfoSizeW.
3367 DWORD WINAPI GetFileVersionInfoSizeWrapW( LPCWSTR filename, LPDWORD handle )
3369 return GetFileVersionInfoSizeW( filename, handle );
3372 /*************************************************************************
3373 * @ [SHLWAPI.351]
3375 * See GetFileVersionInfoW.
3377 BOOL WINAPI GetFileVersionInfoWrapW( LPCWSTR filename, DWORD handle,
3378 DWORD datasize, LPVOID data )
3380 return GetFileVersionInfoW( filename, handle, datasize, data );
3383 /*************************************************************************
3384 * @ [SHLWAPI.352]
3386 * See VerQueryValueW.
3388 WORD WINAPI VerQueryValueWrapW( LPVOID pBlock, LPCWSTR lpSubBlock,
3389 LPVOID *lplpBuffer, UINT *puLen )
3391 return VerQueryValueW( pBlock, lpSubBlock, lplpBuffer, puLen );
3394 #define IsIface(type) SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
3395 #define IShellBrowser_EnableModeless IShellBrowser_EnableModelessSB
3396 #define EnableModeless(type) type##_EnableModeless((type*)lpObj, bModeless)
3398 /*************************************************************************
3399 * @ [SHLWAPI.355]
3401 * Change the modality of a shell object.
3403 * PARAMS
3404 * lpUnknown [I] Object to make modeless
3405 * bModeless [I] TRUE=Make modeless, FALSE=Make modal
3407 * RETURNS
3408 * Success: S_OK. The modality lpUnknown is changed.
3409 * Failure: An HRESULT error code indicating the error.
3411 * NOTES
3412 * lpUnknown must support the IOleInPlaceFrame interface, the
3413 * IInternetSecurityMgrSite interface, the IShellBrowser interface
3414 * the IDocHostUIHandler interface, or the IOleInPlaceActiveObject interface,
3415 * or this call will fail.
3417 HRESULT WINAPI IUnknown_EnableModeless(IUnknown *lpUnknown, BOOL bModeless)
3419 IUnknown *lpObj;
3420 HRESULT hRet;
3422 TRACE("(%p,%d)\n", lpUnknown, bModeless);
3424 if (!lpUnknown)
3425 return E_FAIL;
3427 if (IsIface(IOleInPlaceActiveObject))
3428 EnableModeless(IOleInPlaceActiveObject);
3429 else if (IsIface(IOleInPlaceFrame))
3430 EnableModeless(IOleInPlaceFrame);
3431 else if (IsIface(IShellBrowser))
3432 EnableModeless(IShellBrowser);
3433 else if (IsIface(IInternetSecurityMgrSite))
3434 EnableModeless(IInternetSecurityMgrSite);
3435 else if (IsIface(IDocHostUIHandler))
3436 EnableModeless(IDocHostUIHandler);
3437 else
3438 return hRet;
3440 IUnknown_Release(lpObj);
3441 return S_OK;
3444 /*************************************************************************
3445 * @ [SHLWAPI.357]
3447 * See SHGetNewLinkInfoW.
3449 BOOL WINAPI SHGetNewLinkInfoWrapW(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName,
3450 BOOL *pfMustCopy, UINT uFlags)
3452 return SHGetNewLinkInfoW(pszLinkTo, pszDir, pszName, pfMustCopy, uFlags);
3455 /*************************************************************************
3456 * @ [SHLWAPI.358]
3458 * See SHDefExtractIconW.
3460 UINT WINAPI SHDefExtractIconWrapW(LPCWSTR pszIconFile, int iIndex, UINT uFlags, HICON* phiconLarge,
3461 HICON* phiconSmall, UINT nIconSize)
3463 return SHDefExtractIconW(pszIconFile, iIndex, uFlags, phiconLarge, phiconSmall, nIconSize);
3466 /*************************************************************************
3467 * @ [SHLWAPI.363]
3469 * Get and show a context menu from a shell folder.
3471 * PARAMS
3472 * hWnd [I] Window displaying the shell folder
3473 * lpFolder [I] IShellFolder interface
3474 * lpApidl [I] Id for the particular folder desired
3475 * dwCommandId [I] The command ID to invoke (0=invoke default)
3477 * RETURNS
3478 * Success: S_OK. If bInvokeDefault is TRUE, the default menu action was
3479 * executed.
3480 * Failure: An HRESULT error code indicating the error.
3482 HRESULT WINAPI SHInvokeCommand(HWND hWnd, IShellFolder* lpFolder, LPCITEMIDLIST lpApidl, DWORD dwCommandId)
3484 IContextMenu *iContext;
3485 HRESULT hRet;
3487 TRACE("(%p, %p, %p, %u)\n", hWnd, lpFolder, lpApidl, dwCommandId);
3489 if (!lpFolder)
3490 return E_FAIL;
3492 /* Get the context menu from the shell folder */
3493 hRet = IShellFolder_GetUIObjectOf(lpFolder, hWnd, 1, &lpApidl,
3494 &IID_IContextMenu, 0, (void**)&iContext);
3495 if (SUCCEEDED(hRet))
3497 HMENU hMenu;
3498 if ((hMenu = CreatePopupMenu()))
3500 HRESULT hQuery;
3502 /* Add the context menu entries to the popup */
3503 hQuery = IContextMenu_QueryContextMenu(iContext, hMenu, 0, 1, 0x7FFF,
3504 dwCommandId ? CMF_NORMAL : CMF_DEFAULTONLY);
3506 if (SUCCEEDED(hQuery))
3508 if (!dwCommandId)
3509 dwCommandId = GetMenuDefaultItem(hMenu, 0, 0);
3510 if (dwCommandId != (UINT)-1)
3512 CMINVOKECOMMANDINFO cmIci;
3513 /* Invoke the default item */
3514 memset(&cmIci,0,sizeof(cmIci));
3515 cmIci.cbSize = sizeof(cmIci);
3516 cmIci.fMask = CMIC_MASK_ASYNCOK;
3517 cmIci.hwnd = hWnd;
3518 cmIci.lpVerb = MAKEINTRESOURCEA(dwCommandId);
3519 cmIci.nShow = SW_SHOWNORMAL;
3521 hRet = IContextMenu_InvokeCommand(iContext, &cmIci);
3524 DestroyMenu(hMenu);
3526 IContextMenu_Release(iContext);
3528 return hRet;
3531 /*************************************************************************
3532 * @ [SHLWAPI.370]
3534 * See ExtractIconW.
3536 HICON WINAPI ExtractIconWrapW(HINSTANCE hInstance, LPCWSTR lpszExeFileName,
3537 UINT nIconIndex)
3539 return ExtractIconW(hInstance, lpszExeFileName, nIconIndex);
3542 /*************************************************************************
3543 * @ [SHLWAPI.377]
3545 * Load a library from the directory of a particular process.
3547 * PARAMS
3548 * new_mod [I] Library name
3549 * inst_hwnd [I] Module whose directory is to be used
3550 * dwCrossCodePage [I] Should be FALSE (currently ignored)
3552 * RETURNS
3553 * Success: A handle to the loaded module
3554 * Failure: A NULL handle.
3556 HMODULE WINAPI MLLoadLibraryA(LPCSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3558 /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
3559 * each call here.
3560 * FIXME: Native shows calls to:
3561 * SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
3562 * CheckVersion
3563 * RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
3564 * RegQueryValueExA for "LPKInstalled"
3565 * RegCloseKey
3566 * RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
3567 * RegQueryValueExA for "ResourceLocale"
3568 * RegCloseKey
3569 * RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
3570 * RegQueryValueExA for "Locale"
3571 * RegCloseKey
3572 * and then tests the Locale ("en" for me).
3573 * code below
3574 * after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
3576 CHAR mod_path[2*MAX_PATH];
3577 LPSTR ptr;
3578 DWORD len;
3580 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_a(new_mod), inst_hwnd, dwCrossCodePage);
3581 len = GetModuleFileNameA(inst_hwnd, mod_path, sizeof(mod_path));
3582 if (!len || len >= sizeof(mod_path)) return NULL;
3584 ptr = strrchr(mod_path, '\\');
3585 if (ptr) {
3586 strcpy(ptr+1, new_mod);
3587 TRACE("loading %s\n", debugstr_a(mod_path));
3588 return LoadLibraryA(mod_path);
3590 return NULL;
3593 /*************************************************************************
3594 * @ [SHLWAPI.378]
3596 * Unicode version of MLLoadLibraryA.
3598 HMODULE WINAPI MLLoadLibraryW(LPCWSTR new_mod, HMODULE inst_hwnd, DWORD dwCrossCodePage)
3600 WCHAR mod_path[2*MAX_PATH];
3601 LPWSTR ptr;
3602 DWORD len;
3604 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_w(new_mod), inst_hwnd, dwCrossCodePage);
3605 len = GetModuleFileNameW(inst_hwnd, mod_path, sizeof(mod_path) / sizeof(WCHAR));
3606 if (!len || len >= sizeof(mod_path) / sizeof(WCHAR)) return NULL;
3608 ptr = strrchrW(mod_path, '\\');
3609 if (ptr) {
3610 strcpyW(ptr+1, new_mod);
3611 TRACE("loading %s\n", debugstr_w(mod_path));
3612 return LoadLibraryW(mod_path);
3614 return NULL;
3617 /*************************************************************************
3618 * ColorAdjustLuma [SHLWAPI.@]
3620 * Adjust the luminosity of a color
3622 * PARAMS
3623 * cRGB [I] RGB value to convert
3624 * dwLuma [I] Luma adjustment
3625 * bUnknown [I] Unknown
3627 * RETURNS
3628 * The adjusted RGB color.
3630 COLORREF WINAPI ColorAdjustLuma(COLORREF cRGB, int dwLuma, BOOL bUnknown)
3632 TRACE("(0x%8x,%d,%d)\n", cRGB, dwLuma, bUnknown);
3634 if (dwLuma)
3636 WORD wH, wL, wS;
3638 ColorRGBToHLS(cRGB, &wH, &wL, &wS);
3640 FIXME("Ignoring luma adjustment\n");
3642 /* FIXME: The adjustment is not linear */
3644 cRGB = ColorHLSToRGB(wH, wL, wS);
3646 return cRGB;
3649 /*************************************************************************
3650 * @ [SHLWAPI.389]
3652 * See GetSaveFileNameW.
3654 BOOL WINAPI GetSaveFileNameWrapW(LPOPENFILENAMEW ofn)
3656 return GetSaveFileNameW(ofn);
3659 /*************************************************************************
3660 * @ [SHLWAPI.390]
3662 * See WNetRestoreConnectionW.
3664 DWORD WINAPI WNetRestoreConnectionWrapW(HWND hwndOwner, LPWSTR lpszDevice)
3666 return WNetRestoreConnectionW(hwndOwner, lpszDevice);
3669 /*************************************************************************
3670 * @ [SHLWAPI.391]
3672 * See WNetGetLastErrorW.
3674 DWORD WINAPI WNetGetLastErrorWrapW(LPDWORD lpError, LPWSTR lpErrorBuf, DWORD nErrorBufSize,
3675 LPWSTR lpNameBuf, DWORD nNameBufSize)
3677 return WNetGetLastErrorW(lpError, lpErrorBuf, nErrorBufSize, lpNameBuf, nNameBufSize);
3680 /*************************************************************************
3681 * @ [SHLWAPI.401]
3683 * See PageSetupDlgW.
3685 BOOL WINAPI PageSetupDlgWrapW(LPPAGESETUPDLGW pagedlg)
3687 return PageSetupDlgW(pagedlg);
3690 /*************************************************************************
3691 * @ [SHLWAPI.402]
3693 * See PrintDlgW.
3695 BOOL WINAPI PrintDlgWrapW(LPPRINTDLGW printdlg)
3697 return PrintDlgW(printdlg);
3700 /*************************************************************************
3701 * @ [SHLWAPI.403]
3703 * See GetOpenFileNameW.
3705 BOOL WINAPI GetOpenFileNameWrapW(LPOPENFILENAMEW ofn)
3707 return GetOpenFileNameW(ofn);
3710 /*************************************************************************
3711 * @ [SHLWAPI.404]
3713 HRESULT WINAPI SHIShellFolder_EnumObjects(LPSHELLFOLDER lpFolder, HWND hwnd, SHCONTF flags, IEnumIDList **ppenum)
3715 /* Windows attempts to get an IPersist interface and, if that fails, an
3716 * IPersistFolder interface on the folder passed-in here. If one of those
3717 * interfaces is available, it then calls GetClassID on the folder... and
3718 * then calls IShellFolder_EnumObjects no matter what, even crashing if
3719 * lpFolder isn't actually an IShellFolder object. The purpose of getting
3720 * the ClassID is unknown, so we don't do it here.
3722 * For discussion and detailed tests, see:
3723 * "shlwapi: Be less strict on which type of IShellFolder can be enumerated"
3724 * wine-devel mailing list, 3 Jun 2010
3727 return IShellFolder_EnumObjects(lpFolder, hwnd, flags, ppenum);
3730 /* INTERNAL: Map from HLS color space to RGB */
3731 static WORD ConvertHue(int wHue, WORD wMid1, WORD wMid2)
3733 wHue = wHue > 240 ? wHue - 240 : wHue < 0 ? wHue + 240 : wHue;
3735 if (wHue > 160)
3736 return wMid1;
3737 else if (wHue > 120)
3738 wHue = 160 - wHue;
3739 else if (wHue > 40)
3740 return wMid2;
3742 return ((wHue * (wMid2 - wMid1) + 20) / 40) + wMid1;
3745 /* Convert to RGB and scale into RGB range (0..255) */
3746 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
3748 /*************************************************************************
3749 * ColorHLSToRGB [SHLWAPI.@]
3751 * Convert from hls color space into an rgb COLORREF.
3753 * PARAMS
3754 * wHue [I] Hue amount
3755 * wLuminosity [I] Luminosity amount
3756 * wSaturation [I] Saturation amount
3758 * RETURNS
3759 * A COLORREF representing the converted color.
3761 * NOTES
3762 * Input hls values are constrained to the range (0..240).
3764 COLORREF WINAPI ColorHLSToRGB(WORD wHue, WORD wLuminosity, WORD wSaturation)
3766 WORD wRed;
3768 if (wSaturation)
3770 WORD wGreen, wBlue, wMid1, wMid2;
3772 if (wLuminosity > 120)
3773 wMid2 = wSaturation + wLuminosity - (wSaturation * wLuminosity + 120) / 240;
3774 else
3775 wMid2 = ((wSaturation + 240) * wLuminosity + 120) / 240;
3777 wMid1 = wLuminosity * 2 - wMid2;
3779 wRed = GET_RGB(wHue + 80);
3780 wGreen = GET_RGB(wHue);
3781 wBlue = GET_RGB(wHue - 80);
3783 return RGB(wRed, wGreen, wBlue);
3786 wRed = wLuminosity * 255 / 240;
3787 return RGB(wRed, wRed, wRed);
3790 /*************************************************************************
3791 * @ [SHLWAPI.413]
3793 * Get the current docking status of the system.
3795 * PARAMS
3796 * dwFlags [I] DOCKINFO_ flags from "winbase.h", unused
3798 * RETURNS
3799 * One of DOCKINFO_UNDOCKED, DOCKINFO_UNDOCKED, or 0 if the system is not
3800 * a notebook.
3802 DWORD WINAPI SHGetMachineInfo(DWORD dwFlags)
3804 HW_PROFILE_INFOA hwInfo;
3806 TRACE("(0x%08x)\n", dwFlags);
3808 GetCurrentHwProfileA(&hwInfo);
3809 switch (hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED))
3811 case DOCKINFO_DOCKED:
3812 case DOCKINFO_UNDOCKED:
3813 return hwInfo.dwDockInfo & (DOCKINFO_DOCKED|DOCKINFO_UNDOCKED);
3814 default:
3815 return 0;
3819 /*************************************************************************
3820 * @ [SHLWAPI.416]
3823 DWORD WINAPI SHWinHelpOnDemandW(HWND hwnd, LPCWSTR helpfile, DWORD flags1, VOID *ptr1, DWORD flags2)
3826 FIXME("(%p, %s, 0x%x, %p, %d)\n", hwnd, debugstr_w(helpfile), flags1, ptr1, flags2);
3827 return 0;
3830 /*************************************************************************
3831 * @ [SHLWAPI.417]
3834 DWORD WINAPI SHWinHelpOnDemandA(HWND hwnd, LPCSTR helpfile, DWORD flags1, VOID *ptr1, DWORD flags2)
3837 FIXME("(%p, %s, 0x%x, %p, %d)\n", hwnd, debugstr_a(helpfile), flags1, ptr1, flags2);
3838 return 0;
3841 /*************************************************************************
3842 * @ [SHLWAPI.418]
3844 * Function seems to do FreeLibrary plus other things.
3846 * FIXME native shows the following calls:
3847 * RtlEnterCriticalSection
3848 * LocalFree
3849 * GetProcAddress(Comctl32??, 150L)
3850 * DPA_DeletePtr
3851 * RtlLeaveCriticalSection
3852 * followed by the FreeLibrary.
3853 * The above code may be related to .377 above.
3855 BOOL WINAPI MLFreeLibrary(HMODULE hModule)
3857 FIXME("(%p) semi-stub\n", hModule);
3858 return FreeLibrary(hModule);
3861 /*************************************************************************
3862 * @ [SHLWAPI.419]
3864 BOOL WINAPI SHFlushSFCacheWrap(void) {
3865 FIXME(": stub\n");
3866 return TRUE;
3869 /*************************************************************************
3870 * @ [SHLWAPI.429]
3871 * FIXME I have no idea what this function does or what its arguments are.
3873 BOOL WINAPI MLIsMLHInstance(HINSTANCE hInst)
3875 FIXME("(%p) stub\n", hInst);
3876 return FALSE;
3880 /*************************************************************************
3881 * @ [SHLWAPI.430]
3883 DWORD WINAPI MLSetMLHInstance(HINSTANCE hInst, HANDLE hHeap)
3885 FIXME("(%p,%p) stub\n", hInst, hHeap);
3886 return E_FAIL; /* This is what is used if shlwapi not loaded */
3889 /*************************************************************************
3890 * @ [SHLWAPI.431]
3892 DWORD WINAPI MLClearMLHInstance(DWORD x)
3894 FIXME("(0x%08x)stub\n", x);
3895 return 0xabba1247;
3898 /*************************************************************************
3899 * @ [SHLWAPI.432]
3901 * See SHSendMessageBroadcastW
3904 DWORD WINAPI SHSendMessageBroadcastA(UINT uMsg, WPARAM wParam, LPARAM lParam)
3906 return SendMessageTimeoutA(HWND_BROADCAST, uMsg, wParam, lParam,
3907 SMTO_ABORTIFHUNG, 2000, NULL);
3910 /*************************************************************************
3911 * @ [SHLWAPI.433]
3913 * A wrapper for sending Broadcast Messages to all top level Windows
3916 DWORD WINAPI SHSendMessageBroadcastW(UINT uMsg, WPARAM wParam, LPARAM lParam)
3918 return SendMessageTimeoutW(HWND_BROADCAST, uMsg, wParam, lParam,
3919 SMTO_ABORTIFHUNG, 2000, NULL);
3922 /*************************************************************************
3923 * @ [SHLWAPI.436]
3925 * Convert a Unicode string CLSID into a CLSID.
3927 * PARAMS
3928 * idstr [I] string containing a CLSID in text form
3929 * id [O] CLSID extracted from the string
3931 * RETURNS
3932 * S_OK on success or E_INVALIDARG on failure
3934 HRESULT WINAPI CLSIDFromStringWrap(LPCWSTR idstr, CLSID *id)
3936 return CLSIDFromString((LPCOLESTR)idstr, id);
3939 /*************************************************************************
3940 * @ [SHLWAPI.437]
3942 * Determine if the OS supports a given feature.
3944 * PARAMS
3945 * dwFeature [I] Feature requested (undocumented)
3947 * RETURNS
3948 * TRUE If the feature is available.
3949 * FALSE If the feature is not available.
3951 BOOL WINAPI IsOS(DWORD feature)
3953 OSVERSIONINFOA osvi;
3954 DWORD platform, majorv, minorv;
3956 osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOA);
3957 if(!GetVersionExA(&osvi)) {
3958 ERR("GetVersionEx failed\n");
3959 return FALSE;
3962 majorv = osvi.dwMajorVersion;
3963 minorv = osvi.dwMinorVersion;
3964 platform = osvi.dwPlatformId;
3966 #define ISOS_RETURN(x) \
3967 TRACE("(0x%x) ret=%d\n",feature,(x)); \
3968 return (x);
3970 switch(feature) {
3971 case OS_WIN32SORGREATER:
3972 ISOS_RETURN(platform == VER_PLATFORM_WIN32s
3973 || platform == VER_PLATFORM_WIN32_WINDOWS)
3974 case OS_NT:
3975 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
3976 case OS_WIN95ORGREATER:
3977 ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS)
3978 case OS_NT4ORGREATER:
3979 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 4)
3980 case OS_WIN2000ORGREATER_ALT:
3981 case OS_WIN2000ORGREATER:
3982 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
3983 case OS_WIN98ORGREATER:
3984 ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 10)
3985 case OS_WIN98_GOLD:
3986 ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 10)
3987 case OS_WIN2000PRO:
3988 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
3989 case OS_WIN2000SERVER:
3990 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3991 case OS_WIN2000ADVSERVER:
3992 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3993 case OS_WIN2000DATACENTER:
3994 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3995 case OS_WIN2000TERMINAL:
3996 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && (minorv == 0 || minorv == 1))
3997 case OS_EMBEDDED:
3998 FIXME("(OS_EMBEDDED) What should we return here?\n");
3999 return FALSE;
4000 case OS_TERMINALCLIENT:
4001 FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
4002 return FALSE;
4003 case OS_TERMINALREMOTEADMIN:
4004 FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
4005 return FALSE;
4006 case OS_WIN95_GOLD:
4007 ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv == 0)
4008 case OS_MEORGREATER:
4009 ISOS_RETURN(platform == VER_PLATFORM_WIN32_WINDOWS && minorv >= 90)
4010 case OS_XPORGREATER:
4011 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1)
4012 case OS_HOME:
4013 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5 && minorv >= 1)
4014 case OS_PROFESSIONAL:
4015 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
4016 case OS_DATACENTER:
4017 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
4018 case OS_ADVSERVER:
4019 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 5)
4020 case OS_SERVER:
4021 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
4022 case OS_TERMINALSERVER:
4023 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
4024 case OS_PERSONALTERMINALSERVER:
4025 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && minorv >= 1 && majorv >= 5)
4026 case OS_FASTUSERSWITCHING:
4027 FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
4028 return TRUE;
4029 case OS_WELCOMELOGONUI:
4030 FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
4031 return FALSE;
4032 case OS_DOMAINMEMBER:
4033 FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
4034 return TRUE;
4035 case OS_ANYSERVER:
4036 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
4037 case OS_WOW6432:
4039 BOOL is_wow64;
4040 IsWow64Process(GetCurrentProcess(), &is_wow64);
4041 return is_wow64;
4043 case OS_WEBSERVER:
4044 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
4045 case OS_SMALLBUSINESSSERVER:
4046 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT)
4047 case OS_TABLETPC:
4048 FIXME("(OS_TABLEPC) What should we return here?\n");
4049 return FALSE;
4050 case OS_SERVERADMINUI:
4051 FIXME("(OS_SERVERADMINUI) What should we return here?\n");
4052 return FALSE;
4053 case OS_MEDIACENTER:
4054 FIXME("(OS_MEDIACENTER) What should we return here?\n");
4055 return FALSE;
4056 case OS_APPLIANCE:
4057 FIXME("(OS_APPLIANCE) What should we return here?\n");
4058 return FALSE;
4059 case 0x25: /*OS_VISTAORGREATER*/
4060 ISOS_RETURN(platform == VER_PLATFORM_WIN32_NT && majorv >= 6)
4063 #undef ISOS_RETURN
4065 WARN("(0x%x) unknown parameter\n",feature);
4067 return FALSE;
4070 /*************************************************************************
4071 * @ [SHLWAPI.439]
4073 HRESULT WINAPI SHLoadRegUIStringW(HKEY hkey, LPCWSTR value, LPWSTR buf, DWORD size)
4075 DWORD type, sz = size;
4077 if(RegQueryValueExW(hkey, value, NULL, &type, (LPBYTE)buf, &sz) != ERROR_SUCCESS)
4078 return E_FAIL;
4080 return SHLoadIndirectString(buf, buf, size, NULL);
4083 /*************************************************************************
4084 * @ [SHLWAPI.478]
4086 * Call IInputObject_TranslateAcceleratorIO() on an object.
4088 * PARAMS
4089 * lpUnknown [I] Object supporting the IInputObject interface.
4090 * lpMsg [I] Key message to be processed.
4092 * RETURNS
4093 * Success: S_OK.
4094 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
4096 HRESULT WINAPI IUnknown_TranslateAcceleratorIO(IUnknown *lpUnknown, LPMSG lpMsg)
4098 IInputObject* lpInput = NULL;
4099 HRESULT hRet = E_INVALIDARG;
4101 TRACE("(%p,%p)\n", lpUnknown, lpMsg);
4102 if (lpUnknown)
4104 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObject,
4105 (void**)&lpInput);
4106 if (SUCCEEDED(hRet) && lpInput)
4108 hRet = IInputObject_TranslateAcceleratorIO(lpInput, lpMsg);
4109 IInputObject_Release(lpInput);
4112 return hRet;
4115 /*************************************************************************
4116 * @ [SHLWAPI.481]
4118 * Call IInputObject_HasFocusIO() on an object.
4120 * PARAMS
4121 * lpUnknown [I] Object supporting the IInputObject interface.
4123 * RETURNS
4124 * Success: S_OK, if lpUnknown is an IInputObject object and has the focus,
4125 * or S_FALSE otherwise.
4126 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
4128 HRESULT WINAPI IUnknown_HasFocusIO(IUnknown *lpUnknown)
4130 IInputObject* lpInput = NULL;
4131 HRESULT hRet = E_INVALIDARG;
4133 TRACE("(%p)\n", lpUnknown);
4134 if (lpUnknown)
4136 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObject,
4137 (void**)&lpInput);
4138 if (SUCCEEDED(hRet) && lpInput)
4140 hRet = IInputObject_HasFocusIO(lpInput);
4141 IInputObject_Release(lpInput);
4144 return hRet;
4147 /*************************************************************************
4148 * ColorRGBToHLS [SHLWAPI.@]
4150 * Convert an rgb COLORREF into the hls color space.
4152 * PARAMS
4153 * cRGB [I] Source rgb value
4154 * pwHue [O] Destination for converted hue
4155 * pwLuminance [O] Destination for converted luminance
4156 * pwSaturation [O] Destination for converted saturation
4158 * RETURNS
4159 * Nothing. pwHue, pwLuminance and pwSaturation are set to the converted
4160 * values.
4162 * NOTES
4163 * Output HLS values are constrained to the range (0..240).
4164 * For Achromatic conversions, Hue is set to 160.
4166 VOID WINAPI ColorRGBToHLS(COLORREF cRGB, LPWORD pwHue,
4167 LPWORD pwLuminance, LPWORD pwSaturation)
4169 int wR, wG, wB, wMax, wMin, wHue, wLuminosity, wSaturation;
4171 TRACE("(%08x,%p,%p,%p)\n", cRGB, pwHue, pwLuminance, pwSaturation);
4173 wR = GetRValue(cRGB);
4174 wG = GetGValue(cRGB);
4175 wB = GetBValue(cRGB);
4177 wMax = max(wR, max(wG, wB));
4178 wMin = min(wR, min(wG, wB));
4180 /* Luminosity */
4181 wLuminosity = ((wMax + wMin) * 240 + 255) / 510;
4183 if (wMax == wMin)
4185 /* Achromatic case */
4186 wSaturation = 0;
4187 /* Hue is now unrepresentable, but this is what native returns... */
4188 wHue = 160;
4190 else
4192 /* Chromatic case */
4193 int wDelta = wMax - wMin, wRNorm, wGNorm, wBNorm;
4195 /* Saturation */
4196 if (wLuminosity <= 120)
4197 wSaturation = ((wMax + wMin)/2 + wDelta * 240) / (wMax + wMin);
4198 else
4199 wSaturation = ((510 - wMax - wMin)/2 + wDelta * 240) / (510 - wMax - wMin);
4201 /* Hue */
4202 wRNorm = (wDelta/2 + wMax * 40 - wR * 40) / wDelta;
4203 wGNorm = (wDelta/2 + wMax * 40 - wG * 40) / wDelta;
4204 wBNorm = (wDelta/2 + wMax * 40 - wB * 40) / wDelta;
4206 if (wR == wMax)
4207 wHue = wBNorm - wGNorm;
4208 else if (wG == wMax)
4209 wHue = 80 + wRNorm - wBNorm;
4210 else
4211 wHue = 160 + wGNorm - wRNorm;
4212 if (wHue < 0)
4213 wHue += 240;
4214 else if (wHue > 240)
4215 wHue -= 240;
4217 if (pwHue)
4218 *pwHue = wHue;
4219 if (pwLuminance)
4220 *pwLuminance = wLuminosity;
4221 if (pwSaturation)
4222 *pwSaturation = wSaturation;
4225 /*************************************************************************
4226 * SHCreateShellPalette [SHLWAPI.@]
4228 HPALETTE WINAPI SHCreateShellPalette(HDC hdc)
4230 FIXME("stub\n");
4231 return CreateHalftonePalette(hdc);
4234 /*************************************************************************
4235 * SHGetInverseCMAP (SHLWAPI.@)
4237 * Get an inverse color map table.
4239 * PARAMS
4240 * lpCmap [O] Destination for color map
4241 * dwSize [I] Size of memory pointed to by lpCmap
4243 * RETURNS
4244 * Success: S_OK.
4245 * Failure: E_POINTER, If lpCmap is invalid.
4246 * E_INVALIDARG, If dwFlags is invalid
4247 * E_OUTOFMEMORY, If there is no memory available
4249 * NOTES
4250 * dwSize may only be CMAP_PTR_SIZE (4) or CMAP_SIZE (8192).
4251 * If dwSize = CMAP_PTR_SIZE, *lpCmap is set to the address of this DLL's
4252 * internal CMap.
4253 * If dwSize = CMAP_SIZE, lpCmap is filled with a copy of the data from
4254 * this DLL's internal CMap.
4256 HRESULT WINAPI SHGetInverseCMAP(LPDWORD dest, DWORD dwSize)
4258 if (dwSize == 4) {
4259 FIXME(" - returning bogus address for SHGetInverseCMAP\n");
4260 *dest = (DWORD)0xabba1249;
4261 return 0;
4263 FIXME("(%p, %#x) stub\n", dest, dwSize);
4264 return 0;
4267 /*************************************************************************
4268 * SHIsLowMemoryMachine [SHLWAPI.@]
4270 * Determine if the current computer has low memory.
4272 * PARAMS
4273 * x [I] FIXME
4275 * RETURNS
4276 * TRUE if the users machine has 16 Megabytes of memory or less,
4277 * FALSE otherwise.
4279 BOOL WINAPI SHIsLowMemoryMachine (DWORD x)
4281 FIXME("(0x%08x) stub\n", x);
4282 return FALSE;
4285 /*************************************************************************
4286 * GetMenuPosFromID [SHLWAPI.@]
4288 * Return the position of a menu item from its Id.
4290 * PARAMS
4291 * hMenu [I] Menu containing the item
4292 * wID [I] Id of the menu item
4294 * RETURNS
4295 * Success: The index of the menu item in hMenu.
4296 * Failure: -1, If the item is not found.
4298 INT WINAPI GetMenuPosFromID(HMENU hMenu, UINT wID)
4300 MENUITEMINFOW mi;
4301 INT nCount = GetMenuItemCount(hMenu), nIter = 0;
4303 TRACE("%p %u\n", hMenu, wID);
4305 while (nIter < nCount)
4307 mi.cbSize = sizeof(mi);
4308 mi.fMask = MIIM_ID;
4309 if (GetMenuItemInfoW(hMenu, nIter, TRUE, &mi) && mi.wID == wID)
4311 TRACE("ret %d\n", nIter);
4312 return nIter;
4314 nIter++;
4317 return -1;
4320 /*************************************************************************
4321 * @ [SHLWAPI.179]
4323 * Same as SHLWAPI.GetMenuPosFromID
4325 DWORD WINAPI SHMenuIndexFromID(HMENU hMenu, UINT uID)
4327 TRACE("%p %u\n", hMenu, uID);
4328 return GetMenuPosFromID(hMenu, uID);
4332 /*************************************************************************
4333 * @ [SHLWAPI.448]
4335 VOID WINAPI FixSlashesAndColonW(LPWSTR lpwstr)
4337 while (*lpwstr)
4339 if (*lpwstr == '/')
4340 *lpwstr = '\\';
4341 lpwstr++;
4346 /*************************************************************************
4347 * @ [SHLWAPI.461]
4349 DWORD WINAPI SHGetAppCompatFlags(DWORD dwUnknown)
4351 FIXME("(0x%08x) stub\n", dwUnknown);
4352 return 0;
4356 /*************************************************************************
4357 * @ [SHLWAPI.549]
4359 HRESULT WINAPI SHCoCreateInstanceAC(REFCLSID rclsid, LPUNKNOWN pUnkOuter,
4360 DWORD dwClsContext, REFIID iid, LPVOID *ppv)
4362 return CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, ppv);
4365 /*************************************************************************
4366 * SHSkipJunction [SHLWAPI.@]
4368 * Determine if a bind context can be bound to an object
4370 * PARAMS
4371 * pbc [I] Bind context to check
4372 * pclsid [I] CLSID of object to be bound to
4374 * RETURNS
4375 * TRUE: If it is safe to bind
4376 * FALSE: If pbc is invalid or binding would not be safe
4379 BOOL WINAPI SHSkipJunction(IBindCtx *pbc, const CLSID *pclsid)
4381 static WCHAR szSkipBinding[] = { 'S','k','i','p',' ',
4382 'B','i','n','d','i','n','g',' ','C','L','S','I','D','\0' };
4383 BOOL bRet = FALSE;
4385 if (pbc)
4387 IUnknown* lpUnk;
4389 if (SUCCEEDED(IBindCtx_GetObjectParam(pbc, szSkipBinding, &lpUnk)))
4391 CLSID clsid;
4393 if (SUCCEEDED(IUnknown_GetClassID(lpUnk, &clsid)) &&
4394 IsEqualGUID(pclsid, &clsid))
4395 bRet = TRUE;
4397 IUnknown_Release(lpUnk);
4400 return bRet;
4403 /***********************************************************************
4404 * SHGetShellKey (SHLWAPI.491)
4406 HKEY WINAPI SHGetShellKey(DWORD flags, LPCWSTR sub_key, BOOL create)
4408 enum _shellkey_flags {
4409 SHKEY_Root_HKCU = 0x1,
4410 SHKEY_Root_HKLM = 0x2,
4411 SHKEY_Key_Explorer = 0x00,
4412 SHKEY_Key_Shell = 0x10,
4413 SHKEY_Key_ShellNoRoam = 0x20,
4414 SHKEY_Key_Classes = 0x30,
4415 SHKEY_Subkey_Default = 0x0000,
4416 SHKEY_Subkey_ResourceName = 0x1000,
4417 SHKEY_Subkey_Handlers = 0x2000,
4418 SHKEY_Subkey_Associations = 0x3000,
4419 SHKEY_Subkey_Volatile = 0x4000,
4420 SHKEY_Subkey_MUICache = 0x5000,
4421 SHKEY_Subkey_FileExts = 0x6000
4424 static const WCHAR explorerW[] = {'S','o','f','t','w','a','r','e','\\',
4425 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
4426 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
4427 'E','x','p','l','o','r','e','r','\\'};
4428 static const WCHAR shellW[] = {'S','o','f','t','w','a','r','e','\\',
4429 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
4430 'S','h','e','l','l','\\'};
4431 static const WCHAR shell_no_roamW[] = {'S','o','f','t','w','a','r','e','\\',
4432 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
4433 'S','h','e','l','l','N','o','R','o','a','m','\\'};
4434 static const WCHAR classesW[] = {'S','o','f','t','w','a','r','e','\\',
4435 'C','l','a','s','s','e','s','\\'};
4437 static const WCHAR localized_resource_nameW[] = {'L','o','c','a','l','i','z','e','d',
4438 'R','e','s','o','u','r','c','e','N','a','m','e','\\'};
4439 static const WCHAR handlersW[] = {'H','a','n','d','l','e','r','s','\\'};
4440 static const WCHAR associationsW[] = {'A','s','s','o','c','i','a','t','i','o','n','s','\\'};
4441 static const WCHAR volatileW[] = {'V','o','l','a','t','i','l','e','\\'};
4442 static const WCHAR mui_cacheW[] = {'M','U','I','C','a','c','h','e','\\'};
4443 static const WCHAR file_extsW[] = {'F','i','l','e','E','x','t','s','\\'};
4445 WCHAR *path;
4446 const WCHAR *key, *subkey;
4447 int size_key, size_subkey, size_user;
4448 HKEY hkey = NULL;
4450 TRACE("(0x%08x, %s, %d)\n", flags, debugstr_w(sub_key), create);
4452 /* For compatibility with Vista+ */
4453 if(flags == 0x1ffff)
4454 flags = 0x21;
4456 switch(flags&0xff0) {
4457 case SHKEY_Key_Explorer:
4458 key = explorerW;
4459 size_key = sizeof(explorerW);
4460 break;
4461 case SHKEY_Key_Shell:
4462 key = shellW;
4463 size_key = sizeof(shellW);
4464 break;
4465 case SHKEY_Key_ShellNoRoam:
4466 key = shell_no_roamW;
4467 size_key = sizeof(shell_no_roamW);
4468 break;
4469 case SHKEY_Key_Classes:
4470 key = classesW;
4471 size_key = sizeof(classesW);
4472 break;
4473 default:
4474 FIXME("unsupported flags (0x%08x)\n", flags);
4475 return NULL;
4478 switch(flags&0xff000) {
4479 case SHKEY_Subkey_Default:
4480 subkey = NULL;
4481 size_subkey = 0;
4482 break;
4483 case SHKEY_Subkey_ResourceName:
4484 subkey = localized_resource_nameW;
4485 size_subkey = sizeof(localized_resource_nameW);
4486 break;
4487 case SHKEY_Subkey_Handlers:
4488 subkey = handlersW;
4489 size_subkey = sizeof(handlersW);
4490 break;
4491 case SHKEY_Subkey_Associations:
4492 subkey = associationsW;
4493 size_subkey = sizeof(associationsW);
4494 break;
4495 case SHKEY_Subkey_Volatile:
4496 subkey = volatileW;
4497 size_subkey = sizeof(volatileW);
4498 break;
4499 case SHKEY_Subkey_MUICache:
4500 subkey = mui_cacheW;
4501 size_subkey = sizeof(mui_cacheW);
4502 break;
4503 case SHKEY_Subkey_FileExts:
4504 subkey = file_extsW;
4505 size_subkey = sizeof(file_extsW);
4506 break;
4507 default:
4508 FIXME("unsupported flags (0x%08x)\n", flags);
4509 return NULL;
4512 if(sub_key)
4513 size_user = lstrlenW(sub_key)*sizeof(WCHAR);
4514 else
4515 size_user = 0;
4517 path = HeapAlloc(GetProcessHeap(), 0, size_key+size_subkey+size_user+sizeof(WCHAR));
4518 if(!path) {
4519 ERR("Out of memory\n");
4520 return NULL;
4523 memcpy(path, key, size_key);
4524 if(subkey)
4525 memcpy(path+size_key/sizeof(WCHAR), subkey, size_subkey);
4526 if(sub_key)
4527 memcpy(path+(size_key+size_subkey)/sizeof(WCHAR), sub_key, size_user);
4528 path[(size_key+size_subkey+size_user)/sizeof(WCHAR)] = '\0';
4530 if(create)
4531 RegCreateKeyExW((flags&0xf)==SHKEY_Root_HKLM?HKEY_LOCAL_MACHINE:HKEY_CURRENT_USER,
4532 path, 0, NULL, 0, MAXIMUM_ALLOWED, NULL, &hkey, NULL);
4533 else
4534 RegOpenKeyExW((flags&0xf)==SHKEY_Root_HKLM?HKEY_LOCAL_MACHINE:HKEY_CURRENT_USER,
4535 path, 0, MAXIMUM_ALLOWED, &hkey);
4537 HeapFree(GetProcessHeap(), 0, path);
4538 return hkey;
4541 /***********************************************************************
4542 * SHQueueUserWorkItem (SHLWAPI.@)
4544 BOOL WINAPI SHQueueUserWorkItem(LPTHREAD_START_ROUTINE pfnCallback,
4545 LPVOID pContext, LONG lPriority, DWORD_PTR dwTag,
4546 DWORD_PTR *pdwId, LPCSTR pszModule, DWORD dwFlags)
4548 TRACE("(%p, %p, %d, %lx, %p, %s, %08x)\n", pfnCallback, pContext,
4549 lPriority, dwTag, pdwId, debugstr_a(pszModule), dwFlags);
4551 if(lPriority || dwTag || pdwId || pszModule || dwFlags)
4552 FIXME("Unsupported arguments\n");
4554 return QueueUserWorkItem(pfnCallback, pContext, 0);
4557 /***********************************************************************
4558 * SHSetTimerQueueTimer (SHLWAPI.263)
4560 HANDLE WINAPI SHSetTimerQueueTimer(HANDLE hQueue,
4561 WAITORTIMERCALLBACK pfnCallback, LPVOID pContext, DWORD dwDueTime,
4562 DWORD dwPeriod, LPCSTR lpszLibrary, DWORD dwFlags)
4564 HANDLE hNewTimer;
4566 /* SHSetTimerQueueTimer flags -> CreateTimerQueueTimer flags */
4567 if (dwFlags & TPS_LONGEXECTIME) {
4568 dwFlags &= ~TPS_LONGEXECTIME;
4569 dwFlags |= WT_EXECUTELONGFUNCTION;
4571 if (dwFlags & TPS_EXECUTEIO) {
4572 dwFlags &= ~TPS_EXECUTEIO;
4573 dwFlags |= WT_EXECUTEINIOTHREAD;
4576 if (!CreateTimerQueueTimer(&hNewTimer, hQueue, pfnCallback, pContext,
4577 dwDueTime, dwPeriod, dwFlags))
4578 return NULL;
4580 return hNewTimer;
4583 /***********************************************************************
4584 * IUnknown_OnFocusChangeIS (SHLWAPI.@)
4586 HRESULT WINAPI IUnknown_OnFocusChangeIS(LPUNKNOWN lpUnknown, LPUNKNOWN pFocusObject, BOOL bFocus)
4588 IInputObjectSite *pIOS = NULL;
4589 HRESULT hRet = E_INVALIDARG;
4591 TRACE("(%p, %p, %s)\n", lpUnknown, pFocusObject, bFocus ? "TRUE" : "FALSE");
4593 if (lpUnknown)
4595 hRet = IUnknown_QueryInterface(lpUnknown, &IID_IInputObjectSite,
4596 (void **)&pIOS);
4597 if (SUCCEEDED(hRet) && pIOS)
4599 hRet = IInputObjectSite_OnFocusChangeIS(pIOS, pFocusObject, bFocus);
4600 IInputObjectSite_Release(pIOS);
4603 return hRet;
4606 /***********************************************************************
4607 * SKAllocValueW (SHLWAPI.519)
4609 HRESULT WINAPI SKAllocValueW(DWORD flags, LPCWSTR subkey, LPCWSTR value, DWORD *type,
4610 LPVOID *data, DWORD *count)
4612 DWORD ret, size;
4613 HKEY hkey;
4615 TRACE("(0x%x, %s, %s, %p, %p, %p)\n", flags, debugstr_w(subkey),
4616 debugstr_w(value), type, data, count);
4618 hkey = SHGetShellKey(flags, subkey, FALSE);
4619 if (!hkey)
4620 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
4622 ret = SHQueryValueExW(hkey, value, NULL, type, NULL, &size);
4623 if (ret) {
4624 RegCloseKey(hkey);
4625 return HRESULT_FROM_WIN32(ret);
4628 size += 2;
4629 *data = LocalAlloc(0, size);
4630 if (!*data) {
4631 RegCloseKey(hkey);
4632 return E_OUTOFMEMORY;
4635 ret = SHQueryValueExW(hkey, value, NULL, type, *data, &size);
4636 if (count)
4637 *count = size;
4639 RegCloseKey(hkey);
4640 return HRESULT_FROM_WIN32(ret);
4643 /***********************************************************************
4644 * SKDeleteValueW (SHLWAPI.518)
4646 HRESULT WINAPI SKDeleteValueW(DWORD flags, LPCWSTR subkey, LPCWSTR value)
4648 DWORD ret;
4649 HKEY hkey;
4651 TRACE("(0x%x, %s %s)\n", flags, debugstr_w(subkey), debugstr_w(value));
4653 hkey = SHGetShellKey(flags, subkey, FALSE);
4654 if (!hkey)
4655 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
4657 ret = RegDeleteValueW(hkey, value);
4659 RegCloseKey(hkey);
4660 return HRESULT_FROM_WIN32(ret);
4663 /***********************************************************************
4664 * SKGetValueW (SHLWAPI.516)
4666 HRESULT WINAPI SKGetValueW(DWORD flags, LPCWSTR subkey, LPCWSTR value, DWORD *type,
4667 void *data, DWORD *count)
4669 DWORD ret;
4670 HKEY hkey;
4672 TRACE("(0x%x, %s, %s, %p, %p, %p)\n", flags, debugstr_w(subkey),
4673 debugstr_w(value), type, data, count);
4675 hkey = SHGetShellKey(flags, subkey, FALSE);
4676 if (!hkey)
4677 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
4679 ret = SHQueryValueExW(hkey, value, NULL, type, data, count);
4681 RegCloseKey(hkey);
4682 return HRESULT_FROM_WIN32(ret);
4685 /***********************************************************************
4686 * SKSetValueW (SHLWAPI.516)
4688 HRESULT WINAPI SKSetValueW(DWORD flags, LPCWSTR subkey, LPCWSTR value,
4689 DWORD type, void *data, DWORD count)
4691 DWORD ret;
4692 HKEY hkey;
4694 TRACE("(0x%x, %s, %s, %x, %p, %d)\n", flags, debugstr_w(subkey),
4695 debugstr_w(value), type, data, count);
4697 hkey = SHGetShellKey(flags, subkey, TRUE);
4698 if (!hkey)
4699 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
4701 ret = RegSetValueExW(hkey, value, 0, type, data, count);
4703 RegCloseKey(hkey);
4704 return HRESULT_FROM_WIN32(ret);
4707 typedef HRESULT (WINAPI *DllGetVersion_func)(DLLVERSIONINFO *);
4709 /***********************************************************************
4710 * GetUIVersion (SHLWAPI.452)
4712 DWORD WINAPI GetUIVersion(void)
4714 static DWORD version;
4716 if (!version)
4718 DllGetVersion_func pDllGetVersion;
4719 HMODULE dll = LoadLibraryA("shell32.dll");
4720 if (!dll) return 0;
4722 pDllGetVersion = (DllGetVersion_func)GetProcAddress(dll, "DllGetVersion");
4723 if (pDllGetVersion)
4725 DLLVERSIONINFO dvi;
4726 dvi.cbSize = sizeof(DLLVERSIONINFO);
4727 if (pDllGetVersion(&dvi) == S_OK) version = dvi.dwMajorVersion;
4729 FreeLibrary( dll );
4730 if (!version) version = 3; /* old shell dlls don't have DllGetVersion */
4732 return version;
4735 /***********************************************************************
4736 * ShellMessageBoxWrapW [SHLWAPI.388]
4738 * See shell32.ShellMessageBoxW
4740 * NOTE:
4741 * shlwapi.ShellMessageBoxWrapW is a duplicate of shell32.ShellMessageBoxW
4742 * because we can't forward to it in the .spec file since it's exported by
4743 * ordinal. If you change the implementation here please update the code in
4744 * shell32 as well.
4746 INT WINAPIV ShellMessageBoxWrapW(HINSTANCE hInstance, HWND hWnd, LPCWSTR lpText,
4747 LPCWSTR lpCaption, UINT uType, ...)
4749 WCHAR *szText = NULL, szTitle[100];
4750 LPCWSTR pszText, pszTitle = szTitle;
4751 LPWSTR pszTemp;
4752 __ms_va_list args;
4753 int ret;
4755 __ms_va_start(args, uType);
4757 TRACE("(%p,%p,%p,%p,%08x)\n", hInstance, hWnd, lpText, lpCaption, uType);
4759 if (IS_INTRESOURCE(lpCaption))
4760 LoadStringW(hInstance, LOWORD(lpCaption), szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
4761 else
4762 pszTitle = lpCaption;
4764 if (IS_INTRESOURCE(lpText))
4766 const WCHAR *ptr;
4767 UINT len = LoadStringW(hInstance, LOWORD(lpText), (LPWSTR)&ptr, 0);
4769 if (len)
4771 szText = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
4772 if (szText) LoadStringW(hInstance, LOWORD(lpText), szText, len + 1);
4774 pszText = szText;
4775 if (!pszText) {
4776 WARN("Failed to load id %d\n", LOWORD(lpText));
4777 __ms_va_end(args);
4778 return 0;
4781 else
4782 pszText = lpText;
4784 FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
4785 pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
4787 __ms_va_end(args);
4789 ret = MessageBoxW(hWnd, pszTemp, pszTitle, uType);
4791 HeapFree(GetProcessHeap(), 0, szText);
4792 LocalFree(pszTemp);
4793 return ret;
4796 /***********************************************************************
4797 * ZoneComputePaneSize [SHLWAPI.382]
4799 UINT WINAPI ZoneComputePaneSize(HWND hwnd)
4801 FIXME("\n");
4802 return 0x95;
4805 /***********************************************************************
4806 * SHChangeNotifyWrap [SHLWAPI.394]
4808 void WINAPI SHChangeNotifyWrap(LONG wEventId, UINT uFlags, LPCVOID dwItem1, LPCVOID dwItem2)
4810 SHChangeNotify(wEventId, uFlags, dwItem1, dwItem2);
4813 typedef struct SHELL_USER_SID { /* according to MSDN this should be in shlobj.h... */
4814 SID_IDENTIFIER_AUTHORITY sidAuthority;
4815 DWORD dwUserGroupID;
4816 DWORD dwUserID;
4817 } SHELL_USER_SID, *PSHELL_USER_SID;
4819 typedef struct SHELL_USER_PERMISSION { /* ...and this should be in shlwapi.h */
4820 SHELL_USER_SID susID;
4821 DWORD dwAccessType;
4822 BOOL fInherit;
4823 DWORD dwAccessMask;
4824 DWORD dwInheritMask;
4825 DWORD dwInheritAccessMask;
4826 } SHELL_USER_PERMISSION, *PSHELL_USER_PERMISSION;
4828 /***********************************************************************
4829 * GetShellSecurityDescriptor [SHLWAPI.475]
4831 * prepares SECURITY_DESCRIPTOR from a set of ACEs
4833 * PARAMS
4834 * apUserPerm [I] array of pointers to SHELL_USER_PERMISSION structures,
4835 * each of which describes permissions to apply
4836 * cUserPerm [I] number of entries in apUserPerm array
4838 * RETURNS
4839 * success: pointer to SECURITY_DESCRIPTOR
4840 * failure: NULL
4842 * NOTES
4843 * Call should free returned descriptor with LocalFree
4845 PSECURITY_DESCRIPTOR WINAPI GetShellSecurityDescriptor(PSHELL_USER_PERMISSION *apUserPerm, int cUserPerm)
4847 PSID *sidlist;
4848 PSID cur_user = NULL;
4849 BYTE tuUser[2000];
4850 DWORD acl_size;
4851 int sid_count, i;
4852 PSECURITY_DESCRIPTOR psd = NULL;
4854 TRACE("%p %d\n", apUserPerm, cUserPerm);
4856 if (apUserPerm == NULL || cUserPerm <= 0)
4857 return NULL;
4859 sidlist = HeapAlloc(GetProcessHeap(), 0, cUserPerm * sizeof(PSID));
4860 if (!sidlist)
4861 return NULL;
4863 acl_size = sizeof(ACL);
4865 for(sid_count = 0; sid_count < cUserPerm; sid_count++)
4867 static SHELL_USER_SID null_sid = {{SECURITY_NULL_SID_AUTHORITY}, 0, 0};
4868 PSHELL_USER_PERMISSION perm = apUserPerm[sid_count];
4869 PSHELL_USER_SID sid = &perm->susID;
4870 PSID pSid;
4871 BOOL ret = TRUE;
4873 if (!memcmp((void*)sid, (void*)&null_sid, sizeof(SHELL_USER_SID)))
4874 { /* current user's SID */
4875 if (!cur_user)
4877 HANDLE Token;
4878 DWORD bufsize = sizeof(tuUser);
4880 ret = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &Token);
4881 if (ret)
4883 ret = GetTokenInformation(Token, TokenUser, (void*)tuUser, bufsize, &bufsize );
4884 if (ret)
4885 cur_user = ((PTOKEN_USER)tuUser)->User.Sid;
4886 CloseHandle(Token);
4889 pSid = cur_user;
4890 } else if (sid->dwUserID==0) /* one sub-authority */
4891 ret = AllocateAndInitializeSid(&sid->sidAuthority, 1, sid->dwUserGroupID, 0,
4892 0, 0, 0, 0, 0, 0, &pSid);
4893 else
4894 ret = AllocateAndInitializeSid(&sid->sidAuthority, 2, sid->dwUserGroupID, sid->dwUserID,
4895 0, 0, 0, 0, 0, 0, &pSid);
4896 if (!ret)
4897 goto free_sids;
4899 sidlist[sid_count] = pSid;
4900 /* increment acl_size (1 ACE for non-inheritable and 2 ACEs for inheritable records */
4901 acl_size += (sizeof(ACCESS_ALLOWED_ACE)-sizeof(DWORD) + GetLengthSid(pSid)) * (perm->fInherit ? 2 : 1);
4904 psd = LocalAlloc(0, sizeof(SECURITY_DESCRIPTOR) + acl_size);
4906 if (psd != NULL)
4908 PACL pAcl = (PACL)(((BYTE*)psd)+sizeof(SECURITY_DESCRIPTOR));
4910 if (!InitializeSecurityDescriptor(psd, SECURITY_DESCRIPTOR_REVISION))
4911 goto error;
4913 if (!InitializeAcl(pAcl, acl_size, ACL_REVISION))
4914 goto error;
4916 for(i = 0; i < sid_count; i++)
4918 PSHELL_USER_PERMISSION sup = apUserPerm[i];
4919 PSID sid = sidlist[i];
4921 switch(sup->dwAccessType)
4923 case ACCESS_ALLOWED_ACE_TYPE:
4924 if (!AddAccessAllowedAce(pAcl, ACL_REVISION, sup->dwAccessMask, sid))
4925 goto error;
4926 if (sup->fInherit && !AddAccessAllowedAceEx(pAcl, ACL_REVISION,
4927 (BYTE)sup->dwInheritMask, sup->dwInheritAccessMask, sid))
4928 goto error;
4929 break;
4930 case ACCESS_DENIED_ACE_TYPE:
4931 if (!AddAccessDeniedAce(pAcl, ACL_REVISION, sup->dwAccessMask, sid))
4932 goto error;
4933 if (sup->fInherit && !AddAccessDeniedAceEx(pAcl, ACL_REVISION,
4934 (BYTE)sup->dwInheritMask, sup->dwInheritAccessMask, sid))
4935 goto error;
4936 break;
4937 default:
4938 goto error;
4942 if (!SetSecurityDescriptorDacl(psd, TRUE, pAcl, FALSE))
4943 goto error;
4945 goto free_sids;
4947 error:
4948 LocalFree(psd);
4949 psd = NULL;
4950 free_sids:
4951 for(i = 0; i < sid_count; i++)
4953 if (!cur_user || sidlist[i] != cur_user)
4954 FreeSid(sidlist[i]);
4956 HeapFree(GetProcessHeap(), 0, sidlist);
4958 return psd;
4961 /***********************************************************************
4962 * SHCreatePropertyBagOnRegKey [SHLWAPI.471]
4964 * Creates a property bag from a registry key
4966 * PARAMS
4967 * hKey [I] Handle to the desired registry key
4968 * subkey [I] Name of desired subkey, or NULL to open hKey directly
4969 * grfMode [I] Optional flags
4970 * riid [I] IID of requested property bag interface
4971 * ppv [O] Address to receive pointer to the new interface
4973 * RETURNS
4974 * success: 0
4975 * failure: error code
4978 HRESULT WINAPI SHCreatePropertyBagOnRegKey (HKEY hKey, LPCWSTR subkey,
4979 DWORD grfMode, REFIID riid, void **ppv)
4981 FIXME("%p %s %d %s %p STUB\n", hKey, debugstr_w(subkey), grfMode,
4982 debugstr_guid(riid), ppv);
4984 return E_NOTIMPL;
4987 /***********************************************************************
4988 * SHGetViewStatePropertyBag [SHLWAPI.515]
4990 * Retrieves a property bag in which the view state information of a folder
4991 * can be stored.
4993 * PARAMS
4994 * pidl [I] PIDL of the folder requested
4995 * bag_name [I] Name of the property bag requested
4996 * flags [I] Optional flags
4997 * riid [I] IID of requested property bag interface
4998 * ppv [O] Address to receive pointer to the new interface
5000 * RETURNS
5001 * success: S_OK
5002 * failure: error code
5005 HRESULT WINAPI SHGetViewStatePropertyBag(LPCITEMIDLIST pidl, LPWSTR bag_name,
5006 DWORD flags, REFIID riid, void **ppv)
5008 FIXME("%p %s %d %s %p STUB\n", pidl, debugstr_w(bag_name), flags,
5009 debugstr_guid(riid), ppv);
5011 return E_NOTIMPL;
5014 /***********************************************************************
5015 * SHFormatDateTimeW [SHLWAPI.354]
5017 * Produces a string representation of a time.
5019 * PARAMS
5020 * fileTime [I] Pointer to FILETIME structure specifying the time
5021 * flags [I] Flags specifying the desired output
5022 * buf [O] Pointer to buffer for output
5023 * size [I] Number of characters that can be contained in buffer
5025 * RETURNS
5026 * success: number of characters written to the buffer
5027 * failure: 0
5030 INT WINAPI SHFormatDateTimeW(const FILETIME UNALIGNED *fileTime, DWORD *flags,
5031 LPWSTR buf, UINT size)
5033 #define SHFORMATDT_UNSUPPORTED_FLAGS (FDTF_RELATIVE | FDTF_LTRDATE | FDTF_RTLDATE | FDTF_NOAUTOREADINGORDER)
5034 DWORD fmt_flags = flags ? *flags : FDTF_DEFAULT;
5035 SYSTEMTIME st;
5036 FILETIME ft;
5037 INT ret = 0;
5039 TRACE("%p %p %p %u\n", fileTime, flags, buf, size);
5041 if (!buf || !size)
5042 return 0;
5044 if (fmt_flags & SHFORMATDT_UNSUPPORTED_FLAGS)
5045 FIXME("ignoring some flags - 0x%08x\n", fmt_flags & SHFORMATDT_UNSUPPORTED_FLAGS);
5047 FileTimeToLocalFileTime(fileTime, &ft);
5048 FileTimeToSystemTime(&ft, &st);
5050 /* first of all date */
5051 if (fmt_flags & (FDTF_LONGDATE | FDTF_SHORTDATE))
5053 static const WCHAR sep1[] = {',',' ',0};
5054 static const WCHAR sep2[] = {' ',0};
5056 DWORD date = fmt_flags & FDTF_LONGDATE ? DATE_LONGDATE : DATE_SHORTDATE;
5057 ret = GetDateFormatW(LOCALE_USER_DEFAULT, date, &st, NULL, buf, size);
5058 if (ret >= size) return ret;
5060 /* add separator */
5061 if (ret < size && (fmt_flags & (FDTF_LONGTIME | FDTF_SHORTTIME)))
5063 if ((fmt_flags & FDTF_LONGDATE) && (ret < size + 2))
5065 lstrcatW(&buf[ret-1], sep1);
5066 ret += 2;
5068 else
5070 lstrcatW(&buf[ret-1], sep2);
5071 ret++;
5075 /* time part */
5076 if (fmt_flags & (FDTF_LONGTIME | FDTF_SHORTTIME))
5078 DWORD time = fmt_flags & FDTF_LONGTIME ? 0 : TIME_NOSECONDS;
5080 if (ret) ret--;
5081 ret += GetTimeFormatW(LOCALE_USER_DEFAULT, time, &st, NULL, &buf[ret], size - ret);
5084 return ret;
5086 #undef SHFORMATDT_UNSUPPORTED_FLAGS
5089 /***********************************************************************
5090 * SHFormatDateTimeA [SHLWAPI.353]
5092 * See SHFormatDateTimeW.
5095 INT WINAPI SHFormatDateTimeA(const FILETIME UNALIGNED *fileTime, DWORD *flags,
5096 LPSTR buf, UINT size)
5098 WCHAR *bufW;
5099 INT retval;
5101 if (!buf || !size)
5102 return 0;
5104 bufW = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR) * size);
5105 retval = SHFormatDateTimeW(fileTime, flags, bufW, size);
5107 if (retval != 0)
5108 WideCharToMultiByte(CP_ACP, 0, bufW, -1, buf, size, NULL, NULL);
5110 HeapFree(GetProcessHeap(), 0, bufW);
5111 return retval;
5114 /***********************************************************************
5115 * ZoneCheckUrlExW [SHLWAPI.231]
5117 * Checks the details of the security zone for the supplied site. (?)
5119 * PARAMS
5121 * szURL [I] Pointer to the URL to check
5123 * Other parameters currently unknown.
5125 * RETURNS
5126 * unknown
5129 INT WINAPI ZoneCheckUrlExW(LPWSTR szURL, PVOID pUnknown, DWORD dwUnknown2,
5130 DWORD dwUnknown3, DWORD dwUnknown4, DWORD dwUnknown5, DWORD dwUnknown6,
5131 DWORD dwUnknown7)
5133 FIXME("(%s,%p,%x,%x,%x,%x,%x,%x) STUB\n", debugstr_w(szURL), pUnknown, dwUnknown2,
5134 dwUnknown3, dwUnknown4, dwUnknown5, dwUnknown6, dwUnknown7);
5136 return 0;
5139 /***********************************************************************
5140 * SHVerbExistsNA [SHLWAPI.196]
5143 * PARAMS
5145 * verb [I] a string, often appears to be an extension.
5147 * Other parameters currently unknown.
5149 * RETURNS
5150 * unknown
5152 INT WINAPI SHVerbExistsNA(LPSTR verb, PVOID pUnknown, PVOID pUnknown2, DWORD dwUnknown3)
5154 FIXME("(%s, %p, %p, %i) STUB\n",verb, pUnknown, pUnknown2, dwUnknown3);
5155 return 0;
5158 /*************************************************************************
5159 * @ [SHLWAPI.538]
5161 * Undocumented: Implementation guessed at via Name and behavior
5163 * PARAMS
5164 * lpUnknown [I] Object to get an IServiceProvider interface from
5165 * riid [I] Function requested for QueryService call
5166 * lppOut [O] Destination for the service interface pointer
5168 * RETURNS
5169 * Success: S_OK. lppOut contains an object providing the requested service
5170 * Failure: An HRESULT error code
5172 * NOTES
5173 * lpUnknown is expected to support the IServiceProvider interface.
5175 HRESULT WINAPI IUnknown_QueryServiceForWebBrowserApp(IUnknown* lpUnknown,
5176 REFGUID riid, LPVOID *lppOut)
5178 FIXME("%p %s %p semi-STUB\n", lpUnknown, debugstr_guid(riid), lppOut);
5179 return IUnknown_QueryService(lpUnknown,&IID_IWebBrowserApp,riid,lppOut);
5182 /**************************************************************************
5183 * SHPropertyBag_ReadLONG (SHLWAPI.496)
5185 * This function asks a property bag to read a named property as a LONG.
5187 * PARAMS
5188 * ppb: a IPropertyBag interface
5189 * pszPropName: Unicode string that names the property
5190 * pValue: address to receive the property value as a 32-bit signed integer
5192 * RETURNS
5193 * HRESULT codes
5195 HRESULT WINAPI SHPropertyBag_ReadLONG(IPropertyBag *ppb, LPCWSTR pszPropName, LPLONG pValue)
5197 VARIANT var;
5198 HRESULT hr;
5199 TRACE("%p %s %p\n", ppb,debugstr_w(pszPropName),pValue);
5200 if (!pszPropName || !ppb || !pValue)
5201 return E_INVALIDARG;
5202 V_VT(&var) = VT_I4;
5203 hr = IPropertyBag_Read(ppb, pszPropName, &var, NULL);
5204 if (SUCCEEDED(hr))
5206 if (V_VT(&var) == VT_I4)
5207 *pValue = V_I4(&var);
5208 else
5209 hr = DISP_E_BADVARTYPE;
5211 return hr;
5214 /* return flags for SHGetObjectCompatFlags, names derived from registry value names */
5215 #define OBJCOMPAT_OTNEEDSSFCACHE 0x00000001
5216 #define OBJCOMPAT_NO_WEBVIEW 0x00000002
5217 #define OBJCOMPAT_UNBINDABLE 0x00000004
5218 #define OBJCOMPAT_PINDLL 0x00000008
5219 #define OBJCOMPAT_NEEDSFILESYSANCESTOR 0x00000010
5220 #define OBJCOMPAT_NOTAFILESYSTEM 0x00000020
5221 #define OBJCOMPAT_CTXMENU_NOVERBS 0x00000040
5222 #define OBJCOMPAT_CTXMENU_LIMITEDQI 0x00000080
5223 #define OBJCOMPAT_COCREATESHELLFOLDERONLY 0x00000100
5224 #define OBJCOMPAT_NEEDSSTORAGEANCESTOR 0x00000200
5225 #define OBJCOMPAT_NOLEGACYWEBVIEW 0x00000400
5226 #define OBJCOMPAT_CTXMENU_XPQCMFLAGS 0x00001000
5227 #define OBJCOMPAT_NOIPROPERTYSTORE 0x00002000
5229 /* a search table for compatibility flags */
5230 struct objcompat_entry {
5231 const WCHAR name[30];
5232 DWORD value;
5235 /* expected to be sorted by name */
5236 static const struct objcompat_entry objcompat_table[] = {
5237 { {'C','O','C','R','E','A','T','E','S','H','E','L','L','F','O','L','D','E','R','O','N','L','Y',0},
5238 OBJCOMPAT_COCREATESHELLFOLDERONLY },
5239 { {'C','T','X','M','E','N','U','_','L','I','M','I','T','E','D','Q','I',0},
5240 OBJCOMPAT_CTXMENU_LIMITEDQI },
5241 { {'C','T','X','M','E','N','U','_','N','O','V','E','R','B','S',0},
5242 OBJCOMPAT_CTXMENU_LIMITEDQI },
5243 { {'C','T','X','M','E','N','U','_','X','P','Q','C','M','F','L','A','G','S',0},
5244 OBJCOMPAT_CTXMENU_XPQCMFLAGS },
5245 { {'N','E','E','D','S','F','I','L','E','S','Y','S','A','N','C','E','S','T','O','R',0},
5246 OBJCOMPAT_NEEDSFILESYSANCESTOR },
5247 { {'N','E','E','D','S','S','T','O','R','A','G','E','A','N','C','E','S','T','O','R',0},
5248 OBJCOMPAT_NEEDSSTORAGEANCESTOR },
5249 { {'N','O','I','P','R','O','P','E','R','T','Y','S','T','O','R','E',0},
5250 OBJCOMPAT_NOIPROPERTYSTORE },
5251 { {'N','O','L','E','G','A','C','Y','W','E','B','V','I','E','W',0},
5252 OBJCOMPAT_NOLEGACYWEBVIEW },
5253 { {'N','O','T','A','F','I','L','E','S','Y','S','T','E','M',0},
5254 OBJCOMPAT_NOTAFILESYSTEM },
5255 { {'N','O','_','W','E','B','V','I','E','W',0},
5256 OBJCOMPAT_NO_WEBVIEW },
5257 { {'O','T','N','E','E','D','S','S','F','C','A','C','H','E',0},
5258 OBJCOMPAT_OTNEEDSSFCACHE },
5259 { {'P','I','N','D','L','L',0},
5260 OBJCOMPAT_PINDLL },
5261 { {'U','N','B','I','N','D','A','B','L','E',0},
5262 OBJCOMPAT_UNBINDABLE }
5265 /**************************************************************************
5266 * SHGetObjectCompatFlags (SHLWAPI.476)
5268 * Function returns an integer representation of compatibility flags stored
5269 * in registry for CLSID under ShellCompatibility subkey.
5271 * PARAMS
5272 * pUnk: pointer to object IUnknown interface, idetifies CLSID
5273 * clsid: pointer to CLSID to retrieve data for
5275 * RETURNS
5276 * 0 on failure, flags set on success
5278 DWORD WINAPI SHGetObjectCompatFlags(IUnknown *pUnk, const CLSID *clsid)
5280 static const WCHAR compatpathW[] =
5281 {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
5282 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5283 'S','h','e','l','l','C','o','m','p','a','t','i','b','i','l','i','t','y','\\',
5284 'O','b','j','e','c','t','s','\\','%','s',0};
5285 WCHAR strW[sizeof(compatpathW)/sizeof(WCHAR) + 38 /* { CLSID } */];
5286 DWORD ret, length = sizeof(strW)/sizeof(WCHAR);
5287 OLECHAR *clsid_str;
5288 HKEY key;
5289 INT i;
5291 TRACE("%p %s\n", pUnk, debugstr_guid(clsid));
5293 if (!pUnk && !clsid) return 0;
5295 if (pUnk && !clsid)
5297 FIXME("iface not handled\n");
5298 return 0;
5301 StringFromCLSID(clsid, &clsid_str);
5302 sprintfW(strW, compatpathW, clsid_str);
5303 CoTaskMemFree(clsid_str);
5305 ret = RegOpenKeyW(HKEY_LOCAL_MACHINE, strW, &key);
5306 if (ret != ERROR_SUCCESS) return 0;
5308 /* now collect flag values */
5309 ret = 0;
5310 for (i = 0; RegEnumValueW(key, i, strW, &length, NULL, NULL, NULL, NULL) == ERROR_SUCCESS; i++)
5312 INT left, right, res, x;
5314 /* search in table */
5315 left = 0;
5316 right = sizeof(objcompat_table) / sizeof(struct objcompat_entry) - 1;
5318 while (right >= left) {
5319 x = (left + right) / 2;
5320 res = strcmpW(strW, objcompat_table[x].name);
5321 if (res == 0)
5323 ret |= objcompat_table[x].value;
5324 break;
5326 else if (res < 0)
5327 right = x - 1;
5328 else
5329 left = x + 1;
5332 length = sizeof(strW)/sizeof(WCHAR);
5335 return ret;