Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

gcc /vc6 workarounds

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@23161 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Stefan Csomor
2003-08-24 12:22:08 +00:00
parent bc9fb5723a
commit 2abce5157d
5 changed files with 365 additions and 300 deletions
Download Patch File Download Diff File Expand all files Collapse all files

267
include/wx/xti.h
View File

@@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: wx/xti.h // Name: wx/xti.hG
// Purpose: runtime metadata information (extended class info) // Purpose: runtime metadata information (extended class info)
// Author: Stefan Csomor // Author: Stefan Csomor
// Modified by: // Modified by:
@@ -43,6 +43,30 @@
#include "wx/arrstr.h" #include "wx/arrstr.h"
#include "wx/hashmap.h" #include "wx/hashmap.h"
// we will move this later to defs.h
#if !wxCHECK_GCC_VERSION( 3 , 4 )
# define wxUSE_MEMBER_TEMPLATES 0
#endif
#ifdef _MSC_VER
# if _MSC_VER <= 1200
# define wxUSE_MEMBER_TEMPLATES 0
# endif
#endif
#ifndef wxUSE_MEMBER_TEMPLATES
#define wxUSE_MEMBER_TEMPLATES 1
#endif
#if wxUSE_MEMBER_TEMPLATES
#define WX_TEMPLATED_MEMBER_CALL( method , type ) method<type>()
#define WX_TEMPLATED_MEMBER_FIX( type )
#else
#define WX_TEMPLATED_MEMBER_CALL( method , type ) method((type*)NULL)
#define WX_TEMPLATED_MEMBER_FIX( type ) type* =NULL
#endif
class WXDLLIMPEXP_BASE wxObject; class WXDLLIMPEXP_BASE wxObject;
class WXDLLIMPEXP_BASE wxClassInfo; class WXDLLIMPEXP_BASE wxClassInfo;
class WXDLLIMPEXP_BASE wxHashTable; class WXDLLIMPEXP_BASE wxHashTable;
@@ -217,10 +241,10 @@ void wxSetToString( wxString &s , const wxBitset<e> &data )
} \ } \
void FromLong##SetName( long data , wxxVariant& result ) { result = wxxVariant(SetName((unsigned long)data)) ;} \ void FromLong##SetName( long data , wxxVariant& result ) { result = wxxVariant(SetName((unsigned long)data)) ;} \
void ToLong##SetName( const wxxVariant& data , long &result ) { result = (long) data.Get<SetName>().to_ulong() ;} \ void ToLong##SetName( const wxxVariant& data , long &result ) { result = (long) data.Get<SetName>().to_ulong() ;} \
template<> const wxTypeInfo* wxGetTypeInfo( SetName * ) \ template<> const wxTypeInfo* wxGetTypeInfo( SetName * ) \
{ \ { \
static wxEnumTypeInfo s_typeInfo(wxT_SET , &s_enumData##e , &wxToStringConverter<SetName> , &wxFromStringConverter<SetName> , &ToLong##SetName , &FromLong##SetName, #SetName ) ; return &s_typeInfo ; \ static wxEnumTypeInfo s_typeInfo(wxT_SET , &s_enumData##e , &wxToStringConverter<SetName> , &wxFromStringConverter<SetName> , &ToLong##SetName , &FromLong##SetName, #SetName ) ; return &s_typeInfo ; \
} }
template<typename e> template<typename e>
void wxFlagsFromString(const wxString &s , e &data ) void wxFlagsFromString(const wxString &s , e &data )
@@ -284,10 +308,10 @@ void wxFlagsToString( wxString &s , const e& data )
} \ } \
void FromLong##e( long data , wxxVariant& result ) { result = wxxVariant(e(data)) ;} \ void FromLong##e( long data , wxxVariant& result ) { result = wxxVariant(e(data)) ;} \
void ToLong##e( const wxxVariant& data , long &result ) { result = (long) data.Get<e>().m_data ;} \ void ToLong##e( const wxxVariant& data , long &result ) { result = (long) data.Get<e>().m_data ;} \
template<> const wxTypeInfo* wxGetTypeInfo( e * ) \ template<> const wxTypeInfo* wxGetTypeInfo( e * ) \
{ \ { \
static wxEnumTypeInfo s_typeInfo(wxT_SET , &s_enumData##e , &wxToStringConverter<e> , &wxFromStringConverter<e> , &ToLong##e , &FromLong##e, #e ) ; return &s_typeInfo ; \ static wxEnumTypeInfo s_typeInfo(wxT_SET , &s_enumData##e , &wxToStringConverter<e> , &wxFromStringConverter<e> , &ToLong##e , &FromLong##e, #e ) ; return &s_typeInfo ; \
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Type Information // Type Information
@@ -336,48 +360,48 @@ WX_DECLARE_EXPORTED_STRING_HASH_MAP( wxTypeInfo* , wxTypeInfoMap ) ;
class WXDLLIMPEXP_BASE wxTypeInfo class WXDLLIMPEXP_BASE wxTypeInfo
{ {
public : public :
typedef void (*converterToString_t)( const wxxVariant& data , wxString &result ) ; typedef void (*converterToString_t)( const wxxVariant& data , wxString &result ) ;
typedef void (*converterFromString_t)( const wxString& data , wxxVariant &result ) ; typedef void (*converterFromString_t)( const wxString& data , wxxVariant &result ) ;
wxTypeInfo(wxTypeKind kind , converterToString_t to = NULL , converterFromString_t from= NULL, const wxString &name = wxEmptyString ) : wxTypeInfo(wxTypeKind kind , converterToString_t to = NULL , converterFromString_t from= NULL, const wxString &name = wxEmptyString ) :
m_kind( kind) , m_toString(to) , m_fromString(from) , m_name(name) m_kind( kind) , m_toString(to) , m_fromString(from) , m_name(name)
{ {
Register() ; Register() ;
} }
virtual ~wxTypeInfo() virtual ~wxTypeInfo()
{ {
Unregister() ; Unregister() ;
} }
// return the kind of this type (wxT_... constants) // return the kind of this type (wxT_... constants)
wxTypeKind GetKind() const { return m_kind ; } wxTypeKind GetKind() const { return m_kind ; }
// returns the unique name of this type // returns the unique name of this type
const wxString& GetTypeName() const { return m_name ; } const wxString& GetTypeName() const { return m_name ; }
// is this type a delegate type // is this type a delegate type
bool IsDelegateType() const { return m_kind == wxT_DELEGATE ; } bool IsDelegateType() const { return m_kind == wxT_DELEGATE ; }
// is this type a custom type // is this type a custom type
bool IsCustomType() const { return m_kind == wxT_CUSTOM ; } bool IsCustomType() const { return m_kind == wxT_CUSTOM ; }
// is this type an object type // is this type an object type
bool IsObjectType() const { return m_kind == wxT_OBJECT || m_kind == wxT_OBJECT_PTR ; } bool IsObjectType() const { return m_kind == wxT_OBJECT || m_kind == wxT_OBJECT_PTR ; }
// can the content of this type be converted to and from strings ? // can the content of this type be converted to and from strings ?
bool HasStringConverters() const { return m_toString != NULL && m_fromString != NULL ; } bool HasStringConverters() const { return m_toString != NULL && m_fromString != NULL ; }
// convert a wxxVariant holding data of this type into a string // convert a wxxVariant holding data of this type into a string
void ConvertToString( const wxxVariant& data , wxString &result ) const void ConvertToString( const wxxVariant& data , wxString &result ) const
{ wxASSERT_MSG( m_toString , wxT("String conversions not supported") ) ; (*m_toString)( data , result ) ; } { wxASSERT_MSG( m_toString , wxT("String conversions not supported") ) ; (*m_toString)( data , result ) ; }
// convert a string into a wxxVariant holding the corresponding data in this type // convert a string into a wxxVariant holding the corresponding data in this type
void ConvertFromString( const wxString& data , wxxVariant &result ) const void ConvertFromString( const wxString& data , wxxVariant &result ) const
{ wxASSERT_MSG( m_fromString , wxT("String conversions not supported") ) ; (*m_fromString)( data , result ) ; } { wxASSERT_MSG( m_fromString , wxT("String conversions not supported") ) ; (*m_fromString)( data , result ) ; }
static wxTypeInfo *FindType(const wxChar *typeName); static wxTypeInfo *FindType(const wxChar *typeName);
private : private :
@@ -415,20 +439,20 @@ public :
typedef void (*converterToLong_t)( const wxxVariant& data , long &result ) ; typedef void (*converterToLong_t)( const wxxVariant& data , long &result ) ;
typedef void (*converterFromLong_t)( long data , wxxVariant &result ) ; typedef void (*converterFromLong_t)( long data , wxxVariant &result ) ;
wxEnumTypeInfo( wxTypeKind kind , wxEnumData* enumInfo , converterToString_t to , converterFromString_t from , wxEnumTypeInfo( wxTypeKind kind , wxEnumData* enumInfo , converterToString_t to , converterFromString_t from ,
converterToLong_t toLong , converterFromLong_t fromLong , const wxString &name ) : converterToLong_t toLong , converterFromLong_t fromLong , const wxString &name ) :
wxTypeInfo( kind , to , from , name ) , m_toLong( toLong ) , m_fromLong( fromLong ) wxTypeInfo( kind , to , from , name ) , m_toLong( toLong ) , m_fromLong( fromLong )
{ wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET , wxT("Illegal Kind for Enum Type")) ; m_enumInfo = enumInfo ;} { wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET , wxT("Illegal Kind for Enum Type")) ; m_enumInfo = enumInfo ;}
const wxEnumData* GetEnumData() const { return m_enumInfo ; } const wxEnumData* GetEnumData() const { return m_enumInfo ; }
// convert a wxxVariant holding data of this type into a long // convert a wxxVariant holding data of this type into a long
void ConvertToLong( const wxxVariant& data , long &result ) const void ConvertToLong( const wxxVariant& data , long &result ) const
{ wxASSERT_MSG( m_toLong , wxT("Long conversions not supported") ) ; (*m_toLong)( data , result ) ; } { wxASSERT_MSG( m_toLong , wxT("Long conversions not supported") ) ; (*m_toLong)( data , result ) ; }
// convert a long into a wxxVariant holding the corresponding data in this type // convert a long into a wxxVariant holding the corresponding data in this type
void ConvertFromLong( long data , wxxVariant &result ) const void ConvertFromLong( long data , wxxVariant &result ) const
{ wxASSERT_MSG( m_fromLong , wxT("Long conversions not supported") ) ; (*m_fromLong)( data , result ) ; } { wxASSERT_MSG( m_fromLong , wxT("Long conversions not supported") ) ; (*m_fromLong)( data , result ) ; }
private : private :
converterToLong_t m_toLong ; converterToLong_t m_toLong ;
@@ -441,7 +465,7 @@ class WXDLLIMPEXP_BASE wxClassTypeInfo : public wxTypeInfo
{ {
public : public :
wxClassTypeInfo( wxTypeKind kind , wxClassInfo* classInfo , converterToString_t to = NULL , converterFromString_t from = NULL ) ; wxClassTypeInfo( wxTypeKind kind , wxClassInfo* classInfo , converterToString_t to = NULL , converterFromString_t from = NULL ) ;
const wxClassInfo *GetClassInfo() const { return m_classInfo ; } const wxClassInfo *GetClassInfo() const { return m_classInfo ; }
private : private :
wxClassInfo *m_classInfo; // Kind == wxT_OBJECT - could be NULL wxClassInfo *m_classInfo; // Kind == wxT_OBJECT - could be NULL
} ; } ;
@@ -479,27 +503,12 @@ template<typename T> const wxTypeInfo* wxGetTypeInfo( T * ) ;
template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxCustomTypeInfo s_typeInfo(#e, &wxToStringConverter<e> , &wxFromStringConverter<e>) ; return &s_typeInfo ; } template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxCustomTypeInfo s_typeInfo(#e, &wxToStringConverter<e> , &wxFromStringConverter<e>) ; return &s_typeInfo ; }
#define WX_COLLECTION_TYPE_INFO( element , collection ) \ #define WX_COLLECTION_TYPE_INFO( element , collection ) \
template<> const wxTypeInfo* wxGetTypeInfo( collection * ) \ template<> const wxTypeInfo* wxGetTypeInfo( collection * ) \
{ \ { \
static wxCollectionTypeInfo s_typeInfo( (wxTypeInfo*) wxGetTypeInfo( (element *) NULL) , NULL , NULL , #collection ) ; \ static wxCollectionTypeInfo s_typeInfo( (wxTypeInfo*) wxGetTypeInfo( (element *) NULL) , NULL , NULL , #collection ) ; \
return &s_typeInfo ; \ return &s_typeInfo ; \
} \ } \
// templated streaming, every type must have their specialization for these methods
template<typename T>
void wxStringReadValue( const wxString &s , T &data );
template<typename T>
void wxStringWriteValue( wxString &s , const T &data);
template<typename T>
void wxToStringConverter( const wxxVariant &v, wxString &s) { wxStringWriteValue( s , v.Get<T>() ) ; }
template<typename T>
void wxFromStringConverter( const wxString &s, wxxVariant &v) { T d ; wxStringReadValue( s , d ) ; v = wxxVariant(d) ; } \
// sometimes a compiler invents specializations that are nowhere called, use this macro to satisfy the refs // sometimes a compiler invents specializations that are nowhere called, use this macro to satisfy the refs
#define WX_ILLEGAL_TYPE_SPECIALIZATION( a ) \ #define WX_ILLEGAL_TYPE_SPECIALIZATION( a ) \
@@ -561,7 +570,7 @@ public :
~wxxVariant() { delete m_data ; } ~wxxVariant() { delete m_data ; }
// get a ref to the stored data // get a ref to the stored data
template<typename T> T& Get() template<typename T> T& Get(WX_TEMPLATED_MEMBER_FIX(T))
{ {
wxxVariantDataT<T> *dataptr = dynamic_cast<wxxVariantDataT<T>*> (m_data) ; wxxVariantDataT<T> *dataptr = dynamic_cast<wxxVariantDataT<T>*> (m_data) ;
wxASSERT_MSG( dataptr , wxT("Cast not possible") ) ; wxASSERT_MSG( dataptr , wxT("Cast not possible") ) ;
@@ -569,7 +578,7 @@ public :
} }
// get a ref to the stored data // get a ref to the stored data
template<typename T> const T& Get() const template<typename T> const T& Get(WX_TEMPLATED_MEMBER_FIX(T)) const
{ {
const wxxVariantDataT<T> *dataptr = dynamic_cast<const wxxVariantDataT<T>*> (m_data) ; const wxxVariantDataT<T> *dataptr = dynamic_cast<const wxxVariantDataT<T>*> (m_data) ;
wxASSERT_MSG( dataptr , wxT("Cast not possible") ) ; wxASSERT_MSG( dataptr , wxT("Cast not possible") ) ;
@@ -619,6 +628,20 @@ private :
WX_DECLARE_OBJARRAY_WITH_DECL(wxxVariant, wxxVariantArray, class WXDLLIMPEXP_BASE); WX_DECLARE_OBJARRAY_WITH_DECL(wxxVariant, wxxVariantArray, class WXDLLIMPEXP_BASE);
// templated streaming, every type must have their specialization for these methods
template<typename T>
void wxStringReadValue( const wxString &s , T &data );
template<typename T>
void wxStringWriteValue( wxString &s , const T &data);
template<typename T>
void wxToStringConverter( const wxxVariant &v, wxString &s) { wxStringWriteValue( s , v.WX_TEMPLATED_MEMBER_CALL(Get , T) ) ; }
template<typename T>
void wxFromStringConverter( const wxString &s, wxxVariant &v) { T d ; wxStringReadValue( s , d ) ; v = wxxVariant(d) ; } \
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// Property Support // Property Support
// //
@@ -1069,7 +1092,7 @@ struct wxConstructorBridge_1 : public wxConstructorBridge
{ {
Class *obj = dynamic_cast<Class*>(o); Class *obj = dynamic_cast<Class*>(o);
obj->Create( obj->Create(
args[0].Get<T0>() args[0].WX_TEMPLATED_MEMBER_CALL(Get , T0)
); );
} }
}; };
@@ -1090,8 +1113,8 @@ struct wxConstructorBridge_2 : public wxConstructorBridge
{ {
Class *obj = dynamic_cast<Class*>(o); Class *obj = dynamic_cast<Class*>(o);
obj->Create( obj->Create(
args[0].Get<T0>() , args[0].WX_TEMPLATED_MEMBER_CALL(Get , T0) ,
args[1].Get<T1>() args[1].WX_TEMPLATED_MEMBER_CALL(Get , T1)
); );
} }
}; };
@@ -1112,9 +1135,9 @@ struct wxConstructorBridge_3 : public wxConstructorBridge
{ {
Class *obj = dynamic_cast<Class*>(o); Class *obj = dynamic_cast<Class*>(o);
obj->Create( obj->Create(
args[0].Get<T0>() , args[0].WX_TEMPLATED_MEMBER_CALL(Get , T0) ,
args[1].Get<T1>() , args[1].WX_TEMPLATED_MEMBER_CALL(Get , T1) ,
args[2].Get<T2>() args[2].WX_TEMPLATED_MEMBER_CALL(Get , T2)
); );
} }
}; };
@@ -1135,10 +1158,10 @@ struct wxConstructorBridge_4 : public wxConstructorBridge
{ {
Class *obj = dynamic_cast<Class*>(o); Class *obj = dynamic_cast<Class*>(o);
obj->Create( obj->Create(
args[0].Get<T0>() , args[0].WX_TEMPLATED_MEMBER_CALL(Get , T0) ,
args[1].Get<T1>() , args[1].WX_TEMPLATED_MEMBER_CALL(Get , T1) ,
args[2].Get<T2>() , args[2].WX_TEMPLATED_MEMBER_CALL(Get , T2) ,
args[3].Get<T3>() args[3].WX_TEMPLATED_MEMBER_CALL(Get , T3)
); );
} }
}; };
@@ -1159,11 +1182,11 @@ struct wxConstructorBridge_5 : public wxConstructorBridge
{ {
Class *obj = dynamic_cast<Class*>(o); Class *obj = dynamic_cast<Class*>(o);
obj->Create( obj->Create(
args[0].Get<T0>() , args[0].WX_TEMPLATED_MEMBER_CALL(Get , T0) ,
args[1].Get<T1>() , args[1].WX_TEMPLATED_MEMBER_CALL(Get , T1) ,
args[2].Get<T2>() , args[2].WX_TEMPLATED_MEMBER_CALL(Get , T2) ,
args[3].Get<T3>() , args[3].WX_TEMPLATED_MEMBER_CALL(Get , T3) ,
args[4].Get<T4>() args[4].WX_TEMPLATED_MEMBER_CALL(Get , T4)
); );
} }
}; };
@@ -1184,16 +1207,39 @@ struct wxConstructorBridge_6 : public wxConstructorBridge
{ {
Class *obj = dynamic_cast<Class*>(o); Class *obj = dynamic_cast<Class*>(o);
obj->Create( obj->Create(
args[0].Get<T0>() , args[0].WX_TEMPLATED_MEMBER_CALL(Get , T0) ,
args[1].Get<T1>() , args[1].WX_TEMPLATED_MEMBER_CALL(Get , T1) ,
args[2].Get<T2>() , args[2].WX_TEMPLATED_MEMBER_CALL(Get , T2) ,
args[3].Get<T3>() , args[3].WX_TEMPLATED_MEMBER_CALL(Get , T3) ,
args[4].Get<T4>() , args[4].WX_TEMPLATED_MEMBER_CALL(Get , T4) ,
args[5].Get<T5>() args[5].WX_TEMPLATED_MEMBER_CALL(Get , T5)
); );
} }
}; };
template<typename Class,
typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
struct wxDirectConstructorBridge_6 : public wxConstructorBridge
{
void Create(wxObject *o, wxxVariant *args)
{
Class *obj = new Class(
args[0].WX_TEMPLATED_MEMBER_CALL(Get , T0) ,
args[1].WX_TEMPLATED_MEMBER_CALL(Get , T1) ,
args[2].WX_TEMPLATED_MEMBER_CALL(Get , T2) ,
args[3].WX_TEMPLATED_MEMBER_CALL(Get , T3) ,
args[4].WX_TEMPLATED_MEMBER_CALL(Get , T4) ,
args[5].WX_TEMPLATED_MEMBER_CALL(Get , T5)
);
}
};
#define WX_DIRECT_CONSTRUCTOR_6(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \
wxDirectConstructorBridge_6<klass,t0,t1,t2,t3,t4,t5> constructor##klass ; \
wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 , #v4 , #v5 } ; \
const int klass::sm_constructorPropertiesCount##klass = 6;
#define WX_CONSTRUCTOR_6(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \ #define WX_CONSTRUCTOR_6(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \
wxConstructorBridge_6<klass,t0,t1,t2,t3,t4,t5> constructor##klass ; \ wxConstructorBridge_6<klass,t0,t1,t2,t3,t4,t5> constructor##klass ; \
wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \ wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
@@ -1210,13 +1256,13 @@ struct wxConstructorBridge_7 : public wxConstructorBridge
{ {
Class *obj = dynamic_cast<Class*>(o); Class *obj = dynamic_cast<Class*>(o);
obj->Create( obj->Create(
args[0].Get<T0>() , args[0].WX_TEMPLATED_MEMBER_CALL(Get , T0) ,
args[1].Get<T1>() , args[1].WX_TEMPLATED_MEMBER_CALL(Get , T1) ,
args[2].Get<T2>() , args[2].WX_TEMPLATED_MEMBER_CALL(Get , T2) ,
args[3].Get<T3>() , args[3].WX_TEMPLATED_MEMBER_CALL(Get , T3) ,
args[4].Get<T4>() , args[4].WX_TEMPLATED_MEMBER_CALL(Get , T4) ,
args[5].Get<T5>() , args[5].WX_TEMPLATED_MEMBER_CALL(Get , T5) ,
args[6].Get<T6>() args[6].WX_TEMPLATED_MEMBER_CALL(Get , T6)
); );
} }
}; };
@@ -1237,14 +1283,14 @@ struct wxConstructorBridge_8 : public wxConstructorBridge
{ {
Class *obj = dynamic_cast<Class*>(o); Class *obj = dynamic_cast<Class*>(o);
obj->Create( obj->Create(
args[0].Get<T0>() , args[0].WX_TEMPLATED_MEMBER_CALL(Get , T0) ,
args[1].Get<T1>() , args[1].WX_TEMPLATED_MEMBER_CALL(Get , T1) ,
args[2].Get<T2>() , args[2].WX_TEMPLATED_MEMBER_CALL(Get , T2) ,
args[3].Get<T3>() , args[3].WX_TEMPLATED_MEMBER_CALL(Get , T3) ,
args[4].Get<T4>() , args[4].WX_TEMPLATED_MEMBER_CALL(Get , T4) ,
args[5].Get<T5>() , args[5].WX_TEMPLATED_MEMBER_CALL(Get , T5) ,
args[6].Get<T6>() , args[6].WX_TEMPLATED_MEMBER_CALL(Get , T6) ,
args[7].Get<T7>() args[7].WX_TEMPLATED_MEMBER_CALL(Get , T7)
); );
} }
}; };
@@ -1285,8 +1331,8 @@ public:
) : m_parents(_Parents) , m_unitName(_UnitName) ,m_className(_ClassName), ) : m_parents(_Parents) , m_unitName(_UnitName) ,m_className(_ClassName),
m_objectSize(size), m_objectConstructor(ctor) , m_firstProperty(_Props ) , m_firstHandler(_Handlers ) , m_constructor( _Constructor ) , m_objectSize(size), m_objectConstructor(ctor) , m_firstProperty(_Props ) , m_firstHandler(_Handlers ) , m_constructor( _Constructor ) ,
m_constructorProperties(_ConstructorProperties) , m_constructorPropertiesCount(_ConstructorPropertiesCount), m_constructorProperties(_ConstructorProperties) , m_constructorPropertiesCount(_ConstructorPropertiesCount),
m_variantOfPtrToObjectConverter( _PtrConverter1 ) , m_variantToObjectConverter( _Converter2 ) , m_objectToVariantConverter( _Converter3 ) , m_variantOfPtrToObjectConverter( _PtrConverter1 ) , m_variantToObjectConverter( _Converter2 ) , m_objectToVariantConverter( _Converter3 ) ,
m_next(sm_first) , m_streamingCallback( _streamingCallback ) m_next(sm_first) , m_streamingCallback( _streamingCallback )
{ {
sm_first = this; sm_first = this;
Register() ; Register() ;
@@ -1294,7 +1340,7 @@ public:
wxClassInfo(const wxChar *_UnitName, const wxChar *_ClassName, const wxClassInfo **_Parents) : m_parents(_Parents) , m_unitName(_UnitName) ,m_className(_ClassName), 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_objectSize(0), m_objectConstructor(NULL) , m_firstProperty(NULL ) , m_firstHandler(NULL ) , m_constructor( NULL ) ,
m_constructorProperties(NULL) , m_constructorPropertiesCount(NULL), m_constructorProperties(NULL) , m_constructorPropertiesCount(0),
m_variantOfPtrToObjectConverter( NULL ) , m_variantToObjectConverter( NULL ) , m_objectToVariantConverter( NULL ) , m_next(sm_first) , m_variantOfPtrToObjectConverter( NULL ) , m_variantToObjectConverter( NULL ) , m_objectToVariantConverter( NULL ) , m_next(sm_first) ,
m_streamingCallback( NULL ) m_streamingCallback( NULL )
{ {
@@ -1484,8 +1530,17 @@ public :
virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value) const ; virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value) const ;
virtual wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName) const ; virtual wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName) const ;
// adds a property to this class at runtime
void AddProperty( const wxChar *propertyName , const wxTypeInfo* typeInfo ) ; void AddProperty( const wxChar *propertyName , const wxTypeInfo* typeInfo ) ;
// removes an existing runtime-property
void RemoveProperty( const wxChar *propertyName ) ;
// as a handler to this class at runtime
void AddHandler( const wxChar *handlerName , wxObjectEventFunction address , const wxClassInfo* eventClassInfo ) ; void AddHandler( const wxChar *handlerName , wxObjectEventFunction address , const wxClassInfo* eventClassInfo ) ;
// removes an existing runtime-handler
void RemoveHandler( const wxChar *handlerName ) ;
} ; } ;
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -1500,7 +1555,7 @@ public :
static wxHandlerInfo* GetHandlersStatic() ; \ static wxHandlerInfo* GetHandlersStatic() ; \
static wxClassInfo *GetClassInfoStatic() \ static wxClassInfo *GetClassInfoStatic() \
{ return &name::sm_class##name; } \ { return &name::sm_class##name; } \
virtual wxClassInfo *GetClassInfo() const \ virtual wxClassInfo *GetClassInfo() const \
{ return &name::sm_class##name; } { return &name::sm_class##name; }
#define DECLARE_DYNAMIC_CLASS(name) \ #define DECLARE_DYNAMIC_CLASS(name) \
@@ -1698,9 +1753,9 @@ public :
// Collection Support // Collection Support
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
template<typename collection_t> void wxListCollectionToVariantArray( const collection_t& coll , wxxVariantArray &value ) template<typename iter , typename collection_t > void wxListCollectionToVariantArray( const collection_t& coll , wxxVariantArray &value )
{ {
collection_t::compatibility_iterator current = coll.GetFirst() ; iter current = coll.GetFirst() ;
while (current) while (current)
{ {
value.Add( new wxxVariant(current->GetData()) ) ; value.Add( new wxxVariant(current->GetData()) ) ;

6
include/wx/xtistrm.h
View File

@@ -70,8 +70,8 @@ public :
virtual bool BeforeWriteDelegate( wxWriter *WXUNUSED(writer) , const wxObject *WXUNUSED(object), const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *WXUNUSED(propInfo) , virtual bool BeforeWriteDelegate( wxWriter *WXUNUSED(writer) , const wxObject *WXUNUSED(object), const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *WXUNUSED(propInfo) ,
const wxObject *&WXUNUSED(eventSink) , const wxHandlerInfo* &WXUNUSED(handlerInfo) ) { return true ; } const wxObject *&WXUNUSED(eventSink) , const wxHandlerInfo* &WXUNUSED(handlerInfo) ) { return true ; }
virtual void AfterWriteDelegate( wxWriter *WXUNUSED(writer) , const wxObject *WXUNUSED(object), const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *WXUNUSED(propInfo) , virtual void AfterWriteDelegate( wxWriter *WXUNUSED(writer) , const wxObject *WXUNUSED(object), const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *WXUNUSED(propInfo) ,
const wxObject *&WXUNUSED(eventSink) , const wxHandlerInfo* &WXUNUSED(handlerInfo) ) { } const wxObject *&WXUNUSED(eventSink) , const wxHandlerInfo* &WXUNUSED(handlerInfo) ) { }
} ; } ;
class wxWriter : public wxObject class wxWriter : public wxObject
@@ -90,7 +90,7 @@ public :
// made without wanting to have duplicate objects written, the object identity table will be reset manually // made without wanting to have duplicate objects written, the object identity table will be reset manually
virtual void ClearObjectContext() ; virtual void ClearObjectContext() ;
// gets the object Id for a passed in object in the context // gets the object Id for a passed in object in the context
int GetObjectID(const wxObject *obj) ; int GetObjectID(const wxObject *obj) ;

258
src/common/xti.cpp
View File

@@ -22,9 +22,9 @@
#endif #endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/hash.h" #include "wx/hash.h"
#include "wx/object.h" #include "wx/object.h"
#include "wx/xti.h" #include "wx/xti.h"
#endif #endif
#include "wx/xml/xml.h" #include "wx/xml/xml.h"
@@ -47,36 +47,36 @@ using namespace std ;
wxEnumData::wxEnumData( wxEnumMemberData* data ) wxEnumData::wxEnumData( wxEnumMemberData* data )
{ {
m_members = data ; m_members = data ;
for ( m_count = 0; m_members[m_count].m_name ; m_count++) for ( m_count = 0; m_members[m_count].m_name ; m_count++)
{} ; {} ;
} }
bool wxEnumData::HasEnumMemberValue(const wxChar *name, int *value) bool wxEnumData::HasEnumMemberValue(const wxChar *name, int *value)
{ {
int i; int i;
for (i = 0; m_members[i].m_name ; i++ ) for (i = 0; m_members[i].m_name ; i++ )
{ {
if (!strcmp(name, m_members[i].m_name)) if (!strcmp(name, m_members[i].m_name))
{ {
if ( value ) if ( value )
*value = m_members[i].m_value; *value = m_members[i].m_value;
return true ; return true ;
} }
} }
return false ; return false ;
} }
int wxEnumData::GetEnumMemberValue(const wxChar *name) int wxEnumData::GetEnumMemberValue(const wxChar *name)
{ {
int i; int i;
for (i = 0; m_members[i].m_name ; i++ ) for (i = 0; m_members[i].m_name ; i++ )
{ {
if (!strcmp(name, m_members[i].m_name)) if (!strcmp(name, m_members[i].m_name))
{ {
return m_members[i].m_value; return m_members[i].m_value;
} }
} }
return 0 ; return 0 ;
} }
@@ -84,22 +84,22 @@ const wxChar *wxEnumData::GetEnumMemberName(int value)
{ {
int i; int i;
for (i = 0; m_members[i].m_name ; i++) for (i = 0; m_members[i].m_name ; i++)
if (value == m_members[i].m_value) if (value == m_members[i].m_value)
return m_members[i].m_name; return m_members[i].m_name;
return wxT("") ; return wxT("") ;
} }
int wxEnumData::GetEnumMemberValueByIndex( int idx ) int wxEnumData::GetEnumMemberValueByIndex( int idx )
{ {
// we should cache the count in order to avoid out-of-bounds errors // we should cache the count in order to avoid out-of-bounds errors
return m_members[idx].m_value ; return m_members[idx].m_value ;
} }
const char * wxEnumData::GetEnumMemberNameByIndex( int idx ) const char * wxEnumData::GetEnumMemberNameByIndex( int idx )
{ {
// we should cache the count in order to avoid out-of-bounds errors // we should cache the count in order to avoid out-of-bounds errors
return m_members[idx].m_name ; return m_members[idx].m_name ;
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -116,126 +116,126 @@ const char * wxEnumData::GetEnumMemberNameByIndex( int idx )
template<> void wxStringReadValue(const wxString &s , bool &data ) template<> void wxStringReadValue(const wxString &s , bool &data )
{ {
int intdata ; int intdata ;
wxSscanf(s, _T("%d"), &intdata ) ; wxSscanf(s, _T("%d"), &intdata ) ;
data = bool(intdata) ; data = bool(intdata) ;
} }
template<> void wxStringWriteValue(wxString &s , const bool &data ) template<> void wxStringWriteValue(wxString &s , const bool &data )
{ {
s = wxString::Format("%d", data ) ; s = wxString::Format("%d", data ) ;
} }
// char // char
template<> void wxStringReadValue(const wxString &s , char &data ) template<> void wxStringReadValue(const wxString &s , char &data )
{ {
int intdata ; int intdata ;
wxSscanf(s, _T("%d"), &intdata ) ; wxSscanf(s, _T("%d"), &intdata ) ;
data = char(intdata) ; data = char(intdata) ;
} }
template<> void wxStringWriteValue(wxString &s , const char &data ) template<> void wxStringWriteValue(wxString &s , const char &data )
{ {
s = wxString::Format("%d", data ) ; s = wxString::Format("%d", data ) ;
} }
// unsigned char // unsigned char
template<> void wxStringReadValue(const wxString &s , unsigned char &data ) template<> void wxStringReadValue(const wxString &s , unsigned char &data )
{ {
int intdata ; int intdata ;
wxSscanf(s, _T("%d"), &intdata ) ; wxSscanf(s, _T("%d"), &intdata ) ;
data = (unsigned char)(intdata) ; data = (unsigned char)(intdata) ;
} }
template<> void wxStringWriteValue(wxString &s , const unsigned char &data ) template<> void wxStringWriteValue(wxString &s , const unsigned char &data )
{ {
s = wxString::Format("%d", data ) ; s = wxString::Format("%d", data ) ;
} }
// int // int
template<> void wxStringReadValue(const wxString &s , int &data ) template<> void wxStringReadValue(const wxString &s , int &data )
{ {
wxSscanf(s, _T("%d"), &data ) ; wxSscanf(s, _T("%d"), &data ) ;
} }
template<> void wxStringWriteValue(wxString &s , const int &data ) template<> void wxStringWriteValue(wxString &s , const int &data )
{ {
s = wxString::Format("%d", data ) ; s = wxString::Format("%d", data ) ;
} }
// unsigned int // unsigned int
template<> void wxStringReadValue(const wxString &s , unsigned int &data ) template<> void wxStringReadValue(const wxString &s , unsigned int &data )
{ {
wxSscanf(s, _T("%d"), &data ) ; wxSscanf(s, _T("%d"), &data ) ;
} }
template<> void wxStringWriteValue(wxString &s , const unsigned int &data ) template<> void wxStringWriteValue(wxString &s , const unsigned int &data )
{ {
s = wxString::Format("%d", data ) ; s = wxString::Format("%d", data ) ;
} }
// long // long
template<> void wxStringReadValue(const wxString &s , long &data ) template<> void wxStringReadValue(const wxString &s , long &data )
{ {
wxSscanf(s, _T("%ld"), &data ) ; wxSscanf(s, _T("%ld"), &data ) ;
} }
template<> void wxStringWriteValue(wxString &s , const long &data ) template<> void wxStringWriteValue(wxString &s , const long &data )
{ {
s = wxString::Format("%ld", data ) ; s = wxString::Format("%ld", data ) ;
} }
// unsigned long // unsigned long
template<> void wxStringReadValue(const wxString &s , unsigned long &data ) template<> void wxStringReadValue(const wxString &s , unsigned long &data )
{ {
wxSscanf(s, _T("%ld"), &data ) ; wxSscanf(s, _T("%ld"), &data ) ;
} }
template<> void wxStringWriteValue(wxString &s , const unsigned long &data ) template<> void wxStringWriteValue(wxString &s , const unsigned long &data )
{ {
s = wxString::Format("%ld", data ) ; s = wxString::Format("%ld", data ) ;
} }
// float // float
template<> void wxStringReadValue(const wxString &s , float &data ) template<> void wxStringReadValue(const wxString &s , float &data )
{ {
wxSscanf(s, _T("%f"), &data ) ; wxSscanf(s, _T("%f"), &data ) ;
} }
template<> void wxStringWriteValue(wxString &s , const float &data ) template<> void wxStringWriteValue(wxString &s , const float &data )
{ {
s = wxString::Format("%f", data ) ; s = wxString::Format("%f", data ) ;
} }
// double // double
template<> void wxStringReadValue(const wxString &s , double &data ) template<> void wxStringReadValue(const wxString &s , double &data )
{ {
wxSscanf(s, _T("%lf"), &data ) ; wxSscanf(s, _T("%lf"), &data ) ;
} }
template<> void wxStringWriteValue(wxString &s , const double &data ) template<> void wxStringWriteValue(wxString &s , const double &data )
{ {
s = wxString::Format("%lf", data ) ; s = wxString::Format("%lf", data ) ;
} }
// wxString // wxString
template<> void wxStringReadValue(const wxString &s , wxString &data ) template<> void wxStringReadValue(const wxString &s , wxString &data )
{ {
data = s ; data = s ;
} }
template<> void wxStringWriteValue(wxString &s , const wxString &data ) template<> void wxStringWriteValue(wxString &s , const wxString &data )
{ {
s = data ; s = data ;
} }
// built-ins // built-ins
@@ -243,68 +243,68 @@ template<> void wxStringWriteValue(wxString &s , const wxString &data )
template<> const wxTypeInfo* wxGetTypeInfo( void * ) template<> const wxTypeInfo* wxGetTypeInfo( void * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_VOID ) ; static wxBuiltInTypeInfo s_typeInfo( wxT_VOID ) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( bool * ) template<> const wxTypeInfo* wxGetTypeInfo( bool * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_BOOL , &wxToStringConverter<bool> , &wxFromStringConverter<bool>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_BOOL , &wxToStringConverter<bool> , &wxFromStringConverter<bool>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( char * ) template<> const wxTypeInfo* wxGetTypeInfo( char * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_CHAR , &wxToStringConverter<char> , &wxFromStringConverter<char>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_CHAR , &wxToStringConverter<char> , &wxFromStringConverter<char>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( unsigned char * ) template<> const wxTypeInfo* wxGetTypeInfo( unsigned char * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_UCHAR , &wxToStringConverter< unsigned char > , &wxFromStringConverter<unsigned char>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_UCHAR , &wxToStringConverter< unsigned char > , &wxFromStringConverter<unsigned char>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( int * ) template<> const wxTypeInfo* wxGetTypeInfo( int * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_CHAR , &wxToStringConverter<int> , &wxFromStringConverter<int>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_CHAR , &wxToStringConverter<int> , &wxFromStringConverter<int>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( unsigned int * ) template<> const wxTypeInfo* wxGetTypeInfo( unsigned int * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_UCHAR , &wxToStringConverter<unsigned int> , &wxFromStringConverter<unsigned int>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_UCHAR , &wxToStringConverter<unsigned int> , &wxFromStringConverter<unsigned int>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( long * ) template<> const wxTypeInfo* wxGetTypeInfo( long * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_LONG , &wxToStringConverter<long> , &wxFromStringConverter<long>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_LONG , &wxToStringConverter<long> , &wxFromStringConverter<long>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( unsigned long * ) template<> const wxTypeInfo* wxGetTypeInfo( unsigned long * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_ULONG , &wxToStringConverter<unsigned long> , &wxFromStringConverter<unsigned long>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_ULONG , &wxToStringConverter<unsigned long> , &wxFromStringConverter<unsigned long>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( float * ) template<> const wxTypeInfo* wxGetTypeInfo( float * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_FLOAT , &wxToStringConverter<float> , &wxFromStringConverter<float>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_FLOAT , &wxToStringConverter<float> , &wxFromStringConverter<float>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( double * ) template<> const wxTypeInfo* wxGetTypeInfo( double * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_DOUBLE , &wxToStringConverter<double> , &wxFromStringConverter<double>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_DOUBLE , &wxToStringConverter<double> , &wxFromStringConverter<double>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
template<> const wxTypeInfo* wxGetTypeInfo( wxString * ) template<> const wxTypeInfo* wxGetTypeInfo( wxString * )
{ {
static wxBuiltInTypeInfo s_typeInfo( wxT_STRING , &wxToStringConverter<wxString> , &wxFromStringConverter<wxString>) ; static wxBuiltInTypeInfo s_typeInfo( wxT_STRING , &wxToStringConverter<wxString> , &wxFromStringConverter<wxString>) ;
return &s_typeInfo ; return &s_typeInfo ;
} }
// this are compiler induced specialization which are never used anywhere // this are compiler induced specialization which are never used anywhere
@@ -336,8 +336,8 @@ wxTypeInfo( kind , to , from , classInfo->GetClassName() )
{ wxASSERT_MSG( kind == wxT_OBJECT_PTR || kind == wxT_OBJECT , wxT("Illegal Kind for Enum Type")) ; m_classInfo = classInfo ;} { wxASSERT_MSG( kind == wxT_OBJECT_PTR || kind == wxT_OBJECT , wxT("Illegal Kind for Enum Type")) ; m_classInfo = classInfo ;}
wxDelegateTypeInfo::wxDelegateTypeInfo( int eventType , wxClassInfo* eventClass , converterToString_t to , converterFromString_t from ) : wxDelegateTypeInfo::wxDelegateTypeInfo( int eventType , wxClassInfo* eventClass , converterToString_t to , converterFromString_t from ) :
wxTypeInfo ( wxT_DELEGATE , to , from , wxEmptyString ) wxTypeInfo ( wxT_DELEGATE , to , from , wxEmptyString )
{ m_eventClass = eventClass ; m_eventType = eventType ;} { m_eventClass = eventClass ; m_eventType = eventType ;}
void wxTypeInfo::Register() void wxTypeInfo::Register()
{ {
@@ -352,7 +352,7 @@ void wxTypeInfo::Unregister()
{ {
if( !m_name.IsEmpty() ) if( !m_name.IsEmpty() )
sm_typeTable->erase(m_name); sm_typeTable->erase(m_name);
} }
// removing header dependancy on string tokenizer // removing header dependancy on string tokenizer
@@ -360,11 +360,11 @@ void wxSetStringToArray( const wxString &s , wxArrayString &array )
{ {
wxStringTokenizer tokenizer(s, wxT("| \t\n"), wxTOKEN_STRTOK); wxStringTokenizer tokenizer(s, wxT("| \t\n"), wxTOKEN_STRTOK);
wxString flag; wxString flag;
array.Clear() ; array.Clear() ;
while (tokenizer.HasMoreTokens()) while (tokenizer.HasMoreTokens())
{ {
array.Add(tokenizer.GetNextToken()) ; array.Add(tokenizer.GetNextToken()) ;
} }
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -375,69 +375,69 @@ const wxPropertyAccessor *wxClassInfo::FindAccessor(const char *PropertyName) co
{ {
const wxPropertyInfo* info = FindPropertyInfo( PropertyName ) ; const wxPropertyInfo* info = FindPropertyInfo( PropertyName ) ;
if ( info ) if ( info )
return info->GetAccessor() ; return info->GetAccessor() ;
return NULL ; return NULL ;
} }
const wxPropertyInfo *wxClassInfo::FindPropertyInfoInThisClass (const char *PropertyName) const const wxPropertyInfo *wxClassInfo::FindPropertyInfoInThisClass (const char *PropertyName) const
{ {
const wxPropertyInfo* info = GetFirstProperty() ; const wxPropertyInfo* info = GetFirstProperty() ;
while( info ) while( info )
{ {
if ( strcmp( info->GetName() , PropertyName ) == 0 ) if ( strcmp( info->GetName() , PropertyName ) == 0 )
return info ; return info ;
info = info->GetNext() ; info = info->GetNext() ;
} }
return 0; return 0;
} }
const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const char *PropertyName) const const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const char *PropertyName) const
{ {
const wxPropertyInfo* info = FindPropertyInfoInThisClass( PropertyName ) ; const wxPropertyInfo* info = FindPropertyInfoInThisClass( PropertyName ) ;
if ( info ) if ( info )
return info ; return info ;
const wxClassInfo** parents = GetParents() ; const wxClassInfo** parents = GetParents() ;
for ( int i = 0 ; parents[i] ; ++ i ) for ( int i = 0 ; parents[i] ; ++ i )
{ {
if ( ( info = parents[i]->FindPropertyInfo( PropertyName ) ) != NULL ) if ( ( info = parents[i]->FindPropertyInfo( PropertyName ) ) != NULL )
return info ; return info ;
} }
return 0; return 0;
} }
const wxHandlerInfo *wxClassInfo::FindHandlerInfoInThisClass (const char *PropertyName) const const wxHandlerInfo *wxClassInfo::FindHandlerInfoInThisClass (const char *PropertyName) const
{ {
const wxHandlerInfo* info = GetFirstHandler() ; const wxHandlerInfo* info = GetFirstHandler() ;
while( info ) while( info )
{ {
if ( strcmp( info->GetName() , PropertyName ) == 0 ) if ( strcmp( info->GetName() , PropertyName ) == 0 )
return info ; return info ;
info = info->GetNext() ; info = info->GetNext() ;
} }
return 0; return 0;
} }
const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const char *PropertyName) const const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const char *PropertyName) const
{ {
const wxHandlerInfo* info = FindHandlerInfoInThisClass( PropertyName ) ; const wxHandlerInfo* info = FindHandlerInfoInThisClass( PropertyName ) ;
if ( info ) if ( info )
return info ; return info ;
const wxClassInfo** parents = GetParents() ; const wxClassInfo** parents = GetParents() ;
for ( int i = 0 ; parents[i] ; ++ i ) for ( int i = 0 ; parents[i] ; ++ i )
{ {
if ( ( info = parents[i]->FindHandlerInfo( PropertyName ) ) != NULL ) if ( ( info = parents[i]->FindHandlerInfo( PropertyName ) ) != NULL )
return info ; return info ;
} }
return 0; return 0;
} }
@@ -448,11 +448,11 @@ wxObjectStreamingCallback wxClassInfo::GetStreamingCallback() const
return m_streamingCallback ; return m_streamingCallback ;
wxObjectStreamingCallback retval = NULL ; wxObjectStreamingCallback retval = NULL ;
const wxClassInfo** parents = GetParents() ; const wxClassInfo** parents = GetParents() ;
for ( int i = 0 ; parents[i] && retval == NULL ; ++ i ) for ( int i = 0 ; parents[i] && retval == NULL ; ++ i )
{ {
retval = parents[i]->GetStreamingCallback() ; retval = parents[i]->GetStreamingCallback() ;
} }
return retval ; return retval ;
} }
@@ -471,7 +471,7 @@ void wxClassInfo::SetProperty(wxObject *object, const char *propertyName, const
accessor = FindAccessor(propertyName); accessor = FindAccessor(propertyName);
wxASSERT(accessor->HasSetter()); wxASSERT(accessor->HasSetter());
accessor->SetProperty( object , value ) ; accessor->SetProperty( object , value ) ;
} }
wxxVariant wxClassInfo::GetProperty(wxObject *object, const char *propertyName) const wxxVariant wxClassInfo::GetProperty(wxObject *object, const char *propertyName) const
@@ -529,11 +529,11 @@ VARIANT TO OBJECT
wxObject* wxxVariant::GetAsObject() wxObject* wxxVariant::GetAsObject()
{ {
const wxClassTypeInfo *ti = dynamic_cast<const wxClassTypeInfo*>( m_data->GetTypeInfo() ) ; const wxClassTypeInfo *ti = dynamic_cast<const wxClassTypeInfo*>( m_data->GetTypeInfo() ) ;
if ( ti ) if ( ti )
return ti->GetClassInfo()->VariantToInstance(*this) ; return ti->GetClassInfo()->VariantToInstance(*this) ;
else else
return NULL ; return NULL ;
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -571,8 +571,8 @@ void wxDynamicObject::SetProperty (const wxChar *propertyName, const wxxVariant
wxxVariant wxDynamicObject::GetProperty (const wxChar *propertyName) const wxxVariant wxDynamicObject::GetProperty (const wxChar *propertyName) const
{ {
wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),wxT("Accessing Unknown Property in a Dynamic Object") ) ; wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),wxT("Accessing Unknown Property in a Dynamic Object") ) ;
return m_data->m_properties[propertyName] ; return m_data->m_properties[propertyName] ;
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -580,7 +580,7 @@ wxxVariant wxDynamicObject::GetProperty (const wxChar *propertyName) const
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
wxDynamicClassInfo::wxDynamicClassInfo( const wxChar *unitName, const wxChar *className , const wxClassInfo* superClass ) : wxDynamicClassInfo::wxDynamicClassInfo( const wxChar *unitName, const wxChar *className , const wxClassInfo* superClass ) :
wxClassInfo( unitName, className , new const wxClassInfo*[2]) wxClassInfo( unitName, className , new const wxClassInfo*[2])
{ {
GetParents()[0] = superClass ; GetParents()[0] = superClass ;
GetParents()[1] = NULL ; GetParents()[1] = NULL ;
@@ -646,6 +646,16 @@ void wxDynamicClassInfo::AddHandler( const wxChar *handlerName , wxObjectEventFu
new wxHandlerInfo( m_firstHandler , handlerName , address , eventClassInfo ) ; new wxHandlerInfo( m_firstHandler , handlerName , address , eventClassInfo ) ;
} }
// removes an existing runtime-property
void wxDynamicClassInfo::RemoveProperty( const wxChar *propertyName )
{
}
// removes an existing runtime-handler
void wxDynamicClassInfo::RemoveHandler( const wxChar *handlerName )
{
}
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// wxGenericPropertyAccessor // wxGenericPropertyAccessor
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

92
src/common/xtistrm.cpp
View File

@@ -1,8 +1,8 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// 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 // Created: 27/07/03
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 2003 Stefan Csomor // Copyright: (c) 2003 Stefan Csomor
@@ -120,7 +120,7 @@ void wxWriter::FindConnectEntry(const wxEvtHandler * evSource,const wxDelegateTy
wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData(); wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
// find the match // find the match
if ( entry->m_fn && if ( entry->m_fn &&
(dti->GetEventType() == entry->m_eventType) && (dti->GetEventType() == entry->m_eventType) &&
(entry->m_id == -1 ) && (entry->m_id == -1 ) &&
(entry->m_eventSink != NULL ) ) (entry->m_eventSink != NULL ) )
@@ -175,7 +175,7 @@ void wxWriter::WriteAllProperties( const wxObject * obj , const wxClassInfo* ci
} }
} }
void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , const wxPropertyInfo* pi , wxPersister *persister , wxWriterInternalPropertiesData *WXUNUSED(data) ) void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , const wxPropertyInfo* pi , wxPersister *persister , wxWriterInternalPropertiesData *WXUNUSED(data) )
{ {
if ( pi->GetFlags() & wxPROP_DONT_STREAM ) if ( pi->GetFlags() & wxPROP_DONT_STREAM )
return ; return ;
@@ -207,7 +207,7 @@ void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , c
} }
else else
{ {
DoWriteSimpleType( value ) ; DoWriteSimpleType( value ) ;
} }
} }
DoEndWriteElement() ; DoEndWriteElement() ;
@@ -249,7 +249,7 @@ void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , c
WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT , md) ; WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT , md) ;
} }
else else
{ {
if ( pi->GetFlags() & wxPROP_ENUM_STORE_LONG ) if ( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
{ {
const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ; const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
@@ -264,7 +264,7 @@ void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , c
DoEndWriteProperty( pi ) ; DoEndWriteProperty( pi ) ;
} }
int wxWriter::GetObjectID(const wxObject *obj) int wxWriter::GetObjectID(const wxObject *obj)
{ {
if ( !IsObjectKnown( obj ) ) if ( !IsObjectKnown( obj ) )
return wxInvalidObjectID ; return wxInvalidObjectID ;
@@ -272,14 +272,14 @@ int wxWriter::GetObjectID(const wxObject *obj)
return m_data->m_writtenObjects[obj] ; return m_data->m_writtenObjects[obj] ;
} }
bool wxWriter::IsObjectKnown( const wxObject *obj ) bool wxWriter::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 // reading objects in
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
struct wxReader::wxReaderInternal struct wxReader::wxReaderInternal
@@ -287,7 +287,7 @@ struct wxReader::wxReaderInternal
map<int,wxClassInfo*> m_classInfos; map<int,wxClassInfo*> m_classInfos;
}; };
wxReader::wxReader() wxReader::wxReader()
{ {
m_data = new wxReaderInternal; m_data = new wxReaderInternal;
} }
@@ -309,17 +309,17 @@ void wxReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo )
m_data->m_classInfos[objectID] = classInfo ; m_data->m_classInfos[objectID] = classInfo ;
} }
bool wxReader::HasObjectClassInfo( int objectID ) bool wxReader::HasObjectClassInfo( int objectID )
{ {
return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() ; 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 Reading components has not to be extended for components
as properties are always sought by typeinfo over all levels as properties are always sought by typeinfo over all levels
and create params are always toplevel class only and create params are always toplevel class only
@@ -327,7 +327,7 @@ and create params are always toplevel class only
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// depersisting to memory // depersisting to memory
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
struct wxRuntimeDepersister::wxRuntimeDepersisterInternal struct wxRuntimeDepersister::wxRuntimeDepersisterInternal
@@ -396,7 +396,7 @@ void wxRuntimeDepersister::CreateObject(int objectID,
classInfo->Create(o, paramCount, params); classInfo->Create(o, paramCount, params);
} }
void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
{ {
wxObject *o; wxObject *o;
o = m_data->GetObject(objectID); o = m_data->GetObject(objectID);
@@ -445,8 +445,8 @@ void wxRuntimeDepersister::SetConnect(int eventSourceObjectID,
if ( ehsource && ehsink ) if ( ehsource && ehsink )
{ {
ehsource->Connect( -1 , delegateInfo->GetEventType() , ehsource->Connect( -1 , delegateInfo->GetEventType() ,
handlerInfo->GetEventFunction() , NULL /*user data*/ , handlerInfo->GetEventFunction() , NULL /*user data*/ ,
ehsink ) ; ehsink ) ;
} }
} }
@@ -460,7 +460,7 @@ wxObject *wxRuntimeDepersister::GetObject(int objectID)
void wxRuntimeDepersister::AddToPropertyCollection( int objectID , void wxRuntimeDepersister::AddToPropertyCollection( int objectID ,
const wxClassInfo *classInfo, const wxClassInfo *classInfo,
const wxPropertyInfo* propertyInfo , const wxPropertyInfo* propertyInfo ,
const wxxVariant &value) const wxxVariant &value)
{ {
wxObject *o; wxObject *o;
o = m_data->GetObject(objectID); o = m_data->GetObject(objectID);
@@ -471,7 +471,7 @@ void wxRuntimeDepersister::AddToPropertyCollection( int objectID ,
void wxRuntimeDepersister::AddToPropertyCollectionAsObject(int objectID, void wxRuntimeDepersister::AddToPropertyCollectionAsObject(int objectID,
const wxClassInfo *classInfo, const wxClassInfo *classInfo,
const wxPropertyInfo* propertyInfo , const wxPropertyInfo* propertyInfo ,
int valueObjectId) int valueObjectId)
{ {
wxObject *o, *valo; wxObject *o, *valo;
o = m_data->GetObject(objectID); o = m_data->GetObject(objectID);
@@ -490,7 +490,7 @@ void wxRuntimeDepersister::AddToPropertyCollectionAsObject(int objectID,
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// depersisting to code // depersisting to code
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
struct wxCodeDepersister::wxCodeDepersisterInternal struct wxCodeDepersister::wxCodeDepersisterInternal
@@ -512,7 +512,7 @@ struct wxCodeDepersister::wxCodeDepersisterInternal
} }
} ; } ;
wxCodeDepersister::wxCodeDepersister(wxTextOutputStream *out) wxCodeDepersister::wxCodeDepersister(wxTextOutputStream *out)
: m_fp(out) : m_fp(out)
{ {
m_data = new wxCodeDepersisterInternal ; m_data = new wxCodeDepersisterInternal ;
@@ -529,15 +529,15 @@ void wxCodeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo ,
wxString objectName = wxString::Format( "LocalObject_%d" , objectID ) ; wxString objectName = wxString::Format( "LocalObject_%d" , objectID ) ;
m_fp->WriteString( wxString::Format( "\t%s *%s = new %s;\n", m_fp->WriteString( wxString::Format( "\t%s *%s = new %s;\n",
classInfo->GetClassName(), classInfo->GetClassName(),
objectName, objectName.c_str(),
classInfo->GetClassName()) ); classInfo->GetClassName()) );
m_data->SetObjectName( objectID , objectName ) ; m_data->SetObjectName( objectID , objectName ) ;
} }
void wxCodeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) void wxCodeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
{ {
m_fp->WriteString( wxString::Format( "\tdelete %s;\n", m_fp->WriteString( wxString::Format( "\tdelete %s;\n",
m_data->GetObjectName( objectID) ) ); m_data->GetObjectName( objectID).c_str() ) );
} }
wxString wxCodeDepersister::ValueAsCode( const wxxVariant &param ) wxString wxCodeDepersister::ValueAsCode( const wxxVariant &param )
@@ -548,15 +548,15 @@ wxString wxCodeDepersister::ValueAsCode( const wxxVariant &param )
{ {
const wxCustomTypeInfo* cti = dynamic_cast<const wxCustomTypeInfo*>(type) ; const wxCustomTypeInfo* cti = dynamic_cast<const wxCustomTypeInfo*>(type) ;
wxASSERT_MSG( cti , wxT("Internal error, illegal wxCustomTypeInfo") ) ; wxASSERT_MSG( cti , wxT("Internal error, illegal wxCustomTypeInfo") ) ;
value.Printf( "%s(%s)",cti->GetTypeName(),param.GetAsString() ); value.Printf( "%s(%s)",cti->GetTypeName().c_str(),param.GetAsString().c_str() );
} }
else if ( type->GetKind() == wxT_STRING ) else if ( type->GetKind() == wxT_STRING )
{ {
value.Printf( "\"%s\"",param.GetAsString() ); value.Printf( "\"%s\"",param.GetAsString().c_str() );
} }
else else
{ {
value.Printf( "%s", param.GetAsString() ); value.Printf( "%s", param.GetAsString().c_str() );
} }
return value ; return value ;
} }
@@ -571,14 +571,14 @@ void wxCodeDepersister::CreateObject(int objectID,
) )
{ {
int i; int i;
m_fp->WriteString( wxString::Format( "\t%s->Create(", m_data->GetObjectName(objectID) ) ); m_fp->WriteString( wxString::Format( "\t%s->Create(", m_data->GetObjectName(objectID).c_str() ) );
for (i = 0; i < paramCount; i++) for (i = 0; i < paramCount; i++)
{ {
if ( objectIDValues[i] != wxInvalidObjectID ) if ( objectIDValues[i] != wxInvalidObjectID )
m_fp->WriteString( wxString::Format( "%s", m_data->GetObjectName( objectIDValues[i] ) ) ); m_fp->WriteString( wxString::Format( "%s", m_data->GetObjectName( objectIDValues[i] ).c_str() ) );
else else
{ {
m_fp->WriteString( wxString::Format( "%s", ValueAsCode(params[i]) ) ); m_fp->WriteString( wxString::Format( "%s", ValueAsCode(params[i]).c_str() ) );
} }
if (i < paramCount - 1) if (i < paramCount - 1)
m_fp->WriteString( ", "); m_fp->WriteString( ", ");
@@ -592,9 +592,9 @@ void wxCodeDepersister::SetProperty(int objectID,
const wxxVariant &value) const wxxVariant &value)
{ {
m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n", m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n",
m_data->GetObjectName(objectID), m_data->GetObjectName(objectID).c_str(),
propertyInfo->GetAccessor()->GetSetterName(), propertyInfo->GetAccessor()->GetSetterName().c_str(),
ValueAsCode(value)) ); ValueAsCode(value).c_str()) );
} }
void wxCodeDepersister::SetPropertyAsObject(int objectID, void wxCodeDepersister::SetPropertyAsObject(int objectID,
@@ -604,32 +604,32 @@ void wxCodeDepersister::SetPropertyAsObject(int objectID,
{ {
if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT ) if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT )
m_fp->WriteString( wxString::Format( "\t%s->%s(*%s);\n", m_fp->WriteString( wxString::Format( "\t%s->%s(*%s);\n",
m_data->GetObjectName(objectID), m_data->GetObjectName(objectID).c_str(),
propertyInfo->GetAccessor()->GetSetterName(), propertyInfo->GetAccessor()->GetSetterName().c_str(),
m_data->GetObjectName( valueObjectId) ) ); m_data->GetObjectName( valueObjectId).c_str() ) );
else else
m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n", m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n",
m_data->GetObjectName(objectID), m_data->GetObjectName(objectID).c_str(),
propertyInfo->GetAccessor()->GetSetterName(), propertyInfo->GetAccessor()->GetSetterName().c_str(),
m_data->GetObjectName( valueObjectId) ) ); m_data->GetObjectName( valueObjectId).c_str() ) );
} }
void wxCodeDepersister::AddToPropertyCollection( int objectID , void wxCodeDepersister::AddToPropertyCollection( int objectID ,
const wxClassInfo *WXUNUSED(classInfo), const wxClassInfo *WXUNUSED(classInfo),
const wxPropertyInfo* propertyInfo , const wxPropertyInfo* propertyInfo ,
const wxxVariant &value) const wxxVariant &value)
{ {
m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n", m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n",
m_data->GetObjectName(objectID), m_data->GetObjectName(objectID).c_str(),
propertyInfo->GetAccessor()->GetAdderName(), propertyInfo->GetAccessor()->GetAdderName().c_str(),
ValueAsCode(value)) ); ValueAsCode(value).c_str()) );
} }
// sets the corresponding property (value is an object) // sets the corresponding property (value is an object)
void wxCodeDepersister::AddToPropertyCollectionAsObject(int WXUNUSED(objectID), void wxCodeDepersister::AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
const wxClassInfo *WXUNUSED(classInfo), const wxClassInfo *WXUNUSED(classInfo),
const wxPropertyInfo* WXUNUSED(propertyInfo) , const wxPropertyInfo* WXUNUSED(propertyInfo) ,
int WXUNUSED(valueObjectId)) int WXUNUSED(valueObjectId))
{ {
// TODO // TODO
} }
@@ -647,8 +647,8 @@ void wxCodeDepersister::SetConnect(int eventSourceObjectID,
int eventType = delegateInfo->GetEventType() ; int eventType = delegateInfo->GetEventType() ;
wxString handlerName = handlerInfo->GetName() ; wxString handlerName = handlerInfo->GetName() ;
m_fp->WriteString( wxString::Format( "\t%s->Connect( %s->GetId() , %d , (wxObjectEventFunction)(wxEventFunction) & %s::%s , NULL , %s ) ;" , m_fp->WriteString( wxString::Format( "\t%s->Connect( %s->GetId() , %d , (wxObjectEventFunction)(wxEventFunction) & %s::%s , NULL , %s ) ;" ,
ehsource , ehsource , eventType , ehsinkClass , handlerName , ehsink ) ); ehsource.c_str() , ehsource.c_str() , eventType , ehsinkClass.c_str() , handlerName.c_str() , ehsink.c_str() ) );
} }
#include <wx/arrimpl.cpp> #include <wx/arrimpl.cpp>

