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

Last change on this file since 7508 was 7508, checked in by sandervl, 24 years ago

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