]> git.saurik.com Git - wxWidgets.git/blobdiff - src/common/xtistrm.cpp
projects / wxWidgets.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
better ownership handling
[wxWidgets.git] / src / common / xtistrm.cpp
diff --git a/src/common/xtistrm.cpp b/src/common/xtistrm.cpp
index bdd76724bd2831109fcd199dc7b97404a11b404e..9f0860b933594d044ebcf9cd3234850896e78a82 100644 (file)
--- a/src/common/xtistrm.cpp
+++ b/src/common/xtistrm.cpp
@@ -1,325 +1,454 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/common/xtistrm.cpp
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/common/xtistrm.cpp
-// Purpose:     streaming runtime metadata information 
+// Purpose:     streaming runtime metadata information
 // Author:      Stefan Csomor
 // Author:      Stefan Csomor
-// Modified by: 
+// Modified by:
 // Created:     27/07/03
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 Stefan Csomor
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Created:     27/07/03
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 Stefan Csomor
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#pragma implementation "xtistrm.h"
-#endif
-
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__
-#pragma hdrstop
+    #pragma hdrstop
 #endif
 
 #endif
 
+#if wxUSE_EXTENDED_RTTI
+
+#include "wx/xtistrm.h"
+
 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP
-#include "wx/hash.h"
-#include "wx/object.h"
+    #include "wx/object.h"
+    #include "wx/hash.h"
+    #include "wx/event.h"
 #endif
 
 #include "wx/tokenzr.h"
 #endif
 
 #include "wx/tokenzr.h"
-#include "wx/xtistrm.h"
 #include "wx/txtstrm.h"
 #include "wx/txtstrm.h"
-#include "wx/event.h"
 
 
-#if wxUSE_EXTENDED_RTTI
+// STL headers:
 
 #include "wx/beforestd.h"
 #include <map>
 #include <vector>
 #include <string>
 #include "wx/afterstd.h"
 
 #include "wx/beforestd.h"
 #include <map>
 #include <vector>
 #include <string>
 #include "wx/afterstd.h"
+using namespace std;
+
 
 
-using namespace std ;
+// ----------------------------------------------------------------------------
+// wxObjectWriter
+// ----------------------------------------------------------------------------
 
 
-struct wxWriter::wxWriterInternal
+struct wxObjectWriter::wxObjectWriterInternal
 {
 {
-    map< const wxObject* , int > m_writtenObjects ;
-    int m_nextId ;
-} ;
+    map< const wxObject*, int > m_writtenObjects;
+    int m_nextId;
+};
 
 
-wxWriter::wxWriter()
+wxObjectWriter::wxObjectWriter()
 {
 {
-    m_data = new wxWriterInternal ;
-    m_data->m_nextId = 0 ;
+    m_data = new wxObjectWriterInternal;
+    m_data->m_nextId = 0;
 }
 
 }
 
-wxWriter::~wxWriter()
+wxObjectWriter::~wxObjectWriter()
 {
 {
-    delete m_data ;
+    delete m_data;
 }
 
 }
 
-struct wxWriter::wxWriterInternalPropertiesData
+struct wxObjectWriter::wxObjectWriterInternalPropertiesData
 {
 {
-    char nothing ;
-} ;
+    char nothing;
+};
 
 
-void wxWriter::ClearObjectContext()
+void wxObjectWriter::ClearObjectContext()
 {
 {
-    delete m_data ;
-    m_data = new wxWriterInternal() ;
-    m_data->m_nextId = 0 ;
+    delete m_data;
+    m_data = new wxObjectWriterInternal();
+    m_data->m_nextId = 0;
 }
 
 }
 
-void wxWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo , wxPersister *persister , const wxString &name , wxxVariantArray &metadata )
+void wxObjectWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo, 
+                           wxObjectWriterCallback *writercallback, const wxString &name, 
+                           const wxStringToAnyHashMap &metadata )
 {
 {
-    DoBeginWriteTopLevelEntry( name ) ;
-    WriteObject( object , classInfo , persister , false , metadata) ;
-    DoEndWriteTopLevelEntry( name ) ;
+    DoBeginWriteTopLevelEntry( name );
+    WriteObject( object, classInfo, writercallback, false, metadata);
+    DoEndWriteTopLevelEntry( name );
 }
 
 }
 
