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

257
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,7 +241,7 @@ 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 ; \
} }
@@ -284,7 +308,7 @@ 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 ; \
} }
@@ -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 :
@@ -417,18 +441,18 @@ public :
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)
); );
} }
}; };
@@ -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()) ) ;

4
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

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
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

44
src/common/xtistrm.cpp
View File

@@ -207,7 +207,7 @@ void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , c
} }
else else
{ {
DoWriteSimpleType( value ) ; DoWriteSimpleType( value ) ;
} }
} }
DoEndWriteElement() ; DoEndWriteElement() ;
@@ -529,7 +529,7 @@ 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 ) ;
} }
@@ -537,7 +537,7 @@ void wxCodeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo ,
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,14 +604,14 @@ 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 ,
@@ -620,9 +620,9 @@ void wxCodeDepersister::AddToPropertyCollection( 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()->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)
@@ -648,7 +648,7 @@ void wxCodeDepersister::SetConnect(int eventSourceObjectID,
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>

2
src/common/xtixml.cpp
View File

@@ -185,7 +185,7 @@ void wxXmlWriter::DoWriteDelegate( const wxObject *WXUNUSED(object), const wxCl
{ {
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()) ) ;
} }
} }