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