src/common/xtistrm.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/xtistrm.cpp
// Purpose:     streaming runtime metadata information
// Author:      Stefan Csomor
// Modified by:
// Created:     27/07/03
// 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

#if wxUSE_EXTENDED_RTTI

#include "wx/xtistrm.h"

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

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

// STL headers:

#include "wx/beforestd.h"
#include <map>
#include <vector>
#include <string>
#include "wx/afterstd.h"
using namespace std;


// ----------------------------------------------------------------------------
// wxObjectWriter
// ----------------------------------------------------------------------------

struct wxObjectWriter::wxObjectWriterInternal
{
    map< const wxObject*, int > m_writtenObjects;
    int m_nextId;
};

wxObjectWriter::wxObjectWriter()
{
    m_data = new wxObjectWriterInternal;
    m_data->m_nextId = 0;
}

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

struct wxObjectWriter::wxObjectWriterInternalPropertiesData
{
    char nothing;
};

void wxObjectWriter::ClearObjectContext()
{
    delete m_data;
    m_data = new wxObjectWriterInternal();
    m_data->m_nextId = 0;
}

void wxObjectWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo,
                           wxObjectWriterCallback *writercallback, const wxString &name,
                           const wxStringToAnyHashMap &metadata )
{
    DoBeginWriteTopLevelEntry( name );
    WriteObject( object, classInfo, writercallback, false, metadata);
    DoEndWriteTopLevelEntry( name );
}

void wxObjectWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo,
                           wxObjectWriterCallback *writercallback, bool isEmbedded,
                           const wxStringToAnyHashMap &metadata )
{
    if ( !classInfo->BeforeWriteObject( object, this, writercallback, metadata) )
        return;

    if ( writercallback->BeforeWriteObject( this, object, classInfo, metadata) )
    {
        if ( object == NULL )
            DoWriteNullObject();
        else if ( IsObjectKnown( object ) )
            DoWriteRepeatedObject( GetObjectID(object) );
        else
        {
            int oid = m_data->m_nextId++;
            if ( !isEmbedded )
                m_data->m_writtenObjects[object] = oid;

            // in case this object is a wxDynamicObject we also have to insert is superclass
            // instance with the same id, so that object relations are streamed out correctly
            const wxDynamicObject* dynobj = wx_dynamic_cast(const wxDynamicObject*, object);
            if ( !isEmbedded && dynobj )
                m_data->m_writtenObjects[dynobj->GetSuperClassInstance()] = oid;

            DoBeginWriteObject( object, classInfo, oid, metadata );
            wxObjectWriterInternalPropertiesData data;
            WriteAllProperties( object, classInfo, writercallback, &data );
            DoEndWriteObject( object, classInfo, oid  );
        }
        writercallback->AfterWriteObject( this,object, classInfo );
    }
}

void wxObjectWriter::FindConnectEntry(const wxEvtHandler * evSource,
                                const wxEventSourceTypeInfo* dti,
                                const wxObject* &sink,
                                const wxHandlerInfo *&handler)
{
    wxList *dynamicEvents = evSource->GetDynamicEventTable();

    if ( dynamicEvents )
    {
        for ( wxList::const_iterator node = dynamicEvents->begin(); node != dynamicEvents->end(); ++node )
        {
            wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)(*node);

            // find the match
            if ( entry->m_fn &&
                (dti->GetEventType() == entry->m_eventType) &&
                (entry->m_id == -1 ) &&
                (entry->m_fn->GetEvtHandler() != NULL ) )
            {
                sink = entry->m_fn->GetEvtHandler();
                const wxClassInfo* sinkClassInfo = sink->GetClassInfo();
                const wxHandlerInfo* sinkHandler = sinkClassInfo->GetFirstHandler();
                while ( sinkHandler )
                {
                    if ( sinkHandler->GetEventFunction() == entry->m_fn->GetEvtMethod() )
                    {
                        handler = sinkHandler;
                        break;
                    }
                    sinkHandler = sinkHandler->GetNext();
                }
                break;
            }
        }
    }
}
void wxObjectWriter::WriteAllProperties( const wxObject * obj, const wxClassInfo* ci,
                                   wxObjectWriterCallback *writercallback,
                                   wxObjectWriterInternalPropertiesData * data )
{
    wxPropertyInfoMap map;
    ci->GetProperties( map );
    for ( int i = 0; i < ci->GetCreateParamCount(); ++i )
    {
        wxString name = ci->GetCreateParamName(i);
        wxPropertyInfoMap::const_iterator iter = map.find(name);
        const wxPropertyInfo* prop = iter == map.end() ? NULL : iter->second;
        if ( prop )
        {
            WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data );
        }
        else
        {
            wxLogError( _("Create Parameter %s not found in declared RTTI Parameters"), name.c_str() );
        }
        map.erase( name );
    }
    { // Extra block for broken compilers
        for( wxPropertyInfoMap::iterator iter = map.begin(); iter != map.end(); ++iter )
        {
            const wxPropertyInfo* prop = iter->second;
            if ( prop->GetFlags() & wxPROP_OBJECT_GRAPH )
            {
                WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data );
            }
        }
    }
    { // Extra block for broken compilers
        for( wxPropertyInfoMap::iterator iter = map.begin(); iter != map.end(); ++iter )
        {
            const wxPropertyInfo* prop = iter->second;
            if ( !(prop->GetFlags() & wxPROP_OBJECT_GRAPH) )
            {
                WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data );
            }
        }
    }
}

class WXDLLIMPEXP_BASE wxObjectPropertyWriter: public wxObjectWriterFunctor
{
public:
    wxObjectPropertyWriter(const wxClassTypeInfo* cti,
        wxObjectWriterCallback *writercallback,
        wxObjectWriter* writer,
        wxStringToAnyHashMap &props) :
    m_cti(cti),m_persister(writercallback),m_writer(writer),m_props(props)
    {}

