4 * Copyright 2006 Piotr Caban
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.
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.
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
23 #include "wine/debug.h"
25 WINE_DEFAULT_DEBUG_CHANNEL(oleview
);
28 static const WCHAR wszTypeLib
[] = { 'T','Y','P','E','L','I','B','\0' };
30 static const WCHAR wszFailed
[] = { '<','f','a','i','l','e','d','>','\0' };
32 static const WCHAR wszUUID
[] = { 'u','u','i','d','\0' };
33 static const WCHAR wszOdl
[] = { 'o','d','l','\0' };
35 static const WCHAR wszVT_BOOL
[]
36 = { 'V','A','R','I','A','N','T','_','B','O','O','L','\0' };
37 static const WCHAR wszVT_UI1
[]
38 = { 'u','n','s','i','g','n','e','d',' ','c','h','a','r','\0' };
39 static const WCHAR wszVT_UI2
[]
40 = { 'u','n','s','i','g','n','e','d',' ','s','h','o','r','t','\0' };
41 static const WCHAR wszVT_UI4
[]
42 = { 'u','n','s','i','g','n','e','d',' ','l','o','n','g','\0' };
43 static const WCHAR wszVT_UI8
[] = { 'u','i','n','t','6','4','\0' };
44 static const WCHAR wszVT_UINT
[]
45 = { 'u','n','s','i','g','n','e','d',' ','i','n','t','\0' };
46 static const WCHAR wszVT_I1
[] = { 'c','h','a','r','\0' };
47 static const WCHAR wszVT_I2
[] = { 's','h','o','r','t','\0' };
48 static const WCHAR wszVT_I4
[] = { 'l','o','n','g','\0' };
49 static const WCHAR wszVT_I8
[] = { 'i','n','t','6','4','\0' };
50 static const WCHAR wszVT_R4
[] = { 's','i','n','g','l','e','\0' };
51 static const WCHAR wszVT_INT
[] = { 'i','n','t','\0' };
52 static const WCHAR wszVT_BSTR
[] = { 'B','S','T','R','\0' };
53 static const WCHAR wszVT_CY
[] = { 'C','U','R','R','E','N','C','Y','\0' };
54 static const WCHAR wszVT_VARIANT
[] = { 'V','A','R','I','A','N','T','\0' };
55 static const WCHAR wszVT_VOID
[] = { 'v','o','i','d','\0' };
56 static const WCHAR wszVT_ERROR
[] = { 'S','C','O','D','E','\0' };
57 static const WCHAR wszVT_LPSTR
[] = { 'L','P','S','T','R','\0' };
58 static const WCHAR wszVT_LPWSTR
[] = { 'L','P','W','S','T','R','\0' };
59 static const WCHAR wszVT_HRESULT
[] = { 'H','R','E','S','U','L','T','\0' };
60 static const WCHAR wszVT_UNKNOWN
[] = { 'I','U','n','k','n','o','w','n','\0' };
61 static const WCHAR wszVT_DISPATCH
[] = { 'I','D','i','s','p','a','t','c','h','\0' };
62 static const WCHAR wszVT_DATE
[] = { 'D','A','T','E','\0' };
63 static const WCHAR wszVT_R8
[] = { 'd','o','u','b','l','e','\0' };
64 static const WCHAR wszVT_SAFEARRAY
[] = { 'S','A','F','E','A','R','R','A','Y','\0' };
66 static const WCHAR wszFormat
[] = { '0','x','%','.','8','l','x','\0' };
67 static const WCHAR wszStdCall
[] = { '_','s','t','d','c','a','l','l','\0' };
68 static const WCHAR wszId
[] = { 'i','d','\0' };
69 static const WCHAR wszHelpstring
[] = { 'h','e','l','p','s','t','r','i','n','g','\0' };
70 static const WCHAR wszPropPut
[] = { 'p','r','o','p','p','u','t','\0' };
71 static const WCHAR wszPropGet
[] = { 'p','r','o','p','g','e','t','\0' };
72 static const WCHAR wszPropPutRef
[] = { 'p','r','o','p','p','u','t','r','e','f','\0' };
73 static const WCHAR wszPARAMFLAG_FIN
[] = { 'i','n','\0' };
74 static const WCHAR wszPARAMFLAG_FOUT
[] = { 'o','u','t','\0' };
75 static const WCHAR wszPARAMFLAG_FLCID
[] = { 'c','i','d','\0' };
76 static const WCHAR wszPARAMFLAG_FRETVAL
[] = { 'r','e','t','v','a','l','\0' };
77 static const WCHAR wszPARAMFLAG_FOPT
[] = { 'o','p','t','i','o','n','a','l','\0' };
78 static const WCHAR wszPARAMFLAG_FHASCUSTDATA
[]
79 = { 'h','a','s','c','u','s','t','d','a','t','a','\0' };
80 static const WCHAR wszDefaultValue
[]
81 = { 'd','e','f','a','u','l','t','v','a','l','u','e','\0' };
83 static const WCHAR wszReadOnly
[] = { 'r','e','a','d','o','n','l','y','\0' };
84 static const WCHAR wszConst
[] = { 'c','o','n','s','t','\0' };
86 static void ShowLastError(void)
88 DWORD error
= GetLastError();
90 WCHAR wszTitle
[MAX_LOAD_STRING
];
92 LoadStringW(globals
.hMainInst
, IDS_TYPELIBTITLE
, wszTitle
, ARRAY_SIZE(wszTitle
));
93 FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
,
94 NULL
, error
, 0, (LPWSTR
)&lpMsgBuf
, 0, NULL
);
95 MessageBoxW(NULL
, lpMsgBuf
, wszTitle
, MB_OK
| MB_ICONERROR
);
100 static void SaveIdl(WCHAR
*wszFileName
)
105 DWORD len
, dwNumWrite
;
109 hIDL
= (HTREEITEM
)SendMessageW(typelib
.hTree
, TVM_GETNEXTITEM
,
110 TVGN_CHILD
, (LPARAM
)TVI_ROOT
);
112 memset(&tvi
, 0, sizeof(TVITEMW
));
115 SendMessageW(typelib
.hTree
, TVM_GETITEMW
, 0, (LPARAM
)&tvi
);
116 data
= (TYPELIB_DATA
*)tvi
.lParam
;
118 hFile
= CreateFileW(wszFileName
, GENERIC_WRITE
, FILE_SHARE_WRITE
,
119 NULL
, CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
120 if(hFile
== INVALID_HANDLE_VALUE
)
126 len
= WideCharToMultiByte( CP_UTF8
, 0, data
->idl
, data
->idlLen
, NULL
, 0, NULL
, NULL
);
127 wszIdl
= malloc(len
);
128 WideCharToMultiByte( CP_UTF8
, 0, data
->idl
, data
->idlLen
, wszIdl
, len
, NULL
, NULL
);
130 if(!WriteFile(hFile
, wszIdl
, len
, &dwNumWrite
, NULL
))
137 static void GetSaveIdlAsPath(void)
139 OPENFILENAMEW saveidl
;
141 WCHAR wszPath
[MAX_LOAD_STRING
];
142 WCHAR wszDir
[MAX_LOAD_STRING
];
143 static const WCHAR wszDefaultExt
[] = { 'i','d','l',0 };
144 static const WCHAR wszIdlFiles
[] = { '*','.','i','d','l','\0','\0' };
146 memset(&saveidl
, 0, sizeof(saveidl
));
148 lstrcpyW(wszDir
, typelib
.wszFileName
);
149 pFileName
= wszDir
+ lstrlenW(wszDir
);
150 while(*pFileName
!= '.' && *pFileName
!= '\\' && *pFileName
!= '/'
151 && pFileName
> wszDir
) pFileName
-= 1;
152 if(*pFileName
== '.')
155 while(*pFileName
!= '\\' && *pFileName
!= '/' && pFileName
> wszDir
)
158 if(*pFileName
== '\\' || *pFileName
== '/') pFileName
+= 1;
159 lstrcpyW(wszPath
, pFileName
);
161 GetCurrentDirectoryW(MAX_LOAD_STRING
, wszDir
);
163 saveidl
.lStructSize
= sizeof(OPENFILENAMEW
);
164 saveidl
.hwndOwner
= globals
.hTypeLibWnd
;
165 saveidl
.hInstance
= globals
.hMainInst
;
166 saveidl
.lpstrFilter
= wszIdlFiles
;
167 saveidl
.lpstrFile
= wszPath
;
168 saveidl
.nMaxFile
= MAX_LOAD_STRING
;
169 saveidl
.lpstrInitialDir
= wszDir
;
170 saveidl
.Flags
= OFN_PATHMUSTEXIST
| OFN_OVERWRITEPROMPT
| OFN_HIDEREADONLY
;
171 saveidl
.lpstrDefExt
= wszDefaultExt
;
173 if (GetSaveFileNameW(&saveidl
))
177 static void AddToStrW(WCHAR
*wszDest
, const WCHAR
*wszSource
)
179 lstrcpyW(&wszDest
[lstrlenW(wszDest
)], wszSource
);
182 static void AddToTLDataStrW(TYPELIB_DATA
*pTLData
, const WCHAR
*wszSource
)
184 int SourceLen
= lstrlenW(wszSource
);
186 pTLData
->idl
= realloc(pTLData
->idl
, sizeof(WCHAR
) * (pTLData
->idlLen
+ SourceLen
+ 1));
188 memcpy(&pTLData
->idl
[pTLData
->idlLen
], wszSource
, sizeof(WCHAR
)*(SourceLen
+1));
189 pTLData
->idlLen
+= SourceLen
;
192 static void AddToTLDataStrWithTabsW(TYPELIB_DATA
*pTLData
, WCHAR
*wszSource
)
194 int lineLen
= lstrlenW(wszSource
);
196 WCHAR
*pSourcePos
= wszSource
;
202 if(*pSourcePos
== L
'\n') newLinesNo
++;
205 if(*(pSourcePos
- 1) != L
'\n') newLinesNo
++;
207 pTLData
->idl
= realloc(pTLData
->idl
,
208 sizeof(WCHAR
) * (pTLData
->idlLen
+ lineLen
+ 4 * newLinesNo
+ 1));
210 pSourcePos
= wszSource
;
211 pSourceBeg
= wszSource
;
214 if(*pSourcePos
!= L
'\n' && *pSourcePos
)
224 lineLen
= lstrlenW(pSourceBeg
)+1;
228 else lineLen
= lstrlenW(pSourceBeg
);
230 pTLData
->idl
[pTLData
->idlLen
] = L
' ';
231 pTLData
->idl
[pTLData
->idlLen
+1] = L
' ';
232 pTLData
->idl
[pTLData
->idlLen
+2] = L
' ';
233 pTLData
->idl
[pTLData
->idlLen
+3] = L
' ';
234 memcpy(&pTLData
->idl
[pTLData
->idlLen
+4], pSourceBeg
, sizeof(WCHAR
)*lineLen
);
235 pTLData
->idlLen
+= lineLen
+ 4;
236 pTLData
->idl
[pTLData
->idlLen
] = '\0';
238 pSourceBeg
= pSourcePos
;
242 static TYPELIB_DATA
*InitializeTLData(void)
244 TYPELIB_DATA
*pTLData
;
246 pTLData
= calloc(1, sizeof(TYPELIB_DATA
));
248 pTLData
->idl
= malloc(sizeof(WCHAR
));
249 pTLData
->idl
[0] = '\0';
254 static void AddSpaces(TYPELIB_DATA
*pTLData
, int tabSize
)
256 for(; tabSize
>0; tabSize
--)
257 AddToTLDataStrW(pTLData
, L
" ");
260 static void AddChildrenData(HTREEITEM hParent
, TYPELIB_DATA
*pData
)
265 memset(&tvi
, 0, sizeof(tvi
));
267 hCur
= (HTREEITEM
)SendMessageW(typelib
.hTree
, TVM_GETNEXTITEM
,
268 TVGN_CHILD
, (LPARAM
)hParent
);
274 SendMessageW(typelib
.hTree
, TVM_GETITEMW
, 0, (LPARAM
)&tvi
);
275 if(tvi
.lParam
&& ((TYPELIB_DATA
*)(tvi
.lParam
))->idlLen
)
276 AddToTLDataStrWithTabsW(pData
, ((TYPELIB_DATA
*)(tvi
.lParam
))->idl
);
277 } while((hCur
= (HTREEITEM
)SendMessageW(typelib
.hTree
, TVM_GETNEXTITEM
,
278 TVGN_NEXT
, (LPARAM
)hCur
)));
281 static void CreateTypeInfo(WCHAR
*wszAddTo
, WCHAR
*wszAddAfter
, TYPEDESC tdesc
, ITypeInfo
*pTypeInfo
)
286 ITypeInfo
*pRefTypeInfo
;
287 WCHAR wszBuf
[MAX_LOAD_STRING
];
288 WCHAR wszFormat
[] = { '[','%','l','u',']','\0' };
290 switch(tdesc
.vt
&VT_TYPEMASK
)
292 #define VTADDTOSTR(x) case x:\
293 AddToStrW(wszAddTo, wsz##x);\
309 VTADDTOSTR(VT_VARIANT
);
311 VTADDTOSTR(VT_ERROR
);
312 VTADDTOSTR(VT_LPSTR
);
313 VTADDTOSTR(VT_LPWSTR
);
314 VTADDTOSTR(VT_HRESULT
);
315 VTADDTOSTR(VT_UNKNOWN
);
316 VTADDTOSTR(VT_DISPATCH
);
320 for(i
=0; i
<tdesc
.lpadesc
->cDims
; i
++)
322 wsprintfW(wszBuf
, wszFormat
, tdesc
.lpadesc
->rgbounds
[i
].cElements
);
323 AddToStrW(wszAddAfter
, wszBuf
);
325 CreateTypeInfo(wszAddTo
, wszAddAfter
, tdesc
.lpadesc
->tdescElem
, pTypeInfo
);
328 AddToStrW(wszAddTo
, wszVT_SAFEARRAY
);
329 AddToStrW(wszAddTo
, L
"(");
330 CreateTypeInfo(wszAddTo
, wszAddAfter
, *tdesc
.lptdesc
, pTypeInfo
);
331 AddToStrW(wszAddTo
, L
")");
334 CreateTypeInfo(wszAddTo
, wszAddAfter
, *tdesc
.lptdesc
, pTypeInfo
);
335 AddToStrW(wszAddTo
, L
"*");
338 hRes
= ITypeInfo_GetRefTypeInfo(pTypeInfo
,
339 tdesc
.hreftype
, &pRefTypeInfo
);
342 ITypeInfo_GetDocumentation(pRefTypeInfo
, MEMBERID_NIL
,
343 &bstrData
, NULL
, NULL
, NULL
);
344 AddToStrW(wszAddTo
, bstrData
);
345 SysFreeString(bstrData
);
346 ITypeInfo_Release(pRefTypeInfo
);
348 else AddToStrW(wszAddTo
, wszFailed
);
351 WINE_FIXME("tdesc.vt&VT_TYPEMASK == %d not supported\n",
352 tdesc
.vt
&VT_TYPEMASK
);
356 static int EnumVars(ITypeInfo
*pTypeInfo
, int cVars
, HTREEITEM hParent
)
359 TVINSERTSTRUCTW tvis
;
362 WCHAR wszText
[MAX_LOAD_STRING
];
363 WCHAR wszAfter
[MAX_LOAD_STRING
];
365 tvis
.item
.mask
= TVIF_TEXT
|TVIF_PARAM
;
366 tvis
.item
.cchTextMax
= MAX_LOAD_STRING
;
367 tvis
.item
.pszText
= wszText
;
368 tvis
.hInsertAfter
= TVI_LAST
;
369 tvis
.hParent
= hParent
;
371 for(i
=0; i
<cVars
; i
++)
375 if(FAILED(ITypeInfo_GetVarDesc(pTypeInfo
, i
, &pVarDesc
))) continue;
376 if(FAILED(ITypeInfo_GetDocumentation(pTypeInfo
, pVarDesc
->memid
, &bstrName
,
377 NULL
, NULL
, NULL
))) continue;
379 tld
= InitializeTLData();
380 tvis
.item
.lParam
= (LPARAM
) tld
;
381 if(pVarDesc
->memid
< MIN_VAR_ID
)
384 AddToTLDataStrW(tld
, L
"[");
385 AddToTLDataStrW(tld
, wszId
);
386 AddToTLDataStrW(tld
, L
"(");
387 wsprintfW(wszText
, wszFormat
, pVarDesc
->memid
);
388 AddToTLDataStrW(tld
, wszText
);
389 memset(wszText
, 0, sizeof(wszText
));
390 AddToTLDataStrW(tld
, L
")");
392 if(pVarDesc
->wVarFlags
& VARFLAG_FREADONLY
)
394 AddToTLDataStrW(tld
, L
", ");
395 AddToTLDataStrW(tld
, wszReadOnly
);
397 AddToTLDataStrW(tld
, L
"]\n");
400 memset(wszText
, 0, sizeof(wszText
));
401 memset(wszAfter
, 0, sizeof(wszAfter
));
402 CreateTypeInfo(wszText
, wszAfter
, pVarDesc
->elemdescVar
.tdesc
, pTypeInfo
);
403 AddToStrW(wszText
, L
" ");
404 if (bstrName
) AddToStrW(wszText
, bstrName
);
405 AddToStrW(wszText
, wszAfter
);
406 AddToTLDataStrW(tld
, wszText
);
407 AddToTLDataStrW(tld
, L
";\n");
409 SendMessageW(typelib
.hTree
, TVM_INSERTITEMW
, 0, (LPARAM
)&tvis
);
410 SysFreeString(bstrName
);
411 ITypeInfo_ReleaseVarDesc(pTypeInfo
, pVarDesc
);
417 static int EnumEnums(ITypeInfo
*pTypeInfo
, int cVars
, HTREEITEM hParent
)
420 TVINSERTSTRUCTW tvis
;
423 WCHAR wszText
[MAX_LOAD_STRING
];
424 WCHAR wszAfter
[MAX_LOAD_STRING
];
426 tvis
.item
.mask
= TVIF_TEXT
|TVIF_PARAM
;
427 tvis
.item
.cchTextMax
= MAX_LOAD_STRING
;
428 tvis
.item
.pszText
= wszText
;
429 tvis
.hInsertAfter
= TVI_LAST
;
430 tvis
.hParent
= hParent
;
432 for(i
=0; i
<cVars
; i
++)
436 if(FAILED(ITypeInfo_GetVarDesc(pTypeInfo
, i
, &pVarDesc
))) continue;
437 if(FAILED(ITypeInfo_GetDocumentation(pTypeInfo
, pVarDesc
->memid
, &bstrName
,
438 NULL
, NULL
, NULL
))) continue;
440 tld
= InitializeTLData();
441 tvis
.item
.lParam
= (LPARAM
) tld
;
443 memset(wszText
, 0, sizeof(wszText
));
444 memset(wszAfter
, 0, sizeof(wszAfter
));
446 if (pVarDesc
->varkind
== VAR_CONST
)
450 if (VariantChangeType(&var
, pVarDesc
->lpvarValue
, 0, VT_BSTR
) == S_OK
)
452 AddToStrW(wszText
, wszConst
);
453 AddToStrW(wszText
, L
" ");
454 AddToStrW(wszAfter
, L
" = ");
455 AddToStrW(wszAfter
, V_BSTR(&var
));
459 CreateTypeInfo(wszText
, wszAfter
, pVarDesc
->elemdescVar
.tdesc
, pTypeInfo
);
460 AddToStrW(wszText
, L
" ");
461 AddToStrW(wszText
, bstrName
);
462 AddToStrW(wszText
, wszAfter
);
463 AddToTLDataStrW(tld
, bstrName
);
464 AddToTLDataStrW(tld
, wszAfter
);
466 AddToTLDataStrW(tld
, L
",");
467 AddToTLDataStrW(tld
, L
"\n");
469 SendMessageW(typelib
.hTree
, TVM_INSERTITEMW
, 0, (LPARAM
)&tvis
);
470 SysFreeString(bstrName
);
471 ITypeInfo_ReleaseVarDesc(pTypeInfo
, pVarDesc
);
477 static int EnumFuncs(ITypeInfo
*pTypeInfo
, TYPEATTR
*pTypeAttr
, HTREEITEM hParent
)
482 TVINSERTSTRUCTW tvis
;
484 BSTR bstrName
, bstrHelpString
, *bstrParamNames
;
485 WCHAR wszText
[MAX_LOAD_STRING
];
486 WCHAR wszAfter
[MAX_LOAD_STRING
];
487 WCHAR szRhs
[] = {'r','h','s',0}; /* Right-hand side of a propput */
490 tvis
.item
.mask
= TVIF_TEXT
|TVIF_PARAM
;
491 tvis
.hInsertAfter
= TVI_LAST
;
492 tvis
.hParent
= hParent
;
494 cFuncs
= pTypeAttr
->cFuncs
;
497 if(pTypeAttr
->wTypeFlags
& TYPEFLAG_FDUAL
) { /* skip 7 members of IDispatch */
506 if(FAILED(ITypeInfo_GetFuncDesc(pTypeInfo
, i
, &pFuncDesc
))) continue;
508 if(FAILED(ITypeInfo_GetDocumentation(pTypeInfo
, pFuncDesc
->memid
, &bstrName
,
509 &bstrHelpString
, NULL
, NULL
))) continue;
511 memset(wszText
, 0, sizeof(wszText
));
512 memset(wszAfter
, 0, sizeof(wszAfter
));
513 tld
= InitializeTLData();
514 tvis
.item
.cchTextMax
= SysStringLen(bstrName
);
515 tvis
.item
.pszText
= bstrName
;
516 tvis
.item
.lParam
= (LPARAM
) tld
;
518 if(pFuncDesc
->memid
< MIN_FUNC_ID
|| pTypeAttr
->wTypeFlags
& TYPEFLAG_FDUAL
)
520 AddToTLDataStrW(tld
, L
"[");
522 AddToTLDataStrW(tld
, wszId
);
523 AddToTLDataStrW(tld
, L
"(");
524 wsprintfW(wszText
, wszFormat
, pFuncDesc
->memid
);
525 AddToTLDataStrW(tld
, wszText
);
526 AddToTLDataStrW(tld
, L
")");
527 memset(wszText
, 0, sizeof(wszText
));
530 CreateTypeInfo(wszText
, wszAfter
, pFuncDesc
->elemdescFunc
.tdesc
, pTypeInfo
);
531 switch(pFuncDesc
->invkind
)
533 case INVOKE_PROPERTYGET
:
534 if(bFirst
) AddToTLDataStrW(tld
, L
"[");
535 else AddToTLDataStrW(tld
, L
", ");
537 AddToTLDataStrW(tld
, wszPropGet
);
539 case INVOKE_PROPERTYPUT
:
540 if(bFirst
) AddToTLDataStrW(tld
, L
"[");
541 else AddToTLDataStrW(tld
, L
", ");
543 AddToTLDataStrW(tld
, wszPropPut
);
545 case INVOKE_PROPERTYPUTREF
:
546 if(bFirst
) AddToTLDataStrW(tld
, L
"[");
547 else AddToTLDataStrW(tld
, L
", ");
549 AddToTLDataStrW(tld
, wszPropPutRef
);
553 if(SysStringLen(bstrHelpString
))
555 if(bFirst
) AddToTLDataStrW(tld
, L
"[");
556 else AddToTLDataStrW(tld
, L
", ");
558 AddToTLDataStrW(tld
, wszHelpstring
);
559 AddToTLDataStrW(tld
, L
"(\"");
560 AddToTLDataStrW(tld
, bstrHelpString
);
561 AddToTLDataStrW(tld
, L
"\")");
563 if(!bFirst
) AddToTLDataStrW(tld
, L
"]\n");
565 if(pTypeAttr
->wTypeFlags
& TYPEFLAG_FOLEAUTOMATION
) {
566 AddToTLDataStrW(tld
, wszVT_HRESULT
);
567 if(lstrcmpW(wszText
, wszVT_VOID
)) pFuncDesc
->cParams
++;
570 AddToTLDataStrW(tld
, wszText
);
571 AddToTLDataStrW(tld
, wszAfter
);
574 bstrParamNames
= malloc(sizeof(BSTR
) * (pFuncDesc
->cParams
+ 1));
575 if(FAILED(ITypeInfo_GetNames(pTypeInfo
, pFuncDesc
->memid
, bstrParamNames
,
576 pFuncDesc
->cParams
+1, &namesNo
)))
578 free(bstrParamNames
);
581 SysFreeString(bstrParamNames
[0]);
583 AddToTLDataStrW(tld
, L
" ");
584 if(pFuncDesc
->memid
>= MIN_FUNC_ID
)
586 AddToTLDataStrW(tld
, wszStdCall
);
587 AddToTLDataStrW(tld
, L
" ");
589 if (bstrName
) AddToTLDataStrW(tld
, bstrName
);
590 AddToTLDataStrW(tld
, L
"(");
592 for(j
=0; j
<pFuncDesc
->cParams
; j
++)
594 if(j
!= 0) AddToTLDataStrW(tld
, L
",");
595 if(pFuncDesc
->cParams
!= 1)
597 AddToTLDataStrW(tld
, L
"\n");
598 AddSpaces(tld
, TAB_SIZE
);
601 #define ENUM_PARAM_FLAG(x)\
602 if(pFuncDesc->lprgelemdescParam[j].paramdesc.wParamFlags & x) \
605 AddToTLDataStrW(tld, L"[");\
608 AddToTLDataStrW(tld, L", ");\
611 AddToTLDataStrW(tld, wsz##x);\
613 ENUM_PARAM_FLAG(PARAMFLAG_FIN
);
614 ENUM_PARAM_FLAG(PARAMFLAG_FOUT
);
615 ENUM_PARAM_FLAG(PARAMFLAG_FLCID
);
616 ENUM_PARAM_FLAG(PARAMFLAG_FRETVAL
);
617 ENUM_PARAM_FLAG(PARAMFLAG_FOPT
);
618 ENUM_PARAM_FLAG(PARAMFLAG_FHASCUSTDATA
);
620 if(pFuncDesc
->lprgelemdescParam
[j
].paramdesc
.wParamFlags
& PARAMFLAG_FHASDEFAULT
)
622 VARIANT var
, *param
=&pFuncDesc
->lprgelemdescParam
[j
].paramdesc
.pparamdescex
->varDefaultValue
;
624 if(bFirst
) AddToTLDataStrW(tld
, L
"[");
625 else AddToTLDataStrW(tld
, L
", ");
627 AddToTLDataStrW(tld
, wszDefaultValue
);
628 AddToTLDataStrW(tld
, L
"(");
629 if (V_VT(param
) == VT_BSTR
)
631 AddToTLDataStrW(tld
, L
"\"");
632 AddToTLDataStrW(tld
, V_BSTR(param
));
633 AddToTLDataStrW(tld
, L
"\"");
634 } else if (VariantChangeType(&var
, param
, 0, VT_BSTR
) == S_OK
)
635 AddToTLDataStrW(tld
, V_BSTR(&var
));
636 AddToTLDataStrW(tld
, L
")");
639 if(!bFirst
) AddToTLDataStrW(tld
, L
"] ");
641 memset(wszText
, 0, sizeof(wszText
));
642 memset(wszAfter
, 0, sizeof(wszAfter
));
643 CreateTypeInfo(wszText
, wszAfter
, pFuncDesc
->lprgelemdescParam
[j
].tdesc
,
645 AddToTLDataStrW(tld
, wszText
);
646 AddToTLDataStrW(tld
, wszAfter
);
647 AddToTLDataStrW(tld
, L
" ");
649 if (bstrParamNames
[j
+1])
651 AddToTLDataStrW(tld
, bstrParamNames
[j
+1]);
652 SysFreeString(bstrParamNames
[j
+1]);
655 AddToTLDataStrW(tld
, szRhs
);
658 AddToTLDataStrW(tld
, L
");\n");
660 SendMessageW(typelib
.hTree
, TVM_INSERTITEMW
, 0, (LPARAM
)&tvis
);
661 free(bstrParamNames
);
662 SysFreeString(bstrName
);
663 SysFreeString(bstrHelpString
);
664 ITypeInfo_ReleaseFuncDesc(pTypeInfo
, pFuncDesc
);
670 static int EnumImplTypes(ITypeInfo
*pTypeInfo
, int cImplTypes
, HTREEITEM hParent
)
673 TVINSERTSTRUCTW tvis
;
674 ITypeInfo
*pRefTypeInfo
;
678 WCHAR wszInheritedInterfaces
[MAX_LOAD_STRING
];
680 if(!cImplTypes
) return 0;
682 LoadStringW(globals
.hMainInst
, IDS_INHERITINTERFACES
, wszInheritedInterfaces
,
683 ARRAY_SIZE(wszInheritedInterfaces
));
685 tvis
.item
.mask
= TVIF_TEXT
;
686 tvis
.item
.cchTextMax
= MAX_LOAD_STRING
;
687 tvis
.item
.pszText
= wszInheritedInterfaces
;
688 tvis
.hInsertAfter
= TVI_LAST
;
689 tvis
.hParent
= hParent
;
691 tvis
.hParent
= TreeView_InsertItemW(typelib
.hTree
, &tvis
);
693 for(i
=0; i
<cImplTypes
; i
++)
695 if(FAILED(ITypeInfo_GetRefTypeOfImplType(pTypeInfo
, i
, &hRefType
))) continue;
696 if(FAILED(ITypeInfo_GetRefTypeInfo(pTypeInfo
, hRefType
, &pRefTypeInfo
)))
698 if(FAILED(ITypeInfo_GetDocumentation(pRefTypeInfo
, MEMBERID_NIL
, &bstrName
,
701 ITypeInfo_Release(pRefTypeInfo
);
704 if(FAILED(ITypeInfo_GetTypeAttr(pRefTypeInfo
, &pTypeAttr
)))
706 ITypeInfo_Release(pRefTypeInfo
);
710 tvis
.item
.cchTextMax
= SysStringLen(bstrName
);
711 tvis
.item
.pszText
= bstrName
;
713 hParent
= TreeView_InsertItemW(typelib
.hTree
, &tvis
);
714 EnumVars(pRefTypeInfo
, pTypeAttr
->cVars
, hParent
);
715 EnumFuncs(pRefTypeInfo
, pTypeAttr
, hParent
);
716 EnumImplTypes(pRefTypeInfo
, pTypeAttr
->cImplTypes
, hParent
);
718 SysFreeString(bstrName
);
719 ITypeInfo_ReleaseTypeAttr(pRefTypeInfo
, pTypeAttr
);
720 ITypeInfo_Release(pRefTypeInfo
);
726 static void EnumCoclassImplTypes(ITypeInfo
*pTypeInfo
,
727 int cImplTypes
, TYPELIB_DATA
*pTLData
)
730 ITypeInfo
*pRefTypeInfo
;
736 const WCHAR wszTKIND_INTERFACE
[] = { 'i','n','t','e','r','f','a','c','e',' ','\0' };
737 const WCHAR wszTKIND_DISPATCH
[]
738 = { 'd','i','s','p','i','n','t','e','r','f','a','c','e',' ','\0' };
739 const WCHAR wszIMPLTYPEFLAG_FDEFAULT
[]
740 = { 'd','e','f','a','u','l','t','\0' };
741 const WCHAR wszIMPLTYPEFLAG_FSOURCE
[]
742 = { 's','o','u','r','c','e','\0' };
743 const WCHAR wszIMPLTYPEFLAG_FRESTRICTED
[]
744 = { 'r','e','s','t','r','i','c','t','e','d','\0' };
746 for(i
=0; i
<cImplTypes
; i
++)
748 if(FAILED(ITypeInfo_GetRefTypeOfImplType(pTypeInfo
, i
, &hRefType
))) continue;
749 if(FAILED(ITypeInfo_GetRefTypeInfo(pTypeInfo
, hRefType
, &pRefTypeInfo
)))
751 if(FAILED(ITypeInfo_GetDocumentation(pRefTypeInfo
, MEMBERID_NIL
, &bstrName
,
754 ITypeInfo_Release(pRefTypeInfo
);
757 if(FAILED(ITypeInfo_GetTypeAttr(pRefTypeInfo
, &pTypeAttr
)))
759 ITypeInfo_Release(pRefTypeInfo
);
763 AddSpaces(pTLData
, TAB_SIZE
);
764 ITypeInfo_GetImplTypeFlags(pTypeInfo
, i
, &flags
);
766 #define ENUM_IMPLTYPEFLAG(x)\
770 AddToTLDataStrW(pTLData, L"[");\
773 AddToTLDataStrW(pTLData, L", ");\
776 AddToTLDataStrW(pTLData, wsz##x);\
778 ENUM_IMPLTYPEFLAG(IMPLTYPEFLAG_FDEFAULT
);
779 ENUM_IMPLTYPEFLAG(IMPLTYPEFLAG_FSOURCE
);
780 ENUM_IMPLTYPEFLAG(IMPLTYPEFLAG_FRESTRICTED
);
782 AddToTLDataStrW(pTLData
, L
"] ");
784 if(pTypeAttr
->typekind
== TKIND_INTERFACE
||
785 (pTypeAttr
->wTypeFlags
& TYPEFLAG_FDUAL
))
786 AddToTLDataStrW(pTLData
, wszTKIND_INTERFACE
);
787 else if(pTypeAttr
->typekind
== TKIND_DISPATCH
)
788 AddToTLDataStrW(pTLData
, wszTKIND_DISPATCH
);
789 AddToTLDataStrW(pTLData
, L
" ");
791 AddToTLDataStrW(pTLData
, bstrName
);
792 AddToTLDataStrW(pTLData
, L
";\n");
794 SysFreeString(bstrName
);
795 ITypeInfo_ReleaseTypeAttr(pRefTypeInfo
, pTypeAttr
);
796 ITypeInfo_Release(pRefTypeInfo
);
800 static void AddIdlData(HTREEITEM hCur
, TYPELIB_DATA
*pTLData
)
804 hCur
= (HTREEITEM
)SendMessageW(typelib
.hTree
, TVM_GETNEXTITEM
,
805 TVGN_CHILD
, (LPARAM
)hCur
);
806 memset(&tvi
, 0, sizeof(TVITEMW
));
807 tvi
.mask
= TVIF_PARAM
;
812 SendMessageW(typelib
.hTree
, TVM_GETITEMW
, 0, (LPARAM
)&tvi
);
813 if(!((TYPELIB_DATA
*)(tvi
.lParam
))->bHide
) {
814 AddToTLDataStrW(pTLData
, L
"\n");
815 AddToTLDataStrWithTabsW(pTLData
, ((TYPELIB_DATA
*)(tvi
.lParam
))->idl
);
817 hCur
= (HTREEITEM
)SendMessageW(typelib
.hTree
, TVM_GETNEXTITEM
,
818 TVGN_NEXT
, (LPARAM
)hCur
);
822 static void AddPredefinitions(HTREEITEM hFirst
, TYPELIB_DATA
*pTLData
)
826 WCHAR wszText
[MAX_LOAD_STRING
];
827 WCHAR wszPredefinition
[] = { '/','/',' ','T','L','i','b',' ',':','\n',
828 '/','/',' ','F','o','r','w','a','r','d',' ','d','e','c','l','a','r','e',' ',
829 'a','l','l',' ','t','y','p','e','s',' ','d','e','f','i','n','e','d',' ',
830 'i','n',' ','t','h','i','s',' ','t','y','p','e','l','i','b','\0' };
832 hFirst
= (HTREEITEM
)SendMessageW(typelib
.hTree
, TVM_GETNEXTITEM
,
833 TVGN_CHILD
, (LPARAM
)hFirst
);
835 AddToTLDataStrWithTabsW(pTLData
, wszPredefinition
);
836 AddToTLDataStrW(pTLData
, L
"\n");
839 memset(&tvi
, 0, sizeof(TVITEMW
));
840 tvi
.mask
= TVIF_TEXT
|TVIF_PARAM
;
841 tvi
.cchTextMax
= MAX_LOAD_STRING
;
842 tvi
.pszText
= wszText
;
846 SendMessageW(typelib
.hTree
, TVM_GETITEMW
, 0, (LPARAM
)&tvi
);
847 if(((TYPELIB_DATA
*)(tvi
.lParam
))->bPredefine
&&
848 !((TYPELIB_DATA
*)(tvi
.lParam
))->bHide
)
850 AddToStrW(wszText
, L
";");
851 AddToTLDataStrWithTabsW(pTLData
, wszText
);
852 AddToTLDataStrW(pTLData
, L
"\n");
854 hCur
= (HTREEITEM
)SendMessageW(typelib
.hTree
, TVM_GETNEXTITEM
,
855 TVGN_NEXT
, (LPARAM
)hCur
);
859 static void CreateInterfaceInfo(ITypeInfo
*pTypeInfo
, int cImplTypes
, WCHAR
*wszName
,
860 WCHAR
*wszHelpString
, ULONG ulHelpContext
, TYPEATTR
*pTypeAttr
,
861 TYPELIB_DATA
*pTLData
)
863 ITypeInfo
*pRefTypeInfo
;
866 WCHAR wszGuid
[MAX_LOAD_STRING
];
867 WCHAR wszHelpContext
[MAX_LOAD_STRING
];
869 const WCHAR wszInterface
[] = { 'i','n','t','e','r','f','a','c','e',' ','\0' };
870 const WCHAR wszDispinterface
[]
871 = { 'd','i','s','p','i','n','t','e','r','f','a','c','e',' ','\0' };
872 const WCHAR wszHelpcontext
[] = { 'h','e','l','p','c','o','n','t','e','x','t','\0' };
873 const WCHAR wszTYPEFLAG_FAPPOBJECT
[] = { 'a','p','p','o','b','j','e','c','t','\0' };
874 const WCHAR wszTYPEFLAG_FCANCREATE
[] = { 'c','a','n','c','r','e','a','t','e','\0' };
875 const WCHAR wszTYPEFLAG_FLICENSED
[] = { 'l','i','c','e','n','s','e','d','\0' };
876 const WCHAR wszTYPEFLAG_FPREDECLID
[] = { 'p','r','e','d','e','c','l','i','d','\0' };
877 const WCHAR wszTYPEFLAG_FHIDDEN
[] = { 'h','i','d','d','e','n','\0' };
878 const WCHAR wszTYPEFLAG_FCONTROL
[] = { 'c','o','n','t','r','o','l','\0' };
879 const WCHAR wszTYPEFLAG_FDUAL
[] = { 'd','u','a','l','\0' };
880 const WCHAR wszTYPEFLAG_FNONEXTENSIBLE
[]
881 = { 'n','o','n','e','x','t','e','n','s','i','b','l','e','\0' };
882 const WCHAR wszTYPEFLAG_FOLEAUTOMATION
[]
883 = { 'o','l','e','a','u','t','o','m','a','t','i','o','n','\0' };
884 const WCHAR wszTYPEFLAG_FRESTRICTED
[]
885 = { 'r','e','s','t','r','i','c','t','e','d','\0' };
886 const WCHAR wszTYPEFLAG_FAGGREGATABLE
[]
887 = { 'a','g','g','r','e','g','a','t','a','b','l','e','\0' };
888 const WCHAR wszTYPEFLAG_FREPLACEABLE
[]
889 = { 'r','e','p','l','a','c','a','b','l','e','\0' };
890 const WCHAR wszTYPEFLAG_FREVERSEBIND
[]
891 = { 'r','e','v','e','r','s','e','b','i','n','d','\0' };
892 const WCHAR wszTYPEFLAG_FPROXY
[] = { 'p','r','o','x','y','\0' };
894 AddToTLDataStrW(pTLData
, L
"[\n");
895 if(pTypeAttr
->typekind
!= TKIND_DISPATCH
)
897 AddSpaces(pTLData
, TAB_SIZE
);
898 AddToTLDataStrW(pTLData
, wszOdl
);
899 AddToTLDataStrW(pTLData
, L
",\n");
901 AddSpaces(pTLData
, TAB_SIZE
);
902 AddToTLDataStrW(pTLData
, wszUUID
);
903 AddToTLDataStrW(pTLData
, L
"(");
904 StringFromGUID2(&(pTypeAttr
->guid
), wszGuid
, MAX_LOAD_STRING
);
905 wszGuid
[lstrlenW(wszGuid
)-1] = '\0';
906 AddToTLDataStrW(pTLData
, &wszGuid
[1]);
907 AddToTLDataStrW(pTLData
, L
")");
910 AddToTLDataStrW(pTLData
, L
",\n");
911 AddSpaces(pTLData
, TAB_SIZE
);
912 AddToTLDataStrW(pTLData
, wszHelpstring
);
913 AddToTLDataStrW(pTLData
, L
"(\"");
914 AddToTLDataStrW(pTLData
, wszHelpString
);
915 AddToTLDataStrW(pTLData
, L
"\")");
919 AddToTLDataStrW(pTLData
, L
",\n");
920 AddSpaces(pTLData
, TAB_SIZE
);
921 AddToTLDataStrW(pTLData
, wszHelpcontext
);
922 AddToTLDataStrW(pTLData
, L
"(");
923 wsprintfW(wszHelpContext
, wszFormat
, ulHelpContext
);
924 AddToTLDataStrW(pTLData
, wszHelpContext
);
925 AddToTLDataStrW(pTLData
, L
")");
927 if(pTypeAttr
->wTypeFlags
)
929 #define ENUM_FLAGS(x) if(pTypeAttr->wTypeFlags & x)\
931 AddToTLDataStrW(pTLData, L",\n");\
932 AddSpaces(pTLData, TAB_SIZE);\
933 AddToTLDataStrW(pTLData, wsz##x);\
935 ENUM_FLAGS(TYPEFLAG_FAPPOBJECT
);
936 ENUM_FLAGS(TYPEFLAG_FCANCREATE
);
937 ENUM_FLAGS(TYPEFLAG_FLICENSED
);
938 ENUM_FLAGS(TYPEFLAG_FPREDECLID
);
939 ENUM_FLAGS(TYPEFLAG_FHIDDEN
);
940 ENUM_FLAGS(TYPEFLAG_FCONTROL
);
941 ENUM_FLAGS(TYPEFLAG_FDUAL
);
942 ENUM_FLAGS(TYPEFLAG_FNONEXTENSIBLE
);
943 ENUM_FLAGS(TYPEFLAG_FOLEAUTOMATION
);
944 ENUM_FLAGS(TYPEFLAG_FRESTRICTED
);
945 ENUM_FLAGS(TYPEFLAG_FAGGREGATABLE
);
946 ENUM_FLAGS(TYPEFLAG_FREPLACEABLE
);
947 ENUM_FLAGS(TYPEFLAG_FREVERSEBIND
);
948 ENUM_FLAGS(TYPEFLAG_FPROXY
);
950 AddToTLDataStrW(pTLData
, L
"\n]\n");
951 if(pTypeAttr
->typekind
!= TKIND_DISPATCH
) AddToTLDataStrW(pTLData
, wszInterface
);
952 else AddToTLDataStrW(pTLData
, wszDispinterface
);
953 AddToTLDataStrW(pTLData
, wszName
);
954 AddToTLDataStrW(pTLData
, L
" ");
955 if(cImplTypes
&& pTypeAttr
->typekind
!= TKIND_DISPATCH
)
957 AddToTLDataStrW(pTLData
, L
": ");
959 ITypeInfo_GetRefTypeOfImplType(pTypeInfo
, 0, &hRefType
);
960 if (SUCCEEDED(ITypeInfo_GetRefTypeInfo(pTypeInfo
, hRefType
, &pRefTypeInfo
)))
962 ITypeInfo_GetDocumentation(pRefTypeInfo
, MEMBERID_NIL
, &bstrName
,
964 AddToTLDataStrW(pTLData
, bstrName
);
965 AddToTLDataStrW(pTLData
, L
" ");
967 SysFreeString(bstrName
);
968 ITypeInfo_Release(pRefTypeInfo
);
971 AddToTLDataStrW(pTLData
, wszFailed
);
973 AddToTLDataStrW(pTLData
, L
"{\n");
975 AddToStrW(pTLData
->wszInsertAfter
, L
"};\n");
978 static void CreateTypedefHeader(ITypeInfo
*pTypeInfo
,
979 TYPEATTR
*pTypeAttr
, TYPELIB_DATA
*pTLData
)
982 WCHAR wszGuid
[MAX_LOAD_STRING
];
983 const WCHAR wszTypedef
[] = { 't','y','p','e','d','e','f',' ','\0' };
984 const WCHAR wszPublic
[] = { 'p','u','b','l','i','c','\0' };
986 AddToTLDataStrW(pTLData
, wszTypedef
);
987 if(memcmp(&pTypeAttr
->guid
, &GUID_NULL
, sizeof(GUID
)))
989 AddToTLDataStrW(pTLData
, L
"[");
991 AddToTLDataStrW(pTLData
, wszUUID
);
992 AddToTLDataStrW(pTLData
, L
"(");
993 StringFromGUID2(&(pTypeAttr
->guid
), wszGuid
, MAX_LOAD_STRING
);
994 wszGuid
[lstrlenW(wszGuid
)-1] = '\0';
995 AddToTLDataStrW(pTLData
, &wszGuid
[1]);
996 AddToTLDataStrW(pTLData
, L
")");
998 if(pTypeAttr
->typekind
== TKIND_ALIAS
)
1000 if(bFirst
) AddToTLDataStrW(pTLData
, L
"[");
1001 else AddToTLDataStrW(pTLData
, L
", ");
1003 AddToTLDataStrW(pTLData
, wszPublic
);
1005 if(!bFirst
) AddToTLDataStrW(pTLData
, L
"]\n");
1008 static void CreateCoclassHeader(ITypeInfo
*pTypeInfo
,
1009 TYPEATTR
*pTypeAttr
, TYPELIB_DATA
*pTLData
)
1011 WCHAR wszGuid
[MAX_LOAD_STRING
];
1012 BSTR bstrHelpString
;
1013 const WCHAR wszNoncreatable
[]
1014 = { 'n','o','n','c','r','e','a','t','a','b','l','e','\0' };
1016 AddToTLDataStrW(pTLData
, L
"[\n");
1018 AddSpaces(pTLData
, TAB_SIZE
);
1019 AddToTLDataStrW(pTLData
, wszUUID
);
1020 AddToTLDataStrW(pTLData
, L
"(");
1021 StringFromGUID2(&(pTypeAttr
->guid
), wszGuid
, MAX_LOAD_STRING
);
1022 wszGuid
[lstrlenW(wszGuid
)-1] = '\0';
1023 AddToTLDataStrW(pTLData
, &wszGuid
[1]);
1024 AddToTLDataStrW(pTLData
, L
")");
1026 if(SUCCEEDED(ITypeInfo_GetDocumentation(pTypeInfo
, MEMBERID_NIL
, NULL
,
1027 &bstrHelpString
, NULL
, NULL
)))
1029 if(SysStringLen(bstrHelpString
))
1031 AddToTLDataStrW(pTLData
, L
",\n");
1032 AddSpaces(pTLData
, TAB_SIZE
);
1033 AddToTLDataStrW(pTLData
, wszHelpstring
);
1034 AddToTLDataStrW(pTLData
, L
"(\"");
1035 AddToTLDataStrW(pTLData
, bstrHelpString
);
1036 AddToTLDataStrW(pTLData
, L
"\")");
1038 SysFreeString(bstrHelpString
);
1041 if(!(pTypeAttr
->wTypeFlags
& TYPEFLAG_FCANCREATE
))
1043 AddToTLDataStrW(pTLData
, L
",\n");
1044 AddSpaces(pTLData
, TAB_SIZE
);
1045 AddToTLDataStrW(pTLData
, wszNoncreatable
);
1048 AddToTLDataStrW(pTLData
, L
"\n]\n");
1051 static int PopulateTree(void)
1053 TVINSERTSTRUCTW tvis
;
1056 TLIBATTR
*pTLibAttr
;
1057 ITypeInfo
*pTypeInfo
, *pRefTypeInfo
;
1059 TYPEATTR
*pTypeAttr
;
1061 ULONG ulHelpContext
;
1064 WCHAR wszText
[MAX_LOAD_STRING
];
1065 WCHAR wszAfter
[MAX_LOAD_STRING
];
1070 TYPELIB_DATA
*tldDispatch
;
1073 const WCHAR wszGeneratedInfo
[] = { '/','/',' ','G','e','n','e','r','a','t','e','d',
1074 ' ','.','I','D','L',' ','f','i','l','e',' ','(','b','y',' ','t','h','e',' ',
1075 'O','L','E','/','C','O','M',' ','O','b','j','e','c','t',' ',
1076 'V','i','e','w','e','r',')','\n','/','/','\n','/','/',' ',
1077 't','y','p','e','l','i','b',' ','f','i','l','e','n','a','m','e',':',' ','\0'};
1079 const WCHAR wszFormat
[] = { '%','s',' ','(','%','s',')','\0' };
1080 const WCHAR wszFormat2
[] = { 'v','e','r','s','i','o','n',
1081 '(','%','l','d','.','%','l','d',')','\0' };
1083 const WCHAR wszTKIND_ENUM
[] = { 't','y','p','e','d','e','f',' ','e','n','u','m',' ','\0' };
1084 const WCHAR wszTKIND_RECORD
[]
1085 = { 't','y','p','e','d','e','f',' ','s','t','r','u','c','t',' ','\0' };
1086 const WCHAR wszTKIND_MODULE
[] = { 'm','o','d','u','l','e',' ','\0' };
1087 const WCHAR wszTKIND_INTERFACE
[] = { 'i','n','t','e','r','f','a','c','e',' ','\0' };
1088 const WCHAR wszTKIND_DISPATCH
[]
1089 = { 'd','i','s','p','i','n','t','e','r','f','a','c','e',' ','\0' };
1090 const WCHAR wszTKIND_COCLASS
[] = { 'c','o','c','l','a','s','s',' ','\0' };
1091 const WCHAR wszTKIND_ALIAS
[] = { 't','y','p','e','d','e','f',' ','\0' };
1092 const WCHAR wszTKIND_UNION
[]
1093 = { 't','y','p','e','d','e','f',' ','u','n','i','o','n',' ','\0' };
1095 const WCHAR wszLibrary
[] = { 'l','i','b','r','a','r','y',' ','\0' };
1096 const WCHAR wszTag
[] = { 't','a','g','\0' };
1098 WCHAR wszProperties
[] = { 'p','r','o','p','e','r','t','i','e','s','\0' };
1099 WCHAR wszMethods
[] = { 'm','e','t','h','o','d','s','\0' };
1101 tvis
.item
.mask
= TVIF_TEXT
|TVIF_PARAM
;
1102 tvis
.item
.cchTextMax
= MAX_LOAD_STRING
;
1103 tvis
.item
.pszText
= wszText
;
1104 tvis
.hInsertAfter
= TVI_LAST
;
1105 tvis
.hParent
= TVI_ROOT
;
1107 if(FAILED((hRes
= LoadTypeLib(typelib
.wszFileName
, &pTypeLib
))))
1109 WCHAR wszMessage
[MAX_LOAD_STRING
];
1110 WCHAR wszError
[MAX_LOAD_STRING
];
1113 LoadStringW(globals
.hMainInst
, IDS_ERROR_LOADTYPELIB
, wszError
, ARRAY_SIZE(wszError
));
1114 args
[0] = (DWORD_PTR
)typelib
.wszFileName
;
1116 FormatMessageW(FORMAT_MESSAGE_FROM_STRING
|FORMAT_MESSAGE_ARGUMENT_ARRAY
,
1117 wszError
, 0, 0, wszMessage
, ARRAY_SIZE(wszMessage
), (va_list *)args
);
1118 MessageBoxW(globals
.hMainWnd
, wszMessage
, NULL
, MB_OK
|MB_ICONEXCLAMATION
);
1121 count
= ITypeLib_GetTypeInfoCount(pTypeLib
);
1123 ITypeLib_GetDocumentation(pTypeLib
, -1, &bstrName
, &bstrData
, NULL
, NULL
);
1124 ITypeLib_GetLibAttr(pTypeLib
, &pTLibAttr
);
1126 tld
= InitializeTLData();
1127 tvis
.item
.lParam
= (LPARAM
) tld
;
1128 AddToTLDataStrW(tld
, wszGeneratedInfo
);
1129 AddToTLDataStrW(tld
, typelib
.wszFileName
);
1130 AddToTLDataStrW(tld
, L
"\n\n[\n");
1131 AddSpaces(tld
, TAB_SIZE
);
1132 AddToTLDataStrW(tld
, wszUUID
);
1133 AddToTLDataStrW(tld
, L
"(");
1134 StringFromGUID2(&(pTLibAttr
->guid
), wszText
, MAX_LOAD_STRING
);
1135 wszText
[lstrlenW(wszText
)-1] = '\0';
1136 AddToTLDataStrW(tld
, &wszText
[1]);
1137 AddToTLDataStrW(tld
, L
"),\n");
1138 AddSpaces(tld
, TAB_SIZE
);
1139 wsprintfW(wszText
, wszFormat2
, pTLibAttr
->wMajorVerNum
, pTLibAttr
->wMinorVerNum
);
1140 AddToTLDataStrW(tld
, wszText
);
1144 /* helpstring is optional */
1145 AddToTLDataStrW(tld
, L
",\n");
1146 AddSpaces(tld
, TAB_SIZE
);
1147 AddToTLDataStrW(tld
, wszHelpstring
);
1148 AddToTLDataStrW(tld
, L
"(\"");
1149 AddToTLDataStrW(tld
, bstrData
);
1150 AddToTLDataStrW(tld
, L
"\")");
1153 AddToTLDataStrW(tld
, L
"\n]\n");
1154 AddToTLDataStrW(tld
, wszLibrary
);
1155 if (bstrName
) AddToTLDataStrW(tld
, bstrName
);
1156 AddToTLDataStrW(tld
, L
"\n{\n");
1158 AddToStrW(tld
->wszInsertAfter
, L
"};");
1160 wsprintfW(wszText
, wszFormat
, bstrName
, bstrData
);
1161 SysFreeString(bstrName
);
1162 SysFreeString(bstrData
);
1163 tvis
.hParent
= (HTREEITEM
)SendMessageW(typelib
.hTree
,
1164 TVM_INSERTITEMW
, 0, (LPARAM
)&tvis
);
1166 for(i
=0; i
<count
; i
++)
1169 ITypeLib_GetTypeInfo(pTypeLib
, i
, &pTypeInfo
);
1171 ITypeInfo_GetDocumentation(pTypeInfo
, MEMBERID_NIL
, &bstrName
, &bstrData
,
1172 &ulHelpContext
, NULL
);
1173 ITypeInfo_GetTypeAttr(pTypeInfo
, &pTypeAttr
);
1175 memset(wszText
, 0, sizeof(wszText
));
1176 memset(wszAfter
, 0, sizeof(wszAfter
));
1177 tld
= InitializeTLData();
1178 tvis
.item
.lParam
= (LPARAM
)tld
;
1179 switch(pTypeAttr
->typekind
)
1182 AddToStrW(wszText
, wszTKIND_ENUM
);
1183 AddToStrW(wszText
, bstrName
);
1185 CreateTypedefHeader(pTypeInfo
, pTypeAttr
, tld
);
1186 AddToTLDataStrW(tld
, &wszTKIND_ENUM
[lstrlenW(wszTKIND_ALIAS
)]);
1187 AddToTLDataStrW(tld
, L
"{\n");
1188 AddToStrW(tld
->wszInsertAfter
, L
"} ");
1189 AddToStrW(tld
->wszInsertAfter
, bstrName
);
1190 AddToStrW(tld
->wszInsertAfter
, L
";\n");
1193 hParent
= TreeView_InsertItemW(typelib
.hTree
, &tvis
);
1194 EnumEnums(pTypeInfo
, pTypeAttr
->cVars
, hParent
);
1195 AddChildrenData(hParent
, tld
);
1196 AddToTLDataStrW(tld
, tld
->wszInsertAfter
);
1199 AddToTLDataStrW(tld
, wszTKIND_RECORD
);
1200 AddToTLDataStrW(tld
, wszTag
);
1201 AddToTLDataStrW(tld
, bstrName
);
1202 AddToTLDataStrW(tld
, L
" {\n");
1204 AddToStrW(tld
->wszInsertAfter
, L
"} ");
1205 AddToStrW(tld
->wszInsertAfter
, bstrName
);
1206 AddToStrW(tld
->wszInsertAfter
, L
";\n");
1208 AddToStrW(wszText
, wszTKIND_RECORD
);
1209 AddToStrW(wszText
, bstrName
);
1212 AddToStrW(wszText
, wszTKIND_MODULE
);
1213 AddToStrW(wszText
, bstrName
);
1215 case TKIND_INTERFACE
:
1216 CreateInterfaceInfo(pTypeInfo
, pTypeAttr
->cImplTypes
, bstrName
,
1217 bstrData
, ulHelpContext
, pTypeAttr
, tld
);
1218 tld
->bPredefine
= TRUE
;
1220 AddToStrW(wszText
, wszTKIND_INTERFACE
);
1221 AddToStrW(wszText
, bstrName
);
1224 AddToStrW(wszText
, wszTKIND_COCLASS
);
1225 AddToStrW(wszText
, bstrName
);
1227 CreateCoclassHeader(pTypeInfo
, pTypeAttr
, tld
);
1228 AddToTLDataStrW(tld
, wszTKIND_COCLASS
);
1229 AddToTLDataStrW(tld
, bstrName
);
1230 AddToTLDataStrW(tld
, L
" {\n");
1232 EnumCoclassImplTypes(pTypeInfo
, pTypeAttr
->cImplTypes
, tld
);
1234 AddToStrW(tld
->wszInsertAfter
, L
"};\n");
1237 hParent
= TreeView_InsertItemW(typelib
.hTree
, &tvis
);
1238 AddToTLDataStrW(tld
, tld
->wszInsertAfter
);
1241 AddToStrW(wszText
, wszTKIND_UNION
);
1242 AddToStrW(wszText
, bstrName
);
1244 case TKIND_DISPATCH
:
1245 CreateInterfaceInfo(pTypeInfo
, pTypeAttr
->cImplTypes
, bstrName
,
1246 bstrData
, ulHelpContext
, pTypeAttr
, tld
);
1247 tld
->bPredefine
= TRUE
;
1248 if(pTypeAttr
->wTypeFlags
& TYPEFLAG_FDUAL
)
1250 AddToStrW(wszText
, wszTKIND_DISPATCH
);
1251 AddToStrW(wszText
, bstrName
);
1253 hParent
= TreeView_InsertItemW(typelib
.hTree
, &tvis
);
1254 hMain
= tvis
.hParent
;
1257 lstrcpyW(wszText
, wszProperties
);
1258 tvis
.hParent
= hParent
;
1259 tld
= InitializeTLData();
1260 tvis
.item
.lParam
= (LPARAM
) tld
;
1261 AddToTLDataStrW(tld
, wszProperties
);
1262 AddToTLDataStrW(tld
, L
":\n");
1263 tvis
.hParent
= TreeView_InsertItemW(typelib
.hTree
, &tvis
);
1264 EnumVars(pTypeInfo
, pTypeAttr
->cVars
, tvis
.hParent
);
1265 AddChildrenData(tvis
.hParent
, tld
);
1267 lstrcpyW(wszText
, wszMethods
);
1268 tvis
.hParent
= hParent
;
1269 tld
= InitializeTLData();
1270 tvis
.item
.lParam
= (LPARAM
) tld
;
1271 AddToTLDataStrW(tld
, wszMethods
);
1272 AddToTLDataStrW(tld
, L
":\n");
1273 tvis
.hParent
= TreeView_InsertItemW(typelib
.hTree
, &tvis
);
1274 EnumFuncs(pTypeInfo
, pTypeAttr
, tvis
.hParent
);
1275 AddChildrenData(tvis
.hParent
, tld
);
1277 EnumImplTypes(pTypeInfo
, pTypeAttr
->cImplTypes
, hParent
);
1278 AddChildrenData(hParent
, tldDispatch
);
1279 AddToTLDataStrW(tldDispatch
, tldDispatch
->wszInsertAfter
);
1282 tvis
.hParent
= hMain
;
1284 if(SUCCEEDED(ITypeInfo_GetRefTypeOfImplType(pTypeInfo
, -1, &hRefType
)))
1288 ITypeInfo_ReleaseTypeAttr(pTypeInfo
, pTypeAttr
);
1289 SysFreeString(bstrName
);
1290 SysFreeString(bstrData
);
1292 memset(wszText
, 0, sizeof(wszText
));
1293 tld
= InitializeTLData();
1294 tvis
.item
.lParam
= (LPARAM
) tld
;
1296 ITypeInfo_GetRefTypeInfo(pTypeInfo
, hRefType
, &pRefTypeInfo
);
1297 ITypeInfo_GetDocumentation(pRefTypeInfo
, MEMBERID_NIL
, &bstrName
,
1298 &bstrData
, &ulHelpContext
, NULL
);
1299 ITypeInfo_GetTypeAttr(pRefTypeInfo
, &pTypeAttr
);
1301 CreateInterfaceInfo(pTypeInfo
, pTypeAttr
->cImplTypes
, bstrName
,
1302 bstrData
, ulHelpContext
, pTypeAttr
, tld
);
1303 tld
->bPredefine
= TRUE
;
1305 AddToStrW(wszText
, wszTKIND_INTERFACE
);
1306 AddToStrW(wszText
, bstrName
);
1307 ITypeInfo_Release(pRefTypeInfo
);
1311 AddToStrW(wszText
, wszTKIND_ALIAS
);
1312 CreateTypeInfo(wszText
, wszAfter
, pTypeAttr
->tdescAlias
, pTypeInfo
);
1313 AddToStrW(wszText
, L
" ");
1314 AddToStrW(wszText
, bstrName
);
1315 AddToStrW(wszText
, wszAfter
);
1317 CreateTypedefHeader(pTypeInfo
, pTypeAttr
, tld
);
1318 AddToTLDataStrW(tld
, &wszText
[lstrlenW(wszTKIND_ALIAS
)]);
1319 AddToTLDataStrW(tld
, L
";\n");
1322 lstrcpyW(wszText
, bstrName
);
1323 WINE_FIXME("pTypeAttr->typekind == %d not supported\n",
1324 pTypeAttr
->typekind
);
1329 hParent
= TreeView_InsertItemW(typelib
.hTree
, &tvis
);
1331 EnumVars(pTypeInfo
, pTypeAttr
->cVars
, hParent
);
1332 EnumFuncs(pTypeInfo
, pTypeAttr
, hParent
);
1333 EnumImplTypes(pTypeInfo
, pTypeAttr
->cImplTypes
, hParent
);
1335 if(memcmp(bstrName
, wszVT_UNKNOWN
, sizeof(wszVT_UNKNOWN
)))
1336 AddChildrenData(hParent
, tld
);
1337 AddToTLDataStrW(tld
, tld
->wszInsertAfter
);
1340 ITypeInfo_ReleaseTypeAttr(pTypeInfo
, pTypeAttr
);
1341 ITypeInfo_Release(pTypeInfo
);
1342 SysFreeString(bstrName
);
1343 SysFreeString(bstrData
);
1345 SendMessageW(typelib
.hTree
, TVM_EXPAND
, TVE_EXPAND
, (LPARAM
)tvis
.hParent
);
1347 memset(&tvi
, 0, sizeof(TVITEMW
));
1348 tvi
.mask
= TVIF_PARAM
;
1349 tvi
.hItem
= tvis
.hParent
;
1351 SendMessageW(typelib
.hTree
, TVM_GETITEMW
, 0, (LPARAM
)&tvi
);
1352 AddPredefinitions(tvi
.hItem
, (TYPELIB_DATA
*)(tvi
.lParam
));
1353 AddIdlData(tvi
.hItem
, (TYPELIB_DATA
*)(tvi
.lParam
));
1354 AddToTLDataStrW((TYPELIB_DATA
*)(tvi
.lParam
),
1355 ((TYPELIB_DATA
*)(tvi
.lParam
))->wszInsertAfter
);
1357 ITypeLib_Release(pTypeLib
);
1361 void UpdateData(HTREEITEM item
)
1365 memset(&tvi
, 0, sizeof(TVITEMW
));
1366 tvi
.mask
= TVIF_PARAM
;
1369 SendMessageW(typelib
.hTree
, TVM_GETITEMW
, 0, (LPARAM
)&tvi
);
1372 SetWindowTextW(typelib
.hEdit
, L
" ");
1376 SetWindowTextW(typelib
.hEdit
, ((TYPELIB_DATA
*)tvi
.lParam
)->idl
);
1379 static void TypeLibResizeChild(void)
1383 MoveWindow(typelib
.hStatusBar
, 0, 0, 0, 0, TRUE
);
1385 if(IsWindowVisible(typelib
.hStatusBar
))
1386 GetClientRect(typelib
.hStatusBar
, &stat
);
1387 else stat
.bottom
= 0;
1389 GetClientRect(globals
.hTypeLibWnd
, &client
);
1390 MoveWindow(typelib
.hPaneWnd
, 0, 0,
1391 client
.right
, client
.bottom
-stat
.bottom
, TRUE
);
1394 static void TypeLibMenuCommand(WPARAM wParam
, HWND hWnd
)
1404 vis
= IsWindowVisible(typelib
.hStatusBar
);
1405 ShowWindow(typelib
.hStatusBar
, vis
? SW_HIDE
: SW_SHOW
);
1406 CheckMenuItem(GetMenu(hWnd
), LOWORD(wParam
),
1407 vis
? MF_UNCHECKED
: MF_CHECKED
);
1408 TypeLibResizeChild();
1411 DestroyWindow(hWnd
);
1416 static void UpdateTypeLibStatusBar(int itemID
)
1418 WCHAR info
[MAX_LOAD_STRING
];
1420 if(!LoadStringW(globals
.hMainInst
, itemID
, info
, ARRAY_SIZE(info
)))
1421 LoadStringW(globals
.hMainInst
, IDS_READY
, info
, ARRAY_SIZE(info
));
1423 SendMessageW(typelib
.hStatusBar
, SB_SETTEXTW
, 0, (LPARAM
)info
);
1426 static void EmptyTLTree(void)
1431 tvi
.mask
= TVIF_PARAM
;
1432 cur
= (HTREEITEM
)SendMessageW(typelib
.hTree
, TVM_GETNEXTITEM
,
1433 TVGN_CHILD
, (LPARAM
)TVI_ROOT
);
1438 cur
= (HTREEITEM
)SendMessageW(typelib
.hTree
, TVM_GETNEXTITEM
,
1439 TVGN_CHILD
, (LPARAM
)del
);
1441 if(!cur
) cur
= (HTREEITEM
)SendMessageW(typelib
.hTree
,
1442 TVM_GETNEXTITEM
, TVGN_NEXT
, (LPARAM
)del
);
1443 if(!cur
) cur
= (HTREEITEM
)SendMessageW(typelib
.hTree
,
1444 TVM_GETNEXTITEM
, TVGN_PARENT
, (LPARAM
)del
);
1447 SendMessageW(typelib
.hTree
, TVM_GETITEMW
, 0, (LPARAM
)&tvi
);
1450 free(((TYPELIB_DATA
*)tvi
.lParam
)->idl
);
1451 free((TYPELIB_DATA
*)tvi
.lParam
);
1454 SendMessageW(typelib
.hTree
, TVM_DELETEITEM
, 0, (LPARAM
)del
);
1460 static LRESULT CALLBACK
TypeLibProc(HWND hWnd
, UINT uMsg
, WPARAM wParam
, LPARAM lParam
)
1466 if(!CreatePanedWindow(hWnd
, &typelib
.hPaneWnd
, globals
.hMainInst
))
1467 DestroyWindow(hWnd
);
1468 typelib
.hTree
= CreateWindowExW(WS_EX_CLIENTEDGE
, WC_TREEVIEWW
, NULL
,
1469 WS_CHILD
|WS_VISIBLE
|TVS_HASLINES
|TVS_HASBUTTONS
|TVS_LINESATROOT
,
1470 0, 0, 0, 0, typelib
.hPaneWnd
, (HMENU
)TYPELIB_TREE
,
1471 globals
.hMainInst
, NULL
);
1472 typelib
.hEdit
= CreateWindowExW(WS_EX_CLIENTEDGE
, WC_EDITW
, NULL
,
1473 WS_CHILD
|WS_VISIBLE
|ES_MULTILINE
|ES_READONLY
|WS_HSCROLL
|WS_VSCROLL
,
1474 0, 0, 0, 0, typelib
.hPaneWnd
, NULL
, globals
.hMainInst
, NULL
);
1476 SetLeft(typelib
.hPaneWnd
, typelib
.hTree
);
1477 SetRight(typelib
.hPaneWnd
, typelib
.hEdit
);
1479 if(PopulateTree()) DestroyWindow(hWnd
);
1480 else SetFocus(typelib
.hTree
);
1484 TypeLibMenuCommand(LOWORD(wParam
), hWnd
);
1487 UpdateTypeLibStatusBar(LOWORD(wParam
));
1490 SetFocus(typelib
.hTree
);
1493 if(wParam
== SIZE_MINIMIZED
) break;
1494 TypeLibResizeChild();
1500 return DefWindowProcW(hWnd
, uMsg
, wParam
, lParam
);
1505 BOOL
TypeLibRegisterClassW(void)
1509 memset(&wcc
, 0, sizeof(WNDCLASSW
));
1510 wcc
.lpfnWndProc
= TypeLibProc
;
1511 wcc
.hbrBackground
= (HBRUSH
)(COLOR_WINDOW
+1);
1512 wcc
.hCursor
= LoadCursorW(0, (LPCWSTR
)IDC_ARROW
);
1513 wcc
.lpszMenuName
= MAKEINTRESOURCEW(IDM_TYPELIB
);
1514 wcc
.lpszClassName
= wszTypeLib
;
1516 if(!RegisterClassW(&wcc
))
1522 BOOL
CreateTypeLibWindow(HINSTANCE hInst
, WCHAR
*wszFileName
)
1524 WCHAR wszTitle
[MAX_LOAD_STRING
];
1525 LoadStringW(hInst
, IDS_TYPELIBTITLE
, wszTitle
, ARRAY_SIZE(wszTitle
));
1527 if(wszFileName
) lstrcpyW(typelib
.wszFileName
, wszFileName
);
1532 memset(&tvi
, 0, sizeof(TVITEMW
));
1533 tvi
.hItem
= (HTREEITEM
)SendMessageW(globals
.hTree
, TVM_GETNEXTITEM
,
1536 SendMessageW(globals
.hTree
, TVM_GETITEMW
, 0, (LPARAM
)&tvi
);
1537 lstrcpyW(typelib
.wszFileName
, ((ITEM_INFO
*)tvi
.lParam
)->path
);
1540 globals
.hTypeLibWnd
= CreateWindowW(wszTypeLib
, wszTitle
,
1541 WS_OVERLAPPEDWINDOW
|WS_VISIBLE
,
1542 CW_USEDEFAULT
, CW_USEDEFAULT
, 800, 600, NULL
, NULL
, hInst
, NULL
);
1543 if(!globals
.hTypeLibWnd
) return FALSE
;
1545 typelib
.hStatusBar
= CreateStatusWindowW(WS_VISIBLE
|WS_CHILD
,
1546 wszTitle
, globals
.hTypeLibWnd
, 0);
1548 TypeLibResizeChild();