reactos/dll/win32/shell32/wine/classes.c

   1 /*
   2  *      file type mapping
   3  *      (HKEY_CLASSES_ROOT - Stuff)
   4  *
   5  * Copyright 1998, 1999, 2000 Juergen Schmied
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <wine/config.h>
  23
  24 #include <stdio.h>
  25
  26 #define WIN32_NO_STATUS
  27 #define _INC_WINDOWS
  28 #define COBJMACROS
  29
  30 #include <windef.h>
  31 #include <winbase.h>
  32 #include <shlobj.h>
  33 #include <shlguid_undoc.h>
  34 #include <shlwapi.h>
  35 #include <wine/debug.h>
  36 #include <wine/unicode.h>
  37
  38 #include "pidl.h"
  39 #include "shell32_main.h"
  40 #include "shresdef.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  43
  44 #define MAX_EXTENSION_LENGTH 20
  45
  46 BOOL HCR_MapTypeToValueW(LPCWSTR szExtension, LPWSTR szFileType, LONG len, BOOL bPrependDot)
  47 {
  48         HKEY    hkey;
  49         WCHAR   szTemp[MAX_EXTENSION_LENGTH + 2];
  50
  51         TRACE("%s %p\n", debugstr_w(szExtension), szFileType);
  52
  53         /* added because we do not want to have double dots */
  54         if (szExtension[0] == '.')
  55           bPrependDot = FALSE;
  56
  57         if (bPrependDot)
  58           szTemp[0] = '.';
  59
  60         lstrcpynW(szTemp + (bPrependDot?1:0), szExtension, MAX_EXTENSION_LENGTH);
  61
  62         if (RegOpenKeyExW(HKEY_CLASSES_ROOT, szTemp, 0, KEY_READ, &hkey))
  63         {
  64           return FALSE;
  65         }
  66
  67         if (RegQueryValueW(hkey, NULL, szFileType, &len))
  68         {
  69           RegCloseKey(hkey);
  70           return FALSE;
  71         }
  72
  73         RegCloseKey(hkey);
  74
  75         TRACE("--UE;\n} %s\n", debugstr_w(szFileType));
  76
  77         return TRUE;
  78 }
  79
  80 BOOL HCR_MapTypeToValueA(LPCSTR szExtension, LPSTR szFileType, LONG len, BOOL bPrependDot)
  81 {
  82         HKEY    hkey;
  83         char    szTemp[MAX_EXTENSION_LENGTH + 2];
  84
  85         TRACE("%s %p\n", szExtension, szFileType);
  86
  87         /* added because we do not want to have double dots */
  88         if (szExtension[0] == '.')
  89           bPrependDot = FALSE;
  90
  91         if (bPrependDot)
  92           szTemp[0] = '.';
  93
  94         lstrcpynA(szTemp + (bPrependDot?1:0), szExtension, MAX_EXTENSION_LENGTH);
  95
  96         if (RegOpenKeyExA(HKEY_CLASSES_ROOT, szTemp, 0, KEY_READ, &hkey))
  97         {
  98           return FALSE;
  99         }
 100
 101 #ifdef __REACTOS__
 102         if (!RegLoadMUIStringA(hkey, "FriendlyTypeName", szFileType, len, NULL, 0, NULL))
 103         {
 104             RegCloseKey(hkey);
 105             return TRUE;
 106         }
 107 #endif
 108
 109         if (RegQueryValueA(hkey, NULL, szFileType, &len))
 110         {
 111           RegCloseKey(hkey);
 112           return FALSE;
 113         }
 114
 115         RegCloseKey(hkey);
 116
 117         TRACE("--UE;\n} %s\n", szFileType);
 118
 119         return TRUE;
 120 }
 121
 122 static const WCHAR swShell[] = {'s','h','e','l','l','\\',0};
 123 static const WCHAR swOpen[] = {'o','p','e','n',0};
 124 static const WCHAR swCommand[] = {'\\','c','o','m','m','a','n','d',0};
 125
 126 BOOL HCR_GetDefaultVerbW( HKEY hkeyClass, LPCWSTR szVerb, LPWSTR szDest, DWORD len )
 127 {
 128         WCHAR sTemp[MAX_PATH];
 129         LONG size;
 130         HKEY hkey;
 131
 132         TRACE("%p %s %p\n", hkeyClass, debugstr_w(szVerb), szDest);
 133
 134         if (szVerb && *szVerb)
 135         {
 136             lstrcpynW(szDest, szVerb, len);
 137             return TRUE;
 138         }
 139
 140         size=len;
 141         *szDest='\0';
 142         if (!RegQueryValueW(hkeyClass, swShell, szDest, &size) && *szDest)
 143         {
 144             /* The MSDN says to first try the default verb */
 145             lstrcpyW(sTemp, swShell);
 146             lstrcatW(sTemp, szDest);
 147             lstrcatW(sTemp, swCommand);
 148             if (!RegOpenKeyExW(hkeyClass, sTemp, 0, KEY_READ, &hkey))
 149             {
 150                 RegCloseKey(hkey);
 151                 TRACE("default verb=%s\n", debugstr_w(szDest));
 152                 return TRUE;
 153             }
 154         }
 155
 156         /* then fallback to 'open' */
 157         lstrcpyW(sTemp, swShell);
 158         lstrcatW(sTemp, swOpen);
 159         lstrcatW(sTemp, swCommand);
 160         if (!RegOpenKeyExW(hkeyClass, sTemp, 0, KEY_READ, &hkey))
 161         {
 162             RegCloseKey(hkey);
 163             lstrcpynW(szDest, swOpen, len);
 164             TRACE("default verb=open\n");
 165             return TRUE;
 166         }
 167
 168         /* and then just use the first verb on Windows >= 2000 */
 169 #ifdef __REACTOS__
 170         if (!RegOpenKeyExW(hkeyClass, L"shell", 0, KEY_READ, &hkey))
 171         {
 172             if (!RegEnumKeyW(hkey, 0, szDest, len) && *szDest)
 173             {
 174                 TRACE("default verb=first verb=%s\n", debugstr_w(szDest));
 175                 RegCloseKey(hkey);
 176                 return TRUE;
 177             }
 178             RegCloseKey(hkey);
 179         }
 180 #else
 181         if (!RegEnumKeyW(hkeyClass, 0, szDest, len) && *szDest)
 182         {
 183             TRACE("default verb=first verb=%s\n", debugstr_w(szDest));
 184             return TRUE;
 185         }
 186 #endif
 187
 188         TRACE("no default verb!\n");
 189         return FALSE;
 190 }
 191
 192 BOOL HCR_GetExecuteCommandW( HKEY hkeyClass, LPCWSTR szClass, LPCWSTR szVerb, LPWSTR szDest, DWORD len )
 193 {
 194         WCHAR sTempVerb[MAX_PATH];
 195         BOOL ret;
 196
 197         TRACE("%p %s %s %p\n", hkeyClass, debugstr_w(szClass), debugstr_w(szVerb), szDest);
 198
 199         if (szClass)
 200             RegOpenKeyExW(HKEY_CLASSES_ROOT, szClass, 0, KEY_READ, &hkeyClass);
 201         if (!hkeyClass)
 202             return FALSE;
 203         ret = FALSE;
 204
 205         if (HCR_GetDefaultVerbW(hkeyClass, szVerb, sTempVerb, sizeof(sTempVerb)/sizeof(sTempVerb[0])))
 206         {
 207             WCHAR sTemp[MAX_PATH];
 208             lstrcpyW(sTemp, swShell);
 209             lstrcatW(sTemp, sTempVerb);
 210             lstrcatW(sTemp, swCommand);
 211             ret = (ERROR_SUCCESS == SHGetValueW(hkeyClass, sTemp, NULL, NULL, szDest, &len));
 212         }
 213         if (szClass)
 214             RegCloseKey(hkeyClass);
 215
 216         TRACE("-- %s\n", debugstr_w(szDest) );
 217         return ret;
 218 }
 219
 220 /***************************************************************************************
 221 *       HCR_GetDefaultIcon      [internal]
 222 *
 223 * Gets the icon for a filetype
 224 */
 225 static BOOL HCR_RegOpenClassIDKey(REFIID riid, HKEY *hkey)
 226 {
 227         char    xriid[50];
 228     sprintf( xriid, "CLSID\\{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
 229                  riid->Data1, riid->Data2, riid->Data3,
 230                  riid->Data4[0], riid->Data4[1], riid->Data4[2], riid->Data4[3],
 231                  riid->Data4[4], riid->Data4[5], riid->Data4[6], riid->Data4[7] );
 232
 233         TRACE("%s\n",xriid );
 234
 235         return !RegOpenKeyExA(HKEY_CLASSES_ROOT, xriid, 0, KEY_READ, hkey);
 236 }
 237
 238 static BOOL HCR_RegGetIconW(HKEY hkey, LPWSTR szDest, LPCWSTR szName, DWORD len, int* picon_idx)
 239 {
 240     DWORD dwType;
 241     WCHAR sTemp[MAX_PATH];
 242     WCHAR sNum[7];
 243
 244     if (!RegQueryValueExW(hkey, szName, 0, &dwType, (LPBYTE)szDest, &len))
 245     {
 246       if (dwType == REG_EXPAND_SZ)
 247       {
 248         ExpandEnvironmentStringsW(szDest, sTemp, MAX_PATH);
 249         lstrcpynW(szDest, sTemp, len);
 250       }
 251         if (ParseFieldW (szDest, 2, sNum, _countof(sNum)))
 252              *picon_idx = atoiW(sNum);
 253           else
 254              *picon_idx=0; /* sometimes the icon number is missing */
 255       ParseFieldW (szDest, 1, szDest, len);
 256           PathUnquoteSpacesW(szDest);
 257       return TRUE;
 258     }
 259     return FALSE;
 260 }
 261
 262 static BOOL HCR_RegGetIconA(HKEY hkey, LPSTR szDest, LPCSTR szName, DWORD len, int* picon_idx)
 263 {
 264         DWORD dwType;
 265         char sTemp[MAX_PATH];
 266         char  sNum[5];
 267
 268         if (!RegQueryValueExA(hkey, szName, 0, &dwType, (LPBYTE)szDest, &len))
 269         {
 270           if (dwType == REG_EXPAND_SZ)
 271           {
 272             ExpandEnvironmentStringsA(szDest, sTemp, MAX_PATH);
 273             lstrcpynA(szDest, sTemp, len);
 274           }
 275           if (ParseFieldA (szDest, 2, sNum, 5))
 276              *picon_idx=atoi(sNum);
 277           else
 278              *picon_idx=0; /* sometimes the icon number is missing */
 279           ParseFieldA (szDest, 1, szDest, len);
 280           PathUnquoteSpacesA(szDest);
 281           return TRUE;
 282         }
 283         return FALSE;
 284 }
 285
 286 BOOL HCR_GetIconW(LPCWSTR szClass, LPWSTR szDest, LPCWSTR szName, DWORD len, int* picon_idx)
 287 {
 288         static const WCHAR swDefaultIcon[] = {'\\','D','e','f','a','u','l','t','I','c','o','n',0};
 289         HKEY    hkey;
 290         WCHAR   sTemp[MAX_PATH];
 291         BOOL    ret = FALSE;
 292
 293         TRACE("%s\n",debugstr_w(szClass) );
 294
 295         lstrcpynW(sTemp, szClass, MAX_PATH);
 296         lstrcatW(sTemp, swDefaultIcon);
 297
 298         if (!RegOpenKeyExW(HKEY_CLASSES_ROOT, sTemp, 0, KEY_READ, &hkey))
 299         {
 300           ret = HCR_RegGetIconW(hkey, szDest, szName, len, picon_idx);
 301           RegCloseKey(hkey);
 302         }
 303
 304         if(ret)
 305             TRACE("-- %s %i\n", debugstr_w(szDest), *picon_idx);
 306         else
 307             TRACE("-- not found\n");
 308
 309         return ret;
 310 }
 311
 312 BOOL HCR_GetIconA(LPCSTR szClass, LPSTR szDest, LPCSTR szName, DWORD len, int* picon_idx)
 313 {
 314         HKEY    hkey;
 315         char    sTemp[MAX_PATH];
 316         BOOL    ret = FALSE;
 317
 318         TRACE("%s\n",szClass );
 319
 320         sprintf(sTemp, "%s\\DefaultIcon",szClass);
 321
 322         if (!RegOpenKeyExA(HKEY_CLASSES_ROOT, sTemp, 0, KEY_READ, &hkey))
 323         {
 324           ret = HCR_RegGetIconA(hkey, szDest, szName, len, picon_idx);
 325           RegCloseKey(hkey);
 326         }
 327         TRACE("-- %s %i\n", szDest, *picon_idx);
 328         return ret;
 329 }
 330
 331 /***************************************************************************************
 332 *       HCR_GetClassName        [internal]
 333 *
 334 * Gets the name of a registered class
 335 */
 336 static const WCHAR swEmpty[] = {0};
 337
 338 BOOL HCR_GetClassNameW(REFIID riid, LPWSTR szDest, DWORD len)
 339 {
 340         HKEY    hkey;
 341         BOOL ret = FALSE;
 342         DWORD buflen = len;
 343 #ifdef __REACTOS__
 344         WCHAR szName[100];
 345         LPOLESTR pStr;
 346 #endif
 347
 348         szDest[0] = 0;
 349
 350 #ifdef __REACTOS__
 351         if (StringFromCLSID(riid, &pStr) == S_OK)
 352         {
 353             DWORD dwLen = buflen * sizeof(WCHAR);
 354             swprintf(szName, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\%s", pStr);
 355             if (!RegGetValueW(HKEY_CURRENT_USER, szName, NULL, RRF_RT_REG_SZ, NULL, (PVOID)szDest, &dwLen))
 356             {
 357                 ret = TRUE;
 358             }
 359             CoTaskMemFree(pStr);
 360         }
 361         if (!ret && HCR_RegOpenClassIDKey(riid, &hkey))
 362 #else
 363         if (HCR_RegOpenClassIDKey(riid, &hkey))
 364 #endif
 365         {
 366           static const WCHAR wszLocalizedString[] =
 367             { 'L','o','c','a','l','i','z','e','d','S','t','r','i','n','g', 0 };
 368           if (!RegLoadMUIStringW(hkey, wszLocalizedString, szDest, len, NULL, 0, NULL) ||
 369               !RegQueryValueExW(hkey, swEmpty, 0, NULL, (LPBYTE)szDest, &len))
 370           {
 371             ret = TRUE;
 372           }
 373           RegCloseKey(hkey);
 374         }
 375
 376         if (!ret || !szDest[0])
 377         {
 378           if(IsEqualIID(riid, &CLSID_ShellDesktop))
 379           {
 380             if (LoadStringW(shell32_hInstance, IDS_DESKTOP, szDest, buflen))
 381               ret = TRUE;
 382           }
 383           else if (IsEqualIID(riid, &CLSID_MyComputer))
 384           {
 385             if(LoadStringW(shell32_hInstance, IDS_MYCOMPUTER, szDest, buflen))
 386               ret = TRUE;
 387           }
 388 #ifdef __REACTOS__
 389           else if (IsEqualIID(riid, &CLSID_MyDocuments))
 390           {
 391               if(LoadStringW(shell32_hInstance, IDS_PERSONAL, szDest, buflen))
 392                   ret = TRUE;
 393           }
 394           else if (IsEqualIID(riid, &CLSID_RecycleBin))
 395           {
 396               if(LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_FOLDER_NAME, szDest, buflen))
 397                   ret = TRUE;
 398           }
 399           else if (IsEqualIID(riid, &CLSID_ControlPanel))
 400           {
 401               if(LoadStringW(shell32_hInstance, IDS_CONTROLPANEL, szDest, buflen))
 402                   ret = TRUE;
 403           }
 404           else if (IsEqualIID(riid, &CLSID_AdminFolderShortcut))
 405           {
 406               if(LoadStringW(shell32_hInstance, IDS_ADMINISTRATIVETOOLS, szDest, buflen))
 407                   ret = TRUE;
 408           }
 409 #endif
 410         }
 411         TRACE("-- %s\n", debugstr_w(szDest));
 412         return ret;
 413 }
 414
 415 BOOL HCR_GetClassNameA(REFIID riid, LPSTR szDest, DWORD len)
 416 {       HKEY    hkey;
 417         BOOL ret = FALSE;
 418         DWORD buflen = len;
 419
 420         szDest[0] = 0;
 421         if (HCR_RegOpenClassIDKey(riid, &hkey))
 422         {
 423           if (!RegLoadMUIStringA(hkey,"LocalizedString",szDest,len,NULL,0,NULL) ||
 424               !RegQueryValueExA(hkey,"",0,NULL,(LPBYTE)szDest,&len))
 425           {
 426             ret = TRUE;
 427           }
 428           RegCloseKey(hkey);
 429         }
 430
 431         if (!ret || !szDest[0])
 432         {
 433           if(IsEqualIID(riid, &CLSID_ShellDesktop))
 434           {
 435             if (LoadStringA(shell32_hInstance, IDS_DESKTOP, szDest, buflen))
 436               ret = TRUE;
 437           }
 438           else if (IsEqualIID(riid, &CLSID_MyComputer))
 439           {
 440             if(LoadStringA(shell32_hInstance, IDS_MYCOMPUTER, szDest, buflen))
 441               ret = TRUE;
 442           }
 443         }
 444
 445         TRACE("-- (%s)\n", szDest);
 446
 447         return ret;
 448 }
 449
 450 /******************************************************************************
 451  * HCR_GetFolderAttributes [Internal]
 452  *
 453  * Query the registry for a shell folders' attributes
 454  *
 455  * PARAMS
 456  *  pidlFolder    [I]  A simple pidl of type PT_GUID.
 457  *  pdwAttributes [IO] In: Attributes to be queried, OUT: Resulting attributes.
 458  *
 459  * RETURNS
 460  *  TRUE:  Found information for the attributes in the registry
 461  *  FALSE: No attribute information found
 462  *
 463  * NOTES
 464  *  If queried for an attribute, which is set in the CallForAttributes registry
 465  *  value, the function binds to the shellfolder objects and queries it.
 466  */
 467 BOOL HCR_GetFolderAttributes(LPCITEMIDLIST pidlFolder, LPDWORD pdwAttributes)
 468 {
 469     HKEY hSFKey;
 470     LPOLESTR pwszCLSID;
 471     LONG lResult;
 472     DWORD dwTemp, dwLen;
 473     static const WCHAR wszAttributes[] = { 'A','t','t','r','i','b','u','t','e','s',0 };
 474     static const WCHAR wszCallForAttributes[] = {
 475         'C','a','l','l','F','o','r','A','t','t','r','i','b','u','t','e','s',0 };
 476     WCHAR wszShellFolderKey[] = { 'C','L','S','I','D','\\','{','0','0','0','2','1','4','0','0','-',
 477         '0','0','0','0','-','0','0','0','0','-','C','0','0','0','-','0','0','0','0','0','0','0',
 478         '0','0','0','4','6','}','\\','S','h','e','l','l','F','o','l','d','e','r',0 };
 479
 480     TRACE("(pidlFolder=%p, pdwAttributes=%p)\n", pidlFolder, pdwAttributes);
 481
 482     if (!_ILIsPidlSimple(pidlFolder)) {
 483         static BOOL firstHit = TRUE;
 484         if (firstHit) {
 485             ERR("should be called for simple PIDL's only!\n");
 486             firstHit = FALSE;
 487         }
 488         return FALSE;
 489     }
 490
 491     if (!_ILIsDesktop(pidlFolder)) {
 492         if (FAILED(StringFromCLSID(_ILGetGUIDPointer(pidlFolder), &pwszCLSID))) return FALSE;
 493         memcpy(&wszShellFolderKey[6], pwszCLSID, 38 * sizeof(WCHAR));
 494         CoTaskMemFree(pwszCLSID);
 495     }
 496
 497     lResult = RegOpenKeyExW(HKEY_CLASSES_ROOT, wszShellFolderKey, 0, KEY_READ, &hSFKey);
 498 #ifdef __REACTOS__
 499     if (lResult != ERROR_SUCCESS)
 500     {
 501         ERR("Cannot open key: %ls\n", wszShellFolderKey);
 502         return FALSE;
 503     }
 504 #else
 505     if (lResult != ERROR_SUCCESS) return FALSE;
 506 #endif
 507
 508     dwLen = sizeof(DWORD);
 509     lResult = RegQueryValueExW(hSFKey, wszCallForAttributes, 0, NULL, (LPBYTE)&dwTemp, &dwLen);
 510     if ((lResult == ERROR_SUCCESS) && (dwTemp & *pdwAttributes)) {
 511         LPSHELLFOLDER psfDesktop, psfFolder;
 512         HRESULT hr;
 513
 514         RegCloseKey(hSFKey);
 515         hr = SHGetDesktopFolder(&psfDesktop);
 516         if (SUCCEEDED(hr)) {
 517             hr = IShellFolder_BindToObject(psfDesktop, pidlFolder, NULL, &IID_IShellFolder,
 518                                            (LPVOID*)&psfFolder);
 519             if (SUCCEEDED(hr)) {
 520                 hr = IShellFolder_GetAttributesOf(psfFolder, 0, NULL, pdwAttributes);
 521                 IShellFolder_Release(psfFolder);
 522             }
 523             IShellFolder_Release(psfDesktop);
 524         }
 525         if (FAILED(hr)) return FALSE;
 526     } else {
 527         lResult = RegQueryValueExW(hSFKey, wszAttributes, 0, NULL, (LPBYTE)&dwTemp, &dwLen);
 528         RegCloseKey(hSFKey);
 529         if (lResult == ERROR_SUCCESS) {
 530             *pdwAttributes &= dwTemp;
 531         } else {
 532             return FALSE;
 533         }
 534     }
 535
 536     TRACE("-- *pdwAttributes == 0x%08x\n", *pdwAttributes);
 537
 538     return TRUE;
 539 }