    virtual void operator()(const wxObject *vobj)
    {
        m_writer->WriteObject( vobj, (vobj ? vobj->GetClassInfo() : m_cti->GetClassInfo() ),
            m_persister, m_cti->GetKind()== wxT_OBJECT, m_props );
    }
private:
    const wxClassTypeInfo* m_cti;
    wxObjectWriterCallback *m_persister;
    wxObjectWriter* m_writer;
    wxStringToAnyHashMap& m_props;
};

void wxObjectWriter::WriteOneProperty( const wxObject *obj, const wxClassInfo* ci,
                                 const wxPropertyInfo* pi, wxObjectWriterCallback *writercallback,
                                 wxObjectWriterInternalPropertiesData *WXUNUSED(data) )
{
    if ( pi->GetFlags() & wxPROP_DONT_STREAM )
        return;

    // make sure that we are picking the correct object for accessing the property
    const wxDynamicObject* dynobj = wx_dynamic_cast(const wxDynamicObject*, obj );
    if ( dynobj && (wx_dynamic_cast(const wxDynamicClassInfo*, ci) == NULL) )
        obj = dynobj->GetSuperClassInstance();

    if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION )
    {
        wxAnyList data;
        pi->GetAccessor()->GetPropertyCollection(obj, data);
        const wxTypeInfo * elementType =
            wx_dynamic_cast( const wxCollectionTypeInfo*, pi->GetTypeInfo() )->GetElementType();
        if ( !data.empty() )
        {
            DoBeginWriteProperty( pi );
            for ( wxAnyList::const_iterator iter = data.begin(); iter != data.end(); ++iter )
            {
                DoBeginWriteElement();
                const wxAny* valptr = *iter;
                if ( writercallback->BeforeWriteProperty( this, obj, pi, *valptr ) )
                {
                    const wxClassTypeInfo* cti =
                        wx_dynamic_cast( const wxClassTypeInfo*, elementType );
                    if ( cti )
                    {
                        wxStringToAnyHashMap md;
                        wxObjectPropertyWriter pw(cti,writercallback,this, md);

                        const wxClassInfo* pci = cti->GetClassInfo();
                        pci->CallOnAny( *valptr, &pw);
                    }
                    else
                    {
                        DoWriteSimpleType( *valptr );
                    }
                }
                DoEndWriteElement();
            }
            DoEndWriteProperty( pi );
        }
    }
    else
    {
        const wxEventSourceTypeInfo* dti =
            wx_dynamic_cast( const wxEventSourceTypeInfo* , pi->GetTypeInfo() );
        if ( dti )
        {
            const wxObject* sink = NULL;
            const wxHandlerInfo *handler = NULL;

            const wxEvtHandler * evSource = wx_dynamic_cast(const wxEvtHandler *, obj);
            if ( evSource )
            {
                FindConnectEntry( evSource, dti, sink, handler );
                if ( writercallback->BeforeWriteDelegate( this, obj, ci, pi, sink, handler ) )
                {
                    if ( sink != NULL && handler != NULL )
                    {
                        DoBeginWriteProperty( pi );
                        if ( IsObjectKnown( sink ) )
                        {
                            DoWriteDelegate( obj, ci, pi, sink, GetObjectID( sink ),
                                             sink->GetClassInfo(), handler );
                            DoEndWriteProperty( pi );
                        }
                        else
                        {
                            wxLogError( wxT("Streaming delegates for not already ")
                                        wxT("streamed objects not yet supported") );
                        }
                    }
                }
            }
            else
            {
                wxLogError(_("Illegal Object Class (Non-wxEvtHandler) as Event Source") );
            }
        }
        else
        {
            wxAny value;
            pi->GetAccessor()->GetProperty(obj, value);

            // avoid streaming out void objects
            // TODO Verify
            if( value.IsNull() )
                return;

            if ( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
            {
                const wxEnumTypeInfo *eti =
                    wx_dynamic_cast(const wxEnumTypeInfo*,  pi->GetTypeInfo() );
                if ( eti )
                {
                    eti->ConvertFromLong( wxANY_AS(value, long ), value );
                }
                else
                {
                    wxLogError( _("Type must have enum - long conversion") );
                }
            }

            // avoid streaming out default values
            if ( pi->GetTypeInfo()->HasStringConverters() &&
                 !pi->GetDefaultValue().IsNull() ) // TODO Verify
            {
                if ( wxAnyGetAsString(value) == wxAnyGetAsString(pi->GetDefaultValue()) )
                    return;
            }

            // avoid streaming out null objects
            const wxClassTypeInfo* cti =
                wx_dynamic_cast( const wxClassTypeInfo* , pi->GetTypeInfo() );

            if ( cti && cti->GetKind() == wxT_OBJECT_PTR && wxAnyGetAsObjectPtr(value) == NULL )
                return;

            if ( writercallback->BeforeWriteProperty( this, obj, pi, value ) )
            {
                DoBeginWriteProperty( pi );
                if ( cti )
                {
                    if ( cti->HasStringConverters() )
                    {
                        wxString stringValue;
                        cti->ConvertToString( value, stringValue );
                        wxAny convertedValue(stringValue);
                        DoWriteSimpleType( convertedValue );
                    }
                    else
                    {
                        wxStringToAnyHashMap md;
                        wxObjectPropertyWriter pw(cti,writercallback,this, md);

                        const wxClassInfo* pci = cti->GetClassInfo();
                        pci->CallOnAny(value, &pw);
                    }
                }
                else
                {
                    DoWriteSimpleType( value );
                }
                DoEndWriteProperty( pi );
            }
        }
    }
}

int wxObjectWriter::GetObjectID(const wxObject *obj)
{
    if ( !IsObjectKnown( obj ) )
        return wxInvalidObjectID;

    return m_data->m_writtenObjects[obj];
}

bool wxObjectWriter::IsObjectKnown( const wxObject *obj )
{
    return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end();
}


// ----------------------------------------------------------------------------
// wxObjectReader
// ----------------------------------------------------------------------------

struct wxObjectReader::wxObjectReaderInternal
{
    map<int,wxClassInfo*> m_classInfos;
};

