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