[wxWidgets.git] / samples / xti / codereadercallback.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/xtistrm.cpp
// Purpose:     streaming runtime metadata information
// Author:      Stefan Csomor
// Modified by:
// Created:     27/07/03
// RCS-ID:      $Id$
// Copyright:   (c) 2003 Stefan Csomor
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#include "wx/xtistrm.h"

#ifndef WX_PRECOMP
    #include "wx/object.h"
    #include "wx/hash.h"
    #include "wx/event.h"
#endif

#include <map>
#include <vector>
#include <string>
using namespace std;

#include "wx/tokenzr.h"
#include "wx/txtstrm.h"
#include "codereadercallback.h"

#if !wxUSE_EXTENDED_RTTI
    #error This sample requires XTI (eXtended RTTI) enabled
#endif

// ----------------------------------------------------------------------------
// wxObjectCodeReaderCallback - depersisting to code
// ----------------------------------------------------------------------------

struct wxObjectCodeReaderCallback::wxObjectCodeReaderCallbackInternal
{
#if wxUSE_UNICODE
    map<int,wstring> m_objectNames;
#else
    map<int,string> m_objectNames;
#endif

    void SetObjectName(int objectID, const wxString &name )
    {
        if ( m_objectNames.find(objectID) != m_objectNames.end() )
        {
            wxLogError( _("Passing a already registered object to SetObjectName") );
            return ;
        }
        m_objectNames[objectID] = (const wxChar *)name;
    }

    wxString GetObjectName( int objectID )
    {
        if ( objectID == wxNullObjectID )
            return wxT("NULL");

        if ( m_objectNames.find(objectID) == m_objectNames.end() )
        {
            wxLogError( _("Passing an unkown object to GetObject") );
            return wxEmptyString;
        }
        return wxString( m_objectNames[objectID].c_str() );
    }
};

wxObjectCodeReaderCallback::wxObjectCodeReaderCallback(wxString& headerincludes, wxString &source)
: m_headerincludes(headerincludes),m_source(source)
{
    m_data = new wxObjectCodeReaderCallbackInternal;
}

wxObjectCodeReaderCallback::~wxObjectCodeReaderCallback()
{
    delete m_data;
}

void wxObjectCodeReaderCallback::AllocateObject(int objectID, wxClassInfo *classInfo,
                                       wxStringToAnyHashMap &WXUNUSED(metadata))
{
    if ( classInfo->GetIncludeName() != wxEmptyString)
    {
        // add corresponding header if not already included
        wxString include;
        include.Printf(wxT("#include \"%s\"\n"),classInfo->GetIncludeName());
        if ( m_headerincludes.Find(include) == wxNOT_FOUND)
            m_headerincludes += include;
    }

    wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID );
    m_source += ( wxString::Format( wxT("\t%s *%s = new %s;\n"),
        classInfo->GetClassName(),
        objectName.c_str(),
        classInfo->GetClassName()) );
    m_data->SetObjectName( objectID, objectName );
}

void wxObjectCodeReaderCallback::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
{
    m_source += ( wxString::Format( wxT("\tdelete %s;\n"),
        m_data->GetObjectName( objectID).c_str() ) );
}

class WXDLLIMPEXP_BASE wxObjectConstructorWriter: public wxObjectWriterFunctor
{
public:
    wxObjectConstructorWriter(const wxClassTypeInfo* cti,
        wxObjectCodeReaderCallback* writer) : 
    m_cti(cti),m_writer(writer)
    {}

    virtual void operator()(const wxObject *vobj)
    {
        const wxClassInfo* ci = m_cti->GetClassInfo();

        for ( int i = 0; i < ci->GetCreateParamCount(); ++i )
        {
            wxString name = ci->GetCreateParamName(i);
            const wxPropertyInfo* prop = ci->FindPropertyInfo(name);
            if ( i > 0 )
                m_constructor += ", ";
            wxAny value;
            prop->GetAccessor()->GetProperty(vobj, value);
            m_constructor+= m_writer->ValueAsCode(value);
        }
    }

    const wxString& GetConstructorString() const { return m_constructor;}
private:
    const wxClassTypeInfo* m_cti;
    wxObjectCodeReaderCallback* m_writer;
    wxString m_constructor;
};