wxObjectReader::wxObjectReader()
{
    m_data = new wxObjectReaderInternal;
}

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

wxClassInfo* wxObjectReader::GetObjectClassInfo(int objectID)
{
    if ( objectID == wxNullObjectID || objectID == wxInvalidObjectID )
    {
        wxLogError( _("Invalid or Null Object ID passed to GetObjectClassInfo" ) );
        return NULL;
    }
    if ( m_data->m_classInfos.find(objectID) == m_data->m_classInfos.end() )
    {
        wxLogError( _("Unknown Object passed to GetObjectClassInfo" ) );
        return NULL;
    }
    return m_data->m_classInfos[objectID];
}

void wxObjectReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo )
{
    if ( objectID == wxNullObjectID || objectID == wxInvalidObjectID )
    {
        wxLogError( _("Invalid or Null Object ID passed to GetObjectClassInfo" ) );
        return;
    }
    if ( m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() )
    {
        wxLogError( _("Already Registered Object passed to SetObjectClassInfo" ) );
        return;
    }
    m_data->m_classInfos[objectID] = classInfo;
}

bool wxObjectReader::HasObjectClassInfo( int objectID )
{
    if ( objectID == wxNullObjectID || objectID == wxInvalidObjectID )
    {
        wxLogError( _("Invalid or Null Object ID passed to HasObjectClassInfo" ) );
        return false;
    }
    return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end();
}


// ----------------------------------------------------------------------------
// reading xml in
// ----------------------------------------------------------------------------

/*
Reading components has not to be extended for components
as properties are always sought by typeinfo over all levels
and create params are always toplevel class only
*/


// ----------------------------------------------------------------------------
// wxObjectRuntimeReaderCallback - depersisting to memory
// ----------------------------------------------------------------------------

struct wxObjectRuntimeReaderCallback::wxObjectRuntimeReaderCallbackInternal
{
    map<int,wxObject *> m_objects;

    void SetObject(int objectID, wxObject *obj )
    {
        if ( m_objects.find(objectID) != m_objects.end() )
        {
            wxLogError( _("Passing a already registered object to SetObject") );
            return ;
        }
        m_objects[objectID] = obj;
    }
    wxObject* GetObject( int objectID )
    {
        if ( objectID == wxNullObjectID )
            return NULL;
        if ( m_objects.find(objectID) == m_objects.end() )
        {
            wxLogError( _("Passing an unknown object to GetObject") );
            return NULL;
        }

        return m_objects[objectID];
    }
};

wxObjectRuntimeReaderCallback::wxObjectRuntimeReaderCallback()
{
    m_data = new wxObjectRuntimeReaderCallbackInternal();
}

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

void wxObjectRuntimeReaderCallback::AllocateObject(int objectID, wxClassInfo *classInfo,
                                          wxStringToAnyHashMap &WXUNUSED(metadata))
{
    wxObject *O;
    O = classInfo->CreateObject();
    m_data->SetObject(objectID, O);
}

void wxObjectRuntimeReaderCallback::CreateObject(int objectID,
                                        const wxClassInfo *classInfo,
                                        int paramCount,
                                        wxAny *params,
                                        int *objectIdValues,
                                        const wxClassInfo **objectClassInfos,
                                        wxStringToAnyHashMap &WXUNUSED(metadata))
{
    wxObject *o;
    o = m_data->GetObject(objectID);
    for ( int i = 0; i < paramCount; ++i )
    {
        if ( objectIdValues[i] != wxInvalidObjectID )
        {
            wxObject *o;
            o = m_data->GetObject(objectIdValues[i]);
            // if this is a dynamic object and we are asked for another class
            // than wxDynamicObject we cast it down manually.
            wxDynamicObject *dyno = wx_dynamic_cast( wxDynamicObject *, o);
            if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
            {
                o = dyno->GetSuperClassInstance();
            }
            params[i] = objectClassInfos[i]->ObjectPtrToAny(o);
        }
    }
    classInfo->Create(o, paramCount, params);
}

void wxObjectRuntimeReaderCallback::ConstructObject(int objectID,
                                        const wxClassInfo *classInfo,
                                        int paramCount,
                                        wxAny *params,
                                        int *objectIdValues,
                                        const wxClassInfo **objectClassInfos,
                                        wxStringToAnyHashMap &WXUNUSED(metadata))
{
    wxObject *o;
    for ( int i = 0; i < paramCount; ++i )
    {
        if ( objectIdValues[i] != wxInvalidObjectID )
        {
            wxObject *o;
            o = m_data->GetObject(objectIdValues[i]);
            // if this is a dynamic object and we are asked for another class
            // than wxDynamicObject we cast it down manually.
            wxDynamicObject *dyno = wx_dynamic_cast( wxDynamicObject *, o);
            if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
            {
                o = dyno->GetSuperClassInstance();
            }
            params[i] = objectClassInfos[i]->ObjectPtrToAny(o);
        }
    }
    o = classInfo->ConstructObject(paramCount, params);
    m_data->SetObject(objectID, o);
}


void wxObjectRuntimeReaderCallback::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
{
    wxObject *o;
    o = m_data->GetObject(objectID);
    delete o;
}

void wxObjectRuntimeReaderCallback::SetProperty(int objectID,
                                       const wxClassInfo *classInfo,
                                       const wxPropertyInfo* propertyInfo,
                                       const wxAny &value)
{
    wxObject *o;
    o = m_data->GetObject(objectID);
    classInfo->SetProperty( o, propertyInfo->GetName().c_str(), value );
}

void wxObjectRuntimeReaderCallback::SetPropertyAsObject(int objectID,
                                               const wxClassInfo *classInfo,
                                               const wxPropertyInfo* propertyInfo,
                                               int valueObjectId)
{
    wxObject *o, *valo;
    o = m_data->GetObject(objectID);
    valo = m_data->GetObject(valueObjectId);
    const wxClassInfo* valClassInfo =
        (wx_dynamic_cast(const wxClassTypeInfo*,propertyInfo->GetTypeInfo()))->GetClassInfo();

    // if this is a dynamic object and we are asked for another class
    // than wxDynamicObject we cast it down manually.
    wxDynamicObject *dynvalo = wx_dynamic_cast( wxDynamicObject *, valo);
    if ( dynvalo!=NULL  && (valClassInfo != dynvalo->GetClassInfo()) )
    {
        valo = dynvalo->GetSuperClassInstance();
    }

    classInfo->SetProperty( o, propertyInfo->GetName().c_str(),
                            valClassInfo->ObjectPtrToAny(valo) );
}

