src/common/xtistrm.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

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