tree.c 22.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
/*
 * OleView (tree.c)
 *
 * Copyright 2006 Piotr Caban
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * 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 22 23 24
 */

#include "main.h"

TREE tree;
static const WCHAR wszCLSID[] = { 'C','L','S','I','D','\\','\0' };
25 26 27 28 29 30 31 32
static const WCHAR wszInProcServer32[] = 
    { 'I','n','P','r','o','c','S','e','r','v','e','r','3','2','\0' };
static const WCHAR wszOle32dll[] = { 'o','l','e','3','2','.','d','l','l','\0' };
static const WCHAR wszOleAut32dll[] =
    { 'o','l','e','a','u','t','3','2','.','d','l','l','\0' };
static const WCHAR wszImplementedCategories[] = 
    { 'I','m','p','l','e','m','e','n','t','e','d',' ',
        'C','a','t','e','g','o','r','i','e','s','\0' };
33 34 35 36 37
static const WCHAR wszAppID[] = { 'A','p','p','I','D','\\','\0' };
static const WCHAR wszTypeLib[] = { 'T','y','p','e','L','i','b','\\','\0' };
static const WCHAR wszInterface[] = { 'I','n','t','e','r','f','a','c','e','\\','\0' };
static const WCHAR wszComponentCategories[] = { 'C','o','m','p','o','n','e','n','t',
    ' ','C','a','t','e','g','o','r','i','e','s','\\','\0' };
38
static const WCHAR wszGetPath[] = { '0','\\','w','i','n','3','2','\0' };
39

40
static LPARAM CreateITEM_INFO(INT flag, const WCHAR *info, const WCHAR *clsid, const WCHAR *path)
41 42 43
{
    ITEM_INFO *reg;

44
    reg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(ITEM_INFO));
45 46

    reg->cFlag = flag;
47 48
    lstrcpyW(reg->info, info);
    if(clsid) lstrcpyW(reg->clsid, clsid);
49
    if(path) lstrcpyW(reg->path, path);
50 51 52 53

    return (LPARAM)reg;
}