-void wxWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo , wxPersister *persister , bool isEmbedded, wxxVariantArray &metadata )
+void wxObjectWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo, 
+                           wxObjectWriterCallback *writercallback, bool isEmbedded, 
+                           const wxStringToAnyHashMap &metadata )
 {
 {
-    if ( !classInfo->BeforeWriteObject( object , this , persister , metadata) )
-        return ;
+    if ( !classInfo->BeforeWriteObject( object, this, writercallback, metadata) )
+        return;
 
 
-    if ( persister->BeforeWriteObject( this , object , classInfo , metadata) )
+    if ( writercallback->BeforeWriteObject( this, object, classInfo, metadata) )
     {
         if ( object == NULL )
     {
         if ( object == NULL )
-            DoWriteNullObject() ;
+            DoWriteNullObject();
         else if ( IsObjectKnown( object ) )
         else if ( IsObjectKnown( object ) )
-            DoWriteRepeatedObject( GetObjectID(object) ) ;
+            DoWriteRepeatedObject( GetObjectID(object) );
         else
         {
         else
         {
-            int oid = m_data->m_nextId++ ;
+            int oid = m_data->m_nextId++;
             if ( !isEmbedded )
             if ( !isEmbedded )
-                m_data->m_writtenObjects[object] = oid ;
+                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
 
             // 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 = dynamic_cast<const wxDynamicObject *>( object ) ;
+            const wxDynamicObject* dynobj = wx_dynamic_cast(const wxDynamicObject*, object);
             if ( !isEmbedded && dynobj )
             if ( !isEmbedded && dynobj )
-                m_data->m_writtenObjects[dynobj->GetSuperClassInstance()] = oid ;
+                m_data->m_writtenObjects[dynobj->GetSuperClassInstance()] = oid;
 
 
-            DoBeginWriteObject( object , classInfo , oid , metadata ) ;
-            wxWriterInternalPropertiesData data ;
-            WriteAllProperties( object , classInfo , persister , &data ) ;
-            DoEndWriteObject( object , classInfo , oid  ) ;
+            DoBeginWriteObject( object, classInfo, oid, metadata );
+            wxObjectWriterInternalPropertiesData data;
+            WriteAllProperties( object, classInfo, writercallback, &data );
+            DoEndWriteObject( object, classInfo, oid  );
         }
         }
-        persister->AfterWriteObject( this ,object , classInfo ) ;
+        writercallback->AfterWriteObject( this,object, classInfo );
     }
 }
 
     }
 }
 
-void wxWriter::FindConnectEntry(const wxEvtHandler * evSource,const wxDelegateTypeInfo* dti, const wxObject* &sink , const wxHandlerInfo *&handler)
+void wxObjectWriter::FindConnectEntry(const wxEvtHandler * evSource,
+                                const wxEventSourceTypeInfo* dti, 
+                                const wxObject* &sink, 
+                                const wxHandlerInfo *&handler)
 {
 {
-    wxList *dynamicEvents = evSource->GetDynamicEventTable() ;
+    wxList *dynamicEvents = evSource->GetDynamicEventTable();
 
     if ( dynamicEvents )
     {
 
     if ( dynamicEvents )
     {
-        wxList::compatibility_iterator node = dynamicEvents->GetFirst();
-        while (node)
+        for ( wxList::const_iterator node = dynamicEvents->begin(); node != dynamicEvents->end(); ++node )
         {
         {
-            wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
+            wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)(*node);
 
             // find the match
 
             // find the match
-            if ( entry->m_fn && 
+            if ( entry->m_fn &&
                 (dti->GetEventType() == entry->m_eventType) &&
                 (entry->m_id == -1 ) &&
                 (dti->GetEventType() == entry->m_eventType) &&
                 (entry->m_id == -1 ) &&
-                (entry->m_eventSink != NULL ) )
+                (entry->m_fn->GetEvtHandler() != NULL ) )
             {
             {
-                sink = entry->m_eventSink ;
-                const wxClassInfo* sinkClassInfo = sink->GetClassInfo() ;
-                const wxHandlerInfo* sinkHandler = sinkClassInfo->GetFirstHandler() ;
+                sink = entry->m_fn->GetEvtHandler();
+                const wxClassInfo* sinkClassInfo = sink->GetClassInfo();
+                const wxHandlerInfo* sinkHandler = sinkClassInfo->GetFirstHandler();
                 while ( sinkHandler )
                 {
                 while ( sinkHandler )
                 {
-                    if ( sinkHandler->GetEventFunction() == entry->m_fn )
+                    if ( sinkHandler->GetEventFunction() == entry->m_fn->GetEvtMethod() )
                     {
                     {
-                        handler = sinkHandler ;
-                        break ;
+                        handler = sinkHandler;
+                        break;
                     }
                     }
-                    sinkHandler = sinkHandler->GetNext() ;
+                    sinkHandler = sinkHandler->GetNext();
                 }
                 }
-                break ;
+                break;
             }
             }
-            node = node->GetNext();
         }
     }
 }
         }
     }
 }
