added wxDynamicObject (kind of delegate, docs to come once this has calmed down)

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@22765 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/object.h

@@ -542,6 +542,35 @@ inline wxObject *wxCheckDynamicCast(wxObject *obj, wxClassInfo *classInfo)
     return obj && obj->GetClassInfo()->IsKindOf(classInfo) ? obj : NULL;
 }
 
+#if wxUSE_EXTENDED_RTTI
+class WXDLLIMPEXP_BASE wxDynamicObject : public wxObject
+{
+public:
+    // instantiates this object with an instance of its superclass
+    wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info) ;
+    ~wxDynamicObject();
+
+    void SetProperty (const wxChar *PropertyName, const wxxVariant &Value);
+    wxxVariant GetProperty (const wxChar *PropertyName) const ;
+
+    // get the runtime identity of this object
+    wxClassInfo *GetClassInfo() const
+    {
+		return const_cast<wxClassInfo*>((const wxClassInfo*)m_classInfo);
+    }
+
+    wxObject* GetSuperClassInstance() const
+    {
+        return m_superClassInstance ;
+    }
+private :
+    wxObject *m_superClassInstance ;
+    const wxDynamicClassInfo *m_classInfo;
+    struct wxDynamicObjectInternal;
+    wxDynamicObjectInternal *m_data;
+};
+#endif
+
 // ----------------------------------------------------------------------------
 // more debugging macros
 // ----------------------------------------------------------------------------

include/wx/xti.h

@@ -487,6 +487,8 @@ public :
     class SetAndGetByRefRetBool ;
     class GetByRef ;
 #endif
+    wxPropertyAccessor() { m_setterName = NULL ; m_getterName = NULL ; }
+    virtual ~wxPropertyAccessor() {}
     virtual void SetProperty(wxObject *object, const wxxVariant &value) const = 0 ;
     virtual wxxVariant GetProperty(const wxObject *object) const = 0 ;
     virtual bool HasSetter() const = 0 ;
@@ -500,6 +502,22 @@ protected :
     const wxChar *m_getterName ;
 };
 
+class WXDLLIMPEXP_BASE wxGenericPropertyAccessor : public wxPropertyAccessor
+{
+public :
+    wxGenericPropertyAccessor( const wxChar* propertyName ) ;
+    ~wxGenericPropertyAccessor() ; 
+    virtual void SetProperty(wxObject *object, const wxxVariant &value) const ;
+    virtual wxxVariant GetProperty(const wxObject *object) const ;
+    virtual bool HasSetter() const { return true ; }
+    virtual bool HasGetter() const { return true ; }
+    virtual wxxVariant ReadValue( const wxString &value ) const ;
+    virtual void WriteValue( wxString& value , const wxObject *o ) const ;
+private :
+    struct wxGenericPropertyAccessorInternal ;
+    wxGenericPropertyAccessorInternal* m_data ;
+} ;
+
 template<class Klass, typename T>
 class WXDLLIMPEXP_BASE wxPropertyAccessorT : public wxPropertyAccessor
 {
@@ -537,7 +555,7 @@ public:
     	: m_setter_bool( NULL ) , m_setter_ref_bool( NULL ) , m_setter(NULL), m_setter(setter), m_getter(NULL) ,  m_getter_ref(getter){m_setterName = s;m_getterName=g ;}
 
     // returns true if this accessor has a setter
-    bool HasSetter() const { return m_setter != NULL || m_setter_ref != NULL ; }
+    bool HasSetter() const { return m_setter != NULL || m_setter_ref != NULL || m_setter_ref_bool != NULL || m_setter_bool ; }
 
     // return true if this accessor has a getter
     bool HasGetter() const { return m_getter != NULL || m_getter_ref != NULL ; }
@@ -654,7 +672,7 @@ private :
 };
 
 #define WX_BEGIN_PROPERTIES_TABLE(theClass) \
