?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added memicmpW.
[wine.git] / dlls / shell32 / shellord.c
blob55b0b3f33ebed92991926f9f0b939e3dcfdbc896
1 /*
2 * The parameters of many functions changes between different OS versions
3 * (NT uses Unicode strings, 95 uses ASCII strings)
4 *
5 * Copyright 1997 Marcus Meissner
6 * 1998 Jürgen Schmied
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22 #include "config.h"
23
24 #include <string.h>
25 #include <stdarg.h>
26 #include <stdio.h>
27 #include "winerror.h"
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winreg.h"
31 #include "wine/debug.h"
32 #include "winnls.h"
33
34 #include "shellapi.h"
35 #include "objbase.h"
36 #include "shlguid.h"
37 #include "wingdi.h"
38 #include "winuser.h"
39 #include "shlobj.h"
40 #include "shell32_main.h"
41 #include "undocshell.h"
42 #include "pidl.h"
43 #include "shlwapi.h"
44 #include "commdlg.h"
45
46 WINE_DEFAULT_DEBUG_CHANNEL(shell);
47 WINE_DECLARE_DEBUG_CHANNEL(pidl);
48
49 /* FIXME: !!! move CREATEMRULIST and flags to header file !!! */
50 /* !!! it is in both here and comctl32undoc.c !!! */
51 typedef struct tagCREATEMRULIST
52 {
53 DWORD cbSize; /* size of struct */
54 DWORD nMaxItems; /* max no. of items in list */
55 DWORD dwFlags; /* see below */
56 HKEY hKey; /* root reg. key under which list is saved */
57 LPCSTR lpszSubKey; /* reg. subkey */
58 PROC lpfnCompare; /* item compare proc */
59 } CREATEMRULISTA, *LPCREATEMRULISTA;
60
61 /* dwFlags */
62 #define MRUF_STRING_LIST 0 /* list will contain strings */
63 #define MRUF_BINARY_LIST 1 /* list will contain binary data */
64 #define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */
65
66 extern HANDLE WINAPI CreateMRUListA(LPCREATEMRULISTA lpcml);
67 extern DWORD WINAPI FreeMRUList(HANDLE hMRUList);
68 extern INT WINAPI AddMRUData(HANDLE hList, LPCVOID lpData, DWORD cbData);
69 extern INT WINAPI FindMRUData(HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum);
70 extern INT WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer, DWORD nBufferSize);
71
72 /*************************************************************************
73 * ParseFieldA [internal]
74 *
75 * copies a field from a ',' delimited string
76 *
77 * first field is nField = 1
78 */
79 DWORD WINAPI ParseFieldA(
80 LPCSTR src,
81 DWORD nField,
82 LPSTR dst,
83 DWORD len)
84 {
85 WARN("(%s,0x%08lx,%p,%ld) semi-stub.\n",debugstr_a(src),nField,dst,len);
86
87 if (!src || !src[0] || !dst || !len)
88 return 0;
89
90 /* skip n fields delimited by ',' */
91 while (nField > 1)
92 {
93 if (*src=='\0') return FALSE;
94 if (*(src++)==',') nField--;
95 }
96
97 /* copy part till the next ',' to dst */
98 while ( *src!='\0' && *src!=',' && (len--)>0 ) *(dst++)=*(src++);
99
100 /* finalize the string */
101 *dst=0x0;
102
103 return TRUE;
104 }
105
106 /*************************************************************************
107 * ParseFieldW [internal]
108 *
109 * copies a field from a ',' delimited string
110 *
111 * first field is nField = 1
112 */
113 DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len)
114 {
115 WARN("(%s,0x%08lx,%p,%ld) semi-stub.\n", debugstr_w(src), nField, dst, len);
116
117 if (!src || !src[0] || !dst || !len)
118 return 0;
119
120 /* skip n fields delimited by ',' */
121 while (nField > 1)
122 {
123 if (*src == 0x0) return FALSE;
124 if (*src++ == ',') nField--;
125 }
126
127 /* copy part till the next ',' to dst */
128 while ( *src != 0x0 && *src != ',' && (len--)>0 ) *(dst++) = *(src++);
129
130 /* finalize the string */
131 *dst = 0x0;
132
133 return TRUE;
134 }
135
136 /*************************************************************************
137 * ParseField [SHELL32.58]
138 */
139 DWORD WINAPI ParseFieldAW(LPCVOID src, DWORD nField, LPVOID dst, DWORD len)
140 {
141 if (SHELL_OsIsUnicode())
142 return ParseFieldW(src, nField, dst, len);
143 return ParseFieldA(src, nField, dst, len);
144 }
145
146 /*************************************************************************
147 * GetFileNameFromBrowse [SHELL32.63]
148 *
149 */
150 BOOL WINAPI GetFileNameFromBrowse(
151 HWND hwndOwner,
152 LPSTR lpstrFile,
153 DWORD nMaxFile,
154 LPCSTR lpstrInitialDir,
155 LPCSTR lpstrDefExt,
156 LPCSTR lpstrFilter,
157 LPCSTR lpstrTitle)
158 {
159 HMODULE hmodule;
160 FARPROC pGetOpenFileNameA;
161 OPENFILENAMEA ofn;
162 BOOL ret;
163
164 TRACE("%p, %s, %ld, %s, %s, %s, %s)\n",
165 hwndOwner, lpstrFile, nMaxFile, lpstrInitialDir, lpstrDefExt,
166 lpstrFilter, lpstrTitle);
167
168 hmodule = LoadLibraryA("comdlg32.dll");
169 if(!hmodule) return FALSE;
170 pGetOpenFileNameA = GetProcAddress(hmodule, "GetOpenFileNameA");
171 if(!pGetOpenFileNameA)
172 {
173 FreeLibrary(hmodule);
174 return FALSE;
175 }
176
177 memset(&ofn, 0, sizeof(ofn));
178
179 ofn.lStructSize = sizeof(ofn);
180 ofn.hwndOwner = hwndOwner;
181 ofn.lpstrFilter = lpstrFilter;
182 ofn.lpstrFile = lpstrFile;
183 ofn.nMaxFile = nMaxFile;
184 ofn.lpstrInitialDir = lpstrInitialDir;
185 ofn.lpstrTitle = lpstrTitle;
186 ofn.lpstrDefExt = lpstrDefExt;
187 ofn.Flags = OFN_EXPLORER | OFN_HIDEREADONLY | OFN_FILEMUSTEXIST;
188 ret = pGetOpenFileNameA(&ofn);
189
190 FreeLibrary(hmodule);
191 return ret;
192 }
193
194 /*************************************************************************
195 * SHGetSetSettings [SHELL32.68]
196 */
197 VOID WINAPI SHGetSetSettings(LPSHELLSTATE lpss, DWORD dwMask, BOOL bSet)
198 {
199 if(bSet)
200 {
201 FIXME("%p 0x%08lx TRUE\n", lpss, dwMask);
202 }
203 else
204 {
205 SHGetSettings((LPSHELLFLAGSTATE)lpss,dwMask);
206 }
207 }
208
209 /*************************************************************************
210 * SHGetSettings [SHELL32.@]
211 *
212 * NOTES
213 * the registry path are for win98 (tested)
214 * and possibly are the same in nt40
215 *
216 */
217 VOID WINAPI SHGetSettings(LPSHELLFLAGSTATE lpsfs, DWORD dwMask)
218 {
219 HKEY hKey;
220 DWORD dwData;
221 DWORD dwDataSize = sizeof (DWORD);
222
223 TRACE("(%p 0x%08lx)\n",lpsfs,dwMask);
224
225 if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
226 0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
227 return;
228
229 if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
230 lpsfs->fShowExtensions = ((dwData == 0) ? 0 : 1);
231
232 if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
233 lpsfs->fShowInfoTip = ((dwData == 0) ? 0 : 1);
234
235 if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
236 lpsfs->fDontPrettyPath = ((dwData == 0) ? 0 : 1);
237
238 if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
239 lpsfs->fHideIcons = ((dwData == 0) ? 0 : 1);
240
241 if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
242 lpsfs->fMapNetDrvBtn = ((dwData == 0) ? 0 : 1);
243
244 if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
245 lpsfs->fShowAttribCol = ((dwData == 0) ? 0 : 1);
246
247 if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
248 { if (dwData == 0)
249 { if (SSF_SHOWALLOBJECTS & dwMask) lpsfs->fShowAllObjects = 0;
250 if (SSF_SHOWSYSFILES & dwMask) lpsfs->fShowSysFiles = 0;
251 }
252 else if (dwData == 1)
253 { if (SSF_SHOWALLOBJECTS & dwMask) lpsfs->fShowAllObjects = 1;
254 if (SSF_SHOWSYSFILES & dwMask) lpsfs->fShowSysFiles = 0;
255 }
256 else if (dwData == 2)
257 { if (SSF_SHOWALLOBJECTS & dwMask) lpsfs->fShowAllObjects = 0;
258 if (SSF_SHOWSYSFILES & dwMask) lpsfs->fShowSysFiles = 1;
259 }
260 }
261 RegCloseKey (hKey);
262
263 TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
264 }
265
266 /*************************************************************************
267 * SHShellFolderView_Message [SHELL32.73]
268 *
269 * Send a message to an explorer cabinet window.
270 *
271 * PARAMS
272 * hwndCabinet [I] The window containing the shellview to communicate with
273 * dwMessage [I] The SFVM message to send
274 * dwParam [I] Message parameter
275 *
276 * RETURNS
277 * fixme.
278 *
279 * NOTES
280 * Message SFVM_REARRANGE = 1
281 *
282 * This message gets sent when a column gets clicked to instruct the
283 * shell view to re-sort the item list. dwParam identifies the column
284 * that was clicked.
285 */
286 int WINAPI SHShellFolderView_Message(
287 HWND hwndCabinet,
288 DWORD dwMessage,
289 DWORD dwParam)
290 {
291 FIXME("%p %08lx %08lx stub\n",hwndCabinet, dwMessage, dwParam);
292 return 0;
293 }
294
295 /*************************************************************************
296 * RegisterShellHook [SHELL32.181]
297 *
298 * Register a shell hook.
299 *
300 * PARAMS
301 * hwnd [I] Window handle
302 * dwType [I] Type of hook.
303 *
304 * NOTES
305 * Exported by ordinal
306 */
307 BOOL WINAPI RegisterShellHook(
308 HWND hWnd,
309 DWORD dwType)
310 {
311 FIXME("(%p,0x%08lx):stub.\n",hWnd, dwType);
312 return TRUE;
313 }
314
315 /*************************************************************************
316 * ShellMessageBoxW [SHELL32.182]
317 *
318 * See ShellMessageBoxA.
319 */
320 int WINAPIV ShellMessageBoxW(
321 HINSTANCE hInstance,
322 HWND hWnd,
323 LPCWSTR lpText,
324 LPCWSTR lpCaption,
325 UINT uType,
326 ...)
327 {
328 WCHAR szText[100],szTitle[100];
329 LPCWSTR pszText = szText, pszTitle = szTitle, pszTemp;
330 va_list args;
331 int ret;
332
333 va_start(args, uType);
334 /* wvsprintfA(buf,fmt, args); */
335
336 TRACE("(%08lx,%08lx,%p,%p,%08x)\n",
337 (DWORD)hInstance,(DWORD)hWnd,lpText,lpCaption,uType);
338
339 if (!HIWORD(lpCaption))
340 LoadStringW(hInstance, (DWORD)lpCaption, szTitle, sizeof(szTitle)/sizeof(szTitle[0]));
341 else
342 pszTitle = lpCaption;
343
344 if (!HIWORD(lpText))
345 LoadStringW(hInstance, (DWORD)lpText, szText, sizeof(szText)/sizeof(szText[0]));
346 else
347 pszText = lpText;
348
349 FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
350 pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
351
352 va_end(args);
353
354 ret = MessageBoxW(hWnd,pszTemp,pszTitle,uType);
355 LocalFree((HLOCAL)pszTemp);
356 return ret;
357 }
358
359 /*************************************************************************
360 * ShellMessageBoxA [SHELL32.183]
361 *
362 * Format and output an error message.
363 *
364 * PARAMS
365 * hInstance [I] Instance handle of message creator
366 * hWnd [I] Window handle of message creator
367 * lpText [I] Resource Id of title or LPSTR
368 * lpCaption [I] Resource Id of title or LPSTR
369 * uType [I] Type of error message
370 *
371 * RETURNS
372 * A return value from MessageBoxA().
373 *
374 * NOTES
375 * Exported by ordinal
376 */
377 int WINAPIV ShellMessageBoxA(
378 HINSTANCE hInstance,
379 HWND hWnd,
380 LPCSTR lpText,
381 LPCSTR lpCaption,
382 UINT uType,
383 ...)
384 {
385 char szText[100],szTitle[100];
386 LPCSTR pszText = szText, pszTitle = szTitle, pszTemp;
387 va_list args;
388 int ret;
389
390 va_start(args, uType);
391 /* wvsprintfA(buf,fmt, args); */
392
393 TRACE("(%08lx,%08lx,%p,%p,%08x)\n",
394 (DWORD)hInstance,(DWORD)hWnd,lpText,lpCaption,uType);
395
396 if (!HIWORD(lpCaption))
397 LoadStringA(hInstance, (DWORD)lpCaption, szTitle, sizeof(szTitle));
398 else
399 pszTitle = lpCaption;
400
401 if (!HIWORD(lpText))
402 LoadStringA(hInstance, (DWORD)lpText, szText, sizeof(szText));
403 else
404 pszText = lpText;
405
406 FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
407 pszText, 0, 0, (LPSTR)&pszTemp, 0, &args);
408
409 va_end(args);
410
411 ret = MessageBoxA(hWnd,pszTemp,pszTitle,uType);
412 LocalFree((HLOCAL)pszTemp);
413 return ret;
414 }
415
416 /*************************************************************************
417 * SHRegisterDragDrop [SHELL32.86]
418 *
419 * NOTES
420 * exported by ordinal
421 */
422 HRESULT WINAPI SHRegisterDragDrop(
423 HWND hWnd,
424 LPDROPTARGET pDropTarget)
425 {
426 FIXME("(%p,%p):stub.\n", hWnd, pDropTarget);
427 if (GetShellOle()) return pRegisterDragDrop(hWnd, pDropTarget);
428 return 0;
429 }
430
431 /*************************************************************************
432 * SHRevokeDragDrop [SHELL32.87]
433 *
434 * NOTES
435 * exported by ordinal
436 */
437 HRESULT WINAPI SHRevokeDragDrop(HWND hWnd)
438 {
439 FIXME("(%p):stub.\n",hWnd);
440 if (GetShellOle()) return pRevokeDragDrop(hWnd);
441 return 0;
442 }
443
444 /*************************************************************************
445 * SHDoDragDrop [SHELL32.88]
446 *
447 * NOTES
448 * exported by ordinal
449 */
450 HRESULT WINAPI SHDoDragDrop(
451 HWND hWnd,
452 LPDATAOBJECT lpDataObject,
453 LPDROPSOURCE lpDropSource,
454 DWORD dwOKEffect,
455 LPDWORD pdwEffect)
456 {
457 FIXME("(%p %p %p 0x%08lx %p):stub.\n",
458 hWnd, lpDataObject, lpDropSource, dwOKEffect, pdwEffect);
459 if (GetShellOle()) return pDoDragDrop(lpDataObject, lpDropSource, dwOKEffect, pdwEffect);
460 return 0;
461 }
462
463 /*************************************************************************
464 * ArrangeWindows [SHELL32.184]
465 *
466 */
467 WORD WINAPI ArrangeWindows(
468 HWND hwndParent,
469 DWORD dwReserved,
470 LPCRECT lpRect,
471 WORD cKids,
472 CONST HWND * lpKids)
473 {
474 FIXME("(%p 0x%08lx %p 0x%04x %p):stub.\n",
475 hwndParent, dwReserved, lpRect, cKids, lpKids);
476 return 0;
477 }
478
479 /*************************************************************************
480 * SignalFileOpen [SHELL32.103]
481 *
482 * NOTES
483 * exported by ordinal
484 */
485 DWORD WINAPI
486 SignalFileOpen (DWORD dwParam1)
487 {
488 FIXME("(0x%08lx):stub.\n", dwParam1);
489
490 return 0;
491 }
492
493 /*************************************************************************
494 * SHADD_get_policy - helper function for SHAddToRecentDocs
495 *
496 * PARAMETERS
497 * policy [IN] policy name (null termed string) to find
498 * type [OUT] ptr to DWORD to receive type
499 * buffer [OUT] ptr to area to hold data retrieved
500 * len [IN/OUT] ptr to DWORD holding size of buffer and getting
501 * length filled
502 *
503 * RETURNS
504 * result of the SHQueryValueEx call
505 */
506 static INT SHADD_get_policy(LPSTR policy, LPDWORD type, LPVOID buffer, LPDWORD len)
507 {
508 HKEY Policy_basekey;
509 INT ret;
510
511 /* Get the key for the policies location in the registry
512 */
513 if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
514 "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
515 0, KEY_READ, &Policy_basekey)) {
516
517 if (RegOpenKeyExA(HKEY_CURRENT_USER,
518 "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
519 0, KEY_READ, &Policy_basekey)) {
520 TRACE("No Explorer Policies location exists. Policy wanted=%s\n",
521 policy);
522 *len = 0;
523 return ERROR_FILE_NOT_FOUND;
524 }
525 }
526
527 /* Retrieve the data if it exists
528 */
529 ret = SHQueryValueExA(Policy_basekey, policy, 0, type, buffer, len);
530 RegCloseKey(Policy_basekey);
531 return ret;
532 }
533
534
535 /*************************************************************************
536 * SHADD_compare_mru - helper function for SHAddToRecentDocs
537 *
538 * PARAMETERS
539 * data1 [IN] data being looked for
540 * data2 [IN] data in MRU
541 * cbdata [IN] length from FindMRUData call (not used)
542 *
543 * RETURNS
544 * position within MRU list that data was added.
545 */
546 static INT CALLBACK SHADD_compare_mru(LPCVOID data1, LPCVOID data2, DWORD cbData)
547 {
548 return lstrcmpiA(data1, data2);
549 }
550
551 /*************************************************************************
552 * SHADD_create_add_mru_data - helper function for SHAddToRecentDocs
553 *
554 * PARAMETERS
555 * mruhandle [IN] handle for created MRU list
556 * doc_name [IN] null termed pure doc name
557 * new_lnk_name [IN] null termed path and file name for .lnk file
558 * buffer [IN/OUT] 2048 byte area to consturct MRU data
559 * len [OUT] ptr to int to receive space used in buffer
560 *
561 * RETURNS
562 * position within MRU list that data was added.
563 */
564 static INT SHADD_create_add_mru_data(HANDLE mruhandle, LPSTR doc_name, LPSTR new_lnk_name,
565 LPSTR buffer, INT *len)
566 {
567 LPSTR ptr;
568 INT wlen;
569
570 /*FIXME: Document:
571 * RecentDocs MRU data structure seems to be:
572 * +0h document file name w/ terminating 0h
573 * +nh short int w/ size of remaining
574 * +n+2h 02h 30h, or 01h 30h, or 00h 30h - unknown
575 * +n+4h 10 bytes zeros - unknown
576 * +n+eh shortcut file name w/ terminating 0h
577 * +n+e+nh 3 zero bytes - unknown
578 */
579
580 /* Create the MRU data structure for "RecentDocs"
581 */
582 ptr = buffer;
583 lstrcpyA(ptr, doc_name);
584 ptr += (lstrlenA(buffer) + 1);
585 wlen= lstrlenA(new_lnk_name) + 1 + 12;
586 *((short int*)ptr) = wlen;
587 ptr += 2; /* step past the length */
588 *(ptr++) = 0x30; /* unknown reason */
589 *(ptr++) = 0; /* unknown, but can be 0x00, 0x01, 0x02 */
590 memset(ptr, 0, 10);
591 ptr += 10;
592 lstrcpyA(ptr, new_lnk_name);
593 ptr += (lstrlenA(new_lnk_name) + 1);
594 memset(ptr, 0, 3);
595 ptr += 3;
596 *len = ptr - buffer;
597
598 /* Add the new entry into the MRU list
599 */
600 return AddMRUData(mruhandle, (LPCVOID)buffer, *len);
601 }
602
603 /*************************************************************************
604 * SHAddToRecentDocs [SHELL32.@]
605 *
606 * PARAMETERS
607 * uFlags [IN] SHARD_PATH or SHARD_PIDL
608 * pv [IN] string or pidl, NULL clears the list
609 *
610 * NOTES
611 * exported by name
612 *
613 * FIXME: ?? MSDN shows this as a VOID
614 */
615 DWORD WINAPI SHAddToRecentDocs (UINT uFlags,LPCVOID pv)
616 {
617 /* If list is a string list lpfnCompare has the following prototype
618 * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
619 * for binary lists the prototype is
620 * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
621 * where cbData is the no. of bytes to compare.
622 * Need to check what return value means identical - 0?
623 */
624
625
626 UINT olderrormode;
627 HKEY HCUbasekey;
628 CHAR doc_name[MAX_PATH];
629 CHAR link_dir[MAX_PATH];
630 CHAR new_lnk_filepath[MAX_PATH];
631 CHAR new_lnk_name[MAX_PATH];
632 IMalloc *ppM;
633 LPITEMIDLIST pidl;
634 HWND hwnd = 0; /* FIXME: get real window handle */
635 INT ret;
636 DWORD data[64], datalen, type;
637
638 /*FIXME: Document:
639 * RecentDocs MRU data structure seems to be:
640 * +0h document file name w/ terminating 0h
641 * +nh short int w/ size of remaining
642 * +n+2h 02h 30h, or 01h 30h, or 00h 30h - unknown
643 * +n+4h 10 bytes zeros - unknown
644 * +n+eh shortcut file name w/ terminating 0h
645 * +n+e+nh 3 zero bytes - unknown
646 */
647
648 /* See if we need to do anything.
649 */
650 datalen = 64;
651 ret=SHADD_get_policy( "NoRecentDocsHistory", &type, &data, &datalen);
652 if ((ret > 0) && (ret != ERROR_FILE_NOT_FOUND)) {
653 ERR("Error %d getting policy \"NoRecentDocsHistory\"\n", ret);
654 return 0;
655 }
656 if (ret == ERROR_SUCCESS) {
657 if (!( (type == REG_DWORD) ||
658 ((type == REG_BINARY) && (datalen == 4)) )) {
659 ERR("Error policy data for \"NoRecentDocsHistory\" not formated correctly, type=%ld, len=%ld\n",
660 type, datalen);
661 return 0;
662 }
663
664 TRACE("policy value for NoRecentDocsHistory = %08lx\n", data[0]);
665 /* now test the actual policy value */
666 if ( data[0] != 0)
667 return 0;
668 }
669
670 /* Open key to where the necessary info is
671 */
672 /* FIXME: This should be done during DLL PROCESS_ATTACH (or THREAD_ATTACH)
673 * and the close should be done during the _DETACH. The resulting
674 * key is stored in the DLL global data.
675 */
676 if (RegCreateKeyExA(HKEY_CURRENT_USER,
677 "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
678 0, 0, 0, KEY_READ, 0, &HCUbasekey, 0)) {
679 ERR("Failed to create 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer'\n");
680 return 0;
681 }
682
683 /* Get path to user's "Recent" directory
684 */
685 if(SUCCEEDED(SHGetMalloc(&ppM))) {
686 if (SUCCEEDED(SHGetSpecialFolderLocation(hwnd, CSIDL_RECENT,
687 &pidl))) {
688 SHGetPathFromIDListA(pidl, link_dir);
689 IMalloc_Free(ppM, pidl);
690 }
691 else {
692 /* serious issues */
693 link_dir[0] = 0;
694 ERR("serious issues 1\n");
695 }
696 IMalloc_Release(ppM);
697 }
698 else {
699 /* serious issues */
700 link_dir[0] = 0;
701 ERR("serious issues 2\n");
702 }
703 TRACE("Users Recent dir %s\n", link_dir);
704
705 /* If no input, then go clear the lists */
706 if (!pv) {
707 /* clear user's Recent dir
708 */
709
710 /* FIXME: delete all files in "link_dir"
711 *
712 * while( more files ) {
713 * lstrcpyA(old_lnk_name, link_dir);
714 * PathAppendA(old_lnk_name, filenam);
715 * DeleteFileA(old_lnk_name);
716 * }
717 */
718 FIXME("should delete all files in %s\\ \n", link_dir);
719
720 /* clear MRU list
721 */
722 /* MS Bug ?? v4.72.3612.1700 of shell32 does the delete against
723 * HKEY_LOCAL_MACHINE version of ...CurrentVersion\Explorer
724 * and naturally it fails w/ rc=2. It should do it against
725 * HKEY_CURRENT_USER which is where it is stored, and where
726 * the MRU routines expect it!!!!
727 */
728 RegDeleteKeyA(HCUbasekey, "RecentDocs");
729 RegCloseKey(HCUbasekey);
730 return 0;
731 }
732
733 /* Have data to add, the jobs to be done:
734 * 1. Add document to MRU list in registry "HKCU\Software\
735 * Microsoft\Windows\CurrentVersion\Explorer\RecentDocs".
736 * 2. Add shortcut to document in the user's Recent directory
737 * (CSIDL_RECENT).
738 * 3. Add shortcut to Start menu's Documents submenu.
739 */
740
741 /* Get the pure document name from the input
742 */
743 if (uFlags & SHARD_PIDL) {
744 SHGetPathFromIDListA((LPCITEMIDLIST) pv, doc_name);
745 }
746 else {
747 lstrcpyA(doc_name, (LPSTR) pv);
748 }
749 TRACE("full document name %s\n", doc_name);
750 PathStripPathA(doc_name);
751 TRACE("stripped document name %s\n", doc_name);
752
753
754 /* *** JOB 1: Update registry for ...\Explorer\RecentDocs list *** */
755
756 { /* on input needs:
757 * doc_name - pure file-spec, no path
758 * link_dir - path to the user's Recent directory
759 * HCUbasekey - key of ...Windows\CurrentVersion\Explorer" node
760 * creates:
761 * new_lnk_name- pure file-spec, no path for new .lnk file
762 * new_lnk_filepath
763 * - path and file name of new .lnk file
764 */
765 CREATEMRULISTA mymru;
766 HANDLE mruhandle;
767 INT len, pos, bufused, err;
768 INT i;
769 DWORD attr;
770 CHAR buffer[2048];
771 CHAR *ptr;
772 CHAR old_lnk_name[MAX_PATH];
773 short int slen;
774
775 mymru.cbSize = sizeof(CREATEMRULISTA);
776 mymru.nMaxItems = 15;
777 mymru.dwFlags = MRUF_BINARY_LIST | MRUF_DELAYED_SAVE;
778 mymru.hKey = HCUbasekey;
779 mymru.lpszSubKey = "RecentDocs";
780 mymru.lpfnCompare = &SHADD_compare_mru;
781 mruhandle = CreateMRUListA(&mymru);
782 if (!mruhandle) {
783 /* MRU failed */
784 ERR("MRU processing failed, handle zero\n");
785 RegCloseKey(HCUbasekey);
786 return 0;
787 }
788 len = lstrlenA(doc_name);
789 pos = FindMRUData(mruhandle, doc_name, len, 0);
790
791 /* Now get the MRU entry that will be replaced
792 * and delete the .lnk file for it
793 */
794 if ((bufused = EnumMRUListA(mruhandle, (pos == -1) ? 14 : pos,
795 buffer, 2048)) != -1) {
796 ptr = buffer;
797 ptr += (lstrlenA(buffer) + 1);
798 slen = *((short int*)ptr);
799 ptr += 2; /* skip the length area */
800 if (bufused >= slen + (ptr-buffer)) {
801 /* buffer size looks good */
802 ptr += 12; /* get to string */
803 len = bufused - (ptr-buffer); /* get length of buf remaining */
804 if ((lstrlenA(ptr) > 0) && (lstrlenA(ptr) <= len-1)) {
805 /* appears to be good string */
806 lstrcpyA(old_lnk_name, link_dir);
807 PathAppendA(old_lnk_name, ptr);
808 if (!DeleteFileA(old_lnk_name)) {
809 if ((attr = GetFileAttributesA(old_lnk_name)) == INVALID_FILE_ATTRIBUTES) {
810 if ((err = GetLastError()) != ERROR_FILE_NOT_FOUND) {
811 ERR("Delete for %s failed, err=%d, attr=%08lx\n",
812 old_lnk_name, err, attr);
813 }
814 else {
815 TRACE("old .lnk file %s did not exist\n",
816 old_lnk_name);
817 }
818 }
819 else {
820 ERR("Delete for %s failed, attr=%08lx\n",
821 old_lnk_name, attr);
822 }
823 }
824 else {
825 TRACE("deleted old .lnk file %s\n", old_lnk_name);
826 }
827 }
828 }
829 }
830
831 /* Create usable .lnk file name for the "Recent" directory
832 */
833 wsprintfA(new_lnk_name, "%s.lnk", doc_name);
834 lstrcpyA(new_lnk_filepath, link_dir);
835 PathAppendA(new_lnk_filepath, new_lnk_name);
836 i = 1;
837 olderrormode = SetErrorMode(SEM_FAILCRITICALERRORS);
838 while (GetFileAttributesA(new_lnk_filepath) != INVALID_FILE_ATTRIBUTES) {
839 i++;
840 wsprintfA(new_lnk_name, "%s (%u).lnk", doc_name, i);
841 lstrcpyA(new_lnk_filepath, link_dir);
842 PathAppendA(new_lnk_filepath, new_lnk_name);
843 }
844 SetErrorMode(olderrormode);
845 TRACE("new shortcut will be %s\n", new_lnk_filepath);
846
847 /* Now add the new MRU entry and data
848 */
849 pos = SHADD_create_add_mru_data(mruhandle, doc_name, new_lnk_name,
850 buffer, &len);
851 FreeMRUList(mruhandle);
852 TRACE("Updated MRU list, new doc is position %d\n", pos);
853 }
854
855 /* *** JOB 2: Create shortcut in user's "Recent" directory *** */
856
857 { /* on input needs:
858 * doc_name - pure file-spec, no path
859 * new_lnk_filepath
860 * - path and file name of new .lnk file
861 * uFlags[in] - flags on call to SHAddToRecentDocs
862 * pv[in] - document path/pidl on call to SHAddToRecentDocs
863 */
864 IShellLinkA *psl = NULL;
865 IPersistFile *pPf = NULL;
866 HRESULT hres;
867 CHAR desc[MAX_PATH];
868 WCHAR widelink[MAX_PATH];
869
870 CoInitialize(0);
871
872 hres = CoCreateInstance( &CLSID_ShellLink,
873 NULL,
874 CLSCTX_INPROC_SERVER,
875 &IID_IShellLinkA,
876 (LPVOID )&psl);
877 if(SUCCEEDED(hres)) {
878
879 hres = IShellLinkA_QueryInterface(psl, &IID_IPersistFile,
880 (LPVOID *)&pPf);
881 if(FAILED(hres)) {
882 /* bombed */
883 ERR("failed QueryInterface for IPersistFile %08lx\n", hres);
884 goto fail;
885 }
886
887 /* Set the document path or pidl */
888 if (uFlags & SHARD_PIDL) {
889 hres = IShellLinkA_SetIDList(psl, (LPCITEMIDLIST) pv);
890 } else {
891 hres = IShellLinkA_SetPath(psl, (LPCSTR) pv);
892 }
893 if(FAILED(hres)) {
894 /* bombed */
895 ERR("failed Set{IDList|Path} %08lx\n", hres);
896 goto fail;
897 }
898
899 lstrcpyA(desc, "Shortcut to ");
900 lstrcatA(desc, doc_name);
901 hres = IShellLinkA_SetDescription(psl, desc);
902 if(FAILED(hres)) {
903 /* bombed */
904 ERR("failed SetDescription %08lx\n", hres);
905 goto fail;
906 }
907
908 MultiByteToWideChar(CP_ACP, 0, new_lnk_filepath, -1,
909 widelink, MAX_PATH);
910 /* create the short cut */
911 hres = IPersistFile_Save(pPf, widelink, TRUE);
912 if(FAILED(hres)) {
913 /* bombed */
914 ERR("failed IPersistFile::Save %08lx\n", hres);
915 IPersistFile_Release(pPf);
916 IShellLinkA_Release(psl);
917 goto fail;
918 }
919 hres = IPersistFile_SaveCompleted(pPf, widelink);
920 IPersistFile_Release(pPf);
921 IShellLinkA_Release(psl);
922 TRACE("shortcut %s has been created, result=%08lx\n",
923 new_lnk_filepath, hres);
924 }
925 else {
926 ERR("CoCreateInstance failed, hres=%08lx\n", hres);
927 }
928 }
929
930 fail:
931 CoUninitialize();
932
933 /* all done */
934 RegCloseKey(HCUbasekey);
935 return 0;
936 }
937
938 /*************************************************************************
939 * SHCreateShellFolderViewEx [SHELL32.174]
940 *
941 * NOTES
942 * see IShellFolder::CreateViewObject
943 */
944 HRESULT WINAPI SHCreateShellFolderViewEx(
945 LPCSHELLFOLDERVIEWINFO psvcbi, /* [in] shelltemplate struct */
946 LPSHELLVIEW* ppv) /* [out] IShellView pointer */
947 {
948 IShellView * psf;
949 HRESULT hRes;
950
951 TRACE("sf=%p pidl=%p cb=%p mode=0x%08x parm=0x%08lx\n",
952 psvcbi->pshf, psvcbi->pidlFolder, psvcbi->lpfnCallback,
953 psvcbi->uViewMode, psvcbi->dwUser);
954
955 psf = IShellView_Constructor(psvcbi->pshf);
956
957 if (!psf)
958 return E_OUTOFMEMORY;
959
960 IShellView_AddRef(psf);
961 hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
962 IShellView_Release(psf);
963
964 return hRes;
965 }
966 /*************************************************************************
967 * SHWinHelp [SHELL32.127]
968 *
969 */
970 HRESULT WINAPI SHWinHelp (DWORD v, DWORD w, DWORD x, DWORD z)
971 { FIXME("0x%08lx 0x%08lx 0x%08lx 0x%08lx stub\n",v,w,x,z);
972 return 0;
973 }
974 /*************************************************************************
975 * SHRunControlPanel [SHELL32.161]
976 *
977 */
978 HRESULT WINAPI SHRunControlPanel (DWORD x, DWORD z)
979 { FIXME("0x%08lx 0x%08lx stub\n",x,z);
980 return 0;
981 }
982
983 static LPUNKNOWN SHELL32_IExplorerInterface=0;
984 /*************************************************************************
985 * SHSetInstanceExplorer [SHELL32.176]
986 *
987 * NOTES
988 * Sets the interface
989 */
990 HRESULT WINAPI SHSetInstanceExplorer (LPUNKNOWN lpUnknown)
991 { TRACE("%p\n", lpUnknown);
992 SHELL32_IExplorerInterface = lpUnknown;
993 return (HRESULT) lpUnknown;
994 }
995 /*************************************************************************
996 * SHGetInstanceExplorer [SHELL32.@]
997 *
998 * NOTES
999 * gets the interface pointer of the explorer and a reference
1000 */
1001 HRESULT WINAPI SHGetInstanceExplorer (LPUNKNOWN * lpUnknown)
1002 { TRACE("%p\n", lpUnknown);
1003
1004 *lpUnknown = SHELL32_IExplorerInterface;
1005
1006 if (!SHELL32_IExplorerInterface)
1007 return E_FAIL;
1008
1009 IUnknown_AddRef(SHELL32_IExplorerInterface);
1010 return NOERROR;
1011 }
1012 /*************************************************************************
1013 * SHFreeUnusedLibraries [SHELL32.123]
1014 *
1015 * NOTES
1016 * exported by name
1017 */
1018 void WINAPI SHFreeUnusedLibraries (void)
1019 {
1020 FIXME("stub\n");
1021 }
1022 /*************************************************************************
1023 * DAD_AutoScroll [SHELL32.129]
1024 *
1025 */
1026 BOOL WINAPI DAD_AutoScroll(HWND hwnd, AUTO_SCROLL_DATA *samples, LPPOINT pt)
1027 {
1028 FIXME("hwnd = %p %p %p\n",hwnd,samples,pt);
1029 return 0;
1030 }
1031 /*************************************************************************
1032 * DAD_DragEnter [SHELL32.130]
1033 *
1034 */
1035 BOOL WINAPI DAD_DragEnter(HWND hwnd)
1036 {
1037 FIXME("hwnd = %p\n",hwnd);
1038 return FALSE;
1039 }
1040 /*************************************************************************
1041 * DAD_DragEnterEx [SHELL32.131]
1042 *
1043 */
1044 BOOL WINAPI DAD_DragEnterEx(HWND hwnd, POINT p)
1045 {
1046 FIXME("hwnd = %p (%ld,%ld)\n",hwnd,p.x,p.y);
1047 return FALSE;
1048 }
1049 /*************************************************************************
1050 * DAD_DragMove [SHELL32.134]
1051 *
1052 */
1053 BOOL WINAPI DAD_DragMove(POINT p)
1054 {
1055 FIXME("(%ld,%ld)\n",p.x,p.y);
1056 return FALSE;
1057 }
1058 /*************************************************************************
1059 * DAD_DragLeave [SHELL32.132]
1060 *
1061 */
1062 BOOL WINAPI DAD_DragLeave(VOID)
1063 {
1064 FIXME("\n");
1065 return FALSE;
1066 }
1067 /*************************************************************************
1068 * DAD_SetDragImage [SHELL32.136]
1069 *
1070 * NOTES
1071 * exported by name
1072 */
1073 BOOL WINAPI DAD_SetDragImage(
1074 HIMAGELIST himlTrack,
1075 LPPOINT lppt)
1076 {
1077 FIXME("%p %p stub\n",himlTrack, lppt);
1078 return 0;
1079 }
1080 /*************************************************************************
1081 * DAD_ShowDragImage [SHELL32.137]
1082 *
1083 * NOTES
1084 * exported by name
1085 */
1086 BOOL WINAPI DAD_ShowDragImage(BOOL bShow)
1087 {
1088 FIXME("0x%08x stub\n",bShow);
1089 return 0;
1090 }
1091
1092 static const WCHAR szwCabLocation[] = {
1093 'S','o','f','t','w','a','r','e','\\',
1094 'M','i','c','r','o','s','o','f','t','\\',
1095 'W','i','n','d','o','w','s','\\',
1096 'C','u','r','r','e','n','t','V','e','r','s','i','o','n','\\',
1097 'E','x','p','l','o','r','e','r','\\',
1098 'C','a','b','i','n','e','t','S','t','a','t','e',0
1099 };
1100
1101 static const WCHAR szwSettings[] = { 'S','e','t','t','i','n','g','s',0 };
1102
1103 /*************************************************************************
1104 * ReadCabinetState [SHELL32.651] NT 4.0
1105 *
1106 */
1107 BOOL WINAPI ReadCabinetState(CABINETSTATE *cs, int length)
1108 {
1109 HKEY hkey = 0;
1110 DWORD type, r;
1111
1112 TRACE("%p %d \n",cs,length);
1113
1114 if( (cs == NULL) || (length < (int)sizeof(*cs)) )
1115 return FALSE;
1116
1117 r = RegOpenKeyW( HKEY_CURRENT_USER, szwCabLocation, &hkey );
1118 if( r == ERROR_SUCCESS )
1119 {
1120 type = REG_BINARY;
1121 r = RegQueryValueExW( hkey, szwSettings,
1122 NULL, &type, (LPBYTE)cs, (LPDWORD)&length );
1123 RegCloseKey( hkey );
1124
1125 }
1126
1127 /* if we can't read from the registry, create default values */
1128 if ( (r != ERROR_SUCCESS) || (cs->cLength < sizeof(*cs)) ||
1129 (cs->cLength != length) )
1130 {
1131 ERR("Initializing shell cabinet settings\n");
1132 memset(cs, 0, sizeof(*cs));
1133 cs->cLength = sizeof(*cs);
1134 cs->nVersion = 2;
1135 cs->fFullPathTitle = FALSE;
1136 cs->fSaveLocalView = TRUE;
1137 cs->fNotShell = FALSE;
1138 cs->fSimpleDefault = TRUE;
1139 cs->fDontShowDescBar = FALSE;
1140 cs->fNewWindowMode = FALSE;
1141 cs->fShowCompColor = FALSE;
1142 cs->fDontPrettyNames = FALSE;
1143 cs->fAdminsCreateCommonGroups = TRUE;
1144 cs->fMenuEnumFilter = 96;
1145 }
1146
1147 return TRUE;
1148 }
1149
1150 /*************************************************************************
1151 * WriteCabinetState [SHELL32.652] NT 4.0
1152 *
1153 */
1154 BOOL WINAPI WriteCabinetState(CABINETSTATE *cs)
1155 {
1156 DWORD r;
1157 HKEY hkey = 0;
1158
1159 TRACE("%p\n",cs);
1160
1161 if( cs == NULL )
1162 return FALSE;
1163
1164 r = RegCreateKeyExW( HKEY_CURRENT_USER, szwCabLocation, 0,
1165 NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1166 if( r == ERROR_SUCCESS )
1167 {
1168 r = RegSetValueExW( hkey, szwSettings, 0,
1169 REG_BINARY, (LPBYTE) cs, cs->cLength);
1170
1171 RegCloseKey( hkey );
1172 }
1173
1174 return (r==ERROR_SUCCESS);
1175 }
1176
1177 /*************************************************************************
1178 * FileIconInit [SHELL32.660]
1179 *
1180 */
1181 BOOL WINAPI FileIconInit(BOOL bFullInit)
1182 { FIXME("(%s)\n", bFullInit ? "true" : "false");
1183 return 0;
1184 }
1185 /*************************************************************************
1186 * IsUserAdmin [SHELL32.680] NT 4.0
1187 *
1188 */
1189 HRESULT WINAPI IsUserAdmin(void)
1190 { FIXME("stub\n");
1191 return TRUE;
1192 }
1193
1194 /*************************************************************************
1195 * SHAllocShared [SHELL32.520]
1196 *
1197 * NOTES
1198 * parameter1 is return value from HeapAlloc
1199 * parameter2 is equal to the size allocated with HeapAlloc
1200 * parameter3 is return value from GetCurrentProcessId
1201 *
1202 * the return value is posted as lParam with 0x402 (WM_USER+2) to somewhere
1203 * WM_USER+2 could be the undocumented CWM_SETPATH
1204 * the allocated memory contains a pidl
1205 */
1206 HGLOBAL WINAPI SHAllocShared(LPVOID psrc, DWORD size, DWORD procID)
1207 { HGLOBAL hmem;
1208 LPVOID pmem;
1209
1210 TRACE("ptr=%p size=0x%04lx procID=0x%04lx\n",psrc,size,procID);
1211 hmem = GlobalAlloc(GMEM_FIXED, size);
1212 if (!hmem)
1213 return 0;
1214
1215 pmem = GlobalLock (hmem);
1216
1217 if (! pmem)
1218 return 0;
1219
1220 memcpy (pmem, psrc, size);
1221 GlobalUnlock(hmem);
1222 return hmem;
1223 }
1224 /*************************************************************************
1225 * SHLockShared [SHELL32.521]
1226 *
1227 * NOTES
1228 * parameter1 is return value from SHAllocShared
1229 * parameter2 is return value from GetCurrentProcessId
1230 * the receiver of (WM_USER+2) tries to lock the HANDLE (?)
1231 * the return value seems to be a memory address
1232 */
1233 LPVOID WINAPI SHLockShared(HANDLE hmem, DWORD procID)
1234 { TRACE("handle=%p procID=0x%04lx\n",hmem,procID);
1235 return GlobalLock(hmem);
1236 }
1237 /*************************************************************************
1238 * SHUnlockShared [SHELL32.522]
1239 *
1240 * NOTES
1241 * parameter1 is return value from SHLockShared
1242 */
1243 BOOL WINAPI SHUnlockShared(LPVOID pv)
1244 {
1245 TRACE("%p\n",pv);
1246 return GlobalUnlock((HANDLE)pv);
1247 }
1248 /*************************************************************************
1249 * SHFreeShared [SHELL32.523]
1250 *
1251 * NOTES
1252 * parameter1 is return value from SHAllocShared
1253 * parameter2 is return value from GetCurrentProcessId
1254 */
1255 BOOL WINAPI SHFreeShared(
1256 HANDLE hMem,
1257 DWORD pid)
1258 {
1259 TRACE("handle=%p 0x%04lx\n",hMem,pid);
1260 return (BOOL)GlobalFree(hMem);
1261 }
1262
1263 /*************************************************************************
1264 * SetAppStartingCursor [SHELL32.99]
1265 */
1266 HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
1267 { FIXME("hwnd=%p 0x%04lx stub\n",u,v );
1268 return 0;
1269 }
1270 /*************************************************************************
1271 * SHLoadOLE [SHELL32.151]
1272 *
1273 */
1274 HRESULT WINAPI SHLoadOLE(DWORD u)
1275 { FIXME("0x%04lx stub\n",u);
1276 return S_OK;
1277 }
1278 /*************************************************************************
1279 * DriveType [SHELL32.64]
1280 *
1281 */
1282 HRESULT WINAPI DriveType(DWORD u)
1283 { FIXME("0x%04lx stub\n",u);
1284 return 0;
1285 }
1286 /*************************************************************************
1287 * SHAbortInvokeCommand [SHELL32.198]
1288 *
1289 */
1290 HRESULT WINAPI SHAbortInvokeCommand(void)
1291 { FIXME("stub\n");
1292 return 1;
1293 }
1294 /*************************************************************************
1295 * SHOutOfMemoryMessageBox [SHELL32.126]
1296 *
1297 */
1298 int WINAPI SHOutOfMemoryMessageBox(
1299 HWND hwndOwner,
1300 LPCSTR lpCaption,
1301 UINT uType)
1302 {
1303 FIXME("%p %s 0x%08x stub\n",hwndOwner, lpCaption, uType);
1304 return 0;
1305 }
1306 /*************************************************************************
1307 * SHFlushClipboard [SHELL32.121]
1308 *
1309 */
1310 HRESULT WINAPI SHFlushClipboard(void)
1311 { FIXME("stub\n");
1312 return 1;
1313 }
1314
1315 /*************************************************************************
1316 * SHWaitForFileToOpen [SHELL32.97]
1317 *
1318 */
1319 BOOL WINAPI SHWaitForFileToOpen(
1320 LPCITEMIDLIST pidl,
1321 DWORD dwFlags,
1322 DWORD dwTimeout)
1323 {
1324 FIXME("%p 0x%08lx 0x%08lx stub\n", pidl, dwFlags, dwTimeout);
1325 return 0;
1326 }
1327
1328 /************************************************************************
1329 * @ [SHELL32.654]
1330 *
1331 * NOTES: first parameter seems to be a pointer (same as passed to WriteCabinetState)
1332 * second one could be a size (0x0c). The size is the same as the structure saved to
1333 * HCU\Software\Microsoft\Windows\CurrentVersion\Explorer\CabinetState
1334 * I'm (js) guessing: this one is just ReadCabinetState ;-)
1335 */
1336 HRESULT WINAPI shell32_654 (CABINETSTATE *cs, int length)
1337 {
1338 TRACE("%p %d\n",cs,length);
1339 return ReadCabinetState(cs,length);
1340 }
1341
1342 /************************************************************************
1343 * RLBuildListOfPaths [SHELL32.146]
1344 *
1345 * NOTES
1346 * builds a DPA
1347 */
1348 DWORD WINAPI RLBuildListOfPaths (void)
1349 { FIXME("stub\n");
1350 return 0;
1351 }
1352 /************************************************************************
1353 * SHValidateUNC [SHELL32.173]
1354 *
1355 */
1356 HRESULT WINAPI SHValidateUNC (DWORD x, DWORD y, DWORD z)
1357 {
1358 FIXME("0x%08lx 0x%08lx 0x%08lx stub\n",x,y,z);
1359 return 0;
1360 }
1361
1362 /************************************************************************
1363 * DoEnvironmentSubstA [SHELL32.@]
1364 *
1365 */
1366 HRESULT WINAPI DoEnvironmentSubstA(LPSTR x, LPSTR y)
1367 {
1368 FIXME("(%s, %s) stub\n", debugstr_a(x), debugstr_a(y));
1369 return 0;
1370 }
1371
1372 /************************************************************************
1373 * DoEnvironmentSubstW [SHELL32.@]
1374 *
1375 */
1376 HRESULT WINAPI DoEnvironmentSubstW(LPWSTR x, LPWSTR y)
1377 {
1378 FIXME("(%s, %s): stub\n", debugstr_w(x), debugstr_w(y));
1379 return 0;
1380 }
1381
1382 /************************************************************************
1383 * DoEnvironmentSubst [SHELL32.53]
1384 *
1385 */
1386 HRESULT WINAPI DoEnvironmentSubstAW(LPVOID x, LPVOID y)
1387 {
1388 if (SHELL_OsIsUnicode())
1389 return DoEnvironmentSubstW(x, y);
1390 return DoEnvironmentSubstA(x, y);
1391 }
1392
1393 /*************************************************************************
1394 * @ [SHELL32.243]
1395 *
1396 * Win98+ by-ordinal routine. In Win98 this routine returns zero and
1397 * does nothing else. Possibly this does something in NT or SHELL32 5.0?
1398 *
1399 */
1400
1401 BOOL WINAPI shell32_243(DWORD a, DWORD b)
1402 {
1403 return FALSE;
1404 }
1405
1406 /*************************************************************************
1407 * @ [SHELL32.714]
1408 */
1409 DWORD WINAPI SHELL32_714(LPVOID x)
1410 {
1411 FIXME("(%s)stub\n", debugstr_w(x));
1412 return 0;
1413 }
1414
1415 /*************************************************************************
1416 * SHAddFromPropSheetExtArray [SHELL32.167]
1417 */
1418 DWORD WINAPI SHAddFromPropSheetExtArray(DWORD a, DWORD b, DWORD c)
1419 {
1420 FIXME("(%08lx,%08lx,%08lx)stub\n", a, b, c);
1421 return 0;
1422 }
1423
1424 /*************************************************************************
1425 * SHCreatePropSheetExtArray [SHELL32.168]
1426 */
1427 DWORD WINAPI SHCreatePropSheetExtArray(DWORD a, LPCSTR b, DWORD c)
1428 {
1429 FIXME("(%08lx,%s,%08lx)stub\n", a, debugstr_a(b), c);
1430 return 0;
1431 }
1432
1433 /*************************************************************************
1434 * SHReplaceFromPropSheetExtArray [SHELL32.170]
1435 */
1436 DWORD WINAPI SHReplaceFromPropSheetExtArray(DWORD a, DWORD b, DWORD c, DWORD d)
1437 {
1438 FIXME("(%08lx,%08lx,%08lx,%08lx)stub\n", a, b, c, d);
1439 return 0;
1440 }
1441
1442 /*************************************************************************
1443 * SHDestroyPropSheetExtArray [SHELL32.169]
1444 */
1445 DWORD WINAPI SHDestroyPropSheetExtArray(DWORD a)
1446 {
1447 FIXME("(%08lx)stub\n", a);
1448 return 0;
1449 }
1450
1451 /*************************************************************************
1452 * CIDLData_CreateFromIDArray [SHELL32.83]
1453 *
1454 * Create IDataObject from PIDLs??
1455 */
1456 HRESULT WINAPI CIDLData_CreateFromIDArray(
1457 LPCITEMIDLIST pidlFolder,
1458 DWORD cpidlFiles,
1459 LPCITEMIDLIST *lppidlFiles,
1460 LPDATAOBJECT *ppdataObject)
1461 {
1462 UINT i;
1463 HWND hwnd = 0; /*FIXME: who should be hwnd of owner? set to desktop */
1464
1465 TRACE("(%p, %ld, %p, %p)\n", pidlFolder, cpidlFiles, lppidlFiles, ppdataObject);
1466 if (TRACE_ON(pidl))
1467 {
1468 pdump (pidlFolder);
1469 for (i=0; i<cpidlFiles; i++) pdump (lppidlFiles[i]);
1470 }
1471 *ppdataObject = IDataObject_Constructor( hwnd, pidlFolder,
1472 lppidlFiles, cpidlFiles);
1473 if (*ppdataObject) return S_OK;
1474 return E_OUTOFMEMORY;
1475 }
1476
1477 /*************************************************************************
1478 * SHCreateStdEnumFmtEtc [SHELL32.74]
1479 *
1480 * NOTES
1481 *
1482 */
1483 HRESULT WINAPI SHCreateStdEnumFmtEtc(
1484 DWORD cFormats,
1485 const FORMATETC *lpFormats,
1486 LPENUMFORMATETC *ppenumFormatetc)
1487 {
1488 IEnumFORMATETC *pef;
1489 HRESULT hRes;
1490 TRACE("cf=%ld fe=%p pef=%p\n", cFormats, lpFormats, ppenumFormatetc);
1491
1492 pef = IEnumFORMATETC_Constructor(cFormats, lpFormats);
1493 if (!pef)
1494 return E_OUTOFMEMORY;
1495
1496 IEnumFORMATETC_AddRef(pef);
1497 hRes = IEnumFORMATETC_QueryInterface(pef, &IID_IEnumFORMATETC, (LPVOID*)ppenumFormatetc);
1498 IEnumFORMATETC_Release(pef);
1499
1500 return hRes;
1501 }
1502
1503
1504 /*************************************************************************
1505 * SHELL32_256
1506 */
1507 HRESULT WINAPI SHELL32_256(LPDWORD lpdw0, LPDWORD lpdw1)
1508 {
1509 HRESULT ret = S_OK;
1510
1511 FIXME("stub %p 0x%08lx %p\n", lpdw0, lpdw0 ? *lpdw0 : 0, lpdw1);
1512
1513 if (!lpdw0 || *lpdw0 != 0x10)
1514 ret = E_INVALIDARG;
1515 else
1516 {
1517 LPVOID lpdata = 0;/*LocalAlloc(GMEM_ZEROINIT, 0x4E4);*/
1518
1519 if (!lpdata)
1520 ret = E_OUTOFMEMORY;
1521 else
1522 {
1523 /* Initialize and return unknown lpdata structure */
1524 }
1525 }
1526
1527 return ret;
1528 }
Windows API implementation