source: trunk/src/shlwapi/ordinal.c@ 6608

Last change on this file since 6608 was 6608, checked in by phaller, 24 years ago

SHLWAPI update
File size: 29.2 KB
Line 
1/*
2 * SHLWAPI ordinal functions
3 *
4 * Copyright 1997 Marcus Meissner
5 * 1998 Jürgen Schmied
6 * 2001 Jon Griffiths
7 */
8
9#include <stdio.h>
10#include <string.h>
11
12#include "windef.h"
13#include "winnls.h"
14#include "winbase.h"
15#include "ddeml.h"
16#include "shlobj.h"
17#include "shellapi.h"
18#include "commdlg.h"
19#include "wine/unicode.h"
20#include "wine/obj_base.h"
21#include "wingdi.h"
22#include "winuser.h"
23#include "debugtools.h"
24
25DEFAULT_DEBUG_CHANNEL(shell);
26
27#ifdef __WIN32OS2__
28extern HINSTANCE shlwapi_hInstance = 0;
29extern HMODULE SHLWAPI_hshell32 = 0;
30extern HMODULE SHLWAPI_hwinmm = 0;
31extern HMODULE SHLWAPI_hcomdlg32 = 0;
32extern HMODULE SHLWAPI_hmpr = 0;
33extern HMODULE SHLWAPI_hmlang = 0;
34#undef FIXME
35#ifdef DEBUG
36#define FIXME WriteLog("FIXME %s", __FUNCTION__); WriteLog
37#else
38#define FIXME 1 ? (void)0 : (void)((int (*)(char *, ...)) NULL)
39#endif
40#else
41extern HINSTANCE shlwapi_hInstance;
42extern HMODULE SHLWAPI_hshell32;
43extern HMODULE SHLWAPI_hwinmm;
44extern HMODULE SHLWAPI_hcomdlg32;
45extern HMODULE SHLWAPI_hmpr;
46extern HMODULE SHLWAPI_hmlang;
47#endif
48
49/* Macro to get function pointer for a module*/
50#define GET_FUNC(module, name, fail) \
51 if (!SHLWAPI_h##module) SHLWAPI_h##module = LoadLibraryA(#module ".dll"); \
52 if (!SHLWAPI_h##module) return fail; \
53 if (!pfnFunc) pfnFunc = (void*)GetProcAddress(SHLWAPI_h##module, name); \
54 if (!pfnFunc) return fail
55
56/*
57 NOTES: Most functions exported by ordinal seem to be superflous.
58 The reason for these functions to be there is to provide a wraper
59 for unicode functions to provide these functions on systems without
60 unicode functions eg. win95/win98. Since we have such functions we just
61 call these. If running Wine with native DLL's, some late bound calls may
62 fail. However, its better to implement the functions in the forward DLL
63 and recommend the builtin rather than reimplementing the calls here!
64*/
65#ifndef __WIN32OS2__
66/*************************************************************************
67 * SHLWAPI_1 [SHLWAPI.1]
68 */
69DWORD WINAPI SHLWAPI_1 (
70 LPSTR lpString1,
71 LPSTR lpString2)
72{
73 if (lpString1 == NULL)
74 return 0;
75
76 if (lpString2 == NULL)
77 return 0;
78
79 FIXME("(%p %s %p %s)\n",lpStr, debugstr_a(lpStr),x, debugstr_a(x));
80 return 0;
81}
82
83/*************************************************************************
84 * SHLWAPI_2 [SHLWAPI.2]
85 */
86DWORD WINAPI SHLWAPI_2 (LPCWSTR x,LPVOID y)
87{
88 FIXME("(%s,%p)\n",debugstr_w(x),y);
89 return 0;
90}
91
92/*************************************************************************
93 * SHLWAPI_16 [SHLWAPI.16]
94 */
95HRESULT WINAPI SHLWAPI_16 (
96 LPVOID w,
97 LPVOID x,
98 LPVOID y,
99 LPWSTR z)
100{
101 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
102 return 0xabba1252;
103}
104#endif
105
106/*************************************************************************
107 * SHLWAPI_23 [SHLWAPI.23]
108 *
109 * NOTES
110 * converts a guid to a string
111 * returns strlen(str)
112 */
113DWORD WINAPI SHLWAPI_23 (
114 REFGUID guid, /* [in] clsid */
115 LPSTR str, /* [out] buffer */
116 INT cmax) /* [in] size of buffer */
117{
118 char xguid[40];
119
120 sprintf( xguid, "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
121 guid->Data1, guid->Data2, guid->Data3,
122 guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
123 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
124 TRACE("(%s %p 0x%08x)stub\n", xguid, str, cmax);
125 if (strlen(xguid)>=cmax) return 0;
126 strcpy(str,xguid);
127 return strlen(xguid) + 1;
128}
129
130/*************************************************************************
131 * SHLWAPI_24 [SHLWAPI.24]
132 *
133 * NOTES
134 * converts a guid to a string
135 * returns strlen(str)
136 */
137DWORD WINAPI SHLWAPI_24 (
138 REFGUID guid, /* [in] clsid */
139 LPWSTR str, /* [out] buffer */
140 INT cmax) /* [in] size of buffer */
141{
142 char xguid[40];
143
144 sprintf( xguid, "{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
145 guid->Data1, guid->Data2, guid->Data3,
146 guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
147 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
148 return MultiByteToWideChar( CP_ACP, 0, xguid, -1, str, cmax );
149}
150
151/*************************************************************************
152 * SHLWAPI_30 [SHLWAPI.30]
153 *
154 * Seems to be an isspaceW.
155 */
156BOOL WINAPI SHLWAPI_30(LPWSTR lpcChar)
157{
158 switch (*lpcChar)
159 {
160 case (WCHAR)'\t':
161 case (WCHAR)' ':
162 case 160:
163 case 12288:
164 case 65279:
165 return TRUE;
166 }
167 return FALSE;
168}
169
170/*************************************************************************
171 * SHLWAPI_32 [SHLWAPI.32]
172 */
173BOOL WINAPI SHLWAPI_32(LPCWSTR lpcChar)
174{
175 if (*lpcChar < (WCHAR)' ')
176 return TRUE;
177
178 /* This is probably a shlwapi bug, but we do it the same for compatability */
179 if (((DWORD)lpcChar & 0xffff) - 127 <= (WCHAR)' ')
180 return TRUE;
181 return FALSE;
182}
183
184/*************************************************************************
185 * SHLWAPI_40 [SHLWAPI.40]
186 *
187 * Get pointer to next Unicode character.
188 */
189LPCWSTR WINAPI SHLWAPI_40(LPCWSTR str)
190{
191 return *str ? str + 1 : str;
192}
193
194/*************************************************************************
195 * SHLWAPI_74 [SHLWAPI.74]
196 *
197 * Get the text from a given dialog item.
198 */
199INT WINAPI SHLWAPI_74(HWND hWnd, INT nItem, LPWSTR lpsDest,INT nDestLen)
200{
201 HWND hItem = GetDlgItem(hWnd, nItem);
202
203 if (hItem)
204 return GetWindowTextW(hItem, lpsDest, nDestLen);
205 if (nDestLen)
206 *lpsDest = (WCHAR)'\0';
207 return 0;
208}
209/*************************************************************************
210 * SHLWAPI_151 [SHLWAPI.151]
211 */
212#ifdef __WIN32OS2__
213DWORD WINAPI SHLWAPI_151(LPSTR str1, LPSTR str2, INT len)
214{
215 dprintf(("SHLWAPI_151 (strcmpn) %s %s %d", str1, str2, len));
216 if (!len)
217 return 0;
218
219 while (--len && *str1 && *str1 == *str2)
220 {
221 str1++;
222 str2++;
223 }
224 return *str1 - *str2;
225
226}
227#else
228DWORD WINAPI SHLWAPI_151(void)
229{
230 FIXME(": stub\n");
231 return 0;
232}
233#endif
234
235/*************************************************************************
236 * SHLWAPI_152 [SHLWAPI.152]
237 */
238DWORD WINAPI SHLWAPI_152(LPWSTR str1, LPWSTR str2, INT len)
239{
240 if (!len)
241 return 0;
242
243 while (--len && *str1 && *str1 == *str2)
244 {
245 str1++;
246 str2++;
247 }
248 return *str1 - *str2;
249}
250
251/*************************************************************************
252 * SHLWAPI_153 [SHLWAPI.153]
253 */
254#ifdef __WIN32OS2__
255//case insensitive string compare with length (ascii)
256DWORD WINAPI SHLWAPI_153(LPSTR str1, LPSTR str2, DWORD len)
257{
258 if (!len)
259 return 0;
260
261 return lstrncmpiA(str1, str2, len);
262}
263
264//case insensitive string compare with length (unicode)
265DWORD WINAPI SHLWAPI_154(LPWSTR str1, LPWSTR str2, DWORD len)
266{
267 if (!len)
268 return 0;
269
270 return lstrncmpiW(str1, str2, len);
271}
272
273#else
274DWORD WINAPI SHLWAPI_153(DWORD dw1, DWORD dw2, DWORD dw3)
275{
276 FIXME("%08lx %08lx %08lx - stub\n", dw1, dw2, dw3);
277 return 0;
278}
279#endif
280
281/*************************************************************************
282 * SHLWAPI_156 [SHLWAPI.156]
283 *
284 * Case sensitive string compare. Does not SetLastError().
285 */
286DWORD WINAPI SHLWAPI_156 ( LPWSTR str1, LPWSTR str2)
287{
288 while (*str1 && (*str1 == *str2)) { str1++; str2++; }
289 return (INT)(*str1 - *str2);
290}
291
292/*************************************************************************
293 * SHLWAPI_162 [SHLWAPI.162]
294 *
295 * Ensure a multibyte character string doesn't end in a hanging lead byte.
296 */
297DWORD WINAPI SHLWAPI_162(LPSTR lpStr, DWORD size)
298{
299 if (lpStr && size)
300 {
301 LPSTR lastByte = lpStr + size - 1;
302
303 while(lpStr < lastByte)
304 lpStr += IsDBCSLeadByte(*lpStr) ? 2 : 1;
305
306 if(lpStr == lastByte && IsDBCSLeadByte(*lpStr))
307 {
308 *lpStr = '\0';
309 size--;
310 }
311 return size;
312 }
313 return 0;
314}
315
316/*************************************************************************
317 * SHLWAPI_165 [SHLWAPI.165]
318 *
319 * SetWindowLongA with mask.
320 */
321LONG WINAPI SHLWAPI_165(HWND hwnd, INT offset, UINT wFlags, UINT wMask)
322{
323 LONG ret = GetWindowLongA(hwnd, offset);
324 UINT newFlags = (wFlags & wMask) | (ret & ~wFlags);
325
326 if (newFlags != ret)
327 ret = SetWindowLongA(hwnd, offset, newFlags);
328 return ret;
329}
330
331/*************************************************************************
332 * SHLWAPI_169 [SHLWAPI.169]
333 */
334DWORD WINAPI SHLWAPI_169 (IUnknown * lpUnknown)
335{
336 TRACE("(%p)\n",lpUnknown);
337#if 0
338 if(!lpUnknown || !*((LPDWORD)lpUnknown)) return 0;
339 return IUnknown_Release(lpUnknown);
340#endif
341 return 0;
342}
343
344/*************************************************************************
345 * SHLWAPI_170 [SHLWAPI.170]
346 *
347 * Skip URL '//' sequence.
348 */
349LPCSTR WINAPI SHLWAPI_170(LPCSTR lpszSrc)
350{
351 if (lpszSrc && lpszSrc[0] == '/' && lpszSrc[1] == '/')
352 lpszSrc += 2;
353 return lpszSrc;
354}
355
356/*************************************************************************
357 * SHLWAPI_181 [SHLWAPI.181]
358 *
359 * Enable or disable a menu item.
360 */
361UINT WINAPI SHLWAPI_181(HMENU hMenu, UINT wItemID, BOOL bEnable)
362{
363 return EnableMenuItem(hMenu, wItemID, bEnable ? MF_ENABLED : MF_GRAYED);
364}
365
366/*************************************************************************
367 * SHLWAPI_183 [SHLWAPI.183]
368 *
369 * Register a window class if it isn't already.
370 */
371DWORD WINAPI SHLWAPI_183(WNDCLASSA *wndclass)
372{
373 WNDCLASSA wca;
374 if (GetClassInfoA(wndclass->hInstance, wndclass->lpszClassName, &wca))
375 return TRUE;
376 return (DWORD)RegisterClassA(wndclass);
377}
378
379/*************************************************************************
380 * SHLWAPI_193 [SHLWAPI.193]
381 */
382DWORD WINAPI SHLWAPI_193 ()
383{
384 HDC hdc;
385 DWORD ret;
386
387 TRACE("()\n");
388
389 hdc = GetDC(0);
390 ret = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
391 ReleaseDC(0, hdc);
392 return ret;
393}
394
395/*************************************************************************
396 * SHLWAPI_215 [SHLWAPI.215]
397 *
398 * NOTES
399 * check me!
400 */
401LPWSTR WINAPI SHLWAPI_215 (
402 LPWSTR lpStrSrc,
403 LPVOID lpwStrDest,
404 int len)
405{
406 WARN("(%p %p %u)\n",lpStrSrc,lpwStrDest,len);
407 return strncpyW(lpwStrDest, lpStrSrc, len);
408}
409
410/*************************************************************************
411 * SHLWAPI_218 [SHLWAPI.218]
412 *
413 * WideCharToMultiByte with multi language support.
414 */
415INT WINAPI SHLWAPI_218(UINT CodePage, LPCWSTR lpSrcStr, LPSTR lpDstStr,
416 LPINT lpnMultiCharCount)
417{
418#ifdef __WIN32OS2__
419 static HRESULT (* WINAPI pfnFunc)(LPDWORD,DWORD,LPCWSTR,LPINT,LPSTR,LPINT);
420#else
421 static HRESULT (* WINAPI pfnFunc)(LPDWORD,DWORD,LPCWSTR,LPINT,LPSTR,LPINT);
422#endif
423 WCHAR emptyW[] = { '\0' };
424 int len , reqLen;
425 LPSTR mem;
426
427 if (!lpDstStr || !lpnMultiCharCount)
428 return 0;
429
430 if (!lpSrcStr)
431 lpSrcStr = emptyW;
432
433 *lpDstStr = '\0';
434
435 len = strlenW(lpSrcStr) + 1;
436
437 switch (CodePage)
438 {
439 case CP_WINUNICODE:
440 CodePage = CP_UTF8; /* Fall through... */
441 case 0x0000C350: /* FIXME: CP_ #define */
442 case CP_UTF7:
443 case CP_UTF8:
444 {
445 DWORD dwMode = 0;
446 INT nWideCharCount = len - 1;
447
448 GET_FUNC(mlang, "ConvertINetUnicodeToMultiByte", 0);
449 if (!pfnFunc(&dwMode, CodePage, lpSrcStr, &nWideCharCount, lpDstStr,
450 lpnMultiCharCount))
451 return 0;
452
453 if (nWideCharCount < len - 1)
454 {
455 mem = (LPSTR)HeapAlloc(GetProcessHeap(), 0, *lpnMultiCharCount);
456 if (!mem)
457 return 0;
458
459 *lpnMultiCharCount = 0;
460
461 if (pfnFunc(&dwMode, CodePage, lpSrcStr, &len, mem, lpnMultiCharCount))
462 {
463 SHLWAPI_162 (mem, *lpnMultiCharCount);
464 lstrcpynA(lpDstStr, mem, *lpnMultiCharCount + 1);
465 return *lpnMultiCharCount + 1;
466 }
467 HeapFree(GetProcessHeap(), 0, mem);
468 return *lpnMultiCharCount;
469 }
470 lpDstStr[*lpnMultiCharCount] = '\0';
471 return *lpnMultiCharCount;
472 }
473 break;
474 default:
475 break;
476 }
477
478 reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, lpDstStr,
479 *lpnMultiCharCount, NULL, NULL);
480
481 if (!reqLen && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
482 {
483 reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, NULL, 0, NULL, NULL);
484 if (reqLen)
485 {
486 mem = (LPSTR)HeapAlloc(GetProcessHeap(), 0, reqLen);
487 if (mem)
488 {
489 reqLen = WideCharToMultiByte(CodePage, 0, lpSrcStr, len, mem,
490 reqLen, NULL, NULL);
491
492 reqLen = SHLWAPI_162(mem, *lpnMultiCharCount);
493 reqLen++;
494
495 lstrcpynA(lpDstStr, mem, *lpnMultiCharCount);
496
497 HeapFree(GetProcessHeap(), 0, mem);
498 }
499 }
500 }
501 return reqLen;
502}
503
504/*************************************************************************
505 * SHLWAPI_217 [SHLWAPI.217]
506 *
507 */
508INT WINAPI SHLWAPI_217(LPCWSTR lpSrcStr, LPSTR lpDstStr, LPINT lpnMultiCharCount)
509{
510 return SHLWAPI_218(CP_ACP, lpSrcStr, lpDstStr, lpnMultiCharCount);
511}
512
513#ifndef __WIN32OS2__
514/*************************************************************************
515 * SHLWAPI_219 [SHLWAPI.219]
516 *
517 * NOTES
518 * error codes: E_POINTER, E_NOINTERFACE
519 */
520HRESULT WINAPI SHLWAPI_219 (
521 LPVOID w, /* [???] NOTE: returned by LocalAlloc, 0x450 bytes, iface */
522 LPVOID x,
523 REFIID riid,
524 LPWSTR z) /* [???] NOTE: OUT: path */
525{
526 FIXME("(%p %p %s %p)stub\n",w,x,debugstr_guid(riid),z);
527 return 0xabba1252;
528}
529#endif
530
531/*************************************************************************
532 * SHLWAPI_222 [SHLWAPI.222]
533 *
534 * NOTES
535 * securityattributes missing
536 */
537HANDLE WINAPI SHLWAPI_222 (LPCLSID guid)
538{
539 char lpstrName[80];
540
541 sprintf( lpstrName, "shell.{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
542 guid->Data1, guid->Data2, guid->Data3,
543 guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
544 guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7] );
545 FIXME("(%s) stub\n", lpstrName);
546 return CreateSemaphoreA(NULL,0, 0x7fffffff, lpstrName);
547}
548
549/*************************************************************************
550 * SHLWAPI_223 [SHLWAPI.223]
551 *
552 * NOTES
553 * get the count of the semaphore
554 */
555DWORD WINAPI SHLWAPI_223 (HANDLE handle)
556{
557 DWORD oldCount;
558
559 FIXME("(0x%08x) stub\n",handle);
560
561 ReleaseSemaphore( handle, 1, &oldCount); /* +1 */
562 WaitForSingleObject( handle, 0 ); /* -1 */
563 return oldCount;
564}
565
566/*************************************************************************
567 * SHLWAPI_237 [SHLWAPI.237]
568 *
569 * Unicode version of SHLWAPI_183.
570 */
571DWORD WINAPI SHLWAPI_237 (WNDCLASSW * lpWndClass)
572{
573 WNDCLASSW WndClass;
574
575 TRACE("(0x%08x %s)\n",lpWndClass->hInstance, debugstr_w(lpWndClass->lpszClassName));
576
577 if (GetClassInfoW(lpWndClass->hInstance, lpWndClass->lpszClassName, &WndClass))
578 return TRUE;
579 return RegisterClassW(lpWndClass);
580}
581
582/*************************************************************************
583 * SHLWAPI_240 [SHLWAPI.240]
584 *
585 * Calls ASCII or Unicode WindowProc for the given window.
586 */
587LRESULT CALLBACK SHLWAPI_240(HWND hWnd, UINT uMessage, WPARAM wParam, LPARAM lParam)
588{
589 if (IsWindowUnicode(hWnd))
590 return DefWindowProcW(hWnd, uMessage, wParam, lParam);
591 return DefWindowProcA(hWnd, uMessage, wParam, lParam);
592}
593#ifndef __WIN32OS2__
594/*************************************************************************
595 * SHLWAPI_241 [SHLWAPI.241]
596 *
597 */
598DWORD WINAPI SHLWAPI_241 ()
599{
600 FIXME("()stub\n");
601 return 0xabba1243;
602}
603
604/*************************************************************************
605 * SHLWAPI_266 [SHLWAPI.266]
606 */
607DWORD WINAPI SHLWAPI_266 (
608 LPVOID w,
609 LPVOID x,
610 LPVOID y,
611 LPVOID z)
612{
613 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
614 return 0xabba1248;
615}
616
617/*************************************************************************
618 * SHLWAPI_267 [SHLWAPI.267]
619 */
620HRESULT WINAPI SHLWAPI_267 (
621 LPVOID w, /* [???] NOTE: same as 1th parameter of SHLWAPI_219 */
622 LPVOID x, /* [???] NOTE: same as 2nd parameter of SHLWAPI_219 */
623 LPVOID y,
624 LPVOID z)
625{
626 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
627 *((LPDWORD)z) = 0xabba1200;
628 return 0xabba1254;
629}
630
631/*************************************************************************
632 * SHLWAPI_268 [SHLWAPI.268]
633 */
634DWORD WINAPI SHLWAPI_268 (
635 LPVOID w,
636 LPVOID x)
637{
638 FIXME("(%p %p)\n",w,x);
639 return 0xabba1251; /* 0 = failure */
640}
641
642/*************************************************************************
643 * SHLWAPI_276 [SHLWAPI.276]
644 *
645 */
646DWORD WINAPI SHLWAPI_276 ()
647{
648 FIXME("()stub\n");
649 return 0xabba1244;
650}
651#endif
652/*************************************************************************
653 * SHLWAPI_278 [SHLWAPI.278]
654 *
655 */
656DWORD WINAPI SHLWAPI_278 (
657 LONG wndProc,
658 HWND hWndParent,
659 DWORD dwExStyle,
660 DWORD dwStyle,
661 HMENU hMenu,
662 LONG z)
663{
664 WNDCLASSA wndclass;
665 HWND hwnd;
666 HCURSOR hCursor;
667 char * clsname = "WorkerA";
668
669 FIXME("(0x%08lx 0x%08x 0x%08lx 0x%08lx 0x%08x 0x%08lx)stub\n",
670 wndProc,hWndParent,dwExStyle,dwStyle,hMenu,z);
671
672 hCursor = LoadCursorA(0x00000000,IDC_ARROWA);
673
674 if(!GetClassInfoA(shlwapi_hInstance, clsname, &wndclass))
675 {
676 RtlZeroMemory(&wndclass, sizeof(WNDCLASSA));
677 wndclass.lpfnWndProc = DefWindowProcW;
678 wndclass.cbWndExtra = 4;
679 wndclass.hInstance = shlwapi_hInstance;
680 wndclass.hCursor = hCursor;
681 wndclass.hbrBackground = COLOR_BTNSHADOW;
682 wndclass.lpszMenuName = NULL;
683 wndclass.lpszClassName = clsname;
684 RegisterClassA (&wndclass);
685 }
686 hwnd = CreateWindowExA(dwExStyle, clsname, 0,dwStyle,0,0,0,0,hWndParent,
687 hMenu,shlwapi_hInstance,0);
688 SetWindowLongA(hwnd, 0, z);
689 SetWindowLongA(hwnd, GWL_WNDPROC, wndProc);
690 return hwnd;
691}
692
693/*************************************************************************
694 * SHLWAPI_289 [SHLWAPI.289]
695 *
696 * Late bound call to winmm.PlaySoundW
697 */
698BOOL WINAPI SHLWAPI_289(LPCWSTR pszSound, HMODULE hmod, DWORD fdwSound)
699{
700 static BOOL (* WINAPI pfnFunc)(LPCWSTR, HMODULE, DWORD) = NULL;
701
702 GET_FUNC(winmm, "PlaySoundW", FALSE);
703 return pfnFunc(pszSound, hmod, fdwSound);
704}
705
706/*************************************************************************
707 * SHLWAPI_313 [SHLWAPI.313]
708 *
709 * Late bound call to shell32.SHGetFileInfoW
710 */
711DWORD WINAPI SHLWAPI_313(LPCWSTR path, DWORD dwFileAttributes,
712 SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags)
713{
714 static DWORD (* WINAPI pfnFunc)(LPCWSTR,DWORD,SHFILEINFOW*,UINT,UINT) = NULL;
715
716 GET_FUNC(shell32, "SHGetFileInfoW", 0);
717 return pfnFunc(path, dwFileAttributes, psfi, sizeofpsfi, flags);
718}
719
720/*************************************************************************
721 * SHLWAPI_318 [SHLWAPI.318]
722 *
723 * Late bound call to shell32.DragQueryFileW
724 */
725UINT WINAPI SHLWAPI_318(HDROP hDrop, UINT lFile, LPWSTR lpszFile, UINT lLength)
726{
727 static UINT (* WINAPI pfnFunc)(HDROP, UINT, LPWSTR, UINT) = NULL;
728
729 GET_FUNC(shell32, "DragQueryFileW", 0);
730 return pfnFunc(hDrop, lFile, lpszFile, lLength);
731}
732
733/*************************************************************************
734 * SHLWAPI_333 [SHLWAPI.333]
735 *
736 * Late bound call to shell32.SHBrowseForFolderW
737 */
738LPITEMIDLIST WINAPI SHLWAPI_333(LPBROWSEINFOW lpBi)
739{
740 static LPITEMIDLIST (* WINAPI pfnFunc)(LPBROWSEINFOW) = NULL;
741
742 GET_FUNC(shell32, "SHBrowseForFolderW", NULL);
743 return pfnFunc(lpBi);
744}
745
746/*************************************************************************
747 * SHLWAPI_334 [SHLWAPI.334]
748 *
749 * Late bound call to shell32.SHGetPathFromIDListW
750 */
751BOOL WINAPI SHLWAPI_334(LPCITEMIDLIST pidl,LPWSTR pszPath)
752{
753 static BOOL (* WINAPI pfnFunc)(LPCITEMIDLIST, LPWSTR) = NULL;
754
755 GET_FUNC(shell32, "SHGetPathFromIDListW", 0);
756 return pfnFunc(pidl, pszPath);
757}
758
759/*************************************************************************
760 * SHLWAPI_335 [SHLWAPI.335]
761 *
762 * Late bound call to shell32.ShellExecuteExW
763 */
764BOOL WINAPI SHLWAPI_335(LPSHELLEXECUTEINFOW lpExecInfo)
765{
766 static BOOL (* WINAPI pfnFunc)(LPSHELLEXECUTEINFOW) = NULL;
767
768 GET_FUNC(shell32, "ShellExecuteExW", FALSE);
769 return pfnFunc(lpExecInfo);
770}
771
772/*************************************************************************
773 * SHLWAPI_336 [SHLWAPI.336]
774 *
775 * Late bound call to shell32.SHFileOperationW.
776 */
777DWORD WINAPI SHLWAPI_336(LPSHFILEOPSTRUCTW lpFileOp)
778{
779 static HICON (* WINAPI pfnFunc)(LPSHFILEOPSTRUCTW) = NULL;
780
781 GET_FUNC(shell32, "SHFileOperationW", 0);
782 return pfnFunc(lpFileOp);
783}
784
785/*************************************************************************
786 * SHLWAPI_337 [SHLWAPI.337]
787 *
788 * Late bound call to shell32.ExtractIconExW.
789 */
790HICON WINAPI SHLWAPI_337(LPCWSTR lpszFile, INT nIconIndex, HICON *phiconLarge,
791 HICON *phiconSmall, UINT nIcons)
792{
793 static HICON (* WINAPI pfnFunc)(LPCWSTR, INT,HICON *,HICON *, UINT) = NULL;
794
795 GET_FUNC(shell32, "ExtractIconExW", (HICON)0);
796 return pfnFunc(lpszFile, nIconIndex, phiconLarge, phiconSmall, nIcons);
797}
798#ifndef __WIN32OS2__
799//Bugbug: is forwarder for InterlockedCompareExchange
800/*************************************************************************
801 * SHLWAPI_342 [SHLWAPI.342]
802 *
803 */
804DWORD WINAPI SHLWAPI_342 (
805 LPVOID w,
806 LPVOID x,
807 LPVOID y,
808 LPVOID z)
809{
810 FIXME("(%p %p %p %p)stub\n",w,x,y,z);
811 return 0xabba1249;
812}
813#endif
814/*************************************************************************
815 * SHLWAPI_346 [SHLWAPI.346]
816 */
817DWORD WINAPI SHLWAPI_346 (
818 LPCWSTR src,
819 LPWSTR dest,
820 int len)
821{
822 FIXME("(%s %p 0x%08x)stub\n",debugstr_w(src),dest,len);
823 lstrcpynW(dest, src, len);
824 return lstrlenW(dest)+1;
825}
826
827/*************************************************************************
828 * SHLWAPI_357 [SHLWAPI.357]
829 *
830 * Late bound call to shell32.SHGetNewLinkInfoW
831 */
832BOOL WINAPI SHLWAPI_357(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName,
833 BOOL *pfMustCopy, UINT uFlags)
834{
835 static BOOL (* WINAPI pfnFunc)(LPCWSTR, LPCWSTR, LPCWSTR, BOOL*, UINT) = NULL;
836
837 GET_FUNC(shell32, "SHGetNewLinkInfoW", FALSE);
838 return pfnFunc(pszLinkTo, pszDir, pszName, pfMustCopy, uFlags);
839}
840
841/*************************************************************************
842 * SHLWAPI_358 [SHLWAPI.358]
843 *
844 * Late bound call to shell32.SHDefExtractIconW
845 */
846DWORD WINAPI SHLWAPI_358(LPVOID arg1, LPVOID arg2, LPVOID arg3, LPVOID arg4,
847 LPVOID arg5, LPVOID arg6)
848{
849 /* FIXME: Correct args */
850 static DWORD (* WINAPI pfnFunc)(LPVOID, LPVOID, LPVOID, LPVOID, LPVOID, LPVOID) = NULL;
851
852 GET_FUNC(shell32, "SHDefExtractIconW", 0);
853 return pfnFunc(arg1, arg2, arg3, arg4, arg5, arg6);
854}
855
856/*************************************************************************
857 * SHLWAPI_364 [SHLWAPI.364]
858 *
859 * Wrapper for lstrcpynA with src and dst swapped.
860 */
861DWORD WINAPI SHLWAPI_364(LPCSTR src, LPSTR dst, INT n)
862{
863 lstrcpynA(dst, src, n);
864 return TRUE;
865}
866
867/*************************************************************************
868 * SHLWAPI_370 [SHLWAPI.370]
869 *
870 * Late bound call to shell32.ExtractIconW
871 */
872HICON WINAPI SHLWAPI_370(HINSTANCE hInstance, LPCWSTR lpszExeFileName,
873 UINT nIconIndex)
874{
875 static HICON (* WINAPI pfnFunc)(HINSTANCE, LPCWSTR, UINT) = NULL;
876
877 GET_FUNC(shell32, "ExtractIconW", (HICON)0);
878 return pfnFunc(hInstance, lpszExeFileName, nIconIndex);
879}
880
881/*************************************************************************
882 * SHLWAPI_376 [SHLWAPI.376]
883 */
884DWORD WINAPI SHLWAPI_376 (LONG x)
885{
886 FIXME("(0x%08lx)stub\n", x );
887 /* FIXME: This should be a forward in the .spec file to the win2k function
888 * kernel32.GetUserDefaultUILanguage, however that function isn't there yet.
889 */
890 return 0xabba1245;
891}
892#ifndef __WIN32OS2__
893/*************************************************************************
894 * SHLWAPI_377 [SHLWAPI.377]
895 */
896DWORD WINAPI SHLWAPI_377 (LPVOID x, LPVOID y, LPVOID z)
897{
898 FIXME("(%p %p %p)stub\n", x,y,z);
899 return 0xabba1246;
900}
901#endif
902/*************************************************************************
903 * SHLWAPI_378 [SHLWAPI.378]
904 */
905DWORD WINAPI SHLWAPI_378 (
906 LPSTR x,
907 LPVOID y, /* [???] 0x50000000 */
908 LPVOID z) /* [???] 4 */
909{
910 FIXME("(%s %p %p)stub\n", x,y,z);
911 return LoadLibraryA(x);
912}
913
914/*************************************************************************
915 * SHLWAPI_389 [SHLWAPI.389]
916 *
917 * Late bound call to comdlg32.GetSaveFileNameW
918 */
919BOOL WINAPI SHLWAPI_389(LPOPENFILENAMEW ofn)
920{
921 static BOOL (* WINAPI pfnFunc)(LPOPENFILENAMEW) = NULL;
922
923 GET_FUNC(comdlg32, "GetSaveFileNameW", FALSE);
924 return pfnFunc(ofn);
925}
926
927/*************************************************************************
928 * SHLWAPI_390 [SHLWAPI.390]
929 *
930 * Late bound call to mpr.WNetRestoreConnectionW
931 */
932DWORD WINAPI SHLWAPI_390(LPVOID arg1, LPVOID arg2)
933{
934 /* FIXME: Correct args */
935 static DWORD (* WINAPI pfnFunc)(LPVOID, LPVOID) = NULL;
936
937 GET_FUNC(mpr, "WNetRestoreConnectionW", 0);
938 return pfnFunc(arg1, arg2);
939}
940
941/*************************************************************************
942 * SHLWAPI_391 [SHLWAPI.391]
943 *
944 * Late bound call to mpr.WNetGetLastErrorW
945 */
946DWORD WINAPI SHLWAPI_391(LPVOID arg1, LPVOID arg2, LPVOID arg3, LPVOID arg4,
947 LPVOID arg5)
948{
949 /* FIXME: Correct args */
950 static DWORD (* WINAPI pfnFunc)(LPVOID, LPVOID, LPVOID, LPVOID, LPVOID) = NULL;
951
952 GET_FUNC(mpr, "WNetGetLastErrorW", 0);
953 return pfnFunc(arg1, arg2, arg3, arg4, arg5);
954}
955
956/*************************************************************************
957 * SHLWAPI_401 [SHLWAPI.401]
958 *
959 * Late bound call to comdlg32.PageSetupDlgW
960 */
961BOOL WINAPI SHLWAPI_401(LPPAGESETUPDLGW pagedlg)
962{
963 static BOOL (* WINAPI pfnFunc)(LPPAGESETUPDLGW) = NULL;
964
965 GET_FUNC(comdlg32, "PageSetupDlgW", FALSE);
966 return pfnFunc(pagedlg);
967}
968
969/*************************************************************************
970 * SHLWAPI_402 [SHLWAPI.402]
971 *
972 * Late bound call to comdlg32.PrintDlgW
973 */
974BOOL WINAPI SHLWAPI_402(LPPRINTDLGW printdlg)
975{
976 static BOOL (* WINAPI pfnFunc)(LPPRINTDLGW) = NULL;
977
978 GET_FUNC(comdlg32, "PrintDlgW", FALSE);
979 return pfnFunc(printdlg);
980}
981
982/*************************************************************************
983 * SHLWAPI_403 [SHLWAPI.403]
984 *
985 * Late bound call to comdlg32.GetOpenFileNameW
986 */
987BOOL WINAPI SHLWAPI_403(LPOPENFILENAMEW ofn)
988{
989 static BOOL (* WINAPI pfnFunc)(LPOPENFILENAMEW) = NULL;
990
991 GET_FUNC(comdlg32, "GetOpenFileNameW", FALSE);
992 return pfnFunc(ofn);
993}
994
995/* INTERNAL: Map from HLS color space to RGB */
996static WORD ConvertHue(int wHue, WORD wMid1, WORD wMid2)
997{
998 wHue = wHue > 240 ? wHue - 240 : wHue < 0 ? wHue + 240 : wHue;
999
1000 if (wHue > 160)
1001 return wMid1;
1002 else if (wHue > 120)
1003 wHue = 160 - wHue;
1004 else if (wHue > 40)
1005 return wMid2;
1006
1007 return ((wHue * (wMid2 - wMid1) + 20) / 40) + wMid1;
1008}
1009
1010/* Convert to RGB and scale into RGB range (0..255) */
1011#define GET_RGB(h) (ConvertHue(h, wMid1, wMid2) * 255 + 120) / 240
1012
1013/*************************************************************************
1014 * ColorHLSToRGB [SHLWAPI.404]
1015 *
1016 * Convert from HLS color space into an RGB COLORREF.
1017 *
1018 * NOTES
1019 * Input HLS values are constrained to the range (0..240).
1020 */
1021COLORREF WINAPI ColorHLSToRGB(WORD wHue, WORD wLuminosity, WORD wSaturation)
1022{
1023 WORD wRed;
1024
1025 if (wSaturation)
1026 {
1027 WORD wGreen, wBlue, wMid1, wMid2;
1028
1029 if (wLuminosity > 120)
1030 wMid2 = wSaturation + wLuminosity - (wSaturation * wLuminosity + 120) / 240;
1031 else
1032 wMid2 = ((wSaturation + 240) * wLuminosity + 120) / 240;
1033
1034 wMid1 = wLuminosity * 2 - wMid2;
1035
1036 wRed = GET_RGB(wHue + 80);
1037 wGreen = GET_RGB(wHue);
1038 wBlue = GET_RGB(wHue - 80);
1039
1040 return RGB(wRed, wGreen, wBlue);
1041 }
1042
1043 wRed = wLuminosity * 255 / 240;
1044 return RGB(wRed, wRed, wRed);
1045}
1046
1047/*************************************************************************
1048 * SHLWAPI_431 [SHLWAPI.431]
1049 */
1050DWORD WINAPI SHLWAPI_431 (DWORD x)
1051{
1052 FIXME("(0x%08lx)stub\n", x);
1053 return 0xabba1247;
1054}
1055
1056#ifndef __WIN32OS2__
1057/*************************************************************************
1058 * SHLWAPI_437 [SHLWAPI.437]
1059 *
1060 * NOTES
1061 * In the real shlwapi, One time initilisation calls GetVersionEx and reads
1062 * the registry to determine what O/S & Service Pack level is running, and
1063 * therefore which functions are available. Currently we always run as NT,
1064 * since this means that we don't need extra code to emulate Unicode calls,
1065 * they are forwarded directly to the appropriate API call instead.
1066 * Since the flags for whether to call or emulate Unicode are internal to
1067 * the dll, this function does not need a full implementation.
1068 */
1069DWORD WINAPI SHLWAPI_437 (DWORD functionToCall)
1070{
1071 FIXME("(0x%08lx)stub\n", functionToCall);
1072 return 0xabba1247;
1073}
1074#endif
1075
1076/*************************************************************************
1077 * SHCreateShellPalette [SHLWAPI.@]
1078 */
1079HPALETTE WINAPI SHCreateShellPalette(HDC hdc)
1080{
1081 FIXME("stub\n");
1082 return CreateHalftonePalette(hdc);
1083}
1084
1085/*************************************************************************
1086 * SHGetInverseCMAP
1087 */
1088DWORD WINAPI SHGetInverseCMAP (LPVOID x, DWORD why)
1089{
1090 FIXME("(%p, %#lx)stub\n", x, why);
1091 return 0;
1092}
1093#ifndef __WIN32OS2__
1094/*************************************************************************
1095 * SHIsLowMemoryMachine [SHLWAPI.@]
1096 */
1097DWORD WINAPI SHIsLowMemoryMachine (DWORD x)
1098{
1099 FIXME("0x%08lx\n", x);
1100 return 0;
1101}
1102#endif
1103
1104/*************************************************************************
1105 * GetMenuPosFromID [SHLWAPI.@]
1106 */
1107INT WINAPI GetMenuPosFromID(HMENU hMenu, UINT wID)
1108{
1109 MENUITEMINFOA mi;
1110 INT nCount = GetMenuItemCount(hMenu), nIter = 0;
1111
1112 while (nIter < nCount)
1113 {
1114 mi.wID = 0;
1115 if (!GetMenuItemInfoA(hMenu, nIter, TRUE, &mi) && mi.wID == wID)
1116 return nIter;
1117 nIter++;
1118 }
1119 return -1;
1120}
1121
1122/*************************************************************************
1123 * _SHGetInstanceExplorer [SHLWAPI.@]
1124 *
1125 * Late bound call to shell32.SHGetInstanceExplorer.
1126 */
1127HRESULT WINAPI _SHGetInstanceExplorer (LPUNKNOWN *lpUnknown)
1128{
1129 static HRESULT (* WINAPI pfnFunc)(LPUNKNOWN *) = NULL;
1130
1131 GET_FUNC(shell32, "SHGetInstanceExplorer", E_FAIL);
1132 return pfnFunc(lpUnknown);
1133}
Note: See TracBrowser for help on using the repository browser.