void wxObjectRuntimeReaderCallback::SetConnect(int eventSourceObjectID,
                                      const wxClassInfo *WXUNUSED(eventSourceClassInfo),
                                      const wxPropertyInfo *delegateInfo,
                                      const wxClassInfo *WXUNUSED(eventSinkClassInfo),
                                      const wxHandlerInfo* handlerInfo,
                                      int eventSinkObjectID )
{
    wxEvtHandler *ehsource =
        wx_dynamic_cast( wxEvtHandler* , m_data->GetObject( eventSourceObjectID ) );
    wxEvtHandler *ehsink =
        wx_dynamic_cast( wxEvtHandler *,m_data->GetObject(eventSinkObjectID) );

    if ( ehsource && ehsink )
    {
        const wxEventSourceTypeInfo *delegateTypeInfo =
            wx_dynamic_cast(const wxEventSourceTypeInfo*,delegateInfo->GetTypeInfo());
        if( delegateTypeInfo && delegateTypeInfo->GetLastEventType() == -1 )
        {
            ehsource->Connect( -1, delegateTypeInfo->GetEventType(),
                handlerInfo->GetEventFunction(), NULL /*user data*/,
                ehsink );
        }
        else
        {
            for ( wxEventType iter = delegateTypeInfo->GetEventType();
                  iter <= delegateTypeInfo->GetLastEventType(); ++iter )
            {
                ehsource->Connect( -1, iter,
                    handlerInfo->GetEventFunction(), NULL /*user data*/,
                    ehsink );
            }
        }
    }
}

wxObject *wxObjectRuntimeReaderCallback::GetObject(int objectID)
{
    return m_data->GetObject( objectID );
}

void wxObjectRuntimeReaderCallback::AddToPropertyCollection( int objectID,
                                                   const wxClassInfo *classInfo,
                                                   const wxPropertyInfo* propertyInfo,
                                                   const wxAny &value)
{
    wxObject *o;
    o = m_data->GetObject(objectID);
    classInfo->AddToPropertyCollection( o, propertyInfo->GetName().c_str(), value );
}

void wxObjectRuntimeReaderCallback::AddToPropertyCollectionAsObject(int objectID,
                                                           const wxClassInfo *classInfo,
                                                           const wxPropertyInfo* propertyInfo,
                                                           int valueObjectId)
{
    wxObject *o, *valo;
    o = m_data->GetObject(objectID);
    valo = m_data->GetObject(valueObjectId);
    const wxCollectionTypeInfo * collectionTypeInfo =
        wx_dynamic_cast( const wxCollectionTypeInfo *, propertyInfo->GetTypeInfo() );
    const wxClassInfo* valClassInfo =
        (wx_dynamic_cast(const wxClassTypeInfo*,collectionTypeInfo->GetElementType()))->GetClassInfo();

    // if this is a dynamic object and we are asked for another class
    // than wxDynamicObject we cast it down manually.
    wxDynamicObject *dynvalo = wx_dynamic_cast( wxDynamicObject *, valo);
    if ( dynvalo!=NULL  && (valClassInfo != dynvalo->GetClassInfo()) )
    {
        valo = dynvalo->GetSuperClassInstance();
    }

    classInfo->AddToPropertyCollection( o, propertyInfo->GetName().c_str(),
                                        valClassInfo->ObjectPtrToAny(valo) );
}