wxString wxObjectCodeReaderCallback::ValueAsCode( const wxAny &param )
{
    wxString value;

    const wxTypeInfo* type = param.GetTypeInfo();
    if ( type->GetKind() == wxT_CUSTOM )
    {
        const wxCustomTypeInfo* cti = wx_dynamic_cast(const wxCustomTypeInfo*, type);
        if ( cti )
        {
            value.Printf( wxT("%s(%s)"), cti->GetTypeName().c_str(),
                          wxAnyGetAsString(param).c_str() );
        }
        else
        {
            wxLogError ( _("Internal error, illegal wxCustomTypeInfo") );
        }
    }
    else if ( type->GetKind() == wxT_STRING )
    {
        value.Printf( wxT("\"%s\""), wxAnyGetAsString(param).c_str() );
    }
    else if ( type->GetKind() == wxT_OBJECT )
    {
        const wxClassTypeInfo* ctype = wx_dynamic_cast(const wxClassTypeInfo*,type);
        const wxClassInfo* ci = ctype->GetClassInfo();
        if( ci->NeedsDirectConstruction())
        {
            wxObjectConstructorWriter cw(ctype,this);

            ci->CallOnAny(param,&cw);

            value.Printf( wxT("%s(%s)"), ctype->GetClassInfo()->GetClassName(),
                cw.GetConstructorString() );
        }
    }
    else
    {
        value.Printf( wxT("%s"),  wxAnyGetAsString(param).c_str() );
    }

    return value;
}

void wxObjectCodeReaderCallback::CreateObject(int objectID,
                                     const wxClassInfo *WXUNUSED(classInfo),
                                     int paramCount,
                                     wxAny *params,
                                     int *objectIDValues,
                                     const wxClassInfo **WXUNUSED(objectClassInfos),
                                     wxStringToAnyHashMap &WXUNUSED(metadata)
                                     )
{
    int i;
    m_source += ( wxString::Format( wxT("\t%s->Create("), 
                       m_data->GetObjectName(objectID).c_str() ) );
    for (i = 0; i < paramCount; i++)
    {
        if ( objectIDValues[i] != wxInvalidObjectID )
        {
            wxString str = 
                wxString::Format( wxT("%s"), 
                                  m_data->GetObjectName( objectIDValues[i] ).c_str() );
            m_source += ( str );
        }
        else
        {
            m_source += ( 
                wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
        }
        if (i < paramCount - 1)
            m_source += ( wxT(", "));
    }
    m_source += ( wxT(");\n") );
}

void wxObjectCodeReaderCallback::ConstructObject(int objectID,
                                     const wxClassInfo *classInfo,
                                     int paramCount,
                                     wxAny *params,
                                     int *objectIDValues,
                                     const wxClassInfo **WXUNUSED(objectClassInfos),
                                     wxStringToAnyHashMap &WXUNUSED(metadata)
                                     )
{
    wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID );
    m_source += ( wxString::Format( wxT("\t%s *%s = new %s("),
        classInfo->GetClassName(),
        objectName.c_str(),
        classInfo->GetClassName()) );
    m_data->SetObjectName( objectID, objectName );

    int i;
    for (i = 0; i < paramCount; i++)
    {
        if ( objectIDValues[i] != wxInvalidObjectID )
            m_source += ( wxString::Format( wxT("%s"), 
                               m_data->GetObjectName( objectIDValues[i] ).c_str() ) );
        else
        {
            m_source += ( 
                wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
        }
        if (i < paramCount - 1)
            m_source += ( wxT(", ") );
    }
    m_source += ( wxT(");\n") );
}

void wxObjectCodeReaderCallback::SetProperty(int objectID,
                                    const wxClassInfo *WXUNUSED(classInfo),
                                    const wxPropertyInfo* propertyInfo,
                                    const wxAny &value)
{
    m_source += ( wxString::Format( wxT("\t%s->%s(%s);\n"),
        m_data->GetObjectName(objectID).c_str(),
        propertyInfo->GetAccessor()->GetSetterName().c_str(),
        ValueAsCode(value).c_str()) );
}

void wxObjectCodeReaderCallback::SetPropertyAsObject(int objectID,
                                            const wxClassInfo *WXUNUSED(classInfo),
                                            const wxPropertyInfo* propertyInfo,
                                            int valueObjectId)
{
    if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT )
        m_source += ( wxString::Format( wxT("\t%s->%s(*%s);\n"),
        m_data->GetObjectName(objectID).c_str(),
        propertyInfo->GetAccessor()->GetSetterName().c_str(),
        m_data->GetObjectName( valueObjectId).c_str() ) );
    else
        m_source += ( wxString::Format( wxT("\t%s->%s(%s);\n"),
        m_data->GetObjectName(objectID).c_str(),
        propertyInfo->GetAccessor()->GetSetterName().c_str(),
        m_data->GetObjectName( valueObjectId).c_str() ) );
}

