git.oblomov.eu Git - wine/blob - programs/oleview/typelib.c

   1 /*
   2  * OleView (typelib.c)
   3  *
   4  * Copyright 2006 Piotr Caban
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "main.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(oleview);
  26
  27 TYPELIB typelib;
  28 static const WCHAR wszTypeLib[] = { 'T','Y','P','E','L','I','B','\0' };
  29
  30 static const WCHAR wszFailed[] = { '<','f','a','i','l','e','d','>','\0' };
  31 static const WCHAR wszSpace[] = { ' ','\0' };
  32 static const WCHAR wszAsterix[] = { '*','\0' };
  33 static const WCHAR wszComa[] = { ',','\0' };
  34 static const WCHAR wszSemicolon[] = { ';','\0' };
  35 static const WCHAR wszNewLine[] = { '\n','\0' };
  36 static const WCHAR wszOpenBrackets1[] = { '[','\0' };
  37 static const WCHAR wszCloseBrackets1[] = { ']','\0' };
  38 static const WCHAR wszOpenBrackets2[] = { '(','\0' };
  39 static const WCHAR wszCloseBrackets2[] = { ')','\0' };
  40 static const WCHAR wszOpenBrackets3[] = { '{','\0' };
  41 static const WCHAR wszCloseBrackets3[] = { '}','\0' };
  42 static const WCHAR wszInvertedComa[] = { '"','\0' };
  43 static const WCHAR wszColon[] = { ':','\0' };
  44
  45 static const WCHAR wszUUID[] = { 'u','u','i','d','\0' };
  46 static const WCHAR wszOdl[] = { 'o','d','l','\0' };
  47
  48 static const WCHAR wszVT_BOOL[]
  49     = { 'V','A','R','I','A','N','T','_','B','O','O','L','\0' };
  50 static const WCHAR wszVT_UI1[]
  51     = { 'u','n','s','i','g','n','e','d',' ','c','h','a','r','\0' };
  52 static const WCHAR wszVT_UI2[]
  53     = { 'u','n','s','i','g','n','e','d',' ','s','h','o','r','t','\0' };
  54 static const WCHAR wszVT_UI4[]
  55     = { 'u','n','s','i','g','n','e','d',' ','l','o','n','g','\0' };
  56 static const WCHAR wszVT_UI8[] = { 'u','i','n','t','6','4','\0' };
  57 static const WCHAR wszVT_UINT[]
  58     = { 'u','n','s','i','g','n','e','d',' ','i','n','t','\0' };
  59 static const WCHAR wszVT_I1[] = { 'c','h','a','r','\0' };
  60 static const WCHAR wszVT_I2[] = { 's','h','o','r','t','\0' };
  61 static const WCHAR wszVT_I4[] = { 'l','o','n','g','\0' };
  62 static const WCHAR wszVT_I8[] = { 'i','n','t','6','4','\0' };
  63 static const WCHAR wszVT_R4[] = { 's','i','n','g','l','e','\0' };
  64 static const WCHAR wszVT_INT[] = { 'i','n','t','\0' };
  65 static const WCHAR wszVT_BSTR[] = { 'B','S','T','R','\0' };
  66 static const WCHAR wszVT_CY[] = { 'C','U','R','R','E','N','C','Y','\0' };
  67 static const WCHAR wszVT_VARIANT[] = { 'V','A','R','I','A','N','T','\0' };
  68 static const WCHAR wszVT_VOID[] = { 'v','o','i','d','\0' };
  69 static const WCHAR wszVT_ERROR[] = { 'S','C','O','D','E','\0' };
  70 static const WCHAR wszVT_LPSTR[] = { 'L','P','S','T','R','\0' };
  71 static const WCHAR wszVT_LPWSTR[] = { 'L','P','W','S','T','R','\0' };
  72
  73 void AddToStrW(WCHAR *wszDest, const WCHAR *wszSource)
  74 {
  75     lstrcpyW(&wszDest[lstrlenW(wszDest)], wszSource);
  76 }
  77
  78 void AddToTLDataStrW(TYPELIB_DATA *pTLData, const WCHAR *wszSource)
  79 {
  80     int SourceLen = lstrlenW(wszSource);
  81
  82     pTLData->idl = HeapReAlloc(GetProcessHeap(), 0, pTLData->idl,
  83             sizeof(WCHAR)*(pTLData->idlLen+SourceLen+1));
  84
  85     memcpy(&pTLData->idl[pTLData->idlLen], wszSource, sizeof(WCHAR)*(SourceLen+1));
  86     pTLData->idlLen += SourceLen;
  87 }
  88
  89 LPARAM InitializeTLData(void)
  90 {
  91     TYPELIB_DATA *pTLData;
  92
  93     pTLData = HeapAlloc(GetProcessHeap(), 0, sizeof(TYPELIB_DATA));
  94
  95     memset(pTLData, 0, sizeof(TYPELIB_DATA));
  96     pTLData->idl = HeapAlloc(GetProcessHeap(), 0, sizeof(WCHAR));
  97     pTLData->idl[0] = '\0';
  98
  99     return (LPARAM)pTLData;
 100 }
 101
 102 void AddChildrenData(HTREEITEM hParent, TYPELIB_DATA *pData)
 103 {
 104     HTREEITEM hCur;
 105     TVITEM tvi;
 106
 107     memset(&tvi, 0, sizeof(&tvi));
 108
 109     hCur = TreeView_GetChild(typelib.hTree, hParent);
 110     if(!hCur) return;
 111
 112     do
 113     {
 114         tvi.hItem = hCur;
 115         SendMessage(typelib.hTree, TVM_GETITEM, 0, (LPARAM)&tvi);
 116         if(tvi.lParam && ((TYPELIB_DATA *)(tvi.lParam))->idlLen)
 117             AddToTLDataStrW(pData, ((TYPELIB_DATA *)(tvi.lParam))->idl);
 118     }while((hCur = TreeView_GetNextSibling(typelib.hTree, hCur)));
 119
 120     AddToTLDataStrW(pData, pData->wszInsertAfter);
 121 }
 122
 123 void CreateTypeInfo(WCHAR *wszAddTo, WCHAR *wszAddAfter, TYPEDESC tdesc, ITypeInfo *pTypeInfo)
 124 {
 125     int i;
 126     BSTR bstrData;
 127     HRESULT hRes;
 128     ITypeInfo *pRefTypeInfo;
 129     WCHAR wszBuf[MAX_LOAD_STRING];
 130     WCHAR wszFormat[] = { '[','%','l','u',']','\0' };
 131
 132     switch(tdesc.vt&VT_TYPEMASK)
 133     {
 134 #define VTADDTOSTR(x) case x:\
 135         AddToStrW(wszAddTo, wsz##x);\
 136         break
 137         VTADDTOSTR(VT_BOOL);
 138         VTADDTOSTR(VT_UI1);
 139         VTADDTOSTR(VT_UI2);
 140         VTADDTOSTR(VT_UI4);
 141         VTADDTOSTR(VT_UI8);
 142         VTADDTOSTR(VT_UINT);
 143         VTADDTOSTR(VT_I1);
 144         VTADDTOSTR(VT_I2);
 145         VTADDTOSTR(VT_I4);
 146         VTADDTOSTR(VT_I8);
 147         VTADDTOSTR(VT_R4);
 148         VTADDTOSTR(VT_INT);
 149         VTADDTOSTR(VT_BSTR);
 150         VTADDTOSTR(VT_CY);
 151         VTADDTOSTR(VT_VARIANT);
 152         VTADDTOSTR(VT_VOID);
 153         VTADDTOSTR(VT_ERROR);
 154         VTADDTOSTR(VT_LPSTR);
 155         VTADDTOSTR(VT_LPWSTR);
 156         case VT_CARRAY:
 157         for(i=0; i<U(tdesc).lpadesc->cDims; i++)
 158         {
 159             wsprintfW(wszBuf, wszFormat, U(tdesc).lpadesc->rgbounds[i].cElements);
 160             AddToStrW(wszAddAfter, wszBuf);
 161         }
 162         CreateTypeInfo(wszAddTo, wszAddAfter, U(tdesc).lpadesc->tdescElem, pTypeInfo);
 163         break;
 164         case VT_PTR:
 165         CreateTypeInfo(wszAddTo, wszAddAfter, *U(tdesc).lptdesc, pTypeInfo);
 166         AddToStrW(wszAddTo, wszAsterix);
 167         break;
 168         case VT_USERDEFINED:
 169         hRes = ITypeInfo_GetRefTypeInfo(pTypeInfo,
 170                 U(tdesc).hreftype, &pRefTypeInfo);
 171         if(SUCCEEDED(hRes))
 172         {
 173             ITypeInfo_GetDocumentation(pRefTypeInfo, MEMBERID_NIL,
 174                     &bstrData, NULL, NULL, NULL);
 175             AddToStrW(wszAddTo, bstrData);
 176             SysFreeString(bstrData);
 177             ITypeInfo_Release(pRefTypeInfo);
 178         }
 179         else AddToStrW(wszAddTo, wszFailed);
 180         break;
 181         default:
 182         WINE_FIXME("tdesc.vt&VT_TYPEMASK == %d not supported\n",
 183                 tdesc.vt&VT_TYPEMASK);
 184     }
 185 }
 186
 187 int EnumVars(ITypeInfo *pTypeInfo, int cVars, HTREEITEM hParent)
 188 {
 189     int i;
 190     TVINSERTSTRUCT tvis;
 191     VARDESC *pVarDesc;
 192     BSTR bstrName;
 193     WCHAR wszText[MAX_LOAD_STRING];
 194     WCHAR wszAfter[MAX_LOAD_STRING];
 195
 196     U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
 197     U(tvis).item.cchTextMax = MAX_LOAD_STRING;
 198     U(tvis).item.pszText = wszText;
 199     tvis.hInsertAfter = (HTREEITEM)TVI_LAST;
 200     tvis.hParent = hParent;
 201
 202     for(i=0; i<cVars; i++)
 203     {
 204         if(FAILED(ITypeInfo_GetVarDesc(pTypeInfo, i, &pVarDesc))) continue;
 205         if(FAILED(ITypeInfo_GetDocumentation(pTypeInfo, pVarDesc->memid, &bstrName,
 206                 NULL, NULL, NULL))) continue;
 207
 208         memset(wszText, 0, sizeof(wszText));
 209         memset(wszAfter, 0, sizeof(wszAfter));
 210         CreateTypeInfo(wszText, wszAfter, pVarDesc->elemdescVar.tdesc, pTypeInfo);
 211         AddToStrW(wszText, wszSpace);
 212         AddToStrW(wszText, bstrName);
 213         AddToStrW(wszText, wszAfter);
 214         U(tvis).item.lParam = InitializeTLData();
 215         AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszText);
 216         AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszSemicolon);
 217         AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 218
 219         SendMessage(typelib.hTree, TVM_INSERTITEM, 0, (LPARAM)&tvis);
 220         SysFreeString(bstrName);
 221         ITypeInfo_ReleaseVarDesc(pTypeInfo, pVarDesc);
 222     }
 223
 224     return 0;
 225 }
 226
 227 int EnumFuncs(ITypeInfo *pTypeInfo, int cFuncs, HTREEITEM hParent)
 228 {
 229     int i;
 230     TVINSERTSTRUCT tvis;
 231     FUNCDESC *pFuncDesc;
 232     BSTR bstrName;
 233
 234     U(tvis).item.mask = TVIF_TEXT;
 235     tvis.hInsertAfter = (HTREEITEM)TVI_LAST;
 236     tvis.hParent = hParent;
 237
 238     for(i=0; i<cFuncs; i++)
 239     {
 240         if(FAILED(ITypeInfo_GetFuncDesc(pTypeInfo, i, &pFuncDesc))) continue;
 241         if(FAILED(ITypeInfo_GetDocumentation(pTypeInfo, pFuncDesc->memid, &bstrName,
 242                 NULL, NULL, NULL))) continue;
 243
 244         U(tvis).item.cchTextMax = SysStringLen(bstrName);
 245         U(tvis).item.pszText = bstrName;
 246
 247         SendMessage(typelib.hTree, TVM_INSERTITEM, 0, (LPARAM)&tvis);
 248         SysFreeString(bstrName);
 249         ITypeInfo_ReleaseFuncDesc(pTypeInfo, pFuncDesc);
 250     }
 251
 252     return 0;
 253 }
 254
 255 int EnumImplTypes(ITypeInfo *pTypeInfo, int cImplTypes, HTREEITEM hParent)
 256 {
 257     int i;
 258     TVINSERTSTRUCT tvis;
 259     ITypeInfo *pRefTypeInfo;
 260     HREFTYPE hRefType;
 261     TYPEATTR *pTypeAttr;
 262     BSTR bstrName;
 263     WCHAR wszInheritedInterfaces[MAX_LOAD_STRING];
 264
 265     if(!cImplTypes) return 0;
 266
 267     LoadString(globals.hMainInst, IDS_INHERITINTERFACES, wszInheritedInterfaces,
 268             sizeof(WCHAR[MAX_LOAD_STRING]));
 269
 270     U(tvis).item.mask = TVIF_TEXT;
 271     U(tvis).item.cchTextMax = MAX_LOAD_STRING;
 272     U(tvis).item.pszText = wszInheritedInterfaces;
 273     tvis.hInsertAfter = (HTREEITEM)TVI_LAST;
 274     tvis.hParent = hParent;
 275
 276     tvis.hParent = TreeView_InsertItem(typelib.hTree, &tvis);
 277
 278     for(i=0; i<cImplTypes; i++)
 279     {
 280         if(FAILED(ITypeInfo_GetRefTypeOfImplType(pTypeInfo, i, &hRefType))) continue;
 281         if(FAILED(ITypeInfo_GetRefTypeInfo(pTypeInfo, hRefType, &pRefTypeInfo)))
 282             continue;
 283         if(FAILED(ITypeInfo_GetDocumentation(pRefTypeInfo, MEMBERID_NIL, &bstrName,
 284                 NULL, NULL, NULL))) continue;
 285         if(FAILED(ITypeInfo_GetTypeAttr(pRefTypeInfo, &pTypeAttr))) continue;
 286
 287         U(tvis).item.cchTextMax = SysStringLen(bstrName);
 288         U(tvis).item.pszText = bstrName;
 289
 290         hParent = TreeView_InsertItem(typelib.hTree, &tvis);
 291         EnumVars(pRefTypeInfo, pTypeAttr->cVars, hParent);
 292         EnumFuncs(pRefTypeInfo, pTypeAttr->cFuncs, hParent);
 293         EnumImplTypes(pRefTypeInfo, pTypeAttr->cImplTypes, hParent);
 294
 295         SysFreeString(bstrName);
 296         ITypeInfo_ReleaseTypeAttr(pRefTypeInfo, pTypeAttr);
 297         ITypeInfo_Release(pRefTypeInfo);
 298     }
 299
 300     return 0;
 301 }
 302
 303 void CreateInterfaceInfo(ITypeInfo *pTypeInfo, int cImplTypes, WCHAR *wszName,
 304         WCHAR *wszHelpString, TYPEATTR *pTypeAttr, TYPELIB_DATA *pTLData)
 305 {
 306     ITypeInfo *pRefTypeInfo;
 307     HREFTYPE hRefType;
 308     BSTR bstrName;
 309     WCHAR wszGuid[MAX_LOAD_STRING];
 310     BOOL bFirst;
 311
 312     const WCHAR wszInterface[] = { 'I','n','t','e','r','f','a','c','e',' ','\0' };
 313     const WCHAR wszHelpstring[] = { 'h','e','l','p','s','t','r','i','n','g','\0' };
 314     const WCHAR wszTYPEFLAG_FAPPOBJECT[] = { 'a','p','p','o','b','j','e','c','t','\0' };
 315     const WCHAR wszTYPEFLAG_FCANCREATE[] = { 'c','a','n','c','r','e','a','t','e','\0' };
 316     const WCHAR wszTYPEFLAG_FLICENSED[] = { 'l','i','c','e','n','s','e','d','\0' };
 317     const WCHAR wszTYPEFLAG_FPREDECLID[] = { 'p','r','e','d','e','c','l','i','d','\0' };
 318     const WCHAR wszTYPEFLAG_FHIDDEN[] = { 'h','i','d','d','e','n','\0' };
 319     const WCHAR wszTYPEFLAG_FCONTROL[] = { 'c','o','n','t','r','o','l','\0' };
 320     const WCHAR wszTYPEFLAG_FDUAL[] = { 'd','u','a','l','\0' };
 321     const WCHAR wszTYPEFLAG_FNONEXTENSIBLE[]
 322         = { 'n','o','n','e','x','t','e','n','s','i','b','l','e','\0' };
 323     const WCHAR wszTYPEFLAG_FOLEAUTOMATION[]
 324         = { 'o','l','e','a','u','t','o','m','a','t','i','o','n','\0' };
 325     const WCHAR wszTYPEFLAG_FRESTRICTED[]
 326         = { 'r','e','s','t','r','i','c','t','e','d','\0' };
 327     const WCHAR wszTYPEFLAG_FAGGREGATABLE[]
 328         = { 'a','g','g','r','e','g','a','t','a','b','l','e','\0' };
 329     const WCHAR wszTYPEFLAG_FREPLACEABLE[]
 330         = { 'r','e','p','l','a','c','a','b','l','e','\0' };
 331     const WCHAR wszTYPEFLAG_FDISPATCHABLE[]
 332         = { 'd','i','s','p','a','t','c','h','a','b','l','e','\0' };
 333     const WCHAR wszTYPEFLAG_FREVERSEBIND[]
 334         = { 'r','e','v','e','r','s','e','b','i','n','d','\0' };
 335     const WCHAR wszTYPEFLAG_FPROXY[] = { 'p','r','o','x','y','\0' };
 336
 337     AddToTLDataStrW(pTLData, wszOpenBrackets1);
 338     AddToTLDataStrW(pTLData, wszNewLine);
 339     AddToTLDataStrW(pTLData, wszOdl);
 340     AddToTLDataStrW(pTLData, wszComa);
 341     AddToTLDataStrW(pTLData, wszNewLine);
 342     AddToTLDataStrW(pTLData, wszUUID);
 343     AddToTLDataStrW(pTLData, wszOpenBrackets2);
 344     StringFromGUID2(&(pTypeAttr->guid), wszGuid, MAX_LOAD_STRING);
 345     wszGuid[lstrlenW(wszGuid)-1] = '\0';
 346     AddToTLDataStrW(pTLData, &wszGuid[1]);
 347     AddToTLDataStrW(pTLData, wszCloseBrackets2);
 348     if(wszHelpString)
 349     {
 350         AddToTLDataStrW(pTLData, wszComa);
 351         AddToTLDataStrW(pTLData, wszNewLine);
 352         AddToTLDataStrW(pTLData, wszHelpstring);
 353         AddToTLDataStrW(pTLData, wszOpenBrackets2);
 354         AddToTLDataStrW(pTLData, wszInvertedComa);
 355         AddToTLDataStrW(pTLData, wszHelpString);
 356         AddToTLDataStrW(pTLData, wszInvertedComa);
 357         AddToTLDataStrW(pTLData, wszCloseBrackets2);
 358     }
 359     if(pTypeAttr->wTypeFlags)
 360     {
 361         bFirst = TRUE;
 362         AddToTLDataStrW(pTLData, wszComa);
 363         AddToTLDataStrW(pTLData, wszNewLine);
 364 #define ENUM_FLAGS(x) if(pTypeAttr->wTypeFlags & x)\
 365         {\
 366             if(!bFirst)\
 367             {\
 368                 AddToTLDataStrW(pTLData, wszComa);\
 369                 AddToTLDataStrW(pTLData, wszSpace);\
 370             }\
 371             bFirst = FALSE;\
 372             AddToTLDataStrW(pTLData, wsz##x);\
 373         }
 374         ENUM_FLAGS(TYPEFLAG_FAPPOBJECT);
 375         ENUM_FLAGS(TYPEFLAG_FCANCREATE);
 376         ENUM_FLAGS(TYPEFLAG_FLICENSED);
 377         ENUM_FLAGS(TYPEFLAG_FPREDECLID);
 378         ENUM_FLAGS(TYPEFLAG_FHIDDEN);
 379         ENUM_FLAGS(TYPEFLAG_FCONTROL);
 380         ENUM_FLAGS(TYPEFLAG_FDUAL);
 381         ENUM_FLAGS(TYPEFLAG_FNONEXTENSIBLE);
 382         ENUM_FLAGS(TYPEFLAG_FOLEAUTOMATION);
 383         ENUM_FLAGS(TYPEFLAG_FRESTRICTED);
 384         ENUM_FLAGS(TYPEFLAG_FAGGREGATABLE);
 385         ENUM_FLAGS(TYPEFLAG_FREPLACEABLE);
 386         ENUM_FLAGS(TYPEFLAG_FDISPATCHABLE);
 387         ENUM_FLAGS(TYPEFLAG_FREVERSEBIND);
 388         ENUM_FLAGS(TYPEFLAG_FPROXY);
 389     }
 390     AddToTLDataStrW(pTLData, wszNewLine);
 391     AddToTLDataStrW(pTLData, wszCloseBrackets1);
 392     AddToTLDataStrW(pTLData, wszNewLine);
 393     AddToTLDataStrW(pTLData, wszInterface);
 394     AddToTLDataStrW(pTLData, wszName);
 395     AddToTLDataStrW(pTLData, wszSpace);
 396     if(cImplTypes)
 397     {
 398         AddToTLDataStrW(pTLData, wszColon);
 399         AddToTLDataStrW(pTLData, wszSpace);
 400
 401         ITypeInfo_GetRefTypeOfImplType(pTypeInfo, 0, &hRefType);
 402         ITypeInfo_GetRefTypeInfo(pTypeInfo, hRefType, &pRefTypeInfo);
 403         ITypeInfo_GetDocumentation(pRefTypeInfo, MEMBERID_NIL, &bstrName,
 404                 NULL, NULL, NULL);
 405         AddToTLDataStrW(pTLData, bstrName);
 406         AddToTLDataStrW(pTLData, wszSpace);
 407
 408         SysFreeString(bstrName);
 409         ITypeInfo_Release(pRefTypeInfo);
 410     }
 411     AddToTLDataStrW(pTLData, wszOpenBrackets3);
 412     AddToTLDataStrW(pTLData, wszNewLine);
 413
 414     AddToStrW(pTLData->wszInsertAfter, wszCloseBrackets3);
 415     AddToStrW(pTLData->wszInsertAfter, wszSemicolon);
 416     AddToStrW(pTLData->wszInsertAfter, wszNewLine);
 417 }
 418
 419 int PopulateTree(void)
 420 {
 421     TVINSERTSTRUCT tvis;
 422     ITypeLib *pTypeLib;
 423     TLIBATTR *pTLibAttr;
 424     ITypeInfo *pTypeInfo, *pRefTypeInfo;
 425     HREFTYPE hRefType;
 426     TYPEATTR *pTypeAttr;
 427     INT count, i;
 428     BSTR bstrName;
 429     BSTR bstrData;
 430     WCHAR wszText[MAX_LOAD_STRING];
 431     WCHAR wszAfter[MAX_LOAD_STRING];
 432     HRESULT hRes;
 433     HTREEITEM hParent;
 434
 435     const WCHAR wszGeneratedInfo[] = { '/','/',' ','G','e','n','e','r','a','t','e','d',
 436         ' ','.','I','D','L',' ','f','i','l','e',' ','(','b','y',' ','t','h','e',' ',
 437         'O','L','E','/','C','O','M',' ','O','b','j','e','c','t',' ',
 438         'V','i','e','w','e','r',')','\n','/','/','\n','/','/',' ',
 439         't','y','p','e','l','i','b',' ','f','i','l','e','n','a','m','e',':',' ','\0'};
 440
 441     const WCHAR wszFormat[] = { '%','s',' ','(','%','s',')','\0' };
 442     const WCHAR wszFormat2[] = { 'v','e','r','s','i','o','n',
 443         '(','%','l','d','.','%','l','d',')','\0' };
 444
 445     const WCHAR wszTKIND_ENUM[] = { 't','y','p','e','d','e','f',' ','e','n','u','m',' ','\0' };
 446     const WCHAR wszTKIND_RECORD[]
 447         = { 't','y','p','e','d','e','f',' ','s','t','r','u','c','t',' ','\0' };
 448     const WCHAR wszTKIND_MODULE[] = { 'm','o','d','u','l','e',' ','\0' };
 449     const WCHAR wszTKIND_INTERFACE[] = { 'i','n','t','e','r','f','a','c','e',' ','\0' };
 450     const WCHAR wszTKIND_DISPATCH[]
 451         = { 'd','i','s','p','i','n','t','e','r','f','a','c','e',' ','\0' };
 452     const WCHAR wszTKIND_COCLASS[] = { 'c','o','c','l','a','s','s',' ','\0' };
 453     const WCHAR wszTKIND_ALIAS[] = { 't','y','p','e','d','e','f',' ','\0' };
 454     const WCHAR wszTKIND_UNION[]
 455         = { 't','y','p','e','d','e','f',' ','u','n','i','o','n',' ','\0' };
 456
 457     const WCHAR wszHelpString[] = { 'h','e','l','p','s','t','r','i','n','g','\0' };
 458     const WCHAR wszLibrary[] = { 'l','i','b','r','a','r','y',' ','\0' };
 459     const WCHAR wszTag[] = { 't','a','g','\0' };
 460
 461     U(tvis).item.mask = TVIF_TEXT|TVIF_PARAM;
 462     U(tvis).item.cchTextMax = MAX_LOAD_STRING;
 463     U(tvis).item.pszText = wszText;
 464     tvis.hInsertAfter = (HTREEITEM)TVI_LAST;
 465     tvis.hParent = TVI_ROOT;
 466
 467     if(FAILED((hRes = LoadTypeLib(typelib.wszFileName, &pTypeLib))))
 468     {
 469         WCHAR wszMessage[MAX_LOAD_STRING];
 470         WCHAR wszError[MAX_LOAD_STRING];
 471
 472         LoadString(globals.hMainInst, IDS_ERROR_LOADTYPELIB,
 473                 wszError, sizeof(WCHAR[MAX_LOAD_STRING]));
 474         wsprintfW(wszMessage, wszError, typelib.wszFileName, hRes);
 475         MessageBox(globals.hMainWnd, wszMessage, NULL, MB_OK|MB_ICONEXCLAMATION);
 476         return 1;
 477     }
 478     count = ITypeLib_GetTypeInfoCount(pTypeLib);
 479
 480     ITypeLib_GetDocumentation(pTypeLib, -1, &bstrName, &bstrData, NULL, NULL);
 481     ITypeLib_GetLibAttr(pTypeLib, &pTLibAttr);
 482
 483     U(tvis).item.lParam = InitializeTLData();
 484     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszGeneratedInfo);
 485     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), typelib.wszFileName);
 486     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 487     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 488     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszOpenBrackets1);
 489     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 490     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszUUID);
 491     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszOpenBrackets2);
 492     StringFromGUID2(&(pTLibAttr->guid), wszText, MAX_LOAD_STRING);
 493     wszText[lstrlenW(wszText)-1] = '\0';
 494     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), &wszText[1]);
 495     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszCloseBrackets2);
 496     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszComa);
 497     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 498     wsprintfW(wszText, wszFormat2, pTLibAttr->wMajorVerNum, pTLibAttr->wMinorVerNum);
 499     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszText);
 500     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszComa);
 501     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 502     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszHelpString);
 503     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszOpenBrackets2);
 504     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), bstrData);
 505     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszCloseBrackets2);
 506     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 507     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszCloseBrackets1);
 508     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 509     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszLibrary);
 510     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), bstrName);
 511     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 512     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszOpenBrackets3);
 513     AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 514
 515     AddToStrW(((TYPELIB_DATA*)(U(tvis).item.lParam))->wszInsertAfter, wszCloseBrackets3);
 516     AddToStrW(((TYPELIB_DATA*)(U(tvis).item.lParam))->wszInsertAfter, wszSemicolon);
 517
 518     wsprintfW(wszText, wszFormat, bstrName, bstrData);
 519     SysFreeString(bstrName);
 520     SysFreeString(bstrData);
 521     tvis.hParent = (HTREEITEM)SendMessage(typelib.hTree,
 522             TVM_INSERTITEM, 0, (LPARAM)&tvis);
 523
 524     for(i=0; i<count; i++)
 525     {
 526         ITypeLib_GetTypeInfo(pTypeLib, i, &pTypeInfo);
 527
 528         ITypeInfo_GetDocumentation(pTypeInfo, MEMBERID_NIL, &bstrName, &bstrData,
 529                 NULL, NULL);
 530         ITypeInfo_GetTypeAttr(pTypeInfo, &pTypeAttr);
 531
 532         memset(wszText, 0, sizeof(wszText));
 533         memset(wszAfter, 0, sizeof(wszAfter));
 534         U(tvis).item.lParam = InitializeTLData();
 535         switch(pTypeAttr->typekind)
 536         {
 537             case TKIND_ENUM:
 538                 AddToStrW(wszText, wszTKIND_ENUM);
 539                 AddToStrW(wszText, bstrName);
 540                 break;
 541             case TKIND_RECORD:
 542                 AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszTKIND_RECORD);
 543                 AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszTag);
 544                 AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), bstrName);
 545                 AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszSpace);
 546                 AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszOpenBrackets3);
 547                 AddToTLDataStrW((TYPELIB_DATA*)(U(tvis).item.lParam), wszNewLine);
 548
 549                 AddToStrW(((TYPELIB_DATA*)(U(tvis).item.lParam))->wszInsertAfter,
 550                         wszCloseBrackets3);
 551                 AddToStrW(((TYPELIB_DATA*)(U(tvis).item.lParam))->wszInsertAfter,
 552                         wszSpace);
 553                 AddToStrW(((TYPELIB_DATA*)(U(tvis).item.lParam))->wszInsertAfter,
 554                         bstrName);
 555                 AddToStrW(((TYPELIB_DATA*)(U(tvis).item.lParam))->wszInsertAfter,
 556                         wszSemicolon);
 557                 AddToStrW(((TYPELIB_DATA*)(U(tvis).item.lParam))->wszInsertAfter,
 558                         wszNewLine);
 559
 560                 AddToStrW(wszText, wszTKIND_RECORD);
 561                 AddToStrW(wszText, bstrName);
 562                 break;
 563             case TKIND_MODULE:
 564                 AddToStrW(wszText, wszTKIND_MODULE);
 565                 AddToStrW(wszText, bstrName);
 566                 break;
 567             case TKIND_INTERFACE:
 568                 CreateInterfaceInfo(pTypeInfo, pTypeAttr->cImplTypes, bstrName,
 569                         bstrData, pTypeAttr, (TYPELIB_DATA*)(U(tvis).item.lParam));
 570
 571                 AddToStrW(wszText, wszTKIND_INTERFACE);
 572                 AddToStrW(wszText, bstrName);
 573                 break;
 574             case TKIND_COCLASS:
 575                 AddToStrW(wszText, wszTKIND_COCLASS);
 576                 AddToStrW(wszText, bstrName);
 577                 break;
 578             case TKIND_UNION:
 579                 AddToStrW(wszText, wszTKIND_UNION);
 580                 AddToStrW(wszText, bstrName);
 581                 break;
 582             case TKIND_DISPATCH:
 583                 AddToStrW(wszText, wszTKIND_DISPATCH);
 584                 AddToStrW(wszText, bstrName);
 585                 if(SUCCEEDED(ITypeInfo_GetRefTypeOfImplType(pTypeInfo, -1, &hRefType)))
 586                 {
 587                     hParent = TreeView_InsertItem(typelib.hTree, &tvis);
 588                     EnumImplTypes(pTypeInfo, pTypeAttr->cImplTypes, hParent);
 589                     memset(wszText, 0, sizeof(wszText));
 590                     U(tvis).item.lParam = InitializeTLData();
 591
 592                     ITypeInfo_GetRefTypeInfo(pTypeInfo, hRefType, &pRefTypeInfo);
 593                     ITypeInfo_GetDocumentation(pRefTypeInfo, MEMBERID_NIL, &bstrName,
 594                                 &bstrData, NULL, NULL);
 595
 596                     CreateInterfaceInfo(pTypeInfo, pTypeAttr->cImplTypes, bstrName,
 597                             bstrData, pTypeAttr, (TYPELIB_DATA*)(U(tvis).item.lParam));
 598
 599                     AddToStrW(wszText, wszTKIND_INTERFACE);
 600                     AddToStrW(wszText, bstrName);
 601                     ITypeInfo_Release(pRefTypeInfo);
 602                 }
 603                 break;
 604             case TKIND_ALIAS:
 605                 AddToStrW(wszText, wszTKIND_ALIAS);
 606                 CreateTypeInfo(wszText, wszAfter, pTypeAttr->tdescAlias, pTypeInfo);
 607                 AddToStrW(wszText, wszSpace);
 608                 AddToStrW(wszText, bstrName);
 609                 AddToStrW(wszText, wszAfter);
 610                 break;
 611             default:
 612                 lstrcpyW(wszText, bstrName);
 613                 WINE_FIXME("pTypeAttr->typekind ==  %d\n not supported",
 614                         pTypeAttr->typekind);
 615         }
 616         hParent = TreeView_InsertItem(typelib.hTree, &tvis);
 617
 618         EnumVars(pTypeInfo, pTypeAttr->cVars, hParent);
 619         EnumFuncs(pTypeInfo, pTypeAttr->cFuncs, hParent);
 620         EnumImplTypes(pTypeInfo, pTypeAttr->cImplTypes, hParent);
 621
 622         AddChildrenData(hParent, (TYPELIB_DATA*)(U(tvis).item.lParam));
 623
 624         ITypeInfo_ReleaseTypeAttr(pTypeInfo, pTypeAttr);
 625         ITypeInfo_Release(pTypeInfo);
 626         SysFreeString(bstrName);
 627         SysFreeString(bstrData);
 628     }
 629     SendMessage(typelib.hTree, TVM_EXPAND, TVE_EXPAND, (LPARAM)tvis.hParent);
 630
 631     ITypeLib_Release(pTypeLib);
 632     return 0;
 633 }
 634
 635 void UpdateData(HTREEITEM item)
 636 {
 637     TVITEM tvi;
 638
 639     memset(&tvi, 0, sizeof(TVITEM));
 640     tvi.mask = TVIF_PARAM;
 641     tvi.hItem = item;
 642
 643     SendMessage(typelib.hTree, TVM_GETITEM, 0, (LPARAM)&tvi);
 644     if(!tvi.lParam)
 645     {
 646         SetWindowText(typelib.hEdit, wszSpace);
 647         return;
 648     }
 649
 650     SetWindowText(typelib.hEdit, ((TYPELIB_DATA*)tvi.lParam)->idl);
 651 }
 652
 653 void TypeLibResizeChild(void)
 654 {
 655     RECT client, stat;
 656
 657     MoveWindow(typelib.hStatusBar, 0, 0, 0, 0, TRUE);
 658
 659     if(IsWindowVisible(typelib.hStatusBar))
 660         GetClientRect(typelib.hStatusBar, &stat);
 661     else stat.bottom = 0;
 662
 663     GetClientRect(globals.hTypeLibWnd, &client);
 664     MoveWindow(typelib.hPaneWnd, 0, 0,
 665             client.right, client.bottom-stat.bottom, TRUE);
 666 }
 667
 668 void TypeLibMenuCommand(WPARAM wParam, HWND hWnd)
 669 {
 670     BOOL vis;
 671
 672     switch(wParam)
 673     {
 674         case IDM_STATUSBAR:
 675             vis = IsWindowVisible(typelib.hStatusBar);
 676             ShowWindow(typelib.hStatusBar, vis ? SW_HIDE : SW_SHOW);
 677             CheckMenuItem(GetMenu(hWnd), LOWORD(wParam),
 678                     vis ? MF_UNCHECKED : MF_CHECKED);
 679             TypeLibResizeChild();
 680             break;
 681         case IDM_CLOSE:
 682             DestroyWindow(hWnd);
 683             break;
 684     }
 685 }
 686
 687 void UpdateTypeLibStatusBar(int itemID)
 688 {
 689     WCHAR info[MAX_LOAD_STRING];
 690
 691     if(!LoadString(globals.hMainInst, itemID, info, sizeof(WCHAR[MAX_LOAD_STRING])))
 692         LoadString(globals.hMainInst, IDS_READY, info, sizeof(WCHAR[MAX_LOAD_STRING]));
 693
 694     SendMessage(typelib.hStatusBar, SB_SETTEXT, 0, (LPARAM)info);
 695 }
 696
 697 void EmptyTLTree(void)
 698 {
 699     HTREEITEM cur, del;
 700     TVITEM tvi;
 701
 702     tvi.mask = TVIF_PARAM;
 703     cur = TreeView_GetChild(typelib.hTree, TVI_ROOT);
 704
 705     while(TRUE)
 706     {
 707         del = cur;
 708         cur = TreeView_GetChild(typelib.hTree, del);
 709
 710         if(!cur) cur = TreeView_GetNextSibling(typelib.hTree, del);
 711         if(!cur) cur = TreeView_GetParent(typelib.hTree, del);
 712
 713         tvi.hItem = del;
 714         SendMessage(typelib.hTree, TVM_GETITEM, 0, (LPARAM)&tvi);
 715         if(tvi.lParam)
 716         {
 717             HeapFree(GetProcessHeap(), 0, ((TYPELIB_DATA *)tvi.lParam)->idl);
 718             HeapFree(GetProcessHeap(), 0, (TYPELIB_DATA *)tvi.lParam);
 719         }
 720
 721         SendMessage(typelib.hTree, TVM_DELETEITEM, 0, (LPARAM)del);
 722
 723         if(!cur) break;
 724     }
 725 }
 726
 727 LRESULT CALLBACK TypeLibProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
 728 {
 729     switch(uMsg)
 730     {
 731         case WM_CREATE:
 732         {
 733             if(!CreatePanedWindow(hWnd, &typelib.hPaneWnd, globals.hMainInst))
 734                 DestroyWindow(hWnd);
 735             typelib.hTree = CreateWindowEx(WS_EX_CLIENTEDGE, WC_TREEVIEW, NULL,
 736                     WS_CHILD|WS_VISIBLE|TVS_HASLINES|TVS_HASBUTTONS|TVS_LINESATROOT,
 737                     0, 0, 0, 0, typelib.hPaneWnd, (HMENU)TYPELIB_TREE,
 738                     globals.hMainInst, NULL);
 739             typelib.hEdit = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, NULL,
 740                     WS_CHILD|WS_VISIBLE|ES_MULTILINE|ES_READONLY|WS_HSCROLL|WS_VSCROLL,
 741                     0, 0, 0, 0, typelib.hPaneWnd, NULL, globals.hMainInst, NULL);
 742
 743             SetLeft(typelib.hPaneWnd, typelib.hTree);
 744             SetRight(typelib.hPaneWnd, typelib.hEdit);
 745
 746             if(PopulateTree()) DestroyWindow(hWnd);
 747             else SetFocus(typelib.hTree);
 748             break;
 749         }
 750         case WM_COMMAND:
 751             TypeLibMenuCommand(LOWORD(wParam), hWnd);
 752         case WM_MENUSELECT:
 753             UpdateTypeLibStatusBar(LOWORD(wParam));
 754             break;
 755         case WM_SETFOCUS:
 756             SetFocus(typelib.hTree);
 757             break;
 758         case WM_SIZE:
 759             if(wParam == SIZE_MINIMIZED) break;
 760             TypeLibResizeChild();
 761             break;
 762         case WM_DESTROY:
 763             EmptyTLTree();
 764             break;
 765         default:
 766             return DefWindowProc(hWnd, uMsg, wParam, lParam);
 767     }
 768     return 0;
 769 }
 770
 771 BOOL TypeLibRegisterClass(void)
 772 {
 773     WNDCLASS wcc;
 774
 775     memset(&wcc, 0, sizeof(WNDCLASS));
 776     wcc.lpfnWndProc = TypeLibProc;
 777     wcc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
 778     wcc.lpszMenuName = MAKEINTRESOURCE(IDM_TYPELIB);
 779     wcc.lpszClassName = wszTypeLib;
 780
 781     if(!RegisterClass(&wcc))
 782         return FALSE;
 783
 784     return TRUE;
 785 }
 786
 787 BOOL CreateTypeLibWindow(HINSTANCE hInst, WCHAR *wszFileName)
 788 {
 789     WCHAR wszTitle[MAX_LOAD_STRING];
 790     LoadString(hInst, IDS_TYPELIBTITLE, wszTitle, sizeof(WCHAR[MAX_LOAD_STRING]));
 791
 792     if(wszFileName) lstrcpyW(typelib.wszFileName, wszFileName);
 793     else
 794     {
 795         TVITEM tvi;
 796
 797         memset(&tvi, 0, sizeof(TVITEM));
 798         tvi.hItem = TreeView_GetSelection(globals.hTree);
 799
 800         SendMessage(globals.hTree, TVM_GETITEM, 0, (LPARAM)&tvi);
 801         lstrcpyW(typelib.wszFileName, ((ITEM_INFO*)tvi.lParam)->path);
 802     }
 803
 804     globals.hTypeLibWnd = CreateWindow(wszTypeLib, wszTitle,
 805             WS_OVERLAPPEDWINDOW|WS_VISIBLE,
 806             CW_USEDEFAULT, CW_USEDEFAULT, 800, 600, NULL, NULL, hInst, NULL);
 807     if(!globals.hTypeLibWnd) return FALSE;
 808
 809     typelib.hStatusBar = CreateStatusWindow(WS_VISIBLE|WS_CHILD,
 810             (LPWSTR)wszTitle, globals.hTypeLibWnd, 0);
 811
 812     TypeLibResizeChild();
 813     return TRUE;
 814 }