ReactOS 0.4.16-dev-424-ge4748fe
shell32_main.c
Go to the documentation of this file.
1/*
2 * Shell basics
3 *
4 * Copyright 1998 Marcus Meissner
5 * Copyright 1998 Juergen Schmied (jsch) * <juergen.schmied@metronet.de>
6 * Copyright 2017 Katayama Hirofumi MZ <katayama.hirofumi.mz@gmail.com>
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 <shellapi.h>
32#include <shlobj.h>
33#include <shlwapi.h>
34#include <strsafe.h>
35#include <winnls.h>
36
37#include "undocshell.h"
38#include "pidl.h"
39#include "shell32_main.h"
40#include "shresdef.h"
41
42#include <wine/debug.h>
43#include <wine/unicode.h>
44
45#include <reactos/version.h>
46#include <reactos/buildno.h>
47
49
50const char * const SHELL_Authors[] = { "Copyright 1993-"COPYRIGHT_YEAR" WINE team", "Copyright 1998-"COPYRIGHT_YEAR" ReactOS Team", 0 };
51
52/*************************************************************************
53 * CommandLineToArgvW [SHELL32.@]
54 *
55 * We must interpret the quotes in the command line to rebuild the argv
56 * array correctly:
57 * - arguments are separated by spaces or tabs
58 * - quotes serve as optional argument delimiters
59 * '"a b"' -> 'a b'
60 * - escaped quotes must be converted back to '"'
61 * '\"' -> '"'
62 * - consecutive backslashes preceding a quote see their number halved with
63 * the remainder escaping the quote:
64 * 2n backslashes + quote -> n backslashes + quote as an argument delimiter
65 * 2n+1 backslashes + quote -> n backslashes + literal quote
66 * - backslashes that are not followed by a quote are copied literally:
67 * 'a\b' -> 'a\b'
68 * 'a\\b' -> 'a\\b'
69 * - in quoted strings, consecutive quotes see their number divided by three
70 * with the remainder modulo 3 deciding whether to close the string or not.
71 * Note that the opening quote must be counted in the consecutive quotes,
72 * that's the (1+) below:
73 * (1+) 3n quotes -> n quotes
74 * (1+) 3n+1 quotes -> n quotes plus closes the quoted string
75 * (1+) 3n+2 quotes -> n+1 quotes plus closes the quoted string
76 * - in unquoted strings, the first quote opens the quoted string and the
77 * remaining consecutive quotes follow the above rule.
78 */
79LPWSTR* WINAPI CommandLineToArgvW(LPCWSTR lpCmdline, int* numargs)
80{
81 DWORD argc;
82 LPWSTR *argv;
83 LPCWSTR s;
84 LPWSTR d;
86 int qcount,bcount;
87
88 if(!numargs)
89 {
91 return NULL;
92 }
93
94 if (*lpCmdline==0)
95 {
96 /* Return the path to the executable */
97 DWORD len, deslen=MAX_PATH, size;
98
99 size = sizeof(LPWSTR)*2 + deslen*sizeof(WCHAR);
100 for (;;)
101 {
102 if (!(argv = LocalAlloc(LMEM_FIXED, size))) return NULL;
103 len = GetModuleFileNameW(0, (LPWSTR)(argv+2), deslen);
104 if (!len)
105 {
107 return NULL;
108 }
109 if (len < deslen) break;
110 deslen*=2;
111 size = sizeof(LPWSTR)*2 + deslen*sizeof(WCHAR);
112 LocalFree( argv );
113 }
114 argv[0]=(LPWSTR)(argv+2);
115 argv[1]=NULL;
116 *numargs=1;
117
118 return argv;
119 }
120
121 /* --- First count the arguments */
122 argc=1;
123 s=lpCmdline;
124 /* The first argument, the executable path, follows special rules */
125 if (*s=='"')
126 {
127 /* The executable path ends at the next quote, no matter what */
128 s++;
129 while (*s)
130 if (*s++=='"')
131 break;
132 }
133 else
134 {
135 /* The executable path ends at the next space, no matter what */
136 while (*s && !isspace(*s))
137 s++;
138 }
139 /* skip to the first argument, if any */
140 while (isblank(*s))
141 s++;
142 if (*s)
143 argc++;
144
145 /* Analyze the remaining arguments */
146 qcount=bcount=0;
147 while (*s)
148 {
149 if (isblank(*s) && qcount==0)
150 {
151 /* skip to the next argument and count it if any */
152 while (isblank(*s))
153 s++;
154 if (*s)
155 argc++;
156 bcount=0;
157 }
158 else if (*s=='\\')
159 {
160 /* '\', count them */
161 bcount++;
162 s++;
163 }
164 else if (*s=='"')
165 {
166 /* '"' */
167 if ((bcount & 1)==0)
168 qcount++; /* unescaped '"' */
169 s++;
170 bcount=0;
171 /* consecutive quotes, see comment in copying code below */
172 while (*s=='"')
173 {
174 qcount++;
175 s++;
176 }
177 qcount=qcount % 3;
178 if (qcount==2)
179 qcount=0;
180 }
181 else
182 {
183 /* a regular character */
184 bcount=0;
185 s++;
186 }
187 }
188
189 /* Allocate in a single lump, the string array, and the strings that go
190 * with it. This way the caller can make a single LocalFree() call to free
191 * both, as per MSDN.
192 */
193 argv=LocalAlloc(LMEM_FIXED, (argc+1)*sizeof(LPWSTR)+(strlenW(lpCmdline)+1)*sizeof(WCHAR));
194 if (!argv)
195 return NULL;
196 cmdline=(LPWSTR)(argv+argc+1);
197 strcpyW(cmdline, lpCmdline);
198
199 /* --- Then split and copy the arguments */
200 argv[0]=d=cmdline;
201 argc=1;
202 /* The first argument, the executable path, follows special rules */
203 if (*d=='"')
204 {
205 /* The executable path ends at the next quote, no matter what */
206 s=d+1;
207 while (*s)
208 {
209 if (*s=='"')
210 {
211 s++;
212 break;
213 }
214 *d++=*s++;
215 }
216 }
217 else
218 {
219 /* The executable path ends at the next space, no matter what */
220 while (*d && !isspace(*d))
221 d++;
222 s=d;
223 if (*s)
224 s++;
225 }
226 /* close the executable path */
227 *d++=0;
228 /* skip to the first argument and initialize it if any */
229 while (isblank(*s))
230 s++;
231
232 if (!*s)
233 {
234 /* There are no parameters so we are all done */
235 argv[argc]=NULL;
236 *numargs=argc;
237 return argv;
238 }
239
240 /* Split and copy the remaining arguments */
241 argv[argc++]=d;
242 qcount=bcount=0;
243 while (*s)
244 {
245 if (isblank(*s) && qcount==0)
246 {
247 /* close the argument */
248 *d++=0;
249 bcount=0;
250
251 /* skip to the next one and initialize it if any */
252 do {
253 s++;
254 } while (isblank(*s));
255 if (*s)
256 argv[argc++]=d;
257 }
258 else if (*s=='\\')
259 {
260 *d++=*s++;
261 bcount++;
262 }
263 else if (*s=='"')
264 {
265 if ((bcount & 1)==0)
266 {
267 /* Preceded by an even number of '\', this is half that
268 * number of '\', plus a quote which we erase.
269 */
270 d-=bcount/2;
271 qcount++;
272 }
273 else
274 {
275 /* Preceded by an odd number of '\', this is half that
276 * number of '\' followed by a '"'
277 */
278 d=d-bcount/2-1;
279 *d++='"';
280 }
281 s++;
282 bcount=0;
283 /* Now count the number of consecutive quotes. Note that qcount
284 * already takes into account the opening quote if any, as well as
285 * the quote that lead us here.
286 */
287 while (*s=='"')
288 {
289 if (++qcount==3)
290 {
291 *d++='"';
292 qcount=0;
293 }
294 s++;
295 }
296 if (qcount==2)
297 qcount=0;
298 }
299 else
300 {
301 /* a regular character */
302 *d++=*s++;
303 bcount=0;
304 }
305 }
306 *d='\0';
307 argv[argc]=NULL;
308 *numargs=argc;
309
310 return argv;
311}
312
314 UINT col, LPWSTR Buf, UINT cchBuf)
315{
316 IShellFolder2 *psf2;
317 IShellDetails *psd;
319 HRESULT hr = IShellFolder_QueryInterface(psf, &IID_IShellFolder2, (void**)&psf2);
320 if (SUCCEEDED(hr))
321 {
322 hr = IShellFolder2_GetDetailsOf(psf2, pidl, col, &details);
323 IShellFolder2_Release(psf2);
324 }
325 else if (SUCCEEDED(hr = IShellFolder_QueryInterface(psf, &IID_IShellDetails, (void**)&psd)))
326 {
327 hr = IShellDetails_GetDetailsOf(psd, pidl, col, &details);
329 }
330 if (SUCCEEDED(hr))
331 hr = StrRetToStrNW(Buf, cchBuf, &details.str, pidl) ? S_OK : E_FAIL;
332 return hr;
333}
334
336{
337 BOOL status = FALSE;
338 HANDLE hfile;
339 DWORD BinaryType;
340 IMAGE_DOS_HEADER mz_header;
342 DWORD len;
343 char magic[4];
344
345 status = GetBinaryTypeW (szFullPath, &BinaryType);
346 if (!status)
347 return 0;
348 if (BinaryType == SCS_DOS_BINARY || BinaryType == SCS_PIF_BINARY)
349 return 0x4d5a;
350
351 hfile = CreateFileW( szFullPath, GENERIC_READ, FILE_SHARE_READ,
352 NULL, OPEN_EXISTING, 0, 0 );
353 if ( hfile == INVALID_HANDLE_VALUE )
354 return 0;
355
356 /*
357 * The next section is adapted from MODULE_GetBinaryType, as we need
358 * to examine the image header to get OS and version information. We
359 * know from calling GetBinaryTypeA that the image is valid and either
360 * an NE or PE, so much error handling can be omitted.
361 * Seek to the start of the file and read the header information.
362 */
363
364 SetFilePointer( hfile, 0, NULL, SEEK_SET );
365 ReadFile( hfile, &mz_header, sizeof(mz_header), &len, NULL );
366
367 SetFilePointer( hfile, mz_header.e_lfanew, NULL, SEEK_SET );
368 ReadFile( hfile, magic, sizeof(magic), &len, NULL );
369 if ( *(DWORD*)magic == IMAGE_NT_SIGNATURE )
370 {
371 SetFilePointer( hfile, mz_header.e_lfanew, NULL, SEEK_SET );
372 ReadFile( hfile, &nt, sizeof(nt), &len, NULL );
373 CloseHandle( hfile );
374 /* DLL files are not executable and should return 0 */
376 return 0;
378 {
379 return IMAGE_NT_SIGNATURE |
382 }
383 return IMAGE_NT_SIGNATURE;
384 }
385 else if ( *(WORD*)magic == IMAGE_OS2_SIGNATURE )
386 {
388 SetFilePointer( hfile, mz_header.e_lfanew, NULL, SEEK_SET );
389 ReadFile( hfile, &ne, sizeof(ne), &len, NULL );
390 CloseHandle( hfile );
391 if (ne.ne_exetyp == 2)
392 return IMAGE_OS2_SIGNATURE | (ne.ne_expver << 16);
393 return 0;
394 }
395 CloseHandle( hfile );
396 return 0;
397}
398
399/*************************************************************************
400 * SHELL_IsShortcut [internal]
401 *
402 * Decide if an item id list points to a shell shortcut
403 */
405{
406 WCHAR szTemp[MAX_PATH];
407 HKEY keyCls;
408 BOOL ret = FALSE;
409
410 if (_ILGetExtension(pidlLast, szTemp, _countof(szTemp)) &&
412 {
413 ret = RegQueryValueExW(keyCls, L"IsShortcut", NULL, NULL, NULL, NULL) == ERROR_SUCCESS;
414 RegCloseKey(keyCls);
415 }
416 return ret;
417}
418
419#define SHGFI_KNOWN_FLAGS \
420 (SHGFI_SMALLICON | SHGFI_OPENICON | SHGFI_SHELLICONSIZE | SHGFI_PIDL | \
421 SHGFI_USEFILEATTRIBUTES | SHGFI_ADDOVERLAYS | SHGFI_OVERLAYINDEX | \
422 SHGFI_ICON | SHGFI_DISPLAYNAME | SHGFI_TYPENAME | SHGFI_ATTRIBUTES | \
423 SHGFI_ICONLOCATION | SHGFI_EXETYPE | SHGFI_SYSICONINDEX | \
424 SHGFI_LINKOVERLAY | SHGFI_SELECTED | SHGFI_ATTR_SPECIFIED)
425
426/*************************************************************************
427 * SHGetFileInfoW [SHELL32.@]
428 *
429 */
431 SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags )
432{
433 WCHAR szLocation[MAX_PATH], szFullPath[MAX_PATH];
434 int iIndex;
437 IShellFolder * psfParent = NULL;
438 IExtractIconW * pei = NULL;
439 LPITEMIDLIST pidlLast = NULL, pidl = NULL, pidlFree = NULL;
440 HRESULT hr = S_OK;
441 BOOL IconNotYetLoaded=TRUE;
442 UINT uGilFlags = 0;
443 HIMAGELIST big_icons, small_icons;
444
445 TRACE("%s fattr=0x%x sfi=%p(attr=0x%08x) size=0x%x flags=0x%x\n",
447 psfi, psfi ? psfi->dwAttributes : 0, sizeofpsfi, flags);
448
449 if (!path)
450 return FALSE;
451
452 /* windows initializes these values regardless of the flags */
453 if (psfi != NULL)
454 {
455 psfi->szDisplayName[0] = '\0';
456 psfi->szTypeName[0] = '\0';
457 psfi->hIcon = NULL;
458 }
459
460 if (!(flags & SHGFI_PIDL))
461 {
462 /* SHGetFileInfo should work with absolute and relative paths */
464 {
465 GetCurrentDirectoryW(MAX_PATH, szLocation);
466 PathCombineW(szFullPath, szLocation, path);
467 }
468 else
469 {
470 lstrcpynW(szFullPath, path, MAX_PATH);
471 }
472
473 if ((flags & SHGFI_TYPENAME) && !PathIsRootW(szFullPath))
474 {
475 HRESULT hr2;
477 {
481 }
484 else
486 if (SUCCEEDED(hr2))
487 {
488 flags &= ~SHGFI_TYPENAME;
490 return ret; /* Bail out early if this was our only operation */
491 }
492 }
493 }
494 else
495 {
497 }
498
499 if (flags & SHGFI_EXETYPE)
500 {
501 if (!(flags & SHGFI_SYSICONINDEX))
502 {
504 {
505 return TRUE;
506 }
507 else if (GetFileAttributesW(szFullPath) != INVALID_FILE_ATTRIBUTES)
508 {
509 return shgfi_get_exe_type(szFullPath);
510 }
511 }
512 }
513
514 /*
515 * psfi is NULL normally to query EXE type. If it is NULL, none of the
516 * below makes sense anyway. Windows allows this and just returns FALSE
517 */
518 if (psfi == NULL)
519 return FALSE;
520
521 /*
522 * translate the path into a pidl only when SHGFI_USEFILEATTRIBUTES
523 * is not specified.
524 * The pidl functions fail on not existing file names
525 */
526
527 if (flags & SHGFI_PIDL)
528 {
529 pidl = (LPITEMIDLIST)path;
530 hr = pidl ? S_OK : E_FAIL;
531 }
532 else
533 {
535 {
537 hr = pidl ? S_OK : E_FAIL;
538 }
539 else
540 {
541 hr = SHILCreateFromPathW(szFullPath, &pidl, &dwAttributes);
542 }
543 pidlFree = pidl;
544 }
545
546 if (SUCCEEDED(hr))
547 {
548 hr = SHBindToParent(pidl, &IID_IShellFolder, (void**)&psfParent, (LPCITEMIDLIST*)&pidlLast);
549 }
550
551 /* get the attributes of the child */
553 {
555 {
556 psfi->dwAttributes = 0xffffffff;
557 }
558 hr = IShellFolder_GetAttributesOf(psfParent, 1, (LPCITEMIDLIST*)&pidlLast, &psfi->dwAttributes);
559 }
560
562 {
563 if (flags & SHGFI_ICON)
564 {
565 psfi->dwAttributes = 0;
566 }
567 }
568
569 /* get the displayname */
571 {
572 STRRET str;
573 psfi->szDisplayName[0] = UNICODE_NULL;
574 hr = IShellFolder_GetDisplayNameOf(psfParent, pidlLast, SHGDN_INFOLDER, &str);
575 if (SUCCEEDED(hr))
576 StrRetToStrNW(psfi->szDisplayName, _countof(psfi->szDisplayName), &str, pidlLast);
577 }
578
579 /* get the type name */
580 if (SUCCEEDED(hr) && (flags & SHGFI_TYPENAME))
581 {
582 /* FIXME: Use IShellFolder2::GetDetailsEx */
583 UINT col = _ILIsDrive(pidlLast) ? 1 : 2; /* SHFSF_COL_TYPE */
584 psfi->szTypeName[0] = UNICODE_NULL;
585 hr = SHELL_GetDetailsOfToBuffer(psfParent, pidlLast, col, psfi->szTypeName, _countof(psfi->szTypeName));
586 }
587
588 /* ### icons ###*/
589
590 Shell_GetImageLists( &big_icons, &small_icons );
591
592 if (flags & SHGFI_OPENICON)
593 uGilFlags |= GIL_OPENICON;
594
596 uGilFlags |= GIL_FORSHORTCUT;
597 else if ((flags&SHGFI_ADDOVERLAYS) ||
599 {
600 if (SHELL_IsShortcut(pidlLast))
601 uGilFlags |= GIL_FORSHORTCUT;
602 }
603
605 FIXME("SHGFI_OVERLAYINDEX unhandled\n");
606
607 if (flags & SHGFI_SELECTED)
608 FIXME("set icon to selected, stub\n");
609
611 FIXME("set icon to shell size, stub\n");
612
613 /* get the iconlocation */
615 {
616 UINT uDummy,uFlags;
617
619 {
621 {
623 psfi->iIcon = -IDI_SHELL_FOLDER;
624 }
625 else
626 {
627 WCHAR* szExt;
628 WCHAR sTemp [MAX_PATH];
629
630 szExt = PathFindExtensionW(szFullPath);
631 TRACE("szExt=%s\n", debugstr_w(szExt));
632 if ( szExt &&
633 HCR_MapTypeToValueW(szExt, sTemp, MAX_PATH, TRUE) &&
634 HCR_GetIconW(sTemp, sTemp, NULL, MAX_PATH, &psfi->iIcon))
635 {
636 if (lstrcmpW(L"%1", sTemp))
637 strcpyW(psfi->szDisplayName, sTemp);
638 else
639 {
640 /* the icon is in the file */
641 strcpyW(psfi->szDisplayName, szFullPath);
642 }
643 }
644 else
645 ret = FALSE;
646 }
647 }
648 else if (psfParent)
649 {
650 hr = IShellFolder_GetUIObjectOf(psfParent, 0, 1,
651 (LPCITEMIDLIST*)&pidlLast, &IID_IExtractIconW,
652 &uDummy, (LPVOID*)&pei);
653 if (SUCCEEDED(hr))
654 {
655 hr = IExtractIconW_GetIconLocation(pei, uGilFlags,
656 szLocation, MAX_PATH, &iIndex, &uFlags);
657
658 if (uFlags & GIL_NOTFILENAME)
659 ret = FALSE;
660 else
661 {
662 lstrcpyW (psfi->szDisplayName, szLocation);
663 psfi->iIcon = iIndex;
664 }
665 IExtractIconW_Release(pei);
666 }
667 }
668 }
669
670 /* get icon index (or load icon)*/
672 {
674 {
675 WCHAR sTemp [MAX_PATH];
676 WCHAR * szExt;
677 int icon_idx=0;
678
679 lstrcpynW(sTemp, szFullPath, MAX_PATH);
680
683 else
684 {
685 psfi->iIcon = 0;
686 szExt = PathFindExtensionW(sTemp);
687 if ( szExt &&
688 HCR_MapTypeToValueW(szExt, sTemp, MAX_PATH, TRUE) &&
689 HCR_GetIconW(sTemp, sTemp, NULL, MAX_PATH, &icon_idx))
690 {
691 if (!lstrcmpW(L"%1",sTemp)) /* icon is in the file */
692 strcpyW(sTemp, szFullPath);
693
695 {
696 psfi->iIcon = SIC_GetIconIndex(sTemp,icon_idx,0);
697 if (psfi->iIcon == -1)
698 psfi->iIcon = 0;
699 }
700 else
701 {
702 UINT ret;
704 ret = PrivateExtractIconsW( sTemp,icon_idx,
707 &psfi->hIcon, 0, 1, 0);
708 else
709 ret = PrivateExtractIconsW( sTemp, icon_idx,
712 &psfi->hIcon, 0, 1, 0);
713 if (ret != 0 && ret != (UINT)-1)
714 {
715 IconNotYetLoaded=FALSE;
716 psfi->iIcon = icon_idx;
717 }
718 }
719 }
720 }
721 }
722 else if (psfParent)
723 {
724 if (!(PidlToSicIndex(psfParent, pidlLast, !(flags & SHGFI_SMALLICON),
725 uGilFlags, &(psfi->iIcon))))
726 {
727 ret = FALSE;
728 }
729 }
730 if (ret && (flags & SHGFI_SYSICONINDEX))
731 {
733 ret = (DWORD_PTR)small_icons;
734 else
735 ret = (DWORD_PTR)big_icons;
736 }
737 }
738
739 /* icon handle */
740 if (SUCCEEDED(hr) && (flags & SHGFI_ICON) && IconNotYetLoaded)
741 {
743 psfi->hIcon = ImageList_GetIcon( small_icons, psfi->iIcon, ILD_NORMAL);
744 else
745 psfi->hIcon = ImageList_GetIcon( big_icons, psfi->iIcon, ILD_NORMAL);
746 }
747
749 FIXME("unknown flags %08x\n", flags & ~SHGFI_KNOWN_FLAGS);
750
751 if (psfParent)
752 IShellFolder_Release(psfParent);
753 SHFree(pidlFree);
754
755 if (hr != S_OK)
756 ret = FALSE;
757
758 TRACE ("icon=%p index=0x%08x attr=0x%08x name=%s type=%s ret=0x%08lx\n",
759 psfi->hIcon, psfi->iIcon, psfi->dwAttributes,
761
762 return ret;
763}
764
765/*************************************************************************
766 * SHGetFileInfoA [SHELL32.@]
767 *
768 * Note:
769 * MSVBVM60.__vbaNew2 expects this function to return a value in range
770 * 1 .. 0x7fff when the function succeeds and flags does not contain
771 * SHGFI_EXETYPE or SHGFI_SYSICONINDEX (see bug 7701)
772 */
774 SHFILEINFOA *psfi, UINT sizeofpsfi,
775 UINT flags )
776{
777 INT len;
778 LPWSTR temppath = NULL;
779 LPCWSTR pathW;
781 SHFILEINFOW temppsfi;
782
783 if (flags & SHGFI_PIDL)
784 {
785 /* path contains a pidl */
786 pathW = (LPCWSTR)path;
787 }
788 else
789 {
790 len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0);
791 temppath = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
792 MultiByteToWideChar(CP_ACP, 0, path, -1, temppath, len);
793 pathW = temppath;
794 }
795
796 if (psfi)
797 {
798 temppsfi.hIcon = psfi->hIcon;
799 temppsfi.iIcon = psfi->iIcon;
800 temppsfi.dwAttributes = psfi->dwAttributes;
801
802 ret = SHGetFileInfoW(pathW, dwFileAttributes, &temppsfi, sizeof(temppsfi), flags);
803 psfi->hIcon = temppsfi.hIcon;
804 psfi->iIcon = temppsfi.iIcon;
805 psfi->dwAttributes = temppsfi.dwAttributes;
806
808 psfi->szDisplayName, sizeof(psfi->szDisplayName), NULL, NULL);
809
810 WideCharToMultiByte(CP_ACP, 0, temppsfi.szTypeName, -1,
811 psfi->szTypeName, sizeof(psfi->szTypeName), NULL, NULL);
812 }
813 else
815
816 HeapFree(GetProcessHeap(), 0, temppath);
817
818 return ret;
819}
820
821/*************************************************************************
822 * DuplicateIcon [SHELL32.@]
823 */
825{
827 HICON hDupIcon = 0;
828
829 TRACE("%p %p\n", hInstance, hIcon);
830
832 {
833 hDupIcon = CreateIconIndirect(&IconInfo);
834
835 /* clean up hbmMask and hbmColor */
838 }
839
840 return hDupIcon;
841}
842
843/*************************************************************************
844 * ExtractIconA [SHELL32.@]
845 */
847{
848 HICON ret;
849 INT len = MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, NULL, 0);
850 LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
851
852 TRACE("%p %s %d\n", hInstance, lpszFile, nIconIndex);
853
854 MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, lpwstrFile, len);
855 ret = ExtractIconW(hInstance, lpwstrFile, nIconIndex);
856 HeapFree(GetProcessHeap(), 0, lpwstrFile);
857
858 return ret;
859}
860
861/*************************************************************************
862 * ExtractIconW [SHELL32.@]
863 */
865{
866 HICON hIcon = NULL;
867 UINT ret;
869
870 TRACE("%p %s %d\n", hInstance, debugstr_w(lpszFile), nIconIndex);
871
872 if (nIconIndex == (UINT)-1)
873 {
874 ret = PrivateExtractIconsW(lpszFile, 0, cx, cy, NULL, NULL, 0, LR_DEFAULTCOLOR);
875 if (ret != (UINT)-1 && ret)
876 return (HICON)(UINT_PTR)ret;
877 return NULL;
878 }
879 else
880 ret = PrivateExtractIconsW(lpszFile, nIconIndex, cx, cy, &hIcon, NULL, 1, LR_DEFAULTCOLOR);
881
882 if (ret == (UINT)-1)
883 return (HICON)1;
884 else if (ret > 0 && hIcon)
885 return hIcon;
886
887 return NULL;
888}
889
890/*************************************************************************
891 * Printer_LoadIconsW [SHELL32.205]
892 */
893VOID WINAPI Printer_LoadIconsW(LPCWSTR wsPrinterName, HICON * pLargeIcon, HICON * pSmallIcon)
894{
896
897 TRACE("(%s, %p, %p)\n", debugstr_w(wsPrinterName), pLargeIcon, pSmallIcon);
898
899 /* We should check if wsPrinterName is
900 1. the Default Printer or not
901 2. connected or not
902 3. a Local Printer or a Network-Printer
903 and use different Icons
904 */
905 if((wsPrinterName != NULL) && (wsPrinterName[0] != 0))
906 {
907 FIXME("(select Icon by PrinterName %s not implemented)\n", debugstr_w(wsPrinterName));
908 }
909
910 if(pLargeIcon != NULL)
911 *pLargeIcon = LoadImageW(shell32_hInstance,
912 (LPCWSTR) MAKEINTRESOURCE(iconindex), IMAGE_ICON,
914
915 if(pSmallIcon != NULL)
916 *pSmallIcon = LoadImageW(shell32_hInstance,
917 (LPCWSTR) MAKEINTRESOURCE(iconindex), IMAGE_ICON,
918 16, 16, LR_DEFAULTCOLOR);
919}
920
921/*************************************************************************
922 * Printers_RegisterWindowW [SHELL32.213]
923 * used by "printui.dll":
924 * find the Window of the given Type for the specific Printer and
925 * return the already existent hwnd or open a new window
926 */
928 HANDLE * phClassPidl, HWND * phwnd)
929{
930 FIXME("(%s, %x, %p (%p), %p (%p)) stub!\n", debugstr_w(wsPrinter), dwType,
931 phClassPidl, (phClassPidl != NULL) ? *(phClassPidl) : NULL,
932 phwnd, (phwnd != NULL) ? *(phwnd) : NULL);
933
934 return FALSE;
935}
936
937/*************************************************************************
938 * Printers_UnregisterWindow [SHELL32.214]
939 */
941{
942 FIXME("(%p, %p) stub!\n", hClassPidl, hwnd);
943}
944
945/*************************************************************************/
946
947typedef struct
948{
950#ifdef __REACTOS__
951 LPCWSTR szOSVersion;
952#endif
955} ABOUT_INFO;
956
957/*************************************************************************
958 * SHHelpShortcuts_RunDLLA [SHELL32.@]
959 *
960 */
962{
963 FIXME("(%x, %x, %x, %x) stub!\n", dwArg1, dwArg2, dwArg3, dwArg4);
964 return 0;
965}
966
967/*************************************************************************
968 * SHHelpShortcuts_RunDLLA [SHELL32.@]
969 *
970 */
972{
973 FIXME("(%x, %x, %x, %x) stub!\n", dwArg1, dwArg2, dwArg3, dwArg4);
974 return 0;
975}
976
977/*************************************************************************
978 * SHLoadInProc [SHELL32.@]
979 * Create an instance of specified object class from within
980 * the shell process and release it immediately
981 */
983{
984 void *ptr = NULL;
985
986 TRACE("%s\n", debugstr_guid(rclsid));
987
988 CoCreateInstance(rclsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown,&ptr);
989 if(ptr)
990 {
991 IUnknown * pUnk = ptr;
992 IUnknown_Release(pUnk);
993 return S_OK;
994 }
996}
997
999{
1000 DWORD dwBufferSize;
1001 DWORD dwType;
1003
1004 if( RegQueryValueExW(hKey, Value, NULL, &dwType, NULL, &dwBufferSize) == ERROR_SUCCESS )
1005 {
1006 if(dwType == REG_SZ)
1007 {
1008 lpBuffer = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, dwBufferSize);
1009
1010 if(lpBuffer)
1011 {
1012 if( RegQueryValueExW(hKey, Value, NULL, &dwType, (LPBYTE)lpBuffer, &dwBufferSize) == ERROR_SUCCESS )
1013 {
1015 }
1016
1018 }
1019 }
1020 }
1021}
1022
1024{
1025 switch(msg)
1026 {
1027 case WM_INITDIALOG:
1028 {
1029 const char* const *pstr = SHELL_Authors;
1030
1031 // Add the authors to the list
1033
1034 while (*pstr)
1035 {
1036 WCHAR name[64];
1037
1038 /* authors list is in utf-8 format */
1039 MultiByteToWideChar( CP_UTF8, 0, *pstr, -1, name, sizeof(name)/sizeof(WCHAR) );
1041 pstr++;
1042 }
1043
1045
1046 return TRUE;
1047 }
1048 }
1049
1050 return FALSE;
1051}
1052/*************************************************************************
1053 * AboutDlgProc (internal)
1054 */
1056{
1057#ifdef __REACTOS__
1058
1059 static DWORD cxLogoBmp;
1060 static DWORD cyLogoBmp, cyLineBmp;
1061 static HBITMAP hLogoBmp, hLineBmp;
1062 static HWND hWndAuthors;
1063
1064 switch (msg)
1065 {
1066 case WM_INITDIALOG:
1067 {
1069
1070 if (info)
1071 {
1072 HKEY hRegKey;
1073 MEMORYSTATUSEX MemStat;
1074 WCHAR szAppTitle[512];
1075 WCHAR szAppTitleTemplate[512];
1076 WCHAR szAuthorsText[20];
1077
1078 // Preload the ROS bitmap
1081
1082 if (hLogoBmp && hLineBmp)
1083 {
1084 BITMAP bmpLogo;
1085
1086 GetObject(hLogoBmp, sizeof(BITMAP), &bmpLogo);
1087
1088 cxLogoBmp = bmpLogo.bmWidth;
1089 cyLogoBmp = bmpLogo.bmHeight;
1090
1091 GetObject(hLineBmp, sizeof(BITMAP), &bmpLogo);
1092 cyLineBmp = bmpLogo.bmHeight;
1093 }
1094
1095 // Set App-specific stuff (icon, app name, szOtherStuff string)
1097
1098 GetWindowTextW(hWnd, szAppTitleTemplate, ARRAY_SIZE(szAppTitleTemplate));
1099 swprintf(szAppTitle, szAppTitleTemplate, info->szApp);
1101
1105
1106 // Set the registered user and organization name
1107 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
1108 0, KEY_QUERY_VALUE, &hRegKey) == ERROR_SUCCESS)
1109 {
1110 SetRegTextData(hWnd, hRegKey, L"RegisteredOwner", IDC_ABOUT_REG_USERNAME);
1111 SetRegTextData(hWnd, hRegKey, L"RegisteredOrganization", IDC_ABOUT_REG_ORGNAME);
1112
1115 {
1117 }
1118
1119 RegCloseKey(hRegKey);
1120 }
1121
1122 // Set the value for the installed physical memory
1123 MemStat.dwLength = sizeof(MemStat);
1124 if (GlobalMemoryStatusEx(&MemStat))
1125 {
1126 WCHAR szBuf[12];
1127
1128 if (MemStat.ullTotalPhys > 1024 * 1024 * 1024)
1129 {
1130 double dTotalPhys;
1131 WCHAR szDecimalSeparator[4];
1132 WCHAR szUnits[3];
1133
1134 // We're dealing with GBs or more
1135 MemStat.ullTotalPhys /= 1024 * 1024;
1136
1137 if (MemStat.ullTotalPhys > 1024 * 1024)
1138 {
1139 // We're dealing with TBs or more
1140 MemStat.ullTotalPhys /= 1024;
1141
1142 if (MemStat.ullTotalPhys > 1024 * 1024)
1143 {
1144 // We're dealing with PBs or more
1145 MemStat.ullTotalPhys /= 1024;
1146
1147 dTotalPhys = (double)MemStat.ullTotalPhys / 1024;
1148 wcscpy(szUnits, L"PB");
1149 }
1150 else
1151 {
1152 dTotalPhys = (double)MemStat.ullTotalPhys / 1024;
1153 wcscpy(szUnits, L"TB");
1154 }
1155 }
1156 else
1157 {
1158 dTotalPhys = (double)MemStat.ullTotalPhys / 1024;
1159 wcscpy(szUnits, L"GB");
1160 }
1161
1162 // We need the decimal point of the current locale to display the RAM size correctly
1164 szDecimalSeparator,
1165 ARRAY_SIZE(szDecimalSeparator)) > 0)
1166 {
1167 UCHAR uDecimals;
1168 UINT uIntegral;
1169
1170 uIntegral = (UINT)dTotalPhys;
1171 uDecimals = (UCHAR)((UINT)(dTotalPhys * 100) - uIntegral * 100);
1172
1173 // Display the RAM size with 2 decimals
1174 swprintf(szBuf, L"%u%s%02u %s", uIntegral, szDecimalSeparator, uDecimals, szUnits);
1175 }
1176 }
1177 else
1178 {
1179 // We're dealing with MBs, don't show any decimals
1180 swprintf(szBuf, L"%u MB", (UINT)MemStat.ullTotalPhys / 1024 / 1024);
1181 }
1182
1184 }
1185
1186 // Add the Authors dialog
1188 LoadStringW(shell32_hInstance, IDS_SHELL_ABOUT_AUTHORS, szAuthorsText, ARRAY_SIZE(szAuthorsText));
1189 SetDlgItemTextW(hWnd, IDC_ABOUT_AUTHORS, szAuthorsText);
1190 }
1191
1192 return TRUE;
1193 }
1194
1195 case WM_PAINT:
1196 {
1197 if (hLogoBmp && hLineBmp)
1198 {
1199 PAINTSTRUCT ps;
1200 HDC hdc;
1201 HDC hdcMem;
1202 HGDIOBJ hOldObj;
1203
1204 hdc = BeginPaint(hWnd, &ps);
1206
1207 if (hdcMem)
1208 {
1209 hOldObj = SelectObject(hdcMem, hLogoBmp);
1210 BitBlt(hdc, 0, 0, cxLogoBmp, cyLogoBmp, hdcMem, 0, 0, SRCCOPY);
1211
1212 SelectObject(hdcMem, hLineBmp);
1213 BitBlt(hdc, 0, cyLogoBmp, cxLogoBmp, cyLineBmp, hdcMem, 0, 0, SRCCOPY);
1214
1215 SelectObject(hdcMem, hOldObj);
1217 }
1218
1219 EndPaint(hWnd, &ps);
1220 }
1221 break;
1222 }
1223
1224 case WM_COMMAND:
1225 {
1226 switch(wParam)
1227 {
1228 case IDOK:
1229 case IDCANCEL:
1231 return TRUE;
1232
1233 case IDC_ABOUT_AUTHORS:
1234 {
1235 static BOOL bShowingAuthors = FALSE;
1236 WCHAR szAuthorsText[20];
1237
1238 if (bShowingAuthors)
1239 {
1240 LoadStringW(shell32_hInstance, IDS_SHELL_ABOUT_AUTHORS, szAuthorsText, ARRAY_SIZE(szAuthorsText));
1241 ShowWindow(hWndAuthors, SW_HIDE);
1242 }
1243 else
1244 {
1245 LoadStringW(shell32_hInstance, IDS_SHELL_ABOUT_BACK, szAuthorsText, ARRAY_SIZE(szAuthorsText));
1246 ShowWindow(hWndAuthors, SW_SHOW);
1247 }
1248
1249 SetDlgItemTextW(hWnd, IDC_ABOUT_AUTHORS, szAuthorsText);
1250 bShowingAuthors = !bShowingAuthors;
1251 return TRUE;
1252 }
1253 }
1254 break;
1255 }
1256
1257 case WM_CLOSE:
1259 break;
1260 }
1261
1262#endif // __REACTOS__
1263
1264 return 0;
1265}
1266
1267
1268/*************************************************************************
1269 * ShellAboutA [SHELL32.288]
1270 */
1272{
1273 BOOL ret;
1274 LPWSTR appW = NULL, otherW = NULL;
1275 int len;
1276
1277 if (szApp)
1278 {
1279 len = MultiByteToWideChar(CP_ACP, 0, szApp, -1, NULL, 0);
1280 appW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1281 MultiByteToWideChar(CP_ACP, 0, szApp, -1, appW, len);
1282 }
1283 if (szOtherStuff)
1284 {
1285 len = MultiByteToWideChar(CP_ACP, 0, szOtherStuff, -1, NULL, 0);
1286 otherW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1287 MultiByteToWideChar(CP_ACP, 0, szOtherStuff, -1, otherW, len);
1288 }
1289
1290 ret = ShellAboutW(hWnd, appW, otherW, hIcon);
1291
1292 HeapFree(GetProcessHeap(), 0, otherW);
1293 HeapFree(GetProcessHeap(), 0, appW);
1294 return ret;
1295}
1296
1297
1298/*************************************************************************
1299 * ShellAboutW [SHELL32.289]
1300 */
1302 HICON hIcon )
1303{
1305 HRSRC hRes;
1306 DLGTEMPLATE *DlgTemplate;
1307 BOOL bRet;
1308#ifdef __REACTOS__
1309 WCHAR szVersionString[256];
1310 WCHAR szFormat[256];
1311#endif
1312
1313 TRACE("\n");
1314
1315 // DialogBoxIndirectParamW will be called with the hInstance of the calling application, so we have to preload the dialog template
1317 if(!hRes)
1318 return FALSE;
1319
1320 DlgTemplate = (DLGTEMPLATE *)LoadResource(shell32_hInstance, hRes);
1321 if(!DlgTemplate)
1322 return FALSE;
1323
1324#ifdef __REACTOS__
1325 /* Output the version OS kernel strings */
1327 StringCchPrintfW(szVersionString, _countof(szVersionString), szFormat, KERNEL_VERSION_STR, KERNEL_VERSION_BUILD_STR);
1328#endif
1329
1330 info.szApp = szApp;
1331#ifdef __REACTOS__
1332 info.szOSVersion = szVersionString;
1333#endif
1334 info.szOtherStuff = szOtherStuff;
1335 info.hIcon = hIcon ? hIcon : LoadIconW( 0, (LPWSTR)IDI_WINLOGO );
1336
1338 DlgTemplate, hWnd, AboutDlgProc, (LPARAM)&info );
1339 return bRet;
1340}
1341
1342/*************************************************************************
1343 * FreeIconList (SHELL32.@)
1344 */
1346{
1347 FIXME("%x: stub\n",dw);
1348}
1349
1350/*************************************************************************
1351 * SHLoadNonloadedIconOverlayIdentifiers (SHELL32.@)
1352 */
1354{
1355 FIXME("stub\n");
1356 return S_OK;
1357}
EXTERN_C HRESULT SHELL32_AssocGetFileDescription(PCWSTR Name, PWSTR Buf, UINT cchBuf)
EXTERN_C HRESULT SHELL32_AssocGetFSDirectoryDescription(PWSTR Buf, UINT cchBuf)
DWORD dwFileAttributes
static int argc
Definition: ServiceArgs.c:12
#define shell32_hInstance
#define isspace(c)
Definition: acclib.h:69
#define msg(x)
Definition: auth_time.c:54
HWND hWnd
Definition: settings.c:17
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
void shell(int argc, const char *argv[])
Definition: cmds.c:1231
#define ARRAY_SIZE(A)
Definition: main.h:20
#define IDI_SHELL_FOLDER
Definition: treeview.c:21
#define FIXME(fmt,...)
Definition: precomp.h:53
const GUID IID_IUnknown
#define RegCloseKey(hKey)
Definition: registry.h:49
HINSTANCE hInstance
Definition: charmap.c:19
WPARAM wParam
Definition: combotst.c:138
LPARAM lParam
Definition: combotst.c:139
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
#define E_FAIL
Definition: ddrawi.h:102
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3333
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4103
UINT uFlags
Definition: api.c:59
HICON WINAPI ImageList_GetIcon(HIMAGELIST himl, INT i, UINT fStyle)
Definition: imagelist.c:1963
#define CloseHandle
Definition: compat.h:739
#define GetProcessHeap()
Definition: compat.h:736
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define GetCurrentDirectoryW(x, y)
Definition: compat.h:756
#define CP_ACP
Definition: compat.h:109
#define OPEN_EXISTING
Definition: compat.h:775
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
#define SetFilePointer
Definition: compat.h:743
#define SetLastError(x)
Definition: compat.h:752
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define HeapAlloc
Definition: compat.h:733
#define GENERIC_READ
Definition: compat.h:135
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define CreateFileW
Definition: compat.h:741
#define CALLBACK
Definition: compat.h:35
#define lstrcpyW
Definition: compat.h:749
#define WideCharToMultiByte
Definition: compat.h:111
#define MultiByteToWideChar
Definition: compat.h:110
#define FILE_SHARE_READ
Definition: compat.h:136
#define lstrcpynW
Definition: compat.h:738
DWORD WINAPI GetFileAttributesW(LPCWSTR lpFileName)
Definition: fileinfo.c:652
DWORD WINAPI GetModuleFileNameW(HINSTANCE hModule, LPWSTR lpFilename, DWORD nSize)
Definition: loader.c:600
BOOL WINAPI GetBinaryTypeW(LPCWSTR lpApplicationName, LPDWORD lpBinaryType)
Definition: vdm.c:1243
HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
Definition: res.c:176
HGLOBAL WINAPI LoadResource(HINSTANCE hModule, HRSRC hRsrc)
Definition: res.c:532
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4243
INT WINAPI GetLocaleInfoW(LCID lcid, LCTYPE lctype, LPWSTR buffer, INT len)
Definition: locale.c:1666
HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
Definition: compobj.c:3325
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:326
LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
Definition: path.c:447
BOOL WINAPI PathIsRootW(LPCWSTR lpszPath)
Definition: path.c:1642
BOOL WINAPI PathIsRelativeW(LPCWSTR lpszPath)
Definition: path.c:1579
#define IShellFolder_GetDisplayNameOf
Definition: utils.cpp:13
#define swprintf
Definition: precomp.h:40
static void *static void *static LPDIRECTPLAY IUnknown * pUnk
Definition: dplayx.c:30
static VOID BitBlt(_In_ ULONG Left, _In_ ULONG Top, _In_ ULONG Width, _In_ ULONG Height, _In_reads_bytes_(Delta *Height) PUCHAR Buffer, _In_ ULONG BitsPerPixel, _In_ ULONG Delta)
Definition: common.c:57
#define SHGFI_ADDOVERLAYS
Definition: entries.h:77
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned short WORD
Definition: ntddk_ex.h:93
WCHAR swShell32Name[MAX_PATH]
Definition: folders.cpp:22
FxAutoRegKey hKey
pKey DeleteObject()
GLdouble s
Definition: gl.h:2039
GLsizeiptr size
Definition: glext.h:5919
GLbitfield flags
Definition: glext.h:7161
GLenum GLsizei len
Definition: glext.h:6722
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
BOOL NTAPI GlobalMemoryStatusEx(LPMEMORYSTATUSEX lpBuffer)
Definition: heapmem.c:1272
INT SIC_GetIconIndex(LPCWSTR sSourceFile, INT dwSourceIndex, DWORD dwFlags)
Definition: iconcache.cpp:440
BOOL PidlToSicIndex(IShellFolder *sh, LPCITEMIDLIST pidl, BOOL bBigIcon, UINT uFlags, int *pIndex)
Definition: iconcache.cpp:709
BOOL WINAPI Shell_GetImageLists(HIMAGELIST *lpBigList, HIMAGELIST *lpSmallList)
Definition: iconcache.cpp:683
_Out_opt_ PICONINFO IconInfo
Definition: ntuser.h:2294
REFIID LPVOID DWORD_PTR dw
Definition: atlbase.h:40
#define S_OK
Definition: intsafe.h:52
#define SUCCEEDED(hr)
Definition: intsafe.h:50
#define SEEK_SET
Definition: jmemansi.c:26
#define d
Definition: ke_i.h:81
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_w
Definition: kernel32.h:32
#define REG_SZ
Definition: layer.c:22
static PVOID ptr
Definition: dispmode.c:27
HDC hdc
Definition: main.c:9
static HBITMAP
Definition: button.c:44
static HDC
Definition: imagelist.c:88
static HICON
Definition: imagelist.c:80
IMAGE_NT_HEADERS nt
Definition: module.c:50
static const char mbstate_t *static wchar_t const char mbstate_t *static const wchar_t int *static double
Definition: string.c:80
TCHAR szAppTitle[256]
Definition: mplay32.c:27
#define argv
Definition: mplay32.c:18
int details
Definition: msacm.c:1366
HICON hIcon
Definition: msconfig.c:44
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
unsigned int UINT
Definition: ndis.h:50
#define KEY_QUERY_VALUE
Definition: nt_native.h:1016
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
#define LOCALE_USER_DEFAULT
#define UNICODE_NULL
#define IMAGE_SUBSYSTEM_WINDOWS_GUI
Definition: ntimage.h:437
#define L(x)
Definition: ntvdm.h:50
#define PathCombineW
Definition: pathcch.h:317
#define IMAGE_NT_SIGNATURE
Definition: pedump.c:93
#define RT_DIALOG
Definition: pedump.c:367
#define IMAGE_FILE_DLL
Definition: pedump.c:169
#define IMAGE_OS2_SIGNATURE
Definition: pedump.c:90
HRESULT WINAPI SHILCreateFromPathW(LPCWSTR path, LPITEMIDLIST *ppidl, DWORD *attributes)
Definition: pidl.c:403
HRESULT WINAPI SHBindToParent(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppv, LPCITEMIDLIST *ppidlLast)
Definition: pidl.c:1462
BOOL WINAPI SHGetPathFromIDListW(LPCITEMIDLIST pidl, LPWSTR pszPath)
Definition: pidl.c:1454
LPITEMIDLIST SHELL32_CreateSimpleIDListFromPath(LPCWSTR pszPath, DWORD dwAttributes)
Definition: pidl.c:1188
BOOL _ILIsDrive(LPCITEMIDLIST pidl)
Definition: pidl.c:2113
BOOL _ILGetExtension(LPCITEMIDLIST pidl, LPWSTR pOut, UINT uOutSize)
Definition: pidl.c:2516
_Out_opt_ int _Out_opt_ int * cy
Definition: commctrl.h:586
#define ILD_NORMAL
Definition: commctrl.h:417
_Out_opt_ int * cx
Definition: commctrl.h:585
#define REFCLSID
Definition: guiddef.h:117
#define strlenW(s)
Definition: unicode.h:34
#define strcpyW(d, s)
Definition: unicode.h:35
const WCHAR * str
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
#define CP_UTF8
Definition: nls.h:20
BOOL HCR_GetIconW(LPCWSTR szClass, LPWSTR szDest, LPCWSTR szName, DWORD len, int *picon_idx)
Definition: classes.c:314
BOOL HCR_MapTypeToValueW(LPCWSTR szExtension, LPWSTR szFileType, LONG len, BOOL bPrependDot)
Definition: classes.c:82
HRESULT HCR_GetProgIdKeyOfExtension(PCWSTR szExtension, PHKEY phKey, BOOL AllowFallback)
Definition: classes.c:55
VOID WINAPI Printer_LoadIconsW(LPCWSTR wsPrinterName, HICON *pLargeIcon, HICON *pSmallIcon)
Definition: shell32_main.c:893
BOOL SHELL_IsShortcut(LPCITEMIDLIST pidlLast)
Definition: shell32_main.c:404
DWORD WINAPI SHHelpShortcuts_RunDLLW(DWORD dwArg1, DWORD dwArg2, DWORD dwArg3, DWORD dwArg4)
Definition: shell32_main.c:971
#define SHGFI_KNOWN_FLAGS
Definition: shell32_main.c:419
static DWORD shgfi_get_exe_type(LPCWSTR szFullPath)
Definition: shell32_main.c:335
HRESULT WINAPI SHLoadNonloadedIconOverlayIdentifiers(VOID)
static INT_PTR CALLBACK AboutDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
const char *const SHELL_Authors[]
Definition: shell32_main.c:50
HRESULT WINAPI SHLoadInProc(REFCLSID rclsid)
Definition: shell32_main.c:982
HICON WINAPI DuplicateIcon(HINSTANCE hInstance, HICON hIcon)
Definition: shell32_main.c:824
HICON WINAPI ExtractIconW(HINSTANCE hInstance, LPCWSTR lpszFile, UINT nIconIndex)
Definition: shell32_main.c:864
HICON WINAPI ExtractIconA(HINSTANCE hInstance, LPCSTR lpszFile, UINT nIconIndex)
Definition: shell32_main.c:846
LPWSTR *WINAPI CommandLineToArgvW(LPCWSTR lpCmdline, int *numargs)
Definition: shell32_main.c:79
BOOL WINAPI ShellAboutW(HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff, HICON hIcon)
DWORD_PTR WINAPI SHGetFileInfoA(LPCSTR path, DWORD dwFileAttributes, SHFILEINFOA *psfi, UINT sizeofpsfi, UINT flags)
Definition: shell32_main.c:773
VOID WINAPI Printers_UnregisterWindow(HANDLE hClassPidl, HWND hwnd)
Definition: shell32_main.c:940
BOOL WINAPI Printers_RegisterWindowW(LPCWSTR wsPrinter, DWORD dwType, HANDLE *phClassPidl, HWND *phwnd)
Definition: shell32_main.c:927
BOOL WINAPI ShellAboutA(HWND hWnd, LPCSTR szApp, LPCSTR szOtherStuff, HICON hIcon)
DWORD_PTR WINAPI SHGetFileInfoW(LPCWSTR path, DWORD dwFileAttributes, SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags)
Definition: shell32_main.c:430
INT_PTR CALLBACK AboutAuthorsDlgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
static VOID SetRegTextData(HWND hWnd, HKEY hKey, LPCWSTR Value, UINT uID)
Definition: shell32_main.c:998
DWORD WINAPI SHHelpShortcuts_RunDLLA(DWORD dwArg1, DWORD dwArg2, DWORD dwArg3, DWORD dwArg4)
Definition: shell32_main.c:961
void WINAPI FreeIconList(DWORD dw)
static HRESULT SHELL_GetDetailsOfToBuffer(IShellFolder *psf, PCUITEMID_CHILD pidl, UINT col, LPWSTR Buf, UINT cchBuf)
Definition: shell32_main.c:313
#define SHGFI_ATTR_SPECIFIED
Definition: shellapi.h:175
#define SHGFI_OPENICON
Definition: shellapi.h:179
#define SHGFI_LINKOVERLAY
Definition: shellapi.h:173
#define SHGFI_SYSICONINDEX
Definition: shellapi.h:172
#define SHGFI_ICONLOCATION
Definition: shellapi.h:170
#define SHGFI_DISPLAYNAME
Definition: shellapi.h:167
#define SHGFI_ICON
Definition: shellapi.h:165
#define SHGFI_TYPENAME
Definition: shellapi.h:168
#define SHGFI_USEFILEATTRIBUTES
Definition: shellapi.h:182
#define SHGFI_ATTRIBUTES
Definition: shellapi.h:169
#define SHGFI_SMALLICON
Definition: shellapi.h:177
#define SHGFI_SELECTED
Definition: shellapi.h:174
#define SHGFI_OVERLAYINDEX
Definition: shellapi.h:164
#define SHGFI_PIDL
Definition: shellapi.h:181
#define SHGFI_EXETYPE
Definition: shellapi.h:171
#define SHGFI_SHELLICONSIZE
Definition: shellapi.h:180
BOOL WINAPI StrRetToStrNW(LPWSTR dest, DWORD len, LPSTRRET src, const ITEMIDLIST *pidl)
Definition: shellstring.c:85
HRESULT hr
Definition: shlfolder.c:183
#define IShellDetails_Release(p)
Definition: shlobj.h:662
#define IShellDetails_GetDetailsOf(p, a, b, c)
Definition: shlobj.h:664
#define IDC_ABOUT_REG_USERNAME
Definition: shresdef.h:377
#define IDC_ABOUT_REG_TO
Definition: shresdef.h:376
#define IDC_ABOUT_ICON
Definition: shresdef.h:371
#define IDB_REACTOS
Definition: shresdef.h:30
#define IDC_ABOUT_PHYSMEM
Definition: shresdef.h:379
#define IDB_LINEBAR
Definition: shresdef.h:31
#define IDC_ABOUT_APPNAME
Definition: shresdef.h:372
#define IDC_ABOUT_AUTHORS_LISTBOX
Definition: shresdef.h:384
#define IDD_ABOUT
Definition: shresdef.h:370
#define IDC_ABOUT_AUTHORS
Definition: shresdef.h:383
#define IDS_ABOUT_VERSION_STRING
Definition: shresdef.h:373
#define IDC_ABOUT_REG_ORGNAME
Definition: shresdef.h:378
#define IDI_SHELL_PRINTERS_FOLDER
Definition: shresdef.h:590
#define IDC_ABOUT_VERSION
Definition: shresdef.h:374
#define IDC_ABOUT_OTHERSTUFF
Definition: shresdef.h:375
#define IDD_ABOUT_AUTHORS
Definition: shresdef.h:382
#define IDS_SHELL_ABOUT_BACK
Definition: shresdef.h:137
#define IDS_SHELL_ABOUT_AUTHORS
Definition: shresdef.h:136
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
const ITEMID_CHILD UNALIGNED * PCUITEMID_CHILD
Definition: shtypes.idl:70
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
#define _countof(array)
Definition: sndvol32.h:70
#define TRACE(s)
Definition: solgame.cpp:4
TCHAR * cmdline
Definition: stretchblt.cpp:32
STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:530
LPCWSTR szOtherStuff
Definition: shell32_main.c:953
LPCWSTR szApp
Definition: shell32_main.c:949
Definition: bl.h:1331
HBITMAP hbmColor
Definition: winuser.h:3130
HBITMAP hbmMask
Definition: winuser.h:3129
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
CHAR szTypeName[80]
Definition: shellapi.h:370
HICON hIcon
Definition: shellapi.h:366
DWORD dwAttributes
Definition: shellapi.h:368
CHAR szDisplayName[MAX_PATH]
Definition: shellapi.h:369
WCHAR szTypeName[80]
Definition: shellapi.h:377
DWORD dwAttributes
Definition: shellapi.h:375
WCHAR szDisplayName[MAX_PATH]
Definition: shellapi.h:376
HICON hIcon
Definition: shellapi.h:373
Definition: name.c:39
Definition: ps.c:97
#define DWORD_PTR
Definition: treelist.c:76
#define isblank(x)
Definition: trio.c:93
int32_t INT_PTR
Definition: typedefs.h:64
uint32_t DWORD_PTR
Definition: typedefs.h:65
unsigned char * LPBYTE
Definition: typedefs.h:53
int32_t INT
Definition: typedefs.h:58
DWORD dwAttributes
Definition: vdmdbg.h:34
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
int ret
_Must_inspect_result_ _In_ WDFKEY _In_ PCUNICODE_STRING _Out_opt_ PUSHORT _Inout_opt_ PUNICODE_STRING Value
Definition: wdfregistry.h:413
HDC hdcMem
Definition: welcome.c:104
int WINAPI GetWindowTextW(HWND hWnd, LPWSTR lpString, int nMaxCount)
Definition: window.c:1384
#define SCS_PIF_BINARY
Definition: winbase.h:266
#define SCS_DOS_BINARY
Definition: winbase.h:264
#define LMEM_FIXED
Definition: winbase.h:394
_In_ LONG _In_ HWND hwnd
Definition: winddi.h:4023
LONG_PTR LPARAM
Definition: windef.h:208
UINT_PTR WPARAM
Definition: windef.h:207
#define WINAPI
Definition: msvc.h:6
#define DISP_E_MEMBERNOTFOUND
Definition: winerror.h:2512
HGDIOBJ WINAPI SelectObject(_In_ HDC, _In_ HGDIOBJ)
Definition: dc.c:1546
HDC WINAPI CreateCompatibleDC(_In_opt_ HDC hdc)
#define SRCCOPY
Definition: wingdi.h:333
#define GetObject
Definition: wingdi.h:4468
BOOL WINAPI DeleteDC(_In_ HDC)
#define LOCALE_SDECIMAL
Definition: winnls.h:44
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
#define WM_PAINT
Definition: winuser.h:1623
#define SW_HIDE
Definition: winuser.h:771
#define WM_CLOSE
Definition: winuser.h:1624
#define IMAGE_BITMAP
Definition: winuser.h:211
#define GetWindowLongPtrW
Definition: winuser.h:4832
HICON WINAPI CreateIconIndirect(_In_ PICONINFO)
Definition: cursoricon.c:2667
INT_PTR WINAPI DialogBoxIndirectParamW(_In_opt_ HINSTANCE, _In_ LPCDLGTEMPLATE, _In_opt_ HWND, _In_opt_ DLGPROC, _In_ LPARAM)
BOOL WINAPI ShowWindow(_In_ HWND, _In_ int)
#define STM_SETICON
Definition: winuser.h:2095
#define IDCANCEL
Definition: winuser.h:834
#define IMAGE_ICON
Definition: winuser.h:212
BOOL WINAPI GetIconInfo(_In_ HICON, _Out_ PICONINFO)
Definition: cursoricon.c:2131
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
UINT WINAPI PrivateExtractIconsW(_In_reads_(MAX_PATH) LPCWSTR szFileName, _In_ int nIconIndex, _In_ int cxIcon, _In_ int cyIcon, _Out_writes_opt_(nIcons) HICON *phicon, _Out_writes_opt_(nIcons) UINT *piconid, _In_ UINT nIcons, _In_ UINT flags)
#define WM_COMMAND
Definition: winuser.h:1743
HANDLE WINAPI LoadImageW(_In_opt_ HINSTANCE hInst, _In_ LPCWSTR name, _In_ UINT type, _In_ int cx, _In_ int cy, _In_ UINT fuLoad)
Definition: cursoricon.c:2289
#define SM_CYSMICON
Definition: winuser.h:1016
BOOL WINAPI SetDlgItemTextW(_In_ HWND, _In_ int, _In_ LPCWSTR)
#define WM_INITDIALOG
Definition: winuser.h:1742
#define LB_ADDSTRING
Definition: winuser.h:2034
#define GWLP_HINSTANCE
Definition: winuser.h:859
#define IDI_WINLOGO
Definition: winuser.h:709
HWND WINAPI GetDlgItem(_In_opt_ HWND, _In_ int)
#define IDOK
Definition: winuser.h:833
LRESULT WINAPI SendDlgItemMessageW(_In_ HWND, _In_ int, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
BOOL WINAPI SetWindowTextW(_In_ HWND, _In_opt_ LPCWSTR)
#define SM_CXSMICON
Definition: winuser.h:1015
#define SM_CYICON
Definition: winuser.h:976
BOOL WINAPI EndPaint(_In_ HWND, _In_ const PAINTSTRUCT *)
int WINAPI GetWindowTextLengthW(_In_ HWND)
#define CreateDialogW(h, n, w, f)
Definition: winuser.h:4284
#define LoadImage
Definition: winuser.h:5827
#define LR_DEFAULTCOLOR
Definition: winuser.h:1090
#define SW_SHOW
Definition: winuser.h:778
#define LR_DEFAULTSIZE
Definition: winuser.h:1097
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
HDC WINAPI BeginPaint(_In_ HWND, _Out_ LPPAINTSTRUCT)
#define SM_CXICON
Definition: winuser.h:975
#define MAKEINTRESOURCE
Definition: winuser.h:591
HICON WINAPI LoadIconW(_In_opt_ HINSTANCE hInstance, _In_ LPCWSTR lpIconName)
Definition: cursoricon.c:2161
int WINAPI GetSystemMetrics(_In_ int)
BOOL WINAPI EndDialog(_In_ HWND, _In_ INT_PTR)
#define WM_SETREDRAW
Definition: winuser.h:1619
const char * LPCSTR
Definition: xmlstorage.h:183
unsigned char UCHAR
Definition: xmlstorage.h:181
__wchar_t WCHAR
Definition: xmlstorage.h:180
WCHAR * LPWSTR
Definition: xmlstorage.h:184
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185