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
49 #include "wine/unicode.h"
50 #include "wine/debug.h"
53 WINE_DEFAULT_DEBUG_CHANNEL(shell
);
55 /* DLL handles for late bound calls */
56 extern HINSTANCE shlwapi_hInstance
;
57 extern DWORD SHLWAPI_ThreadRef_index
;
59 HRESULT WINAPI
IUnknown_QueryService(IUnknown
*,REFGUID
,REFIID
,LPVOID
*);
60 HRESULT WINAPI
SHInvokeCommand(HWND
,IShellFolder
*,LPCITEMIDLIST
,BOOL
);
61 BOOL WINAPI
SHAboutInfoW(LPWSTR
,DWORD
);
64 NOTES: Most functions exported by ordinal seem to be superflous.
65 The reason for these functions to be there is to provide a wrapper
66 for unicode functions to provide these functions on systems without
67 unicode functions eg. win95/win98. Since we have such functions we just
68 call these. If running Wine with native DLLs, some late bound calls may
69 fail. However, it is better to implement the functions in the forward DLL
70 and recommend the builtin rather than reimplementing the calls here!
73 /*************************************************************************
74 * SHLWAPI_DupSharedHandle
76 * Internal implemetation of SHLWAPI_11.
79 HANDLE WINAPI
SHLWAPI_DupSharedHandle(HANDLE hShared
, DWORD dwDstProcId
,
80 DWORD dwSrcProcId
, DWORD dwAccess
,
84 DWORD dwMyProcId
= GetCurrentProcessId();
87 TRACE("(%p,%d,%d,%08x,%08x)\n", hShared
, dwDstProcId
, dwSrcProcId
,
90 /* Get dest process handle */
91 if (dwDstProcId
== dwMyProcId
)
92 hDst
= GetCurrentProcess();
94 hDst
= OpenProcess(PROCESS_DUP_HANDLE
, 0, dwDstProcId
);
98 /* Get src process handle */
99 if (dwSrcProcId
== dwMyProcId
)
100 hSrc
= GetCurrentProcess();
102 hSrc
= OpenProcess(PROCESS_DUP_HANDLE
, 0, dwSrcProcId
);
106 /* Make handle available to dest process */
107 if (!DuplicateHandle(hDst
, hShared
, hSrc
, &hRet
,
108 dwAccess
, 0, dwOptions
| DUPLICATE_SAME_ACCESS
))
111 if (dwSrcProcId
!= dwMyProcId
)
115 if (dwDstProcId
!= dwMyProcId
)
119 TRACE("Returning handle %p\n", hRet
);
123 /*************************************************************************
126 * Create a block of sharable memory and initialise it with data.
129 * lpvData [I] Pointer to data to write
130 * dwSize [I] Size of data
131 * dwProcId [I] ID of process owning data
134 * Success: A shared memory handle
138 * Ordinals 7-11 provide a set of calls to create shared memory between a
139 * group of processes. The shared memory is treated opaquely in that its size
140 * is not exposed to clients who map it. This is accomplished by storing
141 * the size of the map as the first DWORD of mapped data, and then offsetting
142 * the view pointer returned by this size.
145 HANDLE WINAPI
SHAllocShared(LPCVOID lpvData
, DWORD dwSize
, DWORD dwProcId
)
151 TRACE("(%p,%d,%d)\n", lpvData
, dwSize
, dwProcId
);
153 /* Create file mapping of the correct length */
154 hMap
= CreateFileMappingA(INVALID_HANDLE_VALUE
, NULL
, FILE_MAP_READ
, 0,
155 dwSize
+ sizeof(dwSize
), NULL
);
159 /* Get a view in our process address space */
160 pMapped
= MapViewOfFile(hMap
, FILE_MAP_READ
| FILE_MAP_WRITE
, 0, 0, 0);
164 /* Write size of data, followed by the data, to the view */
165 *((DWORD
*)pMapped
) = dwSize
;
167 memcpy((char *) pMapped
+ sizeof(dwSize
), lpvData
, dwSize
);
169 /* Release view. All further views mapped will be opaque */
170 UnmapViewOfFile(pMapped
);
171 hRet
= SHLWAPI_DupSharedHandle(hMap
, dwProcId
,
172 GetCurrentProcessId(), FILE_MAP_ALL_ACCESS
,
173 DUPLICATE_SAME_ACCESS
);
180 /*************************************************************************
183 * Get a pointer to a block of shared memory from a shared memory handle.
186 * hShared [I] Shared memory handle
187 * dwProcId [I] ID of process owning hShared
190 * Success: A pointer to the shared memory
194 PVOID WINAPI
SHLockShared(HANDLE hShared
, DWORD dwProcId
)
199 TRACE("(%p %d)\n", hShared
, dwProcId
);
201 /* Get handle to shared memory for current process */
202 hDup
= SHLWAPI_DupSharedHandle(hShared
, dwProcId
, GetCurrentProcessId(),
203 FILE_MAP_ALL_ACCESS
, 0);
205 pMapped
= MapViewOfFile(hDup
, FILE_MAP_READ
| FILE_MAP_WRITE
, 0, 0, 0);
209 return (char *) pMapped
+ sizeof(DWORD
); /* Hide size */
213 /*************************************************************************
216 * Release a pointer to a block of shared memory.
219 * lpView [I] Shared memory pointer
226 BOOL WINAPI
SHUnlockShared(LPVOID lpView
)
228 TRACE("(%p)\n", lpView
);
229 return UnmapViewOfFile((char *) lpView
- sizeof(DWORD
)); /* Include size */
232 /*************************************************************************
235 * Destroy a block of sharable memory.
238 * hShared [I] Shared memory handle
239 * dwProcId [I] ID of process owning hShared
246 BOOL WINAPI
SHFreeShared(HANDLE hShared
, DWORD dwProcId
)
250 TRACE("(%p %d)\n", hShared
, dwProcId
);
252 /* Get a copy of the handle for our process, closing the source handle */
253 hClose
= SHLWAPI_DupSharedHandle(hShared
, dwProcId
, GetCurrentProcessId(),
254 FILE_MAP_ALL_ACCESS
,DUPLICATE_CLOSE_SOURCE
);
255 /* Close local copy */
256 return CloseHandle(hClose
);
259 /*************************************************************************
262 * Copy a sharable memory handle from one process to another.
265 * hShared [I] Shared memory handle to duplicate
266 * dwDstProcId [I] ID of the process wanting the duplicated handle
267 * dwSrcProcId [I] ID of the process owning hShared
268 * dwAccess [I] Desired DuplicateHandle() access
269 * dwOptions [I] Desired DuplicateHandle() options
272 * Success: A handle suitable for use by the dwDstProcId process.
273 * Failure: A NULL handle.
276 HANDLE WINAPI
SHMapHandle(HANDLE hShared
, DWORD dwDstProcId
, DWORD dwSrcProcId
,
277 DWORD dwAccess
, DWORD dwOptions
)
281 hRet
= SHLWAPI_DupSharedHandle(hShared
, dwDstProcId
, dwSrcProcId
,
282 dwAccess
, dwOptions
);
286 /*************************************************************************
289 * Create and register a clipboard enumerator for a web browser.
292 * lpBC [I] Binding context
293 * lpUnknown [I] An object exposing the IWebBrowserApp interface
297 * Failure: An HRESULT error code.
300 * The enumerator is stored as a property of the web browser. If it does not
301 * yet exist, it is created and set before being registered.
303 HRESULT WINAPI
RegisterDefaultAcceptHeaders(LPBC lpBC
, IUnknown
*lpUnknown
)
305 static const WCHAR szProperty
[] = { '{','D','0','F','C','A','4','2','0',
306 '-','D','3','F','5','-','1','1','C','F', '-','B','2','1','1','-','0',
307 '0','A','A','0','0','4','A','E','8','3','7','}','\0' };
309 IEnumFORMATETC
* pIEnumFormatEtc
= NULL
;
312 IWebBrowserApp
* pBrowser
= NULL
;
314 TRACE("(%p, %p)\n", lpBC
, lpUnknown
);
316 /* Get An IWebBrowserApp interface from lpUnknown */
317 hRet
= IUnknown_QueryService(lpUnknown
, &IID_IWebBrowserApp
, &IID_IWebBrowserApp
, (PVOID
)&pBrowser
);
318 if (FAILED(hRet
) || !pBrowser
)
319 return E_NOINTERFACE
;
321 V_VT(&var
) = VT_EMPTY
;
323 /* The property we get is the browsers clipboard enumerator */
324 property
= SysAllocString(szProperty
);
325 hRet
= IWebBrowserApp_GetProperty(pBrowser
, property
, &var
);
326 SysFreeString(property
);
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
))
344 /* Get count of values in key */
347 dwKeySize
= sizeof(szKeyBuff
);
348 dwRet
= RegEnumValueA(hDocs
,dwCount
,szKeyBuff
,&dwKeySize
,0,&dwType
,0,0);
352 dwNumValues
= dwCount
;
354 /* Note: dwCount = number of items + 1; The extra item is the end node */
355 format
= formatList
= HeapAlloc(GetProcessHeap(), 0, dwCount
* sizeof(FORMATETC
));
357 return E_OUTOFMEMORY
;
366 /* Register clipboard formats for the values and populate format list */
367 while(!dwRet
&& dwCount
< dwNumValues
)
369 dwKeySize
= sizeof(szKeyBuff
);
370 dwValueSize
= sizeof(szValueBuff
);
371 dwRet
= RegEnumValueA(hDocs
, dwCount
, szKeyBuff
, &dwKeySize
, 0, &dwType
,
372 (PBYTE
)szValueBuff
, &dwValueSize
);
376 format
->cfFormat
= RegisterClipboardFormatA(szValueBuff
);
378 format
->dwAspect
= 1;
387 /* Terminate the (maybe empty) list, last entry has a cfFormat of 0 */
388 format
->cfFormat
= 0;
390 format
->dwAspect
= 1;
394 /* Create a clipboard enumerator */
395 hRet
= CreateFormatEnumerator(dwNumValues
, formatList
, &pIEnumFormatEtc
);
397 if (FAILED(hRet
) || !pIEnumFormatEtc
)
400 /* Set our enumerator as the browsers property */
401 V_VT(&var
) = VT_UNKNOWN
;
402 V_UNKNOWN(&var
) = (IUnknown
*)pIEnumFormatEtc
;
404 hRet
= IWebBrowserApp_PutProperty(pBrowser
, (BSTR
)szProperty
, var
);
407 IEnumFORMATETC_Release(pIEnumFormatEtc
);
408 goto RegisterDefaultAcceptHeaders_Exit
;
412 if (V_VT(&var
) == VT_UNKNOWN
)
414 /* Our variant is holding the clipboard enumerator */
415 IUnknown
* pIUnknown
= V_UNKNOWN(&var
);
416 IEnumFORMATETC
* pClone
= NULL
;
418 TRACE("Retrieved IEnumFORMATETC property\n");
420 /* Get an IEnumFormatEtc interface from the variants value */
421 pIEnumFormatEtc
= NULL
;
422 hRet
= IUnknown_QueryInterface(pIUnknown
, &IID_IEnumFORMATETC
,
423 (PVOID
)&pIEnumFormatEtc
);
424 if (!hRet
&& pIEnumFormatEtc
)
426 /* Clone and register the enumerator */
427 hRet
= IEnumFORMATETC_Clone(pIEnumFormatEtc
, &pClone
);
430 RegisterFormatEnumerator(lpBC
, pClone
, 0);
432 IEnumFORMATETC_Release(pClone
);
435 /* Release the IEnumFormatEtc interface */
436 IEnumFORMATETC_Release(pIUnknown
);
438 IUnknown_Release(V_UNKNOWN(&var
));
441 RegisterDefaultAcceptHeaders_Exit
:
442 IWebBrowserApp_Release(pBrowser
);
446 /*************************************************************************
449 * Get Explorers "AcceptLanguage" setting.
452 * langbuf [O] Destination for language string
453 * buflen [I] Length of langbuf
454 * [0] Success: used length of langbuf
457 * Success: S_OK. langbuf is set to the language string found.
458 * Failure: E_FAIL, If any arguments are invalid, error occurred, or Explorer
459 * does not contain the setting.
460 * E_INVALIDARG, If the buffer is not big enough
462 HRESULT WINAPI
GetAcceptLanguagesW( LPWSTR langbuf
, LPDWORD buflen
)
464 static const WCHAR szkeyW
[] = {
465 'S','o','f','t','w','a','r','e','\\',
466 'M','i','c','r','o','s','o','f','t','\\',
467 'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
468 'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
469 static const WCHAR valueW
[] = {
470 'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
471 static const WCHAR enusW
[] = {'e','n','-','u','s',0};
472 DWORD mystrlen
, mytype
;
478 if(!langbuf
|| !buflen
|| !*buflen
)
481 mystrlen
= (*buflen
> 20) ? *buflen
: 20 ;
482 mystr
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
) * mystrlen
);
483 RegOpenKeyW(HKEY_CURRENT_USER
, szkeyW
, &mykey
);
484 if(RegQueryValueExW(mykey
, valueW
, 0, &mytype
, (PBYTE
)mystr
, &mystrlen
)) {
485 /* Did not find value */
486 mylcid
= GetUserDefaultLCID();
487 /* somehow the mylcid translates into "en-us"
488 * this is similar to "LOCALE_SABBREVLANGNAME"
489 * which could be gotten via GetLocaleInfo.
490 * The only problem is LOCALE_SABBREVLANGUAGE" is
491 * a 3 char string (first 2 are country code and third is
492 * letter for "sublanguage", which does not come close to
495 lstrcpyW(mystr
, enusW
);
496 mystrlen
= lstrlenW(mystr
);
498 /* handle returned string */
499 FIXME("missing code\n");
501 memcpy( langbuf
, mystr
, min(*buflen
,strlenW(mystr
)+1)*sizeof(WCHAR
) );
503 if(*buflen
> strlenW(mystr
)) {
504 *buflen
= strlenW(mystr
);
508 retval
= E_INVALIDARG
;
509 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
512 HeapFree(GetProcessHeap(), 0, mystr
);
516 /*************************************************************************
519 * Ascii version of GetAcceptLanguagesW.
521 HRESULT WINAPI
GetAcceptLanguagesA( LPSTR langbuf
, LPDWORD buflen
)
524 DWORD buflenW
, convlen
;
527 if(!langbuf
|| !buflen
|| !*buflen
) return E_FAIL
;
530 langbufW
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
) * buflenW
);
531 retval
= GetAcceptLanguagesW(langbufW
, &buflenW
);
535 convlen
= WideCharToMultiByte(CP_ACP
, 0, langbufW
, -1, langbuf
, *buflen
, NULL
, NULL
);
537 else /* copy partial string anyway */
539 convlen
= WideCharToMultiByte(CP_ACP
, 0, langbufW
, *buflen
, langbuf
, *buflen
, NULL
, NULL
);
540 if (convlen
< *buflen
) langbuf
[convlen
] = 0;
542 *buflen
= buflenW
? convlen
: 0;
544 HeapFree(GetProcessHeap(), 0, langbufW
);
548 /*************************************************************************
551 * Convert a GUID to a string.
554 * guid [I] GUID to convert
555 * lpszDest [O] Destination for string
556 * cchMax [I] Length of output buffer
559 * The length of the string created.
561 INT WINAPI
SHStringFromGUIDA(REFGUID guid
, LPSTR lpszDest
, INT cchMax
)
566 TRACE("(%s,%p,%d)\n", debugstr_guid(guid
), lpszDest
, cchMax
);
568 sprintf(xguid
, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
569 guid
->Data1
, guid
->Data2
, guid
->Data3
,
570 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
571 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
573 iLen
= strlen(xguid
) + 1;
577 memcpy(lpszDest
, xguid
, iLen
);
581 /*************************************************************************
584 * Convert a GUID to a string.
587 * guid [I] GUID to convert
588 * str [O] Destination for string
589 * cmax [I] Length of output buffer
592 * The length of the string created.
594 INT WINAPI
SHStringFromGUIDW(REFGUID guid
, LPWSTR lpszDest
, INT cchMax
)
598 static const WCHAR wszFormat
[] = {'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
599 '%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
600 'X','%','0','2','X','%','0','2','X','}',0};
602 TRACE("(%s,%p,%d)\n", debugstr_guid(guid
), lpszDest
, cchMax
);
604 sprintfW(xguid
, wszFormat
, guid
->Data1
, guid
->Data2
, guid
->Data3
,
605 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
606 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
608 iLen
= strlenW(xguid
) + 1;
612 memcpy(lpszDest
, xguid
, iLen
*sizeof(WCHAR
));
616 /*************************************************************************
619 * Determine if a Unicode character is a space.
622 * wc [I] Character to check.
625 * TRUE, if wc is a space,
628 BOOL WINAPI
IsCharSpaceW(WCHAR wc
)
632 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_SPACE
);
635 /*************************************************************************
638 * Determine if a Unicode character is a blank.
641 * wc [I] Character to check.
644 * TRUE, if wc is a blank,
648 BOOL WINAPI
IsCharBlankW(WCHAR wc
)
652 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_BLANK
);
655 /*************************************************************************
658 * Determine if a Unicode character is punctuation.
661 * wc [I] Character to check.
664 * TRUE, if wc is punctuation,
667 BOOL WINAPI
IsCharPunctW(WCHAR wc
)
671 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_PUNCT
);
674 /*************************************************************************
677 * Determine if a Unicode character is a control character.
680 * wc [I] Character to check.
683 * TRUE, if wc is a control character,
686 BOOL WINAPI
IsCharCntrlW(WCHAR wc
)
690 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_CNTRL
);
693 /*************************************************************************
696 * Determine if a Unicode character is a digit.
699 * wc [I] Character to check.
702 * TRUE, if wc is a digit,
705 BOOL WINAPI
IsCharDigitW(WCHAR wc
)
709 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_DIGIT
);
712 /*************************************************************************
715 * Determine if a Unicode character is a hex digit.
718 * wc [I] Character to check.
721 * TRUE, if wc is a hex digit,
724 BOOL WINAPI
IsCharXDigitW(WCHAR wc
)
728 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_XDIGIT
);
731 /*************************************************************************
735 BOOL WINAPI
GetStringType3ExW(LPWSTR src
, INT count
, LPWORD type
)
737 return GetStringTypeW(CT_CTYPE3
, src
, count
, type
);
740 /*************************************************************************
743 * Compare two Ascii strings up to a given length.
746 * lpszSrc [I] Source string
747 * lpszCmp [I] String to compare to lpszSrc
748 * len [I] Maximum length
751 * A number greater than, less than or equal to 0 depending on whether
752 * lpszSrc is greater than, less than or equal to lpszCmp.
754 DWORD WINAPI
StrCmpNCA(LPCSTR lpszSrc
, LPCSTR lpszCmp
, INT len
)
756 return StrCmpNA(lpszSrc
, lpszCmp
, len
);
759 /*************************************************************************
762 * Unicode version of StrCmpNCA.
764 DWORD WINAPI
StrCmpNCW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
, INT len
)
766 return StrCmpNW(lpszSrc
, lpszCmp
, len
);
769 /*************************************************************************
772 * Compare two Ascii strings up to a given length, ignoring case.
775 * lpszSrc [I] Source string
776 * lpszCmp [I] String to compare to lpszSrc
777 * len [I] Maximum length
780 * A number greater than, less than or equal to 0 depending on whether
781 * lpszSrc is greater than, less than or equal to lpszCmp.
783 DWORD WINAPI
StrCmpNICA(LPCSTR lpszSrc
, LPCSTR lpszCmp
, DWORD len
)
785 return StrCmpNIA(lpszSrc
, lpszCmp
, len
);
788 /*************************************************************************
791 * Unicode version of StrCmpNICA.
793 DWORD WINAPI
StrCmpNICW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
, DWORD len
)
795 return StrCmpNIW(lpszSrc
, lpszCmp
, len
);
798 /*************************************************************************
801 * Compare two Ascii strings.
804 * lpszSrc [I] Source string
805 * lpszCmp [I] String to compare to lpszSrc
808 * A number greater than, less than or equal to 0 depending on whether
809 * lpszSrc is greater than, less than or equal to lpszCmp.
811 DWORD WINAPI
StrCmpCA(LPCSTR lpszSrc
, LPCSTR lpszCmp
)
813 return lstrcmpA(lpszSrc
, lpszCmp
);
816 /*************************************************************************
819 * Unicode version of StrCmpCA.
821 DWORD WINAPI
StrCmpCW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
)
823 return lstrcmpW(lpszSrc
, lpszCmp
);
826 /*************************************************************************
829 * Compare two Ascii strings, ignoring case.
832 * lpszSrc [I] Source string
833 * lpszCmp [I] String to compare to lpszSrc
836 * A number greater than, less than or equal to 0 depending on whether
837 * lpszSrc is greater than, less than or equal to lpszCmp.
839 DWORD WINAPI
StrCmpICA(LPCSTR lpszSrc
, LPCSTR lpszCmp
)
841 return lstrcmpiA(lpszSrc
, lpszCmp
);
844 /*************************************************************************
847 * Unicode version of StrCmpICA.
849 DWORD WINAPI
StrCmpICW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
)
851 return lstrcmpiW(lpszSrc
, lpszCmp
);
854 /*************************************************************************
857 * Get an identification string for the OS and explorer.
860 * lpszDest [O] Destination for Id string
861 * dwDestLen [I] Length of lpszDest
864 * TRUE, If the string was created successfully
867 BOOL WINAPI
SHAboutInfoA(LPSTR lpszDest
, DWORD dwDestLen
)
871 TRACE("(%p,%d)\n", lpszDest
, dwDestLen
);
873 if (lpszDest
&& SHAboutInfoW(buff
, dwDestLen
))
875 WideCharToMultiByte(CP_ACP
, 0, buff
, -1, lpszDest
, dwDestLen
, NULL
, NULL
);
881 /*************************************************************************
884 * Unicode version of SHAboutInfoA.
886 BOOL WINAPI
SHAboutInfoW(LPWSTR lpszDest
, DWORD dwDestLen
)
888 static const WCHAR szIEKey
[] = { 'S','O','F','T','W','A','R','E','\\',
889 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
890 ' ','E','x','p','l','o','r','e','r','\0' };
891 static const WCHAR szWinNtKey
[] = { 'S','O','F','T','W','A','R','E','\\',
892 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ',
893 'N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
894 static const WCHAR szWinKey
[] = { 'S','O','F','T','W','A','R','E','\\',
895 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
896 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
897 static const WCHAR szRegKey
[] = { 'S','O','F','T','W','A','R','E','\\',
898 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
899 ' ','E','x','p','l','o','r','e','r','\\',
900 'R','e','g','i','s','t','r','a','t','i','o','n','\0' };
901 static const WCHAR szVersion
[] = { 'V','e','r','s','i','o','n','\0' };
902 static const WCHAR szCustomized
[] = { 'C','u','s','t','o','m','i','z','e','d',
903 'V','e','r','s','i','o','n','\0' };
904 static const WCHAR szOwner
[] = { 'R','e','g','i','s','t','e','r','e','d',
905 'O','w','n','e','r','\0' };
906 static const WCHAR szOrg
[] = { 'R','e','g','i','s','t','e','r','e','d',
907 'O','r','g','a','n','i','z','a','t','i','o','n','\0' };
908 static const WCHAR szProduct
[] = { 'P','r','o','d','u','c','t','I','d','\0' };
909 static const WCHAR szUpdate
[] = { 'I','E','A','K',
910 'U','p','d','a','t','e','U','r','l','\0' };
911 static const WCHAR szHelp
[] = { 'I','E','A','K',
912 'H','e','l','p','S','t','r','i','n','g','\0' };
917 TRACE("(%p,%d)\n", lpszDest
, dwDestLen
);
924 /* Try the NT key first, followed by 95/98 key */
925 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE
, szWinNtKey
, 0, KEY_READ
, &hReg
) &&
926 RegOpenKeyExW(HKEY_LOCAL_MACHINE
, szWinKey
, 0, KEY_READ
, &hReg
))
932 if (!SHGetValueW(HKEY_LOCAL_MACHINE
, szIEKey
, szVersion
, &dwType
, buff
, &dwLen
))
934 DWORD dwStrLen
= strlenW(buff
);
935 dwLen
= 30 - dwStrLen
;
936 SHGetValueW(HKEY_LOCAL_MACHINE
, szIEKey
,
937 szCustomized
, &dwType
, buff
+dwStrLen
, &dwLen
);
939 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
941 /* ~Registered Owner */
944 if (SHGetValueW(hReg
, szOwner
, 0, &dwType
, buff
+1, &dwLen
))
946 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
948 /* ~Registered Organization */
950 if (SHGetValueW(hReg
, szOrg
, 0, &dwType
, buff
+1, &dwLen
))
952 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
954 /* FIXME: Not sure where this number comes from */
958 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
962 if (SHGetValueW(HKEY_LOCAL_MACHINE
, szRegKey
, szProduct
, &dwType
, buff
+1, &dwLen
))
964 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
968 if(SHGetValueW(HKEY_LOCAL_MACHINE
, szWinKey
, szUpdate
, &dwType
, buff
+1, &dwLen
))
970 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
972 /* ~IE Help String */
974 if(SHGetValueW(hReg
, szHelp
, 0, &dwType
, buff
+1, &dwLen
))
976 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
982 /*************************************************************************
985 * Call IOleCommandTarget_QueryStatus() on an object.
988 * lpUnknown [I] Object supporting the IOleCommandTarget interface
989 * pguidCmdGroup [I] GUID for the command group
991 * prgCmds [O] Commands
992 * pCmdText [O] Command text
996 * Failure: E_FAIL, if lpUnknown is NULL.
997 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
998 * Otherwise, an error code from IOleCommandTarget_QueryStatus().
1000 HRESULT WINAPI
IUnknown_QueryStatus(IUnknown
* lpUnknown
, REFGUID pguidCmdGroup
,
1001 ULONG cCmds
, OLECMD
*prgCmds
, OLECMDTEXT
* pCmdText
)
1003 HRESULT hRet
= E_FAIL
;
1005 TRACE("(%p,%p,%d,%p,%p)\n",lpUnknown
, pguidCmdGroup
, cCmds
, prgCmds
, pCmdText
);
1009 IOleCommandTarget
* lpOle
;
1011 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleCommandTarget
,
1014 if (SUCCEEDED(hRet
) && lpOle
)
1016 hRet
= IOleCommandTarget_QueryStatus(lpOle
, pguidCmdGroup
, cCmds
,
1018 IOleCommandTarget_Release(lpOle
);
1024 /*************************************************************************
1027 * Call IOleCommandTarget_Exec() on an object.
1030 * lpUnknown [I] Object supporting the IOleCommandTarget interface
1031 * pguidCmdGroup [I] GUID for the command group
1035 * Failure: E_FAIL, if lpUnknown is NULL.
1036 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
1037 * Otherwise, an error code from IOleCommandTarget_Exec().
1039 HRESULT WINAPI
IUnknown_Exec(IUnknown
* lpUnknown
, REFGUID pguidCmdGroup
,
1040 DWORD nCmdID
, DWORD nCmdexecopt
, VARIANT
* pvaIn
,
1043 HRESULT hRet
= E_FAIL
;
1045 TRACE("(%p,%p,%d,%d,%p,%p)\n",lpUnknown
, pguidCmdGroup
, nCmdID
,
1046 nCmdexecopt
, pvaIn
, pvaOut
);
1050 IOleCommandTarget
* lpOle
;
1052 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleCommandTarget
,
1054 if (SUCCEEDED(hRet
) && lpOle
)
1056 hRet
= IOleCommandTarget_Exec(lpOle
, pguidCmdGroup
, nCmdID
,
1057 nCmdexecopt
, pvaIn
, pvaOut
);
1058 IOleCommandTarget_Release(lpOle
);
1064 /*************************************************************************
1067 * Retrieve, modify, and re-set a value from a window.
1070 * hWnd [I] Window to get value from
1071 * offset [I] Offset of value
1072 * wMask [I] Mask for uiFlags
1073 * wFlags [I] Bits to set in window value
1076 * The new value as it was set, or 0 if any parameter is invalid.
1079 * Any bits set in uiMask are cleared from the value, then any bits set in
1080 * uiFlags are set in the value.
1082 LONG WINAPI
SHSetWindowBits(HWND hwnd
, INT offset
, UINT wMask
, UINT wFlags
)
1084 LONG ret
= GetWindowLongA(hwnd
, offset
);
1085 LONG newFlags
= (wFlags
& wMask
) | (ret
& ~wFlags
);
1087 if (newFlags
!= ret
)
1088 ret
= SetWindowLongA(hwnd
, offset
, newFlags
);
1092 /*************************************************************************
1095 * Change a window's parent.
1098 * hWnd [I] Window to change parent of
1099 * hWndParent [I] New parent window
1102 * The old parent of hWnd.
1105 * If hWndParent is NULL (desktop), the window style is changed to WS_POPUP.
1106 * If hWndParent is NOT NULL then we set the WS_CHILD style.
1108 HWND WINAPI
SHSetParentHwnd(HWND hWnd
, HWND hWndParent
)
1110 TRACE("%p, %p\n", hWnd
, hWndParent
);
1112 if(GetParent(hWnd
) == hWndParent
)
1116 SHSetWindowBits(hWnd
, GWL_STYLE
, WS_CHILD
, WS_CHILD
);
1118 SHSetWindowBits(hWnd
, GWL_STYLE
, WS_POPUP
, WS_POPUP
);
1120 return SetParent(hWnd
, hWndParent
);
1123 /*************************************************************************
1126 * Locate and advise a connection point in an IConnectionPointContainer object.
1129 * lpUnkSink [I] Sink for the connection point advise call
1130 * riid [I] REFIID of connection point to advise
1131 * bAdviseOnly [I] TRUE = Advise only, FALSE = Unadvise first
1132 * lpUnknown [I] Object supporting the IConnectionPointContainer interface
1133 * lpCookie [O] Pointer to connection point cookie
1134 * lppCP [O] Destination for the IConnectionPoint found
1137 * Success: S_OK. If lppCP is non-NULL, it is filled with the IConnectionPoint
1138 * that was advised. The caller is responsible for releasing it.
1139 * Failure: E_FAIL, if any arguments are invalid.
1140 * E_NOINTERFACE, if lpUnknown isn't an IConnectionPointContainer,
1141 * Or an HRESULT error code if any call fails.
1143 HRESULT WINAPI
ConnectToConnectionPoint(IUnknown
* lpUnkSink
, REFIID riid
, BOOL bAdviseOnly
,
1144 IUnknown
* lpUnknown
, LPDWORD lpCookie
,
1145 IConnectionPoint
**lppCP
)
1148 IConnectionPointContainer
* lpContainer
;
1149 IConnectionPoint
*lpCP
;
1151 if(!lpUnknown
|| (bAdviseOnly
&& !lpUnkSink
))
1157 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IConnectionPointContainer
,
1158 (void**)&lpContainer
);
1159 if (SUCCEEDED(hRet
))
1161 hRet
= IConnectionPointContainer_FindConnectionPoint(lpContainer
, riid
, &lpCP
);
1163 if (SUCCEEDED(hRet
))
1166 hRet
= IConnectionPoint_Unadvise(lpCP
, *lpCookie
);
1167 hRet
= IConnectionPoint_Advise(lpCP
, lpUnkSink
, lpCookie
);
1172 if (lppCP
&& SUCCEEDED(hRet
))
1173 *lppCP
= lpCP
; /* Caller keeps the interface */
1175 IConnectionPoint_Release(lpCP
); /* Release it */
1178 IUnknown_Release(lpContainer
);
1183 /*************************************************************************
1186 * Release an interface.
1189 * lpUnknown [I] Object to release
1194 DWORD WINAPI
IUnknown_AtomicRelease(IUnknown
** lpUnknown
)
1198 TRACE("(%p)\n",lpUnknown
);
1200 if(!lpUnknown
|| !*((LPDWORD
)lpUnknown
)) return 0;
1204 TRACE("doing Release\n");
1206 return IUnknown_Release(temp
);
1209 /*************************************************************************
1212 * Skip '//' if present in a string.
1215 * lpszSrc [I] String to check for '//'
1218 * Success: The next character after the '//' or the string if not present
1219 * Failure: NULL, if lpszStr is NULL.
1221 LPCSTR WINAPI
PathSkipLeadingSlashesA(LPCSTR lpszSrc
)
1223 if (lpszSrc
&& lpszSrc
[0] == '/' && lpszSrc
[1] == '/')
1228 /*************************************************************************
1231 * Check if two interfaces come from the same object.
1234 * lpInt1 [I] Interface to check against lpInt2.
1235 * lpInt2 [I] Interface to check against lpInt1.
1238 * TRUE, If the interfaces come from the same object.
1241 BOOL WINAPI
SHIsSameObject(IUnknown
* lpInt1
, IUnknown
* lpInt2
)
1243 LPVOID lpUnknown1
, lpUnknown2
;
1245 TRACE("%p %p\n", lpInt1
, lpInt2
);
1247 if (!lpInt1
|| !lpInt2
)
1250 if (lpInt1
== lpInt2
)
1253 if (!SUCCEEDED(IUnknown_QueryInterface(lpInt1
, &IID_IUnknown
,
1254 (LPVOID
*)&lpUnknown1
)))
1257 if (!SUCCEEDED(IUnknown_QueryInterface(lpInt2
, &IID_IUnknown
,
1258 (LPVOID
*)&lpUnknown2
)))
1261 if (lpUnknown1
== lpUnknown2
)
1267 /*************************************************************************
1270 * Get the window handle of an object.
1273 * lpUnknown [I] Object to get the window handle of
1274 * lphWnd [O] Destination for window handle
1277 * Success: S_OK. lphWnd contains the objects window handle.
1278 * Failure: An HRESULT error code.
1281 * lpUnknown is expected to support one of the following interfaces:
1282 * IOleWindow(), IInternetSecurityMgrSite(), or IShellView().
1284 HRESULT WINAPI
IUnknown_GetWindow(IUnknown
*lpUnknown
, HWND
*lphWnd
)
1286 /* FIXME: Wine has no header for this object */
1287 static const GUID IID_IInternetSecurityMgrSite
= { 0x79eac9ed,
1288 0xbaf9, 0x11ce, { 0x8c, 0x82, 0x00, 0xaa, 0x00, 0x4b, 0xa9, 0x0b }};
1290 HRESULT hRet
= E_FAIL
;
1292 TRACE("(%p,%p)\n", lpUnknown
, lphWnd
);
1297 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleWindow
, (void**)&lpOle
);
1301 hRet
= IUnknown_QueryInterface(lpUnknown
,&IID_IShellView
, (void**)&lpOle
);
1305 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInternetSecurityMgrSite
,
1310 if (SUCCEEDED(hRet
))
1312 /* Lazyness here - Since GetWindow() is the first method for the above 3
1313 * interfaces, we use the same call for them all.
1315 hRet
= IOleWindow_GetWindow((IOleWindow
*)lpOle
, lphWnd
);
1316 IUnknown_Release(lpOle
);
1318 TRACE("Returning HWND=%p\n", *lphWnd
);
1324 /*************************************************************************
1327 * Call a method on as as yet unidentified object.
1330 * pUnk [I] Object supporting the unidentified interface,
1331 * arg [I] Argument for the call on the object.
1336 HRESULT WINAPI
IUnknown_SetOwner(IUnknown
*pUnk
, ULONG arg
)
1338 static const GUID guid_173
= {
1339 0x5836fb00, 0x8187, 0x11cf, { 0xa1,0x2b,0x00,0xaa,0x00,0x4a,0xe8,0x37 }
1343 TRACE("(%p,%d)\n", pUnk
, arg
);
1345 /* Note: arg may not be a ULONG and pUnk2 is for sure not an IMalloc -
1346 * We use this interface as its vtable entry is compatible with the
1347 * object in question.
1348 * FIXME: Find out what this object is and where it should be defined.
1351 SUCCEEDED(IUnknown_QueryInterface(pUnk
, &guid_173
, (void**)&pUnk2
)))
1353 IMalloc_Alloc(pUnk2
, arg
); /* Faked call!! */
1354 IMalloc_Release(pUnk2
);
1359 /*************************************************************************
1362 * Call either IObjectWithSite_SetSite() or IInternetSecurityManager_SetSecuritySite() on
1366 HRESULT WINAPI
IUnknown_SetSite(
1367 IUnknown
*obj
, /* [in] OLE object */
1368 IUnknown
*site
) /* [in] Site interface */
1371 IObjectWithSite
*iobjwithsite
;
1372 IInternetSecurityManager
*isecmgr
;
1374 if (!obj
) return E_FAIL
;
1376 hr
= IUnknown_QueryInterface(obj
, &IID_IObjectWithSite
, (LPVOID
*)&iobjwithsite
);
1377 TRACE("IID_IObjectWithSite QI ret=%08x, %p\n", hr
, iobjwithsite
);
1380 hr
= IObjectWithSite_SetSite(iobjwithsite
, site
);
1381 TRACE("done IObjectWithSite_SetSite ret=%08x\n", hr
);
1382 IUnknown_Release(iobjwithsite
);
1386 hr
= IUnknown_QueryInterface(obj
, &IID_IInternetSecurityManager
, (LPVOID
*)&isecmgr
);
1387 TRACE("IID_IInternetSecurityManager QI ret=%08x, %p\n", hr
, isecmgr
);
1388 if (FAILED(hr
)) return hr
;
1390 hr
= IInternetSecurityManager_SetSecuritySite(isecmgr
, (IInternetSecurityMgrSite
*)site
);
1391 TRACE("done IInternetSecurityManager_SetSecuritySite ret=%08x\n", hr
);
1392 IUnknown_Release(isecmgr
);
1397 /*************************************************************************
1400 * Call IPersist_GetClassID() on an object.
1403 * lpUnknown [I] Object supporting the IPersist interface
1404 * lpClassId [O] Destination for Class Id
1407 * Success: S_OK. lpClassId contains the Class Id requested.
1408 * Failure: E_FAIL, If lpUnknown is NULL,
1409 * E_NOINTERFACE If lpUnknown does not support IPersist,
1410 * Or an HRESULT error code.
1412 HRESULT WINAPI
IUnknown_GetClassID(IUnknown
*lpUnknown
, CLSID
* lpClassId
)
1414 IPersist
* lpPersist
;
1415 HRESULT hRet
= E_FAIL
;
1417 TRACE("(%p,%p)\n", lpUnknown
, debugstr_guid(lpClassId
));
1421 hRet
= IUnknown_QueryInterface(lpUnknown
,&IID_IPersist
,(void**)&lpPersist
);
1422 if (SUCCEEDED(hRet
))
1424 IPersist_GetClassID(lpPersist
, lpClassId
);
1425 IPersist_Release(lpPersist
);
1431 /*************************************************************************
1434 * Retrieve a Service Interface from an object.
1437 * lpUnknown [I] Object to get an IServiceProvider interface from
1438 * sid [I] Service ID for IServiceProvider_QueryService() call
1439 * riid [I] Function requested for QueryService call
1440 * lppOut [O] Destination for the service interface pointer
1443 * Success: S_OK. lppOut contains an object providing the requested service
1444 * Failure: An HRESULT error code
1447 * lpUnknown is expected to support the IServiceProvider interface.
1449 HRESULT WINAPI
IUnknown_QueryService(IUnknown
* lpUnknown
, REFGUID sid
, REFIID riid
,
1452 IServiceProvider
* pService
= NULL
;
1463 /* Get an IServiceProvider interface from the object */
1464 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IServiceProvider
,
1465 (LPVOID
*)&pService
);
1467 if (!hRet
&& pService
)
1469 TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService
);
1471 /* Get a Service interface from the object */
1472 hRet
= IServiceProvider_QueryService(pService
, sid
, riid
, lppOut
);
1474 TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService
, *lppOut
);
1476 /* Release the IServiceProvider interface */
1477 IUnknown_Release(pService
);
1482 /*************************************************************************
1485 * Loads a popup menu.
1488 * hInst [I] Instance handle
1489 * szName [I] Menu name
1495 BOOL WINAPI
SHLoadMenuPopup(HINSTANCE hInst
, LPCWSTR szName
)
1497 HMENU hMenu
, hSubMenu
;
1499 if ((hMenu
= LoadMenuW(hInst
, szName
)))
1501 if ((hSubMenu
= GetSubMenu(hMenu
, 0)))
1502 RemoveMenu(hMenu
, 0, MF_BYPOSITION
);
1510 typedef struct _enumWndData
1515 LRESULT (WINAPI
*pfnPost
)(HWND
,UINT
,WPARAM
,LPARAM
);
1518 /* Callback for SHLWAPI_178 */
1519 static BOOL CALLBACK
SHLWAPI_EnumChildProc(HWND hWnd
, LPARAM lParam
)
1521 enumWndData
*data
= (enumWndData
*)lParam
;
1523 TRACE("(%p,%p)\n", hWnd
, data
);
1524 data
->pfnPost(hWnd
, data
->uiMsgId
, data
->wParam
, data
->lParam
);
1528 /*************************************************************************
1531 * Send or post a message to every child of a window.
1534 * hWnd [I] Window whose children will get the messages
1535 * uiMsgId [I] Message Id
1536 * wParam [I] WPARAM of message
1537 * lParam [I] LPARAM of message
1538 * bSend [I] TRUE = Use SendMessageA(), FALSE = Use PostMessageA()
1544 * The appropriate ASCII or Unicode function is called for the window.
1546 void WINAPI
SHPropagateMessage(HWND hWnd
, UINT uiMsgId
, WPARAM wParam
, LPARAM lParam
, BOOL bSend
)
1550 TRACE("(%p,%u,%ld,%ld,%d)\n", hWnd
, uiMsgId
, wParam
, lParam
, bSend
);
1554 data
.uiMsgId
= uiMsgId
;
1555 data
.wParam
= wParam
;
1556 data
.lParam
= lParam
;
1559 data
.pfnPost
= IsWindowUnicode(hWnd
) ? (void*)SendMessageW
: (void*)SendMessageA
;
1561 data
.pfnPost
= IsWindowUnicode(hWnd
) ? (void*)PostMessageW
: (void*)PostMessageA
;
1563 EnumChildWindows(hWnd
, SHLWAPI_EnumChildProc
, (LPARAM
)&data
);
1567 /*************************************************************************
1570 * Remove all sub-menus from a menu.
1573 * hMenu [I] Menu to remove sub-menus from
1576 * Success: 0. All sub-menus under hMenu are removed
1577 * Failure: -1, if any parameter is invalid
1579 DWORD WINAPI
SHRemoveAllSubMenus(HMENU hMenu
)
1581 int iItemCount
= GetMenuItemCount(hMenu
) - 1;
1582 while (iItemCount
>= 0)
1584 HMENU hSubMenu
= GetSubMenu(hMenu
, iItemCount
);
1586 RemoveMenu(hMenu
, iItemCount
, MF_BYPOSITION
);
1592 /*************************************************************************
1595 * Enable or disable a menu item.
1598 * hMenu [I] Menu holding menu item
1599 * uID [I] ID of menu item to enable/disable
1600 * bEnable [I] Whether to enable (TRUE) or disable (FALSE) the item.
1603 * The return code from EnableMenuItem.
1605 UINT WINAPI
SHEnableMenuItem(HMENU hMenu
, UINT wItemID
, BOOL bEnable
)
1607 return EnableMenuItem(hMenu
, wItemID
, bEnable
? MF_ENABLED
: MF_GRAYED
);
1610 /*************************************************************************
1613 * Check or uncheck a menu item.
1616 * hMenu [I] Menu holding menu item
1617 * uID [I] ID of menu item to check/uncheck
1618 * bCheck [I] Whether to check (TRUE) or uncheck (FALSE) the item.
1621 * The return code from CheckMenuItem.
1623 DWORD WINAPI
SHCheckMenuItem(HMENU hMenu
, UINT uID
, BOOL bCheck
)
1625 return CheckMenuItem(hMenu
, uID
, bCheck
? MF_CHECKED
: MF_UNCHECKED
);
1628 /*************************************************************************
1631 * Register a window class if it isn't already.
1634 * lpWndClass [I] Window class to register
1637 * The result of the RegisterClassA call.
1639 DWORD WINAPI
SHRegisterClassA(WNDCLASSA
*wndclass
)
1642 if (GetClassInfoA(wndclass
->hInstance
, wndclass
->lpszClassName
, &wca
))
1644 return (DWORD
)RegisterClassA(wndclass
);
1647 /*************************************************************************
1650 BOOL WINAPI
SHSimulateDrop(IDropTarget
*pDrop
, IDataObject
*pDataObj
,
1651 DWORD grfKeyState
, PPOINTL lpPt
, DWORD
* pdwEffect
)
1653 DWORD dwEffect
= DROPEFFECT_LINK
| DROPEFFECT_MOVE
| DROPEFFECT_COPY
;
1654 POINTL pt
= { 0, 0 };
1660 pdwEffect
= &dwEffect
;
1662 IDropTarget_DragEnter(pDrop
, pDataObj
, grfKeyState
, *lpPt
, pdwEffect
);
1665 return IDropTarget_Drop(pDrop
, pDataObj
, grfKeyState
, *lpPt
, pdwEffect
);
1667 IDropTarget_DragLeave(pDrop
);
1671 /*************************************************************************
1674 * Call IPersistPropertyBag_Load() on an object.
1677 * lpUnknown [I] Object supporting the IPersistPropertyBag interface
1678 * lpPropBag [O] Destination for loaded IPropertyBag
1682 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1684 DWORD WINAPI
SHLoadFromPropertyBag(IUnknown
*lpUnknown
, IPropertyBag
* lpPropBag
)
1686 IPersistPropertyBag
* lpPPBag
;
1687 HRESULT hRet
= E_FAIL
;
1689 TRACE("(%p,%p)\n", lpUnknown
, lpPropBag
);
1693 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IPersistPropertyBag
,
1695 if (SUCCEEDED(hRet
) && lpPPBag
)
1697 hRet
= IPersistPropertyBag_Load(lpPPBag
, lpPropBag
, NULL
);
1698 IPersistPropertyBag_Release(lpPPBag
);
1704 /*************************************************************************
1707 * Call IOleControlSite_TranslateAccelerator() on an object.
1710 * lpUnknown [I] Object supporting the IOleControlSite interface.
1711 * lpMsg [I] Key message to be processed.
1712 * dwModifiers [I] Flags containing the state of the modifier keys.
1716 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
1718 HRESULT WINAPI
IUnknown_TranslateAcceleratorOCS(IUnknown
*lpUnknown
, LPMSG lpMsg
, DWORD dwModifiers
)
1720 IOleControlSite
* lpCSite
= NULL
;
1721 HRESULT hRet
= E_INVALIDARG
;
1723 TRACE("(%p,%p,0x%08x)\n", lpUnknown
, lpMsg
, dwModifiers
);
1726 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleControlSite
,
1728 if (SUCCEEDED(hRet
) && lpCSite
)
1730 hRet
= IOleControlSite_TranslateAccelerator(lpCSite
, lpMsg
, dwModifiers
);
1731 IOleControlSite_Release(lpCSite
);
1738 /*************************************************************************
1741 * Call IOleControlSite_OnFocus() on an object.
1744 * lpUnknown [I] Object supporting the IOleControlSite interface.
1745 * fGotFocus [I] Whether focus was gained (TRUE) or lost (FALSE).
1749 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1751 HRESULT WINAPI
IUnknown_OnFocusOCS(IUnknown
*lpUnknown
, BOOL fGotFocus
)
1753 IOleControlSite
* lpCSite
= NULL
;
1754 HRESULT hRet
= E_FAIL
;
1756 TRACE("(%p,%s)\n", lpUnknown
, fGotFocus
? "TRUE" : "FALSE");
1759 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleControlSite
,
1761 if (SUCCEEDED(hRet
) && lpCSite
)
1763 hRet
= IOleControlSite_OnFocus(lpCSite
, fGotFocus
);
1764 IOleControlSite_Release(lpCSite
);
1770 /*************************************************************************
1773 HRESULT WINAPI
IUnknown_HandleIRestrict(LPUNKNOWN lpUnknown
, PVOID lpArg1
,
1774 PVOID lpArg2
, PVOID lpArg3
, PVOID lpArg4
)
1776 /* FIXME: {D12F26B2-D90A-11D0-830D-00AA005B4383} - What object does this represent? */
1777 static const DWORD service_id
[] = { 0xd12f26b2, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1778 /* FIXME: {D12F26B1-D90A-11D0-830D-00AA005B4383} - Also Unknown/undocumented */
1779 static const DWORD function_id
[] = { 0xd12f26b1, 0x11d0d90a, 0xaa000d83, 0x83435b00 };
1780 HRESULT hRet
= E_INVALIDARG
;
1781 LPUNKNOWN lpUnkInner
= NULL
; /* FIXME: Real type is unknown */
1783 TRACE("(%p,%p,%p,%p,%p)\n", lpUnknown
, lpArg1
, lpArg2
, lpArg3
, lpArg4
);
1785 if (lpUnknown
&& lpArg4
)
1787 hRet
= IUnknown_QueryService(lpUnknown
, (REFGUID
)service_id
,
1788 (REFGUID
)function_id
, (void**)&lpUnkInner
);
1790 if (SUCCEEDED(hRet
) && lpUnkInner
)
1792 /* FIXME: The type of service object requested is unknown, however
1793 * testing shows that its first method is called with 4 parameters.
1794 * Fake this by using IParseDisplayName_ParseDisplayName since the
1795 * signature and position in the vtable matches our unknown object type.
1797 hRet
= IParseDisplayName_ParseDisplayName((LPPARSEDISPLAYNAME
)lpUnkInner
,
1798 lpArg1
, lpArg2
, lpArg3
, lpArg4
);
1799 IUnknown_Release(lpUnkInner
);
1805 /*************************************************************************
1808 * Get a sub-menu from a menu item.
1811 * hMenu [I] Menu to get sub-menu from
1812 * uID [I] ID of menu item containing sub-menu
1815 * The sub-menu of the item, or a NULL handle if any parameters are invalid.
1817 HMENU WINAPI
SHGetMenuFromID(HMENU hMenu
, UINT uID
)
1821 TRACE("(%p,%u)\n", hMenu
, uID
);
1823 mi
.cbSize
= sizeof(mi
);
1824 mi
.fMask
= MIIM_SUBMENU
;
1826 if (!GetMenuItemInfoW(hMenu
, uID
, FALSE
, &mi
))
1832 /*************************************************************************
1835 * Get the color depth of the primary display.
1841 * The color depth of the primary display.
1843 DWORD WINAPI
SHGetCurColorRes(void)
1851 ret
= GetDeviceCaps(hdc
, BITSPIXEL
) * GetDeviceCaps(hdc
, PLANES
);
1856 /*************************************************************************
1859 * Wait for a message to arrive, with a timeout.
1862 * hand [I] Handle to query
1863 * dwTimeout [I] Timeout in ticks or INFINITE to never timeout
1866 * STATUS_TIMEOUT if no message is received before dwTimeout ticks passes.
1867 * Otherwise returns the value from MsgWaitForMultipleObjectsEx when a
1868 * message is available.
1870 DWORD WINAPI
SHWaitForSendMessageThread(HANDLE hand
, DWORD dwTimeout
)
1872 DWORD dwEndTicks
= GetTickCount() + dwTimeout
;
1875 while ((dwRet
= MsgWaitForMultipleObjectsEx(1, &hand
, dwTimeout
, QS_SENDMESSAGE
, 0)) == 1)
1879 PeekMessageW(&msg
, NULL
, 0, 0, PM_NOREMOVE
);
1881 if (dwTimeout
!= INFINITE
)
1883 if ((int)(dwTimeout
= dwEndTicks
- GetTickCount()) <= 0)
1884 return WAIT_TIMEOUT
;
1891 /*************************************************************************
1894 * Determine if a shell folder can be expanded.
1897 * lpFolder [I] Parent folder containing the object to test.
1898 * pidl [I] Id of the object to test.
1901 * Success: S_OK, if the object is expandable, S_FALSE otherwise.
1902 * Failure: E_INVALIDARG, if any argument is invalid.
1905 * If the object to be tested does not expose the IQueryInfo() interface it
1906 * will not be identified as an expandable folder.
1908 HRESULT WINAPI
SHIsExpandableFolder(LPSHELLFOLDER lpFolder
, LPCITEMIDLIST pidl
)
1910 HRESULT hRet
= E_INVALIDARG
;
1913 if (lpFolder
&& pidl
)
1915 hRet
= IShellFolder_GetUIObjectOf(lpFolder
, NULL
, 1, &pidl
, &IID_IQueryInfo
,
1916 NULL
, (void**)&lpInfo
);
1918 hRet
= S_FALSE
; /* Doesn't expose IQueryInfo */
1923 /* MSDN states of IQueryInfo_GetInfoFlags() that "This method is not
1924 * currently used". Really? You wouldn't be holding out on me would you?
1926 hRet
= IQueryInfo_GetInfoFlags(lpInfo
, &dwFlags
);
1928 if (SUCCEEDED(hRet
))
1930 /* 0x2 is an undocumented flag apparently indicating expandability */
1931 hRet
= dwFlags
& 0x2 ? S_OK
: S_FALSE
;
1934 IQueryInfo_Release(lpInfo
);
1940 /*************************************************************************
1943 * Blank out a region of text by drawing the background only.
1946 * hDC [I] Device context to draw in
1947 * pRect [I] Area to draw in
1948 * cRef [I] Color to draw in
1953 DWORD WINAPI
SHFillRectClr(HDC hDC
, LPCRECT pRect
, COLORREF cRef
)
1955 COLORREF cOldColor
= SetBkColor(hDC
, cRef
);
1956 ExtTextOutA(hDC
, 0, 0, ETO_OPAQUE
, pRect
, 0, 0, 0);
1957 SetBkColor(hDC
, cOldColor
);
1961 /*************************************************************************
1964 * Return the value asociated with a key in a map.
1967 * lpKeys [I] A list of keys of length iLen
1968 * lpValues [I] A list of values associated with lpKeys, of length iLen
1969 * iLen [I] Length of both lpKeys and lpValues
1970 * iKey [I] The key value to look up in lpKeys
1973 * The value in lpValues associated with iKey, or -1 if iKey is not
1977 * - If two elements in the map share the same key, this function returns
1978 * the value closest to the start of the map
1979 * - The native version of this function crashes if lpKeys or lpValues is NULL.
1981 int WINAPI
SHSearchMapInt(const int *lpKeys
, const int *lpValues
, int iLen
, int iKey
)
1983 if (lpKeys
&& lpValues
)
1989 if (lpKeys
[i
] == iKey
)
1990 return lpValues
[i
]; /* Found */
1994 return -1; /* Not found */
1998 /*************************************************************************
2001 * Copy an interface pointer
2004 * lppDest [O] Destination for copy
2005 * lpUnknown [I] Source for copy
2010 VOID WINAPI
IUnknown_Set(IUnknown
**lppDest
, IUnknown
*lpUnknown
)
2012 TRACE("(%p,%p)\n", lppDest
, lpUnknown
);
2015 IUnknown_AtomicRelease(lppDest
); /* Release existing interface */
2020 IUnknown_AddRef(lpUnknown
);
2021 *lppDest
= lpUnknown
;
2025 /*************************************************************************
2029 HRESULT WINAPI
MayQSForward(IUnknown
* lpUnknown
, PVOID lpReserved
,
2030 REFGUID riidCmdGrp
, ULONG cCmds
,
2031 OLECMD
*prgCmds
, OLECMDTEXT
* pCmdText
)
2033 FIXME("(%p,%p,%p,%d,%p,%p) - stub\n",
2034 lpUnknown
, lpReserved
, riidCmdGrp
, cCmds
, prgCmds
, pCmdText
);
2036 /* FIXME: Calls IsQSForward & IUnknown_QueryStatus */
2037 return DRAGDROP_E_NOTREGISTERED
;
2040 /*************************************************************************
2044 HRESULT WINAPI
MayExecForward(IUnknown
* lpUnknown
, INT iUnk
, REFGUID pguidCmdGroup
,
2045 DWORD nCmdID
, DWORD nCmdexecopt
, VARIANT
* pvaIn
,
2048 FIXME("(%p,%d,%p,%d,%d,%p,%p) - stub!\n", lpUnknown
, iUnk
, pguidCmdGroup
,
2049 nCmdID
, nCmdexecopt
, pvaIn
, pvaOut
);
2050 return DRAGDROP_E_NOTREGISTERED
;
2053 /*************************************************************************
2057 HRESULT WINAPI
IsQSForward(REFGUID pguidCmdGroup
,ULONG cCmds
, OLECMD
*prgCmds
)
2059 FIXME("(%p,%d,%p) - stub!\n", pguidCmdGroup
, cCmds
, prgCmds
);
2060 return DRAGDROP_E_NOTREGISTERED
;
2063 /*************************************************************************
2066 * Determine if a window is not a child of another window.
2069 * hParent [I] Suspected parent window
2070 * hChild [I] Suspected child window
2073 * TRUE: If hChild is a child window of hParent
2074 * FALSE: If hChild is not a child window of hParent, or they are equal
2076 BOOL WINAPI
SHIsChildOrSelf(HWND hParent
, HWND hChild
)
2078 TRACE("(%p,%p)\n", hParent
, hChild
);
2080 if (!hParent
|| !hChild
)
2082 else if(hParent
== hChild
)
2084 return !IsChild(hParent
, hChild
);
2087 /*************************************************************************
2088 * FDSA functions. Manage a dynamic array of fixed size memory blocks.
2093 DWORD num_items
; /* Number of elements inserted */
2094 void *mem
; /* Ptr to array */
2095 DWORD blocks_alloced
; /* Number of elements allocated */
2096 BYTE inc
; /* Number of elements to grow by when we need to expand */
2097 BYTE block_size
; /* Size in bytes of an element */
2098 BYTE flags
; /* Flags */
2101 #define FDSA_FLAG_INTERNAL_ALLOC 0x01 /* When set we have allocated mem internally */
2103 /*************************************************************************
2106 * Initialize an FDSA arrary.
2108 BOOL WINAPI
FDSA_Initialize(DWORD block_size
, DWORD inc
, FDSA_info
*info
, void *mem
,
2111 TRACE("(0x%08x 0x%08x %p %p 0x%08x)\n", block_size
, inc
, info
, mem
, init_blocks
);
2117 memset(mem
, 0, block_size
* init_blocks
);
2119 info
->num_items
= 0;
2122 info
->blocks_alloced
= init_blocks
;
2123 info
->block_size
= block_size
;
2129 /*************************************************************************
2132 * Destroy an FDSA array
2134 BOOL WINAPI
FDSA_Destroy(FDSA_info
*info
)
2136 TRACE("(%p)\n", info
);
2138 if(info
->flags
& FDSA_FLAG_INTERNAL_ALLOC
)
2140 HeapFree(GetProcessHeap(), 0, info
->mem
);
2147 /*************************************************************************
2150 * Insert element into an FDSA array
2152 DWORD WINAPI
FDSA_InsertItem(FDSA_info
*info
, DWORD where
, const void *block
)
2154 TRACE("(%p 0x%08x %p)\n", info
, where
, block
);
2155 if(where
> info
->num_items
)
2156 where
= info
->num_items
;
2158 if(info
->num_items
>= info
->blocks_alloced
)
2160 DWORD size
= (info
->blocks_alloced
+ info
->inc
) * info
->block_size
;
2161 if(info
->flags
& 0x1)
2162 info
->mem
= HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, info
->mem
, size
);
2165 void *old_mem
= info
->mem
;
2166 info
->mem
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, size
);
2167 memcpy(info
->mem
, old_mem
, info
->blocks_alloced
* info
->block_size
);
2169 info
->blocks_alloced
+= info
->inc
;
2173 if(where
< info
->num_items
)
2175 memmove((char*)info
->mem
+ (where
+ 1) * info
->block_size
,
2176 (char*)info
->mem
+ where
* info
->block_size
,
2177 (info
->num_items
- where
) * info
->block_size
);
2179 memcpy((char*)info
->mem
+ where
* info
->block_size
, block
, info
->block_size
);
2185 /*************************************************************************
2188 * Delete an element from an FDSA array.
2190 BOOL WINAPI
FDSA_DeleteItem(FDSA_info
*info
, DWORD where
)
2192 TRACE("(%p 0x%08x)\n", info
, where
);
2194 if(where
>= info
->num_items
)
2197 if(where
< info
->num_items
- 1)
2199 memmove((char*)info
->mem
+ where
* info
->block_size
,
2200 (char*)info
->mem
+ (where
+ 1) * info
->block_size
,
2201 (info
->num_items
- where
- 1) * info
->block_size
);
2203 memset((char*)info
->mem
+ (info
->num_items
- 1) * info
->block_size
,
2204 0, info
->block_size
);
2215 /*************************************************************************
2218 * Call IUnknown_QueryInterface() on a table of objects.
2222 * Failure: E_POINTER or E_NOINTERFACE.
2224 HRESULT WINAPI
QISearch(
2225 LPVOID w
, /* [in] Table of interfaces */
2226 IFACE_INDEX_TBL
*x
, /* [in] Array of REFIIDs and indexes into the table */
2227 REFIID riid
, /* [in] REFIID to get interface for */
2228 LPVOID
*ppv
) /* [out] Destination for interface pointer */
2232 IFACE_INDEX_TBL
*xmove
;
2234 TRACE("(%p %p %s %p)\n", w
,x
,debugstr_guid(riid
),ppv
);
2237 while (xmove
->refid
) {
2238 TRACE("trying (indx %d) %s\n", xmove
->indx
, debugstr_guid(xmove
->refid
));
2239 if (IsEqualIID(riid
, xmove
->refid
)) {
2240 a_vtbl
= (IUnknown
*)(xmove
->indx
+ (LPBYTE
)w
);
2241 TRACE("matched, returning (%p)\n", a_vtbl
);
2242 *ppv
= (LPVOID
)a_vtbl
;
2243 IUnknown_AddRef(a_vtbl
);
2249 if (IsEqualIID(riid
, &IID_IUnknown
)) {
2250 a_vtbl
= (IUnknown
*)(x
->indx
+ (LPBYTE
)w
);
2251 TRACE("returning first for IUnknown (%p)\n", a_vtbl
);
2252 *ppv
= (LPVOID
)a_vtbl
;
2253 IUnknown_AddRef(a_vtbl
);
2257 ret
= E_NOINTERFACE
;
2261 TRACE("-- 0x%08x\n", ret
);
2265 /*************************************************************************
2268 * Remove the "PropDlgFont" property from a window.
2271 * hWnd [I] Window to remove the property from
2274 * A handle to the removed property, or NULL if it did not exist.
2276 HANDLE WINAPI
SHRemoveDefaultDialogFont(HWND hWnd
)
2280 TRACE("(%p)\n", hWnd
);
2282 hProp
= GetPropA(hWnd
, "PropDlgFont");
2286 DeleteObject(hProp
);
2287 hProp
= RemovePropA(hWnd
, "PropDlgFont");
2292 /*************************************************************************
2295 * Load the in-process server of a given GUID.
2298 * refiid [I] GUID of the server to load.
2301 * Success: A handle to the loaded server dll.
2302 * Failure: A NULL handle.
2304 HMODULE WINAPI
SHPinDllOfCLSID(REFIID refiid
)
2308 CHAR value
[MAX_PATH
], string
[MAX_PATH
];
2310 strcpy(string
, "CLSID\\");
2311 SHStringFromGUIDA(refiid
, string
+ 6, sizeof(string
)/sizeof(char) - 6);
2312 strcat(string
, "\\InProcServer32");
2315 RegOpenKeyExA(HKEY_CLASSES_ROOT
, string
, 0, 1, &newkey
);
2316 RegQueryValueExA(newkey
, 0, 0, &type
, (PBYTE
)value
, &count
);
2317 RegCloseKey(newkey
);
2318 return LoadLibraryExA(value
, 0, 0);
2321 /*************************************************************************
2324 * Unicode version of SHLWAPI_183.
2326 DWORD WINAPI
SHRegisterClassW(WNDCLASSW
* lpWndClass
)
2330 TRACE("(%p %s)\n",lpWndClass
->hInstance
, debugstr_w(lpWndClass
->lpszClassName
));
2332 if (GetClassInfoW(lpWndClass
->hInstance
, lpWndClass
->lpszClassName
, &WndClass
))
2334 return RegisterClassW(lpWndClass
);
2337 /*************************************************************************
2340 * Unregister a list of classes.
2343 * hInst [I] Application instance that registered the classes
2344 * lppClasses [I] List of class names
2345 * iCount [I] Number of names in lppClasses
2350 void WINAPI
SHUnregisterClassesA(HINSTANCE hInst
, LPCSTR
*lppClasses
, INT iCount
)
2354 TRACE("(%p,%p,%d)\n", hInst
, lppClasses
, iCount
);
2358 if (GetClassInfoA(hInst
, *lppClasses
, &WndClass
))
2359 UnregisterClassA(*lppClasses
, hInst
);
2365 /*************************************************************************
2368 * Unicode version of SHUnregisterClassesA.
2370 void WINAPI
SHUnregisterClassesW(HINSTANCE hInst
, LPCWSTR
*lppClasses
, INT iCount
)
2374 TRACE("(%p,%p,%d)\n", hInst
, lppClasses
, iCount
);
2378 if (GetClassInfoW(hInst
, *lppClasses
, &WndClass
))
2379 UnregisterClassW(*lppClasses
, hInst
);
2385 /*************************************************************************
2388 * Call The correct (Ascii/Unicode) default window procedure for a window.
2391 * hWnd [I] Window to call the default procedure for
2392 * uMessage [I] Message ID
2393 * wParam [I] WPARAM of message
2394 * lParam [I] LPARAM of message
2397 * The result of calling DefWindowProcA() or DefWindowProcW().
2399 LRESULT CALLBACK
SHDefWindowProc(HWND hWnd
, UINT uMessage
, WPARAM wParam
, LPARAM lParam
)
2401 if (IsWindowUnicode(hWnd
))
2402 return DefWindowProcW(hWnd
, uMessage
, wParam
, lParam
);
2403 return DefWindowProcA(hWnd
, uMessage
, wParam
, lParam
);
2406 /*************************************************************************
2409 HRESULT WINAPI
IUnknown_GetSite(LPUNKNOWN lpUnknown
, REFIID iid
, PVOID
*lppSite
)
2411 HRESULT hRet
= E_INVALIDARG
;
2412 LPOBJECTWITHSITE lpSite
= NULL
;
2414 TRACE("(%p,%s,%p)\n", lpUnknown
, debugstr_guid(iid
), lppSite
);
2416 if (lpUnknown
&& iid
&& lppSite
)
2418 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IObjectWithSite
,
2420 if (SUCCEEDED(hRet
) && lpSite
)
2422 hRet
= IObjectWithSite_GetSite(lpSite
, iid
, lppSite
);
2423 IObjectWithSite_Release(lpSite
);
2429 /*************************************************************************
2432 * Create a worker window using CreateWindowExA().
2435 * wndProc [I] Window procedure
2436 * hWndParent [I] Parent window
2437 * dwExStyle [I] Extra style flags
2438 * dwStyle [I] Style flags
2439 * hMenu [I] Window menu
2443 * Success: The window handle of the newly created window.
2446 HWND WINAPI
SHCreateWorkerWindowA(LONG wndProc
, HWND hWndParent
, DWORD dwExStyle
,
2447 DWORD dwStyle
, HMENU hMenu
, LONG z
)
2449 static const char szClass
[] = "WorkerA";
2453 TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2454 wndProc
, hWndParent
, dwExStyle
, dwStyle
, hMenu
, z
);
2456 /* Create Window class */
2458 wc
.lpfnWndProc
= DefWindowProcA
;
2461 wc
.hInstance
= shlwapi_hInstance
;
2463 wc
.hCursor
= LoadCursorA(NULL
, (LPSTR
)IDC_ARROW
);
2464 wc
.hbrBackground
= (HBRUSH
)(COLOR_BTNFACE
+ 1);
2465 wc
.lpszMenuName
= NULL
;
2466 wc
.lpszClassName
= szClass
;
2468 SHRegisterClassA(&wc
); /* Register class */
2470 /* FIXME: Set extra bits in dwExStyle */
2472 hWnd
= CreateWindowExA(dwExStyle
, szClass
, 0, dwStyle
, 0, 0, 0, 0,
2473 hWndParent
, hMenu
, shlwapi_hInstance
, 0);
2476 SetWindowLongPtrW(hWnd
, DWLP_MSGRESULT
, z
);
2479 SetWindowLongPtrA(hWnd
, GWLP_WNDPROC
, wndProc
);
2484 typedef struct tagPOLICYDATA
2486 DWORD policy
; /* flags value passed to SHRestricted */
2487 LPCWSTR appstr
; /* application str such as "Explorer" */
2488 LPCWSTR keystr
; /* name of the actual registry key / policy */
2489 } POLICYDATA
, *LPPOLICYDATA
;
2491 #define SHELL_NO_POLICY 0xffffffff
2493 /* default shell policy registry key */
2494 static const WCHAR strRegistryPolicyW
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o',
2495 's','o','f','t','\\','W','i','n','d','o','w','s','\\',
2496 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',
2497 '\\','P','o','l','i','c','i','e','s',0};
2499 /*************************************************************************
2502 * Retrieve a policy value from the registry.
2505 * lpSubKey [I] registry key name
2506 * lpSubName [I] subname of registry key
2507 * lpValue [I] value name of registry value
2510 * the value associated with the registry key or 0 if not found
2512 DWORD WINAPI
SHGetRestriction(LPCWSTR lpSubKey
, LPCWSTR lpSubName
, LPCWSTR lpValue
)
2514 DWORD retval
, datsize
= sizeof(retval
);
2518 lpSubKey
= strRegistryPolicyW
;
2520 retval
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, lpSubKey
, &hKey
);
2521 if (retval
!= ERROR_SUCCESS
)
2522 retval
= RegOpenKeyW(HKEY_CURRENT_USER
, lpSubKey
, &hKey
);
2523 if (retval
!= ERROR_SUCCESS
)
2526 SHGetValueW(hKey
, lpSubName
, lpValue
, NULL
, (LPBYTE
)&retval
, &datsize
);
2531 /*************************************************************************
2534 * Helper function to retrieve the possibly cached value for a specific policy
2537 * policy [I] The policy to look for
2538 * initial [I] Main registry key to open, if NULL use default
2539 * polTable [I] Table of known policies, 0 terminated
2540 * polArr [I] Cache array of policy values
2543 * The retrieved policy value or 0 if not successful
2546 * This function is used by the native SHRestricted function to search for the
2547 * policy and cache it once retrieved. The current Wine implementation uses a
2548 * different POLICYDATA structure and implements a similar algorithme adapted to
2551 DWORD WINAPI
SHRestrictionLookup(
2554 LPPOLICYDATA polTable
,
2557 TRACE("(0x%08x %s %p %p)\n", policy
, debugstr_w(initial
), polTable
, polArr
);
2559 if (!polTable
|| !polArr
)
2562 for (;polTable
->policy
; polTable
++, polArr
++)
2564 if (policy
== polTable
->policy
)
2566 /* we have a known policy */
2568 /* check if this policy has been cached */
2569 if (*polArr
== SHELL_NO_POLICY
)
2570 *polArr
= SHGetRestriction(initial
, polTable
->appstr
, polTable
->keystr
);
2574 /* we don't know this policy, return 0 */
2575 TRACE("unknown policy: (%08x)\n", policy
);
2579 /*************************************************************************
2582 * Get an interface from an object.
2585 * Success: S_OK. ppv contains the requested interface.
2586 * Failure: An HRESULT error code.
2589 * This QueryInterface asks the inner object for an interface. In case
2590 * of aggregation this request would be forwarded by the inner to the
2591 * outer object. This function asks the inner object directly for the
2592 * interface circumventing the forwarding to the outer object.
2594 HRESULT WINAPI
SHWeakQueryInterface(
2595 IUnknown
* pUnk
, /* [in] Outer object */
2596 IUnknown
* pInner
, /* [in] Inner object */
2597 IID
* riid
, /* [in] Interface GUID to query for */
2598 LPVOID
* ppv
) /* [out] Destination for queried interface */
2600 HRESULT hret
= E_NOINTERFACE
;
2601 TRACE("(pUnk=%p pInner=%p\n\tIID: %s %p)\n",pUnk
,pInner
,debugstr_guid(riid
), ppv
);
2604 if(pUnk
&& pInner
) {
2605 hret
= IUnknown_QueryInterface(pInner
, riid
, (LPVOID
*)ppv
);
2606 if (SUCCEEDED(hret
)) IUnknown_Release(pUnk
);
2608 TRACE("-- 0x%08x\n", hret
);
2612 /*************************************************************************
2615 * Move a reference from one interface to another.
2618 * lpDest [O] Destination to receive the reference
2619 * lppUnknown [O] Source to give up the reference to lpDest
2624 VOID WINAPI
SHWeakReleaseInterface(IUnknown
*lpDest
, IUnknown
**lppUnknown
)
2626 TRACE("(%p,%p)\n", lpDest
, lppUnknown
);
2631 IUnknown_AddRef(lpDest
);
2632 IUnknown_AtomicRelease(lppUnknown
); /* Release existing interface */
2636 /*************************************************************************
2639 * Convert an ASCII string of a CLSID into a CLSID.
2642 * idstr [I] String representing a CLSID in registry format
2643 * id [O] Destination for the converted CLSID
2646 * Success: TRUE. id contains the converted CLSID.
2649 BOOL WINAPI
GUIDFromStringA(LPCSTR idstr
, CLSID
*id
)
2652 MultiByteToWideChar(CP_ACP
, 0, idstr
, -1, wClsid
, sizeof(wClsid
)/sizeof(WCHAR
));
2653 return SUCCEEDED(CLSIDFromString(wClsid
, id
));
2656 /*************************************************************************
2659 * Unicode version of GUIDFromStringA.
2661 BOOL WINAPI
GUIDFromStringW(LPCWSTR idstr
, CLSID
*id
)
2663 return SUCCEEDED(CLSIDFromString((LPOLESTR
)idstr
, id
));
2666 /*************************************************************************
2669 * Determine if the browser is integrated into the shell, and set a registry
2676 * 1, If the browser is not integrated.
2677 * 2, If the browser is integrated.
2680 * The key "HKLM\Software\Microsoft\Internet Explorer\IntegratedBrowser" is
2681 * either set to TRUE, or removed depending on whether the browser is deemed
2684 DWORD WINAPI
WhichPlatform(void)
2686 static const char szIntegratedBrowser
[] = "IntegratedBrowser";
2687 static DWORD dwState
= 0;
2689 DWORD dwRet
, dwData
, dwSize
;
2695 /* If shell32 exports DllGetVersion(), the browser is integrated */
2697 hshell32
= LoadLibraryA("shell32.dll");
2700 FARPROC pDllGetVersion
;
2701 pDllGetVersion
= GetProcAddress(hshell32
, "DllGetVersion");
2702 dwState
= pDllGetVersion
? 2 : 1;
2703 FreeLibrary(hshell32
);
2706 /* Set or delete the key accordingly */
2707 dwRet
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
2708 "Software\\Microsoft\\Internet Explorer", 0,
2709 KEY_ALL_ACCESS
, &hKey
);
2712 dwRet
= RegQueryValueExA(hKey
, szIntegratedBrowser
, 0, 0,
2713 (LPBYTE
)&dwData
, &dwSize
);
2715 if (!dwRet
&& dwState
== 1)
2717 /* Value exists but browser is not integrated */
2718 RegDeleteValueA(hKey
, szIntegratedBrowser
);
2720 else if (dwRet
&& dwState
== 2)
2722 /* Browser is integrated but value does not exist */
2724 RegSetValueExA(hKey
, szIntegratedBrowser
, 0, REG_DWORD
,
2725 (LPBYTE
)&dwData
, sizeof(dwData
));
2732 /*************************************************************************
2735 * Unicode version of SHCreateWorkerWindowA.
2737 HWND WINAPI
SHCreateWorkerWindowW(LONG wndProc
, HWND hWndParent
, DWORD dwExStyle
,
2738 DWORD dwStyle
, HMENU hMenu
, LONG z
)
2740 static const WCHAR szClass
[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', '\0' };
2744 TRACE("(0x%08x,%p,0x%08x,0x%08x,%p,0x%08x)\n",
2745 wndProc
, hWndParent
, dwExStyle
, dwStyle
, hMenu
, z
);
2747 /* If our OS is natively ASCII, use the ASCII version */
2748 if (!(GetVersion() & 0x80000000)) /* NT */
2749 return SHCreateWorkerWindowA(wndProc
, hWndParent
, dwExStyle
, dwStyle
, hMenu
, z
);
2751 /* Create Window class */
2753 wc
.lpfnWndProc
= DefWindowProcW
;
2756 wc
.hInstance
= shlwapi_hInstance
;
2758 wc
.hCursor
= LoadCursorW(NULL
, (LPWSTR
)IDC_ARROW
);
2759 wc
.hbrBackground
= (HBRUSH
)(COLOR_BTNFACE
+ 1);
2760 wc
.lpszMenuName
= NULL
;
2761 wc
.lpszClassName
= szClass
;
2763 SHRegisterClassW(&wc
); /* Register class */
2765 /* FIXME: Set extra bits in dwExStyle */
2767 hWnd
= CreateWindowExW(dwExStyle
, szClass
, 0, dwStyle
, 0, 0, 0, 0,
2768 hWndParent
, hMenu
, shlwapi_hInstance
, 0);
2771 SetWindowLongPtrW(hWnd
, DWLP_MSGRESULT
, z
);
2774 SetWindowLongPtrW(hWnd
, GWLP_WNDPROC
, wndProc
);
2779 /*************************************************************************
2782 * Get and show a context menu from a shell folder.
2785 * hWnd [I] Window displaying the shell folder
2786 * lpFolder [I] IShellFolder interface
2787 * lpApidl [I] Id for the particular folder desired
2791 * Failure: An HRESULT error code indicating the error.
2793 HRESULT WINAPI
SHInvokeDefaultCommand(HWND hWnd
, IShellFolder
* lpFolder
, LPCITEMIDLIST lpApidl
)
2795 return SHInvokeCommand(hWnd
, lpFolder
, lpApidl
, FALSE
);
2798 /*************************************************************************
2801 * _SHPackDispParamsV
2803 HRESULT WINAPI
SHPackDispParamsV(DISPPARAMS
*params
, VARIANTARG
*args
, UINT cnt
, va_list valist
)
2807 TRACE("(%p %p %u ...)\n", params
, args
, cnt
);
2809 params
->rgvarg
= args
;
2810 params
->rgdispidNamedArgs
= NULL
;
2811 params
->cArgs
= cnt
;
2812 params
->cNamedArgs
= 0;
2816 while(iter
-- > args
) {
2817 V_VT(iter
) = va_arg(valist
, enum VARENUM
);
2819 TRACE("vt=%d\n", V_VT(iter
));
2821 if(V_VT(iter
) & VT_BYREF
) {
2822 V_BYREF(iter
) = va_arg(valist
, LPVOID
);
2824 switch(V_VT(iter
)) {
2826 V_I4(iter
) = va_arg(valist
, LONG
);
2829 V_BSTR(iter
) = va_arg(valist
, BSTR
);
2832 V_DISPATCH(iter
) = va_arg(valist
, IDispatch
*);
2835 V_BOOL(iter
) = va_arg(valist
, int);
2838 V_UNKNOWN(iter
) = va_arg(valist
, IUnknown
*);
2842 V_I4(iter
) = va_arg(valist
, LONG
);
2850 /*************************************************************************
2855 HRESULT WINAPIV
SHPackDispParams(DISPPARAMS
*params
, VARIANTARG
*args
, UINT cnt
, ...)
2860 va_start(valist
, cnt
);
2862 hres
= SHPackDispParamsV(params
, args
, cnt
, valist
);
2868 /*************************************************************************
2869 * SHLWAPI_InvokeByIID
2871 * This helper function calls IDispatch::Invoke for each sink
2872 * which implements given iid or IDispatch.
2875 static HRESULT
SHLWAPI_InvokeByIID(
2876 IConnectionPoint
* iCP
,
2879 DISPPARAMS
* dispParams
)
2881 IEnumConnections
*enumerator
;
2884 HRESULT result
= IConnectionPoint_EnumConnections(iCP
, &enumerator
);
2888 while(IEnumConnections_Next(enumerator
, 1, &rgcd
, NULL
)==S_OK
)
2890 IDispatch
*dispIface
;
2891 if (SUCCEEDED(IUnknown_QueryInterface(rgcd
.pUnk
, iid
, (LPVOID
*)&dispIface
)) ||
2892 SUCCEEDED(IUnknown_QueryInterface(rgcd
.pUnk
, &IID_IDispatch
, (LPVOID
*)&dispIface
)))
2894 IDispatch_Invoke(dispIface
, dispId
, &IID_NULL
, 0, DISPATCH_METHOD
, dispParams
, NULL
, NULL
, NULL
);
2895 IDispatch_Release(dispIface
);
2899 IEnumConnections_Release(enumerator
);
2904 /*************************************************************************
2907 * IConnectionPoint_SimpleInvoke
2909 HRESULT WINAPI
IConnectionPoint_SimpleInvoke(
2910 IConnectionPoint
* iCP
,
2912 DISPPARAMS
* dispParams
)
2917 TRACE("(%p)->(0x%x %p)\n",iCP
,dispId
,dispParams
);
2919 result
= IConnectionPoint_GetConnectionInterface(iCP
, &iid
);
2920 if (SUCCEEDED(result
))
2921 result
= SHLWAPI_InvokeByIID(iCP
, &iid
, dispId
, dispParams
);
2926 /*************************************************************************
2929 * Notify an IConnectionPoint object of changes.
2932 * lpCP [I] Object to notify
2937 * Failure: E_NOINTERFACE, if lpCP is NULL or does not support the
2938 * IConnectionPoint interface.
2940 HRESULT WINAPI
IConnectionPoint_OnChanged(IConnectionPoint
* lpCP
, DISPID dispID
)
2942 IEnumConnections
*lpEnum
;
2943 HRESULT hRet
= E_NOINTERFACE
;
2945 TRACE("(%p,0x%8X)\n", lpCP
, dispID
);
2947 /* Get an enumerator for the connections */
2949 hRet
= IConnectionPoint_EnumConnections(lpCP
, &lpEnum
);
2951 if (SUCCEEDED(hRet
))
2953 IPropertyNotifySink
*lpSink
;
2954 CONNECTDATA connData
;
2957 /* Call OnChanged() for every notify sink in the connection point */
2958 while (IEnumConnections_Next(lpEnum
, 1, &connData
, &ulFetched
) == S_OK
)
2960 if (SUCCEEDED(IUnknown_QueryInterface(connData
.pUnk
, &IID_IPropertyNotifySink
, (void**)&lpSink
)) &&
2963 IPropertyNotifySink_OnChanged(lpSink
, dispID
);
2964 IPropertyNotifySink_Release(lpSink
);
2966 IUnknown_Release(connData
.pUnk
);
2969 IEnumConnections_Release(lpEnum
);
2974 /*************************************************************************
2977 * IUnknown_CPContainerInvokeParam
2979 HRESULT WINAPIV
IUnknown_CPContainerInvokeParam(
2980 IUnknown
*container
,
2987 IConnectionPoint
*iCP
;
2988 IConnectionPointContainer
*iCPC
;
2989 DISPPARAMS dispParams
= {buffer
, NULL
, cParams
, 0};
2993 return E_NOINTERFACE
;
2995 result
= IUnknown_QueryInterface(container
, &IID_IConnectionPointContainer
,(LPVOID
*) &iCPC
);
2999 result
= IConnectionPointContainer_FindConnectionPoint(iCPC
, riid
, &iCP
);
3000 IConnectionPointContainer_Release(iCPC
);
3004 va_start(valist
, cParams
);
3005 SHPackDispParamsV(&dispParams
, buffer
, cParams
, valist
);
3008 result
= SHLWAPI_InvokeByIID(iCP
, riid
, dispId
, &dispParams
);
3009 IConnectionPoint_Release(iCP
);
3014 /*************************************************************************
3017 * Notify an IConnectionPointContainer object of changes.
3020 * lpUnknown [I] Object to notify
3025 * Failure: E_NOINTERFACE, if lpUnknown is NULL or does not support the
3026 * IConnectionPointContainer interface.
3028 HRESULT WINAPI
IUnknown_CPContainerOnChanged(IUnknown
*lpUnknown
, DISPID dispID
)
3030 IConnectionPointContainer
* lpCPC
= NULL
;
3031 HRESULT hRet
= E_NOINTERFACE
;
3033 TRACE("(%p,0x%8X)\n", lpUnknown
, dispID
);
3036 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IConnectionPointContainer
, (void**)&lpCPC
);
3038 if (SUCCEEDED(hRet
))
3040 IConnectionPoint
* lpCP
;
3042 hRet
= IConnectionPointContainer_FindConnectionPoint(lpCPC
, &IID_IPropertyNotifySink
, &lpCP
);
3043 IConnectionPointContainer_Release(lpCPC
);
3045 hRet
= IConnectionPoint_OnChanged(lpCP
, dispID
);
3046 IConnectionPoint_Release(lpCP
);
3051 /*************************************************************************
3056 BOOL WINAPI
PlaySoundWrapW(LPCWSTR pszSound
, HMODULE hmod
, DWORD fdwSound
)
3058 return PlaySoundW(pszSound
, hmod
, fdwSound
);
3061 /*************************************************************************
3064 BOOL WINAPI
SHGetIniStringW(LPCWSTR str1
, LPCWSTR str2
, LPWSTR pStr
, DWORD some_len
, LPCWSTR lpStr2
)
3066 FIXME("(%s,%s,%p,%08x,%s): stub!\n", debugstr_w(str1
), debugstr_w(str2
),
3067 pStr
, some_len
, debugstr_w(lpStr2
));
3071 /*************************************************************************
3074 * Called by ICQ2000b install via SHDOCVW:
3075 * str1: "InternetShortcut"
3076 * x: some unknown pointer
3077 * str2: "http://free.aol.com/tryaolfree/index.adp?139269"
3078 * str3: "C:\\WINDOWS\\Desktop.new2\\Free AOL & Unlimited Internet.url"
3080 * In short: this one maybe creates a desktop link :-)
3082 BOOL WINAPI
SHSetIniStringW(LPWSTR str1
, LPVOID x
, LPWSTR str2
, LPWSTR str3
)
3084 FIXME("(%s, %p, %s, %s), stub.\n", debugstr_w(str1
), x
, debugstr_w(str2
), debugstr_w(str3
));
3088 /*************************************************************************
3091 * See SHGetFileInfoW.
3093 DWORD WINAPI
SHGetFileInfoWrapW(LPCWSTR path
, DWORD dwFileAttributes
,
3094 SHFILEINFOW
*psfi
, UINT sizeofpsfi
, UINT flags
)
3096 return SHGetFileInfoW(path
, dwFileAttributes
, psfi
, sizeofpsfi
, flags
);
3099 /*************************************************************************
3102 * See DragQueryFileW.
3104 UINT WINAPI
DragQueryFileWrapW(HDROP hDrop
, UINT lFile
, LPWSTR lpszFile
, UINT lLength
)
3106 return DragQueryFileW(hDrop
, lFile
, lpszFile
, lLength
);
3109 /*************************************************************************
3112 * See SHBrowseForFolderW.
3114 LPITEMIDLIST WINAPI
SHBrowseForFolderWrapW(LPBROWSEINFOW lpBi
)
3116 return SHBrowseForFolderW(lpBi
);
3119 /*************************************************************************
3122 * See SHGetPathFromIDListW.
3124 BOOL WINAPI
SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl
,LPWSTR pszPath
)
3126 return SHGetPathFromIDListW(pidl
, pszPath
);
3129 /*************************************************************************
3132 * See ShellExecuteExW.
3134 BOOL WINAPI
ShellExecuteExWrapW(LPSHELLEXECUTEINFOW lpExecInfo
)
3136 return ShellExecuteExW(lpExecInfo
);
3139 /*************************************************************************
3142 * See SHFileOperationW.
3144 INT WINAPI
SHFileOperationWrapW(LPSHFILEOPSTRUCTW lpFileOp
)
3146 return SHFileOperationW(lpFileOp
);
3149 /*************************************************************************
3153 PVOID WINAPI
SHInterlockedCompareExchange( PVOID
*dest
, PVOID xchg
, PVOID compare
)
3155 return InterlockedCompareExchangePointer( dest
, xchg
, compare
);
3158 /*************************************************************************
3161 * See GetFileVersionInfoSizeW.
3163 DWORD WINAPI
GetFileVersionInfoSizeWrapW( LPCWSTR filename
, LPDWORD handle
)
3165 return GetFileVersionInfoSizeW( filename
, handle
);
3168 /*************************************************************************
3171 * See GetFileVersionInfoW.
3173 BOOL WINAPI
GetFileVersionInfoWrapW( LPCWSTR filename
, DWORD handle
,
3174 DWORD datasize
, LPVOID data
)
3176 return GetFileVersionInfoW( filename
, handle
, datasize
, data
);
3179 /*************************************************************************
3182 * See VerQueryValueW.
3184 WORD WINAPI
VerQueryValueWrapW( LPVOID pBlock
, LPCWSTR lpSubBlock
,
3185 LPVOID
*lplpBuffer
, UINT
*puLen
)
3187 return VerQueryValueW( pBlock
, lpSubBlock
, lplpBuffer
, puLen
);
3190 #define IsIface(type) SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
3191 #define IShellBrowser_EnableModeless IShellBrowser_EnableModelessSB
3192 #define EnableModeless(type) type##_EnableModeless((type*)lpObj, bModeless)
3194 /*************************************************************************
3197 * Change the modality of a shell object.
3200 * lpUnknown [I] Object to make modeless
3201 * bModeless [I] TRUE=Make modeless, FALSE=Make modal
3204 * Success: S_OK. The modality lpUnknown is changed.
3205 * Failure: An HRESULT error code indicating the error.
3208 * lpUnknown must support the IOleInPlaceFrame interface, the
3209 * IInternetSecurityMgrSite interface, the IShellBrowser interface
3210 * the IDocHostUIHandler interface, or the IOleInPlaceActiveObject interface,
3211 * or this call will fail.
3213 HRESULT WINAPI
IUnknown_EnableModeless(IUnknown
*lpUnknown
, BOOL bModeless
)
3218 TRACE("(%p,%d)\n", lpUnknown
, bModeless
);
3223 if (IsIface(IOleInPlaceActiveObject
))
3224 EnableModeless(IOleInPlaceActiveObject
);
3225 else if (IsIface(IOleInPlaceFrame
))
3226 EnableModeless(IOleInPlaceFrame
);
3227 else if (IsIface(IShellBrowser
))
3228 EnableModeless(IShellBrowser
);
3230 /* FIXME: Wine has no headers for these objects yet */
3231 else if (IsIface(IInternetSecurityMgrSite
))
3232 EnableModeless(IInternetSecurityMgrSite
);
3233 else if (IsIface(IDocHostUIHandler
))
3234 EnableModeless(IDocHostUIHandler
);
3239 IUnknown_Release(lpObj
);
3243 /*************************************************************************
3246 * See SHGetNewLinkInfoW.
3248 BOOL WINAPI
SHGetNewLinkInfoWrapW(LPCWSTR pszLinkTo
, LPCWSTR pszDir
, LPWSTR pszName
,
3249 BOOL
*pfMustCopy
, UINT uFlags
)
3251 return SHGetNewLinkInfoW(pszLinkTo
, pszDir
, pszName
, pfMustCopy
, uFlags
);
3254 /*************************************************************************
3257 * See SHDefExtractIconW.
3259 UINT WINAPI
SHDefExtractIconWrapW(LPCWSTR pszIconFile
, int iIndex
, UINT uFlags
, HICON
* phiconLarge
,
3260 HICON
* phiconSmall
, UINT nIconSize
)
3262 return SHDefExtractIconW(pszIconFile
, iIndex
, uFlags
, phiconLarge
, phiconSmall
, nIconSize
);
3265 /*************************************************************************
3268 * Get and show a context menu from a shell folder.
3271 * hWnd [I] Window displaying the shell folder
3272 * lpFolder [I] IShellFolder interface
3273 * lpApidl [I] Id for the particular folder desired
3274 * bInvokeDefault [I] Whether to invoke the default menu item
3277 * Success: S_OK. If bInvokeDefault is TRUE, the default menu action was
3279 * Failure: An HRESULT error code indicating the error.
3281 HRESULT WINAPI
SHInvokeCommand(HWND hWnd
, IShellFolder
* lpFolder
, LPCITEMIDLIST lpApidl
, BOOL bInvokeDefault
)
3283 IContextMenu
*iContext
;
3284 HRESULT hRet
= E_FAIL
;
3286 TRACE("(%p,%p,%p,%d)\n", hWnd
, lpFolder
, lpApidl
, bInvokeDefault
);
3291 /* Get the context menu from the shell folder */
3292 hRet
= IShellFolder_GetUIObjectOf(lpFolder
, hWnd
, 1, &lpApidl
,
3293 &IID_IContextMenu
, 0, (void**)&iContext
);
3294 if (SUCCEEDED(hRet
))
3297 if ((hMenu
= CreatePopupMenu()))
3300 DWORD dwDefaultId
= 0;
3302 /* Add the context menu entries to the popup */
3303 hQuery
= IContextMenu_QueryContextMenu(iContext
, hMenu
, 0, 1, 0x7FFF,
3304 bInvokeDefault
? CMF_NORMAL
: CMF_DEFAULTONLY
);
3306 if (SUCCEEDED(hQuery
))
3308 if (bInvokeDefault
&&
3309 (dwDefaultId
= GetMenuDefaultItem(hMenu
, 0, 0)) != 0xFFFFFFFF)
3311 CMINVOKECOMMANDINFO cmIci
;
3312 /* Invoke the default item */
3313 memset(&cmIci
,0,sizeof(cmIci
));
3314 cmIci
.cbSize
= sizeof(cmIci
);
3315 cmIci
.fMask
= CMIC_MASK_ASYNCOK
;
3317 cmIci
.lpVerb
= MAKEINTRESOURCEA(dwDefaultId
);
3318 cmIci
.nShow
= SW_SCROLLCHILDREN
;
3320 hRet
= IContextMenu_InvokeCommand(iContext
, &cmIci
);
3325 IContextMenu_Release(iContext
);
3330 /*************************************************************************
3335 HICON WINAPI
ExtractIconWrapW(HINSTANCE hInstance
, LPCWSTR lpszExeFileName
,
3338 return ExtractIconW(hInstance
, lpszExeFileName
, nIconIndex
);
3341 /*************************************************************************
3344 * Load a library from the directory of a particular process.
3347 * new_mod [I] Library name
3348 * inst_hwnd [I] Module whose directory is to be used
3349 * dwCrossCodePage [I] Should be FALSE (currently ignored)
3352 * Success: A handle to the loaded module
3353 * Failure: A NULL handle.
3355 HMODULE WINAPI
MLLoadLibraryA(LPCSTR new_mod
, HMODULE inst_hwnd
, DWORD dwCrossCodePage
)
3357 /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
3359 * FIXME: Native shows calls to:
3360 * SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
3362 * RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
3363 * RegQueryValueExA for "LPKInstalled"
3365 * RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
3366 * RegQueryValueExA for "ResourceLocale"
3368 * RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
3369 * RegQueryValueExA for "Locale"
3371 * and then tests the Locale ("en" for me).
3373 * after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
3375 CHAR mod_path
[2*MAX_PATH
];
3379 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_a(new_mod
), inst_hwnd
, dwCrossCodePage
);
3380 len
= GetModuleFileNameA(inst_hwnd
, mod_path
, sizeof(mod_path
));
3381 if (!len
|| len
>= sizeof(mod_path
)) return NULL
;
3383 ptr
= strrchr(mod_path
, '\\');
3385 strcpy(ptr
+1, new_mod
);
3386 TRACE("loading %s\n", debugstr_a(mod_path
));
3387 return LoadLibraryA(mod_path
);
3392 /*************************************************************************
3395 * Unicode version of MLLoadLibraryA.
3397 HMODULE WINAPI
MLLoadLibraryW(LPCWSTR new_mod
, HMODULE inst_hwnd
, DWORD dwCrossCodePage
)
3399 WCHAR mod_path
[2*MAX_PATH
];
3403 FIXME("(%s,%p,%d) semi-stub!\n", debugstr_w(new_mod
), inst_hwnd
, dwCrossCodePage
);
3404 len
= GetModuleFileNameW(inst_hwnd
, mod_path
, sizeof(mod_path
) / sizeof(WCHAR
));
3405 if (!len
|| len
>= sizeof(mod_path
) / sizeof(WCHAR
)) return NULL
;
3407 ptr
= strrchrW(mod_path
, '\\');
3409 strcpyW(ptr
+1, new_mod
);
3410 TRACE("loading %s\n", debugstr_w(mod_path
));
3411 return LoadLibraryW(mod_path
);
3416 /*************************************************************************
3417 * ColorAdjustLuma [SHLWAPI.@]
3419 * Adjust the luminosity of a color
3422 * cRGB [I] RGB value to convert
3423 * dwLuma [I] Luma adjustment
3424 * bUnknown [I] Unknown
3427 * The adjusted RGB color.
3429 COLORREF WINAPI
ColorAdjustLuma(COLORREF cRGB
, int dwLuma
, BOOL bUnknown
)
3431 TRACE("(0x%8x,%d,%d)\n", cRGB
, dwLuma
, bUnknown
);
3437 ColorRGBToHLS(cRGB
, &wH
, &wL
, &wS
);
3439 FIXME("Ignoring luma adjustment\n");
3441 /* FIXME: The ajdustment is not linear */
3443 cRGB
= ColorHLSToRGB(wH
, wL
, wS
);
3448 /*************************************************************************
3451 * See GetSaveFileNameW.
3453 BOOL WINAPI
GetSaveFileNameWrapW(LPOPENFILENAMEW ofn
)
3455 return GetSaveFileNameW(ofn
);
3458 /*************************************************************************
3461 * See WNetRestoreConnectionW.
3463 DWORD WINAPI
WNetRestoreConnectionWrapW(HWND hwndOwner
, LPWSTR lpszDevice
)
3465 return WNetRestoreConnectionW(hwndOwner
, lpszDevice
);
3468 /*************************************************************************
3471 * See WNetGetLastErrorW.
3473 DWORD WINAPI
WNetGetLastErrorWrapW(LPDWORD lpError
, LPWSTR lpErrorBuf
, DWORD nErrorBufSize
,
3474 LPWSTR lpNameBuf
, DWORD nNameBufSize
)
3476 return WNetGetLastErrorW(lpError
, lpErrorBuf
, nErrorBufSize
, lpNameBuf
, nNameBufSize
);
3479 /*************************************************************************
3482 * See PageSetupDlgW.
3484 BOOL WINAPI
PageSetupDlgWrapW(LPPAGESETUPDLGW pagedlg
)
3486 return PageSetupDlgW(pagedlg
);
3489 /*************************************************************************
3494 BOOL WINAPI
PrintDlgWrapW(LPPRINTDLGW printdlg
)
3496 return PrintDlgW(printdlg
);
3499 /*************************************************************************
3502 * See GetOpenFileNameW.
3504 BOOL WINAPI
GetOpenFileNameWrapW(LPOPENFILENAMEW ofn
)
3506 return GetOpenFileNameW(ofn
);
3509 /*************************************************************************
3512 HRESULT WINAPI
SHIShellFolder_EnumObjects(LPSHELLFOLDER lpFolder
, HWND hwnd
, SHCONTF flags
, IEnumIDList
**ppenum
)
3517 hr
= IShellFolder_QueryInterface(lpFolder
, &IID_IPersist
, (LPVOID
)&persist
);
3521 hr
= IPersist_GetClassID(persist
, &clsid
);
3524 if(IsEqualCLSID(&clsid
, &CLSID_ShellFSFolder
))
3525 hr
= IShellFolder_EnumObjects(lpFolder
, hwnd
, flags
, ppenum
);
3529 IPersist_Release(persist
);
3534 /* INTERNAL: Map from HLS color space to RGB */
3535 static WORD WINAPI
ConvertHue(int wHue
, WORD wMid1
, WORD wMid2
)
3537 wHue
= wHue
> 240 ? wHue
- 240 : wHue
< 0 ? wHue
+ 240 : wHue
;
3541 else if (wHue
> 120)
3546 return ((wHue
* (wMid2
- wMid1
) + 20) / 40) + wMid1
;
3549 /* Convert to RGB and scale into RGB range (0..255) */
3550 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
3552 /*************************************************************************
3553 * ColorHLSToRGB [SHLWAPI.@]
3555 * Convert from hls color space into an rgb COLORREF.
3558 * wHue [I] Hue amount
3559 * wLuminosity [I] Luminosity amount
3560 * wSaturation [I] Saturation amount
3563 * A COLORREF representing the converted color.
3566 * Input hls values are constrained to the range (0..240).
3568 COLORREF WINAPI
ColorHLSToRGB(WORD wHue
, WORD wLuminosity
, WORD wSaturation
)
3574 WORD wGreen
, wBlue
, wMid1
, wMid2
;
3576 if (wLuminosity
> 120)
3577 wMid2
= wSaturation
+ wLuminosity
- (wSaturation
* wLuminosity
+ 120) / 240;
3579 wMid2
= ((wSaturation
+ 240) * wLuminosity
+ 120) / 240;
3581 wMid1
= wLuminosity
* 2 - wMid2
;
3583 wRed
= GET_RGB(wHue
+ 80);
3584 wGreen
= GET_RGB(wHue
);
3585 wBlue
= GET_RGB(wHue
- 80);
3587 return RGB(wRed
, wGreen
, wBlue
);
3590 wRed
= wLuminosity
* 255 / 240;
3591 return RGB(wRed
, wRed
, wRed
);
3594 /*************************************************************************
3597 * Get the current docking status of the system.
3600 * dwFlags [I] DOCKINFO_ flags from "winbase.h", unused
3603 * One of DOCKINFO_UNDOCKED, DOCKINFO_UNDOCKED, or 0 if the system is not
3606 DWORD WINAPI
SHGetMachineInfo(DWORD dwFlags
)
3608 HW_PROFILE_INFOA hwInfo
;
3610 TRACE("(0x%08x)\n", dwFlags
);
3612 GetCurrentHwProfileA(&hwInfo
);
3613 switch (hwInfo
.dwDockInfo
& (DOCKINFO_DOCKED
|DOCKINFO_UNDOCKED
))
3615 case DOCKINFO_DOCKED
:
3616 case DOCKINFO_UNDOCKED
:
3617 return hwInfo
.dwDockInfo
& (DOCKINFO_DOCKED
|DOCKINFO_UNDOCKED
);
3623 /*************************************************************************
3626 * Function seems to do FreeLibrary plus other things.
3628 * FIXME native shows the following calls:
3629 * RtlEnterCriticalSection
3631 * GetProcAddress(Comctl32??, 150L)
3633 * RtlLeaveCriticalSection
3634 * followed by the FreeLibrary.
3635 * The above code may be related to .377 above.
3637 BOOL WINAPI
MLFreeLibrary(HMODULE hModule
)
3639 FIXME("(%p) semi-stub\n", hModule
);
3640 return FreeLibrary(hModule
);
3643 /*************************************************************************
3646 BOOL WINAPI
SHFlushSFCacheWrap(void) {
3651 /*************************************************************************
3653 * FIXME I have no idea what this function does or what its arguments are.
3655 BOOL WINAPI
MLIsMLHInstance(HINSTANCE hInst
)
3657 FIXME("(%p) stub\n", hInst
);
3662 /*************************************************************************
3665 DWORD WINAPI
MLSetMLHInstance(HINSTANCE hInst
, HANDLE hHeap
)
3667 FIXME("(%p,%p) stub\n", hInst
, hHeap
);
3668 return E_FAIL
; /* This is what is used if shlwapi not loaded */
3671 /*************************************************************************
3674 DWORD WINAPI
MLClearMLHInstance(DWORD x
)
3676 FIXME("(0x%08x)stub\n", x
);
3680 /*************************************************************************
3683 * Convert an Unicode string CLSID into a CLSID.
3686 * idstr [I] string containing a CLSID in text form
3687 * id [O] CLSID extracted from the string
3690 * S_OK on success or E_INVALIDARG on failure
3692 HRESULT WINAPI
CLSIDFromStringWrap(LPCWSTR idstr
, CLSID
*id
)
3694 return CLSIDFromString((LPOLESTR
)idstr
, id
);
3697 /*************************************************************************
3700 * Determine if the OS supports a given feature.
3703 * dwFeature [I] Feature requested (undocumented)
3706 * TRUE If the feature is available.
3707 * FALSE If the feature is not available.
3709 BOOL WINAPI
IsOS(DWORD feature
)
3711 OSVERSIONINFOA osvi
;
3712 DWORD platform
, majorv
, minorv
;
3714 osvi
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFOA
);
3715 if(!GetVersionExA(&osvi
)) {
3716 ERR("GetVersionEx failed\n");
3720 majorv
= osvi
.dwMajorVersion
;
3721 minorv
= osvi
.dwMinorVersion
;
3722 platform
= osvi
.dwPlatformId
;
3724 #define ISOS_RETURN(x) \
3725 TRACE("(0x%x) ret=%d\n",feature,(x)); \
3729 case OS_WIN32SORGREATER
:
3730 ISOS_RETURN(platform
== VER_PLATFORM_WIN32s
3731 || platform
== VER_PLATFORM_WIN32_WINDOWS
)
3733 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3734 case OS_WIN95ORGREATER
:
3735 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
)
3736 case OS_NT4ORGREATER
:
3737 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 4)
3738 case OS_WIN2000ORGREATER_ALT
:
3739 case OS_WIN2000ORGREATER
:
3740 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3741 case OS_WIN98ORGREATER
:
3742 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
>= 10)
3744 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
== 10)
3746 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3747 case OS_WIN2000SERVER
:
3748 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3749 case OS_WIN2000ADVSERVER
:
3750 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3751 case OS_WIN2000DATACENTER
:
3752 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3753 case OS_WIN2000TERMINAL
:
3754 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3756 FIXME("(OS_EMBEDDED) What should we return here?\n");
3758 case OS_TERMINALCLIENT
:
3759 FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
3761 case OS_TERMINALREMOTEADMIN
:
3762 FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
3765 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
== 0)
3766 case OS_MEORGREATER
:
3767 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
>= 90)
3768 case OS_XPORGREATER
:
3769 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5 && minorv
>= 1)
3771 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5 && minorv
>= 1)
3772 case OS_PROFESSIONAL
:
3773 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3775 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3777 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3779 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3780 case OS_TERMINALSERVER
:
3781 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3782 case OS_PERSONALTERMINALSERVER
:
3783 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& minorv
>= 1 && majorv
>= 5)
3784 case OS_FASTUSERSWITCHING
:
3785 FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
3787 case OS_WELCOMELOGONUI
:
3788 FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
3790 case OS_DOMAINMEMBER
:
3791 FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
3794 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3796 FIXME("(OS_WOW6432) Should we check this?\n");
3799 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3800 case OS_SMALLBUSINESSSERVER
:
3801 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3803 FIXME("(OS_TABLEPC) What should we return here?\n");
3805 case OS_SERVERADMINUI
:
3806 FIXME("(OS_SERVERADMINUI) What should we return here?\n");
3808 case OS_MEDIACENTER
:
3809 FIXME("(OS_MEDIACENTER) What should we return here?\n");
3812 FIXME("(OS_APPLIANCE) What should we return here?\n");
3818 WARN("(0x%x) unknown parameter\n",feature
);
3823 /*************************************************************************
3826 HRESULT WINAPI
SHLoadRegUIStringW(HKEY hkey
, LPCWSTR value
, LPWSTR buf
, DWORD size
)
3828 DWORD type
, sz
= size
;
3830 if(RegQueryValueExW(hkey
, value
, NULL
, &type
, (LPBYTE
)buf
, &sz
) != ERROR_SUCCESS
)
3833 return SHLoadIndirectString(buf
, buf
, size
, NULL
);
3836 /*************************************************************************
3839 * Call IInputObject_TranslateAcceleratorIO() on an object.
3842 * lpUnknown [I] Object supporting the IInputObject interface.
3843 * lpMsg [I] Key message to be processed.
3847 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
3849 HRESULT WINAPI
IUnknown_TranslateAcceleratorIO(IUnknown
*lpUnknown
, LPMSG lpMsg
)
3851 IInputObject
* lpInput
= NULL
;
3852 HRESULT hRet
= E_INVALIDARG
;
3854 TRACE("(%p,%p)\n", lpUnknown
, lpMsg
);
3857 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInputObject
,
3859 if (SUCCEEDED(hRet
) && lpInput
)
3861 hRet
= IInputObject_TranslateAcceleratorIO(lpInput
, lpMsg
);
3862 IInputObject_Release(lpInput
);
3868 /*************************************************************************
3871 * Call IInputObject_HasFocusIO() on an object.
3874 * lpUnknown [I] Object supporting the IInputObject interface.
3877 * Success: S_OK, if lpUnknown is an IInputObject object and has the focus,
3878 * or S_FALSE otherwise.
3879 * Failure: An HRESULT error code, or E_INVALIDARG if lpUnknown is NULL.
3881 HRESULT WINAPI
IUnknown_HasFocusIO(IUnknown
*lpUnknown
)
3883 IInputObject
* lpInput
= NULL
;
3884 HRESULT hRet
= E_INVALIDARG
;
3886 TRACE("(%p)\n", lpUnknown
);
3889 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInputObject
,
3891 if (SUCCEEDED(hRet
) && lpInput
)
3893 hRet
= IInputObject_HasFocusIO(lpInput
);
3894 IInputObject_Release(lpInput
);
3900 /*************************************************************************
3901 * ColorRGBToHLS [SHLWAPI.@]
3903 * Convert an rgb COLORREF into the hls color space.
3906 * cRGB [I] Source rgb value
3907 * pwHue [O] Destination for converted hue
3908 * pwLuminance [O] Destination for converted luminance
3909 * pwSaturation [O] Destination for converted saturation
3912 * Nothing. pwHue, pwLuminance and pwSaturation are set to the converted
3916 * Output HLS values are constrained to the range (0..240).
3917 * For Achromatic conversions, Hue is set to 160.
3919 VOID WINAPI
ColorRGBToHLS(COLORREF cRGB
, LPWORD pwHue
,
3920 LPWORD pwLuminance
, LPWORD pwSaturation
)
3922 int wR
, wG
, wB
, wMax
, wMin
, wHue
, wLuminosity
, wSaturation
;
3924 TRACE("(%08x,%p,%p,%p)\n", cRGB
, pwHue
, pwLuminance
, pwSaturation
);
3926 wR
= GetRValue(cRGB
);
3927 wG
= GetGValue(cRGB
);
3928 wB
= GetBValue(cRGB
);
3930 wMax
= max(wR
, max(wG
, wB
));
3931 wMin
= min(wR
, min(wG
, wB
));
3934 wLuminosity
= ((wMax
+ wMin
) * 240 + 255) / 510;
3938 /* Achromatic case */
3940 /* Hue is now unrepresentable, but this is what native returns... */
3945 /* Chromatic case */
3946 int wDelta
= wMax
- wMin
, wRNorm
, wGNorm
, wBNorm
;
3949 if (wLuminosity
<= 120)
3950 wSaturation
= ((wMax
+ wMin
)/2 + wDelta
* 240) / (wMax
+ wMin
);
3952 wSaturation
= ((510 - wMax
- wMin
)/2 + wDelta
* 240) / (510 - wMax
- wMin
);
3955 wRNorm
= (wDelta
/2 + wMax
* 40 - wR
* 40) / wDelta
;
3956 wGNorm
= (wDelta
/2 + wMax
* 40 - wG
* 40) / wDelta
;
3957 wBNorm
= (wDelta
/2 + wMax
* 40 - wB
* 40) / wDelta
;
3960 wHue
= wBNorm
- wGNorm
;
3961 else if (wG
== wMax
)
3962 wHue
= 80 + wRNorm
- wBNorm
;
3964 wHue
= 160 + wGNorm
- wRNorm
;
3967 else if (wHue
> 240)
3973 *pwLuminance
= wLuminosity
;
3975 *pwSaturation
= wSaturation
;
3978 /*************************************************************************
3979 * SHCreateShellPalette [SHLWAPI.@]
3981 HPALETTE WINAPI
SHCreateShellPalette(HDC hdc
)
3984 return CreateHalftonePalette(hdc
);
3987 /*************************************************************************
3988 * SHGetInverseCMAP (SHLWAPI.@)
3990 * Get an inverse color map table.
3993 * lpCmap [O] Destination for color map
3994 * dwSize [I] Size of memory pointed to by lpCmap
3998 * Failure: E_POINTER, If lpCmap is invalid.
3999 * E_INVALIDARG, If dwFlags is invalid
4000 * E_OUTOFMEMORY, If there is no memory available
4003 * dwSize may only be CMAP_PTR_SIZE (4) or CMAP_SIZE (8192).
4004 * If dwSize = CMAP_PTR_SIZE, *lpCmap is set to the address of this DLL's
4006 * If dwSize = CMAP_SIZE, lpCmap is filled with a copy of the data from
4007 * this DLL's internal CMap.
4009 HRESULT WINAPI
SHGetInverseCMAP(LPDWORD dest
, DWORD dwSize
)
4012 FIXME(" - returning bogus address for SHGetInverseCMAP\n");
4013 *dest
= (DWORD
)0xabba1249;
4016 FIXME("(%p, %#x) stub\n", dest
, dwSize
);
4020 /*************************************************************************
4021 * SHIsLowMemoryMachine [SHLWAPI.@]
4023 * Determine if the current computer has low memory.
4029 * TRUE if the users machine has 16 Megabytes of memory or less,
4032 BOOL WINAPI
SHIsLowMemoryMachine (DWORD x
)
4034 FIXME("(0x%08x) stub\n", x
);
4038 /*************************************************************************
4039 * GetMenuPosFromID [SHLWAPI.@]
4041 * Return the position of a menu item from its Id.
4044 * hMenu [I] Menu containing the item
4045 * wID [I] Id of the menu item
4048 * Success: The index of the menu item in hMenu.
4049 * Failure: -1, If the item is not found.
4051 INT WINAPI
GetMenuPosFromID(HMENU hMenu
, UINT wID
)
4054 INT nCount
= GetMenuItemCount(hMenu
), nIter
= 0;
4056 while (nIter
< nCount
)
4058 mi
.cbSize
= sizeof(mi
);
4060 if (GetMenuItemInfoW(hMenu
, nIter
, TRUE
, &mi
) && mi
.wID
== wID
)
4067 /*************************************************************************
4070 * Same as SHLWAPI.GetMenuPosFromID
4072 DWORD WINAPI
SHMenuIndexFromID(HMENU hMenu
, UINT uID
)
4074 return GetMenuPosFromID(hMenu
, uID
);
4078 /*************************************************************************
4081 VOID WINAPI
FixSlashesAndColonW(LPWSTR lpwstr
)
4092 /*************************************************************************
4095 DWORD WINAPI
SHGetAppCompatFlags(DWORD dwUnknown
)
4097 FIXME("(0x%08x) stub\n", dwUnknown
);
4102 /*************************************************************************
4105 HRESULT WINAPI
SHCoCreateInstanceAC(REFCLSID rclsid
, LPUNKNOWN pUnkOuter
,
4106 DWORD dwClsContext
, REFIID iid
, LPVOID
*ppv
)
4108 return CoCreateInstance(rclsid
, pUnkOuter
, dwClsContext
, iid
, ppv
);
4111 /*************************************************************************
4112 * SHSkipJunction [SHLWAPI.@]
4114 * Determine if a bind context can be bound to an object
4117 * pbc [I] Bind context to check
4118 * pclsid [I] CLSID of object to be bound to
4121 * TRUE: If it is safe to bind
4122 * FALSE: If pbc is invalid or binding would not be safe
4125 BOOL WINAPI
SHSkipJunction(IBindCtx
*pbc
, const CLSID
*pclsid
)
4127 static WCHAR szSkipBinding
[] = { 'S','k','i','p',' ',
4128 'B','i','n','d','i','n','g',' ','C','L','S','I','D','\0' };
4135 if (SUCCEEDED(IBindCtx_GetObjectParam(pbc
, (LPOLESTR
)szSkipBinding
, &lpUnk
)))
4139 if (SUCCEEDED(IUnknown_GetClassID(lpUnk
, &clsid
)) &&
4140 IsEqualGUID(pclsid
, &clsid
))
4143 IUnknown_Release(lpUnk
);
4149 /***********************************************************************
4150 * SHGetShellKey (SHLWAPI.@)
4152 DWORD WINAPI
SHGetShellKey(DWORD a
, DWORD b
, DWORD c
)
4154 FIXME("(%x, %x, %x): stub\n", a
, b
, c
);
4158 /***********************************************************************
4159 * SHQueueUserWorkItem (SHLWAPI.@)
4161 BOOL WINAPI
SHQueueUserWorkItem(LPTHREAD_START_ROUTINE pfnCallback
,
4162 LPVOID pContext
, LONG lPriority
, DWORD_PTR dwTag
,
4163 DWORD_PTR
*pdwId
, LPCSTR pszModule
, DWORD dwFlags
)
4165 TRACE("(%p, %p, %d, %lx, %p, %s, %08x)\n", pfnCallback
, pContext
,
4166 lPriority
, dwTag
, pdwId
, debugstr_a(pszModule
), dwFlags
);
4168 if(lPriority
|| dwTag
|| pdwId
|| pszModule
|| dwFlags
)
4169 FIXME("Unsupported arguments\n");
4171 return QueueUserWorkItem(pfnCallback
, pContext
, 0);
4174 /***********************************************************************
4175 * SHSetTimerQueueTimer (SHLWAPI.263)
4177 HANDLE WINAPI
SHSetTimerQueueTimer(HANDLE hQueue
,
4178 WAITORTIMERCALLBACK pfnCallback
, LPVOID pContext
, DWORD dwDueTime
,
4179 DWORD dwPeriod
, LPCSTR lpszLibrary
, DWORD dwFlags
)
4183 /* SHSetTimerQueueTimer flags -> CreateTimerQueueTimer flags */
4184 if (dwFlags
& TPS_LONGEXECTIME
) {
4185 dwFlags
&= ~TPS_LONGEXECTIME
;
4186 dwFlags
|= WT_EXECUTELONGFUNCTION
;
4188 if (dwFlags
& TPS_EXECUTEIO
) {
4189 dwFlags
&= ~TPS_EXECUTEIO
;
4190 dwFlags
|= WT_EXECUTEINIOTHREAD
;
4193 if (!CreateTimerQueueTimer(&hNewTimer
, hQueue
, pfnCallback
, pContext
,
4194 dwDueTime
, dwPeriod
, dwFlags
))
4200 /***********************************************************************
4201 * IUnknown_OnFocusChangeIS (SHLWAPI.@)
4203 HRESULT WINAPI
IUnknown_OnFocusChangeIS(LPUNKNOWN lpUnknown
, LPUNKNOWN pFocusObject
, BOOL bFocus
)
4205 IInputObjectSite
*pIOS
= NULL
;
4206 HRESULT hRet
= E_INVALIDARG
;
4208 TRACE("(%p, %p, %s)\n", lpUnknown
, pFocusObject
, bFocus
? "TRUE" : "FALSE");
4212 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInputObjectSite
,
4214 if (SUCCEEDED(hRet
) && pIOS
)
4216 hRet
= IInputObjectSite_OnFocusChangeIS(pIOS
, pFocusObject
, bFocus
);
4217 IInputObjectSite_Release(pIOS
);
4223 /***********************************************************************
4224 * SHGetValueW (SHLWAPI.@)
4226 HRESULT WINAPI
SKGetValueW(DWORD a
, LPWSTR b
, LPWSTR c
, DWORD d
, DWORD e
, DWORD f
)
4228 FIXME("(%x, %s, %s, %x, %x, %x): stub\n", a
, debugstr_w(b
), debugstr_w(c
), d
, e
, f
);
4232 typedef HRESULT (WINAPI
*DllGetVersion_func
)(DLLVERSIONINFO
*);
4234 /***********************************************************************
4235 * GetUIVersion (SHLWAPI.452)
4237 DWORD WINAPI
GetUIVersion(void)
4239 static DWORD version
;
4243 DllGetVersion_func pDllGetVersion
;
4244 HMODULE dll
= LoadLibraryA("shell32.dll");
4247 pDllGetVersion
= (DllGetVersion_func
)GetProcAddress(dll
, "DllGetVersion");
4251 dvi
.cbSize
= sizeof(DLLVERSIONINFO
);
4252 if (pDllGetVersion(&dvi
) == S_OK
) version
= dvi
.dwMajorVersion
;
4255 if (!version
) version
= 3; /* old shell dlls don't have DllGetVersion */
4260 /***********************************************************************
4261 * ShellMessageBoxWrapW [SHLWAPI.388]
4263 * See shell32.ShellMessageBoxW
4266 * shlwapi.ShellMessageBoxWrapW is a duplicate of shell32.ShellMessageBoxW
4267 * because we can't forward to it in the .spec file since it's exported by
4268 * ordinal. If you change the implementation here please update the code in
4271 INT WINAPIV
ShellMessageBoxWrapW(HINSTANCE hInstance
, HWND hWnd
, LPCWSTR lpText
,
4272 LPCWSTR lpCaption
, UINT uType
, ...)
4274 WCHAR szText
[100], szTitle
[100];
4275 LPCWSTR pszText
= szText
, pszTitle
= szTitle
;
4280 va_start(args
, uType
);
4282 TRACE("(%p,%p,%p,%p,%08x)\n", hInstance
, hWnd
, lpText
, lpCaption
, uType
);
4284 if (IS_INTRESOURCE(lpCaption
))
4285 LoadStringW(hInstance
, LOWORD(lpCaption
), szTitle
, sizeof(szTitle
)/sizeof(szTitle
[0]));
4287 pszTitle
= lpCaption
;
4289 if (IS_INTRESOURCE(lpText
))
4290 LoadStringW(hInstance
, LOWORD(lpText
), szText
, sizeof(szText
)/sizeof(szText
[0]));
4294 FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_STRING
,
4295 pszText
, 0, 0, (LPWSTR
)&pszTemp
, 0, &args
);
4299 ret
= MessageBoxW(hWnd
, pszTemp
, pszTitle
, uType
);
4300 LocalFree((HLOCAL
)pszTemp
);
4304 HRESULT WINAPI
IUnknown_QueryServiceExec(IUnknown
*unk
, REFIID service
, REFIID clsid
,
4305 DWORD x1
, DWORD x2
, DWORD x3
, void **ppvOut
)
4307 FIXME("%p %s %s %08x %08x %08x %p\n", unk
,
4308 debugstr_guid(service
), debugstr_guid(clsid
), x1
, x2
, x3
, ppvOut
);
4312 HRESULT WINAPI
IUnknown_ProfferService(IUnknown
*unk
, void *x0
, void *x1
, void *x2
)
4314 FIXME("%p %p %p %p\n", unk
, x0
, x1
, x2
);
4318 /***********************************************************************
4319 * ZoneComputePaneSize [SHLWAPI.382]
4321 UINT WINAPI
ZoneComputePaneSize(HWND hwnd
)
4327 /***********************************************************************
4328 * SHChangeNotifyWrap [SHLWAPI.394]
4330 void WINAPI
SHChangeNotifyWrap(LONG wEventId
, UINT uFlags
, LPCVOID dwItem1
, LPCVOID dwItem2
)
4332 SHChangeNotify(wEventId
, uFlags
, dwItem1
, dwItem2
);
4335 typedef struct SHELL_USER_SID
{ /* according to MSDN this should be in shlobj.h... */
4336 SID_IDENTIFIER_AUTHORITY sidAuthority
;
4337 DWORD dwUserGroupID
;
4339 } SHELL_USER_SID
, *PSHELL_USER_SID
;
4341 typedef struct SHELL_USER_PERMISSION
{ /* ...and this should be in shlwapi.h */
4342 SHELL_USER_SID susID
;
4346 DWORD dwInheritMask
;
4347 DWORD dwInheritAccessMask
;
4348 } SHELL_USER_PERMISSION
, *PSHELL_USER_PERMISSION
;
4350 /***********************************************************************
4351 * GetShellSecurityDescriptor [SHLWAPI.475]
4353 * prepares SECURITY_DESCRIPTOR from a set of ACEs
4356 * apUserPerm [I] array of pointers to SHELL_USER_PERMISSION structures,
4357 * each of which describes permissions to apply
4358 * cUserPerm [I] number of entries in apUserPerm array
4361 * success: pointer to SECURITY_DESCRIPTOR
4365 * Call should free returned descriptor with LocalFree
4367 PSECURITY_DESCRIPTOR WINAPI
GetShellSecurityDescriptor(PSHELL_USER_PERMISSION
*apUserPerm
, int cUserPerm
)
4370 PSID cur_user
= NULL
;
4374 PSECURITY_DESCRIPTOR psd
= NULL
;
4376 TRACE("%p %d\n", apUserPerm
, cUserPerm
);
4378 if (apUserPerm
== NULL
|| cUserPerm
<= 0)
4381 sidlist
= HeapAlloc(GetProcessHeap(), 0, cUserPerm
* sizeof(PSID
));
4385 acl_size
= sizeof(ACL
);
4387 for(sid_count
= 0; sid_count
< cUserPerm
; sid_count
++)
4389 static SHELL_USER_SID null_sid
= {{SECURITY_NULL_SID_AUTHORITY
}, 0, 0};
4390 PSHELL_USER_PERMISSION perm
= apUserPerm
[sid_count
];
4391 PSHELL_USER_SID sid
= &perm
->susID
;
4395 if (!memcmp((void*)sid
, (void*)&null_sid
, sizeof(SHELL_USER_SID
)))
4396 { /* current user's SID */
4400 DWORD bufsize
= sizeof(tuUser
);
4402 ret
= OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY
, &Token
);
4405 ret
= GetTokenInformation(Token
, TokenUser
, (void*)tuUser
, bufsize
, &bufsize
);
4407 cur_user
= ((PTOKEN_USER
)&tuUser
)->User
.Sid
;
4412 } else if (sid
->dwUserID
==0) /* one sub-authority */
4413 ret
= AllocateAndInitializeSid(&sid
->sidAuthority
, 1, sid
->dwUserGroupID
, 0,
4414 0, 0, 0, 0, 0, 0, &pSid
);
4416 ret
= AllocateAndInitializeSid(&sid
->sidAuthority
, 2, sid
->dwUserGroupID
, sid
->dwUserID
,
4417 0, 0, 0, 0, 0, 0, &pSid
);
4421 sidlist
[sid_count
] = pSid
;
4422 /* increment acl_size (1 ACE for non-inheritable and 2 ACEs for inheritable records */
4423 acl_size
+= (sizeof(ACCESS_ALLOWED_ACE
)-sizeof(DWORD
) + GetLengthSid(pSid
)) * (perm
->fInherit
? 2 : 1);
4426 psd
= LocalAlloc(0, sizeof(SECURITY_DESCRIPTOR
) + acl_size
);
4430 PACL pAcl
= (PACL
)(((BYTE
*)psd
)+sizeof(SECURITY_DESCRIPTOR
));
4432 if (!InitializeSecurityDescriptor(psd
, SECURITY_DESCRIPTOR_REVISION
))
4435 if (!InitializeAcl(pAcl
, acl_size
, ACL_REVISION
))
4438 for(i
= 0; i
< sid_count
; i
++)
4440 PSHELL_USER_PERMISSION sup
= apUserPerm
[i
];
4441 PSID sid
= sidlist
[i
];
4443 switch(sup
->dwAccessType
)
4445 case ACCESS_ALLOWED_ACE_TYPE
:
4446 if (!AddAccessAllowedAce(pAcl
, ACL_REVISION
, sup
->dwAccessMask
, sid
))
4448 if (sup
->fInherit
&& !AddAccessAllowedAceEx(pAcl
, ACL_REVISION
,
4449 (BYTE
)sup
->dwInheritMask
, sup
->dwInheritAccessMask
, sid
))
4452 case ACCESS_DENIED_ACE_TYPE
:
4453 if (!AddAccessDeniedAce(pAcl
, ACL_REVISION
, sup
->dwAccessMask
, sid
))
4455 if (sup
->fInherit
&& !AddAccessDeniedAceEx(pAcl
, ACL_REVISION
,
4456 (BYTE
)sup
->dwInheritMask
, sup
->dwInheritAccessMask
, sid
))
4464 if (!SetSecurityDescriptorDacl(psd
, TRUE
, pAcl
, FALSE
))
4473 for(i
= 0; i
< sid_count
; i
++)
4475 if (!cur_user
|| sidlist
[i
] != cur_user
)
4476 FreeSid(sidlist
[i
]);
4478 HeapFree(GetProcessHeap(), 0, sidlist
);