42
src/common/xtixml.cpp
View File

@@ -1,8 +1,8 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// 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 // Created: 27/07/03
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 2003 Stefan Csomor // Copyright: (c) 2003 Stefan Csomor
@@ -44,7 +44,7 @@ using namespace std ;
// //
// XML Streaming // XML Streaming
// //
// convenience functions // convenience functions
@@ -80,19 +80,19 @@ struct wxXmlWriter::wxXmlWriterInternal
} }
} ; } ;
wxXmlWriter::wxXmlWriter( wxXmlNode * rootnode ) wxXmlWriter::wxXmlWriter( wxXmlNode * rootnode )
{ {
m_data = new wxXmlWriterInternal() ; m_data = new wxXmlWriterInternal() ;
m_data->m_root = rootnode ; m_data->m_root = rootnode ;
m_data->m_current = rootnode ; m_data->m_current = rootnode ;
} }
wxXmlWriter::~wxXmlWriter() wxXmlWriter::~wxXmlWriter()
{ {
delete m_data ; delete m_data ;
} }
void wxXmlWriter::DoBeginWriteTopLevelEntry( const wxString &name ) void wxXmlWriter::DoBeginWriteTopLevelEntry( const wxString &name )
{ {
wxXmlNode *pnode; wxXmlNode *pnode;
pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("entry")); pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("entry"));
@@ -106,7 +106,7 @@ void wxXmlWriter::DoEndWriteTopLevelEntry( const wxString &WXUNUSED(name) )
m_data->Pop() ; m_data->Pop() ;
} }
void wxXmlWriter::DoBeginWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *classInfo, int objectID , wxxVariantArray &metadata ) void wxXmlWriter::DoBeginWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *classInfo, int objectID , wxxVariantArray &metadata )
{ {
wxXmlNode *pnode; wxXmlNode *pnode;
pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object")); pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
@@ -122,18 +122,18 @@ void wxXmlWriter::DoBeginWriteObject(const wxObject *WXUNUSED(object), const wxC
} }
// end of writing the root object // end of writing the root object
void wxXmlWriter::DoEndWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *WXUNUSED(classInfo), int WXUNUSED(objectID) ) void wxXmlWriter::DoEndWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *WXUNUSED(classInfo), int WXUNUSED(objectID) )
{ {
m_data->Pop() ; m_data->Pop() ;
} }
// writes a property in the stream format // writes a property in the stream format
void wxXmlWriter::DoWriteSimpleType( wxxVariant &value ) void wxXmlWriter::DoWriteSimpleType( wxxVariant &value )
{ {
wxXmlAddContentToNode( m_data->m_current ,value.GetAsString() ) ; wxXmlAddContentToNode( m_data->m_current ,value.GetAsString() ) ;
} }
void wxXmlWriter::DoBeginWriteElement() void wxXmlWriter::DoBeginWriteElement()
{ {
wxXmlNode *pnode; wxXmlNode *pnode;
pnode = new wxXmlNode(wxXML_ELEMENT_NODE, "element" ); pnode = new wxXmlNode(wxXML_ELEMENT_NODE, "element" );
@@ -141,7 +141,7 @@ void wxXmlWriter::DoBeginWriteElement()
m_data->Push( pnode ) ; m_data->Push( pnode ) ;
} }
void wxXmlWriter::DoEndWriteElement() void wxXmlWriter::DoEndWriteElement()
{ {
m_data->Pop() ; m_data->Pop() ;
} }
@@ -163,7 +163,7 @@ void wxXmlWriter::DoEndWriteProperty(const wxPropertyInfo *WXUNUSED(propInfo) )
// insert an object reference to an already written object // insert an object reference to an already written object
void wxXmlWriter::DoWriteRepeatedObject( int objectID ) void wxXmlWriter::DoWriteRepeatedObject( int objectID )
{ {
wxXmlNode *pnode; wxXmlNode *pnode;
pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object")); pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
@@ -172,7 +172,7 @@ void wxXmlWriter::DoWriteRepeatedObject( int objectID )
} }
// insert a null reference // insert a null reference
void wxXmlWriter::DoWriteNullObject() void wxXmlWriter::DoWriteNullObject()
{ {
wxXmlNode *pnode; wxXmlNode *pnode;
pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object")); pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
@@ -180,26 +180,26 @@ void wxXmlWriter::DoWriteNullObject()
} }
// writes a delegate in the stream format // writes a delegate in the stream format
void wxXmlWriter::DoWriteDelegate( const wxObject *WXUNUSED(object), const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *WXUNUSED(pi) , void wxXmlWriter::DoWriteDelegate( const wxObject *WXUNUSED(object), const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *WXUNUSED(pi) ,
const wxObject *eventSink, int sinkObjectID , const wxClassInfo* WXUNUSED(eventSinkClassInfo) , const wxHandlerInfo* handlerInfo ) const wxObject *eventSink, int sinkObjectID , const wxClassInfo* WXUNUSED(eventSinkClassInfo) , const wxHandlerInfo* handlerInfo )
{ {
if ( eventSink != NULL && handlerInfo != NULL ) if ( eventSink != NULL && handlerInfo != NULL )
{ {
wxXmlAddContentToNode( m_data->m_current ,wxString::Format(wxT("%d.%s"), sinkObjectID , handlerInfo->GetName()) ) ; wxXmlAddContentToNode( m_data->m_current ,wxString::Format(wxT("%d.%s"), sinkObjectID , handlerInfo->GetName().c_str()) ) ;
} }
} }
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// reading objects in // reading objects in
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// reading xml in // reading xml in
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
/* /*
Reading components has not to be extended for components Reading components has not to be extended for components
as properties are always sought by typeinfo over all levels as properties are always sought by typeinfo over all levels
and create params are always toplevel class only and create params are always toplevel class only
@@ -267,7 +267,7 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
} }
callbacks->AllocateObject(objectID, classInfo, metadata); callbacks->AllocateObject(objectID, classInfo, metadata);
// //
// stream back the Create parameters first // stream back the Create parameters first
createParams = new wxxVariant[ classInfo->GetCreateParamCount() ] ; createParams = new wxxVariant[ classInfo->GetCreateParamCount() ] ;
createParamOids = new int[classInfo->GetCreateParamCount() ] ; createParamOids = new int[classInfo->GetCreateParamCount() ] ;
@@ -368,7 +368,7 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
{ {
if ( pi->GetAccessor()->HasAdder() ) if ( pi->GetAccessor()->HasAdder() )
callbacks->AddToPropertyCollectionAsObject( objectID , classInfo , pi , valueId ) ; callbacks->AddToPropertyCollectionAsObject( objectID , classInfo , pi , valueId ) ;
// TODO for collections we must have a notation on taking over ownership or not // TODO for collections we must have a notation on taking over ownership or not
if ( elementType->GetKind() == wxT_OBJECT && valueId != wxNullObjectID ) if ( elementType->GetKind() == wxT_OBJECT && valueId != wxNullObjectID )
callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ; callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ;
} }