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"
45 // some compilers have troubles getting the correct wxPropertyAccessorT constructor
46 // set this to 1 to make things work for these, too
48 #ifndef WX_XTI_TEMPLATE_FIX
49 #define WX_XTI_TEMPLATE_FIX 0
52 #if WX_XTI_TEMPLATE_FIX
53 #define WX_XTI_PARAM_FIX(a,b) a,b
55 #define WX_XTI_PARAM_FIX(a,b)
58 class WXDLLIMPEXP_BASE wxObject
;
59 class WXDLLIMPEXP_BASE wxClassInfo
;
60 class WXDLLIMPEXP_BASE wxHashTable
;
61 class WXDLLIMPEXP_BASE wxObjectRefData
;
62 class WXDLLIMPEXP_BASE wxEvent
;
64 typedef void (wxObject::*wxObjectEventFunction
)(wxEvent
&);
66 // ----------------------------------------------------------------------------
69 // In the header files there would no change from pure c++ code, in the
70 // implementation, an enum would have
71 // to be enumerated eg :
73 // WX_BEGIN_ENUM( wxFlavor )
74 // WX_ENUM_MEMBER( Vanilla )
75 // WX_ENUM_MEMBER( Chocolate )
76 // WX_ENUM_MEMBER( Strawberry )
77 // WX_END_ENUM( wxFlavor )
78 // ----------------------------------------------------------------------------
80 struct WXDLLIMPEXP_BASE wxEnumMemberData
86 class WXDLLIMPEXP_BASE wxEnumData
89 wxEnumData( wxEnumMemberData
* data
) ;
91 // returns true if the member has been found and sets the int value
92 // pointed to accordingly (if ptr != null )
93 // if not found returns false, value left unchanged
94 bool HasEnumMemberValue( const wxChar
*name
, int *value
= NULL
) ;
96 // returns the value of the member, if not found in debug mode an
97 // assert is issued, in release 0 is returned
98 int GetEnumMemberValue(const wxChar
*name
);
100 // returns the name of the enum member having the passed in value
101 // returns an emtpy string if not found
102 const wxChar
*GetEnumMemberName(int value
);
104 // returns the number of members in this enum
105 int GetEnumCount() { return m_count
; }
107 // returns the value of the nth member
108 int GetEnumMemberValueByIndex( int n
) ;
110 // returns the value of the nth member
111 const wxChar
*GetEnumMemberNameByIndex( int n
) ;
113 wxEnumMemberData
*m_members
;
117 #define WX_BEGIN_ENUM( e ) \
118 wxEnumMemberData s_enumDataMembers##e[] = {
120 #define WX_ENUM_MEMBER( v ) { #v, v } ,
122 #define WX_END_ENUM( e ) { NULL , 0 } } ; \
123 wxEnumData s_enumData##e( s_enumDataMembers##e ) ; \
124 wxEnumData *wxGetEnumData(e) { return &s_enumData##e ; } \
125 template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxEnumTypeInfo s_typeInfo(wxT_ENUM , &s_enumData##e) ; return &s_typeInfo ; } \
126 template<> void wxStringReadValue(const wxString& s , e &data ) \
128 data = (e) s_enumData##e.GetEnumMemberValue(s) ; \
130 template<> void wxStringWriteValue(wxString &s , const e &data ) \
132 s = s_enumData##e.GetEnumMemberName((int)data) ; \
134 template<> const wxTypeInfo* wxGetTypeInfo( e ** ){ static wxBuiltInTypeInfo s_typeInfo(wxT_VOID ) ; assert(0) ; return &s_typeInfo ; } \
135 template<> void wxStringReadValue(const wxString& , e* & ) \
139 template<> void wxStringWriteValue(wxString &s , e* const & ) \
144 // ----------------------------------------------------------------------------
156 // typedef wxSet<wxFlavor> wxCoupe ;
158 // in the implementation file :
160 // WX_BEGIN_ENUM( wxFlavor )
161 // WX_ENUM_MEMBER( Vanilla )
162 // WX_ENUM_MEMBER( Chocolate )
163 // WX_ENUM_MEMBER( Strawberry )
164 // WX_END_ENUM( wxFlavor )
166 // WX_IMPLEMENT_SET_STREAMING( wxCoupe , wxFlavor )
168 // implementation note : no partial specialization for streaming, but a delegation to a
171 // ----------------------------------------------------------------------------
173 // in order to remove dependancy on string tokenizer
174 void wxSetStringToArray( const wxString
&s
, wxArrayString
&array
) ;
177 void wxSetFromString(const wxString
&s
, wxSet
<e
> &data
)
179 wxEnumData
* edata
= wxGetEnumData((e
) 0) ;
182 wxArrayString array
;
183 wxSetStringToArray( s
, array
) ;
185 for ( int i
= 0 ; i
< array
.Count() ; ++i
)
189 if ( edata
->HasEnumMemberValue( flag
, &ivalue
) )
191 data
.Set( (e
) ivalue
) ;
197 void wxSetToString( wxString
&s
, const wxSet
<e
> &data
)
199 wxEnumData
* edata
= wxGetEnumData((e
) 0) ;
200 int count
= edata
->GetEnumCount() ;
203 for ( i
= 0 ; i
< count
; i
++ )
205 e value
= (e
) edata
->GetEnumMemberValueByIndex(i
) ;
206 if ( data
.Contains( value
) )
208 // this could also be done by the templated calls
211 s
+= edata
->GetEnumMemberNameByIndex(i
) ;
216 // if the wxSet specialization above does not work for all compilers, add this to the WX_IMPLEMENT_SET_STREAMING macro
217 // template<> const wxTypeInfo* wxGetTypeInfo( SetName * ){ static wxEnumTypeInfo s_typeInfo(wxT_SET , &s_enumData##e) ; return &s_typeInfo ; }
219 #define WX_IMPLEMENT_SET_STREAMING(SetName,e) \
220 template<> void wxStringReadValue(const wxString &s , wxSet<e> &data ) \
222 wxSetFromString( s , data ) ; \
224 template<> void wxStringWriteValue( wxString &s , const wxSet<e> &data ) \
226 wxSetToString( s , data ) ; \
230 // ----------------------------------------------------------------------------
232 // ----------------------------------------------------------------------------
235 // All data exposed by the RTTI is characterized using the following classes.
236 // The first characterization is done by wxTypeKind. All enums up to and including
237 // wxT_CUSTOM represent so called simple types. These cannot be divided any further.
238 // They can be converted to and from wxStrings, that's all.
243 wxT_VOID
= 0, // unknown type
253 wxT_STRING
, // must be wxString
254 wxT_SET
, // must be wxSet<> template
256 wxT_CUSTOM
, // user defined type (e.g. wxPoint)
258 wxT_LAST_SIMPLE_TYPE_KIND
= wxT_CUSTOM
,
260 wxT_OBJECT_PTR
, // object reference
261 wxT_OBJECT
, // embedded object
262 wxT_COLLECTION
, // collection
264 wxT_DELEGATE
, // for connecting against an event source
266 wxT_LAST_TYPE_KIND
= wxT_DELEGATE
// sentinel for bad data, asserts, debugging
269 class WXDLLIMPEXP_BASE wxTypeInfo
272 wxTypeInfo() : m_kind( wxT_VOID
) {}
273 virtual ~wxTypeInfo() {}
274 wxTypeKind
GetKind() const { return m_kind
; }
275 bool IsDelegateType() const { return m_kind
== wxT_DELEGATE
; }
276 bool IsCustomType() const { return m_kind
== wxT_CUSTOM
; }
277 bool IsObjectType() const { return m_kind
== wxT_OBJECT
|| m_kind
== wxT_OBJECT_PTR
; }
282 class WXDLLIMPEXP_BASE wxBuiltInTypeInfo
: public wxTypeInfo
285 wxBuiltInTypeInfo( wxTypeKind kind
) { wxASSERT_MSG( kind
< wxT_SET
, wxT("Illegal Kind for Base Type") ) ; m_kind
= kind
;}
288 class WXDLLIMPEXP_BASE wxCustomTypeInfo
: public wxTypeInfo
291 wxCustomTypeInfo( const wxChar
*typeName
)
292 { m_kind
= wxT_CUSTOM
; m_typeName
= typeName
;}
293 const wxChar
*GetTypeName() const { return m_typeName
; }
295 const wxChar
*m_typeName
; // Kind == wxT_CUSTOM
298 class WXDLLIMPEXP_BASE wxEnumTypeInfo
: public wxTypeInfo
301 wxEnumTypeInfo( wxTypeKind kind
, wxEnumData
* enumInfo
)
302 { wxASSERT_MSG( kind
== wxT_ENUM
|| kind
== wxT_SET
, wxT("Illegal Kind for Enum Type")) ; m_kind
= kind
; m_enumInfo
= enumInfo
;}
303 const wxEnumData
* GetEnumData() const { return m_enumInfo
; }
305 wxEnumData
*m_enumInfo
; // Kind == wxT_ENUM or Kind == wxT_SET
308 class WXDLLIMPEXP_BASE wxClassTypeInfo
: public wxTypeInfo
311 wxClassTypeInfo( wxTypeKind kind
, wxClassInfo
* classInfo
)
312 { wxASSERT_MSG( kind
== wxT_OBJECT_PTR
|| kind
== wxT_OBJECT
, wxT("Illegal Kind for Enum Type")) ; m_kind
= kind
; m_classInfo
= classInfo
;}
313 const wxClassInfo
*GetClassInfo() const { return m_classInfo
; }
315 wxClassInfo
*m_classInfo
; // Kind == wxT_OBJECT - could be NULL
318 class WXDLLIMPEXP_BASE wxCollectionTypeInfo
: public wxTypeInfo
321 wxCollectionTypeInfo( wxTypeInfo
*elementType
)
322 { m_kind
= wxT_COLLECTION
, m_elementType
= elementType
; }
324 const wxTypeInfo
* GetElementType() const { return m_elementType
; }
326 wxTypeInfo
* m_elementType
;
329 // a delegate is an exposed event source
331 class WXDLLIMPEXP_BASE wxDelegateTypeInfo
: public wxTypeInfo
334 wxDelegateTypeInfo( int eventType
, wxClassInfo
* eventClass
)
335 { m_kind
= wxT_DELEGATE
; m_eventClass
= eventClass
; m_eventType
= eventType
;}
336 const wxClassInfo
*GetEventClass() const { assert( m_kind
== wxT_DELEGATE
) ; return m_eventClass
; }
337 int GetEventType() const { return m_eventType
; }
339 const wxClassInfo
*m_eventClass
; // (extended will merge into classinfo)
343 template<typename T
> const wxTypeInfo
* wxGetTypeInfo( T
* ) ;
345 template<typename T
> const wxTypeInfo
* wxGetTypeInfo( wxSet
<T
> * )
347 static wxEnumTypeInfo
s_typeInfo(wxT_SET
, wxGetEnumData((T
) 0) ) ; return &s_typeInfo
;
350 // this macro is for usage with custom, non-object derived classes and structs, wxPoint is such a custom type
352 #define WX_CUSTOM_TYPE_INFO( e ) \
353 template<> const wxTypeInfo* wxGetTypeInfo( e ** ){ static wxBuiltInTypeInfo s_typeInfo(wxT_VOID) ; assert(0) ; return &s_typeInfo ; } \
354 template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxCustomTypeInfo s_typeInfo(#e) ; return &s_typeInfo ; }
356 // templated streaming, every type must have their specialization for these methods
359 void wxStringReadValue( const wxString
&s
, T
&data
);
362 void wxStringWriteValue( wxString
&s
, const T
&data
);
364 // sometimes a compiler invents specializations that are nowhere called, use this macro to satisfy the refs
366 #define WX_ILLEGAL_TYPE_SPECIALIZATION( a ) \
367 template<> const wxTypeInfo* wxGetTypeInfo( a * ) { assert(0) ; \
368 static wxBuiltInTypeInfo s_typeInfo( wxT_VOID ) ; return &s_typeInfo ; } \
369 template<> void wxStringReadValue(const wxString & , a & ) { assert(0) ; }\
370 template<> void wxStringWriteValue(wxString & , a const & ) { assert(0) ; }
372 // ----------------------------------------------------------------------------
373 // wxxVariant as typesafe data holder
374 // ----------------------------------------------------------------------------
376 class WXDLLIMPEXP_BASE wxxVariantData
379 virtual ~wxxVariantData() {}
381 // return a heap allocated duplicate
382 virtual wxxVariantData
* Clone() const = 0 ;
384 // returns the type info of the contentc
385 virtual const wxTypeInfo
* GetTypeInfo() const = 0 ;
387 // write the value into a string
388 virtual void Write( wxString
&s
) const = 0 ;
390 // read the value from a string
391 virtual void Read( const wxString
&s
) = 0 ;
394 template<typename T
> class WXDLLIMPEXP_BASE wxxVariantDataT
: public wxxVariantData
397 wxxVariantDataT(const T
& d
) : m_data(d
) {}
398 virtual ~wxxVariantDataT() {}
400 // get a ref to the stored data
401 T
& Get() { return m_data
; }
403 // get a const ref to the stored data
404 const T
& Get() const { return m_data
; }
407 void Set(const T
& d
) { m_data
= d
; }
409 // return a heap allocated duplicate
410 virtual wxxVariantData
* Clone() const { return new wxxVariantDataT
<T
>( Get() ) ; }
412 // returns the type info of the contentc
413 virtual const wxTypeInfo
* GetTypeInfo() const { return wxGetTypeInfo( (T
*) NULL
) ; }
415 // write the value into a string
416 virtual void Write( wxString
&s
) const { wxStringWriteValue( s
, m_data
) ; }
418 // read the value from a string
419 virtual void Read( const wxString
&s
) { wxStringReadValue( s
, m_data
) ; }
425 class WXDLLIMPEXP_BASE wxxVariant
428 wxxVariant() { m_data
= NULL
; }
429 wxxVariant( wxxVariantData
* data
, const wxString
& name
= wxT("") ) : m_data(data
) , m_name(name
) {}
430 wxxVariant( const wxxVariant
&d
) { if ( d
.m_data
) m_data
= d
.m_data
->Clone() ; else m_data
= NULL
; m_name
= d
.m_name
; }
432 template<typename T
> wxxVariant( T data
, const wxString
& name
= wxT("") ) :
433 m_data(new wxxVariantDataT
<T
>(data
) ), m_name(name
) {}
434 ~wxxVariant() { delete m_data
; }
436 // get a ref to the stored data
437 template<typename T
> T
& Get()
439 wxxVariantDataT
<T
> *dataptr
= dynamic_cast<wxxVariantDataT
<T
>*> (m_data
) ;
440 wxASSERT_MSG( dataptr
, "Cast not possible" ) ;
441 return dataptr
->Get() ;
444 // get a ref to the stored data
445 template<typename T
> const T
& Get() const
447 const wxxVariantDataT
<T
> *dataptr
= dynamic_cast<const wxxVariantDataT
<T
>*> (m_data
) ;
448 wxASSERT_MSG( dataptr
, "Cast not possible" ) ;
449 return dataptr
->Get() ;
453 template<typename T
> void Set(const T
& data
) const
456 m_data
= new wxxVariantDataT
<T
>(data
) ;
459 wxxVariant
& operator=(const wxxVariant
&d
)
461 m_data
= d
.m_data
->Clone() ;
466 // gets the stored data casted to a wxObject* , returning NULL if cast is not possible
467 wxObject
* GetAsObject() ;
469 // get the typeinfo of the stored object
470 const wxTypeInfo
* GetTypeInfo() const { return m_data
->GetTypeInfo() ; }
472 // write the value into a string
473 void Write( wxString
&s
) const { m_data
->Write( s
) ; }
475 // read the value from a string
476 void Read( const wxString
&s
) { m_data
->Read( s
) ; }
478 // returns this value as string
479 wxString
GetAsString() const
486 void SetFromString( const wxString
&s
)
491 wxxVariantData
* m_data
;
495 #include <wx/dynarray.h>
497 WX_DECLARE_OBJARRAY_WITH_DECL(wxxVariant
, wxxVariantArray
, class WXDLLIMPEXP_BASE
);
499 // ----------------------------------------------------------------------------
502 // wxPropertyInfo is used to inquire of the property by name. It doesn't
503 // provide access to the property, only information about it. If you
504 // want access, look at wxPropertyAccessor.
505 // ----------------------------------------------------------------------------
507 class WXDLLIMPEXP_BASE wxPropertyAccessor
510 #if WX_XTI_TEMPLATE_FIX
512 class SetByRefRetBool
;
514 class SetAndGetByRef
;
515 class SetAndGetByRefRetBool
;
518 wxPropertyAccessor() { m_setterName
= NULL
; m_getterName
= NULL
; m_adderName
= NULL
;}
519 virtual ~wxPropertyAccessor() {}
521 // Setting a simple property (non-collection)
522 virtual void SetProperty(wxObject
*object
, const wxxVariant
&value
) const = 0 ;
524 // Getting a simple property (non-collection)
525 virtual wxxVariant
GetProperty(const wxObject
*object
) const = 0 ;
527 // Adding an element to a collection property
528 virtual void AddToPropertyCollection(wxObject
*object
, const wxxVariant
&value
) const
529 { wxASSERT_MSG(0,wxT("Collection Operation called on non Collection Property")) ; }
531 // Getting a collection property
532 virtual wxxVariantArray
GetPropertyCollection( const wxObject
*obj
) const
533 { wxASSERT_MSG(0,wxT("Collection Operation called on non Collection Property")) ; return wxxVariantArray() ; }
535 virtual bool HasSetter() const = 0 ;
536 virtual bool HasGetter() const = 0 ;
537 virtual bool HasAdder() const = 0 ;
539 const wxChar
* GetGetterName() const { return m_setterName
; }
540 const wxChar
* GetSetterName() const { return m_getterName
; }
541 const wxChar
* GetAdderName() const { return m_adderName
; }
543 virtual wxxVariant
ReadValue( const wxString
&value
) const = 0 ;
544 virtual void WriteValue( wxString
& value
, const wxObject
*o
) const = 0 ;
546 const wxChar
*m_setterName
;
547 const wxChar
*m_getterName
;
548 const wxChar
*m_adderName
;
551 class WXDLLIMPEXP_BASE wxGenericPropertyAccessor
: public wxPropertyAccessor
554 wxGenericPropertyAccessor( const wxChar
* propertyName
) ;
555 ~wxGenericPropertyAccessor() ;
556 virtual void SetProperty(wxObject
*object
, const wxxVariant
&value
) const ;
557 virtual wxxVariant
GetProperty(const wxObject
*object
) const ;
559 virtual bool HasSetter() const { return true ; }
560 virtual bool HasGetter() const { return true ; }
561 virtual bool HasAdder() const { return false ; }
563 virtual wxxVariant
ReadValue( const wxString
&value
) const ;
564 virtual void WriteValue( wxString
& value
, const wxObject
*o
) const ;
566 struct wxGenericPropertyAccessorInternal
;
567 wxGenericPropertyAccessorInternal
* m_data
;
570 template<class Klass
, typename T
>
571 class WXDLLIMPEXP_BASE wxPropertyAccessorT
: public wxPropertyAccessor
575 typedef void (Klass::*setter_t
)(T value
);
576 typedef bool (Klass::*setter_bool_t
)(T value
);
577 typedef void (Klass::*setter_ref_t
)(const T
& value
);
578 typedef bool (Klass::*setter_ref_bool_t
)(const T
& value
);
579 typedef T (Klass::*getter_t
)() const;
580 typedef const T
& (Klass::*getter_ref_t
)() const;
582 wxPropertyAccessorT(setter_t setter
, getter_t getter
, const wxChar
*s
, const wxChar
*g
)
583 : m_setter_bool( NULL
) , m_setter_ref_bool( NULL
) , m_setter(setter
), m_setter_ref(NULL
), m_getter(getter
) ,m_getter_ref(NULL
) {m_setterName
= s
;m_getterName
=g
;}
585 wxPropertyAccessorT( getter_t getter
, const wxChar
*g
)
586 : m_setter_bool( NULL
) , m_setter_ref_bool( NULL
) , m_setter(NULL
), m_setter_ref(NULL
), m_getter(getter
) ,m_getter_ref(NULL
) {m_setterName
= "";m_getterName
=g
;}
588 wxPropertyAccessorT(WX_XTI_PARAM_FIX(SetRetBool
*,) setter_bool_t setter
, getter_t getter
, const wxChar
*s
, const wxChar
*g
)
589 : m_setter_bool( setter
) , m_setter_ref_bool( NULL
) , m_setter(NULL
), m_setter_ref(NULL
), m_getter(getter
) , m_getter_ref(NULL
){m_setterName
= s
;m_getterName
=g
;}
591 wxPropertyAccessorT(WX_XTI_PARAM_FIX(SetByRef
*,) setter_ref_t setter
, getter_t getter
, const wxChar
*s
, const wxChar
*g
)
592 : m_setter_bool( NULL
) , m_setter_ref_bool( NULL
) , m_setter(NULL
), m_setter_ref(setter
), m_getter(getter
) , m_getter_ref(NULL
){m_setterName
= s
;m_getterName
=g
;}
594 wxPropertyAccessorT(WX_XTI_PARAM_FIX(SetByRefRetBool
*,) setter_ref_bool_t setter
, getter_t getter
, const wxChar
*s
, const wxChar
*g
)
595 : m_setter_bool( NULL
) , m_setter_ref_bool( setter
) , m_setter(NULL
), m_setter_ref(NULL
), m_getter(getter
) , m_getter_ref(NULL
){m_setterName
= s
;m_getterName
=g
;}
597 wxPropertyAccessorT(WX_XTI_PARAM_FIX(SetAndGetByRef
*,) setter_ref_t setter
, getter_ref_t getter
, const wxChar
*s
, const wxChar
*g
)
598 : m_setter_bool( NULL
) , m_setter_ref_bool( NULL
) , m_setter(NULL
), m_setter_ref(setter
), m_getter(NULL
) , m_getter_ref(getter
){m_setterName
= s
;m_getterName
=g
;}
600 wxPropertyAccessorT(WX_XTI_PARAM_FIX(SetAndGetByRefRetBool
*,) setter_ref_bool_t setter
, getter_ref_t getter
, const wxChar
*s
, const wxChar
*g
)
601 : m_setter_bool( NULL
) , m_setter_ref_bool( setter
) , m_setter(NULL
), m_setter_ref(NULL
), m_getter(NULL
) , m_getter_ref(getter
){m_setterName
= s
;m_getterName
=g
;}
603 wxPropertyAccessorT(WX_XTI_PARAM_FIX(GetByRef
*,) setter_t setter
, getter_ref_t getter
, const wxChar
*s
, const wxChar
*g
)
604 : m_setter_bool( NULL
) , m_setter_ref_bool( NULL
) , m_setter(NULL
), m_setter(setter
), m_getter(NULL
) , m_getter_ref(getter
){m_setterName
= s
;m_getterName
=g
;}
606 // returns true if this accessor has a setter
607 bool HasSetter() const { return m_setter
!= NULL
|| m_setter_ref
!= NULL
|| m_setter_ref_bool
!= NULL
|| m_setter_bool
; }
609 // return true if this accessor has a getter
610 bool HasGetter() const { return m_getter
!= NULL
|| m_getter_ref
!= NULL
; }
612 bool HasAdder() const { return true ; }
613 // set the property this accessor is responsible for in an object
614 void SetProperty(wxObject
*o
, const wxxVariant
&v
) const
616 Klass
*obj
= dynamic_cast<Klass
*>(o
);
619 if ( wxGetTypeInfo((T
*)NULL
)->GetKind() == wxT_OBJECT
&& v
.GetTypeInfo()->GetKind() == wxT_OBJECT_PTR
)
620 value
= *v
.Get
<T
*>();
624 (obj
->*(m_setter
))(value
);
625 else if ( m_setter_ref
)
626 (obj
->*(m_setter_ref
))(value
);
627 else if ( m_setter_ref_bool
)
628 (obj
->*(m_setter_ref_bool
))(value
);
629 else if ( m_setter_bool
)
630 (obj
->*(m_setter_bool
))(value
);
633 wxASSERT_MSG(0 , wxT("SetPropertyCalled without a valid Setter") ) ;
637 // gets the property this accessor is responsible for from an object
638 wxxVariant
GetProperty(const wxObject
*o
) const
640 return wxxVariant( (wxxVariantData
* ) DoGetProperty( o
) ) ;
643 // write the property this accessor is responsible for from an object into
645 void WriteValue( wxString
& s
, const wxObject
*o
) const
647 DoGetProperty( o
)->Write( s
) ;
650 // read a wxxVariant having the correct type for the property this accessor
651 // is responsible for from a string
652 wxxVariant
ReadValue( const wxString
&value
) const
655 wxStringReadValue( value
, data
) ;
656 return wxxVariant( data
) ;
660 wxxVariantDataT
<T
>* DoGetProperty(const wxObject
*o
) const
662 const Klass
*obj
= dynamic_cast<const Klass
*>(o
);
664 return new wxxVariantDataT
<T
>( (obj
->*(m_getter
))() ) ;
666 return new wxxVariantDataT
<T
>( (obj
->*(m_getter_ref
))() ) ;
670 setter_ref_t m_setter_ref
;
671 setter_ref_bool_t m_setter_ref_bool
;
672 setter_bool_t m_setter_bool
;
674 getter_ref_t m_getter_ref
;
677 template<class Klass
, typename CollectionType
, typename AddedElementType
>
678 class WXDLLIMPEXP_BASE wxPropertyCollectionAccessorT
: public wxPropertyAccessor
682 typedef void (Klass::*adder_t
)(AddedElementType value
);
683 typedef const CollectionType
& (Klass::*getter_t
)() const ;
685 wxPropertyCollectionAccessorT(adder_t adder
, getter_t getter
, const wxChar
*a
, const wxChar
*g
)
686 : m_getter(getter
), m_adder(adder
) { m_adderName
= a
;m_getterName
=g
;}
688 ~wxPropertyCollectionAccessorT() {}
690 // returns true if this accessor has a setter
691 bool HasSetter() const { return false ;}
693 // return true if this accessor has a getter
694 bool HasGetter() const { return m_getter
!= NULL
;}
696 // return true if this accessor has a getter
697 bool HasAdder() const { return m_adder
!= NULL
;}
699 // set the property this accessor is responsible for in an object
700 void AddToPropertyCollection(wxObject
*o
, const wxxVariant
&v
) const
702 Klass
*obj
= dynamic_cast<Klass
*>(o
);
703 AddedElementType value
;
705 if ( wxGetTypeInfo((AddedElementType
*)NULL
)->GetKind() == wxT_OBJECT
&& v
.GetTypeInfo()->GetKind() == wxT_OBJECT_PTR
)
706 value
= *v
.Get
<AddedElementType
*>();
708 value
= v
.Get
<AddedElementType
>();
711 (obj
->*(m_adder
))(value
);
714 wxASSERT_MSG(0 , wxT("SetPropertyCalled without a valid Setter") ) ;
718 // gets the property this accessor is responsible for from an object
719 wxxVariantArray
GetPropertyCollection(const wxObject
*o
) const
721 const Klass
*obj
= dynamic_cast<const Klass
*>(o
);
723 wxxVariantArray result
;
724 CollectionType::compatibility_iterator current
= (obj
->*(m_getter
))().GetFirst();
727 result
.Add( new wxxVariant(current
->GetData()) ) ;
728 current
= current
->GetNext();
734 // set the property this accessor is responsible for in an object
735 void SetProperty(wxObject
*WXUNUSED(o
), const wxxVariant
&WXUNUSED(v
)) const
737 wxASSERT_MSG(0,wxT("SetProperty called on Collection Property")) ;
740 // gets the property this accessor is responsible for from an object
741 wxxVariant
GetProperty(const wxObject
*WXUNUSED(o
)) const
743 wxASSERT_MSG(0,wxT("GetProperty called on Collection Property")) ;
744 return wxxVariant() ;
747 // write the property this accessor is responsible for from an object into
749 void WriteValue( wxString
& s
, const wxObject
*o
) const
751 wxASSERT_MSG(0,wxT("WriteValue called on Collection Property")) ;
754 // read a wxxVariant having the correct type for the property this accessor
755 // is responsible for from a string
756 wxxVariant
ReadValue( const wxString
&value
) const
758 wxASSERT_MSG(0,wxT("ReadValue called on Collection Property")) ;
759 return wxxVariant() ;
767 class WXDLLIMPEXP_BASE wxPropertyInfo
770 wxPropertyInfo( wxPropertyInfo
* &iter
, const wxChar
*name
, const wxTypeInfo
* typeInfo
, wxPropertyAccessor
*accessor
, wxxVariant dv
) :
771 m_name( name
) , m_typeInfo( typeInfo
) , m_accessor( accessor
) , m_defaultValue( dv
) , m_collectionElementTypeInfo(NULL
)
776 wxPropertyInfo( wxPropertyInfo
* &iter
, const wxChar
*name
, const wxTypeInfo
* collTypeInfo
, const wxTypeInfo
* elemTypeInfo
, wxPropertyAccessor
*accessor
) :
777 m_name( name
) , m_typeInfo( collTypeInfo
) , m_accessor( accessor
) , m_collectionElementTypeInfo(elemTypeInfo
)
782 // return the name of this property
783 const wxChar
* GetName() const { return m_name
; }
785 // return the element type info of this property (for collections, otherwise NULL)
786 const wxTypeInfo
* GetCollectionElementTypeInfo() const { return m_collectionElementTypeInfo
; }
788 // return the type info of this property
789 const wxTypeInfo
* GetTypeInfo() const { return m_typeInfo
; }
791 // return the accessor for this property
792 wxPropertyAccessor
* GetAccessor() const { return m_accessor
; }
794 // returns NULL if this is the last property of this class
795 wxPropertyInfo
* GetNext() const { return m_next
; }
797 // returns the default value of this property, its kind may be wxT_VOID if it is not valid
798 wxxVariant
GetDefaultValue() const { return m_defaultValue
; }
800 void Insert(wxPropertyInfo
* &iter
)
807 wxPropertyInfo
* i
= iter
;
815 const wxChar
* m_name
;
816 const wxChar
* m_typeName
;
817 const wxTypeInfo
* m_typeInfo
;
818 const wxTypeInfo
* m_collectionElementTypeInfo
;
819 wxPropertyAccessor
* m_accessor
;
820 wxxVariant m_defaultValue
;
821 // string representation of the default value
822 // to be assigned by the designer to the property
823 // when the component is dropped on the container.
824 wxPropertyInfo
* m_next
;
827 #define WX_BEGIN_PROPERTIES_TABLE(theClass) \
828 wxPropertyInfo *theClass::GetPropertiesStatic() \
830 typedef theClass class_t; \
831 static wxPropertyInfo* first = NULL ;
833 #define WX_END_PROPERTIES_TABLE() \
837 #if WX_XTI_TEMPLATE_FIX
839 #define WX_PROPERTY( name , type , setter , getter ,defaultValue ) \
840 static wxPropertyAccessorT<class_t , type> _accessor##name( &setter , &getter , #setter , #getter ) ; \
841 static wxPropertyInfo _propertyInfo##name( first , #name , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
843 #define WX_PROPERTY_COLLECTION( name , colltype , addelemtype , adder , getter ) \
844 static wxPropertyCollectionAccessorT<class_t , colltype , addelemtype > _accessor##name( &adder , &getter , #adder , #getter ) ; \
845 static wxPropertyInfo _propertyInfo##name( first , #name , wxGetTypeInfo( (colltype*) NULL ) ,wxGetTypeInfo( (addelemtype*) NULL ) ,&_accessor##name ) ;
847 #define WX_PROPERTY_SET_RET_BOOL( name , type , setter , getter ,defaultValue ) \
848 static wxPropertyAccessorT<class_t , type> _accessor##name( (wxPropertyAccessor::SetRetBool*)NULL , &setter , &getter , #setter , #getter ) ; \
849 static wxPropertyInfo _propertyInfo##name( first , #name , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
851 #define WX_PROPERTY_SET_BY_REF( name , type , setter , getter ,defaultValue ) \
852 static wxPropertyAccessorT<class_t , type> _accessor##name( (wxPropertyAccessor::SetByRef*)NULL, &setter , &getter , #setter , #getter ) ; \
853 static wxPropertyInfo _propertyInfo##name( first , #name , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
855 #define WX_PROPERTY_SET_BY_REF_RET_BOOL( name , type , setter , getter ,defaultValue ) \
856 static wxPropertyAccessorT<class_t , type> _accessor##name( (wxPropertyAccessor::SetByRefRetBool*)NULL, &setter , &getter , #setter , #getter ) ; \
857 static wxPropertyInfo _propertyInfo##name( first , #name , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
859 #define WX_PROPERTY_SET_AND_GET_BY_REF_RET_BOOL( name , type , setter , getter ,defaultValue ) \
860 static wxPropertyAccessorT<class_t , type> _accessor##name( (wxPropertyAccessor::SetAndGetByRefRetBool*)NULL, &setter , &getter , #setter , #getter ) ; \
861 static wxPropertyInfo _propertyInfo##name( first , #name , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
865 #define WX_PROPERTY( name , type , setter , getter ,defaultValue ) \
866 static wxPropertyAccessorT<class_t , type> _accessor##name( &setter , &getter , #setter , #getter ) ; \
867 static wxPropertyInfo _propertyInfo##name( first , #name , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
869 #define WX_PROPERTY_COLLECTION( name , colltype , addelemtype , adder , getter ) \
870 static wxPropertyCollectionAccessorT<class_t , colltype , addelemtype > _accessor##name( &adder , &getter , #adder , #getter ) ; \
871 static wxPropertyInfo _propertyInfo##name( first , #name , wxGetTypeInfo( (colltype*) NULL ) ,wxGetTypeInfo( (addelemtype*) NULL ) ,&_accessor##name ) ;
873 #define WX_PROPERTY_SET_RET_BOOL( name , type , setter , getter ,defaultValue ) \
874 WX_PROPERTY( name , type , setter , getter , defaultValue )
876 #define WX_PROPERTY_SET_BY_REF( name , type , setter , getter ,defaultValue ) \
877 WX_PROPERTY( name , type , setter , getter , defaultValue )
879 #define WX_PROPERTY_SET_BY_REF_RET_BOOL( name , type , setter , getter ,defaultValue ) \
880 WX_PROPERTY( name , type , setter , getter , defaultValue )
882 #define WX_PROPERTY_SET_AND_GET_BY_REF_RET_BOOL( name , type , setter , getter ,defaultValue ) \
883 WX_PROPERTY( name , type , setter , getter , defaultValue )
887 #define WX_READONLY_PROPERTY( name , type , getter ,defaultValue ) \
888 static wxPropertyAccessorT<class_t , type> _accessor##name( &getter , #getter ) ; \
889 static wxPropertyInfo _propertyInfo##name( first , #name , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
891 #define WX_DELEGATE( name , eventType , eventClass ) \
892 static wxDelegateTypeInfo _typeInfo##name( eventType , CLASSINFO( eventClass ) ) ; \
893 static wxPropertyInfo _propertyInfo##name( first , #name , &_typeInfo##name , NULL , wxxVariant() ) ; \
895 // ----------------------------------------------------------------------------
898 // this is describing an event sink
899 // ----------------------------------------------------------------------------
904 wxHandlerInfo( wxHandlerInfo
* &iter
, const wxChar
*name
, wxObjectEventFunction address
, const wxClassInfo
* eventClassInfo
) :
905 m_name( name
) , m_eventClassInfo( eventClassInfo
) , m_eventFunction( address
)
912 wxHandlerInfo
* i
= iter
;
920 // get the name of the handler method
921 const wxChar
* GetName() const { return m_name
; }
923 // return the class info of the event
924 const wxClassInfo
* GetEventClassInfo() const { return m_eventClassInfo
; }
926 // get the handler function pointer
927 wxObjectEventFunction
GetEventFunction() const { return m_eventFunction
; }
929 // returns NULL if this is the last handler of this class
930 wxHandlerInfo
* GetNext() const { return m_next
; }
932 wxObjectEventFunction m_eventFunction
;
933 const wxChar
* m_name
;
934 const wxClassInfo
* m_eventClassInfo
;
935 wxHandlerInfo
* m_next
;
938 #define WX_HANDLER(name,eventClassType) \
939 static wxHandlerInfo _handlerInfo##name( first , #name , (wxObjectEventFunction) (wxEventFunction) &name , CLASSINFO( eventClassType ) ) ;
941 #define WX_BEGIN_HANDLERS_TABLE(theClass) \
942 wxHandlerInfo *theClass::GetHandlersStatic() \
944 typedef theClass class_t; \
945 static wxHandlerInfo* first = NULL ;
947 #define WX_END_HANDLERS_TABLE() \
950 // ----------------------------------------------------------------------------
951 // Constructor Bridges
953 // allow to set up constructors with params during runtime
954 // ----------------------------------------------------------------------------
956 class WXDLLIMPEXP_BASE wxConstructorBridge
959 virtual void Create(wxObject
*o
, wxxVariant
*args
) = 0;
962 // Creator Bridges for all Numbers of Params
966 template<typename Class
>
967 struct wxConstructorBridge_0
: public wxConstructorBridge
969 void Create(wxObject
*o
, wxxVariant
*)
971 Class
*obj
= dynamic_cast<Class
*>(o
);
976 struct wxConstructorBridge_Dummy
: public wxConstructorBridge
978 void Create(wxObject
*, wxxVariant
*)
983 #define WX_CONSTRUCTOR_0(klass) \
984 wxConstructorBridge_0<klass> constructor##klass ; \
985 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
986 const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
987 const int klass::sm_constructorPropertiesCount##klass = 0 ;
989 #define WX_CONSTRUCTOR_DUMMY(klass) \
990 wxConstructorBridge_Dummy constructor##klass ; \
991 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
992 const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
993 const int klass::sm_constructorPropertiesCount##klass = 0 ;
997 template<typename Class
, typename T0
>
998 struct wxConstructorBridge_1
: public wxConstructorBridge
1000 void Create(wxObject
*o
, wxxVariant
*args
)
1002 Class
*obj
= dynamic_cast<Class
*>(o
);
1009 #define WX_CONSTRUCTOR_1(klass,t0,v0) \
1010 wxConstructorBridge_1<klass,t0> constructor##klass ; \
1011 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1012 const wxChar *klass::sm_constructorProperties##klass[] = { #v0 } ; \
1013 const int klass::sm_constructorPropertiesCount##klass = 1 ;
1017 template<typename Class
,
1018 typename T0
, typename T1
>
1019 struct wxConstructorBridge_2
: public wxConstructorBridge
1021 void Create(wxObject
*o
, wxxVariant
*args
)
1023 Class
*obj
= dynamic_cast<Class
*>(o
);
1031 #define WX_CONSTRUCTOR_2(klass,t0,v0,t1,v1) \
1032 wxConstructorBridge_2<klass,t0,t1> constructor##klass ; \
1033 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1034 const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 } ; \
1035 const int klass::sm_constructorPropertiesCount##klass = 2;
1039 template<typename Class
,
1040 typename T0
, typename T1
, typename T2
>
1041 struct wxConstructorBridge_3
: public wxConstructorBridge
1043 void Create(wxObject
*o
, wxxVariant
*args
)
1045 Class
*obj
= dynamic_cast<Class
*>(o
);
1054 #define WX_CONSTRUCTOR_3(klass,t0,v0,t1,v1,t2,v2) \
1055 wxConstructorBridge_3<klass,t0,t1,t2> constructor##klass ; \
1056 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1057 const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 } ; \
1058 const int klass::sm_constructorPropertiesCount##klass = 3 ;
1062 template<typename Class
,
1063 typename T0
, typename T1
, typename T2
, typename T3
>
1064 struct wxConstructorBridge_4
: public wxConstructorBridge
1066 void Create(wxObject
*o
, wxxVariant
*args
)
1068 Class
*obj
= dynamic_cast<Class
*>(o
);
1078 #define WX_CONSTRUCTOR_4(klass,t0,v0,t1,v1,t2,v2,t3,v3) \
1079 wxConstructorBridge_4<klass,t0,t1,t2,t3> constructor##klass ; \
1080 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1081 const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 } ; \
1082 const int klass::sm_constructorPropertiesCount##klass = 4 ;
1086 template<typename Class
,
1087 typename T0
, typename T1
, typename T2
, typename T3
, typename T4
>
1088 struct wxConstructorBridge_5
: public wxConstructorBridge
1090 void Create(wxObject
*o
, wxxVariant
*args
)
1092 Class
*obj
= dynamic_cast<Class
*>(o
);
1103 #define WX_CONSTRUCTOR_5(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4) \
1104 wxConstructorBridge_5<klass,t0,t1,t2,t3,t4> constructor##klass ; \
1105 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1106 const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 , #v4 } ; \
1107 const int klass::sm_constructorPropertiesCount##klass = 5;
1111 template<typename Class
,
1112 typename T0
, typename T1
, typename T2
, typename T3
, typename T4
, typename T5
>
1113 struct wxConstructorBridge_6
: public wxConstructorBridge
1115 void Create(wxObject
*o
, wxxVariant
*args
)
1117 Class
*obj
= dynamic_cast<Class
*>(o
);
1129 #define WX_CONSTRUCTOR_6(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \
1130 wxConstructorBridge_6<klass,t0,t1,t2,t3,t4,t5> constructor##klass ; \
1131 wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
1132 const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 , #v4 , #v5 } ; \
1133 const int klass::sm_constructorPropertiesCount##klass = 6;
1136 // ----------------------------------------------------------------------------
1138 // ----------------------------------------------------------------------------
1140 typedef wxObject
*(*wxObjectConstructorFn
)(void);
1141 typedef wxObject
* (*wxVariantToObjectConverter
)( wxxVariant
&data
) ;
1142 typedef wxxVariant (*wxObjectToVariantConverter
)( wxObject
* ) ;
1144 class WXDLLIMPEXP_BASE wxClassInfo
1147 wxClassInfo(const wxClassInfo
**_Parents
,
1148 const wxChar
*_UnitName
,
1149 const wxChar
*_ClassName
,
1151 wxObjectConstructorFn ctor
,
1152 wxPropertyInfo
*_Props
,
1153 wxHandlerInfo
*_Handlers
,
1154 wxConstructorBridge
* _Constructor
,
1155 const wxChar
** _ConstructorProperties
,
1156 const int _ConstructorPropertiesCount
,
1157 wxVariantToObjectConverter _PtrConverter1
,
1158 wxVariantToObjectConverter _Converter2
,
1159 wxObjectToVariantConverter _Converter3
1160 ) : m_parents(_Parents
) , m_unitName(_UnitName
) ,m_className(_ClassName
),
1161 m_objectSize(size
), m_objectConstructor(ctor
) , m_firstProperty(_Props
) , m_firstHandler(_Handlers
) , m_constructor( _Constructor
) ,
1162 m_constructorProperties(_ConstructorProperties
) , m_constructorPropertiesCount(_ConstructorPropertiesCount
),
1163 m_variantOfPtrToObjectConverter( _PtrConverter1
) , m_variantToObjectConverter( _Converter2
) , m_objectToVariantConverter( _Converter3
) , m_next(sm_first
)
1169 wxClassInfo(const wxChar
*_UnitName
, const wxChar
*_ClassName
, const wxClassInfo
**_Parents
) : m_parents(_Parents
) , m_unitName(_UnitName
) ,m_className(_ClassName
),
1170 m_objectSize(0), m_objectConstructor(NULL
) , m_firstProperty(NULL
) , m_firstHandler(NULL
) , m_constructor( NULL
) ,
1171 m_constructorProperties(NULL
) , m_constructorPropertiesCount(NULL
),
1172 m_variantOfPtrToObjectConverter( NULL
) , m_variantToObjectConverter( NULL
) , m_objectToVariantConverter( NULL
) , m_next(sm_first
)
1178 virtual ~wxClassInfo() ;
1180 // allocates an instance of this class, this object does not have to be initialized or fully constructed
1181 // as this call will be followed by a call to Create
1182 virtual wxObject
*AllocateObject() const { return m_objectConstructor
? (*m_objectConstructor
)() : 0; }
1184 // 'old naming' for AllocateObject staying here for backward compatibility
1185 wxObject
*CreateObject() const { return AllocateObject() ; }
1187 const wxChar
*GetClassName() const { return m_className
; }
1188 const wxClassInfo
**GetParents() const { return m_parents
; }
1189 int GetSize() const { return m_objectSize
; }
1191 wxObjectConstructorFn
GetConstructor() const { return m_objectConstructor
; }
1192 static const wxClassInfo
*GetFirst() { return sm_first
; }
1193 const wxClassInfo
*GetNext() const { return m_next
; }
1194 static wxClassInfo
*FindClass(const wxChar
*className
);
1196 // Climb upwards through inheritance hierarchy.
1197 // Dual inheritance is catered for.
1199 bool IsKindOf(const wxClassInfo
*info
) const
1206 for ( int i
= 0 ; m_parents
[i
] ; ++ i
)
1208 if ( m_parents
[i
]->IsKindOf( info
) )
1215 #ifdef WXWIN_COMPATIBILITY_2_4
1216 // Initializes parent pointers and hash table for fast searching.
1217 wxDEPRECATED( static void InitializeClasses() );
1218 // Cleans up hash table used for fast searching.
1219 wxDEPRECATED( static void CleanUpClasses() );
1221 static void CleanUp();
1223 // returns the first property
1224 const wxPropertyInfo
* GetFirstProperty() const { return m_firstProperty
; }
1226 // returns the first handler
1227 const wxHandlerInfo
* GetFirstHandler() const { return m_firstHandler
; }
1229 // Call the Create upon an instance of the class, in the end the object is fully
1231 virtual void Create (wxObject
*object
, int ParamCount
, wxxVariant
*Params
) const
1233 wxASSERT_MSG( ParamCount
== m_constructorPropertiesCount
, wxT("Illegal Parameter Count for Create Method")) ;
1234 m_constructor
->Create( object
, Params
) ;
1237 // get number of parameters for constructor
1238 virtual int GetCreateParamCount() const { return m_constructorPropertiesCount
; }
1240 // get n-th constructor parameter
1241 virtual const wxChar
* GetCreateParamName(int n
) const { return m_constructorProperties
[n
] ; }
1243 // Runtime access to objects for simple properties (get/set) by property name, and variant data
1244 virtual void SetProperty (wxObject
*object
, const wxChar
*propertyName
, const wxxVariant
&value
) const ;
1245 virtual wxxVariant
GetProperty (wxObject
*object
, const wxChar
*propertyName
) const;
1247 // Runtime access to objects for collection properties by property name
1248 virtual wxxVariantArray
GetPropertyCollection(wxObject
*object
, const wxChar
*propertyName
) const ;
1249 virtual void AddPropertyCollection(wxObject
*object
, const wxChar
*propertyName
, const wxxVariant
& value
) const ;
1251 // we must be able to cast variants to wxObject pointers, templates seem not to be suitable
1252 wxObject
* VariantToInstance( wxxVariant
&data
) const
1253 { if ( data
.GetTypeInfo()->GetKind() == wxT_OBJECT
)
1254 return m_variantToObjectConverter( data
) ;
1256 return m_variantOfPtrToObjectConverter( data
) ;
1259 wxxVariant
InstanceToVariant( wxObject
*object
) const { return m_objectToVariantConverter( object
) ; }
1261 // find property by name
1262 virtual const wxPropertyInfo
*FindPropertyInfo (const wxChar
*PropertyName
) const ;
1264 // find handler by name
1265 virtual const wxHandlerInfo
*FindHandlerInfo (const wxChar
*PropertyName
) const ;
1267 // find property by name
1268 virtual const wxPropertyInfo
*FindPropertyInfoInThisClass (const wxChar
*PropertyName
) const ;
1270 // find handler by name
1271 virtual const wxHandlerInfo
*FindHandlerInfoInThisClass (const wxChar
*PropertyName
) const ;
1273 const wxChar
*m_className
;
1275 wxObjectConstructorFn m_objectConstructor
;
1277 // class info object live in a linked list:
1278 // pointers to its head and the next element in it
1280 static wxClassInfo
*sm_first
;
1281 wxClassInfo
*m_next
;
1283 // FIXME: this should be private (currently used directly by way too
1285 static wxHashTable
*sm_classTable
;
1288 wxPropertyInfo
* m_firstProperty
;
1289 wxHandlerInfo
* m_firstHandler
;
1291 const wxClassInfo
** m_parents
;
1292 const wxChar
* m_unitName
;
1294 wxConstructorBridge
* m_constructor
;
1295 const wxChar
** m_constructorProperties
;
1296 const int m_constructorPropertiesCount
;
1297 wxVariantToObjectConverter m_variantOfPtrToObjectConverter
;
1298 wxVariantToObjectConverter m_variantToObjectConverter
;
1299 wxObjectToVariantConverter m_objectToVariantConverter
;
1301 const wxPropertyAccessor
*FindAccessor (const wxChar
*propertyName
) const ;
1304 // InitializeClasses() helper
1305 static wxClassInfo
*GetBaseByName(const wxChar
*name
) ;
1308 // registers the class
1312 DECLARE_NO_COPY_CLASS(wxClassInfo
)
1316 WXDLLIMPEXP_BASE wxObject
*wxCreateDynamicObject(const wxChar
*name
);
1318 // ----------------------------------------------------------------------------
1320 // ----------------------------------------------------------------------------
1322 // this object leads to having a pure runtime-instantiation
1324 class wxDynamicClassInfo
: public wxClassInfo
1327 wxDynamicClassInfo( const wxChar
*_UnitName
, const wxChar
*_ClassName
, const wxClassInfo
* superClass
) ;
1328 virtual ~wxDynamicClassInfo() ;
1330 // constructs a wxDynamicObject with an instance
1331 virtual wxObject
*AllocateObject() const ;
1333 // Call the Create method for a class
1334 virtual void Create (wxObject
*object
, int ParamCount
, wxxVariant
*Params
) const ;
1336 // get number of parameters for constructor
1337 virtual int GetCreateParamCount() const ;
1339 // get i-th constructor parameter
1340 virtual const wxChar
* GetCreateParamName(int i
) const ;
1342 // Runtime access to objects by property name, and variant data
1343 virtual void SetProperty (wxObject
*object
, const wxChar
*PropertyName
, const wxxVariant
&Value
) const ;
1344 virtual wxxVariant
GetProperty (wxObject
*object
, const wxChar
*PropertyName
) const ;
1346 void AddProperty( const wxChar
*propertyName
, const wxTypeInfo
* typeInfo
) ;
1347 void AddHandler( const wxChar
*handlerName
, wxObjectEventFunction address
, const wxClassInfo
* eventClassInfo
) ;
1350 // ----------------------------------------------------------------------------
1351 // Dynamic class macros
1352 // ----------------------------------------------------------------------------
1354 #define _DECLARE_DYNAMIC_CLASS(name) \
1356 static wxClassInfo sm_class##name; \
1357 static const wxClassInfo* sm_classParents##name[] ; \
1358 static wxPropertyInfo* GetPropertiesStatic() ; \
1359 static wxHandlerInfo* GetHandlersStatic() ; \
1360 virtual wxClassInfo *GetClassInfo() const \
1361 { return &name::sm_class##name; }
1363 #define DECLARE_DYNAMIC_CLASS(name) \
1364 static wxConstructorBridge* sm_constructor##name ; \
1365 static const wxChar * sm_constructorProperties##name[] ; \
1366 static const int sm_constructorPropertiesCount##name ; \
1367 _DECLARE_DYNAMIC_CLASS(name)
1369 #define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name) \
1370 DECLARE_NO_ASSIGN_CLASS(name) \
1371 DECLARE_DYNAMIC_CLASS(name)
1373 #define DECLARE_DYNAMIC_CLASS_NO_COPY(name) \
1374 DECLARE_NO_COPY_CLASS(name) \
1375 DECLARE_DYNAMIC_CLASS(name)
1377 #define DECLARE_ABSTRACT_CLASS(name) _DECLARE_DYNAMIC_CLASS(name)
1378 #define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
1380 // -----------------------------------
1381 // for concrete classes
1382 // -----------------------------------
1384 // Single inheritance with one base class
1386 #define _IMPLEMENT_DYNAMIC_CLASS(name, basename, unit) \
1387 wxObject* wxConstructorFor##name() \
1388 { return new name; } \
1389 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
1390 wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1391 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1392 wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name), \
1393 (int) sizeof(name), \
1394 (wxObjectConstructorFn) wxConstructorFor##name , \
1395 name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name , \
1396 name::sm_constructorPropertiesCount##name , wxVariantOfPtrToObjectConverter##name , NULL , wxObjectToVariantConverter##name); \
1397 template<> void wxStringReadValue(const wxString & , name & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") ) ;}\
1398 template<> void wxStringWriteValue(wxString & , name const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1399 template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") ) ;}\
1400 template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1401 template<> void wxStringReadValue(const wxString & , name ** & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1402 template<> void wxStringWriteValue(wxString & , name** const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1403 template<> const wxTypeInfo* wxGetTypeInfo( name *** ){ static wxBuiltInTypeInfo s_typeInfo(wxT_VOID ) ; wxASSERT_MSG(0 , wxT("illegal specialization called") ) ; return &s_typeInfo ; } \
1404 template<> const wxTypeInfo* wxGetTypeInfo( name * ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT , &name::sm_class##name) ; return &s_typeInfo ; } \
1405 template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT_PTR , &name::sm_class##name) ; return &s_typeInfo ; }
1407 #define _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY(name, basename, unit) \
1408 wxObject* wxConstructorFor##name() \
1409 { return new name; } \
1410 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
1411 wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return &data.Get<name>() ; } \
1412 wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1413 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1414 wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name), \
1415 (int) sizeof(name), \
1416 (wxObjectConstructorFn) wxConstructorFor##name , \
1417 name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name , \
1418 name::sm_constructorPropertiesCount##name , wxVariantOfPtrToObjectConverter##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
1419 template<> void wxStringReadValue(const wxString & , name & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") ) ;}\
1420 template<> void wxStringWriteValue(wxString & , name const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1421 template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") ) ;}\
1422 template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1423 template<> void wxStringReadValue(const wxString & , name ** & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1424 template<> void wxStringWriteValue(wxString & , name** const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1425 template<> const wxTypeInfo* wxGetTypeInfo( name *** ){ static wxBuiltInTypeInfo s_typeInfo(wxT_VOID ) ; wxASSERT_MSG(0 , wxT("illegal specialization called") ) ; return &s_typeInfo ; } \
1426 template<> const wxTypeInfo* wxGetTypeInfo( name * ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT , &name::sm_class##name) ; return &s_typeInfo ; } \
1427 template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT_PTR , &name::sm_class##name) ; return &s_typeInfo ; }
1429 #define IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename ) \
1430 _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , "" ) \
1431 const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
1432 const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1433 WX_CONSTRUCTOR_DUMMY( name )
1435 #define IMPLEMENT_DYNAMIC_CLASS( name , basename ) \
1436 _IMPLEMENT_DYNAMIC_CLASS( name , basename , "" ) \
1437 wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
1438 wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1439 WX_CONSTRUCTOR_DUMMY( name )
1441 #define IMPLEMENT_DYNAMIC_CLASS_XTI( name , basename , unit ) \
1442 _IMPLEMENT_DYNAMIC_CLASS( name , basename , unit )
1444 #define IMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI( name , basename , unit ) \
1445 _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , unit )
1447 // this is for classes that do not derive from wxobject, there are no creators for these
1449 #define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_NO_BASE_XTI( name , unit ) \
1450 const wxClassInfo* name::sm_classParents##name[] = { NULL } ; \
1451 wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name), \
1452 (int) sizeof(name), \
1453 (wxObjectConstructorFn) 0 , \
1454 name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
1456 template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1457 template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1458 template<> void wxStringReadValue(const wxString & , name ** & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1459 template<> void wxStringWriteValue(wxString & , name** const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1460 template<> const wxTypeInfo* wxGetTypeInfo( name *** ){ static wxBuiltInTypeInfo s_typeInfo(wxT_VOID ) ; wxASSERT_MSG(0 , wxT("illegal specialization called") ) ; return &s_typeInfo ; } \
1461 template<> const wxTypeInfo* wxGetTypeInfo( name * ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT , &name::sm_class##name) ; return &s_typeInfo ; } \
1462 template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT_PTR , &name::sm_class##name) ; return &s_typeInfo ; }
1464 // this is for subclasses that still do not derive from wxobject
1466 #define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_XTI( name , basename, unit ) \
1467 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
1468 wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name), \
1469 (int) sizeof(name), \
1470 (wxObjectConstructorFn) 0 , \
1471 name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
1473 template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1474 template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1475 template<> void wxStringReadValue(const wxString & , name ** & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1476 template<> void wxStringWriteValue(wxString & , name** const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1477 template<> const wxTypeInfo* wxGetTypeInfo( name *** ){ static wxBuiltInTypeInfo s_typeInfo(wxT_VOID ) ; wxASSERT_MSG(0 , wxT("illegal specialization called") ) ; return &s_typeInfo ; } \
1478 template<> const wxTypeInfo* wxGetTypeInfo( name * ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT , &name::sm_class##name) ; return &s_typeInfo ; } \
1479 template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT_PTR , &name::sm_class##name) ; return &s_typeInfo ; }
1482 // Multiple inheritance with two base classes
1484 #define _IMPLEMENT_DYNAMIC_CLASS2(name, basename, basename2, unit) \
1485 wxObject* wxConstructorFor##name() \
1486 { return new name; } \
1487 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,&basename2::sm_class##basename2 , NULL } ; \
1488 wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1489 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1490 wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name), \
1491 (int) sizeof(name), \
1492 (wxObjectConstructorFn) wxConstructorFor##name , \
1493 name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name , \
1494 name::sm_constructorPropertiesCount##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
1495 template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1496 template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1497 template<> void wxStringReadValue(const wxString & , name ** & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1498 template<> void wxStringWriteValue(wxString & , name** const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1499 template<> const wxTypeInfo* wxGetTypeInfo( name *** ){ static wxBuiltInTypeInfo s_typeInfo(wxT_VOID ) ; wxASSERT_MSG(0 , wxT("illegal specialization called") ) ; return &s_typeInfo ; } \
1500 template<> const wxTypeInfo* wxGetTypeInfo( name * ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT , &name::sm_class##name) ; return &s_typeInfo ; } \
1501 template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT_PTR , &name::sm_class##name) ; return &s_typeInfo ; }
1503 #define IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2) \
1504 _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , "") \
1505 wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
1506 wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1507 WX_CONSTRUCTOR_DUMMY( name )
1509 #define IMPLEMENT_DYNAMIC_CLASS2_XTI( name , basename , basename2, unit) \
1510 _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , unit)
1512 // -----------------------------------
1513 // for abstract classes
1514 // -----------------------------------
1516 // Single inheritance with one base class
1518 #define _IMPLEMENT_ABSTRACT_CLASS(name, basename) \
1519 const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
1520 wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1521 wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.Get<name*>() ; } \
1522 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1523 wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name), \
1524 (int) sizeof(name), \
1525 (wxObjectConstructorFn) 0 , \
1526 name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
1527 0 , wxVariantOfPtrToObjectConverter##name ,wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
1528 template<> void wxStringReadValue(const wxString & , name * & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1529 template<> void wxStringWriteValue(wxString & , name* const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1530 template<> void wxStringReadValue(const wxString & , name ** & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1531 template<> void wxStringWriteValue(wxString & , name** const & ){wxASSERT_MSG( 0 , wxT("Illegal Spezialication Called") );}\
1532 template<> const wxTypeInfo* wxGetTypeInfo( name * ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT , &name::sm_class##name) ; return &s_typeInfo ; } \
1533 template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(wxT_OBJECT_PTR , &name::sm_class##name) ; return &s_typeInfo ; } \
1534 template<> const wxTypeInfo* wxGetTypeInfo( name *** ){ static wxBuiltInTypeInfo s_typeInfo(wxT_VOID) ; assert(0) ; return &s_typeInfo ; }
1536 #define IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
1537 _IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
1538 wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1539 wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; }
1541 // Multiple inheritance with two base classes
1543 #define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
1544 wxClassInfo name::sm_class##name(wxT(#name), wxT(#basename1), \
1545 wxT(#basename2), (int) sizeof(name), \
1546 (wxObjectConstructorFn) 0);
1548 #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
1549 #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2