-    const wxPropertyInfo *theClass::GetPropertiesStatic()  \
+    wxPropertyInfo *theClass::GetPropertiesStatic()  \
     {  \
         typedef theClass class_t; \
         static wxPropertyInfo* first = NULL ;
@@ -760,7 +778,7 @@ private :
     static wxHandlerInfo _handlerInfo##name( first , #name , (wxObjectEventFunction) (wxEventFunction) &name , CLASSINFO( eventClassType ) ) ;
 
 #define WX_BEGIN_HANDLERS_TABLE(theClass) \
-    const wxHandlerInfo *theClass::GetHandlersStatic()  \
+    wxHandlerInfo *theClass::GetHandlersStatic()  \
     {  \
         typedef theClass class_t; \
         static wxHandlerInfo* first = NULL ;
@@ -970,8 +988,8 @@ public:
             const wxChar *_ClassName,
             int size,
             wxObjectConstructorFn ctor ,
-			const wxPropertyInfo *_Props ,
+			wxPropertyInfo *_Props ,
-			const wxHandlerInfo *_Handlers ,
+			wxHandlerInfo *_Handlers ,
 			wxConstructorBridge* _Constructor ,
 			const wxChar ** _ConstructorProperties ,
 			const int _ConstructorPropertiesCount ,
@@ -987,9 +1005,18 @@ public:
 		Register() ;
 	}
 
+   wxClassInfo(const wxChar *_UnitName, const wxChar *_ClassName, const wxClassInfo **_Parents) : m_parents(_Parents) , m_unitName(_UnitName) ,m_className(_ClassName),
+			m_objectSize(0), m_objectConstructor(NULL) , m_firstProperty(NULL ) , m_firstHandler(NULL ) , m_constructor( NULL ) ,
+			m_constructorProperties(NULL) , m_constructorPropertiesCount(NULL),
+			m_variantOfPtrToObjectConverter( NULL ) , m_variantToObjectConverter( NULL ) , m_objectToVariantConverter( NULL ) , m_next(sm_first)
+	{
+		sm_first = this;
+		Register() ;
+	}
+
     virtual ~wxClassInfo() ;
 
-    wxObject *CreateObject() const { return m_objectConstructor ? (*m_objectConstructor)() : 0; }
+    virtual wxObject *CreateObject() const { return m_objectConstructor ? (*m_objectConstructor)() : 0; }
 
     const wxChar       *GetClassName() const { return m_className; }
     const wxClassInfo **GetParents() const { return m_parents; }
@@ -1047,8 +1074,8 @@ public:
     virtual const wxChar* GetCreateParamName(int i) const { return m_constructorProperties[i] ; }
 
    // Runtime access to objects by property name, and variant data
-    virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value);
+    virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value) const ;
-    virtual wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName);
+    virtual wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName) const;
 
 	// we must be able to cast variants to wxObject pointers, templates seem not to be suitable
 	wxObject* VariantToInstance( wxxVariant &data ) const
@@ -1066,6 +1093,11 @@ public:
     // find handler by name
     virtual const wxHandlerInfo *FindHandlerInfo (const wxChar *PropertyName) const ;
 
+    // find property by name
+    virtual const wxPropertyInfo *FindPropertyInfoInThisClass (const wxChar *PropertyName) const ;
+
+    // find handler by name
+    virtual const wxHandlerInfo *FindHandlerInfoInThisClass (const wxChar *PropertyName) const ;
 public:
     const wxChar            *m_className;
     int                      m_objectSize;
@@ -1081,10 +1113,11 @@ public:
     //        many clients)
     static wxHashTable      *sm_classTable;
 
+protected :
+ 	wxPropertyInfo *	    m_firstProperty ;
+  	wxHandlerInfo *	        m_firstHandler ;
 private:
 	const wxClassInfo**		m_parents ;
- 	const wxPropertyInfo *	m_firstProperty ;
-  	const wxHandlerInfo *	m_firstHandler ;
     const wxChar*			m_unitName;
 
 	wxConstructorBridge*	m_constructor ;
@@ -1094,7 +1127,7 @@ private:
 	wxVariantToObjectConverter m_variantToObjectConverter ;
 	wxObjectToVariantConverter m_objectToVariantConverter ;
 
-    const wxPropertyAccessor *FindAccessor (const wxChar *propertyName);
+    const wxPropertyAccessor *FindAccessor (const wxChar *propertyName) const ;
 
 
     // InitializeClasses() helper
@@ -1108,8 +1141,41 @@ protected:
     DECLARE_NO_COPY_CLASS(wxClassInfo)
 };
 
+
 WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
 