-void wxWriter::WriteAllProperties( const wxObject * obj , const wxClassInfo* ci , wxPersister *persister, wxWriterInternalPropertiesData * data )
+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 )
+    wxPropertyInfoMap map;
+    ci->GetProperties( map );
+    for ( int i = 0; i < ci->GetCreateParamCount(); ++i )
     {
     {
-        wxString name = ci->GetCreateParamName(i) ;
-        const wxPropertyInfo* prop = map.find(name)->second ;
-        wxASSERT_MSG( prop , wxT("Create Parameter not found in declared RTTI Parameters") ) ;
-        WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
-        map.erase( name ) ;
+        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 );
     }
     }
-
-    for( wxPropertyInfoMap::iterator iter = map.begin() ; iter != map.end() ; ++iter )
-    {
-        const wxPropertyInfo* prop = iter->second ;
-        if ( prop->GetFlags() & wxPROP_OBJECT_GRAPH )
+    { // Extra block for broken compilers
+        for( wxPropertyInfoMap::iterator iter = map.begin(); iter != map.end(); ++iter )
         {
         {
-            WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
+            const wxPropertyInfo* prop = iter->second;
+            if ( prop->GetFlags() & wxPROP_OBJECT_GRAPH )
+            {
+                WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data );
+            }
         }
     }
         }
     }
-
-    for( wxPropertyInfoMap::iterator iter = map.begin() ; iter != map.end() ; ++iter )
-    {
-        const wxPropertyInfo* prop = iter->second ;
-        if ( !(prop->GetFlags() & wxPROP_OBJECT_GRAPH) )
+    { // Extra block for broken compilers
+        for( wxPropertyInfoMap::iterator iter = map.begin(); iter != map.end(); ++iter )
         {
         {
-            WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
+            const wxPropertyInfo* prop = iter->second;
+            if ( !(prop->GetFlags() & wxPROP_OBJECT_GRAPH) )
+            {
+                WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data );
+            }
         }
     }
 }
 
         }
     }
 }
 