54
void CreateInst(HTREEITEM item, WCHAR *wszMachineName)
55
{
56
    TVITEMW tvi;
57
    HTREEITEM hCur;
58
    TVINSERTSTRUCTW tvis;
59 60 61 62 63 64 65
    WCHAR wszTitle[MAX_LOAD_STRING];
    WCHAR wszMessage[MAX_LOAD_STRING];
    WCHAR wszFlagName[MAX_LOAD_STRING];
    WCHAR wszTreeName[MAX_LOAD_STRING];
    WCHAR wszRegPath[MAX_LOAD_STRING];
    const WCHAR wszFormat[] = { '\n','%','s',' ','(','$','%','x',')','\n','\0' };
    CLSID clsid;
66 67
    COSERVERINFO remoteInfo;
    MULTI_QI qi;
68 69 70
    IUnknown *obj, *unk;
    HRESULT hRes;

71
    memset(&tvi, 0, sizeof(TVITEMW));
72 73 74 75 76
    tvi.mask = TVIF_TEXT;
    tvi.hItem = item;
    tvi.cchTextMax = MAX_LOAD_STRING;
    tvi.pszText = wszTreeName;

77
    memset(&tvis, 0, sizeof(TVINSERTSTRUCTW));
78 79
    U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
    U(tvis).item.cchTextMax = MAX_LOAD_STRING;
80
    tvis.hInsertAfter = TVI_FIRST;
81
    U(tvis).item.pszText = tvi.pszText;
82 83 84
    tvis.hParent = item;
    tvis.hInsertAfter = TVI_LAST;

85
    SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
86 87 88 89 90 91

    if(!tvi.lParam || ((ITEM_INFO *)tvi.lParam)->loaded
                || !(((ITEM_INFO *)tvi.lParam)->cFlag&SHOWALL)) return;

    if(FAILED(CLSIDFromString(((ITEM_INFO *)tvi.lParam)->clsid, &clsid))) return;

92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
    if(wszMachineName)
    {
        remoteInfo.dwReserved1 = 0;
        remoteInfo.dwReserved2 = 0;
        remoteInfo.pAuthInfo = NULL;
        remoteInfo.pwszName = wszMachineName;

        qi.pIID = &IID_IUnknown;

        CoCreateInstanceEx(&clsid, NULL, globals.dwClsCtx|CLSCTX_REMOTE_SERVER,
                &remoteInfo, 1, &qi);
        hRes = qi.hr;
        obj = qi.pItf;
    }
    else hRes = CoCreateInstance(&clsid, NULL, globals.dwClsCtx,
107 108 109 110
            &IID_IUnknown, (void **)&obj);

    if(FAILED(hRes))
    {
111
        LoadStringW(globals.hMainInst, IDS_CGCOFAIL, wszMessage,
112
                sizeof(wszMessage)/sizeof(wszMessage[0]));
113
        LoadStringW(globals.hMainInst, IDS_ABOUT, wszTitle,
114
                sizeof(wszTitle)/sizeof(wszTitle[0]));
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132

#define CASE_ERR(i) case i: \
    MultiByteToWideChar(CP_ACP, 0, #i, -1, wszFlagName, MAX_LOAD_STRING); \
    break

        switch(hRes)
        {
            CASE_ERR(REGDB_E_CLASSNOTREG);
            CASE_ERR(E_NOINTERFACE);
            CASE_ERR(REGDB_E_READREGDB);
            CASE_ERR(REGDB_E_KEYMISSING);
            CASE_ERR(CO_E_DLLNOTFOUND);
            CASE_ERR(CO_E_APPNOTFOUND);
            CASE_ERR(E_ACCESSDENIED);
            CASE_ERR(CO_E_ERRORINDLL);
            CASE_ERR(CO_E_APPDIDNTREG);
            CASE_ERR(CLASS_E_CLASSNOTAVAILABLE);
            default:
133
                LoadStringW(globals.hMainInst, IDS_ERROR_UNKN, wszFlagName, sizeof(wszFlagName)/sizeof(wszFlagName[0]));
134 135
        }

136
        wsprintfW(&wszMessage[lstrlenW(wszMessage)], wszFormat,
137
                wszFlagName, (unsigned)hRes);
138
        MessageBoxW(globals.hMainWnd, wszMessage, wszTitle, MB_OK|MB_ICONEXCLAMATION);
139 140 141 142 143 144 145 146 147
        return;
    }

    ((ITEM_INFO *)tvi.lParam)->loaded = 1;
    ((ITEM_INFO *)tvi.lParam)->pU = obj;

    tvi.mask = TVIF_STATE;
    tvi.state = TVIS_BOLD;
    tvi.stateMask = TVIS_BOLD;
148
    SendMessageW(globals.hTree, TVM_SETITEMW, 0, (LPARAM)&tvi);
149 150

    tvi.mask = TVIF_TEXT;
151 152
    hCur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
            TVGN_CHILD, (LPARAM)tree.hI);
153 154 155 156

    while(hCur)
    {
        tvi.hItem = hCur;
157
        SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
158 159 160

        if(!tvi.lParam)
        {
161 162
            hCur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
                    TVGN_NEXT, (LPARAM)hCur);
163 164 165 166 167 168 169 170 171 172
            continue;
        }

        CLSIDFromString(((ITEM_INFO *)tvi.lParam)->clsid, &clsid);
        hRes = IUnknown_QueryInterface(obj, &clsid, (void *)&unk);

        if(SUCCEEDED(hRes))
        {
            IUnknown_Release(unk);

173 174
            lstrcpyW(wszRegPath, wszInterface);
            lstrcpyW(&wszRegPath[lstrlenW(wszRegPath)], ((ITEM_INFO *)tvi.lParam)->clsid);
175
            U(tvis).item.lParam = CreateITEM_INFO(REGTOP|INTERFACE|REGPATH,
176
                    wszRegPath, ((ITEM_INFO *)tvi.lParam)->clsid, NULL);
177
            SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
178
        }
179 180
        hCur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
                TVGN_NEXT, (LPARAM)hCur);
