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
// ----------------------------------------------------------------------------
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 ;
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
{
: 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 ; }
};
#define WX_BEGIN_PROPERTIES_TABLE(theClass) \
- const wxPropertyInfo *theClass::GetPropertiesStatic() \
+ wxPropertyInfo *theClass::GetPropertiesStatic() \
{ \
typedef theClass class_t; \
static wxPropertyInfo* first = NULL ;
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 ;
const wxChar *_ClassName,
int size,
wxObjectConstructorFn ctor ,
- const wxPropertyInfo *_Props ,
- const wxHandlerInfo *_Handlers ,
+ wxPropertyInfo *_Props ,
+ wxHandlerInfo *_Handlers ,
wxConstructorBridge* _Constructor ,
const wxChar ** _ConstructorProperties ,
const int _ConstructorPropertiesCount ,
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; }
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 wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName);
+ virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value) const ;
+ 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
// 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;
// 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 ;
wxVariantToObjectConverter m_variantToObjectConverter ;
wxObjectToVariantConverter m_objectToVariantConverter ;
- const wxPropertyAccessor *FindAccessor (const wxChar *propertyName);
+ const wxPropertyAccessor *FindAccessor (const wxChar *propertyName) const ;
// InitializeClasses() helper
- static wxClassInfo *GetBaseByName(const wxChar *name);
+ static wxClassInfo *GetBaseByName(const wxChar *name) ;
protected:
// registers the class
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
// ----------------------------------------------------------------------------
public: \
static wxClassInfo sm_class##name; \
static const wxClassInfo* sm_classParents##name[] ; \
- static const wxPropertyInfo* GetPropertiesStatic() ; \
- static const wxHandlerInfo* GetHandlersStatic() ; \
+ static wxPropertyInfo* GetPropertiesStatic() ; \
+ static wxHandlerInfo* GetHandlersStatic() ; \
virtual wxClassInfo *GetClassInfo() const \
{ return &name::sm_class##name; }
#define IMPLEMENT_DYNAMIC_CLASS( name , basename ) \
_IMPLEMENT_DYNAMIC_CLASS( name , basename , "" ) \
-const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
-const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
+wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
+wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
WX_CONSTRUCTOR_DUMMY( name )
#define IMPLEMENT_DYNAMIC_CLASS_XTI( name , basename , unit ) \
#define IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2) \
_IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , "") \
-const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
-const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
+wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
+wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
WX_CONSTRUCTOR_DUMMY( name )
#define IMPLEMENT_DYNAMIC_CLASS2_XTI( name , basename , basename2, unit) \
#define IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
_IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
-const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
-const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; }
+wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
+wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; }
// Multiple inheritance with two base classes
#if wxUSE_EXTENDED_RTTI
+#include <map>
+#include <string>
+
+using namespace std ;
+
// ----------------------------------------------------------------------------
// Enum Support
// ----------------------------------------------------------------------------
// wxClassInfo
// ----------------------------------------------------------------------------
-const wxPropertyAccessor *wxClassInfo::FindAccessor(const char *PropertyName)
+const wxPropertyAccessor *wxClassInfo::FindAccessor(const char *PropertyName) const
{
const wxPropertyInfo* info = FindPropertyInfo( PropertyName ) ;
return NULL ;
}
-const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const char *PropertyName) const
+const wxPropertyInfo *wxClassInfo::FindPropertyInfoInThisClass (const char *PropertyName) const
{
const wxPropertyInfo* info = GetFirstProperty() ;
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 )
{
return 0;
}
-const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const char *PropertyName) const
+const wxHandlerInfo *wxClassInfo::FindHandlerInfoInThisClass (const char *PropertyName) const
{
const wxHandlerInfo* info = GetFirstHandler() ;
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 )
{
}
-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;
accessor->SetProperty( object , value ) ;
}
-wxxVariant wxClassInfo::GetProperty(wxObject *object, const char *propertyName)
+wxxVariant wxClassInfo::GetProperty(wxObject *object, const char *propertyName) const
{
const wxPropertyAccessor *accessor;
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
{
if ( persister->BeforeWriteObject( object , classInfo , name ) )
{
- int oid = m_data->m_nextId++ ;
- m_data->m_writtenObjects[object] = oid ;
- DoBeginWriteObject( object , classInfo , oid , name ) ;
- wxWriterInternalPropertiesData data ;
- WriteAllProperties( object , classInfo , persister , &data ) ;
- DoEndWriteObject( object , classInfo , oid , 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 ) ;
+ }
}
}
{
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 )
}
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 )
{
{
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) ;
}
}
}
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 ,
- (dynamic_cast<const wxClassTypeInfo*>(propertyInfo->GetTypeInfo()))->GetClassInfo()->InstanceToVariant(valo) ) ;
+ const wxClassInfo* valClassInfo = (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 = 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,
projects / wxWidgets.git / commitdiff
