dll/win32/shell32/classes.cpp

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