2 * SHLWAPI ordinal functions
4 * Copyright 1997 Marcus Meissner
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
24 #include "wine/port.h"
31 #define NONAMELESSUNION
32 #define NONAMELESSSTRUCT
45 #include "shdeprecated.h"
52 #include "wine/unicode.h"
53 #include "wine/debug.h"
56 WINE_DEFAULT_DEBUG_CHANNEL(shell
);
58 /* DLL handles for late bound calls */
59 extern HINSTANCE shlwapi_hInstance
;
60 extern DWORD SHLWAPI_ThreadRef_index
;
62 HRESULT WINAPI
IUnknown_QueryService(IUnknown
*,REFGUID
,REFIID
,LPVOID
*);
63 HRESULT WINAPI
SHInvokeCommand(HWND
,IShellFolder
*,LPCITEMIDLIST
,BOOL
);
64 BOOL WINAPI
SHAboutInfoW(LPWSTR
,DWORD
);
67 NOTES: Most functions exported by ordinal seem to be superfluous.
68 The reason for these functions to be there is to provide a wrapper
69 for unicode functions to provide these functions on systems without
70 unicode functions eg. win95/win98. Since we have such functions we just
71 call these. If running Wine with native DLLs, some late bound calls may
72 fail. However, it is better to implement the functions in the forward DLL
73 and recommend the builtin rather than reimplementing the calls here!
76 /*************************************************************************
77 * SHLWAPI_DupSharedHandle
79 * Internal implemetation of SHLWAPI_11.
81 static HANDLE
SHLWAPI_DupSharedHandle(HANDLE hShared
, DWORD dwDstProcId
,
82 DWORD dwSrcProcId
, DWORD dwAccess
,
86 DWORD dwMyProcId
= GetCurrentProcessId();
89 TRACE("(%p,%d,%d,%08x,%08x)\n", hShared
, dwDstProcId
, dwSrcProcId
,
92 /* Get dest process handle */
93 if (dwDstProcId
== dwMyProcId
)
94 hDst
= GetCurrentProcess();
96 hDst
= OpenProcess(PROCESS_DUP_HANDLE
, 0, dwDstProcId
);
100 /* Get src process handle */
101 if (dwSrcProcId
== dwMyProcId
)
102 hSrc
= GetCurrentProcess();
104 hSrc
= OpenProcess(PROCESS_DUP_HANDLE
, 0, dwSrcProcId
);
108 /* Make handle available to dest process */
109 if (!DuplicateHandle(hDst
, hShared
, hSrc
, &hRet
,
110 dwAccess
, 0, dwOptions
| DUPLICATE_SAME_ACCESS
))
113 if (dwSrcProcId
!= dwMyProcId
)
117 if (dwDstProcId
!= dwMyProcId
)
121 TRACE("Returning handle %p\n", hRet
);
125 /*************************************************************************
128 * Create a block of sharable memory and initialise it with data.
131 * lpvData [I] Pointer to data to write
132 * dwSize [I] Size of data
133 * dwProcId [I] ID of process owning data
136 * Success: A shared memory handle
140 * Ordinals 7-11 provide a set of calls to create shared memory between a
141 * group of processes. The shared memory is treated opaquely in that its size
142 * is not exposed to clients who map it. This is accomplished by storing
143 * the size of the map as the first DWORD of mapped data, and then offsetting
144 * the view pointer returned by this size.
147 HANDLE WINAPI
SHAllocShared(LPCVOID lpvData
, DWORD dwSize
, DWORD dwProcId
)
153 TRACE("(%p,%d,%d)\n", lpvData
, dwSize
, dwProcId
);
155 /* Create file mapping of the correct length */
156 hMap
= CreateFileMappingA(INVALID_HANDLE_VALUE
, NULL
, FILE_MAP_READ
, 0,
157 dwSize
+ sizeof(dwSize
), NULL
);
161 /* Get a view in our process address space */
162 pMapped
= MapViewOfFile(hMap
, FILE_MAP_READ
| FILE_MAP_WRITE
, 0, 0, 0);
166 /* Write size of data, followed by the data, to the view */
167 *((DWORD
*)pMapped
) = dwSize
;
169 memcpy((char *) pMapped
+ sizeof(dwSize
), lpvData
, dwSize
);
171 /* Release view. All further views mapped will be opaque */
172 UnmapViewOfFile(pMapped
);
173 hRet
= SHLWAPI_DupSharedHandle(hMap
, dwProcId
,
174 GetCurrentProcessId(), FILE_MAP_ALL_ACCESS
,
175 DUPLICATE_SAME_ACCESS
);
182 /*************************************************************************
185 * Get a pointer to a block of shared memory from a shared memory handle.
188 * hShared [I] Shared memory handle
189 * dwProcId [I] ID of process owning hShared
192 * Success: A pointer to the shared memory
196 PVOID WINAPI
SHLockShared(HANDLE hShared
, DWORD dwProcId
)
201 TRACE("(%p %d)\n", hShared
, dwProcId
);
203 /* Get handle to shared memory for current process */
204 hDup
= SHLWAPI_DupSharedHandle(hShared
, dwProcId
, GetCurrentProcessId(),
205 FILE_MAP_ALL_ACCESS
, 0);
207 pMapped
= MapViewOfFile(hDup
, FILE_MAP_READ
| FILE_MAP_WRITE
, 0, 0, 0);
211 return (char *) pMapped
+ sizeof(DWORD
); /* Hide size */
215 /*************************************************************************
218 * Release a pointer to a block of shared memory.
221 * lpView [I] Shared memory pointer
228 BOOL WINAPI
SHUnlockShared(LPVOID lpView
)
230 TRACE("(%p)\n", lpView
);
231 return UnmapViewOfFile((char *) lpView
- sizeof(DWORD
)); /* Include size */
234 /*************************************************************************
237 * Destroy a block of sharable memory.
240 * hShared [I] Shared memory handle
241 * dwProcId [I] ID of process owning hShared
248 BOOL WINAPI
SHFreeShared(HANDLE hShared
, DWORD dwProcId
)
252 TRACE("(%p %d)\n", hShared
, dwProcId
);
254 /* Get a copy of the handle for our process, closing the source handle */
255 hClose
= SHLWAPI_DupSharedHandle(hShared
, dwProcId
, GetCurrentProcessId(),
256 FILE_MAP_ALL_ACCESS
,DUPLICATE_CLOSE_SOURCE
);
257 /* Close local copy */
258 return CloseHandle(hClose
);
261 /*************************************************************************
264 * Copy a sharable memory handle from one process to another.
267 * hShared [I] Shared memory handle to duplicate
268 * dwDstProcId [I] ID of the process wanting the duplicated handle
269 * dwSrcProcId [I] ID of the process owning hShared
270 * dwAccess [I] Desired DuplicateHandle() access
271 * dwOptions [I] Desired DuplicateHandle() options
274 * Success: A handle suitable for use by the dwDstProcId process.
275 * Failure: A NULL handle.
278 HANDLE WINAPI
SHMapHandle(HANDLE hShared
, DWORD dwDstProcId
, DWORD dwSrcProcId
,
279 DWORD dwAccess
, DWORD dwOptions
)
283 hRet
= SHLWAPI_DupSharedHandle(hShared
, dwDstProcId
, dwSrcProcId
,
284 dwAccess
, dwOptions
);
288 /*************************************************************************
291 * Create and register a clipboard enumerator for a web browser.
294 * lpBC [I] Binding context
295 * lpUnknown [I] An object exposing the IWebBrowserApp interface
299 * Failure: An HRESULT error code.
302 * The enumerator is stored as a property of the web browser. If it does not
303 * yet exist, it is created and set before being registered.
305 HRESULT WINAPI
RegisterDefaultAcceptHeaders(LPBC lpBC
, IUnknown
*lpUnknown
)
307 static const WCHAR szProperty
[] = { '{','D','0','F','C','A','4','2','0',
308 '-','D','3','F','5','-','1','1','C','F', '-','B','2','1','1','-','0',
309 '0','A','A','0','0','4','A','E','8','3','7','}','\0' };
311 IEnumFORMATETC
* pIEnumFormatEtc
= NULL
;
314 IWebBrowserApp
* pBrowser
;
316 TRACE("(%p, %p)\n", lpBC
, lpUnknown
);
318 hr
= IUnknown_QueryService(lpUnknown
, &IID_IWebBrowserApp
, &IID_IWebBrowserApp
, (void**)&pBrowser
);
322 V_VT(&var
) = VT_EMPTY
;
324 /* The property we get is the browsers clipboard enumerator */
325 property
= SysAllocString(szProperty
);
326 hr
= IWebBrowserApp_GetProperty(pBrowser
, property
, &var
);
327 SysFreeString(property
);
328 if (FAILED(hr
)) goto exit
;
330 if (V_VT(&var
) == VT_EMPTY
)
332 /* Iterate through accepted documents and RegisterClipBoardFormatA() them */
333 char szKeyBuff
[128], szValueBuff
[128];
334 DWORD dwKeySize
, dwValueSize
, dwRet
= 0, dwCount
= 0, dwNumValues
, dwType
;
335 FORMATETC
* formatList
, *format
;
338 TRACE("Registering formats and creating IEnumFORMATETC instance\n");
340 if (!RegOpenKeyA(HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Windows\\Current"
341 "Version\\Internet Settings\\Accepted Documents", &hDocs
))
347 /* Get count of values in key */
350 dwKeySize
= sizeof(szKeyBuff
);
351 dwRet
= RegEnumValueA(hDocs
,dwCount
,szKeyBuff
,&dwKeySize
,0,&dwType
,0,0);
355 dwNumValues
= dwCount
;
357 /* Note: dwCount = number of items + 1; The extra item is the end node */
358 format
= formatList
= HeapAlloc(GetProcessHeap(), 0, dwCount
* sizeof(FORMATETC
));
373 /* Register clipboard formats for the values and populate format list */
374 while(!dwRet
&& dwCount
< dwNumValues
)
376 dwKeySize
= sizeof(szKeyBuff
);
377 dwValueSize
= sizeof(szValueBuff
);
378 dwRet
= RegEnumValueA(hDocs
, dwCount
, szKeyBuff
, &dwKeySize
, 0, &dwType
,
379 (PBYTE
)szValueBuff
, &dwValueSize
);
382 HeapFree(GetProcessHeap(), 0, formatList
);
388 format
->cfFormat
= RegisterClipboardFormatA(szValueBuff
);
390 format
->dwAspect
= 1;
401 /* Terminate the (maybe empty) list, last entry has a cfFormat of 0 */
402 format
->cfFormat
= 0;
404 format
->dwAspect
= 1;
408 /* Create a clipboard enumerator */
409 hr
= CreateFormatEnumerator(dwNumValues
, formatList
, &pIEnumFormatEtc
);
410 HeapFree(GetProcessHeap(), 0, formatList
);
411 if (FAILED(hr
)) goto exit
;
413 /* Set our enumerator as the browsers property */
414 V_VT(&var
) = VT_UNKNOWN
;
415 V_UNKNOWN(&var
) = (IUnknown
*)pIEnumFormatEtc
;
417 property
= SysAllocString(szProperty
);
418 hr
= IWebBrowserApp_PutProperty(pBrowser
, property
, var
);
419 SysFreeString(property
);
422 IEnumFORMATETC_Release(pIEnumFormatEtc
);
427 if (V_VT(&var
) == VT_UNKNOWN
)
429 /* Our variant is holding the clipboard enumerator */
430 IUnknown
* pIUnknown
= V_UNKNOWN(&var
);
431 IEnumFORMATETC
* pClone
= NULL
;
433 TRACE("Retrieved IEnumFORMATETC property\n");
435 /* Get an IEnumFormatEtc interface from the variants value */
436 pIEnumFormatEtc
= NULL
;
437 hr
= IUnknown_QueryInterface(pIUnknown
, &IID_IEnumFORMATETC
, (void**)&pIEnumFormatEtc
);
438 if (hr
== S_OK
&& pIEnumFormatEtc
)
440 /* Clone and register the enumerator */
441 hr
= IEnumFORMATETC_Clone(pIEnumFormatEtc
, &pClone
);
442 if (hr
== S_OK
&& pClone
)
444 RegisterFormatEnumerator(lpBC
, pClone
, 0);
446 IEnumFORMATETC_Release(pClone
);
449 IEnumFORMATETC_Release(pIUnknown
);
451 IUnknown_Release(V_UNKNOWN(&var
));
455 IWebBrowserApp_Release(pBrowser
);
459 /*************************************************************************
462 * Get Explorers "AcceptLanguage" setting.
465 * langbuf [O] Destination for language string
466 * buflen [I] Length of langbuf in characters
467 * [0] Success: used length of langbuf
470 * Success: S_OK. langbuf is set to the language string found.
471 * Failure: E_FAIL, If any arguments are invalid, error occurred, or Explorer
472 * does not contain the setting.
473 * HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER), If the buffer is not big enough
475 HRESULT WINAPI
GetAcceptLanguagesW( LPWSTR langbuf
, LPDWORD buflen
)
477 static const WCHAR szkeyW
[] = {
478 'S','o','f','t','w','a','r','e','\\',
479 'M','i','c','r','o','s','o','f','t','\\',
480 'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
481 'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
482 static const WCHAR valueW
[] = {
483 'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
484 DWORD mystrlen
, mytype
;
491 TRACE("(%p, %p) *%p: %d\n", langbuf
, buflen
, buflen
, buflen
? *buflen
: -1);
493 if(!langbuf
|| !buflen
|| !*buflen
)
496 mystrlen
= (*buflen
> 20) ? *buflen
: 20 ;
497 len
= mystrlen
* sizeof(WCHAR
);
498 mystr
= HeapAlloc(GetProcessHeap(), 0, len
);
500 RegOpenKeyW(HKEY_CURRENT_USER
, szkeyW
, &mykey
);
501 lres
= RegQueryValueExW(mykey
, valueW
, 0, &mytype
, (PBYTE
)mystr
, &len
);
503 len
= lstrlenW(mystr
);
505 if (!lres
&& (*buflen
> len
)) {
506 lstrcpyW(langbuf
, mystr
);
508 HeapFree(GetProcessHeap(), 0, mystr
);
512 /* Did not find a value in the registry or the user buffer is too small */
513 mylcid
= GetUserDefaultLCID();
514 LcidToRfc1766W(mylcid
, mystr
, mystrlen
);
515 len
= lstrlenW(mystr
);
517 memcpy( langbuf
, mystr
, min(*buflen
, len
+1)*sizeof(WCHAR
) );
518 HeapFree(GetProcessHeap(), 0, mystr
);
526 return __HRESULT_FROM_WIN32(ERROR_INSUFFICIENT_BUFFER
);
529 /*************************************************************************
532 * Ascii version of GetAcceptLanguagesW.
534 HRESULT WINAPI
GetAcceptLanguagesA( LPSTR langbuf
, LPDWORD buflen
)
537 DWORD buflenW
, convlen
;
540 TRACE("(%p, %p) *%p: %d\n", langbuf
, buflen
, buflen
, buflen
? *buflen
: -1);
542 if(!langbuf
|| !buflen
|| !*buflen
) return E_FAIL
;
545 langbufW
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
) * buflenW
);
546 retval
= GetAcceptLanguagesW(langbufW
, &buflenW
);
550 convlen
= WideCharToMultiByte(CP_ACP
, 0, langbufW
, -1, langbuf
, *buflen
, NULL
, NULL
);
551 convlen
--; /* do not count the terminating 0 */
553 else /* copy partial string anyway */
555 convlen
= WideCharToMultiByte(CP_ACP
, 0, langbufW
, *buflen
, langbuf
, *buflen
, NULL
, NULL
);
556 if (convlen
< *buflen
)
558 langbuf
[convlen
] = 0;
559 convlen
--; /* do not count the terminating 0 */
566 *buflen
= buflenW
? convlen
: 0;
568 HeapFree(GetProcessHeap(), 0, langbufW
);
572 /*************************************************************************
575 * Convert a GUID to a string.
578 * guid [I] GUID to convert
579 * lpszDest [O] Destination for string
580 * cchMax [I] Length of output buffer
583 * The length of the string created.
585 INT WINAPI
SHStringFromGUIDA(REFGUID guid
, LPSTR lpszDest
, INT cchMax
)
590 TRACE("(%s,%p,%d)\n", debugstr_guid(guid
), lpszDest
, cchMax
);
592 sprintf(xguid
, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
593 guid
->Data1
, guid
->Data2
, guid
->Data3
,
594 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
595 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
597 iLen
= strlen(xguid
) + 1;
601 memcpy(lpszDest
, xguid
, iLen
);
605 /*************************************************************************
608 * Convert a GUID to a string.
611 * guid [I] GUID to convert
612 * str [O] Destination for string
613 * cmax [I] Length of output buffer
616 * The length of the string created.
618 INT WINAPI
SHStringFromGUIDW(REFGUID guid
, LPWSTR lpszDest
, INT cchMax
)
622 static const WCHAR wszFormat
[] = {'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
623 '%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
624 'X','%','0','2','X','%','0','2','X','}',0};
626 TRACE("(%s,%p,%d)\n", debugstr_guid(guid
), lpszDest
, cchMax
);
628 sprintfW(xguid
, wszFormat
, guid
->Data1
, guid
->Data2
, guid
->Data3
,
629 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
630 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
632 iLen
= strlenW(xguid
) + 1;
636 memcpy(lpszDest
, xguid
, iLen
*sizeof(WCHAR
));
640 /*************************************************************************
643 * Determine if a Unicode character is a space.
646 * wc [I] Character to check.
649 * TRUE, if wc is a space,
652 BOOL WINAPI
IsCharSpaceW(WCHAR wc
)
656 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_SPACE
);
659 /*************************************************************************
662 * Determine if a Unicode character is a blank.
665 * wc [I] Character to check.
668 * TRUE, if wc is a blank,
672 BOOL WINAPI
IsCharBlankW(WCHAR wc
)
676 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_BLANK
);
679 /*************************************************************************
682 * Determine if a Unicode character is punctuation.
685 * wc [I] Character to check.
688 * TRUE, if wc is punctuation,
691 BOOL WINAPI
IsCharPunctW(WCHAR wc
)
695 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_PUNCT
);
698 /*************************************************************************
701 * Determine if a Unicode character is a control character.
704 * wc [I] Character to check.
707 * TRUE, if wc is a control character,
710 BOOL WINAPI
IsCharCntrlW(WCHAR wc
)
714 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_CNTRL
);
717 /*************************************************************************
720 * Determine if a Unicode character is a digit.
723 * wc [I] Character to check.
726 * TRUE, if wc is a digit,
729 BOOL WINAPI
IsCharDigitW(WCHAR wc
)
733 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_DIGIT
);
736 /*************************************************************************
739 * Determine if a Unicode character is a hex digit.
742 * wc [I] Character to check.
745 * TRUE, if wc is a hex digit,
748 BOOL WINAPI
IsCharXDigitW(WCHAR wc
)
752 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_XDIGIT
);
755 /*************************************************************************
759 BOOL WINAPI
GetStringType3ExW(LPWSTR src
, INT count
, LPWORD type
)
761 return GetStringTypeW(CT_CTYPE3
, src
, count
, type
);
764 /*************************************************************************
767 * Compare two Ascii strings up to a given length.
770 * lpszSrc [I] Source string
771 * lpszCmp [I] String to compare to lpszSrc
772 * len [I] Maximum length
775 * A number greater than, less than or equal to 0 depending on whether
776 * lpszSrc is greater than, less than or equal to lpszCmp.
778 DWORD WINAPI
StrCmpNCA(LPCSTR lpszSrc
, LPCSTR lpszCmp
, INT len
)
780 return StrCmpNA(lpszSrc
, lpszCmp
, len
);
783 /*************************************************************************
786 * Unicode version of StrCmpNCA.
788 DWORD WINAPI
StrCmpNCW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
, INT len
)
790 return StrCmpNW(lpszSrc
, lpszCmp
, len
);
793 /*************************************************************************
796 * Compare two Ascii strings up to a given length, ignoring case.
799 * lpszSrc [I] Source string
800 * lpszCmp [I] String to compare to lpszSrc
801 * len [I] Maximum length
804 * A number greater than, less than or equal to 0 depending on whether
805 * lpszSrc is greater than, less than or equal to lpszCmp.
807 DWORD WINAPI
StrCmpNICA(LPCSTR lpszSrc
, LPCSTR lpszCmp
, DWORD len
)
809 return StrCmpNIA(lpszSrc
, lpszCmp
, len
);
812 /*************************************************************************
815 * Unicode version of StrCmpNICA.
817 DWORD WINAPI
StrCmpNICW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
, DWORD len
)
819 return StrCmpNIW(lpszSrc
, lpszCmp
, len
);
822 /*************************************************************************
825 * Compare two Ascii strings.
828 * lpszSrc [I] Source string
829 * lpszCmp [I] String to compare to lpszSrc
832 * A number greater than, less than or equal to 0 depending on whether
833 * lpszSrc is greater than, less than or equal to lpszCmp.
835 DWORD WINAPI
StrCmpCA(LPCSTR lpszSrc
, LPCSTR lpszCmp
)
837 return lstrcmpA(lpszSrc
, lpszCmp
);
840 /*************************************************************************
843 * Unicode version of StrCmpCA.
845 DWORD WINAPI
StrCmpCW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
)
847 return lstrcmpW(lpszSrc
, lpszCmp
);
850 /*************************************************************************
853 * Compare two Ascii strings, ignoring case.
856 * lpszSrc [I] Source string
857 * lpszCmp [I] String to compare to lpszSrc
860 * A number greater than, less than or equal to 0 depending on whether
861 * lpszSrc is greater than, less than or equal to lpszCmp.
863 DWORD WINAPI
StrCmpICA(LPCSTR lpszSrc
, LPCSTR lpszCmp
)
865 return lstrcmpiA(lpszSrc
, lpszCmp
);
868 /*************************************************************************
871 * Unicode version of StrCmpICA.
873 DWORD WINAPI
StrCmpICW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
)
875 return lstrcmpiW(lpszSrc
, lpszCmp
);
878 /*************************************************************************
881 * Get an identification string for the OS and explorer.
884 * lpszDest [O] Destination for Id string
885 * dwDestLen [I] Length of lpszDest
888 * TRUE, If the string was created successfully
891 BOOL WINAPI
SHAboutInfoA(LPSTR lpszDest
, DWORD dwDestLen
)
895 TRACE("(%p,%d)\n", lpszDest
, dwDestLen
);
897 if (lpszDest
&& SHAboutInfoW(buff
, dwDestLen
))
899 WideCharToMultiByte(CP_ACP
, 0, buff
, -1, lpszDest
, dwDestLen
, NULL
, NULL
);
905 /*************************************************************************
908 * Unicode version of SHAboutInfoA.
910 BOOL WINAPI
SHAboutInfoW(LPWSTR lpszDest
, DWORD dwDestLen
)
912 static const WCHAR szIEKey
[] = { 'S','O','F','T','W','A','R','E','\\',
913 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
914 ' ','E','x','p','l','o','r','e','r','\0' };
915 static const WCHAR szWinNtKey
[] = { 'S','O','F','T','W','A','R','E','\\',
916 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ',
917 'N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
918 static const WCHAR szWinKey
[] = { 'S','O','F','T','W','A','R','E','\\',
919 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
920 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
921 static const WCHAR szRegKey
[] = { 'S','O','F','T','W','A','R','E','\\',
922 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
923 ' ','E','x','p','l','o','r','e','r','\\',
924 'R','e','g','i','s','t','r','a','t','i','o','n','\0' };
925 static const WCHAR szVersion
[] = { 'V','e','r','s','i','o','n','\0' };
926 static const WCHAR szCustomized
[] = { 'C','u','s','t','o','m','i','z','e','d',
927 'V','e','r','s','i','o','n','\0' };
928 static const WCHAR szOwner
[] = { 'R','e','g','i','s','t','e','r','e','d',
929 'O','w','n','e','r','\0' };
930 static const WCHAR szOrg
[] = { 'R','e','g','i','s','t','e','r','e','d',
931 'O','r','g','a','n','i','z','a','t','i','o','n','\0' };
932 static const WCHAR szProduct
[] = { 'P','r','o','d','u','c','t','I','d','\0' };
933 static const WCHAR szUpdate
[] = { 'I','E','A','K',
934 'U','p','d','a','t','e','U','r','l','\0' };
935 static const WCHAR szHelp
[] = { 'I','E','A','K',
936 'H','e','l','p','S','t','r','i','n','g','\0' };
941 TRACE("(%p,%d)\n", lpszDest
, dwDestLen
);
948 /* Try the NT key first, followed by 95/98 key */
949 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE
, szWinNtKey
, 0, KEY_READ
, &hReg
) &&
950 RegOpenKeyExW(HKEY_LOCAL_MACHINE
, szWinKey
, 0, KEY_READ
, &hReg
))
956 if (!SHGetValueW(HKEY_LOCAL_MACHINE
, szIEKey
, szVersion
, &dwType
, buff
, &dwLen
))
958 DWORD dwStrLen
= strlenW(buff
);
959 dwLen
= 30 - dwStrLen
;
960 SHGetValueW(HKEY_LOCAL_MACHINE
, szIEKey
,
961 szCustomized
, &dwType
, buff
+dwStrLen
, &dwLen
);
963 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
965 /* ~Registered Owner */
968 if (SHGetValueW(hReg
, szOwner
, 0, &dwType
, buff
+1, &dwLen
))
970 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
972 /* ~Registered Organization */
974 if (SHGetValueW(hReg
, szOrg
, 0, &dwType
, buff
+1, &dwLen
))
976 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
978 /* FIXME: Not sure where this number comes from */
982 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
986 if (SHGetValueW(HKEY_LOCAL_MACHINE
, szRegKey
, szProduct
, &dwType
, buff
+1, &dwLen
))
988 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
992 if(SHGetValueW(HKEY_LOCAL_MACHINE
, szWinKey
, szUpdate
, &dwType
, buff
+1, &dwLen
))
994 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
996 /* ~IE Help String */
998 if(SHGetValueW(hReg
, szHelp
, 0, &dwType
, buff
+1, &dwLen
))
1000 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
1006 /*************************************************************************
1009 * Call IOleCommandTarget_QueryStatus() on an object.
1012 * lpUnknown [I] Object supporting the IOleCommandTarget interface
1013 * pguidCmdGroup [I] GUID for the command group
1015 * prgCmds [O] Commands
1016 * pCmdText [O] Command text
1020 * Failure: E_FAIL, if lpUnknown is NULL.
1021 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
1022 * Otherwise, an error code from IOleCommandTarget_QueryStatus().
1024 HRESULT WINAPI
IUnknown_QueryStatus(IUnknown
* lpUnknown
, REFGUID pguidCmdGroup
,
1025 ULONG cCmds
, OLECMD
*prgCmds
, OLECMDTEXT
* pCmdText
)
1027 HRESULT hRet
= E_FAIL
;
1029 TRACE("(%p,%p,%d,%p,%p)\n",lpUnknown
, pguidCmdGroup
, cCmds
, prgCmds
, pCmdText
);
1033 IOleCommandTarget
* lpOle
;
1035 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleCommandTarget
,
1038 if (SUCCEEDED(hRet
) && lpOle
)
1040 hRet
= IOleCommandTarget_QueryStatus(lpOle
, pguidCmdGroup
, cCmds
,
1042 IOleCommandTarget_Release(lpOle
);
1048 /*************************************************************************
1051 * Call IOleCommandTarget_Exec() on an object.
1054 * lpUnknown [I] Object supporting the IOleCommandTarget interface
1055 * pguidCmdGroup [I] GUID for the command group
1059 * Failure: E_FAIL, if lpUnknown is NULL.
1060 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
1061 * Otherwise, an error code from IOleCommandTarget_Exec().
1063 HRESULT WINAPI
IUnknown_Exec(IUnknown
* lpUnknown
, REFGUID pguidCmdGroup
,
1064 DWORD nCmdID
, DWORD nCmdexecopt
, VARIANT
* pvaIn
,
1067 HRESULT hRet
= E_FAIL
;
1069 TRACE("(%p,%p,%d,%d,%p,%p)\n",lpUnknown
, pguidCmdGroup
, nCmdID
,
1070 nCmdexecopt
, pvaIn
, pvaOut
);
1074 IOleCommandTarget
* lpOle
;
1076 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleCommandTarget
,
1078 if (SUCCEEDED(hRet
) && lpOle
)
1080 hRet
= IOleCommandTarget_Exec(lpOle
, pguidCmdGroup
, nCmdID
,
1081 nCmdexecopt
, pvaIn
, pvaOut
);
1082 IOleCommandTarget_Release(lpOle
);
1088 /*************************************************************************
1091 * Retrieve, modify, and re-set a value from a window.
1094 * hWnd [I] Window to get value from
1095 * offset [I] Offset of value
1096 * mask [I] Mask for flags
1097 * flags [I] Bits to set in window value
1100 * The new value as it was set, or 0 if any parameter is invalid.
1103 * Only bits specified in mask are affected - set if present in flags and
1106 LONG WINAPI
SHSetWindowBits(HWND hwnd
, INT offset
, UINT mask
, UINT flags
)
1108 LONG ret
= GetWindowLongW(hwnd
, offset
);
1109 LONG new_flags
= (flags
& mask
) | (ret
& ~mask
);
1111 TRACE("%p %d %x %x\n", hwnd
, offset
, mask
, flags
);
1113 if (new_flags
!= ret
)
1114 ret
= SetWindowLongW(hwnd
, offset
, new_flags
);
1118 /*************************************************************************
1121 * Change a window's parent.
1124 * hWnd [I] Window to change parent of
1125 * hWndParent [I] New parent window
1128 * The old parent of hWnd.
1131 * If hWndParent is NULL (desktop), the window style is changed to WS_POPUP.
1132 * If hWndParent is NOT NULL then we set the WS_CHILD style.
1134 HWND WINAPI
SHSetParentHwnd(HWND hWnd
, HWND hWndParent
)
1136 TRACE("%p, %p\n", hWnd
, hWndParent
);
1138 if(GetParent(hWnd
) == hWndParent
)
1142 SHSetWindowBits(hWnd
, GWL_STYLE
, WS_CHILD
, WS_CHILD
);
1144 SHSetWindowBits(hWnd
, GWL_STYLE
, WS_POPUP
, WS_POPUP
);
1146 return SetParent(hWnd
, hWndParent
);
1149 /*************************************************************************
1152 * Locate and advise a connection point in an IConnectionPointContainer object.
1155 * lpUnkSink [I] Sink for the connection point advise call
1156 * riid [I] REFIID of connection point to advise
1157 * fConnect [I] TRUE = Connection being establisted, FALSE = broken
1158 * lpUnknown [I] Object supporting the IConnectionPointContainer interface
1159 * lpCookie [O] Pointer to connection point cookie
1160 * lppCP [O] Destination for the IConnectionPoint found
1163 * Success: S_OK. If lppCP is non-NULL, it is filled with the IConnectionPoint
1164 * that was advised. The caller is responsible for releasing it.
1165 * Failure: E_FAIL, if any arguments are invalid.
1166 * E_NOINTERFACE, if lpUnknown isn't an IConnectionPointContainer,
1167 * Or an HRESULT error code if any call fails.
1169 HRESULT WINAPI
ConnectToConnectionPoint(IUnknown
* lpUnkSink
, REFIID riid
, BOOL fConnect
,
1170 IUnknown
* lpUnknown
, LPDWORD lpCookie
,
1171 IConnectionPoint
**lppCP
)
1174 IConnectionPointContainer
* lpContainer
;
1175 IConnectionPoint
*lpCP
;
1177 if(!lpUnknown
|| (fConnect
&& !lpUnkSink
))
1183 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IConnectionPointContainer
,
1184 (void**)&lpContainer
);
1185 if (SUCCEEDED(hRet
))
1187 hRet
= IConnectionPointContainer_FindConnectionPoint(lpContainer
, riid
, &lpCP
);
1189 if (SUCCEEDED(hRet
))
1192 hRet
= IConnectionPoint_Unadvise(lpCP
, *lpCookie
);
1194 hRet
= IConnectionPoint_Advise(lpCP
, lpUnkSink
, lpCookie
);
1199 if (lppCP
&& SUCCEEDED(hRet
))
1200 *lppCP
= lpCP
; /* Caller keeps the interface */
1202 IConnectionPoint_Release(lpCP
); /* Release it */
1205 IUnknown_Release(lpContainer
);
1210 /*************************************************************************
1213 * Release an interface and zero a supplied pointer.
1216 * lpUnknown [I] Object to release
1221 void WINAPI
IUnknown_AtomicRelease(IUnknown
** lpUnknown
)
1223 TRACE("(%p)\n", lpUnknown
);
1225 if(!lpUnknown
|| !*lpUnknown
) return;
1227 TRACE("doing Release\n");
1229 IUnknown_Release(*lpUnknown
);
1233 /*************************************************************************
1236 * Skip '//' if present in a string.
1239 * lpszSrc [I] String to check for '//'
1242 * Success: The next character after the '//' or the string if not present
1243 * Failure: NULL, if lpszStr is NULL.
1245 LPCSTR WINAPI
PathSkipLeadingSlashesA(LPCSTR lpszSrc
)
1247 if (lpszSrc
&& lpszSrc
[0] == '/' && lpszSrc
[1] == '/')
1252 /*************************************************************************
1255 * Check if two interfaces come from the same object.
1258 * lpInt1 [I] Interface to check against lpInt2.
1259 * lpInt2 [I] Interface to check against lpInt1.
1262 * TRUE, If the interfaces come from the same object.
1265 BOOL WINAPI
SHIsSameObject(IUnknown
* lpInt1
, IUnknown
* lpInt2
)
1267 IUnknown
*lpUnknown1
, *lpUnknown2
;
1270 TRACE("(%p %p)\n", lpInt1
, lpInt2
);
1272 if (!lpInt1
|| !lpInt2
)
1275 if (lpInt1
== lpInt2
)
1278 if (IUnknown_QueryInterface(lpInt1
, &IID_IUnknown
, (void**)&lpUnknown1
) != S_OK
)
1281 if (IUnknown_QueryInterface(lpInt2
, &IID_IUnknown
, (void**)&lpUnknown2
) != S_OK
)
1283 IUnknown_Release(lpUnknown1
);
1287 ret
= lpUnknown1
== lpUnknown2
;
1289 IUnknown_Release(lpUnknown1
);
1290 IUnknown_Release(lpUnknown2
);
1295 /*************************************************************************
1298 * Get the window handle of an object.
1301 * lpUnknown [I] Object to get the window handle of
1302 * lphWnd [O] Destination for window handle
1305 * Success: S_OK. lphWnd contains the objects window handle.
1306 * Failure: An HRESULT error code.
1309 * lpUnknown is expected to support one of the following interfaces:
1310 * IOleWindow(), IInternetSecurityMgrSite(), or IShellView().
1312 HRESULT WINAPI
IUnknown_GetWindow(IUnknown
*lpUnknown
, HWND
*lphWnd
)
1315 HRESULT hRet
= E_FAIL
;
1317 TRACE("(%p,%p)\n", lpUnknown
, lphWnd
);
1322 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleWindow
, (void**)&lpOle
);
1326 hRet
= IUnknown_QueryInterface(lpUnknown
,&IID_IShellView
, (void**)&lpOle
);
1330 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInternetSecurityMgrSite
,
1335 if (SUCCEEDED(hRet
))
1337 /* Lazyness here - Since GetWindow() is the first method for the above 3
1338 * interfaces, we use the same call for them all.
1340 hRet
= IOleWindow_GetWindow((IOleWindow
*)lpOle
, lphWnd
);
1341 IUnknown_Release(lpOle
);
1343 TRACE("Returning HWND=%p\n", *lphWnd
);
1349 /*************************************************************************
1352 * Call a SetOwner method of IShellService from specified object.
1355 * iface [I] Object that supports IShellService
1356 * pUnk [I] Argument for the SetOwner call
1359 * Corresponding return value from last call or E_FAIL for null input
1361 HRESULT WINAPI
IUnknown_SetOwner(IUnknown
*iface
, IUnknown
*pUnk
)
1363 IShellService
*service
;
1366 TRACE("(%p, %p)\n", iface
, pUnk
);
1368 if (!iface
) return E_FAIL
;
1370 hr
= IUnknown_QueryInterface(iface
, &IID_IShellService
, (void**)&service
);
1373 hr
= IShellService_SetOwner(service
, pUnk
);
1374 IShellService_Release(service
);
1380 /*************************************************************************
1383 * Call either IObjectWithSite_SetSite() or IInternetSecurityManager_SetSecuritySite() on
1387 HRESULT WINAPI
IUnknown_SetSite(
1388 IUnknown
*obj
, /* [in] OLE object */
1389 IUnknown
*site
) /* [in] Site interface */
1392 IObjectWithSite
*iobjwithsite
;
1393 IInternetSecurityManager
*isecmgr
;
1395 if (!obj
) return E_FAIL
;
1397 hr
= IUnknown_QueryInterface(obj
, &IID_IObjectWithSite
, (LPVOID
*)&iobjwithsite
);
1398 TRACE("IID_IObjectWithSite QI ret=%08x, %p\n", hr
, iobjwithsite
);
1401 hr
= IObjectWithSite_SetSite(iobjwithsite
, site
);
1402 TRACE("done IObjectWithSite_SetSite ret=%08x\n", hr
);
1403 IUnknown_Release(iobjwithsite
);
1407 hr
= IUnknown_QueryInterface(obj
, &IID_IInternetSecurityManager
, (LPVOID
*)&isecmgr
);
1408 TRACE("IID_IInternetSecurityManager QI ret=%08x, %p\n", hr
, isecmgr
);
1409 if (FAILED(hr
)) return hr
;
1411 hr
= IInternetSecurityManager_SetSecuritySite(isecmgr
, (IInternetSecurityMgrSite
*)site
);
1412 TRACE("done IInternetSecurityManager_SetSecuritySite ret=%08x\n", hr
);
1413 IUnknown_Release(isecmgr
);
1418 /*************************************************************************
1421 * Call IPersist_GetClassID() on an object.
1424 * lpUnknown [I] Object supporting the IPersist interface
1425 * lpClassId [O] Destination for Class Id
1428 * Success: S_OK. lpClassId contains the Class Id requested.
1429 * Failure: E_FAIL, If lpUnknown is NULL,
1430 * E_NOINTERFACE If lpUnknown does not support IPersist,
1431 * Or an HRESULT error code.
1433 HRESULT WINAPI
IUnknown_GetClassID(IUnknown
*lpUnknown
, CLSID
* lpClassId
)
1435 IPersist
* lpPersist
;
1436 HRESULT hRet
= E_FAIL
;
1438 TRACE("(%p,%p)\n", lpUnknown
, debugstr_guid(lpClassId
));
1442 hRet
= IUnknown_QueryInterface(lpUnknown
,&IID_IPersist
,(void**)&lpPersist
);
1443 if (SUCCEEDED(hRet
))
1445 IPersist_GetClassID(lpPersist
, lpClassId
);
1446 IPersist_Release(lpPersist
);
1452 /*************************************************************************
1455 * Retrieve a Service Interface from an object.
1458 * lpUnknown [I] Object to get an IServiceProvider interface from
1459 * sid [I] Service ID for IServiceProvider_QueryService() call
1460 * riid [I] Function requested for QueryService call
1461 * lppOut [O] Destination for the service interface pointer
1464 * Success: S_OK. lppOut contains an object providing the requested service
1465 * Failure: An HRESULT error code
1468 * lpUnknown is expected to support the IServiceProvider interface.
1470 HRESULT WINAPI
IUnknown_QueryService(IUnknown
* lpUnknown
, REFGUID sid
, REFIID riid
,
1473 IServiceProvider
* pService
= NULL
;
1484 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IServiceProvider
,
1485 (LPVOID
*)&pService
);
1487 if (hRet
== S_OK
&& pService
)
1489 TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService
);
1491 /* Get a Service interface from the object */
1492 hRet
= IServiceProvider_QueryService(pService
, sid
, riid
, lppOut
);
1494 TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService
, *lppOut
);
1496 IUnknown_Release(pService
);
1501 /*************************************************************************
1504 * Calls IOleCommandTarget::Exec() for specified service object.
1507 * lpUnknown [I] Object to get an IServiceProvider interface from
1508 * service [I] Service ID for IServiceProvider_QueryService() call
1509 * group [I] Group ID for IOleCommandTarget::Exec() call
1510 * cmdId [I] Command ID for IOleCommandTarget::Exec() call
1511 * cmdOpt [I] Options flags for command
1512 * pIn [I] Input arguments for command
1513 * pOut [O] Output arguments for command
1516 * Success: S_OK. lppOut contains an object providing the requested service
1517 * Failure: An HRESULT error code
1520 * lpUnknown is expected to support the IServiceProvider interface.
1522 HRESULT WINAPI
IUnknown_QueryServiceExec(IUnknown
*lpUnknown
, REFIID service
,
1523 const GUID
*group
, DWORD cmdId
, DWORD cmdOpt
, VARIANT
*pIn
, VARIANT
*pOut
)
1525 IOleCommandTarget
*target
;
1528 TRACE("%p %s %s %d %08x %p %p\n", lpUnknown
, debugstr_guid(service
),
1529 debugstr_guid(group
), cmdId
, cmdOpt
, pIn
, pOut
);
1531 hr
= IUnknown_QueryService(lpUnknown
, service
, &IID_IOleCommandTarget
, (void**)&target
);
1534 hr
= IOleCommandTarget_Exec(target
, group
, cmdId
, cmdOpt
, pIn
, pOut
);
1535 IOleCommandTarget_Release(target
);
1538 TRACE("<-- hr=0x%08x\n", hr
);
1543 /*************************************************************************
1546 * Calls IProfferService methods to proffer/revoke specified service.
1549 * lpUnknown [I] Object to get an IServiceProvider interface from
1550 * service [I] Service ID for IProfferService::Proffer/Revoke calls
1551 * pService [I] Service to proffer. If NULL ::Revoke is called
1552 * pCookie [IO] Group ID for IOleCommandTarget::Exec() call
1555 * Success: S_OK. IProffer method returns S_OK
1556 * Failure: An HRESULT error code
1559 * lpUnknown is expected to support the IServiceProvider interface.
1561 HRESULT WINAPI
IUnknown_ProfferService(IUnknown
*lpUnknown
, REFGUID service
, IServiceProvider
*pService
, DWORD
*pCookie
)
1563 IProfferService
*proffer
;
1566 TRACE("%p %s %p %p\n", lpUnknown
, debugstr_guid(service
), pService
, pCookie
);
1568 hr
= IUnknown_QueryService(lpUnknown
, &IID_IProfferService
, &IID_IProfferService
, (void**)&proffer
);
1572 hr
= IProfferService_ProfferService(proffer
, service
, pService
, pCookie
);
1574 hr
= IProfferService_RevokeService(proffer
, *pCookie
);
1576 IProfferService_Release(proffer
);
1582 /*************************************************************************
1585 * Call an object's UIActivateIO method.
1588 * unknown [I] Object to call the UIActivateIO method on
1589 * activate [I] Parameter for UIActivateIO call
1590 * msg [I] Parameter for UIActivateIO call
1593 * Success: Value of UI_ActivateIO call
1594 * Failure: An HRESULT error code
1597 * unknown is expected to support the IInputObject interface.
1599 HRESULT WINAPI
IUnknown_UIActivateIO(IUnknown
*unknown
, BOOL activate
, LPMSG msg
)
1601 IInputObject
* object
= NULL
;
1607 /* Get an IInputObject interface from the object */
1608 ret
= IUnknown_QueryInterface(unknown
, &IID_IInputObject
, (LPVOID
*) &object
);
1612 ret
= IInputObject_UIActivateIO(object
, activate
, msg
);
1613 IUnknown_Release(object
);
1619 /*************************************************************************
1622 * Loads a popup menu.
1625 * hInst [I] Instance handle
1626 * szName [I] Menu name
1632 BOOL WINAPI
SHLoadMenuPopup(HINSTANCE hInst
, LPCWSTR szName
)
1636 TRACE("%p %s\n", hInst
, debugstr_w(szName
));
1638 if ((hMenu
= LoadMenuW(hInst
, szName
)))
1640 if (GetSubMenu(hMenu
, 0))
1641 RemoveMenu(hMenu
, 0, MF_BYPOSITION
);
1649 typedef struct _enumWndData
1654 LRESULT (WINAPI
*pfnPost
)(HWND
,UINT
,WPARAM
,LPARAM
);
1657 /* Callback for SHLWAPI_178 */
1658 static BOOL CALLBACK
SHLWAPI_EnumChildProc(HWND hWnd
, LPARAM lParam
)
1660 enumWndData
*data
= (enumWndData
*)lParam
;
1662 TRACE("(%p,%p)\n", hWnd
, data
);
1663 data
->pfnPost(hWnd
, data
->uiMsgId
, data
->wParam
, data
->lParam
);
1667 /*************************************************************************
1670 * Send or post a message to every child of a window.
1673 * hWnd [I] Window whose children will get the messages
1674 * uiMsgId [I] Message Id
1675 * wParam [I] WPARAM of message
1676 * lParam [I] LPARAM of message
1677 * bSend [I] TRUE = Use SendMessageA(), FALSE = Use PostMessageA()
1683 * The appropriate ASCII or Unicode function is called for the window.
1685 void WINAPI
SHPropagateMessage(HWND hWnd
, UINT uiMsgId
, WPARAM wParam
, LPARAM lParam
, BOOL bSend
)
1689 TRACE("(%p,%u,%ld,%ld,%d)\n", hWnd
, uiMsgId
, wParam
, lParam
, bSend
);
1693 data
.uiMsgId
= uiMsgId
;
1694 data
.wParam
= wParam
;
1695 data
.lParam
= lParam
;
1698 data
.pfnPost
= IsWindowUnicode(hWnd
) ? (void*)SendMessageW
: (void*)SendMessageA
;
1700 data
.pfnPost
= IsWindowUnicode(hWnd
) ? (void*)PostMessageW
: (void*)PostMessageA
;
1702 EnumChildWindows(hWnd
, SHLWAPI_EnumChildProc
, (LPARAM
)&data
);
1706 /*************************************************************************
1709 * Remove all sub-menus from a menu.
1712 * hMenu [I] Menu to remove sub-menus from
1715 * Success: 0. All sub-menus under hMenu are removed
1716 * Failure: -1, if any parameter is invalid
1718 DWORD WINAPI
SHRemoveAllSubMenus(HMENU hMenu
)
1720 int iItemCount
= GetMenuItemCount(hMenu
) - 1;
1722 TRACE("%p\n", hMenu
);
1724 while (iItemCount
>= 0)
1726 HMENU hSubMenu
= GetSubMenu(hMenu
, iItemCount
);
1728 RemoveMenu(hMenu
, iItemCount
, MF_BYPOSITION
);
1734 /*************************************************************************
1737 * Enable or disable a menu item.
1740 * hMenu [I] Menu holding menu item
1741 * uID [I] ID of menu item to enable/disable
1742 * bEnable [I] Whether to enable (TRUE) or disable (FALSE) the item.
1745 * The return code from EnableMenuItem.
1747 UINT WINAPI
SHEnableMenuItem(HMENU hMenu
, UINT wItemID
, BOOL bEnable
)
1749 TRACE("%p, %u, %d\n", hMenu
, wItemID
, bEnable
);
1750 return EnableMenuItem(hMenu
, wItemID
, bEnable
? MF_ENABLED
: MF_GRAYED
);
1753 /*************************************************************************
1756 * Check or uncheck a menu item.
1759 * hMenu [I] Menu holding menu item
1760 * uID [I] ID of menu item to check/uncheck
1761 * bCheck [I] Whether to check (TRUE) or uncheck (FALSE) the item.
1764 * The return code from CheckMenuItem.
1766 DWORD WINAPI
SHCheckMenuItem(HMENU hMenu
, UINT uID
, BOOL bCheck
)
1768 TRACE("%p, %u, %d\n", hMenu
, uID
, bCheck
);
1769 return CheckMenuItem(hMenu
, uID
, bCheck
? MF_CHECKED
: MF_UNCHECKED
);
1772 /*************************************************************************
1775 * Register a window class if it isn't already.
1778 * lpWndClass [I] Window class to register
1781 * The result of the RegisterClassA call.
1783 DWORD WINAPI
SHRegisterClassA(WNDCLASSA
*wndclass
)
1786 if (GetClassInfoA(wndclass
->hInstance
, wndclass
->lpszClassName
, &wca
))
1788 return (DWORD
)RegisterClassA(wndclass
);
1791 /*************************************************************************
1794 BOOL WINAPI
SHSimulateDrop(IDropTarget
*pDrop
, IDataObject
*pDataObj
,
1795 DWORD grfKeyState
, PPOINTL lpPt
, DWORD
* pdwEffect
)
1797 DWORD dwEffect
= DROPEFFECT_LINK
| DROPEFFECT_MOVE
| DROPEFFECT_COPY
;
1798 POINTL pt
= { 0, 0 };
1800 TRACE("%p %p 0x%08x %p %p\n", pDrop
, pDataObj
, grfKeyState
, lpPt
, pdwEffect
);
1806 pdwEffect
= &dwEffect
;
1808 IDropTarget_DragEnter(pDrop
, pDataObj
, grfKeyState
, *lpPt
, pdwEffect
);
1810 if (*pdwEffect
!= DROPEFFECT_NONE
)
1811 return IDropTarget_Drop(pDrop
, pDataObj
, grfKeyState
, *lpPt
, pdwEffect
);
1813 IDropTarget_DragLeave(pDrop
);
1817 /*************************************************************************
1820 * Call IPersistPropertyBag_Load() on an object.
1823 * lpUnknown [I] Object supporting the IPersistPropertyBag interface
1824 * lpPropBag [O] Destination for loaded IPropertyBag
1828 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1830 DWORD WINAPI
SHLoadFromPropertyBag(IUnknown
*lpUnknown
, IPropertyBag
* lpPropBag
)
1832 IPersistPropertyBag
* lpPPBag
;
1833 HRESULT hRet
= E_FAIL
;
1835 TRACE("(%p,%p)\n", lpUnknown
, lpPropBag
);
1839 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IPersistPropertyBag
,
1841 if (SUCCEEDED(hRet
) && lpPPBag
)
1843 hRet
= IPersistPropertyBag_Load(lpPPBag
, lpPropBag
, NULL
);
1844 IPersistPropertyBag_Release(lpPPBag
);
1850 /*************************************************************************
1853 * Call IOleControlSite_TranslateAccelerator() on an object.
1856 * lpUnknown [I] Object supporting the IOleControlSite interface.
1857 * lpMsg [I] Key message to be processed.
1858 * dwModifiers [I] Flags containing the state of the modifier keys.
1862 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
1864 HRESULT WINAPI
IUnknown_TranslateAcceleratorOCS(IUnknown
*lpUnknown
, LPMSG lpMsg
, DWORD dwModifiers
)
1866 IOleControlSite
* lpCSite
= NULL
;
1867 HRESULT hRet
= E_INVALIDARG
;
1869 TRACE("(%p,%p,0x%08x)\n", lpUnknown
, lpMsg
, dwModifiers
);
1872 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleControlSite
,
1874 if (SUCCEEDED(hRet
) && lpCSite
)
1876 hRet
= IOleControlSite_TranslateAccelerator(lpCSite
, lpMsg
, dwModifiers
);
1877 IOleControlSite_Release(lpCSite
);
1884 /*************************************************************************
1887 * Call IOleControlSite_OnFocus() on an object.
1890 * lpUnknown [I] Object supporting the IOleControlSite interface.
1891 * fGotFocus [I] Whether focus was gained (TRUE) or lost (FALSE).
1895 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1897 HRESULT WINAPI
IUnknown_OnFocusOCS(IUnknown
*lpUnknown
, BOOL fGotFocus
)
1899 IOleControlSite
* lpCSite
= NULL
;
1900 HRESULT hRet
= E_FAIL
;
1902 TRACE("(%p, %d)\n", lpUnknown
, fGotFocus
);
1905 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleControlSite
,
1907 if (SUCCEEDED(hRet
) && lpCSite
)
1909 hRet
= IOleControlSite_OnFocus(lpCSite
, fGotFocus
);
1910 IOleControlSite_Release(lpCSite
);
1916 /*************************************************************************
1919 HRESULT WINAPI
IUnknown_HandleIRestrict(LPUNKNOWN lpUnknown
, PVOID lpArg1
,
1920 PVOID lpArg2
, PVOID lpArg3
, PVOID lpArg4
)
1922 /* FIXME: {D12F26B2-D90A-11D0-830D-00AA005B4383} - What object does this represent? */
1923 static const DWORD service_id
[] = { 0xd12f26b2, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1924 /* FIXME: {D12F26B1-D90A-11D0-830D-00AA005B4383} - Also Unknown/undocumented */
1925 static const DWORD function_id
[] = { 0xd12f26b1, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1926 HRESULT hRet
= E_INVALIDARG
;
1927 LPUNKNOWN lpUnkInner
= NULL
; /* FIXME: Real type is unknown */
1929 TRACE("(%p,%p,%p,%p,%p)\n", lpUnknown
, lpArg1
, lpArg2
, lpArg3
, lpArg4
);
1931 if (lpUnknown
&& lpArg4
)
1933 hRet
= IUnknown_QueryService(lpUnknown
, (REFGUID
)service_id
,
1934 (REFGUID
)function_id
, (void**)&lpUnkInner
);
1936 if (SUCCEEDED(hRet
) && lpUnkInner
)
1938 /* FIXME: The type of service object requested is unknown, however
1939 * testing shows that its first method is called with 4 parameters.
1940 * Fake this by using IParseDisplayName_ParseDisplayName since the
1941 * signature and position in the vtable matches our unknown object type.
1943 hRet
= IParseDisplayName_ParseDisplayName((LPPARSEDISPLAYNAME
)lpUnkInner
,
1944 lpArg1
, lpArg2
, lpArg3
, lpArg4
);
1945 IUnknown_Release(lpUnkInner
);
1951 /*************************************************************************
1954 * Get a sub-menu from a menu item.
1957 * hMenu [I] Menu to get sub-menu from
1958 * uID [I] ID of menu item containing sub-menu
1961 * The sub-menu of the item, or a NULL handle if any parameters are invalid.
1963 HMENU WINAPI
SHGetMenuFromID(HMENU hMenu
, UINT uID
)
1967 TRACE("(%p,%u)\n", hMenu
, uID
);
1969 mi
.cbSize
= sizeof(mi
);
1970 mi
.fMask
= MIIM_SUBMENU
;
1972 if (!GetMenuItemInfoW(hMenu
, uID
, FALSE
, &mi
))
1978 /*************************************************************************
1981 * Get the color depth of the primary display.
1987 * The color depth of the primary display.
1989 DWORD WINAPI
SHGetCurColorRes(void)
1997 ret
= GetDeviceCaps(hdc
, BITSPIXEL
) * GetDeviceCaps(hdc
, PLANES
);
2002 /*************************************************************************
2005 * Wait for a message to arrive, with a timeout.
2008 * hand [I] Handle to query
2009 * dwTimeout [I] Timeout in ticks or INFINITE to never timeout
2012 * STATUS_TIMEOUT if no message is received before dwTimeout ticks passes.
2013 * Otherwise returns the value from MsgWaitForMultipleObjectsEx when a
2014 * message is available.
2016 DWORD WINAPI
SHWaitForSendMessageThread(HANDLE hand
, DWORD dwTimeout
)
2018 DWORD dwEndTicks
= GetTickCount() + dwTimeout
;
2021 while ((dwRet
= MsgWaitForMultipleObjectsEx(1, &hand
, dwTimeout
, QS_SENDMESSAGE
, 0)) == 1)
2025 PeekMessageW(&msg
, NULL
, 0, 0, PM_NOREMOVE
);
2027 if (dwTimeout
!= INFINITE
)
2029 if ((int)(dwTimeout
= dwEndTicks
- GetTickCount()) <= 0)
2030 return WAIT_TIMEOUT
;
2037 /*************************************************************************
2040 * Determine if a shell folder can be expanded.
2043 * lpFolder [I] Parent folder containing the object to test.
2044 * pidl [I] Id of the object to test.
2047 * Success: S_OK, if the object is expandable, S_FALSE otherwise.
2048 * Failure: E_INVALIDARG, if any argument is invalid.
2051 * If the object to be tested does not expose the IQueryInfo() interface it
2052 * will not be identified as an expandable folder.
2054 HRESULT WINAPI
SHIsExpandableFolder(LPSHELLFOLDER lpFolder
, LPCITEMIDLIST pidl
)
2056 HRESULT hRet
= E_INVALIDARG
;
2059 if (lpFolder
&& pidl
)
2061 hRet
= IShellFolder_GetUIObjectOf(lpFolder
, NULL
, 1, &pidl
, &IID_IQueryInfo
,
2062 NULL
, (void**)&lpInfo
);
2064 hRet
= S_FALSE
; /* Doesn't expose IQueryInfo */
2069 /* MSDN states of IQueryInfo_GetInfoFlags() that "This method is not
2070 * currently used". Really? You wouldn't be holding out on me would you?
2072 hRet
= IQueryInfo_GetInfoFlags(lpInfo
, &dwFlags
);
2074 if (SUCCEEDED(hRet
))
2076 /* 0x2 is an undocumented flag apparently indicating expandability */
2077 hRet
= dwFlags
& 0x2 ? S_OK
: S_FALSE
;
2080 IQueryInfo_Release(lpInfo
);
2086 /*************************************************************************
2089 * Blank out a region of text by drawing the background only.
2092 * hDC [I] Device context to draw in
2093 * pRect [I] Area to draw in
2094 * cRef [I] Color to draw in
2099 DWORD WINAPI
SHFillRectClr(HDC hDC
, LPCRECT pRect
, COLORREF cRef
)
2101 COLORREF cOldColor
= SetBkColor(hDC
, cRef
);
2102 ExtTextOutA(hDC
, 0, 0, ETO_OPAQUE
, pRect
, 0, 0, 0);
2103 SetBkColor(hDC
, cOldColor
);
2107 /*************************************************************************
2110 * Return the value associated with a key in a map.
2113 * lpKeys [I] A list of keys of length iLen
2114 * lpValues [I] A list of values associated with lpKeys, of length iLen
2115 * iLen [I] Length of both lpKeys and lpValues
2116 * iKey [I] The key value to look up in lpKeys
2119 * The value in lpValues associated with iKey, or -1 if iKey is not
2123 * - If two elements in the map share the same key, this function returns
2124 * the value closest to the start of the map
2125 * - The native version of this function crashes if lpKeys or lpValues is NULL.
2127 int WINAPI
SHSearchMapInt(const int *lpKeys
, const int *lpValues
, int iLen
, int iKey
)
2129 if (lpKeys
&& lpValues
)
2135 if (lpKeys
[i
] == iKey
)
2136 return lpValues
[i
]; /* Found */
2140 return -1; /* Not found */
2144 /*************************************************************************
2147 * Copy an interface pointer
2150 * lppDest [O] Destination for copy
2151 * lpUnknown [I] Source for copy
2156 VOID WINAPI
IUnknown_Set(IUnknown
**lppDest
, IUnknown
*lpUnknown
)
2158 TRACE("(%p,%p)\n", lppDest
, lpUnknown
);
2160 IUnknown_AtomicRelease(lppDest
);
2164 IUnknown_AddRef(lpUnknown
);
2165 *lppDest
= lpUnknown
;
2169 /*************************************************************************
2173 HRESULT WINAPI
MayQSForward(IUnknown
* lpUnknown
, PVOID lpReserved
,
2174 REFGUID riidCmdGrp
, ULONG cCmds
,
2175 OLECMD
*prgCmds
, OLECMDTEXT
* pCmdText
)
2177 FIXME("(%p,%p,%p,%d,%p,%p) - stub\n",
2178 lpUnknown
, lpReserved
, riidCmdGrp
, cCmds
, prgCmds
, pCmdText
);
2180 /* FIXME: Calls IsQSForward & IUnknown_QueryStatus */
2181 return DRAGDROP_E_NOTREGISTERED
;
2184 /*************************************************************************
2188 HRESULT WINAPI
MayExecForward(IUnknown
* lpUnknown
, INT iUnk
, REFGUID pguidCmdGroup
,
2189 DWORD nCmdID
, DWORD nCmdexecopt
, VARIANT
* pvaIn
,
2192 FIXME("(%p,%d,%p,%d,%d,%p,%p) - stub!\n", lpUnknown
, iUnk
, pguidCmdGroup
,
2193 nCmdID
, nCmdexecopt
, pvaIn
, pvaOut
);
2194 return DRAGDROP_E_NOTREGISTERED
;
2197 /*************************************************************************
2201 HRESULT WINAPI
IsQSForward(REFGUID pguidCmdGroup
,ULONG cCmds
, OLECMD
*prgCmds
)
2203 FIXME("(%p,%d,%p) - stub!\n", pguidCmdGroup
, cCmds
, prgCmds
);
2204 return DRAGDROP_E_NOTREGISTERED
;
2207 /*************************************************************************
2210 * Determine if a window is not a child of another window.
2213 * hParent [I] Suspected parent window
2214 * hChild [I] Suspected child window
2217 * TRUE: If hChild is a child window of hParent
2218 * FALSE: If hChild is not a child window of hParent, or they are equal
2220 BOOL WINAPI
SHIsChildOrSelf(HWND hParent
, HWND hChild
)
2222 TRACE("(%p,%p)\n", hParent
, hChild
);
2224 if (!hParent
|| !hChild
)
2226 else if(hParent
== hChild
)
2228 return !IsChild(hParent
, hChild
);
2231 /*************************************************************************
2232 * FDSA functions. Manage a dynamic array of fixed size memory blocks.
2237 DWORD num_items
; /* Number of elements inserted */
2238 void *mem
; /* Ptr to array */
2239 DWORD blocks_alloced
; /* Number of elements allocated */
2240 BYTE inc
; /* Number of elements to grow by when we need to expand */
2241 BYTE block_size
; /* Size in bytes of an element */
2242 BYTE flags
; /* Flags */
2245 #define FDSA_FLAG_INTERNAL_ALLOC 0x01 /* When set we have allocated mem internally */
2247 /*************************************************************************
2250 * Initialize an FDSA array.
2252 BOOL WINAPI
FDSA_Initialize(DWORD block_size
, DWORD inc
, FDSA_info
*info
, void *mem
,
2255 TRACE("(0x%08x 0x%08x %p %p 0x%08x)\n", block_size
, inc
, info
, mem
, init_blocks
);
2261 memset(mem
, 0, block_size
* init_blocks
);
2263 info
->num_items
= 0;
2266 info
->blocks_alloced
= init_blocks
;
2267 info
->block_size
= block_size
;
2273 /*************************************************************************
2276 * Destroy an FDSA array
2278 BOOL WINAPI
FDSA_Destroy(FDSA_info
*info
)
2280 TRACE("(%p)\n", info
);
2282 if(info
->flags
& FDSA_FLAG_INTERNAL_ALLOC
)
2284 HeapFree(GetProcessHeap(), 0, info
->mem
);
2291 /*************************************************************************
2294 * Insert element into an FDSA array
2296 DWORD WINAPI
FDSA_InsertItem(FDSA_info
*info
, DWORD where
, const void *block
)
2298 TRACE("(%p 0x%08x %p)\n", info
, where
, block
);
2299 if(where
> info
->num_items
)
2300 where
= info
->num_items
;
2302 if(info
->num_items
>= info
->blocks_alloced
)
2304 DWORD size
= (info
->blocks_alloced
+ info
->inc
) * info
->block_size
;
2305 if(info
->flags
& 0x1)
2306 info
->mem
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, info
->mem
, size
);
2309 void *old_mem
= info
->mem
;
2310 info
->mem
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
2311 memcpy(info
->mem
, old_mem
, info
->blocks_alloced
* info
->block_size
);
2313 info
->blocks_alloced
+= info
->inc
;
2317 if(where
< info
->num_items
)
2319 memmove((char*)info
->mem
+ (where
+ 1) * info
->block_size
,
2320 (char*)info
->mem
+ where
* info
->block_size
,
2321 (info
->num_items
- where
) * info
->block_size
);
2323 memcpy((char*)info
->mem
+ where
* info
->block_size
, block
, info
->block_size
);
2329 /*************************************************************************
2332 * Delete an element from an FDSA array.
2334 BOOL WINAPI
FDSA_DeleteItem(FDSA_info
*info
, DWORD where
)
2336 TRACE("(%p 0x%08x)\n", info
, where
);
2338 if(where
>= info
->num_items
)
2341 if(where
< info
->num_items
- 1)
2343 memmove((char*)info
->mem
+ where
* info
->block_size
,
2344 (char*)info
->mem
+ (where
+ 1) * info
->block_size
,
2345 (info
->num_items
- where
- 1) * info
->block_size
);
2347 memset((char*)info
->mem
+ (info
->num_items
- 1) * info
->block_size
,
2348 0, info
->block_size
);
2353 /*************************************************************************
2356 * Call IUnknown_QueryInterface() on a table of objects.
2360 * Failure: E_POINTER or E_NOINTERFACE.
2362 HRESULT WINAPI
QISearch(
2363 void *base
, /* [in] Table of interfaces */
2364 const QITAB
*table
, /* [in] Array of REFIIDs and indexes into the table */
2365 REFIID riid
, /* [in] REFIID to get interface for */
2366 void **ppv
) /* [out] Destination for interface pointer */
2372 TRACE("(%p %p %s %p)\n", base
, table
, debugstr_guid(riid
), ppv
);
2375 while (xmove
->piid
) {
2376 TRACE("trying (offset %d) %s\n", xmove
->dwOffset
, debugstr_guid(xmove
->piid
));
2377 if (IsEqualIID(riid
, xmove
->piid
)) {
2378 a_vtbl
= (IUnknown
*)(xmove
->dwOffset
+ (LPBYTE
)base
);
2379 TRACE("matched, returning (%p)\n", a_vtbl
);
2381 IUnknown_AddRef(a_vtbl
);
2387 if (IsEqualIID(riid
, &IID_IUnknown
)) {
2388 a_vtbl
= (IUnknown
*)(table
->dwOffset
+ (LPBYTE
)base
);
2389 TRACE("returning first for IUnknown (%p)\n", a_vtbl
);
2391 IUnknown_AddRef(a_vtbl
);
2395 ret
= E_NOINTERFACE
;
2399 TRACE("-- 0x%08x\n", ret
);
2403 /*************************************************************************
2406 * Set the Font for a window and the "PropDlgFont" property of the parent window.
2409 * hWnd [I] Parent Window to set the property
2410 * id [I] Index of child Window to set the Font
2416 HRESULT WINAPI
SHSetDefaultDialogFont(HWND hWnd
, INT id
)
2418 FIXME("(%p, %d) stub\n", hWnd
, id
);
2422 /*************************************************************************
2425 * Remove the "PropDlgFont" property from a window.
2428 * hWnd [I] Window to remove the property from
2431 * A handle to the removed property, or NULL if it did not exist.
2433 HANDLE WINAPI
SHRemoveDefaultDialogFont(HWND hWnd
)
2437 TRACE("(%p)\n", hWnd
);
2439 hProp
= GetPropA(hWnd
, "PropDlgFont");
2443 DeleteObject(hProp
);
2444 hProp
= RemovePropA(hWnd
, "PropDlgFont");
2449 /*************************************************************************
2452 * Load the in-process server of a given GUID.
2455 * refiid [I] GUID of the server to load.
2458 * Success: A handle to the loaded server dll.
2459 * Failure: A NULL handle.
2461 HMODULE WINAPI
SHPinDllOfCLSID(REFIID refiid
)
2465 CHAR value
[MAX_PATH
], string
[MAX_PATH
];
2467 strcpy(string
, "CLSID\\");
2468 SHStringFromGUIDA(refiid
, string
+ 6, sizeof(string
)/sizeof(char) - 6);
2469 strcat(string
, "\\InProcServer32");
2472 RegOpenKeyExA(HKEY_CLASSES_ROOT
, string
, 0, 1, &newkey
);
2473 RegQueryValueExA(newkey
, 0, 0, &type
, (PBYTE
)value
, &count
);
2474 RegCloseKey(newkey
);
2475 return LoadLibraryExA(value
, 0, 0);
2478 /*************************************************************************
2481 * Unicode version of SHLWAPI_183.
2483 DWORD WINAPI
SHRegisterClassW(WNDCLASSW
* lpWndClass
)
2487 TRACE("(%p %s)\n",lpWndClass
->hInstance
, debugstr_w(lpWndClass
->lpszClassName
));
2489 if (GetClassInfoW(lpWndClass
->hInstance
, lpWndClass
->lpszClassName
, &WndClass
))
2491 return RegisterClassW(lpWndClass
);
2494 /*************************************************************************
2497 * Unregister a list of classes.
2500 * hInst [I] Application instance that registered the classes
2501 * lppClasses [I] List of class names
2502 * iCount [I] Number of names in lppClasses
2507 void WINAPI
SHUnregisterClassesA(HINSTANCE hInst
, LPCSTR
*lppClasses
, INT iCount
)
2511 TRACE("(%p,%p,%d)\n", hInst
, lppClasses
, iCount
);
2515 if (GetClassInfoA(hInst
, *lppClasses
, &WndClass
))
2516 UnregisterClassA(*lppClasses
, hInst
);
2522 /*************************************************************************
2525 * Unicode version of SHUnregisterClassesA.
2527 void WINAPI
SHUnregisterClassesW(HINSTANCE hInst
, LPCWSTR
*lppClasses
, INT iCount
)
2531 TRACE("(%p,%p,%d)\n", hInst
, lppClasses
, iCount
);
2535 if (GetClassInfoW(hInst
, *lppClasses
, &WndClass
))
2536 UnregisterClassW(*lppClasses
, hInst
);
2542 /*************************************************************************
2545 * Call The correct (Ascii/Unicode) default window procedure for a window.
2548 * hWnd [I] Window to call the default procedure for
2549 * uMessage [I] Message ID
2550 * wParam [I] WPARAM of message
2551 * lParam [I] LPARAM of message
2554 * The result of calling DefWindowProcA() or DefWindowProcW().
2556 LRESULT CALLBACK
SHDefWindowProc(HWND hWnd
, UINT uMessage
, WPARAM wParam
, LPARAM lParam
)
2558 if (IsWindowUnicode(hWnd
))
2559 return DefWindowProcW(hWnd
, uMessage
, wParam
, lParam
);
2560 return DefWindowProcA(hWnd
, uMessage
, wParam
, lParam
);
2563 /*************************************************************************
2566 HRESULT WINAPI
IUnknown_GetSite(LPUNKNOWN lpUnknown
, REFIID iid
, PVOID
*lppSite
)
2568 HRESULT hRet
= E_INVALIDARG
;
2569 LPOBJECTWITHSITE lpSite
= NULL
;
2571 TRACE("(%p,%s,%p)\n", lpUnknown
, debugstr_guid(iid
), lppSite
);
2573 if (lpUnknown
&& iid
&& lppSite
)
2575 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IObjectWithSite
,
2577 if (SUCCEEDED(hRet
) && lpSite
)
2579 hRet
= IObjectWithSite_GetSite(lpSite
, iid
, lppSite
);
2580 IObjectWithSite_Release(lpSite
);
2586 /*************************************************************************
2589 * Create a worker window using CreateWindowExA().
2592 * wndProc [I] Window procedure
2593 * hWndParent [I] Parent window
2594 * dwExStyle [I] Extra style flags
2595 * dwStyle [I] Style flags
2596 * hMenu [I] Window menu
2597 * wnd_extra [I] Window extra bytes value
2600 * Success: The window handle of the newly created window.
2603 HWND WINAPI
SHCreateWorkerWindowA(LONG wndProc
, HWND hWndParent
, DWORD dwExStyle
,
2604 DWORD dwStyle
, HMENU hMenu
, LONG_PTR wnd_extra
)
2606 static const char szClass
[] = "WorkerA";
2610 TRACE("(0x%08x, %p, 0x%08x, 0x%08x, %p, 0x%08lx)\n",
2611 wndProc
, hWndParent
, dwExStyle
, dwStyle
, hMenu
, wnd_extra
);
2613 /* Create Window class */
2615 wc
.lpfnWndProc
= DefWindowProcA
;
2617 wc
.cbWndExtra
= sizeof(LONG_PTR
);
2618 wc
.hInstance
= shlwapi_hInstance
;
2620 wc
.hCursor
= LoadCursorA(NULL
, (LPSTR
)IDC_ARROW
);
2621 wc
.hbrBackground
= (HBRUSH
)(COLOR_BTNFACE
+ 1);
2622 wc
.lpszMenuName
= NULL
;
2623 wc
.lpszClassName
= szClass
;
2625 SHRegisterClassA(&wc
);
2627 hWnd
= CreateWindowExA(dwExStyle
, szClass
, 0, dwStyle
, 0, 0, 0, 0,
2628 hWndParent
, hMenu
, shlwapi_hInstance
, 0);
2631 SetWindowLongPtrW(hWnd
, 0, wnd_extra
);
2633 if (wndProc
) SetWindowLongPtrA(hWnd
, GWLP_WNDPROC
, wndProc
);
2639 typedef struct tagPOLICYDATA
2641 DWORD policy
; /* flags value passed to SHRestricted */
2642 LPCWSTR appstr
; /* application str such as "Explorer" */
2643 LPCWSTR keystr
; /* name of the actual registry key / policy */
2644 } POLICYDATA
, *LPPOLICYDATA
;
2646 #define SHELL_NO_POLICY 0xffffffff
2648 /* default shell policy registry key */
2649 static const WCHAR strRegistryPolicyW
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o',
2650 's','o','f','t','\\','W','i','n','d','o','w','s','\\',
2651 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',
2652 '\\','P','o','l','i','c','i','e','s',0};
2654 /*************************************************************************
2657 * Retrieve a policy value from the registry.
2660 * lpSubKey [I] registry key name
2661 * lpSubName [I] subname of registry key
2662 * lpValue [I] value name of registry value
2665 * the value associated with the registry key or 0 if not found
2667 DWORD WINAPI
SHGetRestriction(LPCWSTR lpSubKey
, LPCWSTR lpSubName
, LPCWSTR lpValue
)
2669 DWORD retval
, datsize
= sizeof(retval
);
2673 lpSubKey
= strRegistryPolicyW
;
2675 retval
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, lpSubKey
, &hKey
);
2676 if (retval
!= ERROR_SUCCESS
)
2677 retval
= RegOpenKeyW(HKEY_CURRENT_USER
, lpSubKey
, &hKey
);
2678 if (retval
!= ERROR_SUCCESS
)
2681 SHGetValueW(hKey
, lpSubName
, lpValue
, NULL
, &retval
, &datsize
);
2686 /*************************************************************************
2689 * Helper function to retrieve the possibly cached value for a specific policy
2692 * policy [I] The policy to look for
2693 * initial [I] Main registry key to open, if NULL use default
2694 * polTable [I] Table of known policies, 0 terminated
2695 * polArr [I] Cache array of policy values
2698 * The retrieved policy value or 0 if not successful
2701 * This function is used by the native SHRestricted function to search for the
2702 * policy and cache it once retrieved. The current Wine implementation uses a
2703 * different POLICYDATA structure and implements a similar algorithm adapted to
2706 DWORD WINAPI
SHRestrictionLookup(
2709 LPPOLICYDATA polTable
,
2712 TRACE("(0x%08x %s %p %p)\n", policy
, debugstr_w(initial
), polTable
, polArr
);
2714 if (!polTable
|| !polArr
)
2717 for (;polTable
->policy
; polTable
++, polArr
++)
2719 if (policy
== polTable
->policy
)
2721 /* we have a known policy */
2723 /* check if this policy has been cached */
2724 if (*polArr
== SHELL_NO_POLICY
)
2725 *polArr
= SHGetRestriction(initial
, polTable
->appstr
, polTable
->keystr
);
2729 /* we don't know this policy, return 0 */
2730 TRACE("unknown policy: (%08x)\n", policy
);
2734 /*************************************************************************
2737 * Get an interface from an object.
2740 * Success: S_OK. ppv contains the requested interface.
2741 * Failure: An HRESULT error code.
2744 * This QueryInterface asks the inner object for an interface. In case
2745 * of aggregation this request would be forwarded by the inner to the
2746 * outer object. This function asks the inner object directly for the
2747 * interface circumventing the forwarding to the outer object.
2749 HRESULT WINAPI
SHWeakQueryInterface(
2750 IUnknown
* pUnk
, /* [in] Outer object */
2751 IUnknown
* pInner
, /* [in] Inner object */
2752 IID
* riid
, /* [in] Interface GUID to query for */
2753 LPVOID
* ppv
) /* [out] Destination for queried interface */
2755 HRESULT hret
= E_NOINTERFACE
;
2756 TRACE("(pUnk=%p pInner=%p\n\tIID: %s %p)\n",pUnk
,pInner
,debugstr_guid(riid
), ppv
);
2759 if(pUnk
&& pInner
) {
2760 hret
= IUnknown_QueryInterface(pInner
, riid
, ppv
);
2761 if (SUCCEEDED(hret
)) IUnknown_Release(pUnk
);
2763 TRACE("-- 0x%08x\n", hret
);
2767 /*************************************************************************
2770 * Move a reference from one interface to another.
2773 * lpDest [O] Destination to receive the reference
2774 * lppUnknown [O] Source to give up the reference to lpDest
2779 VOID WINAPI
SHWeakReleaseInterface(IUnknown
*lpDest
, IUnknown
**lppUnknown
)
2781 TRACE("(%p,%p)\n", lpDest
, lppUnknown
);
2786 IUnknown_AddRef(lpDest
);
2787 IUnknown_AtomicRelease(lppUnknown
); /* Release existing interface */
2791 /*************************************************************************
2794 * Convert an ASCII string of a CLSID into a CLSID.
2797 * idstr [I] String representing a CLSID in registry format
2798 * id [O] Destination for the converted CLSID
2801 * Success: TRUE. id contains the converted CLSID.
2804 BOOL WINAPI
GUIDFromStringA(LPCSTR idstr
, CLSID
*id
)
2807 MultiByteToWideChar(CP_ACP
, 0, idstr
, -1, wClsid
, sizeof(wClsid
)/sizeof(WCHAR
));
2808 return SUCCEEDED(CLSIDFromString(wClsid
, id
));
2811 /*************************************************************************
2814 * Unicode version of GUIDFromStringA.
2816 BOOL WINAPI
GUIDFromStringW(LPCWSTR idstr
, CLSID
*id
)
2818 return SUCCEEDED(CLSIDFromString((LPCOLESTR
)idstr
, id
));
2821 /*************************************************************************
2824 * Determine if the browser is integrated into the shell, and set a registry
2831 * 1, If the browser is not integrated.
2832 * 2, If the browser is integrated.
2835 * The key "HKLM\Software\Microsoft\Internet Explorer\IntegratedBrowser" is
2836 * either set to TRUE, or removed depending on whether the browser is deemed
2839 DWORD WINAPI
WhichPlatform(void)
2841 static const char szIntegratedBrowser
[] = "IntegratedBrowser";
2842 static DWORD dwState
= 0;
2844 DWORD dwRet
, dwData
, dwSize
;
2850 /* If shell32 exports DllGetVersion(), the browser is integrated */
2852 hshell32
= LoadLibraryA("shell32.dll");
2855 FARPROC pDllGetVersion
;
2856 pDllGetVersion
= GetProcAddress(hshell32
, "DllGetVersion");
2857 dwState
= pDllGetVersion
? 2 : 1;
2858 FreeLibrary(hshell32
);
2861 /* Set or delete the key accordingly */
2862 dwRet
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
2863 "Software\\Microsoft\\Internet Explorer", 0,
2864 KEY_ALL_ACCESS
, &hKey
);
2867 dwRet
= RegQueryValueExA(hKey
, szIntegratedBrowser
, 0, 0,
2868 (LPBYTE
)&dwData
, &dwSize
);
2870 if (!dwRet
&& dwState
== 1)
2872 /* Value exists but browser is not integrated */
2873 RegDeleteValueA(hKey
, szIntegratedBrowser
);
2875 else if (dwRet
&& dwState
== 2)
2877 /* Browser is integrated but value does not exist */
2879 RegSetValueExA(hKey
, szIntegratedBrowser
, 0, REG_DWORD
,
2880 (LPBYTE
)&dwData
, sizeof(dwData
));
2887 /*************************************************************************
2890 * Unicode version of SHCreateWorkerWindowA.
2892 HWND WINAPI
SHCreateWorkerWindowW(LONG wndProc
, HWND hWndParent
, DWORD dwExStyle
,
2893 DWORD dwStyle
, HMENU hMenu
, LONG msg_result
)
2895 static const WCHAR szClass
[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', 0 };
2899 TRACE("(0x%08x, %p, 0x%08x, 0x%08x, %p, 0x%08x)\n",
2900 wndProc
, hWndParent
, dwExStyle
, dwStyle
, hMenu
, msg_result
);
2902 /* If our OS is natively ANSI, use the ANSI version */
2903 if (GetVersion() & 0x80000000) /* not NT */
2905 TRACE("fallback to ANSI, ver 0x%08x\n", GetVersion());
2906 return SHCreateWorkerWindowA(wndProc
, hWndParent
, dwExStyle
, dwStyle
, hMenu
, msg_result
);
2909 /* Create Window class */
2911 wc
.lpfnWndProc
= DefWindowProcW
;
2914 wc
.hInstance
= shlwapi_hInstance
;
2916 wc
.hCursor
= LoadCursorW(NULL
, (LPWSTR
)IDC_ARROW
);
2917 wc
.hbrBackground
= (HBRUSH
)(COLOR_BTNFACE
+ 1);
2918 wc
.lpszMenuName
= NULL
;
2919 wc
.lpszClassName
= szClass
;
2921 SHRegisterClassW(&wc
);
2923 hWnd
= CreateWindowExW(dwExStyle
, szClass
, 0, dwStyle
, 0, 0, 0, 0,
2924 hWndParent
, hMenu
, shlwapi_hInstance
, 0);
2927 SetWindowLongPtrW(hWnd
, DWLP_MSGRESULT
, msg_result
);
2929 if (wndProc
) SetWindowLongPtrW(hWnd
, GWLP_WNDPROC
, wndProc
);
2935 /*************************************************************************
2938 * Get and show a context menu from a shell folder.
2941 * hWnd [I] Window displaying the shell folder
2942 * lpFolder [I] IShellFolder interface
2943 * lpApidl [I] Id for the particular folder desired
2947 * Failure: An HRESULT error code indicating the error.
2949 HRESULT WINAPI
SHInvokeDefaultCommand(HWND hWnd
, IShellFolder
* lpFolder
, LPCITEMIDLIST lpApidl
)
2951 TRACE("%p %p %p\n", hWnd
, lpFolder
, lpApidl
);
2952 return SHInvokeCommand(hWnd
, lpFolder
, lpApidl
, FALSE
);
2955 /*************************************************************************
2958 * _SHPackDispParamsV
2960 HRESULT WINAPI
SHPackDispParamsV(DISPPARAMS
*params
, VARIANTARG
*args
, UINT cnt
, __ms_va_list valist
)
2964 TRACE("(%p %p %u ...)\n", params
, args
, cnt
);
2966 params
->rgvarg
= args
;
2967 params
->rgdispidNamedArgs
= NULL
;
2968 params
->cArgs
= cnt
;
2969 params
->cNamedArgs
= 0;
2973 while(iter
-- > args
) {
2974 V_VT(iter
) = va_arg(valist
, enum VARENUM
);
2976 TRACE("vt=%d\n", V_VT(iter
));
2978 if(V_VT(iter
) & VT_BYREF
) {
2979 V_BYREF(iter
) = va_arg(valist
, LPVOID
);
2981 switch(V_VT(iter
)) {
2983 V_I4(iter
) = va_arg(valist
, LONG
);
2986 V_BSTR(iter
) = va_arg(valist
, BSTR
);
2989 V_DISPATCH(iter
) = va_arg(valist
, IDispatch
*);
2992 V_BOOL(iter
) = va_arg(valist
, int);
2995 V_UNKNOWN(iter
) = va_arg(valist
, IUnknown
*);
2999 V_I4(iter
) = va_arg(valist
, LONG
);
3007 /*************************************************************************
3012 HRESULT WINAPIV
SHPackDispParams(DISPPARAMS
*params
, VARIANTARG
*args
, UINT cnt
, ...)
3014 __ms_va_list valist
;
3017 __ms_va_start(valist
, cnt
);
3018 hres
= SHPackDispParamsV(params
, args
, cnt
, valist
);
3019 __ms_va_end(valist
);
3023 /*************************************************************************
3024 * SHLWAPI_InvokeByIID
3026 * This helper function calls IDispatch::Invoke for each sink
3027 * which implements given iid or IDispatch.
3030 static HRESULT
SHLWAPI_InvokeByIID(
3031 IConnectionPoint
* iCP
,
3034 DISPPARAMS
* dispParams
)
3036 IEnumConnections
*enumerator
;
3038 static DISPPARAMS empty
= {NULL
, NULL
, 0, 0};
3039 DISPPARAMS
* params
= dispParams
;
3041 HRESULT result
= IConnectionPoint_EnumConnections(iCP
, &enumerator
);
3045 /* Invoke is never happening with an NULL dispParams */
3049 while(IEnumConnections_Next(enumerator
, 1, &rgcd
, NULL
)==S_OK
)
3051 IDispatch
*dispIface
;
3052 if ((iid
&& SUCCEEDED(IUnknown_QueryInterface(rgcd
.pUnk
, iid
, (LPVOID
*)&dispIface
))) ||
3053 SUCCEEDED(IUnknown_QueryInterface(rgcd
.pUnk
, &IID_IDispatch
, (LPVOID
*)&dispIface
)))
3055 IDispatch_Invoke(dispIface
, dispId
, &IID_NULL
, 0, DISPATCH_METHOD
, params
, NULL
, NULL
, NULL
);
3056 IDispatch_Release(dispIface
);
3058 IUnknown_Release(rgcd
.pUnk
);
3061 IEnumConnections_Release(enumerator
);
3066 /*************************************************************************
3067 * IConnectionPoint_InvokeWithCancel [SHLWAPI.283]
3069 HRESULT WINAPI
IConnectionPoint_InvokeWithCancel( IConnectionPoint
* iCP
,
3070 DISPID dispId
, DISPPARAMS
* dispParams
,
3071 DWORD unknown1
, DWORD unknown2
)
3076 FIXME("(%p)->(0x%x %p %x %x) partial stub\n", iCP
, dispId
, dispParams
, unknown1
, unknown2
);
3078 result
= IConnectionPoint_GetConnectionInterface(iCP
, &iid
);
3079 if (SUCCEEDED(result
))
3080 result
= SHLWAPI_InvokeByIID(iCP
, &iid
, dispId
, dispParams
);
3082 result
= SHLWAPI_InvokeByIID(iCP
, NULL
, dispId
, dispParams
);
3088 /*************************************************************************
3091 * IConnectionPoint_SimpleInvoke
3093 HRESULT WINAPI
IConnectionPoint_SimpleInvoke(
3094 IConnectionPoint
* iCP
,
3096 DISPPARAMS
* dispParams
)
3101 TRACE("(%p)->(0x%x %p)\n",iCP
,dispId
,dispParams
);
3103 result
= IConnectionPoint_GetConnectionInterface(iCP
, &iid
);
3104 if (SUCCEEDED(result
))
3105 result
= SHLWAPI_InvokeByIID(iCP
, &iid
, dispId
, dispParams
);
3107 result
= SHLWAPI_InvokeByIID(iCP
, NULL
, dispId
, dispParams
);
3112 /*************************************************************************
3115 * Notify an IConnectionPoint object of changes.
3118 * lpCP [I] Object to notify
3123 * Failure: E_NOINTERFACE, if lpCP is NULL or does not support the
3124 * IConnectionPoint interface.
3126 HRESULT WINAPI
IConnectionPoint_OnChanged(IConnectionPoint
* lpCP
, DISPID dispID
)
3128 IEnumConnections
*lpEnum
;
3129 HRESULT hRet
= E_NOINTERFACE
;
3131 TRACE("(%p,0x%8X)\n", lpCP
, dispID
);
3133 /* Get an enumerator for the connections */
3135 hRet
= IConnectionPoint_EnumConnections(lpCP
, &lpEnum
);
3137 if (SUCCEEDED(hRet
))
3139 IPropertyNotifySink
*lpSink
;
3140 CONNECTDATA connData
;
3143 /* Call OnChanged() for every notify sink in the connection point */
3144 while (IEnumConnections_Next(lpEnum
, 1, &connData
, &ulFetched
) == S_OK
)
3146 if (SUCCEEDED(IUnknown_QueryInterface(connData
.pUnk
, &IID_IPropertyNotifySink
, (void**)&lpSink
)) &&
3149 IPropertyNotifySink_OnChanged(lpSink
, dispID
);
3150 IPropertyNotifySink_Release(lpSink
);
3152 IUnknown_Release(connData
.pUnk
);
3155 IEnumConnections_Release(lpEnum
);
3160 /*************************************************************************
3163 * IUnknown_CPContainerInvokeParam
3165 HRESULT WINAPIV
IUnknown_CPContainerInvokeParam(
3166 IUnknown
*container
,
3173 IConnectionPoint
*iCP
;
3174 IConnectionPointContainer
*iCPC
;
3175 DISPPARAMS dispParams
= {buffer
, NULL
, cParams
, 0};
3176 __ms_va_list valist
;
3179 return E_NOINTERFACE
;
3181 result
= IUnknown_QueryInterface(container
, &IID_IConnectionPointContainer
,(LPVOID
*) &iCPC
);
3185 result
= IConnectionPointContainer_FindConnectionPoint(iCPC
, riid
, &iCP
);
3186 IConnectionPointContainer_Release(iCPC
);
3190 __ms_va_start(valist
, cParams
);
3191 SHPackDispParamsV(&dispParams
, buffer
, cParams
, valist
);
3192 __ms_va_end(valist
);
3194 result
= SHLWAPI_InvokeByIID(iCP
, riid
, dispId
, &dispParams
);
3195 IConnectionPoint_Release(iCP
);
3200 /*************************************************************************
3203 * Notify an IConnectionPointContainer object of changes.
3206 * lpUnknown [I] Object to notify
3211 * Failure: E_NOINTERFACE, if lpUnknown is NULL or does not support the
3212 * IConnectionPointContainer interface.
3214 HRESULT WINAPI
IUnknown_CPContainerOnChanged(IUnknown
*lpUnknown
, DISPID dispID
)
3216 IConnectionPointContainer
* lpCPC
= NULL
;
3217 HRESULT hRet
= E_NOINTERFACE
;
3219 TRACE("(%p,0x%8X)\n", lpUnknown
, dispID
);
3222 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IConnectionPointContainer
, (void**)&lpCPC
);
3224 if (SUCCEEDED(hRet
))
3226 IConnectionPoint
* lpCP
;
3228 hRet
= IConnectionPointContainer_FindConnectionPoint(lpCPC
, &IID_IPropertyNotifySink
, &lpCP
);
3229 IConnectionPointContainer_Release(lpCPC
);
3231 hRet
= IConnectionPoint_OnChanged(lpCP
, dispID
);
3232 IConnectionPoint_Release(lpCP
);
3237 /*************************************************************************
3242 BOOL WINAPI
PlaySoundWrapW(LPCWSTR pszSound
, HMODULE hmod
, DWORD fdwSound
)
3244 return PlaySoundW(pszSound
, hmod
, fdwSound
);
3247 /*************************************************************************
3250 * Retrieve a key value from an INI file. See GetPrivateProfileString for
3254 * appName [I] The section in the INI file that contains the key
3255 * keyName [I] The key to be retrieved
3256 * out [O] The buffer into which the key's value will be copied
3257 * outLen [I] The length of the `out' buffer
3258 * filename [I] The location of the INI file
3261 * Length of string copied into `out'.
3263 DWORD WINAPI
SHGetIniStringW(LPCWSTR appName
, LPCWSTR keyName
, LPWSTR out
,
3264 DWORD outLen
, LPCWSTR filename
)
3269 TRACE("(%s,%s,%p,%08x,%s)\n", debugstr_w(appName
), debugstr_w(keyName
),
3270 out
, outLen
, debugstr_w(filename
));
3275 buf
= HeapAlloc(GetProcessHeap(), 0, outLen
* sizeof(WCHAR
));
3281 ret
= GetPrivateProfileStringW(appName
, keyName
, NULL
, buf
, outLen
, filename
);
3287 HeapFree(GetProcessHeap(), 0, buf
);
3289 return strlenW(out
);
3292 /*************************************************************************
3295 * Set a key value in an INI file. See WritePrivateProfileString for
3299 * appName [I] The section in the INI file that contains the key
3300 * keyName [I] The key to be set
3301 * str [O] The value of the key
3302 * filename [I] The location of the INI file
3308 BOOL WINAPI
SHSetIniStringW(LPCWSTR appName
, LPCWSTR keyName
, LPCWSTR str
,
3311 TRACE("(%s, %p, %s, %s)\n", debugstr_w(appName
), keyName
, debugstr_w(str
),
3312 debugstr_w(filename
));
3314 return WritePrivateProfileStringW(appName
, keyName
, str
, filename
);
3317 /*************************************************************************
3320 * See SHGetFileInfoW.
3322 DWORD WINAPI
SHGetFileInfoWrapW(LPCWSTR path
, DWORD dwFileAttributes
,
3323 SHFILEINFOW
*psfi
, UINT sizeofpsfi
, UINT flags
)
3325 return SHGetFileInfoW(path
, dwFileAttributes
, psfi
, sizeofpsfi
, flags
);
3328 /*************************************************************************
3331 * See DragQueryFileW.
3333 UINT WINAPI
DragQueryFileWrapW(HDROP hDrop
, UINT lFile
, LPWSTR lpszFile
, UINT lLength
)
3335 return DragQueryFileW(hDrop
, lFile
, lpszFile
, lLength
);
3338 /*************************************************************************
3341 * See SHBrowseForFolderW.
3343 LPITEMIDLIST WINAPI
SHBrowseForFolderWrapW(LPBROWSEINFOW lpBi
)
3345 return SHBrowseForFolderW(lpBi
);
3348 /*************************************************************************
3351 * See SHGetPathFromIDListW.
3353 BOOL WINAPI
SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl
,LPWSTR pszPath
)
3355 return SHGetPathFromIDListW(pidl
, pszPath
);
3358 /*************************************************************************
3361 * See ShellExecuteExW.
3363 BOOL WINAPI
ShellExecuteExWrapW(LPSHELLEXECUTEINFOW lpExecInfo
)
3365 return ShellExecuteExW(lpExecInfo
);
3368 /*************************************************************************
3371 * See SHFileOperationW.
3373 INT WINAPI
SHFileOperationWrapW(LPSHFILEOPSTRUCTW lpFileOp
)
3375 return SHFileOperationW(lpFileOp
);
3378 /*************************************************************************
3382 PVOID WINAPI
SHInterlockedCompareExchange( PVOID
*dest
, PVOID xchg
, PVOID compare
)
3384 return InterlockedCompareExchangePointer( dest
, xchg
, compare
);
3387 /*************************************************************************
3390 * See GetFileVersionInfoSizeW.
3392 DWORD WINAPI
GetFileVersionInfoSizeWrapW( LPCWSTR filename
, LPDWORD handle
)
3394 return GetFileVersionInfoSizeW( filename
, handle
);
3397 /*************************************************************************
3400 * See GetFileVersionInfoW.
3402 BOOL WINAPI
GetFileVersionInfoWrapW( LPCWSTR filename
, DWORD handle
,
3403 DWORD datasize
, LPVOID data
)
3405 return GetFileVersionInfoW( filename
, handle
, datasize
, data
);
3408 /*************************************************************************
3411 * See VerQueryValueW.
3413 WORD WINAPI
VerQueryValueWrapW( LPVOID pBlock
, LPCWSTR lpSubBlock
,
3414 LPVOID
*lplpBuffer
, UINT
*puLen
)
3416 return VerQueryValueW( pBlock
, lpSubBlock
, lplpBuffer
, puLen
);
3419 #define IsIface(type) SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
3420 #define IShellBrowser_EnableModeless IShellBrowser_EnableModelessSB
3421 #define EnableModeless(type) type##_EnableModeless((type*)lpObj, bModeless)
3423 /*************************************************************************
3426 * Change the modality of a shell object.
3429 * lpUnknown [I] Object to make modeless
3430 * bModeless [I] TRUE=Make modeless, FALSE=Make modal
3433 * Success: S_OK. The modality lpUnknown is changed.
3434 * Failure: An HRESULT error code indicating the error.
3437 * lpUnknown must support the IOleInPlaceFrame interface, the
3438 * IInternetSecurityMgrSite interface, the IShellBrowser interface
3439 * the IDocHostUIHandler interface, or the IOleInPlaceActiveObject interface,
3440 * or this call will fail.
3442 HRESULT WINAPI
IUnknown_EnableModeless(IUnknown
*lpUnknown
, BOOL bModeless
)
3447 TRACE("(%p,%d)\n", lpUnknown
, bModeless
);
3452 if (IsIface(IOleInPlaceActiveObject
))
3453 EnableModeless(IOleInPlaceActiveObject
);
3454 else if (IsIface(IOleInPlaceFrame
))
3455 EnableModeless(IOleInPlaceFrame
);
3456 else if (IsIface(IShellBrowser
))
3457 EnableModeless(IShellBrowser
);
3458 else if (IsIface(IInternetSecurityMgrSite
))
3459 EnableModeless(IInternetSecurityMgrSite
);
3460 else if (IsIface(IDocHostUIHandler
))
3461 EnableModeless(IDocHostUIHandler
);
3465 IUnknown_Release(lpObj
);
3469 /*************************************************************************
3472 * See SHGetNewLinkInfoW.
3474 BOOL WINAPI
SHGetNewLinkInfoWrapW(LPCWSTR pszLinkTo
, LPCWSTR pszDir
, LPWSTR pszName
,
3475 BOOL
*pfMustCopy
, UINT uFlags
)
3477 return SHGetNewLinkInfoW(pszLinkTo
, pszDir
, pszName
, pfMustCopy
, uFlags
);
3480 /*************************************************************************
3483 * See SHDefExtractIconW.
3485 UINT WINAPI
SHDefExtractIconWrapW(LPCWSTR pszIconFile
, int iIndex
, UINT uFlags
, HICON
* phiconLarge
,
3486 HICON
* phiconSmall
, UINT nIconSize
)
3488 return SHDefExtractIconW(pszIconFile
, iIndex
, uFlags
, phiconLarge
, phiconSmall
, nIconSize
);
3491 /*************************************************************************
3494 * Get and show a context menu from a shell folder.
3497 * hWnd [I] Window displaying the shell folder
3498 * lpFolder [I] IShellFolder interface
3499 * lpApidl [I] Id for the particular folder desired
3500 * bInvokeDefault [I] Whether to invoke the default menu item
3503 * Success: S_OK. If bInvokeDefault is TRUE, the default menu action was
3505 * Failure: An HRESULT error code indicating the error.
3507 HRESULT WINAPI
SHInvokeCommand(HWND hWnd
, IShellFolder
* lpFolder
, LPCITEMIDLIST lpApidl
, BOOL bInvokeDefault
)
3509 IContextMenu
*iContext
;
3512 TRACE("(%p, %p, %p, %d)\n", hWnd
, lpFolder
, lpApidl
, bInvokeDefault
);
3517 /* Get the context menu from the shell folder */
3518 hRet
= IShellFolder_GetUIObjectOf(lpFolder
, hWnd
, 1, &lpApidl
,
3519 &IID_IContextMenu
, 0, (void**)&iContext
);
3520 if (SUCCEEDED(hRet
))
3523 if ((hMenu
= CreatePopupMenu()))
3526 DWORD dwDefaultId
= 0;
3528 /* Add the context menu entries to the popup */
3529 hQuery
= IContextMenu_QueryContextMenu(iContext
, hMenu
, 0, 1, 0x7FFF,
3530 bInvokeDefault
? CMF_NORMAL
: CMF_DEFAULTONLY
);
3532 if (SUCCEEDED(hQuery
))
3534 if (bInvokeDefault
&&
3535 (dwDefaultId
= GetMenuDefaultItem(hMenu
, 0, 0)) != (UINT
)-1)
3537 CMINVOKECOMMANDINFO cmIci
;
3538 /* Invoke the default item */
3539 memset(&cmIci
,0,sizeof(cmIci
));
3540 cmIci
.cbSize
= sizeof(cmIci
);
3541 cmIci
.fMask
= CMIC_MASK_ASYNCOK
;
3543 cmIci
.lpVerb
= MAKEINTRESOURCEA(dwDefaultId
);
3544 cmIci
.nShow
= SW_SCROLLCHILDREN
;
3546 hRet
= IContextMenu_InvokeCommand(iContext
, &cmIci
);
3551 IContextMenu_Release(iContext
);
3556 /*************************************************************************
3561 HICON WINAPI
ExtractIconWrapW(HINSTANCE hInstance
, LPCWSTR lpszExeFileName
,
3564 return ExtractIconW(hInstance
, lpszExeFileName
, nIconIndex
);
3567 /*************************************************************************
3570 * Load a library from the directory of a particular process.
3573 * new_mod [I] Library name
3574 * inst_hwnd [I] Module whose directory is to be used
3575 * dwCrossCodePage [I] Should be FALSE (currently ignored)
3578 * Success: A handle to the loaded module
3579 * Failure: A NULL handle.
3581 HMODULE WINAPI
MLLoadLibraryA(LPCSTR new_mod
, HMODULE inst_hwnd
, DWORD dwCrossCodePage
)
3583 /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
3585 * FIXME: Native shows calls to:
3586 * SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
3588 * RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
3589 * RegQueryValueExA for "LPKInstalled"
3591 * RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
3592 * RegQueryValueExA for "ResourceLocale"
3594 * RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
3595 * RegQueryValueExA for "Locale"
3597 * and then tests the Locale ("en" for me).
3599 * after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
3601 CHAR mod_path
[2*MAX_PATH
];
3605 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_a(new_mod
), inst_hwnd
, dwCrossCodePage
);
3606 len
= GetModuleFileNameA(inst_hwnd
, mod_path
, sizeof(mod_path
));
3607 if (!len
|| len
>= sizeof(mod_path
)) return NULL
;
3609 ptr
= strrchr(mod_path
, '\\');
3611 strcpy(ptr
+1, new_mod
);
3612 TRACE("loading %s\n", debugstr_a(mod_path
));
3613 return LoadLibraryA(mod_path
);
3618 /*************************************************************************
3621 * Unicode version of MLLoadLibraryA.
3623 HMODULE WINAPI
MLLoadLibraryW(LPCWSTR new_mod
, HMODULE inst_hwnd
, DWORD dwCrossCodePage
)
3625 WCHAR mod_path
[2*MAX_PATH
];
3629 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_w(new_mod
), inst_hwnd
, dwCrossCodePage
);
3630 len
= GetModuleFileNameW(inst_hwnd
, mod_path
, sizeof(mod_path
) / sizeof(WCHAR
));
3631 if (!len
|| len
>= sizeof(mod_path
) / sizeof(WCHAR
)) return NULL
;
3633 ptr
= strrchrW(mod_path
, '\\');
3635 strcpyW(ptr
+1, new_mod
);
3636 TRACE("loading %s\n", debugstr_w(mod_path
));
3637 return LoadLibraryW(mod_path
);
3642 /*************************************************************************
3643 * ColorAdjustLuma [SHLWAPI.@]
3645 * Adjust the luminosity of a color
3648 * cRGB [I] RGB value to convert
3649 * dwLuma [I] Luma adjustment
3650 * bUnknown [I] Unknown
3653 * The adjusted RGB color.
3655 COLORREF WINAPI
ColorAdjustLuma(COLORREF cRGB
, int dwLuma
, BOOL bUnknown
)
3657 TRACE("(0x%8x,%d,%d)\n", cRGB
, dwLuma
, bUnknown
);
3663 ColorRGBToHLS(cRGB
, &wH
, &wL
, &wS
);
3665 FIXME("Ignoring luma adjustment\n");
3667 /* FIXME: The adjustment is not linear */
3669 cRGB
= ColorHLSToRGB(wH
, wL
, wS
);
3674 /*************************************************************************
3677 * See GetSaveFileNameW.
3679 BOOL WINAPI
GetSaveFileNameWrapW(LPOPENFILENAMEW ofn
)
3681 return GetSaveFileNameW(ofn
);
3684 /*************************************************************************
3687 * See WNetRestoreConnectionW.
3689 DWORD WINAPI
WNetRestoreConnectionWrapW(HWND hwndOwner
, LPWSTR lpszDevice
)
3691 return WNetRestoreConnectionW(hwndOwner
, lpszDevice
);
3694 /*************************************************************************
3697 * See WNetGetLastErrorW.
3699 DWORD WINAPI
WNetGetLastErrorWrapW(LPDWORD lpError
, LPWSTR lpErrorBuf
, DWORD nErrorBufSize
,
3700 LPWSTR lpNameBuf
, DWORD nNameBufSize
)
3702 return WNetGetLastErrorW(lpError
, lpErrorBuf
, nErrorBufSize
, lpNameBuf
, nNameBufSize
);
3705 /*************************************************************************
3708 * See PageSetupDlgW.
3710 BOOL WINAPI
PageSetupDlgWrapW(LPPAGESETUPDLGW pagedlg
)
3712 return PageSetupDlgW(pagedlg
);
3715 /*************************************************************************
3720 BOOL WINAPI
PrintDlgWrapW(LPPRINTDLGW printdlg
)
3722 return PrintDlgW(printdlg
);
3725 /*************************************************************************
3728 * See GetOpenFileNameW.
3730 BOOL WINAPI
GetOpenFileNameWrapW(LPOPENFILENAMEW ofn
)
3732 return GetOpenFileNameW(ofn
);
3735 /*************************************************************************
3738 HRESULT WINAPI
SHIShellFolder_EnumObjects(LPSHELLFOLDER lpFolder
, HWND hwnd
, SHCONTF flags
, IEnumIDList
**ppenum
)
3740 /* Windows attempts to get an IPersist interface and, if that fails, an
3741 * IPersistFolder interface on the folder passed-in here. If one of those
3742 * interfaces is available, it then calls GetClassID on the folder... and
3743 * then calls IShellFolder_EnumObjects no matter what, even crashing if
3744 * lpFolder isn't actually an IShellFolder object. The purpose of getting
3745 * the ClassID is unknown, so we don't do it here.
3747 * For discussion and detailed tests, see:
3748 * "shlwapi: Be less strict on which type of IShellFolder can be enumerated"
3749 * wine-devel mailing list, 3 Jun 2010
3752 return IShellFolder_EnumObjects(lpFolder
, hwnd
, flags
, ppenum
);
3755 /* INTERNAL: Map from HLS color space to RGB */
3756 static WORD
ConvertHue(int wHue
, WORD wMid1
, WORD wMid2
)
3758 wHue
= wHue
> 240 ? wHue
- 240 : wHue
< 0 ? wHue
+ 240 : wHue
;
3762 else if (wHue
> 120)
3767 return ((wHue
* (wMid2
- wMid1
) + 20) / 40) + wMid1
;
3770 /* Convert to RGB and scale into RGB range (0..255) */
3771 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
3773 /*************************************************************************
3774 * ColorHLSToRGB [SHLWAPI.@]
3776 * Convert from hls color space into an rgb COLORREF.
3779 * wHue [I] Hue amount
3780 * wLuminosity [I] Luminosity amount
3781 * wSaturation [I] Saturation amount
3784 * A COLORREF representing the converted color.
3787 * Input hls values are constrained to the range (0..240).
3789 COLORREF WINAPI
ColorHLSToRGB(WORD wHue
, WORD wLuminosity
, WORD wSaturation
)
3795 WORD wGreen
, wBlue
, wMid1
, wMid2
;
3797 if (wLuminosity
> 120)
3798 wMid2
= wSaturation
+ wLuminosity
- (wSaturation
* wLuminosity
+ 120) / 240;
3800 wMid2
= ((wSaturation
+ 240) * wLuminosity
+ 120) / 240;
3802 wMid1
= wLuminosity
* 2 - wMid2
;
3804 wRed
= GET_RGB(wHue
+ 80);
3805 wGreen
= GET_RGB(wHue
);
3806 wBlue
= GET_RGB(wHue
- 80);
3808 return RGB(wRed
, wGreen
, wBlue
);
3811 wRed
= wLuminosity
* 255 / 240;
3812 return RGB(wRed
, wRed
, wRed
);
3815 /*************************************************************************
3818 * Get the current docking status of the system.
3821 * dwFlags [I] DOCKINFO_ flags from "winbase.h", unused
3824 * One of DOCKINFO_UNDOCKED, DOCKINFO_UNDOCKED, or 0 if the system is not
3827 DWORD WINAPI
SHGetMachineInfo(DWORD dwFlags
)
3829 HW_PROFILE_INFOA hwInfo
;
3831 TRACE("(0x%08x)\n", dwFlags
);
3833 GetCurrentHwProfileA(&hwInfo
);
3834 switch (hwInfo
.dwDockInfo
& (DOCKINFO_DOCKED
|DOCKINFO_UNDOCKED
))
3836 case DOCKINFO_DOCKED
:
3837 case DOCKINFO_UNDOCKED
:
3838 return hwInfo
.dwDockInfo
& (DOCKINFO_DOCKED
|DOCKINFO_UNDOCKED
);
3844 /*************************************************************************
3847 * Function seems to do FreeLibrary plus other things.
3849 * FIXME native shows the following calls:
3850 * RtlEnterCriticalSection
3852 * GetProcAddress(Comctl32??, 150L)
3854 * RtlLeaveCriticalSection
3855 * followed by the FreeLibrary.
3856 * The above code may be related to .377 above.
3858 BOOL WINAPI
MLFreeLibrary(HMODULE hModule
)
3860 FIXME("(%p) semi-stub\n", hModule
);
3861 return FreeLibrary(hModule
);
3864 /*************************************************************************
3867 BOOL WINAPI
SHFlushSFCacheWrap(void) {
3872 /*************************************************************************
3874 * FIXME I have no idea what this function does or what its arguments are.
3876 BOOL WINAPI
MLIsMLHInstance(HINSTANCE hInst
)
3878 FIXME("(%p) stub\n", hInst
);
3883 /*************************************************************************
3886 DWORD WINAPI
MLSetMLHInstance(HINSTANCE hInst
, HANDLE hHeap
)
3888 FIXME("(%p,%p) stub\n", hInst
, hHeap
);
3889 return E_FAIL
; /* This is what is used if shlwapi not loaded */
3892 /*************************************************************************
3895 DWORD WINAPI
MLClearMLHInstance(DWORD x
)
3897 FIXME("(0x%08x)stub\n", x
);
3901 /*************************************************************************
3904 * See SHSendMessageBroadcastW
3907 DWORD WINAPI
SHSendMessageBroadcastA(UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
3909 return SendMessageTimeoutA(HWND_BROADCAST
, uMsg
, wParam
, lParam
,
3910 SMTO_ABORTIFHUNG
, 2000, NULL
);
3913 /*************************************************************************
3916 * A wrapper for sending Broadcast Messages to all top level Windows
3919 DWORD WINAPI
SHSendMessageBroadcastW(UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
3921 return SendMessageTimeoutW(HWND_BROADCAST
, uMsg
, wParam
, lParam
,
3922 SMTO_ABORTIFHUNG
, 2000, NULL
);
3925 /*************************************************************************
3928 * Convert a Unicode string CLSID into a CLSID.
3931 * idstr [I] string containing a CLSID in text form
3932 * id [O] CLSID extracted from the string
3935 * S_OK on success or E_INVALIDARG on failure
3937 HRESULT WINAPI
CLSIDFromStringWrap(LPCWSTR idstr
, CLSID
*id
)
3939 return CLSIDFromString((LPCOLESTR
)idstr
, id
);
3942 /*************************************************************************
3945 * Determine if the OS supports a given feature.
3948 * dwFeature [I] Feature requested (undocumented)
3951 * TRUE If the feature is available.
3952 * FALSE If the feature is not available.
3954 BOOL WINAPI
IsOS(DWORD feature
)
3956 OSVERSIONINFOA osvi
;
3957 DWORD platform
, majorv
, minorv
;
3959 osvi
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFOA
);
3960 if(!GetVersionExA(&osvi
)) {
3961 ERR("GetVersionEx failed\n");
3965 majorv
= osvi
.dwMajorVersion
;
3966 minorv
= osvi
.dwMinorVersion
;
3967 platform
= osvi
.dwPlatformId
;
3969 #define ISOS_RETURN(x) \
3970 TRACE("(0x%x) ret=%d\n",feature,(x)); \
3974 case OS_WIN32SORGREATER
:
3975 ISOS_RETURN(platform
== VER_PLATFORM_WIN32s
3976 || platform
== VER_PLATFORM_WIN32_WINDOWS
)
3978 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3979 case OS_WIN95ORGREATER
:
3980 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
)
3981 case OS_NT4ORGREATER
:
3982 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 4)
3983 case OS_WIN2000ORGREATER_ALT
:
3984 case OS_WIN2000ORGREATER
:
3985 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3986 case OS_WIN98ORGREATER
:
3987 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
>= 10)
3989 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
== 10)
3991 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3992 case OS_WIN2000SERVER
:
3993 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3994 case OS_WIN2000ADVSERVER
:
3995 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3996 case OS_WIN2000DATACENTER
:
3997 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3998 case OS_WIN2000TERMINAL
:
3999 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
4001 FIXME("(OS_EMBEDDED) What should we return here?\n");
4003 case OS_TERMINALCLIENT
:
4004 FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
4006 case OS_TERMINALREMOTEADMIN
:
4007 FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
4010 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
== 0)
4011 case OS_MEORGREATER
:
4012 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
>= 90)
4013 case OS_XPORGREATER
:
4014 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5 && minorv
>= 1)
4016 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5 && minorv
>= 1)
4017 case OS_PROFESSIONAL
:
4018 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4020 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4022 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
4024 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4025 case OS_TERMINALSERVER
:
4026 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4027 case OS_PERSONALTERMINALSERVER
:
4028 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& minorv
>= 1 && majorv
>= 5)
4029 case OS_FASTUSERSWITCHING
:
4030 FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
4032 case OS_WELCOMELOGONUI
:
4033 FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
4035 case OS_DOMAINMEMBER
:
4036 FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
4039 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4041 FIXME("(OS_WOW6432) Should we check this?\n");
4044 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4045 case OS_SMALLBUSINESSSERVER
:
4046 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4048 FIXME("(OS_TABLEPC) What should we return here?\n");
4050 case OS_SERVERADMINUI
:
4051 FIXME("(OS_SERVERADMINUI) What should we return here?\n");
4053 case OS_MEDIACENTER
:
4054 FIXME("(OS_MEDIACENTER) What should we return here?\n");
4057 FIXME("(OS_APPLIANCE) What should we return here?\n");
4059 case 0x25: /*OS_VISTAORGREATER*/
4060 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 6)
4065 WARN("(0x%x) unknown parameter\n",feature
);
4070 /*************************************************************************
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
)
4080 return SHLoadIndirectString(buf
, buf
, size
, NULL
);
4083 /*************************************************************************
4086 * Call IInputObject_TranslateAcceleratorIO() on an object.
4089 * lpUnknown [I] Object supporting the IInputObject interface.
4090 * lpMsg [I] Key message to be processed.
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
);
4104 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInputObject
,
4106 if (SUCCEEDED(hRet
) && lpInput
)
4108 hRet
= IInputObject_TranslateAcceleratorIO(lpInput
, lpMsg
);
4109 IInputObject_Release(lpInput
);
4115 /*************************************************************************
4118 * Call IInputObject_HasFocusIO() on an object.
4121 * lpUnknown [I] Object supporting the IInputObject interface.
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
);
4136 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInputObject
,
4138 if (SUCCEEDED(hRet
) && lpInput
)
4140 hRet
= IInputObject_HasFocusIO(lpInput
);
4141 IInputObject_Release(lpInput
);
4147 /*************************************************************************
4148 * ColorRGBToHLS [SHLWAPI.@]
4150 * Convert an rgb COLORREF into the hls color space.
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
4159 * Nothing. pwHue, pwLuminance and pwSaturation are set to the converted
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
));
4181 wLuminosity
= ((wMax
+ wMin
) * 240 + 255) / 510;
4185 /* Achromatic case */
4187 /* Hue is now unrepresentable, but this is what native returns... */
4192 /* Chromatic case */
4193 int wDelta
= wMax
- wMin
, wRNorm
, wGNorm
, wBNorm
;
4196 if (wLuminosity
<= 120)
4197 wSaturation
= ((wMax
+ wMin
)/2 + wDelta
* 240) / (wMax
+ wMin
);
4199 wSaturation
= ((510 - wMax
- wMin
)/2 + wDelta
* 240) / (510 - wMax
- wMin
);
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
;
4207 wHue
= wBNorm
- wGNorm
;
4208 else if (wG
== wMax
)
4209 wHue
= 80 + wRNorm
- wBNorm
;
4211 wHue
= 160 + wGNorm
- wRNorm
;
4214 else if (wHue
> 240)
4220 *pwLuminance
= wLuminosity
;
4222 *pwSaturation
= wSaturation
;
4225 /*************************************************************************
4226 * SHCreateShellPalette [SHLWAPI.@]
4228 HPALETTE WINAPI
SHCreateShellPalette(HDC hdc
)
4231 return CreateHalftonePalette(hdc
);
4234 /*************************************************************************
4235 * SHGetInverseCMAP (SHLWAPI.@)
4237 * Get an inverse color map table.
4240 * lpCmap [O] Destination for color map
4241 * dwSize [I] Size of memory pointed to by lpCmap
4245 * Failure: E_POINTER, If lpCmap is invalid.
4246 * E_INVALIDARG, If dwFlags is invalid
4247 * E_OUTOFMEMORY, If there is no memory available
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
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
)
4259 FIXME(" - returning bogus address for SHGetInverseCMAP\n");
4260 *dest
= (DWORD
)0xabba1249;
4263 FIXME("(%p, %#x) stub\n", dest
, dwSize
);
4267 /*************************************************************************
4268 * SHIsLowMemoryMachine [SHLWAPI.@]
4270 * Determine if the current computer has low memory.
4276 * TRUE if the users machine has 16 Megabytes of memory or less,
4279 BOOL WINAPI
SHIsLowMemoryMachine (DWORD x
)
4281 FIXME("(0x%08x) stub\n", x
);
4285 /*************************************************************************
4286 * GetMenuPosFromID [SHLWAPI.@]
4288 * Return the position of a menu item from its Id.
4291 * hMenu [I] Menu containing the item
4292 * wID [I] Id of the menu item
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
)
4301 INT nCount
= GetMenuItemCount(hMenu
), nIter
= 0;
4303 TRACE("%p %u\n", hMenu
, wID
);
4305 while (nIter
< nCount
)
4307 mi
.cbSize
= sizeof(mi
);
4309 if (GetMenuItemInfoW(hMenu
, nIter
, TRUE
, &mi
) && mi
.wID
== wID
)
4311 TRACE("ret %d\n", nIter
);
4320 /*************************************************************************
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 /*************************************************************************
4335 VOID WINAPI
FixSlashesAndColonW(LPWSTR lpwstr
)
4346 /*************************************************************************
4349 DWORD WINAPI
SHGetAppCompatFlags(DWORD dwUnknown
)
4351 FIXME("(0x%08x) stub\n", dwUnknown
);
4356 /*************************************************************************
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
4371 * pbc [I] Bind context to check
4372 * pclsid [I] CLSID of object to be bound to
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' };
4389 if (SUCCEEDED(IBindCtx_GetObjectParam(pbc
, szSkipBinding
, &lpUnk
)))
4393 if (SUCCEEDED(IUnknown_GetClassID(lpUnk
, &clsid
)) &&
4394 IsEqualGUID(pclsid
, &clsid
))
4397 IUnknown_Release(lpUnk
);
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','\\'};
4446 const WCHAR
*key
, *subkey
;
4447 int size_key
, size_subkey
, size_user
;
4450 TRACE("(0x%08x, %s, %d)\n", flags
, debugstr_w(sub_key
), create
);
4452 /* For compatibility with Vista+ */
4453 if(flags
== 0x1ffff)
4456 switch(flags
&0xff0) {
4457 case SHKEY_Key_Explorer
:
4459 size_key
= sizeof(explorerW
);
4461 case SHKEY_Key_Shell
:
4463 size_key
= sizeof(shellW
);
4465 case SHKEY_Key_ShellNoRoam
:
4466 key
= shell_no_roamW
;
4467 size_key
= sizeof(shell_no_roamW
);
4469 case SHKEY_Key_Classes
:
4471 size_key
= sizeof(classesW
);
4474 FIXME("unsupported flags (0x%08x)\n", flags
);
4478 switch(flags
&0xff000) {
4479 case SHKEY_Subkey_Default
:
4483 case SHKEY_Subkey_ResourceName
:
4484 subkey
= localized_resource_nameW
;
4485 size_subkey
= sizeof(localized_resource_nameW
);
4487 case SHKEY_Subkey_Handlers
:
4489 size_subkey
= sizeof(handlersW
);
4491 case SHKEY_Subkey_Associations
:
4492 subkey
= associationsW
;
4493 size_subkey
= sizeof(associationsW
);
4495 case SHKEY_Subkey_Volatile
:
4497 size_subkey
= sizeof(volatileW
);
4499 case SHKEY_Subkey_MUICache
:
4500 subkey
= mui_cacheW
;
4501 size_subkey
= sizeof(mui_cacheW
);
4503 case SHKEY_Subkey_FileExts
:
4504 subkey
= file_extsW
;
4505 size_subkey
= sizeof(file_extsW
);
4508 FIXME("unsupported flags (0x%08x)\n", flags
);
4513 size_user
= lstrlenW(sub_key
)*sizeof(WCHAR
);
4517 path
= HeapAlloc(GetProcessHeap(), 0, size_key
+size_subkey
+size_user
);
4519 ERR("Out of memory\n");
4523 memcpy(path
, key
, size_key
);
4525 memcpy(path
+size_key
/sizeof(WCHAR
), subkey
, size_subkey
);
4527 memcpy(path
+(size_key
+size_subkey
)/sizeof(WCHAR
), sub_key
, size_user
);
4528 path
[(size_key
+size_subkey
+size_user
)/sizeof(WCHAR
)] = '\0';
4531 RegCreateKeyExW((flags
&0xf)==SHKEY_Root_HKLM
?HKEY_LOCAL_MACHINE
:HKEY_CURRENT_USER
,
4532 path
, 0, NULL
, 0, MAXIMUM_ALLOWED
, NULL
, &hkey
, NULL
);
4534 RegOpenKeyExW((flags
&0xf)==SHKEY_Root_HKLM
?HKEY_LOCAL_MACHINE
:HKEY_CURRENT_USER
,
4535 path
, 0, MAXIMUM_ALLOWED
, &hkey
);
4537 HeapFree(GetProcessHeap(), 0, path
);
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
)
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
))
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");
4595 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInputObjectSite
,
4597 if (SUCCEEDED(hRet
) && pIOS
)
4599 hRet
= IInputObjectSite_OnFocusChangeIS(pIOS
, pFocusObject
, bFocus
);
4600 IInputObjectSite_Release(pIOS
);
4606 /***********************************************************************
4607 * SKAllocValueW (SHLWAPI.519)
4609 HRESULT WINAPI
SKAllocValueW(DWORD flags
, LPCWSTR subkey
, LPCWSTR value
, DWORD
*type
,
4610 LPVOID
*data
, DWORD
*count
)
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
);
4620 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND
);
4622 ret
= SHQueryValueExW(hkey
, value
, NULL
, type
, NULL
, &size
);
4625 return HRESULT_FROM_WIN32(ret
);
4629 *data
= LocalAlloc(0, size
);
4632 return E_OUTOFMEMORY
;
4635 ret
= SHQueryValueExW(hkey
, value
, NULL
, type
, *data
, &size
);
4640 return HRESULT_FROM_WIN32(ret
);
4643 /***********************************************************************
4644 * SKDeleteValueW (SHLWAPI.518)
4646 HRESULT WINAPI
SKDeleteValueW(DWORD flags
, LPCWSTR subkey
, LPCWSTR value
)
4651 TRACE("(0x%x, %s %s)\n", flags
, debugstr_w(subkey
), debugstr_w(value
));
4653 hkey
= SHGetShellKey(flags
, subkey
, FALSE
);
4655 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND
);
4657 ret
= RegDeleteValueW(hkey
, value
);
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
)
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
);
4677 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND
);
4679 ret
= SHQueryValueExW(hkey
, value
, NULL
, type
, data
, count
);
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
)
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
);
4699 return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND
);
4701 ret
= RegSetValueExW(hkey
, value
, 0, type
, data
, count
);
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
;
4718 DllGetVersion_func pDllGetVersion
;
4719 HMODULE dll
= LoadLibraryA("shell32.dll");
4722 pDllGetVersion
= (DllGetVersion_func
)GetProcAddress(dll
, "DllGetVersion");
4726 dvi
.cbSize
= sizeof(DLLVERSIONINFO
);
4727 if (pDllGetVersion(&dvi
) == S_OK
) version
= dvi
.dwMajorVersion
;
4730 if (!version
) version
= 3; /* old shell dlls don't have DllGetVersion */
4735 /***********************************************************************
4736 * ShellMessageBoxWrapW [SHLWAPI.388]
4738 * See shell32.ShellMessageBoxW
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
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
;
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]));
4762 pszTitle
= lpCaption
;
4764 if (IS_INTRESOURCE(lpText
))
4767 UINT len
= LoadStringW(hInstance
, LOWORD(lpText
), (LPWSTR
)&ptr
, 0);
4771 szText
= HeapAlloc(GetProcessHeap(), 0, (len
+ 1) * sizeof(WCHAR
));
4772 if (szText
) LoadStringW(hInstance
, LOWORD(lpText
), szText
, len
+ 1);
4776 WARN("Failed to load id %d\n", LOWORD(lpText
));
4784 FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_STRING
,
4785 pszText
, 0, 0, (LPWSTR
)&pszTemp
, 0, &args
);
4789 ret
= MessageBoxW(hWnd
, pszTemp
, pszTitle
, uType
);
4791 HeapFree(GetProcessHeap(), 0, szText
);
4796 /***********************************************************************
4797 * ZoneComputePaneSize [SHLWAPI.382]
4799 UINT WINAPI
ZoneComputePaneSize(HWND hwnd
)
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
;
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
;
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
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
4839 * success: pointer to SECURITY_DESCRIPTOR
4843 * Call should free returned descriptor with LocalFree
4845 PSECURITY_DESCRIPTOR WINAPI
GetShellSecurityDescriptor(PSHELL_USER_PERMISSION
*apUserPerm
, int cUserPerm
)
4848 PSID cur_user
= NULL
;
4852 PSECURITY_DESCRIPTOR psd
= NULL
;
4854 TRACE("%p %d\n", apUserPerm
, cUserPerm
);
4856 if (apUserPerm
== NULL
|| cUserPerm
<= 0)
4859 sidlist
= HeapAlloc(GetProcessHeap(), 0, cUserPerm
* sizeof(PSID
));
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
;
4873 if (!memcmp((void*)sid
, (void*)&null_sid
, sizeof(SHELL_USER_SID
)))
4874 { /* current user's SID */
4878 DWORD bufsize
= sizeof(tuUser
);
4880 ret
= OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY
, &Token
);
4883 ret
= GetTokenInformation(Token
, TokenUser
, (void*)tuUser
, bufsize
, &bufsize
);
4885 cur_user
= ((PTOKEN_USER
)tuUser
)->User
.Sid
;
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
);
4894 ret
= AllocateAndInitializeSid(&sid
->sidAuthority
, 2, sid
->dwUserGroupID
, sid
->dwUserID
,
4895 0, 0, 0, 0, 0, 0, &pSid
);
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
);
4908 PACL pAcl
= (PACL
)(((BYTE
*)psd
)+sizeof(SECURITY_DESCRIPTOR
));
4910 if (!InitializeSecurityDescriptor(psd
, SECURITY_DESCRIPTOR_REVISION
))
4913 if (!InitializeAcl(pAcl
, acl_size
, ACL_REVISION
))
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
))
4926 if (sup
->fInherit
&& !AddAccessAllowedAceEx(pAcl
, ACL_REVISION
,
4927 (BYTE
)sup
->dwInheritMask
, sup
->dwInheritAccessMask
, sid
))
4930 case ACCESS_DENIED_ACE_TYPE
:
4931 if (!AddAccessDeniedAce(pAcl
, ACL_REVISION
, sup
->dwAccessMask
, sid
))
4933 if (sup
->fInherit
&& !AddAccessDeniedAceEx(pAcl
, ACL_REVISION
,
4934 (BYTE
)sup
->dwInheritMask
, sup
->dwInheritAccessMask
, sid
))
4942 if (!SetSecurityDescriptorDacl(psd
, TRUE
, pAcl
, FALSE
))
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
);
4961 /***********************************************************************
4962 * SHCreatePropertyBagOnRegKey [SHLWAPI.471]
4964 * Creates a property bag from a registry key
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
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
);
4987 /***********************************************************************
4988 * SHGetViewStatePropertyBag [SHLWAPI.515]
4990 * Retrieves a property bag in which the view state information of a folder
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
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
);
5014 /***********************************************************************
5015 * SHFormatDateTimeW [SHLWAPI.354]
5017 * Produces a string representation of a time.
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
5026 * success: number of characters written to the buffer
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
;
5039 TRACE("%p %p %p %u\n", fileTime
, flags
, buf
, size
);
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
;
5061 if (ret
< size
&& (fmt_flags
& (FDTF_LONGTIME
| FDTF_SHORTTIME
)))
5063 if ((fmt_flags
& FDTF_LONGDATE
) && (ret
< size
+ 2))
5067 lstrcatW(&buf
[ret
-1], sep1
);
5073 lstrcatW(&buf
[ret
-1], sep2
);
5079 if (fmt_flags
& (FDTF_LONGTIME
| FDTF_SHORTTIME
))
5081 DWORD time
= fmt_flags
& FDTF_LONGTIME
? 0 : TIME_NOSECONDS
;
5084 ret
+= GetTimeFormatW(LOCALE_USER_DEFAULT
, time
, &st
, NULL
, &buf
[ret
], size
- ret
);
5089 #undef SHFORMATDT_UNSUPPORTED_FLAGS
5092 /***********************************************************************
5093 * SHFormatDateTimeA [SHLWAPI.353]
5095 * See SHFormatDateTimeW.
5098 INT WINAPI
SHFormatDateTimeA(const FILETIME UNALIGNED
*fileTime
, DWORD
*flags
,
5099 LPSTR buf
, UINT size
)
5107 bufW
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
) * size
);
5108 retval
= SHFormatDateTimeW(fileTime
, flags
, bufW
, size
);
5111 WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, buf
, size
, NULL
, NULL
);
5113 HeapFree(GetProcessHeap(), 0, bufW
);
5117 /***********************************************************************
5118 * ZoneCheckUrlExW [SHLWAPI.231]
5120 * Checks the details of the security zone for the supplied site. (?)
5124 * szURL [I] Pointer to the URL to check
5126 * Other parameters currently unknown.
5132 INT WINAPI
ZoneCheckUrlExW(LPWSTR szURL
, PVOID pUnknown
, DWORD dwUnknown2
,
5133 DWORD dwUnknown3
, DWORD dwUnknown4
, DWORD dwUnknown5
, DWORD dwUnknown6
,
5136 FIXME("(%s,%p,%x,%x,%x,%x,%x,%x) STUB\n", debugstr_w(szURL
), pUnknown
, dwUnknown2
,
5137 dwUnknown3
, dwUnknown4
, dwUnknown5
, dwUnknown6
, dwUnknown7
);
5142 /***********************************************************************
5143 * SHVerbExistsNA [SHLWAPI.196]
5148 * verb [I] a string, often appears to be an extension.
5150 * Other parameters currently unknown.
5155 INT WINAPI
SHVerbExistsNA(LPSTR verb
, PVOID pUnknown
, PVOID pUnknown2
, DWORD dwUnknown3
)
5157 FIXME("(%s, %p, %p, %i) STUB\n",verb
, pUnknown
, pUnknown2
, dwUnknown3
);
5161 /*************************************************************************
5164 * Undocumented: Implementation guessed at via Name and behavior
5167 * lpUnknown [I] Object to get an IServiceProvider interface from
5168 * riid [I] Function requested for QueryService call
5169 * lppOut [O] Destination for the service interface pointer
5172 * Success: S_OK. lppOut contains an object providing the requested service
5173 * Failure: An HRESULT error code
5176 * lpUnknown is expected to support the IServiceProvider interface.
5178 HRESULT WINAPI
IUnknown_QueryServiceForWebBrowserApp(IUnknown
* lpUnknown
,
5179 REFGUID riid
, LPVOID
*lppOut
)
5181 FIXME("%p %s %p semi-STUB\n", lpUnknown
, debugstr_guid(riid
), lppOut
);
5182 return IUnknown_QueryService(lpUnknown
,&IID_IWebBrowserApp
,riid
,lppOut
);
5185 /**************************************************************************
5186 * SHPropertyBag_ReadLONG (SHLWAPI.496)
5188 * This function asks a property bag to read a named property as a LONG.
5191 * ppb: a IPropertyBag interface
5192 * pszPropName: Unicode string that names the property
5193 * pValue: address to receive the property value as a 32-bit signed integer
5198 BOOL WINAPI
SHPropertyBag_ReadLONG(IPropertyBag
*ppb
, LPCWSTR pszPropName
, LPLONG pValue
)
5202 TRACE("%p %s %p\n", ppb
,debugstr_w(pszPropName
),pValue
);
5203 if (!pszPropName
|| !ppb
|| !pValue
)
5204 return E_INVALIDARG
;
5206 hr
= IPropertyBag_Read(ppb
, pszPropName
, &var
, NULL
);
5209 if (V_VT(&var
) == VT_I4
)
5210 *pValue
= V_I4(&var
);
5212 hr
= DISP_E_BADVARTYPE
;
5217 /* return flags for SHGetObjectCompatFlags, names derived from registry value names */
5218 #define OBJCOMPAT_OTNEEDSSFCACHE 0x00000001
5219 #define OBJCOMPAT_NO_WEBVIEW 0x00000002
5220 #define OBJCOMPAT_UNBINDABLE 0x00000004
5221 #define OBJCOMPAT_PINDLL 0x00000008
5222 #define OBJCOMPAT_NEEDSFILESYSANCESTOR 0x00000010
5223 #define OBJCOMPAT_NOTAFILESYSTEM 0x00000020
5224 #define OBJCOMPAT_CTXMENU_NOVERBS 0x00000040
5225 #define OBJCOMPAT_CTXMENU_LIMITEDQI 0x00000080
5226 #define OBJCOMPAT_COCREATESHELLFOLDERONLY 0x00000100
5227 #define OBJCOMPAT_NEEDSSTORAGEANCESTOR 0x00000200
5228 #define OBJCOMPAT_NOLEGACYWEBVIEW 0x00000400
5229 #define OBJCOMPAT_CTXMENU_XPQCMFLAGS 0x00001000
5230 #define OBJCOMPAT_NOIPROPERTYSTORE 0x00002000
5232 /* a search table for compatibility flags */
5233 struct objcompat_entry
{
5234 const WCHAR name
[30];
5238 /* expected to be sorted by name */
5239 static const struct objcompat_entry objcompat_table
[] = {
5240 { {'C','O','C','R','E','A','T','E','S','H','E','L','L','F','O','L','D','E','R','O','N','L','Y',0},
5241 OBJCOMPAT_COCREATESHELLFOLDERONLY
},
5242 { {'C','T','X','M','E','N','U','_','L','I','M','I','T','E','D','Q','I',0},
5243 OBJCOMPAT_CTXMENU_LIMITEDQI
},
5244 { {'C','T','X','M','E','N','U','_','N','O','V','E','R','B','S',0},
5245 OBJCOMPAT_CTXMENU_LIMITEDQI
},
5246 { {'C','T','X','M','E','N','U','_','X','P','Q','C','M','F','L','A','G','S',0},
5247 OBJCOMPAT_CTXMENU_XPQCMFLAGS
},
5248 { {'N','E','E','D','S','F','I','L','E','S','Y','S','A','N','C','E','S','T','O','R',0},
5249 OBJCOMPAT_NEEDSFILESYSANCESTOR
},
5250 { {'N','E','E','D','S','S','T','O','R','A','G','E','A','N','C','E','S','T','O','R',0},
5251 OBJCOMPAT_NEEDSSTORAGEANCESTOR
},
5252 { {'N','O','I','P','R','O','P','E','R','T','Y','S','T','O','R','E',0},
5253 OBJCOMPAT_NOIPROPERTYSTORE
},
5254 { {'N','O','L','E','G','A','C','Y','W','E','B','V','I','E','W',0},
5255 OBJCOMPAT_NOLEGACYWEBVIEW
},
5256 { {'N','O','T','A','F','I','L','E','S','Y','S','T','E','M',0},
5257 OBJCOMPAT_NOTAFILESYSTEM
},
5258 { {'N','O','_','W','E','B','V','I','E','W',0},
5259 OBJCOMPAT_NO_WEBVIEW
},
5260 { {'O','T','N','E','E','D','S','S','F','C','A','C','H','E',0},
5261 OBJCOMPAT_OTNEEDSSFCACHE
},
5262 { {'P','I','N','D','L','L',0},
5264 { {'U','N','B','I','N','D','A','B','L','E',0},
5265 OBJCOMPAT_UNBINDABLE
}
5268 /**************************************************************************
5269 * SHGetObjectCompatFlags (SHLWAPI.476)
5271 * Function returns an integer representation of compatibility flags stored
5272 * in registry for CLSID under ShellCompatibility subkey.
5275 * pUnk: pointer to object IUnknown interface, idetifies CLSID
5276 * clsid: pointer to CLSID to retrieve data for
5279 * 0 on failure, flags set on success
5281 DWORD WINAPI
SHGetObjectCompatFlags(IUnknown
*pUnk
, const CLSID
*clsid
)
5283 static const WCHAR compatpathW
[] =
5284 {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
5285 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5286 'S','h','e','l','l','C','o','m','p','a','t','i','b','i','l','i','t','y','\\',
5287 'O','b','j','e','c','t','s','\\','%','s',0};
5288 WCHAR strW
[sizeof(compatpathW
)/sizeof(WCHAR
) + 38 /* { CLSID } */];
5289 DWORD ret
, length
= sizeof(strW
)/sizeof(WCHAR
);
5294 TRACE("%p %s\n", pUnk
, debugstr_guid(clsid
));
5296 if (!pUnk
&& !clsid
) return 0;
5300 FIXME("iface not handled\n");
5304 StringFromCLSID(clsid
, &clsid_str
);
5305 sprintfW(strW
, compatpathW
, clsid_str
);
5306 CoTaskMemFree(clsid_str
);
5308 ret
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, strW
, &key
);
5309 if (ret
!= ERROR_SUCCESS
) return 0;
5311 /* now collect flag values */
5313 for (i
= 0; RegEnumValueW(key
, i
, strW
, &length
, NULL
, NULL
, NULL
, NULL
) == ERROR_SUCCESS
; i
++)
5315 INT left
, right
, res
, x
;
5317 /* search in table */
5319 right
= sizeof(objcompat_table
) / sizeof(struct objcompat_entry
) - 1;
5321 while (right
>= left
) {
5322 x
= (left
+ right
) / 2;
5323 res
= strcmpW(strW
, objcompat_table
[x
].name
);
5326 ret
|= objcompat_table
[x
].value
;
5335 length
= sizeof(strW
)/sizeof(WCHAR
);