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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #define COM_NO_WINDOWS_H
25 #include "wine/port.h"
32 #define NONAMELESSUNION
33 #define NONAMELESSSTRUCT
47 #include "wine/unicode.h"
49 #include "wine/debug.h"
53 WINE_DEFAULT_DEBUG_CHANNEL(shell
);
55 /* Get a function pointer from a DLL handle */
56 #define GET_FUNC(func, module, name, fail) \
59 if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
60 func = (fn##func)GetProcAddress(SHLWAPI_h##module, name); \
61 if (!func) return fail; \
65 /* DLL handles for late bound calls */
66 extern HINSTANCE shlwapi_hInstance
;
67 extern HMODULE SHLWAPI_hshell32
;
68 extern HMODULE SHLWAPI_hwinmm
;
69 extern HMODULE SHLWAPI_hcomdlg32
;
70 extern HMODULE SHLWAPI_hcomctl32
;
71 extern HMODULE SHLWAPI_hmpr
;
72 extern HMODULE SHLWAPI_hurlmon
;
73 extern HMODULE SHLWAPI_hversion
;
75 extern DWORD SHLWAPI_ThreadRef_index
;
77 /* following is GUID for IObjectWithSite::SetSite -- see _174 */
78 static DWORD id1
[4] = {0xfc4801a3, 0x11cf2ba9, 0xaa0029a2, 0x52733d00};
79 /* following is GUID for IPersistMoniker::GetClassID -- see _174 */
80 static DWORD id2
[4] = {0x79eac9ee, 0x11cebaf9, 0xaa00828c, 0x0ba94b00};
82 /* Function pointers for GET_FUNC macro; these need to be global because of gcc bug */
83 typedef LPITEMIDLIST (WINAPI
*fnpSHBrowseForFolderW
)(LPBROWSEINFOW
);
84 static fnpSHBrowseForFolderW pSHBrowseForFolderW
;
85 typedef BOOL (WINAPI
*fnpPlaySoundW
)(LPCWSTR
, HMODULE
, DWORD
);
86 static fnpPlaySoundW pPlaySoundW
;
87 typedef DWORD (WINAPI
*fnpSHGetFileInfoW
)(LPCWSTR
,DWORD
,SHFILEINFOW
*,UINT
,UINT
);
88 static fnpSHGetFileInfoW pSHGetFileInfoW
;
89 typedef UINT (WINAPI
*fnpDragQueryFileW
)(HDROP
, UINT
, LPWSTR
, UINT
);
90 static fnpDragQueryFileW pDragQueryFileW
;
91 typedef BOOL (WINAPI
*fnpSHGetPathFromIDListW
)(LPCITEMIDLIST
, LPWSTR
);
92 static fnpSHGetPathFromIDListW pSHGetPathFromIDListW
;
93 typedef BOOL (WINAPI
*fnpShellExecuteExW
)(LPSHELLEXECUTEINFOW
);
94 static fnpShellExecuteExW pShellExecuteExW
;
95 typedef HICON (WINAPI
*fnpSHFileOperationW
)(LPSHFILEOPSTRUCTW
);
96 static fnpSHFileOperationW pSHFileOperationW
;
97 typedef UINT (WINAPI
*fnpExtractIconExW
)(LPCWSTR
, INT
,HICON
*,HICON
*, UINT
);
98 static fnpExtractIconExW pExtractIconExW
;
99 typedef BOOL (WINAPI
*fnpSHGetNewLinkInfoW
)(LPCWSTR
, LPCWSTR
, LPCWSTR
, BOOL
*, UINT
);
100 static fnpSHGetNewLinkInfoW pSHGetNewLinkInfoW
;
101 typedef HRESULT (WINAPI
*fnpSHDefExtractIconW
)(LPCWSTR
, int, UINT
, HICON
*, HICON
*, UINT
);
102 static fnpSHDefExtractIconW pSHDefExtractIconW
;
103 typedef HICON (WINAPI
*fnpExtractIconW
)(HINSTANCE
, LPCWSTR
, UINT
);
104 static fnpExtractIconW pExtractIconW
;
105 typedef BOOL (WINAPI
*fnpGetSaveFileNameW
)(LPOPENFILENAMEW
);
106 static fnpGetSaveFileNameW pGetSaveFileNameW
;
107 typedef DWORD (WINAPI
*fnpWNetRestoreConnectionW
)(HWND
, LPWSTR
);
108 static fnpWNetRestoreConnectionW pWNetRestoreConnectionW
;
109 typedef DWORD (WINAPI
*fnpWNetGetLastErrorW
)(LPDWORD
, LPWSTR
, DWORD
, LPWSTR
, DWORD
);
110 static fnpWNetGetLastErrorW pWNetGetLastErrorW
;
111 typedef BOOL (WINAPI
*fnpPageSetupDlgW
)(LPPAGESETUPDLGW
);
112 static fnpPageSetupDlgW pPageSetupDlgW
;
113 typedef BOOL (WINAPI
*fnpPrintDlgW
)(LPPRINTDLGW
);
114 static fnpPrintDlgW pPrintDlgW
;
115 typedef BOOL (WINAPI
*fnpGetOpenFileNameW
)(LPOPENFILENAMEW
);
116 static fnpGetOpenFileNameW pGetOpenFileNameW
;
117 typedef DWORD (WINAPI
*fnpGetFileVersionInfoSizeW
)(LPCWSTR
,LPDWORD
);
118 static fnpGetFileVersionInfoSizeW pGetFileVersionInfoSizeW
;
119 typedef BOOL (WINAPI
*fnpGetFileVersionInfoW
)(LPCWSTR
,DWORD
,DWORD
,LPVOID
);
120 static fnpGetFileVersionInfoW pGetFileVersionInfoW
;
121 typedef WORD (WINAPI
*fnpVerQueryValueW
)(LPVOID
,LPCWSTR
,LPVOID
*,UINT
*);
122 static fnpVerQueryValueW pVerQueryValueW
;
123 typedef BOOL (WINAPI
*fnpCOMCTL32_417
)(HDC
,INT
,INT
,UINT
,const RECT
*,LPCWSTR
,UINT
,const INT
*);
124 static fnpCOMCTL32_417 pCOMCTL32_417
;
125 typedef HRESULT (WINAPI
*fnpDllGetVersion
)(DLLVERSIONINFO
*);
126 static fnpDllGetVersion pDllGetVersion
;
127 typedef HRESULT (WINAPI
*fnpCreateFormatEnumerator
)(UINT
,FORMATETC
*,IEnumFORMATETC
**);
128 static fnpCreateFormatEnumerator pCreateFormatEnumerator
;
129 typedef HRESULT (WINAPI
*fnpRegisterFormatEnumerator
)(LPBC
,IEnumFORMATETC
*,DWORD
);
130 static fnpRegisterFormatEnumerator pRegisterFormatEnumerator
;
132 HRESULT WINAPI
IUnknown_QueryService(IUnknown
*,REFGUID
,REFIID
,LPVOID
*);
133 HRESULT WINAPI
SHInvokeCommand(HWND
,IShellFolder
*,LPCITEMIDLIST
,BOOL
);
134 HRESULT WINAPI
CLSIDFromStringWrap(LPCWSTR
,CLSID
*);
135 BOOL WINAPI
SHAboutInfoW(LPWSTR
,DWORD
);
138 NOTES: Most functions exported by ordinal seem to be superflous.
139 The reason for these functions to be there is to provide a wrapper
140 for unicode functions to provide these functions on systems without
141 unicode functions eg. win95/win98. Since we have such functions we just
142 call these. If running Wine with native DLL's, some late bound calls may
143 fail. However, it is better to implement the functions in the forward DLL
144 and recommend the builtin rather than reimplementing the calls here!
147 /*************************************************************************
148 * SHLWAPI_DupSharedHandle
150 * Internal implemetation of SHLWAPI_11.
153 HANDLE WINAPI
SHLWAPI_DupSharedHandle(HANDLE hShared
, DWORD dwDstProcId
,
154 DWORD dwSrcProcId
, DWORD dwAccess
,
158 DWORD dwMyProcId
= GetCurrentProcessId();
161 TRACE("(%p,%ld,%ld,%08lx,%08lx)\n", hShared
, dwDstProcId
, dwSrcProcId
,
162 dwAccess
, dwOptions
);
164 /* Get dest process handle */
165 if (dwDstProcId
== dwMyProcId
)
166 hDst
= GetCurrentProcess();
168 hDst
= OpenProcess(PROCESS_DUP_HANDLE
, 0, dwDstProcId
);
172 /* Get src process handle */
173 if (dwSrcProcId
== dwMyProcId
)
174 hSrc
= GetCurrentProcess();
176 hSrc
= OpenProcess(PROCESS_DUP_HANDLE
, 0, dwSrcProcId
);
180 /* Make handle available to dest process */
181 if (!DuplicateHandle(hDst
, hShared
, hSrc
, &hRet
,
182 dwAccess
, 0, dwOptions
| DUPLICATE_SAME_ACCESS
))
185 if (dwSrcProcId
!= dwMyProcId
)
189 if (dwDstProcId
!= dwMyProcId
)
193 TRACE("Returning handle %p\n", hRet
);
197 /*************************************************************************
200 * Create a block of sharable memory and initialise it with data.
203 * lpvData [I] Pointer to data to write
204 * dwSize [I] Size of data
205 * dwProcId [I] ID of process owning data
208 * Success: A shared memory handle
212 * Ordinals 7-11 provide a set of calls to create shared memory between a
213 * group of processes. The shared memory is treated opaquely in that its size
214 * is not exposed to clients who map it. This is accomplished by storing
215 * the size of the map as the first DWORD of mapped data, and then offsetting
216 * the view pointer returned by this size.
219 HANDLE WINAPI
SHAllocShared(LPCVOID lpvData
, DWORD dwSize
, DWORD dwProcId
)
225 TRACE("(%p,%ld,%ld)\n", lpvData
, dwSize
, dwProcId
);
227 /* Create file mapping of the correct length */
228 hMap
= CreateFileMappingA(INVALID_HANDLE_VALUE
, NULL
, FILE_MAP_READ
, 0,
229 dwSize
+ sizeof(dwSize
), NULL
);
233 /* Get a view in our process address space */
234 pMapped
= MapViewOfFile(hMap
, FILE_MAP_READ
| FILE_MAP_WRITE
, 0, 0, 0);
238 /* Write size of data, followed by the data, to the view */
239 *((DWORD
*)pMapped
) = dwSize
;
241 memcpy((char *) pMapped
+ sizeof(dwSize
), lpvData
, dwSize
);
243 /* Release view. All further views mapped will be opaque */
244 UnmapViewOfFile(pMapped
);
245 hRet
= SHLWAPI_DupSharedHandle(hMap
, dwProcId
,
246 GetCurrentProcessId(), FILE_MAP_ALL_ACCESS
,
247 DUPLICATE_SAME_ACCESS
);
254 /*************************************************************************
257 * Get a pointer to a block of shared memory from a shared memory handle.
260 * hShared [I] Shared memory handle
261 * dwProcId [I] ID of process owning hShared
264 * Success: A pointer to the shared memory
268 PVOID WINAPI
SHLockShared(HANDLE hShared
, DWORD dwProcId
)
273 TRACE("(%p %ld)\n", hShared
, dwProcId
);
275 /* Get handle to shared memory for current process */
276 hDup
= SHLWAPI_DupSharedHandle(hShared
, dwProcId
, GetCurrentProcessId(),
277 FILE_MAP_ALL_ACCESS
, 0);
279 pMapped
= MapViewOfFile(hDup
, FILE_MAP_READ
| FILE_MAP_WRITE
, 0, 0, 0);
283 return (char *) pMapped
+ sizeof(DWORD
); /* Hide size */
287 /*************************************************************************
290 * Release a pointer to a block of shared memory.
293 * lpView [I] Shared memory pointer
300 BOOL WINAPI
SHUnlockShared(LPVOID lpView
)
302 TRACE("(%p)\n", lpView
);
303 return UnmapViewOfFile((char *) lpView
- sizeof(DWORD
)); /* Include size */
306 /*************************************************************************
309 * Destroy a block of sharable memory.
312 * hShared [I] Shared memory handle
313 * dwProcId [I] ID of process owning hShared
320 BOOL WINAPI
SHFreeShared(HANDLE hShared
, DWORD dwProcId
)
324 TRACE("(%p %ld)\n", hShared
, dwProcId
);
326 /* Get a copy of the handle for our process, closing the source handle */
327 hClose
= SHLWAPI_DupSharedHandle(hShared
, dwProcId
, GetCurrentProcessId(),
328 FILE_MAP_ALL_ACCESS
,DUPLICATE_CLOSE_SOURCE
);
329 /* Close local copy */
330 return CloseHandle(hClose
);
333 /*************************************************************************
336 * Copy a sharable memory handle from one process to another.
339 * hShared [I] Shared memory handle to duplicate
340 * dwDstProcId [I] ID of the process wanting the duplicated handle
341 * dwSrcProcId [I] ID of the process owning hShared
342 * dwAccess [I] Desired DuplicateHandle() access
343 * dwOptions [I] Desired DuplicateHandle() options
346 * Success: A handle suitable for use by the dwDstProcId process.
347 * Failure: A NULL handle.
350 HANDLE WINAPI
SHMapHandle(HANDLE hShared
, DWORD dwDstProcId
, DWORD dwSrcProcId
,
351 DWORD dwAccess
, DWORD dwOptions
)
355 hRet
= SHLWAPI_DupSharedHandle(hShared
, dwDstProcId
, dwSrcProcId
,
356 dwAccess
, dwOptions
);
360 /*************************************************************************
363 * Create and register a clipboard enumerator for a web browser.
366 * lpBC [I] Binding context
367 * lpUnknown [I] An object exposing the IWebBrowserApp interface
371 * Failure: An HRESULT error code.
374 * The enumerator is stored as a property of the web browser. If it does not
375 * yet exist, it is created and set before being registered.
377 HRESULT WINAPI
RegisterDefaultAcceptHeaders(LPBC lpBC
, IUnknown
*lpUnknown
)
379 static const WCHAR szProperty
[] = { '{','D','0','F','C','A','4','2','0',
380 '-','D','3','F','5','-','1','1','C','F', '-','B','2','1','1','-','0',
381 '0','A','A','0','0','4','A','E','8','3','7','}','\0' };
382 IEnumFORMATETC
* pIEnumFormatEtc
= NULL
;
385 IWebBrowserApp
* pBrowser
= NULL
;
387 TRACE("(%p, %p)\n", lpBC
, lpUnknown
);
389 /* Get An IWebBrowserApp interface from lpUnknown */
390 hRet
= IUnknown_QueryService(lpUnknown
, &IID_IWebBrowserApp
, &IID_IWebBrowserApp
, (PVOID
)&pBrowser
);
391 if (FAILED(hRet
) || !pBrowser
)
392 return E_NOINTERFACE
;
394 V_VT(&var
) = VT_EMPTY
;
396 /* The property we get is the browsers clipboard enumerator */
397 hRet
= IWebBrowserApp_GetProperty(pBrowser
, (BSTR
)szProperty
, &var
);
401 if (V_VT(&var
) == VT_EMPTY
)
403 /* Iterate through accepted documents and RegisterClipBoardFormatA() them */
404 char szKeyBuff
[128], szValueBuff
[128];
405 DWORD dwKeySize
, dwValueSize
, dwRet
= 0, dwCount
= 0, dwNumValues
, dwType
;
406 FORMATETC
* formatList
, *format
;
409 TRACE("Registering formats and creating IEnumFORMATETC instance\n");
411 if (!RegOpenKeyA(HKEY_LOCAL_MACHINE
, "Software\\Microsoft\\Windows\\Current"
412 "Version\\Internet Settings\\Accepted Documents", &hDocs
))
415 /* Get count of values in key */
418 dwKeySize
= sizeof(szKeyBuff
);
419 dwRet
= RegEnumValueA(hDocs
,dwCount
,szKeyBuff
,&dwKeySize
,0,&dwType
,0,0);
423 dwNumValues
= dwCount
;
425 /* Note: dwCount = number of items + 1; The extra item is the end node */
426 format
= formatList
= HeapAlloc(GetProcessHeap(), 0, dwCount
* sizeof(FORMATETC
));
428 return E_OUTOFMEMORY
;
437 /* Register clipboard formats for the values and populate format list */
438 while(!dwRet
&& dwCount
< dwNumValues
)
440 dwKeySize
= sizeof(szKeyBuff
);
441 dwValueSize
= sizeof(szValueBuff
);
442 dwRet
= RegEnumValueA(hDocs
, dwCount
, szKeyBuff
, &dwKeySize
, 0, &dwType
,
443 (PBYTE
)szValueBuff
, &dwValueSize
);
447 format
->cfFormat
= RegisterClipboardFormatA(szValueBuff
);
449 format
->dwAspect
= 1;
458 /* Terminate the (maybe empty) list, last entry has a cfFormat of 0 */
459 format
->cfFormat
= 0;
461 format
->dwAspect
= 1;
465 /* Create a clipboard enumerator */
466 GET_FUNC(pCreateFormatEnumerator
, urlmon
, "CreateFormatEnumerator", E_FAIL
);
467 hRet
= pCreateFormatEnumerator(dwNumValues
, formatList
, &pIEnumFormatEtc
);
469 if (FAILED(hRet
) || !pIEnumFormatEtc
)
472 /* Set our enumerator as the browsers property */
473 V_VT(&var
) = VT_UNKNOWN
;
474 V_UNKNOWN(&var
) = (IUnknown
*)pIEnumFormatEtc
;
476 hRet
= IWebBrowserApp_PutProperty(pBrowser
, (BSTR
)szProperty
, var
);
479 IEnumFORMATETC_Release(pIEnumFormatEtc
);
480 goto RegisterDefaultAcceptHeaders_Exit
;
484 if (V_VT(&var
) == VT_UNKNOWN
)
486 /* Our variant is holding the clipboard enumerator */
487 IUnknown
* pIUnknown
= V_UNKNOWN(&var
);
488 IEnumFORMATETC
* pClone
= NULL
;
490 TRACE("Retrieved IEnumFORMATETC property\n");
492 /* Get an IEnumFormatEtc interface from the variants value */
493 pIEnumFormatEtc
= NULL
;
494 hRet
= IUnknown_QueryInterface(pIUnknown
, &IID_IEnumFORMATETC
,
495 (PVOID
)&pIEnumFormatEtc
);
496 if (!hRet
&& pIEnumFormatEtc
)
498 /* Clone and register the enumerator */
499 hRet
= IEnumFORMATETC_Clone(pIEnumFormatEtc
, &pClone
);
502 GET_FUNC(pRegisterFormatEnumerator
, urlmon
, "RegisterFormatEnumerator", E_FAIL
);
503 pRegisterFormatEnumerator(lpBC
, pClone
, 0);
505 IEnumFORMATETC_Release(pClone
);
508 /* Release the IEnumFormatEtc interface */
509 IEnumFORMATETC_Release(pIUnknown
);
511 IUnknown_Release(V_UNKNOWN(&var
));
514 RegisterDefaultAcceptHeaders_Exit
:
515 IWebBrowserApp_Release(pBrowser
);
519 /*************************************************************************
522 * Get Explorers "AcceptLanguage" setting.
525 * langbuf [O] Destination for language string
526 * buflen [I] Length of langbuf
527 * [0] Success: used length of langbuf
530 * Success: S_OK. langbuf is set to the language string found.
531 * Failure: E_FAIL, If any arguments are invalid, error occurred, or Explorer
532 * does not contain the setting.
533 * E_INVALIDARG, If the buffer is not big enough
535 HRESULT WINAPI
GetAcceptLanguagesW( LPWSTR langbuf
, LPDWORD buflen
)
537 static const WCHAR szkeyW
[] = {
538 'S','o','f','t','w','a','r','e','\\',
539 'M','i','c','r','o','s','o','f','t','\\',
540 'I','n','t','e','r','n','e','t',' ','E','x','p','l','o','r','e','r','\\',
541 'I','n','t','e','r','n','a','t','i','o','n','a','l',0};
542 static const WCHAR valueW
[] = {
543 'A','c','c','e','p','t','L','a','n','g','u','a','g','e',0};
544 static const WCHAR enusW
[] = {'e','n','-','u','s',0};
545 DWORD mystrlen
, mytype
;
551 if(!langbuf
|| !buflen
|| !*buflen
)
554 mystrlen
= (*buflen
> 20) ? *buflen
: 20 ;
555 mystr
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
) * mystrlen
);
556 RegOpenKeyW(HKEY_CURRENT_USER
, szkeyW
, &mykey
);
557 if(RegQueryValueExW(mykey
, valueW
, 0, &mytype
, (PBYTE
)mystr
, &mystrlen
)) {
558 /* Did not find value */
559 mylcid
= GetUserDefaultLCID();
560 /* somehow the mylcid translates into "en-us"
561 * this is similar to "LOCALE_SABBREVLANGNAME"
562 * which could be gotten via GetLocaleInfo.
563 * The only problem is LOCALE_SABBREVLANGUAGE" is
564 * a 3 char string (first 2 are country code and third is
565 * letter for "sublanguage", which does not come close to
568 lstrcpyW(mystr
, enusW
);
569 mystrlen
= lstrlenW(mystr
);
571 /* handle returned string */
572 FIXME("missing code\n");
574 memcpy( langbuf
, mystr
, min(*buflen
,strlenW(mystr
)+1)*sizeof(WCHAR
) );
576 if(*buflen
> strlenW(mystr
)) {
577 *buflen
= strlenW(mystr
);
581 retval
= E_INVALIDARG
;
582 SetLastError(ERROR_INSUFFICIENT_BUFFER
);
585 HeapFree(GetProcessHeap(), 0, mystr
);
589 /*************************************************************************
592 * Ascii version of GetAcceptLanguagesW.
594 HRESULT WINAPI
GetAcceptLanguagesA( LPSTR langbuf
, LPDWORD buflen
)
597 DWORD buflenW
, convlen
;
600 if(!langbuf
|| !buflen
|| !*buflen
) return E_FAIL
;
603 langbufW
= HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR
) * buflenW
);
604 retval
= GetAcceptLanguagesW(langbufW
, &buflenW
);
606 /* FIXME: this is wrong, the string may not be null-terminated */
607 convlen
= WideCharToMultiByte(CP_ACP
, 0, langbufW
, -1, langbuf
,
608 *buflen
, NULL
, NULL
);
609 *buflen
= buflenW
? convlen
: 0;
611 HeapFree(GetProcessHeap(), 0, langbufW
);
615 /*************************************************************************
618 * Convert a GUID to a string.
621 * guid [I] GUID to convert
622 * lpszDest [O] Destination for string
623 * cchMax [I] Length of output buffer
626 * The length of the string created.
628 INT WINAPI
SHStringFromGUIDA(REFGUID guid
, LPSTR lpszDest
, INT cchMax
)
633 TRACE("(%s,%p,%d)\n", debugstr_guid(guid
), lpszDest
, cchMax
);
635 sprintf(xguid
, "{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
636 guid
->Data1
, guid
->Data2
, guid
->Data3
,
637 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
638 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
640 iLen
= strlen(xguid
) + 1;
644 memcpy(lpszDest
, xguid
, iLen
);
648 /*************************************************************************
651 * Convert a GUID to a string.
654 * guid [I] GUID to convert
655 * str [O] Destination for string
656 * cmax [I] Length of output buffer
659 * The length of the string created.
661 INT WINAPI
SHStringFromGUIDW(REFGUID guid
, LPWSTR lpszDest
, INT cchMax
)
665 static const WCHAR wszFormat
[] = {'{','%','0','8','l','X','-','%','0','4','X','-','%','0','4','X','-',
666 '%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X','%','0','2',
667 'X','%','0','2','X','%','0','2','X','}',0};
669 TRACE("(%s,%p,%d)\n", debugstr_guid(guid
), lpszDest
, cchMax
);
671 sprintfW(xguid
, wszFormat
, guid
->Data1
, guid
->Data2
, guid
->Data3
,
672 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
673 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7]);
675 iLen
= strlenW(xguid
) + 1;
679 memcpy(lpszDest
, xguid
, iLen
*sizeof(WCHAR
));
683 /*************************************************************************
686 * Determine if a Unicode character is a space.
689 * wc [I] Character to check.
692 * TRUE, if wc is a space,
695 BOOL WINAPI
IsCharSpaceW(WCHAR wc
)
699 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_SPACE
);
702 /*************************************************************************
705 * Determine if a Unicode character is a blank.
708 * wc [I] Character to check.
711 * TRUE, if wc is a blank,
715 BOOL WINAPI
IsCharBlankW(WCHAR wc
)
719 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_BLANK
);
722 /*************************************************************************
725 * Determine if a Unicode character is punctuation.
728 * wc [I] Character to check.
731 * TRUE, if wc is punctuation,
734 BOOL WINAPI
IsCharPunctW(WCHAR wc
)
738 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_PUNCT
);
741 /*************************************************************************
744 * Determine if a Unicode character is a control character.
747 * wc [I] Character to check.
750 * TRUE, if wc is a control character,
753 BOOL WINAPI
IsCharCntrlW(WCHAR wc
)
757 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_CNTRL
);
760 /*************************************************************************
763 * Determine if a Unicode character is a digit.
766 * wc [I] Character to check.
769 * TRUE, if wc is a digit,
772 BOOL WINAPI
IsCharDigitW(WCHAR wc
)
776 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_DIGIT
);
779 /*************************************************************************
782 * Determine if a Unicode character is a hex digit.
785 * wc [I] Character to check.
788 * TRUE, if wc is a hex digit,
791 BOOL WINAPI
IsCharXDigitW(WCHAR wc
)
795 return GetStringTypeW(CT_CTYPE1
, &wc
, 1, &CharType
) && (CharType
& C1_XDIGIT
);
798 /*************************************************************************
802 BOOL WINAPI
GetStringType3ExW(LPWSTR lpszStr
, DWORD dwLen
, LPVOID p3
)
804 FIXME("(%s,0x%08lx,%p): stub\n", debugstr_w(lpszStr
), dwLen
, p3
);
808 /*************************************************************************
811 * Insert a bitmap menu item at the bottom of a menu.
814 * hMenu [I] Menu to insert into
815 * flags [I] Flags for insertion
816 * id [I] Menu ID of the item
817 * str [I] Menu text for the item
820 * Success: TRUE, the item is inserted into the menu
821 * Failure: FALSE, if any parameter is invalid
823 BOOL WINAPI
AppendMenuWrapW(HMENU hMenu
, UINT flags
, UINT id
, LPCWSTR str
)
825 TRACE("(%p,0x%08x,0x%08x,%s)\n",hMenu
, flags
, id
, debugstr_w(str
));
826 return InsertMenuW(hMenu
, -1, flags
| MF_BITMAP
, id
, str
);
829 /*************************************************************************
832 * Get the text from a given dialog item.
835 * hWnd [I] Handle of dialog
836 * nItem [I] Index of item
837 * lpsDest [O] Buffer for receiving window text
838 * nDestLen [I] Length of buffer.
841 * Success: The length of the returned text.
844 INT WINAPI
GetDlgItemTextWrapW(HWND hWnd
, INT nItem
, LPWSTR lpsDest
,INT nDestLen
)
846 HWND hItem
= GetDlgItem(hWnd
, nItem
);
849 return GetWindowTextW(hItem
, lpsDest
, nDestLen
);
851 *lpsDest
= (WCHAR
)'\0';
855 /*************************************************************************
858 * Set the text of a given dialog item.
861 * hWnd [I] Handle of dialog
862 * iItem [I] Index of item
863 * lpszText [O] Text to set
866 * Success: TRUE. The text of the dialog is set to lpszText.
867 * Failure: FALSE, Otherwise.
869 BOOL WINAPI
SetDlgItemTextWrapW(HWND hWnd
, INT iItem
, LPCWSTR lpszText
)
871 HWND hWndItem
= GetDlgItem(hWnd
, iItem
);
873 return SetWindowTextW(hWndItem
, lpszText
);
877 /*************************************************************************
880 * Compare two Ascii strings up to a given length.
883 * lpszSrc [I] Source string
884 * lpszCmp [I] String to compare to lpszSrc
885 * len [I] Maximum length
888 * A number greater than, less than or equal to 0 depending on whether
889 * lpszSrc is greater than, less than or equal to lpszCmp.
891 DWORD WINAPI
StrCmpNCA(LPCSTR lpszSrc
, LPCSTR lpszCmp
, INT len
)
893 return strncmp(lpszSrc
, lpszCmp
, len
);
896 /*************************************************************************
899 * Unicode version of StrCmpNCA.
901 DWORD WINAPI
StrCmpNCW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
, INT len
)
903 return strncmpW(lpszSrc
, lpszCmp
, len
);
906 /*************************************************************************
909 * Compare two Ascii strings up to a given length, ignoring case.
912 * lpszSrc [I] Source string
913 * lpszCmp [I] String to compare to lpszSrc
914 * len [I] Maximum length
917 * A number greater than, less than or equal to 0 depending on whether
918 * lpszSrc is greater than, less than or equal to lpszCmp.
920 DWORD WINAPI
StrCmpNICA(LPCSTR lpszSrc
, LPCSTR lpszCmp
, DWORD len
)
922 return strncasecmp(lpszSrc
, lpszCmp
, len
);
925 /*************************************************************************
928 * Unicode version of StrCmpNICA.
930 DWORD WINAPI
StrCmpNICW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
, DWORD len
)
932 return strncmpiW(lpszSrc
, lpszCmp
, len
);
935 /*************************************************************************
938 * Compare two Ascii strings.
941 * lpszSrc [I] Source string
942 * lpszCmp [I] String to compare to lpszSrc
945 * A number greater than, less than or equal to 0 depending on whether
946 * lpszSrc is greater than, less than or equal to lpszCmp.
948 DWORD WINAPI
StrCmpCA(LPCSTR lpszSrc
, LPCSTR lpszCmp
)
950 return strcmp(lpszSrc
, lpszCmp
);
953 /*************************************************************************
956 * Unicode version of StrCmpCA.
958 DWORD WINAPI
StrCmpCW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
)
960 return strcmpW(lpszSrc
, lpszCmp
);
963 /*************************************************************************
966 * Compare two Ascii strings, ignoring case.
969 * lpszSrc [I] Source string
970 * lpszCmp [I] String to compare to lpszSrc
973 * A number greater than, less than or equal to 0 depending on whether
974 * lpszSrc is greater than, less than or equal to lpszCmp.
976 DWORD WINAPI
StrCmpICA(LPCSTR lpszSrc
, LPCSTR lpszCmp
)
978 return strcasecmp(lpszSrc
, lpszCmp
);
981 /*************************************************************************
984 * Unicode version of StrCmpICA.
986 DWORD WINAPI
StrCmpICW(LPCWSTR lpszSrc
, LPCWSTR lpszCmp
)
988 return strcmpiW(lpszSrc
, lpszCmp
);
991 /*************************************************************************
994 * Get an identification string for the OS and explorer.
997 * lpszDest [O] Destination for Id string
998 * dwDestLen [I] Length of lpszDest
1001 * TRUE, If the string was created successfully
1004 BOOL WINAPI
SHAboutInfoA(LPSTR lpszDest
, DWORD dwDestLen
)
1008 TRACE("(%p,%ld)\n", lpszDest
, dwDestLen
);
1010 if (lpszDest
&& SHAboutInfoW(buff
, dwDestLen
))
1012 WideCharToMultiByte(CP_ACP
, 0, buff
, -1, lpszDest
, dwDestLen
, NULL
, NULL
);
1018 /*************************************************************************
1021 * Unicode version of SHAboutInfoA.
1023 BOOL WINAPI
SHAboutInfoW(LPWSTR lpszDest
, DWORD dwDestLen
)
1025 static const WCHAR szIEKey
[] = { 'S','O','F','T','W','A','R','E','\\',
1026 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
1027 ' ','E','x','p','l','o','r','e','r','\0' };
1028 static const WCHAR szWinNtKey
[] = { 'S','O','F','T','W','A','R','E','\\',
1029 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s',' ',
1030 'N','T','\\','C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
1031 static const WCHAR szWinKey
[] = { 'S','O','F','T','W','A','R','E','\\',
1032 'M','i','c','r','o','s','o','f','t','\\','W','i','n','d','o','w','s','\\',
1033 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\0' };
1034 static const WCHAR szRegKey
[] = { 'S','O','F','T','W','A','R','E','\\',
1035 'M','i','c','r','o','s','o','f','t','\\','I','n','t','e','r','n','e','t',
1036 ' ','E','x','p','l','o','r','e','r','\\',
1037 'R','e','g','i','s','t','r','a','t','i','o','n','\0' };
1038 static const WCHAR szVersion
[] = { 'V','e','r','s','i','o','n','\0' };
1039 static const WCHAR szCustomized
[] = { 'C','u','s','t','o','m','i','z','e','d',
1040 'V','e','r','s','i','o','n','\0' };
1041 static const WCHAR szOwner
[] = { 'R','e','g','i','s','t','e','r','e','d',
1042 'O','w','n','e','r','\0' };
1043 static const WCHAR szOrg
[] = { 'R','e','g','i','s','t','e','r','e','d',
1044 'O','r','g','a','n','i','z','a','t','i','o','n','\0' };
1045 static const WCHAR szProduct
[] = { 'P','r','o','d','u','c','t','I','d','\0' };
1046 static const WCHAR szUpdate
[] = { 'I','E','A','K',
1047 'U','p','d','a','t','e','U','r','l','\0' };
1048 static const WCHAR szHelp
[] = { 'I','E','A','K',
1049 'H','e','l','p','S','t','r','i','n','g','\0' };
1052 DWORD dwType
, dwLen
;
1054 TRACE("(%p,%ld)\n", lpszDest
, dwDestLen
);
1061 /* Try the NT key first, followed by 95/98 key */
1062 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE
, szWinNtKey
, 0, KEY_READ
, &hReg
) &&
1063 RegOpenKeyExW(HKEY_LOCAL_MACHINE
, szWinKey
, 0, KEY_READ
, &hReg
))
1069 if (!SHGetValueW(HKEY_LOCAL_MACHINE
, szIEKey
, szVersion
, &dwType
, buff
, &dwLen
))
1071 DWORD dwStrLen
= strlenW(buff
);
1072 dwLen
= 30 - dwStrLen
;
1073 SHGetValueW(HKEY_LOCAL_MACHINE
, szIEKey
,
1074 szCustomized
, &dwType
, buff
+dwStrLen
, &dwLen
);
1076 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
1078 /* ~Registered Owner */
1081 if (SHGetValueW(hReg
, szOwner
, 0, &dwType
, buff
+1, &dwLen
))
1083 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
1085 /* ~Registered Organization */
1087 if (SHGetValueW(hReg
, szOrg
, 0, &dwType
, buff
+1, &dwLen
))
1089 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
1091 /* FIXME: Not sure where this number comes from */
1095 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
1099 if (SHGetValueW(HKEY_LOCAL_MACHINE
, szRegKey
, szProduct
, &dwType
, buff
+1, &dwLen
))
1101 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
1103 /* ~IE Update Url */
1105 if(SHGetValueW(HKEY_LOCAL_MACHINE
, szWinKey
, szUpdate
, &dwType
, buff
+1, &dwLen
))
1107 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
1109 /* ~IE Help String */
1111 if(SHGetValueW(hReg
, szHelp
, 0, &dwType
, buff
+1, &dwLen
))
1113 StrCatBuffW(lpszDest
, buff
, dwDestLen
);
1119 /*************************************************************************
1122 * Call IOleCommandTarget_QueryStatus() on an object.
1125 * lpUnknown [I] Object supporting the IOleCommandTarget interface
1126 * pguidCmdGroup [I] GUID for the command group
1128 * prgCmds [O] Commands
1129 * pCmdText [O] Command text
1133 * Failure: E_FAIL, if lpUnknown is NULL.
1134 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
1135 * Otherwise, an error code from IOleCommandTarget_QueryStatus().
1137 HRESULT WINAPI
IUnknown_QueryStatus(IUnknown
* lpUnknown
, REFGUID pguidCmdGroup
,
1138 ULONG cCmds
, OLECMD
*prgCmds
, OLECMDTEXT
* pCmdText
)
1140 HRESULT hRet
= E_FAIL
;
1142 TRACE("(%p,%p,%ld,%p,%p)\n",lpUnknown
, pguidCmdGroup
, cCmds
, prgCmds
, pCmdText
);
1146 IOleCommandTarget
* lpOle
;
1148 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleCommandTarget
,
1151 if (SUCCEEDED(hRet
) && lpOle
)
1153 hRet
= IOleCommandTarget_QueryStatus(lpOle
, pguidCmdGroup
, cCmds
,
1155 IOleCommandTarget_Release(lpOle
);
1161 /*************************************************************************
1164 * Call IOleCommandTarget_Exec() on an object.
1167 * lpUnknown [I] Object supporting the IOleCommandTarget interface
1168 * pguidCmdGroup [I] GUID for the command group
1172 * Failure: E_FAIL, if lpUnknown is NULL.
1173 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
1174 * Otherwise, an error code from IOleCommandTarget_Exec().
1176 HRESULT WINAPI
IUnknown_Exec(IUnknown
* lpUnknown
, REFGUID pguidCmdGroup
,
1177 DWORD nCmdID
, DWORD nCmdexecopt
, VARIANT
* pvaIn
,
1180 HRESULT hRet
= E_FAIL
;
1182 TRACE("(%p,%p,%ld,%ld,%p,%p)\n",lpUnknown
, pguidCmdGroup
, nCmdID
,
1183 nCmdexecopt
, pvaIn
, pvaOut
);
1187 IOleCommandTarget
* lpOle
;
1189 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleCommandTarget
,
1191 if (SUCCEEDED(hRet
) && lpOle
)
1193 hRet
= IOleCommandTarget_Exec(lpOle
, pguidCmdGroup
, nCmdID
,
1194 nCmdexecopt
, pvaIn
, pvaOut
);
1195 IOleCommandTarget_Release(lpOle
);
1201 /*************************************************************************
1204 * Retrieve, modify, and re-set a value from a window.
1207 * hWnd [I] Window to get value from
1208 * offset [I] Offset of value
1209 * wMask [I] Mask for uiFlags
1210 * wFlags [I] Bits to set in window value
1213 * The new value as it was set, or 0 if any parameter is invalid.
1216 * Any bits set in uiMask are cleared from the value, then any bits set in
1217 * uiFlags are set in the value.
1219 LONG WINAPI
SHSetWindowBits(HWND hwnd
, INT offset
, UINT wMask
, UINT wFlags
)
1221 LONG ret
= GetWindowLongA(hwnd
, offset
);
1222 LONG newFlags
= (wFlags
& wMask
) | (ret
& ~wFlags
);
1224 if (newFlags
!= ret
)
1225 ret
= SetWindowLongA(hwnd
, offset
, newFlags
);
1229 /*************************************************************************
1232 * Change a window's parent.
1235 * hWnd [I] Window to change parent of
1236 * hWndParent [I] New parent window
1239 * The old parent of hWnd.
1242 * If hWndParent is NULL (desktop), the window style is changed to WS_POPUP.
1243 * If hWndParent is NOT NULL then we set the WS_CHILD style.
1245 HWND WINAPI
SHSetParentHwnd(HWND hWnd
, HWND hWndParent
)
1247 TRACE("%p, %p\n", hWnd
, hWndParent
);
1249 if(GetParent(hWnd
) == hWndParent
)
1253 SHSetWindowBits(hWnd
, GWL_STYLE
, WS_CHILD
, WS_CHILD
);
1255 SHSetWindowBits(hWnd
, GWL_STYLE
, WS_POPUP
, WS_POPUP
);
1257 return SetParent(hWnd
, hWndParent
);
1260 /*************************************************************************
1263 * Locate and advise a connection point in an IConnectionPointContainer object.
1266 * lpUnkSink [I] Sink for the connection point advise call
1267 * riid [I] REFIID of connection point to advise
1268 * bAdviseOnly [I] TRUE = Advise only, FALSE = Unadvise first
1269 * lpUnknown [I] Object supporting the IConnectionPointContainer interface
1270 * lpCookie [O] Pointer to connection point cookie
1271 * lppCP [O] Destination for the IConnectionPoint found
1274 * Success: S_OK. If lppCP is non-NULL, it is filled with the IConnectionPoint
1275 * that was advised. The caller is responsable for releasing it.
1276 * Failure: E_FAIL, if any arguments are invalid.
1277 * E_NOINTERFACE, if lpUnknown isn't an IConnectionPointContainer,
1278 * Or an HRESULT error code if any call fails.
1280 HRESULT WINAPI
ConnectToConnectionPoint(IUnknown
* lpUnkSink
, REFIID riid
, BOOL bAdviseOnly
,
1281 IUnknown
* lpUnknown
, LPDWORD lpCookie
,
1282 IConnectionPoint
**lppCP
)
1285 IConnectionPointContainer
* lpContainer
;
1286 IConnectionPoint
*lpCP
;
1288 if(!lpUnknown
|| (bAdviseOnly
&& !lpUnkSink
))
1294 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IConnectionPointContainer
,
1295 (void**)&lpContainer
);
1296 if (SUCCEEDED(hRet
))
1298 hRet
= IConnectionPointContainer_FindConnectionPoint(lpContainer
, riid
, &lpCP
);
1300 if (SUCCEEDED(hRet
))
1303 hRet
= IConnectionPoint_Unadvise(lpCP
, *lpCookie
);
1304 hRet
= IConnectionPoint_Advise(lpCP
, lpUnkSink
, lpCookie
);
1309 if (lppCP
&& SUCCEEDED(hRet
))
1310 *lppCP
= lpCP
; /* Caller keeps the interface */
1312 IConnectionPoint_Release(lpCP
); /* Release it */
1315 IUnknown_Release(lpContainer
);
1320 /*************************************************************************
1323 * Release an interface.
1326 * lpUnknown [I] Object to release
1331 DWORD WINAPI
IUnknown_AtomicRelease(IUnknown
** lpUnknown
)
1335 TRACE("(%p)\n",lpUnknown
);
1337 if(!lpUnknown
|| !*((LPDWORD
)lpUnknown
)) return 0;
1341 TRACE("doing Release\n");
1343 return IUnknown_Release(temp
);
1346 /*************************************************************************
1349 * Skip '//' if present in a string.
1352 * lpszSrc [I] String to check for '//'
1355 * Success: The next character after the '//' or the string if not present
1356 * Failure: NULL, if lpszStr is NULL.
1358 LPCSTR WINAPI
PathSkipLeadingSlashesA(LPCSTR lpszSrc
)
1360 if (lpszSrc
&& lpszSrc
[0] == '/' && lpszSrc
[1] == '/')
1365 /*************************************************************************
1368 * Check if two interfaces come from the same object.
1371 * lpInt1 [I] Interface to check against lpInt2.
1372 * lpInt2 [I] Interface to check against lpInt1.
1375 * TRUE, If the interfaces come from the same object.
1378 BOOL WINAPI
SHIsSameObject(IUnknown
* lpInt1
, IUnknown
* lpInt2
)
1380 LPVOID lpUnknown1
, lpUnknown2
;
1382 TRACE("%p %p\n", lpInt1
, lpInt2
);
1384 if (!lpInt1
|| !lpInt2
)
1387 if (lpInt1
== lpInt2
)
1390 if (!SUCCEEDED(IUnknown_QueryInterface(lpInt1
, &IID_IUnknown
,
1391 (LPVOID
*)&lpUnknown1
)))
1394 if (!SUCCEEDED(IUnknown_QueryInterface(lpInt2
, &IID_IUnknown
,
1395 (LPVOID
*)&lpUnknown2
)))
1398 if (lpUnknown1
== lpUnknown2
)
1404 /*************************************************************************
1407 * Get the window handle of an object.
1410 * lpUnknown [I] Object to get the window handle of
1411 * lphWnd [O] Destination for window handle
1414 * Success: S_OK. lphWnd contains the objects window handle.
1415 * Failure: An HRESULT error code.
1418 * lpUnknown is expected to support one of the following interfaces:
1419 * IOleWindow(), IInternetSecurityMgrSite(), or IShellView().
1421 HRESULT WINAPI
IUnknown_GetWindow(IUnknown
*lpUnknown
, HWND
*lphWnd
)
1423 /* FIXME: Wine has no header for this object */
1424 static const GUID IID_IInternetSecurityMgrSite
= { 0x79eac9ed,
1425 0xbaf9, 0x11ce, { 0x8c, 0x82, 0x00, 0xaa, 0x00, 0x4b, 0xa9, 0x0b }};
1427 HRESULT hRet
= E_FAIL
;
1429 TRACE("(%p,%p)\n", lpUnknown
, lphWnd
);
1434 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleWindow
, (void**)&lpOle
);
1438 hRet
= IUnknown_QueryInterface(lpUnknown
,&IID_IShellView
, (void**)&lpOle
);
1442 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInternetSecurityMgrSite
,
1447 if (SUCCEEDED(hRet
))
1449 /* Lazyness here - Since GetWindow() is the first method for the above 3
1450 * interfaces, we use the same call for them all.
1452 hRet
= IOleWindow_GetWindow((IOleWindow
*)lpOle
, lphWnd
);
1453 IUnknown_Release(lpOle
);
1455 TRACE("Returning HWND=%p\n", *lphWnd
);
1461 /*************************************************************************
1464 * Call a method on as as yet unidentified object.
1467 * pUnk [I] Object supporting the unidentified interface,
1468 * arg [I] Argument for the call on the object.
1473 HRESULT WINAPI
IUnknown_SetOwner(IUnknown
*pUnk
, ULONG arg
)
1475 static const GUID guid_173
= {
1476 0x5836fb00, 0x8187, 0x11cf, { 0xa1,0x2b,0x00,0xaa,0x00,0x4a,0xe8,0x37 }
1480 TRACE("(%p,%ld)\n", pUnk
, arg
);
1482 /* Note: arg may not be a ULONG and pUnk2 is for sure not an IMalloc -
1483 * We use this interface as its vtable entry is compatible with the
1484 * object in question.
1485 * FIXME: Find out what this object is and where it should be defined.
1488 SUCCEEDED(IUnknown_QueryInterface(pUnk
, &guid_173
, (void**)&pUnk2
)))
1490 IMalloc_Alloc(pUnk2
, arg
); /* Faked call!! */
1491 IMalloc_Release(pUnk2
);
1496 /*************************************************************************
1499 * Call either IObjectWithSite_SetSite() or IPersistMoniker_GetClassID() on
1504 * Failure: E_FAIL, if p1 is NULL.
1505 * E_NOINTERFACE If p1 does not support the IPersist interface,
1506 * Or an HRESULT error code.
1508 DWORD WINAPI
IUnknown_SetSite(
1509 IUnknown
*p1
, /* [in] OLE object */
1510 LPVOID
*p2
) /* [out] ptr for call results */
1513 IUnknown
*iobjectwithsite
;
1515 if (!p1
) return E_FAIL
;
1517 /* see if SetSite interface exists for IObjectWithSite object */
1518 ret
= IUnknown_QueryInterface((IUnknown
*)p1
, (REFIID
)id1
, (LPVOID
*)&iobjectwithsite
);
1519 TRACE("first IU_QI ret=%08lx, iobjectwithsite=%p\n", ret
, iobjectwithsite
);
1522 /* see if GetClassId interface exists for IPersistMoniker object */
1523 ret
= IUnknown_QueryInterface(p1
, (REFIID
)id2
, (LPVOID
*)&aa
);
1524 TRACE("second IU_QI ret=%08lx, aa=%08lx\n", ret
, aa
);
1525 if (ret
) return ret
;
1527 /* fake a GetClassId call */
1528 ret
= IOleWindow_GetWindow((IOleWindow
*)aa
, (HWND
*)p2
);
1529 TRACE("second IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret
,
1531 IUnknown_Release((IUnknown
*)aa
);
1534 /* fake a SetSite call */
1535 ret
= IOleWindow_GetWindow((IOleWindow
*)iobjectwithsite
, (HWND
*)p2
);
1536 TRACE("first IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret
,
1538 IUnknown_Release((IUnknown
*)iobjectwithsite
);
1543 /*************************************************************************
1546 * Call IPersist_GetClassID() on an object.
1549 * lpUnknown [I] Object supporting the IPersist interface
1550 * lpClassId [O] Destination for Class Id
1553 * Success: S_OK. lpClassId contains the Class Id requested.
1554 * Failure: E_FAIL, If lpUnknown is NULL,
1555 * E_NOINTERFACE If lpUnknown does not support IPersist,
1556 * Or an HRESULT error code.
1558 HRESULT WINAPI
IUnknown_GetClassID(IUnknown
*lpUnknown
, CLSID
* lpClassId
)
1560 IPersist
* lpPersist
;
1561 HRESULT hRet
= E_FAIL
;
1563 TRACE("(%p,%p)\n", lpUnknown
, debugstr_guid(lpClassId
));
1567 hRet
= IUnknown_QueryInterface(lpUnknown
,&IID_IPersist
,(void**)&lpPersist
);
1568 if (SUCCEEDED(hRet
))
1570 IPersist_GetClassID(lpPersist
, lpClassId
);
1571 IPersist_Release(lpPersist
);
1577 /*************************************************************************
1580 * Retrieve a Service Interface from an object.
1583 * lpUnknown [I] Object to get an IServiceProvider interface from
1584 * sid [I] Service ID for IServiceProvider_QueryService() call
1585 * riid [I] Function requested for QueryService call
1586 * lppOut [O] Destination for the service interface pointer
1589 * Success: S_OK. lppOut contains an object providing the requested service
1590 * Failure: An HRESULT error code
1593 * lpUnknown is expected to support the IServiceProvider interface.
1595 HRESULT WINAPI
IUnknown_QueryService(IUnknown
* lpUnknown
, REFGUID sid
, REFIID riid
,
1598 IServiceProvider
* pService
= NULL
;
1609 /* Get an IServiceProvider interface from the object */
1610 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IServiceProvider
,
1611 (LPVOID
*)&pService
);
1613 if (!hRet
&& pService
)
1615 TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService
);
1617 /* Get a Service interface from the object */
1618 hRet
= IServiceProvider_QueryService(pService
, sid
, riid
, lppOut
);
1620 TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService
, *lppOut
);
1622 /* Release the IServiceProvider interface */
1623 IUnknown_Release(pService
);
1628 /*************************************************************************
1631 * Loads a popup menu.
1634 * hInst [I] Instance handle
1635 * szName [I] Menu name
1641 BOOL WINAPI
SHLoadMenuPopup(HINSTANCE hInst
, LPCWSTR szName
)
1643 HMENU hMenu
, hSubMenu
;
1645 if ((hMenu
= LoadMenuW(hInst
, szName
)))
1647 if ((hSubMenu
= GetSubMenu(hMenu
, 0)))
1648 RemoveMenu(hMenu
, 0, MF_BYPOSITION
);
1656 typedef struct _enumWndData
1661 LRESULT (WINAPI
*pfnPost
)(HWND
,UINT
,WPARAM
,LPARAM
);
1664 /* Callback for SHLWAPI_178 */
1665 static BOOL CALLBACK
SHLWAPI_EnumChildProc(HWND hWnd
, LPARAM lParam
)
1667 enumWndData
*data
= (enumWndData
*)lParam
;
1669 TRACE("(%p,%p)\n", hWnd
, data
);
1670 data
->pfnPost(hWnd
, data
->uiMsgId
, data
->wParam
, data
->lParam
);
1674 /*************************************************************************
1677 * Send or post a message to every child of a window.
1680 * hWnd [I] Window whose children will get the messages
1681 * uiMsgId [I] Message Id
1682 * wParam [I] WPARAM of message
1683 * lParam [I] LPARAM of message
1684 * bSend [I] TRUE = Use SendMessageA(), FALSE = Use PostMessageA()
1690 * The appropriate ASCII or Unicode function is called for the window.
1692 void WINAPI
SHPropagateMessage(HWND hWnd
, UINT uiMsgId
, WPARAM wParam
, LPARAM lParam
, BOOL bSend
)
1696 TRACE("(%p,%u,%d,%ld,%d)\n", hWnd
, uiMsgId
, wParam
, lParam
, bSend
);
1700 data
.uiMsgId
= uiMsgId
;
1701 data
.wParam
= wParam
;
1702 data
.lParam
= lParam
;
1705 data
.pfnPost
= IsWindowUnicode(hWnd
) ? (void*)SendMessageW
: (void*)SendMessageA
;
1707 data
.pfnPost
= IsWindowUnicode(hWnd
) ? (void*)PostMessageW
: (void*)PostMessageA
;
1709 EnumChildWindows(hWnd
, SHLWAPI_EnumChildProc
, (LPARAM
)&data
);
1713 /*************************************************************************
1716 * Remove all sub-menus from a menu.
1719 * hMenu [I] Menu to remove sub-menus from
1722 * Success: 0. All sub-menus under hMenu are removed
1723 * Failure: -1, if any parameter is invalid
1725 DWORD WINAPI
SHRemoveAllSubMenus(HMENU hMenu
)
1727 int iItemCount
= GetMenuItemCount(hMenu
) - 1;
1728 while (iItemCount
>= 0)
1730 HMENU hSubMenu
= GetSubMenu(hMenu
, iItemCount
);
1732 RemoveMenu(hMenu
, iItemCount
, MF_BYPOSITION
);
1738 /*************************************************************************
1741 * Enable or disable a menu item.
1744 * hMenu [I] Menu holding menu item
1745 * uID [I] ID of menu item to enable/disable
1746 * bEnable [I] Whether to enable (TRUE) or disable (FALSE) the item.
1749 * The return code from EnableMenuItem.
1751 UINT WINAPI
SHEnableMenuItem(HMENU hMenu
, UINT wItemID
, BOOL bEnable
)
1753 return EnableMenuItem(hMenu
, wItemID
, bEnable
? MF_ENABLED
: MF_GRAYED
);
1756 /*************************************************************************
1759 * Check or uncheck a menu item.
1762 * hMenu [I] Menu holding menu item
1763 * uID [I] ID of menu item to check/uncheck
1764 * bCheck [I] Whether to check (TRUE) or uncheck (FALSE) the item.
1767 * The return code from CheckMenuItem.
1769 DWORD WINAPI
SHCheckMenuItem(HMENU hMenu
, UINT uID
, BOOL bCheck
)
1771 return CheckMenuItem(hMenu
, uID
, bCheck
? MF_CHECKED
: MF_UNCHECKED
);
1774 /*************************************************************************
1777 * Register a window class if it isn't already.
1780 * lpWndClass [I] Window class to register
1783 * The result of the RegisterClassA call.
1785 DWORD WINAPI
SHRegisterClassA(WNDCLASSA
*wndclass
)
1788 if (GetClassInfoA(wndclass
->hInstance
, wndclass
->lpszClassName
, &wca
))
1790 return (DWORD
)RegisterClassA(wndclass
);
1793 /*************************************************************************
1796 BOOL WINAPI
SHSimulateDrop(IDropTarget
*pDrop
, IDataObject
*pDataObj
,
1797 DWORD grfKeyState
, PPOINTL lpPt
, DWORD
* pdwEffect
)
1799 DWORD dwEffect
= DROPEFFECT_LINK
| DROPEFFECT_MOVE
| DROPEFFECT_COPY
;
1800 POINTL pt
= { 0, 0 };
1806 pdwEffect
= &dwEffect
;
1808 IDropTarget_DragEnter(pDrop
, pDataObj
, grfKeyState
, *lpPt
, pdwEffect
);
1811 return IDropTarget_Drop(pDrop
, pDataObj
, grfKeyState
, *lpPt
, pdwEffect
);
1813 IDropTarget_DragLeave(pDrop
);
1817 /*************************************************************************
1820 * Call IPersistPropertyBag_Load() on an object.
1823 * lpUnknown [I] Object supporting the IPersistPropertyBag interface
1824 * lpPropBag [O] Destination for loaded IPropertyBag
1828 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1830 DWORD WINAPI
SHLoadFromPropertyBag(IUnknown
*lpUnknown
, IPropertyBag
* lpPropBag
)
1832 IPersistPropertyBag
* lpPPBag
;
1833 HRESULT hRet
= E_FAIL
;
1835 TRACE("(%p,%p)\n", lpUnknown
, lpPropBag
);
1839 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IPersistPropertyBag
,
1841 if (SUCCEEDED(hRet
) && lpPPBag
)
1843 hRet
= IPersistPropertyBag_Load(lpPPBag
, lpPropBag
, NULL
);
1844 IPersistPropertyBag_Release(lpPPBag
);
1850 /*************************************************************************
1853 * Call IOleControlSite_GetExtendedControl() on an object.
1856 * lpUnknown [I] Object supporting the IOleControlSite interface
1857 * lppDisp [O] Destination for resulting IDispatch.
1861 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1863 DWORD WINAPI
IUnknown_OnFocusOCS(IUnknown
*lpUnknown
, IDispatch
** lppDisp
)
1865 IOleControlSite
* lpCSite
;
1866 HRESULT hRet
= E_FAIL
;
1868 TRACE("(%p,%p)\n", lpUnknown
, lppDisp
);
1871 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleControlSite
,
1873 if (SUCCEEDED(hRet
) && lpCSite
)
1875 hRet
= IOleControlSite_GetExtendedControl(lpCSite
, lppDisp
);
1876 IOleControlSite_Release(lpCSite
);
1882 /*************************************************************************
1885 * Get a sub-menu from a menu item.
1888 * hMenu [I] Menu to get sub-menu from
1889 * uID [I] ID of menu item containing sub-menu
1892 * The sub-menu of the item, or a NULL handle if any parameters are invalid.
1894 HMENU WINAPI
SHGetMenuFromID(HMENU hMenu
, UINT uID
)
1898 TRACE("(%p,%uld)\n", hMenu
, uID
);
1900 mi
.cbSize
= sizeof(MENUITEMINFOA
);
1901 mi
.fMask
= MIIM_SUBMENU
;
1903 if (!GetMenuItemInfoA(hMenu
, uID
, 0, &mi
))
1909 /*************************************************************************
1912 * Get the color depth of the primary display.
1918 * The color depth of the primary display.
1920 DWORD WINAPI
SHGetCurColorRes()
1928 ret
= GetDeviceCaps(hdc
, BITSPIXEL
) * GetDeviceCaps(hdc
, PLANES
);
1933 /*************************************************************************
1936 * Wait for a message to arrive, with a timeout.
1939 * hand [I] Handle to query
1940 * dwTimeout [I] Timeout in ticks or INFINITE to never timeout
1943 * STATUS_TIMEOUT if no message is received before dwTimeout ticks passes.
1944 * Otherwise returns the value from MsgWaitForMultipleObjectsEx when a
1945 * message is available.
1947 DWORD WINAPI
SHWaitForSendMessageThread(HANDLE hand
, DWORD dwTimeout
)
1949 DWORD dwEndTicks
= GetTickCount() + dwTimeout
;
1952 while ((dwRet
= MsgWaitForMultipleObjectsEx(1, &hand
, dwTimeout
, QS_SENDMESSAGE
, 0)) == 1)
1956 PeekMessageW(&msg
, NULL
, 0, 0, PM_NOREMOVE
);
1958 if (dwTimeout
!= INFINITE
)
1960 if ((int)(dwTimeout
= dwEndTicks
- GetTickCount()) <= 0)
1961 return WAIT_TIMEOUT
;
1968 /*************************************************************************
1971 * Blank out a region of text by drawing the background only.
1974 * hDC [I] Device context to draw in
1975 * pRect [I] Area to draw in
1976 * cRef [I] Color to draw in
1981 DWORD WINAPI
SHFillRectClr(HDC hDC
, LPCRECT pRect
, COLORREF cRef
)
1983 COLORREF cOldColor
= SetBkColor(hDC
, cRef
);
1984 ExtTextOutA(hDC
, 0, 0, ETO_OPAQUE
, pRect
, 0, 0, 0);
1985 SetBkColor(hDC
, cOldColor
);
1989 /*************************************************************************
1992 * Return the value asociated with a key in a map.
1995 * lpKeys [I] A list of keys of length iLen
1996 * lpValues [I] A list of values associated with lpKeys, of length iLen
1997 * iLen [I] Length of both lpKeys and lpValues
1998 * iKey [I] The key value to look up in lpKeys
2001 * The value in lpValues associated with iKey, or -1 if iKey is not
2005 * - If two elements in the map share the same key, this function returns
2006 * the value closest to the start of the map
2007 * - The native version of this function crashes if lpKeys or lpValues is NULL.
2009 int WINAPI
SHSearchMapInt(const int *lpKeys
, const int *lpValues
, int iLen
, int iKey
)
2011 if (lpKeys
&& lpValues
)
2017 if (lpKeys
[i
] == iKey
)
2018 return lpValues
[i
]; /* Found */
2022 return -1; /* Not found */
2026 /*************************************************************************
2029 * Copy an interface pointer
2032 * lppDest [O] Destination for copy
2033 * lpUnknown [I] Source for copy
2038 VOID WINAPI
IUnknown_Set(IUnknown
**lppDest
, IUnknown
*lpUnknown
)
2040 TRACE("(%p,%p)\n", lppDest
, lpUnknown
);
2043 IUnknown_AtomicRelease(lppDest
); /* Release existing interface */
2048 IUnknown_AddRef(lpUnknown
);
2049 *lppDest
= lpUnknown
;
2053 /*************************************************************************
2057 HRESULT WINAPI
MayExecForward(IUnknown
* lpUnknown
, INT iUnk
, REFGUID pguidCmdGroup
,
2058 DWORD nCmdID
, DWORD nCmdexecopt
, VARIANT
* pvaIn
,
2061 FIXME("(%p,%d,%p,%ld,%ld,%p,%p) - stub!\n", lpUnknown
, iUnk
, pguidCmdGroup
,
2062 nCmdID
, nCmdexecopt
, pvaIn
, pvaOut
);
2063 return DRAGDROP_E_NOTREGISTERED
;
2066 /*************************************************************************
2070 HRESULT WINAPI
IsQSForward(REFGUID pguidCmdGroup
,ULONG cCmds
, OLECMD
*prgCmds
)
2072 FIXME("(%p,%ld,%p) - stub!\n", pguidCmdGroup
, cCmds
, prgCmds
);
2073 return DRAGDROP_E_NOTREGISTERED
;
2076 /*************************************************************************
2079 * Determine if a window is not a child of another window.
2082 * hParent [I] Suspected parent window
2083 * hChild [I] Suspected child window
2086 * TRUE: If hChild is a child window of hParent
2087 * FALSE: If hChild is not a child window of hParent, or they are equal
2089 BOOL WINAPI
SHIsChildOrSelf(HWND hParent
, HWND hChild
)
2091 TRACE("(%p,%p)\n", hParent
, hChild
);
2093 if (!hParent
|| !hChild
)
2095 else if(hParent
== hChild
)
2097 return !IsChild(hParent
, hChild
);
2100 /*************************************************************************
2103 * Some sort of memory management process.
2105 DWORD WINAPI
FDSA_Initialize(
2112 FIXME("(0x%08lx 0x%08lx %p %p 0x%08lx) stub\n",
2117 /*************************************************************************
2120 * Some sort of memory management process.
2122 DWORD WINAPI
FDSA_Destroy(
2125 FIXME("(%p) stub\n",
2130 /*************************************************************************
2133 * Some sort of memory management process.
2135 DWORD WINAPI
FDSA_InsertItem(
2140 FIXME("(%p 0x%08lx %p) stub\n",
2145 /*************************************************************************
2148 DWORD WINAPI
FDSA_DeleteItem(
2152 FIXME("(%p 0x%08lx) stub\n",
2162 /*************************************************************************
2165 * Call IUnknown_QueryInterface() on a table of objects.
2169 * Failure: E_POINTER or E_NOINTERFACE.
2171 HRESULT WINAPI
QISearch(
2172 LPVOID w
, /* [in] Table of interfaces */
2173 IFACE_INDEX_TBL
*x
, /* [in] Array of REFIIDs and indexes into the table */
2174 REFIID riid
, /* [in] REFIID to get interface for */
2175 LPVOID
*ppv
) /* [out] Destination for interface pointer */
2179 IFACE_INDEX_TBL
*xmove
;
2181 TRACE("(%p %p %s %p)\n", w
,x
,debugstr_guid(riid
),ppv
);
2184 while (xmove
->refid
) {
2185 TRACE("trying (indx %ld) %s\n", xmove
->indx
, debugstr_guid(xmove
->refid
));
2186 if (IsEqualIID(riid
, xmove
->refid
)) {
2187 a_vtbl
= (IUnknown
*)(xmove
->indx
+ (LPBYTE
)w
);
2188 TRACE("matched, returning (%p)\n", a_vtbl
);
2189 *ppv
= (LPVOID
)a_vtbl
;
2190 IUnknown_AddRef(a_vtbl
);
2196 if (IsEqualIID(riid
, &IID_IUnknown
)) {
2197 a_vtbl
= (IUnknown
*)(x
->indx
+ (LPBYTE
)w
);
2198 TRACE("returning first for IUnknown (%p)\n", a_vtbl
);
2199 *ppv
= (LPVOID
)a_vtbl
;
2200 IUnknown_AddRef(a_vtbl
);
2204 ret
= E_NOINTERFACE
;
2208 TRACE("-- 0x%08lx\n", ret
);
2212 /*************************************************************************
2215 * Remove the "PropDlgFont" property from a window.
2218 * hWnd [I] Window to remove the property from
2221 * A handle to the removed property, or NULL if it did not exist.
2223 HANDLE WINAPI
SHRemoveDefaultDialogFont(HWND hWnd
)
2227 TRACE("(%p)\n", hWnd
);
2229 hProp
= GetPropA(hWnd
, "PropDlgFont");
2233 DeleteObject(hProp
);
2234 hProp
= RemovePropA(hWnd
, "PropDlgFont");
2239 /*************************************************************************
2242 * Load the in-process server of a given GUID.
2245 * refiid [I] GUID of the server to load.
2248 * Success: A handle to the loaded server dll.
2249 * Failure: A NULL handle.
2251 HMODULE WINAPI
SHPinDllOfCLSID(REFIID refiid
)
2255 CHAR value
[MAX_PATH
], string
[MAX_PATH
];
2257 strcpy(string
, "CLSID\\");
2258 SHStringFromGUIDA(refiid
, string
+ 6, sizeof(string
)/sizeof(char) - 6);
2259 strcat(string
, "\\InProcServer32");
2262 RegOpenKeyExA(HKEY_CLASSES_ROOT
, string
, 0, 1, &newkey
);
2263 RegQueryValueExA(newkey
, 0, 0, &type
, (PBYTE
)value
, &count
);
2264 RegCloseKey(newkey
);
2265 return LoadLibraryExA(value
, 0, 0);
2268 /*************************************************************************
2271 * Unicode version of SHLWAPI_183.
2273 DWORD WINAPI
SHRegisterClassW(WNDCLASSW
* lpWndClass
)
2277 TRACE("(%p %s)\n",lpWndClass
->hInstance
, debugstr_w(lpWndClass
->lpszClassName
));
2279 if (GetClassInfoW(lpWndClass
->hInstance
, lpWndClass
->lpszClassName
, &WndClass
))
2281 return RegisterClassW(lpWndClass
);
2284 /*************************************************************************
2287 * Unregister a list of classes.
2290 * hInst [I] Application instance that registered the classes
2291 * lppClasses [I] List of class names
2292 * iCount [I] Number of names in lppClasses
2297 void WINAPI
SHUnregisterClassesA(HINSTANCE hInst
, LPCSTR
*lppClasses
, INT iCount
)
2301 TRACE("(%p,%p,%d)\n", hInst
, lppClasses
, iCount
);
2305 if (GetClassInfoA(hInst
, *lppClasses
, &WndClass
))
2306 UnregisterClassA(*lppClasses
, hInst
);
2312 /*************************************************************************
2315 * Unicode version of SHUnregisterClassesA.
2317 void WINAPI
SHUnregisterClassesW(HINSTANCE hInst
, LPCWSTR
*lppClasses
, INT iCount
)
2321 TRACE("(%p,%p,%d)\n", hInst
, lppClasses
, iCount
);
2325 if (GetClassInfoW(hInst
, *lppClasses
, &WndClass
))
2326 UnregisterClassW(*lppClasses
, hInst
);
2332 /*************************************************************************
2335 * Call The correct (Ascii/Unicode) default window procedure for a window.
2338 * hWnd [I] Window to call the default procedure for
2339 * uMessage [I] Message ID
2340 * wParam [I] WPARAM of message
2341 * lParam [I] LPARAM of message
2344 * The result of calling DefWindowProcA() or DefWindowProcW().
2346 LRESULT CALLBACK
SHDefWindowProc(HWND hWnd
, UINT uMessage
, WPARAM wParam
, LPARAM lParam
)
2348 if (IsWindowUnicode(hWnd
))
2349 return DefWindowProcW(hWnd
, uMessage
, wParam
, lParam
);
2350 return DefWindowProcA(hWnd
, uMessage
, wParam
, lParam
);
2353 /*************************************************************************
2356 * Create a worker window using CreateWindowExA().
2359 * wndProc [I] Window procedure
2360 * hWndParent [I] Parent window
2361 * dwExStyle [I] Extra style flags
2362 * dwStyle [I] Style flags
2363 * hMenu [I] Window menu
2367 * Success: The window handle of the newly created window.
2370 HWND WINAPI
SHCreateWorkerWindowA(LONG wndProc
, HWND hWndParent
, DWORD dwExStyle
,
2371 DWORD dwStyle
, HMENU hMenu
, LONG z
)
2373 static const char* szClass
= "WorkerA";
2377 TRACE("(0x%08lx,%p,0x%08lx,0x%08lx,%p,0x%08lx)\n",
2378 wndProc
, hWndParent
, dwExStyle
, dwStyle
, hMenu
, z
);
2380 /* Create Window class */
2382 wc
.lpfnWndProc
= DefWindowProcA
;
2385 wc
.hInstance
= shlwapi_hInstance
;
2387 wc
.hCursor
= LoadCursorA(NULL
, (LPSTR
)IDC_ARROW
);
2388 wc
.hbrBackground
= (HBRUSH
)COLOR_BTNSHADOW
;
2389 wc
.lpszMenuName
= NULL
;
2390 wc
.lpszClassName
= szClass
;
2392 SHRegisterClassA(&wc
); /* Register class */
2394 /* FIXME: Set extra bits in dwExStyle */
2396 hWnd
= CreateWindowExA(dwExStyle
, szClass
, 0, dwStyle
, 0, 0, 0, 0,
2397 hWndParent
, hMenu
, shlwapi_hInstance
, 0);
2400 SetWindowLongA(hWnd
, DWL_MSGRESULT
, z
);
2403 SetWindowLongPtrA(hWnd
, GWLP_WNDPROC
, wndProc
);
2408 typedef struct tagPOLICYDATA
2410 DWORD policy
; /* flags value passed to SHRestricted */
2411 LPCWSTR appstr
; /* application str such as "Explorer" */
2412 LPCWSTR keystr
; /* name of the actual registry key / policy */
2413 } POLICYDATA
, *LPPOLICYDATA
;
2415 #define SHELL_NO_POLICY 0xffffffff
2417 /* default shell policy registry key */
2418 static const WCHAR strRegistryPolicyW
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o',
2419 's','o','f','t','\\','W','i','n','d','o','w','s','\\',
2420 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',
2421 '\\','P','o','l','i','c','i','e','s',0};
2423 /*************************************************************************
2426 * Retrieve a policy value from the registry.
2429 * lpSubKey [I] registry key name
2430 * lpSubName [I] subname of registry key
2431 * lpValue [I] value name of registry value
2434 * the value associated with the registry key or 0 if not found
2436 DWORD WINAPI
SHGetRestriction(LPCWSTR lpSubKey
, LPCWSTR lpSubName
, LPCWSTR lpValue
)
2438 DWORD retval
, datsize
= sizeof(retval
);
2442 lpSubKey
= strRegistryPolicyW
;
2444 retval
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, lpSubKey
, &hKey
);
2445 if (retval
!= ERROR_SUCCESS
)
2446 retval
= RegOpenKeyW(HKEY_CURRENT_USER
, lpSubKey
, &hKey
);
2447 if (retval
!= ERROR_SUCCESS
)
2450 SHGetValueW(hKey
, lpSubName
, lpValue
, NULL
, (LPBYTE
)&retval
, &datsize
);
2455 /*************************************************************************
2458 * Helper function to retrieve the possibly cached value for a specific policy
2461 * policy [I] The policy to look for
2462 * initial [I] Main registry key to open, if NULL use default
2463 * polTable [I] Table of known policies, 0 terminated
2464 * polArr [I] Cache array of policy values
2467 * The retrieved policy value or 0 if not successful
2470 * This function is used by the native SHRestricted function to search for the
2471 * policy and cache it once retrieved. The current Wine implementation uses a
2472 * different POLICYDATA structure and implements a similar algorithme adapted to
2475 DWORD WINAPI
SHRestrictionLookup(
2478 LPPOLICYDATA polTable
,
2481 TRACE("(0x%08lx %s %p %p)\n", policy
, debugstr_w(initial
), polTable
, polArr
);
2483 if (!polTable
|| !polArr
)
2486 for (;polTable
->policy
; polTable
++, polArr
++)
2488 if (policy
== polTable
->policy
)
2490 /* we have a known policy */
2492 /* check if this policy has been cached */
2493 if (*polArr
== SHELL_NO_POLICY
)
2494 *polArr
= SHGetRestriction(initial
, polTable
->appstr
, polTable
->keystr
);
2498 /* we don't know this policy, return 0 */
2499 TRACE("unknown policy: (%08lx)\n", policy
);
2503 /*************************************************************************
2506 * Get an interface from an object.
2509 * Success: S_OK. ppv contains the requested interface.
2510 * Failure: An HRESULT error code.
2513 * This QueryInterface asks the inner object for a interface. In case
2514 * of aggregation this request would be forwarded by the inner to the
2515 * outer object. This function asks the inner object directly for the
2516 * interface circumventing the forwarding to the outer object.
2518 HRESULT WINAPI
SHWeakQueryInterface(
2519 IUnknown
* pUnk
, /* [in] Outer object */
2520 IUnknown
* pInner
, /* [in] Inner object */
2521 IID
* riid
, /* [in] Interface GUID to query for */
2522 LPVOID
* ppv
) /* [out] Destination for queried interface */
2524 HRESULT hret
= E_NOINTERFACE
;
2525 TRACE("(pUnk=%p pInner=%p\n\tIID: %s %p)\n",pUnk
,pInner
,debugstr_guid(riid
), ppv
);
2528 if(pUnk
&& pInner
) {
2529 hret
= IUnknown_QueryInterface(pInner
, riid
, (LPVOID
*)ppv
);
2530 if (SUCCEEDED(hret
)) IUnknown_Release(pUnk
);
2532 TRACE("-- 0x%08lx\n", hret
);
2536 /*************************************************************************
2539 * Move a reference from one interface to another.
2542 * lpDest [O] Destination to receive the reference
2543 * lppUnknown [O] Source to give up the reference to lpDest
2548 VOID WINAPI
SHWeakReleaseInterface(IUnknown
*lpDest
, IUnknown
**lppUnknown
)
2550 TRACE("(%p,%p)\n", lpDest
, lppUnknown
);
2555 IUnknown_AddRef(lpDest
);
2556 IUnknown_AtomicRelease(lppUnknown
); /* Release existing interface */
2560 /*************************************************************************
2563 * Convert an ASCII string of a CLSID into a CLSID.
2566 * idstr [I] String representing a CLSID in registry format
2567 * id [O] Destination for the converted CLSID
2570 * Success: TRUE. id contains the converted CLSID.
2573 BOOL WINAPI
GUIDFromStringA(LPCSTR idstr
, CLSID
*id
)
2576 MultiByteToWideChar(CP_ACP
, 0, idstr
, -1, wClsid
, sizeof(wClsid
)/sizeof(WCHAR
));
2577 return SUCCEEDED(CLSIDFromStringWrap(wClsid
, id
));
2580 /*************************************************************************
2583 * Unicode version of GUIDFromStringA.
2585 BOOL WINAPI
GUIDFromStringW(LPCWSTR idstr
, CLSID
*id
)
2587 return SUCCEEDED(CLSIDFromStringWrap(idstr
, id
));
2590 /*************************************************************************
2593 * Determine if the browser is integrated into the shell, and set a registry
2600 * 1, If the browser is not integrated.
2601 * 2, If the browser is integrated.
2604 * The key "HKLM\Software\Microsoft\Internet Explorer\IntegratedBrowser" is
2605 * either set to TRUE, or removed depending on whether the browser is deemed
2608 DWORD WINAPI
WhichPlatform()
2610 static LPCSTR szIntegratedBrowser
= "IntegratedBrowser";
2611 static DWORD dwState
= 0;
2613 DWORD dwRet
, dwData
, dwSize
;
2618 /* If shell32 exports DllGetVersion(), the browser is integrated */
2619 GET_FUNC(pDllGetVersion
, shell32
, "DllGetVersion", 1);
2620 dwState
= pDllGetVersion
? 2 : 1;
2622 /* Set or delete the key accordingly */
2623 dwRet
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
2624 "Software\\Microsoft\\Internet Explorer", 0,
2625 KEY_ALL_ACCESS
, &hKey
);
2628 dwRet
= RegQueryValueExA(hKey
, szIntegratedBrowser
, 0, 0,
2629 (LPBYTE
)&dwData
, &dwSize
);
2631 if (!dwRet
&& dwState
== 1)
2633 /* Value exists but browser is not integrated */
2634 RegDeleteValueA(hKey
, szIntegratedBrowser
);
2636 else if (dwRet
&& dwState
== 2)
2638 /* Browser is integrated but value does not exist */
2640 RegSetValueExA(hKey
, szIntegratedBrowser
, 0, REG_DWORD
,
2641 (LPBYTE
)&dwData
, sizeof(dwData
));
2648 /*************************************************************************
2651 * Unicode version of SHCreateWorkerWindowA.
2653 HWND WINAPI
SHCreateWorkerWindowW(LONG wndProc
, HWND hWndParent
, DWORD dwExStyle
,
2654 DWORD dwStyle
, HMENU hMenu
, LONG z
)
2656 static const WCHAR szClass
[] = { 'W', 'o', 'r', 'k', 'e', 'r', 'W', '\0' };
2660 TRACE("(0x%08lx,%p,0x%08lx,0x%08lx,%p,0x%08lx)\n",
2661 wndProc
, hWndParent
, dwExStyle
, dwStyle
, hMenu
, z
);
2663 /* If our OS is natively ASCII, use the ASCII version */
2664 if (!(GetVersion() & 0x80000000)) /* NT */
2665 return SHCreateWorkerWindowA(wndProc
, hWndParent
, dwExStyle
, dwStyle
, hMenu
, z
);
2667 /* Create Window class */
2669 wc
.lpfnWndProc
= DefWindowProcW
;
2672 wc
.hInstance
= shlwapi_hInstance
;
2674 wc
.hCursor
= LoadCursorW(NULL
, (LPWSTR
)IDC_ARROW
);
2675 wc
.hbrBackground
= (HBRUSH
)COLOR_BTNSHADOW
;
2676 wc
.lpszMenuName
= NULL
;
2677 wc
.lpszClassName
= szClass
;
2679 SHRegisterClassW(&wc
); /* Register class */
2681 /* FIXME: Set extra bits in dwExStyle */
2683 hWnd
= CreateWindowExW(dwExStyle
, szClass
, 0, dwStyle
, 0, 0, 0, 0,
2684 hWndParent
, hMenu
, shlwapi_hInstance
, 0);
2687 SetWindowLongW(hWnd
, DWL_MSGRESULT
, z
);
2690 SetWindowLongPtrW(hWnd
, GWLP_WNDPROC
, wndProc
);
2695 /*************************************************************************
2698 * Get and show a context menu from a shell folder.
2701 * hWnd [I] Window displaying the shell folder
2702 * lpFolder [I] IShellFolder interface
2703 * lpApidl [I] Id for the particular folder desired
2707 * Failure: An HRESULT error code indicating the error.
2709 HRESULT WINAPI
SHInvokeDefaultCommand(HWND hWnd
, IShellFolder
* lpFolder
, LPCITEMIDLIST lpApidl
)
2711 return SHInvokeCommand(hWnd
, lpFolder
, lpApidl
, FALSE
);
2714 /*************************************************************************
2717 * _SHPackDispParamsV
2719 HRESULT WINAPI
SHPackDispParamsV(LPVOID w
, LPVOID x
, LPVOID y
, LPVOID z
)
2721 FIXME("%p %p %p %p\n",w
,x
,y
,z
);
2725 /*************************************************************************
2728 * This function seems to be a forward to SHPackDispParamsV (whatever THAT
2729 * function does...).
2731 HRESULT WINAPI
SHPackDispParams(LPVOID w
, LPVOID x
, LPVOID y
, LPVOID z
)
2733 FIXME("%p %p %p %p\n", w
, x
, y
, z
);
2737 /*************************************************************************
2740 * _IConnectionPoint_SimpleInvoke
2742 DWORD WINAPI
IConnectionPoint_SimpleInvoke(
2747 FIXME("(%p %p %p) stub\n",x
,y
,z
);
2751 /*************************************************************************
2754 * Notify an IConnectionPoint object of changes.
2757 * lpCP [I] Object to notify
2762 * Failure: E_NOINTERFACE, if lpCP is NULL or does not support the
2763 * IConnectionPoint interface.
2765 HRESULT WINAPI
IConnectionPoint_OnChanged(IConnectionPoint
* lpCP
, DISPID dispID
)
2767 IEnumConnections
*lpEnum
;
2768 HRESULT hRet
= E_NOINTERFACE
;
2770 TRACE("(%p,0x%8lX)\n", lpCP
, dispID
);
2772 /* Get an enumerator for the connections */
2774 hRet
= IConnectionPoint_EnumConnections(lpCP
, &lpEnum
);
2776 if (SUCCEEDED(hRet
))
2778 IPropertyNotifySink
*lpSink
;
2779 CONNECTDATA connData
;
2782 /* Call OnChanged() for every notify sink in the connection point */
2783 while (IEnumConnections_Next(lpEnum
, 1, &connData
, &ulFetched
) == S_OK
)
2785 if (SUCCEEDED(IUnknown_QueryInterface(connData
.pUnk
, &IID_IPropertyNotifySink
, (void**)&lpSink
)) &&
2788 IPropertyNotifySink_OnChanged(lpSink
, dispID
);
2789 IPropertyNotifySink_Release(lpSink
);
2791 IUnknown_Release(connData
.pUnk
);
2794 IEnumConnections_Release(lpEnum
);
2799 /*************************************************************************
2802 * Notify an IConnectionPointContainer object of changes.
2805 * lpUnknown [I] Object to notify
2810 * Failure: E_NOINTERFACE, if lpUnknown is NULL or does not support the
2811 * IConnectionPointContainer interface.
2813 HRESULT WINAPI
IUnknown_CPContainerOnChanged(IUnknown
*lpUnknown
, DISPID dispID
)
2815 IConnectionPointContainer
* lpCPC
= NULL
;
2816 HRESULT hRet
= E_NOINTERFACE
;
2818 TRACE("(%p,0x%8lX)\n", lpUnknown
, dispID
);
2821 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IConnectionPointContainer
, (void**)&lpCPC
);
2823 if (SUCCEEDED(hRet
))
2825 IConnectionPoint
* lpCP
;
2827 hRet
= IConnectionPointContainer_FindConnectionPoint(lpCPC
, &IID_IPropertyNotifySink
, &lpCP
);
2828 IConnectionPointContainer_Release(lpCPC
);
2830 hRet
= IConnectionPoint_OnChanged(lpCP
, dispID
);
2831 IConnectionPoint_Release(lpCP
);
2836 /*************************************************************************
2841 BOOL WINAPI
PlaySoundWrapW(LPCWSTR pszSound
, HMODULE hmod
, DWORD fdwSound
)
2843 GET_FUNC(pPlaySoundW
, winmm
, "PlaySoundW", FALSE
);
2844 return pPlaySoundW(pszSound
, hmod
, fdwSound
);
2847 /*************************************************************************
2850 BOOL WINAPI
SHGetIniStringW(LPSTR str1
, LPSTR str2
, LPSTR pStr
, DWORD some_len
, LPCSTR lpStr2
)
2853 * str1: "I" "I" pushl esp+0x20
2854 * str2: "U" "I" pushl 0x77c93810
2855 * (is "I" and "U" "integer" and "unsigned" ??)
2857 * pStr: "" "" pushl eax
2858 * some_len: 0x824 0x104 pushl 0x824
2859 * lpStr2: "%l" "%l" pushl esp+0xc
2861 * shlwapi. StrCpyNW(lpStr2, irrelevant_var, 0x104);
2862 * LocalAlloc(0x00, some_len) -> irrelevant_var
2863 * LocalAlloc(0x40, irrelevant_len) -> pStr
2864 * shlwapi.294(str1, str2, pStr, some_len, lpStr2);
2865 * shlwapi.PathRemoveBlanksW(pStr);
2867 FIXME("('%s', '%s', '%s', %08lx, '%s'): stub!\n", str1
, str2
, pStr
, some_len
, lpStr2
);
2871 /*************************************************************************
2874 * Called by ICQ2000b install via SHDOCVW:
2875 * str1: "InternetShortcut"
2876 * x: some unknown pointer
2877 * str2: "http://free.aol.com/tryaolfree/index.adp?139269"
2878 * str3: "C:\\WINDOWS\\Desktop.new2\\Free AOL & Unlimited Internet.url"
2880 * In short: this one maybe creates a desktop link :-)
2882 BOOL WINAPI
SHSetIniStringW(LPWSTR str1
, LPVOID x
, LPWSTR str2
, LPWSTR str3
)
2884 FIXME("('%s', %p, '%s', '%s'), stub.\n", debugstr_w(str1
), x
, debugstr_w(str2
), debugstr_w(str3
));
2888 /*************************************************************************
2893 BOOL WINAPI
ExtTextOutWrapW(HDC hdc
, INT x
, INT y
, UINT flags
, const RECT
*lprect
,
2894 LPCWSTR str
, UINT count
, const INT
*lpDx
)
2896 GET_FUNC(pCOMCTL32_417
, comctl32
, (LPCSTR
)417, FALSE
);
2897 return pCOMCTL32_417(hdc
, x
, y
, flags
, lprect
, str
, count
, lpDx
);
2900 /*************************************************************************
2903 * See SHGetFileInfoW.
2905 DWORD WINAPI
SHGetFileInfoWrapW(LPCWSTR path
, DWORD dwFileAttributes
,
2906 SHFILEINFOW
*psfi
, UINT sizeofpsfi
, UINT flags
)
2908 GET_FUNC(pSHGetFileInfoW
, shell32
, "SHGetFileInfoW", 0);
2909 return pSHGetFileInfoW(path
, dwFileAttributes
, psfi
, sizeofpsfi
, flags
);
2912 /*************************************************************************
2915 * See DragQueryFileW.
2917 UINT WINAPI
DragQueryFileWrapW(HDROP hDrop
, UINT lFile
, LPWSTR lpszFile
, UINT lLength
)
2919 GET_FUNC(pDragQueryFileW
, shell32
, "DragQueryFileW", 0);
2920 return pDragQueryFileW(hDrop
, lFile
, lpszFile
, lLength
);
2923 /*************************************************************************
2926 * See SHBrowseForFolderW.
2928 LPITEMIDLIST WINAPI
SHBrowseForFolderWrapW(LPBROWSEINFOW lpBi
)
2930 GET_FUNC(pSHBrowseForFolderW
, shell32
, "SHBrowseForFolderW", NULL
);
2931 return pSHBrowseForFolderW(lpBi
);
2934 /*************************************************************************
2937 * See SHGetPathFromIDListW.
2939 BOOL WINAPI
SHGetPathFromIDListWrapW(LPCITEMIDLIST pidl
,LPWSTR pszPath
)
2941 GET_FUNC(pSHGetPathFromIDListW
, shell32
, "SHGetPathFromIDListW", 0);
2942 return pSHGetPathFromIDListW(pidl
, pszPath
);
2945 /*************************************************************************
2948 * See ShellExecuteExW.
2950 BOOL WINAPI
ShellExecuteExWrapW(LPSHELLEXECUTEINFOW lpExecInfo
)
2952 GET_FUNC(pShellExecuteExW
, shell32
, "ShellExecuteExW", FALSE
);
2953 return pShellExecuteExW(lpExecInfo
);
2956 /*************************************************************************
2959 * See SHFileOperationW.
2961 HICON WINAPI
SHFileOperationWrapW(LPSHFILEOPSTRUCTW lpFileOp
)
2963 GET_FUNC(pSHFileOperationW
, shell32
, "SHFileOperationW", 0);
2964 return pSHFileOperationW(lpFileOp
);
2967 /*************************************************************************
2970 * See ExtractIconExW.
2972 UINT WINAPI
ExtractIconExWrapW(LPCWSTR lpszFile
, INT nIconIndex
, HICON
*phiconLarge
,
2973 HICON
*phiconSmall
, UINT nIcons
)
2975 GET_FUNC(pExtractIconExW
, shell32
, "ExtractIconExW", 0);
2976 return pExtractIconExW(lpszFile
, nIconIndex
, phiconLarge
, phiconSmall
, nIcons
);
2979 /*************************************************************************
2983 LONG WINAPI
SHInterlockedCompareExchange( PLONG dest
, LONG xchg
, LONG compare
)
2985 return InterlockedCompareExchange(dest
, xchg
, compare
);
2988 /*************************************************************************
2991 * See GetFileVersionInfoSizeW.
2993 DWORD WINAPI
GetFileVersionInfoSizeWrapW(
2999 GET_FUNC(pGetFileVersionInfoSizeW
, version
, "GetFileVersionInfoSizeW", 0);
3000 ret
= pGetFileVersionInfoSizeW(x
, y
);
3004 /*************************************************************************
3007 * See GetFileVersionInfoW.
3009 BOOL WINAPI
GetFileVersionInfoWrapW(
3010 LPWSTR w
, /* [in] path to dll */
3011 DWORD x
, /* [in] parm 2 to GetFileVersionInfoA */
3012 DWORD y
, /* [in] return value from SHLWAPI_350() - assume length */
3013 LPVOID z
) /* [in/out] buffer (+0x208 sent to GetFileVersionInfoA()) */
3015 GET_FUNC(pGetFileVersionInfoW
, version
, "GetFileVersionInfoW", 0);
3016 return pGetFileVersionInfoW(w
, x
, y
-0x208, (char*)z
+0x208);
3019 /*************************************************************************
3022 * See VerQueryValueW.
3024 WORD WINAPI
VerQueryValueWrapW(
3025 LPVOID w
, /* [in] Buffer from SHLWAPI_351() */
3026 LPWSTR x
, /* [in] Value to retrieve - converted and passed to VerQueryValueA() as #2 */
3027 LPVOID y
, /* [out] Ver buffer - passed to VerQueryValueA as #3 */
3028 UINT
* z
) /* [in] Ver length - passed to VerQueryValueA as #4 */
3030 GET_FUNC(pVerQueryValueW
, version
, "VerQueryValueW", 0);
3031 return pVerQueryValueW((char*)w
+0x208, x
, y
, z
);
3034 #define IsIface(type) SUCCEEDED((hRet = IUnknown_QueryInterface(lpUnknown, &IID_##type, (void**)&lpObj)))
3035 #define IShellBrowser_EnableModeless IShellBrowser_EnableModelessSB
3036 #define EnableModeless(type) type##_EnableModeless((type*)lpObj, bModeless)
3038 /*************************************************************************
3041 * Change the modality of a shell object.
3044 * lpUnknown [I] Object to make modeless
3045 * bModeless [I] TRUE=Make modeless, FALSE=Make modal
3048 * Success: S_OK. The modality lpUnknown is changed.
3049 * Failure: An HRESULT error code indicating the error.
3052 * lpUnknown must support the IOleInPlaceFrame interface, the
3053 * IInternetSecurityMgrSite interface, the IShellBrowser interface
3054 * or the IDocHostUIHandler interface, or this call fails.
3056 HRESULT WINAPI
IUnknown_EnableModeless(IUnknown
*lpUnknown
, BOOL bModeless
)
3061 TRACE("(%p,%d)\n", lpUnknown
, bModeless
);
3066 if (IsIface(IOleInPlaceFrame
))
3067 EnableModeless(IOleInPlaceFrame
);
3068 else if (IsIface(IShellBrowser
))
3069 EnableModeless(IShellBrowser
);
3071 /* FIXME: Wine has no headers for these objects yet */
3072 else if (IsIface(IInternetSecurityMgrSite
))
3073 EnableModeless(IInternetSecurityMgrSite
);
3074 else if (IsIface(IDocHostUIHandler
))
3075 EnableModeless(IDocHostUIHandler
);
3080 IUnknown_Release(lpObj
);
3084 /*************************************************************************
3087 * See SHGetNewLinkInfoW.
3089 BOOL WINAPI
SHGetNewLinkInfoWrapW(LPCWSTR pszLinkTo
, LPCWSTR pszDir
, LPWSTR pszName
,
3090 BOOL
*pfMustCopy
, UINT uFlags
)
3092 GET_FUNC(pSHGetNewLinkInfoW
, shell32
, "SHGetNewLinkInfoW", FALSE
);
3093 return pSHGetNewLinkInfoW(pszLinkTo
, pszDir
, pszName
, pfMustCopy
, uFlags
);
3096 /*************************************************************************
3099 * See SHDefExtractIconW.
3101 UINT WINAPI
SHDefExtractIconWrapW(LPCWSTR pszIconFile
, int iIndex
, UINT uFlags
, HICON
* phiconLarge
,
3102 HICON
* phiconSmall
, UINT nIconSize
)
3104 GET_FUNC(pSHDefExtractIconW
, shell32
, "SHDefExtractIconW", 0);
3105 return pSHDefExtractIconW(pszIconFile
, iIndex
, uFlags
, phiconLarge
, phiconSmall
, nIconSize
);
3108 /*************************************************************************
3111 * Get and show a context menu from a shell folder.
3114 * hWnd [I] Window displaying the shell folder
3115 * lpFolder [I] IShellFolder interface
3116 * lpApidl [I] Id for the particular folder desired
3117 * bInvokeDefault [I] Whether to invoke the default menu item
3120 * Success: S_OK. If bInvokeDefault is TRUE, the default menu action was
3122 * Failure: An HRESULT error code indicating the error.
3124 HRESULT WINAPI
SHInvokeCommand(HWND hWnd
, IShellFolder
* lpFolder
, LPCITEMIDLIST lpApidl
, BOOL bInvokeDefault
)
3126 IContextMenu
*iContext
;
3127 HRESULT hRet
= E_FAIL
;
3129 TRACE("(%p,%p,%p,%d)\n", hWnd
, lpFolder
, lpApidl
, bInvokeDefault
);
3134 /* Get the context menu from the shell folder */
3135 hRet
= IShellFolder_GetUIObjectOf(lpFolder
, hWnd
, 1, &lpApidl
,
3136 &IID_IContextMenu
, 0, (void**)&iContext
);
3137 if (SUCCEEDED(hRet
))
3140 if ((hMenu
= CreatePopupMenu()))
3143 DWORD dwDefaultId
= 0;
3145 /* Add the context menu entries to the popup */
3146 hQuery
= IContextMenu_QueryContextMenu(iContext
, hMenu
, 0, 1, 0x7FFF,
3147 bInvokeDefault
? CMF_NORMAL
: CMF_DEFAULTONLY
);
3149 if (SUCCEEDED(hQuery
))
3151 if (bInvokeDefault
&&
3152 (dwDefaultId
= GetMenuDefaultItem(hMenu
, 0, 0)) != 0xFFFFFFFF)
3154 CMINVOKECOMMANDINFO cmIci
;
3155 /* Invoke the default item */
3156 memset(&cmIci
,0,sizeof(cmIci
));
3157 cmIci
.cbSize
= sizeof(cmIci
);
3158 cmIci
.fMask
= CMIC_MASK_ASYNCOK
;
3160 cmIci
.lpVerb
= MAKEINTRESOURCEA(dwDefaultId
);
3161 cmIci
.nShow
= SW_SCROLLCHILDREN
;
3163 hRet
= IContextMenu_InvokeCommand(iContext
, &cmIci
);
3168 IContextMenu_Release(iContext
);
3173 /*************************************************************************
3178 HICON WINAPI
ExtractIconWrapW(HINSTANCE hInstance
, LPCWSTR lpszExeFileName
,
3181 GET_FUNC(pExtractIconW
, shell32
, "ExtractIconW", NULL
);
3182 return pExtractIconW(hInstance
, lpszExeFileName
, nIconIndex
);
3185 /*************************************************************************
3188 LANGID WINAPI
MLGetUILanguage()
3191 /* FIXME: This should be a forward in the .spec file to the win2k function
3192 * kernel32.GetUserDefaultUILanguage, however that function isn't there yet.
3194 return GetUserDefaultLangID();
3197 /*************************************************************************
3200 * Load a library from the directory of a particular process.
3203 * new_mod [I] Library name
3204 * inst_hwnd [I] Module whose directory is to be used
3205 * dwFlags [I] Flags controlling the load
3208 * Success: A handle to the loaded module
3209 * Failure: A NULL handle.
3211 HMODULE WINAPI
MLLoadLibraryA(LPCSTR new_mod
, HMODULE inst_hwnd
, DWORD dwFlags
)
3213 /* FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
3215 * FIXME: Native shows calls to:
3216 * SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
3218 * RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
3219 * RegQueryValueExA for "LPKInstalled"
3221 * RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
3222 * RegQueryValueExA for "ResourceLocale"
3224 * RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
3225 * RegQueryValueExA for "Locale"
3227 * and then tests the Locale ("en" for me).
3229 * after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
3231 CHAR mod_path
[2*MAX_PATH
];
3235 FIXME("(%s,%p,0x%08lx) semi-stub!\n", debugstr_a(new_mod
), inst_hwnd
, dwFlags
);
3236 len
= GetModuleFileNameA(inst_hwnd
, mod_path
, sizeof(mod_path
));
3237 if (!len
|| len
>= sizeof(mod_path
)) return NULL
;
3239 ptr
= strrchr(mod_path
, '\\');
3241 strcpy(ptr
+1, new_mod
);
3242 TRACE("loading %s\n", debugstr_a(mod_path
));
3243 return LoadLibraryA(mod_path
);
3248 /*************************************************************************
3251 * Unicode version of MLLoadLibraryA.
3253 HMODULE WINAPI
MLLoadLibraryW(LPCWSTR new_mod
, HMODULE inst_hwnd
, DWORD dwFlags
)
3255 WCHAR mod_path
[2*MAX_PATH
];
3259 FIXME("(%s,%p,0x%08lx) semi-stub!\n", debugstr_w(new_mod
), inst_hwnd
, dwFlags
);
3260 len
= GetModuleFileNameW(inst_hwnd
, mod_path
, sizeof(mod_path
) / sizeof(WCHAR
));
3261 if (!len
|| len
>= sizeof(mod_path
) / sizeof(WCHAR
)) return NULL
;
3263 ptr
= strrchrW(mod_path
, '\\');
3265 strcpyW(ptr
+1, new_mod
);
3266 TRACE("loading %s\n", debugstr_w(mod_path
));
3267 return LoadLibraryW(mod_path
);
3272 /*************************************************************************
3273 * ColorAdjustLuma [SHLWAPI.@]
3275 * Adjust the luminosity of a color
3278 * cRGB [I] RGB value to convert
3279 * dwLuma [I] Luma adjustment
3280 * bUnknown [I] Unknown
3283 * The adjusted RGB color.
3285 COLORREF WINAPI
ColorAdjustLuma(COLORREF cRGB
, int dwLuma
, BOOL bUnknown
)
3287 TRACE("(0x%8lx,%d,%d)\n", cRGB
, dwLuma
, bUnknown
);
3293 ColorRGBToHLS(cRGB
, &wH
, &wL
, &wS
);
3295 FIXME("Ignoring luma adjustment\n");
3297 /* FIXME: The ajdustment is not linear */
3299 cRGB
= ColorHLSToRGB(wH
, wL
, wS
);
3304 /*************************************************************************
3307 * See GetSaveFileNameW.
3309 BOOL WINAPI
GetSaveFileNameWrapW(LPOPENFILENAMEW ofn
)
3311 GET_FUNC(pGetSaveFileNameW
, comdlg32
, "GetSaveFileNameW", FALSE
);
3312 return pGetSaveFileNameW(ofn
);
3315 /*************************************************************************
3318 * See WNetRestoreConnectionW.
3320 DWORD WINAPI
WNetRestoreConnectionWrapW(HWND hwndOwner
, LPWSTR lpszDevice
)
3322 GET_FUNC(pWNetRestoreConnectionW
, mpr
, "WNetRestoreConnectionW", 0);
3323 return pWNetRestoreConnectionW(hwndOwner
, lpszDevice
);
3326 /*************************************************************************
3329 * See WNetGetLastErrorW.
3331 DWORD WINAPI
WNetGetLastErrorWrapW(LPDWORD lpError
, LPWSTR lpErrorBuf
, DWORD nErrorBufSize
,
3332 LPWSTR lpNameBuf
, DWORD nNameBufSize
)
3334 GET_FUNC(pWNetGetLastErrorW
, mpr
, "WNetGetLastErrorW", 0);
3335 return pWNetGetLastErrorW(lpError
, lpErrorBuf
, nErrorBufSize
, lpNameBuf
, nNameBufSize
);
3338 /*************************************************************************
3341 * See PageSetupDlgW.
3343 BOOL WINAPI
PageSetupDlgWrapW(LPPAGESETUPDLGW pagedlg
)
3345 GET_FUNC(pPageSetupDlgW
, comdlg32
, "PageSetupDlgW", FALSE
);
3346 return pPageSetupDlgW(pagedlg
);
3349 /*************************************************************************
3354 BOOL WINAPI
PrintDlgWrapW(LPPRINTDLGW printdlg
)
3356 GET_FUNC(pPrintDlgW
, comdlg32
, "PrintDlgW", FALSE
);
3357 return pPrintDlgW(printdlg
);
3360 /*************************************************************************
3363 * See GetOpenFileNameW.
3365 BOOL WINAPI
GetOpenFileNameWrapW(LPOPENFILENAMEW ofn
)
3367 GET_FUNC(pGetOpenFileNameW
, comdlg32
, "GetOpenFileNameW", FALSE
);
3368 return pGetOpenFileNameW(ofn
);
3371 /* INTERNAL: Map from HLS color space to RGB */
3372 static WORD WINAPI
ConvertHue(int wHue
, WORD wMid1
, WORD wMid2
)
3374 wHue
= wHue
> 240 ? wHue
- 240 : wHue
< 0 ? wHue
+ 240 : wHue
;
3378 else if (wHue
> 120)
3383 return ((wHue
* (wMid2
- wMid1
) + 20) / 40) + wMid1
;
3386 /* Convert to RGB and scale into RGB range (0..255) */
3387 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
3389 /*************************************************************************
3390 * ColorHLSToRGB [SHLWAPI.@]
3392 * Convert from hls color space into an rgb COLORREF.
3395 * wHue [I] Hue amount
3396 * wLuminosity [I] Luminosity amount
3397 * wSaturation [I] Saturation amount
3400 * A COLORREF representing the converted color.
3403 * Input hls values are constrained to the range (0..240).
3405 COLORREF WINAPI
ColorHLSToRGB(WORD wHue
, WORD wLuminosity
, WORD wSaturation
)
3411 WORD wGreen
, wBlue
, wMid1
, wMid2
;
3413 if (wLuminosity
> 120)
3414 wMid2
= wSaturation
+ wLuminosity
- (wSaturation
* wLuminosity
+ 120) / 240;
3416 wMid2
= ((wSaturation
+ 240) * wLuminosity
+ 120) / 240;
3418 wMid1
= wLuminosity
* 2 - wMid2
;
3420 wRed
= GET_RGB(wHue
+ 80);
3421 wGreen
= GET_RGB(wHue
);
3422 wBlue
= GET_RGB(wHue
- 80);
3424 return RGB(wRed
, wGreen
, wBlue
);
3427 wRed
= wLuminosity
* 255 / 240;
3428 return RGB(wRed
, wRed
, wRed
);
3431 /*************************************************************************
3434 * Get the current docking status of the system.
3437 * dwFlags [I] DOCKINFO_ flags from "winbase.h", unused
3440 * One of DOCKINFO_UNDOCKED, DOCKINFO_UNDOCKED, or 0 if the system is not
3443 DWORD WINAPI
SHGetMachineInfo(DWORD dwFlags
)
3445 HW_PROFILE_INFOA hwInfo
;
3447 TRACE("(0x%08lx)\n", dwFlags
);
3449 GetCurrentHwProfileA(&hwInfo
);
3450 switch (hwInfo
.dwDockInfo
& (DOCKINFO_DOCKED
|DOCKINFO_UNDOCKED
))
3452 case DOCKINFO_DOCKED
:
3453 case DOCKINFO_UNDOCKED
:
3454 return hwInfo
.dwDockInfo
& (DOCKINFO_DOCKED
|DOCKINFO_UNDOCKED
);
3460 /*************************************************************************
3463 * Function seems to do FreeLibrary plus other things.
3465 * FIXME native shows the following calls:
3466 * RtlEnterCriticalSection
3468 * GetProcAddress(Comctl32??, 150L)
3470 * RtlLeaveCriticalSection
3471 * followed by the FreeLibrary.
3472 * The above code may be related to .377 above.
3474 BOOL WINAPI
MLFreeLibrary(HMODULE hModule
)
3476 FIXME("(%p) semi-stub\n", hModule
);
3477 return FreeLibrary(hModule
);
3480 /*************************************************************************
3483 BOOL WINAPI
SHFlushSFCacheWrap(void) {
3488 /*************************************************************************
3490 * FIXME I have no idea what this function does or what its arguments are.
3492 BOOL WINAPI
MLIsMLHInstance(HINSTANCE hInst
)
3494 FIXME("(%p) stub\n", hInst
);
3499 /*************************************************************************
3502 DWORD WINAPI
MLSetMLHInstance(HINSTANCE hInst
, HANDLE hHeap
)
3504 FIXME("(%p,%p) stub\n", hInst
, hHeap
);
3505 return E_FAIL
; /* This is what is used if shlwapi not loaded */
3508 /*************************************************************************
3511 DWORD WINAPI
MLClearMLHInstance(DWORD x
)
3513 FIXME("(0x%08lx)stub\n", x
);
3517 /*************************************************************************
3520 * Convert an Unicode string CLSID into a CLSID.
3523 * idstr [I] string containing a CLSID in text form
3524 * id [O] CLSID extracted from the string
3527 * S_OK on success or E_INVALIDARG on failure
3530 * This is really CLSIDFromString() which is exported by ole32.dll,
3531 * however the native shlwapi.dll does *not* import ole32. Nor does
3532 * ole32.dll import this ordinal from shlwapi. Therefore we must conclude
3533 * that MS duplicated the code for CLSIDFromString(), and yes they did, only
3534 * it returns an E_INVALIDARG error code on failure.
3535 * This is a duplicate (with changes for Unicode) of CLSIDFromString16()
3536 * in "dlls/ole32/compobj.c".
3538 HRESULT WINAPI
CLSIDFromStringWrap(LPCWSTR idstr
, CLSID
*id
)
3546 memset(id
, 0, sizeof(CLSID
));
3549 else { /* validate the CLSID string */
3551 if (strlenW(s
) != 38)
3552 return E_INVALIDARG
;
3554 if ((s
[0]!=L
'{') || (s
[9]!=L
'-') || (s
[14]!=L
'-') || (s
[19]!=L
'-') || (s
[24]!=L
'-') || (s
[37]!=L
'}'))
3555 return E_INVALIDARG
;
3557 for (i
=1; i
<37; i
++)
3559 if ((i
== 9)||(i
== 14)||(i
== 19)||(i
== 24))
3561 if (!(((s
[i
] >= L
'0') && (s
[i
] <= L
'9')) ||
3562 ((s
[i
] >= L
'a') && (s
[i
] <= L
'f')) ||
3563 ((s
[i
] >= L
'A') && (s
[i
] <= L
'F')))
3565 return E_INVALIDARG
;
3569 TRACE("%s -> %p\n", debugstr_w(s
), id
);
3571 /* quick lookup table */
3572 memset(table
, 0, 256*sizeof(WCHAR
));
3574 for (i
= 0; i
< 10; i
++) {
3577 for (i
= 0; i
< 6; i
++) {
3578 table
['A' + i
] = i
+10;
3579 table
['a' + i
] = i
+10;
3582 /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
3586 s
++; /* skip leading brace */
3587 for (i
= 0; i
< 4; i
++) {
3588 p
[3 - i
] = table
[*s
]<<4 | table
[*(s
+1)];
3594 for (i
= 0; i
< 2; i
++) {
3595 p
[1-i
] = table
[*s
]<<4 | table
[*(s
+1)];
3601 for (i
= 0; i
< 2; i
++) {
3602 p
[1-i
] = table
[*s
]<<4 | table
[*(s
+1)];
3608 /* these are just sequential bytes */
3609 for (i
= 0; i
< 2; i
++) {
3610 *p
++ = table
[*s
]<<4 | table
[*(s
+1)];
3615 for (i
= 0; i
< 6; i
++) {
3616 *p
++ = table
[*s
]<<4 | table
[*(s
+1)];
3623 /*************************************************************************
3626 * Determine if the OS supports a given feature.
3629 * dwFeature [I] Feature requested (undocumented)
3632 * TRUE If the feature is available.
3633 * FALSE If the feature is not available.
3635 BOOL WINAPI
IsOS(DWORD feature
)
3637 OSVERSIONINFOA osvi
;
3638 DWORD platform
, majorv
, minorv
;
3640 osvi
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFOA
);
3641 if(!GetVersionExA(&osvi
)) {
3642 ERR("GetVersionEx failed");
3646 majorv
= osvi
.dwMajorVersion
;
3647 minorv
= osvi
.dwMinorVersion
;
3648 platform
= osvi
.dwPlatformId
;
3650 #define ISOS_RETURN(x) \
3651 TRACE("(0x%lx) ret=%d\n",feature,(x)); \
3655 case OS_WIN32SORGREATER
:
3656 ISOS_RETURN(platform
== VER_PLATFORM_WIN32s
3657 || platform
== VER_PLATFORM_WIN32_WINDOWS
)
3659 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3660 case OS_WIN95ORGREATER
:
3661 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
)
3662 case OS_NT4ORGREATER
:
3663 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 4)
3664 case OS_WIN2000ORGREATER_ALT
:
3665 case OS_WIN2000ORGREATER
:
3666 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3667 case OS_WIN98ORGREATER
:
3668 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
>= 10)
3670 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
== 10)
3672 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3673 case OS_WIN2000SERVER
:
3674 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3675 case OS_WIN2000ADVSERVER
:
3676 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3677 case OS_WIN2000DATACENTER
:
3678 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3679 case OS_WIN2000TERMINAL
:
3680 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& (minorv
== 0 || minorv
== 1))
3682 FIXME("(OS_EMBEDDED) What should we return here?\n");
3684 case OS_TERMINALCLIENT
:
3685 FIXME("(OS_TERMINALCLIENT) What should we return here?\n");
3687 case OS_TERMINALREMOTEADMIN
:
3688 FIXME("(OS_TERMINALREMOTEADMIN) What should we return here?\n");
3691 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
== 0)
3692 case OS_MEORGREATER
:
3693 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_WINDOWS
&& minorv
>= 90)
3694 case OS_XPORGREATER
:
3695 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5 && minorv
>= 1)
3697 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5 && minorv
>= 1)
3698 case OS_PROFESSIONAL
:
3699 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3701 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3703 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& majorv
>= 5)
3705 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3706 case OS_TERMINALSERVER
:
3707 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3708 case OS_PERSONALTERMINALSERVER
:
3709 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
&& minorv
>= 1 && majorv
>= 5)
3710 case OS_FASTUSERSWITCHING
:
3711 FIXME("(OS_FASTUSERSWITCHING) What should we return here?\n");
3713 case OS_WELCOMELOGONUI
:
3714 FIXME("(OS_WELCOMELOGONUI) What should we return here?\n");
3716 case OS_DOMAINMEMBER
:
3717 FIXME("(OS_DOMAINMEMBER) What should we return here?\n");
3720 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3722 FIXME("(OS_WOW6432) Should we check this?\n");
3725 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3726 case OS_SMALLBUSINESSSERVER
:
3727 ISOS_RETURN(platform
== VER_PLATFORM_WIN32_NT
)
3729 FIXME("(OS_TABLEPC) What should we return here?\n");
3731 case OS_SERVERADMINUI
:
3732 FIXME("(OS_SERVERADMINUI) What should we return here?\n");
3734 case OS_MEDIACENTER
:
3735 FIXME("(OS_MEDIACENTER) What should we return here?\n");
3738 FIXME("(OS_APPLIANCE) What should we return here?\n");
3744 WARN("(0x%lx) unknown parameter\n",feature
);
3749 /*************************************************************************
3750 * ColorRGBToHLS [SHLWAPI.@]
3752 * Convert an rgb COLORREF into the hls color space.
3755 * cRGB [I] Source rgb value
3756 * pwHue [O] Destination for converted hue
3757 * pwLuminance [O] Destination for converted luminance
3758 * pwSaturation [O] Destination for converted saturation
3761 * Nothing. pwHue, pwLuminance and pwSaturation are set to the converted
3765 * Output HLS values are constrained to the range (0..240).
3766 * For Achromatic conversions, Hue is set to 160.
3768 VOID WINAPI
ColorRGBToHLS(COLORREF cRGB
, LPWORD pwHue
,
3769 LPWORD pwLuminance
, LPWORD pwSaturation
)
3771 int wR
, wG
, wB
, wMax
, wMin
, wHue
, wLuminosity
, wSaturation
;
3773 TRACE("(%08lx,%p,%p,%p)\n", cRGB
, pwHue
, pwLuminance
, pwSaturation
);
3775 wR
= GetRValue(cRGB
);
3776 wG
= GetGValue(cRGB
);
3777 wB
= GetBValue(cRGB
);
3779 wMax
= max(wR
, max(wG
, wB
));
3780 wMin
= min(wR
, min(wG
, wB
));
3783 wLuminosity
= ((wMax
+ wMin
) * 240 + 255) / 510;
3787 /* Achromatic case */
3789 /* Hue is now unrepresentable, but this is what native returns... */
3794 /* Chromatic case */
3795 int wDelta
= wMax
- wMin
, wRNorm
, wGNorm
, wBNorm
;
3798 if (wLuminosity
<= 120)
3799 wSaturation
= ((wMax
+ wMin
)/2 + wDelta
* 240) / (wMax
+ wMin
);
3801 wSaturation
= ((510 - wMax
- wMin
)/2 + wDelta
* 240) / (510 - wMax
- wMin
);
3804 wRNorm
= (wDelta
/2 + wMax
* 40 - wR
* 40) / wDelta
;
3805 wGNorm
= (wDelta
/2 + wMax
* 40 - wG
* 40) / wDelta
;
3806 wBNorm
= (wDelta
/2 + wMax
* 40 - wB
* 40) / wDelta
;
3809 wHue
= wBNorm
- wGNorm
;
3810 else if (wG
== wMax
)
3811 wHue
= 80 + wRNorm
- wBNorm
;
3813 wHue
= 160 + wGNorm
- wRNorm
;
3816 else if (wHue
> 240)
3822 *pwLuminance
= wLuminosity
;
3824 *pwSaturation
= wSaturation
;
3827 /*************************************************************************
3828 * SHCreateShellPalette [SHLWAPI.@]
3830 HPALETTE WINAPI
SHCreateShellPalette(HDC hdc
)
3833 return CreateHalftonePalette(hdc
);
3836 /*************************************************************************
3837 * SHGetInverseCMAP (SHLWAPI.@)
3839 * Get an inverse color map table.
3842 * lpCmap [O] Destination for color map
3843 * dwSize [I] Size of memory pointed to by lpCmap
3847 * Failure: E_POINTER, If lpCmap is invalid.
3848 * E_INVALIDARG, If dwFlags is invalid
3849 * E_OUTOFMEMORY, If there is no memory available
3852 * dwSize may only be CMAP_PTR_SIZE (4) or CMAP_SIZE (8192).
3853 * If dwSize = CMAP_PTR_SIZE, *lpCmap is set to the address of this DLL's
3855 * If dwSize = CMAP_SIZE, lpCmap is filled with a copy of the data from
3856 * this DLL's internal CMap.
3858 HRESULT WINAPI
SHGetInverseCMAP(LPDWORD dest
, DWORD dwSize
)
3861 FIXME(" - returning bogus address for SHGetInverseCMAP\n");
3862 *dest
= (DWORD
)0xabba1249;
3865 FIXME("(%p, %#lx) stub\n", dest
, dwSize
);
3869 /*************************************************************************
3870 * SHIsLowMemoryMachine [SHLWAPI.@]
3872 * Determine if the current computer has low memory.
3878 * TRUE if the users machine has 16 Megabytes of memory or less,
3881 BOOL WINAPI
SHIsLowMemoryMachine (DWORD x
)
3883 FIXME("(0x%08lx) stub\n", x
);
3887 /*************************************************************************
3888 * GetMenuPosFromID [SHLWAPI.@]
3890 * Return the position of a menu item from its Id.
3893 * hMenu [I] Menu containing the item
3894 * wID [I] Id of the menu item
3897 * Success: The index of the menu item in hMenu.
3898 * Failure: -1, If the item is not found.
3900 INT WINAPI
GetMenuPosFromID(HMENU hMenu
, UINT wID
)
3903 INT nCount
= GetMenuItemCount(hMenu
), nIter
= 0;
3905 while (nIter
< nCount
)
3908 if (!GetMenuItemInfoA(hMenu
, nIter
, TRUE
, &mi
) && mi
.wID
== wID
)
3915 /*************************************************************************
3918 * Same as SHLWAPI.GetMenuPosFromID
3920 DWORD WINAPI
SHMenuIndexFromID(HMENU hMenu
, UINT uID
)
3922 return GetMenuPosFromID(hMenu
, uID
);
3926 /*************************************************************************
3929 VOID WINAPI
FixSlashesAndColonW(LPWSTR lpwstr
)
3940 /*************************************************************************
3943 DWORD WINAPI
SHGetAppCompatFlags(DWORD Unknown
)
3950 /*************************************************************************
3953 HRESULT WINAPI
SHCoCreateInstanceAC(REFCLSID rclsid
, LPUNKNOWN pUnkOuter
,
3954 DWORD dwClsContext
, REFIID iid
, LPVOID
*ppv
)
3956 return CoCreateInstance(rclsid
, pUnkOuter
, dwClsContext
, iid
, ppv
);
3959 /*************************************************************************
3960 * SHSkipJunction [SHLWAPI.@]
3962 * Determine if a bind context can be bound to an object
3965 * pbc [I] Bind context to check
3966 * pclsid [I] CLSID of object to be bound to
3969 * TRUE: If it is safe to bind
3970 * FALSE: If pbc is invalid or binding would not be safe
3973 BOOL WINAPI
SHSkipJunction(IBindCtx
*pbc
, const CLSID
*pclsid
)
3975 static const WCHAR szSkipBinding
[] = { 'S','k','i','p',' ',
3976 'B','i','n','d','i','n','g',' ','C','L','S','I','D','\0' };
3983 if (SUCCEEDED(IBindCtx_GetObjectParam(pbc
, (LPOLESTR
)szSkipBinding
, &lpUnk
)))
3987 if (SUCCEEDED(IUnknown_GetClassID(lpUnk
, &clsid
)) &&
3988 IsEqualGUID(pclsid
, &clsid
))
3991 IUnknown_Release(lpUnk
);
3997 /***********************************************************************
3998 * SHGetShellKey (SHLWAPI.@)
4000 DWORD WINAPI
SHGetShellKey(DWORD a
, DWORD b
, DWORD c
)
4002 FIXME("(%lx, %lx, %lx): stub\n", a
, b
, c
);
4006 /***********************************************************************
4007 * SHQueueUserWorkItem (SHLWAPI.@)
4009 HRESULT WINAPI
SHQueueUserWorkItem(DWORD a
, DWORD b
, DWORD c
, DWORD d
, DWORD e
, DWORD f
, DWORD g
)
4011 FIXME("(%lx, %lx, %lx, %lx, %lx, %lx, %lx): stub\n", a
, b
, c
, d
, e
, f
, g
);
4015 /***********************************************************************
4016 * IUnknown_OnFocusChangeIS (SHLWAPI.@)
4018 DWORD WINAPI
IUnknown_OnFocusChangeIS(IUnknown
* pUnk
, IUnknown
* pFocusObject
, BOOL bChange
)
4020 FIXME("(%p, %p, %s)\n", pUnk
, pFocusObject
, bChange
? "TRUE" : "FALSE");
4023 IInputObjectSite * pIOS = NULL;
4024 if (SUCCEEDED(IUnknown_QueryInterface(pUnk, &IID_IInputObjectSite, (void **)&pIOS))
4025 IInputObjectSite_OnFocusChangeIS(pIOS, pFocusObject, bChange);
4031 /***********************************************************************
4032 * SHGetValueW (SHLWAPI.@)
4034 HRESULT WINAPI
SKGetValueW(DWORD a
, LPWSTR b
, LPWSTR c
, DWORD d
, DWORD e
, DWORD f
)
4036 FIXME("(%lx, %s, %s, %lx, %lx, %lx): stub\n", a
, debugstr_w(b
), debugstr_w(c
), d
, e
, f
);
4040 typedef HRESULT (WINAPI
*DllGetVersion_func
)(DLLVERSIONINFO
*);
4042 /***********************************************************************
4043 * GetUIVersion (SHLWAPI.452)
4045 DWORD WINAPI
GetUIVersion(void)
4047 static DWORD version
;
4051 DllGetVersion_func pDllGetVersion
;
4052 HMODULE dll
= LoadLibraryA("shell32.dll");
4055 pDllGetVersion
= (DllGetVersion_func
)GetProcAddress(dll
, "DllGetVersion");
4059 dvi
.cbSize
= sizeof(DLLVERSIONINFO
);
4060 if (pDllGetVersion(&dvi
) == S_OK
) version
= dvi
.dwMajorVersion
;
4063 if (!version
) version
= 3; /* old shell dlls don't have DllGetVersion */