181
    }
182 183

    RefreshMenu(item);
184
    RefreshDetails(item);
185 186 187 188
}

void ReleaseInst(HTREEITEM item)
{
189
    TVITEMW tvi;
190 191 192
    HTREEITEM cur;
    IUnknown *pU;

193
    memset(&tvi, 0, sizeof(TVITEMW));
194
    tvi.hItem = item;
195
    SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
196 197 198 199 200 201 202 203

    if(!tvi.lParam) return;

    pU = ((ITEM_INFO *)tvi.lParam)->pU;

    if(pU) IUnknown_Release(pU);
    ((ITEM_INFO *)tvi.lParam)->loaded = 0;

204
    SendMessageW(globals.hTree, TVM_EXPAND, TVE_COLLAPSE, (LPARAM)item);
205

206 207
    cur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
            TVGN_CHILD, (LPARAM)item);
208 209
    while(cur)
    {
210
        SendMessageW(globals.hTree, TVM_DELETEITEM, 0, (LPARAM)cur);
211 212
        cur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
                TVGN_CHILD, (LPARAM)item);
213 214 215 216 217 218
    }

    tvi.mask = TVIF_CHILDREN|TVIF_STATE;
    tvi.state = 0;
    tvi.stateMask = TVIS_BOLD;
    tvi.cChildren = 1;
219
    SendMessageW(globals.hTree, TVM_SETITEMW, 0, (LPARAM)&tvi);
220 221
}

222 223
BOOL CreateRegPath(HTREEITEM item, WCHAR *buffer, int bufSize)
{
224
    TVITEMW tvi;
225 226 227 228
    int bufLen;
    BOOL ret;

    memset(buffer, 0, sizeof(WCHAR[bufSize]));
229
    memset(&tvi, 0, sizeof(TVITEMW));
230 231
    tvi.hItem = item;

232
    SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
233 234 235 236
    ret = (tvi.lParam && ((ITEM_INFO *)tvi.lParam)->cFlag & REGPATH);

    while(TRUE)
    {
237
        SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
238 239 240

        if(tvi.lParam && (((ITEM_INFO *)tvi.lParam)->cFlag & (REGPATH|REGTOP)))
        {
241
            bufLen = lstrlenW(((ITEM_INFO *)tvi.lParam)->info);
242 243 244 245 246 247 248 249
            memmove(&buffer[bufLen], buffer, sizeof(WCHAR[bufSize-bufLen]));
            memcpy(buffer, ((ITEM_INFO *)tvi.lParam)->info, sizeof(WCHAR[bufLen]));
        }

        if(tvi.lParam && ((ITEM_INFO *)tvi.lParam)->cFlag & REGTOP) break;

        if(!tvi.lParam) return FALSE;

250 251
        tvi.hItem = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
                TVGN_PARENT, (LPARAM)tvi.hItem);
252 253 254 255
    }
    return ret;
}