-void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , const wxPropertyInfo* pi , wxPersister *persister , wxWriterInternalPropertiesData *WXUNUSED(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 )
 {
     if ( pi->GetFlags() & wxPROP_DONT_STREAM )
-        return ;
+        return;
 
     // make sure that we are picking the correct object for accessing the property
 
     // make sure that we are picking the correct object for accessing the property
-    const wxDynamicObject* dynobj = dynamic_cast< const wxDynamicObject* > (obj ) ;
-    if ( dynobj && (dynamic_cast<const wxDynamicClassInfo*>(ci) == NULL) )
-        obj = dynobj->GetSuperClassInstance() ;
+    const wxDynamicObject* dynobj = wx_dynamic_cast(const wxDynamicObject*, obj );
+    if ( dynobj && (wx_dynamic_cast(const wxDynamicClassInfo*, ci) == NULL) )
+        obj = dynobj->GetSuperClassInstance();
 
 
-    DoBeginWriteProperty( pi ) ;
     if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION )
     {
     if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION )
     {
-        wxxVariantArray data ;
-        pi->GetAccessor()->GetPropertyCollection(obj, data) ;
-        const wxTypeInfo * elementType = dynamic_cast< const wxCollectionTypeInfo* >( pi->GetTypeInfo() )->GetElementType() ;
-        for ( size_t i = 0 ; i < data.GetCount() ; ++i )
+        wxAnyList data;
+        pi->GetAccessor()->GetPropertyCollection(obj, data);
+        const wxTypeInfo * elementType = 
+            wx_dynamic_cast( const wxCollectionTypeInfo*, pi->GetTypeInfo() )->GetElementType();
+        if ( !data.empty() )
         {
         {
-            DoBeginWriteElement() ;
-            wxxVariant value = data[i] ;
-            if ( persister->BeforeWriteProperty( this , pi , value ) )
+            DoBeginWriteProperty( pi );
+            for ( wxAnyList::const_iterator iter = data.begin(); iter != data.end(); ++iter )
             {
             {
-                const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( elementType ) ;
-                if ( cti )
-                {
-                    const wxClassInfo* pci = cti->GetClassInfo() ;
-                    wxObject *vobj = pci->VariantToInstance( value ) ;
-                    wxxVariantArray md ;
-                    WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT , md ) ;
-                }
-                else
+                DoBeginWriteElement();
+                const wxAny* valptr = *iter;
+                if ( writercallback->BeforeWriteProperty( this, obj, pi, *valptr ) )
                 {
                 {
-                     DoWriteSimpleType( value ) ;
+                    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();
             }
             }
-            DoEndWriteElement() ;
+            DoEndWriteProperty( pi );
         }
     }
     else
     {
         }
     }
     else
     {
-        const wxDelegateTypeInfo* dti = dynamic_cast< const wxDelegateTypeInfo* > ( pi->GetTypeInfo() ) ;
+        const wxEventSourceTypeInfo* dti = 
+            wx_dynamic_cast( const wxEventSourceTypeInfo* , pi->GetTypeInfo() );
         if ( dti )
         {
         if ( dti )
         {
-            const wxObject* sink = NULL ;
-            const wxHandlerInfo *handler = NULL ;
-
-            const wxEvtHandler * evSource = dynamic_cast<const wxEvtHandler *>(obj) ;
-            wxASSERT_MSG( evSource , wxT("Illegal Object Class (Non-wxEvtHandler) as Event Source") ) ;
+            const wxObject* sink = NULL;
+            const wxHandlerInfo *handler = NULL;
 
 
-            FindConnectEntry( evSource , dti , sink , handler ) ;
-            if ( persister->BeforeWriteDelegate( this , obj , ci , pi , sink , handler ) )
+            const wxEvtHandler * evSource = wx_dynamic_cast(const wxEvtHandler *, obj);
+            if ( evSource )
             {
             {
-                if ( sink != NULL && handler != NULL )
+                FindConnectEntry( evSource, dti, sink, handler );
+                if ( writercallback->BeforeWriteDelegate( this, obj, ci, pi, sink, handler ) )
                 {
                 {
-                    wxASSERT_MSG( IsObjectKnown( sink ) , wxT("Streaming delegates for not already streamed objects not yet supported") ) ;
-                    DoWriteDelegate( obj , ci , pi , sink , GetObjectID( sink ) , sink->GetClassInfo() , 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
         {
         }
         else
         {
-            wxxVariant value ;
-            pi->GetAccessor()->GetProperty(obj, value) ;
-            if ( persister->BeforeWriteProperty( this , pi , value ) )
+            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 wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( pi->GetTypeInfo() ) ;
-                if ( cti )
+                const wxEnumTypeInfo *eti = 
+                    wx_dynamic_cast(const wxEnumTypeInfo*,  pi->GetTypeInfo() );
+                if ( eti )
                 {
                 {
-                    const wxClassInfo* pci = cti->GetClassInfo() ;
-                    wxObject *vobj = pci->VariantToInstance( value ) ;
-                    wxxVariantArray md ;
-                    WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT , md) ;
+                    eti->ConvertFromLong( wxANY_AS(value, long ), value );
                 }
                 else
                 }
                 else
-                {                        
-                    if ( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
+                {
+                    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() )
                     {
                     {
-                        const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
-                        wxASSERT_MSG( eti , wxT("Type must have enum - long conversion") ) ;
-                        eti->ConvertFromLong( value.Get<long>() , value ) ;
+                        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);
                     }
                     }
-                    DoWriteSimpleType( value ) ;
                 }
                 }
+                else
+                {
+                    DoWriteSimpleType( value );
+                }
+                DoEndWriteProperty( pi );
             }
         }
     }
             }
         }
     }
-    DoEndWriteProperty( pi ) ;
 }
 
 }
 
-int wxWriter::GetObjectID(const wxObject *obj) 
+int wxObjectWriter::GetObjectID(const wxObject *obj)
 {
     if ( !IsObjectKnown( obj ) )
 {
     if ( !IsObjectKnown( obj ) )
-        return wxInvalidObjectID ;
+        return wxInvalidObjectID;
 
 
-    return m_data->m_writtenObjects[obj] ;
+    return m_data->m_writtenObjects[obj];
 }
 
 }
 
-bool wxWriter::IsObjectKnown( const wxObject *obj ) 
+bool wxObjectWriter::IsObjectKnown( const wxObject *obj )
 {
 {
-    return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end() ;
+    return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end();
 }
 
 
 // ----------------------------------------------------------------------------
 }
 
 
 // ----------------------------------------------------------------------------
-// reading objects in 
+// wxObjectReader
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-struct wxReader::wxReaderInternal
+struct wxObjectReader::wxObjectReaderInternal
 {
     map<int,wxClassInfo*> m_classInfos;
 };
 
 {
     map<int,wxClassInfo*> m_classInfos;
 };
 
-wxReader::wxReader() 
+wxObjectReader::wxObjectReader()
 {
 {
-    m_data = new wxReaderInternal;
+    m_data = new wxObjectReaderInternal;
 }
 
 }
 
-wxReader::~wxReader()
+wxObjectReader::~wxObjectReader()
 {
     delete m_data;
 }
 
 {
     delete m_data;
 }
 