void wxObjectCodeReaderCallback::AddToPropertyCollection( int objectID,
                                                const wxClassInfo *WXUNUSED(classInfo),
                                                const wxPropertyInfo* propertyInfo,
                                                const wxAny &value)
{
    m_source += ( wxString::Format( wxT("\t%s->%s(%s);\n"),
        m_data->GetObjectName(objectID).c_str(),
        propertyInfo->GetAccessor()->GetAdderName().c_str(),
        ValueAsCode(value).c_str()) );
}

// sets the corresponding property (value is an object)
void wxObjectCodeReaderCallback::
    AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
                                    const wxClassInfo *WXUNUSED(classInfo),
                                    const wxPropertyInfo* WXUNUSED(propertyInfo),
                                    int WXUNUSED(valueObjectId))
{
    // TODO
}

void wxObjectCodeReaderCallback::SetConnect(int eventSourceObjectID,
                                   const wxClassInfo *WXUNUSED(eventSourceClassInfo),
                                   const wxPropertyInfo *delegateInfo,
                                   const wxClassInfo *eventSinkClassInfo,
                                   const wxHandlerInfo* handlerInfo,
                                   int eventSinkObjectID )
{
    wxString ehsource = m_data->GetObjectName( eventSourceObjectID );
    wxString ehsink = m_data->GetObjectName(eventSinkObjectID);
    wxString ehsinkClass = eventSinkClassInfo->GetClassName();
    const wxEventSourceTypeInfo *delegateTypeInfo = 
        wx_dynamic_cast(const wxEventSourceTypeInfo*, delegateInfo->GetTypeInfo());
    if ( delegateTypeInfo )
    {
        int eventType = delegateTypeInfo->GetEventType();
        wxString handlerName = handlerInfo->GetName();

        wxString code =
            wxString::Format( 
                wxT("\t%s->Connect( %s->GetId(), %d, ")
                wxT("(wxObjectEventFunction)(wxEventFunction) & %s::%s, NULL, %s );"),
                ehsource.c_str(), ehsource.c_str(), eventType, ehsinkClass.c_str(),
                handlerName.c_str(), ehsink.c_str() );

        m_source += ( code );
    }
    else
    {
        wxLogError(_("delegate has no type info"));
    }
}
Commit	Line	Data
e1d3601a PC	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/xtistrm.cpp
	3	// Purpose: streaming runtime metadata information
	4	// Author: Stefan Csomor
	5	// Modified by:
	6	// Created: 27/07/03
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 2003 Stefan Csomor
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#include "wx/xtistrm.h"
	20
	21	#ifndef WX_PRECOMP
	22	#include "wx/object.h"
	23	#include "wx/hash.h"
	24	#include "wx/event.h"
	25	#endif
	26
	27	#include <map>
	28	#include <vector>
	29	#include <string>
	30	using namespace std;
	31
	32	#include "wx/tokenzr.h"
	33	#include "wx/txtstrm.h"
	34	#include "codereadercallback.h"
	35
	36	#if !wxUSE_EXTENDED_RTTI
	37	#error This sample requires XTI (eXtended RTTI) enabled
	38	#endif
	39
	40	// ----------------------------------------------------------------------------
	41	// wxObjectCodeReaderCallback - depersisting to code
	42	// ----------------------------------------------------------------------------
	43
	44	struct wxObjectCodeReaderCallback::wxObjectCodeReaderCallbackInternal
	45	{
	46	#if wxUSE_UNICODE
	47	map<int,wstring> m_objectNames;
	48	#else
	49	map<int,string> m_objectNames;
	50	#endif
	51
	52	void SetObjectName(int objectID, const wxString &name )
	53	{
	54	if ( m_objectNames.find(objectID) != m_objectNames.end() )
	55	{
	56	wxLogError( _("Passing a already registered object to SetObjectName") );
	57	return ;
	58	}
	59	m_objectNames[objectID] = (const wxChar *)name;
	60	}
	61
	62	wxString GetObjectName( int objectID )
	63	{
	64	if ( objectID == wxNullObjectID )
65	return wxT("NULL");
66
67	if ( m_objectNames.find(objectID) == m_objectNames.end() )
68	{
69	wxLogError( _("Passing an unkown object to GetObject") );
70	return wxEmptyString;
71	}
72	return wxString( m_objectNames[objectID].c_str() );
73	}
74	};
75
1bf29304 SC	76	wxObjectCodeReaderCallback::wxObjectCodeReaderCallback(wxString& headerincludes, wxString &source)
1bf29304 SC	77	: m_headerincludes(headerincludes),m_source(source)
e1d3601a PC	78	{
	79	m_data = new wxObjectCodeReaderCallbackInternal;
	80	}
	81
	82	wxObjectCodeReaderCallback::~wxObjectCodeReaderCallback()
	83	{
	84	delete m_data;
	85	}
	86
	87	void wxObjectCodeReaderCallback::AllocateObject(int objectID, wxClassInfo *classInfo,
1bf29304	88	wxStringToAnyHashMap &WXUNUSED(metadata))
e1d3601a	89	{
1bf29304 SC	90	if ( classInfo->GetIncludeName() != wxEmptyString)
	91	{
	92	// add corresponding header if not already included
	93	wxString include;
	94	include.Printf(wxT("#include \"%s\"\n"),classInfo->GetIncludeName());
	95	if ( m_headerincludes.Find(include) == wxNOT_FOUND)
	96	m_headerincludes += include;
	97	}
	98
e1d3601a	99	wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID );
1bf29304	100	m_source += ( wxString::Format( wxT("\t%s *%s = new %s;\n"),
e1d3601a PC	101	classInfo->GetClassName(),
	102	objectName.c_str(),
	103	classInfo->GetClassName()) );
	104	m_data->SetObjectName( objectID, objectName );
	105	}
	106
	107	void wxObjectCodeReaderCallback::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
	108	{
1bf29304	109	m_source += ( wxString::Format( wxT("\tdelete %s;\n"),
e1d3601a PC	110	m_data->GetObjectName( objectID).c_str() ) );
	111	}
	112
