programs/oleview/typelib.c

   1 /*
   2  * OleView (typelib.c)
   3  *
   4  * Copyright 2006 Piotr Caban
   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 "main.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(oleview);
  26
  27 TYPELIB typelib;
  28 static const WCHAR wszTypeLib[] = { 'T','Y','P','E','L','I','B','\0' };
  29
  30 static const WCHAR wszFailed[] = { '<','f','a','i','l','e','d','>','\0' };
  31
  32 static const WCHAR wszUUID[] = { 'u','u','i','d','\0' };
  33 static const WCHAR wszOdl[] = { 'o','d','l','\0' };
  34
  35 static const WCHAR wszVT_BOOL[]
  36     = { 'V','A','R','I','A','N','T','_','B','O','O','L','\0' };
  37 static const WCHAR wszVT_UI1[]
  38     = { 'u','n','s','i','g','n','e','d',' ','c','h','a','r','\0' };
  39 static const WCHAR wszVT_UI2[]
  40     = { 'u','n','s','i','g','n','e','d',' ','s','h','o','r','t','\0' };
  41 static const WCHAR wszVT_UI4[]
  42     = { 'u','n','s','i','g','n','e','d',' ','l','o','n','g','\0' };
  43 static const WCHAR wszVT_UI8[] = { 'u','i','n','t','6','4','\0' };
  44 static const WCHAR wszVT_UINT[]
  45     = { 'u','n','s','i','g','n','e','d',' ','i','n','t','\0' };
  46 static const WCHAR wszVT_I1[] = { 'c','h','a','r','\0' };
  47 static const WCHAR wszVT_I2[] = { 's','h','o','r','t','\0' };
  48 static const WCHAR wszVT_I4[] = { 'l','o','n','g','\0' };
  49 static const WCHAR wszVT_I8[] = { 'i','n','t','6','4','\0' };
  50 static const WCHAR wszVT_R4[] = { 's','i','n','g','l','e','\0' };
  51 static const WCHAR wszVT_INT[] = { 'i','n','t','\0' };
  52 static const WCHAR wszVT_BSTR[] = { 'B','S','T','R','\0' };
  53 static const WCHAR wszVT_CY[] = { 'C','U','R','R','E','N','C','Y','\0' };
  54 static const WCHAR wszVT_VARIANT[] = { 'V','A','R','I','A','N','T','\0' };
  55 static const WCHAR wszVT_VOID[] = { 'v','o','i','d','\0' };
  56 static const WCHAR wszVT_ERROR[] = { 'S','C','O','D','E','\0' };
  57 static const WCHAR wszVT_LPSTR[] = { 'L','P','S','T','R','\0' };
  58 static const WCHAR wszVT_LPWSTR[] = { 'L','P','W','S','T','R','\0' };
  59 static const WCHAR wszVT_HRESULT[] = { 'H','R','E','S','U','L','T','\0' };
  60 static const WCHAR wszVT_UNKNOWN[] = { 'I','U','n','k','n','o','w','n','\0' };
  61 static const WCHAR wszVT_DISPATCH[] = { 'I','D','i','s','p','a','t','c','h','\0' };
  62 static const WCHAR wszVT_DATE[] = { 'D','A','T','E','\0' };
  63 static const WCHAR wszVT_R8[] = { 'd','o','u','b','l','e','\0' };
  64 static const WCHAR wszVT_SAFEARRAY[] = { 'S','A','F','E','A','R','R','A','Y','\0' };
  65
  66 static const WCHAR wszFormat[] = { '0','x','%','.','8','l','x','\0' };
  67 static const WCHAR wszStdCall[] = { '_','s','t','d','c','a','l','l','\0' };
  68 static const WCHAR wszId[] = { 'i','d','\0' };
  69 static const WCHAR wszHelpstring[] = { 'h','e','l','p','s','t','r','i','n','g','\0' };
  70 static const WCHAR wszPropPut[] = { 'p','r','o','p','p','u','t','\0' };
  71 static const WCHAR wszPropGet[] = { 'p','r','o','p','g','e','t','\0' };
  72 static const WCHAR wszPropPutRef[] = { 'p','r','o','p','p','u','t','r','e','f','\0' };
  73 static const WCHAR wszPARAMFLAG_FIN[] = { 'i','n','\0' };
  74 static const WCHAR wszPARAMFLAG_FOUT[] = { 'o','u','t','\0' };
  75 static const WCHAR wszPARAMFLAG_FLCID[] = { 'c','i','d','\0' };
  76 static const WCHAR wszPARAMFLAG_FRETVAL[] = { 'r','e','t','v','a','l','\0' };
  77 static const WCHAR wszPARAMFLAG_FOPT[] = { 'o','p','t','i','o','n','a','l','\0' };
  78 static const WCHAR wszPARAMFLAG_FHASCUSTDATA[]
  79     = { 'h','a','s','c','u','s','t','d','a','t','a','\0' };
  80 static const WCHAR wszDefaultValue[]
  81     = { 'd','e','f','a','u','l','t','v','a','l','u','e','\0' };
  82
  83 static const WCHAR wszReadOnly[] = { 'r','e','a','d','o','n','l','y','\0' };
  84 static const WCHAR wszConst[] = { 'c','o','n','s','t','\0' };
  85
  86 static void ShowLastError(void)
  87 {
  88     DWORD error = GetLastError();
  89     LPWSTR lpMsgBuf;
  90     WCHAR wszTitle[MAX_LOAD_STRING];
  91
  92     LoadStringW(globals.hMainInst, IDS_TYPELIBTITLE, wszTitle, ARRAY_SIZE(wszTitle));
  93     FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
  94             NULL, error, 0, (LPWSTR)&lpMsgBuf, 0, NULL);
  95     MessageBoxW(NULL, lpMsgBuf, wszTitle, MB_OK | MB_ICONERROR);
  96     LocalFree(lpMsgBuf);
  97     return;
  98 }
  99
 100 static void SaveIdl(WCHAR *wszFileName)
 101 {
 102     HTREEITEM hIDL;
 103     TVITEMW tvi;
 104     HANDLE hFile;
 105     DWORD len, dwNumWrite;
 106     char *wszIdl;
 107     TYPELIB_DATA *data;
 108
 109     hIDL = (HTREEITEM)SendMessageW(typelib.hTree, TVM_GETNEXTITEM,
 110             TVGN_CHILD, (LPARAM)TVI_ROOT);
 111
 112     memset(&tvi, 0, sizeof(TVITEMW));
 113     tvi.hItem = hIDL;
 114
 115     SendMessageW(typelib.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
 116     data = (TYPELIB_DATA *)tvi.lParam;
 117
 118     hFile = CreateFileW(wszFileName, GENERIC_WRITE, FILE_SHARE_WRITE,
 119                        NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 120     if(hFile == INVALID_HANDLE_VALUE)
 121     {
 122         ShowLastError();
 123         return;
 124     }
 125
 126     len = WideCharToMultiByte( CP_UTF8, 0, data->idl, data->idlLen, NULL, 0, NULL, NULL );
 127     wszIdl = malloc(len);
 128     WideCharToMultiByte( CP_UTF8, 0, data->idl, data->idlLen, wszIdl, len, NULL, NULL );
 129
 130     if(!WriteFile(hFile, wszIdl, len, &dwNumWrite, NULL))
 131         ShowLastError();
 132
 133     free(wszIdl);
 134     CloseHandle(hFile);
 135 }
 136
 137 static void GetSaveIdlAsPath(void)
 138 {
 139     OPENFILENAMEW saveidl;
 140     WCHAR *pFileName;
 141     WCHAR wszPath[MAX_LOAD_STRING];
 142     WCHAR wszDir[MAX_LOAD_STRING];
 143     static const WCHAR wszDefaultExt[] = { 'i','d','l',0 };
 144     static const WCHAR wszIdlFiles[] = { '*','.','i','d','l','\0','\0' };
 145
 146     memset(&saveidl, 0, sizeof(saveidl));
 147
 148     lstrcpyW(wszDir, typelib.wszFileName);
 149     pFileName = wszDir + lstrlenW(wszDir);
 150     while(*pFileName != '.' && *pFileName != '\\' && *pFileName != '/'
 151             && pFileName > wszDir) pFileName -= 1;
 152     if(*pFileName == '.')
 153     {
 154         *pFileName = '\0';
 155         while(*pFileName != '\\' && *pFileName != '/' && pFileName > wszDir)
 156             pFileName -= 1;
 157     }
 158     if(*pFileName == '\\' || *pFileName == '/') pFileName += 1;
 159     lstrcpyW(wszPath, pFileName);
 160
 161     GetCurrentDirectoryW(MAX_LOAD_STRING, wszDir);
 162
 163     saveidl.lStructSize = sizeof(OPENFILENAMEW);
 164     saveidl.hwndOwner = globals.hTypeLibWnd;
 165     saveidl.hInstance = globals.hMainInst;
 166     saveidl.lpstrFilter = wszIdlFiles;
 167     saveidl.lpstrFile = wszPath;
 168     saveidl.nMaxFile = MAX_LOAD_STRING;
 169     saveidl.lpstrInitialDir = wszDir;
 170     saveidl.Flags = OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY;
 171     saveidl.lpstrDefExt = wszDefaultExt;
 172
 173     if (GetSaveFileNameW(&saveidl))
 174         SaveIdl(wszPath);
 175 }
 176
 177 static void AddToStrW(WCHAR *wszDest, const WCHAR *wszSource)
 178 {
 179     lstrcpyW(&wszDest[lstrlenW(wszDest)], wszSource);
 180 }
 181
 182 static void AddToTLDataStrW(TYPELIB_DATA *pTLData, const WCHAR *wszSource)
 183 {
 184     int SourceLen = lstrlenW(wszSource);
 185
 186     pTLData->idl = realloc(pTLData->idl, sizeof(WCHAR) * (pTLData->idlLen + SourceLen + 1));
 187
 188     memcpy(&pTLData->idl[pTLData->idlLen], wszSource, sizeof(WCHAR)*(SourceLen+1));
 189     pTLData->idlLen += SourceLen;
 190 }
 191
 192 static void AddToTLDataStrWithTabsW(TYPELIB_DATA *pTLData, WCHAR *wszSource)
 193 {
 194     int lineLen = lstrlenW(wszSource);
 195     int newLinesNo = 0;
 196     WCHAR *pSourcePos = wszSource;
 197     WCHAR *pSourceBeg;
 198
 199     if(!lineLen) return;
 200     while(*pSourcePos)
 201     {
 202         if(*pSourcePos == L'\n') newLinesNo++;
 203         pSourcePos += 1;
 204     }
 205     if(*(pSourcePos - 1) != L'\n') newLinesNo++;
 206
 207     pTLData->idl = realloc(pTLData->idl,
 208             sizeof(WCHAR) * (pTLData->idlLen + lineLen + 4 * newLinesNo + 1));
 209
 210     pSourcePos = wszSource;
 211     pSourceBeg = wszSource;
 212     while(newLinesNo)
 213     {
 214         if(*pSourcePos != L'\n' && *pSourcePos)
 215         {
 216             pSourcePos += 1;
 217             continue;
 218         }
 219         newLinesNo--;
 220
 221         if(*pSourcePos)
 222         {
 223             *pSourcePos = '\0';
 224             lineLen = lstrlenW(pSourceBeg)+1;
 225             *pSourcePos = '\n';
 226             pSourcePos += 1;
 227         }
 228         else lineLen = lstrlenW(pSourceBeg);
 229
 230         pTLData->idl[pTLData->idlLen] = L' ';
 231         pTLData->idl[pTLData->idlLen+1] = L' ';
 232         pTLData->idl[pTLData->idlLen+2] = L' ';
 233         pTLData->idl[pTLData->idlLen+3] = L' ';
 234         memcpy(&pTLData->idl[pTLData->idlLen+4], pSourceBeg, sizeof(WCHAR)*lineLen);
 235         pTLData->idlLen += lineLen + 4;
 236         pTLData->idl[pTLData->idlLen] = '\0';
 237
 238         pSourceBeg = pSourcePos;
 239     }
 240 }
 241
 242 static TYPELIB_DATA *InitializeTLData(void)
 243 {
 244     TYPELIB_DATA *pTLData;
 245
 246     pTLData = calloc(1, sizeof(TYPELIB_DATA));
 247
 248     pTLData->idl = malloc(sizeof(WCHAR));
 249     pTLData->idl[0] = '\0';
 250
 251     return pTLData;
 252 }
 253
 254 static void AddSpaces(TYPELIB_DATA *pTLData, int tabSize)
 255 {
 256     for(; tabSize>0; tabSize--)
 257         AddToTLDataStrW(pTLData, L" ");
 258 }
 259
 260 static void AddChildrenData(HTREEITEM hParent, TYPELIB_DATA *pData)
 261 {
 262     HTREEITEM hCur;
 263     TVITEMW tvi;
 264
 265     memset(&tvi, 0, sizeof(tvi));
 266
 267     hCur = (HTREEITEM)SendMessageW(typelib.hTree, TVM_GETNEXTITEM,
 268             TVGN_CHILD, (LPARAM)hParent);
 269     if(!hCur) return;
 270
 271     do
 272     {
 273         tvi.hItem = hCur;
 274         SendMessageW(typelib.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
 275         if(tvi.lParam && ((TYPELIB_DATA *)(tvi.lParam))->idlLen)
 276             AddToTLDataStrWithTabsW(pData, ((TYPELIB_DATA *)(tvi.lParam))->idl);
 277     } while((hCur = (HTREEITEM)SendMessageW(typelib.hTree, TVM_GETNEXTITEM,
 278             TVGN_NEXT, (LPARAM)hCur)));
 279 }
 280
 281 static void CreateTypeInfo(WCHAR *wszAddTo, WCHAR *wszAddAfter, TYPEDESC tdesc, ITypeInfo *pTypeInfo)
 282 {
 283     int i;
 284     BSTR bstrData;
 285     HRESULT hRes;
 286     ITypeInfo *pRefTypeInfo;
 287     WCHAR wszBuf[MAX_LOAD_STRING];
 288     WCHAR wszFormat[] = { '[','%','l','u',']','\0' };
 289
 290     switch(tdesc.vt&VT_TYPEMASK)
 291     {
 292 #define VTADDTOSTR(x) case x:\
 293         AddToStrW(wszAddTo, wsz##x);\
 294         break
 295         VTADDTOSTR(VT_BOOL);
 296         VTADDTOSTR(VT_UI1);
 297         VTADDTOSTR(VT_UI2);
 298         VTADDTOSTR(VT_UI4);
 299         VTADDTOSTR(VT_UI8);
 300         VTADDTOSTR(VT_UINT);
 301         VTADDTOSTR(VT_I1);
 302         VTADDTOSTR(VT_I2);
 303         VTADDTOSTR(VT_I4);
 304         VTADDTOSTR(VT_I8);
 305         VTADDTOSTR(VT_R4);
 306         VTADDTOSTR(VT_INT);
 307         VTADDTOSTR(VT_BSTR);
 308         VTADDTOSTR(VT_CY);
 309         VTADDTOSTR(VT_VARIANT);
 310         VTADDTOSTR(VT_VOID);
 311         VTADDTOSTR(VT_ERROR);
 312         VTADDTOSTR(VT_LPSTR);
 313         VTADDTOSTR(VT_LPWSTR);
 314         VTADDTOSTR(VT_HRESULT);
 315         VTADDTOSTR(VT_UNKNOWN);
 316         VTADDTOSTR(VT_DISPATCH);
 317         VTADDTOSTR(VT_DATE);
 318         VTADDTOSTR(VT_R8);
 319         case VT_CARRAY:
 320         for(i=0; i<tdesc.lpadesc->cDims; i++)
 321         {
 322             wsprintfW(wszBuf, wszFormat, tdesc.lpadesc->rgbounds[i].cElements);
 323             AddToStrW(wszAddAfter, wszBuf);
 324         }
 325         CreateTypeInfo(wszAddTo, wszAddAfter, tdesc.lpadesc->tdescElem, pTypeInfo);
 326         break;
 327         case VT_SAFEARRAY:
 328         AddToStrW(wszAddTo, wszVT_SAFEARRAY);
 329         AddToStrW(wszAddTo, L"(");
 330         CreateTypeInfo(wszAddTo, wszAddAfter, *tdesc.lptdesc, pTypeInfo);
 331         AddToStrW(wszAddTo, L")");
 332         break;
 333         case VT_PTR:
 334         CreateTypeInfo(wszAddTo, wszAddAfter, *tdesc.lptdesc, pTypeInfo);
 335         AddToStrW(wszAddTo, L"*");
 336         break;
 337         case VT_USERDEFINED:
 338         hRes = ITypeInfo_GetRefTypeInfo(pTypeInfo,
 339                 tdesc.hreftype, &pRefTypeInfo);
 340         if(SUCCEEDED(hRes))
 341         {
 342             ITypeInfo_GetDocumentation(pRefTypeInfo, MEMBERID_NIL,
 343                     &bstrData, NULL, NULL, NULL);
 344             AddToStrW(wszAddTo, bstrData);
 345             SysFreeString(bstrData);
 346             ITypeInfo_Release(pRefTypeInfo);
 347         }
 348         else AddToStrW(wszAddTo, wszFailed);
 349         break;
 350         default:
 351         WINE_FIXME("tdesc.vt&VT_TYPEMASK == %d not supported\n",
 352                 tdesc.vt&VT_TYPEMASK);
 353     }
 354 }
 355
 356 static int EnumVars(ITypeInfo *pTypeInfo, int cVars, HTREEITEM hParent)
 357 {
 358     int i;
 359     TVINSERTSTRUCTW tvis;
 360     VARDESC *pVarDesc;
 361     BSTR bstrName;
 362     WCHAR wszText[MAX_LOAD_STRING];
 363     WCHAR wszAfter[MAX_LOAD_STRING];
 364
 365     tvis.item.mask = TVIF_TEXT|TVIF_PARAM;
 366     tvis.item.cchTextMax = MAX_LOAD_STRING;
 367     tvis.item.pszText = wszText;
 368     tvis.hInsertAfter = TVI_LAST;
 369     tvis.hParent = hParent;
 370
 371     for(i=0; i<cVars; i++)
 372     {
 373         TYPELIB_DATA *tld;
 374
 375         if(FAILED(ITypeInfo_GetVarDesc(pTypeInfo, i, &pVarDesc))) continue;
 376         if(FAILED(ITypeInfo_GetDocumentation(pTypeInfo, pVarDesc->memid, &bstrName,
 377                 NULL, NULL, NULL))) continue;
 378
 379         tld = InitializeTLData();
 380         tvis.item.lParam = (LPARAM) tld;
 381         if(pVarDesc->memid < MIN_VAR_ID)
 382         {
 383
 384             AddToTLDataStrW(tld, L"[");
 385             AddToTLDataStrW(tld, wszId);
 386             AddToTLDataStrW(tld, L"(");
 387             wsprintfW(wszText, wszFormat, pVarDesc->memid);
 388             AddToTLDataStrW(tld, wszText);
 389             memset(wszText, 0, sizeof(wszText));
 390             AddToTLDataStrW(tld, L")");
 391
 392             if(pVarDesc->wVarFlags & VARFLAG_FREADONLY)
 393             {
 394                 AddToTLDataStrW(tld, L", ");
 395                 AddToTLDataStrW(tld, wszReadOnly);
 396             }
 397             AddToTLDataStrW(tld, L"]\n");
 398         }
 399
 400         memset(wszText, 0, sizeof(wszText));
 401         memset(wszAfter, 0, sizeof(wszAfter));
 402         CreateTypeInfo(wszText, wszAfter, pVarDesc->elemdescVar.tdesc, pTypeInfo);
 403         AddToStrW(wszText, L" ");
 404         if (bstrName) AddToStrW(wszText, bstrName);
 405         AddToStrW(wszText, wszAfter);
 406         AddToTLDataStrW(tld, wszText);
 407         AddToTLDataStrW(tld, L";\n");
 408
 409         SendMessageW(typelib.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
 410         SysFreeString(bstrName);
 411         ITypeInfo_ReleaseVarDesc(pTypeInfo, pVarDesc);
 412     }
 413
 414     return 0;
 415 }
 416
 417 static int EnumEnums(ITypeInfo *pTypeInfo, int cVars, HTREEITEM hParent)
 418 {
 419     int i;
 420     TVINSERTSTRUCTW tvis;
 421     VARDESC *pVarDesc;
 422     BSTR bstrName;
 423     WCHAR wszText[MAX_LOAD_STRING];
 424     WCHAR wszAfter[MAX_LOAD_STRING];
 425
 426     tvis.item.mask = TVIF_TEXT|TVIF_PARAM;
 427     tvis.item.cchTextMax = MAX_LOAD_STRING;
 428     tvis.item.pszText = wszText;
 429     tvis.hInsertAfter = TVI_LAST;
 430     tvis.hParent = hParent;
 431
 432     for(i=0; i<cVars; i++)
 433     {
 434         TYPELIB_DATA *tld;
 435
 436         if(FAILED(ITypeInfo_GetVarDesc(pTypeInfo, i, &pVarDesc))) continue;
 437         if(FAILED(ITypeInfo_GetDocumentation(pTypeInfo, pVarDesc->memid, &bstrName,
 438                 NULL, NULL, NULL))) continue;
 439
 440         tld = InitializeTLData();
 441         tvis.item.lParam = (LPARAM) tld;
 442
 443         memset(wszText, 0, sizeof(wszText));
 444         memset(wszAfter, 0, sizeof(wszAfter));
 445
 446         if (pVarDesc->varkind == VAR_CONST)
 447         {
 448             VARIANT var;
 449             VariantInit(&var);
 450             if (VariantChangeType(&var, pVarDesc->lpvarValue, 0, VT_BSTR) == S_OK)
 451             {
 452                 AddToStrW(wszText, wszConst);
 453                 AddToStrW(wszText, L" ");
 454                 AddToStrW(wszAfter, L" = ");
 455                 AddToStrW(wszAfter, V_BSTR(&var));
 456             }
 457         }
 458
 459         CreateTypeInfo(wszText, wszAfter, pVarDesc->elemdescVar.tdesc, pTypeInfo);
 460         AddToStrW(wszText, L" ");
 461         AddToStrW(wszText, bstrName);
 462         AddToStrW(wszText, wszAfter);
 463         AddToTLDataStrW(tld, bstrName);
 464         AddToTLDataStrW(tld, wszAfter);
 465         if (i<cVars-1)
 466             AddToTLDataStrW(tld, L",");
 467         AddToTLDataStrW(tld, L"\n");
 468
 469         SendMessageW(typelib.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
 470         SysFreeString(bstrName);
 471         ITypeInfo_ReleaseVarDesc(pTypeInfo, pVarDesc);
 472     }
 473
 474     return 0;
 475 }
 476
 477 static int EnumFuncs(ITypeInfo *pTypeInfo, TYPEATTR *pTypeAttr, HTREEITEM hParent)
 478 {
 479     int i, j;
 480     int cFuncs;
 481     unsigned namesNo;
 482     TVINSERTSTRUCTW tvis;
 483     FUNCDESC *pFuncDesc;
 484     BSTR bstrName, bstrHelpString, *bstrParamNames;
 485     WCHAR wszText[MAX_LOAD_STRING];
 486     WCHAR wszAfter[MAX_LOAD_STRING];
 487     WCHAR szRhs[] = {'r','h','s',0};    /* Right-hand side of a propput */
 488     BOOL bFirst;
 489
 490     tvis.item.mask = TVIF_TEXT|TVIF_PARAM;
 491     tvis.hInsertAfter = TVI_LAST;
 492     tvis.hParent = hParent;
 493
 494     cFuncs = pTypeAttr->cFuncs;
 495
 496     i = 0;
 497     if(pTypeAttr->wTypeFlags & TYPEFLAG_FDUAL) { /* skip 7 members of IDispatch */
 498         cFuncs += 7;
 499         i += 7;
 500     }
 501
 502     for(; i<cFuncs; i++)
 503     {
 504         TYPELIB_DATA *tld;
 505
 506         if(FAILED(ITypeInfo_GetFuncDesc(pTypeInfo, i, &pFuncDesc))) continue;
 507
 508         if(FAILED(ITypeInfo_GetDocumentation(pTypeInfo, pFuncDesc->memid, &bstrName,
 509                 &bstrHelpString, NULL, NULL))) continue;
 510
 511         memset(wszText, 0, sizeof(wszText));
 512         memset(wszAfter, 0, sizeof(wszAfter));
 513         tld = InitializeTLData();
 514         tvis.item.cchTextMax = SysStringLen(bstrName);
 515         tvis.item.pszText = bstrName;
 516         tvis.item.lParam = (LPARAM) tld;
 517         bFirst = TRUE;
 518         if(pFuncDesc->memid < MIN_FUNC_ID || pTypeAttr->wTypeFlags & TYPEFLAG_FDUAL)
 519         {
 520             AddToTLDataStrW(tld, L"[");
 521             bFirst = FALSE;
 522             AddToTLDataStrW(tld, wszId);
 523             AddToTLDataStrW(tld, L"(");
 524             wsprintfW(wszText, wszFormat, pFuncDesc->memid);
 525             AddToTLDataStrW(tld, wszText);
 526             AddToTLDataStrW(tld, L")");
 527             memset(wszText, 0, sizeof(wszText));
 528         }
 529
 530         CreateTypeInfo(wszText, wszAfter, pFuncDesc->elemdescFunc.tdesc, pTypeInfo);
 531         switch(pFuncDesc->invkind)
 532         {
 533             case INVOKE_PROPERTYGET:
 534                 if(bFirst) AddToTLDataStrW(tld, L"[");
 535                 else AddToTLDataStrW(tld, L", ");
 536                 bFirst = FALSE;
 537                 AddToTLDataStrW(tld, wszPropGet);
 538                 break;
 539             case INVOKE_PROPERTYPUT:
 540                 if(bFirst) AddToTLDataStrW(tld, L"[");
 541                 else AddToTLDataStrW(tld, L", ");
 542                 bFirst = FALSE;
 543                 AddToTLDataStrW(tld, wszPropPut);
 544                 break;
 545             case INVOKE_PROPERTYPUTREF:
 546                 if(bFirst) AddToTLDataStrW(tld, L"[");
 547                 else AddToTLDataStrW(tld, L", ");
 548                 bFirst = FALSE;
 549                 AddToTLDataStrW(tld, wszPropPutRef);
 550                 break;
 551             default:;
 552         }
 553         if(SysStringLen(bstrHelpString))
 554         {
 555             if(bFirst) AddToTLDataStrW(tld, L"[");
 556             else AddToTLDataStrW(tld, L", ");
 557             bFirst = FALSE;
 558             AddToTLDataStrW(tld, wszHelpstring);
 559             AddToTLDataStrW(tld, L"(\"");
 560             AddToTLDataStrW(tld, bstrHelpString);
 561             AddToTLDataStrW(tld, L"\")");
 562         }
 563         if(!bFirst) AddToTLDataStrW(tld, L"]\n");
 564
 565         if(pTypeAttr->wTypeFlags & TYPEFLAG_FOLEAUTOMATION) {
 566             AddToTLDataStrW(tld, wszVT_HRESULT);
 567             if(lstrcmpW(wszText, wszVT_VOID)) pFuncDesc->cParams++;
 568         }
 569         else {
 570             AddToTLDataStrW(tld, wszText);
 571             AddToTLDataStrW(tld, wszAfter);
 572         }
 573
 574         bstrParamNames = malloc(sizeof(BSTR) * (pFuncDesc->cParams + 1));
 575         if(FAILED(ITypeInfo_GetNames(pTypeInfo, pFuncDesc->memid, bstrParamNames,
 576                 pFuncDesc->cParams+1, &namesNo)))
 577         {
 578             free(bstrParamNames);
 579             continue;
 580         }
 581         SysFreeString(bstrParamNames[0]);
 582
 583         AddToTLDataStrW(tld, L" ");
 584         if(pFuncDesc->memid >= MIN_FUNC_ID)
 585         {
 586             AddToTLDataStrW(tld, wszStdCall);
 587             AddToTLDataStrW(tld, L" ");
 588         }
 589         if (bstrName) AddToTLDataStrW(tld, bstrName);
 590         AddToTLDataStrW(tld, L"(");
 591
 592         for(j=0; j<pFuncDesc->cParams; j++)
 593         {
 594             if(j != 0) AddToTLDataStrW(tld, L",");
 595             if(pFuncDesc->cParams != 1)
 596             {
 597                 AddToTLDataStrW(tld, L"\n");
 598                 AddSpaces(tld, TAB_SIZE);
 599             }
 600             bFirst = TRUE;
 601 #define ENUM_PARAM_FLAG(x)\
 602             if(pFuncDesc->lprgelemdescParam[j].paramdesc.wParamFlags & x) \
 603             {\
 604                 if(bFirst)\
 605                     AddToTLDataStrW(tld, L"[");\
 606                 else\
 607                 {\
 608                     AddToTLDataStrW(tld, L", ");\
 609                 }\
 610                 bFirst = FALSE;\
 611                 AddToTLDataStrW(tld, wsz##x);\
 612             }
 613             ENUM_PARAM_FLAG(PARAMFLAG_FIN);
 614             ENUM_PARAM_FLAG(PARAMFLAG_FOUT);
 615             ENUM_PARAM_FLAG(PARAMFLAG_FLCID);
 616             ENUM_PARAM_FLAG(PARAMFLAG_FRETVAL);
 617             ENUM_PARAM_FLAG(PARAMFLAG_FOPT);
 618             ENUM_PARAM_FLAG(PARAMFLAG_FHASCUSTDATA);
 619
 620             if(pFuncDesc->lprgelemdescParam[j].paramdesc.wParamFlags & PARAMFLAG_FHASDEFAULT)
 621             {
 622                 VARIANT var, *param=&pFuncDesc->lprgelemdescParam[j].paramdesc.pparamdescex->varDefaultValue;
 623                 VariantInit(&var);
 624                 if(bFirst) AddToTLDataStrW(tld, L"[");
 625                 else AddToTLDataStrW(tld, L", ");
 626                 bFirst = FALSE;
 627                 AddToTLDataStrW(tld, wszDefaultValue);
 628                 AddToTLDataStrW(tld, L"(");
 629                 if (V_VT(param) == VT_BSTR)
 630                 {
 631                     AddToTLDataStrW(tld, L"\"");
 632                     AddToTLDataStrW(tld, V_BSTR(param));
 633                     AddToTLDataStrW(tld, L"\"");
 634                 } else if (VariantChangeType(&var, param, 0, VT_BSTR) == S_OK)
 635                     AddToTLDataStrW(tld, V_BSTR(&var));
 636                 AddToTLDataStrW(tld, L")");
 637             }
 638
 639             if(!bFirst) AddToTLDataStrW(tld, L"] ");
 640
 641             memset(wszText, 0, sizeof(wszText));
 642             memset(wszAfter, 0, sizeof(wszAfter));
 643             CreateTypeInfo(wszText, wszAfter, pFuncDesc->lprgelemdescParam[j].tdesc,
 644                     pTypeInfo);
 645             AddToTLDataStrW(tld, wszText);
 646             AddToTLDataStrW(tld, wszAfter);
 647             AddToTLDataStrW(tld, L" ");
 648             if (j+1 < namesNo) {
 649                 if (bstrParamNames[j+1])
 650                 {
 651                     AddToTLDataStrW(tld, bstrParamNames[j+1]);
 652                     SysFreeString(bstrParamNames[j+1]);
 653                 }
 654             } else {
 655                 AddToTLDataStrW(tld, szRhs);
 656             }
 657         }
 658         AddToTLDataStrW(tld, L");\n");
 659
 660         SendMessageW(typelib.hTree, TVM_INSERTITEMW, 0, (LPARAM)&tvis);
 661         free(bstrParamNames);
 662         SysFreeString(bstrName);
 663         SysFreeString(bstrHelpString);
 664         ITypeInfo_ReleaseFuncDesc(pTypeInfo, pFuncDesc);
 665     }
 666
 667     return 0;
 668 }
 669
 670 static int EnumImplTypes(ITypeInfo *pTypeInfo, int cImplTypes, HTREEITEM hParent)
 671 {
 672     int i;
 673     TVINSERTSTRUCTW tvis;
 674     ITypeInfo *pRefTypeInfo;
 675     HREFTYPE hRefType;
 676     TYPEATTR *pTypeAttr;
 677     BSTR bstrName;
 678     WCHAR wszInheritedInterfaces[MAX_LOAD_STRING];
 679
 680     if(!cImplTypes) return 0;
 681
 682     LoadStringW(globals.hMainInst, IDS_INHERITINTERFACES, wszInheritedInterfaces,
 683                 ARRAY_SIZE(wszInheritedInterfaces));
 684
 685     tvis.item.mask = TVIF_TEXT;
 686     tvis.item.cchTextMax = MAX_LOAD_STRING;
 687     tvis.item.pszText = wszInheritedInterfaces;
 688     tvis.hInsertAfter = TVI_LAST;
 689     tvis.hParent = hParent;
 690
 691     tvis.hParent = TreeView_InsertItemW(typelib.hTree, &tvis);
 692
 693     for(i=0; i<cImplTypes; i++)
 694     {
 695         if(FAILED(ITypeInfo_GetRefTypeOfImplType(pTypeInfo, i, &hRefType))) continue;
 696         if(FAILED(ITypeInfo_GetRefTypeInfo(pTypeInfo, hRefType, &pRefTypeInfo)))
 697             continue;
 698         if(FAILED(ITypeInfo_GetDocumentation(pRefTypeInfo, MEMBERID_NIL, &bstrName,
 699                 NULL, NULL, NULL)))
 700         {
 701             ITypeInfo_Release(pRefTypeInfo);
 702             continue;
 703         }
 704         if(FAILED(ITypeInfo_GetTypeAttr(pRefTypeInfo, &pTypeAttr)))
 705         {
 706             ITypeInfo_Release(pRefTypeInfo);
 707             continue;
 708         }
 709
 710         tvis.item.cchTextMax = SysStringLen(bstrName);
 711         tvis.item.pszText = bstrName;
 712
 713         hParent = TreeView_InsertItemW(typelib.hTree, &tvis);
 714         EnumVars(pRefTypeInfo, pTypeAttr->cVars, hParent);
 715         EnumFuncs(pRefTypeInfo, pTypeAttr, hParent);
 716         EnumImplTypes(pRefTypeInfo, pTypeAttr->cImplTypes, hParent);
 717
 718         SysFreeString(bstrName);
 719         ITypeInfo_ReleaseTypeAttr(pRefTypeInfo, pTypeAttr);
 720         ITypeInfo_Release(pRefTypeInfo);
 721     }
 722
 723     return 0;
 724 }
 725
 726 static void EnumCoclassImplTypes(ITypeInfo *pTypeInfo,
 727         int cImplTypes, TYPELIB_DATA *pTLData)
 728 {
 729     int i;
 730     ITypeInfo *pRefTypeInfo;
 731     HREFTYPE hRefType;
 732     TYPEATTR *pTypeAttr;
 733     BSTR bstrName;
 734     BOOL bFirst;
 735     INT flags;
 736     const WCHAR wszTKIND_INTERFACE[] = { 'i','n','t','e','r','f','a','c','e',' ','\0' };
 737     const WCHAR wszTKIND_DISPATCH[]
 738         = { 'd','i','s','p','i','n','t','e','r','f','a','c','e',' ','\0' };
 739     const WCHAR wszIMPLTYPEFLAG_FDEFAULT[]
 740         = { 'd','e','f','a','u','l','t','\0' };
 741     const WCHAR wszIMPLTYPEFLAG_FSOURCE[]
 742         = { 's','o','u','r','c','e','\0' };
 743     const WCHAR wszIMPLTYPEFLAG_FRESTRICTED[]
 744         = { 'r','e','s','t','r','i','c','t','e','d','\0' };
 745
 746     for(i=0; i<cImplTypes; i++)
 747     {
 748         if(FAILED(ITypeInfo_GetRefTypeOfImplType(pTypeInfo, i, &hRefType))) continue;
 749         if(FAILED(ITypeInfo_GetRefTypeInfo(pTypeInfo, hRefType, &pRefTypeInfo)))
 750             continue;
 751         if(FAILED(ITypeInfo_GetDocumentation(pRefTypeInfo, MEMBERID_NIL, &bstrName,
 752                         NULL, NULL, NULL)))
 753         {
 754             ITypeInfo_Release(pRefTypeInfo);
 755             continue;
 756         }
 757         if(FAILED(ITypeInfo_GetTypeAttr(pRefTypeInfo, &pTypeAttr)))
 758         {
 759             ITypeInfo_Release(pRefTypeInfo);
 760             continue;
 761         }
 762
 763         AddSpaces(pTLData, TAB_SIZE);
 764         ITypeInfo_GetImplTypeFlags(pTypeInfo, i, &flags);
 765         bFirst = TRUE;
 766 #define ENUM_IMPLTYPEFLAG(x)\
 767         if(flags & x) \
 768         {\
 769             if(bFirst)\
 770                 AddToTLDataStrW(pTLData, L"[");\
 771             else\
 772             {\
 773                 AddToTLDataStrW(pTLData, L", ");\
 774             }\
 775             bFirst = FALSE;\
 776             AddToTLDataStrW(pTLData, wsz##x);\
 777         }
 778         ENUM_IMPLTYPEFLAG(IMPLTYPEFLAG_FDEFAULT);
 779         ENUM_IMPLTYPEFLAG(IMPLTYPEFLAG_FSOURCE);
 780         ENUM_IMPLTYPEFLAG(IMPLTYPEFLAG_FRESTRICTED);
 781         if(!bFirst)
 782             AddToTLDataStrW(pTLData, L"] ");
 783
 784         if(pTypeAttr->typekind == TKIND_INTERFACE ||
 785                 (pTypeAttr->wTypeFlags & TYPEFLAG_FDUAL))
 786             AddToTLDataStrW(pTLData, wszTKIND_INTERFACE);
 787         else if(pTypeAttr->typekind == TKIND_DISPATCH)
 788             AddToTLDataStrW(pTLData, wszTKIND_DISPATCH);
 789         AddToTLDataStrW(pTLData, L" ");
 790
 791         AddToTLDataStrW(pTLData, bstrName);
 792         AddToTLDataStrW(pTLData, L";\n");
 793
 794         SysFreeString(bstrName);
 795         ITypeInfo_ReleaseTypeAttr(pRefTypeInfo, pTypeAttr);
 796         ITypeInfo_Release(pRefTypeInfo);
 797     }
 798 }
 799
 800 static void AddIdlData(HTREEITEM hCur, TYPELIB_DATA *pTLData)
 801 {
 802     TVITEMW tvi;
 803
 804     hCur = (HTREEITEM)SendMessageW(typelib.hTree, TVM_GETNEXTITEM,
 805             TVGN_CHILD, (LPARAM)hCur);
 806     memset(&tvi, 0, sizeof(TVITEMW));
 807     tvi.mask = TVIF_PARAM;
 808
 809     while(hCur)
 810     {
 811         tvi.hItem = hCur;
 812         SendMessageW(typelib.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
 813         if(!((TYPELIB_DATA*)(tvi.lParam))->bHide) {
 814             AddToTLDataStrW(pTLData, L"\n");
 815             AddToTLDataStrWithTabsW(pTLData, ((TYPELIB_DATA*)(tvi.lParam))->idl);
 816         }
 817         hCur = (HTREEITEM)SendMessageW(typelib.hTree, TVM_GETNEXTITEM,
 818                 TVGN_NEXT, (LPARAM)hCur);
 819     }
 820 }
 821
 822 static void AddPredefinitions(HTREEITEM hFirst, TYPELIB_DATA *pTLData)
 823 {
 824     HTREEITEM hCur;
 825     TVITEMW tvi;
 826     WCHAR wszText[MAX_LOAD_STRING];
 827     WCHAR wszPredefinition[] = { '/','/',' ','T','L','i','b',' ',':','\n',
 828         '/','/',' ','F','o','r','w','a','r','d',' ','d','e','c','l','a','r','e',' ',
 829         'a','l','l',' ','t','y','p','e','s',' ','d','e','f','i','n','e','d',' ',
 830         'i','n',' ','t','h','i','s',' ','t','y','p','e','l','i','b','\0' };
 831
 832     hFirst = (HTREEITEM)SendMessageW(typelib.hTree, TVM_GETNEXTITEM,
 833             TVGN_CHILD, (LPARAM)hFirst);
 834
 835     AddToTLDataStrWithTabsW(pTLData, wszPredefinition);
 836     AddToTLDataStrW(pTLData, L"\n");
 837
 838     hCur = hFirst;
 839     memset(&tvi, 0, sizeof(TVITEMW));
 840     tvi.mask = TVIF_TEXT|TVIF_PARAM;
 841     tvi.cchTextMax = MAX_LOAD_STRING;
 842     tvi.pszText = wszText;
 843     while(hCur)
 844     {
 845         tvi.hItem = hCur;
 846         SendMessageW(typelib.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
 847         if(((TYPELIB_DATA*)(tvi.lParam))->bPredefine &&
 848                 !((TYPELIB_DATA*)(tvi.lParam))->bHide)
 849         {
 850             AddToStrW(wszText, L";");
 851             AddToTLDataStrWithTabsW(pTLData, wszText);
 852             AddToTLDataStrW(pTLData, L"\n");
 853         }
 854         hCur = (HTREEITEM)SendMessageW(typelib.hTree, TVM_GETNEXTITEM,
 855                 TVGN_NEXT, (LPARAM)hCur);
 856     }
 857 }
 858
 859 static void CreateInterfaceInfo(ITypeInfo *pTypeInfo, int cImplTypes, WCHAR *wszName,
 860         WCHAR *wszHelpString, ULONG ulHelpContext, TYPEATTR *pTypeAttr,
 861         TYPELIB_DATA *pTLData)
 862 {
 863     ITypeInfo *pRefTypeInfo;
 864     HREFTYPE hRefType;
 865     BSTR bstrName;
 866     WCHAR wszGuid[MAX_LOAD_STRING];
 867     WCHAR wszHelpContext[MAX_LOAD_STRING];
 868
 869     const WCHAR wszInterface[] = { 'i','n','t','e','r','f','a','c','e',' ','\0' };
 870     const WCHAR wszDispinterface[]
 871         = { 'd','i','s','p','i','n','t','e','r','f','a','c','e',' ','\0' };
 872     const WCHAR wszHelpcontext[] = { 'h','e','l','p','c','o','n','t','e','x','t','\0' };
 873     const WCHAR wszTYPEFLAG_FAPPOBJECT[] = { 'a','p','p','o','b','j','e','c','t','\0' };
 874     const WCHAR wszTYPEFLAG_FCANCREATE[] = { 'c','a','n','c','r','e','a','t','e','\0' };
 875     const WCHAR wszTYPEFLAG_FLICENSED[] = { 'l','i','c','e','n','s','e','d','\0' };
 876     const WCHAR wszTYPEFLAG_FPREDECLID[] = { 'p','r','e','d','e','c','l','i','d','\0' };
 877     const WCHAR wszTYPEFLAG_FHIDDEN[] = { 'h','i','d','d','e','n','\0' };
 878     const WCHAR wszTYPEFLAG_FCONTROL[] = { 'c','o','n','t','r','o','l','\0' };
 879     const WCHAR wszTYPEFLAG_FDUAL[] = { 'd','u','a','l','\0' };
 880     const WCHAR wszTYPEFLAG_FNONEXTENSIBLE[]
 881         = { 'n','o','n','e','x','t','e','n','s','i','b','l','e','\0' };
 882     const WCHAR wszTYPEFLAG_FOLEAUTOMATION[]
 883         = { 'o','l','e','a','u','t','o','m','a','t','i','o','n','\0' };
 884     const WCHAR wszTYPEFLAG_FRESTRICTED[]
 885         = { 'r','e','s','t','r','i','c','t','e','d','\0' };
 886     const WCHAR wszTYPEFLAG_FAGGREGATABLE[]
 887         = { 'a','g','g','r','e','g','a','t','a','b','l','e','\0' };
 888     const WCHAR wszTYPEFLAG_FREPLACEABLE[]
 889         = { 'r','e','p','l','a','c','a','b','l','e','\0' };
 890     const WCHAR wszTYPEFLAG_FREVERSEBIND[]
 891         = { 'r','e','v','e','r','s','e','b','i','n','d','\0' };
 892     const WCHAR wszTYPEFLAG_FPROXY[] = { 'p','r','o','x','y','\0' };
 893
 894     AddToTLDataStrW(pTLData, L"[\n");
 895     if(pTypeAttr->typekind != TKIND_DISPATCH)
 896     {
 897         AddSpaces(pTLData, TAB_SIZE);
 898         AddToTLDataStrW(pTLData, wszOdl);
 899         AddToTLDataStrW(pTLData, L",\n");
 900     }
 901     AddSpaces(pTLData, TAB_SIZE);
 902     AddToTLDataStrW(pTLData, wszUUID);
 903     AddToTLDataStrW(pTLData, L"(");
 904     StringFromGUID2(&(pTypeAttr->guid), wszGuid, MAX_LOAD_STRING);
 905     wszGuid[lstrlenW(wszGuid)-1] = '\0';
 906     AddToTLDataStrW(pTLData, &wszGuid[1]);
 907     AddToTLDataStrW(pTLData, L")");
 908     if(wszHelpString)
 909     {
 910         AddToTLDataStrW(pTLData, L",\n");
 911         AddSpaces(pTLData, TAB_SIZE);
 912         AddToTLDataStrW(pTLData, wszHelpstring);
 913         AddToTLDataStrW(pTLData, L"(\"");
 914         AddToTLDataStrW(pTLData, wszHelpString);
 915         AddToTLDataStrW(pTLData, L"\")");
 916     }
 917     if(ulHelpContext)
 918     {
 919         AddToTLDataStrW(pTLData, L",\n");
 920         AddSpaces(pTLData, TAB_SIZE);
 921         AddToTLDataStrW(pTLData, wszHelpcontext);
 922         AddToTLDataStrW(pTLData, L"(");
 923         wsprintfW(wszHelpContext, wszFormat, ulHelpContext);
 924         AddToTLDataStrW(pTLData, wszHelpContext);
 925         AddToTLDataStrW(pTLData, L")");
 926     }
 927     if(pTypeAttr->wTypeFlags)
 928     {
 929 #define ENUM_FLAGS(x) if(pTypeAttr->wTypeFlags & x)\
 930         {\
 931             AddToTLDataStrW(pTLData, L",\n");\
 932             AddSpaces(pTLData, TAB_SIZE);\
 933             AddToTLDataStrW(pTLData, wsz##x);\
 934         }
 935         ENUM_FLAGS(TYPEFLAG_FAPPOBJECT);
 936         ENUM_FLAGS(TYPEFLAG_FCANCREATE);
 937         ENUM_FLAGS(TYPEFLAG_FLICENSED);
 938         ENUM_FLAGS(TYPEFLAG_FPREDECLID);
 939         ENUM_FLAGS(TYPEFLAG_FHIDDEN);
 940         ENUM_FLAGS(TYPEFLAG_FCONTROL);
 941         ENUM_FLAGS(TYPEFLAG_FDUAL);
 942         ENUM_FLAGS(TYPEFLAG_FNONEXTENSIBLE);
 943         ENUM_FLAGS(TYPEFLAG_FOLEAUTOMATION);
 944         ENUM_FLAGS(TYPEFLAG_FRESTRICTED);
 945         ENUM_FLAGS(TYPEFLAG_FAGGREGATABLE);
 946         ENUM_FLAGS(TYPEFLAG_FREPLACEABLE);
 947         ENUM_FLAGS(TYPEFLAG_FREVERSEBIND);
 948         ENUM_FLAGS(TYPEFLAG_FPROXY);
 949     }
 950     AddToTLDataStrW(pTLData, L"\n]\n");
 951     if(pTypeAttr->typekind != TKIND_DISPATCH) AddToTLDataStrW(pTLData, wszInterface);
 952     else AddToTLDataStrW(pTLData, wszDispinterface);
 953     AddToTLDataStrW(pTLData, wszName);
 954     AddToTLDataStrW(pTLData, L" ");
 955     if(cImplTypes && pTypeAttr->typekind != TKIND_DISPATCH)
 956     {
 957         AddToTLDataStrW(pTLData, L": ");
 958
 959         ITypeInfo_GetRefTypeOfImplType(pTypeInfo, 0, &hRefType);
 960         if (SUCCEEDED(ITypeInfo_GetRefTypeInfo(pTypeInfo, hRefType, &pRefTypeInfo)))
 961         {
 962             ITypeInfo_GetDocumentation(pRefTypeInfo, MEMBERID_NIL, &bstrName,
 963                 NULL, NULL, NULL);
 964             AddToTLDataStrW(pTLData, bstrName);
 965             AddToTLDataStrW(pTLData, L" ");
 966
 967             SysFreeString(bstrName);
 968             ITypeInfo_Release(pRefTypeInfo);
 969         }
 970         else
 971             AddToTLDataStrW(pTLData, wszFailed);
 972     }
 973     AddToTLDataStrW(pTLData, L"{\n");
 974
 975     AddToStrW(pTLData->wszInsertAfter, L"};\n");
 976 }
 977
 978 static void CreateTypedefHeader(ITypeInfo *pTypeInfo,
 979         TYPEATTR *pTypeAttr, TYPELIB_DATA *pTLData)
 980 {
 981     BOOL bFirst = TRUE;
 982     WCHAR wszGuid[MAX_LOAD_STRING];
 983     const WCHAR wszTypedef[] = { 't','y','p','e','d','e','f',' ','\0' };
 984     const WCHAR wszPublic[] = { 'p','u','b','l','i','c','\0' };
 985
 986     AddToTLDataStrW(pTLData, wszTypedef);
 987     if(memcmp(&pTypeAttr->guid, &GUID_NULL, sizeof(GUID)))
 988     {
 989         AddToTLDataStrW(pTLData, L"[");
 990         bFirst = FALSE;
 991         AddToTLDataStrW(pTLData, wszUUID);
 992         AddToTLDataStrW(pTLData, L"(");
 993         StringFromGUID2(&(pTypeAttr->guid), wszGuid, MAX_LOAD_STRING);
 994         wszGuid[lstrlenW(wszGuid)-1] = '\0';
 995         AddToTLDataStrW(pTLData, &wszGuid[1]);
 996         AddToTLDataStrW(pTLData, L")");
 997     }
 998     if(pTypeAttr->typekind == TKIND_ALIAS)
 999     {
1000         if(bFirst) AddToTLDataStrW(pTLData, L"[");
1001         else AddToTLDataStrW(pTLData, L", ");
1002         bFirst = FALSE;
1003         AddToTLDataStrW(pTLData, wszPublic);
1004     }
1005     if(!bFirst) AddToTLDataStrW(pTLData, L"]\n");
1006 }
1007
1008 static void CreateCoclassHeader(ITypeInfo *pTypeInfo,
1009         TYPEATTR *pTypeAttr, TYPELIB_DATA *pTLData)
1010 {
1011     WCHAR wszGuid[MAX_LOAD_STRING];
1012     BSTR bstrHelpString;
1013     const WCHAR wszNoncreatable[]
1014         = { 'n','o','n','c','r','e','a','t','a','b','l','e','\0' };
1015
1016     AddToTLDataStrW(pTLData, L"[\n");
1017
1018     AddSpaces(pTLData, TAB_SIZE);
1019     AddToTLDataStrW(pTLData, wszUUID);
1020     AddToTLDataStrW(pTLData, L"(");
1021     StringFromGUID2(&(pTypeAttr->guid), wszGuid, MAX_LOAD_STRING);
1022     wszGuid[lstrlenW(wszGuid)-1] = '\0';
1023     AddToTLDataStrW(pTLData, &wszGuid[1]);
1024     AddToTLDataStrW(pTLData, L")");
1025
1026     if(SUCCEEDED(ITypeInfo_GetDocumentation(pTypeInfo, MEMBERID_NIL, NULL,
1027             &bstrHelpString, NULL, NULL)))
1028     {
1029         if(SysStringLen(bstrHelpString))
1030         {
1031             AddToTLDataStrW(pTLData, L",\n");
1032             AddSpaces(pTLData, TAB_SIZE);
1033             AddToTLDataStrW(pTLData, wszHelpstring);
1034             AddToTLDataStrW(pTLData, L"(\"");
1035             AddToTLDataStrW(pTLData, bstrHelpString);
1036             AddToTLDataStrW(pTLData, L"\")");
1037         }
1038         SysFreeString(bstrHelpString);
1039     }
1040
1041     if(!(pTypeAttr->wTypeFlags & TYPEFLAG_FCANCREATE))
1042     {
1043         AddToTLDataStrW(pTLData, L",\n");
1044         AddSpaces(pTLData, TAB_SIZE);
1045         AddToTLDataStrW(pTLData, wszNoncreatable);
1046     }
1047
1048     AddToTLDataStrW(pTLData, L"\n]\n");
1049 }
1050
1051 static int PopulateTree(void)
1052 {
1053     TVINSERTSTRUCTW tvis;
1054     TVITEMW tvi;
1055     ITypeLib *pTypeLib;
1056     TLIBATTR *pTLibAttr;
1057     ITypeInfo *pTypeInfo, *pRefTypeInfo;
1058     HREFTYPE hRefType;
1059     TYPEATTR *pTypeAttr;
1060     INT count, i;
1061     ULONG ulHelpContext;
1062     BSTR bstrName;
1063     BSTR bstrData;
1064     WCHAR wszText[MAX_LOAD_STRING];
1065     WCHAR wszAfter[MAX_LOAD_STRING];
1066     HRESULT hRes;
1067     HTREEITEM hParent;
1068     HTREEITEM hMain;
1069     BOOL bInsert;
1070     TYPELIB_DATA *tldDispatch;
1071     TYPELIB_DATA *tld;
1072
1073     const WCHAR wszGeneratedInfo[] = { '/','/',' ','G','e','n','e','r','a','t','e','d',
1074         ' ','.','I','D','L',' ','f','i','l','e',' ','(','b','y',' ','t','h','e',' ',
1075         'O','L','E','/','C','O','M',' ','O','b','j','e','c','t',' ',
1076         'V','i','e','w','e','r',')','\n','/','/','\n','/','/',' ',
1077         't','y','p','e','l','i','b',' ','f','i','l','e','n','a','m','e',':',' ','\0'};
1078
1079     const WCHAR wszFormat[] = { '%','s',' ','(','%','s',')','\0' };
1080     const WCHAR wszFormat2[] = { 'v','e','r','s','i','o','n',
1081         '(','%','l','d','.','%','l','d',')','\0' };
1082
1083     const WCHAR wszTKIND_ENUM[] = { 't','y','p','e','d','e','f',' ','e','n','u','m',' ','\0' };
1084     const WCHAR wszTKIND_RECORD[]
1085         = { 't','y','p','e','d','e','f',' ','s','t','r','u','c','t',' ','\0' };
1086     const WCHAR wszTKIND_MODULE[] = { 'm','o','d','u','l','e',' ','\0' };
1087     const WCHAR wszTKIND_INTERFACE[] = { 'i','n','t','e','r','f','a','c','e',' ','\0' };
1088     const WCHAR wszTKIND_DISPATCH[]
1089         = { 'd','i','s','p','i','n','t','e','r','f','a','c','e',' ','\0' };
1090     const WCHAR wszTKIND_COCLASS[] = { 'c','o','c','l','a','s','s',' ','\0' };
1091     const WCHAR wszTKIND_ALIAS[] = { 't','y','p','e','d','e','f',' ','\0' };
1092     const WCHAR wszTKIND_UNION[]
1093         = { 't','y','p','e','d','e','f',' ','u','n','i','o','n',' ','\0' };
1094
1095     const WCHAR wszLibrary[] = { 'l','i','b','r','a','r','y',' ','\0' };
1096     const WCHAR wszTag[] = { 't','a','g','\0' };
1097
1098     WCHAR wszProperties[] = { 'p','r','o','p','e','r','t','i','e','s','\0' };
1099     WCHAR wszMethods[] = { 'm','e','t','h','o','d','s','\0' };
1100
1101     tvis.item.mask = TVIF_TEXT|TVIF_PARAM;
1102     tvis.item.cchTextMax = MAX_LOAD_STRING;
1103     tvis.item.pszText = wszText;
1104     tvis.hInsertAfter = TVI_LAST;
1105     tvis.hParent = TVI_ROOT;
1106
1107     if(FAILED((hRes = LoadTypeLib(typelib.wszFileName, &pTypeLib))))
1108     {
1109         WCHAR wszMessage[MAX_LOAD_STRING];
1110         WCHAR wszError[MAX_LOAD_STRING];
1111         DWORD_PTR args[2];
1112
1113         LoadStringW(globals.hMainInst, IDS_ERROR_LOADTYPELIB, wszError, ARRAY_SIZE(wszError));
1114         args[0] = (DWORD_PTR)typelib.wszFileName;
1115         args[1] = hRes;
1116         FormatMessageW(FORMAT_MESSAGE_FROM_STRING|FORMAT_MESSAGE_ARGUMENT_ARRAY,
1117                        wszError, 0, 0, wszMessage, ARRAY_SIZE(wszMessage), (va_list *)args);
1118         MessageBoxW(globals.hMainWnd, wszMessage, NULL, MB_OK|MB_ICONEXCLAMATION);
1119         return 1;
1120     }
1121     count = ITypeLib_GetTypeInfoCount(pTypeLib);
1122
1123     ITypeLib_GetDocumentation(pTypeLib, -1, &bstrName, &bstrData, NULL, NULL);
1124     ITypeLib_GetLibAttr(pTypeLib, &pTLibAttr);
1125
1126     tld = InitializeTLData();
1127     tvis.item.lParam = (LPARAM) tld;
1128     AddToTLDataStrW(tld, wszGeneratedInfo);
1129     AddToTLDataStrW(tld, typelib.wszFileName);
1130     AddToTLDataStrW(tld, L"\n\n[\n");
1131     AddSpaces(tld, TAB_SIZE);
1132     AddToTLDataStrW(tld, wszUUID);
1133     AddToTLDataStrW(tld, L"(");
1134     StringFromGUID2(&(pTLibAttr->guid), wszText, MAX_LOAD_STRING);
1135     wszText[lstrlenW(wszText)-1] = '\0';
1136     AddToTLDataStrW(tld, &wszText[1]);
1137     AddToTLDataStrW(tld, L"),\n");
1138     AddSpaces(tld, TAB_SIZE);
1139     wsprintfW(wszText, wszFormat2, pTLibAttr->wMajorVerNum, pTLibAttr->wMinorVerNum);
1140     AddToTLDataStrW(tld, wszText);
1141
1142     if (bstrData)
1143     {
1144         /* helpstring is optional */
1145         AddToTLDataStrW(tld, L",\n");
1146         AddSpaces(tld, TAB_SIZE);
1147         AddToTLDataStrW(tld, wszHelpstring);
1148         AddToTLDataStrW(tld, L"(\"");
1149         AddToTLDataStrW(tld, bstrData);
1150         AddToTLDataStrW(tld, L"\")");
1151     }
1152
1153     AddToTLDataStrW(tld, L"\n]\n");
1154     AddToTLDataStrW(tld, wszLibrary);
1155     if (bstrName) AddToTLDataStrW(tld, bstrName);
1156     AddToTLDataStrW(tld, L"\n{\n");
1157
1158     AddToStrW(tld->wszInsertAfter, L"};");
1159
1160     wsprintfW(wszText, wszFormat, bstrName, bstrData);
1161     SysFreeString(bstrName);
1162     SysFreeString(bstrData);
1163     tvis.hParent = (HTREEITEM)SendMessageW(typelib.hTree,
1164             TVM_INSERTITEMW, 0, (LPARAM)&tvis);
1165
1166     for(i=0; i<count; i++)
1167     {
1168         bInsert = TRUE;
1169         ITypeLib_GetTypeInfo(pTypeLib, i, &pTypeInfo);
1170
1171         ITypeInfo_GetDocumentation(pTypeInfo, MEMBERID_NIL, &bstrName, &bstrData,
1172                 &ulHelpContext, NULL);
1173         ITypeInfo_GetTypeAttr(pTypeInfo, &pTypeAttr);
1174
1175         memset(wszText, 0, sizeof(wszText));
1176         memset(wszAfter, 0, sizeof(wszAfter));
1177         tld = InitializeTLData();
1178         tvis.item.lParam = (LPARAM)tld;
1179         switch(pTypeAttr->typekind)
1180         {
1181             case TKIND_ENUM:
1182                 AddToStrW(wszText, wszTKIND_ENUM);
1183                 AddToStrW(wszText, bstrName);
1184
1185                 CreateTypedefHeader(pTypeInfo, pTypeAttr, tld);
1186                 AddToTLDataStrW(tld, &wszTKIND_ENUM[lstrlenW(wszTKIND_ALIAS)]);
1187                 AddToTLDataStrW(tld, L"{\n");
1188                 AddToStrW(tld->wszInsertAfter, L"} ");
1189                 AddToStrW(tld->wszInsertAfter, bstrName);
1190                 AddToStrW(tld->wszInsertAfter, L";\n");
1191
1192                 bInsert = FALSE;
1193                 hParent = TreeView_InsertItemW(typelib.hTree, &tvis);
1194                 EnumEnums(pTypeInfo, pTypeAttr->cVars, hParent);
1195                 AddChildrenData(hParent, tld);
1196                 AddToTLDataStrW(tld, tld->wszInsertAfter);
1197                 break;
1198             case TKIND_RECORD:
1199                 AddToTLDataStrW(tld, wszTKIND_RECORD);
1200                 AddToTLDataStrW(tld, wszTag);
1201                 AddToTLDataStrW(tld, bstrName);
1202                 AddToTLDataStrW(tld, L" {\n");
1203
1204                 AddToStrW(tld->wszInsertAfter, L"} ");
1205                 AddToStrW(tld->wszInsertAfter, bstrName);
1206                 AddToStrW(tld->wszInsertAfter, L";\n");
1207
1208                 AddToStrW(wszText, wszTKIND_RECORD);
1209                 AddToStrW(wszText, bstrName);
1210                 break;
1211             case TKIND_MODULE:
1212                 AddToStrW(wszText, wszTKIND_MODULE);
1213                 AddToStrW(wszText, bstrName);
1214                 break;
1215             case TKIND_INTERFACE:
1216                 CreateInterfaceInfo(pTypeInfo, pTypeAttr->cImplTypes, bstrName,
1217                         bstrData, ulHelpContext, pTypeAttr, tld);
1218                 tld->bPredefine = TRUE;
1219
1220                 AddToStrW(wszText, wszTKIND_INTERFACE);
1221                 AddToStrW(wszText, bstrName);
1222                 break;
1223             case TKIND_COCLASS:
1224                 AddToStrW(wszText, wszTKIND_COCLASS);
1225                 AddToStrW(wszText, bstrName);
1226
1227                 CreateCoclassHeader(pTypeInfo, pTypeAttr, tld);
1228                 AddToTLDataStrW(tld, wszTKIND_COCLASS);
1229                 AddToTLDataStrW(tld, bstrName);
1230                 AddToTLDataStrW(tld, L" {\n");
1231
1232                 EnumCoclassImplTypes(pTypeInfo, pTypeAttr->cImplTypes, tld);
1233
1234                 AddToStrW(tld->wszInsertAfter, L"};\n");
1235
1236                 bInsert = FALSE;
1237                 hParent = TreeView_InsertItemW(typelib.hTree, &tvis);
1238                 AddToTLDataStrW(tld, tld->wszInsertAfter);
1239                 break;
1240             case TKIND_UNION:
1241                 AddToStrW(wszText, wszTKIND_UNION);
1242                 AddToStrW(wszText, bstrName);
1243                 break;
1244             case TKIND_DISPATCH:
1245                 CreateInterfaceInfo(pTypeInfo, pTypeAttr->cImplTypes, bstrName,
1246                         bstrData, ulHelpContext, pTypeAttr, tld);
1247                 tld->bPredefine = TRUE;
1248                 if(pTypeAttr->wTypeFlags & TYPEFLAG_FDUAL)
1249                     tld->bHide = TRUE;
1250                 AddToStrW(wszText, wszTKIND_DISPATCH);
1251                 AddToStrW(wszText, bstrName);
1252
1253                 hParent = TreeView_InsertItemW(typelib.hTree, &tvis);
1254                 hMain = tvis.hParent;
1255                 tldDispatch = tld;
1256
1257                 lstrcpyW(wszText, wszProperties);
1258                 tvis.hParent = hParent;
1259                 tld = InitializeTLData();
1260                 tvis.item.lParam = (LPARAM) tld;
1261                 AddToTLDataStrW(tld, wszProperties);
1262                 AddToTLDataStrW(tld, L":\n");
1263                 tvis.hParent = TreeView_InsertItemW(typelib.hTree, &tvis);
1264                 EnumVars(pTypeInfo, pTypeAttr->cVars, tvis.hParent);
1265                 AddChildrenData(tvis.hParent, tld);
1266
1267                 lstrcpyW(wszText, wszMethods);
1268                 tvis.hParent = hParent;
1269                 tld = InitializeTLData();
1270                 tvis.item.lParam = (LPARAM) tld;
1271                 AddToTLDataStrW(tld, wszMethods);
1272                 AddToTLDataStrW(tld, L":\n");
1273                 tvis.hParent = TreeView_InsertItemW(typelib.hTree, &tvis);
1274                 EnumFuncs(pTypeInfo, pTypeAttr, tvis.hParent);
1275                 AddChildrenData(tvis.hParent, tld);
1276
1277                 EnumImplTypes(pTypeInfo, pTypeAttr->cImplTypes, hParent);
1278                 AddChildrenData(hParent, tldDispatch);
1279                 AddToTLDataStrW(tldDispatch, tldDispatch->wszInsertAfter);
1280
1281                 bInsert = FALSE;
1282                 tvis.hParent = hMain;
1283
1284                 if(SUCCEEDED(ITypeInfo_GetRefTypeOfImplType(pTypeInfo, -1, &hRefType)))
1285                 {
1286                     bInsert = TRUE;
1287
1288                     ITypeInfo_ReleaseTypeAttr(pTypeInfo, pTypeAttr);
1289                     SysFreeString(bstrName);
1290                     SysFreeString(bstrData);
1291
1292                     memset(wszText, 0, sizeof(wszText));
1293                     tld = InitializeTLData();
1294                     tvis.item.lParam = (LPARAM) tld;
1295
1296                     ITypeInfo_GetRefTypeInfo(pTypeInfo, hRefType, &pRefTypeInfo);
1297                     ITypeInfo_GetDocumentation(pRefTypeInfo, MEMBERID_NIL, &bstrName,
1298                                 &bstrData, &ulHelpContext, NULL);
1299                     ITypeInfo_GetTypeAttr(pRefTypeInfo, &pTypeAttr);
1300
1301                     CreateInterfaceInfo(pTypeInfo, pTypeAttr->cImplTypes, bstrName,
1302                             bstrData, ulHelpContext, pTypeAttr, tld);
1303                     tld->bPredefine = TRUE;
1304
1305                     AddToStrW(wszText, wszTKIND_INTERFACE);
1306                     AddToStrW(wszText, bstrName);
1307                     ITypeInfo_Release(pRefTypeInfo);
1308                 }
1309                 break;
1310             case TKIND_ALIAS:
1311                 AddToStrW(wszText, wszTKIND_ALIAS);
1312                 CreateTypeInfo(wszText, wszAfter, pTypeAttr->tdescAlias, pTypeInfo);
1313                 AddToStrW(wszText, L" ");
1314                 AddToStrW(wszText, bstrName);
1315                 AddToStrW(wszText, wszAfter);
1316
1317                 CreateTypedefHeader(pTypeInfo, pTypeAttr, tld);
1318                 AddToTLDataStrW(tld, &wszText[lstrlenW(wszTKIND_ALIAS)]);
1319                 AddToTLDataStrW(tld, L";\n");
1320                 break;
1321             default:
1322                 lstrcpyW(wszText, bstrName);
1323                 WINE_FIXME("pTypeAttr->typekind == %d not supported\n",
1324                         pTypeAttr->typekind);
1325         }
1326
1327         if(bInsert)
1328         {
1329             hParent = TreeView_InsertItemW(typelib.hTree, &tvis);
1330
1331             EnumVars(pTypeInfo, pTypeAttr->cVars, hParent);
1332             EnumFuncs(pTypeInfo, pTypeAttr, hParent);
1333             EnumImplTypes(pTypeInfo, pTypeAttr->cImplTypes, hParent);
1334
1335             if(memcmp(bstrName, wszVT_UNKNOWN, sizeof(wszVT_UNKNOWN)))
1336                 AddChildrenData(hParent, tld);
1337             AddToTLDataStrW(tld, tld->wszInsertAfter);
1338         }
1339
1340         ITypeInfo_ReleaseTypeAttr(pTypeInfo, pTypeAttr);
1341         ITypeInfo_Release(pTypeInfo);
1342         SysFreeString(bstrName);
1343         SysFreeString(bstrData);
1344     }
1345     SendMessageW(typelib.hTree, TVM_EXPAND, TVE_EXPAND, (LPARAM)tvis.hParent);
1346
1347     memset(&tvi, 0, sizeof(TVITEMW));
1348     tvi.mask = TVIF_PARAM;
1349     tvi.hItem = tvis.hParent;
1350
1351     SendMessageW(typelib.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
1352     AddPredefinitions(tvi.hItem, (TYPELIB_DATA*)(tvi.lParam));
1353     AddIdlData(tvi.hItem, (TYPELIB_DATA*)(tvi.lParam));
1354     AddToTLDataStrW((TYPELIB_DATA*)(tvi.lParam),
1355             ((TYPELIB_DATA*)(tvi.lParam))->wszInsertAfter);
1356
1357     ITypeLib_Release(pTypeLib);
1358     return 0;
1359 }
1360
1361 void UpdateData(HTREEITEM item)
1362 {
1363     TVITEMW tvi;
1364
1365     memset(&tvi, 0, sizeof(TVITEMW));
1366     tvi.mask = TVIF_PARAM;
1367     tvi.hItem = item;
1368
1369     SendMessageW(typelib.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
1370     if(!tvi.lParam)
1371     {
1372         SetWindowTextW(typelib.hEdit, L" ");
1373         return;
1374     }
1375
1376     SetWindowTextW(typelib.hEdit, ((TYPELIB_DATA*)tvi.lParam)->idl);
1377 }
1378
1379 static void TypeLibResizeChild(void)
1380 {
1381     RECT client, stat;
1382
1383     MoveWindow(typelib.hStatusBar, 0, 0, 0, 0, TRUE);
1384
1385     if(IsWindowVisible(typelib.hStatusBar))
1386         GetClientRect(typelib.hStatusBar, &stat);
1387     else stat.bottom = 0;
1388
1389     GetClientRect(globals.hTypeLibWnd, &client);
1390     MoveWindow(typelib.hPaneWnd, 0, 0,
1391             client.right, client.bottom-stat.bottom, TRUE);
1392 }
1393
1394 static void TypeLibMenuCommand(WPARAM wParam, HWND hWnd)
1395 {
1396     BOOL vis;
1397
1398     switch(wParam)
1399     {
1400         case IDM_SAVEAS:
1401             GetSaveIdlAsPath();
1402             break;
1403         case IDM_STATUSBAR:
1404             vis = IsWindowVisible(typelib.hStatusBar);
1405             ShowWindow(typelib.hStatusBar, vis ? SW_HIDE : SW_SHOW);
1406             CheckMenuItem(GetMenu(hWnd), LOWORD(wParam),
1407                     vis ? MF_UNCHECKED : MF_CHECKED);
1408             TypeLibResizeChild();
1409             break;
1410         case IDM_CLOSE:
1411             DestroyWindow(hWnd);
1412             break;
1413     }
1414 }
1415
1416 static void UpdateTypeLibStatusBar(int itemID)
1417 {
1418     WCHAR info[MAX_LOAD_STRING];
1419
1420     if(!LoadStringW(globals.hMainInst, itemID, info, ARRAY_SIZE(info)))
1421         LoadStringW(globals.hMainInst, IDS_READY, info, ARRAY_SIZE(info));
1422
1423     SendMessageW(typelib.hStatusBar, SB_SETTEXTW, 0, (LPARAM)info);
1424 }
1425
1426 static void EmptyTLTree(void)
1427 {
1428     HTREEITEM cur, del;
1429     TVITEMW tvi;
1430
1431     tvi.mask = TVIF_PARAM;
1432     cur = (HTREEITEM)SendMessageW(typelib.hTree, TVM_GETNEXTITEM,
1433             TVGN_CHILD, (LPARAM)TVI_ROOT);
1434
1435     while(TRUE)
1436     {
1437         del = cur;
1438         cur = (HTREEITEM)SendMessageW(typelib.hTree, TVM_GETNEXTITEM,
1439                 TVGN_CHILD, (LPARAM)del);
1440
1441         if(!cur) cur = (HTREEITEM)SendMessageW(typelib.hTree,
1442                 TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)del);
1443         if(!cur) cur = (HTREEITEM)SendMessageW(typelib.hTree,
1444                 TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)del);
1445
1446         tvi.hItem = del;
1447         SendMessageW(typelib.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
1448         if(tvi.lParam)
1449         {
1450             free(((TYPELIB_DATA*)tvi.lParam)->idl);
1451             free((TYPELIB_DATA*)tvi.lParam);
1452         }
1453
1454         SendMessageW(typelib.hTree, TVM_DELETEITEM, 0, (LPARAM)del);
1455
1456         if(!cur) break;
1457     }
1458 }
1459
1460 static LRESULT CALLBACK TypeLibProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1461 {
1462     switch(uMsg)
1463     {
1464         case WM_CREATE:
1465         {
1466             if(!CreatePanedWindow(hWnd, &typelib.hPaneWnd, globals.hMainInst))
1467                 DestroyWindow(hWnd);
1468             typelib.hTree = CreateWindowExW(WS_EX_CLIENTEDGE, WC_TREEVIEWW, NULL,
1469                     WS_CHILD|WS_VISIBLE|TVS_HASLINES|TVS_HASBUTTONS|TVS_LINESATROOT,
1470                     0, 0, 0, 0, typelib.hPaneWnd, (HMENU)TYPELIB_TREE,
1471                     globals.hMainInst, NULL);
1472             typelib.hEdit = CreateWindowExW(WS_EX_CLIENTEDGE, WC_EDITW, NULL,
1473                     WS_CHILD|WS_VISIBLE|ES_MULTILINE|ES_READONLY|WS_HSCROLL|WS_VSCROLL,
1474                     0, 0, 0, 0, typelib.hPaneWnd, NULL, globals.hMainInst, NULL);
1475
1476             SetLeft(typelib.hPaneWnd, typelib.hTree);
1477             SetRight(typelib.hPaneWnd, typelib.hEdit);
1478
1479             if(PopulateTree()) DestroyWindow(hWnd);
1480             else SetFocus(typelib.hTree);
1481             break;
1482         }
1483         case WM_COMMAND:
1484             TypeLibMenuCommand(LOWORD(wParam), hWnd);
1485             break;
1486         case WM_MENUSELECT:
1487             UpdateTypeLibStatusBar(LOWORD(wParam));
1488             break;
1489         case WM_SETFOCUS:
1490             SetFocus(typelib.hTree);
1491             break;
1492         case WM_SIZE:
1493             if(wParam == SIZE_MINIMIZED) break;
1494             TypeLibResizeChild();
1495             break;
1496         case WM_DESTROY:
1497             EmptyTLTree();
1498             break;
1499         default:
1500             return DefWindowProcW(hWnd, uMsg, wParam, lParam);
1501     }
1502     return 0;
1503 }
1504
1505 BOOL TypeLibRegisterClassW(void)
1506 {
1507     WNDCLASSW wcc;
1508
1509     memset(&wcc, 0, sizeof(WNDCLASSW));
1510     wcc.lpfnWndProc = TypeLibProc;
1511     wcc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
1512     wcc.hCursor       = LoadCursorW(0, (LPCWSTR)IDC_ARROW);
1513     wcc.lpszMenuName = MAKEINTRESOURCEW(IDM_TYPELIB);
1514     wcc.lpszClassName = wszTypeLib;
1515
1516     if(!RegisterClassW(&wcc))
1517         return FALSE;
1518
1519     return TRUE;
1520 }
1521
1522 BOOL CreateTypeLibWindow(HINSTANCE hInst, WCHAR *wszFileName)
1523 {
1524     WCHAR wszTitle[MAX_LOAD_STRING];
1525     LoadStringW(hInst, IDS_TYPELIBTITLE, wszTitle, ARRAY_SIZE(wszTitle));
1526
1527     if(wszFileName) lstrcpyW(typelib.wszFileName, wszFileName);
1528     else
1529     {
1530         TVITEMW tvi;
1531
1532         memset(&tvi, 0, sizeof(TVITEMW));
1533         tvi.hItem = (HTREEITEM)SendMessageW(globals.hTree, TVM_GETNEXTITEM,
1534                 TVGN_CARET, 0);
1535
1536         SendMessageW(globals.hTree, TVM_GETITEMW, 0, (LPARAM)&tvi);
1537         lstrcpyW(typelib.wszFileName, ((ITEM_INFO*)tvi.lParam)->path);
1538     }
1539
1540     globals.hTypeLibWnd = CreateWindowW(wszTypeLib, wszTitle,
1541             WS_OVERLAPPEDWINDOW|WS_VISIBLE,
1542             CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, NULL, NULL, hInst, NULL);
1543     if(!globals.hTypeLibWnd) return FALSE;
1544
1545     typelib.hStatusBar = CreateStatusWindowW(WS_VISIBLE|WS_CHILD,
1546             wszTitle, globals.hTypeLibWnd, 0);
1547
1548     TypeLibResizeChild();
1549     return TRUE;
1550 }