treeitem.cpp

来自「这是VCF框架的代码」· C++ 代码 · 共 1,084 行 · 第 1/2 页

// tree.cpp
//

// This is a part of the Microsoft Foundation Classes C++ library.
// Copyright (C) 1992-1998 Microsoft Corporation
// All rights reserved.
//
// This source code is only intended as a supplement to the
// Microsoft Foundation Classes Reference and related
// electronic documentation provided with the library.
// See these sources for detailed information regarding the
// Microsoft Foundation Classes product.

#include "stdafx.h"
#include "TreeItem.h"
#include "util.h"

#define MAX_NAMES   64

IMPLEMENT_DYNCREATE(CTreeItem, CObject)
CTreeItem::CTreeItem(CTreeCtrl* pTree )
{
	ASSERT(pTree) ;
	m_pTree = pTree ;
	m_punk = NULL ;
	m_Type = typeUnknown ;
	m_uiMemid = 0 ;
}

CTreeItem::~CTreeItem()
{
	if (m_punk )
		m_punk->Release()  ;
}

BOOL CTreeItem::Expand( HTREEITEM hitem )
{
	BOOL fExpand = FALSE ;

	switch(m_Type)
	{
	case typeUnknown:
	case typeUnknown2:
	break ;

	case typeTypeLib:
		fExpand = ExpandTypeLib( hitem );
	break ;

	case typeTypeLib2:
	{
		// CTypeLibWnd::m_fGroupByType == TRUE
		CTreeItem* pItem ;

		TV_INSERTSTRUCT tvis ;
		tvis.hParent = hitem ;
		tvis.hInsertAfter = TVI_LAST ;
		tvis.item.mask = TVIF_TEXT | TVIF_CHILDREN | TVIF_PARAM | TVIF_IMAGE | TVIF_SELECTEDIMAGE ;
		tvis.item.iImage = CTreeItem::typeUnknown ;
		tvis.item.iSelectedImage = tvis.item.iImage + 1 ;
		tvis.item.cChildren = 1 ;

		pItem = new CTreeItem(m_pTree) ;
		pItem->SetTypeLib( GetTypeLib() ) ;
		GetTypeLib()->AddRef() ;
		pItem->m_Type = CTreeItem::typeEnums ;
		tvis.item.lParam = (LPARAM)pItem ;
		tvis.item.pszText = _T("Enums") ;
		m_pTree->InsertItem(&tvis) ;

		pItem = new CTreeItem(m_pTree) ;
		pItem->SetTypeLib( GetTypeLib() ) ;
		GetTypeLib()->AddRef() ;
		pItem->m_Type = CTreeItem::typeRecords ;
		tvis.item.lParam = (LPARAM)pItem ;
		tvis.item.pszText = _T("Structs") ;
		m_pTree->InsertItem(&tvis) ;

		pItem = new CTreeItem(m_pTree) ;
		pItem->SetTypeLib( GetTypeLib() ) ;
		GetTypeLib()->AddRef() ;
		pItem->m_Type = CTreeItem::typeModules ;
		tvis.item.lParam = (LPARAM)pItem ;
		tvis.item.pszText = _T("Modules") ;
		m_pTree->InsertItem(&tvis) ;

		pItem = new CTreeItem(m_pTree) ;
		pItem->SetTypeLib( GetTypeLib() ) ;
		GetTypeLib()->AddRef() ;
		pItem->m_Type = CTreeItem::typeInterfaces ;
		tvis.item.lParam = (LPARAM)pItem ;
		tvis.item.pszText = _T("Interfaces") ;
		m_pTree->InsertItem(&tvis) ;

		pItem = new CTreeItem(m_pTree) ;
		pItem->SetTypeLib( GetTypeLib() ) ;
		GetTypeLib()->AddRef() ;
		pItem->m_Type = CTreeItem::typeDispinterfaces ;
		tvis.item.lParam = (LPARAM)pItem ;
		tvis.item.pszText = _T("Dispinterfaces") ;
		m_pTree->InsertItem(&tvis) ;

		pItem = new CTreeItem(m_pTree) ;
		pItem->SetTypeLib( GetTypeLib() ) ;
		GetTypeLib()->AddRef() ;
		pItem->m_Type = CTreeItem::typeCoClasses ;
		tvis.item.lParam = (LPARAM)pItem ;
		tvis.item.pszText = _T("CoClasses") ;
		m_pTree->InsertItem(&tvis) ;

		pItem = new CTreeItem(m_pTree) ;
		pItem->SetTypeLib( GetTypeLib() ) ;
		GetTypeLib()->AddRef() ;
		pItem->m_Type = CTreeItem::typeAliases ;
		tvis.item.lParam = (LPARAM)pItem ;
		tvis.item.pszText = _T("Typedefs") ;
		m_pTree->InsertItem(&tvis) ;

		pItem = new CTreeItem(m_pTree) ;
		pItem->SetTypeLib( GetTypeLib() ) ;
		GetTypeLib()->AddRef() ;
		pItem->m_Type = CTreeItem::typeUnions ;
		tvis.item.lParam = (LPARAM)pItem ;
		tvis.item.pszText = _T("Unions") ;
		m_pTree->InsertItem(&tvis) ;

		fExpand = TRUE ;
	}
	break ;

	case typeEnums:
	case typeRecords:
	case typeModules:
	case typeInterfaces:
	case typeDispinterfaces:
	case typeCoClasses:
	case typeAliases:
	case typeUnions:
		fExpand = ExpandTypeLib( hitem ) ;
	break ;

	case typeTypeInfo:
	case typeTypeInfo2:
	case typeEnum:
	case typeRecord:
	case typeModule:
	case typeInterface:
	case typeDispinterface:
	case typeCoClass:
	case typeAlias:
	case typeUnion:
		fExpand = ExpandTypeInfo( hitem ) ;
	break ;

	case typeMethods:
	case typeMethods2:
		fExpand = ExpandFuncs( hitem ) ;
	break ;

	case typeProperties:
	case typeProperties2:
	case typeConstants:
	case typeConstants2:
		fExpand = ExpandVars( hitem ) ;
	break ;

	case typeImplTypes:
	case typeImplTypes2:
		fExpand = ExpandImplTypes( hitem ) ;
	break ;

	case typeMethod:
	case typeProperty:
	case typeConstant:
	default:
	break ;
	}

	return fExpand ;
}

