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

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

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