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