1bf29304 SC	113	class WXDLLIMPEXP_BASE wxObjectConstructorWriter: public wxObjectWriterFunctor
	114	{
	115	public:
	116	wxObjectConstructorWriter(const wxClassTypeInfo* cti,
	117	wxObjectCodeReaderCallback* writer) :
	118	m_cti(cti),m_writer(writer)
	119	{}
	120
	121	virtual void operator()(const wxObject *vobj)
	122	{
	123	const wxClassInfo* ci = m_cti->GetClassInfo();
	124
	125	for ( int i = 0; i < ci->GetCreateParamCount(); ++i )
	126	{
	127	wxString name = ci->GetCreateParamName(i);
	128	const wxPropertyInfo* prop = ci->FindPropertyInfo(name);
	129	if ( i > 0 )
	130	m_constructor += ", ";
	131	wxAny value;
	132	prop->GetAccessor()->GetProperty(vobj, value);
	133	m_constructor+= m_writer->ValueAsCode(value);
	134	}
	135	}
	136
	137	const wxString& GetConstructorString() const { return m_constructor;}
	138	private:
	139	const wxClassTypeInfo* m_cti;
	140	wxObjectCodeReaderCallback* m_writer;
	141	wxString m_constructor;
	142	};
	143
	144	wxString wxObjectCodeReaderCallback::ValueAsCode( const wxAny &param )