BOOL CTreeItem::ExpandTypeLib( HTREEITEM hitem )
{
	ASSERT(hitem) ;
	CTreeItem*  pNewItem = NULL ;

	UINT            uiTypeInfoCount = GetTypeLib()->GetTypeInfoCount() ;
	HRESULT         hr = S_OK ;
	TV_INSERTSTRUCT tvis ;
	CString         strError = "Enumerating typeinfos";
	TYPEATTR*       pattr = NULL ;
	BOOL            fExpand = FALSE ;

	tvis.hParent = hitem  ;
	tvis.hInsertAfter = TVI_LAST ;
	tvis.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN ;
	tvis.item.cChildren = 1 ;
	TRY
	{
		for (UINT n = 0 ; n < uiTypeInfoCount ; n++)
		{
			pNewItem = new CTreeItem( m_pTree ) ;
			pNewItem->m_Type = typeTypeInfo ;
			ASSERT(pNewItem) ;

			tvis.item.lParam = (LPARAM)pNewItem ;
			hr = GetTypeLib()->GetTypeInfo( n, (ITypeInfo**)&pNewItem->m_punk ) ;
			if (FAILED(hr))
			{
				strError.Format(_T("Could not get TypeInfo #%u"), n ) ;
				AfxThrowOleException(hr) ;
			}
			ASSERT(pNewItem->m_punk) ;

			hr = pNewItem->GetTypeInfo()->GetTypeAttr(&pattr) ;
			if FAILED(hr)
			{
				strError.Format(_T("ITypeInfo::GetTypeAttr() failed") ) ;
				AfxThrowOleException(hr) ;
			}

			if ((m_Type == typeTypeLib) ||
				(m_Type == (TypeKindToItemType(pattr->typekind) + 8)))
			{
				tvis.item.iImage = pattr->typekind + typeEnum ;
				tvis.item.iSelectedImage = tvis.item.iImage ;
				CString sName;
				pNewItem->GetName(sName, TRUE );
				tvis.item.pszText = sName.GetBuffer(0);
				m_pTree->InsertItem( &tvis ) ;
				sName.ReleaseBuffer();
				pNewItem->GetTypeInfo()->ReleaseTypeAttr( pattr ) ;
				fExpand = TRUE ;
			}
			else
			{
				pNewItem->GetTypeInfo()->ReleaseTypeAttr( pattr ) ;
				delete pNewItem ;
			}
	   }
	}
	CATCH(CException, pException)
	{
		if (pException->IsKindOf(RUNTIME_CLASS(COleException)))
			ErrorMessage( strError, ((COleException*)pException)->m_sc ) ;
		else
			ErrorMessage( strError, hr ) ;

		if (pNewItem)
			delete pNewItem ;
		return FALSE ;
	}
	END_CATCH

	return fExpand ;
}