-wxClassInfo* wxReader::GetObjectClassInfo(int objectID)
+wxClassInfo* wxObjectReader::GetObjectClassInfo(int objectID)
 {
 {
-    assert( m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() );
-    return m_data->m_classInfos[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 wxReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo )
+void wxObjectReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo )
 {
 {
-    assert(  m_data->m_classInfos.find(objectID) == m_data->m_classInfos.end()  ) ;
-    m_data->m_classInfos[objectID] = 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 wxReader::HasObjectClassInfo( int objectID ) 
+bool wxObjectReader::HasObjectClassInfo( int objectID )
 {
 {
-    return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() ;
+    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 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
 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
@@ -327,57 +456,65 @@ and create params are always toplevel class only
 
 
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------
-// depersisting to memory 
+// wxObjectRuntimeReaderCallback - depersisting to memory
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 
-struct wxRuntimeDepersister::wxRuntimeDepersisterInternal
+struct wxObjectRuntimeReaderCallback::wxObjectRuntimeReaderCallbackInternal
 {
     map<int,wxObject *> m_objects;
 
     void SetObject(int objectID, wxObject *obj )
     {
 {
     map<int,wxObject *> m_objects;
 
     void SetObject(int objectID, wxObject *obj )
     {
-        assert(  m_objects.find(objectID) == m_objects.end()  ) ;
-        m_objects[objectID] = 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 )
     }
     wxObject* GetObject( int objectID )
     {
         if ( objectID == wxNullObjectID )
-            return NULL ;
+            return NULL;
+        if ( m_objects.find(objectID) == m_objects.end() )
+        {
+            wxLogError( _("Passing an unkown object to GetObject") );
+            return NULL;
+        }
 
 
-        assert(  m_objects.find(objectID) != m_objects.end()  ) ;
-        return m_objects[objectID] ;
+        return m_objects[objectID];
     }
     }
-} ;
+};
 
 
-wxRuntimeDepersister::wxRuntimeDepersister()
+wxObjectRuntimeReaderCallback::wxObjectRuntimeReaderCallback()
 {
 {
-    m_data = new wxRuntimeDepersisterInternal() ;
+    m_data = new wxObjectRuntimeReaderCallbackInternal();
 }
 
 }
 
-wxRuntimeDepersister::~wxRuntimeDepersister()
+wxObjectRuntimeReaderCallback::~wxObjectRuntimeReaderCallback()
 {
 {
-    delete m_data ;
+    delete m_data;
 }
 
 }
 
-void wxRuntimeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo ,
-                                          wxxVariantArray &WXUNUSED(metadata))
+void wxObjectRuntimeReaderCallback::AllocateObject(int objectID, wxClassInfo *classInfo,
+                                          wxStringToAnyHashMap &WXUNUSED(metadata))
 {
     wxObject *O;
     O = classInfo->CreateObject();
     m_data->SetObject(objectID, O);
 }
 
 {
     wxObject *O;
     O = classInfo->CreateObject();
     m_data->SetObject(objectID, O);
 }
 
-void wxRuntimeDepersister::CreateObject(int objectID,
+void wxObjectRuntimeReaderCallback::CreateObject(int objectID,
                                         const wxClassInfo *classInfo,
                                         int paramCount,
                                         const wxClassInfo *classInfo,
                                         int paramCount,
-                                        wxxVariant *params,
+                                        wxAny *params,
                                         int *objectIdValues,
                                         int *objectIdValues,
-                                        const wxClassInfo **objectClassInfos ,
-                                        wxxVariantArray &WXUNUSED(metadata))
+                                        const wxClassInfo **objectClassInfos,
+                                        wxStringToAnyHashMap &WXUNUSED(metadata))
 {
     wxObject *o;
     o = m_data->GetObject(objectID);
 {
     wxObject *o;
     o = m_data->GetObject(objectID);
-    for ( int i = 0 ; i < paramCount ; ++i )
+    for ( int i = 0; i < paramCount; ++i )
     {
         if ( objectIdValues[i] != wxInvalidObjectID )
         {
     {
         if ( objectIdValues[i] != wxInvalidObjectID )
         {
@@ -385,35 +522,65 @@ void wxRuntimeDepersister::CreateObject(int objectID,
             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.
             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 = dynamic_cast< wxDynamicObject * > (o) ;
+            wxDynamicObject *dyno = wx_dynamic_cast( wxDynamicObject *, o);
             if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
             {
             if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
             {
-                o = dyno->GetSuperClassInstance() ;
+                o = dyno->GetSuperClassInstance();
             }
             }
-            params[i] = objectClassInfos[i]->InstanceToVariant(o) ;
+            params[i] = objectClassInfos[i]->ObjectPtrToAny(o);
         }
     }
     classInfo->Create(o, paramCount, params);
 }
 
         }
     }
     classInfo->Create(o, paramCount, params);
 }
 
-void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) 
+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);
 {
     wxObject *o;
     o = m_data->GetObject(objectID);
-    delete o ;
+    delete o;
 }
 
 }
 
-void wxRuntimeDepersister::SetProperty(int objectID,
+void wxObjectRuntimeReaderCallback::SetProperty(int objectID,
                                        const wxClassInfo *classInfo,
                                        const wxPropertyInfo* propertyInfo,
                                        const wxClassInfo *classInfo,
                                        const wxPropertyInfo* propertyInfo,
-                                       const wxxVariant &value)
+                                       const wxAny &value)
 {
     wxObject *o;
     o = m_data->GetObject(objectID);
 {
     wxObject *o;
     o = m_data->GetObject(objectID);
-    classInfo->SetProperty( o , propertyInfo->GetName() , value ) ;
+    classInfo->SetProperty( o, propertyInfo->GetName().c_str(), value );
 }
 
 }
 
-void wxRuntimeDepersister::SetPropertyAsObject(int objectID,
+void wxObjectRuntimeReaderCallback::SetPropertyAsObject(int objectID,
                                                const wxClassInfo *classInfo,
                                                const wxPropertyInfo* propertyInfo,
                                                int valueObjectId)
                                                const wxClassInfo *classInfo,
                                                const wxPropertyInfo* propertyInfo,
                                                int valueObjectId)
@@ -421,238 +588,94 @@ void wxRuntimeDepersister::SetPropertyAsObject(int objectID,
     wxObject *o, *valo;
     o = m_data->GetObject(objectID);
     valo = m_data->GetObject(valueObjectId);
     wxObject *o, *valo;
     o = m_data->GetObject(objectID);
     valo = m_data->GetObject(valueObjectId);
-    const wxClassInfo* valClassInfo = (dynamic_cast<const wxClassTypeInfo*>(propertyInfo->GetTypeInfo()))->GetClassInfo() ;
+    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.
     // if this is a dynamic object and we are asked for another class
     // than wxDynamicObject we cast it down manually.
-    wxDynamicObject *dynvalo = dynamic_cast< wxDynamicObject * > (valo) ;
+    wxDynamicObject *dynvalo = wx_dynamic_cast( wxDynamicObject *, valo);
     if ( dynvalo!=NULL  && (valClassInfo != dynvalo->GetClassInfo()) )
     {
     if ( dynvalo!=NULL  && (valClassInfo != dynvalo->GetClassInfo()) )
     {
-        valo = dynvalo->GetSuperClassInstance() ;
+        valo = dynvalo->GetSuperClassInstance();
     }
 
     }
 
-    classInfo->SetProperty( o , propertyInfo->GetName() , valClassInfo->InstanceToVariant(valo) ) ;
+    classInfo->SetProperty( o, propertyInfo->GetName().c_str(),
+                            valClassInfo->ObjectPtrToAny(valo) );
 }
 
 }
 
