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