BOOL CTreeItem::ExpandTypeInfo( HTREEITEM hitem )
{
	ASSERT(m_pTree) ;
	ASSERT(hitem) ;

	CTreeItem*  pNewItem = NULL ;
	HRESULT         hr = S_OK ;
	TV_INSERTSTRUCT tvis ;
	CString         strError = "Enumerating TypeInfo" ;
	TYPEATTR*       pattr = NULL ;
	ITypeInfo*      pti = GetTypeInfo() ;
	ASSERT(pti) ;
	BOOL            fExpand = FALSE ;

	tvis.hParent = hitem  ;
	tvis.hInsertAfter = TVI_LAST ;
	tvis.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN ;
	tvis.item.iImage = typeUnknown ;
	tvis.item.iSelectedImage = tvis.item.iImage + 1 ;

	TRY
	{
		hr = pti->GetTypeAttr(&pattr) ;
		if FAILED(hr)
		{
			strError.Format(_T("ITypeInfo::GetTypeAttr() failed"), hr ) ;
			AfxThrowMemoryException() ;
		}

		switch(pattr->typekind)
		{
		// typedef [attributes] enum [tag] {
		//      enumlist
		// } enumname;
		//
		// "typedef enum enumname"
		case TKIND_ENUM:
			fExpand = ExpandVars( hitem ) ;
		break ;

		// typedef [attributes]
		//  struct [tag] {
		//      memberlist
		//  } structname;
		//
		// "typedef struct structname"
		case TKIND_RECORD:
			fExpand = ExpandVars( hitem ) ;
		break ;

		// [attributes]
		//  module modulename {
		//      elementlist
		// };
		case TKIND_MODULE:
			if (pattr->cVars)
			{
				// Add "Constants" folder
				//
				pNewItem = new CTreeItem(m_pTree) ;
				pNewItem->m_Type = typeProperties ;
				pNewItem->SetTypeInfo(pti) ;
				pti->AddRef() ;
				tvis.item.cChildren = pattr->cVars ;
				tvis.item.lParam = (LPARAM)pNewItem ;
				tvis.item.pszText = _T("Constants") ;
				tvis.item.iImage = typeConstants ;
				tvis.item.iSelectedImage = tvis.item.iImage + 1 ;
				m_pTree->InsertItem( &tvis ) ;
				fExpand = TRUE ;
			}
			if (pattr->cFuncs)
			{
				pNewItem = new CTreeItem(m_pTree) ;
				pNewItem->m_Type = typeMethods ;
				pNewItem->SetTypeInfo(pti) ;
				pti->AddRef() ;
				tvis.item.cChildren = pattr->cFuncs ;
				tvis.item.lParam = (LPARAM)pNewItem ;
				tvis.item.pszText = _T("Functions") ;
				tvis.item.iImage = typeMethods ;
				tvis.item.iSelectedImage = tvis.item.iImage + 1 ;
				m_pTree->InsertItem( &tvis ) ;
				fExpand = TRUE ;
			}
		break ;

		// [attributes]
		//  interface interfacename  [:baseinterface] {
		//      functionlist
		// };
		case TKIND_INTERFACE:
			fExpand = ExpandFuncs( hitem) ;
			if (pattr->cImplTypes)
			{
				pNewItem = new CTreeItem(m_pTree) ;
				pNewItem->m_Type = typeImplTypes ;
				pNewItem->SetTypeInfo(pti) ;
				pti->AddRef() ;
				tvis.item.pszText = _T("Inherited Interfaces") ;
				tvis.item.iImage = typeInterface ;
				tvis.item.cChildren = pattr->cImplTypes ;
				tvis.item.lParam = (LPARAM)pNewItem ;
				tvis.item.iSelectedImage = tvis.item.iImage ;
				m_pTree->InsertItem( &tvis ) ;
				fExpand = TRUE ;
			}
		break ;

		// [attributes]
		//  dispinterface intfname {
		//      interface interfacename
		// };
		case TKIND_DISPATCH :
			if (pattr->cVars)
			{
				// Add "Constants" folder
				//
				pNewItem = new CTreeItem(m_pTree) ;
				pNewItem->m_Type = typeConstants ;
				pNewItem->SetTypeInfo(pti) ;
				pti->AddRef() ;
				tvis.item.cChildren = pattr->cVars ;
				tvis.item.lParam = (LPARAM)pNewItem ;
				tvis.item.pszText = _T("Constants") ;
				tvis.item.iImage = typeConstants ;
				tvis.item.iSelectedImage = tvis.item.iImage + 1 ;
				m_pTree->InsertItem( &tvis ) ;

				// Add "Properties" folder
				//
				pNewItem = new CTreeItem(m_pTree) ;
				pNewItem->m_Type = typeProperties ;
				pNewItem->SetTypeInfo(pti) ;
				pti->AddRef() ;
				tvis.item.cChildren = pattr->cVars ;
				tvis.item.lParam = (LPARAM)pNewItem ;
				tvis.item.pszText = _T("Properties") ;
				tvis.item.iImage = typeProperties ;
				tvis.item.iSelectedImage = tvis.item.iImage + 1 ;
				m_pTree->InsertItem( &tvis ) ;
				fExpand = TRUE ;
			 }
			if (pattr->cFuncs)
			{
				pNewItem = new CTreeItem(m_pTree) ;
				pNewItem->m_Type = typeMethods ;
				pNewItem->SetTypeInfo(pti) ;
				pti->AddRef() ;
				tvis.item.cChildren = pattr->cFuncs ;
				tvis.item.lParam = (LPARAM)pNewItem ;
				tvis.item.pszText = _T("Methods") ;
				tvis.item.iImage = typeMethods ;
				tvis.item.iSelectedImage = tvis.item.iImage + 1 ;
				m_pTree->InsertItem( &tvis ) ;
				fExpand = TRUE ;
			}
			if (pattr->cImplTypes)
			{
				pNewItem = new CTreeItem(m_pTree) ;
				pNewItem->m_Type = typeImplTypes ;
				pNewItem->SetTypeInfo(pti) ;
				pti->AddRef() ;
				tvis.item.pszText = _T("Inherited Interfaces") ;
				tvis.item.iImage = typeInterface ;
				tvis.item.cChildren = pattr->cImplTypes ;
				tvis.item.lParam = (LPARAM)pNewItem ;
				tvis.item.iSelectedImage = tvis.item.iImage ;
				m_pTree->InsertItem( &tvis ) ;
				fExpand = TRUE ;
			}
		break ;

		// [attributes]
		//  coclass classname {
		//      [attributes2] [interface | dispinterface] interfacename;
		//      ...
		// };
		case TKIND_COCLASS:
			fExpand = ExpandImplTypes( hitem ) ;
		break ;

		// typedef [attributes] basetype aliasname;
		case TKIND_ALIAS:
			if (pattr->tdescAlias.vt == VT_USERDEFINED)
			{
				ITypeInfo* ptiRefType = NULL ;
				HRESULT hr = pti->GetRefTypeInfo( pattr->tdescAlias.hreftype, &ptiRefType ) ;
				if (FAILED(hr))
					AfxThrowOleException( hr ) ;

				CTreeItem* pNewItem = new CTreeItem(m_pTree) ;
				pNewItem->SetTypeInfo( ptiRefType ) ;
				pNewItem->m_Type = TypeKindToItemType( pNewItem->GetTypeKind() ) ;
				tvis.item.iImage = TypeKindToItemType( pNewItem->GetTypeKind() ) ;
				tvis.item.cChildren = 1 ;
				tvis.item.lParam = (LPARAM)pNewItem ;
				tvis.item.iSelectedImage = tvis.item.iImage ;
				CString sName;
				pNewItem->GetName(sName, TRUE );
				tvis.item.pszText = sName.GetBuffer(0) ;
				m_pTree->InsertItem( &tvis ) ;
				sName.ReleaseBuffer();
				fExpand = TRUE ;
			}
		break ;

		// typedef [attributes] union [tag] {
		//      memberlist
		// } unionname;
		case TKIND_UNION:
			fExpand = ExpandVars( hitem ) ;
		break ;

		default:
		break ;
		}

		if (pattr)
			pti->ReleaseTypeAttr( pattr ) ;
	}
	CATCH(CException, pException)
	{
		ErrorMessage( strError, hr ) ;
		if (pNewItem)
			delete pNewItem ;

		if (pattr)
			pti->ReleaseTypeAttr( pattr ) ;

		return FALSE ;
	}
	END_CATCH
	return fExpand ;
}

