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 BOOL WINAPI
SHGetIniStringW(LPCWSTR str1
, LPCWSTR str2
, LPWSTR pStr
, DWORD some_len
, LPCWSTR lpStr2
)
3252 FIXME("(%s,%s,%p,%08x,%s): stub!\n", debugstr_w(str1
), debugstr_w(str2
),
3253 pStr
, some_len
, debugstr_w(lpStr2
));
3257 /*************************************************************************
3260 * Called by ICQ2000b install via SHDOCVW:
3261 * str1: "InternetShortcut"
3262 * x: some unknown pointer
3263 * str2: "http://free.aol.com/tryaolfree/index.adp?139269"
3264 * str3: "C:\\WINDOWS\\Desktop.new2\\Free AOL & Unlimited Internet.url"
3266 * In short: this one maybe creates a desktop link :-)
3268 BOOL WINAPI
SHSetIniStringW(LPWSTR str1
, LPVOID x
, LPWSTR str2
, LPWSTR str3
)
3270 FIXME("(%s, %p, %s, %s), stub.\n", debugstr_w(str1
), x
, debugstr_w(str2
), debugstr_w(str3
));
3274 /*************************************************************************
3277 * See SHGetFileInfoW.
3279 DWORD WINAPI
SHGetFileInfoWrapW(LPCWSTR path
, DWORD dwFileAttributes
,
3280 SHFILEINFOW
*psfi
, UINT sizeofpsfi
, UINT flags
)
3282 return SHGetFileInfoW(path
, dwFileAttributes
, psfi
, sizeofpsfi
, flags
);
3285 /*************************************************************************
3288 * See DragQueryFileW.
3290 UINT WINAPI
DragQueryFileWrapW(HDROP hDrop
, UINT lFile
, LPWSTR lpszFile
, UINT lLength
)
3292 return DragQueryFileW(hDrop
, lFile
, lpszFile
, lLength
);
3295 /*************************************************************************
3298 * See SHBrowseForFolderW.
3300 LPITEMIDLIST WINAPI
SHBrowseForFolderWrapW(LPBROWSEINFOW lpBi
)
3302 return SHBrowseForFolderW(lpBi
);
3305 /*************************************************************************
3308 * See SHGetPathFromIDListW.
3310 BOOL WINAPI
SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl
,LPWSTR pszPath
)
3312 return SHGetPathFromIDListW(pidl
, pszPath
);
3315 /*************************************************************************
3318 * See ShellExecuteExW.
3320 BOOL WINAPI
ShellExecuteExWrapW(LPSHELLEXECUTEINFOW lpExecInfo
)
3322 return ShellExecuteExW(lpExecInfo
);
3325 /*************************************************************************
3328 * See SHFileOperationW.
3330 INT WINAPI
SHFileOperationWrapW(LPSHFILEOPSTRUCTW lpFileOp
)
3332 return SHFileOperationW(lpFileOp
);
3335 /*************************************************************************
3339 PVOID WINAPI
SHInterlockedCompareExchange( PVOID
*dest
, PVOID xchg
, PVOID compare
)
3341 return InterlockedCompareExchangePointer( dest
, xchg
, compare
);
3344 /*************************************************************************
3347 * See GetFileVersionInfoSizeW.
3349 DWORD WINAPI
GetFileVersionInfoSizeWrapW( LPCWSTR filename
, LPDWORD handle
)
3351 return GetFileVersionInfoSizeW( filename
, handle
);
3354 /*************************************************************************
3357 * See GetFileVersionInfoW.
3359 BOOL WINAPI
GetFileVersionInfoWrapW( LPCWSTR filename
, DWORD handle
,
3360 DWORD datasize
, LPVOID data
)
3362 return GetFileVersionInfoW( filename
, handle
, datasize
, data
);
3365 /*************************************************************************
3368 * See VerQueryValueW.
3370 WORD WINAPI
VerQueryValueWrapW( LPVOID pBlock
, LPCWSTR lpSubBlock
,
3371 LPVOID
*lplpBuffer
, UINT
*puLen
)
3373 return VerQueryValueW( pBlock
, lpSubBlock
, lplpBuffer
, puLen
);
3376 #define IsIface(type) SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
3377 #define IShellBrowser_EnableModeless IShellBrowser_EnableModelessSB
3378 #define EnableModeless(type) type##_EnableModeless((type*)lpObj, bModeless)
3380 /*************************************************************************
3383 * Change the modality of a shell object.
3386 * lpUnknown [I] Object to make modeless
3387 * bModeless [I] TRUE=Make modeless, FALSE=Make modal
3390 * Success: S_OK. The modality lpUnknown is changed.
3391 * Failure: An HRESULT error code indicating the error.
3394 * lpUnknown must support the IOleInPlaceFrame interface, the
3395 * IInternetSecurityMgrSite interface, the IShellBrowser interface
3396 * the IDocHostUIHandler interface, or the IOleInPlaceActiveObject interface,
3397 * or this call will fail.
3399 HRESULT WINAPI
IUnknown_EnableModeless(IUnknown
*lpUnknown
, BOOL bModeless
)
3404 TRACE("(%p,%d)\n", lpUnknown
, bModeless
);
3409 if (IsIface(IOleInPlaceActiveObject
))
3410 EnableModeless(IOleInPlaceActiveObject
);
3411 else if (IsIface(IOleInPlaceFrame
))
3412 EnableModeless(IOleInPlaceFrame
);
3413 else if (IsIface(IShellBrowser
))
3414 EnableModeless(IShellBrowser
);
3415 else if (IsIface(IInternetSecurityMgrSite
))
3416 EnableModeless(IInternetSecurityMgrSite
);
3417 else if (IsIface(IDocHostUIHandler
))
3418 EnableModeless(IDocHostUIHandler
);
3422 IUnknown_Release(lpObj
);
3426 /*************************************************************************
3429 * See SHGetNewLinkInfoW.
3431 BOOL WINAPI
SHGetNewLinkInfoWrapW(LPCWSTR pszLinkTo
, LPCWSTR pszDir
, LPWSTR pszName
,
3432 BOOL
*pfMustCopy
, UINT uFlags
)
3434 return SHGetNewLinkInfoW(pszLinkTo
, pszDir
, pszName
, pfMustCopy
, uFlags
);
3437 /*************************************************************************
3440 * See SHDefExtractIconW.
3442 UINT WINAPI
SHDefExtractIconWrapW(LPCWSTR pszIconFile
, int iIndex
, UINT uFlags
, HICON
* phiconLarge
,
3443 HICON
* phiconSmall
, UINT nIconSize
)
3445 return SHDefExtractIconW(pszIconFile
, iIndex
, uFlags
, phiconLarge
, phiconSmall
, nIconSize
);
3448 /*************************************************************************
3451 * Get and show a context menu from a shell folder.
3454 * hWnd [I] Window displaying the shell folder
3455 * lpFolder [I] IShellFolder interface
3456 * lpApidl [I] Id for the particular folder desired
3457 * bInvokeDefault [I] Whether to invoke the default menu item
3460 * Success: S_OK. If bInvokeDefault is TRUE, the default menu action was
3462 * Failure: An HRESULT error code indicating the error.
3464 HRESULT WINAPI
SHInvokeCommand(HWND hWnd
, IShellFolder
* lpFolder
, LPCITEMIDLIST lpApidl
, BOOL bInvokeDefault
)
3466 IContextMenu
*iContext
;
3469 TRACE("(%p, %p, %p, %d)\n", hWnd
, lpFolder
, lpApidl
, bInvokeDefault
);
3474 /* Get the context menu from the shell folder */
3475 hRet
= IShellFolder_GetUIObjectOf(lpFolder
, hWnd
, 1, &lpApidl
,
3476 &IID_IContextMenu
, 0, (void**)&iContext
);
3477 if (SUCCEEDED(hRet
))
3480 if ((hMenu
= CreatePopupMenu()))
3483 DWORD dwDefaultId
= 0;
3485 /* Add the context menu entries to the popup */
3486 hQuery
= IContextMenu_QueryContextMenu(iContext
, hMenu
, 0, 1, 0x7FFF,
3487 bInvokeDefault
? CMF_NORMAL
: CMF_DEFAULTONLY
);
3489 if (SUCCEEDED(hQuery
))
3491 if (bInvokeDefault
&&
3492 (dwDefaultId
= GetMenuDefaultItem(hMenu
, 0, 0)) != (UINT
)-1)
3494 CMINVOKECOMMANDINFO cmIci
;
3495 /* Invoke the default item */
3496 memset(&cmIci
,0,sizeof(cmIci
));
3497 cmIci
.cbSize
= sizeof(cmIci
);
3498 cmIci
.fMask
= CMIC_MASK_ASYNCOK
;
3500 cmIci
.lpVerb
= MAKEINTRESOURCEA(dwDefaultId
);
3501 cmIci
.nShow
= SW_SCROLLCHILDREN
;
3503 hRet
= IContextMenu_InvokeCommand(iContext
, &cmIci
);
3508 IContextMenu_Release(iContext
);
3513 /*************************************************************************
3518 HICON WINAPI
ExtractIconWrapW(HINSTANCE hInstance
, LPCWSTR lpszExeFileName
,
3521 return ExtractIconW(hInstance
, lpszExeFileName
, nIconIndex
);
3524 /*************************************************************************
3527 * Load a library from the directory of a particular process.
3530 * new_mod [I] Library name
3531 * inst_hwnd [I] Module whose directory is to be used
3532 * dwCrossCodePage [I] Should be FALSE (currently ignored)
3535 * Success: A handle to the loaded module
3536 * Failure: A NULL handle.
3538 HMODULE WINAPI
MLLoadLibraryA(LPCSTR new_mod
, HMODULE inst_hwnd
, DWORD dwCrossCodePage
)
3540 /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
3542 * FIXME: Native shows calls to:
3543 * SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
3545 * RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
3546 * RegQueryValueExA for "LPKInstalled"
3548 * RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
3549 * RegQueryValueExA for "ResourceLocale"
3551 * RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
3552 * RegQueryValueExA for "Locale"
3554 * and then tests the Locale ("en" for me).
3556 * after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
3558 CHAR mod_path
[2*MAX_PATH
];
3562 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_a(new_mod
), inst_hwnd
, dwCrossCodePage
);
3563 len
= GetModuleFileNameA(inst_hwnd
, mod_path
, sizeof(mod_path
));
3564 if (!len
|| len
>= sizeof(mod_path
)) return NULL
;
3566 ptr
= strrchr(mod_path
, '\\');
3568 strcpy(ptr
+1, new_mod
);
3569 TRACE("loading %s\n", debugstr_a(mod_path
));
3570 return LoadLibraryA(mod_path
);
3575 /*************************************************************************
3578 * Unicode version of MLLoadLibraryA.
3580 HMODULE WINAPI
MLLoadLibraryW(LPCWSTR new_mod
, HMODULE inst_hwnd
, DWORD dwCrossCodePage
)
3582 WCHAR mod_path
[2*MAX_PATH
];
3586 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_w(new_mod
), inst_hwnd
, dwCrossCodePage
);
3587 len
= GetModuleFileNameW(inst_hwnd
, mod_path
, sizeof(mod_path
) / sizeof(WCHAR
));
3588 if (!len
|| len
>= sizeof(mod_path
) / sizeof(WCHAR
)) return NULL
;
3590 ptr
= strrchrW(mod_path
, '\\');
3592 strcpyW(ptr
+1, new_mod
);
3593 TRACE("loading %s\n", debugstr_w(mod_path
));
3594 return LoadLibraryW(mod_path
);
3599 /*************************************************************************
3600 * ColorAdjustLuma [SHLWAPI.@]
3602 * Adjust the luminosity of a color
3605 * cRGB [I] RGB value to convert
3606 * dwLuma [I] Luma adjustment
3607 * bUnknown [I] Unknown
3610 * The adjusted RGB color.
3612 COLORREF WINAPI
ColorAdjustLuma(COLORREF cRGB
, int dwLuma
, BOOL bUnknown
)
3614 TRACE("(0x%8x,%d,%d)\n", cRGB
, dwLuma
, bUnknown
);
3620 ColorRGBToHLS(cRGB
, &wH
, &wL
, &wS
);
3622 FIXME("Ignoring luma adjustment\n");
3624 /* FIXME: The adjustment is not linear */
3626 cRGB
= ColorHLSToRGB(wH
, wL
, wS
);
3631 /*************************************************************************
3634 * See GetSaveFileNameW.
3636 BOOL WINAPI
GetSaveFileNameWrapW(LPOPENFILENAMEW ofn
)
3638 return GetSaveFileNameW(ofn
);
3641 /*************************************************************************
3644 * See WNetRestoreConnectionW.
3646 DWORD WINAPI
WNetRestoreConnectionWrapW(HWND hwndOwner
, LPWSTR lpszDevice
)
3648 return WNetRestoreConnectionW(hwndOwner
, lpszDevice
);
3651 /*************************************************************************
3654 * See WNetGetLastErrorW.
3656 DWORD WINAPI
WNetGetLastErrorWrapW(LPDWORD lpError
, LPWSTR lpErrorBuf
, DWORD nErrorBufSize
,
3657 LPWSTR lpNameBuf
, DWORD nNameBufSize
)
3659 return WNetGetLastErrorW(lpError
, lpErrorBuf
, nErrorBufSize
, lpNameBuf
, nNameBufSize
);
3662 /*************************************************************************
3665 * See PageSetupDlgW.
3667 BOOL WINAPI
PageSetupDlgWrapW(LPPAGESETUPDLGW pagedlg
)
3669 return PageSetupDlgW(pagedlg
);
3672 /*************************************************************************
3677 BOOL WINAPI
PrintDlgWrapW(LPPRINTDLGW printdlg
)
3679 return PrintDlgW(printdlg
);
3682 /*************************************************************************
3685 * See GetOpenFileNameW.
3687 BOOL WINAPI
GetOpenFileNameWrapW(LPOPENFILENAMEW ofn
)
3689 return GetOpenFileNameW(ofn
);
3692 /*************************************************************************
3695 HRESULT WINAPI
SHIShellFolder_EnumObjects(LPSHELLFOLDER lpFolder
, HWND hwnd
, SHCONTF flags
, IEnumIDList
**ppenum
)
3700 hr
= IShellFolder_QueryInterface(lpFolder
, &IID_IPersist
, (LPVOID
)&persist
);
3704 hr
= IPersist_GetClassID(persist
, &clsid
);
3707 if(IsEqualCLSID(&clsid
, &CLSID_ShellFSFolder
))
3708 hr
= IShellFolder_EnumObjects(lpFolder
, hwnd
, flags
, ppenum
);
3712 IPersist_Release(persist
);
3717 /* INTERNAL: Map from HLS color space to RGB */
3718 static WORD
ConvertHue(int wHue
, WORD wMid1
, WORD wMid2
)
3720 wHue
= wHue
> 240 ? wHue
- 240 : wHue
< 0 ? wHue
+ 240 : wHue
;
3724 else if (wHue
> 120)
3729 return ((wHue
* (wMid2
- wMid1
) + 20) / 40) + wMid1
;
3732 /* Convert to RGB and scale into RGB range (0..255) */
3733 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
3735 /*************************************************************************
3736 * ColorHLSToRGB [SHLWAPI.@]
3738 * Convert from hls color space into an rgb COLORREF.
3741 * wHue [I] Hue amount
3742 * wLuminosity [I] Luminosity amount
3743 * wSaturation [I] Saturation amount
3746 * A COLORREF representing the converted color.
3749 * Input hls values are constrained to the range (0..240).
3751 COLORREF WINAPI
ColorHLSToRGB(WORD wHue
, WORD wLuminosity
, WORD wSaturation
)
3757 WORD wGreen
, wBlue
, wMid1
, wMid2
;
3759 if (wLuminosity
> 120)
3760 wMid2
= wSaturation
+ wLuminosity
- (wSaturation
* wLuminosity
+ 120) / 240;
3762 wMid2
= ((wSaturation
+ 240) * wLuminosity
+ 120) / 240;
3764 wMid1
= wLuminosity
* 2 - wMid2
;
3766 wRed
= GET_RGB(wHue
+ 80);
3767 wGreen
= GET_RGB(wHue
);
3768 wBlue
= GET_RGB(wHue
- 80);
3770 return RGB(wRed
, wGreen
, wBlue
);
3773 wRed
= wLuminosity
* 255 / 240;
3774 return RGB(wRed
, wRed
, wRed
);
3777 /*************************************************************************
3780 * Get the current docking status of the system.
3783 * dwFlags [I] DOCKINFO_ flags from "winbase.h", unused
3786 * One of DOCKINFO_UNDOCKED, DOCKINFO_UNDOCKED, or 0 if the system is not
3789 DWORD WINAPI
SHGetMachineInfo(DWORD dwFlags
)
3791 HW_PROFILE_INFOA hwInfo
;
3793 TRACE("(0x%08x)\n", dwFlags
);
3795 GetCurrentHwProfileA(&hwInfo
);
3796 switch (hwInfo
.dwDockInfo
& (DOCKINFO_DOCKED
|DOCKINFO_UNDOCKED
))
3798 case DOCKINFO_DOCKED
:
3799 case DOCKINFO_UNDOCKED
:
3800 return hwInfo
.dwDockInfo
& (DOCKINFO_DOCKED
|DOCKINFO_UNDOCKED
);
3806 /*************************************************************************
3809 * Function seems to do FreeLibrary plus other things.
3811 * FIXME native shows the following calls:
3812 * RtlEnterCriticalSection
3814 * GetProcAddress(Comctl32??, 150L)
3816 * RtlLeaveCriticalSection
3817 * followed by the FreeLibrary.
3818 * The above code may be related to .377 above.
3820 BOOL WINAPI
MLFreeLibrary(HMODULE hModule
)
3822 FIXME("(%p) semi-stub\n", hModule
);
3823 return FreeLibrary(hModule
);
3826 /*************************************************************************
3829 BOOL WINAPI
SHFlushSFCacheWrap(void) {
3834 /*************************************************************************
3836 * FIXME I have no idea what this function does or what its arguments are.
3838 BOOL WINAPI
MLIsMLHInstance(HINSTANCE hInst
)
3840 FIXME("(%p) stub\n", hInst
);
3845 /*************************************************************************
3848 DWORD WINAPI
MLSetMLHInstance(HINSTANCE hInst
, HANDLE hHeap
)
3850 FIXME("(%p,%p) stub\n", hInst
, hHeap
);
3851 return E_FAIL
; /* This is what is used if shlwapi not loaded */
3854 /*************************************************************************
3857 DWORD WINAPI
MLClearMLHInstance(DWORD x
)
3859 FIXME("(0x%08x)stub\n", x
);
3863 /*************************************************************************
3866 * See SHSendMessageBroadcastW
3869 DWORD WINAPI
SHSendMessageBroadcastA(UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
3871 return SendMessageTimeoutA(HWND_BROADCAST
, uMsg
, wParam
, lParam
,
3872 SMTO_ABORTIFHUNG
, 2000, NULL
);
3875 /*************************************************************************
3878 * A wrapper for sending Broadcast Messages to all top level Windows
3881 DWORD WINAPI
SHSendMessageBroadcastW(UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
3883 return SendMessageTimeoutW(HWND_BROADCAST
, uMsg
, wParam
, lParam
,
3884 SMTO_ABORTIFHUNG
, 2000, NULL
);
3887 /*************************************************************************
3890 * Convert a Unicode string CLSID into a CLSID.
3893 * idstr [I] string containing a CLSID in text form
3894 * id [O] CLSID extracted from the string
3897 * S_OK on success or E_INVALIDARG on failure
3899 HRESULT WINAPI
CLSIDFromStringWrap(LPCWSTR idstr
, CLSID
*id
)
3901 return CLSIDFromString((LPCOLESTR
)idstr
, id
);
3904 /*************************************************************************
3907 * Determine if the OS supports a given feature.
3910 * dwFeature [I] Feature requested (undocumented)
3913 * TRUE If the feature is available.
3914 * FALSE If the feature is not available.
3916 BOOL WINAPI
IsOS(DWORD feature
)
3918 OSVERSIONINFOA osvi
;
3919 DWORD platform
, majorv
, minorv
;
3921 osvi
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFOA
);
3922 if(!GetVersionExA(&osvi
)) {
3923 ERR("GetVersionEx failed\n");
3927 majorv
= osvi
.dwMajorVersion
;
3928 minorv
= osvi
.dwMinorVersion
;
3929 platform
= osvi
.dwPlatformId
;
3931 #define ISOS_RETURN(x) \
3932 TRACE("(0x%x) ret=%d\n",feature,(x)); \
3936 case OS_WIN32SORGREATER
:
3937 ISOS_RETURN(platform
== VER_PLATFORM_WIN32s
3938 || platform
== VER_PLATFORM_WIN32_WINDOWS
)
3940 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3941 case OS_WIN95ORGREATER
:
3942 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
)
3943 case OS_NT4ORGREATER
:
3944 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 4)
3945 case OS_WIN2000ORGREATER_ALT
:
3946 case OS_WIN2000ORGREATER
:
3947 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3948 case OS_WIN98ORGREATER
:
3949 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
>= 10)
3951 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
== 10)
3953 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3954 case OS_WIN2000SERVER
:
3955 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3956 case OS_WIN2000ADVSERVER
:
3957 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3958 case OS_WIN2000DATACENTER
:
3959 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3960 case OS_WIN2000TERMINAL
:
3961 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3963 FIXME("(OS_EMBEDDED) What should we return here?\n");
3965 case OS_TERMINALCLIENT
:
3966 FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
3968 case OS_TERMINALREMOTEADMIN
:
3969 FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
3972 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
== 0)
3973 case OS_MEORGREATER
:
3974 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
>= 90)
3975 case OS_XPORGREATER
:
3976 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5 && minorv
>= 1)
3978 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5 && minorv
>= 1)
3979 case OS_PROFESSIONAL
:
3980 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3982 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3984 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3986 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3987 case OS_TERMINALSERVER
:
3988 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3989 case OS_PERSONALTERMINALSERVER
:
3990 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& minorv
>= 1 && majorv
>= 5)
3991 case OS_FASTUSERSWITCHING
:
3992 FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
3994 case OS_WELCOMELOGONUI
:
3995 FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
3997 case OS_DOMAINMEMBER
:
3998 FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
4001 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4003 FIXME("(OS_WOW6432) Should we check this?\n");
4006 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4007 case OS_SMALLBUSINESSSERVER
:
4008 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
4010 FIXME("(OS_TABLEPC) What should we return here?\n");
4012 case OS_SERVERADMINUI
:
4013 FIXME("(OS_SERVERADMINUI) What should we return here?\n");
4015 case OS_MEDIACENTER
:
4016 FIXME("(OS_MEDIACENTER) What should we return here?\n");
4019 FIXME("(OS_APPLIANCE) What should we return here?\n");
4021 case 0x25: /*OS_VISTAORGREATER*/
4022 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 6)
4027 WARN("(0x%x) unknown parameter\n",feature
);
4032 /*************************************************************************
4035 HRESULT WINAPI
SHLoadRegUIStringW(HKEY hkey
, LPCWSTR value
, LPWSTR buf
, DWORD size
)
4037 DWORD type
, sz
= size
;
4039 if(RegQueryValueExW(hkey
, value
, NULL
, &type
, (LPBYTE
)buf
, &sz
) != ERROR_SUCCESS
)
4042 return SHLoadIndirectString(buf
, buf
, size
, NULL
);
4045 /*************************************************************************
4048 * Call IInputObject_TranslateAcceleratorIO() on an object.
4051 * lpUnknown [I] Object supporting the IInputObject interface.
4052 * lpMsg [I] Key message to be processed.
4056 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
4058 HRESULT WINAPI
IUnknown_TranslateAcceleratorIO(IUnknown
*lpUnknown
, LPMSG lpMsg
)
4060 IInputObject
* lpInput
= NULL
;
4061 HRESULT hRet
= E_INVALIDARG
;
4063 TRACE("(%p,%p)\n", lpUnknown
, lpMsg
);
4066 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInputObject
,
4068 if (SUCCEEDED(hRet
) && lpInput
)
4070 hRet
= IInputObject_TranslateAcceleratorIO(lpInput
, lpMsg
);
4071 IInputObject_Release(lpInput
);
4077 /*************************************************************************
4080 * Call IInputObject_HasFocusIO() on an object.
4083 * lpUnknown [I] Object supporting the IInputObject interface.
4086 * Success: S_OK, if lpUnknown is an IInputObject object and has the focus,
4087 * or S_FALSE otherwise.
4088 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
4090 HRESULT WINAPI
IUnknown_HasFocusIO(IUnknown
*lpUnknown
)
4092 IInputObject
* lpInput
= NULL
;
4093 HRESULT hRet
= E_INVALIDARG
;
4095 TRACE("(%p)\n", lpUnknown
);
4098 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInputObject
,
4100 if (SUCCEEDED(hRet
) && lpInput
)
4102 hRet
= IInputObject_HasFocusIO(lpInput
);
4103 IInputObject_Release(lpInput
);
4109 /*************************************************************************
4110 * ColorRGBToHLS [SHLWAPI.@]
4112 * Convert an rgb COLORREF into the hls color space.
4115 * cRGB [I] Source rgb value
4116 * pwHue [O] Destination for converted hue
4117 * pwLuminance [O] Destination for converted luminance
4118 * pwSaturation [O] Destination for converted saturation
4121 * Nothing. pwHue, pwLuminance and pwSaturation are set to the converted
4125 * Output HLS values are constrained to the range (0..240).
4126 * For Achromatic conversions, Hue is set to 160.
4128 VOID WINAPI
ColorRGBToHLS(COLORREF cRGB
, LPWORD pwHue
,
4129 LPWORD pwLuminance
, LPWORD pwSaturation
)
4131 int wR
, wG
, wB
, wMax
, wMin
, wHue
, wLuminosity
, wSaturation
;
4133 TRACE("(%08x,%p,%p,%p)\n", cRGB
, pwHue
, pwLuminance
, pwSaturation
);
4135 wR
= GetRValue(cRGB
);
4136 wG
= GetGValue(cRGB
);
4137 wB
= GetBValue(cRGB
);
4139 wMax
= max(wR
, max(wG
, wB
));
4140 wMin
= min(wR
, min(wG
, wB
));
4143 wLuminosity
= ((wMax
+ wMin
) * 240 + 255) / 510;
4147 /* Achromatic case */
4149 /* Hue is now unrepresentable, but this is what native returns... */
4154 /* Chromatic case */
4155 int wDelta
= wMax
- wMin
, wRNorm
, wGNorm
, wBNorm
;
4158 if (wLuminosity
<= 120)
4159 wSaturation
= ((wMax
+ wMin
)/2 + wDelta
* 240) / (wMax
+ wMin
);
4161 wSaturation
= ((510 - wMax
- wMin
)/2 + wDelta
* 240) / (510 - wMax
- wMin
);
4164 wRNorm
= (wDelta
/2 + wMax
* 40 - wR
* 40) / wDelta
;
4165 wGNorm
= (wDelta
/2 + wMax
* 40 - wG
* 40) / wDelta
;
4166 wBNorm
= (wDelta
/2 + wMax
* 40 - wB
* 40) / wDelta
;
4169 wHue
= wBNorm
- wGNorm
;
4170 else if (wG
== wMax
)
4171 wHue
= 80 + wRNorm
- wBNorm
;
4173 wHue
= 160 + wGNorm
- wRNorm
;
4176 else if (wHue
> 240)
4182 *pwLuminance
= wLuminosity
;
4184 *pwSaturation
= wSaturation
;
4187 /*************************************************************************
4188 * SHCreateShellPalette [SHLWAPI.@]
4190 HPALETTE WINAPI
SHCreateShellPalette(HDC hdc
)
4193 return CreateHalftonePalette(hdc
);
4196 /*************************************************************************
4197 * SHGetInverseCMAP (SHLWAPI.@)
4199 * Get an inverse color map table.
4202 * lpCmap [O] Destination for color map
4203 * dwSize [I] Size of memory pointed to by lpCmap
4207 * Failure: E_POINTER, If lpCmap is invalid.
4208 * E_INVALIDARG, If dwFlags is invalid
4209 * E_OUTOFMEMORY, If there is no memory available
4212 * dwSize may only be CMAP_PTR_SIZE (4) or CMAP_SIZE (8192).
4213 * If dwSize = CMAP_PTR_SIZE, *lpCmap is set to the address of this DLL's
4215 * If dwSize = CMAP_SIZE, lpCmap is filled with a copy of the data from
4216 * this DLL's internal CMap.
4218 HRESULT WINAPI
SHGetInverseCMAP(LPDWORD dest
, DWORD dwSize
)
4221 FIXME(" - returning bogus address for SHGetInverseCMAP\n");
4222 *dest
= (DWORD
)0xabba1249;
4225 FIXME("(%p, %#x) stub\n", dest
, dwSize
);
4229 /*************************************************************************
4230 * SHIsLowMemoryMachine [SHLWAPI.@]
4232 * Determine if the current computer has low memory.
4238 * TRUE if the users machine has 16 Megabytes of memory or less,
4241 BOOL WINAPI
SHIsLowMemoryMachine (DWORD x
)
4243 FIXME("(0x%08x) stub\n", x
);
4247 /*************************************************************************
4248 * GetMenuPosFromID [SHLWAPI.@]
4250 * Return the position of a menu item from its Id.
4253 * hMenu [I] Menu containing the item
4254 * wID [I] Id of the menu item
4257 * Success: The index of the menu item in hMenu.
4258 * Failure: -1, If the item is not found.
4260 INT WINAPI
GetMenuPosFromID(HMENU hMenu
, UINT wID
)
4263 INT nCount
= GetMenuItemCount(hMenu
), nIter
= 0;
4265 TRACE("%p %u\n", hMenu
, wID
);
4267 while (nIter
< nCount
)
4269 mi
.cbSize
= sizeof(mi
);
4271 if (GetMenuItemInfoW(hMenu
, nIter
, TRUE
, &mi
) && mi
.wID
== wID
)
4273 TRACE("ret %d\n", nIter
);
4282 /*************************************************************************
4285 * Same as SHLWAPI.GetMenuPosFromID
4287 DWORD WINAPI
SHMenuIndexFromID(HMENU hMenu
, UINT uID
)
4289 TRACE("%p %u\n", hMenu
, uID
);
4290 return GetMenuPosFromID(hMenu
, uID
);
4294 /*************************************************************************
4297 VOID WINAPI
FixSlashesAndColonW(LPWSTR lpwstr
)
4308 /*************************************************************************
4311 DWORD WINAPI
SHGetAppCompatFlags(DWORD dwUnknown
)
4313 FIXME("(0x%08x) stub\n", dwUnknown
);
4318 /*************************************************************************
4321 HRESULT WINAPI
SHCoCreateInstanceAC(REFCLSID rclsid
, LPUNKNOWN pUnkOuter
,
4322 DWORD dwClsContext
, REFIID iid
, LPVOID
*ppv
)
4324 return CoCreateInstance(rclsid
, pUnkOuter
, dwClsContext
, iid
, ppv
);
4327 /*************************************************************************
4328 * SHSkipJunction [SHLWAPI.@]
4330 * Determine if a bind context can be bound to an object
4333 * pbc [I] Bind context to check
4334 * pclsid [I] CLSID of object to be bound to
4337 * TRUE: If it is safe to bind
4338 * FALSE: If pbc is invalid or binding would not be safe
4341 BOOL WINAPI
SHSkipJunction(IBindCtx
*pbc
, const CLSID
*pclsid
)
4343 static WCHAR szSkipBinding
[] = { 'S','k','i','p',' ',
4344 'B','i','n','d','i','n','g',' ','C','L','S','I','D','\0' };
4351 if (SUCCEEDED(IBindCtx_GetObjectParam(pbc
, szSkipBinding
, &lpUnk
)))
4355 if (SUCCEEDED(IUnknown_GetClassID(lpUnk
, &clsid
)) &&
4356 IsEqualGUID(pclsid
, &clsid
))
4359 IUnknown_Release(lpUnk
);
4365 /***********************************************************************
4366 * SHGetShellKey (SHLWAPI.@)
4368 HKEY WINAPI
SHGetShellKey(DWORD flags
, LPCWSTR sub_key
, BOOL create
)
4370 FIXME("(0x%08x, %s, %d): stub\n", flags
, debugstr_w(sub_key
), create
);
4374 /***********************************************************************
4375 * SHQueueUserWorkItem (SHLWAPI.@)
4377 BOOL WINAPI
SHQueueUserWorkItem(LPTHREAD_START_ROUTINE pfnCallback
,
4378 LPVOID pContext
, LONG lPriority
, DWORD_PTR dwTag
,
4379 DWORD_PTR
*pdwId
, LPCSTR pszModule
, DWORD dwFlags
)
4381 TRACE("(%p, %p, %d, %lx, %p, %s, %08x)\n", pfnCallback
, pContext
,
4382 lPriority
, dwTag
, pdwId
, debugstr_a(pszModule
), dwFlags
);
4384 if(lPriority
|| dwTag
|| pdwId
|| pszModule
|| dwFlags
)
4385 FIXME("Unsupported arguments\n");
4387 return QueueUserWorkItem(pfnCallback
, pContext
, 0);
4390 /***********************************************************************
4391 * SHSetTimerQueueTimer (SHLWAPI.263)
4393 HANDLE WINAPI
SHSetTimerQueueTimer(HANDLE hQueue
,
4394 WAITORTIMERCALLBACK pfnCallback
, LPVOID pContext
, DWORD dwDueTime
,
4395 DWORD dwPeriod
, LPCSTR lpszLibrary
, DWORD dwFlags
)
4399 /* SHSetTimerQueueTimer flags -> CreateTimerQueueTimer flags */
4400 if (dwFlags
& TPS_LONGEXECTIME
) {
4401 dwFlags
&= ~TPS_LONGEXECTIME
;
4402 dwFlags
|= WT_EXECUTELONGFUNCTION
;
4404 if (dwFlags
& TPS_EXECUTEIO
) {
4405 dwFlags
&= ~TPS_EXECUTEIO
;
4406 dwFlags
|= WT_EXECUTEINIOTHREAD
;
4409 if (!CreateTimerQueueTimer(&hNewTimer
, hQueue
, pfnCallback
, pContext
,
4410 dwDueTime
, dwPeriod
, dwFlags
))
4416 /***********************************************************************
4417 * IUnknown_OnFocusChangeIS (SHLWAPI.@)
4419 HRESULT WINAPI
IUnknown_OnFocusChangeIS(LPUNKNOWN lpUnknown
, LPUNKNOWN pFocusObject
, BOOL bFocus
)
4421 IInputObjectSite
*pIOS
= NULL
;
4422 HRESULT hRet
= E_INVALIDARG
;
4424 TRACE("(%p, %p, %s)\n", lpUnknown
, pFocusObject
, bFocus
? "TRUE" : "FALSE");
4428 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInputObjectSite
,
4430 if (SUCCEEDED(hRet
) && pIOS
)
4432 hRet
= IInputObjectSite_OnFocusChangeIS(pIOS
, pFocusObject
, bFocus
);
4433 IInputObjectSite_Release(pIOS
);
4439 /***********************************************************************
4440 * SHGetValueW (SHLWAPI.@)
4442 HRESULT WINAPI
SKGetValueW(DWORD a
, LPWSTR b
, LPWSTR c
, DWORD d
, DWORD e
, DWORD f
)
4444 FIXME("(%x, %s, %s, %x, %x, %x): stub\n", a
, debugstr_w(b
), debugstr_w(c
), d
, e
, f
);
4448 typedef HRESULT (WINAPI
*DllGetVersion_func
)(DLLVERSIONINFO
*);
4450 /***********************************************************************
4451 * GetUIVersion (SHLWAPI.452)
4453 DWORD WINAPI
GetUIVersion(void)
4455 static DWORD version
;
4459 DllGetVersion_func pDllGetVersion
;
4460 HMODULE dll
= LoadLibraryA("shell32.dll");
4463 pDllGetVersion
= (DllGetVersion_func
)GetProcAddress(dll
, "DllGetVersion");
4467 dvi
.cbSize
= sizeof(DLLVERSIONINFO
);
4468 if (pDllGetVersion(&dvi
) == S_OK
) version
= dvi
.dwMajorVersion
;
4471 if (!version
) version
= 3; /* old shell dlls don't have DllGetVersion */
4476 /***********************************************************************
4477 * ShellMessageBoxWrapW [SHLWAPI.388]
4479 * See shell32.ShellMessageBoxW
4482 * shlwapi.ShellMessageBoxWrapW is a duplicate of shell32.ShellMessageBoxW
4483 * because we can't forward to it in the .spec file since it's exported by
4484 * ordinal. If you change the implementation here please update the code in
4487 INT WINAPIV
ShellMessageBoxWrapW(HINSTANCE hInstance
, HWND hWnd
, LPCWSTR lpText
,
4488 LPCWSTR lpCaption
, UINT uType
, ...)
4490 WCHAR
*szText
= NULL
, szTitle
[100];
4491 LPCWSTR pszText
, pszTitle
= szTitle
;
4496 __ms_va_start(args
, uType
);
4498 TRACE("(%p,%p,%p,%p,%08x)\n", hInstance
, hWnd
, lpText
, lpCaption
, uType
);
4500 if (IS_INTRESOURCE(lpCaption
))
4501 LoadStringW(hInstance
, LOWORD(lpCaption
), szTitle
, sizeof(szTitle
)/sizeof(szTitle
[0]));
4503 pszTitle
= lpCaption
;
4505 if (IS_INTRESOURCE(lpText
))
4508 UINT len
= LoadStringW(hInstance
, LOWORD(lpText
), (LPWSTR
)&ptr
, 0);
4511 szText
= HeapAlloc(GetProcessHeap(), 0, (len
+ 1) * sizeof(WCHAR
));
4512 if (szText
) LoadStringW(hInstance
, LOWORD(lpText
), szText
, len
+ 1);
4519 FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_STRING
,
4520 pszText
, 0, 0, (LPWSTR
)&pszTemp
, 0, &args
);
4524 ret
= MessageBoxW(hWnd
, pszTemp
, pszTitle
, uType
);
4526 HeapFree(GetProcessHeap(), 0, szText
);
4531 /***********************************************************************
4532 * ZoneComputePaneSize [SHLWAPI.382]
4534 UINT WINAPI
ZoneComputePaneSize(HWND hwnd
)
4540 /***********************************************************************
4541 * SHChangeNotifyWrap [SHLWAPI.394]
4543 void WINAPI
SHChangeNotifyWrap(LONG wEventId
, UINT uFlags
, LPCVOID dwItem1
, LPCVOID dwItem2
)
4545 SHChangeNotify(wEventId
, uFlags
, dwItem1
, dwItem2
);
4548 typedef struct SHELL_USER_SID
{ /* according to MSDN this should be in shlobj.h... */
4549 SID_IDENTIFIER_AUTHORITY sidAuthority
;
4550 DWORD dwUserGroupID
;
4552 } SHELL_USER_SID
, *PSHELL_USER_SID
;
4554 typedef struct SHELL_USER_PERMISSION
{ /* ...and this should be in shlwapi.h */
4555 SHELL_USER_SID susID
;
4559 DWORD dwInheritMask
;
4560 DWORD dwInheritAccessMask
;
4561 } SHELL_USER_PERMISSION
, *PSHELL_USER_PERMISSION
;
4563 /***********************************************************************
4564 * GetShellSecurityDescriptor [SHLWAPI.475]
4566 * prepares SECURITY_DESCRIPTOR from a set of ACEs
4569 * apUserPerm [I] array of pointers to SHELL_USER_PERMISSION structures,
4570 * each of which describes permissions to apply
4571 * cUserPerm [I] number of entries in apUserPerm array
4574 * success: pointer to SECURITY_DESCRIPTOR
4578 * Call should free returned descriptor with LocalFree
4580 PSECURITY_DESCRIPTOR WINAPI
GetShellSecurityDescriptor(PSHELL_USER_PERMISSION
*apUserPerm
, int cUserPerm
)
4583 PSID cur_user
= NULL
;
4587 PSECURITY_DESCRIPTOR psd
= NULL
;
4589 TRACE("%p %d\n", apUserPerm
, cUserPerm
);
4591 if (apUserPerm
== NULL
|| cUserPerm
<= 0)
4594 sidlist
= HeapAlloc(GetProcessHeap(), 0, cUserPerm
* sizeof(PSID
));
4598 acl_size
= sizeof(ACL
);
4600 for(sid_count
= 0; sid_count
< cUserPerm
; sid_count
++)
4602 static SHELL_USER_SID null_sid
= {{SECURITY_NULL_SID_AUTHORITY
}, 0, 0};
4603 PSHELL_USER_PERMISSION perm
= apUserPerm
[sid_count
];
4604 PSHELL_USER_SID sid
= &perm
->susID
;
4608 if (!memcmp((void*)sid
, (void*)&null_sid
, sizeof(SHELL_USER_SID
)))
4609 { /* current user's SID */
4613 DWORD bufsize
= sizeof(tuUser
);
4615 ret
= OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY
, &Token
);
4618 ret
= GetTokenInformation(Token
, TokenUser
, (void*)tuUser
, bufsize
, &bufsize
);
4620 cur_user
= ((PTOKEN_USER
)tuUser
)->User
.Sid
;
4625 } else if (sid
->dwUserID
==0) /* one sub-authority */
4626 ret
= AllocateAndInitializeSid(&sid
->sidAuthority
, 1, sid
->dwUserGroupID
, 0,
4627 0, 0, 0, 0, 0, 0, &pSid
);
4629 ret
= AllocateAndInitializeSid(&sid
->sidAuthority
, 2, sid
->dwUserGroupID
, sid
->dwUserID
,
4630 0, 0, 0, 0, 0, 0, &pSid
);
4634 sidlist
[sid_count
] = pSid
;
4635 /* increment acl_size (1 ACE for non-inheritable and 2 ACEs for inheritable records */
4636 acl_size
+= (sizeof(ACCESS_ALLOWED_ACE
)-sizeof(DWORD
) + GetLengthSid(pSid
)) * (perm
->fInherit
? 2 : 1);
4639 psd
= LocalAlloc(0, sizeof(SECURITY_DESCRIPTOR
) + acl_size
);
4643 PACL pAcl
= (PACL
)(((BYTE
*)psd
)+sizeof(SECURITY_DESCRIPTOR
));
4645 if (!InitializeSecurityDescriptor(psd
, SECURITY_DESCRIPTOR_REVISION
))
4648 if (!InitializeAcl(pAcl
, acl_size
, ACL_REVISION
))
4651 for(i
= 0; i
< sid_count
; i
++)
4653 PSHELL_USER_PERMISSION sup
= apUserPerm
[i
];
4654 PSID sid
= sidlist
[i
];
4656 switch(sup
->dwAccessType
)
4658 case ACCESS_ALLOWED_ACE_TYPE
:
4659 if (!AddAccessAllowedAce(pAcl
, ACL_REVISION
, sup
->dwAccessMask
, sid
))
4661 if (sup
->fInherit
&& !AddAccessAllowedAceEx(pAcl
, ACL_REVISION
,
4662 (BYTE
)sup
->dwInheritMask
, sup
->dwInheritAccessMask
, sid
))
4665 case ACCESS_DENIED_ACE_TYPE
:
4666 if (!AddAccessDeniedAce(pAcl
, ACL_REVISION
, sup
->dwAccessMask
, sid
))
4668 if (sup
->fInherit
&& !AddAccessDeniedAceEx(pAcl
, ACL_REVISION
,
4669 (BYTE
)sup
->dwInheritMask
, sup
->dwInheritAccessMask
, sid
))
4677 if (!SetSecurityDescriptorDacl(psd
, TRUE
, pAcl
, FALSE
))
4686 for(i
= 0; i
< sid_count
; i
++)
4688 if (!cur_user
|| sidlist
[i
] != cur_user
)
4689 FreeSid(sidlist
[i
]);
4691 HeapFree(GetProcessHeap(), 0, sidlist
);
4696 /***********************************************************************
4697 * SHCreatePropertyBagOnRegKey [SHLWAPI.471]
4699 * Creates a property bag from a registry key
4702 * hKey [I] Handle to the desired registry key
4703 * subkey [I] Name of desired subkey, or NULL to open hKey directly
4704 * grfMode [I] Optional flags
4705 * riid [I] IID of requested property bag interface
4706 * ppv [O] Address to receive pointer to the new interface
4710 * failure: error code
4713 HRESULT WINAPI
SHCreatePropertyBagOnRegKey (HKEY hKey
, LPCWSTR subkey
,
4714 DWORD grfMode
, REFIID riid
, void **ppv
)
4716 FIXME("%p %s %d %s %p STUB\n", hKey
, debugstr_w(subkey
), grfMode
,
4717 debugstr_guid(riid
), ppv
);
4722 /***********************************************************************
4723 * SHGetViewStatePropertyBag [SHLWAPI.515]
4725 * Retrieves a property bag in which the view state information of a folder
4729 * pidl [I] PIDL of the folder requested
4730 * bag_name [I] Name of the property bag requested
4731 * flags [I] Optional flags
4732 * riid [I] IID of requested property bag interface
4733 * ppv [O] Address to receive pointer to the new interface
4737 * failure: error code
4740 HRESULT WINAPI
SHGetViewStatePropertyBag(LPCITEMIDLIST pidl
, LPWSTR bag_name
,
4741 DWORD flags
, REFIID riid
, void **ppv
)
4743 FIXME("%p %s %d %s %p STUB\n", pidl
, debugstr_w(bag_name
), flags
,
4744 debugstr_guid(riid
), ppv
);
4749 /***********************************************************************
4750 * SHFormatDateTimeW [SHLWAPI.354]
4752 * Produces a string representation of a time.
4755 * fileTime [I] Pointer to FILETIME structure specifying the time
4756 * flags [I] Flags specifying the desired output
4757 * buf [O] Pointer to buffer for output
4758 * size [I] Number of characters that can be contained in buffer
4761 * success: number of characters written to the buffer
4765 INT WINAPI
SHFormatDateTimeW(const FILETIME UNALIGNED
*fileTime
, DWORD
*flags
,
4766 LPWSTR buf
, UINT size
)
4768 #define SHFORMATDT_UNSUPPORTED_FLAGS (FDTF_RELATIVE | FDTF_LTRDATE | FDTF_RTLDATE | FDTF_NOAUTOREADINGORDER)
4769 DWORD fmt_flags
= flags
? *flags
: FDTF_DEFAULT
;
4774 TRACE("%p %p %p %u\n", fileTime
, flags
, buf
, size
);
4779 if (fmt_flags
& SHFORMATDT_UNSUPPORTED_FLAGS
)
4780 FIXME("ignoring some flags - 0x%08x\n", fmt_flags
& SHFORMATDT_UNSUPPORTED_FLAGS
);
4782 FileTimeToLocalFileTime(fileTime
, &ft
);
4783 FileTimeToSystemTime(&ft
, &st
);
4785 /* first of all date */
4786 if (fmt_flags
& (FDTF_LONGDATE
| FDTF_SHORTDATE
))
4788 static const WCHAR sep1
[] = {',',' ',0};
4789 static const WCHAR sep2
[] = {' ',0};
4791 DWORD date
= fmt_flags
& FDTF_LONGDATE
? DATE_LONGDATE
: DATE_SHORTDATE
;
4792 ret
= GetDateFormatW(LOCALE_USER_DEFAULT
, date
, &st
, NULL
, buf
, size
);
4793 if (ret
>= size
) return ret
;
4796 if (ret
< size
&& (fmt_flags
& (FDTF_LONGTIME
| FDTF_SHORTTIME
)))
4798 if ((fmt_flags
& FDTF_LONGDATE
) && (ret
< size
+ 2))
4802 lstrcatW(&buf
[ret
-1], sep1
);
4808 lstrcatW(&buf
[ret
-1], sep2
);
4814 if (fmt_flags
& (FDTF_LONGTIME
| FDTF_SHORTTIME
))
4816 DWORD time
= fmt_flags
& FDTF_LONGTIME
? 0 : TIME_NOSECONDS
;
4819 ret
+= GetTimeFormatW(LOCALE_USER_DEFAULT
, time
, &st
, NULL
, &buf
[ret
], size
- ret
);
4824 #undef SHFORMATDT_UNSUPPORTED_FLAGS
4827 /***********************************************************************
4828 * SHFormatDateTimeA [SHLWAPI.353]
4830 * See SHFormatDateTimeW.
4833 INT WINAPI
SHFormatDateTimeA(const FILETIME UNALIGNED
*fileTime
, DWORD
*flags
,
4834 LPSTR buf
, UINT size
)
4842 bufW
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
) * size
);
4843 retval
= SHFormatDateTimeW(fileTime
, flags
, bufW
, size
);
4846 WideCharToMultiByte(CP_ACP
, 0, bufW
, -1, buf
, size
, NULL
, NULL
);
4848 HeapFree(GetProcessHeap(), 0, bufW
);
4852 /***********************************************************************
4853 * ZoneCheckUrlExW [SHLWAPI.231]
4855 * Checks the details of the security zone for the supplied site. (?)
4859 * szURL [I] Pointer to the URL to check
4861 * Other parameters currently unknown.
4867 INT WINAPI
ZoneCheckUrlExW(LPWSTR szURL
, PVOID pUnknown
, DWORD dwUnknown2
,
4868 DWORD dwUnknown3
, DWORD dwUnknown4
, DWORD dwUnknown5
, DWORD dwUnknown6
,
4871 FIXME("(%s,%p,%x,%x,%x,%x,%x,%x) STUB\n", debugstr_w(szURL
), pUnknown
, dwUnknown2
,
4872 dwUnknown3
, dwUnknown4
, dwUnknown5
, dwUnknown6
, dwUnknown7
);
4877 /***********************************************************************
4878 * SHVerbExistsNA [SHLWAPI.196]
4883 * verb [I] a string, often appears to be an extension.
4885 * Other parameters currently unknown.
4890 INT WINAPI
SHVerbExistsNA(LPSTR verb
, PVOID pUnknown
, PVOID pUnknown2
, DWORD dwUnknown3
)
4892 FIXME("(%s, %p, %p, %i) STUB\n",verb
, pUnknown
, pUnknown2
, dwUnknown3
);
4896 /*************************************************************************
4899 * Undocumented: Implementation guessed at via Name and behavior
4902 * lpUnknown [I] Object to get an IServiceProvider interface from
4903 * riid [I] Function requested for QueryService call
4904 * lppOut [O] Destination for the service interface pointer
4907 * Success: S_OK. lppOut contains an object providing the requested service
4908 * Failure: An HRESULT error code
4911 * lpUnknown is expected to support the IServiceProvider interface.
4913 HRESULT WINAPI
IUnknown_QueryServiceForWebBrowserApp(IUnknown
* lpUnknown
,
4914 REFGUID riid
, LPVOID
*lppOut
)
4916 FIXME("%p %s %p semi-STUB\n", lpUnknown
, debugstr_guid(riid
), lppOut
);
4917 return IUnknown_QueryService(lpUnknown
,&IID_IWebBrowserApp
,riid
,lppOut
);
4920 /**************************************************************************
4921 * SHPropertyBag_ReadLONG (SHLWAPI.496)
4923 * This function asks a property bag to read a named property as a LONG.
4926 * ppb: a IPropertyBag interface
4927 * pszPropName: Unicode string that names the property
4928 * pValue: address to receive the property value as a 32-bit signed integer
4933 BOOL WINAPI
SHPropertyBag_ReadLONG(IPropertyBag
*ppb
, LPCWSTR pszPropName
, LPLONG pValue
)
4937 TRACE("%p %s %p\n", ppb
,debugstr_w(pszPropName
),pValue
);
4938 if (!pszPropName
|| !ppb
|| !pValue
)
4939 return E_INVALIDARG
;
4941 hr
= IPropertyBag_Read(ppb
, pszPropName
, &var
, NULL
);
4944 if (V_VT(&var
) == VT_I4
)
4945 *pValue
= V_I4(&var
);
4947 hr
= DISP_E_BADVARTYPE
;
4952 /* return flags for SHGetObjectCompatFlags, names derived from registry value names */
4953 #define OBJCOMPAT_OTNEEDSSFCACHE 0x00000001
4954 #define OBJCOMPAT_NO_WEBVIEW 0x00000002
4955 #define OBJCOMPAT_UNBINDABLE 0x00000004
4956 #define OBJCOMPAT_PINDLL 0x00000008
4957 #define OBJCOMPAT_NEEDSFILESYSANCESTOR 0x00000010
4958 #define OBJCOMPAT_NOTAFILESYSTEM 0x00000020
4959 #define OBJCOMPAT_CTXMENU_NOVERBS 0x00000040
4960 #define OBJCOMPAT_CTXMENU_LIMITEDQI 0x00000080
4961 #define OBJCOMPAT_COCREATESHELLFOLDERONLY 0x00000100
4962 #define OBJCOMPAT_NEEDSSTORAGEANCESTOR 0x00000200
4963 #define OBJCOMPAT_NOLEGACYWEBVIEW 0x00000400
4964 #define OBJCOMPAT_CTXMENU_XPQCMFLAGS 0x00001000
4965 #define OBJCOMPAT_NOIPROPERTYSTORE 0x00002000
4967 /* a search table for compatibility flags */
4968 struct objcompat_entry
{
4969 const WCHAR name
[30];
4973 /* expected to be sorted by name */
4974 static const struct objcompat_entry objcompat_table
[] = {
4975 { {'C','O','C','R','E','A','T','E','S','H','E','L','L','F','O','L','D','E','R','O','N','L','Y',0},
4976 OBJCOMPAT_COCREATESHELLFOLDERONLY
},
4977 { {'C','T','X','M','E','N','U','_','L','I','M','I','T','E','D','Q','I',0},
4978 OBJCOMPAT_CTXMENU_LIMITEDQI
},
4979 { {'C','T','X','M','E','N','U','_','N','O','V','E','R','B','S',0},
4980 OBJCOMPAT_CTXMENU_LIMITEDQI
},
4981 { {'C','T','X','M','E','N','U','_','X','P','Q','C','M','F','L','A','G','S',0},
4982 OBJCOMPAT_CTXMENU_XPQCMFLAGS
},
4983 { {'N','E','E','D','S','F','I','L','E','S','Y','S','A','N','C','E','S','T','O','R',0},
4984 OBJCOMPAT_NEEDSFILESYSANCESTOR
},
4985 { {'N','E','E','D','S','S','T','O','R','A','G','E','A','N','C','E','S','T','O','R',0},
4986 OBJCOMPAT_NEEDSSTORAGEANCESTOR
},
4987 { {'N','O','I','P','R','O','P','E','R','T','Y','S','T','O','R','E',0},
4988 OBJCOMPAT_NOIPROPERTYSTORE
},
4989 { {'N','O','L','E','G','A','C','Y','W','E','B','V','I','E','W',0},
4990 OBJCOMPAT_NOLEGACYWEBVIEW
},
4991 { {'N','O','T','A','F','I','L','E','S','Y','S','T','E','M',0},
4992 OBJCOMPAT_NOTAFILESYSTEM
},
4993 { {'N','O','_','W','E','B','V','I','E','W',0},
4994 OBJCOMPAT_NO_WEBVIEW
},
4995 { {'O','T','N','E','E','D','S','S','F','C','A','C','H','E',0},
4996 OBJCOMPAT_OTNEEDSSFCACHE
},
4997 { {'P','I','N','D','L','L',0},
4999 { {'U','N','B','I','N','D','A','B','L','E',0},
5000 OBJCOMPAT_UNBINDABLE
}
5003 /**************************************************************************
5004 * SHGetObjectCompatFlags (SHLWAPI.476)
5006 * Function returns an integer representation of compatibility flags stored
5007 * in registry for CLSID under ShellCompatibility subkey.
5010 * pUnk: pointer to object IUnknown interface, idetifies CLSID
5011 * clsid: pointer to CLSID to retrieve data for
5014 * 0 on failure, flags set on success
5016 DWORD WINAPI
SHGetObjectCompatFlags(IUnknown
*pUnk
, const CLSID
*clsid
)
5018 static const WCHAR compatpathW
[] =
5019 {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o','s','o','f','t','\\',
5020 'W','i','n','d','o','w','s','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
5021 'S','h','e','l','l','C','o','m','p','a','t','i','b','i','l','i','t','y','\\',
5022 'O','b','j','e','c','t','s','\\','%','s',0};
5023 WCHAR strW
[sizeof(compatpathW
)/sizeof(WCHAR
) + 38 /* { CLSID } */];
5024 DWORD ret
, length
= sizeof(strW
)/sizeof(WCHAR
);
5029 TRACE("%p %s\n", pUnk
, debugstr_guid(clsid
));
5031 if (!pUnk
&& !clsid
) return 0;
5035 FIXME("iface not handled\n");
5039 StringFromCLSID(clsid
, &clsid_str
);
5040 sprintfW(strW
, compatpathW
, clsid_str
);
5041 CoTaskMemFree(clsid_str
);
5043 ret
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, strW
, &key
);
5044 if (ret
!= ERROR_SUCCESS
) return 0;
5046 /* now collect flag values */
5048 for (i
= 0; RegEnumValueW(key
, i
, strW
, &length
, NULL
, NULL
, NULL
, NULL
) == ERROR_SUCCESS
; i
++)
5050 INT left
, right
, res
, x
;
5052 /* search in table */
5054 right
= sizeof(objcompat_table
) / sizeof(struct objcompat_entry
) - 1;
5056 while (right
>= left
) {
5057 x
= (left
+ right
) / 2;
5058 res
= strcmpW(strW
, objcompat_table
[x
].name
);
5061 ret
|= objcompat_table
[x
].value
;
5070 length
= sizeof(strW
)/sizeof(WCHAR
);