256
static void AddCOMandAll(void)
257
{
258 259
    TVINSERTSTRUCTW tvis;
    TVITEMW tvi;
260 261 262 263 264 265 266 267
    HTREEITEM curSearch;
    HKEY hKey, hCurKey, hInfo;
    WCHAR valName[MAX_LOAD_STRING];
    WCHAR buffer[MAX_LOAD_STRING];
    WCHAR wszComp[MAX_LOAD_STRING];
    LONG lenBuffer;
    int i=-1;

268
    memset(&tvi, 0, sizeof(TVITEMW));
269 270 271
    U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM|TVIF_CHILDREN;
    U(tvis).item.cchTextMax = MAX_LOAD_STRING;
    U(tvis).item.cChildren = 1;
272
    tvis.hInsertAfter = TVI_FIRST;
273

274
    if(RegOpenKeyW(HKEY_CLASSES_ROOT, wszCLSID, &hKey) != ERROR_SUCCESS) return;
275 276 277 278 279

    while(TRUE)
    {
        i++;

280
        if(RegEnumKeyW(hKey, i, valName, sizeof(valName)/sizeof(valName[0])) != ERROR_SUCCESS) break;
281

282
        if(RegOpenKeyW(hKey, valName, &hCurKey) != ERROR_SUCCESS) continue;
283 284 285 286

        lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);
        tvis.hParent = tree.hAO;

287
        if(RegOpenKeyW(hCurKey, wszInProcServer32, &hInfo) == ERROR_SUCCESS)
288
        {
289
            if(RegQueryValueW(hInfo, NULL, buffer, &lenBuffer) == ERROR_SUCCESS
290 291 292 293 294 295 296 297 298 299
                    && *buffer)
                if(!memcmp(buffer, wszOle32dll, sizeof(WCHAR[9]))
                        ||!memcmp(buffer, wszOleAut32dll, sizeof(WCHAR[12])))
                    tvis.hParent = tree.hCLO;

            RegCloseKey(hInfo);
        }

        lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);

300
        if(RegQueryValueW(hCurKey, NULL, buffer, &lenBuffer) == ERROR_SUCCESS && *buffer)
301 302
            U(tvis).item.pszText = buffer;
        else U(tvis).item.pszText = valName;
303

304
        U(tvis).item.lParam = CreateITEM_INFO(REGPATH|SHOWALL, valName, valName, NULL);
305
        if(tvis.hParent) SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
306

307
        if(RegOpenKeyW(hCurKey, wszImplementedCategories, &hInfo) == ERROR_SUCCESS)
308
        {
309
            if(RegEnumKeyW(hInfo, 0, wszComp, sizeof(wszComp)/sizeof(wszComp[0])) != ERROR_SUCCESS) break;
310 311 312

            RegCloseKey(hInfo);

313 314 315 316
            if(tree.hGBCC) curSearch = (HTREEITEM)SendMessageW(globals.hTree,
                    TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)tree.hGBCC);
            else curSearch = (HTREEITEM)SendMessageW(globals.hTree,
                    TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)TVI_ROOT);
317 318 319 320

            while(curSearch)
            {
                tvi.hItem = curSearch;
321
                SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
322

323
                if(tvi.lParam && !lstrcmpW(((ITEM_INFO *)tvi.lParam)->info, wszComp))
324 325 326 327 328
                {
                    tvis.hParent = curSearch;

                    memmove(&valName[6], valName, sizeof(WCHAR[MAX_LOAD_STRING-6]));
                    memmove(valName, wszCLSID, sizeof(WCHAR[6]));
329
                    U(tvis).item.lParam = CreateITEM_INFO(REGTOP|REGPATH|SHOWALL,
330
                            valName, &valName[6], NULL);
331

332
                    SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
333 334
                    break;
                }
335 336
                curSearch = (HTREEITEM)SendMessageW(globals.hTree,
                        TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)curSearch);
337 338 339 340 341 342
            }
        }
        RegCloseKey(hCurKey);
    }
    RegCloseKey(hKey);

343 344
    SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hCLO);
    SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hAO);
345 346
}