+// ----------------------------------------------------------------------------
+// wxDynamicObject
+// ----------------------------------------------------------------------------
+//
+// this object leads to having a pure runtime-instantiation
+
+class wxDynamicClassInfo : public wxClassInfo
+{
+public :
+    wxDynamicClassInfo( const wxChar *_UnitName, const wxChar *_ClassName , const wxClassInfo* superClass ) ;
+    virtual ~wxDynamicClassInfo() ;
+
+    // constructs a wxDynamicObject with an instance
+    virtual wxObject *CreateObject() const ;
+
+    // Call the Create method for a class
+    virtual void Create (wxObject *object, int ParamCount, wxxVariant *Params) const ;
+
+    // get number of parameters for constructor
+    virtual int GetCreateParamCount() const ;
+
+    // get i-th constructor parameter
+    virtual const wxChar* GetCreateParamName(int i) const ;
+
+    // Runtime access to objects by property name, and variant data
+    virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value) const ;
+    virtual wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName) const ;
+
+    void AddProperty( const wxChar *propertyName , const wxTypeInfo* typeInfo ) ;
+    void AddHandler( const wxChar *handlerName , wxObjectEventFunction address , const wxClassInfo* eventClassInfo ) ;
+} ;
+
 // ----------------------------------------------------------------------------
 // Dynamic class macros
 // ----------------------------------------------------------------------------
@@ -1118,8 +1184,8 @@ WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
  public:                                      \
   static wxClassInfo sm_class##name;          \
   static const wxClassInfo* sm_classParents##name[] ; \
-  static const wxPropertyInfo* GetPropertiesStatic() ; \
+  static wxPropertyInfo* GetPropertiesStatic() ; \
-  static const wxHandlerInfo* GetHandlersStatic() ; \
+  static wxHandlerInfo* GetHandlersStatic() ; \
   virtual wxClassInfo *GetClassInfo() const   \
    { return &name::sm_class##name; }
 
@@ -1197,8 +1263,8 @@ WX_CONSTRUCTOR_DUMMY( name )
 
 #define IMPLEMENT_DYNAMIC_CLASS( name , basename ) \
 _IMPLEMENT_DYNAMIC_CLASS( name , basename , "" ) \
-const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
+wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
-const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
+wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
 WX_CONSTRUCTOR_DUMMY( name )
 
 #define IMPLEMENT_DYNAMIC_CLASS_XTI( name , basename , unit ) \
@@ -1265,8 +1331,8 @@ _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , unit )
 
 #define IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2) \
 _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , "") \
-const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
+wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
-const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
+wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
 WX_CONSTRUCTOR_DUMMY( name )
 
 #define IMPLEMENT_DYNAMIC_CLASS2_XTI( name , basename , basename2, unit) \
@@ -1298,8 +1364,8 @@ wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVaria
 
 #define IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
 _IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
-const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
+wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
-const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; }
+wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; }
 
     // Multiple inheritance with two base classes
 

src/common/xti.cpp

@@ -33,6 +33,11 @@
 
 #if wxUSE_EXTENDED_RTTI
 
+#include <map>
+#include <string>
+
+using namespace std ;
+
 // ----------------------------------------------------------------------------
 // Enum Support
 // ----------------------------------------------------------------------------
@@ -407,7 +412,7 @@ void wxSetStringToArray( const wxString &s , wxArrayString &array )
 // wxClassInfo
 // ----------------------------------------------------------------------------
 
-const wxPropertyAccessor *wxClassInfo::FindAccessor(const char *PropertyName)
+const wxPropertyAccessor *wxClassInfo::FindAccessor(const char *PropertyName) const
 {
     const wxPropertyInfo* info = FindPropertyInfo( PropertyName ) ;
 
@@ -417,7 +422,7 @@ const wxPropertyAccessor *wxClassInfo::FindAccessor(const char *PropertyName)
 	return NULL ;
 }
 
-const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const char *PropertyName) const
+const wxPropertyInfo *wxClassInfo::FindPropertyInfoInThisClass (const char *PropertyName) const
 {
 	const wxPropertyInfo* info = GetFirstProperty() ;
 
@@ -428,6 +433,15 @@ const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const char *PropertyName) c
 		info = info->GetNext() ;
 	}
 
+    return 0;
+}
+
+const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const char *PropertyName) const
+{
+	const wxPropertyInfo* info = FindPropertyInfoInThisClass( PropertyName ) ;
+    if ( info )
+        return info ;
+
 	const wxClassInfo** parents = GetParents() ;
 	for ( int i = 0 ; parents[i] ; ++ i )
 	{
@@ -438,7 +452,7 @@ const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const char *PropertyName) c
     return 0;
 }
 
