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