/////////////////////////////////////////////////////////////////////////////
-// Name: wx/xti.hG
+// Name: wx/xti.h
// Purpose: runtime metadata information (extended class info)
// Author: Stefan Csomor
// Modified by:
// we will move this later to defs.h
-#if !wxCHECK_GCC_VERSION( 3 , 4 )
+#if defined(__GNUC__) && !wxCHECK_GCC_VERSION( 3 , 4 )
# define wxUSE_MEMBER_TEMPLATES 0
#endif
-#ifdef _MSC_VER
-# if _MSC_VER <= 1200
-# define wxUSE_MEMBER_TEMPLATES 0
-# endif
+#if defined(_MSC_VER) && _MSC_VER <= 1200
+# define wxUSE_MEMBER_TEMPLATES 0
+# define wxUSE_FUNC_TEMPLATE_POINTER 0
#endif
#ifndef wxUSE_MEMBER_TEMPLATES
-#define wxUSE_MEMBER_TEMPLATES 1
+# define wxUSE_MEMBER_TEMPLATES 1
+#endif
+
+#ifndef wxUSE_FUNC_TEMPLATE_POINTER
+# define wxUSE_FUNC_TEMPLATE_POINTER 1
#endif
#if wxUSE_MEMBER_TEMPLATES
-#define wxTEMPLATED_MEMBER_CALL( method , type ) method<type>()
-#define wxTEMPLATED_MEMBER_FIX( type )
+# define wxTEMPLATED_MEMBER_CALL( method , type ) method<type>()
+# define wxTEMPLATED_MEMBER_FIX( type )
#else
-#define wxTEMPLATED_MEMBER_CALL( method , type ) method((type*)NULL)
-#define wxTEMPLATED_MEMBER_FIX( type ) type* =NULL
+# define wxTEMPLATED_MEMBER_CALL( method , type ) method((type*)NULL)
+# define wxTEMPLATED_MEMBER_FIX( type ) type* =NULL
#endif
+#if defined(_MSC_VER) && _MSC_VER <= 1200
+# define wxTEMPLATED_FUNCTION_FIX( type ) , wxTEMPLATED_MEMBER_FIX(type)
+# define wxINFUNC_CLASS_TYPE_FIX( type ) typedef type type;
+#else
+# define wxTEMPLATED_FUNCTION_FIX( type )
+# define wxINFUNC_CLASS_TYPE_FIX( type )
+#endif
+
+#define EMPTY_MACROVALUE /**/
+
class WXDLLIMPEXP_BASE wxObject;
class WXDLLIMPEXP_BASE wxClassInfo;
class WXDLLIMPEXP_BASE wxDynamicClassInfo;
class WXDLLIMPEXP_BASE wxHashTable;
class WXDLLIMPEXP_BASE wxObjectRefData;
class WXDLLIMPEXP_BASE wxEvent;
+class WXDLLIMPEXP_BASE wxEvtHandler;
typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);
+#if wxUSE_FUNC_TEMPLATE_POINTER
+# define wxTO_STRING(type) wxToStringConverter<type>
+# define wxTO_STRING_IMP(type)
+# define wxFROM_STRING(type) wxFromStringConverter<type>
+# define wxFROM_STRING_IMP(type)
+#else
+# define wxTO_STRING(type) ToString##type
+# define wxTO_STRING_IMP(type) inline void ToString##type( const wxxVariant& data , wxString &result ) { wxToStringConverter<type>(data, result); }
+# define wxFROM_STRING(type) FromString##type
+# define wxFROM_STRING_IMP(type) inline void FromString##type( const wxString& data , wxxVariant &result ) { wxFromStringConverter<type>(data, result); }
+#endif
+
// ----------------------------------------------------------------------------
// Enum Support
//
s = s_enumData##e.GetEnumMemberName((int)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>() ;} \
- wxEnumTypeInfo s_typeInfo##e(wxT_ENUM , &s_enumData##e , &wxToStringConverter<e> , &wxFromStringConverter<e> , &ToLong##e , &FromLong##e , typeid(e).name() ) ;
+ void ToLong##e( const wxxVariant& data , long &result ) { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get , e) ;} \
+ wxTO_STRING_IMP( e ) \
+ wxFROM_STRING_IMP( e ) \
+ wxEnumTypeInfo s_typeInfo##e(wxT_ENUM , &s_enumData##e , &wxTO_STRING( e ) , &wxFROM_STRING( e ) , &ToLong##e , &FromLong##e , typeid(e).name() ) ;
// ----------------------------------------------------------------------------
// Set Support
// ----------------------------------------------------------------------------
// in order to remove dependancy on string tokenizer
-void wxSetStringToArray( const wxString &s , wxArrayString &array ) ;
+void WXDLLIMPEXP_BASE wxSetStringToArray( const wxString &s , wxArrayString &array ) ;
template<typename e>
void wxSetFromString(const wxString &s , wxBitset<e> &data )
if ( data.test( value ) )
{
// this could also be done by the templated calls
- if ( !s.IsEmpty() )
+ if ( !s.empty() )
s +=wxT("|") ;
s += edata->GetEnumMemberNameByIndex(i) ;
}
wxSetToString( s , 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() ;} \
- wxEnumTypeInfo s_typeInfo##SetName(wxT_SET , &s_enumData##e , &wxToStringConverter<SetName> , &wxFromStringConverter<SetName> , &ToLong##SetName , &FromLong##SetName, typeid(SetName).name() ) ; \
+ void ToLong##SetName( const wxxVariant& data , long &result ) { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get , SetName).to_ulong() ;} \
+ wxTO_STRING_IMP( SetName ) \
+ wxFROM_STRING_IMP( SetName ) \
+ wxEnumTypeInfo s_typeInfo##SetName(wxT_SET , &s_enumData##e , &wxTO_STRING( SetName ) , &wxFROM_STRING( SetName ) , &ToLong##SetName , &FromLong##SetName, typeid(SetName).name() ) ; \
}
template<typename e>
// clear the flags we just set
dataValue &= ~value ;
// this could also be done by the templated calls
- if ( !s.IsEmpty() )
+ if ( !s.empty() )
s +=wxT("|") ;
s += edata->GetEnumMemberNameByIndex(i) ;
}
wxFlagsToString<e>( s , 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 ;} \
- wxEnumTypeInfo s_typeInfo##e(wxT_SET , &s_enumData##e , &wxToStringConverter<e> , &wxFromStringConverter<e> , &ToLong##e , &FromLong##e, typeid(e).name() ) ;
+ void ToLong##e( const wxxVariant& data , long &result ) { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get , e).m_data ;} \
+ wxTO_STRING_IMP( e ) \
+ wxFROM_STRING_IMP( e ) \
+ wxEnumTypeInfo s_typeInfo##e(wxT_SET , &s_enumData##e , &wxTO_STRING( e ) , &wxFROM_STRING( e ) , &ToLong##e , &FromLong##e, typeid(e).name() ) ;
// ----------------------------------------------------------------------------
// Type Information
// ----------------------------------------------------------------------------
}
#if wxUSE_UNICODE
wxTypeInfo(wxTypeKind kind,
- converterToString_t to = NULL, converterFromString_t from = NULL,
- const char *name = ""):
+ converterToString_t to, converterFromString_t from,
+ const char *name):
m_toString(to), m_fromString(from), m_kind(kind), m_name(wxString::FromAscii(name))
{
Register();
converterToString_t m_toString ;
converterFromString_t m_fromString ;
- static wxTypeInfoMap* sm_typeTable ;
+ static wxTypeInfoMap* ms_typeTable ;
wxTypeKind m_kind;
wxString m_name;
wxTypeInfo( wxT_COLLECTION , to , from , name )
{ m_elementTypeName = wxString::FromAscii( elementName ) ; m_elementType = NULL ;}
#endif
- const wxTypeInfo* GetElementType() const
- {
+ const wxTypeInfo* GetElementType() const
+ {
if ( m_elementType == NULL )
m_elementType = wxTypeInfo::FindType( m_elementTypeName ) ;
return m_elementType ; }
// this macro is for usage with custom, non-object derived classes and structs, wxPoint is such a custom type
+#if wxUSE_FUNC_TEMPLATE_POINTER
#define wxCUSTOM_TYPE_INFO( e , toString , fromString ) \
wxCustomTypeInfo s_typeInfo##e(typeid(e).name() , &toString , &fromString) ;
+#else
+#define wxCUSTOM_TYPE_INFO( e , toString , fromString ) \
+ void ToString##e( const wxxVariant& data , wxString &result ) { toString(data, result); } \
+ void FromString##e( const wxString& data , wxxVariant &result ) { fromString(data, result); } \
+ wxCustomTypeInfo s_typeInfo##e(typeid(e).name() , &ToString##e , &FromString##e) ;
+#endif
#define wxCOLLECTION_TYPE_INFO( element , collection ) \
wxCollectionTypeInfo s_typeInfo##collection( typeid(element).name() , NULL , NULL , typeid(collection).name() ) ;
{
public :
wxxVariant() { m_data = NULL ; }
- wxxVariant( wxxVariantData* data , const wxString& name = wxT("") ) : m_data(data) , m_name(name) {}
+ wxxVariant( wxxVariantData* data , const wxString& name = wxEmptyString ) : m_data(data) , m_name(name) {}
wxxVariant( const wxxVariant &d ) { if ( d.m_data ) m_data = d.m_data->Clone() ; else m_data = NULL ; m_name = d.m_name ; }
- template<typename T> wxxVariant( const T& data , const wxString& name = wxT("") ) :
+ template<typename T> wxxVariant( const T& data , const wxString& name = wxEmptyString ) :
m_data(new wxxVariantDataT<T>(data) ), m_name(name) {}
~wxxVariant() { delete m_data ; }
template<typename T> T& Get(wxTEMPLATED_MEMBER_FIX(T))
{
wxxVariantDataT<T> *dataptr = dynamic_cast<wxxVariantDataT<T>*> (m_data) ;
- wxASSERT_MSG( dataptr , wxT("Cast not possible") ) ;
+ wxASSERT_MSG( dataptr , wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) ) ;
return dataptr->Get() ;
}
template<typename T> const T& Get(wxTEMPLATED_MEMBER_FIX(T)) const
{
const wxxVariantDataT<T> *dataptr = dynamic_cast<const wxxVariantDataT<T>*> (m_data) ;
- wxASSERT_MSG( dataptr , wxT("Cast not possible") ) ;
+ wxASSERT_MSG( dataptr , wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) ) ;
return dataptr->Get() ;
}
bool IsEmpty() const { return m_data == NULL ; }
- template<typename T> bool HasData() const
+ template<typename T> bool HasData(wxTEMPLATED_MEMBER_FIX(T)) const
{
const wxxVariantDataT<T> *dataptr = dynamic_cast<const wxxVariantDataT<T>*> (m_data) ;
return dataptr != NULL ;
wxxVariant& operator=(const wxxVariant &d)
{
- m_data = d.m_data->Clone() ;
+ delete m_data;
+ m_data = d.m_data ? d.m_data->Clone() : NULL ;
m_name = d.m_name ;
return *this ;
}
void wxStringWriteValue( wxString &s , const T &data);
template<typename T>
-void wxToStringConverter( const wxxVariant &v, wxString &s) { wxStringWriteValue( s , v.wxTEMPLATED_MEMBER_CALL(Get , T) ) ; }
+void wxToStringConverter( const wxxVariant &v, wxString &s wxTEMPLATED_FUNCTION_FIX(T)) { wxStringWriteValue( s , v.wxTEMPLATED_MEMBER_CALL(Get , T) ) ; }
template<typename T>
-void wxFromStringConverter( const wxString &s, wxxVariant &v) { T d ; wxStringReadValue( s , d ) ; v = wxxVariant(d) ; } \
+void wxFromStringConverter( const wxString &s, wxxVariant &v wxTEMPLATED_FUNCTION_FIX(T)) { T d ; wxStringReadValue( s , d ) ; v = wxxVariant(d) ; }
// ----------------------------------------------------------------------------
// Property Support
wxString m_name ;
} ;
-template<typename coll_t> void wxCollectionToVariantArray( const coll_t& coll , wxxVariantArray& result ) ;
+template<typename coll_t> void WXDLLIMPEXP_BASE wxCollectionToVariantArray( const coll_t& coll , wxxVariantArray& result ) ;
class WXDLLIMPEXP_BASE wxAdder
{
} ;
-
#define wxSETTER( property, Klass, valueType, setterMethod ) \
class wxSetter##property : public wxSetter \
{ \
public: \
+ wxINFUNC_CLASS_TYPE_FIX(Klass) \
wxSetter##property() : wxSetter( wxT(#setterMethod) ) {} \
~wxSetter##property() {} \
void Set( wxObject *object, const wxxVariant &variantValue ) const \
{ \
Klass *obj = dynamic_cast<Klass*>(object) ; \
- if ( variantValue.HasData<valueType>() ) \
- obj->setterMethod(variantValue.Get<valueType>()) ; \
+ if ( variantValue.wxTEMPLATED_MEMBER_CALL(HasData, valueType) ) \
+ obj->setterMethod(variantValue.wxTEMPLATED_MEMBER_CALL(Get , valueType)) ; \
else \
- obj->setterMethod(*variantValue.Get<valueType*>()) ; \
+ obj->setterMethod(*variantValue.wxTEMPLATED_MEMBER_CALL(Get , valueType*)) ; \
} \
} ;
class wxGetter##property : public wxGetter \
{ \
public : \
+ wxINFUNC_CLASS_TYPE_FIX(Klass) \
wxGetter##property() : wxGetter( wxT(#gettermethod) ) {} \
~wxGetter##property() {} \
void Get( const wxObject *object , wxxVariant &result) const \
class wxAdder##property : public wxAdder \
{ \
public: \
+ wxINFUNC_CLASS_TYPE_FIX(Klass) \
wxAdder##property() : wxAdder( wxT(#addermethod) ) {} \
~wxAdder##property() {} \
void Add( wxObject *object, const wxxVariant &variantValue ) const \
{ \
Klass *obj = dynamic_cast<Klass*>(object) ; \
- if ( variantValue.HasData<valueType>() ) \
- obj->addermethod(variantValue.Get<valueType>()) ; \
+ if ( variantValue.wxTEMPLATED_MEMBER_CALL(HasData, valueType) ) \
+ obj->addermethod(variantValue.wxTEMPLATED_MEMBER_CALL(Get , valueType)) ; \
else \
- obj->addermethod(*variantValue.Get<valueType*>()) ; \
+ obj->addermethod(*variantValue.wxTEMPLATED_MEMBER_CALL(Get , valueType*)) ; \
} \
} ;
class wxCollectionGetter##property : public wxCollectionGetter \
{ \
public : \
+ wxINFUNC_CLASS_TYPE_FIX(Klass) \
wxCollectionGetter##property() : wxCollectionGetter( wxT(#gettermethod) ) {} \
~wxCollectionGetter##property() {} \
void Get( const wxObject *object , wxxVariantArray &result) const \
wxGenericPropertyAccessor( const wxString &propName ) ;
~wxGenericPropertyAccessor() ;
- void RenameProperty( const wxString &oldName , const wxString &newName )
+ void RenameProperty( const wxString& WXUNUSED_UNLESS_DEBUG(oldName),
+ const wxString& newName )
{
wxASSERT( oldName == m_propertyName ) ; m_propertyName = newName ;
}
~wxPropertyInfo() ;
// return the class this property is declared in
- const wxClassInfo* GetDeclaringClass() const { return m_itsClass ; }
+ const wxClassInfo* GetDeclaringClass() const { return m_itsClass ; }
// return the name of this property
- const wxString& GetName() const { return m_name ; }
+ const wxString& GetName() const { return m_name ; }
// returns the flags of this property
- wxPropertyInfoFlags GetFlags() const { return m_flags ;}
+ wxPropertyInfoFlags GetFlags() const { return m_flags ;}
// returns the short help string of this property
const wxString& GetHelpString() const { return m_helpString ; }
const wxString& GetGroupString() const { return m_groupString ; }
// return the element type info of this property (for collections, otherwise NULL)
- const wxTypeInfo * GetCollectionElementTypeInfo() const
+ const wxTypeInfo * GetCollectionElementTypeInfo() const
{
if ( m_collectionElementTypeInfo == NULL )
m_collectionElementTypeInfo = wxTypeInfo::FindType(m_collectionElementTypeName) ;
}
// return the type info of this property
- const wxTypeInfo * GetTypeInfo() const
+ const wxTypeInfo * GetTypeInfo() const
{
if ( m_typeInfo == NULL )
m_typeInfo = wxTypeInfo::FindType(m_typeName) ;
wxPropertyInfo* GetNext() const { return m_next ; }
// returns the default value of this property, its kind may be wxT_VOID if it is not valid
- wxxVariant GetDefaultValue() const { return m_defaultValue ; }
+ wxxVariant GetDefaultValue() const { return m_defaultValue ; }
private :
void Insert(wxPropertyInfo* &iter)
{
mutable wxTypeInfo* m_collectionElementTypeInfo ;
wxString m_collectionElementTypeName ;
wxPropertyAccessor* m_accessor ;
- wxxVariant m_defaultValue;
+ wxxVariant m_defaultValue;
wxPropertyInfoFlags m_flags ;
wxString m_helpString ;
wxString m_groupString ;
#define wxHIDE_PROPERTY( pname ) \
static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(void).name() ,NULL , wxxVariant() , wxPROP_DONT_STREAM , wxEmptyString , wxEmptyString ) ;
-#define wxPROPERTY( pname , type , setter , getter ,defaultValue , flags , help , group) \
+#define wxPROPERTY( pname , type , setter , getter , defaultValue , flags , help , group) \
wxSETTER( pname , class_t , type , setter ) \
static wxSetter##pname _setter##pname ; \
wxGETTER( pname , class_t , type , getter ) \
~wxHandlerInfo() ;
// return the name of this handler
- const wxString& GetName() const { return m_name ; }
+ const wxString& GetName() const { return m_name ; }
// return the class info of the event
- const wxClassInfo * GetEventClassInfo() const { return m_eventClassInfo ; }
+ const wxClassInfo *GetEventClassInfo() const { return m_eventClassInfo ; }
// get the handler function pointer
- wxObjectEventFunction GetEventFunction() const { return m_eventFunction ; }
+ wxObjectEventFunction GetEventFunction() const { return m_eventFunction ; }
// returns NULL if this is the last handler of this class
wxHandlerInfo* GetNext() const { return m_next ; }
#define wxCONSTRUCTOR_0(klass) \
wxConstructorBridge_0<klass> constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
- const int klass::sm_constructorPropertiesCount##klass = 0 ;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { NULL } ; \
+ const int klass::ms_constructorPropertiesCount = 0 ;
#define wxCONSTRUCTOR_DUMMY(klass) \
wxConstructorBridge_Dummy constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
- const int klass::sm_constructorPropertiesCount##klass = 0 ;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { NULL } ; \
+ const int klass::ms_constructorPropertiesCount = 0 ;
// 1 param
#define wxCONSTRUCTOR_1(klass,t0,v0) \
wxConstructorBridge_1<klass,t0> constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 1 ;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) } ; \
+ const int klass::ms_constructorPropertiesCount = 1 ;
// 2 params
#define wxCONSTRUCTOR_2(klass,t0,v0,t1,v1) \
wxConstructorBridge_2<klass,t0,t1> constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 2;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) } ; \
+ const int klass::ms_constructorPropertiesCount = 2;
// direct constructor version
#define wxDIRECT_CONSTRUCTOR_2(klass,t0,v0,t1,v1) \
wxDirectConstructorBridge_2<klass,t0,t1> constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 2;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) } ; \
+ const int klass::ms_constructorPropertiesCount = 2;
// 3 params
#define wxCONSTRUCTOR_3(klass,t0,v0,t1,v1,t2,v2) \
wxConstructorBridge_3<klass,t0,t1,t2> constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 3 ;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) } ; \
+ const int klass::ms_constructorPropertiesCount = 3 ;
// 4 params
#define wxCONSTRUCTOR_4(klass,t0,v0,t1,v1,t2,v2,t3,v3) \
wxConstructorBridge_4<klass,t0,t1,t2,t3> constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 4 ;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) } ; \
+ const int klass::ms_constructorPropertiesCount = 4 ;
// 5 params
#define wxCONSTRUCTOR_5(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4) \
wxConstructorBridge_5<klass,t0,t1,t2,t3,t4> constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 5;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) } ; \
+ const int klass::ms_constructorPropertiesCount = 5;
// 6 params
#define wxCONSTRUCTOR_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* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 6;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) } ; \
+ const int klass::ms_constructorPropertiesCount = 6;
// direct constructor version
#define wxDIRECT_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[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 6;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) } ; \
+ const int klass::ms_constructorPropertiesCount = 6;
// 7 params
#define wxCONSTRUCTOR_7(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6) \
wxConstructorBridge_7<klass,t0,t1,t2,t3,t4,t5,t6> constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) , wxT(#v6) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 7;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) , wxT(#v6) } ; \
+ const int klass::ms_constructorPropertiesCount = 7;
// 8 params
#define wxCONSTRUCTOR_8(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7) \
wxConstructorBridge_8<klass,t0,t1,t2,t3,t4,t5,t6,t7> constructor##klass ; \
- wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
- const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) , wxT(#v6) , wxT(#v7) } ; \
- const int klass::sm_constructorPropertiesCount##klass = 8;
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) , wxT(#v6) , wxT(#v7) } ; \
+ const int klass::ms_constructorPropertiesCount = 8;
// ----------------------------------------------------------------------------
// wxClassInfo
// ----------------------------------------------------------------------------
// gets the streaming callback from this class or any superclass
wxObjectStreamingCallback GetStreamingCallback() const ;
-#ifdef WXWIN_COMPATIBILITY_2_4
+#if WXWIN_COMPATIBILITY_2_4
// Initializes parent pointers and hash table for fast searching.
- wxDEPRECATED( static void InitializeClasses() );
+ wxDEPRECATED( static void InitializeClasses() );
// Cleans up hash table used for fast searching.
- wxDEPRECATED( static void CleanUpClasses() );
+ wxDEPRECATED( static void CleanUpClasses() );
#endif
- static void CleanUp();
+ static void CleanUp();
// returns the first property
const wxPropertyInfo* GetFirstProperty() const { return m_firstProperty ; }
// we must be able to cast variants to wxObject pointers, templates seem not to be suitable
wxObject* VariantToInstance( wxxVariant &data ) const
- { if ( data.GetTypeInfo()->GetKind() == wxT_OBJECT )
- return m_variantToObjectConverter( data ) ;
- else
- return m_variantOfPtrToObjectConverter( data ) ;
+ {
+ if ( data.GetTypeInfo()->GetKind() == wxT_OBJECT )
+ return m_variantToObjectConverter( data ) ;
+ else
+ return m_variantOfPtrToObjectConverter( data ) ;
}
wxxVariant InstanceToVariant( wxObject *object ) const { return m_objectToVariantConverter( object ) ; }
static wxHashTable *sm_classTable;
protected :
- wxPropertyInfo * m_firstProperty ;
- wxHandlerInfo * m_firstHandler ;
+ wxPropertyInfo * m_firstProperty ;
+ wxHandlerInfo * m_firstHandler ;
private:
- const wxClassInfo** m_parents ;
- const wxChar* m_unitName;
+ const wxClassInfo** m_parents ;
+ const wxChar* m_unitName;
- wxConstructorBridge* m_constructor ;
- const wxChar ** m_constructorProperties ;
- const int m_constructorPropertiesCount ;
+ wxConstructorBridge* m_constructor ;
+ const wxChar ** m_constructorProperties ;
+ const int m_constructorPropertiesCount ;
wxVariantToObjectConverter m_variantOfPtrToObjectConverter ;
wxVariantToObjectConverter m_variantToObjectConverter ;
wxObjectToVariantConverter m_objectToVariantConverter ;
#define _DECLARE_DYNAMIC_CLASS(name) \
public: \
- static wxClassInfo sm_class##name; \
- static const wxClassInfo* sm_classParents##name[] ; \
+ static wxClassInfo ms_classInfo; \
+ static const wxClassInfo* ms_classParents[] ; \
static wxPropertyInfo* GetPropertiesStatic() ; \
static wxHandlerInfo* GetHandlersStatic() ; \
static wxClassInfo *GetClassInfoStatic() \
-{ return &name::sm_class##name; } \
+{ return &name::ms_classInfo; } \
virtual wxClassInfo *GetClassInfo() const \
-{ return &name::sm_class##name; }
+{ return &name::ms_classInfo; }
+/*
+#define _DECLARE_DYNAMIC_CLASS(name) \
+ public: \
+ static wxClassInfo ms_class##name; \
+ static const wxClassInfo* ms_classParents##name[] ; \
+ static wxPropertyInfo* GetPropertiesStatic() ; \
+ static wxHandlerInfo* GetHandlersStatic() ; \
+ static wxClassInfo *GetClassInfoStatic() \
+{ return &name::ms_class##name; } \
+ virtual wxClassInfo *GetClassInfo() const \
+{ return &name::ms_class##name; }
+*/
#define DECLARE_DYNAMIC_CLASS(name) \
- static wxConstructorBridge* sm_constructor##name ; \
- static const wxChar * sm_constructorProperties##name[] ; \
- static const int sm_constructorPropertiesCount##name ; \
+ static wxConstructorBridge* ms_constructor ; \
+ static const wxChar * ms_constructorProperties[] ; \
+ static const int ms_constructorPropertiesCount ; \
_DECLARE_DYNAMIC_CLASS(name)
#define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name) \
// Single inheritance with one base class
#define _TYPEINFO_CLASSES(n , toString , fromString ) \
- wxClassTypeInfo s_typeInfo##n(wxT_OBJECT , &n::sm_class##n , toString , fromString , typeid(n).name()) ; \
- wxClassTypeInfo s_typeInfoPtr##n(wxT_OBJECT_PTR , &n::sm_class##n , toString , fromString , typeid(n*).name()) ;
+ wxClassTypeInfo s_typeInfo##n(wxT_OBJECT , &n::ms_classInfo , toString , fromString , typeid(n).name()) ; \
+ wxClassTypeInfo s_typeInfoPtr##n(wxT_OBJECT_PTR , &n::ms_classInfo , toString , fromString , typeid(n*).name()) ;
#define _IMPLEMENT_DYNAMIC_CLASS(name, basename, unit , callback) \
wxObject* wxConstructorFor##name() \
{ return new name; } \
- const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
- wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
+ const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,NULL } ; \
+ wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name), \
+ wxClassInfo name::ms_classInfo(name::ms_classParents , wxT(unit) , wxT(#name), \
(int) sizeof(name), \
(wxObjectConstructorFn) wxConstructorFor##name , \
- name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name , \
- name::sm_constructorPropertiesCount##name , wxVariantOfPtrToObjectConverter##name , NULL , wxObjectToVariantConverter##name , callback);
+ name::GetPropertiesStatic(),name::GetHandlersStatic(),name::ms_constructor , name::ms_constructorProperties , \
+ name::ms_constructorPropertiesCount , wxVariantOfPtrToObjectConverter##name , NULL , wxObjectToVariantConverter##name , callback);
#define _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY(name, basename, unit, callback ) \
wxObject* wxConstructorFor##name() \
{ return new name; } \
- const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
- wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return &data.Get<name>() ; } \
- wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
+ const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,NULL } ; \
+ wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return &data.wxTEMPLATED_MEMBER_CALL(Get , name) ; } \
+ wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name), \
+ wxClassInfo name::ms_classInfo(name::ms_classParents , wxT(unit) , wxT(#name), \
(int) sizeof(name), \
(wxObjectConstructorFn) wxConstructorFor##name , \
- name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name , \
- name::sm_constructorPropertiesCount##name , wxVariantOfPtrToObjectConverter##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name, callback);
+ name::GetPropertiesStatic(),name::GetHandlersStatic(),name::ms_constructor , name::ms_constructorProperties, \
+ name::ms_constructorPropertiesCount , wxVariantOfPtrToObjectConverter##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name, callback);
#define IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename ) \
_IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , "" , NULL ) \
// this is for classes that do not derive from wxobject, there are no creators for these
#define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_NO_BASE_XTI( name , unit ) \
- const wxClassInfo* name::sm_classParents##name[] = { NULL } ; \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name), \
+ const wxClassInfo* name::ms_classParents[] = { NULL } ; \
+ wxClassInfo name::ms_classInfo(name::ms_classParents , wxEmptyString , wxT(#name), \
(int) sizeof(name), \
(wxObjectConstructorFn) 0 , \
name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
// this is for subclasses that still do not derive from wxobject
#define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_XTI( name , basename, unit ) \
- const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name), \
+ const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,NULL } ; \
+ wxClassInfo name::ms_classInfo(name::ms_classParents , wxEmptyString , wxT(#name), \
(int) sizeof(name), \
(wxObjectConstructorFn) 0 , \
name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
#define _IMPLEMENT_DYNAMIC_CLASS2(name, basename, basename2, unit) \
wxObject* wxConstructorFor##name() \
{ return new name; } \
- const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,&basename2::sm_class##basename2 , NULL } ; \
- wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
+ const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,&basename2::ms_classInfo , NULL } ; \
+ wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name), \
+ wxClassInfo name::ms_classInfo(name::ms_classParents , wxT(unit) , wxT(#name), \
(int) sizeof(name), \
(wxObjectConstructorFn) wxConstructorFor##name , \
- name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name , \
- name::sm_constructorPropertiesCount##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
+ name::GetPropertiesStatic(),name::GetHandlersStatic(),name::ms_constructor , name::ms_constructorProperties , \
+ name::ms_constructorPropertiesCount , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
#define IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2) \
_IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , "") \
// Single inheritance with one base class
#define _IMPLEMENT_ABSTRACT_CLASS(name, basename) \
- const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
- wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
- wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
+ const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,NULL } ; \
+ wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
+ wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name), \
+ wxClassInfo name::ms_classInfo(name::ms_classParents , wxEmptyString , wxT(#name), \
(int) sizeof(name), \
(wxObjectConstructorFn) 0 , \
name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
// Multiple inheritance with two base classes
#define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
- wxClassInfo name::sm_class##name(wxT(#name), wxT(#basename1), \
+ wxClassInfo name::ms_classInfo(wxT(#name), wxT(#basename1), \
wxT(#basename2), (int) sizeof(name), \
(wxObjectConstructorFn) 0);
projects / wxWidgets.git / blobdiff