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 35 #include "undocshell.h" 36 #include "pidl.h" 37 #include "shell32_main.h" 38 #include "shresdef.h" 39 40 #include <wine/debug.h> 41 #include <wine/unicode.h> 42 43 #include <reactos/version.h> 44 45 WINE_DEFAULT_DEBUG_CHANNEL(shell); 46 47 const char * const SHELL_Authors[] = { "Copyright 1993-"COPYRIGHT_YEAR" WINE team", "Copyright 1998-"COPYRIGHT_YEAR" ReactOS Team", 0 }; 48 49 /************************************************************************* 50 * CommandLineToArgvW [SHELL32.@] 51 * 52 * We must interpret the quotes in the command line to rebuild the argv 53 * array correctly: 54 * - arguments are separated by spaces or tabs 55 * - quotes serve as optional argument delimiters 56 * '"a b"' -> 'a b' 57 * - escaped quotes must be converted back to '"' 58 * '\"' -> '"' 59 * - consecutive backslashes preceding a quote see their number halved with 60 * the remainder escaping the quote: 61 * 2n backslashes + quote -> n backslashes + quote as an argument delimiter 62 * 2n+1 backslashes + quote -> n backslashes + literal quote 63 * - backslashes that are not followed by a quote are copied literally: 64 * 'a\b' -> 'a\b' 65 * 'a\\b' -> 'a\\b' 66 * - in quoted strings, consecutive quotes see their number divided by three 67 * with the remainder modulo 3 deciding whether to close the string or not. 68 * Note that the opening quote must be counted in the consecutive quotes, 69 * that's the (1+) below: 70 * (1+) 3n quotes -> n quotes 71 * (1+) 3n+1 quotes -> n quotes plus closes the quoted string 72 * (1+) 3n+2 quotes -> n+1 quotes plus closes the quoted string 73 * - in unquoted strings, the first quote opens the quoted string and the 74 * remaining consecutive quotes follow the above rule. 75 */ 76 LPWSTR* WINAPI CommandLineToArgvW(LPCWSTR lpCmdline, int* numargs) 77 { 78 DWORD argc; 79 LPWSTR *argv; 80 LPCWSTR s; 81 LPWSTR d; 82 LPWSTR cmdline; 83 int qcount,bcount; 84 85 if(!numargs) 86 { 87 SetLastError(ERROR_INVALID_PARAMETER); 88 return NULL; 89 } 90 91 if (*lpCmdline==0) 92 { 93 /* Return the path to the executable */ 94 DWORD len, deslen=MAX_PATH, size; 95 96 size = sizeof(LPWSTR)*2 + deslen*sizeof(WCHAR); 97 for (;;) 98 { 99 if (!(argv = LocalAlloc(LMEM_FIXED, size))) return NULL; 100 len = GetModuleFileNameW(0, (LPWSTR)(argv+2), deslen); 101 if (!len) 102 { 103 LocalFree(argv); 104 return NULL; 105 } 106 if (len < deslen) break; 107 deslen*=2; 108 size = sizeof(LPWSTR)*2 + deslen*sizeof(WCHAR); 109 LocalFree( argv ); 110 } 111 argv[0]=(LPWSTR)(argv+2); 112 argv[1]=NULL; 113 *numargs=1; 114 115 return argv; 116 } 117 118 /* --- First count the arguments */ 119 argc=1; 120 s=lpCmdline; 121 /* The first argument, the executable path, follows special rules */ 122 if (*s=='"') 123 { 124 /* The executable path ends at the next quote, no matter what */ 125 s++; 126 while (*s) 127 if (*s++=='"') 128 break; 129 } 130 else 131 { 132 /* The executable path ends at the next space, no matter what */ 133 while (*s && *s!=' ' && *s!='\t') 134 s++; 135 } 136 /* skip to the first argument, if any */ 137 while (*s==' ' || *s=='\t') 138 s++; 139 if (*s) 140 argc++; 141 142 /* Analyze the remaining arguments */ 143 qcount=bcount=0; 144 while (*s) 145 { 146 if ((*s==' ' || *s=='\t') && qcount==0) 147 { 148 /* skip to the next argument and count it if any */ 149 while (*s==' ' || *s=='\t') 150 s++; 151 if (*s) 152 argc++; 153 bcount=0; 154 } 155 else if (*s=='\\') 156 { 157 /* '\', count them */ 158 bcount++; 159 s++; 160 } 161 else if (*s=='"') 162 { 163 /* '"' */ 164 if ((bcount & 1)==0) 165 qcount++; /* unescaped '"' */ 166 s++; 167 bcount=0; 168 /* consecutive quotes, see comment in copying code below */ 169 while (*s=='"') 170 { 171 qcount++; 172 s++; 173 } 174 qcount=qcount % 3; 175 if (qcount==2) 176 qcount=0; 177 } 178 else 179 { 180 /* a regular character */ 181 bcount=0; 182 s++; 183 } 184 } 185 186 /* Allocate in a single lump, the string array, and the strings that go 187 * with it. This way the caller can make a single LocalFree() call to free 188 * both, as per MSDN. 189 */ 190 argv=LocalAlloc(LMEM_FIXED, (argc+1)*sizeof(LPWSTR)+(strlenW(lpCmdline)+1)*sizeof(WCHAR)); 191 if (!argv) 192 return NULL; 193 cmdline=(LPWSTR)(argv+argc+1); 194 strcpyW(cmdline, lpCmdline); 195 196 /* --- Then split and copy the arguments */ 197 argv[0]=d=cmdline; 198 argc=1; 199 /* The first argument, the executable path, follows special rules */ 200 if (*d=='"') 201 { 202 /* The executable path ends at the next quote, no matter what */ 203 s=d+1; 204 while (*s) 205 { 206 if (*s=='"') 207 { 208 s++; 209 break; 210 } 211 *d++=*s++; 212 } 213 } 214 else 215 { 216 /* The executable path ends at the next space, no matter what */ 217 while (*d && *d!=' ' && *d!='\t') 218 d++; 219 s=d; 220 if (*s) 221 s++; 222 } 223 /* close the executable path */ 224 *d++=0; 225 /* skip to the first argument and initialize it if any */ 226 while (*s==' ' || *s=='\t') 227 s++; 228 if (!*s) 229 { 230 /* There are no parameters so we are all done */ 231 argv[argc]=NULL; 232 *numargs=argc; 233 return argv; 234 } 235 236 /* Split and copy the remaining arguments */ 237 argv[argc++]=d; 238 qcount=bcount=0; 239 while (*s) 240 { 241 if ((*s==' ' || *s=='\t') && qcount==0) 242 { 243 /* close the argument */ 244 *d++=0; 245 bcount=0; 246 247 /* skip to the next one and initialize it if any */ 248 do { 249 s++; 250 } while (*s==' ' || *s=='\t'); 251 if (*s) 252 argv[argc++]=d; 253 } 254 else if (*s=='\\') 255 { 256 *d++=*s++; 257 bcount++; 258 } 259 else if (*s=='"') 260 { 261 if ((bcount & 1)==0) 262 { 263 /* Preceded by an even number of '\', this is half that 264 * number of '\', plus a quote which we erase. 265 */ 266 d-=bcount/2; 267 qcount++; 268 } 269 else 270 { 271 /* Preceded by an odd number of '\', this is half that 272 * number of '\' followed by a '"' 273 */ 274 d=d-bcount/2-1; 275 *d++='"'; 276 } 277 s++; 278 bcount=0; 279 /* Now count the number of consecutive quotes. Note that qcount 280 * already takes into account the opening quote if any, as well as 281 * the quote that lead us here. 282 */ 283 while (*s=='"') 284 { 285 if (++qcount==3) 286 { 287 *d++='"'; 288 qcount=0; 289 } 290 s++; 291 } 292 if (qcount==2) 293 qcount=0; 294 } 295 else 296 { 297 /* a regular character */ 298 *d++=*s++; 299 bcount=0; 300 } 301 } 302 *d='\0'; 303 argv[argc]=NULL; 304 *numargs=argc; 305 306 return argv; 307 } 308 309 static DWORD shgfi_get_exe_type(LPCWSTR szFullPath) 310 { 311 BOOL status = FALSE; 312 HANDLE hfile; 313 DWORD BinaryType; 314 IMAGE_DOS_HEADER mz_header; 315 IMAGE_NT_HEADERS nt; 316 DWORD len; 317 char magic[4]; 318 319 status = GetBinaryTypeW (szFullPath, &BinaryType); 320 if (!status) 321 return 0; 322 if (BinaryType == SCS_DOS_BINARY || BinaryType == SCS_PIF_BINARY) 323 return 0x4d5a; 324 325 hfile = CreateFileW( szFullPath, GENERIC_READ, FILE_SHARE_READ, 326 NULL, OPEN_EXISTING, 0, 0 ); 327 if ( hfile == INVALID_HANDLE_VALUE ) 328 return 0; 329 330 /* 331 * The next section is adapted from MODULE_GetBinaryType, as we need 332 * to examine the image header to get OS and version information. We 333 * know from calling GetBinaryTypeA that the image is valid and either 334 * an NE or PE, so much error handling can be omitted. 335 * Seek to the start of the file and read the header information. 336 */ 337 338 SetFilePointer( hfile, 0, NULL, SEEK_SET ); 339 ReadFile( hfile, &mz_header, sizeof(mz_header), &len, NULL ); 340 341 SetFilePointer( hfile, mz_header.e_lfanew, NULL, SEEK_SET ); 342 ReadFile( hfile, magic, sizeof(magic), &len, NULL ); 343 if ( *(DWORD*)magic == IMAGE_NT_SIGNATURE ) 344 { 345 SetFilePointer( hfile, mz_header.e_lfanew, NULL, SEEK_SET ); 346 ReadFile( hfile, &nt, sizeof(nt), &len, NULL ); 347 CloseHandle( hfile ); 348 /* DLL files are not executable and should return 0 */ 349 if (nt.FileHeader.Characteristics & IMAGE_FILE_DLL) 350 return 0; 351 if (nt.OptionalHeader.Subsystem == IMAGE_SUBSYSTEM_WINDOWS_GUI) 352 { 353 return IMAGE_NT_SIGNATURE | 354 (nt.OptionalHeader.MajorSubsystemVersion << 24) | 355 (nt.OptionalHeader.MinorSubsystemVersion << 16); 356 } 357 return IMAGE_NT_SIGNATURE; 358 } 359 else if ( *(WORD*)magic == IMAGE_OS2_SIGNATURE ) 360 { 361 IMAGE_OS2_HEADER ne; 362 SetFilePointer( hfile, mz_header.e_lfanew, NULL, SEEK_SET ); 363 ReadFile( hfile, &ne, sizeof(ne), &len, NULL ); 364 CloseHandle( hfile ); 365 if (ne.ne_exetyp == 2) 366 return IMAGE_OS2_SIGNATURE | (ne.ne_expver << 16); 367 return 0; 368 } 369 CloseHandle( hfile ); 370 return 0; 371 } 372 373 /************************************************************************* 374 * SHELL_IsShortcut [internal] 375 * 376 * Decide if an item id list points to a shell shortcut 377 */ 378 BOOL SHELL_IsShortcut(LPCITEMIDLIST pidlLast) 379 { 380 char szTemp[MAX_PATH]; 381 HKEY keyCls; 382 BOOL ret = FALSE; 383 384 if (_ILGetExtension(pidlLast, szTemp, MAX_PATH) && 385 HCR_MapTypeToValueA(szTemp, szTemp, MAX_PATH, TRUE)) 386 { 387 if (ERROR_SUCCESS == RegOpenKeyExA(HKEY_CLASSES_ROOT, szTemp, 0, KEY_QUERY_VALUE, &keyCls)) 388 { 389 if (ERROR_SUCCESS == RegQueryValueExA(keyCls, "IsShortcut", NULL, NULL, NULL, NULL)) 390 ret = TRUE; 391 392 RegCloseKey(keyCls); 393 } 394 } 395 396 return ret; 397 } 398 399 #define SHGFI_KNOWN_FLAGS \ 400 (SHGFI_SMALLICON | SHGFI_OPENICON | SHGFI_SHELLICONSIZE | SHGFI_PIDL | \ 401 SHGFI_USEFILEATTRIBUTES | SHGFI_ADDOVERLAYS | SHGFI_OVERLAYINDEX | \ 402 SHGFI_ICON | SHGFI_DISPLAYNAME | SHGFI_TYPENAME | SHGFI_ATTRIBUTES | \ 403 SHGFI_ICONLOCATION | SHGFI_EXETYPE | SHGFI_SYSICONINDEX | \ 404 SHGFI_LINKOVERLAY | SHGFI_SELECTED | SHGFI_ATTR_SPECIFIED) 405 406 /************************************************************************* 407 * SHGetFileInfoW [SHELL32.@] 408 * 409 */ 410 DWORD_PTR WINAPI SHGetFileInfoW(LPCWSTR path,DWORD dwFileAttributes, 411 SHFILEINFOW *psfi, UINT sizeofpsfi, UINT flags ) 412 { 413 WCHAR szLocation[MAX_PATH], szFullPath[MAX_PATH]; 414 int iIndex; 415 DWORD_PTR ret = TRUE; 416 DWORD dwAttributes = 0; 417 IShellFolder * psfParent = NULL; 418 IExtractIconW * pei = NULL; 419 LPITEMIDLIST pidlLast = NULL, pidl = NULL; 420 HRESULT hr = S_OK; 421 BOOL IconNotYetLoaded=TRUE; 422 UINT uGilFlags = 0; 423 HIMAGELIST big_icons, small_icons; 424 425 TRACE("%s fattr=0x%x sfi=%p(attr=0x%08x) size=0x%x flags=0x%x\n", 426 (flags & SHGFI_PIDL)? "pidl" : debugstr_w(path), dwFileAttributes, 427 psfi, psfi ? psfi->dwAttributes : 0, sizeofpsfi, flags); 428 429 if (!path) 430 return FALSE; 431 432 /* windows initializes these values regardless of the flags */ 433 if (psfi != NULL) 434 { 435 psfi->szDisplayName[0] = '\0'; 436 psfi->szTypeName[0] = '\0'; 437 psfi->hIcon = NULL; 438 } 439 440 if (!(flags & SHGFI_PIDL)) 441 { 442 /* SHGetFileInfo should work with absolute and relative paths */ 443 if (PathIsRelativeW(path)) 444 { 445 GetCurrentDirectoryW(MAX_PATH, szLocation); 446 PathCombineW(szFullPath, szLocation, path); 447 } 448 else 449 { 450 lstrcpynW(szFullPath, path, MAX_PATH); 451 } 452 } 453 else 454 { 455 SHGetPathFromIDListW((LPITEMIDLIST)path, szFullPath); 456 } 457 458 if (flags & SHGFI_EXETYPE) 459 { 460 if (!(flags & SHGFI_SYSICONINDEX)) 461 { 462 if (flags & SHGFI_USEFILEATTRIBUTES) 463 { 464 return TRUE; 465 } 466 else if (GetFileAttributesW(szFullPath) != INVALID_FILE_ATTRIBUTES) 467 { 468 return shgfi_get_exe_type(szFullPath); 469 } 470 } 471 } 472 473 /* 474 * psfi is NULL normally to query EXE type. If it is NULL, none of the 475 * below makes sense anyway. Windows allows this and just returns FALSE 476 */ 477 if (psfi == NULL) 478 return FALSE; 479 480 /* 481 * translate the path into a pidl only when SHGFI_USEFILEATTRIBUTES 482 * is not specified. 483 * The pidl functions fail on not existing file names 484 */ 485 486 if (flags & SHGFI_PIDL) 487 { 488 pidl = ILClone((LPCITEMIDLIST)path); 489 } 490 else if (!(flags & SHGFI_USEFILEATTRIBUTES)) 491 { 492 hr = SHILCreateFromPathW(szFullPath, &pidl, &dwAttributes); 493 } 494 495 if ((flags & SHGFI_PIDL) || !(flags & SHGFI_USEFILEATTRIBUTES)) 496 { 497 /* get the parent shellfolder */ 498 if (pidl) 499 { 500 hr = SHBindToParent( pidl, &IID_IShellFolder, (LPVOID*)&psfParent, 501 (LPCITEMIDLIST*)&pidlLast ); 502 if (SUCCEEDED(hr)) 503 pidlLast = ILClone(pidlLast); 504 else 505 hr = S_OK; 506 ILFree(pidl); 507 } 508 else 509 { 510 ERR("pidl is null!\n"); 511 return FALSE; 512 } 513 } 514 515 /* get the attributes of the child */ 516 if (SUCCEEDED(hr) && (flags & SHGFI_ATTRIBUTES)) 517 { 518 if (!(flags & SHGFI_ATTR_SPECIFIED)) 519 { 520 psfi->dwAttributes = 0xffffffff; 521 } 522 if (psfParent) 523 { 524 IShellFolder_GetAttributesOf(psfParent, 1, (LPCITEMIDLIST*)&pidlLast, 525 &(psfi->dwAttributes)); 526 } 527 } 528 529 if (flags & SHGFI_USEFILEATTRIBUTES) 530 { 531 if (flags & SHGFI_ICON) 532 { 533 psfi->dwAttributes = 0; 534 } 535 } 536 537 /* get the displayname */ 538 if (SUCCEEDED(hr) && (flags & SHGFI_DISPLAYNAME)) 539 { 540 if (flags & SHGFI_USEFILEATTRIBUTES && !(flags & SHGFI_PIDL)) 541 { 542 lstrcpyW (psfi->szDisplayName, PathFindFileNameW(szFullPath)); 543 } 544 else if (psfParent) 545 { 546 STRRET str; 547 hr = IShellFolder_GetDisplayNameOf( psfParent, pidlLast, 548 SHGDN_INFOLDER, &str); 549 StrRetToStrNW (psfi->szDisplayName, MAX_PATH, &str, pidlLast); 550 } 551 } 552 553 /* get the type name */ 554 if (SUCCEEDED(hr) && (flags & SHGFI_TYPENAME)) 555 { 556 static const WCHAR szFolder[] = { 'F','o','l','d','e','r',0 }; 557 static const WCHAR szFile[] = { 'F','i','l','e',0 }; 558 static const WCHAR szSpaceFile[] = { ' ','f','i','l','e',0 }; 559 560 if (!(flags & SHGFI_USEFILEATTRIBUTES) || (flags & SHGFI_PIDL)) 561 { 562 char ftype[80]; 563 564 _ILGetFileType(pidlLast, ftype, 80); 565 MultiByteToWideChar(CP_ACP, 0, ftype, -1, psfi->szTypeName, 80 ); 566 } 567 else 568 { 569 if (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 570 strcatW (psfi->szTypeName, szFolder); 571 else 572 { 573 WCHAR sTemp[64]; 574 575 lstrcpyW(sTemp,PathFindExtensionW(szFullPath)); 576 if (sTemp[0] == 0 || (sTemp[0] == '.' && sTemp[1] == 0)) 577 { 578 /* "name" or "name." => "File" */ 579 lstrcpynW (psfi->szTypeName, szFile, 64); 580 } 581 else if (!( HCR_MapTypeToValueW(sTemp, sTemp, 64, TRUE) && 582 HCR_MapTypeToValueW(sTemp, psfi->szTypeName, 80, FALSE ))) 583 { 584 if (sTemp[0]) 585 { 586 lstrcpynW (psfi->szTypeName, sTemp, 64); 587 strcatW (psfi->szTypeName, szSpaceFile); 588 } 589 else 590 { 591 lstrcpynW (psfi->szTypeName, szFile, 64); 592 } 593 } 594 } 595 } 596 } 597 598 /* ### icons ###*/ 599 600 Shell_GetImageLists( &big_icons, &small_icons ); 601 602 if (flags & SHGFI_OPENICON) 603 uGilFlags |= GIL_OPENICON; 604 605 if (flags & SHGFI_LINKOVERLAY) 606 uGilFlags |= GIL_FORSHORTCUT; 607 else if ((flags&SHGFI_ADDOVERLAYS) || 608 (flags&(SHGFI_ICON|SHGFI_SMALLICON))==SHGFI_ICON) 609 { 610 if (SHELL_IsShortcut(pidlLast)) 611 uGilFlags |= GIL_FORSHORTCUT; 612 } 613 614 if (flags & SHGFI_OVERLAYINDEX) 615 FIXME("SHGFI_OVERLAYINDEX unhandled\n"); 616 617 if (flags & SHGFI_SELECTED) 618 FIXME("set icon to selected, stub\n"); 619 620 if (flags & SHGFI_SHELLICONSIZE) 621 FIXME("set icon to shell size, stub\n"); 622 623 /* get the iconlocation */ 624 if (SUCCEEDED(hr) && (flags & SHGFI_ICONLOCATION )) 625 { 626 UINT uDummy,uFlags; 627 628 if (flags & SHGFI_USEFILEATTRIBUTES && !(flags & SHGFI_PIDL)) 629 { 630 if (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 631 { 632 lstrcpyW(psfi->szDisplayName, swShell32Name); 633 psfi->iIcon = -IDI_SHELL_FOLDER; 634 } 635 else 636 { 637 WCHAR* szExt; 638 static const WCHAR p1W[] = {'%','1',0}; 639 WCHAR sTemp [MAX_PATH]; 640 641 szExt = PathFindExtensionW(szFullPath); 642 TRACE("szExt=%s\n", debugstr_w(szExt)); 643 if ( szExt && 644 HCR_MapTypeToValueW(szExt, sTemp, MAX_PATH, TRUE) && 645 HCR_GetIconW(sTemp, sTemp, NULL, MAX_PATH, &psfi->iIcon)) 646 { 647 if (lstrcmpW(p1W, sTemp)) 648 strcpyW(psfi->szDisplayName, sTemp); 649 else 650 { 651 /* the icon is in the file */ 652 strcpyW(psfi->szDisplayName, szFullPath); 653 } 654 } 655 else 656 ret = FALSE; 657 } 658 } 659 else if (psfParent) 660 { 661 hr = IShellFolder_GetUIObjectOf(psfParent, 0, 1, 662 (LPCITEMIDLIST*)&pidlLast, &IID_IExtractIconW, 663 &uDummy, (LPVOID*)&pei); 664 if (SUCCEEDED(hr)) 665 { 666 hr = IExtractIconW_GetIconLocation(pei, uGilFlags, 667 szLocation, MAX_PATH, &iIndex, &uFlags); 668 669 if (uFlags & GIL_NOTFILENAME) 670 ret = FALSE; 671 else 672 { 673 lstrcpyW (psfi->szDisplayName, szLocation); 674 psfi->iIcon = iIndex; 675 } 676 IExtractIconW_Release(pei); 677 } 678 } 679 } 680 681 /* get icon index (or load icon)*/ 682 if (SUCCEEDED(hr) && (flags & (SHGFI_ICON | SHGFI_SYSICONINDEX))) 683 { 684 if (flags & SHGFI_USEFILEATTRIBUTES && !(flags & SHGFI_PIDL)) 685 { 686 WCHAR sTemp [MAX_PATH]; 687 WCHAR * szExt; 688 int icon_idx=0; 689 690 lstrcpynW(sTemp, szFullPath, MAX_PATH); 691 692 if (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 693 psfi->iIcon = SIC_GetIconIndex(swShell32Name, -IDI_SHELL_FOLDER, 0); 694 else 695 { 696 static const WCHAR p1W[] = {'%','1',0}; 697 698 psfi->iIcon = 0; 699 szExt = PathFindExtensionW(sTemp); 700 if ( szExt && 701 HCR_MapTypeToValueW(szExt, sTemp, MAX_PATH, TRUE) && 702 HCR_GetIconW(sTemp, sTemp, NULL, MAX_PATH, &icon_idx)) 703 { 704 if (!lstrcmpW(p1W,sTemp)) /* icon is in the file */ 705 strcpyW(sTemp, szFullPath); 706 707 if (flags & SHGFI_SYSICONINDEX) 708 { 709 psfi->iIcon = SIC_GetIconIndex(sTemp,icon_idx,0); 710 if (psfi->iIcon == -1) 711 psfi->iIcon = 0; 712 } 713 else 714 { 715 UINT ret; 716 if (flags & SHGFI_SMALLICON) 717 ret = PrivateExtractIconsW( sTemp,icon_idx, 718 GetSystemMetrics( SM_CXSMICON ), 719 GetSystemMetrics( SM_CYSMICON ), 720 &psfi->hIcon, 0, 1, 0); 721 else 722 ret = PrivateExtractIconsW( sTemp, icon_idx, 723 GetSystemMetrics( SM_CXICON), 724 GetSystemMetrics( SM_CYICON), 725 &psfi->hIcon, 0, 1, 0); 726 if (ret != 0 && ret != (UINT)-1) 727 { 728 IconNotYetLoaded=FALSE; 729 psfi->iIcon = icon_idx; 730 } 731 } 732 } 733 } 734 } 735 else if (psfParent) 736 { 737 if (!(PidlToSicIndex(psfParent, pidlLast, !(flags & SHGFI_SMALLICON), 738 uGilFlags, &(psfi->iIcon)))) 739 { 740 ret = FALSE; 741 } 742 } 743 if (ret && (flags & SHGFI_SYSICONINDEX)) 744 { 745 if (flags & SHGFI_SMALLICON) 746 ret = (DWORD_PTR)small_icons; 747 else 748 ret = (DWORD_PTR)big_icons; 749 } 750 } 751 752 /* icon handle */ 753 if (SUCCEEDED(hr) && (flags & SHGFI_ICON) && IconNotYetLoaded) 754 { 755 if (flags & SHGFI_SMALLICON) 756 psfi->hIcon = ImageList_GetIcon( small_icons, psfi->iIcon, ILD_NORMAL); 757 else 758 psfi->hIcon = ImageList_GetIcon( big_icons, psfi->iIcon, ILD_NORMAL); 759 } 760 761 if (flags & ~SHGFI_KNOWN_FLAGS) 762 FIXME("unknown flags %08x\n", flags & ~SHGFI_KNOWN_FLAGS); 763 764 if (psfParent) 765 IShellFolder_Release(psfParent); 766 767 if (hr != S_OK) 768 ret = FALSE; 769 770 SHFree(pidlLast); 771 772 TRACE ("icon=%p index=0x%08x attr=0x%08x name=%s type=%s ret=0x%08lx\n", 773 psfi->hIcon, psfi->iIcon, psfi->dwAttributes, 774 debugstr_w(psfi->szDisplayName), debugstr_w(psfi->szTypeName), ret); 775 776 return ret; 777 } 778 779 /************************************************************************* 780 * SHGetFileInfoA [SHELL32.@] 781 * 782 * Note: 783 * MSVBVM60.__vbaNew2 expects this function to return a value in range 784 * 1 .. 0x7fff when the function succeeds and flags does not contain 785 * SHGFI_EXETYPE or SHGFI_SYSICONINDEX (see bug 7701) 786 */ 787 DWORD_PTR WINAPI SHGetFileInfoA(LPCSTR path,DWORD dwFileAttributes, 788 SHFILEINFOA *psfi, UINT sizeofpsfi, 789 UINT flags ) 790 { 791 INT len; 792 LPWSTR temppath = NULL; 793 LPCWSTR pathW; 794 DWORD_PTR ret; 795 SHFILEINFOW temppsfi; 796 797 if (flags & SHGFI_PIDL) 798 { 799 /* path contains a pidl */ 800 pathW = (LPCWSTR)path; 801 } 802 else 803 { 804 len = MultiByteToWideChar(CP_ACP, 0, path, -1, NULL, 0); 805 temppath = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR)); 806 MultiByteToWideChar(CP_ACP, 0, path, -1, temppath, len); 807 pathW = temppath; 808 } 809 810 if (psfi) 811 { 812 temppsfi.hIcon = psfi->hIcon; 813 temppsfi.iIcon = psfi->iIcon; 814 temppsfi.dwAttributes = psfi->dwAttributes; 815 816 ret = SHGetFileInfoW(pathW, dwFileAttributes, &temppsfi, sizeof(temppsfi), flags); 817 psfi->hIcon = temppsfi.hIcon; 818 psfi->iIcon = temppsfi.iIcon; 819 psfi->dwAttributes = temppsfi.dwAttributes; 820 821 WideCharToMultiByte(CP_ACP, 0, temppsfi.szDisplayName, -1, 822 psfi->szDisplayName, sizeof(psfi->szDisplayName), NULL, NULL); 823 824 WideCharToMultiByte(CP_ACP, 0, temppsfi.szTypeName, -1, 825 psfi->szTypeName, sizeof(psfi->szTypeName), NULL, NULL); 826 } 827 else 828 ret = SHGetFileInfoW(pathW, dwFileAttributes, NULL, 0, flags); 829 830 HeapFree(GetProcessHeap(), 0, temppath); 831 832 return ret; 833 } 834 835 /************************************************************************* 836 * DuplicateIcon [SHELL32.@] 837 */ 838 HICON WINAPI DuplicateIcon( HINSTANCE hInstance, HICON hIcon) 839 { 840 ICONINFO IconInfo; 841 HICON hDupIcon = 0; 842 843 TRACE("%p %p\n", hInstance, hIcon); 844 845 if (GetIconInfo(hIcon, &IconInfo)) 846 { 847 hDupIcon = CreateIconIndirect(&IconInfo); 848 849 /* clean up hbmMask and hbmColor */ 850 DeleteObject(IconInfo.hbmMask); 851 DeleteObject(IconInfo.hbmColor); 852 } 853 854 return hDupIcon; 855 } 856 857 /************************************************************************* 858 * ExtractIconA [SHELL32.@] 859 */ 860 HICON WINAPI ExtractIconA(HINSTANCE hInstance, LPCSTR lpszFile, UINT nIconIndex) 861 { 862 HICON ret; 863 INT len = MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, NULL, 0); 864 LPWSTR lpwstrFile = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); 865 866 TRACE("%p %s %d\n", hInstance, lpszFile, nIconIndex); 867 868 MultiByteToWideChar(CP_ACP, 0, lpszFile, -1, lpwstrFile, len); 869 ret = ExtractIconW(hInstance, lpwstrFile, nIconIndex); 870 HeapFree(GetProcessHeap(), 0, lpwstrFile); 871 872 return ret; 873 } 874 875 /************************************************************************* 876 * ExtractIconW [SHELL32.@] 877 */ 878 HICON WINAPI ExtractIconW(HINSTANCE hInstance, LPCWSTR lpszFile, UINT nIconIndex) 879 { 880 HICON hIcon = NULL; 881 UINT ret; 882 UINT cx = GetSystemMetrics(SM_CXICON), cy = GetSystemMetrics(SM_CYICON); 883 884 TRACE("%p %s %d\n", hInstance, debugstr_w(lpszFile), nIconIndex); 885 886 if (nIconIndex == (UINT)-1) 887 { 888 ret = PrivateExtractIconsW(lpszFile, 0, cx, cy, NULL, NULL, 0, LR_DEFAULTCOLOR); 889 if (ret != (UINT)-1 && ret) 890 return (HICON)(UINT_PTR)ret; 891 return NULL; 892 } 893 else 894 ret = PrivateExtractIconsW(lpszFile, nIconIndex, cx, cy, &hIcon, NULL, 1, LR_DEFAULTCOLOR); 895 896 if (ret == (UINT)-1) 897 return (HICON)1; 898 else if (ret > 0 && hIcon) 899 return hIcon; 900 901 return NULL; 902 } 903 904 /************************************************************************* 905 * Printer_LoadIconsW [SHELL32.205] 906 */ 907 VOID WINAPI Printer_LoadIconsW(LPCWSTR wsPrinterName, HICON * pLargeIcon, HICON * pSmallIcon) 908 { 909 INT iconindex=IDI_SHELL_PRINTERS_FOLDER; 910 911 TRACE("(%s, %p, %p)\n", debugstr_w(wsPrinterName), pLargeIcon, pSmallIcon); 912 913 /* We should check if wsPrinterName is 914 1. the Default Printer or not 915 2. connected or not 916 3. a Local Printer or a Network-Printer 917 and use different Icons 918 */ 919 if((wsPrinterName != NULL) && (wsPrinterName[0] != 0)) 920 { 921 FIXME("(select Icon by PrinterName %s not implemented)\n", debugstr_w(wsPrinterName)); 922 } 923 924 if(pLargeIcon != NULL) 925 *pLargeIcon = LoadImageW(shell32_hInstance, 926 (LPCWSTR) MAKEINTRESOURCE(iconindex), IMAGE_ICON, 927 0, 0, LR_DEFAULTCOLOR|LR_DEFAULTSIZE); 928 929 if(pSmallIcon != NULL) 930 *pSmallIcon = LoadImageW(shell32_hInstance, 931 (LPCWSTR) MAKEINTRESOURCE(iconindex), IMAGE_ICON, 932 16, 16, LR_DEFAULTCOLOR); 933 } 934 935 /************************************************************************* 936 * Printers_RegisterWindowW [SHELL32.213] 937 * used by "printui.dll": 938 * find the Window of the given Type for the specific Printer and 939 * return the already existent hwnd or open a new window 940 */ 941 BOOL WINAPI Printers_RegisterWindowW(LPCWSTR wsPrinter, DWORD dwType, 942 HANDLE * phClassPidl, HWND * phwnd) 943 { 944 FIXME("(%s, %x, %p (%p), %p (%p)) stub!\n", debugstr_w(wsPrinter), dwType, 945 phClassPidl, (phClassPidl != NULL) ? *(phClassPidl) : NULL, 946 phwnd, (phwnd != NULL) ? *(phwnd) : NULL); 947 948 return FALSE; 949 } 950 951 /************************************************************************* 952 * Printers_UnregisterWindow [SHELL32.214] 953 */ 954 VOID WINAPI Printers_UnregisterWindow(HANDLE hClassPidl, HWND hwnd) 955 { 956 FIXME("(%p, %p) stub!\n", hClassPidl, hwnd); 957 } 958 959 /*************************************************************************/ 960 961 typedef struct 962 { 963 LPCWSTR szApp; 964 LPCWSTR szOtherStuff; 965 HICON hIcon; 966 } ABOUT_INFO; 967 968 #define DROP_FIELD_TOP (-15) 969 #define DROP_FIELD_HEIGHT 15 970 971 /************************************************************************* 972 * SHAppBarMessage [SHELL32.@] 973 */ 974 UINT_PTR WINAPI SHAppBarMessage(DWORD msg, PAPPBARDATA data) 975 { 976 int width=data->rc.right - data->rc.left; 977 int height=data->rc.bottom - data->rc.top; 978 RECT rec=data->rc; 979 980 TRACE("msg=%d, data={cb=%d, hwnd=%p, callback=%x, edge=%d, rc=%s, lparam=%lx}\n", 981 msg, data->cbSize, data->hWnd, data->uCallbackMessage, data->uEdge, 982 wine_dbgstr_rect(&data->rc), data->lParam); 983 984 switch (msg) 985 { 986 case ABM_GETSTATE: 987 return ABS_ALWAYSONTOP | ABS_AUTOHIDE; 988 989 case ABM_GETTASKBARPOS: 990 GetWindowRect(data->hWnd, &rec); 991 data->rc=rec; 992 return TRUE; 993 994 case ABM_ACTIVATE: 995 SetActiveWindow(data->hWnd); 996 return TRUE; 997 998 case ABM_GETAUTOHIDEBAR: 999 return 0; /* pretend there is no autohide bar */ 1000 1001 case ABM_NEW: 1002 /* cbSize, hWnd, and uCallbackMessage are used. All other ignored */ 1003 SetWindowPos(data->hWnd,HWND_TOP,0,0,0,0,SWP_SHOWWINDOW|SWP_NOMOVE|SWP_NOSIZE); 1004 return TRUE; 1005 1006 case ABM_QUERYPOS: 1007 GetWindowRect(data->hWnd, &(data->rc)); 1008 return TRUE; 1009 1010 case ABM_REMOVE: 1011 FIXME("ABM_REMOVE broken\n"); 1012 /* FIXME: this is wrong; should it be DestroyWindow instead? */ 1013 /*CloseHandle(data->hWnd);*/ 1014 return TRUE; 1015 1016 case ABM_SETAUTOHIDEBAR: 1017 SetWindowPos(data->hWnd,HWND_TOP,rec.left+1000,rec.top, 1018 width,height,SWP_SHOWWINDOW); 1019 return TRUE; 1020 1021 case ABM_SETPOS: 1022 data->uEdge=(ABE_RIGHT | ABE_LEFT); 1023 SetWindowPos(data->hWnd,HWND_TOP,data->rc.left,data->rc.top, 1024 width,height,SWP_SHOWWINDOW); 1025 return TRUE; 1026 1027 case ABM_WINDOWPOSCHANGED: 1028 return TRUE; 1029 } 1030 1031 return FALSE; 1032 } 1033 1034 /************************************************************************* 1035 * SHHelpShortcuts_RunDLLA [SHELL32.@] 1036 * 1037 */ 1038 DWORD WINAPI SHHelpShortcuts_RunDLLA(DWORD dwArg1, DWORD dwArg2, DWORD dwArg3, DWORD dwArg4) 1039 { 1040 FIXME("(%x, %x, %x, %x) stub!\n", dwArg1, dwArg2, dwArg3, dwArg4); 1041 return 0; 1042 } 1043 1044 /************************************************************************* 1045 * SHHelpShortcuts_RunDLLA [SHELL32.@] 1046 * 1047 */ 1048 DWORD WINAPI SHHelpShortcuts_RunDLLW(DWORD dwArg1, DWORD dwArg2, DWORD dwArg3, DWORD dwArg4) 1049 { 1050 FIXME("(%x, %x, %x, %x) stub!\n", dwArg1, dwArg2, dwArg3, dwArg4); 1051 return 0; 1052 } 1053 1054 /************************************************************************* 1055 * SHLoadInProc [SHELL32.@] 1056 * Create an instance of specified object class from within 1057 * the shell process and release it immediately 1058 */ 1059 HRESULT WINAPI SHLoadInProc (REFCLSID rclsid) 1060 { 1061 void *ptr = NULL; 1062 1063 TRACE("%s\n", debugstr_guid(rclsid)); 1064 1065 CoCreateInstance(rclsid, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown,&ptr); 1066 if(ptr) 1067 { 1068 IUnknown * pUnk = ptr; 1069 IUnknown_Release(pUnk); 1070 return S_OK; 1071 } 1072 return DISP_E_MEMBERNOTFOUND; 1073 } 1074 1075 static VOID SetRegTextData(HWND hWnd, HKEY hKey, LPCWSTR Value, UINT uID) 1076 { 1077 DWORD dwBufferSize; 1078 DWORD dwType; 1079 LPWSTR lpBuffer; 1080 1081 if( RegQueryValueExW(hKey, Value, NULL, &dwType, NULL, &dwBufferSize) == ERROR_SUCCESS ) 1082 { 1083 if(dwType == REG_SZ) 1084 { 1085 lpBuffer = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, dwBufferSize); 1086 1087 if(lpBuffer) 1088 { 1089 if( RegQueryValueExW(hKey, Value, NULL, &dwType, (LPBYTE)lpBuffer, &dwBufferSize) == ERROR_SUCCESS ) 1090 { 1091 SetDlgItemTextW(hWnd, uID, lpBuffer); 1092 } 1093 1094 HeapFree(GetProcessHeap(), 0, lpBuffer); 1095 } 1096 } 1097 } 1098 } 1099 1100 INT_PTR CALLBACK AboutAuthorsDlgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ) 1101 { 1102 switch(msg) 1103 { 1104 case WM_INITDIALOG: 1105 { 1106 const char* const *pstr = SHELL_Authors; 1107 1108 // Add the authors to the list 1109 SendDlgItemMessageW( hWnd, IDC_ABOUT_AUTHORS_LISTBOX, WM_SETREDRAW, FALSE, 0 ); 1110 1111 while (*pstr) 1112 { 1113 WCHAR name[64]; 1114 1115 /* authors list is in utf-8 format */ 1116 MultiByteToWideChar( CP_UTF8, 0, *pstr, -1, name, sizeof(name)/sizeof(WCHAR) ); 1117 SendDlgItemMessageW( hWnd, IDC_ABOUT_AUTHORS_LISTBOX, LB_ADDSTRING, (WPARAM)-1, (LPARAM)name ); 1118 pstr++; 1119 } 1120 1121 SendDlgItemMessageW( hWnd, IDC_ABOUT_AUTHORS_LISTBOX, WM_SETREDRAW, TRUE, 0 ); 1122 1123 return TRUE; 1124 } 1125 } 1126 1127 return FALSE; 1128 } 1129 /************************************************************************* 1130 * AboutDlgProc (internal) 1131 */ 1132 static INT_PTR CALLBACK AboutDlgProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam ) 1133 { 1134 static DWORD cxLogoBmp; 1135 static DWORD cyLogoBmp; 1136 static HBITMAP hLogoBmp; 1137 static HWND hWndAuthors; 1138 1139 switch(msg) 1140 { 1141 case WM_INITDIALOG: 1142 { 1143 ABOUT_INFO *info = (ABOUT_INFO *)lParam; 1144 1145 if (info) 1146 { 1147 const WCHAR szRegKey[] = L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"; 1148 HKEY hRegKey; 1149 MEMORYSTATUSEX MemStat; 1150 WCHAR szAppTitle[512]; 1151 WCHAR szAppTitleTemplate[512]; 1152 WCHAR szAuthorsText[20]; 1153 1154 // Preload the ROS bitmap 1155 hLogoBmp = (HBITMAP)LoadImage(shell32_hInstance, MAKEINTRESOURCE(IDB_REACTOS), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR); 1156 1157 if(hLogoBmp) 1158 { 1159 BITMAP bmpLogo; 1160 1161 GetObject( hLogoBmp, sizeof(BITMAP), &bmpLogo ); 1162 1163 cxLogoBmp = bmpLogo.bmWidth; 1164 cyLogoBmp = bmpLogo.bmHeight; 1165 } 1166 1167 // Set App-specific stuff (icon, app name, szOtherStuff string) 1168 SendDlgItemMessageW(hWnd, IDC_ABOUT_ICON, STM_SETICON, (WPARAM)info->hIcon, 0); 1169 1170 GetWindowTextW( hWnd, szAppTitleTemplate, sizeof(szAppTitleTemplate) / sizeof(WCHAR) ); 1171 swprintf( szAppTitle, szAppTitleTemplate, info->szApp ); 1172 SetWindowTextW( hWnd, szAppTitle ); 1173 1174 SetDlgItemTextW( hWnd, IDC_ABOUT_APPNAME, info->szApp ); 1175 SetDlgItemTextW( hWnd, IDC_ABOUT_OTHERSTUFF, info->szOtherStuff ); 1176 1177 // Set the registered user and organization name 1178 if(RegOpenKeyExW( HKEY_LOCAL_MACHINE, szRegKey, 0, KEY_QUERY_VALUE, &hRegKey ) == ERROR_SUCCESS) 1179 { 1180 SetRegTextData( hWnd, hRegKey, L"RegisteredOwner", IDC_ABOUT_REG_USERNAME ); 1181 SetRegTextData( hWnd, hRegKey, L"RegisteredOrganization", IDC_ABOUT_REG_ORGNAME ); 1182 1183 RegCloseKey( hRegKey ); 1184 } 1185 1186 // Set the value for the installed physical memory 1187 MemStat.dwLength = sizeof(MemStat); 1188 if( GlobalMemoryStatusEx(&MemStat) ) 1189 { 1190 WCHAR szBuf[12]; 1191 1192 if (MemStat.ullTotalPhys > 1024 * 1024 * 1024) 1193 { 1194 double dTotalPhys; 1195 WCHAR szDecimalSeparator[4]; 1196 WCHAR szUnits[3]; 1197 1198 // We're dealing with GBs or more 1199 MemStat.ullTotalPhys /= 1024 * 1024; 1200 1201 if (MemStat.ullTotalPhys > 1024 * 1024) 1202 { 1203 // We're dealing with TBs or more 1204 MemStat.ullTotalPhys /= 1024; 1205 1206 if (MemStat.ullTotalPhys > 1024 * 1024) 1207 { 1208 // We're dealing with PBs or more 1209 MemStat.ullTotalPhys /= 1024; 1210 1211 dTotalPhys = (double)MemStat.ullTotalPhys / 1024; 1212 wcscpy( szUnits, L"PB" ); 1213 } 1214 else 1215 { 1216 dTotalPhys = (double)MemStat.ullTotalPhys / 1024; 1217 wcscpy( szUnits, L"TB" ); 1218 } 1219 } 1220 else 1221 { 1222 dTotalPhys = (double)MemStat.ullTotalPhys / 1024; 1223 wcscpy( szUnits, L"GB" ); 1224 } 1225 1226 // We need the decimal point of the current locale to display the RAM size correctly 1227 if (GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, 1228 szDecimalSeparator, 1229 sizeof(szDecimalSeparator) / sizeof(WCHAR)) > 0) 1230 { 1231 UCHAR uDecimals; 1232 UINT uIntegral; 1233 1234 uIntegral = (UINT)dTotalPhys; 1235 uDecimals = (UCHAR)((UINT)(dTotalPhys * 100) - uIntegral * 100); 1236 1237 // Display the RAM size with 2 decimals 1238 swprintf(szBuf, L"%u%s%02u %s", uIntegral, szDecimalSeparator, uDecimals, szUnits); 1239 } 1240 } 1241 else 1242 { 1243 // We're dealing with MBs, don't show any decimals 1244 swprintf( szBuf, L"%u MB", (UINT)MemStat.ullTotalPhys / 1024 / 1024 ); 1245 } 1246 1247 SetDlgItemTextW( hWnd, IDC_ABOUT_PHYSMEM, szBuf); 1248 } 1249 1250 // Add the Authors dialog 1251 hWndAuthors = CreateDialogW( shell32_hInstance, MAKEINTRESOURCEW(IDD_ABOUT_AUTHORS), hWnd, AboutAuthorsDlgProc ); 1252 LoadStringW( shell32_hInstance, IDS_SHELL_ABOUT_AUTHORS, szAuthorsText, sizeof(szAuthorsText) / sizeof(WCHAR) ); 1253 SetDlgItemTextW( hWnd, IDC_ABOUT_AUTHORS, szAuthorsText ); 1254 } 1255 1256 return TRUE; 1257 } 1258 1259 case WM_PAINT: 1260 { 1261 if(hLogoBmp) 1262 { 1263 PAINTSTRUCT ps; 1264 HDC hdc; 1265 HDC hdcMem; 1266 1267 hdc = BeginPaint(hWnd, &ps); 1268 hdcMem = CreateCompatibleDC(hdc); 1269 1270 if(hdcMem) 1271 { 1272 SelectObject(hdcMem, hLogoBmp); 1273 BitBlt(hdc, 0, 0, cxLogoBmp, cyLogoBmp, hdcMem, 0, 0, SRCCOPY); 1274 1275 DeleteDC(hdcMem); 1276 } 1277 1278 EndPaint(hWnd, &ps); 1279 } 1280 }; break; 1281 1282 case WM_COMMAND: 1283 { 1284 switch(wParam) 1285 { 1286 case IDOK: 1287 case IDCANCEL: 1288 EndDialog(hWnd, TRUE); 1289 return TRUE; 1290 1291 case IDC_ABOUT_AUTHORS: 1292 { 1293 static BOOL bShowingAuthors = FALSE; 1294 WCHAR szAuthorsText[20]; 1295 1296 if(bShowingAuthors) 1297 { 1298 LoadStringW( shell32_hInstance, IDS_SHELL_ABOUT_AUTHORS, szAuthorsText, sizeof(szAuthorsText) / sizeof(WCHAR) ); 1299 ShowWindow( hWndAuthors, SW_HIDE ); 1300 } 1301 else 1302 { 1303 LoadStringW( shell32_hInstance, IDS_SHELL_ABOUT_BACK, szAuthorsText, sizeof(szAuthorsText) / sizeof(WCHAR) ); 1304 ShowWindow( hWndAuthors, SW_SHOW ); 1305 } 1306 1307 SetDlgItemTextW( hWnd, IDC_ABOUT_AUTHORS, szAuthorsText ); 1308 bShowingAuthors = !bShowingAuthors; 1309 return TRUE; 1310 } 1311 } 1312 }; break; 1313 1314 case WM_CLOSE: 1315 EndDialog(hWnd, TRUE); 1316 break; 1317 } 1318 1319 return 0; 1320 } 1321 1322 1323 /************************************************************************* 1324 * ShellAboutA [SHELL32.288] 1325 */ 1326 BOOL WINAPI ShellAboutA( HWND hWnd, LPCSTR szApp, LPCSTR szOtherStuff, HICON hIcon ) 1327 { 1328 BOOL ret; 1329 LPWSTR appW = NULL, otherW = NULL; 1330 int len; 1331 1332 if (szApp) 1333 { 1334 len = MultiByteToWideChar(CP_ACP, 0, szApp, -1, NULL, 0); 1335 appW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); 1336 MultiByteToWideChar(CP_ACP, 0, szApp, -1, appW, len); 1337 } 1338 if (szOtherStuff) 1339 { 1340 len = MultiByteToWideChar(CP_ACP, 0, szOtherStuff, -1, NULL, 0); 1341 otherW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR)); 1342 MultiByteToWideChar(CP_ACP, 0, szOtherStuff, -1, otherW, len); 1343 } 1344 1345 ret = ShellAboutW(hWnd, appW, otherW, hIcon); 1346 1347 HeapFree(GetProcessHeap(), 0, otherW); 1348 HeapFree(GetProcessHeap(), 0, appW); 1349 return ret; 1350 } 1351 1352 1353 /************************************************************************* 1354 * ShellAboutW [SHELL32.289] 1355 */ 1356 BOOL WINAPI ShellAboutW( HWND hWnd, LPCWSTR szApp, LPCWSTR szOtherStuff, 1357 HICON hIcon ) 1358 { 1359 ABOUT_INFO info; 1360 HRSRC hRes; 1361 DLGTEMPLATE *DlgTemplate; 1362 BOOL bRet; 1363 1364 TRACE("\n"); 1365 1366 // DialogBoxIndirectParamW will be called with the hInstance of the calling application, so we have to preload the dialog template 1367 hRes = FindResourceW(shell32_hInstance, MAKEINTRESOURCEW(IDD_ABOUT), (LPWSTR)RT_DIALOG); 1368 if(!hRes) 1369 return FALSE; 1370 1371 DlgTemplate = (DLGTEMPLATE *)LoadResource(shell32_hInstance, hRes); 1372 if(!DlgTemplate) 1373 return FALSE; 1374 1375 info.szApp = szApp; 1376 info.szOtherStuff = szOtherStuff; 1377 info.hIcon = hIcon ? hIcon : LoadIconW( 0, (LPWSTR)IDI_WINLOGO ); 1378 1379 bRet = DialogBoxIndirectParamW((HINSTANCE)GetWindowLongPtrW( hWnd, GWLP_HINSTANCE ), 1380 DlgTemplate, hWnd, AboutDlgProc, (LPARAM)&info ); 1381 return bRet; 1382 } 1383 1384 /************************************************************************* 1385 * FreeIconList (SHELL32.@) 1386 */ 1387 void WINAPI FreeIconList( DWORD dw ) 1388 { 1389 FIXME("%x: stub\n",dw); 1390 } 1391 1392 /************************************************************************* 1393 * SHLoadNonloadedIconOverlayIdentifiers (SHELL32.@) 1394 */ 1395 HRESULT WINAPI SHLoadNonloadedIconOverlayIdentifiers( VOID ) 1396 { 1397 FIXME("stub\n"); 1398 return S_OK; 1399 } 1400