-void wxRuntimeDepersister::SetConnect(int eventSourceObjectID,
+void wxObjectRuntimeReaderCallback::SetConnect(int eventSourceObjectID,
                                       const wxClassInfo *WXUNUSED(eventSourceClassInfo),
                                       const wxClassInfo *WXUNUSED(eventSourceClassInfo),
-                                      const wxDelegateTypeInfo *delegateInfo ,
-                                      const wxClassInfo *WXUNUSED(eventSinkClassInfo) ,
-                                      const wxHandlerInfo* handlerInfo ,
+                                      const wxPropertyInfo *delegateInfo,
+                                      const wxClassInfo *WXUNUSED(eventSinkClassInfo),
+                                      const wxHandlerInfo* handlerInfo,
                                       int eventSinkObjectID )
 {
                                       int eventSinkObjectID )
 {
-    wxEvtHandler *ehsource = dynamic_cast< wxEvtHandler* >( m_data->GetObject( eventSourceObjectID ) ) ;
-    wxEvtHandler *ehsink = dynamic_cast< wxEvtHandler *>(m_data->GetObject(eventSinkObjectID) ) ;
+    wxEvtHandler *ehsource = 
+        wx_dynamic_cast( wxEvtHandler* , m_data->GetObject( eventSourceObjectID ) );
+    wxEvtHandler *ehsink = 
+        wx_dynamic_cast( wxEvtHandler *,m_data->GetObject(eventSinkObjectID) );
 
     if ( ehsource && ehsink )
     {
 
     if ( ehsource && ehsink )
     {
-        ehsource->Connect( -1 , delegateInfo->GetEventType() , 
-            handlerInfo->GetEventFunction() , NULL /*user data*/ , 
-            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 *wxRuntimeDepersister::GetObject(int objectID)
+wxObject *wxObjectRuntimeReaderCallback::GetObject(int objectID)
 {
 {
-    return m_data->GetObject( objectID ) ;
+    return m_data->GetObject( objectID );
 }
 
 }
 
-// adds an element to a property collection
-void wxRuntimeDepersister::AddToPropertyCollection( int objectID ,
+void wxObjectRuntimeReaderCallback::AddToPropertyCollection( int objectID,
                                                    const wxClassInfo *classInfo,
                                                    const wxClassInfo *classInfo,
-                                                   const wxPropertyInfo* propertyInfo ,
-                                                   const wxxVariant &value) 
+                                                   const wxPropertyInfo* propertyInfo,
+                                                   const wxAny &value)
 {
     wxObject *o;
     o = m_data->GetObject(objectID);
 {
     wxObject *o;
     o = m_data->GetObject(objectID);
-    classInfo->AddToPropertyCollection( o , propertyInfo->GetName() , value ) ;
+    classInfo->AddToPropertyCollection( o, propertyInfo->GetName().c_str(), value );
 }
 
 }
 
-// sets the corresponding property (value is an object)
-void wxRuntimeDepersister::AddToPropertyCollectionAsObject(int objectID,
+void wxObjectRuntimeReaderCallback::AddToPropertyCollectionAsObject(int objectID,
                                                            const wxClassInfo *classInfo,
                                                            const wxClassInfo *classInfo,
-                                                           const wxPropertyInfo* propertyInfo ,
-                                                           int valueObjectId) 
+                                                           const wxPropertyInfo* propertyInfo,
+                                                           int valueObjectId)
 {
     wxObject *o, *valo;
     o = m_data->GetObject(objectID);
     valo = m_data->GetObject(valueObjectId);
 {
     wxObject *o, *valo;
     o = m_data->GetObject(objectID);
     valo = m_data->GetObject(valueObjectId);
-    const wxCollectionTypeInfo * collectionTypeInfo = dynamic_cast< const wxCollectionTypeInfo * >(propertyInfo->GetTypeInfo() ) ;
-    const wxClassInfo* valClassInfo = (dynamic_cast<const wxClassTypeInfo*>(collectionTypeInfo->GetElementType()))->GetClassInfo() ;
+    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.
     // if this is a dynamic object and we are asked for another class
     // than wxDynamicObject we cast it down manually.
-    wxDynamicObject *dynvalo = dynamic_cast< wxDynamicObject * > (valo) ;
+    wxDynamicObject *dynvalo = wx_dynamic_cast( wxDynamicObject *, valo);
     if ( dynvalo!=NULL  && (valClassInfo != dynvalo->GetClassInfo()) )
     {
     if ( dynvalo!=NULL  && (valClassInfo != dynvalo->GetClassInfo()) )
     {
-        valo = dynvalo->GetSuperClassInstance() ;
-    }
-
-    classInfo->AddToPropertyCollection( o , propertyInfo->GetName() , valClassInfo->InstanceToVariant(valo) ) ;
-}
-
-// ----------------------------------------------------------------------------
-// depersisting to code 
-// ----------------------------------------------------------------------------
-
-struct wxCodeDepersister::wxCodeDepersisterInternal
-{
-    map<int,string> m_objectNames ;
-
-    void SetObjectName(int objectID, const wxString &name )
-    {
-        assert(  m_objectNames.find(objectID) == m_objectNames.end()  ) ;
-        m_objectNames[objectID] = (const char *)name;
-    }
-    wxString GetObjectName( int objectID )
-    {
-        if ( objectID == wxNullObjectID )
-            return "NULL" ;
-
-        assert(  m_objectNames.find(objectID) != m_objectNames.end()  ) ;
-        return wxString( m_objectNames[objectID].c_str() ) ;
-    }
-} ;
-
-wxCodeDepersister::wxCodeDepersister(wxTextOutputStream *out) 
-: m_fp(out)
-{
-    m_data = new wxCodeDepersisterInternal ;
-}
-
-wxCodeDepersister::~wxCodeDepersister()
-{
-    delete m_data ;
-}
-
-void wxCodeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo ,
-                                       wxxVariantArray &WXUNUSED(metadata))
-{
-    wxString objectName = wxString::Format( "LocalObject_%d" , objectID ) ;
-    m_fp->WriteString( wxString::Format( "\t%s *%s = new %s;\n",
-        classInfo->GetClassName(),
-        objectName,
-        classInfo->GetClassName()) );
-    m_data->SetObjectName( objectID , objectName ) ;
-}
-
-void wxCodeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) 
-{
-    m_fp->WriteString( wxString::Format( "\tdelete %s;\n",
-        m_data->GetObjectName( objectID) ) );
-}
-
-wxString wxCodeDepersister::ValueAsCode( const wxxVariant &param )
-{
-    wxString value ;
-    const wxTypeInfo* type = param.GetTypeInfo() ;
-    if ( type->GetKind() == wxT_CUSTOM )
-    {
-        const wxCustomTypeInfo* cti = dynamic_cast<const wxCustomTypeInfo*>(type) ;
-        wxASSERT_MSG( cti , wxT("Internal error, illegal wxCustomTypeInfo") ) ;
-        value.Printf( "%s(%s)",cti->GetTypeName(),param.GetAsString() );
+        valo = dynvalo->GetSuperClassInstance();
     }
     }
-    else if ( type->GetKind() == wxT_STRING )
-    {
-        value.Printf( "\"%s\"",param.GetAsString() );
-    }
-    else
-    {
-        value.Printf( "%s", param.GetAsString() );
-    }
-    return value ;
-}
 
 
-void wxCodeDepersister::CreateObject(int objectID,
-                                     const wxClassInfo *WXUNUSED(classInfo),
-                                     int paramCount,
-                                     wxxVariant *params,
-                                     int *objectIDValues,
-                                     const wxClassInfo **WXUNUSED(objectClassInfos) ,
-                                     wxxVariantArray &WXUNUSED(metadata)
-                                     )
-{
-    int i;
-    m_fp->WriteString( wxString::Format( "\t%s->Create(", m_data->GetObjectName(objectID) ) );
-    for (i = 0; i < paramCount; i++)
-    {
-        if ( objectIDValues[i] != wxInvalidObjectID )
-            m_fp->WriteString( wxString::Format( "%s", m_data->GetObjectName( objectIDValues[i] ) ) );
-        else
-        {
-            m_fp->WriteString( wxString::Format( "%s", ValueAsCode(params[i]) ) );
-        }
-        if (i < paramCount - 1)
-            m_fp->WriteString( ", ");
-    }
-    m_fp->WriteString( ");\n");
-}
-
-void wxCodeDepersister::SetProperty(int objectID,
-                                    const wxClassInfo *WXUNUSED(classInfo),
-                                    const wxPropertyInfo* propertyInfo,
-                                    const wxxVariant &value)
-{
-    m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n",
-        m_data->GetObjectName(objectID),
-        propertyInfo->GetAccessor()->GetSetterName(),
-        ValueAsCode(value)) );
+    classInfo->AddToPropertyCollection( o, propertyInfo->GetName().c_str(),
+                                        valClassInfo->ObjectPtrToAny(valo) );
 }
 
 }
 
-void wxCodeDepersister::SetPropertyAsObject(int objectID,
-                                            const wxClassInfo *WXUNUSED(classInfo),
-                                            const wxPropertyInfo* propertyInfo,
-                                            int valueObjectId)
-{
-    if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT )
-        m_fp->WriteString( wxString::Format( "\t%s->%s(*%s);\n",
-        m_data->GetObjectName(objectID),
-        propertyInfo->GetAccessor()->GetSetterName(),
-        m_data->GetObjectName( valueObjectId) ) );
-    else
-        m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n",
-        m_data->GetObjectName(objectID),
-        propertyInfo->GetAccessor()->GetSetterName(),
-        m_data->GetObjectName( valueObjectId) ) );
-}
-
-void wxCodeDepersister::AddToPropertyCollection( int objectID ,
-                                                const wxClassInfo *WXUNUSED(classInfo),
-                                                const wxPropertyInfo* propertyInfo ,
-                                                const wxxVariant &value) 
-{
-    m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n",
-        m_data->GetObjectName(objectID),
-        propertyInfo->GetAccessor()->GetAdderName(),
-        ValueAsCode(value)) );
-}
-
-// sets the corresponding property (value is an object)
-void wxCodeDepersister::AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
-                                                        const wxClassInfo *WXUNUSED(classInfo),
-                                                        const wxPropertyInfo* WXUNUSED(propertyInfo) ,
-                                                        int WXUNUSED(valueObjectId)) 
-{
-    // TODO
-}
-
-void wxCodeDepersister::SetConnect(int eventSourceObjectID,
-                                   const wxClassInfo *WXUNUSED(eventSourceClassInfo),
-                                   const wxDelegateTypeInfo *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() ;
-    int eventType = delegateInfo->GetEventType() ;
-    wxString handlerName = handlerInfo->GetName() ;
-
-    m_fp->WriteString( wxString::Format(  "\t%s->Connect( %s->GetId() , %d , (wxObjectEventFunction)(wxEventFunction) & %s::%s , NULL , %s ) ;" , 
-        ehsource , ehsource , eventType , ehsinkClass , handlerName , ehsink ) );
-}
-
-#include <wx/arrimpl.cpp>
-
-WX_DEFINE_OBJARRAY(wxxVariantArray);
-
-#endif
+#endif // wxUSE_EXTENDED_RTTI
wxWidgets (Impactor)