e1d3601a PC	145	{
e1d3601a PC	146	wxString value;
1bf29304	147
e1d3601a PC	148	const wxTypeInfo* type = param.GetTypeInfo();
	149	if ( type->GetKind() == wxT_CUSTOM )
	150	{
	151	const wxCustomTypeInfo* cti = wx_dynamic_cast(const wxCustomTypeInfo*, type);
	152	if ( cti )
	153	{
	154	value.Printf( wxT("%s(%s)"), cti->GetTypeName().c_str(),
1bf29304	155	wxAnyGetAsString(param).c_str() );
e1d3601a PC	156	}
	157	else
	158	{
	159	wxLogError ( _("Internal error, illegal wxCustomTypeInfo") );
	160	}
	161	}
	162	else if ( type->GetKind() == wxT_STRING )
	163	{
1bf29304 SC	164	value.Printf( wxT("\"%s\""), wxAnyGetAsString(param).c_str() );
	165	}
	166	else if ( type->GetKind() == wxT_OBJECT )
	167	{
	168	const wxClassTypeInfo* ctype = wx_dynamic_cast(const wxClassTypeInfo*,type);
	169	const wxClassInfo* ci = ctype->GetClassInfo();
	170	if( ci->NeedsDirectConstruction())
	171	{
	172	wxObjectConstructorWriter cw(ctype,this);
	173
	174	ci->CallOnAny(param,&cw);
	175
	176	value.Printf( wxT("%s(%s)"), ctype->GetClassInfo()->GetClassName(),
	177	cw.GetConstructorString() );
	178	}
e1d3601a PC	179	}
	180	else
	181	{
1bf29304	182	value.Printf( wxT("%s"), wxAnyGetAsString(param).c_str() );
e1d3601a	183	}
1bf29304	184
e1d3601a PC	185	return value;
	186	}
	187
	188	void wxObjectCodeReaderCallback::CreateObject(int objectID,
	189	const wxClassInfo *WXUNUSED(classInfo),
	190	int paramCount,
1bf29304	191	wxAny *params,
e1d3601a PC	192	int *objectIDValues,
e1d3601a PC	193	const wxClassInfo **WXUNUSED(objectClassInfos),
1bf29304	194	wxStringToAnyHashMap &WXUNUSED(metadata)
e1d3601a PC	195	)
	196	{
	197	int i;
1bf29304	198	m_source += ( wxString::Format( wxT("\t%s->Create("),
e1d3601a PC	199	m_data->GetObjectName(objectID).c_str() ) );
	200	for (i = 0; i < paramCount; i++)
	201	{
	202	if ( objectIDValues[i] != wxInvalidObjectID )
	203	{
	204	wxString str =
	205	wxString::Format( wxT("%s"),
	206	m_data->GetObjectName( objectIDValues[i] ).c_str() );
1bf29304	207	m_source += ( str );
e1d3601a PC	208	}
	209	else
	210	{
1bf29304	211	m_source += (
e1d3601a PC	212	wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
	213	}
	214	if (i < paramCount - 1)
1bf29304	215	m_source += ( wxT(", "));
e1d3601a	216	}
1bf29304	217	m_source += ( wxT(");\n") );
e1d3601a PC	218	}
	219
	220	void wxObjectCodeReaderCallback::ConstructObject(int objectID,
	221	const wxClassInfo *classInfo,
	222	int paramCount,
1bf29304	223	wxAny *params,
e1d3601a PC	224	int *objectIDValues,
e1d3601a PC	225	const wxClassInfo **WXUNUSED(objectClassInfos),
1bf29304	226	wxStringToAnyHashMap &WXUNUSED(metadata)
e1d3601a PC	227	)
	228	{
	229	wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID );
1bf29304	230	m_source += ( wxString::Format( wxT("\t%s *%s = new %s("),
e1d3601a PC	231	classInfo->GetClassName(),
	232	objectName.c_str(),
	233	classInfo->GetClassName()) );
	234	m_data->SetObjectName( objectID, objectName );
	235
	236	int i;
	237	for (i = 0; i < paramCount; i++)
	238	{
	239	if ( objectIDValues[i] != wxInvalidObjectID )
1bf29304	240	m_source += ( wxString::Format( wxT("%s"),
e1d3601a PC	241	m_data->GetObjectName( objectIDValues[i] ).c_str() ) );
	242	else
	243	{
1bf29304	244	m_source += (
e1d3601a PC	245	wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
	246	}
	247	if (i < paramCount - 1)
1bf29304	248	m_source += ( wxT(", ") );
e1d3601a	249	}
1bf29304	250	m_source += ( wxT(");\n") );
e1d3601a PC	251	}
	252
	253	void wxObjectCodeReaderCallback::SetProperty(int objectID,
	254	const wxClassInfo *WXUNUSED(classInfo),
	255	const wxPropertyInfo* propertyInfo,
1bf29304	256	const wxAny &value)
e1d3601a	257	{
1bf29304	258	m_source += ( wxString::Format( wxT("\t%s->%s(%s);\n"),
e1d3601a PC	259	m_data->GetObjectName(objectID).c_str(),
	260	propertyInfo->GetAccessor()->GetSetterName().c_str(),
	261	ValueAsCode(value).c_str()) );
	262	}
	263
	264	void wxObjectCodeReaderCallback::SetPropertyAsObject(int objectID,
	265	const wxClassInfo *WXUNUSED(classInfo),
	266	const wxPropertyInfo* propertyInfo,
	267	int valueObjectId)
	268	{
	269	if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT )
1bf29304	270	m_source += ( wxString::Format( wxT("\t%s->%s(*%s);\n"),
e1d3601a PC	271	m_data->GetObjectName(objectID).c_str(),
	272	propertyInfo->GetAccessor()->GetSetterName().c_str(),
	273	m_data->GetObjectName( valueObjectId).c_str() ) );
	274	else
1bf29304	275	m_source += ( wxString::Format( wxT("\t%s->%s(%s);\n"),
e1d3601a PC	276	m_data->GetObjectName(objectID).c_str(),
	277	propertyInfo->GetAccessor()->GetSetterName().c_str(),
	278	m_data->GetObjectName( valueObjectId).c_str() ) );
	279	}
	280
	281	void wxObjectCodeReaderCallback::AddToPropertyCollection( int objectID,
	282	const wxClassInfo *WXUNUSED(classInfo),
	283	const wxPropertyInfo* propertyInfo,
1bf29304	284	const wxAny &value)
e1d3601a	285	{
1bf29304	286	m_source += ( wxString::Format( wxT("\t%s->%s(%s);\n"),
e1d3601a PC	287	m_data->GetObjectName(objectID).c_str(),
	288	propertyInfo->GetAccessor()->GetAdderName().c_str(),
	289	ValueAsCode(value).c_str()) );
	290	}
	291
	292	// sets the corresponding property (value is an object)
	293	void wxObjectCodeReaderCallback::
	294	AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
	295	const wxClassInfo *WXUNUSED(classInfo),
	296	const wxPropertyInfo* WXUNUSED(propertyInfo),
	297	int WXUNUSED(valueObjectId))
	298	{
	299	// TODO
	300	}
	301
	302	void wxObjectCodeReaderCallback::SetConnect(int eventSourceObjectID,
	303	const wxClassInfo *WXUNUSED(eventSourceClassInfo),
	304	const wxPropertyInfo *delegateInfo,
	305	const wxClassInfo *eventSinkClassInfo,
	306	const wxHandlerInfo* handlerInfo,
	307	int eventSinkObjectID )
	308	{
	309	wxString ehsource = m_data->GetObjectName( eventSourceObjectID );
	310	wxString ehsink = m_data->GetObjectName(eventSinkObjectID);
	311	wxString ehsinkClass = eventSinkClassInfo->GetClassName();
	312	const wxEventSourceTypeInfo *delegateTypeInfo =
	313	wx_dynamic_cast(const wxEventSourceTypeInfo*, delegateInfo->GetTypeInfo());
	314	if ( delegateTypeInfo )
	315	{
	316	int eventType = delegateTypeInfo->GetEventType();
	317	wxString handlerName = handlerInfo->GetName();
	318
	319	wxString code =
	320	wxString::Format(
	321	wxT("\t%s->Connect( %s->GetId(), %d, ")
	322	wxT("(wxObjectEventFunction)(wxEventFunction) & %s::%s, NULL, %s );"),
	323	ehsource.c_str(), ehsource.c_str(), eventType, ehsinkClass.c_str(),
	324	handlerName.c_str(), ehsink.c_str() );
	325
1bf29304	326	m_source += ( code );
e1d3601a PC	327	}
	328	else
	329	{
	330	wxLogError(_("delegate has no type info"));
	331	}
	332	}