#endif // wxUSE_EXTENDED_RTTI
Commit	Line	Data
	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	// Copyright: (c) 2003 Stefan Csomor
	8	// Licence: wxWindows licence
	9	/////////////////////////////////////////////////////////////////////////////
	10
	11	// For compilers that support precompilation, includes "wx.h".
	12	#include "wx/wxprec.h"
	13
	14	#ifdef __BORLANDC__
	15	#pragma hdrstop
	16	#endif
	17
	18	#if wxUSE_EXTENDED_RTTI
	19
	20	#include "wx/xtistrm.h"
	21
	22	#ifndef WX_PRECOMP
	23	#include "wx/object.h"
	24	#include "wx/hash.h"
	25	#include "wx/event.h"
	26	#endif
	27
	28	#include "wx/tokenzr.h"
	29	#include "wx/txtstrm.h"
	30
	31	// STL headers:
	32
	33	#include "wx/beforestd.h"
	34	#include <map>
	35	#include <vector>
	36	#include <string>
	37	#include "wx/afterstd.h"
	38	using namespace std;
	39
	40
	41	// ----------------------------------------------------------------------------
	42	// wxObjectWriter
	43	// ----------------------------------------------------------------------------
	44
	45	struct wxObjectWriter::wxObjectWriterInternal
	46	{
	47	map< const wxObject*, int > m_writtenObjects;
	48	int m_nextId;
	49	};
	50
	51	wxObjectWriter::wxObjectWriter()
	52	{
	53	m_data = new wxObjectWriterInternal;
	54	m_data->m_nextId = 0;
	55	}
	56
	57	wxObjectWriter::~wxObjectWriter()
	58	{
	59	delete m_data;
	60	}
	61
	62	struct wxObjectWriter::wxObjectWriterInternalPropertiesData
	63	{
	64	char nothing;
	65	};
	66
	67	void wxObjectWriter::ClearObjectContext()
	68	{
	69	delete m_data;
	70	m_data = new wxObjectWriterInternal();
	71	m_data->m_nextId = 0;
	72	}
	73
	74	void wxObjectWriter::WriteObject(const wxObject object, const wxClassInfo classInfo,
	75	wxObjectWriterCallback *writercallback, const wxString &name,
	76	const wxStringToAnyHashMap &metadata )
	77	{
	78	DoBeginWriteTopLevelEntry( name );
	79	WriteObject( object, classInfo, writercallback, false, metadata);
	80	DoEndWriteTopLevelEntry( name );
	81	}
	82
	83	void wxObjectWriter::WriteObject(const wxObject object, const wxClassInfo classInfo,
	84	wxObjectWriterCallback *writercallback, bool isEmbedded,
	85	const wxStringToAnyHashMap &metadata )
	86	{
	87	if ( !classInfo->BeforeWriteObject( object, this, writercallback, metadata) )
	88	return;
	89
	90	if ( writercallback->BeforeWriteObject( this, object, classInfo, metadata) )
	91	{
	92	if ( object == NULL )
	93	DoWriteNullObject();
	94	else if ( IsObjectKnown( object ) )
	95	DoWriteRepeatedObject( GetObjectID(object) );
	96	else
	97	{
	98	int oid = m_data->m_nextId++;
	99	if ( !isEmbedded )
	100	m_data->m_writtenObjects[object] = oid;
	101
	102	// in case this object is a wxDynamicObject we also have to insert is superclass
	103	// instance with the same id, so that object relations are streamed out correctly
	104	const wxDynamicObject* dynobj = wx_dynamic_cast(const wxDynamicObject*, object);
	105	if ( !isEmbedded && dynobj )
	106	m_data->m_writtenObjects[dynobj->GetSuperClassInstance()] = oid;
	107
	108	DoBeginWriteObject( object, classInfo, oid, metadata );
	109	wxObjectWriterInternalPropertiesData data;
	110	WriteAllProperties( object, classInfo, writercallback, &data );
	111	DoEndWriteObject( object, classInfo, oid );
	112	}
	113	writercallback->AfterWriteObject( this,object, classInfo );
	114	}
	115	}
	116
	117	void wxObjectWriter::FindConnectEntry(const wxEvtHandler * evSource,
	118	const wxEventSourceTypeInfo* dti,
	119	const wxObject* &sink,
	120	const wxHandlerInfo *&handler)
	121	{
	122	wxList *dynamicEvents = evSource->GetDynamicEventTable();
	123
	124	if ( dynamicEvents )
	125	{
	126	for ( wxList::const_iterator node = dynamicEvents->begin(); node != dynamicEvents->end(); ++node )
	127	{
	128	wxDynamicEventTableEntry entry = (wxDynamicEventTableEntry)(*node);
	129
	130	// find the match
	131	if ( entry->m_fn &&
	132	(dti->GetEventType() == entry->m_eventType) &&
	133	(entry->m_id == -1 ) &&
	134	(entry->m_fn->GetEvtHandler() != NULL ) )
	135	{
	136	sink = entry->m_fn->GetEvtHandler();
	137	const wxClassInfo* sinkClassInfo = sink->GetClassInfo();
	138	const wxHandlerInfo* sinkHandler = sinkClassInfo->GetFirstHandler();
	139	while ( sinkHandler )
	140	{
	141	if ( sinkHandler->GetEventFunction() == entry->m_fn->GetEvtMethod() )
	142	{
	143	handler = sinkHandler;
	144	break;
	145	}
	146	sinkHandler = sinkHandler->GetNext();
	147	}
	148	break;
	149	}
	150	}
	151	}
	152	}
	153	void wxObjectWriter::WriteAllProperties( const wxObject * obj, const wxClassInfo* ci,
	154	wxObjectWriterCallback *writercallback,
	155	wxObjectWriterInternalPropertiesData * data )
	156	{
	157	wxPropertyInfoMap map;
	158	ci->GetProperties( map );
	159	for ( int i = 0; i < ci->GetCreateParamCount(); ++i )
	160	{
	161	wxString name = ci->GetCreateParamName(i);
	162	wxPropertyInfoMap::const_iterator iter = map.find(name);
	163	const wxPropertyInfo* prop = iter == map.end() ? NULL : iter->second;
	164	if ( prop )
	165	{
	166	WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data );
	167	}
	168	else
	169	{
	170	wxLogError( _("Create Parameter %s not found in declared RTTI Parameters"), name.c_str() );
	171	}
	172	map.erase( name );
	173	}
	174	{ // Extra block for broken compilers
	175	for( wxPropertyInfoMap::iterator iter = map.begin(); iter != map.end(); ++iter )
	176	{
	177	const wxPropertyInfo* prop = iter->second;
	178	if ( prop->GetFlags() & wxPROP_OBJECT_GRAPH )
	179	{
	180	WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data );
	181	}
	182	}
	183	}
	184	{ // Extra block for broken compilers
	185	for( wxPropertyInfoMap::iterator iter = map.begin(); iter != map.end(); ++iter )
	186	{
	187	const wxPropertyInfo* prop = iter->second;
	188	if ( !(prop->GetFlags() & wxPROP_OBJECT_GRAPH) )
	189	{
	190	WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data );
	191	}
	192	}
	193	}
	194	}
	195
	196	class WXDLLIMPEXP_BASE wxObjectPropertyWriter: public wxObjectWriterFunctor
	197	{
	198	public:
	199	wxObjectPropertyWriter(const wxClassTypeInfo* cti,
	200	wxObjectWriterCallback *writercallback,
	201	wxObjectWriter* writer,
	202	wxStringToAnyHashMap &props) :
	203	m_cti(cti),m_persister(writercallback),m_writer(writer),m_props(props)
	204	{}
	205
	206	virtual void operator()(const wxObject *vobj)
	207	{
	208	m_writer->WriteObject( vobj, (vobj ? vobj->GetClassInfo() : m_cti->GetClassInfo() ),
	209	m_persister, m_cti->GetKind()== wxT_OBJECT, m_props );
	210	}
	211	private:
	212	const wxClassTypeInfo* m_cti;
	213	wxObjectWriterCallback *m_persister;
	214	wxObjectWriter* m_writer;
	215	wxStringToAnyHashMap& m_props;
	216	};
	217
	218	void wxObjectWriter::WriteOneProperty( const wxObject obj, const wxClassInfo ci,
	219	const wxPropertyInfo* pi, wxObjectWriterCallback *writercallback,
	220	wxObjectWriterInternalPropertiesData *WXUNUSED(data) )
	221	{
	222	if ( pi->GetFlags() & wxPROP_DONT_STREAM )
	223	return;
	224
	225	// make sure that we are picking the correct object for accessing the property
	226	const wxDynamicObject* dynobj = wx_dynamic_cast(const wxDynamicObject*, obj );
	227	if ( dynobj && (wx_dynamic_cast(const wxDynamicClassInfo*, ci) == NULL) )
	228	obj = dynobj->GetSuperClassInstance();
	229
	230	if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION )
	231	{
	232	wxAnyList data;
	233	pi->GetAccessor()->GetPropertyCollection(obj, data);
	234	const wxTypeInfo * elementType =
	235	wx_dynamic_cast( const wxCollectionTypeInfo*, pi->GetTypeInfo() )->GetElementType();
	236	if ( !data.empty() )
	237	{
	238	DoBeginWriteProperty( pi );
	239	for ( wxAnyList::const_iterator iter = data.begin(); iter != data.end(); ++iter )
	240	{
	241	DoBeginWriteElement();
	242	const wxAny* valptr = *iter;
	243	if ( writercallback->BeforeWriteProperty( this, obj, pi, *valptr ) )
	244	{
	245	const wxClassTypeInfo* cti =
	246	wx_dynamic_cast( const wxClassTypeInfo*, elementType );
	247	if ( cti )
	248	{
	249	wxStringToAnyHashMap md;
	250	wxObjectPropertyWriter pw(cti,writercallback,this, md);
	251
	252	const wxClassInfo* pci = cti->GetClassInfo();
	253	pci->CallOnAny( *valptr, &pw);
	254	}
	255	else
	256	{
	257	DoWriteSimpleType( *valptr );
	258	}
	259	}
	260	DoEndWriteElement();
	261	}
	262	DoEndWriteProperty( pi );
	263	}
	264	}
	265	else
	266	{
	267	const wxEventSourceTypeInfo* dti =
	268	wx_dynamic_cast( const wxEventSourceTypeInfo* , pi->GetTypeInfo() );
	269	if ( dti )
	270	{
	271	const wxObject* sink = NULL;
	272	const wxHandlerInfo *handler = NULL;
	273
	274	const wxEvtHandler * evSource = wx_dynamic_cast(const wxEvtHandler *, obj);
	275	if ( evSource )
	276	{
	277	FindConnectEntry( evSource, dti, sink, handler );
	278	if ( writercallback->BeforeWriteDelegate( this, obj, ci, pi, sink, handler ) )
	279	{
	280	if ( sink != NULL && handler != NULL )
	281	{
	282	DoBeginWriteProperty( pi );
	283	if ( IsObjectKnown( sink ) )
	284	{
	285	DoWriteDelegate( obj, ci, pi, sink, GetObjectID( sink ),
	286	sink->GetClassInfo(), handler );
	287	DoEndWriteProperty( pi );
	288	}
	289	else
	290	{
	291	wxLogError( wxT("Streaming delegates for not already ")
	292	wxT("streamed objects not yet supported") );
	293	}
	294	}
	295	}
	296	}
	297	else
	298	{
	299	wxLogError(_("Illegal Object Class (Non-wxEvtHandler) as Event Source") );
	300	}
	301	}
	302	else
	303	{
	304	wxAny value;
	305	pi->GetAccessor()->GetProperty(obj, value);
	306
	307	// avoid streaming out void objects
	308	// TODO Verify
	309	if( value.IsNull() )
	310	return;
	311
	312	if ( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
	313	{
	314	const wxEnumTypeInfo *eti =
	315	wx_dynamic_cast(const wxEnumTypeInfo*, pi->GetTypeInfo() );
	316	if ( eti )
	317	{
	318	eti->ConvertFromLong( wxANY_AS(value, long ), value );
	319	}
	320	else
	321	{
	322	wxLogError( _("Type must have enum - long conversion") );
	323	}
	324	}
	325
	326	// avoid streaming out default values
	327	if ( pi->GetTypeInfo()->HasStringConverters() &&
	328	!pi->GetDefaultValue().IsNull() ) // TODO Verify
	329	{
	330	if ( wxAnyGetAsString(value) == wxAnyGetAsString(pi->GetDefaultValue()) )
	331	return;
	332	}
	333
	334	// avoid streaming out null objects
	335	const wxClassTypeInfo* cti =
	336	wx_dynamic_cast( const wxClassTypeInfo* , pi->GetTypeInfo() );
	337
	338	if ( cti && cti->GetKind() == wxT_OBJECT_PTR && wxAnyGetAsObjectPtr(value) == NULL )
	339	return;
	340
	341	if ( writercallback->BeforeWriteProperty( this, obj, pi, value ) )
	342	{
	343	DoBeginWriteProperty( pi );
	344	if ( cti )
	345	{
	346	if ( cti->HasStringConverters() )
	347	{
	348	wxString stringValue;
	349	cti->ConvertToString( value, stringValue );
	350	wxAny convertedValue(stringValue);
	351	DoWriteSimpleType( convertedValue );
	352	}
	353	else
	354	{
	355	wxStringToAnyHashMap md;
	356	wxObjectPropertyWriter pw(cti,writercallback,this, md);
	357
	358	const wxClassInfo* pci = cti->GetClassInfo();
	359	pci->CallOnAny(value, &pw);
	360	}
	361	}
	362	else
	363	{
	364	DoWriteSimpleType( value );
	365	}
	366	DoEndWriteProperty( pi );
	367	}
	368	}
	369	}
	370	}
	371
	372	int wxObjectWriter::GetObjectID(const wxObject *obj)
	373	{
	374	if ( !IsObjectKnown( obj ) )
	375	return wxInvalidObjectID;
	376
	377	return m_data->m_writtenObjects[obj];
	378	}
	379
	380	bool wxObjectWriter::IsObjectKnown( const wxObject *obj )
	381	{
	382	return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end();
	383	}
	384
	385
	386	// ----------------------------------------------------------------------------
	387	// wxObjectReader
	388	// ----------------------------------------------------------------------------
	389
	390	struct wxObjectReader::wxObjectReaderInternal
	391	{
	392	map<int,wxClassInfo*> m_classInfos;
	393	};
	394
	395	wxObjectReader::wxObjectReader()
	396	{
	397	m_data = new wxObjectReaderInternal;
	398	}
	399
	400	wxObjectReader::~wxObjectReader()
	401	{
	402	delete m_data;
	403	}
	404
	405	wxClassInfo* wxObjectReader::GetObjectClassInfo(int objectID)
	406	{
	407	if ( objectID == wxNullObjectID \|\| objectID == wxInvalidObjectID )
	408	{
	409	wxLogError( _("Invalid or Null Object ID passed to GetObjectClassInfo" ) );
	410	return NULL;
	411	}
	412	if ( m_data->m_classInfos.find(objectID) == m_data->m_classInfos.end() )
	413	{
	414	wxLogError( _("Unknown Object passed to GetObjectClassInfo" ) );
	415	return NULL;
	416	}
	417	return m_data->m_classInfos[objectID];
	418	}
	419
	420	void wxObjectReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo )
	421	{
	422	if ( objectID == wxNullObjectID \|\| objectID == wxInvalidObjectID )
	423	{
	424	wxLogError( _("Invalid or Null Object ID passed to GetObjectClassInfo" ) );
	425	return;
	426	}
	427	if ( m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() )
	428	{
	429	wxLogError( _("Already Registered Object passed to SetObjectClassInfo" ) );
	430	return;
	431	}
	432	m_data->m_classInfos[objectID] = classInfo;
	433	}
	434
	435	bool wxObjectReader::HasObjectClassInfo( int objectID )
	436	{
	437	if ( objectID == wxNullObjectID \|\| objectID == wxInvalidObjectID )
	438	{
	439	wxLogError( _("Invalid or Null Object ID passed to HasObjectClassInfo" ) );
	440	return false;
	441	}
	442	return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end();
	443	}
	444
	445
	446	// ----------------------------------------------------------------------------
	447	// reading xml in
	448	// ----------------------------------------------------------------------------
	449
	450	/*
	451	Reading components has not to be extended for components
	452	as properties are always sought by typeinfo over all levels
	453	and create params are always toplevel class only
	454	*/
	455
	456
	457	// ----------------------------------------------------------------------------
	458	// wxObjectRuntimeReaderCallback - depersisting to memory
	459	// ----------------------------------------------------------------------------
	460
	461	struct wxObjectRuntimeReaderCallback::wxObjectRuntimeReaderCallbackInternal
	462	{
	463	map<int,wxObject *> m_objects;
	464
	465	void SetObject(int objectID, wxObject *obj )
	466	{
	467	if ( m_objects.find(objectID) != m_objects.end() )
	468	{
	469	wxLogError( _("Passing a already registered object to SetObject") );
	470	return ;
	471	}
	472	m_objects[objectID] = obj;
	473	}
	474	wxObject* GetObject( int objectID )
	475	{
	476	if ( objectID == wxNullObjectID )
	477	return NULL;
	478	if ( m_objects.find(objectID) == m_objects.end() )
	479	{
	480	wxLogError( _("Passing an unknown object to GetObject") );
	481	return NULL;
	482	}
	483
	484	return m_objects[objectID];
	485	}
	486	};
	487
	488	wxObjectRuntimeReaderCallback::wxObjectRuntimeReaderCallback()
	489	{
	490	m_data = new wxObjectRuntimeReaderCallbackInternal();
	491	}
	492
	493	wxObjectRuntimeReaderCallback::~wxObjectRuntimeReaderCallback()
	494	{
	495	delete m_data;
	496	}
	497
	498	void wxObjectRuntimeReaderCallback::AllocateObject(int objectID, wxClassInfo *classInfo,
	499	wxStringToAnyHashMap &WXUNUSED(metadata))
	500	{
	501	wxObject *O;
	502	O = classInfo->CreateObject();
	503	m_data->SetObject(objectID, O);
	504	}
	505
	506	void wxObjectRuntimeReaderCallback::CreateObject(int objectID,
	507	const wxClassInfo *classInfo,
	508	int paramCount,
	509	wxAny *params,
	510	int *objectIdValues,
	511	const wxClassInfo **objectClassInfos,
	512	wxStringToAnyHashMap &WXUNUSED(metadata))
	513	{
	514	wxObject *o;
	515	o = m_data->GetObject(objectID);
	516	for ( int i = 0; i < paramCount; ++i )
	517	{
	518	if ( objectIdValues[i] != wxInvalidObjectID )
	519	{
	520	wxObject *o;
	521	o = m_data->GetObject(objectIdValues[i]);
	522	// if this is a dynamic object and we are asked for another class
	523	// than wxDynamicObject we cast it down manually.
	524	wxDynamicObject dyno = wx_dynamic_cast( wxDynamicObject , o);
	525	if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
	526	{
	527	o = dyno->GetSuperClassInstance();
	528	}
	529	params[i] = objectClassInfos[i]->ObjectPtrToAny(o);
	530	}
	531	}
	532	classInfo->Create(o, paramCount, params);
	533	}
	534
	535	void wxObjectRuntimeReaderCallback::ConstructObject(int objectID,
	536	const wxClassInfo *classInfo,
	537	int paramCount,
	538	wxAny *params,
	539	int *objectIdValues,
	540	const wxClassInfo **objectClassInfos,
	541	wxStringToAnyHashMap &WXUNUSED(metadata))
	542	{
	543	wxObject *o;
	544	for ( int i = 0; i < paramCount; ++i )
	545	{
	546	if ( objectIdValues[i] != wxInvalidObjectID )
	547	{
	548	wxObject *o;
	549	o = m_data->GetObject(objectIdValues[i]);
	550	// if this is a dynamic object and we are asked for another class
	551	// than wxDynamicObject we cast it down manually.
	552	wxDynamicObject dyno = wx_dynamic_cast( wxDynamicObject , o);
	553	if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
	554	{
	555	o = dyno->GetSuperClassInstance();
	556	}
	557	params[i] = objectClassInfos[i]->ObjectPtrToAny(o);
	558	}
	559	}
	560	o = classInfo->ConstructObject(paramCount, params);
	561	m_data->SetObject(objectID, o);
	562	}
	563
	564
	565	void wxObjectRuntimeReaderCallback::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
	566	{
	567	wxObject *o;
	568	o = m_data->GetObject(objectID);
	569	delete o;
	570	}
	571
	572	void wxObjectRuntimeReaderCallback::SetProperty(int objectID,
	573	const wxClassInfo *classInfo,
	574	const wxPropertyInfo* propertyInfo,
	575	const wxAny &value)
	576	{
	577	wxObject *o;
	578	o = m_data->GetObject(objectID);
	579	classInfo->SetProperty( o, propertyInfo->GetName().c_str(), value );
	580	}
	581
	582	void wxObjectRuntimeReaderCallback::SetPropertyAsObject(int objectID,
	583	const wxClassInfo *classInfo,
	584	const wxPropertyInfo* propertyInfo,
	585	int valueObjectId)
	586	{
	587	wxObject o, valo;
	588	o = m_data->GetObject(objectID);
	589	valo = m_data->GetObject(valueObjectId);
	590	const wxClassInfo* valClassInfo =
	591	(wx_dynamic_cast(const wxClassTypeInfo*,propertyInfo->GetTypeInfo()))->GetClassInfo();
	592
	593	// if this is a dynamic object and we are asked for another class
	594	// than wxDynamicObject we cast it down manually.
	595	wxDynamicObject dynvalo = wx_dynamic_cast( wxDynamicObject , valo);
	596	if ( dynvalo!=NULL && (valClassInfo != dynvalo->GetClassInfo()) )
	597	{
	598	valo = dynvalo->GetSuperClassInstance();
	599	}
	600
	601	classInfo->SetProperty( o, propertyInfo->GetName().c_str(),
	602	valClassInfo->ObjectPtrToAny(valo) );
	603	}
	604
	605	void wxObjectRuntimeReaderCallback::SetConnect(int eventSourceObjectID,
	606	const wxClassInfo *WXUNUSED(eventSourceClassInfo),
	607	const wxPropertyInfo *delegateInfo,
	608	const wxClassInfo *WXUNUSED(eventSinkClassInfo),
	609	const wxHandlerInfo* handlerInfo,
	610	int eventSinkObjectID )
	611	{
	612	wxEvtHandler *ehsource =
	613	wx_dynamic_cast( wxEvtHandler* , m_data->GetObject( eventSourceObjectID ) );
	614	wxEvtHandler *ehsink =
	615	wx_dynamic_cast( wxEvtHandler *,m_data->GetObject(eventSinkObjectID) );
	616
	617	if ( ehsource && ehsink )
	618	{
	619	const wxEventSourceTypeInfo *delegateTypeInfo =
	620	wx_dynamic_cast(const wxEventSourceTypeInfo*,delegateInfo->GetTypeInfo());
	621	if( delegateTypeInfo && delegateTypeInfo->GetLastEventType() == -1 )
	622	{
	623	ehsource->Connect( -1, delegateTypeInfo->GetEventType(),
	624	handlerInfo->GetEventFunction(), NULL /user data/,
	625	ehsink );
	626	}
	627	else
	628	{
	629	for ( wxEventType iter = delegateTypeInfo->GetEventType();
	630	iter <= delegateTypeInfo->GetLastEventType(); ++iter )
	631	{
	632	ehsource->Connect( -1, iter,
	633	handlerInfo->GetEventFunction(), NULL /user data/,
	634	ehsink );
	635	}
	636	}
	637	}
	638	}
	639
	640	wxObject *wxObjectRuntimeReaderCallback::GetObject(int objectID)
	641	{
	642	return m_data->GetObject( objectID );
	643	}
	644
	645	void wxObjectRuntimeReaderCallback::AddToPropertyCollection( int objectID,
	646	const wxClassInfo *classInfo,
	647	const wxPropertyInfo* propertyInfo,
	648	const wxAny &value)
	649	{
	650	wxObject *o;
	651	o = m_data->GetObject(objectID);
	652	classInfo->AddToPropertyCollection( o, propertyInfo->GetName().c_str(), value );
	653	}
	654
	655	void wxObjectRuntimeReaderCallback::AddToPropertyCollectionAsObject(int objectID,
	656	const wxClassInfo *classInfo,
	657	const wxPropertyInfo* propertyInfo,
	658	int valueObjectId)
	659	{
	660	wxObject o, valo;
	661	o = m_data->GetObject(objectID);
	662	valo = m_data->GetObject(valueObjectId);
	663	const wxCollectionTypeInfo * collectionTypeInfo =
	664	wx_dynamic_cast( const wxCollectionTypeInfo *, propertyInfo->GetTypeInfo() );
	665	const wxClassInfo* valClassInfo =
	666	(wx_dynamic_cast(const wxClassTypeInfo*,collectionTypeInfo->GetElementType()))->GetClassInfo();
	667
	668	// if this is a dynamic object and we are asked for another class
	669	// than wxDynamicObject we cast it down manually.
	670	wxDynamicObject dynvalo = wx_dynamic_cast( wxDynamicObject , valo);
	671	if ( dynvalo!=NULL && (valClassInfo != dynvalo->GetClassInfo()) )
	672	{
	673	valo = dynvalo->GetSuperClassInstance();
	674	}
	675
	676	classInfo->AddToPropertyCollection( o, propertyInfo->GetName().c_str(),
	677	valClassInfo->ObjectPtrToAny(valo) );
	678	}
	679
	680	#endif // wxUSE_EXTENDED_RTTI