BOOL CTreeItem::ExpandFuncs( HTREEITEM hitem )
{
	ASSERT(hitem) ;

	CTreeItem*  pNewItem = NULL ;
	HRESULT         hr = S_OK ;
	TV_INSERTSTRUCT tvis ;
	CString         strError ;
	TYPEATTR*       pattr = NULL ;
	ITypeInfo*      pti = GetTypeInfo() ;
	ASSERT(pti) ;
	FUNCDESC*       pfuncdesc = NULL ;
	BSTR            bstrParams = NULL ;
	BOOL            fExpand = FALSE ;

	tvis.hParent = hitem  ;
	tvis.hInsertAfter = TVI_LAST ;
	tvis.item.mask = TVIF_PARAM | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN ;

	TRY
	{
		hr = pti->GetTypeAttr(&pattr) ;
		if FAILED(hr)
		{
			strError.Format(_T("ITypeInfo::GetTypeAttr() failed: %x"), hr);
			AfxThrowMemoryException() ;
		}

		BSTR  rgbstrNames[MAX_NAMES] ;
		int   cNames ;

		//
		// Enumerate through all FUNCDESCS
		for ( int iIndex = 0 ; iIndex < pattr->cFuncs ; iIndex++)
		{
			hr = pti->GetFuncDesc( iIndex, &pfuncdesc ) ;
			if (FAILED(hr))
			{
				strError.Format(_T("GetVarDesc failed for function #%u"), iIndex) ;
				AfxThrowMemoryException() ;
			}

			//int cParams = pfuncdesc->cParams ;
			//int cParamsOpt = abs(pfuncdesc->cParamsOpt) ;

			// Get the names of the function and it's parameters into rgbstrNames.
			// cNames gets the number of parameters + 1.
			//