-const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const char *PropertyName) const
+const wxHandlerInfo *wxClassInfo::FindHandlerInfoInThisClass (const char *PropertyName) const
 {
 	const wxHandlerInfo* info = GetFirstHandler() ;
 
@@ -449,6 +463,16 @@ const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const char *PropertyName) con
 		info = info->GetNext() ;
 	}
 
+    return 0;
+}
+
+const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const char *PropertyName) const
+{
+	const wxHandlerInfo* info = FindHandlerInfoInThisClass( PropertyName ) ;
+
+    if ( info )
+        return info ;
+
 	const wxClassInfo** parents = GetParents() ;
 	for ( int i = 0 ; parents[i] ; ++ i )
 	{
@@ -460,7 +484,7 @@ const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const char *PropertyName) con
 }
 
 
-void wxClassInfo::SetProperty(wxObject *object, const char *propertyName, const wxxVariant &value)
+void wxClassInfo::SetProperty(wxObject *object, const char *propertyName, const wxxVariant &value) const
 {
     const wxPropertyAccessor *accessor;
 
@@ -469,7 +493,7 @@ void wxClassInfo::SetProperty(wxObject *object, const char *propertyName, const
 	accessor->SetProperty( object , value ) ;
 }
 
-wxxVariant wxClassInfo::GetProperty(wxObject *object, const char *propertyName)
+wxxVariant wxClassInfo::GetProperty(wxObject *object, const char *propertyName) const
 {
     const wxPropertyAccessor *accessor;
 
@@ -491,5 +515,160 @@ wxObject* wxxVariant::GetAsObject()
 		return NULL ;
 }
 
+// ----------------------------------------------------------------------------
+// wxDynamicObject support
+// ----------------------------------------------------------------------------
+//
+// Dynamic Objects are objects that have a real superclass instance and carry their
+// own attributes in a hash map. Like this it is possible to create the objects and
+// stream them, as if their class information was already available from compiled data
+
+struct wxDynamicObject::wxDynamicObjectInternal
+{
+    map<string,wxxVariant> m_properties ;
+} ;
+
+// instantiates this object with an instance of its superclass
+wxDynamicObject::wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info) 
+{
+    m_superClassInstance = superClassInstance ;
+    m_classInfo = info ;
+    m_data = new wxDynamicObjectInternal ;
+}
+
+wxDynamicObject::~wxDynamicObject()
+{
+    delete m_data ;
+    delete m_superClassInstance ;
+}
+
+void wxDynamicObject::SetProperty (const wxChar *propertyName, const wxxVariant &value)
+{
+    wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),wxT("Accessing Unknown Property in a Dynamic Object") ) ;
+    m_data->m_properties[propertyName] = value ;
+}
+
+wxxVariant wxDynamicObject::GetProperty (const wxChar *propertyName) const
+{
+   wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),wxT("Accessing Unknown Property in a Dynamic Object") ) ;
+   return m_data->m_properties[propertyName] ;
+}
+
+// ----------------------------------------------------------------------------
+// wxDynamiClassInfo
+// ----------------------------------------------------------------------------
+
+wxDynamicClassInfo::wxDynamicClassInfo( const wxChar *unitName, const wxChar *className , const wxClassInfo* superClass ) :
+    wxClassInfo( unitName, className , new const wxClassInfo*[2]) 
+{
+    GetParents()[0] = superClass ;
+    GetParents()[1] = NULL ;
+}
+
+wxDynamicClassInfo::~wxDynamicClassInfo()
+{
+    delete[] GetParents() ;
+}
+
+wxObject *wxDynamicClassInfo::CreateObject() const 
+{
+    wxObject* parent = GetParents()[0]->CreateObject() ;
+    return new wxDynamicObject( parent , this ) ;
+}
+
+void wxDynamicClassInfo::Create (wxObject *object, int paramCount, wxxVariant *params) const 
+{
+    wxDynamicObject *dynobj = dynamic_cast< wxDynamicObject *>( object ) ;
+    wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::Create on an object other than wxDynamicObject") ) ;
+    GetParents()[0]->Create( dynobj->GetSuperClassInstance() , paramCount , params ) ;
+}
+
+// get number of parameters for constructor
+int wxDynamicClassInfo::GetCreateParamCount() const 
+{
+    return GetParents()[0]->GetCreateParamCount() ;
+}
+
+// get i-th constructor parameter
+const wxChar* wxDynamicClassInfo::GetCreateParamName(int i) const 
+{
+    return GetParents()[0]->GetCreateParamName( i ) ;
+}
+
+void wxDynamicClassInfo::SetProperty(wxObject *object, const char *propertyName, const wxxVariant &value) const
+{
+    wxDynamicObject* dynobj = dynamic_cast< wxDynamicObject * >( object ) ;
+    wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") ) ;
+    if ( FindPropertyInfoInThisClass(propertyName) )
+        dynobj->SetProperty( propertyName , value ) ;
+    else
+        GetParents()[0]->SetProperty( dynobj->GetSuperClassInstance() , propertyName , value ) ;
+}
+
+wxxVariant wxDynamicClassInfo::GetProperty(wxObject *object, const char *propertyName) const
+{
+    wxDynamicObject* dynobj = dynamic_cast< wxDynamicObject * >( object ) ;
+    wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") ) ;
+    if ( FindPropertyInfoInThisClass(propertyName) )
+        return dynobj->GetProperty( propertyName ) ;
+    else
+        return GetParents()[0]->GetProperty( dynobj->GetSuperClassInstance() , propertyName ) ;
+}
+
+void wxDynamicClassInfo::AddProperty( const wxChar *propertyName , const wxTypeInfo* typeInfo ) 
+{
+    new wxPropertyInfo( m_firstProperty , propertyName , "" , typeInfo , new wxGenericPropertyAccessor( propertyName ) , wxxVariant() ) ;
+}
+
+void wxDynamicClassInfo::AddHandler( const wxChar *handlerName , wxObjectEventFunction address , const wxClassInfo* eventClassInfo ) 
+{
+    new wxHandlerInfo( m_firstHandler , handlerName , address , eventClassInfo ) ;
+}
+
+// ----------------------------------------------------------------------------
+// wxGenericPropertyAccessor
+// ----------------------------------------------------------------------------
+
+struct wxGenericPropertyAccessor::wxGenericPropertyAccessorInternal
+{
+    wxString m_propertyName ;
+} ;
+
+wxGenericPropertyAccessor::wxGenericPropertyAccessor( const wxChar* propertyName ) 
+{
+    m_data = new wxGenericPropertyAccessorInternal ;
+    m_data->m_propertyName = propertyName ;
+}
+
+wxGenericPropertyAccessor::~wxGenericPropertyAccessor()
+{
+    delete m_data ;
+}
+void wxGenericPropertyAccessor::SetProperty(wxObject *object, const wxxVariant &value) const 
+{
+    wxDynamicObject* dynobj = dynamic_cast< wxDynamicObject * >( object ) ;
+    wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") ) ;
+    dynobj->SetProperty(m_data->m_propertyName , value ) ;
+}
+
+wxxVariant wxGenericPropertyAccessor::GetProperty(const wxObject *object) const 
+{
+    const wxDynamicObject* dynobj = dynamic_cast< const wxDynamicObject * >( object ) ;
+    wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") ) ;
+    return dynobj->GetProperty( m_data->m_propertyName ) ;
+}
+
+wxxVariant wxGenericPropertyAccessor::ReadValue( const wxString &value ) const 
+{
+    return wxxVariant(value) ;
+}
+
+void wxGenericPropertyAccessor::WriteValue( wxString& value , const wxObject *object ) const 
+{
+    const wxDynamicObject* dynobj = dynamic_cast< const wxDynamicObject * >( object ) ;
+    wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") ) ;
+    wxxVariant val = dynobj->GetProperty( m_data->m_propertyName ) ;
+    value = val.GetAsString() ;
+}
 
 #endif