347
static void AddApplicationID(void)
348
{
349
    TVINSERTSTRUCTW tvis;
350 351 352 353 354 355
    HKEY hKey, hCurKey;
    WCHAR valName[MAX_LOAD_STRING];
    WCHAR buffer[MAX_LOAD_STRING];
    LONG lenBuffer;
    int i=-1;

356 357
    U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
    U(tvis).item.cchTextMax = MAX_LOAD_STRING;
358
    tvis.hInsertAfter = TVI_FIRST;
359 360
    tvis.hParent = tree.hAID;

361
    if(RegOpenKeyW(HKEY_CLASSES_ROOT, wszAppID, &hKey) != ERROR_SUCCESS) return;
362 363 364 365 366

    while(TRUE)
    {
        i++;

367
        if(RegEnumKeyW(hKey, i, valName, sizeof(valName)/sizeof(valName[0])) != ERROR_SUCCESS) break;
368

369
        if(RegOpenKeyW(hKey, valName, &hCurKey) != ERROR_SUCCESS) continue;
370 371 372

        lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);

373
        if(RegQueryValueW(hCurKey, NULL, buffer, &lenBuffer) == ERROR_SUCCESS && *buffer)
374 375
            U(tvis).item.pszText = buffer;
        else U(tvis).item.pszText = valName;
376 377 378

        RegCloseKey(hCurKey);

379
        U(tvis).item.lParam = CreateITEM_INFO(REGPATH, valName, valName, NULL);
380
        SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
381 382 383
    }
    RegCloseKey(hKey);

384
    SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hAID);
385 386
}

387
static void AddTypeLib(void)
388
{
389
    TVINSERTSTRUCTW tvis;
390
    HKEY hKey, hCurKey, hInfoKey, hPath;
391 392 393 394
    WCHAR valName[MAX_LOAD_STRING];
    WCHAR valParent[MAX_LOAD_STRING];
    WCHAR buffer[MAX_LOAD_STRING];
    WCHAR wszVer[MAX_LOAD_STRING];
395
    WCHAR wszPath[MAX_LOAD_STRING];
396 397 398 399 400
    const WCHAR wszFormat[] = { ' ','(','%','s',' ','%','s',')','\0' };
    const WCHAR wszFormat2[] = { '%','s','\\','%','s','\0' };
    LONG lenBuffer;
    int i=-1, j;

401 402
    U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
    U(tvis).item.cchTextMax = MAX_LOAD_STRING;
403
    tvis.hInsertAfter = TVI_FIRST;
404 405
    tvis.hParent = tree.hTL;

406
    if(RegOpenKeyW(HKEY_CLASSES_ROOT, wszTypeLib, &hKey) != ERROR_SUCCESS) return;
407 408 409 410 411

    while(TRUE)
    {
        i++;

412
        if(RegEnumKeyW(hKey, i, valParent, sizeof(valParent)/sizeof(valParent[0])) != ERROR_SUCCESS) break;
413

414
        if(RegOpenKeyW(hKey, valParent, &hCurKey) != ERROR_SUCCESS) continue;
415 416 417 418 419 420

        j = -1;
        while(TRUE)
        {
            j++;

421
            if(RegEnumKeyW(hCurKey, j, valName, sizeof(valName)/sizeof(valName[0])) != ERROR_SUCCESS) break;
422

423
            if(RegOpenKeyW(hCurKey, valName, &hInfoKey) != ERROR_SUCCESS) continue;
424 425 426

            lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);

427
            if(RegQueryValueW(hInfoKey, NULL, buffer, &lenBuffer) == ERROR_SUCCESS
428 429
                    && *buffer)
            {
430
                LoadStringW(globals.hMainInst, IDS_TL_VER, wszVer,
431
                        sizeof(wszVer)/sizeof(wszVer[0]));
432

433
                wsprintfW(&buffer[lstrlenW(buffer)], wszFormat, wszVer, valName);
434
                U(tvis).item.pszText = buffer;
435 436

                lenBuffer = MAX_LOAD_STRING;
437 438
                RegOpenKeyW(hInfoKey, wszGetPath, &hPath);
                RegQueryValueW(hPath, NULL, wszPath, &lenBuffer);
439
                RegCloseKey(hPath);
440
            }
441
            else U(tvis).item.pszText = valName;
442 443 444 445

            RegCloseKey(hInfoKey);

            wsprintfW(wszVer, wszFormat2, valParent, valName);
446
            U(tvis).item.lParam = CreateITEM_INFO(REGPATH, wszVer, valParent, wszPath);
447

448
            SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
449 450 451 452 453 454
        }
        RegCloseKey(hCurKey);
    }

    RegCloseKey(hKey);

