dlls/comcat/register.c

   1 /*
   2  *      ComCatMgr ICatRegister implementation for comcat.dll
   3  *
   4  * Copyright (C) 2002 John K. Hohm
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "comcat_private.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  26
  27 /**********************************************************************
  28  * File-scope string constants
  29  */
  30 static const WCHAR comcat_keyname[21] = {
  31     'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n', 't', ' ', 'C', 'a',
  32     't', 'e', 'g', 'o', 'r', 'i', 'e', 's', 0 };
  33 static const WCHAR impl_keyname[23] = {
  34     'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n',
  35     't', 'e', 'd', ' ', 'C', 'a', 't', 'e',
  36     'g', 'o', 'r', 'i', 'e', 's', 0 };
  37 static const WCHAR req_keyname[20] = {
  38     'R', 'e', 'q', 'u', 'i', 'r', 'e', 'd',
  39     ' ', 'C', 'a', 't', 'e', 'g', 'o', 'r',
  40     'i', 'e', 's', 0 };
  41
  42 static HRESULT COMCAT_RegisterClassCategories(
  43     REFCLSID rclsid, LPCWSTR type,
  44     ULONG cCategories, const CATID *rgcatid);
  45 static HRESULT COMCAT_UnRegisterClassCategories(
  46     REFCLSID rclsid, LPCWSTR type,
  47     ULONG cCategories, const CATID *rgcatid);
  48
  49 /**********************************************************************
  50  * COMCAT_ICatRegister_QueryInterface
  51  */
  52 static HRESULT WINAPI COMCAT_ICatRegister_QueryInterface(
  53     LPCATREGISTER iface,
  54     REFIID riid,
  55     LPVOID *ppvObj)
  56 {
  57     ComCatMgrImpl *This = (ComCatMgrImpl *)iface;
  58     TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
  59
  60     if (ppvObj == NULL) return E_POINTER;
  61
  62     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ICatRegister)) {
  63         *ppvObj = iface;
  64         IUnknown_AddRef(iface);
  65         return S_OK;
  66     }
  67
  68     if (IsEqualGUID(riid, &IID_ICatInformation)) {
  69         *ppvObj = &This->infVtbl;
  70         IUnknown_AddRef(iface);
  71         return S_OK;
  72     }
  73
  74     return E_NOINTERFACE;
  75 }
  76
  77 /**********************************************************************
  78  * COMCAT_ICatRegister_AddRef
  79  */
  80 static ULONG WINAPI COMCAT_ICatRegister_AddRef(LPCATREGISTER iface)
  81 {
  82     return 2; /* non-heap based object */
  83 }
  84
  85 /**********************************************************************
  86  * COMCAT_ICatRegister_Release
  87  */
  88 static ULONG WINAPI COMCAT_ICatRegister_Release(LPCATREGISTER iface)
  89 {
  90     return 1; /* non-heap based object */
  91 }
  92
  93 /**********************************************************************
  94  * COMCAT_ICatRegister_RegisterCategories
  95  */
  96 static HRESULT WINAPI COMCAT_ICatRegister_RegisterCategories(
  97     LPCATREGISTER iface,
  98     ULONG cCategories,
  99     CATEGORYINFO *rgci)
 100 {
 101     HKEY comcat_key;
 102     HRESULT res;
 103
 104     TRACE("\n");
 105
 106     if (cCategories && rgci == NULL)
 107         return E_POINTER;
 108
 109     /* Create (or open) the component categories key. */
 110     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, comcat_keyname, 0, NULL, 0,
 111                           KEY_READ | KEY_WRITE, NULL, &comcat_key, NULL);
 112     if (res != ERROR_SUCCESS) return E_FAIL;
 113
 114     for (; cCategories; --cCategories, ++rgci) {
 115         static const WCHAR fmt[] = { '%', 'l', 'X', 0 };
 116         WCHAR keyname[39];
 117         WCHAR valname[9];
 118         HKEY cat_key;
 119
 120         /* Create (or open) the key for this category. */
 121         if (!StringFromGUID2(&rgci->catid, keyname, 39)) continue;
 122         res = RegCreateKeyExW(comcat_key, keyname, 0, NULL, 0,
 123                               KEY_READ | KEY_WRITE, NULL, &cat_key, NULL);
 124         if (res != ERROR_SUCCESS) continue;
 125
 126         /* Set the value for this locale's description. */
 127         wsprintfW(valname, fmt, rgci->lcid);
 128         RegSetValueExW(cat_key, valname, 0, REG_SZ,
 129                        (CONST BYTE*)(rgci->szDescription),
 130                        (lstrlenW(rgci->szDescription) + 1) * sizeof(WCHAR));
 131
 132         RegCloseKey(cat_key);
 133     }
 134
 135     RegCloseKey(comcat_key);
 136     return S_OK;
 137 }
 138
 139 /**********************************************************************
 140  * COMCAT_ICatRegister_UnRegisterCategories
 141  */
 142 static HRESULT WINAPI COMCAT_ICatRegister_UnRegisterCategories(
 143     LPCATREGISTER iface,
 144     ULONG cCategories,
 145     CATID *rgcatid)
 146 {
 147     HKEY comcat_key;
 148     HRESULT res;
 149
 150     TRACE("\n");
 151
 152     if (cCategories && rgcatid == NULL)
 153         return E_POINTER;
 154
 155     /* Open the component categories key. */
 156     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, comcat_keyname, 0,
 157                         KEY_READ | KEY_WRITE, &comcat_key);
 158     if (res != ERROR_SUCCESS) return E_FAIL;
 159
 160     for (; cCategories; --cCategories, ++rgcatid) {
 161         WCHAR keyname[39];
 162
 163         /* Delete the key for this category. */
 164         if (!StringFromGUID2(rgcatid, keyname, 39)) continue;
 165         RegDeleteKeyW(comcat_key, keyname);
 166     }
 167
 168     RegCloseKey(comcat_key);
 169     return S_OK;
 170 }
 171
 172 /**********************************************************************
 173  * COMCAT_ICatRegister_RegisterClassImplCategories
 174  */
 175 static HRESULT WINAPI COMCAT_ICatRegister_RegisterClassImplCategories(
 176     LPCATREGISTER iface,
 177     REFCLSID rclsid,
 178     ULONG cCategories,
 179     CATID *rgcatid)
 180 {
 181     TRACE("\n");
 182
 183     return COMCAT_RegisterClassCategories(
 184         rclsid, impl_keyname, cCategories, rgcatid);
 185 }
 186
 187 /**********************************************************************
 188  * COMCAT_ICatRegister_UnRegisterClassImplCategories
 189  */
 190 static HRESULT WINAPI COMCAT_ICatRegister_UnRegisterClassImplCategories(
 191     LPCATREGISTER iface,
 192     REFCLSID rclsid,
 193     ULONG cCategories,
 194     CATID *rgcatid)
 195 {
 196     TRACE("\n");
 197
 198     return COMCAT_UnRegisterClassCategories(
 199         rclsid, impl_keyname, cCategories, rgcatid);
 200 }
 201
 202 /**********************************************************************
 203  * COMCAT_ICatRegister_RegisterClassReqCategories
 204  */
 205 static HRESULT WINAPI COMCAT_ICatRegister_RegisterClassReqCategories(
 206     LPCATREGISTER iface,
 207     REFCLSID rclsid,
 208     ULONG cCategories,
 209     CATID *rgcatid)
 210 {
 211     TRACE("\n");
 212
 213     return COMCAT_RegisterClassCategories(
 214         rclsid, req_keyname, cCategories, rgcatid);
 215 }
 216
 217 /**********************************************************************
 218  * COMCAT_ICatRegister_UnRegisterClassReqCategories
 219  */
 220 static HRESULT WINAPI COMCAT_ICatRegister_UnRegisterClassReqCategories(
 221     LPCATREGISTER iface,
 222     REFCLSID rclsid,
 223     ULONG cCategories,
 224     CATID *rgcatid)
 225 {
 226     TRACE("\n");
 227
 228     return COMCAT_UnRegisterClassCategories(
 229         rclsid, req_keyname, cCategories, rgcatid);
 230 }
 231
 232 /**********************************************************************
 233  * COMCAT_ICatRegister_Vtbl
 234  */
 235 static const ICatRegisterVtbl COMCAT_ICatRegister_Vtbl =
 236 {
 237     COMCAT_ICatRegister_QueryInterface,
 238     COMCAT_ICatRegister_AddRef,
 239     COMCAT_ICatRegister_Release,
 240     COMCAT_ICatRegister_RegisterCategories,
 241     COMCAT_ICatRegister_UnRegisterCategories,
 242     COMCAT_ICatRegister_RegisterClassImplCategories,
 243     COMCAT_ICatRegister_UnRegisterClassImplCategories,
 244     COMCAT_ICatRegister_RegisterClassReqCategories,
 245     COMCAT_ICatRegister_UnRegisterClassReqCategories
 246 };
 247
 248
 249 /**********************************************************************
 250  * static ComCatMgr instance
 251  */
 252 ComCatMgrImpl COMCAT_ComCatMgr =
 253 {
 254     &COMCAT_ICatRegister_Vtbl,
 255     &COMCAT_ICatInformation_Vtbl
 256 };
 257
 258 /**********************************************************************
 259  * COMCAT_RegisterClassCategories
 260  */
 261 static HRESULT COMCAT_RegisterClassCategories(
 262     REFCLSID rclsid,
 263     LPCWSTR type,
 264     ULONG cCategories,
 265     const CATID *rgcatid)
 266 {
 267     WCHAR keyname[39];
 268     HRESULT res;
 269     HKEY clsid_key, class_key, type_key;
 270
 271     if (cCategories && rgcatid == NULL) return E_POINTER;
 272
 273     /* Format the class key name. */
 274     res = StringFromGUID2(rclsid, keyname, 39);
 275     if (FAILED(res)) return res;
 276
 277     /* Create (or open) the CLSID key. */
 278     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
 279                           KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
 280     if (res != ERROR_SUCCESS) return E_FAIL;
 281
 282     /* Create (or open) the class key. */
 283     res = RegCreateKeyExW(clsid_key, keyname, 0, NULL, 0,
 284                           KEY_READ | KEY_WRITE, NULL, &class_key, NULL);
 285     if (res == ERROR_SUCCESS) {
 286         /* Create (or open) the category type key. */
 287         res = RegCreateKeyExW(class_key, type, 0, NULL, 0,
 288                               KEY_READ | KEY_WRITE, NULL, &type_key, NULL);
 289         if (res == ERROR_SUCCESS) {
 290             for (; cCategories; --cCategories, ++rgcatid) {
 291                 HKEY key;
 292
 293                 /* Format the category key name. */
 294                 res = StringFromGUID2(rgcatid, keyname, 39);
 295                 if (FAILED(res)) continue;
 296
 297                 /* Do the register. */
 298                 res = RegCreateKeyExW(type_key, keyname, 0, NULL, 0,
 299                                       KEY_READ | KEY_WRITE, NULL, &key, NULL);
 300                 if (res == ERROR_SUCCESS) RegCloseKey(key);
 301             }
 302             res = S_OK;
 303         } else res = E_FAIL;
 304         RegCloseKey(class_key);
 305     } else res = E_FAIL;
 306     RegCloseKey(clsid_key);
 307
 308     return res;
 309 }
 310
 311 /**********************************************************************
 312  * COMCAT_UnRegisterClassCategories
 313  */
 314 static HRESULT COMCAT_UnRegisterClassCategories(
 315     REFCLSID rclsid,
 316     LPCWSTR type,
 317     ULONG cCategories,
 318     const CATID *rgcatid)
 319 {
 320     WCHAR keyname[68] = { 'C', 'L', 'S', 'I', 'D', '\\' };
 321     HRESULT res;
 322     HKEY type_key;
 323
 324     if (cCategories && rgcatid == NULL) return E_POINTER;
 325
 326     /* Format the class category type key name. */
 327     res = StringFromGUID2(rclsid, keyname + 6, 39);
 328     if (FAILED(res)) return res;
 329     keyname[44] = '\\';
 330     lstrcpyW(keyname + 45, type);
 331
 332     /* Open the class category type key. */
 333     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0,
 334                         KEY_READ | KEY_WRITE, &type_key);
 335     if (res != ERROR_SUCCESS) return E_FAIL;
 336
 337     for (; cCategories; --cCategories, ++rgcatid) {
 338         /* Format the category key name. */
 339         res = StringFromGUID2(rgcatid, keyname, 39);
 340         if (FAILED(res)) continue;
 341
 342         /* Do the unregister. */
 343         RegDeleteKeyW(type_key, keyname);
 344     }
 345     RegCloseKey(type_key);
 346
 347     return S_OK;
 348 }