src/common/xtistrm.cpp

@@ -62,15 +62,28 @@ struct wxWriter::wxWriterInternalPropertiesData
 void wxWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo , wxPersister *persister , const wxString &name )
 {
     if ( persister->BeforeWriteObject( object , classInfo , name ) )
+    {
+        if ( object == NULL || IsObjectKnown( object ) )
+        {
+            DoWriteObjectReference( NULL , NULL , object , classInfo , GetObjectID(object) , NULL ) ;
+        }
+        else
         {
             int oid = m_data->m_nextId++ ;
             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 = dynamic_cast<const wxDynamicObject *>( object ) ;
+            if ( dynobj )
+                m_data->m_writtenObjects[dynobj->GetSuperClassInstance()] = oid ;
+
             DoBeginWriteObject( object , classInfo , oid , name ) ;
             wxWriterInternalPropertiesData data ;
             WriteAllProperties( object , classInfo , persister , &data ) ;
             DoEndWriteObject( object , classInfo , oid , name  ) ;
         }
     }
+}
 
 void wxWriter::WriteAllProperties( const wxObject * obj , const wxClassInfo* ci , wxPersister *persister, wxWriterInternalPropertiesData * data )
 {
@@ -98,7 +111,15 @@ void wxWriter::WriteAllProperties( const wxObject * obj , const wxClassInfo* ci
                     {
                         int oid = m_data->m_nextId++ ;
                         if ( !embeddedObject)
+                        {
+                            // insert this object and its id
                             m_data->m_writtenObjects[vobj] = 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 = dynamic_cast<const wxDynamicObject *>( vobj ) ;
+                            if ( dynobj )
+                                m_data->m_writtenObjects[dynobj->GetSuperClassInstance()] = oid ;
+                        }
 
                         DoBeginWriteParamAsObject( obj , ci , vobj , pci , oid , pi ) ;
                         if ( vobj != NULL )
@@ -177,6 +198,11 @@ void wxWriter::WriteAllProperties( const wxObject * obj , const wxClassInfo* ci
         }
         pi = pi->GetNext() ;
     }
+    // in case this object is wxDynamic object we have to hand over the streaming
+    // of the properties of the superclasses to the real super class instance
+    const wxDynamicObject* dynobj = dynamic_cast< const wxDynamicObject* > (obj ) ;
+    if ( dynobj )
+        obj = dynobj->GetSuperClassInstance() ;
     const wxClassInfo** parents = ci->GetParents() ;
     for ( int i = 0 ; parents[i] ; ++ i )
     {
@@ -589,6 +615,13 @@ void wxRuntimeDepersister::CreateObject(int objectID,
         {
             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 = dynamic_cast< wxDynamicObject * > (o) ;
+            if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
+            {
+                o = dyno->GetSuperClassInstance() ;
+            }
             params[i] = objectClassInfos[i]->InstanceToVariant(o) ;
         }
     }
@@ -603,25 +636,36 @@ void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(cla
 }
 
 void wxRuntimeDepersister::SetProperty(int objectID,
-                                       const wxClassInfo *WXUNUSED(classInfo),
+                                       const wxClassInfo *classInfo,
                                        const wxPropertyInfo* propertyInfo,
                                        const wxxVariant &value)
 {
     wxObject *o;
     o = m_data->GetObject(objectID);
-    propertyInfo->GetAccessor()->SetProperty( o , value ) ;
+    classInfo->SetProperty( o , propertyInfo->GetName() , value ) ;
+    // propertyInfo->GetAccessor()->SetProperty( o , value ) ;
 }
 
 void wxRuntimeDepersister::SetPropertyAsObject(int objectID,
-                                               const wxClassInfo *WXUNUSED(classInfo),
+                                               const wxClassInfo *classInfo,
                                                const wxPropertyInfo* propertyInfo,
                                                int valueObjectId)
 {
     wxObject *o, *valo;
     o = m_data->GetObject(objectID);
     valo = m_data->GetObject(valueObjectId);
-    propertyInfo->GetAccessor()->SetProperty( o , 
+    const wxClassInfo* valClassInfo = (dynamic_cast<const wxClassTypeInfo*>(propertyInfo->GetTypeInfo()))->GetClassInfo() ;
-        (dynamic_cast<const wxClassTypeInfo*>(propertyInfo->GetTypeInfo()))->GetClassInfo()->InstanceToVariant(valo) ) ;
+    // 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) ;
+    if ( dynvalo!=NULL  && (valClassInfo != dynvalo->GetClassInfo()) )
+    {
+        valo = dynvalo->GetSuperClassInstance() ;
+    }
+
+    classInfo->SetProperty( o , propertyInfo->GetName() , valClassInfo->InstanceToVariant(valo) ) ;
+//    propertyInfo->GetAccessor()->SetProperty( o , 
+//        (dynamic_cast<const wxClassTypeInfo*>(propertyInfo->GetTypeInfo()))->GetClassInfo()->InstanceToVariant(valo) ) ;
 }
 
 void wxRuntimeDepersister::SetConnect(int eventSourceObjectID,