ReactOS 0.4.15-dev-5666-gc548b97
shellord.c
Go to the documentation of this file.
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23#include <wine/config.h>
24
25#define WIN32_NO_STATUS
26#define _INC_WINDOWS
27#define COBJMACROS
28
29#include <windef.h>
30#include <winbase.h>
31#include <wine/winternl.h>
32#include <shlobj.h>
33#include <undocshell.h>
34#include <shlwapi.h>
35#include <commdlg.h>
36#include <commoncontrols.h>
37#include "../shellrecyclebin/recyclebin.h"
38
39#include <wine/debug.h>
40#include <wine/unicode.h>
41
42#include "pidl.h"
43#include "shell32_main.h"
44
47
48#ifdef __REACTOS__
49#include <comctl32_undoc.h>
50#else
51/* FIXME: !!! move CREATEMRULIST and flags to header file !!! */
52/* !!! it is in both here and comctl32undoc.c !!! */
53typedef struct tagCREATEMRULIST
54{
55 DWORD cbSize; /* size of struct */
56 DWORD nMaxItems; /* max no. of items in list */
57 DWORD dwFlags; /* see below */
58 HKEY hKey; /* root reg. key under which list is saved */
59 LPCSTR lpszSubKey; /* reg. subkey */
60 int (CALLBACK *lpfnCompare)(LPCVOID, LPCVOID, DWORD); /* item compare proc */
62
63/* dwFlags */
64#define MRUF_STRING_LIST 0 /* list will contain strings */
65#define MRUF_BINARY_LIST 1 /* list will contain binary data */
66#define MRUF_DELAYED_SAVE 2 /* only save list order to reg. is FreeMRUList */
67
69extern VOID WINAPI FreeMRUList(HANDLE hMRUList);
70extern INT WINAPI AddMRUData(HANDLE hList, LPCVOID lpData, DWORD cbData);
71extern INT WINAPI FindMRUData(HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum);
72extern INT WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer, DWORD nBufferSize);
73#endif
74
75/*************************************************************************
76 * ParseFieldA [internal]
77 *
78 * copies a field from a ',' delimited string
79 *
80 * first field is nField = 1
81 */
83 LPCSTR src,
84 DWORD nField,
85 LPSTR dst,
86 DWORD len)
87{
88 WARN("(%s,0x%08x,%p,%d) semi-stub.\n",debugstr_a(src),nField,dst,len);
89
90 if (!src || !src[0] || !dst || !len)
91 return 0;
92
93 /* skip n fields delimited by ',' */
94 while (nField > 1)
95 {
96 if (*src=='\0') return FALSE;
97 if (*(src++)==',') nField--;
98 }
99
100 /* copy part till the next ',' to dst */
101 while ( *src!='\0' && *src!=',' && (len--)>0 ) *(dst++)=*(src++);
102
103 /* finalize the string */
104 *dst=0x0;
105
106 return TRUE;
107}
108
109/*************************************************************************
110 * ParseFieldW [internal]
111 *
112 * copies a field from a ',' delimited string
113 *
114 * first field is nField = 1
115 */
117{
118 WARN("(%s,0x%08x,%p,%d) semi-stub.\n", debugstr_w(src), nField, dst, len);
119
120 if (!src || !src[0] || !dst || !len)
121 return 0;
122
123 /* skip n fields delimited by ',' */
124 while (nField > 1)
125 {
126 if (*src == 0x0) return FALSE;
127 if (*src++ == ',') nField--;
128 }
129
130 /* copy part till the next ',' to dst */
131 while ( *src != 0x0 && *src != ',' && (len--)>0 ) *(dst++) = *(src++);
132
133 /* finalize the string */
134 *dst = 0x0;
135
136 return TRUE;
137}
138
139/*************************************************************************
140 * ParseField [SHELL32.58]
141 */
143{
144 if (SHELL_OsIsUnicode())
145 return ParseFieldW(src, nField, dst, len);
146 return ParseFieldA(src, nField, dst, len);
147}
148
149/*************************************************************************
150 * GetFileNameFromBrowse [SHELL32.63]
151 *
152 */
154 HWND hwndOwner,
155 LPWSTR lpstrFile,
156 UINT nMaxFile,
157 LPCWSTR lpstrInitialDir,
158 LPCWSTR lpstrDefExt,
159 LPCWSTR lpstrFilter,
160 LPCWSTR lpstrTitle)
161{
162typedef BOOL (WINAPI *GetOpenFileNameProc)(OPENFILENAMEW *ofn);
164 GetOpenFileNameProc pGetOpenFileNameW;
166 BOOL ret;
167
168 TRACE("%p, %s, %d, %s, %s, %s, %s)\n",
169 hwndOwner, debugstr_w(lpstrFile), nMaxFile, lpstrInitialDir, lpstrDefExt,
170 lpstrFilter, lpstrTitle);
171
172 hmodule = LoadLibraryW(L"comdlg32.dll");
173 if(!hmodule) return FALSE;
174 pGetOpenFileNameW = (GetOpenFileNameProc)GetProcAddress(hmodule, "GetOpenFileNameW");
175 if(!pGetOpenFileNameW)
176 {
178 return FALSE;
179 }
180
181 memset(&ofn, 0, sizeof(ofn));
182
183 ofn.lStructSize = sizeof(ofn);
184 ofn.hwndOwner = hwndOwner;
185 ofn.lpstrFilter = lpstrFilter;
186 ofn.lpstrFile = lpstrFile;
187 ofn.nMaxFile = nMaxFile;
188 ofn.lpstrInitialDir = lpstrInitialDir;
189 ofn.lpstrTitle = lpstrTitle;
190 ofn.lpstrDefExt = lpstrDefExt;
192 ret = pGetOpenFileNameW(&ofn);
193
195 return ret;
196}
197
198/*************************************************************************
199 * SHGetSetSettings [SHELL32.68]
200 */
202{
203 if(bSet)
204 {
205 FIXME("%p 0x%08x TRUE\n", lpss, dwMask);
206 }
207 else
208 {
209 SHGetSettings((LPSHELLFLAGSTATE)lpss,dwMask);
210 }
211}
212
213/*************************************************************************
214 * SHGetSettings [SHELL32.@]
215 *
216 * NOTES
217 * the registry path are for win98 (tested)
218 * and possibly are the same in nt40
219 *
220 */
222{
223 HKEY hKey;
225 DWORD dwDataSize = sizeof (DWORD);
226
227 TRACE("(%p 0x%08x)\n",lpsfs,dwMask);
228
229 if (RegCreateKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Advanced",
230 0, 0, 0, KEY_ALL_ACCESS, 0, &hKey, 0))
231 return;
232
233 if ( (SSF_SHOWEXTENSIONS & dwMask) && !RegQueryValueExA(hKey, "HideFileExt", 0, 0, (LPBYTE)&dwData, &dwDataSize))
234 lpsfs->fShowExtensions = ((dwData == 0) ? 0 : 1);
235
236 if ( (SSF_SHOWINFOTIP & dwMask) && !RegQueryValueExA(hKey, "ShowInfoTip", 0, 0, (LPBYTE)&dwData, &dwDataSize))
237 lpsfs->fShowInfoTip = ((dwData == 0) ? 0 : 1);
238
239 if ( (SSF_DONTPRETTYPATH & dwMask) && !RegQueryValueExA(hKey, "DontPrettyPath", 0, 0, (LPBYTE)&dwData, &dwDataSize))
240 lpsfs->fDontPrettyPath = ((dwData == 0) ? 0 : 1);
241
242 if ( (SSF_HIDEICONS & dwMask) && !RegQueryValueExA(hKey, "HideIcons", 0, 0, (LPBYTE)&dwData, &dwDataSize))
243 lpsfs->fHideIcons = ((dwData == 0) ? 0 : 1);
244
245 if ( (SSF_MAPNETDRVBUTTON & dwMask) && !RegQueryValueExA(hKey, "MapNetDrvBtn", 0, 0, (LPBYTE)&dwData, &dwDataSize))
246 lpsfs->fMapNetDrvBtn = ((dwData == 0) ? 0 : 1);
247
248 if ( (SSF_SHOWATTRIBCOL & dwMask) && !RegQueryValueExA(hKey, "ShowAttribCol", 0, 0, (LPBYTE)&dwData, &dwDataSize))
249 lpsfs->fShowAttribCol = ((dwData == 0) ? 0 : 1);
250
251 if (((SSF_SHOWALLOBJECTS | SSF_SHOWSYSFILES) & dwMask) && !RegQueryValueExA(hKey, "Hidden", 0, 0, (LPBYTE)&dwData, &dwDataSize))
252 { if (dwData == 0)
253 { if (SSF_SHOWALLOBJECTS & dwMask) lpsfs->fShowAllObjects = 0;
254 if (SSF_SHOWSYSFILES & dwMask) lpsfs->fShowSysFiles = 0;
255 }
256 else if (dwData == 1)
257 { if (SSF_SHOWALLOBJECTS & dwMask) lpsfs->fShowAllObjects = 1;
258 if (SSF_SHOWSYSFILES & dwMask) lpsfs->fShowSysFiles = 0;
259 }
260 else if (dwData == 2)
261 { if (SSF_SHOWALLOBJECTS & dwMask) lpsfs->fShowAllObjects = 0;
262 if (SSF_SHOWSYSFILES & dwMask) lpsfs->fShowSysFiles = 1;
263 }
264 }
266
267 TRACE("-- 0x%04x\n", *(WORD*)lpsfs);
268}
269
270/*************************************************************************
271 * SHShellFolderView_Message [SHELL32.73]
272 *
273 * Send a message to an explorer cabinet window.
274 *
275 * PARAMS
276 * hwndCabinet [I] The window containing the shellview to communicate with
277 * dwMessage [I] The SFVM message to send
278 * dwParam [I] Message parameter
279 *
280 * RETURNS
281 * fixme.
282 *
283 * NOTES
284 * Message SFVM_REARRANGE = 1
285 *
286 * This message gets sent when a column gets clicked to instruct the
287 * shell view to re-sort the item list. dwParam identifies the column
288 * that was clicked.
289 */
291 HWND hwndCabinet,
292 UINT uMessage,
294{
295 FIXME("%p %08x %08lx stub\n",hwndCabinet, uMessage, lParam);
296 return 0;
297}
298
299/*************************************************************************
300 * RegisterShellHook [SHELL32.181]
301 *
302 * Register a shell hook.
303 *
304 * PARAMS
305 * hwnd [I] Window handle
306 * dwType [I] Type of hook.
307 *
308 * NOTES
309 * Exported by ordinal
310 */
312 HWND hWnd,
313 DWORD dwType)
314{
315 if (dwType == 3)
316 {
319 }
320 else if (dwType == 0)
321 {
323 }
324
325 ERR("Unsupported argument");
326 return FALSE;
327}
328
329/*************************************************************************
330 * ShellMessageBoxW [SHELL32.182]
331 *
332 * See ShellMessageBoxA.
333 *
334 */
335#ifdef __REACTOS__
336/*
337 * shell32.ShellMessageBoxW directly redirects to shlwapi.ShellMessageBoxWrapW,
338 * while shell32.ShellMessageBoxA is a copy-paste ANSI adaptation of the
339 * shlwapi.ShellMessageBoxWrapW function.
340 *
341 * From Vista+ onwards, all the implementation of ShellMessageBoxA/W that
342 * were existing in shell32 has been completely moved to shlwapi, so that
343 * shell32.ShellMessageBoxA and shell32.ShellMessageBoxW are redirections
344 * to the corresponding shlwapi functions.
345 *
346 */
347#else // !__REACTOS__
348/*
349 * NOTE:
350 * shlwapi.ShellMessageBoxWrapW is a duplicate of shell32.ShellMessageBoxW
351 * because we can't forward to it in the .spec file since it's exported by
352 * ordinal. If you change the implementation here please update the code in
353 * shlwapi as well.
354 */
355// Wine version, broken.
358 HWND hWnd,
359 LPCWSTR lpText,
360 LPCWSTR lpCaption,
361 UINT uType,
362 ...)
363{
364 WCHAR szText[100],szTitle[100];
365 LPCWSTR pszText = szText, pszTitle = szTitle;
366 LPWSTR pszTemp;
368 int ret;
369
370 __ms_va_start(args, uType);
371 /* wvsprintfA(buf,fmt, args); */
372
373 TRACE("(%p,%p,%p,%p,%08x)\n",
374 hInstance,hWnd,lpText,lpCaption,uType);
375
376 if (IS_INTRESOURCE(lpCaption))
378 else
379 pszTitle = lpCaption;
380
381 if (IS_INTRESOURCE(lpText))
382 LoadStringW(hInstance, LOWORD(lpText), szText, ARRAY_SIZE(szText));
383 else
384 pszText = lpText;
385
387 pszText, 0, 0, (LPWSTR)&pszTemp, 0, &args);
388
390
391 ret = MessageBoxW(hWnd,pszTemp,pszTitle,uType);
392 LocalFree(pszTemp);
393 return ret;
394}
395#endif
396
397/*************************************************************************
398 * ShellMessageBoxA [SHELL32.183]
399 *
400 * Format and output an error message.
401 *
402 * PARAMS
403 * hInstance [I] Instance handle of message creator
404 * hWnd [I] Window handle of message creator
405 * lpText [I] Resource Id of title or LPSTR
406 * lpCaption [I] Resource Id of title or LPSTR
407 * uType [I] Type of error message
408 *
409 * RETURNS
410 * A return value from MessageBoxA().
411 *
412 * NOTES
413 * Exported by ordinal
414 */
415#ifdef __REACTOS__
416/*
417 * Note that we cannot straightforwardly implement ShellMessageBoxA around
418 * ShellMessageBoxW, by converting some parameters from ANSI to UNICODE,
419 * because there may be some variadic ANSI strings, associated with '%s'
420 * printf-like formatters inside the format string, that would also need
421 * to be converted; however there is no way for us to find these and perform
422 * the conversion ourselves.
423 * Therefore, we re-implement ShellMessageBoxA by doing a copy-paste ANSI
424 * adaptation of the shlwapi.ShellMessageBoxWrapW function.
425 */
426#endif
429 HWND hWnd,
430 LPCSTR lpText,
431 LPCSTR lpCaption,
432 UINT uType,
433 ...)
434{
435#ifdef __REACTOS__
436 CHAR *szText = NULL, szTitle[100];
437 LPCSTR pszText, pszTitle = szTitle;
438 LPSTR pszTemp;
440 int ret;
441
442 __ms_va_start(args, uType);
443
444 TRACE("(%p,%p,%p,%p,%08x)\n", hInstance, hWnd, lpText, lpCaption, uType);
445
446 if (IS_INTRESOURCE(lpCaption))
448 else
449 pszTitle = lpCaption;
450
451 if (IS_INTRESOURCE(lpText))
452 {
453 /* Retrieve the length of the Unicode string and obtain the maximum
454 * possible length for the corresponding ANSI string (not counting
455 * any possible NULL-terminator). */
456 const WCHAR *ptr;
457 UINT len = LoadStringW(hInstance, LOWORD(lpText), (LPWSTR)&ptr, 0);
458
460 NULL, 0, NULL, NULL);
461
462 if (len)
463 {
464 szText = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(CHAR));
465 if (szText) LoadStringA(hInstance, LOWORD(lpText), szText, len + 1);
466 }
467 pszText = szText;
468 if (!pszText) {
469 WARN("Failed to load id %d\n", LOWORD(lpText));
471 return 0;
472 }
473 }
474 else
475 pszText = lpText;
476
478 pszText, 0, 0, (LPSTR)&pszTemp, 0, &args);
479
481
482 ret = MessageBoxA(hWnd, pszTemp, pszTitle, uType | MB_SETFOREGROUND);
483
484 HeapFree(GetProcessHeap(), 0, szText);
485 LocalFree(pszTemp);
486 return ret;
487
488#else // __REACTOS__
489
490// Wine version, broken.
491 char szText[100],szTitle[100];
492 LPCSTR pszText = szText, pszTitle = szTitle;
493 LPSTR pszTemp;
495 int ret;
496
497 __ms_va_start(args, uType);
498 /* wvsprintfA(buf,fmt, args); */
499
500 TRACE("(%p,%p,%p,%p,%08x)\n",
501 hInstance,hWnd,lpText,lpCaption,uType);
502
503 if (IS_INTRESOURCE(lpCaption))
504 LoadStringA(hInstance, LOWORD(lpCaption), szTitle, sizeof(szTitle));
505 else
506 pszTitle = lpCaption;
507
508 if (IS_INTRESOURCE(lpText))
509 LoadStringA(hInstance, LOWORD(lpText), szText, sizeof(szText));
510 else
511 pszText = lpText;
512
514 pszText, 0, 0, (LPSTR)&pszTemp, 0, &args);
515
517
518 ret = MessageBoxA(hWnd,pszTemp,pszTitle,uType);
519 LocalFree(pszTemp);
520 return ret;
521#endif
522}
523
524/*************************************************************************
525 * SHRegisterDragDrop [SHELL32.86]
526 *
527 * Probably equivalent to RegisterDragDrop but under Windows 95 it could use the
528 * shell32 built-in "mini-COM" without the need to load ole32.dll - see SHLoadOLE
529 * for details. Under Windows 98 this function initializes the true OLE when called
530 * the first time, on XP always returns E_OUTOFMEMORY and it got removed from Vista.
531 *
532 * We follow Windows 98 behaviour.
533 *
534 * NOTES
535 * exported by ordinal
536 *
537 * SEE ALSO
538 * RegisterDragDrop, SHLoadOLE
539 */
541 HWND hWnd,
542 LPDROPTARGET pDropTarget)
543{
544 static BOOL ole_initialized = FALSE;
545 HRESULT hr;
546
547 TRACE("(%p,%p)\n", hWnd, pDropTarget);
548
549 if (!ole_initialized)
550 {
552 if (FAILED(hr))
553 return hr;
554 ole_initialized = TRUE;
555 }
556 return RegisterDragDrop(hWnd, pDropTarget);
557}
558
559/*************************************************************************
560 * SHRevokeDragDrop [SHELL32.87]
561 *
562 * Probably equivalent to RevokeDragDrop but under Windows 95 it could use the
563 * shell32 built-in "mini-COM" without the need to load ole32.dll - see SHLoadOLE
564 * for details. Function removed from Windows Vista.
565 *
566 * We call ole32 RevokeDragDrop which seems to work even if OleInitialize was
567 * not called.
568 *
569 * NOTES
570 * exported by ordinal
571 *
572 * SEE ALSO
573 * RevokeDragDrop, SHLoadOLE
574 */
576{
577 TRACE("(%p)\n", hWnd);
578 return RevokeDragDrop(hWnd);
579}
580
581/*************************************************************************
582 * SHDoDragDrop [SHELL32.88]
583 *
584 * Probably equivalent to DoDragDrop but under Windows 9x it could use the
585 * shell32 built-in "mini-COM" without the need to load ole32.dll - see SHLoadOLE
586 * for details
587 *
588 * NOTES
589 * exported by ordinal
590 *
591 * SEE ALSO
592 * DoDragDrop, SHLoadOLE
593 */
595 HWND hWnd,
596 LPDATAOBJECT lpDataObject,
597 LPDROPSOURCE lpDropSource,
598 DWORD dwOKEffect,
599 LPDWORD pdwEffect)
600{
601 FIXME("(%p %p %p 0x%08x %p):stub.\n",
602 hWnd, lpDataObject, lpDropSource, dwOKEffect, pdwEffect);
603 return DoDragDrop(lpDataObject, lpDropSource, dwOKEffect, pdwEffect);
604}
605
606/*************************************************************************
607 * ArrangeWindows [SHELL32.184]
608 *
609 */
611 WORD cKids, const HWND *lpKids)
612{
613 /* Unimplemented in WinXP SP3 */
614 TRACE("(%p 0x%08x %p 0x%04x %p):stub.\n",
615 hwndParent, dwReserved, lpRect, cKids, lpKids);
616 return 0;
617}
618
619/*************************************************************************
620 * SignalFileOpen [SHELL32.103]
621 *
622 * NOTES
623 * exported by ordinal
624 */
627{
628 FIXME("(%p):stub.\n", pidl);
629
630 return FALSE;
631}
632
633/*************************************************************************
634 * SHADD_get_policy - helper function for SHAddToRecentDocs
635 *
636 * PARAMETERS
637 * policy [IN] policy name (null termed string) to find
638 * type [OUT] ptr to DWORD to receive type
639 * buffer [OUT] ptr to area to hold data retrieved
640 * len [IN/OUT] ptr to DWORD holding size of buffer and getting
641 * length filled
642 *
643 * RETURNS
644 * result of the SHQueryValueEx call
645 */
647{
648 HKEY Policy_basekey;
649 INT ret;
650
651 /* Get the key for the policies location in the registry
652 */
654 "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
655 0, KEY_READ, &Policy_basekey)) {
656
658 "Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer",
659 0, KEY_READ, &Policy_basekey)) {
660 TRACE("No Explorer Policies location exists. Policy wanted=%s\n",
661 policy);
662 *len = 0;
664 }
665 }
666
667 /* Retrieve the data if it exists
668 */
669 ret = SHQueryValueExA(Policy_basekey, policy, 0, type, buffer, len);
670 RegCloseKey(Policy_basekey);
671 return ret;
672}
673
674
675/*************************************************************************
676 * SHADD_compare_mru - helper function for SHAddToRecentDocs
677 *
678 * PARAMETERS
679 * data1 [IN] data being looked for
680 * data2 [IN] data in MRU
681 * cbdata [IN] length from FindMRUData call (not used)
682 *
683 * RETURNS
684 * position within MRU list that data was added.
685 */
687{
688#ifdef __REACTOS__
689 LPCWSTR psz1, psz2;
690 INT iCmp = lstrcmpiW(data1, data2);
691 if (iCmp != 0)
692 return iCmp;
693 psz1 = data1;
694 psz2 = data2;
695 psz1 += lstrlenW(psz1) + 1;
696 psz2 += lstrlenW(psz2) + 1;
697 return lstrcmpiW(psz1, psz2);
698#else
699 return lstrcmpiA(data1, data2);
700#endif
701}
702
703#ifdef __REACTOS__
704static BOOL
705DoStoreMRUData(LPBYTE pbBuffer, LPDWORD pcbBuffer,
706 LPCWSTR pszTargetTitle, LPCWSTR pszTargetPath, LPCWSTR pszLinkTitle)
707{
708 DWORD ib = 0, cb;
709 INT cchTargetTitle = lstrlenW(pszTargetTitle);
710 INT cchTargetPath = lstrlenW(pszTargetPath);
711 INT cchLinkTitle = lstrlenW(pszLinkTitle);
712
713 cb = (cchTargetTitle + 1 + cchTargetPath + 1 + cchLinkTitle + 2) * sizeof(WCHAR);
714 if (cb > *pcbBuffer)
715 return FALSE;
716
717 ZeroMemory(pbBuffer, *pcbBuffer);
718
719 cb = (cchTargetTitle + 1) * sizeof(WCHAR);
720 if (ib + cb > *pcbBuffer)
721 return FALSE;
722 CopyMemory(&pbBuffer[ib], pszTargetTitle, cb);
723 ib += cb;
724
725 cb = (cchTargetPath + 1) * sizeof(WCHAR);
726 if (ib + cb > *pcbBuffer)
727 return FALSE;
728 CopyMemory(&pbBuffer[ib], pszTargetPath, cb);
729 ib += cb;
730
731 cb = (cchLinkTitle + 1) * sizeof(WCHAR);
732 if (ib + cb > *pcbBuffer)
733 return FALSE;
734 CopyMemory(&pbBuffer[ib], pszLinkTitle, cb);
735 ib += cb;
736
737 *pcbBuffer = ib;
738 return TRUE;
739}
740#else
741/*************************************************************************
742 * SHADD_create_add_mru_data - helper function for SHAddToRecentDocs
743 *
744 * PARAMETERS
745 * mruhandle [IN] handle for created MRU list
746 * doc_name [IN] null termed pure doc name
747 * new_lnk_name [IN] null termed path and file name for .lnk file
748 * buffer [IN/OUT] 2048 byte area to construct MRU data
749 * len [OUT] ptr to int to receive space used in buffer
750 *
751 * RETURNS
752 * position within MRU list that data was added.
753 */
754static INT SHADD_create_add_mru_data(HANDLE mruhandle, LPCSTR doc_name, LPCSTR new_lnk_name,
756{
757 LPSTR ptr;
758 INT wlen;
759
760 /*FIXME: Document:
761 * RecentDocs MRU data structure seems to be:
762 * +0h document file name w/ terminating 0h
763 * +nh short int w/ size of remaining
764 * +n+2h 02h 30h, or 01h 30h, or 00h 30h - unknown
765 * +n+4h 10 bytes zeros - unknown
766 * +n+eh shortcut file name w/ terminating 0h
767 * +n+e+nh 3 zero bytes - unknown
768 */
769
770 /* Create the MRU data structure for "RecentDocs"
771 */
772 ptr = buffer;
773 lstrcpyA(ptr, doc_name);
774 ptr += (lstrlenA(buffer) + 1);
775 wlen= lstrlenA(new_lnk_name) + 1 + 12;
776 *((short int*)ptr) = wlen;
777 ptr += 2; /* step past the length */
778 *(ptr++) = 0x30; /* unknown reason */
779 *(ptr++) = 0; /* unknown, but can be 0x00, 0x01, 0x02 */
780 memset(ptr, 0, 10);
781 ptr += 10;
782 lstrcpyA(ptr, new_lnk_name);
783 ptr += (lstrlenA(new_lnk_name) + 1);
784 memset(ptr, 0, 3);
785 ptr += 3;
786 *len = ptr - buffer;
787
788 /* Add the new entry into the MRU list
789 */
790 return AddMRUData(mruhandle, buffer, *len);
791}
792#endif
793
794/*************************************************************************
795 * SHAddToRecentDocs [SHELL32.@]
796 *
797 * Modify (add/clear) Shell's list of recently used documents.
798 *
799 * PARAMETERS
800 * uFlags [IN] SHARD_PATHA, SHARD_PATHW or SHARD_PIDL
801 * pv [IN] string or pidl, NULL clears the list
802 *
803 * NOTES
804 * exported by name
805 *
806 * FIXME
807 * convert to unicode
808 */
810{
811#ifdef __REACTOS__
812 INT ret;
813 WCHAR szTargetPath[MAX_PATH], szLinkDir[MAX_PATH], szLinkFile[MAX_PATH], szDescription[80];
815 DWORD cbBuffer, data[64], datalen, type;
816 HANDLE hFind;
818 HKEY hExplorerKey;
819 LONG error;
820 LPWSTR pchDotExt, pchTargetTitle, pchLinkTitle;
821 MRUINFOW mru;
822 HANDLE hMRUList = NULL;
823 IShellLinkW *psl = NULL;
824 IPersistFile *pPf = NULL;
825 HRESULT hr;
826 BYTE Buffer[(MAX_PATH + 64) * sizeof(WCHAR)];
827
828 TRACE("%04x %p\n", uFlags, pv);
829
830 /* check policy */
831 ret = SHADD_get_policy("NoRecentDocsHistory", &type, data, &datalen);
832 if (ret > 0 && ret != ERROR_FILE_NOT_FOUND)
833 {
834 ERR("Error %d getting policy \"NoRecentDocsHistory\"\n", ret);
835 }
836 else if (ret == ERROR_SUCCESS)
837 {
838 if (!(type == REG_DWORD || (type == REG_BINARY && datalen == 4)))
839 {
840 ERR("Error policy data for \"NoRecentDocsHistory\" not formatted correctly, type=%d, len=%d\n",
841 type, datalen);
842 return;
843 }
844
845 TRACE("policy value for NoRecentDocsHistory = %08x\n", data[0]);
846 /* now test the actual policy value */
847 if (data[0] != 0)
848 return;
849 }
850
851 /* store to szTargetPath */
852 szTargetPath[0] = 0;
853 if (pv)
854 {
855 switch (uFlags)
856 {
857 case SHARD_PATHA:
858 MultiByteToWideChar(CP_ACP, 0, pv, -1, szLinkDir, ARRAYSIZE(szLinkDir));
859 GetFullPathNameW(szLinkDir, ARRAYSIZE(szTargetPath), szTargetPath, NULL);
860 break;
861
862 case SHARD_PATHW:
863 GetFullPathNameW(pv, ARRAYSIZE(szTargetPath), szTargetPath, NULL);
864 break;
865
866 case SHARD_PIDL:
867 SHGetPathFromIDListW(pv, szLinkDir);
868 GetFullPathNameW(szLinkDir, ARRAYSIZE(szTargetPath), szTargetPath, NULL);
869 break;
870
871 default:
872 FIXME("Unsupported flags: %u\n", uFlags);
873 return;
874 }
875 }
876
877 /* get recent folder */
879 {
880 ERR("serious issues 1\n");
881 return;
882 }
883 TRACE("Users Recent dir %S\n", szLinkDir);
884
885 /* open Explorer key */
886 error = RegCreateKeyExW(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer",
887 0, NULL, 0,
888 KEY_READ | KEY_WRITE, NULL, &hExplorerKey, NULL);
889 if (error)
890 {
891 ERR("Failed to RegCreateKeyExW: 0x%08X\n", error);
892 return;
893 }
894
895 if (!pv)
896 {
897 TRACE("pv is NULL, so delete all shortcut files in %S\n", szLinkDir);
898
899 lstrcpynW(szLinkFile, szLinkDir, ARRAYSIZE(szLinkFile));
900 PathAppendW(szLinkFile, L"*.lnk");
901
902 hFind = FindFirstFileW(szLinkFile, &find);
903 if (hFind != INVALID_HANDLE_VALUE)
904 {
905 do
906 {
907 lstrcpynW(szLinkFile, szLinkDir, ARRAYSIZE(szLinkFile));
908 PathAppendW(szLinkFile, find.cFileName);
909 DeleteFileW(szLinkFile);
910 } while (FindNextFile(hFind, &find));
911 FindClose(hFind);
912 }
913
914 SHDeleteKeyW(hExplorerKey, L"RecentDocs");
915 RegCloseKey(hExplorerKey);
916 return;
917 }
918
919 if (szTargetPath[0] == 0 || !PathFileExistsW(szTargetPath) ||
920 PathIsDirectoryW(szTargetPath))
921 {
922 /* path is not normal file */
923 RegCloseKey(hExplorerKey);
924 return;
925 }
926
928 if (FAILED(hr))
929 {
930 ERR("CoInitialize: %08X\n", hr);
931 RegCloseKey(hExplorerKey);
932 return;
933 }
934
935 /* check if file is a shortcut */
936 ret = 0;
937 pchDotExt = PathFindExtensionW(szTargetPath);
938 while (lstrcmpiW(pchDotExt, L".lnk") == 0)
939 {
940 hr = IShellLink_ConstructFromPath(szTargetPath, &IID_IShellLinkW, (LPVOID*)&psl);
941 if (FAILED(hr))
942 {
943 ERR("IShellLink_ConstructFromPath: 0x%08X\n", hr);
944 goto Quit;
945 }
946
947 IShellLinkW_GetPath(psl, szPath, ARRAYSIZE(szPath), NULL, 0);
948 IShellLinkW_Release(psl);
949 psl = NULL;
950
951 lstrcpynW(szTargetPath, szPath, ARRAYSIZE(szTargetPath));
952 pchDotExt = PathFindExtensionW(szTargetPath);
953
954 if (++ret >= 8)
955 {
956 ERR("Link loop?\n");
957 goto Quit;
958 }
959 }
960 if (!lstrcmpiW(pchDotExt, L".exe"))
961 {
962 /* executables are not added */
963 goto Quit;
964 }
965
966 /* *** JOB 0: Build strings *** */
967
968 pchTargetTitle = PathFindFileNameW(szTargetPath);
969
970 lstrcpyW(szDescription, L"Shortcut to ");
972
973 lstrcpynW(szLinkFile, szLinkDir, ARRAYSIZE(szLinkFile));
974 PathAppendW(szLinkFile, pchTargetTitle);
975 StrCatBuffW(szLinkFile, L".lnk", ARRAYSIZE(szLinkFile));
976 pchLinkTitle = PathFindFileNameW(szLinkFile);
977
978 /* *** JOB 1: Update registry for ...\Explorer\RecentDocs list *** */
979
980 /* store MRU data */
981 cbBuffer = sizeof(Buffer);
982 ret = DoStoreMRUData(Buffer, &cbBuffer, pchTargetTitle, szTargetPath, pchLinkTitle);
983 if (!ret)
984 {
985 ERR("DoStoreMRUData failed: %d\n", ret);
986 goto Quit;
987 }
988
989 /* create MRU list */
990 mru.cbSize = sizeof(mru);
991 mru.uMax = 16;
993 mru.hKey = hExplorerKey;
994 mru.lpszSubKey = L"RecentDocs";
995 mru.lpfnCompare = (MRUCMPPROCW)SHADD_compare_mru;
996 hMRUList = CreateMRUListW(&mru);
997 if (!hMRUList)
998 {
999 ERR("CreateMRUListW failed\n");
1000 goto Quit;
1001 }
1002
1003 /* already exists? */
1004 ret = FindMRUData(hMRUList, Buffer, cbBuffer, NULL);
1005 if (ret >= 0)
1006 {
1007 /* Just touch for speed */
1008 HANDLE hFile;
1012 {
1013 TRACE("Just touch file '%S'.\n", szLinkFile);
1015 goto Quit;
1016 }
1017 }
1018
1019 /* add MRU data */
1020 ret = AddMRUData(hMRUList, Buffer, cbBuffer);
1021 if (ret < 0)
1022 {
1023 ERR("AddMRUData failed: %d\n", ret);
1024 goto Quit;
1025 }
1026
1027 /* *** JOB 2: Create shortcut in user's "Recent" directory *** */
1028
1029 hr = CoCreateInstance(&CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER,
1030 &IID_IShellLinkW, (LPVOID *)&psl);
1031 if (FAILED(hr))
1032 {
1033 ERR("CoInitialize for IID_IShellLinkW: %08X\n", hr);
1034 goto Quit;
1035 }
1036
1037 hr = IShellLinkW_QueryInterface(psl, &IID_IPersistFile, (LPVOID *)&pPf);
1038 if (FAILED(hr))
1039 {
1040 ERR("IShellLinkW_QueryInterface: %08X\n", hr);
1041 goto Quit;
1042 }
1043
1044 if (uFlags == SHARD_PIDL)
1045 hr = IShellLinkW_SetIDList(psl, pv);
1046 else
1047 hr = IShellLinkW_SetPath(psl, pv);
1048
1049 IShellLinkW_SetDescription(psl, szDescription);
1050
1051 hr = IPersistFile_Save(pPf, szLinkFile, TRUE);
1052 if (FAILED(hr))
1053 {
1054 ERR("IPersistFile_Save: 0x%08X\n", hr);
1055 }
1056
1057 hr = IPersistFile_SaveCompleted(pPf, szLinkFile);
1058 if (FAILED(hr))
1059 {
1060 ERR("IPersistFile_SaveCompleted: 0x%08X\n", hr);
1061 }
1062
1063Quit:
1064 if (hMRUList)
1065 FreeMRUList(hMRUList);
1066 if (pPf)
1067 IPersistFile_Release(pPf);
1068 if (psl)
1069 IShellLinkW_Release(psl);
1071 RegCloseKey(hExplorerKey);
1072#else
1073/* If list is a string list lpfnCompare has the following prototype
1074 * int CALLBACK MRUCompareString(LPCSTR s1, LPCSTR s2)
1075 * for binary lists the prototype is
1076 * int CALLBACK MRUCompareBinary(LPCVOID data1, LPCVOID data2, DWORD cbData)
1077 * where cbData is the no. of bytes to compare.
1078 * Need to check what return value means identical - 0?
1079 */
1080
1081
1082 UINT olderrormode;
1083 HKEY HCUbasekey;
1084 CHAR doc_name[MAX_PATH];
1085 CHAR link_dir[MAX_PATH];
1086 CHAR new_lnk_filepath[MAX_PATH];
1087 CHAR new_lnk_name[MAX_PATH];
1088 CHAR * ext;
1089 IMalloc *ppM;
1090 LPITEMIDLIST pidl;
1091 HWND hwnd = 0; /* FIXME: get real window handle */
1092 INT ret;
1093 DWORD data[64], datalen, type;
1094
1095 TRACE("%04x %p\n", uFlags, pv);
1096
1097 /*FIXME: Document:
1098 * RecentDocs MRU data structure seems to be:
1099 * +0h document file name w/ terminating 0h
1100 * +nh short int w/ size of remaining
1101 * +n+2h 02h 30h, or 01h 30h, or 00h 30h - unknown
1102 * +n+4h 10 bytes zeros - unknown
1103 * +n+eh shortcut file name w/ terminating 0h
1104 * +n+e+nh 3 zero bytes - unknown
1105 */
1106
1107 /* See if we need to do anything.
1108 */
1109 datalen = 64;
1110 ret=SHADD_get_policy( "NoRecentDocsHistory", &type, data, &datalen);
1111 if ((ret > 0) && (ret != ERROR_FILE_NOT_FOUND)) {
1112 ERR("Error %d getting policy \"NoRecentDocsHistory\"\n", ret);
1113 return;
1114 }
1115 if (ret == ERROR_SUCCESS) {
1116 if (!( (type == REG_DWORD) ||
1117 ((type == REG_BINARY) && (datalen == 4)) )) {
1118 ERR("Error policy data for \"NoRecentDocsHistory\" not formatted correctly, type=%d, len=%d\n",
1119 type, datalen);
1120 return;
1121 }
1122
1123 TRACE("policy value for NoRecentDocsHistory = %08x\n", data[0]);
1124 /* now test the actual policy value */
1125 if ( data[0] != 0)
1126 return;
1127 }
1128
1129 /* Open key to where the necessary info is
1130 */
1131 /* FIXME: This should be done during DLL PROCESS_ATTACH (or THREAD_ATTACH)
1132 * and the close should be done during the _DETACH. The resulting
1133 * key is stored in the DLL global data.
1134 */
1136 "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer",
1137 0, 0, 0, KEY_READ, 0, &HCUbasekey, 0)) {
1138 ERR("Failed to create 'Software\\Microsoft\\Windows\\CurrentVersion\\Explorer'\n");
1139 return;
1140 }
1141
1142 /* Get path to user's "Recent" directory
1143 */
1144 if(SUCCEEDED(SHGetMalloc(&ppM))) {
1146 &pidl))) {
1147 SHGetPathFromIDListA(pidl, link_dir);
1148 IMalloc_Free(ppM, pidl);
1149 }
1150 else {
1151 /* serious issues */
1152 link_dir[0] = 0;
1153 ERR("serious issues 1\n");
1154 }
1155 IMalloc_Release(ppM);
1156 }
1157 else {
1158 /* serious issues */
1159 link_dir[0] = 0;
1160 ERR("serious issues 2\n");
1161 }
1162 TRACE("Users Recent dir %s\n", link_dir);
1163
1164 /* If no input, then go clear the lists */
1165 if (!pv) {
1166 /* clear user's Recent dir
1167 */
1168
1169 /* FIXME: delete all files in "link_dir"
1170 *
1171 * while( more files ) {
1172 * lstrcpyA(old_lnk_name, link_dir);
1173 * PathAppendA(old_lnk_name, filenam);
1174 * DeleteFileA(old_lnk_name);
1175 * }
1176 */
1177 FIXME("should delete all files in %s\\\n", link_dir);
1178
1179 /* clear MRU list
1180 */
1181 /* MS Bug ?? v4.72.3612.1700 of shell32 does the delete against
1182 * HKEY_LOCAL_MACHINE version of ...CurrentVersion\Explorer
1183 * and naturally it fails w/ rc=2. It should do it against
1184 * HKEY_CURRENT_USER which is where it is stored, and where
1185 * the MRU routines expect it!!!!
1186 */
1187 RegDeleteKeyA(HCUbasekey, "RecentDocs");
1188 RegCloseKey(HCUbasekey);
1189 return;
1190 }
1191
1192 /* Have data to add, the jobs to be done:
1193 * 1. Add document to MRU list in registry "HKCU\Software\
1194 * Microsoft\Windows\CurrentVersion\Explorer\RecentDocs".
1195 * 2. Add shortcut to document in the user's Recent directory
1196 * (CSIDL_RECENT).
1197 * 3. Add shortcut to Start menu's Documents submenu.
1198 */
1199
1200 /* Get the pure document name from the input
1201 */
1202 switch (uFlags)
1203 {
1204 case SHARD_PIDL:
1205 if (!SHGetPathFromIDListA(pv, doc_name))
1206 {
1207 WARN("can't get path from PIDL\n");
1208 return;
1209 }
1210 break;
1211
1212 case SHARD_PATHA:
1213 lstrcpynA(doc_name, pv, MAX_PATH);
1214 break;
1215
1216 case SHARD_PATHW:
1217 WideCharToMultiByte(CP_ACP, 0, pv, -1, doc_name, MAX_PATH, NULL, NULL);
1218 break;
1219
1220 default:
1221 FIXME("Unsupported flags: %u\n", uFlags);
1222 return;
1223 }
1224
1225 TRACE("full document name %s\n", debugstr_a(doc_name));
1226
1227 PathStripPathA(doc_name);
1228 TRACE("stripped document name %s\n", debugstr_a(doc_name));
1229
1230
1231 /* *** JOB 1: Update registry for ...\Explorer\RecentDocs list *** */
1232
1233 { /* on input needs:
1234 * doc_name - pure file-spec, no path
1235 * link_dir - path to the user's Recent directory
1236 * HCUbasekey - key of ...Windows\CurrentVersion\Explorer" node
1237 * creates:
1238 * new_lnk_name- pure file-spec, no path for new .lnk file
1239 * new_lnk_filepath
1240 * - path and file name of new .lnk file
1241 */
1242 CREATEMRULISTA mymru;
1243 HANDLE mruhandle;
1244 INT len, pos, bufused, err;
1245 INT i;
1246 DWORD attr;
1247 CHAR buffer[2048];
1248 CHAR *ptr;
1249 CHAR old_lnk_name[MAX_PATH];
1250 short int slen;
1251
1252 mymru.cbSize = sizeof(CREATEMRULISTA);
1253 mymru.nMaxItems = 15;
1255 mymru.hKey = HCUbasekey;
1256 mymru.lpszSubKey = "RecentDocs";
1257 mymru.lpfnCompare = SHADD_compare_mru;
1258 mruhandle = CreateMRUListA(&mymru);
1259 if (!mruhandle) {
1260 /* MRU failed */
1261 ERR("MRU processing failed, handle zero\n");
1262 RegCloseKey(HCUbasekey);
1263 return;
1264 }
1265 len = lstrlenA(doc_name);
1266 pos = FindMRUData(mruhandle, doc_name, len, 0);
1267
1268 /* Now get the MRU entry that will be replaced
1269 * and delete the .lnk file for it
1270 */
1271 if ((bufused = EnumMRUListA(mruhandle, (pos == -1) ? 14 : pos,
1272 buffer, 2048)) != -1) {
1273 ptr = buffer;
1274 ptr += (lstrlenA(buffer) + 1);
1275 slen = *((short int*)ptr);
1276 ptr += 2; /* skip the length area */
1277 if (bufused >= slen + (ptr-buffer)) {
1278 /* buffer size looks good */
1279 ptr += 12; /* get to string */
1280 len = bufused - (ptr-buffer); /* get length of buf remaining */
1281 if (ptr[0] && (lstrlenA(ptr) <= len-1)) {
1282 /* appears to be good string */
1283 lstrcpyA(old_lnk_name, link_dir);
1284 PathAppendA(old_lnk_name, ptr);
1285 if (!DeleteFileA(old_lnk_name)) {
1286 if ((attr = GetFileAttributesA(old_lnk_name)) == INVALID_FILE_ATTRIBUTES) {
1287 if ((err = GetLastError()) != ERROR_FILE_NOT_FOUND) {
1288 ERR("Delete for %s failed, err=%d, attr=%08x\n",
1289 old_lnk_name, err, attr);
1290 }
1291 else {
1292 TRACE("old .lnk file %s did not exist\n",
1293 old_lnk_name);
1294 }
1295 }
1296 else {
1297 ERR("Delete for %s failed, attr=%08x\n",
1298 old_lnk_name, attr);
1299 }
1300 }
1301 else {
1302 TRACE("deleted old .lnk file %s\n", old_lnk_name);
1303 }
1304 }
1305 }
1306 }
1307
1308 /* Create usable .lnk file name for the "Recent" directory
1309 */
1310 wsprintfA(new_lnk_name, "%s.lnk", doc_name);
1311 lstrcpyA(new_lnk_filepath, link_dir);
1312 PathAppendA(new_lnk_filepath, new_lnk_name);
1313 i = 1;
1314 olderrormode = SetErrorMode(SEM_FAILCRITICALERRORS);
1315 while (GetFileAttributesA(new_lnk_filepath) != INVALID_FILE_ATTRIBUTES) {
1316 i++;
1317 wsprintfA(new_lnk_name, "%s (%u).lnk", doc_name, i);
1318 lstrcpyA(new_lnk_filepath, link_dir);
1319 PathAppendA(new_lnk_filepath, new_lnk_name);
1320 }
1321 SetErrorMode(olderrormode);
1322 TRACE("new shortcut will be %s\n", new_lnk_filepath);
1323
1324 /* Now add the new MRU entry and data
1325 */
1326 pos = SHADD_create_add_mru_data(mruhandle, doc_name, new_lnk_name,
1327 buffer, &len);
1328 FreeMRUList(mruhandle);
1329 TRACE("Updated MRU list, new doc is position %d\n", pos);
1330 }
1331
1332 /* *** JOB 2: Create shortcut in user's "Recent" directory *** */
1333
1334 { /* on input needs:
1335 * doc_name - pure file-spec, no path
1336 * new_lnk_filepath
1337 * - path and file name of new .lnk file
1338 * uFlags[in] - flags on call to SHAddToRecentDocs
1339 * pv[in] - document path/pidl on call to SHAddToRecentDocs
1340 */
1341 IShellLinkA *psl = NULL;
1342 IPersistFile *pPf = NULL;
1343 HRESULT hres;
1345 WCHAR widelink[MAX_PATH];
1346
1347 CoInitialize(0);
1348
1349 hres = CoCreateInstance( &CLSID_ShellLink,
1350 NULL,
1351 CLSCTX_INPROC_SERVER,
1352 &IID_IShellLinkA,
1353 (LPVOID )&psl);
1354 if(SUCCEEDED(hres)) {
1355
1356 hres = IShellLinkA_QueryInterface(psl, &IID_IPersistFile,
1357 (LPVOID *)&pPf);
1358 if(FAILED(hres)) {
1359 /* bombed */
1360 ERR("failed QueryInterface for IPersistFile %08x\n", hres);
1361 goto fail;
1362 }
1363
1364 /* Set the document path or pidl */
1365 if (uFlags == SHARD_PIDL) {
1366 hres = IShellLinkA_SetIDList(psl, pv);
1367 } else {
1368 hres = IShellLinkA_SetPath(psl, pv);
1369 }
1370 if(FAILED(hres)) {
1371 /* bombed */
1372 ERR("failed Set{IDList|Path} %08x\n", hres);
1373 goto fail;
1374 }
1375
1376 lstrcpyA(desc, "Shortcut to ");
1377 lstrcatA(desc, doc_name);
1378 hres = IShellLinkA_SetDescription(psl, desc);
1379 if(FAILED(hres)) {
1380 /* bombed */
1381 ERR("failed SetDescription %08x\n", hres);
1382 goto fail;
1383 }
1384
1385 MultiByteToWideChar(CP_ACP, 0, new_lnk_filepath, -1,
1386 widelink, MAX_PATH);
1387 /* create the short cut */
1388 hres = IPersistFile_Save(pPf, widelink, TRUE);
1389 if(FAILED(hres)) {
1390 /* bombed */
1391 ERR("failed IPersistFile::Save %08x\n", hres);
1392 IPersistFile_Release(pPf);
1393 IShellLinkA_Release(psl);
1394 goto fail;
1395 }
1396 hres = IPersistFile_SaveCompleted(pPf, widelink);
1397 IPersistFile_Release(pPf);
1398 IShellLinkA_Release(psl);
1399 TRACE("shortcut %s has been created, result=%08x\n",
1400 new_lnk_filepath, hres);
1401 }
1402 else {
1403 ERR("CoCreateInstance failed, hres=%08x\n", hres);
1404 }
1405 }
1406
1407 fail:
1409
1410 /* all done */
1411 RegCloseKey(HCUbasekey);
1412 return;
1413#endif
1414}
1415
1416/*************************************************************************
1417 * SHCreateShellFolderViewEx [SHELL32.174]
1418 *
1419 * Create a new instance of the default Shell folder view object.
1420 *
1421 * RETURNS
1422 * Success: S_OK
1423 * Failure: error value
1424 *
1425 * NOTES
1426 * see IShellFolder::CreateViewObject
1427 */
1428 #ifndef __REACTOS__
1429
1431 LPCSFV psvcbi, /* [in] shelltemplate struct */
1432 IShellView **ppv) /* [out] IShellView pointer */
1433{
1434 IShellView * psf;
1435 HRESULT hRes;
1436
1437 TRACE("sf=%p pidl=%p cb=%p mode=0x%08x parm=%p\n",
1438 psvcbi->pshf, psvcbi->pidl, psvcbi->pfnCallback,
1439 psvcbi->fvm, psvcbi->psvOuter);
1440
1441 *ppv = NULL;
1442 hRes = IShellView_Constructor(psvcbi->pshf, &psf);
1443
1444 if (FAILED(hRes))
1445 return hRes;
1446
1447 hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppv);
1448 IShellView_Release(psf);
1449
1450 return hRes;
1451}
1452#endif
1453
1454/*************************************************************************
1455 * SHWinHelp [SHELL32.127]
1456 *
1457 */
1459{
1460 TRACE("(%p, %s, 0x%08x, %p)\n", hwnd, debugstr_w(pszHelp), uCommand, dwData);
1461 if (!WinHelpW(hwnd, pszHelp, uCommand, dwData))
1462 {
1463#if 0
1466#endif
1467 return FALSE;
1468 }
1469 return TRUE;
1470}
1471/*************************************************************************
1472 * SHRunControlPanel [SHELL32.161]
1473 *
1474 */
1476{
1477#ifdef __REACTOS__
1478 /*
1479 * TODO: Run in-process when possible, using
1480 * HKLM\Software\Microsoft\Windows\CurrentVersion\Explorer\ControlPanel\InProcCPLs
1481 * and possibly some extra rules.
1482 * See also https://docs.microsoft.com/en-us/windows/win32/api/shlobj/nf-shlobj-shruncontrolpanel
1483 * "If the specified Control Panel item is already running, SHRunControlPanel
1484 * attempts to switch to that instance rather than opening a new instance."
1485 * This function is not supported as of Windows Vista, where it always returns FALSE.
1486 * However we need to keep it "alive" even when ReactOS is compliled as NT6+
1487 * in order to keep control panel elements launch commands.
1488 */
1489 WCHAR parameters[MAX_PATH] = L"shell32.dll,Control_RunDLL ";
1490 TRACE("(%s, %p)n", debugstr_w(commandLine), parent);
1491 wcscat(parameters, commandLine);
1492
1493 return ((INT_PTR)ShellExecuteW(parent, L"open", L"rundll32.exe", parameters, NULL, SW_SHOWNORMAL) > 32);
1494#else
1495 FIXME("(%s, %p): stub\n", debugstr_w(commandLine), parent);
1496 return FALSE;
1497#endif
1498}
1499
1501/*************************************************************************
1502 * SHSetInstanceExplorer [SHELL32.176]
1503 *
1504 * NOTES
1505 * Sets the interface
1506 */
1508{ TRACE("%p\n", lpUnknown);
1509 SHELL32_IExplorerInterface = lpUnknown;
1510}
1511/*************************************************************************
1512 * SHGetInstanceExplorer [SHELL32.@]
1513 *
1514 * NOTES
1515 * gets the interface pointer of the explorer and a reference
1516 */
1518{ TRACE("%p\n", lpUnknown);
1519
1520 *lpUnknown = SHELL32_IExplorerInterface;
1521
1523 return E_FAIL;
1524
1525 IUnknown_AddRef(SHELL32_IExplorerInterface);
1526 return S_OK;
1527}
1528/*************************************************************************
1529 * SHFreeUnusedLibraries [SHELL32.123]
1530 *
1531 * Probably equivalent to CoFreeUnusedLibraries but under Windows 9x it could use
1532 * the shell32 built-in "mini-COM" without the need to load ole32.dll - see SHLoadOLE
1533 * for details
1534 *
1535 * NOTES
1536 * exported by ordinal
1537 *
1538 * SEE ALSO
1539 * CoFreeUnusedLibraries, SHLoadOLE
1540 */
1542{
1543 FIXME("stub\n");
1545}
1546/*************************************************************************
1547 * DAD_AutoScroll [SHELL32.129]
1548 *
1549 */
1551{
1552 FIXME("hwnd = %p %p %p\n",hwnd,samples,pt);
1553 return FALSE;
1554}
1555/*************************************************************************
1556 * DAD_DragEnter [SHELL32.130]
1557 *
1558 */
1560{
1561 FIXME("hwnd = %p\n",hwnd);
1562 return FALSE;
1563}
1564/*************************************************************************
1565 * DAD_DragEnterEx [SHELL32.131]
1566 *
1567 */
1569{
1570 FIXME("hwnd = %p (%d,%d)\n",hwnd,p.x,p.y);
1571 return FALSE;
1572}
1573/*************************************************************************
1574 * DAD_DragMove [SHELL32.134]
1575 *
1576 */
1578{
1579 FIXME("(%d,%d)\n",p.x,p.y);
1580 return FALSE;
1581}
1582/*************************************************************************
1583 * DAD_DragLeave [SHELL32.132]
1584 *
1585 */
1587{
1588 FIXME("\n");
1589 return FALSE;
1590}
1591/*************************************************************************
1592 * DAD_SetDragImage [SHELL32.136]
1593 *
1594 * NOTES
1595 * exported by name
1596 */
1598 HIMAGELIST himlTrack,
1599 LPPOINT lppt)
1600{
1601 FIXME("%p %p stub\n",himlTrack, lppt);
1602 return FALSE;
1603}
1604/*************************************************************************
1605 * DAD_ShowDragImage [SHELL32.137]
1606 *
1607 * NOTES
1608 * exported by name
1609 */
1611{
1612 FIXME("0x%08x stub\n",bShow);
1613 return FALSE;
1614}
1615
1616/*************************************************************************
1617 * ReadCabinetState [SHELL32.651] NT 4.0
1618 *
1619 */
1621{
1622 HKEY hkey = 0;
1623 DWORD type, r;
1624
1625 TRACE("%p %d\n", cs, length);
1626
1627 if( (cs == NULL) || (length < (int)sizeof(*cs)) )
1628 return FALSE;
1629
1630 r = RegOpenKeyW( HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CabinetState", &hkey );
1631 if( r == ERROR_SUCCESS )
1632 {
1633 type = REG_BINARY;
1634 r = RegQueryValueExW( hkey, L"Settings",
1635 NULL, &type, (LPBYTE)cs, (LPDWORD)&length );
1636 RegCloseKey( hkey );
1637
1638 }
1639
1640 /* if we can't read from the registry, create default values */
1641 if ( (r != ERROR_SUCCESS) || (cs->cLength < sizeof(*cs)) ||
1642 (cs->cLength != length) )
1643 {
1644 TRACE("Initializing shell cabinet settings\n");
1645 memset(cs, 0, sizeof(*cs));
1646 cs->cLength = sizeof(*cs);
1647 cs->nVersion = 2;
1648 cs->fFullPathTitle = FALSE;
1649 cs->fSaveLocalView = TRUE;
1650 cs->fNotShell = FALSE;
1651 cs->fSimpleDefault = TRUE;
1652 cs->fDontShowDescBar = FALSE;
1653 cs->fNewWindowMode = FALSE;
1654 cs->fShowCompColor = FALSE;
1655 cs->fDontPrettyNames = FALSE;
1656 cs->fAdminsCreateCommonGroups = TRUE;
1657 cs->fMenuEnumFilter = 96;
1658 }
1659
1660 return TRUE;
1661}
1662
1663/*************************************************************************
1664 * WriteCabinetState [SHELL32.652] NT 4.0
1665 *
1666 */
1668{
1669 DWORD r;
1670 HKEY hkey = 0;
1671
1672 TRACE("%p\n",cs);
1673
1674 if( cs == NULL )
1675 return FALSE;
1676
1677 r = RegCreateKeyExW( HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CabinetState", 0,
1678 NULL, 0, KEY_ALL_ACCESS, NULL, &hkey, NULL);
1679 if( r == ERROR_SUCCESS )
1680 {
1681 r = RegSetValueExW( hkey, L"Settings", 0,
1682 REG_BINARY, (LPBYTE) cs, cs->cLength);
1683
1684 RegCloseKey( hkey );
1685 }
1686
1687 return (r==ERROR_SUCCESS);
1688}
1689
1690/*************************************************************************
1691 * FileIconInit [SHELL32.660]
1692 *
1693 */
1695{
1696 return SIC_Initialize();
1697}
1698
1699/*************************************************************************
1700 * SetAppStartingCursor [SHELL32.99]
1701 */
1703{ FIXME("hwnd=%p 0x%04x stub\n",u,v );
1704 return 0;
1705}
1706
1707/*************************************************************************
1708 * SHLoadOLE [SHELL32.151]
1709 *
1710 * To reduce the memory usage of Windows 95, its shell32 contained an
1711 * internal implementation of a part of COM (see e.g. SHGetMalloc, SHCoCreateInstance,
1712 * SHRegisterDragDrop etc.) that allowed to use in-process STA objects without
1713 * the need to load OLE32.DLL. If OLE32.DLL was already loaded, the SH* function
1714 * would just call the Co* functions.
1715 *
1716 * The SHLoadOLE was called when OLE32.DLL was being loaded to transfer all the
1717 * information from the shell32 "mini-COM" to ole32.dll.
1718 *
1719 * See http://blogs.msdn.com/oldnewthing/archive/2004/07/05/173226.aspx for a
1720 * detailed description.
1721 *
1722 * Under wine ole32.dll is always loaded as it is imported by shlwapi.dll which is
1723 * imported by shell32 and no "mini-COM" is used (except for the "LoadWithoutCOM"
1724 * hack in SHCoCreateInstance)
1725 */
1727{ FIXME("0x%08lx stub\n",lParam);
1728 return S_OK;
1729}
1730/*************************************************************************
1731 * DriveType [SHELL32.64]
1732 *
1733 */
1735{
1736 WCHAR root[] = L"A:\\";
1737 root[0] = L'A' + DriveType;
1738 return GetDriveTypeW(root);
1739}
1740/*************************************************************************
1741 * InvalidateDriveType [SHELL32.65]
1742 * Unimplemented in XP SP3
1743 */
1745{
1746 TRACE("0x%08x stub\n",u);
1747 return 0;
1748}
1749/*************************************************************************
1750 * SHAbortInvokeCommand [SHELL32.198]
1751 *
1752 */
1754{ FIXME("stub\n");
1755 return 1;
1756}
1757/*************************************************************************
1758 * SHOutOfMemoryMessageBox [SHELL32.126]
1759 *
1760 */
1762 HWND hwndOwner,
1763 LPCSTR lpCaption,
1764 UINT uType)
1765{
1766 FIXME("%p %s 0x%08x stub\n",hwndOwner, lpCaption, uType);
1767 return 0;
1768}
1769/*************************************************************************
1770 * SHFlushClipboard [SHELL32.121]
1771 *
1772 */
1774{
1775 return OleFlushClipboard();
1776}
1777
1778/*************************************************************************
1779 * SHWaitForFileToOpen [SHELL32.97]
1780 *
1781 */
1783 LPCITEMIDLIST pidl,
1784 DWORD dwFlags,
1786{
1787 FIXME("%p 0x%08x 0x%08x stub\n", pidl, dwFlags, dwTimeout);
1788 return FALSE;
1789}
1790
1791/************************************************************************
1792 * RLBuildListOfPaths [SHELL32.146]
1793 *
1794 * NOTES
1795 * builds a DPA
1796 */
1798{ FIXME("stub\n");
1799 return 0;
1800}
1801/************************************************************************
1802 * SHValidateUNC [SHELL32.173]
1803 *
1804 */
1805BOOL WINAPI SHValidateUNC (HWND hwndOwner, PWSTR pszFile, UINT fConnect)
1806{
1807 FIXME("(%p, %s, 0x%08x): stub\n", hwndOwner, debugstr_w(pszFile), fConnect);
1808 return FALSE;
1809}
1810
1811/************************************************************************
1812 * DoEnvironmentSubstA [SHELL32.@]
1813 *
1814 * See DoEnvironmentSubstW.
1815 */
1817{
1818 LPSTR dst;
1819 BOOL res = FALSE;
1820 DWORD len = cchString;
1821
1822 TRACE("(%s, %d)\n", debugstr_a(pszString), cchString);
1823 if (pszString == NULL) /* Really return 0? */
1824 return 0;
1825 if ((dst = (LPSTR)HeapAlloc(GetProcessHeap(), 0, cchString * sizeof(CHAR))))
1826 {
1828 /* len includes the terminating 0 */
1829 if (len && len < cchString)
1830 {
1831 res = TRUE;
1833 }
1834 else
1835 len = cchString;
1836
1838 }
1839 return MAKELONG(len, res);
1840}
1841
1842/************************************************************************
1843 * DoEnvironmentSubstW [SHELL32.@]
1844 *
1845 * Replace all %KEYWORD% in the string with the value of the named
1846 * environment variable. If the buffer is too small, the string is not modified.
1847 *
1848 * PARAMS
1849 * pszString [I] '\0' terminated string with %keyword%.
1850 * [O] '\0' terminated string with %keyword% substituted.
1851 * cchString [I] size of str.
1852 *
1853 * RETURNS
1854 * Success: The string in the buffer is updated
1855 * HIWORD: TRUE
1856 * LOWORD: characters used in the buffer, including space for the terminating 0
1857 * Failure: buffer too small. The string is not modified.
1858 * HIWORD: FALSE
1859 * LOWORD: provided size of the buffer in characters
1860 */
1862{
1863 LPWSTR dst;
1864 BOOL res = FALSE;
1865 DWORD len = cchString;
1866
1867 TRACE("(%s, %d)\n", debugstr_w(pszString), cchString);
1868
1869 if ((cchString < MAXLONG) && (dst = HeapAlloc(GetProcessHeap(), 0, cchString * sizeof(WCHAR))))
1870 {
1872 /* len includes the terminating 0 */
1873 if (len && len <= cchString)
1874 {
1875 res = TRUE;
1876 memcpy(pszString, dst, len * sizeof(WCHAR));
1877 }
1878 else
1879 len = cchString;
1880
1882 }
1883 return MAKELONG(len, res);
1884}
1885
1886/************************************************************************
1887 * DoEnvironmentSubst [SHELL32.53]
1888 *
1889 * See DoEnvironmentSubstA.
1890 */
1892{
1893 if (SHELL_OsIsUnicode())
1894 return DoEnvironmentSubstW(x, y);
1895 return DoEnvironmentSubstA(x, y);
1896}
1897
1898/*************************************************************************
1899 * GUIDFromStringA [SHELL32.703]
1900 */
1902{
1903 TRACE("GUIDFromStringA() stub\n");
1904 return FALSE;
1905}
1906
1907/*************************************************************************
1908 * GUIDFromStringW [SHELL32.704]
1909 */
1911{
1912 UNICODE_STRING guid_str;
1913
1914 RtlInitUnicodeString(&guid_str, str);
1915 return !RtlGUIDFromString(&guid_str, guid);
1916}
1917
1918/*************************************************************************
1919 * PathIsTemporaryA [SHELL32.713]
1920 */
1922{
1923 FIXME("(%s)stub\n", debugstr_a(Str));
1924 return FALSE;
1925}
1926
1927/*************************************************************************
1928 * PathIsTemporaryW [SHELL32.714]
1929 */
1931{
1932 FIXME("(%s)stub\n", debugstr_w(Str));
1933 return FALSE;
1934}
1935
1936typedef struct _PSXA
1937{
1942
1943typedef struct _PSXA_CALL
1944{
1951
1953{
1955
1956 if (Call != NULL)
1957 {
1958 if ((Call->bMultiple || !Call->bCalled) &&
1959 Call->lpfnAddReplaceWith(hpage, Call->lParam))
1960 {
1961 Call->bCalled = TRUE;
1962 Call->uiCount++;
1963 return TRUE;
1964 }
1965 }
1966
1967 return FALSE;
1968}
1969
1970/*************************************************************************
1971 * SHAddFromPropSheetExtArray [SHELL32.167]
1972 */
1974{
1975 PSXA_CALL Call;
1976 UINT i;
1977 PPSXA psxa = (PPSXA)hpsxa;
1978
1979 TRACE("(%p,%p,%08lx)\n", hpsxa, lpfnAddPage, lParam);
1980
1981 if (psxa)
1982 {
1983 ZeroMemory(&Call, sizeof(Call));
1984 Call.lpfnAddReplaceWith = lpfnAddPage;
1985 Call.lParam = lParam;
1986 Call.bMultiple = TRUE;
1987
1988 /* Call the AddPage method of all registered IShellPropSheetExt interfaces */
1989 for (i = 0; i != psxa->uiCount; i++)
1990 {
1991 psxa->pspsx[i]->lpVtbl->AddPages(psxa->pspsx[i], PsxaCall, (LPARAM)&Call);
1992 }
1993
1994 return Call.uiCount;
1995 }
1996
1997 return 0;
1998}
1999
2000/*************************************************************************
2001 * SHCreatePropSheetExtArray [SHELL32.168]
2002 */
2004{
2005 return SHCreatePropSheetExtArrayEx(hKey, pszSubKey, max_iface, NULL);
2006}
2007
2008/*************************************************************************
2009 * SHCreatePropSheetExtArrayEx [SHELL32.194]
2010 */
2012{
2013 WCHAR szHandler[64];
2014 DWORD dwHandlerLen;
2015 WCHAR szClsidHandler[39];
2016 DWORD dwClsidSize;
2017 CLSID clsid;
2018 LONG lRet;
2019 DWORD dwIndex;
2020 IShellExtInit *psxi;
2021 IShellPropSheetExt *pspsx;
2022 HKEY hkBase, hkPropSheetHandlers;
2023 PPSXA psxa = NULL;
2024
2025 TRACE("(%p,%s,%u)\n", hKey, debugstr_w(pszSubKey), max_iface);
2026
2027 if (max_iface == 0)
2028 return NULL;
2029
2030 /* Open the registry key */
2031 lRet = RegOpenKeyW(hKey, pszSubKey, &hkBase);
2032 if (lRet != ERROR_SUCCESS)
2033 return NULL;
2034
2035 lRet = RegOpenKeyExW(hkBase, L"shellex\\PropertySheetHandlers", 0, KEY_ENUMERATE_SUB_KEYS, &hkPropSheetHandlers);
2036 RegCloseKey(hkBase);
2037 if (lRet == ERROR_SUCCESS)
2038 {
2039 /* Create and initialize the Property Sheet Extensions Array */
2040 psxa = LocalAlloc(LMEM_FIXED, FIELD_OFFSET(PSXA, pspsx[max_iface]));
2041 if (psxa)
2042 {
2043 ZeroMemory(psxa, FIELD_OFFSET(PSXA, pspsx[max_iface]));
2044 psxa->uiAllocated = max_iface;
2045
2046 /* Enumerate all subkeys and attempt to load the shell extensions */
2047 dwIndex = 0;
2048 do
2049 {
2050 dwHandlerLen = sizeof(szHandler) / sizeof(szHandler[0]);
2051 lRet = RegEnumKeyExW(hkPropSheetHandlers, dwIndex++, szHandler, &dwHandlerLen, NULL, NULL, NULL, NULL);
2052 if (lRet != ERROR_SUCCESS)
2053 {
2054 if (lRet == ERROR_MORE_DATA)
2055 continue;
2056
2057 if (lRet == ERROR_NO_MORE_ITEMS)
2058 lRet = ERROR_SUCCESS;
2059 break;
2060 }
2061
2062 /* The CLSID is stored either in the key itself or in its default value. */
2063 if (FAILED(lRet = SHCLSIDFromStringW(szHandler, &clsid)))
2064 {
2065 dwClsidSize = sizeof(szClsidHandler);
2066 if (SHGetValueW(hkPropSheetHandlers, szHandler, NULL, NULL, szClsidHandler, &dwClsidSize) == ERROR_SUCCESS)
2067 {
2068 /* Force a NULL-termination and convert the string */
2069 szClsidHandler[(sizeof(szClsidHandler) / sizeof(szClsidHandler[0])) - 1] = 0;
2070 lRet = SHCLSIDFromStringW(szClsidHandler, &clsid);
2071 }
2072 }
2073
2074 if (SUCCEEDED(lRet))
2075 {
2076 /* Attempt to get an IShellPropSheetExt and an IShellExtInit instance.
2077 Only if both interfaces are supported it's a real shell extension.
2078 Then call IShellExtInit's Initialize method. */
2079 if (SUCCEEDED(CoCreateInstance(&clsid, NULL, CLSCTX_INPROC_SERVER/* | CLSCTX_NO_CODE_DOWNLOAD */, &IID_IShellPropSheetExt, (LPVOID *)&pspsx)))
2080 {
2081 if (SUCCEEDED(pspsx->lpVtbl->QueryInterface(pspsx, &IID_IShellExtInit, (PVOID *)&psxi)))
2082 {
2083 if (SUCCEEDED(psxi->lpVtbl->Initialize(psxi, NULL, pDataObj, hKey)))
2084 {
2085 /* Add the IShellPropSheetExt instance to the array */
2086 psxa->pspsx[psxa->uiCount++] = pspsx;
2087 }
2088 else
2089 {
2090 psxi->lpVtbl->Release(psxi);
2091 pspsx->lpVtbl->Release(pspsx);
2092 }
2093 }
2094 else
2095 pspsx->lpVtbl->Release(pspsx);
2096 }
2097 }
2098
2099 } while (psxa->uiCount != psxa->uiAllocated);
2100 }
2101 else
2103
2104 RegCloseKey(hkPropSheetHandlers);
2105 }
2106
2107 if (lRet != ERROR_SUCCESS && psxa)
2108 {
2109 SHDestroyPropSheetExtArray((HPSXA)psxa);
2110 psxa = NULL;
2111 }
2112
2113 return (HPSXA)psxa;
2114}
2115
2116/*************************************************************************
2117 * SHReplaceFromPropSheetExtArray [SHELL32.170]
2118 */
2120{
2121 PSXA_CALL Call;
2122 UINT i;
2123 PPSXA psxa = (PPSXA)hpsxa;
2124
2125 TRACE("(%p,%u,%p,%08lx)\n", hpsxa, uPageID, lpfnReplaceWith, lParam);
2126
2127 if (psxa)
2128 {
2129 ZeroMemory(&Call, sizeof(Call));
2130 Call.lpfnAddReplaceWith = lpfnReplaceWith;
2131 Call.lParam = lParam;
2132
2133 /* Call the ReplacePage method of all registered IShellPropSheetExt interfaces.
2134 Each shell extension is only allowed to call the callback once during the callback. */
2135 for (i = 0; i != psxa->uiCount; i++)
2136 {
2137 Call.bCalled = FALSE;
2138 psxa->pspsx[i]->lpVtbl->ReplacePage(psxa->pspsx[i], uPageID, PsxaCall, (LPARAM)&Call);
2139 }
2140
2141 return Call.uiCount;
2142 }
2143
2144 return 0;
2145}
2146
2147/*************************************************************************
2148 * SHDestroyPropSheetExtArray [SHELL32.169]
2149 */
2151{
2152 UINT i;
2153 PPSXA psxa = (PPSXA)hpsxa;
2154
2155 TRACE("(%p)\n", hpsxa);
2156
2157 if (psxa)
2158 {
2159 for (i = 0; i != psxa->uiCount; i++)
2160 {
2161 psxa->pspsx[i]->lpVtbl->Release(psxa->pspsx[i]);
2162 }
2163
2164 LocalFree(psxa);
2165 }
2166}
2167
2168/*************************************************************************
2169 * CIDLData_CreateFromIDArray [SHELL32.83]
2170 *
2171 * Create IDataObject from PIDLs??
2172 */
2174 PCIDLIST_ABSOLUTE pidlFolder,
2175 UINT cpidlFiles,
2176 PCUIDLIST_RELATIVE_ARRAY lppidlFiles,
2177 LPDATAOBJECT *ppdataObject)
2178{
2179 UINT i;
2180 HWND hwnd = 0; /*FIXME: who should be hwnd of owner? set to desktop */
2181 HRESULT hResult;
2182
2183 TRACE("(%p, %d, %p, %p)\n", pidlFolder, cpidlFiles, lppidlFiles, ppdataObject);
2184 if (TRACE_ON(pidl))
2185 {
2186 pdump (pidlFolder);
2187 for (i=0; i<cpidlFiles; i++) pdump (lppidlFiles[i]);
2188 }
2189 hResult = IDataObject_Constructor(hwnd, pidlFolder, lppidlFiles, cpidlFiles, FALSE, ppdataObject);
2190 return hResult;
2191}
2192
2193/*************************************************************************
2194 * SHCreateStdEnumFmtEtc [SHELL32.74]
2195 *
2196 * NOTES
2197 *
2198 */
2200 UINT cFormats,
2201 const FORMATETC *lpFormats,
2202 LPENUMFORMATETC *ppenumFormatetc)
2203{
2204 IEnumFORMATETC *pef;
2205 HRESULT hRes;
2206 TRACE("cf=%d fe=%p pef=%p\n", cFormats, lpFormats, ppenumFormatetc);
2207
2208 hRes = IEnumFORMATETC_Constructor(cFormats, lpFormats, &pef);
2209 if (FAILED(hRes))
2210 return hRes;
2211
2212 IEnumFORMATETC_AddRef(pef);
2213 hRes = IEnumFORMATETC_QueryInterface(pef, &IID_IEnumFORMATETC, (LPVOID*)ppenumFormatetc);
2214 IEnumFORMATETC_Release(pef);
2215
2216 return hRes;
2217}
2218
2219/*************************************************************************
2220 * SHFindFiles (SHELL32.90)
2221 */
2223{
2224 FIXME("params ignored: %p %p\n", pidlFolder, pidlSaveFile);
2226 {
2227 return FALSE;
2228 }
2229 /* Open the search results folder */
2230 /* FIXME: CSearchBar should be opened as well */
2231 return ShellExecuteW(NULL, NULL, L"explorer.exe", L"::{E17D4FC0-5564-11D1-83F2-00A0C90DC849}", NULL, SW_SHOWNORMAL) > (HINSTANCE)32;
2232}
2233
2234/*************************************************************************
2235 * SHUpdateImageW (SHELL32.192)
2236 *
2237 * Notifies the shell that an icon in the system image list has been changed.
2238 *
2239 * PARAMS
2240 * pszHashItem [I] Path to file that contains the icon.
2241 * iIndex [I] Zero-based index of the icon in the file.
2242 * uFlags [I] Flags determining the icon attributes. See notes.
2243 * iImageIndex [I] Index of the icon in the system image list.
2244 *
2245 * RETURNS
2246 * Nothing
2247 *
2248 * NOTES
2249 * uFlags can be one or more of the following flags:
2250 * GIL_NOTFILENAME - pszHashItem is not a file name.
2251 * GIL_SIMULATEDOC - Create a document icon using the specified icon.
2252 */
2253void WINAPI SHUpdateImageW(LPCWSTR pszHashItem, int iIndex, UINT uFlags, int iImageIndex)
2254{
2255 FIXME("%s, %d, 0x%x, %d - stub\n", debugstr_w(pszHashItem), iIndex, uFlags, iImageIndex);
2256}
2257
2258/*************************************************************************
2259 * SHUpdateImageA (SHELL32.191)
2260 *
2261 * See SHUpdateImageW.
2262 */
2263VOID WINAPI SHUpdateImageA(LPCSTR pszHashItem, INT iIndex, UINT uFlags, INT iImageIndex)
2264{
2265 FIXME("%s, %d, 0x%x, %d - stub\n", debugstr_a(pszHashItem), iIndex, uFlags, iImageIndex);
2266}
2267
2269{
2270 FIXME("%p - stub\n", pidlExtra);
2271
2272 return -1;
2273}
2274
2276{
2277 FIXME("%p, 0x%08x, %s, %s - stub\n", hwnd, dwType, debugstr_w(szObject), debugstr_w(szPage));
2278
2279 return TRUE;
2280}
2281
2283 UINT uFlags)
2284{
2285 WCHAR wszLinkTo[MAX_PATH];
2286 WCHAR wszDir[MAX_PATH];
2287 WCHAR wszName[MAX_PATH];
2288 BOOL res;
2289
2290 MultiByteToWideChar(CP_ACP, 0, pszLinkTo, -1, wszLinkTo, MAX_PATH);
2291 MultiByteToWideChar(CP_ACP, 0, pszDir, -1, wszDir, MAX_PATH);
2292
2293 res = SHGetNewLinkInfoW(wszLinkTo, wszDir, wszName, pfMustCopy, uFlags);
2294
2295 if (res)
2296 WideCharToMultiByte(CP_ACP, 0, wszName, -1, pszName, MAX_PATH, NULL, NULL);
2297
2298 return res;
2299}
2300
2302 UINT uFlags)
2303{
2304 const WCHAR *basename;
2305 WCHAR *dst_basename;
2306 int i=2;
2307
2308 TRACE("(%s, %s, %p, %p, 0x%08x)\n", debugstr_w(pszLinkTo), debugstr_w(pszDir),
2309 pszName, pfMustCopy, uFlags);
2310
2311 *pfMustCopy = FALSE;
2312
2313 if (uFlags & SHGNLI_PIDL)
2314 {
2315 FIXME("SHGNLI_PIDL flag unsupported\n");
2316 return FALSE;
2317 }
2318
2319 if (uFlags)
2320 FIXME("ignoring flags: 0x%08x\n", uFlags);
2321
2322 /* FIXME: should test if the file is a shortcut or DOS program */
2324 return FALSE;
2325
2326 basename = strrchrW(pszLinkTo, '\\');
2327 if (basename)
2328 basename = basename+1;
2329 else
2330 basename = pszLinkTo;
2331
2332 lstrcpynW(pszName, pszDir, MAX_PATH);
2333 if (!PathAddBackslashW(pszName))
2334 return FALSE;
2335
2336 dst_basename = pszName + strlenW(pszName);
2337
2338 snprintfW(dst_basename, pszName + MAX_PATH - dst_basename, L"%s.lnk", basename);
2339
2341 {
2342 snprintfW(dst_basename, pszName + MAX_PATH - dst_basename, L"%s (%d).lnk", basename, i);
2343 i++;
2344 }
2345
2346 return TRUE;
2347}
2348
2350{
2351 FIXME("%p, %s, 0x%08x - stub\n", hwnd, debugstr_a(pszRemoteName), dwType);
2352
2353 return S_OK;
2354}
2355/*************************************************************************
2356 * SHSetLocalizedName (SHELL32.@)
2357 */
2358HRESULT WINAPI SHSetLocalizedName(LPCWSTR pszPath, LPCWSTR pszResModule, int idsRes)
2359{
2360 FIXME("%p, %s, %d - stub\n", pszPath, debugstr_w(pszResModule), idsRes);
2361
2362 return S_OK;
2363}
2364
2365/*************************************************************************
2366 * LinkWindow_RegisterClass (SHELL32.258)
2367 */
2369{
2370 FIXME("()\n");
2371 return TRUE;
2372}
2373
2374/*************************************************************************
2375 * LinkWindow_UnregisterClass (SHELL32.259)
2376 */
2378{
2379 FIXME("()\n");
2380 return TRUE;
2381}
2382
2383/*************************************************************************
2384 * SHFlushSFCache (SHELL32.526)
2385 *
2386 * Notifies the shell that a user-specified special folder location has changed.
2387 *
2388 * NOTES
2389 * In Wine, the shell folder registry values are not cached, so this function
2390 * has no effect.
2391 */
2393{
2394}
2395
2396/*************************************************************************
2397 * SHGetImageList (SHELL32.727)
2398 *
2399 * Returns a copy of a shell image list.
2400 *
2401 * NOTES
2402 * Windows XP features 4 sizes of image list, and Vista 5. Wine currently
2403 * only supports the traditional small and large image lists, so requests
2404 * for the others will currently fail.
2405 */
2406HRESULT WINAPI SHGetImageList(int iImageList, REFIID riid, void **ppv)
2407{
2408 HIMAGELIST hLarge, hSmall;
2409 HIMAGELIST hNew;
2410 HRESULT ret = E_FAIL;
2411
2412 /* Wine currently only maintains large and small image lists */
2413 if ((iImageList != SHIL_LARGE) && (iImageList != SHIL_SMALL) && (iImageList != SHIL_SYSSMALL))
2414 {
2415 FIXME("Unsupported image list %i requested\n", iImageList);
2416 return E_FAIL;
2417 }
2418
2419 Shell_GetImageLists(&hLarge, &hSmall);
2420#ifndef __REACTOS__
2421 hNew = ImageList_Duplicate(iImageList == SHIL_LARGE ? hLarge : hSmall);
2422
2423 /* Get the interface for the new image list */
2424 if (hNew)
2425 {
2427 ImageList_Destroy(hNew);
2428 }
2429#else
2430 /* Duplicating the imagelist causes the start menu items not to draw on
2431 * the first show. Was the Duplicate necessary for some reason? I believe
2432 * Windows returns the raw pointer here. */
2433 hNew = (iImageList == SHIL_LARGE ? hLarge : hSmall);
2434 ret = IImageList2_QueryInterface((IImageList2 *) hNew, riid, ppv);
2435#endif
2436
2437 return ret;
2438}
2439
2440#ifndef __REACTOS__
2441
2442/*************************************************************************
2443 * SHCreateShellFolderView [SHELL32.256]
2444 *
2445 * Create a new instance of the default Shell folder view object.
2446 *
2447 * RETURNS
2448 * Success: S_OK
2449 * Failure: error value
2450 *
2451 * NOTES
2452 * see IShellFolder::CreateViewObject
2453 */
2455 IShellView **ppsv)
2456{
2457 IShellView * psf;
2458 HRESULT hRes;
2459
2460 *ppsv = NULL;
2461 if (!pcsfv || pcsfv->cbSize != sizeof(*pcsfv))
2462 return E_INVALIDARG;
2463
2464 TRACE("sf=%p outer=%p callback=%p\n",
2465 pcsfv->pshf, pcsfv->psvOuter, pcsfv->psfvcb);
2466
2467 hRes = IShellView_Constructor(pcsfv->pshf, &psf);
2468 if (FAILED(hRes))
2469 return hRes;
2470
2471 hRes = IShellView_QueryInterface(psf, &IID_IShellView, (LPVOID *)ppsv);
2472 IShellView_Release(psf);
2473
2474 return hRes;
2475}
2476#endif
2477
2478
2479/*************************************************************************
2480 * SHTestTokenMembership [SHELL32.245]
2481 *
2482 * Checks whether a given token is a mamber of a local group with the
2483 * specified RID.
2484 *
2485 */
2487WINAPI
2489{
2491 DWORD nSubAuthority0, nSubAuthority1;
2492 DWORD nSubAuthorityCount;
2493 PSID SidToCheck;
2494 BOOL IsMember = FALSE;
2495
2496 if ((ulRID == SECURITY_SERVICE_RID) || ulRID == SECURITY_LOCAL_SYSTEM_RID)
2497 {
2498 nSubAuthority0 = ulRID;
2499 nSubAuthority1 = 0;
2500 nSubAuthorityCount= 1;
2501 }
2502 else
2503 {
2504 nSubAuthority0 = SECURITY_BUILTIN_DOMAIN_RID;
2505 nSubAuthority1 = ulRID;
2506 nSubAuthorityCount= 2;
2507 }
2508
2509 if (!AllocateAndInitializeSid(&ntAuth,
2510 nSubAuthorityCount,
2511 nSubAuthority0,
2512 nSubAuthority1,
2513 0, 0, 0, 0, 0, 0,
2514 &SidToCheck))
2515 {
2516 return FALSE;
2517 }
2518
2519 if (!CheckTokenMembership(TokenHandle, SidToCheck, &IsMember))
2520 {
2521 IsMember = FALSE;
2522 }
2523
2524 FreeSid(SidToCheck);
2525 return IsMember;
2526}
2527
2528/*************************************************************************
2529 * IsUserAnAdmin [SHELL32.680] NT 4.0
2530 *
2531 * Checks whether the current user is a member of the Administrators group.
2532 *
2533 * PARAMS
2534 * None
2535 *
2536 * RETURNS
2537 * Success: TRUE
2538 * Failure: FALSE
2539 */
2541{
2543}
2544
2545/*************************************************************************
2546 * SHLimitInputEdit(SHELL32.@)
2547 */
2548
2549/* TODO: Show baloon popup window with TTS_BALLOON */
2550
2551typedef struct UxSubclassInfo
2552{
2558
2559static void
2561{
2562 if (!pInfo)
2563 return;
2564
2565 RemovePropW(pInfo->hwnd, L"UxSubclassInfo");
2566
2569
2571
2572 HeapFree(GetProcessHeap(), 0, pInfo);
2573}
2574
2575static BOOL
2576DoSanitizeText(LPWSTR pszSanitized, LPCWSTR pszInvalidChars, LPCWSTR pszValidChars)
2577{
2578 LPWSTR pch1, pch2;
2579 BOOL bFound = FALSE;
2580
2581 for (pch1 = pch2 = pszSanitized; *pch1; ++pch1)
2582 {
2583 if (pszInvalidChars)
2584 {
2585 if (wcschr(pszInvalidChars, *pch1) != NULL)
2586 {
2587 bFound = TRUE;
2588 continue;
2589 }
2590 }
2591 else if (pszValidChars)
2592 {
2593 if (wcschr(pszValidChars, *pch1) == NULL)
2594 {
2595 bFound = TRUE;
2596 continue;
2597 }
2598 }
2599
2600 *pch2 = *pch1;
2601 ++pch2;
2602 }
2603 *pch2 = 0;
2604
2605 return bFound;
2606}
2607
2608static void
2610{
2611 HGLOBAL hData;
2612 LPWSTR pszText, pszSanitized;
2613 DWORD cbData;
2614
2616 return;
2617 if (!OpenClipboard(hwnd))
2618 return;
2619
2621 pszText = GlobalLock(hData);
2622 if (!pszText)
2623 {
2625 return;
2626 }
2627 SHStrDupW(pszText, &pszSanitized);
2628 GlobalUnlock(hData);
2629
2630 if (pszSanitized &&
2631 DoSanitizeText(pszSanitized, pInfo->pwszInvalidChars, pInfo->pwszValidChars))
2632 {
2633 MessageBeep(0xFFFFFFFF);
2634
2635 /* Update clipboard text */
2636 cbData = (lstrlenW(pszSanitized) + 1) * sizeof(WCHAR);
2637 hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, cbData);
2638 pszText = GlobalLock(hData);
2639 if (pszText)
2640 {
2641 CopyMemory(pszText, pszSanitized, cbData);
2642 GlobalUnlock(hData);
2643
2645 }
2646 }
2647
2648 CoTaskMemFree(pszSanitized);
2650}
2651
2652static LRESULT CALLBACK
2654{
2655 WNDPROC fnWndProc;
2656 WCHAR wch;
2657 UxSubclassInfo *pInfo = GetPropW(hwnd, L"UxSubclassInfo");
2658 if (!pInfo)
2659 return DefWindowProcW(hwnd, uMsg, wParam, lParam);
2660
2661 fnWndProc = pInfo->fnWndProc;
2662
2663 switch (uMsg)
2664 {
2665 case WM_KEYDOWN:
2666 if (GetKeyState(VK_SHIFT) < 0 && wParam == VK_INSERT)
2667 DoSanitizeClipboard(hwnd, pInfo);
2668 else if (GetKeyState(VK_CONTROL) < 0 && wParam == L'V')
2669 DoSanitizeClipboard(hwnd, pInfo);
2670
2671 return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
2672
2673 case WM_PASTE:
2674 DoSanitizeClipboard(hwnd, pInfo);
2675 return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
2676
2677 case WM_CHAR:
2678 if (GetKeyState(VK_CONTROL) < 0 && wParam == L'V')
2679 break;
2680
2681 if (pInfo->pwszInvalidChars)
2682 {
2683 if (wcschr(pInfo->pwszInvalidChars, (WCHAR)wParam) != NULL)
2684 {
2685 MessageBeep(0xFFFFFFFF);
2686 break;
2687 }
2688 }
2689 else if (pInfo->pwszValidChars)
2690 {
2691 if (wcschr(pInfo->pwszValidChars, (WCHAR)wParam) == NULL)
2692 {
2693 MessageBeep(0xFFFFFFFF);
2694 break;
2695 }
2696 }
2697 return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
2698
2699 case WM_UNICHAR:
2700 if (wParam == UNICODE_NOCHAR)
2701 return TRUE;
2702
2703 /* FALL THROUGH */
2704
2705 case WM_IME_CHAR:
2706 wch = (WCHAR)wParam;
2707 if (GetKeyState(VK_CONTROL) < 0 && wch == L'V')
2708 break;
2709
2710 if (!IsWindowUnicode(hwnd) && HIBYTE(wch) != 0)
2711 {
2712 CHAR data[] = {HIBYTE(wch), LOBYTE(wch)};
2713 MultiByteToWideChar(CP_ACP, 0, data, 2, &wch, 1);
2714 }
2715
2716 if (pInfo->pwszInvalidChars)
2717 {
2718 if (wcschr(pInfo->pwszInvalidChars, wch) != NULL)
2719 {
2720 MessageBeep(0xFFFFFFFF);
2721 break;
2722 }
2723 }
2724 else if (pInfo->pwszValidChars)
2725 {
2726 if (wcschr(pInfo->pwszValidChars, wch) == NULL)
2727 {
2728 MessageBeep(0xFFFFFFFF);
2729 break;
2730 }
2731 }
2732 return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
2733
2734 case WM_NCDESTROY:
2736 return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
2737
2738 default:
2739 return CallWindowProcW(fnWndProc, hwnd, uMsg, wParam, lParam);
2740 }
2741
2742 return 0;
2743}
2744
2745static UxSubclassInfo *
2747{
2748 UxSubclassInfo *pInfo;
2750 if (!pInfo)
2751 {
2752 ERR("HeapAlloc failed.\n");
2755 return NULL;
2756 }
2757
2759 if (!pInfo->fnWndProc)
2760 {
2761 ERR("SetWindowLongPtrW failed\n");
2764 HeapFree(GetProcessHeap(), 0, pInfo);
2765 return NULL;
2766 }
2767
2768 pInfo->hwnd = hwnd;
2769 pInfo->pwszValidChars = valid;
2770 pInfo->pwszInvalidChars = invalid;
2771 if (!SetPropW(hwnd, L"UxSubclassInfo", pInfo))
2772 {
2774 pInfo = NULL;
2775 }
2776 return pInfo;
2777}
2778
2781{
2782 IItemNameLimits *pLimits;
2783 HRESULT hr;
2784 LPWSTR pwszValidChars, pwszInvalidChars;
2785 UxSubclassInfo *pInfo;
2786
2787 pInfo = GetPropW(hWnd, L"UxSubclassInfo");
2788 if (pInfo)
2789 {
2791 pInfo = NULL;
2792 }
2793
2794 hr = psf->lpVtbl->QueryInterface(psf, &IID_IItemNameLimits, (LPVOID *)&pLimits);
2795 if (FAILED(hr))
2796 {
2797 ERR("hr: %x\n", hr);
2798 return hr;
2799 }
2800
2801 pwszValidChars = pwszInvalidChars = NULL;
2802 hr = pLimits->lpVtbl->GetValidCharacters(pLimits, &pwszValidChars, &pwszInvalidChars);
2803 if (FAILED(hr))
2804 {
2805 ERR("hr: %x\n", hr);
2806 pLimits->lpVtbl->Release(pLimits);
2807 return hr;
2808 }
2809
2810 pInfo = UxSubclassInfo_Create(hWnd, pwszValidChars, pwszInvalidChars);
2811 if (!pInfo)
2812 hr = E_FAIL;
2813
2814 pLimits->lpVtbl->Release(pLimits);
2815
2816 return hr;
2817}
HRESULT IDataObject_Constructor(HWND hwndOwner, PCIDLIST_ABSOLUTE pMyPidl, PCUIDLIST_RELATIVE_ARRAY apidl, UINT cidl, BOOL bExtendedObject, IDataObject **dataObject)
HRESULT IEnumFORMATETC_Constructor(UINT cfmt, const FORMATETC afmt[], IEnumFORMATETC **ppFormat)
UINT DriveType
#define shell32_hInstance
HWND hWnd
Definition: settings.c:17
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define CF_UNICODETEXT
Definition: constants.h:408
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
#define ARRAY_SIZE(a)
Definition: main.h:24
#define EXTERN_C
Definition: basetyps.h:12
#define FIXME(fmt,...)
Definition: debug.h:111
#define WARN(fmt,...)
Definition: debug.h:112
#define ERR(fmt,...)
Definition: debug.h:110
#define RegCloseKey(hKey)
Definition: registry.h:47
HINSTANCE hInstance
Definition: charmap.c:19
Definition: bufpool.h:45
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
INT(CALLBACK * MRUCMPPROCW)(LPCWSTR, LPCWSTR)
#define MRU_BINARY
HANDLE WINAPI CreateMRUListW(const MRUINFOW *infoW)
#define MRU_CACHEWRITE
#define OFN_EXPLORER
Definition: commdlg.h:104
#define OFN_HIDEREADONLY
Definition: commdlg.h:107
#define OFN_FILEMUSTEXIST
Definition: commdlg.h:106
static HWND hwndParent
Definition: cryptui.c:300
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
static TAGID TAGID find
Definition: db.cpp:155
#define ERROR_NOT_ENOUGH_MEMORY
Definition: dderror.h:7
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define E_INVALIDARG
Definition: ddrawi.h:101
#define E_FAIL
Definition: ddrawi.h:102
void pdump(LPCITEMIDLIST pidl)
Definition: debughlp.cpp:311
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
static const WCHAR szDescription[]
Definition: provider.c:55
#define ARRAYSIZE(array)
Definition: filtermapper.c:47
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1091
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3356
LONG WINAPI RegOpenKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD ulOptions, _In_ REGSAM samDesired, _Out_ PHKEY phkResult)
Definition: reg.c:3321
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2527
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3291
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4900
LONG WINAPI RegQueryValueExA(_In_ HKEY hkeyorg, _In_ LPCSTR name, _In_ LPDWORD reserved, _Out_opt_ LPDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ LPDWORD count)
Definition: reg.c:4027
LONG WINAPI RegCreateKeyExA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey, _In_ DWORD Reserved, _In_ LPSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_ LPDWORD lpdwDisposition)
Definition: reg.c:1029
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4121
LONG WINAPI RegDeleteKeyA(_In_ HKEY hKey, _In_ LPCSTR lpSubKey)
Definition: reg.c:1222
BOOL WINAPI CheckTokenMembership(IN HANDLE ExistingTokenHandle, IN PSID SidToCheck, OUT PBOOL IsMember)
Definition: token.c:21
BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority, BYTE nSubAuthorityCount, DWORD nSubAuthority0, DWORD nSubAuthority1, DWORD nSubAuthority2, DWORD nSubAuthority3, DWORD nSubAuthority4, DWORD nSubAuthority5, DWORD nSubAuthority6, DWORD nSubAuthority7, PSID *pSid)
Definition: security.c:676
PVOID WINAPI FreeSid(PSID pSid)
Definition: security.c:700
UINT uFlags
Definition: api.c:59
HRESULT WINAPI HIMAGELIST_QueryInterface(HIMAGELIST himl, REFIID riid, void **ppv)
Definition: imagelist.c:4038
HIMAGELIST WINAPI ImageList_Duplicate(HIMAGELIST himlSrc)
Definition: imagelist.c:1801
BOOL WINAPI ImageList_Destroy(HIMAGELIST himl)
Definition: imagelist.c:928
#define CloseHandle
Definition: compat.h:739
#define wcschr
Definition: compat.h:17
#define GetProcessHeap()
Definition: compat.h:736
#define CP_ACP
Definition: compat.h:109
#define OPEN_EXISTING
Definition: compat.h:775
#define lstrcpynA
Definition: compat.h:751
#define GetProcAddress(x, y)
Definition: compat.h:753
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define HeapAlloc
Definition: compat.h:733
#define FreeLibrary(x)
Definition: compat.h:748
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:105
#define GENERIC_READ
Definition: compat.h:135
#define TRACE_ON(x)
Definition: compat.h:75
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CreateFileW
Definition: compat.h:741
#define WINE_DECLARE_DEBUG_CHANNEL(x)
Definition: compat.h:45
#define CALLBACK
Definition: compat.h:35
#define lstrcpyW
Definition: compat.h:749
#define WideCharToMultiByte
Definition: compat.h:111
#define MultiByteToWideChar
Definition: compat.h:110
#define LoadLibraryW(x)
Definition: compat.h:747
#define FILE_SHARE_READ
Definition: compat.h:136
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define lstrcpynW
Definition: compat.h:738
#define lstrlenW
Definition: compat.h:750
static const WCHAR *const ext[]
Definition: module.c:53
DWORD WINAPI ExpandEnvironmentStringsA(IN LPCSTR lpSrc, IN LPSTR lpDst, IN DWORD nSize)
Definition: environ.c:399
DWORD WINAPI ExpandEnvironmentStringsW(IN LPCWSTR lpSrc, IN LPWSTR lpDst, IN DWORD nSize)
Definition: environ.c:519
UINT WINAPI SetErrorMode(IN UINT uMode)
Definition: except.c:749
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
UINT WINAPI GetDriveTypeW(IN LPCWSTR lpRootPathName)
Definition: disk.c:497
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:652
DWORD WINAPI GetFileAttributesA(LPCSTR lpFileName)
Definition: fileinfo.c:636
HANDLE WINAPI FindFirstFileW(IN LPCWSTR lpFileName, OUT LPWIN32_FIND_DATAW lpFindFileData)
Definition: find.c:320
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
DWORD WINAPI GetFullPathNameW(IN LPCWSTR lpFileName, IN DWORD nBufferLength, OUT LPWSTR lpBuffer, OUT LPWSTR *lpFilePart)
Definition: path.c:1106
DWORD WINAPI FormatMessageW(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPWSTR lpBuffer, DWORD nSize, __ms_va_list *args)
Definition: format_msg.c:583
DWORD WINAPI FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, __ms_va_list *args)
Definition: format_msg.c:483
static void basename(LPCWSTR path, LPWSTR name)
Definition: profile.c:38
HRESULT WINAPI OleFlushClipboard(void)
Definition: clipboard.c:2293
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
void WINAPI DECLSPEC_HOTPATCH CoFreeUnusedLibraries(void)
Definition: compobj.c:3701
HRESULT WINAPI CoInitialize(LPVOID lpReserved)
Definition: compobj.c:1964
void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
Definition: compobj.c:2067
HRESULT WINAPI DECLSPEC_HOTPATCH OleInitialize(LPVOID reserved)
Definition: ole2.c:169
HRESULT WINAPI RegisterDragDrop(HWND hwnd, LPDROPTARGET pDropTarget)
Definition: ole2.c:557
HRESULT WINAPI DoDragDrop(IDataObject *pDataObject, IDropSource *pDropSource, DWORD dwOKEffect, DWORD *pdwEffect)
Definition: ole2.c:753
HRESULT WINAPI RevokeDragDrop(HWND hwnd)
Definition: ole2.c:639
#define ShellMessageBoxW
Definition: precomp.h:59
HRESULT WINAPI SHGetMalloc(LPMALLOC *lpmal)
Definition: shellole.c:285
DWORD WINAPI SHCLSIDFromStringW(LPCWSTR clsid, CLSID *id)
Definition: shellole.c:256
HRESULT WINAPI SHGetSpecialFolderLocation(HWND hwndOwner, INT nFolder, LPITEMIDLIST *ppidl)
Definition: shellpath.c:3194
BOOL WINAPI SHGetSpecialFolderPathW(HWND hwndOwner, LPWSTR szPath, int nFolder, BOOL bCreate)
Definition: shellpath.c:3061
LPWSTR WINAPI PathAddBackslashW(LPWSTR lpszPath)
Definition: path.c:294
void WINAPI PathStripPathA(LPSTR lpszPath)
Definition: path.c:677
LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
Definition: path.c:394
LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
Definition: path.c:447
BOOL WINAPI PathAppendW(LPWSTR lpszPath, LPCWSTR lpszAppend)
Definition: path.c:126
BOOL WINAPI PathFileExistsW(LPCWSTR lpszPath)
Definition: path.c:1776
BOOL WINAPI PathAppendA(LPSTR lpszPath, LPCSTR lpszAppend)
Definition: path.c:106
BOOL WINAPI PathIsDirectoryW(LPCWSTR lpszPath)
Definition: path.c:1722
DWORD WINAPI SHDeleteKeyW(HKEY hKey, LPCWSTR lpszSubKey)
Definition: reg.c:1546
DWORD WINAPI SHGetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
Definition: reg.c:1236
DWORD WINAPI SHQueryValueExA(HKEY hKey, LPCSTR lpszValue, LPDWORD lpReserved, LPDWORD pwType, LPVOID pvData, LPDWORD pcbData)
Definition: reg.c:1402
HRESULT WINAPI SHStrDupW(LPCWSTR src, LPWSTR *dest)
Definition: string.c:2004
LPWSTR WINAPI StrCatBuffW(LPWSTR lpszStr, LPCWSTR lpszCat, INT cchMax)
Definition: string.c:1436
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define pt(x, y)
Definition: drawing.c:79
r parent
Definition: btrfs.c:3010
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
FxAutoRegKey hKey
WDF_INTERRUPT_POLICY policy
BOOLEAN valid
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
const GLdouble * v
Definition: gl.h:2040
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLint GLint GLint GLint GLint GLint y
Definition: gl.h:1548
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLsizei samples
Definition: glext.h:7006
GLuint res
Definition: glext.h:9613
GLenum src
Definition: glext.h:6340
GLuint buffer
Definition: glext.h:5915
GLenum GLenum dst
Definition: glext.h:6340
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
OPENFILENAME ofn
Definition: main.cpp:37
LPVOID NTAPI GlobalLock(HGLOBAL hMem)
Definition: heapmem.c:755
BOOL NTAPI GlobalUnlock(HGLOBAL hMem)
Definition: heapmem.c:1190
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1373
HGLOBAL NTAPI GlobalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:368
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
#define cs
Definition: i386-dis.c:443
BOOL SIC_Initialize(void)
Definition: iconcache.cpp:484
BOOL WINAPI Shell_GetImageLists(HIMAGELIST *lpBigList, HIMAGELIST *lpSmallList)
Definition: iconcache.cpp:700
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
REFIID riid
Definition: atlbase.h:39
REFIID LPVOID * ppv
Definition: atlbase.h:39
NTSYSAPI NTSTATUS WINAPI RtlGUIDFromString(PUNICODE_STRING, GUID *)
HRESULT ReplacePage([in] EXPPS uPageID, [in] LPFNSVADDPROPSHEETPAGE pfnReplaceWith, [in] LPARAM lParam)
HRESULT AddPages([in] LPFNSVADDPROPSHEETPAGE pfnAddPage, [in] LPARAM lParam)
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
ULONG Release()
nsresult QueryInterface(nsIIDRef riid, void **result)
nsrefcnt Release()
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define FAILED(hr)
Definition: intsafe.h:51
#define LOBYTE(W)
Definition: jmemdos.c:487
#define HIBYTE(W)
Definition: jmemdos.c:486
int const JOCTET unsigned int datalen
Definition: jpeglib.h:1031
#define debugstr_a
Definition: kernel32.h:31
#define debugstr_w
Definition: kernel32.h:32
HWND hList
Definition: livecd.c:10
unsigned int ULONG
Definition: retypes.h:1
int WINAPI lstrcmpiA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:42
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100
LPSTR WINAPI lstrcatA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:123
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
TCHAR szTitle[MAX_LOADSTRING]
Definition: magnifier.c:35
const GUID * guid
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
LPCWSTR szPath
Definition: env.c:37
static PVOID ptr
Definition: dispmode.c:27
static const WCHAR desc[]
Definition: protectdata.c:36
HRESULT hres
Definition: protocol.c:465
static HANDLE ULONG_PTR dwData
Definition: file.c:35
static HMODULE MODULEINFO DWORD cb
Definition: module.c:33
static HMODULE hmodule
Definition: rasapi.c:29
static const WCHAR invalid[]
Definition: assoc.c:39
#define _In_
Definition: ms_sal.h:308
#define _In_opt_
Definition: ms_sal.h:309
REFCLSID clsid
Definition: msctf.c:82
struct _PSP * HPROPSHEETPAGE
Definition: mstask.idl:90
__int3264 LONG_PTR
Definition: mstsclib_h.h:276
_In_ HANDLE hFile
Definition: mswsock.h:90
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:95
unsigned int UINT
Definition: ndis.h:50
_In_ ACCESS_MASK _In_ ULONG _Out_ PHANDLE TokenHandle
Definition: psfuncs.h:718
#define SEM_FAILCRITICALERRORS
Definition: rtltypes.h:69
static LPUNKNOWN
Definition: ndr_ole.c:49
#define BOOL
Definition: nt_native.h:43
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define KEY_READ
Definition: nt_native.h:1023
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define KEY_ENUMERATE_SUB_KEYS
Definition: nt_native.h:1019
#define KEY_WRITE
Definition: nt_native.h:1031
#define DWORD
Definition: nt_native.h:44
#define GENERIC_WRITE
Definition: nt_native.h:90
#define L(x)
Definition: ntvdm.h:50
interface IEnumFORMATETC * LPENUMFORMATETC
Definition: objfwd.h:24
interface IDataObject * LPDATAOBJECT
Definition: objfwd.h:21
const GUID IID_IEnumFORMATETC
const GUID IID_IPersistFile
#define LOWORD(l)
Definition: pedump.c:82
#define ES_READONLY
Definition: pedump.c:675
long LONG
Definition: pedump.c:60
BOOL WINAPI SHGetPathFromIDListA(LPCITEMIDLIST pidl, LPSTR pszPath)
Definition: pidl.c:1278
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1294
BOOL(CALLBACK * LPFNADDPROPSHEETPAGE)(HPROPSHEETPAGE, LPARAM)
Definition: prsht.h:327
#define REFIID
Definition: guiddef.h:118
#define strlenW(s)
Definition: unicode.h:28
#define strrchrW(s, c)
Definition: unicode.h:35
#define snprintfW
Definition: unicode.h:60
#define err(...)
#define WM_UNICHAR
Definition: richedit.h:67
const WCHAR * str
#define REG_DWORD
Definition: sdbapi.c:596
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
#define memset(x, y, z)
Definition: compat.h:39
#define args
Definition: format.c:66
static __inline BOOL SHELL_OsIsUnicode(void)
Definition: shell32_main.h:130
#define SHIL_SYSSMALL
Definition: shellapi.h:184
#define SHIL_SMALL
Definition: shellapi.h:182
_In_ LPCSTR pszDir
Definition: shellapi.h:581
#define SHIL_LARGE
Definition: shellapi.h:181
_In_ LPCSTR _Out_ BOOL * pfMustCopy
Definition: shellapi.h:583
#define SHGNLI_PIDL
Definition: shellapi.h:401
BOOL WINAPI SignalFileOpen(PCIDLIST_ABSOLUTE pidl)
Definition: shellord.c:626
struct _PSXA_CALL * PPSXA_CALL
HRESULT WINAPI SHLoadOLE(LPARAM lParam)
Definition: shellord.c:1726
static INT CALLBACK SHADD_compare_mru(LPCVOID data1, LPCVOID data2, DWORD cbData)
Definition: shellord.c:686
DWORD WINAPI DoEnvironmentSubstAW(LPVOID x, UINT y)
Definition: shellord.c:1891
static BOOL DoSanitizeText(LPWSTR pszSanitized, LPCWSTR pszInvalidChars, LPCWSTR pszValidChars)
Definition: shellord.c:2576
HRESULT WINAPI SHRegisterDragDrop(HWND hWnd, LPDROPTARGET pDropTarget)
Definition: shellord.c:540
WORD WINAPI ArrangeWindows(HWND hwndParent, DWORD dwReserved, const RECT *lpRect, WORD cKids, const HWND *lpKids)
Definition: shellord.c:610
DWORD WINAPI DoEnvironmentSubstW(LPWSTR pszString, UINT cchString)
Definition: shellord.c:1861
HRESULT WINAPI SHAbortInvokeCommand(void)
Definition: shellord.c:1753
BOOL WINAPI DAD_AutoScroll(HWND hwnd, AUTO_SCROLL_DATA *samples, const POINT *pt)
Definition: shellord.c:1550
void WINAPI SHUpdateImageW(LPCWSTR pszHashItem, int iIndex, UINT uFlags, int iImageIndex)
Definition: shellord.c:2253
void WINAPI SHAddToRecentDocs(UINT uFlags, LPCVOID pv)
Definition: shellord.c:809
HRESULT WINAPI SHStartNetConnectionDialog(HWND hwnd, LPCSTR pszRemoteName, DWORD dwType)
Definition: shellord.c:2349
int WINAPI InvalidateDriveType(int u)
Definition: shellord.c:1744
VOID WINAPI SHGetSettings(LPSHELLFLAGSTATE lpsfs, DWORD dwMask)
Definition: shellord.c:221
BOOL WINAPI RegisterShellHook(HWND hWnd, DWORD dwType)
Definition: shellord.c:311
BOOL WINAPI SHObjectProperties(HWND hwnd, DWORD dwType, LPCWSTR szObject, LPCWSTR szPage)
Definition: shellord.c:2275
#define MRUF_BINARY_LIST
Definition: shellord.c:65
void WINAPI SHFreeUnusedLibraries(void)
Definition: shellord.c:1541
static BOOL CALLBACK PsxaCall(HPROPSHEETPAGE hpage, LPARAM lParam)
Definition: shellord.c:1952
struct _PSXA PSXA
BOOL WINAPI DAD_DragEnter(HWND hwnd)
Definition: shellord.c:1559
#define MRUF_DELAYED_SAVE
Definition: shellord.c:66
INT WINAPI SHHandleUpdateImage(PCIDLIST_ABSOLUTE pidlExtra)
Definition: shellord.c:2268
void WINAPI SHDestroyPropSheetExtArray(HPSXA hpsxa)
Definition: shellord.c:2150
HRESULT WINAPI SHCreateStdEnumFmtEtc(UINT cFormats, const FORMATETC *lpFormats, LPENUMFORMATETC *ppenumFormatetc)
Definition: shellord.c:2199
EXTERN_C BOOL WINAPI SHTestTokenMembership(HANDLE TokenHandle, ULONG ulRID)
Definition: shellord.c:2488
BOOL WINAPI DAD_SetDragImage(HIMAGELIST himlTrack, LPPOINT lppt)
Definition: shellord.c:1597
INT WINAPI FindMRUData(HANDLE hList, LPCVOID lpData, DWORD cbData, LPINT lpRegNum)
struct _PSXA * PPSXA
HRESULT WINAPI SHGetImageList(int iImageList, REFIID riid, void **ppv)
Definition: shellord.c:2406
static void DoSanitizeClipboard(HWND hwnd, UxSubclassInfo *pInfo)
Definition: shellord.c:2609
HANDLE WINAPI CreateMRUListA(LPCREATEMRULISTA lpcml)
DWORD WINAPI ParseFieldAW(LPCVOID src, DWORD nField, LPVOID dst, DWORD len)
Definition: shellord.c:142
void WINAPI SHFlushSFCache(void)
Definition: shellord.c:2392
BOOL WINAPI LinkWindow_RegisterClass(void)
Definition: shellord.c:2368
BOOL WINAPI GUIDFromStringA(LPCSTR str, LPGUID guid)
Definition: shellord.c:1901
BOOL WINAPI PathIsTemporaryW(LPWSTR Str)
Definition: shellord.c:1930
struct tagCREATEMRULIST * LPCREATEMRULISTA
BOOL WINAPI GUIDFromStringW(LPCWSTR str, LPGUID guid)
Definition: shellord.c:1910
BOOL WINAPI LinkWindow_UnregisterClass(DWORD dwUnused)
Definition: shellord.c:2377
VOID WINAPI SHUpdateImageA(LPCSTR pszHashItem, INT iIndex, UINT uFlags, INT iImageIndex)
Definition: shellord.c:2263
HRESULT WINAPI SHWinHelp(HWND hwnd, LPCWSTR pszHelp, UINT uCommand, ULONG_PTR dwData)
Definition: shellord.c:1458
HPSXA WINAPI SHCreatePropSheetExtArrayEx(HKEY hKey, LPCWSTR pszSubKey, UINT max_iface, LPDATAOBJECT pDataObj)
Definition: shellord.c:2011
DWORD WINAPI ParseFieldW(LPCWSTR src, DWORD nField, LPWSTR dst, DWORD len)
Definition: shellord.c:116
static LRESULT CALLBACK LimitEditWindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
Definition: shellord.c:2653
BOOL WINAPI ReadCabinetState(CABINETSTATE *cs, int length)
Definition: shellord.c:1620
BOOL WINAPI FileIconInit(BOOL bFullInit)
Definition: shellord.c:1694
int ShellMessageBoxA(HINSTANCE hInstance, HWND hWnd, LPCSTR lpText, LPCSTR lpCaption, UINT uType,...)
Definition: shellord.c:427
BOOL WINAPI DAD_ShowDragImage(BOOL bShow)
Definition: shellord.c:1610
BOOL WINAPI DAD_DragEnterEx(HWND hwnd, POINT p)
Definition: shellord.c:1568
DWORD WINAPI RLBuildListOfPaths(void)
Definition: shellord.c:1797
VOID WINAPI FreeMRUList(HANDLE hMRUList)
BOOL WINAPI SHGetNewLinkInfoW(LPCWSTR pszLinkTo, LPCWSTR pszDir, LPWSTR pszName, BOOL *pfMustCopy, UINT uFlags)
Definition: shellord.c:2301
static INT SHADD_create_add_mru_data(HANDLE mruhandle, LPCSTR doc_name, LPCSTR new_lnk_name, LPSTR buffer, INT *len)
Definition: shellord.c:754
DWORD WINAPI DoEnvironmentSubstA(LPSTR pszString, UINT cchString)
Definition: shellord.c:1816
VOID WINAPI SHGetSetSettings(LPSHELLSTATE lpss, DWORD dwMask, BOOL bSet)
Definition: shellord.c:201
static INT SHADD_get_policy(LPCSTR policy, LPDWORD type, LPVOID buffer, LPDWORD len)
Definition: shellord.c:646
HRESULT WINAPI SetAppStartingCursor(HWND u, DWORD v)
Definition: shellord.c:1702
HRESULT WINAPI SHRevokeDragDrop(HWND hWnd)
Definition: shellord.c:575
BOOL WINAPI SHRunControlPanel(_In_ LPCWSTR commandLine, _In_opt_ HWND parent)
Definition: shellord.c:1475
HRESULT WINAPI SHLimitInputEdit(HWND hWnd, IShellFolder *psf)
Definition: shellord.c:2780
struct _PSXA_CALL PSXA_CALL
BOOL WINAPI SHValidateUNC(HWND hwndOwner, PWSTR pszFile, UINT fConnect)
Definition: shellord.c:1805
BOOL WINAPI SHWaitForFileToOpen(LPCITEMIDLIST pidl, DWORD dwFlags, DWORD dwTimeout)
Definition: shellord.c:1782
HRESULT WINAPI SHGetInstanceExplorer(IUnknown **lpUnknown)
Definition: shellord.c:1517
static UxSubclassInfo * UxSubclassInfo_Create(HWND hwnd, LPWSTR valid, LPWSTR invalid)
Definition: shellord.c:2746
INT WINAPI EnumMRUListA(HANDLE hList, INT nItemPos, LPVOID lpBuffer, DWORD nBufferSize)
UINT WINAPI SHReplaceFromPropSheetExtArray(HPSXA hpsxa, UINT uPageID, LPFNADDPROPSHEETPAGE lpfnReplaceWith, LPARAM lParam)
Definition: shellord.c:2119
BOOL WINAPI SHGetNewLinkInfoA(LPCSTR pszLinkTo, LPCSTR pszDir, LPSTR pszName, BOOL *pfMustCopy, UINT uFlags)
Definition: shellord.c:2282
BOOL WINAPI DAD_DragMove(POINT p)
Definition: shellord.c:1577
struct tagCREATEMRULIST CREATEMRULISTA
HRESULT WINAPI SHSetLocalizedName(LPCWSTR pszPath, LPCWSTR pszResModule, int idsRes)
Definition: shellord.c:2358
HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, IShellView **ppsv)
Definition: shellord.c:2454
VOID WINAPI SHSetInstanceExplorer(LPUNKNOWN lpUnknown)
Definition: shellord.c:1507
HRESULT WINAPI SHCreateShellFolderViewEx(LPCSFV psvcbi, IShellView **ppv)
Definition: shellord.c:1430
BOOL WINAPI SHFindFiles(PCIDLIST_ABSOLUTE pidlFolder, PCIDLIST_ABSOLUTE pidlSaveFile)
Definition: shellord.c:2222
LRESULT WINAPI SHShellFolderView_Message(HWND hwndCabinet, UINT uMessage, LPARAM lParam)
Definition: shellord.c:290
static void UxSubclassInfo_Destroy(UxSubclassInfo *pInfo)
Definition: shellord.c:2560
BOOL WINAPI GetFileNameFromBrowse(HWND hwndOwner, LPWSTR lpstrFile, UINT nMaxFile, LPCWSTR lpstrInitialDir, LPCWSTR lpstrDefExt, LPCWSTR lpstrFilter, LPCWSTR lpstrTitle)
Definition: shellord.c:153
HRESULT WINAPI CIDLData_CreateFromIDArray(PCIDLIST_ABSOLUTE pidlFolder, UINT cpidlFiles, PCUIDLIST_RELATIVE_ARRAY lppidlFiles, LPDATAOBJECT *ppdataObject)
Definition: shellord.c:2173
UINT WINAPI SHAddFromPropSheetExtArray(HPSXA hpsxa, LPFNADDPROPSHEETPAGE lpfnAddPage, LPARAM lParam)
Definition: shellord.c:1973
int WINAPI SHOutOfMemoryMessageBox(HWND hwndOwner, LPCSTR lpCaption, UINT uType)
Definition: shellord.c:1761
static LPUNKNOWN SHELL32_IExplorerInterface
Definition: shellord.c:1500
INT WINAPI AddMRUData(HANDLE hList, LPCVOID lpData, DWORD cbData)
BOOL WINAPI PathIsTemporaryA(LPSTR Str)
Definition: shellord.c:1921
HPSXA WINAPI SHCreatePropSheetExtArray(HKEY hKey, LPCWSTR pszSubKey, UINT max_iface)
Definition: shellord.c:2003
BOOL WINAPI WriteCabinetState(CABINETSTATE *cs)
Definition: shellord.c:1667
HRESULT WINAPI SHDoDragDrop(HWND hWnd, LPDATAOBJECT lpDataObject, LPDROPSOURCE lpDropSource, DWORD dwOKEffect, LPDWORD pdwEffect)
Definition: shellord.c:594
DWORD WINAPI ParseFieldA(LPCSTR src, DWORD nField, LPSTR dst, DWORD len)
Definition: shellord.c:82
HRESULT WINAPI SHFlushClipboard(void)
Definition: shellord.c:1773
HINSTANCE WINAPI ShellExecuteW(HWND hwnd, LPCWSTR lpVerb, LPCWSTR lpFile, LPCWSTR lpParameters, LPCWSTR lpDirectory, INT nShowCmd)
Definition: shlexec.cpp:2346
static IMalloc * ppM
Definition: shlfolder.c:47
HRESULT hr
Definition: shlfolder.c:183
#define CSIDL_RECENT
Definition: shlobj.h:2033
#define SSF_DONTPRETTYPATH
Definition: shlobj.h:1535
#define SSF_SHOWATTRIBCOL
Definition: shlobj.h:1532
#define SSF_SHOWSYSFILES
Definition: shlobj.h:1530
BOOL WINAPI IsUserAnAdmin(void)
Definition: shellord.c:2540
#define SHARD_PATHW
Definition: shlobj.h:1103
#define SHARD_PIDL
Definition: shlobj.h:1101
#define SSF_MAPNETDRVBUTTON
Definition: shlobj.h:1537
#define SSF_SHOWEXTENSIONS
Definition: shlobj.h:1528
#define SSF_SHOWALLOBJECTS
Definition: shlobj.h:1527
#define SHARD_PATHA
Definition: shlobj.h:1102
@ REST_NOFIND
Definition: shlobj.h:1569
BOOL WINAPI DAD_DragLeave(void)
Definition: shellord.c:1586
#define SSF_SHOWINFOTIP
Definition: shlobj.h:1536
#define SSF_HIDEICONS
Definition: shlobj.h:1539
DWORD WINAPI SHRestricted(RESTRICTIONS policy)
Definition: shpolicy.c:827
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
const PCUIDLIST_RELATIVE * PCUIDLIST_RELATIVE_ARRAY
Definition: shtypes.idl:58
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
#define TRACE(s)
Definition: solgame.cpp:4
BOOL fMapNetDrvBtn
Definition: shlobj.h:1517
BOOL fShowInfoTip
Definition: shlobj.h:1518
BOOL fHideIcons
Definition: shlobj.h:1520
BOOL fShowExtensions
Definition: shlobj.h:1506
BOOL fShowSysFiles
Definition: shlobj.h:1508
BOOL fDontPrettyPath
Definition: shlobj.h:1515
BOOL fShowAllObjects
Definition: shlobj.h:1505
BOOL fShowAttribCol
Definition: shlobj.h:1516
LPWSTR pwszValidChars
Definition: shellord.c:2555
LPWSTR pwszInvalidChars
Definition: shellord.c:2556
WNDPROC fnWndProc
Definition: shellord.c:2554
Definition: shlobj.h:1202
FOLDERVIEWMODE fvm
Definition: shlobj.h:1209
IShellView * psvOuter
Definition: shlobj.h:1205
LPFNVIEWCALLBACK pfnCallback
Definition: shlobj.h:1208
PCIDLIST_ABSOLUTE pidl
Definition: shlobj.h:1206
IShellFolder * pshf
Definition: shlobj.h:1204
LPFNADDPROPSHEETPAGE lpfnAddReplaceWith
Definition: shellord.c:1945
LPARAM lParam
Definition: shellord.c:1946
BOOL bCalled
Definition: shellord.c:1947
BOOL bMultiple
Definition: shellord.c:1948
UINT uiCount
Definition: shellord.c:1949
UINT uiCount
Definition: shellord.c:1938
IShellPropSheetExt * pspsx[1]
Definition: shellord.c:1940
UINT uiAllocated
Definition: shellord.c:1939
IShellFolderViewCB * psfvcb
Definition: shlobj.h:1285
IShellView * psvOuter
Definition: shlobj.h:1284
UINT cbSize
Definition: shlobj.h:1282
IShellFolder * pshf
Definition: shlobj.h:1283
Definition: match.c:390
Definition: cookie.c:202
Definition: tftpd.h:126
Definition: tftpd.h:138
LPCSTR lpszSubKey
Definition: shellord.c:59
DWORD nMaxItems
Definition: shellord.c:56
LPWSTR lpszSubKey
LPCSTR lpstrDefExt
Definition: commdlg.h:345
HWND hwndOwner
Definition: commdlg.h:330
LPCSTR lpstrTitle
Definition: commdlg.h:341
LPSTR lpstrFile
Definition: commdlg.h:336
DWORD Flags
Definition: commdlg.h:342
LPCSTR lpstrInitialDir
Definition: commdlg.h:340
DWORD lStructSize
Definition: commdlg.h:329
LPCSTR lpstrFilter
Definition: commdlg.h:332
DWORD nMaxFile
Definition: commdlg.h:337
#define GWLP_WNDPROC
Definition: treelist.c:66
HANDLE HINSTANCE
Definition: typedefs.h:77
uint16_t * PWSTR
Definition: typedefs.h:56
int32_t INT_PTR
Definition: typedefs.h:64
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:255
unsigned char * LPBYTE
Definition: typedefs.h:53
uint32_t * LPDWORD
Definition: typedefs.h:59
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG_PTR
Definition: typedefs.h:65
#define MAKELONG(a, b)
Definition: typedefs.h:249
#define MAXLONG
Definition: umtypes.h:116
HWND WINAPI SetTaskmanWindow(HWND)
Definition: window.c:1909
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
int ret
#define ZeroMemory
Definition: winbase.h:1670
DWORD WINAPI GetLastError(void)
Definition: except.c:1040
#define FORMAT_MESSAGE_FROM_STRING
Definition: winbase.h:421
#define CopyMemory
Definition: winbase.h:1668
#define FORMAT_MESSAGE_ALLOCATE_BUFFER
Definition: winbase.h:419
#define FindNextFile
Definition: winbase.h:3659
#define GMEM_MOVEABLE
Definition: winbase.h:294
#define GMEM_SHARE
Definition: winbase.h:305
#define LMEM_FIXED
Definition: winbase.h:368
_In_ DWORD _In_ DWORD _Out_writes_to_opt_ pcchString LPSTR pszString
Definition: wincrypt.h:4505
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
_In_ void _In_ PCCERT_CONTEXT _In_opt_ LPFILETIME _In_ DWORD _In_ DWORD dwTimeout
Definition: wincrypt.h:6081
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
LONG_PTR LPARAM
Definition: windef.h:208
#define __ms_va_list
Definition: windef.h:456
LONG_PTR LRESULT
Definition: windef.h:209
UINT_PTR WPARAM
Definition: windef.h:207
int * LPINT
Definition: windef.h:178
#define __ms_va_end(list)
Definition: windef.h:458
#define __ms_va_start(list, arg)
Definition: windef.h:457
CONST void * LPCVOID
Definition: windef.h:191
#define WINAPI
Definition: msvc.h:6
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define HKEY_CURRENT_USER
Definition: winreg.h:11
#define SW_SHOWNORMAL
Definition: winuser.h:764
BOOL WINAPI DeregisterShellHookWindow(_In_ HWND)
#define MB_SETFOREGROUND
Definition: winuser.h:808
#define GetWindowLongPtrW
Definition: winuser.h:4819
#define WM_PASTE
Definition: winuser.h:1853
HANDLE WINAPI RemovePropW(_In_ HWND, _In_ LPCWSTR)
LRESULT WINAPI DefWindowProcW(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
BOOL WINAPI RegisterShellHookWindow(_In_ HWND)
int WINAPI MessageBoxA(_In_opt_ HWND hWnd, _In_opt_ LPCSTR lpText, _In_opt_ LPCSTR lpCaption, _In_ UINT uType)
HANDLE WINAPI SetClipboardData(_In_ UINT, _In_opt_ HANDLE)
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
BOOL WINAPI CloseClipboard(void)
Definition: ntwrapper.h:178
BOOL WINAPI WinHelpW(_In_opt_ HWND, _In_opt_ LPCWSTR, _In_ UINT, _In_ ULONG_PTR)
#define VK_CONTROL
Definition: winuser.h:2193
BOOL WINAPI OpenClipboard(_In_opt_ HWND)
BOOL WINAPI MessageBeep(_In_ UINT uType)
int WINAPI LoadStringA(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPSTR lpBuffer, _In_ int cchBufferMax)
HANDLE WINAPI GetClipboardData(_In_ UINT)
int WINAPI MessageBoxW(_In_opt_ HWND hWnd, _In_opt_ LPCWSTR lpText, _In_opt_ LPCWSTR lpCaption, _In_ UINT uType)
int WINAPIV wsprintfA(_Out_ LPSTR, _In_ _Printf_format_string_ LPCSTR,...)
BOOL WINAPI IsWindowUnicode(_In_ HWND)
#define WM_IME_CHAR
Definition: winuser.h:1824
BOOL WINAPI SetPropW(_In_ HWND, _In_ LPCWSTR, _In_opt_ HANDLE)
#define WM_CHAR
Definition: winuser.h:1707
HANDLE WINAPI GetPropW(_In_ HWND, _In_ LPCWSTR)
#define WM_NCDESTROY
Definition: winuser.h:1674
#define MB_ICONSTOP
Definition: winuser.h:797
#define VK_SHIFT
Definition: winuser.h:2192
#define WM_KEYDOWN
Definition: winuser.h:1705
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
LRESULT(CALLBACK * WNDPROC)(HWND, UINT, WPARAM, LPARAM)
Definition: winuser.h:2896
#define SetWindowLongPtrW
Definition: winuser.h:5336
LRESULT WINAPI CallWindowProcW(_In_ WNDPROC, _In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
#define GWL_STYLE
Definition: winuser.h:846
#define VK_INSERT
Definition: winuser.h:2222
SHORT WINAPI GetKeyState(_In_ int)
#define SECURITY_BUILTIN_DOMAIN_RID
Definition: setypes.h:581
#define SECURITY_SERVICE_RID
Definition: setypes.h:562
#define SECURITY_LOCAL_SYSTEM_RID
Definition: setypes.h:574
#define SECURITY_NT_AUTHORITY
Definition: setypes.h:554
#define DOMAIN_ALIAS_RID_ADMINS
Definition: setypes.h:652
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
char CHAR
Definition: xmlstorage.h:175
unsigned char BYTE
Definition: xxhash.c:193