2 * SHLWAPI ordinal functions
4 * Copyright 1997 Marcus Meissner
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"
39 #include "wine/unicode.h"
40 #include "wine/obj_serviceprovider.h"
41 #include "wine/obj_control.h"
42 #include "wine/obj_connection.h"
43 #include "wine/obj_property.h"
47 #include "wine/debug.h"
52 WINE_DEFAULT_DEBUG_CHANNEL(shell
);
54 /* Get a function pointer from a DLL handle */
55 #define GET_FUNC(func, module, name, fail) \
58 if (!SHLWAPI_h##module && !(SHLWAPI_h##module = LoadLibraryA(#module ".dll"))) return fail; \
59 if (!(func = (void*)GetProcAddress(SHLWAPI_h##module, name))) return fail; \
63 /* DLL handles for late bound calls */
64 extern HINSTANCE shlwapi_hInstance
;
65 extern HMODULE SHLWAPI_hshell32
;
66 extern HMODULE SHLWAPI_hwinmm
;
67 extern HMODULE SHLWAPI_hcomdlg32
;
68 extern HMODULE SHLWAPI_hcomctl32
;
69 extern HMODULE SHLWAPI_hmpr
;
70 extern HMODULE SHLWAPI_hmlang
;
71 extern HMODULE SHLWAPI_hversion
;
73 extern DWORD SHLWAPI_ThreadRef_index
;
75 typedef HANDLE HSHARED
; /* Shared memory */
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 static LPITEMIDLIST (WINAPI
*pSHBrowseForFolderW
)(LPBROWSEINFOW
);
84 static HRESULT (WINAPI
*pConvertINetUnicodeToMultiByte
)(LPDWORD
,DWORD
,LPCWSTR
,LPINT
,LPSTR
,LPINT
);
85 static BOOL (WINAPI
*pPlaySoundW
)(LPCWSTR
, HMODULE
, DWORD
);
86 static DWORD (WINAPI
*pSHGetFileInfoW
)(LPCWSTR
,DWORD
,SHFILEINFOW
*,UINT
,UINT
);
87 static UINT (WINAPI
*pDragQueryFileW
)(HDROP
, UINT
, LPWSTR
, UINT
);
88 static BOOL (WINAPI
*pSHGetPathFromIDListW
)(LPCITEMIDLIST
, LPWSTR
);
89 static BOOL (WINAPI
*pShellExecuteExW
)(LPSHELLEXECUTEINFOW
);
90 static HICON (WINAPI
*pSHFileOperationW
)(LPSHFILEOPSTRUCTW
);
91 static UINT (WINAPI
*pExtractIconExW
)(LPCWSTR
, INT
,HICON
*,HICON
*, UINT
);
92 static BOOL (WINAPI
*pSHGetNewLinkInfoW
)(LPCWSTR
, LPCWSTR
, LPCWSTR
, BOOL
*, UINT
);
93 static HRESULT (WINAPI
*pSHDefExtractIconW
)(LPCWSTR
, int, UINT
, HICON
*, HICON
*, UINT
);
94 static HICON (WINAPI
*pExtractIconW
)(HINSTANCE
, LPCWSTR
, UINT
);
95 static BOOL (WINAPI
*pGetSaveFileNameW
)(LPOPENFILENAMEW
);
96 static DWORD (WINAPI
*pWNetRestoreConnectionW
)(HWND
, LPWSTR
);
97 static DWORD (WINAPI
*pWNetGetLastErrorW
)(LPDWORD
, LPWSTR
, DWORD
, LPWSTR
, DWORD
);
98 static BOOL (WINAPI
*pPageSetupDlgW
)(LPPAGESETUPDLGW
);
99 static BOOL (WINAPI
*pPrintDlgW
)(LPPRINTDLGW
);
100 static BOOL (WINAPI
*pGetOpenFileNameW
)(LPOPENFILENAMEW
);
101 static DWORD (WINAPI
*pGetFileVersionInfoSizeW
)(LPCWSTR
,LPDWORD
);
102 static BOOL (WINAPI
*pGetFileVersionInfoW
)(LPCWSTR
,DWORD
,DWORD
,LPVOID
);
103 static WORD (WINAPI
*pVerQueryValueW
)(LPVOID
,LPCWSTR
,LPVOID
*,UINT
*);
104 static BOOL (WINAPI
*pCOMCTL32_417
)(HDC
,INT
,INT
,UINT
,const RECT
*,LPCWSTR
,UINT
,const INT
*);
105 static HRESULT (WINAPI
*pDllGetVersion
)(DLLVERSIONINFO
*);
108 NOTES: Most functions exported by ordinal seem to be superflous.
109 The reason for these functions to be there is to provide a wrapper
110 for unicode functions to provide these functions on systems without
111 unicode functions eg. win95/win98. Since we have such functions we just
112 call these. If running Wine with native DLL's, some late bound calls may
113 fail. However, its better to implement the functions in the forward DLL
114 and recommend the builtin rather than reimplementing the calls here!
117 /*************************************************************************
118 * SHLWAPI_DupSharedHandle
120 * Internal implemetation of SHLWAPI_11.
123 HSHARED WINAPI
SHLWAPI_DupSharedHandle(HSHARED hShared
, DWORD dwDstProcId
,
124 DWORD dwSrcProcId
, DWORD dwAccess
,
128 DWORD dwMyProcId
= GetCurrentProcessId();
129 HSHARED hRet
= (HSHARED
)NULL
;
131 TRACE("(%p,%ld,%ld,%08lx,%08lx)\n", (PVOID
)hShared
, dwDstProcId
, dwSrcProcId
,
132 dwAccess
, dwOptions
);
134 /* Get dest process handle */
135 if (dwDstProcId
== dwMyProcId
)
136 hDst
= GetCurrentProcess();
138 hDst
= OpenProcess(PROCESS_DUP_HANDLE
, 0, dwDstProcId
);
142 /* Get src process handle */
143 if (dwSrcProcId
== dwMyProcId
)
144 hSrc
= GetCurrentProcess();
146 hSrc
= OpenProcess(PROCESS_DUP_HANDLE
, 0, dwSrcProcId
);
150 /* Make handle available to dest process */
151 if (!DuplicateHandle(hDst
, (HANDLE
)hShared
, hSrc
, &hRet
,
152 dwAccess
, 0, dwOptions
| DUPLICATE_SAME_ACCESS
))
153 hRet
= (HSHARED
)NULL
;
155 if (dwSrcProcId
!= dwMyProcId
)
159 if (dwDstProcId
!= dwMyProcId
)
163 TRACE("Returning handle %p\n", (PVOID
)hRet
);
167 /*************************************************************************
170 * Create a block of sharable memory and initialise it with data.
173 * dwProcId [I] ID of process owning data
174 * lpvData [I] Pointer to data to write
175 * dwSize [I] Size of data
178 * Success: A shared memory handle
182 * Ordinals 7-11 provide a set of calls to create shared memory between a
183 * group of processes. The shared memory is treated opaquely in that its size
184 * is not exposed to clients who map it. This is accomplished by storing
185 * the size of the map as the first DWORD of mapped data, and then offsetting
186 * the view pointer returned by this size.
188 * SHLWAPI_7/SHLWAPI_10 - Create/Destroy the shared memory handle
189 * SHLWAPI_8/SHLWAPI_9 - Get/Release a pointer to the shared data
190 * SHLWAPI_11 - Helper function; Duplicate cross-process handles
192 HSHARED WINAPI
SHLWAPI_7 (DWORD dwProcId
, DWORD dwSize
, LPCVOID lpvData
)
196 HSHARED hRet
= (HSHARED
)NULL
;
198 TRACE("(%ld,%p,%ld)\n", dwProcId
, lpvData
, dwSize
);
200 /* Create file mapping of the correct length */
201 hMap
= CreateFileMappingA(INVALID_HANDLE_VALUE
, NULL
, FILE_MAP_READ
, 0,
202 dwSize
+ sizeof(dwSize
), NULL
);
206 /* Get a view in our process address space */
207 pMapped
= MapViewOfFile(hMap
, FILE_MAP_READ
| FILE_MAP_WRITE
, 0, 0, 0);
211 /* Write size of data, followed by the data, to the view */
212 *((DWORD
*)pMapped
) = dwSize
;
214 memcpy((char *) pMapped
+ sizeof(dwSize
), lpvData
, dwSize
);
216 /* Release view. All further views mapped will be opaque */
217 UnmapViewOfFile(pMapped
);
218 hRet
= SHLWAPI_DupSharedHandle((HSHARED
)hMap
, dwProcId
,
219 GetCurrentProcessId(), FILE_MAP_ALL_ACCESS
,
220 DUPLICATE_SAME_ACCESS
);
227 /*************************************************************************
230 * Get a pointer to a block of shared memory from a shared memory handle.
233 * hShared [I] Shared memory handle
234 * dwProcId [I] ID of process owning hShared
237 * Success: A pointer to the shared memory
243 PVOID WINAPI
SHLWAPI_8 (HSHARED hShared
, DWORD dwProcId
)
248 TRACE("(%p %ld)\n", (PVOID
)hShared
, dwProcId
);
250 /* Get handle to shared memory for current process */
251 hDup
= SHLWAPI_DupSharedHandle(hShared
, dwProcId
, GetCurrentProcessId(),
252 FILE_MAP_ALL_ACCESS
, 0);
254 pMapped
= MapViewOfFile((HANDLE
)hDup
, FILE_MAP_READ
| FILE_MAP_WRITE
, 0, 0, 0);
258 return (char *) pMapped
+ sizeof(DWORD
); /* Hide size */
262 /*************************************************************************
265 * Release a pointer to a block of shared memory.
268 * lpView [I] Shared memory pointer
277 BOOL WINAPI
SHLWAPI_9 (LPVOID lpView
)
279 TRACE("(%p)\n", lpView
);
280 return UnmapViewOfFile((char *) lpView
- sizeof(DWORD
)); /* Include size */
283 /*************************************************************************
286 * Destroy a block of sharable memory.
289 * hShared [I] Shared memory handle
290 * dwProcId [I] ID of process owning hShared
299 BOOL WINAPI
SHLWAPI_10 (HSHARED hShared
, DWORD dwProcId
)
303 TRACE("(%p %ld)\n", (PVOID
)hShared
, dwProcId
);
305 /* Get a copy of the handle for our process, closing the source handle */
306 hClose
= SHLWAPI_DupSharedHandle(hShared
, dwProcId
, GetCurrentProcessId(),
307 FILE_MAP_ALL_ACCESS
,DUPLICATE_CLOSE_SOURCE
);
308 /* Close local copy */
309 return CloseHandle((HANDLE
)hClose
);
312 /*************************************************************************
315 * Copy a sharable memory handle from one process to another.
318 * hShared [I] Shared memory handle to duplicate
319 * dwDstProcId [I] ID of the process wanting the duplicated handle
320 * dwSrcProcId [I] ID of the process owning hShared
321 * dwAccess [I] Desired DuplicateHandle access
322 * dwOptions [I] Desired DuplicateHandle options
325 * Success: A handle suitable for use by the dwDstProcId process.
326 * Failure: A NULL handle.
331 HSHARED WINAPI
SHLWAPI_11(HSHARED hShared
, DWORD dwDstProcId
, DWORD dwSrcProcId
,
332 DWORD dwAccess
, DWORD dwOptions
)
336 hRet
= SHLWAPI_DupSharedHandle(hShared
, dwDstProcId
, dwSrcProcId
,
337 dwAccess
, dwOptions
);
341 /*************************************************************************
344 * Create and register a clipboard enumerator for a web browser.
347 * lpBC [I] Binding context
348 * lpUnknown [I] An object exposing the IWebBrowserApp interface
352 * Failure: An HRESULT error code.
355 * The enumerator is stored as a property of the web browser. If it does not
356 * yet exist, it is created and set before being registered.
361 HRESULT WINAPI
SHLWAPI_13(LPBC lpBC
, IUnknown
*lpUnknown
)
363 FIXME("(%p,%p) stub\n", lpBC
, lpUnknown
);
366 /* pseudo code extracted from relay trace */
367 RegOpenKeyA(HKLM
, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings\\Accepted Documents", &newkey
);
372 ret
= RegEnumValueA(newkey
, i
, a1
, a2
, 0, a3
, 0, 0);
376 b1
= LocalAlloc(0x40, size
);
380 ret
= RegEnumValueA(newkey
, i
, a1
, a2
, 0, a3
, a4
, a5
);
381 RegisterClipBoardFormatA(a4
);
384 hmod1
= GetModuleHandleA("URLMON.DLL");
385 proc
= GetProcAddress(hmod1
, "CreateFormatEnumerator");
386 HeapAlloc(??, 0, 0x14);
387 HeapAlloc(??, 0, 0x50);
388 LocalAlloc(0x40, 0x78);
389 /* FIXME: bad string below */
390 lstrlenW(L
"{D0FCA420-D3F5-11CF-B211-00AA004AE837}");
391 StrCpyW(a6
, L
"{D0FCA420-D3F5-11CF-B211-00AA004AE837}");
394 IsBadReadPtr(c1
= 0x403fd210,4);
395 InterlockedIncrement(c1
+4);
398 IsBadReadPtr(c1
= 0x403fd210,4);
399 InterlockedIncrement(c1
+4);
401 HeapAlloc(40350000,00000000,00000014) retval
=403fd0a8
;
402 HeapAlloc(40350000,00000000,00000050) retval
=403feb44
;
403 hmod1
= GetModuleHandleA("URLMON.DLL");
404 proc
= GetProcAddress(hmod1
, "RegisterFormatEnumerator");
405 /* 0x1a40c88c is in URLMON.DLL just before above proc
406 * content is L"_EnumFORMATETC_"
409 IsBadReadPtr(d1
= 0x1a40c88c,00000002);
412 HeapAlloc(40350000,00000000,0000001e
) retval
=403fed44
;
413 IsBadReadPtr(d2
= 0x403fd0a8,00000004);
414 InterlockedIncrement(d2
+4);
415 IsBadReadPtr(d2
= 0x403fd0a8,00000004);
416 InterlockedDecrement(d2
+4);
417 IsBadReadPtr(c1
,00000004);
418 InterlockedDecrement(c1
+4);
419 IsBadReadPtr(c1
,00000004);
420 InterlockedDecrement(c1
+4);
425 /*************************************************************************
428 * Get Explorers "AcceptLanguage" setting.
431 * langbuf [O] Destination for language string
432 * buflen [I] Length of langbuf
435 * Success: S_OK. langbuf is set to the language string found.
436 * Failure: E_FAIL, If any arguments are invalid, error occurred, or Explorer
437 * does not contain the setting.
439 HRESULT WINAPI
SHLWAPI_14 (
444 DWORD mystrlen
, mytype
;
448 mystrlen
= (*buflen
> 6) ? *buflen
: 6;
449 mystr
= (CHAR
*)HeapAlloc(GetProcessHeap(),
450 HEAP_ZERO_MEMORY
, mystrlen
);
451 RegOpenKeyA(HKEY_CURRENT_USER
,
452 "Software\\Microsoft\\Internet Explorer\\International",
454 if (RegQueryValueExA(mykey
, "AcceptLanguage",
455 0, &mytype
, mystr
, &mystrlen
)) {
456 /* Did not find value */
457 mylcid
= GetUserDefaultLCID();
458 /* somehow the mylcid translates into "en-us"
459 * this is similar to "LOCALE_SABBREVLANGNAME"
460 * which could be gotten via GetLocaleInfo.
461 * The only problem is LOCALE_SABBREVLANGUAGE" is
462 * a 3 char string (first 2 are country code and third is
463 * letter for "sublanguage", which does not come close to
466 lstrcpyA(mystr
, "en-us");
467 mystrlen
= lstrlenA(mystr
);
470 /* handle returned string */
471 FIXME("missing code\n");
473 if (mystrlen
> *buflen
)
474 lstrcpynA(langbuf
, mystr
, *buflen
);
476 lstrcpyA(langbuf
, mystr
);
477 *buflen
= lstrlenA(langbuf
);
480 HeapFree(GetProcessHeap(), 0, mystr
);
481 TRACE("language is %s\n", debugstr_a(langbuf
));
485 /*************************************************************************
488 * Unicode version of SHLWAPI_14.
490 HRESULT WINAPI
SHLWAPI_15 (
495 DWORD mystrlen
, mytype
;
499 mystrlen
= (*buflen
> 6) ? *buflen
: 6;
500 mystr
= (CHAR
*)HeapAlloc(GetProcessHeap(),
501 HEAP_ZERO_MEMORY
, mystrlen
);
502 RegOpenKeyA(HKEY_CURRENT_USER
,
503 "Software\\Microsoft\\Internet Explorer\\International",
505 if (RegQueryValueExA(mykey
, "AcceptLanguage",
506 0, &mytype
, mystr
, &mystrlen
)) {
507 /* Did not find value */
508 mylcid
= GetUserDefaultLCID();
509 /* somehow the mylcid translates into "en-us"
510 * this is similar to "LOCALE_SABBREVLANGNAME"
511 * which could be gotten via GetLocaleInfo.
512 * The only problem is LOCALE_SABBREVLANGUAGE" is
513 * a 3 char string (first 2 are country code and third is
514 * letter for "sublanguage", which does not come close to
517 lstrcpyA(mystr
, "en-us");
518 mystrlen
= lstrlenA(mystr
);
521 /* handle returned string */
522 FIXME("missing code\n");
525 *buflen
= MultiByteToWideChar(0, 0, mystr
, -1, langbuf
, (*buflen
)-1);
526 HeapFree(GetProcessHeap(), 0, mystr
);
527 TRACE("language is %s\n", debugstr_w(langbuf
));
531 /*************************************************************************
535 * converts a guid to a string
536 * returns strlen(str)
538 DWORD WINAPI
SHLWAPI_23 (
539 REFGUID guid
, /* [in] clsid */
540 LPSTR str
, /* [out] buffer */
541 INT cmax
) /* [in] size of buffer */
545 sprintf( xguid
, "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
546 guid
->Data1
, guid
->Data2
, guid
->Data3
,
547 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
548 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7] );
549 TRACE("(%s %p 0x%08x)stub\n", xguid
, str
, cmax
);
550 if (strlen(xguid
)>=cmax
) return 0;
552 return strlen(xguid
) + 1;
555 /*************************************************************************
559 * converts a guid to a string
560 * returns strlen(str)
562 DWORD WINAPI
SHLWAPI_24 (
563 REFGUID guid
, /* [in] clsid */
564 LPWSTR str
, /* [out] buffer */
565 INT cmax
) /* [in] size of buffer */
569 sprintf( xguid
, "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
570 guid
->Data1
, guid
->Data2
, guid
->Data3
,
571 guid
->Data4
[0], guid
->Data4
[1], guid
->Data4
[2], guid
->Data4
[3],
572 guid
->Data4
[4], guid
->Data4
[5], guid
->Data4
[6], guid
->Data4
[7] );
573 return MultiByteToWideChar( CP_ACP
, 0, xguid
, -1, str
, cmax
);
576 /*************************************************************************
579 * Seems to be iswalpha
581 BOOL WINAPI
SHLWAPI_25(WCHAR wc
)
583 return (get_char_typeW(wc
) & C1_ALPHA
) != 0;
586 /*************************************************************************
589 * Seems to be iswupper
591 BOOL WINAPI
SHLWAPI_26(WCHAR wc
)
593 return (get_char_typeW(wc
) & C1_UPPER
) != 0;
596 /*************************************************************************
599 * Seems to be iswlower
601 BOOL WINAPI
SHLWAPI_27(WCHAR wc
)
603 return (get_char_typeW(wc
) & C1_LOWER
) != 0;
606 /*************************************************************************
609 * Seems to be iswalnum
611 BOOL WINAPI
SHLWAPI_28(WCHAR wc
)
613 return (get_char_typeW(wc
) & (C1_ALPHA
|C1_DIGIT
)) != 0;
616 /*************************************************************************
619 * Seems to be iswspace
621 BOOL WINAPI
SHLWAPI_29(WCHAR wc
)
623 return (get_char_typeW(wc
) & C1_SPACE
) != 0;
626 /*************************************************************************
629 * Seems to be iswblank
631 BOOL WINAPI
SHLWAPI_30(WCHAR wc
)
633 return (get_char_typeW(wc
) & C1_BLANK
) != 0;
636 /*************************************************************************
639 * Seems to be iswpunct
641 BOOL WINAPI
SHLWAPI_31(WCHAR wc
)
643 return (get_char_typeW(wc
) & C1_PUNCT
) != 0;
646 /*************************************************************************
649 * Seems to be iswcntrl
651 BOOL WINAPI
SHLWAPI_32(WCHAR wc
)
653 return (get_char_typeW(wc
) & C1_CNTRL
) != 0;
656 /*************************************************************************
659 * Seems to be iswdigit
661 BOOL WINAPI
SHLWAPI_33(WCHAR wc
)
663 return (get_char_typeW(wc
) & C1_DIGIT
) != 0;
666 /*************************************************************************
669 * Seems to be iswxdigit
671 BOOL WINAPI
SHLWAPI_34(WCHAR wc
)
673 return (get_char_typeW(wc
) & C1_XDIGIT
) != 0;
676 /*************************************************************************
680 BOOL WINAPI
SHLWAPI_35(LPVOID p1
, DWORD dw2
, LPVOID p3
)
682 FIXME("(%p, 0x%08lx, %p): stub\n", p1
, dw2
, p3
);
686 /*************************************************************************
689 * Insert a bitmap menu item at the bottom of a menu.
692 * hMenu [I] Menu to insert into
693 * flags [I] Flags for insertion
694 * id [I] Menu ID of the item
695 * str [I] Menu text for the item
698 * Success: TRUE, the item is inserted into the menu
699 * Failure: FALSE, if any parameter is invalid
701 BOOL WINAPI
SHLWAPI_36(HMENU hMenu
, UINT flags
, UINT id
, LPCWSTR str
)
703 TRACE("(%p,0x%08x,0x%08x,%s)\n",hMenu
, flags
, id
, debugstr_w(str
));
704 return InsertMenuW(hMenu
, -1, flags
| MF_BITMAP
, id
, str
);
707 /*************************************************************************
710 * Get the text from a given dialog item.
713 * hWnd [I] Handle of dialog
714 * nItem [I] Index of item
715 * lpsDest [O] Buffer for receiving window text
716 * nDestLen [I] Length of buffer.
719 * Success: The length of the returned text.
722 INT WINAPI
SHLWAPI_74(HWND hWnd
, INT nItem
, LPWSTR lpsDest
,INT nDestLen
)
724 HWND hItem
= GetDlgItem(hWnd
, nItem
);
727 return GetWindowTextW(hItem
, lpsDest
, nDestLen
);
729 *lpsDest
= (WCHAR
)'\0';
733 /*************************************************************************
736 * Set the text of a given dialog item.
739 * hWnd [I] Handle of dialog
740 * iItem [I] Index of item
741 * lpszText [O] Text to set
744 * Success: TRUE. The text of the dialog is set to lpszText.
745 * Failure: FALSE, Otherwise.
747 BOOL WINAPI
SHLWAPI_138(HWND hWnd
, INT iItem
, LPCWSTR lpszText
)
749 HWND hWndItem
= GetDlgItem(hWnd
, iItem
);
751 return SetWindowTextW(hWndItem
, lpszText
);
755 /*************************************************************************
757 * Function: Compare two ASCII strings for "len" bytes.
758 * Returns: *str1-*str2 (case sensitive)
760 DWORD WINAPI
SHLWAPI_151(LPCSTR str1
, LPCSTR str2
, INT len
)
762 return strncmp( str1
, str2
, len
);
765 /*************************************************************************
768 * Function: Compare two WIDE strings for "len" bytes.
769 * Returns: *str1-*str2 (case sensitive)
771 DWORD WINAPI
SHLWAPI_152(LPCWSTR str1
, LPCWSTR str2
, INT len
)
773 return strncmpW( str1
, str2
, len
);
776 /*************************************************************************
778 * Function: Compare two ASCII strings for "len" bytes via caseless compare.
779 * Returns: *str1-*str2 (case insensitive)
781 DWORD WINAPI
SHLWAPI_153(LPCSTR str1
, LPCSTR str2
, DWORD len
)
783 return strncasecmp( str1
, str2
, len
);
786 /*************************************************************************
789 * Function: Compare two WIDE strings for "len" bytes via caseless compare.
790 * Returns: *str1-*str2 (case insensitive)
792 DWORD WINAPI
SHLWAPI_154(LPCWSTR str1
, LPCWSTR str2
, DWORD len
)
794 return strncmpiW( str1
, str2
, len
);
797 /*************************************************************************
800 * Case sensitive string compare (ASCII). Does not SetLastError().
802 DWORD WINAPI
SHLWAPI_155(LPCSTR str1
, LPCSTR str2
)
804 return strcmp(str1
, str2
);
807 /*************************************************************************
810 * Case sensitive string compare. Does not SetLastError().
812 DWORD WINAPI
SHLWAPI_156(LPCWSTR str1
, LPCWSTR str2
)
814 return strcmpW( str1
, str2
);
817 /*************************************************************************
820 * Case insensitive string compare (ASCII). Does not SetLastError().
822 DWORD WINAPI
SHLWAPI_157(LPCSTR str1
, LPCSTR str2
)
824 return strcasecmp(str1
, str2
);
826 /*************************************************************************
829 * Case insensitive string compare. Does not SetLastError(). ??
831 DWORD WINAPI
SHLWAPI_158 (LPCWSTR str1
, LPCWSTR str2
)
833 return strcmpiW( str1
, str2
);
836 /*************************************************************************
839 * Remove a hanging lead byte from the end of a string, if present.
842 * lpStr [I] String to check for a hanging lead byte
843 * size [I] Length of lpszStr
846 * Success: The new size of the string. Any hanging lead bytes are removed.
847 * Failure: 0, if any parameters are invalid.
849 DWORD WINAPI
SHLWAPI_162(LPSTR lpStr
, DWORD size
)
853 LPSTR lastByte
= lpStr
+ size
- 1;
855 while(lpStr
< lastByte
)
856 lpStr
+= IsDBCSLeadByte(*lpStr
) ? 2 : 1;
858 if(lpStr
== lastByte
&& IsDBCSLeadByte(*lpStr
))
868 /*************************************************************************
871 * Call IOleCommandTarget::QueryStatus() on an object.
874 * lpUnknown [I] Object supporting the IOleCommandTarget interface
875 * pguidCmdGroup [I] GUID for the command group
877 * prgCmds [O] Commands
878 * pCmdText [O] Command text
882 * Failure: E_FAIL, if lpUnknown is NULL.
883 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
884 * Otherwise, an error code from IOleCommandTarget::QueryStatus().
886 HRESULT WINAPI
SHLWAPI_163(IUnknown
* lpUnknown
, REFGUID pguidCmdGroup
,
887 ULONG cCmds
, OLECMD
*prgCmds
, OLECMDTEXT
* pCmdText
)
889 HRESULT hRet
= E_FAIL
;
891 TRACE("(%p,%p,%ld,%p,%p)\n",lpUnknown
, pguidCmdGroup
, cCmds
, prgCmds
, pCmdText
);
895 IOleCommandTarget
* lpOle
;
897 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleCommandTarget
,
900 if (SUCCEEDED(hRet
) && lpOle
)
902 hRet
= IOleCommandTarget_QueryStatus(lpOle
, pguidCmdGroup
, cCmds
,
904 IOleCommandTarget_Release(lpOle
);
910 /*************************************************************************
913 * Call IOleCommandTarget::Exec() on an object.
916 * lpUnknown [I] Object supporting the IOleCommandTarget interface
917 * pguidCmdGroup [I] GUID for the command group
921 * Failure: E_FAIL, if lpUnknown is NULL.
922 * E_NOINTERFACE, if lpUnknown does not support IOleCommandTarget.
923 * Otherwise, an error code from IOleCommandTarget::Exec().
925 HRESULT WINAPI
SHLWAPI_164(IUnknown
* lpUnknown
, REFGUID pguidCmdGroup
,
926 DWORD nCmdID
, DWORD nCmdexecopt
, VARIANT
* pvaIn
,
929 HRESULT hRet
= E_FAIL
;
931 TRACE("(%p,%p,%ld,%ld,%p,%p)\n",lpUnknown
, pguidCmdGroup
, nCmdID
,
932 nCmdexecopt
, pvaIn
, pvaOut
);
936 IOleCommandTarget
* lpOle
;
938 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleCommandTarget
,
940 if (SUCCEEDED(hRet
) && lpOle
)
942 hRet
= IOleCommandTarget_Exec(lpOle
, pguidCmdGroup
, nCmdID
,
943 nCmdexecopt
, pvaIn
, pvaOut
);
944 IOleCommandTarget_Release(lpOle
);
950 /*************************************************************************
953 * Retrieve, modify, and re-set a value from a window.
956 * hWnd [I] Windows to get value from
957 * offset [I] Offset of value
958 * wMask [I] Mask for uiFlags
959 * wFlags [I] Bits to set in window value
962 * The new value as it was set, or 0 if any parameter is invalid.
965 * Any bits set in uiMask are cleared from the value, then any bits set in
966 * uiFlags are set in the value.
968 LONG WINAPI
SHLWAPI_165(HWND hwnd
, INT offset
, UINT wMask
, UINT wFlags
)
970 LONG ret
= GetWindowLongA(hwnd
, offset
);
971 UINT newFlags
= (wFlags
& wMask
) | (ret
& ~wFlags
);
974 ret
= SetWindowLongA(hwnd
, offset
, newFlags
);
978 /*************************************************************************
981 * Change a window's parent.
984 * hWnd [I] Window to change parent of
985 * hWndParent [I] New parent window
988 * The old parent of hWnd.
991 * If hWndParent is NULL (desktop), the window style is changed to WS_POPUP.
992 * If hWndParent is NOT NULL then we set the WS_CHILD style.
994 HWND WINAPI
SHLWAPI_167(HWND hWnd
, HWND hWndParent
)
996 TRACE("%p, %p\n", hWnd
, hWndParent
);
998 if(GetParent(hWnd
) == hWndParent
)
1002 SHLWAPI_165(hWnd
, GWL_STYLE
, WS_CHILD
, WS_CHILD
);
1004 SHLWAPI_165(hWnd
, GWL_STYLE
, WS_POPUP
, WS_POPUP
);
1006 return SetParent(hWnd
, hWndParent
);
1009 /*************************************************************************
1012 * Locate and advise a connection point in an IConnectionPointContainer.
1015 * lpUnkSink [I] Sink for the connection point advise call
1016 * riid [I] REFIID of connection point to advise
1017 * bAdviseOnly [I] TRUE = Advise only, FALSE = Unadvise first
1018 * lpUnknown [I] Object supporting the IConnectionPointContainer interface
1019 * lpCookie [O] Pointer to connection point cookie
1020 * lppCP [O] Destination for the IConnectionPoint found
1023 * Success: S_OK. If lppCP is non-NULL, it is filled with the IConnectionPoint
1024 * that was advised. The caller is responsable for releasing it.
1025 * Failure: E_FAIL, if any arguments are invalid.
1026 * E_NOINTERFACE, if lpUnknown isn't an IConnectionPointContainer,
1027 * Or an HRESULT error code if any call fails.
1029 HRESULT WINAPI
SHLWAPI_168(IUnknown
* lpUnkSink
, REFIID riid
, BOOL bAdviseOnly
,
1030 IUnknown
* lpUnknown
, LPDWORD lpCookie
,
1031 IConnectionPoint
**lppCP
)
1034 IConnectionPointContainer
* lpContainer
;
1035 IConnectionPoint
*lpCP
;
1037 if(!lpUnknown
|| (bAdviseOnly
&& !lpUnkSink
))
1043 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IConnectionPointContainer
,
1044 (void**)&lpContainer
);
1045 if (SUCCEEDED(hRet
))
1047 hRet
= IConnectionPointContainer_FindConnectionPoint(lpContainer
, riid
, &lpCP
);
1049 if (SUCCEEDED(hRet
))
1052 hRet
= IConnectionPoint_Unadvise(lpCP
, *lpCookie
);
1053 hRet
= IConnectionPoint_Advise(lpCP
, lpUnkSink
, lpCookie
);
1058 if (lppCP
&& SUCCEEDED(hRet
))
1059 *lppCP
= lpCP
; /* Caller keeps the interface */
1061 IConnectionPoint_Release(lpCP
); /* Release it */
1064 IUnknown_Release(lpContainer
);
1069 /*************************************************************************
1072 * Release an interface.
1075 * lpUnknown [I] Object to release
1080 DWORD WINAPI
SHLWAPI_169 (IUnknown
** lpUnknown
)
1084 TRACE("(%p)\n",lpUnknown
);
1085 if(!lpUnknown
|| !*((LPDWORD
)lpUnknown
)) return 0;
1088 TRACE("doing Release\n");
1089 return IUnknown_Release(temp
);
1092 /*************************************************************************
1095 * Skip '//' if present in a string.
1098 * lpszSrc [I] String to check for '//'
1101 * Success: The next character after the '//' or the string if not present
1102 * Failure: NULL, if lpszStr is NULL.
1104 LPCSTR WINAPI
SHLWAPI_170(LPCSTR lpszSrc
)
1106 if (lpszSrc
&& lpszSrc
[0] == '/' && lpszSrc
[1] == '/')
1111 /*************************************************************************
1114 * Check the two interfaces if they come from the same object.
1117 * lpInt1 [I]: Interface to check against lpInt2.
1118 * lpInt2 [I]: Interface to check against lpInt1.
1121 * TRUE: Interfaces come from the same object.
1122 * FALSE: Interfaces come from different objects.
1124 BOOL WINAPI
SHLWAPI_171(IUnknown
* lpInt1
, IUnknown
* lpInt2
)
1126 LPVOID lpUnknown1
, lpUnknown2
;
1128 TRACE("%p %p\n", lpInt1
, lpInt2
);
1130 if (!lpInt1
|| !lpInt2
)
1133 if (lpInt1
== lpInt2
)
1136 if (!SUCCEEDED(IUnknown_QueryInterface(lpInt1
, &IID_IUnknown
,
1137 (LPVOID
*)&lpUnknown1
)))
1140 if (!SUCCEEDED(IUnknown_QueryInterface(lpInt2
, &IID_IUnknown
,
1141 (LPVOID
*)&lpUnknown2
)))
1144 if (lpUnknown1
== lpUnknown2
)
1150 /*************************************************************************
1153 * Get the window handle of an object.
1156 * lpUnknown [I] Object to get the window handle of
1157 * lphWnd [O] Destination for window handle
1160 * Success: S_OK. lphWnd contains the objects window handle.
1161 * Failure: An HRESULT error code.
1164 * lpUnknown is expected to support one of the following interfaces:
1166 * IInternetSecurityMgrSite
1169 HRESULT WINAPI
SHLWAPI_172(IUnknown
*lpUnknown
, HWND
*lphWnd
)
1171 /* FIXME: Wine has no header for this object */
1172 static const GUID IID_IInternetSecurityMgrSite
= { 0x79eac9ed,
1173 0xbaf9, 0x11ce, { 0x8c, 0x82, 0x00, 0xaa, 0x00, 0x4b, 0xa9, 0x0b }};
1175 HRESULT hRet
= E_FAIL
;
1177 TRACE("(%p,%p)\n", lpUnknown
, lphWnd
);
1182 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IOleWindow
, (void**)&lpOle
);
1186 hRet
= IUnknown_QueryInterface(lpUnknown
,&IID_IShellView
, (void**)&lpOle
);
1190 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IInternetSecurityMgrSite
,
1195 if (SUCCEEDED(hRet
))
1197 /* Lazyness here - Since GetWindow() is the first method for the above 3
1198 * interfaces, we use the same call for them all.
1200 hRet
= IOleWindow_GetWindow((IOleWindow
*)lpOle
, lphWnd
);
1201 IUnknown_Release(lpOle
);
1203 TRACE("Returning HWND=%p\n", *lphWnd
);
1209 /*************************************************************************
1212 * Seems to do call either IObjectWithSite::SetSite or
1213 * IPersistMoniker::GetClassID. But since we do not implement either
1214 * of those classes in our headers, we will fake it out.
1216 DWORD WINAPI
SHLWAPI_174(
1217 IUnknown
*p1
, /* [in] OLE object */
1218 LPVOID
*p2
) /* [out] ptr to result of either GetClassID
1223 if (!p1
) return E_FAIL
;
1225 /* see if SetSite interface exists for IObjectWithSite object */
1226 ret
= IUnknown_QueryInterface((IUnknown
*)p1
, (REFIID
)id1
, (LPVOID
*)&p1
);
1227 TRACE("first IU_QI ret=%08lx, p1=%p\n", ret
, p1
);
1230 /* see if GetClassId interface exists for IPersistMoniker object */
1231 ret
= IUnknown_QueryInterface((IUnknown
*)p1
, (REFIID
)id2
, (LPVOID
*)&aa
);
1232 TRACE("second IU_QI ret=%08lx, aa=%08lx\n", ret
, aa
);
1233 if (ret
) return ret
;
1235 /* fake a GetClassId call */
1236 ret
= IOleWindow_GetWindow((IOleWindow
*)aa
, (HWND
*)p2
);
1237 TRACE("second IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret
,
1239 IUnknown_Release((IUnknown
*)aa
);
1242 /* fake a SetSite call */
1243 ret
= IOleWindow_GetWindow((IOleWindow
*)p1
, (HWND
*)p2
);
1244 TRACE("first IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret
,
1246 IUnknown_Release((IUnknown
*)p1
);
1251 /*************************************************************************
1254 * Call IPersist::GetClassID on an object.
1257 * lpUnknown [I] Object supporting the IPersist interface
1258 * lpClassId [O] Destination for Class Id
1261 * Success: S_OK. lpClassId contains the Class Id requested.
1262 * Failure: E_FAIL, If lpUnknown is NULL,
1263 * E_NOINTERFACE If lpUnknown does not support IPersist,
1264 * Or an HRESULT error code.
1266 HRESULT WINAPI
SHLWAPI_175 (IUnknown
*lpUnknown
, CLSID
* lpClassId
)
1268 IPersist
* lpPersist
;
1269 HRESULT hRet
= E_FAIL
;
1271 TRACE("(%p,%p)\n", lpUnknown
, debugstr_guid(lpClassId
));
1275 hRet
= IUnknown_QueryInterface(lpUnknown
,&IID_IPersist
,(void**)&lpPersist
);
1276 if (SUCCEEDED(hRet
))
1278 IPersist_GetClassID(lpPersist
, lpClassId
);
1279 IPersist_Release(lpPersist
);
1285 /*************************************************************************
1288 * Retrieve a Service Interface from an object.
1291 * lpUnknown [I] Object to get an IServiceProvider interface from
1292 * sid [I] Service ID for QueryService call
1293 * riid [I] Function requested for QueryService call
1294 * lppOut [O] Destination for the service interface pointer
1296 * Function appears to be interface to IServiceProvider::QueryService
1299 * Success: S_OK. lppOut contains an object providing the requested service
1300 * Failure: An HRESULT error code
1303 * lpUnknown is expected to support the IServiceProvider interface.
1305 HRESULT WINAPI
SHLWAPI_176(IUnknown
* lpUnknown
, REFGUID sid
, REFIID riid
,
1308 IServiceProvider
* pService
= NULL
;
1319 /* Get an IServiceProvider interface from the object */
1320 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IServiceProvider
,
1321 (LPVOID
*)&pService
);
1323 if (!hRet
&& pService
)
1325 TRACE("QueryInterface returned (IServiceProvider*)%p\n", pService
);
1327 /* Get a Service interface from the object */
1328 hRet
= IServiceProvider_QueryService(pService
, sid
, riid
, lppOut
);
1330 TRACE("(IServiceProvider*)%p returned (IUnknown*)%p\n", pService
, *lppOut
);
1332 /* Release the IServiceProvider interface */
1333 IUnknown_Release(pService
);
1338 /*************************************************************************
1341 * Remove all sub-menus from a menu.
1344 * hMenu [I] Menu to remove sub-menus from
1347 * Success: 0. All sub-menus under hMenu are removed
1348 * Failure: -1, if any parameter is invalid
1350 DWORD WINAPI
SHLWAPI_180(HMENU hMenu
)
1352 int iItemCount
= GetMenuItemCount(hMenu
) - 1;
1353 while (iItemCount
>= 0)
1355 HMENU hSubMenu
= GetSubMenu(hMenu
, iItemCount
);
1357 RemoveMenu(hMenu
, iItemCount
, 0x400);
1363 /*************************************************************************
1366 * Enable or disable a menu item.
1369 * hMenu [I] Menu holding menu item
1370 * uID [I] ID of menu item to enable/disable
1371 * bEnable [I] Whether to enable (TRUE) or disable (FALSE) the item.
1374 * The return code from EnableMenuItem.
1376 UINT WINAPI
SHLWAPI_181(HMENU hMenu
, UINT wItemID
, BOOL bEnable
)
1378 return EnableMenuItem(hMenu
, wItemID
, bEnable
? MF_ENABLED
: MF_GRAYED
);
1381 /*************************************************************************
1384 * Check or uncheck a menu item.
1387 * hMenu [I] Menu holding menu item
1388 * uID [I] ID of menu item to check/uncheck
1389 * bCheck [I] Whether to check (TRUE) or uncheck (FALSE) the item.
1392 * The return code from CheckMenuItem.
1394 DWORD WINAPI
SHLWAPI_182(HMENU hMenu
, UINT uID
, BOOL bCheck
)
1396 return CheckMenuItem(hMenu
, uID
, bCheck
? MF_CHECKED
: 0);
1399 /*************************************************************************
1402 * Register a window class if it isn't already.
1405 * lpWndClass [I] Window class to register
1408 * The result of the RegisterClassA call.
1410 DWORD WINAPI
SHLWAPI_183(WNDCLASSA
*wndclass
)
1413 if (GetClassInfoA(wndclass
->hInstance
, wndclass
->lpszClassName
, &wca
))
1415 return (DWORD
)RegisterClassA(wndclass
);
1418 /*************************************************************************
1421 * Call IPersistPropertyBag::Load on an object.
1424 * lpUnknown [I] Object supporting the IPersistPropertyBag interface
1425 * lpPropBag [O] Destination for loaded IPropertyBag
1429 * Failure: An HRESULT error code, or E_FAIL if lpUnknown is NULL.
1431 DWORD WINAPI
SHLWAPI_187(IUnknown
*lpUnknown
, IPropertyBag
* lpPropBag
)
1433 IPersistPropertyBag
* lpPPBag
;
1434 HRESULT hRet
= E_FAIL
;
1436 TRACE("(%p,%p)\n", lpUnknown
, lpPropBag
);
1440 hRet
= IUnknown_QueryInterface(lpUnknown
, &IID_IPersistPropertyBag
,
1442 if (SUCCEEDED(hRet
) && lpPPBag
)
1444 hRet
= IPersistPropertyBag_Load(lpPPBag
, lpPropBag
, NULL
);
1445 IPersistPropertyBag_Release(lpPPBag
);
1451 /*************************************************************************
1454 * _IUnknown_OnFocusOCS
1456 DWORD WINAPI
SHLWAPI_189(LPVOID x
, LPVOID y
)
1458 FIXME("%p %p\n", x
, y
);
1462 /*************************************************************************
1465 * Get the color depth of the primary display.
1471 * The color depth of the primary display.
1473 DWORD WINAPI
SHLWAPI_193 ()
1481 ret
= GetDeviceCaps(hdc
, BITSPIXEL
) * GetDeviceCaps(hdc
, PLANES
);
1486 /*************************************************************************
1489 * Blank out a region of text by drawing the background only.
1492 * hDC [I] Device context to draw in
1493 * pRect [I] Area to draw in
1494 * cRef [I] Color to draw in
1499 DWORD WINAPI
SHLWAPI_197(HDC hDC
, LPCRECT pRect
, COLORREF cRef
)
1501 COLORREF cOldColor
= SetBkColor(hDC
, cRef
);
1502 ExtTextOutA(hDC
, 0, 0, ETO_OPAQUE
, pRect
, 0, 0, 0);
1503 SetBkColor(hDC
, cOldColor
);
1507 /*************************************************************************
1510 * Copy interface pointer
1513 * lppDest [O] Destination for copy
1514 * lpUnknown [I] Source for copy
1519 VOID WINAPI
SHLWAPI_199(IUnknown
**lppDest
, IUnknown
*lpUnknown
)
1521 TRACE("(%p,%p)\n", lppDest
, lpUnknown
);
1524 SHLWAPI_169(lppDest
); /* Release existing interface */
1529 IUnknown_AddRef(lpUnknown
);
1530 *lppDest
= lpUnknown
;
1534 /*************************************************************************
1538 HRESULT WINAPI
SHLWAPI_201(IUnknown
* lpUnknown
, INT iUnk
, REFGUID pguidCmdGroup
,
1539 DWORD nCmdID
, DWORD nCmdexecopt
, VARIANT
* pvaIn
,
1542 FIXME("(%p,%d,%p,%ld,%ld,%p,%p) - stub!\n", lpUnknown
, iUnk
, pguidCmdGroup
,
1543 nCmdID
, nCmdexecopt
, pvaIn
, pvaOut
);
1544 return DRAGDROP_E_NOTREGISTERED
;
1547 /*************************************************************************
1551 HRESULT WINAPI
SHLWAPI_202(REFGUID pguidCmdGroup
,ULONG cCmds
, OLECMD
*prgCmds
)
1553 FIXME("(%p,%ld,%p) - stub!\n", pguidCmdGroup
, cCmds
, prgCmds
);
1554 return DRAGDROP_E_NOTREGISTERED
;
1557 /*************************************************************************
1561 VOID WINAPI
SHLWAPI_203(LPCSTR lpszStr
)
1563 FIXME("(%s) - stub!\n", debugstr_a(lpszStr
));
1566 /*************************************************************************
1569 * Determine if a window is not a child of another window.
1572 * hParent [I] Suspected parent window
1573 * hChild [I] Suspected child window
1576 * TRUE: If hChild is a child window of hParent
1577 * FALSE: If hChild is not a child window of hParent, or they are equal
1579 BOOL WINAPI
SHLWAPI_204(HWND hParent
, HWND hChild
)
1581 TRACE("(%p,%p)\n", hParent
, hChild
);
1583 if (!hParent
|| !hChild
)
1585 else if(hParent
== hChild
)
1587 return !IsChild(hParent
, hChild
);
1590 /*************************************************************************
1593 * Some sort of memory management process - associated with _210
1595 DWORD WINAPI
SHLWAPI_208 (
1602 FIXME("(0x%08lx 0x%08lx %p %p 0x%08lx) stub\n",
1607 /*************************************************************************
1610 * Some sort of memory management process - associated with _208
1612 DWORD WINAPI
SHLWAPI_209 (
1615 FIXME("(%p) stub\n",
1620 /*************************************************************************
1623 * Some sort of memory management process - associated with _208
1625 DWORD WINAPI
SHLWAPI_210 (
1630 FIXME("(%p 0x%08lx %p) stub\n",
1635 /*************************************************************************
1638 DWORD WINAPI
SHLWAPI_211 (
1642 FIXME("(%p 0x%08lx) stub\n",
1647 /*************************************************************************
1653 DWORD WINAPI
SHLWAPI_215 (
1660 len_a
= lstrlenA(lpStrSrc
);
1661 ret
= MultiByteToWideChar(0, 0, lpStrSrc
, len_a
, lpwStrDest
, len
);
1662 TRACE("%s %s %d, ret=%d\n",
1663 debugstr_a(lpStrSrc
), debugstr_w(lpwStrDest
), len
, ret
);
1667 /*************************************************************************
1670 * WideCharToMultiByte with multi language support.
1672 INT WINAPI
SHLWAPI_218(UINT CodePage
, LPCWSTR lpSrcStr
, LPSTR lpDstStr
,
1673 LPINT lpnMultiCharCount
)
1675 WCHAR emptyW
[] = { '\0' };
1679 if (!lpDstStr
|| !lpnMultiCharCount
)
1687 len
= strlenW(lpSrcStr
) + 1;
1692 CodePage
= CP_UTF8
; /* Fall through... */
1693 case 0x0000C350: /* FIXME: CP_ #define */
1698 INT nWideCharCount
= len
- 1;
1700 GET_FUNC(pConvertINetUnicodeToMultiByte
, mlang
, "ConvertINetUnicodeToMultiByte", 0);
1701 if (!pConvertINetUnicodeToMultiByte(&dwMode
, CodePage
, lpSrcStr
, &nWideCharCount
, lpDstStr
,
1705 if (nWideCharCount
< len
- 1)
1707 mem
= (LPSTR
)HeapAlloc(GetProcessHeap(), 0, *lpnMultiCharCount
);
1711 *lpnMultiCharCount
= 0;
1713 if (pConvertINetUnicodeToMultiByte(&dwMode
, CodePage
, lpSrcStr
, &len
, mem
, lpnMultiCharCount
))
1715 SHLWAPI_162 (mem
, *lpnMultiCharCount
);
1716 lstrcpynA(lpDstStr
, mem
, *lpnMultiCharCount
+ 1);
1717 return *lpnMultiCharCount
+ 1;
1719 HeapFree(GetProcessHeap(), 0, mem
);
1720 return *lpnMultiCharCount
;
1722 lpDstStr
[*lpnMultiCharCount
] = '\0';
1723 return *lpnMultiCharCount
;
1730 reqLen
= WideCharToMultiByte(CodePage
, 0, lpSrcStr
, len
, lpDstStr
,
1731 *lpnMultiCharCount
, NULL
, NULL
);
1733 if (!reqLen
&& GetLastError() == ERROR_INSUFFICIENT_BUFFER
)
1735 reqLen
= WideCharToMultiByte(CodePage
, 0, lpSrcStr
, len
, NULL
, 0, NULL
, NULL
);
1738 mem
= (LPSTR
)HeapAlloc(GetProcessHeap(), 0, reqLen
);
1741 reqLen
= WideCharToMultiByte(CodePage
, 0, lpSrcStr
, len
, mem
,
1742 reqLen
, NULL
, NULL
);
1744 reqLen
= SHLWAPI_162(mem
, *lpnMultiCharCount
);
1747 lstrcpynA(lpDstStr
, mem
, *lpnMultiCharCount
);
1749 HeapFree(GetProcessHeap(), 0, mem
);
1756 /*************************************************************************
1759 * Hmm, some program used lpnMultiCharCount == 0x3 (and lpSrcStr was "C")
1760 * --> Crash. Something wrong here.
1762 * It seems from OE v5 that the third param is the count. (GA 11/2001)
1764 INT WINAPI
SHLWAPI_217(LPCWSTR lpSrcStr
, LPSTR lpDstStr
, INT MultiCharCount
)
1766 INT myint
= MultiCharCount
;
1768 return SHLWAPI_218(CP_ACP
, lpSrcStr
, lpDstStr
, &myint
);
1771 /*************************************************************************
1774 * Seems to be "super" QueryInterface. Supplied with a table of interfaces
1775 * and an array of IIDs and offsets into the table.
1778 * error codes: E_POINTER, E_NOINTERFACE
1785 HRESULT WINAPI
SHLWAPI_219 (
1786 LPVOID w
, /* [in] table of interfaces */
1787 IFACE_INDEX_TBL
*x
, /* [in] array of REFIIDs and indexes to above */
1788 REFIID riid
, /* [in] REFIID to get interface for */
1789 LPVOID
*ppv
) /* [out] location to get interface pointer */
1793 IFACE_INDEX_TBL
*xmove
;
1795 TRACE("(%p %p %s %p)\n", w
,x
,debugstr_guid(riid
),ppv
);
1798 while (xmove
->refid
) {
1799 TRACE("trying (indx %ld) %s\n", xmove
->indx
, debugstr_guid(xmove
->refid
));
1800 if (IsEqualIID(riid
, xmove
->refid
)) {
1801 a_vtbl
= (IUnknown
*)(xmove
->indx
+ (LPBYTE
)w
);
1802 TRACE("matched, returning (%p)\n", a_vtbl
);
1803 *ppv
= (LPVOID
)a_vtbl
;
1804 IUnknown_AddRef(a_vtbl
);
1810 if (IsEqualIID(riid
, &IID_IUnknown
)) {
1811 a_vtbl
= (IUnknown
*)(x
->indx
+ (LPBYTE
)w
);
1812 TRACE("returning first for IUnknown (%p)\n", a_vtbl
);
1813 *ppv
= (LPVOID
)a_vtbl
;
1814 IUnknown_AddRef(a_vtbl
);
1818 ret
= E_NOINTERFACE
;
1822 TRACE("-- 0x%08lx\n", ret
);
1826 /*************************************************************************
1829 HMODULE WINAPI
SHLWAPI_236 (REFIID lpUnknown
)
1833 CHAR value
[MAX_PATH
], string
[MAX_PATH
];
1835 strcpy(string
, "CLSID\\");
1836 strcat(string
, debugstr_guid(lpUnknown
));
1837 strcat(string
, "\\InProcServer32");
1840 RegOpenKeyExA(HKEY_CLASSES_ROOT
, string
, 0, 1, &newkey
);
1841 RegQueryValueExA(newkey
, 0, 0, &type
, value
, &count
);
1842 RegCloseKey(newkey
);
1843 return LoadLibraryExA(value
, 0, 0);
1846 /*************************************************************************
1849 * Unicode version of SHLWAPI_183.
1851 DWORD WINAPI
SHLWAPI_237 (WNDCLASSW
* lpWndClass
)
1855 TRACE("(%p %s)\n",lpWndClass
->hInstance
, debugstr_w(lpWndClass
->lpszClassName
));
1857 if (GetClassInfoW(lpWndClass
->hInstance
, lpWndClass
->lpszClassName
, &WndClass
))
1859 return RegisterClassW(lpWndClass
);
1862 /*************************************************************************
1865 DWORD WINAPI
SHLWAPI_239(HINSTANCE hInstance
, LPVOID p2
, DWORD dw3
)
1867 FIXME("(%p %p 0x%08lx) stub\n",
1868 hInstance
, p2
, dw3
);
1871 /* pseudo code from relay trace */
1872 WideCharToMultiByte(0, 0, L
"Shell DocObject View", -1, &aa
, 0x0207, 0, 0);
1873 GetClassInfoA(70fe0000
,405868ec
"Shell DocObject View",40586b14
);
1874 /* above pair repeated for:
1875 TridentThicketUrlDlClass
1884 /*************************************************************************
1887 * Call The correct (ASCII/Unicode) default window procedure for a window.
1890 * hWnd [I] Window to call the default proceedure for
1891 * uMessage [I] Message ID
1892 * wParam [I] WPARAM of message
1893 * lParam [I] LPARAM of message
1896 * The result of calling the window proceedure.
1898 LRESULT CALLBACK
SHLWAPI_240(HWND hWnd
, UINT uMessage
, WPARAM wParam
, LPARAM lParam
)
1900 if (IsWindowUnicode(hWnd
))
1901 return DefWindowProcW(hWnd
, uMessage
, wParam
, lParam
);
1902 return DefWindowProcA(hWnd
, uMessage
, wParam
, lParam
);
1905 /*************************************************************************
1909 DWORD WINAPI
SHLWAPI_241 ()
1912 return /* 0xabba1243 */ 0;
1915 /* default shell policy registry key */
1916 static WCHAR strRegistryPolicyW
[] = {'S','o','f','t','w','a','r','e','\\','M','i','c','r','o',
1917 's','o','f','t','\\','W','i','n','d','o','w','s','\\',
1918 'C','u','r','r','e','n','t','V','e','r','s','i','o','n',
1919 '\\','P','o','l','i','c','i','e','s',0};
1921 /*************************************************************************
1924 * Retrieve a policy value from the registry.
1927 * lpSubKey [I] registry key name
1928 * lpSubName [I] subname of registry key
1929 * lpValue [I] value name of registry value
1932 * the value associated with the registry key or 0 if not found
1934 DWORD WINAPI
SHLWAPI_271(LPCWSTR lpSubKey
, LPCWSTR lpSubName
, LPCWSTR lpValue
)
1936 DWORD retval
, datsize
= 4;
1940 lpSubKey
= (LPCWSTR
)strRegistryPolicyW
;
1942 retval
= RegOpenKeyW(HKEY_LOCAL_MACHINE
, lpSubKey
, &hKey
);
1943 if (retval
!= ERROR_SUCCESS
)
1944 retval
= RegOpenKeyW(HKEY_CURRENT_USER
, lpSubKey
, &hKey
);
1945 if (retval
!= ERROR_SUCCESS
)
1948 SHGetValueW(hKey
, lpSubName
, lpValue
, NULL
, (LPBYTE
)&retval
, &datsize
);
1953 /*************************************************************************
1956 * Helper function to retrieve the possibly cached value for a specific policy
1959 * policy [I] The policy to look for
1960 * initial [I] Main registry key to open, if NULL use default
1961 * polTable [I] Table of known policies, 0 terminated
1962 * polArr [I] Cache array of policy values
1965 * The retrieved policy value or 0 if not successful
1968 * This function is used by the native SHRestricted function to search for the
1969 * policy and cache it once retrieved. The current Wine implementation uses a
1970 * different POLICYDATA structure and implements a similar algorithme adapted to
1973 DWORD WINAPI
SHLWAPI_266 (
1975 LPCWSTR initial
, /* [in] partial registry key */
1976 LPPOLICYDATA polTable
,
1979 TRACE("(0x%08lx %s %p %p)\n", policy
, debugstr_w(initial
), polTable
, polArr
);
1981 if (!polTable
|| !polArr
)
1984 for (;polTable
->policy
; polTable
++, polArr
++)
1986 if (policy
== polTable
->policy
)
1988 /* we have a known policy */
1990 /* check if this policy has been cached */
1991 if (*polArr
== SHELL_NO_POLICY
)
1992 *polArr
= SHLWAPI_271(initial
, polTable
->appstr
, polTable
->keystr
);
1996 /* we don't know this policy, return 0 */
1997 TRACE("unknown policy: (%08lx)\n", policy
);
2001 /*************************************************************************
2005 * This QueryInterface asks the inner object for a interface. In case
2006 * of aggregation this request would be forwarded by the inner to the
2007 * outer object. This function asks the inner object directly for the
2008 * interface circumventing the forwarding to the outer object.
2010 HRESULT WINAPI
SHLWAPI_267 (
2011 IUnknown
* pUnk
, /* [in] outer object */
2012 IUnknown
* pInner
, /* [in] inner object */
2016 HRESULT hret
= E_NOINTERFACE
;
2017 TRACE("(pUnk=%p pInner=%p\n\tIID: %s %p)\n",pUnk
,pInner
,debugstr_guid(riid
), ppv
);
2020 if(pUnk
&& pInner
) {
2021 hret
= IUnknown_QueryInterface(pInner
, riid
, (LPVOID
*)ppv
);
2022 if (SUCCEEDED(hret
)) IUnknown_Release(pUnk
);
2024 TRACE("-- 0x%08lx\n", hret
);
2028 /*************************************************************************
2031 * Move a reference from one interface to another.
2034 * lpDest [O] Destination to receive the reference
2035 * lppUnknown [O] Source to give up the reference to lpDest
2040 VOID WINAPI
SHLWAPI_268(IUnknown
*lpDest
, IUnknown
**lppUnknown
)
2042 TRACE("(%p,%p)\n", lpDest
, lppUnknown
);
2047 IUnknown_AddRef(lpDest
);
2048 SHLWAPI_169(lppUnknown
); /* Release existing interface */
2052 /*************************************************************************
2055 * Determine if the browser is integrated into the shell, and set a registry
2062 * 1, If the browser is not integrated.
2063 * 2, If the browser is integrated.
2066 * The key HKLM\Software\Microsoft\Internet Explorer\IntegratedBrowser is
2067 * either set to TRUE, or removed depending on whether the browser is deemed
2070 DWORD WINAPI
SHLWAPI_276()
2072 static LPCSTR szIntegratedBrowser
= "IntegratedBrowser";
2073 static DWORD dwState
= 0;
2075 DWORD dwRet
, dwData
, dwSize
;
2080 /* If shell32 exports DllGetVersion(), the browser is integrated */
2081 GET_FUNC(pDllGetVersion
, shell32
, "DllGetVersion", 1);
2082 dwState
= pDllGetVersion
? 2 : 1;
2084 /* Set or delete the key accordinly */
2085 dwRet
= RegOpenKeyExA(HKEY_LOCAL_MACHINE
,
2086 "Software\\Microsoft\\Internet Explorer", 0,
2087 KEY_ALL_ACCESS
, &hKey
);
2090 dwRet
= RegQueryValueExA(hKey
, szIntegratedBrowser
, 0, 0,
2091 (LPBYTE
)&dwData
, &dwSize
);
2093 if (!dwRet
&& dwState
== 1)
2095 /* Value exists but browser is not integrated */
2096 RegDeleteValueA(hKey
, szIntegratedBrowser
);
2098 else if (dwRet
&& dwState
== 2)
2100 /* Browser is integrated but value does not exist */
2102 RegSetValueExA(hKey
, szIntegratedBrowser
, 0, REG_DWORD
,
2103 (LPBYTE
)&dwData
, sizeof(dwData
));
2110 /*************************************************************************
2114 HWND WINAPI
SHLWAPI_278 (
2125 char * clsname
= "WorkerA";
2127 FIXME("(0x%08lx %p 0x%08lx 0x%08lx %p 0x%08lx) partial stub\n",
2128 wndProc
,hWndParent
,dwExStyle
,dwStyle
,hMenu
,z
);
2130 hCursor
= LoadCursorA(0x00000000,IDC_ARROWA
);
2132 if(!GetClassInfoA(shlwapi_hInstance
, clsname
, &wndclass
))
2134 RtlZeroMemory(&wndclass
, sizeof(WNDCLASSA
));
2135 wndclass
.lpfnWndProc
= DefWindowProcW
;
2136 wndclass
.cbWndExtra
= 4;
2137 wndclass
.hInstance
= shlwapi_hInstance
;
2138 wndclass
.hCursor
= hCursor
;
2139 wndclass
.hbrBackground
= (HBRUSH
)COLOR_BTNSHADOW
;
2140 wndclass
.lpszMenuName
= NULL
;
2141 wndclass
.lpszClassName
= clsname
;
2142 RegisterClassA (&wndclass
);
2144 hwnd
= CreateWindowExA(dwExStyle
, clsname
, 0,dwStyle
,0,0,0,0,hWndParent
,
2145 hMenu
,shlwapi_hInstance
,0);
2146 SetWindowLongA(hwnd
, 0, z
);
2147 SetWindowLongA(hwnd
, GWL_WNDPROC
, wndProc
);
2151 /*************************************************************************
2154 * _SHPackDispParamsV
2156 HRESULT WINAPI
SHLWAPI_281(LPVOID w
, LPVOID x
, LPVOID y
, LPVOID z
)
2158 FIXME("%p %p %p %p\n",w
,x
,y
,z
);
2162 /*************************************************************************
2165 * This function seems to be a forward to SHLWAPI.281 (whatever THAT
2166 * function does...).
2168 HRESULT WINAPI
SHLWAPI_282(LPVOID w
, LPVOID x
, LPVOID y
, LPVOID z
)
2170 FIXME("%p %p %p %p\n", w
, x
, y
, z
);
2174 /*************************************************************************
2177 * _IConnectionPoint_SimpleInvoke
2179 DWORD WINAPI
SHLWAPI_284 (
2184 TRACE("(%p %p %p) stub\n",x
,y
,z
);
2188 /*************************************************************************
2191 * _IUnknown_CPContainerOnChanged
2193 HRESULT WINAPI
SHLWAPI_287(LPVOID x
, LPVOID y
)
2195 FIXME("%p %p\n", x
,y
);
2199 /*************************************************************************
2202 * Late bound call to winmm.PlaySoundW
2204 BOOL WINAPI
SHLWAPI_289(LPCWSTR pszSound
, HMODULE hmod
, DWORD fdwSound
)
2206 GET_FUNC(pPlaySoundW
, winmm
, "PlaySoundW", FALSE
);
2207 return pPlaySoundW(pszSound
, hmod
, fdwSound
);
2210 /*************************************************************************
2213 BOOL WINAPI
SHLWAPI_294(LPSTR str1
, LPSTR str2
, LPSTR pStr
, DWORD some_len
, LPCSTR lpStr2
)
2216 * str1: "I" "I" pushl esp+0x20
2217 * str2: "U" "I" pushl 0x77c93810
2218 * (is "I" and "U" "integer" and "unsigned" ??)
2220 * pStr: "" "" pushl eax
2221 * some_len: 0x824 0x104 pushl 0x824
2222 * lpStr2: "%l" "%l" pushl esp+0xc
2224 * shlwapi. StrCpyNW(lpStr2, irrelevant_var, 0x104);
2225 * LocalAlloc(0x00, some_len) -> irrelevant_var
2226 * LocalAlloc(0x40, irrelevant_len) -> pStr
2227 * shlwapi.294(str1, str2, pStr, some_len, lpStr2);
2228 * shlwapi.PathRemoveBlanksW(pStr);
2230 FIXME("('%s', '%s', '%s', %08lx, '%s'): stub!\n", str1
, str2
, pStr
, some_len
, lpStr2
);
2234 /*************************************************************************
2237 * Called by ICQ2000b install via SHDOCVW:
2238 * str1: "InternetShortcut"
2239 * x: some unknown pointer
2240 * str2: "http://free.aol.com/tryaolfree/index.adp?139269"
2241 * str3: "C:\\WINDOWS\\Desktop.new2\\Free AOL & Unlimited Internet.url"
2243 * In short: this one maybe creates a desktop link :-)
2245 BOOL WINAPI
SHLWAPI_295(LPWSTR str1
, LPVOID x
, LPWSTR str2
, LPWSTR str3
)
2247 FIXME("('%s', %p, '%s', '%s'), stub.\n", debugstr_w(str1
), x
, debugstr_w(str2
), debugstr_w(str3
));
2251 /*************************************************************************
2254 * Late bound call to comctl32.417
2256 BOOL WINAPI
SHLWAPI_299(HDC hdc
, INT x
, INT y
, UINT flags
, const RECT
*lprect
,
2257 LPCWSTR str
, UINT count
, const INT
*lpDx
)
2259 GET_FUNC(pCOMCTL32_417
, comctl32
, (LPCSTR
)417, FALSE
);
2260 return pCOMCTL32_417(hdc
, x
, y
, flags
, lprect
, str
, count
, lpDx
);
2263 /*************************************************************************
2266 * Late bound call to shell32.SHGetFileInfoW
2268 DWORD WINAPI
SHLWAPI_313(LPCWSTR path
, DWORD dwFileAttributes
,
2269 SHFILEINFOW
*psfi
, UINT sizeofpsfi
, UINT flags
)
2271 GET_FUNC(pSHGetFileInfoW
, shell32
, "SHGetFileInfoW", 0);
2272 return pSHGetFileInfoW(path
, dwFileAttributes
, psfi
, sizeofpsfi
, flags
);
2275 /*************************************************************************
2278 * Late bound call to shell32.DragQueryFileW
2280 UINT WINAPI
SHLWAPI_318(HDROP hDrop
, UINT lFile
, LPWSTR lpszFile
, UINT lLength
)
2282 GET_FUNC(pDragQueryFileW
, shell32
, "DragQueryFileW", 0);
2283 return pDragQueryFileW(hDrop
, lFile
, lpszFile
, lLength
);
2286 /*************************************************************************
2289 * Late bound call to shell32.SHBrowseForFolderW
2291 LPITEMIDLIST WINAPI
SHLWAPI_333(LPBROWSEINFOW lpBi
)
2293 GET_FUNC(pSHBrowseForFolderW
, shell32
, "SHBrowseForFolderW", NULL
);
2294 return pSHBrowseForFolderW(lpBi
);
2297 /*************************************************************************
2300 * Late bound call to shell32.SHGetPathFromIDListW
2302 BOOL WINAPI
SHLWAPI_334(LPCITEMIDLIST pidl
,LPWSTR pszPath
)
2304 GET_FUNC(pSHGetPathFromIDListW
, shell32
, "SHGetPathFromIDListW", 0);
2305 return pSHGetPathFromIDListW(pidl
, pszPath
);
2308 /*************************************************************************
2311 * Late bound call to shell32.ShellExecuteExW
2313 BOOL WINAPI
SHLWAPI_335(LPSHELLEXECUTEINFOW lpExecInfo
)
2315 GET_FUNC(pShellExecuteExW
, shell32
, "ShellExecuteExW", FALSE
);
2316 return pShellExecuteExW(lpExecInfo
);
2319 /*************************************************************************
2322 * Late bound call to shell32.SHFileOperationW.
2324 HICON WINAPI
SHLWAPI_336(LPSHFILEOPSTRUCTW lpFileOp
)
2326 GET_FUNC(pSHFileOperationW
, shell32
, "SHFileOperationW", 0);
2327 return pSHFileOperationW(lpFileOp
);
2330 /*************************************************************************
2333 * Late bound call to shell32.ExtractIconExW.
2335 UINT WINAPI
SHLWAPI_337(LPCWSTR lpszFile
, INT nIconIndex
, HICON
*phiconLarge
,
2336 HICON
*phiconSmall
, UINT nIcons
)
2338 GET_FUNC(pExtractIconExW
, shell32
, "ExtractIconExW", 0);
2339 return pExtractIconExW(lpszFile
, nIconIndex
, phiconLarge
, phiconSmall
, nIcons
);
2342 /*************************************************************************
2346 LONG WINAPI
SHInterlockedCompareExchange( PLONG dest
, LONG xchg
, LONG compare
)
2348 return InterlockedCompareExchange(dest
, xchg
, compare
);
2351 /*************************************************************************
2354 DWORD WINAPI
SHLWAPI_346 (
2359 FIXME("(%s %p 0x%08x)stub\n",debugstr_w(src
),dest
,len
);
2360 lstrcpynW(dest
, src
, len
);
2361 return lstrlenW(dest
)+1;
2364 /*************************************************************************
2367 * seems to be late bound call to GetFileVersionInfoSizeW
2369 DWORD WINAPI
SHLWAPI_350 (
2375 GET_FUNC(pGetFileVersionInfoSizeW
, version
, "GetFileVersionInfoSizeW", 0);
2376 ret
= pGetFileVersionInfoSizeW(x
, y
);
2380 /*************************************************************************
2383 * seems to be late bound call to GetFileVersionInfoW
2385 BOOL WINAPI
SHLWAPI_351 (
2386 LPWSTR w
, /* [in] path to dll */
2387 DWORD x
, /* [in] parm 2 to GetFileVersionInfoA */
2388 DWORD y
, /* [in] return value from .350 - assume length */
2389 LPVOID z
) /* [in/out] buffer (+0x208 sent to GetFileVersionInfoA) */
2391 GET_FUNC(pGetFileVersionInfoW
, version
, "GetFileVersionInfoW", 0);
2392 return pGetFileVersionInfoW(w
, x
, y
-0x208, (char*)z
+0x208);
2395 /*************************************************************************
2398 * seems to be late bound call to VerQueryValueW
2400 WORD WINAPI
SHLWAPI_352 (
2401 LPVOID w
, /* [in] buffer from _351 */
2402 LPWSTR x
, /* [in] value to retrieve -
2403 converted and passed to VerQueryValueA as #2 */
2404 LPVOID y
, /* [out] ver buffer - passed to VerQueryValueA as #3 */
2405 UINT
* z
) /* [in] ver length - passed to VerQueryValueA as #4 */
2407 GET_FUNC(pVerQueryValueW
, version
, "VerQueryValueW", 0);
2408 return pVerQueryValueW((char*)w
+0x208, x
, y
, z
);
2411 /*************************************************************************
2414 * Late bound call to shell32.SHGetNewLinkInfoW
2416 BOOL WINAPI
SHLWAPI_357(LPCWSTR pszLinkTo
, LPCWSTR pszDir
, LPWSTR pszName
,
2417 BOOL
*pfMustCopy
, UINT uFlags
)
2419 GET_FUNC(pSHGetNewLinkInfoW
, shell32
, "SHGetNewLinkInfoW", FALSE
);
2420 return pSHGetNewLinkInfoW(pszLinkTo
, pszDir
, pszName
, pfMustCopy
, uFlags
);
2423 /*************************************************************************
2426 * Late bound call to shell32.SHDefExtractIconW
2428 UINT WINAPI
SHLWAPI_358(LPCWSTR pszIconFile
, int iIndex
, UINT uFlags
, HICON
* phiconLarge
,
2429 HICON
* phiconSmall
, UINT nIconSize
)
2431 GET_FUNC(pSHDefExtractIconW
, shell32
, "SHDefExtractIconW", 0);
2432 return pSHDefExtractIconW(pszIconFile
, iIndex
, uFlags
, phiconLarge
, phiconSmall
, nIconSize
);
2435 /*************************************************************************
2438 * Wrapper for lstrcpynA with src and dst swapped.
2440 DWORD WINAPI
SHLWAPI_364(LPCSTR src
, LPSTR dst
, INT n
)
2442 lstrcpynA(dst
, src
, n
);
2446 /*************************************************************************
2449 * Late bound call to shell32.ExtractIconW
2451 HICON WINAPI
SHLWAPI_370(HINSTANCE hInstance
, LPCWSTR lpszExeFileName
,
2454 GET_FUNC(pExtractIconW
, shell32
, "ExtractIconW", NULL
);
2455 return pExtractIconW(hInstance
, lpszExeFileName
, nIconIndex
);
2458 /*************************************************************************
2461 LANGID WINAPI
SHLWAPI_376 ()
2464 /* FIXME: This should be a forward in the .spec file to the win2k function
2465 * kernel32.GetUserDefaultUILanguage, however that function isn't there yet.
2467 return GetUserDefaultLangID();
2470 /*************************************************************************
2473 * FIXME: Native appears to do DPA_Create and a DPA_InsertPtr for
2475 * FIXME: Native shows calls to:
2476 * SHRegGetUSValue for "Software\Microsoft\Internet Explorer\International"
2478 * RegOpenKeyExA for "HKLM\Software\Microsoft\Internet Explorer"
2479 * RegQueryValueExA for "LPKInstalled"
2481 * RegOpenKeyExA for "HKCU\Software\Microsoft\Internet Explorer\International"
2482 * RegQueryValueExA for "ResourceLocale"
2484 * RegOpenKeyExA for "HKLM\Software\Microsoft\Active Setup\Installed Components\{guid}"
2485 * RegQueryValueExA for "Locale"
2487 * and then tests the Locale ("en" for me).
2489 * after the code then a DPA_Create (first time) and DPA_InsertPtr are done.
2491 DWORD WINAPI
SHLWAPI_377 (LPCSTR new_mod
, HMODULE inst_hwnd
, LPVOID z
)
2493 CHAR mod_path
[2*MAX_PATH
];
2496 GetModuleFileNameA(inst_hwnd
, mod_path
, 2*MAX_PATH
);
2497 ptr
= strrchr(mod_path
, '\\');
2499 strcpy(ptr
+1, new_mod
);
2500 TRACE("loading %s\n", debugstr_a(mod_path
));
2501 return (DWORD
)LoadLibraryA(mod_path
);
2506 /*************************************************************************
2509 * This is Unicode version of .377
2511 DWORD WINAPI
SHLWAPI_378 (
2512 LPCWSTR new_mod
, /* [in] new module name */
2513 HMODULE inst_hwnd
, /* [in] calling module handle */
2514 LPVOID z
) /* [???] 4 */
2516 WCHAR mod_path
[2*MAX_PATH
];
2519 GetModuleFileNameW(inst_hwnd
, mod_path
, 2*MAX_PATH
);
2520 ptr
= strrchrW(mod_path
, '\\');
2522 strcpyW(ptr
+1, new_mod
);
2523 TRACE("loading %s\n", debugstr_w(mod_path
));
2524 return (DWORD
)LoadLibraryW(mod_path
);
2529 /*************************************************************************
2532 * Late bound call to comdlg32.GetSaveFileNameW
2534 BOOL WINAPI
SHLWAPI_389(LPOPENFILENAMEW ofn
)
2536 GET_FUNC(pGetSaveFileNameW
, comdlg32
, "GetSaveFileNameW", FALSE
);
2537 return pGetSaveFileNameW(ofn
);
2540 /*************************************************************************
2543 * Late bound call to mpr.WNetRestoreConnectionW
2545 DWORD WINAPI
SHLWAPI_390(HWND hwndOwner
, LPWSTR lpszDevice
)
2547 GET_FUNC(pWNetRestoreConnectionW
, mpr
, "WNetRestoreConnectionW", 0);
2548 return pWNetRestoreConnectionW(hwndOwner
, lpszDevice
);
2551 /*************************************************************************
2554 * Late bound call to mpr.WNetGetLastErrorW
2556 DWORD WINAPI
SHLWAPI_391(LPDWORD lpError
, LPWSTR lpErrorBuf
, DWORD nErrorBufSize
,
2557 LPWSTR lpNameBuf
, DWORD nNameBufSize
)
2559 GET_FUNC(pWNetGetLastErrorW
, mpr
, "WNetGetLastErrorW", 0);
2560 return pWNetGetLastErrorW(lpError
, lpErrorBuf
, nErrorBufSize
, lpNameBuf
, nNameBufSize
);
2563 /*************************************************************************
2566 * Late bound call to comdlg32.PageSetupDlgW
2568 BOOL WINAPI
SHLWAPI_401(LPPAGESETUPDLGW pagedlg
)
2570 GET_FUNC(pPageSetupDlgW
, comdlg32
, "PageSetupDlgW", FALSE
);
2571 return pPageSetupDlgW(pagedlg
);
2574 /*************************************************************************
2577 * Late bound call to comdlg32.PrintDlgW
2579 BOOL WINAPI
SHLWAPI_402(LPPRINTDLGW printdlg
)
2581 GET_FUNC(pPrintDlgW
, comdlg32
, "PrintDlgW", FALSE
);
2582 return pPrintDlgW(printdlg
);
2585 /*************************************************************************
2588 * Late bound call to comdlg32.GetOpenFileNameW
2590 BOOL WINAPI
SHLWAPI_403(LPOPENFILENAMEW ofn
)
2592 GET_FUNC(pGetOpenFileNameW
, comdlg32
, "GetOpenFileNameW", FALSE
);
2593 return pGetOpenFileNameW(ofn
);
2596 /* INTERNAL: Map from HLS color space to RGB */
2597 static WORD
ConvertHue(int wHue
, WORD wMid1
, WORD wMid2
)
2599 wHue
= wHue
> 240 ? wHue
- 240 : wHue
< 0 ? wHue
+ 240 : wHue
;
2603 else if (wHue
> 120)
2608 return ((wHue
* (wMid2
- wMid1
) + 20) / 40) + wMid1
;
2611 /* Convert to RGB and scale into RGB range (0..255) */
2612 #define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
2614 /*************************************************************************
2615 * ColorHLSToRGB [SHLWAPI.404]
2617 * Convert from HLS color space into an RGB COLORREF.
2620 * Input HLS values are constrained to the range (0..240).
2622 COLORREF WINAPI
ColorHLSToRGB(WORD wHue
, WORD wLuminosity
, WORD wSaturation
)
2628 WORD wGreen
, wBlue
, wMid1
, wMid2
;
2630 if (wLuminosity
> 120)
2631 wMid2
= wSaturation
+ wLuminosity
- (wSaturation
* wLuminosity
+ 120) / 240;
2633 wMid2
= ((wSaturation
+ 240) * wLuminosity
+ 120) / 240;
2635 wMid1
= wLuminosity
* 2 - wMid2
;
2637 wRed
= GET_RGB(wHue
+ 80);
2638 wGreen
= GET_RGB(wHue
);
2639 wBlue
= GET_RGB(wHue
- 80);
2641 return RGB(wRed
, wGreen
, wBlue
);
2644 wRed
= wLuminosity
* 255 / 240;
2645 return RGB(wRed
, wRed
, wRed
);
2648 /*************************************************************************
2651 DWORD WINAPI
SHLWAPI_406(LPVOID u
, LPVOID v
, LPVOID w
, LPVOID x
, LPVOID y
, LPVOID z
)
2653 FIXME("%p %p %p %p %p %p\n", u
, v
, w
, x
, y
, z
);
2657 /*************************************************************************
2660 * Function unknown seems to always to return 0
2663 DWORD WINAPI
SHLWAPI_413 (DWORD x
)
2665 FIXME("(0x%08lx)stub\n", x
);
2669 /*************************************************************************
2672 * Function seems to do FreeLibrary plus other things.
2674 * FIXME native shows the following calls:
2675 * RtlEnterCriticalSection
2677 * GetProcAddress(Comctl32??, 150L)
2679 * RtlLeaveCriticalSection
2680 * followed by the FreeLibrary.
2681 * The above code may be related to .377 above.
2683 BOOL WINAPI
SHLWAPI_418 (HMODULE x
)
2685 FIXME("(0x%08lx) partial stub\n", (LONG
)x
);
2686 return FreeLibrary(x
);
2689 /*************************************************************************
2692 DWORD WINAPI
SHLWAPI_430 (HINSTANCE hModule
, HANDLE heap
)
2694 FIXME("(0x%08lx 0x%08lx) stub\n", (DWORD
)hModule
, (DWORD
)heap
);
2695 return E_FAIL
; /* This is what is used if shlwapi not loaded */
2698 /*************************************************************************
2701 DWORD WINAPI
SHLWAPI_431 (DWORD x
)
2703 FIXME("(0x%08lx)stub\n", x
);
2707 /*************************************************************************
2710 * This is really CLSIDFromString which is exported by ole32.dll,
2711 * however the native shlwapi.dll does *not* import ole32. Nor does
2712 * ole32.dll import this ordinal from shlwapi. Therefore we must conclude
2713 * that MS duplicated the code for CLSIDFromString.
2715 * This is a duplicate (with changes for UNICODE) of CLSIDFromString16
2716 * in dlls/ole32/compobj.c
2718 DWORD WINAPI
SHLWAPI_436 (LPWSTR idstr
, CLSID
*id
)
2726 memset(s
, 0, sizeof(CLSID
));
2729 else { /* validate the CLSID string */
2731 if (strlenW(s
) != 38)
2732 return CO_E_CLASSSTRING
;
2734 if ((s
[0]!=L
'{') || (s
[9]!=L
'-') || (s
[14]!=L
'-') || (s
[19]!=L
'-') || (s
[24]!=L
'-') || (s
[37]!=L
'}'))
2735 return CO_E_CLASSSTRING
;
2737 for (i
=1; i
<37; i
++)
2739 if ((i
== 9)||(i
== 14)||(i
== 19)||(i
== 24)) continue;
2740 if (!(((s
[i
] >= L
'0') && (s
[i
] <= L
'9')) ||
2741 ((s
[i
] >= L
'a') && (s
[i
] <= L
'f')) ||
2742 ((s
[i
] >= L
'A') && (s
[i
] <= L
'F')))
2744 return CO_E_CLASSSTRING
;
2748 TRACE("%s -> %p\n", debugstr_w(s
), id
);
2750 /* quick lookup table */
2751 memset(table
, 0, 256*sizeof(WCHAR
));
2753 for (i
= 0; i
< 10; i
++) {
2756 for (i
= 0; i
< 6; i
++) {
2757 table
['A' + i
] = i
+10;
2758 table
['a' + i
] = i
+10;
2761 /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
2765 s
++; /* skip leading brace */
2766 for (i
= 0; i
< 4; i
++) {
2767 p
[3 - i
] = table
[*s
]<<4 | table
[*(s
+1)];
2773 for (i
= 0; i
< 2; i
++) {
2774 p
[1-i
] = table
[*s
]<<4 | table
[*(s
+1)];
2780 for (i
= 0; i
< 2; i
++) {
2781 p
[1-i
] = table
[*s
]<<4 | table
[*(s
+1)];
2787 /* these are just sequential bytes */
2788 for (i
= 0; i
< 2; i
++) {
2789 *p
++ = table
[*s
]<<4 | table
[*(s
+1)];
2794 for (i
= 0; i
< 6; i
++) {
2795 *p
++ = table
[*s
]<<4 | table
[*(s
+1)];
2802 /*************************************************************************
2805 * Determine if the OS supports a given feature.
2808 * dwFeature [I] Feature requested (undocumented)
2811 * TRUE If the feature is available.
2812 * FALSE If the feature is not available.
2814 DWORD WINAPI
SHLWAPI_437 (DWORD feature
)
2816 FIXME("(0x%08lx) stub\n", feature
);
2820 /*************************************************************************
2821 * ColorRGBToHLS [SHLWAPI.445]
2823 * Convert from RGB COLORREF into the HLS color space.
2826 * Input HLS values are constrained to the range (0..240).
2828 VOID WINAPI
ColorRGBToHLS(COLORREF drRGB
, LPWORD pwHue
,
2829 LPWORD wLuminance
, LPWORD pwSaturation
)
2835 /*************************************************************************
2836 * SHCreateShellPalette [SHLWAPI.@]
2838 HPALETTE WINAPI
SHCreateShellPalette(HDC hdc
)
2841 return CreateHalftonePalette(hdc
);
2844 /*************************************************************************
2845 * SHGetInverseCMAP (SHLWAPI.@)
2847 DWORD WINAPI
SHGetInverseCMAP (LPDWORD
* x
, DWORD why
)
2850 FIXME(" - returning bogus address for SHGetInverseCMAP\n");
2851 *x
= (LPDWORD
)0xabba1249;
2854 FIXME("(%p, %#lx)stub\n", x
, why
);
2858 /*************************************************************************
2859 * SHIsLowMemoryMachine [SHLWAPI.@]
2861 DWORD WINAPI
SHIsLowMemoryMachine (DWORD x
)
2863 FIXME("0x%08lx\n", x
);
2867 /*************************************************************************
2868 * GetMenuPosFromID [SHLWAPI.@]
2870 INT WINAPI
GetMenuPosFromID(HMENU hMenu
, UINT wID
)
2873 INT nCount
= GetMenuItemCount(hMenu
), nIter
= 0;
2875 while (nIter
< nCount
)
2878 if (!GetMenuItemInfoA(hMenu
, nIter
, TRUE
, &mi
) && mi
.wID
== wID
)
2885 /*************************************************************************
2886 * SHSkipJunction [SHLWAPI.@]
2888 * Determine if a bind context can be bound to an object
2891 * pbc [I] Bind context to check
2892 * pclsid [I] CLSID of object to be bound to
2895 * TRUE: If it is safe to bind
2896 * FALSE: If pbc is invalid or binding would not be safe
2899 BOOL WINAPI
SHSkipJunction(IBindCtx
*pbc
, const CLSID
*pclsid
)
2901 static WCHAR szSkipBinding
[] = { 'S','k','i','p',' ',
2902 'B','i','n','d','i','n','g',' ','C','L','S','I','D','\0' };
2909 if (SUCCEEDED(IBindCtx_GetObjectParam(pbc
, szSkipBinding
, &lpUnk
)))
2913 if (SUCCEEDED(SHLWAPI_175(lpUnk
, &clsid
)) &&
2914 IsEqualGUID(pclsid
, &clsid
))
2917 IUnknown_Release(lpUnk
);