455
    SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hTL);
456 457
}

458
static void AddInterfaces(void)
459
{
460
    TVINSERTSTRUCTW tvis;
461 462 463 464 465 466
    HKEY hKey, hCurKey;
    WCHAR valName[MAX_LOAD_STRING];
    WCHAR buffer[MAX_LOAD_STRING];
    LONG lenBuffer;
    int i=-1;

467 468
    U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
    U(tvis).item.cchTextMax = MAX_LOAD_STRING;
469
    tvis.hInsertAfter = TVI_FIRST;
470 471
    tvis.hParent = tree.hI;

472
    if(RegOpenKeyW(HKEY_CLASSES_ROOT, wszInterface, &hKey) != ERROR_SUCCESS) return;
473 474 475 476 477

    while(TRUE)
    {
        i++;

478
        if(RegEnumKeyW(hKey, i, valName, sizeof(valName)/sizeof(valName[0])) != ERROR_SUCCESS) break;
479

480
        if(RegOpenKeyW(hKey, valName, &hCurKey) != ERROR_SUCCESS) continue;
481 482 483

        lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);

484
        if(RegQueryValueW(hCurKey, NULL, buffer, &lenBuffer) == ERROR_SUCCESS && *buffer)
485 486
            U(tvis).item.pszText = buffer;
        else U(tvis).item.pszText = valName;
487 488 489

        RegCloseKey(hCurKey);

490
        U(tvis).item.lParam = CreateITEM_INFO(REGPATH|INTERFACE, valName, valName, NULL);
491
        SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
492 493 494 495
    }

    RegCloseKey(hKey);

496
    SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hI);
497 498
}

