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