1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: runtime metadata information (extended class info)
4 // Author: Stefan Csomor
8 // Copyright: (c) 1997 Julian Smart
9 // (c) 2003 Stefan Csomor
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
16 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
17 #pragma interface "xti.h"
20 // We want to support properties, event sources and events sinks through
21 // explicit declarations, using templates and specialization to make the
22 // effort as painless as possible.
24 // This means we have the following domains :
26 // - Type Information for categorizing built in types as well as custom types
27 // this includes information about enums, their values and names
28 // - Type safe value storage : a kind of wxVariant, called right now wxxVariant
29 // which will be merged with wxVariant
30 // - Property Information and Property Accessors providing access to a class'
31 // values and exposed event delegates
32 // - Information about event handlers
33 // - extended Class Information for accessing all these
35 // ----------------------------------------------------------------------------
37 // ----------------------------------------------------------------------------
40 #include "wx/memory.h"
42 #include "wx/string.h"
43 #include "wx/arrstr.h"
44 #include "wx/hashmap.h"
48 // we will move this later to defs.h
50 #if !wxCHECK_GCC_VERSION( 3 , 4 )
51 # define wxUSE_MEMBER_TEMPLATES 0
56 # define wxUSE_MEMBER_TEMPLATES 0
60 #ifndef wxUSE_MEMBER_TEMPLATES
61 #define wxUSE_MEMBER_TEMPLATES 1
64 #if wxUSE_MEMBER_TEMPLATES
65 #define WX_TEMPLATED_MEMBER_CALL( method , type ) method<type>()
66 #define WX_TEMPLATED_MEMBER_FIX( type )
68 #define WX_TEMPLATED_MEMBER_CALL( method , type ) method((type*)NULL)
69 #define WX_TEMPLATED_MEMBER_FIX( type ) type* =NULL
72 class WXDLLIMPEXP_BASE wxObject
;
73 class WXDLLIMPEXP_BASE wxClassInfo
;
74 class WXDLLIMPEXP_BASE wxDynamicClassInfo
;
75 class WXDLLIMPEXP_BASE wxHashTable
;
76 class WXDLLIMPEXP_BASE wxObjectRefData
;
77 class WXDLLIMPEXP_BASE wxEvent
;
79 typedef void (wxObject::*wxObjectEventFunction
)(wxEvent
&);
81 // ----------------------------------------------------------------------------
84 // In the header files there would no change from pure c++ code, in the
85 // implementation, an enum would have
86 // to be enumerated eg :
88 // WX_BEGIN_ENUM( wxFlavor )
89 // WX_ENUM_MEMBER( Vanilla )
90 // WX_ENUM_MEMBER( Chocolate )
91 // WX_ENUM_MEMBER( Strawberry )
92 // WX_END_ENUM( wxFlavor )
93 // ----------------------------------------------------------------------------
95 struct WXDLLIMPEXP_BASE wxEnumMemberData
101 class WXDLLIMPEXP_BASE wxEnumData
104 wxEnumData( wxEnumMemberData
* data
) ;
106 // returns true if the member has been found and sets the int value
107 // pointed to accordingly (if ptr != null )
108 // if not found returns false, value left unchanged
109 bool HasEnumMemberValue( const wxChar
*name
, int *value
= NULL
) const ;
111 // returns the value of the member, if not found in debug mode an
112 // assert is issued, in release 0 is returned
113 int GetEnumMemberValue(const wxChar
*name
) const ;
115 // returns the name of the enum member having the passed in value
116 // returns an emtpy string if not found
117 const wxChar
*GetEnumMemberName(int value
) const ;
119 // returns the number of members in this enum
120 int GetEnumCount() const { return m_count
; }
122 // returns the value of the nth member
123 int GetEnumMemberValueByIndex( int n
) const ;
125 // returns the value of the nth member
126 const wxChar
*GetEnumMemberNameByIndex( int n
) const ;
128 wxEnumMemberData
*m_members
;
132 #define WX_BEGIN_ENUM( e ) \
133 wxEnumMemberData s_enumDataMembers##e[] = {
135 #define WX_ENUM_MEMBER( v ) { wxT(#v), v } ,
137 #define WX_END_ENUM( e ) { NULL , 0 } } ; \
138 wxEnumData s_enumData##e( s_enumDataMembers##e ) ; \
139 wxEnumData *wxGetEnumData(e) { return &s_enumData##e ; } \
140 template<> void wxStringReadValue(const wxString& s , e &data ) \
142 data = (e) s_enumData##e.GetEnumMemberValue(s) ; \
144 template<> void wxStringWriteValue(wxString &s , const e &data ) \
146 s = s_enumData##e.GetEnumMemberName((int)data) ; \
148 void FromLong##e( long data , wxxVariant& result ) { result = wxxVariant((e)data) ;} \
149 void ToLong##e( const wxxVariant& data , long &result ) { result = (long) data.Get<e>() ;} \
150 wxEnumTypeInfo s_typeInfo##e(wxT_ENUM , &s_enumData##e , &wxToStringConverter<e> , &wxFromStringConverter<e> , &ToLong##e , &FromLong##e , typeid(e).name() ) ;
152 // ----------------------------------------------------------------------------
164 // typedef wxBitset<wxFlavor> wxCoupe ;
166 // in the implementation file :
168 // WX_BEGIN_ENUM( wxFlavor )
169 // WX_ENUM_MEMBER( Vanilla )
170 // WX_ENUM_MEMBER( Chocolate )
171 // WX_ENUM_MEMBER( Strawberry )
172 // WX_END_ENUM( wxFlavor )
174 // WX_IMPLEMENT_SET_STREAMING( wxCoupe , wxFlavor )
176 // implementation note : no partial specialization for streaming, but a delegation to a
179 // ----------------------------------------------------------------------------
181 // in order to remove dependancy on string tokenizer
182 void wxSetStringToArray( const wxString
&s
, wxArrayString
&array
) ;
185 void wxSetFromString(const wxString
&s
, wxBitset
<e
> &data
)
187 wxEnumData
* edata
= wxGetEnumData((e
) 0) ;
190 wxArrayString array
;
191 wxSetStringToArray( s
, array
) ;
193 for ( int i
= 0 ; i
< array
.Count() ; ++i
)
197 if ( edata
->HasEnumMemberValue( flag
, &ivalue
) )
199 data
.set( (e
) ivalue
) ;
205 void wxSetToString( wxString
&s
, const wxBitset
<e
> &data
)
207 wxEnumData
* edata
= wxGetEnumData((e
) 0) ;
208 int count
= edata
->GetEnumCount() ;
211 for ( i
= 0 ; i
< count
; i
++ )
213 e value
= (e
) edata
->GetEnumMemberValueByIndex(i
) ;
214 if ( data
.test( value
) )
216 // this could also be done by the templated calls
219 s
+= edata
->GetEnumMemberNameByIndex(i
) ;
224 #define WX_IMPLEMENT_SET_STREAMING(SetName,e) \
225 template<> void wxStringReadValue(const wxString &s , wxBitset<e> &data ) \
227 wxSetFromString( s , data ) ; \
229 template<> void wxStringWriteValue( wxString &s , const wxBitset<e> &data ) \
231 wxSetToString( s , data ) ; \
233 void FromLong##SetName( long data , wxxVariant& result ) { result = wxxVariant(SetName((unsigned long)data)) ;} \
234 void ToLong##SetName( const wxxVariant& data , long &result ) { result = (long) data.Get<SetName>().to_ulong() ;} \
235 wxEnumTypeInfo s_typeInfo##SetName(wxT_SET , &s_enumData##e , &wxToStringConverter<SetName> , &wxFromStringConverter<SetName> , &ToLong##SetName , &FromLong##SetName, typeid(SetName).name() ) ; \
239 void wxFlagsFromString(const wxString
&s
, e
&data
)
241 wxEnumData
* edata
= wxGetEnumData((e
*) 0) ;
244 wxArrayString array
;
245 wxSetStringToArray( s
, array
) ;
247 for ( size_t i
= 0 ; i
< array
.Count() ; ++i
)
251 if ( edata
->HasEnumMemberValue( flag
, &ivalue
) )
253 data
.m_data
|= ivalue
;
259 void wxFlagsToString( wxString
&s
, const e
& data
)
261 wxEnumData
* edata
= wxGetEnumData((e
*) 0) ;
262 int count
= edata
->GetEnumCount() ;
265 long dataValue
= data
.m_data
;
266 for ( i
= 0 ; i
< count
; i
++ )
268 int value
= edata
->GetEnumMemberValueByIndex(i
) ;
269 // make this to allow for multi-bit constants to work
270 if ( value
&& ( dataValue
& value
) == value
)
272 // clear the flags we just set
273 dataValue
&= ~value
;
274 // this could also be done by the templated calls
277 s
+= edata
->GetEnumMemberNameByIndex(i
) ;
282 #define WX_BEGIN_FLAGS( e ) \
283 wxEnumMemberData s_enumDataMembers##e[] = {
285 #define WX_FLAGS_MEMBER( v ) { wxT(#v), v } ,
287 #define WX_END_FLAGS( e ) { NULL , 0 } } ; \
288 wxEnumData s_enumData##e( s_enumDataMembers##e ) ; \
289 wxEnumData *wxGetEnumData(e*) { return &s_enumData##e ; } \
290 template<> void wxStringReadValue(const wxString &s , e &data ) \
292 wxFlagsFromString<e>( s , data ) ; \
294 template<> void wxStringWriteValue( wxString &s , const e& data ) \
296 wxFlagsToString<e>( s , data ) ; \
298 void FromLong##e( long data , wxxVariant& result ) { result = wxxVariant(e(data)) ;} \
299 void ToLong##e( const wxxVariant& data , long &result ) { result = (long) data.Get<e>().m_data ;} \
300 wxEnumTypeInfo s_typeInfo##e(wxT_SET , &s_enumData##e , &wxToStringConverter<e> , &wxFromStringConverter<e> , &ToLong##e , &FromLong##e, typeid(e).name() ) ;
301 // ----------------------------------------------------------------------------
303 // ----------------------------------------------------------------------------
306 // All data exposed by the RTTI is characterized using the following classes.
307 // The first characterization is done by wxTypeKind. All enums up to and including
308 // wxT_CUSTOM represent so called simple types. These cannot be divided any further.
309 // They can be converted to and from wxStrings, that's all.
314 wxT_VOID
= 0, // unknown type
324 wxT_STRING
, // must be wxString
325 wxT_SET
, // must be wxBitset<> template
327 wxT_CUSTOM
, // user defined type (e.g. wxPoint)
329 wxT_LAST_SIMPLE_TYPE_KIND
= wxT_CUSTOM
,
331 wxT_OBJECT_PTR
, // object reference
332 wxT_OBJECT
, // embedded object
333 wxT_COLLECTION
, // collection
335 wxT_DELEGATE
, // for connecting against an event source
337 wxT_LAST_TYPE_KIND
= wxT_DELEGATE
// sentinel for bad data, asserts, debugging
340 class WXDLLIMPEXP_BASE wxxVariant
;
341 class WXDLLIMPEXP_BASE wxTypeInfo
;
343 WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxTypeInfo
* , wxTypeInfoMap
, class WXDLLIMPEXP_BASE
) ;
345 class WXDLLIMPEXP_BASE wxTypeInfo
348 typedef void (*converterToString_t
)( const wxxVariant
& data
, wxString
&result
) ;
349 typedef void (*converterFromString_t
)( const wxString
& data
, wxxVariant
&result
) ;
351 wxTypeInfo(wxTypeKind kind
,
352 converterToString_t to
= NULL
, converterFromString_t from
= NULL
,
353 const wxString
&name
= wxEmptyString
):
354 m_toString(to
), m_fromString(from
), m_kind(kind
), m_name(name
)
359 wxTypeInfo(wxTypeKind kind
,
360 converterToString_t to
= NULL
, converterFromString_t from
= NULL
,
361 const char *name
= ""):
362 m_toString(to
), m_fromString(from
), m_kind(kind
), m_name(wxString::FromAscii(name
))
368 virtual ~wxTypeInfo()
373 // return the kind of this type (wxT_... constants)
374 wxTypeKind
GetKind() const { return m_kind
; }
376 // returns the unique name of this type
377 const wxString
& GetTypeName() const { return m_name
; }
379 // is this type a delegate type
380 bool IsDelegateType() const { return m_kind
== wxT_DELEGATE
; }
382 // is this type a custom type
383 bool IsCustomType() const { return m_kind
== wxT_CUSTOM
; }
385 // is this type an object type
386 bool IsObjectType() const { return m_kind
== wxT_OBJECT
|| m_kind
== wxT_OBJECT_PTR
; }
388 // can the content of this type be converted to and from strings ?
389 bool HasStringConverters() const { return m_toString
!= NULL
&& m_fromString
!= NULL
; }
391 // convert a wxxVariant holding data of this type into a string
392 void ConvertToString( const wxxVariant
& data
, wxString
&result
) const
394 { wxASSERT_MSG( m_toString
, wxT("String conversions not supported") ) ; (*m_toString
)( data
, result
) ; }
396 // convert a string into a wxxVariant holding the corresponding data in this type
397 void ConvertFromString( const wxString
& data
, wxxVariant
&result
) const
398 { wxASSERT_MSG( m_fromString
, wxT("String conversions not supported") ) ; (*m_fromString
)( data
, result
) ; }
401 static wxTypeInfo
*FindType(const char *typeName
) { return FindType( wxString::FromAscii(typeName
) ) ; }
403 static wxTypeInfo
*FindType(const wxChar
*typeName
);
410 converterToString_t m_toString
;
411 converterFromString_t m_fromString
;
413 static wxTypeInfoMap
* sm_typeTable
;
419 class WXDLLIMPEXP_BASE wxBuiltInTypeInfo
: public wxTypeInfo
422 wxBuiltInTypeInfo( wxTypeKind kind
, converterToString_t to
= NULL
, converterFromString_t from
= NULL
, const wxString
&name
= wxEmptyString
) :
423 wxTypeInfo( kind
, to
, from
, name
)
424 { wxASSERT_MSG( GetKind() < wxT_SET
, wxT("Illegal Kind for Base Type") ) ; }
426 wxBuiltInTypeInfo( wxTypeKind kind
, converterToString_t to
, converterFromString_t from
, const char *name
) :
427 wxTypeInfo( kind
, to
, from
, name
)
428 { wxASSERT_MSG( GetKind() < wxT_SET
, wxT("Illegal Kind for Base Type") ) ; }
432 class WXDLLIMPEXP_BASE wxCustomTypeInfo
: public wxTypeInfo
435 wxCustomTypeInfo( const wxString
&name
, converterToString_t to
, converterFromString_t from
) :
436 wxTypeInfo( wxT_CUSTOM
, to
, from
, name
)
439 wxCustomTypeInfo( const char *name
, converterToString_t to
, converterFromString_t from
) :
440 wxTypeInfo( wxT_CUSTOM
, to
, from
, name
)
445 class WXDLLIMPEXP_BASE wxEnumTypeInfo
: public wxTypeInfo
448 typedef void (*converterToLong_t
)( const wxxVariant
& data
, long &result
) ;
449 typedef void (*converterFromLong_t
)( long data
, wxxVariant
&result
) ;
451 wxEnumTypeInfo( wxTypeKind kind
, wxEnumData
* enumInfo
, converterToString_t to
, converterFromString_t from
,
452 converterToLong_t toLong
, converterFromLong_t fromLong
, const wxString
&name
) :
453 wxTypeInfo( kind
, to
, from
, name
) , m_toLong( toLong
) , m_fromLong( fromLong
)
454 { wxASSERT_MSG( kind
== wxT_ENUM
|| kind
== wxT_SET
, wxT("Illegal Kind for Enum Type")) ; m_enumInfo
= enumInfo
;}
457 wxEnumTypeInfo( wxTypeKind kind
, wxEnumData
* enumInfo
, converterToString_t to
, converterFromString_t from
,
458 converterToLong_t toLong
, converterFromLong_t fromLong
, const char * name
) :
459 wxTypeInfo( kind
, to
, from
, name
) , m_toLong( toLong
) , m_fromLong( fromLong
)
460 { wxASSERT_MSG( kind
== wxT_ENUM
|| kind
== wxT_SET
, wxT("Illegal Kind for Enum Type")) ; m_enumInfo
= enumInfo
;}
462 const wxEnumData
* GetEnumData() const { return m_enumInfo
; }
464 // convert a wxxVariant holding data of this type into a long
465 void ConvertToLong( const wxxVariant
& data
, long &result
) const
467 { wxASSERT_MSG( m_toLong
, wxT("Long conversions not supported") ) ; (*m_toLong
)( data
, result
) ; }
469 // convert a long into a wxxVariant holding the corresponding data in this type
470 void ConvertFromLong( long data
, wxxVariant
&result
) const
471 { wxASSERT_MSG( m_fromLong
, wxT("Long conversions not supported") ) ; (*m_fromLong
)( data
, result
) ; }
474 converterToLong_t m_toLong
;
475 converterFromLong_t m_fromLong
;
477 wxEnumData
*m_enumInfo
; // Kind == wxT_ENUM or Kind == wxT_SET
480 class WXDLLIMPEXP_BASE wxClassTypeInfo
: public wxTypeInfo
483 wxClassTypeInfo( wxTypeKind kind
, wxClassInfo
* classInfo
, converterToString_t to
= NULL
, converterFromString_t from
= NULL
, const wxString
&name
= wxEmptyString
) ;
485 wxClassTypeInfo( wxTypeKind kind
, wxClassInfo
* classInfo
, converterToString_t to
, converterFromString_t from
, const char *name
) ;
487 const wxClassInfo
*GetClassInfo() const { return m_classInfo
; }
489 wxClassInfo
*m_classInfo
; // Kind == wxT_OBJECT - could be NULL
492 class WXDLLIMPEXP_BASE wxCollectionTypeInfo
: public wxTypeInfo
495 wxCollectionTypeInfo( const wxString
&elementName
, converterToString_t to
, converterFromString_t from
, const wxString
&name
) :
496 wxTypeInfo( wxT_COLLECTION
, to
, from
, name
)
497 { m_elementTypeName
= elementName
; m_elementType
= NULL
;}
499 wxCollectionTypeInfo( const char *elementName
, converterToString_t to
, converterFromString_t from
, const char *name
) :
500 wxTypeInfo( wxT_COLLECTION
, to
, from
, name
)
501 { m_elementTypeName
= wxString::FromAscii( elementName
) ; m_elementType
= NULL
;}
503 const wxTypeInfo
* GetElementType() const
505 if ( m_elementType
== NULL
)
506 m_elementType
= wxTypeInfo::FindType( m_elementTypeName
) ;
507 return m_elementType
; }
509 mutable wxTypeInfo
* m_elementType
;
510 wxString m_elementTypeName
;
513 // a delegate is an exposed event source
515 class WXDLLIMPEXP_BASE wxDelegateTypeInfo
: public wxTypeInfo
518 wxDelegateTypeInfo( int eventType
, wxClassInfo
* eventClass
, converterToString_t to
= NULL
, converterFromString_t from
= NULL
) ;
519 int GetEventType() const { return m_eventType
; }
520 const wxClassInfo
* GetEventClass() const { return m_eventClass
; }
522 const wxClassInfo
*m_eventClass
; // (extended will merge into classinfo)
526 template<typename T
> const wxTypeInfo
* wxGetTypeInfo( T
* ) { return wxTypeInfo::FindType(typeid(T
).name()) ; }
528 // this macro is for usage with custom, non-object derived classes and structs, wxPoint is such a custom type
530 #define WX_CUSTOM_TYPE_INFO( e , toString , fromString ) \
531 wxCustomTypeInfo s_typeInfo##e(typeid(e).name() , &toString , &fromString) ;
533 #define WX_COLLECTION_TYPE_INFO( element , collection ) \
534 wxCollectionTypeInfo s_typeInfo##collection( typeid(element).name() , NULL , NULL , typeid(collection).name() ) ;
536 // sometimes a compiler invents specializations that are nowhere called, use this macro to satisfy the refs
538 #define WX_ILLEGAL_TYPE_SPECIALIZATION( a )
540 template<> const wxTypeInfo* wxGetTypeInfo( a * ) { assert(0) ; \
541 static wxBuiltInTypeInfo s_typeInfo( wxT_VOID ) ; return &s_typeInfo ; } \
542 template<> void wxStringReadValue(const wxString & , a & ) { assert(0) ; }\
543 template<> void wxStringWriteValue(wxString & , a const & ) { assert(0) ; }
546 // ----------------------------------------------------------------------------
547 // wxxVariant as typesafe data holder
548 // ----------------------------------------------------------------------------
550 class WXDLLIMPEXP_BASE wxxVariantData
553 virtual ~wxxVariantData() {}
555 // return a heap allocated duplicate
556 virtual wxxVariantData
* Clone() const = 0 ;
558 // returns the type info of the contentc
559 virtual const wxTypeInfo
* GetTypeInfo() const = 0 ;
562 template<typename T
> class wxxVariantDataT
: public wxxVariantData
565 wxxVariantDataT(const T
& d
) : m_data(d
) {}
566 virtual ~wxxVariantDataT() {}
568 // get a ref to the stored data
569 T
& Get() { return m_data
; }
571 // get a const ref to the stored data
572 const T
& Get() const { return m_data
; }
575 void Set(const T
& d
) { m_data
= d
; }
577 // return a heap allocated duplicate
578 virtual wxxVariantData
* Clone() const { return new wxxVariantDataT
<T
>( Get() ) ; }
580 // returns the type info of the contentc
581 virtual const wxTypeInfo
* GetTypeInfo() const { return wxGetTypeInfo( (T
*) NULL
) ; }
587 class WXDLLIMPEXP_BASE wxxVariant
590 wxxVariant() { m_data
= NULL
; }
591 wxxVariant( wxxVariantData
* data
, const wxString
& name
= wxT("") ) : m_data(data
) , m_name(name
) {}
592 wxxVariant( const wxxVariant
&d
) { if ( d
.m_data
) m_data
= d
.m_data
->Clone() ; else m_data
= NULL
; m_name
= d
.m_name
; }
594 template<typename T
> wxxVariant( const T
& data
, const wxString
& name
= wxT("") ) :
595 m_data(new wxxVariantDataT
<T
>(data
) ), m_name(name
) {}
597 ~wxxVariant() { delete m_data
; }
599 // get a ref to the stored data
600 template<typename T
> T
& Get(WX_TEMPLATED_MEMBER_FIX(T
))
602 wxxVariantDataT
<T
> *dataptr
= dynamic_cast<wxxVariantDataT
<T
>*> (m_data
) ;
603 wxASSERT_MSG( dataptr
, wxT("Cast not possible") ) ;
604 return dataptr
->Get() ;
607 // get a ref to the stored data
608 template<typename T
> const T
& Get(WX_TEMPLATED_MEMBER_FIX(T
)) const
610 const wxxVariantDataT
<T
> *dataptr
= dynamic_cast<const wxxVariantDataT
<T
>*> (m_data
) ;
611 wxASSERT_MSG( dataptr
, wxT("Cast not possible") ) ;
612 return dataptr
->Get() ;
615 bool IsEmpty() const { return m_data
== NULL
; }
617 template<typename T
> bool HasData() const
619 const wxxVariantDataT
<T
> *dataptr
= dynamic_cast<const wxxVariantDataT
<T
>*> (m_data
) ;
620 return dataptr
!= NULL
;
624 template<typename T
> void Set(const T
& data
) const
627 m_data
= new wxxVariantDataT
<T
>(data
) ;
630 wxxVariant
& operator=(const wxxVariant
&d
)
632 m_data
= d
.m_data
->Clone() ;
637 // gets the stored data casted to a wxObject* , returning NULL if cast is not possible
638 wxObject
* GetAsObject() ;
640 // get the typeinfo of the stored object
641 const wxTypeInfo
* GetTypeInfo() const { return m_data
->GetTypeInfo() ; }
643 // returns this value as string
644 wxString
GetAsString() const
647 GetTypeInfo()->ConvertToString( *this , s
) ;
650 const wxString
& GetName() const { return m_name
; }
652 wxxVariantData
* m_data
;
656 #include <wx/dynarray.h>
658 WX_DECLARE_OBJARRAY_WITH_DECL(wxxVariant
, wxxVariantArray
, class WXDLLIMPEXP_BASE
);
660 // templated streaming, every type must have their specialization for these methods
663 void wxStringReadValue( const wxString
&s
, T
&data
);
666 void wxStringWriteValue( wxString
&s
, const T
&data
);
669 void wxToStringConverter( const wxxVariant
&v
, wxString
&s
) { wxStringWriteValue( s
, v
.WX_TEMPLATED_MEMBER_CALL(Get
, T
) ) ; }
672 void wxFromStringConverter( const wxString
&s
, wxxVariant
&v
) { T d
; wxStringReadValue( s
, d
) ; v
= wxxVariant(d
) ; } \
674 // ----------------------------------------------------------------------------
677 // wxPropertyInfo is used to inquire of the property by name. It doesn't
678 // provide access to the property, only information about it. If you
679 // want access, look at wxPropertyAccessor.
680 // ----------------------------------------------------------------------------
682 class WXDLLIMPEXP_BASE wxSetter
685 wxSetter( const wxString name
) { m_name
= name
; }
686 virtual ~wxSetter() {}
687 virtual void Set( wxObject
*object
, const wxxVariant
&variantValue
) const = 0;
688 const wxString
& GetName() const { return m_name
; }
693 class WXDLLIMPEXP_BASE wxGetter
696 wxGetter( const wxString name
) { m_name
= name
; }
697 virtual ~wxGetter() {}
698 virtual void Get( const wxObject
*object
, wxxVariant
& result
) const = 0;
699 const wxString
& GetName() const { return m_name
; }
704 class WXDLLIMPEXP_BASE wxCollectionGetter
707 wxCollectionGetter( const wxString name
) { m_name
= name
; }
708 virtual ~wxCollectionGetter() {}
709 virtual void Get( const wxObject
*object
, wxxVariantArray
& result
) const = 0;
710 const wxString
& GetName() const { return m_name
; }
715 template<typename coll_t
> void wxCollectionToVariantArray( const coll_t
& coll
, wxxVariantArray
& result
) ;
717 class WXDLLIMPEXP_BASE wxAdder
720 wxAdder( const wxString name
) { m_name
= name
; }
721 virtual ~wxAdder() {}
722 virtual void Add( wxObject
*object
, const wxxVariant
&variantValue
) const= 0;
723 const wxString
& GetName() const { return m_name
; }
730 #define WX_SETTER( property, Klass, valueType, setterMethod ) \
731 class wxSetter##property : public wxSetter \
734 wxSetter##property() : wxSetter( wxT(#setterMethod) ) {} \
735 ~wxSetter##property() {} \
736 void Set( wxObject *object, const wxxVariant &variantValue ) const \
738 Klass *obj = dynamic_cast<Klass*>(object) ; \
739 if ( variantValue.HasData<valueType>() ) \
740 obj->setterMethod(variantValue.Get<valueType>()) ; \
742 obj->setterMethod(*variantValue.Get<valueType*>()) ; \
746 #define WX_GETTER( property, Klass, valueType , gettermethod ) \
747 class wxGetter##property : public wxGetter \
750 wxGetter##property() : wxGetter( wxT(#gettermethod) ) {} \
751 ~wxGetter##property() {} \
752 void Get( const wxObject *object , wxxVariant &result) const \
754 const Klass *obj = dynamic_cast<const Klass*>(object) ; \
755 result = wxxVariant( obj->gettermethod() ) ; \
759 #define WX_ADDER( property, Klass, valueType , addermethod ) \
760 class wxAdder##property : public wxAdder \
763 wxAdder##property() : wxAdder( wxT(#addermethod) ) {} \
764 ~wxAdder##property() {} \
765 void Add( wxObject *object, const wxxVariant &variantValue ) const \
767 Klass *obj = dynamic_cast<Klass*>(object) ; \
768 if ( variantValue.HasData<valueType>() ) \
769 obj->addermethod(variantValue.Get<valueType>()) ; \
771 obj->addermethod(*variantValue.Get<valueType*>()) ; \
775 #define WX_COLLECTION_GETTER( property, Klass, valueType , gettermethod ) \
776 class wxCollectionGetter##property : public wxCollectionGetter \
779 wxCollectionGetter##property() : wxCollectionGetter( wxT(#gettermethod) ) {} \
780 ~wxCollectionGetter##property() {} \
781 void Get( const wxObject *object , wxxVariantArray &result) const \
783 const Klass *obj = dynamic_cast<const Klass*>(object) ; \
784 wxCollectionToVariantArray( obj->gettermethod() , result ) ; \
788 class WXDLLIMPEXP_BASE wxPropertyAccessor
791 wxPropertyAccessor( wxSetter
*setter
, wxGetter
*getter
, wxAdder
*adder
, wxCollectionGetter
*collectionGetter
)
792 { m_setter
= setter
; m_getter
= getter
; m_adder
= adder
; m_collectionGetter
= collectionGetter
;}
794 virtual ~wxPropertyAccessor() {}
796 // Setting a simple property (non-collection)
797 virtual void SetProperty(wxObject
*object
, const wxxVariant
&value
) const
798 { wxASSERT_MSG(m_setter
,wxT("SetProperty called w/o valid setter") ) ; m_setter
->Set( object
, value
) ;}
800 // Getting a simple property (non-collection)
801 virtual void GetProperty(const wxObject
*object
, wxxVariant
&result
) const
802 { wxASSERT_MSG(m_getter
,wxT("GetProperty called w/o valid getter") ) ; m_getter
->Get( object
, result
) ;}
804 // Adding an element to a collection property
805 virtual void AddToPropertyCollection(wxObject
*object
, const wxxVariant
&value
) const
806 { wxASSERT_MSG(m_adder
,wxT("AddToPropertyCollection called w/o valid adder") ) ; m_adder
->Add( object
, value
) ;}
808 // Getting a collection property
809 virtual void GetPropertyCollection( const wxObject
*obj
, wxxVariantArray
&result
) const
810 { wxASSERT_MSG(m_collectionGetter
,wxT("GetPropertyCollection called w/o valid collection getter") ) ; m_collectionGetter
->Get( obj
, result
) ;}
812 virtual bool HasSetter() const { return m_setter
!= NULL
; }
813 virtual bool HasCollectionGetter() const { return m_collectionGetter
!= NULL
; }
814 virtual bool HasGetter() const { return m_getter
!= NULL
; }
815 virtual bool HasAdder() const { return m_adder
!= NULL
; }
817 virtual const wxString
& GetCollectionGetterName() const
818 { return m_collectionGetter
->GetName() ; }
819 virtual const wxString
& GetGetterName() const
820 { return m_getter
->GetName() ; }
821 virtual const wxString
& GetSetterName() const
822 { return m_setter
->GetName() ; }
823 virtual const wxString
& GetAdderName() const
824 { return m_adder
->GetName() ; }
830 wxCollectionGetter
* m_collectionGetter
;
833 class WXDLLIMPEXP_BASE wxGenericPropertyAccessor
: public wxPropertyAccessor
836 wxGenericPropertyAccessor( const wxString
&propName
) ;
837 ~wxGenericPropertyAccessor() ;
839 void RenameProperty( const wxString
&oldName
, const wxString
&newName
)
841 wxASSERT( oldName
== m_propertyName
) ; m_propertyName
= newName
;
843 virtual bool HasSetter() const { return true ; }
844 virtual bool HasGetter() const { return true ; }
845 virtual bool HasAdder() const { return false ; }
846 virtual bool HasCollectionGetter() const { return false ; }
848 virtual const wxString
& GetGetterName() const
849 { return m_getterName
; }
850 virtual const wxString
& GetSetterName() const
851 { return m_setterName
; }
853 virtual void SetProperty(wxObject
*object
, const wxxVariant
&value
) const ;
854 virtual void GetProperty(const wxObject
*object
, wxxVariant
&value
) const ;
856 // Adding an element to a collection property
857 virtual void AddToPropertyCollection(wxObject
*WXUNUSED(object
), const wxxVariant
&WXUNUSED(value
)) const
858 { wxASSERT_MSG(0,wxT("AddToPropertyCollection called on a generic accessor") ) ;}
860 // Getting a collection property
861 virtual void GetPropertyCollection( const wxObject
*WXUNUSED(obj
), wxxVariantArray
&WXUNUSED(result
)) const
862 { wxASSERT_MSG(0,wxT("GetPropertyCollection called on a generic accessor") ) ;}
864 struct wxGenericPropertyAccessorInternal
;
865 wxGenericPropertyAccessorInternal
* m_data
;
866 wxString m_propertyName
;
867 wxString m_setterName
;
868 wxString m_getterName
;
871 typedef long wxPropertyInfoFlags
;
873 // will be removed in future releases
874 wxPROP_DEPRECATED
= 0x00000001 ,
875 // object graph property, will be streamed with priority (after constructor properties)
876 wxPROP_OBJECT_GRAPH
= 0x00000002 ,
877 // this will only be streamed out and in as enum/set, the internal representation is still a long
878 wxPROP_ENUM_STORE_LONG
= 0x00000004 ,
879 // don't stream out this property, needed eg to avoid streaming out children that are always created by their parents
880 wxPROP_DONT_STREAM
= 0x00000008 ,
883 class WXDLLIMPEXP_BASE wxPropertyInfo
885 friend class WXDLLIMPEXP_BASE wxDynamicClassInfo
;
887 wxPropertyInfo(wxPropertyInfo
* &iter
,
888 wxClassInfo
* itsClass
,
889 const wxString
& name
,
890 const wxString
& typeName
,
891 wxPropertyAccessor
*accessor
,
893 wxPropertyInfoFlags flags
= 0,
894 const wxString
& helpString
= wxEmptyString
,
895 const wxString
& groupString
= wxEmptyString
) :
896 m_itsClass(itsClass
),
899 m_typeName(typeName
) ,
900 m_collectionElementTypeInfo(NULL
),
901 m_accessor(accessor
),
904 m_helpString(helpString
),
905 m_groupString(groupString
)
911 wxPropertyInfo(wxPropertyInfo
* &iter
,
912 wxClassInfo
* itsClass
,
913 const wxString
& name
,
914 const char* typeName
,
915 wxPropertyAccessor
*accessor
,
917 wxPropertyInfoFlags flags
= 0,
918 const wxString
& helpString
= wxEmptyString
,
919 const wxString
& groupString
= wxEmptyString
) :
920 m_itsClass(itsClass
),
923 m_typeName(wxString::FromAscii(typeName
)) ,
924 m_collectionElementTypeInfo(NULL
),
925 m_accessor(accessor
),
928 m_helpString(helpString
),
929 m_groupString(groupString
)
934 wxPropertyInfo(wxPropertyInfo
* &iter
,
935 wxClassInfo
* itsClass
,
936 const wxString
& name
,
937 wxDelegateTypeInfo
* type
,
938 wxPropertyAccessor
*accessor
,
940 wxPropertyInfoFlags flags
= 0,
941 const wxString
& helpString
= wxEmptyString
,
942 const wxString
& groupString
= wxEmptyString
) :
943 m_itsClass(itsClass
),
946 m_collectionElementTypeInfo(NULL
),
947 m_accessor(accessor
),
950 m_helpString(helpString
),
951 m_groupString(groupString
)
956 wxPropertyInfo(wxPropertyInfo
* &iter
,
957 wxClassInfo
* itsClass
, const wxString
& name
,
958 const wxString
& collectionTypeName
,
959 const wxString
& elementTypeName
,
960 wxPropertyAccessor
*accessor
,
961 wxPropertyInfoFlags flags
= 0,
962 const wxString
& helpString
= wxEmptyString
,
963 const wxString
& groupString
= wxEmptyString
) :
964 m_itsClass(itsClass
),
967 m_typeName(collectionTypeName
) ,
968 m_collectionElementTypeInfo(NULL
),
969 m_collectionElementTypeName(elementTypeName
),
970 m_accessor(accessor
) ,
972 m_helpString(helpString
),
973 m_groupString(groupString
)
979 wxPropertyInfo(wxPropertyInfo
* &iter
,
980 wxClassInfo
* itsClass
, const wxString
& name
,
981 const char* collectionTypeName
,
982 const char* elementTypeName
,
983 wxPropertyAccessor
*accessor
,
984 wxPropertyInfoFlags flags
= 0,
985 const wxString
& helpString
= wxEmptyString
,
986 const wxString
& groupString
= wxEmptyString
) :
987 m_itsClass(itsClass
),
990 m_typeName(wxString::FromAscii(collectionTypeName
)) ,
991 m_collectionElementTypeInfo(NULL
),
992 m_collectionElementTypeName(wxString::FromAscii(elementTypeName
)),
993 m_accessor(accessor
) ,
995 m_helpString(helpString
),
996 m_groupString(groupString
)
1003 // return the class this property is declared in
1004 const wxClassInfo
* GetDeclaringClass() const { return m_itsClass
; }
1006 // return the name of this property
1007 const wxString
& GetName() const { return m_name
; }
1009 // returns the flags of this property
1010 wxPropertyInfoFlags
GetFlags() const { return m_flags
;}
1012 // returns the short help string of this property
1013 const wxString
& GetHelpString() const { return m_helpString
; }
1015 // returns the group string of this property
1016 const wxString
& GetGroupString() const { return m_groupString
; }
1018 // return the element type info of this property (for collections, otherwise NULL)
1019 const wxTypeInfo
* GetCollectionElementTypeInfo() const
1021 if ( m_collectionElementTypeInfo
== NULL
)
1022 m_collectionElementTypeInfo
= wxTypeInfo::FindType(m_collectionElementTypeName
) ;
1023 return m_collectionElementTypeInfo
;
1026 // return the type info of this property
1027 const wxTypeInfo
* GetTypeInfo() const
1029 if ( m_typeInfo
== NULL
)
1030 m_typeInfo
= wxTypeInfo::FindType(m_typeName
) ;
1034 // return the accessor for this property
1035 wxPropertyAccessor
* GetAccessor() const { return m_accessor
; }
1037 // returns NULL if this is the last property of this class
1038 wxPropertyInfo
* GetNext() const { return m_next
; }
1040 // returns the default value of this property, its kind may be wxT_VOID if it is not valid
1041 wxxVariant
GetDefaultValue() const { return m_defaultValue
; }
1043 void Insert(wxPropertyInfo
* &iter
)
1050 wxPropertyInfo
* i
= iter
;
1058 wxClassInfo
* m_itsClass
;
1060 mutable wxTypeInfo
* m_typeInfo
;
1061 wxString m_typeName
;
1062 mutable wxTypeInfo
* m_collectionElementTypeInfo
;
1063 wxString m_collectionElementTypeName
;
1064 wxPropertyAccessor
* m_accessor
;
1065 wxxVariant m_defaultValue
;
1066 wxPropertyInfoFlags m_flags
;
1067 wxString m_helpString
;
1068 wxString m_groupString
;
1069 // string representation of the default value
1070 // to be assigned by the designer to the property
1071 // when the component is dropped on the container.
1072 wxPropertyInfo
* m_next
;
1075 WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxPropertyInfo
* , wxPropertyInfoMap
, class WXDLLIMPEXP_BASE
) ;
1077 #define WX_BEGIN_PROPERTIES_TABLE(theClass) \
1078 wxPropertyInfo *theClass::GetPropertiesStatic() \
1080 typedef theClass class_t; \
1081 static wxPropertyInfo* first = NULL ;
1083 #define WX_END_PROPERTIES_TABLE() \
1086 #define WX_HIDE_PROPERTY( pname ) \
1087 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(void).name() ,NULL , wxxVariant() , wxPROP_DONT_STREAM , wxEmptyString , wxEmptyString ) ;
1089 #define WX_PROPERTY( pname , type , setter , getter ,defaultValue , flags , help , group) \
1090 WX_SETTER( pname , class_t , type , setter ) \
1091 static wxSetter##pname _setter##pname ; \
1092 WX_GETTER( pname , class_t , type , getter ) \
1093 static wxGetter##pname _getter##pname ; \
1094 static wxPropertyAccessor _accessor##pname( &_setter##pname , &_getter##pname , NULL , NULL ) ; \
1095 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(type).name() ,&_accessor##pname , wxxVariant(defaultValue) , flags , group , help ) ;
1097 #define WX_PROPERTY_FLAGS( pname , flags , type , setter , getter ,defaultValue , pflags , help , group) \
1098 WX_SETTER( pname , class_t , type , setter ) \
1099 static wxSetter##pname _setter##pname ; \
1100 WX_GETTER( pname , class_t , type , getter ) \
1101 static wxGetter##pname _getter##pname ; \
1102 static wxPropertyAccessor _accessor##pname( &_setter##pname , &_getter##pname , NULL , NULL ) ; \
1103 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(flags).name() ,&_accessor##pname , wxxVariant(defaultValue), wxPROP_ENUM_STORE_LONG | pflags , help , group ) ;
1105 #define WX_READONLY_PROPERTY( pname , type , getter ,defaultValue , flags , help , group) \
1106 WX_GETTER( pname , class_t , type , getter ) \
1107 static wxGetter##pname _getter##pname ; \
1108 static wxPropertyAccessor _accessor##pname( NULL , &_getter##pname , NULL , NULL ) ; \
1109 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(type).name() ,&_accessor##pname , wxxVariant(defaultValue), flags , help , group ) ;
1111 #define WX_READONLY_PROPERTY_FLAGS( pname , flags , type , getter ,defaultValue , pflags , help , group) \
1112 WX_GETTER( pname , class_t , type , getter ) \
1113 static wxGetter##pname _getter##pname ; \
1114 static wxPropertyAccessor _accessor##pname( NULL , &_getter##pname , NULL , NULL ) ; \
1115 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(flags).name() ,&_accessor##pname , wxxVariant(defaultValue), wxPROP_ENUM_STORE_LONG | pflags , help , group ) ;
1117 #define WX_PROPERTY_COLLECTION( pname , colltype , addelemtype , adder , getter , flags , help , group ) \
1118 WX_ADDER( pname , class_t , addelemtype , adder ) \
1119 static wxAdder##pname _adder##pname ; \
1120 WX_COLLECTION_GETTER( pname , class_t , colltype , getter ) \
1121 static wxCollectionGetter##pname _collectionGetter##pname ; \
1122 static wxPropertyAccessor _accessor##pname( NULL , NULL ,&_adder##pname , &_collectionGetter##pname ) ; \
1123 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(colltype).name() ,typeid(addelemtype).name() ,&_accessor##pname , flags , help , group ) ;
1125 #define WX_READONLY_PROPERTY_COLLECTION( pname , colltype , addelemtype , getter , flags , help , group) \
1126 WX_COLLECTION_GETTER( pname , class_t , colltype , getter ) \
1127 static wxCollectionGetter##pname _collectionGetter##pname ; \
1128 static wxPropertyAccessor _accessor##pname( NULL , NULL , NULL , &_collectionGetter##pname ) ; \
1129 static wxPropertyInfo _propertyInfo##pname( first ,class_t::GetClassInfoStatic() , wxT(#pname) , typeid(colltype).name() ,typeid(addelemtype).name() ,&_accessor##pname , flags , help , group ) ;
1132 #define WX_DELEGATE( name , eventType , eventClass ) \
1133 static wxDelegateTypeInfo _typeInfo##name( eventType , CLASSINFO( eventClass ) ) ; \
1134 static wxPropertyInfo _propertyInfo##name( first ,class_t::GetClassInfoStatic() , wxT(#name) , &_typeInfo##name , NULL , wxxVariant() ) ; \
1136 // ----------------------------------------------------------------------------
1139 // this is describing an event sink
1140 // ----------------------------------------------------------------------------
1142 class WXDLLIMPEXP_BASE wxHandlerInfo
1144 friend class WXDLLIMPEXP_BASE wxDynamicClassInfo
;
1146 wxHandlerInfo(wxHandlerInfo
* &iter
,
1147 wxClassInfo
* itsClass
,
1148 const wxString
& name
,
1149 wxObjectEventFunction address
,
1150 const wxClassInfo
* eventClassInfo
) :
1151 m_eventFunction(address
),
1153 m_eventClassInfo(eventClassInfo
) ,
1154 m_itsClass(itsClass
)
1161 wxHandlerInfo
* i
= iter
;
1171 // return the name of this handler
1172 const wxString
& GetName() const { return m_name
; }
1174 // return the class info of the event
1175 const wxClassInfo
* GetEventClassInfo() const { return m_eventClassInfo
; }
1177 // get the handler function pointer
1178 wxObjectEventFunction
GetEventFunction() const { return m_eventFunction
; }
1180 // returns NULL if this is the last handler of this class
1181 wxHandlerInfo
* GetNext() const { return m_next
; }
1183 // return the class this property is declared in
1184 const wxClassInfo
* GetDeclaringClass() const { return m_itsClass
; }
1187 wxObjectEventFunction m_eventFunction
;
1189 const wxClassInfo
* m_eventClassInfo
;
1190 wxHandlerInfo
* m_next
;
1191 wxClassInfo
* m_itsClass
;
1194 #define WX_HANDLER(name,eventClassType) \
1195 static wxHandlerInfo _handlerInfo##name( first , class_t::GetClassInfoStatic() , #name , (wxObjectEventFunction) (wxEventFunction) &name , CLASSINFO( eventClassType ) ) ;
1197 #define WX_BEGIN_HANDLERS_TABLE(theClass) \
1198 wxHandlerInfo *theClass::GetHandlersStatic() \
1200 typedef theClass class_t; \
1201 static wxHandlerInfo* first = NULL ;
1203 #define WX_END_HANDLERS_TABLE() \
1206 // ----------------------------------------------------------------------------
1207 // Constructor Bridges
1209 // allow to set up constructors with params during runtime
1210 // ----------------------------------------------------------------------------
1212 class WXDLLIMPEXP_BASE wxConstructorBridge
1215 virtual void Create(wxObject
* &o
, wxxVariant
*args
) = 0;
1218 // a direct constructor bridge calls the operator new for this class and
1219 // passes all params to the constructor. needed for classes that cannot be
1220 // instantiated using alloc-create semantics
1221 class WXDLLIMPEXP_BASE wxDirectConstructorBrigde
: public wxConstructorBridge
1224 virtual void Create(wxObject
* &o
, wxxVariant
*args
) = 0;
1227 // Creator Bridges for all Numbers of Params
1231 template<typename Class
>
1232 struct wxConstructorBridge_0
: public wxConstructorBridge
1234 void Create(wxObject
* &o
, wxxVariant
*)
1236 Class
*obj
= dynamic_cast<Class
*>(o
);
1241 struct wxConstructorBridge_Dummy
: public wxConstructorBridge
1243 void Create(wxObject
*&, wxxVariant
*)
1248 #define WX_CONSTRUCTOR_0(klass) \
1249 wxConstructorBridge_0<klass> constructor##klass ; \
1250 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1251 const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
1252 const int klass::sm_constructorPropertiesCount##klass = 0 ;
1254 #define WX_CONSTRUCTOR_DUMMY(klass) \
1255 wxConstructorBridge_Dummy constructor##klass ; \
1256 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1257 const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
1258 const int klass::sm_constructorPropertiesCount##klass = 0 ;
1262 template<typename Class
, typename T0
>
1263 struct wxConstructorBridge_1
: public wxConstructorBridge
1265 void Create(wxObject
* &o
, wxxVariant
*args
)
1267 Class
*obj
= dynamic_cast<Class
*>(o
);
1269 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
)
1274 #define WX_CONSTRUCTOR_1(klass,t0,v0) \
1275 wxConstructorBridge_1<klass,t0> constructor##klass ; \
1276 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1277 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) } ; \
1278 const int klass::sm_constructorPropertiesCount##klass = 1 ;
1282 template<typename Class
,
1283 typename T0
, typename T1
>
1284 struct wxConstructorBridge_2
: public wxConstructorBridge
1286 void Create(wxObject
* &o
, wxxVariant
*args
)
1288 Class
*obj
= dynamic_cast<Class
*>(o
);
1290 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
) ,
1291 args
[1].WX_TEMPLATED_MEMBER_CALL(Get
, T1
)
1296 #define WX_CONSTRUCTOR_2(klass,t0,v0,t1,v1) \
1297 wxConstructorBridge_2<klass,t0,t1> constructor##klass ; \
1298 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1299 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) } ; \
1300 const int klass::sm_constructorPropertiesCount##klass = 2;
1302 // direct constructor version
1304 template<typename Class
,
1305 typename T0
, typename T1
>
1306 struct wxDirectConstructorBridge_2
: public wxDirectConstructorBrigde
1308 void Create(wxObject
* &o
, wxxVariant
*args
)
1311 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
) ,
1312 args
[1].WX_TEMPLATED_MEMBER_CALL(Get
, T1
)
1317 #define WX_DIRECT_CONSTRUCTOR_2(klass,t0,v0,t1,v1) \
1318 wxDirectConstructorBridge_2<klass,t0,t1> constructor##klass ; \
1319 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1320 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) } ; \
1321 const int klass::sm_constructorPropertiesCount##klass = 2;
1326 template<typename Class
,
1327 typename T0
, typename T1
, typename T2
>
1328 struct wxConstructorBridge_3
: public wxConstructorBridge
1330 void Create(wxObject
* &o
, wxxVariant
*args
)
1332 Class
*obj
= dynamic_cast<Class
*>(o
);
1334 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
) ,
1335 args
[1].WX_TEMPLATED_MEMBER_CALL(Get
, T1
) ,
1336 args
[2].WX_TEMPLATED_MEMBER_CALL(Get
, T2
)
1341 #define WX_CONSTRUCTOR_3(klass,t0,v0,t1,v1,t2,v2) \
1342 wxConstructorBridge_3<klass,t0,t1,t2> constructor##klass ; \
1343 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1344 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) } ; \
1345 const int klass::sm_constructorPropertiesCount##klass = 3 ;
1349 template<typename Class
,
1350 typename T0
, typename T1
, typename T2
, typename T3
>
1351 struct wxConstructorBridge_4
: public wxConstructorBridge
1353 void Create(wxObject
* &o
, wxxVariant
*args
)
1355 Class
*obj
= dynamic_cast<Class
*>(o
);
1357 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
) ,
1358 args
[1].WX_TEMPLATED_MEMBER_CALL(Get
, T1
) ,
1359 args
[2].WX_TEMPLATED_MEMBER_CALL(Get
, T2
) ,
1360 args
[3].WX_TEMPLATED_MEMBER_CALL(Get
, T3
)
1365 #define WX_CONSTRUCTOR_4(klass,t0,v0,t1,v1,t2,v2,t3,v3) \
1366 wxConstructorBridge_4<klass,t0,t1,t2,t3> constructor##klass ; \
1367 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1368 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) } ; \
1369 const int klass::sm_constructorPropertiesCount##klass = 4 ;
1373 template<typename Class
,
1374 typename T0
, typename T1
, typename T2
, typename T3
, typename T4
>
1375 struct wxConstructorBridge_5
: public wxConstructorBridge
1377 void Create(wxObject
* &o
, wxxVariant
*args
)
1379 Class
*obj
= dynamic_cast<Class
*>(o
);
1381 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
) ,
1382 args
[1].WX_TEMPLATED_MEMBER_CALL(Get
, T1
) ,
1383 args
[2].WX_TEMPLATED_MEMBER_CALL(Get
, T2
) ,
1384 args
[3].WX_TEMPLATED_MEMBER_CALL(Get
, T3
) ,
1385 args
[4].WX_TEMPLATED_MEMBER_CALL(Get
, T4
)
1390 #define WX_CONSTRUCTOR_5(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4) \
1391 wxConstructorBridge_5<klass,t0,t1,t2,t3,t4> constructor##klass ; \
1392 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1393 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) } ; \
1394 const int klass::sm_constructorPropertiesCount##klass = 5;
1398 template<typename Class
,
1399 typename T0
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
>
1400 struct wxConstructorBridge_6
: public wxConstructorBridge
1402 void Create(wxObject
* &o
, wxxVariant
*args
)
1404 Class
*obj
= dynamic_cast<Class
*>(o
);
1406 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
) ,
1407 args
[1].WX_TEMPLATED_MEMBER_CALL(Get
, T1
) ,
1408 args
[2].WX_TEMPLATED_MEMBER_CALL(Get
, T2
) ,
1409 args
[3].WX_TEMPLATED_MEMBER_CALL(Get
, T3
) ,
1410 args
[4].WX_TEMPLATED_MEMBER_CALL(Get
, T4
) ,
1411 args
[5].WX_TEMPLATED_MEMBER_CALL(Get
, T5
)
1416 #define WX_CONSTRUCTOR_6(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \
1417 wxConstructorBridge_6<klass,t0,t1,t2,t3,t4,t5> constructor##klass ; \
1418 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1419 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) } ; \
1420 const int klass::sm_constructorPropertiesCount##klass = 6;
1422 // direct constructor version
1424 template<typename Class
,
1425 typename T0
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
>
1426 struct wxDirectConstructorBridge_6
: public wxDirectConstructorBrigde
1428 void Create(wxObject
* &o
, wxxVariant
*args
)
1431 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
) ,
1432 args
[1].WX_TEMPLATED_MEMBER_CALL(Get
, T1
) ,
1433 args
[2].WX_TEMPLATED_MEMBER_CALL(Get
, T2
) ,
1434 args
[3].WX_TEMPLATED_MEMBER_CALL(Get
, T3
) ,
1435 args
[4].WX_TEMPLATED_MEMBER_CALL(Get
, T4
) ,
1436 args
[5].WX_TEMPLATED_MEMBER_CALL(Get
, T5
)
1441 #define WX_DIRECT_CONSTRUCTOR_6(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \
1442 wxDirectConstructorBridge_6<klass,t0,t1,t2,t3,t4,t5> constructor##klass ; \
1443 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1444 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) } ; \
1445 const int klass::sm_constructorPropertiesCount##klass = 6;
1449 template<typename Class
,
1450 typename T0
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
>
1451 struct wxConstructorBridge_7
: public wxConstructorBridge
1453 void Create(wxObject
* &o
, wxxVariant
*args
)
1455 Class
*obj
= dynamic_cast<Class
*>(o
);
1457 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
) ,
1458 args
[1].WX_TEMPLATED_MEMBER_CALL(Get
, T1
) ,
1459 args
[2].WX_TEMPLATED_MEMBER_CALL(Get
, T2
) ,
1460 args
[3].WX_TEMPLATED_MEMBER_CALL(Get
, T3
) ,
1461 args
[4].WX_TEMPLATED_MEMBER_CALL(Get
, T4
) ,
1462 args
[5].WX_TEMPLATED_MEMBER_CALL(Get
, T5
) ,
1463 args
[6].WX_TEMPLATED_MEMBER_CALL(Get
, T6
)
1468 #define WX_CONSTRUCTOR_7(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6) \
1469 wxConstructorBridge_7<klass,t0,t1,t2,t3,t4,t5,t6> constructor##klass ; \
1470 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1471 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) , wxT(#v6) } ; \
1472 const int klass::sm_constructorPropertiesCount##klass = 7;
1476 template<typename Class
,
1477 typename T0
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
, typename T6
, typename T7
>
1478 struct wxConstructorBridge_8
: public wxConstructorBridge
1480 void Create(wxObject
* &o
, wxxVariant
*args
)
1482 Class
*obj
= dynamic_cast<Class
*>(o
);
1484 args
[0].WX_TEMPLATED_MEMBER_CALL(Get
, T0
) ,
1485 args
[1].WX_TEMPLATED_MEMBER_CALL(Get
, T1
) ,
1486 args
[2].WX_TEMPLATED_MEMBER_CALL(Get
, T2
) ,
1487 args
[3].WX_TEMPLATED_MEMBER_CALL(Get
, T3
) ,
1488 args
[4].WX_TEMPLATED_MEMBER_CALL(Get
, T4
) ,
1489 args
[5].WX_TEMPLATED_MEMBER_CALL(Get
, T5
) ,
1490 args
[6].WX_TEMPLATED_MEMBER_CALL(Get
, T6
) ,
1491 args
[7].WX_TEMPLATED_MEMBER_CALL(Get
, T7
)
1496 #define WX_CONSTRUCTOR_8(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7) \
1497 wxConstructorBridge_8<klass,t0,t1,t2,t3,t4,t5,t6,t7> constructor##klass ; \
1498 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1499 const wxChar *klass::sm_constructorProperties##klass[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) , wxT(#v6) , wxT(#v7) } ; \
1500 const int klass::sm_constructorPropertiesCount##klass = 8;
1501 // ----------------------------------------------------------------------------
1503 // ----------------------------------------------------------------------------
1505 typedef wxObject
*(*wxObjectConstructorFn
)(void);
1506 typedef wxObject
* (*wxVariantToObjectConverter
)( wxxVariant
&data
) ;
1507 typedef wxxVariant (*wxObjectToVariantConverter
)( wxObject
* ) ;
1509 class WXDLLIMPEXP_BASE wxWriter
;
1510 class WXDLLIMPEXP_BASE wxPersister
;
1512 typedef bool (*wxObjectStreamingCallback
) ( const wxObject
*, wxWriter
* , wxPersister
* , wxxVariantArray
& ) ;
1514 class WXDLLIMPEXP_BASE wxClassInfo
1516 friend class WXDLLIMPEXP_BASE wxPropertyInfo
;
1517 friend class WXDLLIMPEXP_BASE wxHandlerInfo
;
1519 wxClassInfo(const wxClassInfo
**_Parents
,
1520 const wxChar
*_UnitName
,
1521 const wxChar
*_ClassName
,
1523 wxObjectConstructorFn ctor
,
1524 wxPropertyInfo
*_Props
,
1525 wxHandlerInfo
*_Handlers
,
1526 wxConstructorBridge
* _Constructor
,
1527 const wxChar
** _ConstructorProperties
,
1528 const int _ConstructorPropertiesCount
,
1529 wxVariantToObjectConverter _PtrConverter1
,
1530 wxVariantToObjectConverter _Converter2
,
1531 wxObjectToVariantConverter _Converter3
,
1532 wxObjectStreamingCallback _streamingCallback
= NULL
1535 m_className(_ClassName
),
1537 m_objectConstructor(ctor
),
1539 m_firstProperty(_Props
),
1540 m_firstHandler(_Handlers
),
1541 m_parents(_Parents
),
1542 m_unitName(_UnitName
),
1543 m_constructor(_Constructor
),
1544 m_constructorProperties(_ConstructorProperties
),
1545 m_constructorPropertiesCount(_ConstructorPropertiesCount
),
1546 m_variantOfPtrToObjectConverter(_PtrConverter1
),
1547 m_variantToObjectConverter(_Converter2
),
1548 m_objectToVariantConverter(_Converter3
),
1549 m_streamingCallback(_streamingCallback
)
1555 wxClassInfo(const wxChar
*_UnitName
, const wxChar
*_ClassName
,
1556 const wxClassInfo
**_Parents
) :
1557 m_className(_ClassName
),
1559 m_objectConstructor(NULL
),
1561 m_firstProperty(NULL
),
1562 m_firstHandler(NULL
),
1563 m_parents(_Parents
),
1564 m_unitName(_UnitName
),
1565 m_constructor(NULL
),
1566 m_constructorProperties(NULL
),
1567 m_constructorPropertiesCount(0),
1568 m_variantOfPtrToObjectConverter(NULL
),
1569 m_variantToObjectConverter(NULL
),
1570 m_objectToVariantConverter(NULL
),
1571 m_streamingCallback(NULL
)
1577 virtual ~wxClassInfo() ;
1579 // allocates an instance of this class, this object does not have to be initialized or fully constructed
1580 // as this call will be followed by a call to Create
1581 virtual wxObject
*AllocateObject() const { return m_objectConstructor
? (*m_objectConstructor
)() : 0; }
1583 // 'old naming' for AllocateObject staying here for backward compatibility
1584 wxObject
*CreateObject() const { return AllocateObject() ; }
1586 // direct construction call for classes that cannot construct instances via alloc/create
1587 wxObject
*ConstructObject(int ParamCount
, wxxVariant
*Params
) const
1589 wxASSERT_MSG( ParamCount
== m_constructorPropertiesCount
, wxT("Illegal Parameter Count for ConstructObject Method")) ;
1590 wxObject
*object
= NULL
;
1591 m_constructor
->Create( object
, Params
) ;
1595 bool NeedsDirectConstruction() const { return dynamic_cast<wxDirectConstructorBrigde
*>( m_constructor
) != NULL
; }
1597 const wxChar
*GetClassName() const { return m_className
; }
1598 const wxChar
*GetIncludeName() const { return m_unitName
; }
1599 const wxClassInfo
**GetParents() const { return m_parents
; }
1600 int GetSize() const { return m_objectSize
; }
1602 wxObjectConstructorFn
GetConstructor() const { return m_objectConstructor
; }
1603 static const wxClassInfo
*GetFirst() { return sm_first
; }
1604 const wxClassInfo
*GetNext() const { return m_next
; }
1605 static wxClassInfo
*FindClass(const wxChar
*className
);
1607 // Climb upwards through inheritance hierarchy.
1608 // Dual inheritance is catered for.
1610 bool IsKindOf(const wxClassInfo
*info
) const
1617 for ( int i
= 0 ; m_parents
[i
] ; ++ i
)
1619 if ( m_parents
[i
]->IsKindOf( info
) )
1626 // if there is a callback registered with that class it will be called
1627 // before this object will be written to disk, it can veto streaming out
1628 // this object by returning false, if this class has not registered a
1629 // callback, the search will go up the inheritance tree if no callback has
1630 // been registered true will be returned by default
1631 bool BeforeWriteObject( const wxObject
*obj
, wxWriter
*streamer
, wxPersister
*persister
, wxxVariantArray
&metadata
) const ;
1633 // gets the streaming callback from this class or any superclass
1634 wxObjectStreamingCallback
GetStreamingCallback() const ;
1636 #ifdef WXWIN_COMPATIBILITY_2_4
1637 // Initializes parent pointers and hash table for fast searching.
1638 wxDEPRECATED( static void InitializeClasses() );
1639 // Cleans up hash table used for fast searching.
1640 wxDEPRECATED( static void CleanUpClasses() );
1642 static void CleanUp();
1644 // returns the first property
1645 const wxPropertyInfo
* GetFirstProperty() const { return m_firstProperty
; }
1647 // returns the first handler
1648 const wxHandlerInfo
* GetFirstHandler() const { return m_firstHandler
; }
1650 // Call the Create upon an instance of the class, in the end the object is fully
1652 virtual void Create (wxObject
*object
, int ParamCount
, wxxVariant
*Params
) const
1654 wxASSERT_MSG( ParamCount
== m_constructorPropertiesCount
, wxT("Illegal Parameter Count for Create Method")) ;
1655 m_constructor
->Create( object
, Params
) ;
1658 // get number of parameters for constructor
1659 virtual int GetCreateParamCount() const { return m_constructorPropertiesCount
; }
1661 // get n-th constructor parameter
1662 virtual const wxChar
* GetCreateParamName(int n
) const { return m_constructorProperties
[n
] ; }
1664 // Runtime access to objects for simple properties (get/set) by property name, and variant data
1665 virtual void SetProperty (wxObject
*object
, const wxChar
*propertyName
, const wxxVariant
&value
) const ;
1666 virtual wxxVariant
GetProperty (wxObject
*object
, const wxChar
*propertyName
) const;
1668 // Runtime access to objects for collection properties by property name
1669 virtual wxxVariantArray
GetPropertyCollection(wxObject
*object
, const wxChar
*propertyName
) const ;
1670 virtual void AddToPropertyCollection(wxObject
*object
, const wxChar
*propertyName
, const wxxVariant
& value
) const ;
1672 // we must be able to cast variants to wxObject pointers, templates seem not to be suitable
1673 wxObject
* VariantToInstance( wxxVariant
&data
) const
1674 { if ( data
.GetTypeInfo()->GetKind() == wxT_OBJECT
)
1675 return m_variantToObjectConverter( data
) ;
1677 return m_variantOfPtrToObjectConverter( data
) ;
1680 wxxVariant
InstanceToVariant( wxObject
*object
) const { return m_objectToVariantConverter( object
) ; }
1682 // find property by name
1683 virtual const wxPropertyInfo
*FindPropertyInfo (const wxChar
*PropertyName
) const ;
1685 // find handler by name
1686 virtual const wxHandlerInfo
*FindHandlerInfo (const wxChar
*PropertyName
) const ;
1688 // find property by name
1689 virtual wxPropertyInfo
*FindPropertyInfoInThisClass (const wxChar
*PropertyName
) const ;
1691 // find handler by name
1692 virtual wxHandlerInfo
*FindHandlerInfoInThisClass (const wxChar
*PropertyName
) const ;
1694 // puts all the properties of this class and its superclasses in the map, as long as there is not yet
1695 // an entry with the same name (overriding mechanism)
1696 void GetProperties( wxPropertyInfoMap
&map
) const ;
1698 const wxChar
*m_className
;
1700 wxObjectConstructorFn m_objectConstructor
;
1702 // class info object live in a linked list:
1703 // pointers to its head and the next element in it
1705 static wxClassInfo
*sm_first
;
1706 wxClassInfo
*m_next
;
1708 // FIXME: this should be private (currently used directly by way too
1710 static wxHashTable
*sm_classTable
;
1713 wxPropertyInfo
* m_firstProperty
;
1714 wxHandlerInfo
* m_firstHandler
;
1716 const wxClassInfo
** m_parents
;
1717 const wxChar
* m_unitName
;
1719 wxConstructorBridge
* m_constructor
;
1720 const wxChar
** m_constructorProperties
;
1721 const int m_constructorPropertiesCount
;
1722 wxVariantToObjectConverter m_variantOfPtrToObjectConverter
;
1723 wxVariantToObjectConverter m_variantToObjectConverter
;
1724 wxObjectToVariantConverter m_objectToVariantConverter
;
1725 wxObjectStreamingCallback m_streamingCallback
;
1726 const wxPropertyAccessor
*FindAccessor (const wxChar
*propertyName
) const ;
1729 // InitializeClasses() helper
1730 static wxClassInfo
*GetBaseByName(const wxChar
*name
) ;
1733 // registers the class
1737 DECLARE_NO_COPY_CLASS(wxClassInfo
)
1741 WXDLLIMPEXP_BASE wxObject
*wxCreateDynamicObject(const wxChar
*name
);
1743 // ----------------------------------------------------------------------------
1745 // ----------------------------------------------------------------------------
1747 // this object leads to having a pure runtime-instantiation
1749 class WXDLLIMPEXP_BASE wxDynamicClassInfo
: public wxClassInfo
1752 wxDynamicClassInfo( const wxChar
*_UnitName
, const wxChar
*_ClassName
, const wxClassInfo
* superClass
) ;
1753 virtual ~wxDynamicClassInfo() ;
1755 // constructs a wxDynamicObject with an instance
1756 virtual wxObject
*AllocateObject() const ;
1758 // Call the Create method for a class
1759 virtual void Create (wxObject
*object
, int ParamCount
, wxxVariant
*Params
) const ;
1761 // get number of parameters for constructor
1762 virtual int GetCreateParamCount() const ;
1764 // get i-th constructor parameter
1765 virtual const wxChar
* GetCreateParamName(int i
) const ;
1767 // Runtime access to objects by property name, and variant data
1768 virtual void SetProperty (wxObject
*object
, const wxChar
*PropertyName
, const wxxVariant
&Value
) const ;
1769 virtual wxxVariant
GetProperty (wxObject
*object
, const wxChar
*PropertyName
) const ;
1771 // adds a property to this class at runtime
1772 void AddProperty( const wxChar
*propertyName
, const wxTypeInfo
* typeInfo
) ;
1774 // removes an existing runtime-property
1775 void RemoveProperty( const wxChar
*propertyName
) ;
1777 // renames an existing runtime-property
1778 void RenameProperty( const wxChar
*oldPropertyName
, const wxChar
*newPropertyName
) ;
1780 // as a handler to this class at runtime
1781 void AddHandler( const wxChar
*handlerName
, wxObjectEventFunction address
, const wxClassInfo
* eventClassInfo
) ;
1783 // removes an existing runtime-handler
1784 void RemoveHandler( const wxChar
*handlerName
) ;
1786 // renames an existing runtime-handler
1787 void RenameHandler( const wxChar
*oldHandlerName
, const wxChar
*newHandlerName
) ;
1790 // ----------------------------------------------------------------------------
1791 // Dynamic class macros
1792 // ----------------------------------------------------------------------------
1794 #define _DECLARE_DYNAMIC_CLASS(name) \
1796 static wxClassInfo sm_class##name; \
1797 static const wxClassInfo* sm_classParents##name[] ; \
1798 static wxPropertyInfo* GetPropertiesStatic() ; \
1799 static wxHandlerInfo* GetHandlersStatic() ; \
1800 static wxClassInfo *GetClassInfoStatic() \
1801 { return &name::sm_class##name; } \
1802 virtual wxClassInfo *GetClassInfo() const \
1803 { return &name::sm_class##name; }
1805 #define DECLARE_DYNAMIC_CLASS(name) \
1806 static wxConstructorBridge* sm_constructor##name ; \
1807 static const wxChar * sm_constructorProperties##name[] ; \
1808 static const int sm_constructorPropertiesCount##name ; \
1809 _DECLARE_DYNAMIC_CLASS(name)
1811 #define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name) \
1812 DECLARE_NO_ASSIGN_CLASS(name) \
1813 DECLARE_DYNAMIC_CLASS(name)
1815 #define DECLARE_DYNAMIC_CLASS_NO_COPY(name) \
1816 DECLARE_NO_COPY_CLASS(name) \
1817 DECLARE_DYNAMIC_CLASS(name)
1819 #define DECLARE_ABSTRACT_CLASS(name) _DECLARE_DYNAMIC_CLASS(name)
1820 #define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
1822 // -----------------------------------
1823 // for concrete classes
1824 // -----------------------------------
1826 // Single inheritance with one base class
1828 #define _TYPEINFO_CLASSES(n , toString , fromString ) \
1829 wxClassTypeInfo s_typeInfo##n(wxT_OBJECT , &n::sm_class##n , toString , fromString , typeid(n).name()) ; \
1830 wxClassTypeInfo s_typeInfoPtr##n(wxT_OBJECT_PTR , &n::sm_class##n , toString , fromString , typeid(n*).name()) ;
1832 #define _IMPLEMENT_DYNAMIC_CLASS(name, basename, unit , callback) \
1833 wxObject* wxConstructorFor##name() \
1834 { return new name; } \
1835 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
1836 wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1837 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1838 wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name), \
1839 (int) sizeof(name), \
1840 (wxObjectConstructorFn) wxConstructorFor##name , \
1841 name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name , \
1842 name::sm_constructorPropertiesCount##name , wxVariantOfPtrToObjectConverter##name , NULL , wxObjectToVariantConverter##name , callback);
1844 #define _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY(name, basename, unit, callback ) \
1845 wxObject* wxConstructorFor##name() \
1846 { return new name; } \
1847 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
1848 wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return &data.Get<name>() ; } \
1849 wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1850 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1851 wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name), \
1852 (int) sizeof(name), \
1853 (wxObjectConstructorFn) wxConstructorFor##name , \
1854 name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name , \
1855 name::sm_constructorPropertiesCount##name , wxVariantOfPtrToObjectConverter##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name, callback);
1857 #define IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename ) \
1858 _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , "" , NULL ) \
1859 _TYPEINFO_CLASSES(name, NULL , NULL) \
1860 const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
1861 const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1862 WX_CONSTRUCTOR_DUMMY( name )
1864 #define IMPLEMENT_DYNAMIC_CLASS( name , basename ) \
1865 _IMPLEMENT_DYNAMIC_CLASS( name , basename , "" , NULL ) \
1866 _TYPEINFO_CLASSES(name, NULL , NULL) \
1867 wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
1868 wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1869 WX_CONSTRUCTOR_DUMMY( name )
1871 #define IMPLEMENT_DYNAMIC_CLASS_XTI( name , basename , unit ) \
1872 _IMPLEMENT_DYNAMIC_CLASS( name , basename , unit , NULL ) \
1873 _TYPEINFO_CLASSES(name, NULL , NULL)
1875 #define IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK( name , basename , unit , callback ) \
1876 _IMPLEMENT_DYNAMIC_CLASS( name , basename , unit , &callback ) \
1877 _TYPEINFO_CLASSES(name, NULL , NULL)
1879 #define IMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI( name , basename , unit ) \
1880 _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , unit , NULL ) \
1881 _TYPEINFO_CLASSES(name, NULL , NULL)
1883 #define IMPLEMENT_DYNAMIC_CLASS_WITH_COPY_AND_STREAMERS_XTI( name , basename , unit , toString , fromString ) \
1884 _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , unit , NULL ) \
1885 _TYPEINFO_CLASSES(name, toString , fromString)
1887 // this is for classes that do not derive from wxobject, there are no creators for these
1889 #define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_NO_BASE_XTI( name , unit ) \
1890 const wxClassInfo* name::sm_classParents##name[] = { NULL } ; \
1891 wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name), \
1892 (int) sizeof(name), \
1893 (wxObjectConstructorFn) 0 , \
1894 name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
1896 _TYPEINFO_CLASSES(name, NULL , NULL)
1898 // this is for subclasses that still do not derive from wxobject
1900 #define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_XTI( name , basename, unit ) \
1901 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
1902 wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name), \
1903 (int) sizeof(name), \
1904 (wxObjectConstructorFn) 0 , \
1905 name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
1907 _TYPEINFO_CLASSES(name, NULL , NULL)
1910 // Multiple inheritance with two base classes
1912 #define _IMPLEMENT_DYNAMIC_CLASS2(name, basename, basename2, unit) \
1913 wxObject* wxConstructorFor##name() \
1914 { return new name; } \
1915 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,&basename2::sm_class##basename2 , NULL } ; \
1916 wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1917 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1918 wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name), \
1919 (int) sizeof(name), \
1920 (wxObjectConstructorFn) wxConstructorFor##name , \
1921 name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name , \
1922 name::sm_constructorPropertiesCount##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
1924 #define IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2) \
1925 _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , "") \
1926 _TYPEINFO_CLASSES(name, NULL , NULL) \
1927 wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
1928 wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1929 WX_CONSTRUCTOR_DUMMY( name )
1931 #define IMPLEMENT_DYNAMIC_CLASS2_XTI( name , basename , basename2, unit) \
1932 _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , unit) \
1933 _TYPEINFO_CLASSES(name, NULL , NULL)
1936 // -----------------------------------
1937 // for abstract classes
1938 // -----------------------------------
1940 // Single inheritance with one base class
1942 #define _IMPLEMENT_ABSTRACT_CLASS(name, basename) \
1943 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
1944 wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1945 wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1946 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1947 wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name), \
1948 (int) sizeof(name), \
1949 (wxObjectConstructorFn) 0 , \
1950 name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
1951 0 , wxVariantOfPtrToObjectConverter##name ,wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
1952 _TYPEINFO_CLASSES(name, NULL , NULL)
1954 #define IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
1955 _IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
1956 wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1957 wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; }
1959 // Multiple inheritance with two base classes
1961 #define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
1962 wxClassInfo name::sm_class##name(wxT(#name), wxT(#basename1), \
1963 wxT(#basename2), (int) sizeof(name), \
1964 (wxObjectConstructorFn) 0);
1966 #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
1967 #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
1969 // --------------------------------------------------------------------------
1970 // Collection Support
1971 // --------------------------------------------------------------------------
1973 template<typename iter
, typename collection_t
> void wxListCollectionToVariantArray( const collection_t
& coll
, wxxVariantArray
&value
)
1975 iter current
= coll
.GetFirst() ;
1978 value
.Add( new wxxVariant(current
->GetData()) ) ;
1979 current
= current
->GetNext();
1983 template<typename collection_t
> void wxArrayCollectionToVariantArray( const collection_t
& coll
, wxxVariantArray
&value
)
1985 for( size_t i
= 0 ; i
< coll
.GetCount() ; i
++ )
1987 value
.Add( new wxxVariant(coll
[i
]) ) ;