499
static void AddComponentCategories(void)
500
{
501
    TVINSERTSTRUCTW tvis;
502 503 504 505 506 507 508
    HKEY hKey, hCurKey;
    WCHAR valName[MAX_LOAD_STRING];
    WCHAR buffer[MAX_LOAD_STRING];
    LONG lenBuffer;
    DWORD lenBufferHlp;
    int i=-1;

509 510
    U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM|TVIF_CHILDREN;
    U(tvis).item.cchTextMax = MAX_LOAD_STRING;
511
    tvis.hInsertAfter = TVI_FIRST;
512 513
    if(tree.hGBCC) tvis.hParent = tree.hGBCC;
    else tvis.hParent = TVI_ROOT;
514
    U(tvis).item.cChildren = 1;
515

516
    if(RegOpenKeyW(HKEY_CLASSES_ROOT, wszComponentCategories, &hKey) != ERROR_SUCCESS)
517 518 519 520 521 522
        return;

    while(TRUE)
    {
        i++;

523
        if(RegEnumKeyW(hKey, i, valName, sizeof(valName)/sizeof(valName[0])) != ERROR_SUCCESS) break;
524

525
        if(RegOpenKeyW(hKey, valName, &hCurKey) != ERROR_SUCCESS) continue;
526 527 528 529

        lenBuffer = sizeof(WCHAR[MAX_LOAD_STRING]);
        lenBufferHlp = sizeof(WCHAR[MAX_LOAD_STRING]);

530
        if(RegQueryValueW(hCurKey, NULL, buffer, &lenBuffer) == ERROR_SUCCESS && *buffer)
531
            U(tvis).item.pszText = buffer;
532
        else if(RegEnumValueW(hCurKey, 0, NULL, NULL, NULL, NULL,
533
                    (LPBYTE)buffer, &lenBufferHlp) == ERROR_SUCCESS && *buffer)
534
            U(tvis).item.pszText = buffer;
535 536 537 538
        else continue;

        RegCloseKey(hCurKey);

539
        U(tvis).item.lParam = CreateITEM_INFO(REGTOP, valName, valName, NULL);
540
        SendMessageW(globals.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
541 542 543 544
    }

    RegCloseKey(hKey);

545
    SendMessageW(globals.hTree, TVM_SORTCHILDREN, FALSE, (LPARAM)tree.hGBCC);
546 547
}

548
static void AddBaseEntries(void)
549
{
550
    TVINSERTSTRUCTW tvis;
551 552
    WCHAR name[MAX_LOAD_STRING];

553
    U(tvis).item.mask = TVIF_TEXT|TVIF_CHILDREN|TVIF_PARAM;
554
    /* FIXME add TVIF_IMAGE */
555 556 557
    U(tvis).item.pszText = name;
    U(tvis).item.cchTextMax = MAX_LOAD_STRING;
    U(tvis).item.cChildren = 1;
558
    tvis.hInsertAfter = TVI_FIRST;
559 560
    tvis.hParent = TVI_ROOT;

561
    LoadStringW(globals.hMainInst, IDS_TREE_I, U(tvis).item.pszText,
562
            MAX_LOAD_STRING);
563
    U(tvis).item.lParam = CreateITEM_INFO(REGTOP, wszInterface, NULL, NULL);
564
    tree.hI = TreeView_InsertItemW(globals.hTree, &tvis);
565

566
    LoadStringW(globals.hMainInst, IDS_TREE_TL, U(tvis).item.pszText,
567
            MAX_LOAD_STRING);
568
    U(tvis).item.lParam = CreateITEM_INFO(REGTOP, wszTypeLib, NULL, NULL);
569
    tree.hTL = TreeView_InsertItemW(globals.hTree, &tvis);
570

571
    LoadStringW(globals.hMainInst, IDS_TREE_AID, U(tvis).item.pszText,
572
            MAX_LOAD_STRING);
573
    U(tvis).item.lParam = CreateITEM_INFO(REGTOP|REGPATH, wszAppID, NULL, NULL);
574
    tree.hAID = TreeView_InsertItemW(globals.hTree, &tvis);
575

576
    LoadStringW(globals.hMainInst, IDS_TREE_OC, U(tvis).item.pszText,
577
            MAX_LOAD_STRING);
578
    U(tvis).item.lParam = 0;
579
    tree.hOC = TreeView_InsertItemW(globals.hTree, &tvis);
580 581 582


    tvis.hParent = tree.hOC;
583
    LoadStringW(globals.hMainInst, IDS_TREE_AO, U(tvis).item.pszText,
584
            MAX_LOAD_STRING);
585
    U(tvis).item.lParam = CreateITEM_INFO(REGTOP, wszCLSID, NULL, NULL);
586
    tree.hAO = TreeView_InsertItemW(globals.hTree, &tvis);
587

588
    LoadStringW(globals.hMainInst, IDS_TREE_CLO, U(tvis).item.pszText,
589
            MAX_LOAD_STRING);
590
    tree.hCLO = TreeView_InsertItemW(globals.hTree, &tvis);
591

592
    LoadStringW(globals.hMainInst, IDS_TREE_O1O, U(tvis).item.pszText,
593
            MAX_LOAD_STRING);
594
    U(tvis).item.lParam = 0;
595
    tree.hO1O = TreeView_InsertItemW(globals.hTree, &tvis);
596

597
    LoadStringW(globals.hMainInst, IDS_TREE_GBCC, U(tvis).item.pszText,
598
            MAX_LOAD_STRING);
599 600
    U(tvis).item.lParam = CreateITEM_INFO(REGTOP|REGPATH,
            wszComponentCategories, NULL, NULL);
601
    tree.hGBCC = TreeView_InsertItemW(globals.hTree, &tvis);
602

603
    SendMessageW(globals.hTree, TVM_EXPAND, TVE_EXPAND, (LPARAM)tree.hOC);
604 605 606 607 608
}

void EmptyTree(void)
{
    HTREEITEM cur, del;
609
    TVITEMW tvi;
610 611

    tvi.mask = TVIF_PARAM;
612 613
    cur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
            TVGN_CHILD, (LPARAM)TVI_ROOT);
614 615 616 617

    while(TRUE)
    {
        del = cur;
618 619
        cur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
                TVGN_CHILD, (LPARAM)del);
620

621 622
        if(!cur) cur = (HTREEITEM)SendMessageW(globals.hTree,
                TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)del);
623 624
        if(!cur)
        {
625 626 627 628
            cur = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
                    TVGN_PREVIOUS, (LPARAM)del);
            if(!cur) cur = (HTREEITEM)SendMessageW(globals.hTree,
                    TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)del);
629 630

            tvi.hItem = del;
631
            SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
632 633

            if(tvi.lParam)
634 635
            {
                if(((ITEM_INFO *)tvi.lParam)->loaded) ReleaseInst(del);
636
                HeapFree(GetProcessHeap(), 0, (ITEM_INFO *)tvi.lParam);
637
            }
638

639
            SendMessageW(globals.hTree, TVM_DELETEITEM, 0, (LPARAM)del);
640 641 642 643 644 645 646 647 648

            if(!cur) break;
        }
    }
}

void AddTreeEx(void)
{
    AddBaseEntries();
649 650 651 652 653 654 655 656 657 658 659 660
    AddComponentCategories();
    AddCOMandAll();
    AddApplicationID();
    AddTypeLib();
    AddInterfaces();
}

void AddTree(void)
{
    memset(&tree, 0, sizeof(TREE));
    AddComponentCategories();
    AddCOMandAll();
661 662
}

663
static LRESULT CALLBACK TreeProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
664 665 666 667
{
    switch(uMsg)
    {
        case WM_CREATE:
668
            globals.hTree = CreateWindowW(WC_TREEVIEWW, NULL,
669 670 671 672
                    WS_CHILD|WS_VISIBLE|TVS_HASLINES|TVS_HASBUTTONS|TVS_LINESATROOT,
                    0, 0, 0, 0, hWnd, (HMENU)TREE_WINDOW, globals.hMainInst, NULL);
            AddTreeEx();
            break;
673 674 675 676
        case WM_NOTIFY:
            if((int)wParam != TREE_WINDOW) break;
            switch(((LPNMHDR)lParam)->code)
            {
677 678
                case TVN_ITEMEXPANDINGW:
                    CreateInst(((NMTREEVIEWW *)lParam)->itemNew.hItem, NULL);
679
                    break;
680 681 682
                case TVN_SELCHANGEDW:
                    RefreshMenu(((NMTREEVIEWW *)lParam)->itemNew.hItem);
                    RefreshDetails(((NMTREEVIEWW *)lParam)->itemNew.hItem);
683
                    break;
684 685
            }
            break;
686 687 688 689
        case WM_SIZE:
            MoveWindow(globals.hTree, 0, 0, LOWORD(lParam), HIWORD(lParam), TRUE);
            break;
        default:
690
            return DefWindowProcW(hWnd, uMsg, wParam, lParam);
691 692 693 694 695 696
    }
    return 0;
}

HWND CreateTreeWindow(HINSTANCE hInst)
{
697
    WNDCLASSW wct;
698 699
    const WCHAR wszTreeClass[] = { 'T','R','E','E','\0' };

700
    memset(&wct, 0, sizeof(WNDCLASSW));
701 702 703
    wct.lpfnWndProc = TreeProc;
    wct.lpszClassName = wszTreeClass;

704
    if(!RegisterClassW(&wct)) return NULL;
705

706
    return CreateWindowExW(WS_EX_CLIENTEDGE, wszTreeClass, NULL, WS_CHILD|WS_VISIBLE,
707 708
            0, 0, 0, 0, globals.hPaneWnd, NULL, hInst, NULL);
}