]> git.saurik.com Git - wxWidgets.git/blob - include/wx/xti.h
added accessor function to hide __VISAGECPP__ ugliness and avoid having #ifdef's...
[wxWidgets.git] / include / wx / xti.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/xti.h
3 // Purpose: runtime metadata information (extended class info)
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 27/07/03
7 // RCS-ID: $Id$
8 // Copyright: (c) 1997 Julian Smart
9 // (c) 2003 Stefan Csomor
10 // Licence: wxWindows licence
11 /////////////////////////////////////////////////////////////////////////////
12
13 #ifndef _WX_XTIH__
14 #define _WX_XTIH__
15
16 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
17 #pragma interface "xti.h"
18 #endif
19
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.
23 //
24 // This means we have the following domains :
25 //
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
34
35 // ----------------------------------------------------------------------------
36 // headers
37 // ----------------------------------------------------------------------------
38
39 #include "wx/defs.h"
40 #include "wx/memory.h"
41 #include "wx/flags.h"
42 #include "wx/string.h"
43 #include "wx/arrstr.h"
44 #include "wx/hashmap.h"
45 #include "wx/log.h"
46 #include "wx/intl.h"
47
48 #include <typeinfo>
49
50 // we will move this later to defs.h
51
52 #if defined(__GNUC__) && !wxCHECK_GCC_VERSION( 3 , 4 )
53 # define wxUSE_MEMBER_TEMPLATES 0
54 #endif
55
56 #if defined(_MSC_VER) && _MSC_VER <= 1200
57 # define wxUSE_MEMBER_TEMPLATES 0
58 # define wxUSE_FUNC_TEMPLATE_POINTER 0
59 #endif
60
61 #ifndef wxUSE_MEMBER_TEMPLATES
62 # define wxUSE_MEMBER_TEMPLATES 1
63 #endif
64
65 #ifndef wxUSE_FUNC_TEMPLATE_POINTER
66 # define wxUSE_FUNC_TEMPLATE_POINTER 1
67 #endif
68
69 #if wxUSE_MEMBER_TEMPLATES
70 # define wxTEMPLATED_MEMBER_CALL( method , type ) method<type>()
71 # define wxTEMPLATED_MEMBER_FIX( type )
72 #else
73 # define wxTEMPLATED_MEMBER_CALL( method , type ) method((type*)NULL)
74 # define wxTEMPLATED_MEMBER_FIX( type ) type* =NULL
75 #endif
76
77 #if defined(_MSC_VER) && _MSC_VER <= 1200
78 # define wxTEMPLATED_FUNCTION_FIX( type ) , wxTEMPLATED_MEMBER_FIX(type)
79 # define wxINFUNC_CLASS_TYPE_FIX( type ) typedef type type;
80 #else
81 # define wxTEMPLATED_FUNCTION_FIX( type )
82 # define wxINFUNC_CLASS_TYPE_FIX( type )
83 #endif
84
85 #define EMPTY_MACROVALUE /**/
86
87 class WXDLLIMPEXP_BASE wxObject;
88 class WXDLLIMPEXP_BASE wxClassInfo;
89 class WXDLLIMPEXP_BASE wxDynamicClassInfo;
90 class WXDLLIMPEXP_BASE wxHashTable;
91 class WXDLLIMPEXP_BASE wxObjectRefData;
92 class WXDLLIMPEXP_BASE wxEvent;
93 class WXDLLIMPEXP_BASE wxEvtHandler;
94
95 typedef void (wxEvtHandler::*wxObjectEventFunction)(wxEvent&);
96
97 #if wxUSE_FUNC_TEMPLATE_POINTER
98 # define wxTO_STRING(type) wxToStringConverter<type>
99 # define wxTO_STRING_IMP(type)
100 # define wxFROM_STRING(type) wxFromStringConverter<type>
101 # define wxFROM_STRING_IMP(type)
102 #else
103 # define wxTO_STRING(type) ToString##type
104 # define wxTO_STRING_IMP(type) inline void ToString##type( const wxxVariant& data , wxString &result ) { wxToStringConverter<type>(data, result); }
105 # define wxFROM_STRING(type) FromString##type
106 # define wxFROM_STRING_IMP(type) inline void FromString##type( const wxString& data , wxxVariant &result ) { wxFromStringConverter<type>(data, result); }
107 #endif
108
109 // ----------------------------------------------------------------------------
110 // Enum Support
111 //
112 // In the header files there would no change from pure c++ code, in the
113 // implementation, an enum would have
114 // to be enumerated eg :
115 //
116 // wxBEGIN_ENUM( wxFlavor )
117 // wxENUM_MEMBER( Vanilla )
118 // wxENUM_MEMBER( Chocolate )
119 // wxENUM_MEMBER( Strawberry )
120 // wxEND_ENUM( wxFlavor )
121 // ----------------------------------------------------------------------------
122
123 struct WXDLLIMPEXP_BASE wxEnumMemberData
124 {
125 const wxChar* m_name;
126 int m_value;
127 };
128
129 class WXDLLIMPEXP_BASE wxEnumData
130 {
131 public :
132 wxEnumData( wxEnumMemberData* data ) ;
133
134 // returns true if the member has been found and sets the int value
135 // pointed to accordingly (if ptr != null )
136 // if not found returns false, value left unchanged
137 bool HasEnumMemberValue( const wxChar *name , int *value = NULL ) const ;
138
139 // returns the value of the member, if not found in debug mode an
140 // assert is issued, in release 0 is returned
141 int GetEnumMemberValue(const wxChar *name ) const ;
142
143 // returns the name of the enum member having the passed in value
144 // returns an emtpy string if not found
145 const wxChar *GetEnumMemberName(int value) const ;
146
147 // returns the number of members in this enum
148 int GetEnumCount() const { return m_count ; }
149
150 // returns the value of the nth member
151 int GetEnumMemberValueByIndex( int n ) const ;
152
153 // returns the value of the nth member
154 const wxChar *GetEnumMemberNameByIndex( int n ) const ;
155 private :
156 wxEnumMemberData *m_members;
157 int m_count ;
158 };
159
160 #define wxBEGIN_ENUM( e ) \
161 wxEnumMemberData s_enumDataMembers##e[] = {
162
163 #define wxENUM_MEMBER( v ) { wxT(#v), v } ,
164
165 #define wxEND_ENUM( e ) { NULL , 0 } } ; \
166 wxEnumData s_enumData##e( s_enumDataMembers##e ) ; \
167 wxEnumData *wxGetEnumData(e) { return &s_enumData##e ; } \
168 template<> void wxStringReadValue(const wxString& s , e &data ) \
169 { \
170 data = (e) s_enumData##e.GetEnumMemberValue(s) ; \
171 } \
172 template<> void wxStringWriteValue(wxString &s , const e &data ) \
173 { \
174 s = s_enumData##e.GetEnumMemberName((int)data) ; \
175 } \
176 void FromLong##e( long data , wxxVariant& result ) { result = wxxVariant((e)data) ;} \
177 void ToLong##e( const wxxVariant& data , long &result ) { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get , e) ;} \
178 wxTO_STRING_IMP( e ) \
179 wxFROM_STRING_IMP( e ) \
180 wxEnumTypeInfo s_typeInfo##e(wxT_ENUM , &s_enumData##e , &wxTO_STRING( e ) , &wxFROM_STRING( e ) , &ToLong##e , &FromLong##e , typeid(e).name() ) ;
181
182 // ----------------------------------------------------------------------------
183 // Set Support
184 //
185 // in the header :
186 //
187 // enum wxFlavor
188 // {
189 // Vanilla,
190 // Chocolate,
191 // Strawberry,
192 // };
193 //
194 // typedef wxBitset<wxFlavor> wxCoupe ;
195 //
196 // in the implementation file :
197 //
198 // wxBEGIN_ENUM( wxFlavor )
199 // wxENUM_MEMBER( Vanilla )
200 // wxENUM_MEMBER( Chocolate )
201 // wxENUM_MEMBER( Strawberry )
202 // wxEND_ENUM( wxFlavor )
203 //
204 // wxIMPLEMENT_SET_STREAMING( wxCoupe , wxFlavor )
205 //
206 // implementation note : no partial specialization for streaming, but a delegation to a
207 // different class
208 //
209 // ----------------------------------------------------------------------------
210
211 // in order to remove dependancy on string tokenizer
212 void WXDLLIMPEXP_BASE wxSetStringToArray( const wxString &s , wxArrayString &array ) ;
213
214 template<typename e>
215 void wxSetFromString(const wxString &s , wxBitset<e> &data )
216 {
217 wxEnumData* edata = wxGetEnumData((e) 0) ;
218 data.reset() ;
219
220 wxArrayString array ;
221 wxSetStringToArray( s , array ) ;
222 wxString flag;
223 for ( int i = 0 ; i < array.Count() ; ++i )
224 {
225 flag = array[i] ;
226 int ivalue ;
227 if ( edata->HasEnumMemberValue( flag , &ivalue ) )
228 {
229 data.set( (e) ivalue ) ;
230 }
231 }
232 }
233
234 template<typename e>
235 void wxSetToString( wxString &s , const wxBitset<e> &data )
236 {
237 wxEnumData* edata = wxGetEnumData((e) 0) ;
238 int count = edata->GetEnumCount() ;
239 int i ;
240 s.Clear() ;
241 for ( i = 0 ; i < count ; i++ )
242 {
243 e value = (e) edata->GetEnumMemberValueByIndex(i) ;
244 if ( data.test( value ) )
245 {
246 // this could also be done by the templated calls
247 if ( !s.empty() )
248 s +=wxT("|") ;
249 s += edata->GetEnumMemberNameByIndex(i) ;
250 }
251 }
252 }
253
254 #define wxIMPLEMENT_SET_STREAMING(SetName,e) \
255 template<> void wxStringReadValue(const wxString &s , wxBitset<e> &data ) \
256 { \
257 wxSetFromString( s , data ) ; \
258 } \
259 template<> void wxStringWriteValue( wxString &s , const wxBitset<e> &data ) \
260 { \
261 wxSetToString( s , data ) ; \
262 } \
263 void FromLong##SetName( long data , wxxVariant& result ) { result = wxxVariant(SetName((unsigned long)data)) ;} \
264 void ToLong##SetName( const wxxVariant& data , long &result ) { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get , SetName).to_ulong() ;} \
265 wxTO_STRING_IMP( SetName ) \
266 wxFROM_STRING_IMP( SetName ) \
267 wxEnumTypeInfo s_typeInfo##SetName(wxT_SET , &s_enumData##e , &wxTO_STRING( SetName ) , &wxFROM_STRING( SetName ) , &ToLong##SetName , &FromLong##SetName, typeid(SetName).name() ) ; \
268 }
269
270 template<typename e>
271 void wxFlagsFromString(const wxString &s , e &data )
272 {
273 wxEnumData* edata = wxGetEnumData((e*) 0) ;
274 data.m_data = 0 ;
275
276 wxArrayString array ;
277 wxSetStringToArray( s , array ) ;
278 wxString flag;
279 for ( size_t i = 0 ; i < array.Count() ; ++i )
280 {
281 flag = array[i] ;
282 int ivalue ;
283 if ( edata->HasEnumMemberValue( flag , &ivalue ) )
284 {
285 data.m_data |= ivalue ;
286 }
287 }
288 }
289
290 template<typename e>
291 void wxFlagsToString( wxString &s , const e& data )
292 {
293 wxEnumData* edata = wxGetEnumData((e*) 0) ;
294 int count = edata->GetEnumCount() ;
295 int i ;
296 s.Clear() ;
297 long dataValue = data.m_data ;
298 for ( i = 0 ; i < count ; i++ )
299 {
300 int value = edata->GetEnumMemberValueByIndex(i) ;
301 // make this to allow for multi-bit constants to work
302 if ( value && ( dataValue & value ) == value )
303 {
304 // clear the flags we just set
305 dataValue &= ~value ;
306 // this could also be done by the templated calls
307 if ( !s.empty() )
308 s +=wxT("|") ;
309 s += edata->GetEnumMemberNameByIndex(i) ;
310 }
311 }
312 }
313
314 #define wxBEGIN_FLAGS( e ) \
315 wxEnumMemberData s_enumDataMembers##e[] = {
316
317 #define wxFLAGS_MEMBER( v ) { wxT(#v), v } ,
318
319 #define wxEND_FLAGS( e ) { NULL , 0 } } ; \
320 wxEnumData s_enumData##e( s_enumDataMembers##e ) ; \
321 wxEnumData *wxGetEnumData(e*) { return &s_enumData##e ; } \
322 template<> void wxStringReadValue(const wxString &s , e &data ) \
323 { \
324 wxFlagsFromString<e>( s , data ) ; \
325 } \
326 template<> void wxStringWriteValue( wxString &s , const e& data ) \
327 { \
328 wxFlagsToString<e>( s , data ) ; \
329 } \
330 void FromLong##e( long data , wxxVariant& result ) { result = wxxVariant(e(data)) ;} \
331 void ToLong##e( const wxxVariant& data , long &result ) { result = (long) data.wxTEMPLATED_MEMBER_CALL(Get , e).m_data ;} \
332 wxTO_STRING_IMP( e ) \
333 wxFROM_STRING_IMP( e ) \
334 wxEnumTypeInfo s_typeInfo##e(wxT_SET , &s_enumData##e , &wxTO_STRING( e ) , &wxFROM_STRING( e ) , &ToLong##e , &FromLong##e, typeid(e).name() ) ;
335 // ----------------------------------------------------------------------------
336 // Type Information
337 // ----------------------------------------------------------------------------
338 //
339 //
340 // All data exposed by the RTTI is characterized using the following classes.
341 // The first characterization is done by wxTypeKind. All enums up to and including
342 // wxT_CUSTOM represent so called simple types. These cannot be divided any further.
343 // They can be converted to and from wxStrings, that's all.
344
345
346 enum wxTypeKind
347 {
348 wxT_VOID = 0, // unknown type
349 wxT_BOOL,
350 wxT_CHAR,
351 wxT_UCHAR,
352 wxT_INT,
353 wxT_UINT,
354 wxT_LONG,
355 wxT_ULONG,
356 wxT_FLOAT,
357 wxT_DOUBLE,
358 wxT_STRING, // must be wxString
359 wxT_SET, // must be wxBitset<> template
360 wxT_ENUM,
361 wxT_CUSTOM, // user defined type (e.g. wxPoint)
362
363 wxT_LAST_SIMPLE_TYPE_KIND = wxT_CUSTOM ,
364
365 wxT_OBJECT_PTR, // object reference
366 wxT_OBJECT , // embedded object
367 wxT_COLLECTION , // collection
368
369 wxT_DELEGATE , // for connecting against an event source
370
371 wxT_LAST_TYPE_KIND = wxT_DELEGATE // sentinel for bad data, asserts, debugging
372 };
373
374 class WXDLLIMPEXP_BASE wxxVariant ;
375 class WXDLLIMPEXP_BASE wxTypeInfo ;
376
377 WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxTypeInfo* , wxTypeInfoMap , class WXDLLIMPEXP_BASE ) ;
378
379 class WXDLLIMPEXP_BASE wxTypeInfo
380 {
381 public :
382 typedef void (*converterToString_t)( const wxxVariant& data , wxString &result ) ;
383 typedef void (*converterFromString_t)( const wxString& data , wxxVariant &result ) ;
384
385 wxTypeInfo(wxTypeKind kind,
386 converterToString_t to = NULL, converterFromString_t from = NULL,
387 const wxString &name = wxEmptyString):
388 m_toString(to), m_fromString(from), m_kind(kind), m_name(name)
389 {
390 Register();
391 }
392 #if wxUSE_UNICODE
393 wxTypeInfo(wxTypeKind kind,
394 converterToString_t to, converterFromString_t from,
395 const char *name):
396 m_toString(to), m_fromString(from), m_kind(kind), m_name(wxString::FromAscii(name))
397 {
398 Register();
399 }
400 #endif
401
402 virtual ~wxTypeInfo()
403 {
404 Unregister() ;
405 }
406
407 // return the kind of this type (wxT_... constants)
408 wxTypeKind GetKind() const { return m_kind ; }
409
410 // returns the unique name of this type
411 const wxString& GetTypeName() const { return m_name ; }
412
413 // is this type a delegate type
414 bool IsDelegateType() const { return m_kind == wxT_DELEGATE ; }
415
416 // is this type a custom type
417 bool IsCustomType() const { return m_kind == wxT_CUSTOM ; }
418
419 // is this type an object type
420 bool IsObjectType() const { return m_kind == wxT_OBJECT || m_kind == wxT_OBJECT_PTR ; }
421
422 // can the content of this type be converted to and from strings ?
423 bool HasStringConverters() const { return m_toString != NULL && m_fromString != NULL ; }
424
425 // convert a wxxVariant holding data of this type into a string
426 void ConvertToString( const wxxVariant& data , wxString &result ) const
427
428 { if ( m_toString ) (*m_toString)( data , result ) ; else wxLogError( _("String conversions not supported") ) ; }
429
430 // convert a string into a wxxVariant holding the corresponding data in this type
431 void ConvertFromString( const wxString& data , wxxVariant &result ) const
432 { if( m_fromString ) (*m_fromString)( data , result ) ; else wxLogError( _("String conversions not supported") ) ; }
433
434 #if wxUSE_UNICODE
435 static wxTypeInfo *FindType(const char *typeName) { return FindType( wxString::FromAscii(typeName) ) ; }
436 #endif
437 static wxTypeInfo *FindType(const wxChar *typeName);
438
439 private :
440
441 void Register();
442 void Unregister();
443
444 converterToString_t m_toString ;
445 converterFromString_t m_fromString ;
446
447 static wxTypeInfoMap* ms_typeTable ;
448
449 wxTypeKind m_kind;
450 wxString m_name;
451 };
452
453 class WXDLLIMPEXP_BASE wxBuiltInTypeInfo : public wxTypeInfo
454 {
455 public :
456 wxBuiltInTypeInfo( wxTypeKind kind , converterToString_t to = NULL , converterFromString_t from = NULL , const wxString &name = wxEmptyString ) :
457 wxTypeInfo( kind , to , from , name )
458 { wxASSERT_MSG( GetKind() < wxT_SET , wxT("Illegal Kind for Base Type") ) ; }
459 #if wxUSE_UNICODE
460 wxBuiltInTypeInfo( wxTypeKind kind , converterToString_t to , converterFromString_t from , const char *name ) :
461 wxTypeInfo( kind , to , from , name )
462 { wxASSERT_MSG( GetKind() < wxT_SET , wxT("Illegal Kind for Base Type") ) ; }
463 #endif
464 } ;
465
466 class WXDLLIMPEXP_BASE wxCustomTypeInfo : public wxTypeInfo
467 {
468 public :
469 wxCustomTypeInfo( const wxString &name , converterToString_t to , converterFromString_t from ) :
470 wxTypeInfo( wxT_CUSTOM , to , from , name )
471 {}
472 #if wxUSE_UNICODE
473 wxCustomTypeInfo( const char *name , converterToString_t to , converterFromString_t from ) :
474 wxTypeInfo( wxT_CUSTOM , to , from , name )
475 {}
476 #endif
477 } ;
478
479 class WXDLLIMPEXP_BASE wxEnumTypeInfo : public wxTypeInfo
480 {
481 public :
482 typedef void (*converterToLong_t)( const wxxVariant& data , long &result ) ;
483 typedef void (*converterFromLong_t)( long data , wxxVariant &result ) ;
484
485 wxEnumTypeInfo( wxTypeKind kind , wxEnumData* enumInfo , converterToString_t to , converterFromString_t from ,
486 converterToLong_t toLong , converterFromLong_t fromLong , const wxString &name ) :
487 wxTypeInfo( kind , to , from , name ) , m_toLong( toLong ) , m_fromLong( fromLong )
488 { wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET , wxT("Illegal Kind for Enum Type")) ; m_enumInfo = enumInfo ;}
489
490 #if wxUSE_UNICODE
491 wxEnumTypeInfo( wxTypeKind kind , wxEnumData* enumInfo , converterToString_t to , converterFromString_t from ,
492 converterToLong_t toLong , converterFromLong_t fromLong , const char * name ) :
493 wxTypeInfo( kind , to , from , name ) , m_toLong( toLong ) , m_fromLong( fromLong )
494 { wxASSERT_MSG( kind == wxT_ENUM || kind == wxT_SET , wxT("Illegal Kind for Enum Type")) ; m_enumInfo = enumInfo ;}
495 #endif
496 const wxEnumData* GetEnumData() const { return m_enumInfo ; }
497
498 // convert a wxxVariant holding data of this type into a long
499 void ConvertToLong( const wxxVariant& data , long &result ) const
500
501 { if( m_toLong ) (*m_toLong)( data , result ) ; else wxLogError( _("Long Conversions not supported") ) ; }
502
503 // convert a long into a wxxVariant holding the corresponding data in this type
504 void ConvertFromLong( long data , wxxVariant &result ) const
505 { if( m_fromLong ) (*m_fromLong)( data , result ) ; else wxLogError( _("Long Conversions not supported") ) ;}
506
507 private :
508 converterToLong_t m_toLong ;
509 converterFromLong_t m_fromLong ;
510
511 wxEnumData *m_enumInfo; // Kind == wxT_ENUM or Kind == wxT_SET
512 } ;
513
514 class WXDLLIMPEXP_BASE wxClassTypeInfo : public wxTypeInfo
515 {
516 public :
517 wxClassTypeInfo( wxTypeKind kind , wxClassInfo* classInfo , converterToString_t to = NULL , converterFromString_t from = NULL , const wxString &name = wxEmptyString) ;
518 #if wxUSE_UNICODE
519 wxClassTypeInfo( wxTypeKind kind , wxClassInfo* classInfo , converterToString_t to , converterFromString_t from , const char *name ) ;
520 #endif
521 const wxClassInfo *GetClassInfo() const { return m_classInfo ; }
522 private :
523 wxClassInfo *m_classInfo; // Kind == wxT_OBJECT - could be NULL
524 } ;
525
526 class WXDLLIMPEXP_BASE wxCollectionTypeInfo : public wxTypeInfo
527 {
528 public :
529 wxCollectionTypeInfo( const wxString &elementName , converterToString_t to , converterFromString_t from , const wxString &name) :
530 wxTypeInfo( wxT_COLLECTION , to , from , name )
531 { m_elementTypeName = elementName ; m_elementType = NULL ;}
532 #if wxUSE_UNICODE
533 wxCollectionTypeInfo( const char *elementName , converterToString_t to , converterFromString_t from , const char *name ) :
534 wxTypeInfo( wxT_COLLECTION , to , from , name )
535 { m_elementTypeName = wxString::FromAscii( elementName ) ; m_elementType = NULL ;}
536 #endif
537 const wxTypeInfo* GetElementType() const
538 {
539 if ( m_elementType == NULL )
540 m_elementType = wxTypeInfo::FindType( m_elementTypeName ) ;
541 return m_elementType ; }
542 private :
543 mutable wxTypeInfo * m_elementType ;
544 wxString m_elementTypeName ;
545 } ;
546
547 // a delegate is an exposed event source
548
549 class WXDLLIMPEXP_BASE wxDelegateTypeInfo : public wxTypeInfo
550 {
551 public :
552 wxDelegateTypeInfo( int eventType , wxClassInfo* eventClass , converterToString_t to = NULL , converterFromString_t from = NULL ) ;
553 wxDelegateTypeInfo( int eventType , int lastEventType, wxClassInfo* eventClass , converterToString_t to = NULL , converterFromString_t from = NULL ) ;
554 int GetEventType() const { return m_eventType ; }
555 int GetLastEventType() const { return m_lastEventType ; }
556 const wxClassInfo* GetEventClass() const { return m_eventClass ; }
557 private :
558 const wxClassInfo *m_eventClass; // (extended will merge into classinfo)
559 int m_eventType ;
560 int m_lastEventType ;
561 } ;
562
563 template<typename T> const wxTypeInfo* wxGetTypeInfo( T * ) { return wxTypeInfo::FindType(typeid(T).name()) ; }
564
565 // this macro is for usage with custom, non-object derived classes and structs, wxPoint is such a custom type
566
567 #if wxUSE_FUNC_TEMPLATE_POINTER
568 #define wxCUSTOM_TYPE_INFO( e , toString , fromString ) \
569 wxCustomTypeInfo s_typeInfo##e(typeid(e).name() , &toString , &fromString) ;
570 #else
571 #define wxCUSTOM_TYPE_INFO( e , toString , fromString ) \
572 void ToString##e( const wxxVariant& data , wxString &result ) { toString(data, result); } \
573 void FromString##e( const wxString& data , wxxVariant &result ) { fromString(data, result); } \
574 wxCustomTypeInfo s_typeInfo##e(typeid(e).name() , &ToString##e , &FromString##e) ;
575 #endif
576
577 #define wxCOLLECTION_TYPE_INFO( element , collection ) \
578 wxCollectionTypeInfo s_typeInfo##collection( typeid(element).name() , NULL , NULL , typeid(collection).name() ) ;
579
580 // sometimes a compiler invents specializations that are nowhere called, use this macro to satisfy the refs, currently
581 // we don't have to play tricks, but if we will have to according to the compiler, we will use that macro for that
582
583 #define wxILLEGAL_TYPE_SPECIALIZATION( a )
584
585 // ----------------------------------------------------------------------------
586 // wxxVariant as typesafe data holder
587 // ----------------------------------------------------------------------------
588
589 class WXDLLIMPEXP_BASE wxxVariantData
590 {
591 public:
592 virtual ~wxxVariantData() {}
593
594 // return a heap allocated duplicate
595 virtual wxxVariantData* Clone() const = 0 ;
596
597 // returns the type info of the contentc
598 virtual const wxTypeInfo* GetTypeInfo() const = 0 ;
599 } ;
600
601 template<typename T> class wxxVariantDataT : public wxxVariantData
602 {
603 public:
604 wxxVariantDataT(const T& d) : m_data(d) {}
605 virtual ~wxxVariantDataT() {}
606
607 // get a ref to the stored data
608 T & Get() { return m_data; }
609
610 // get a const ref to the stored data
611 const T & Get() const { return m_data; }
612
613 // set the data
614 void Set(const T& d) { m_data = d; }
615
616 // return a heap allocated duplicate
617 virtual wxxVariantData* Clone() const { return new wxxVariantDataT<T>( Get() ) ; }
618
619 // returns the type info of the contentc
620 virtual const wxTypeInfo* GetTypeInfo() const { return wxGetTypeInfo( (T*) NULL ) ; }
621
622 private:
623 T m_data;
624 };
625
626 class WXDLLIMPEXP_BASE wxxVariant
627 {
628 public :
629 wxxVariant() { m_data = NULL ; }
630 wxxVariant( wxxVariantData* data , const wxString& name = wxEmptyString ) : m_data(data) , m_name(name) {}
631 wxxVariant( const wxxVariant &d ) { if ( d.m_data ) m_data = d.m_data->Clone() ; else m_data = NULL ; m_name = d.m_name ; }
632
633 template<typename T> wxxVariant( const T& data , const wxString& name = wxEmptyString ) :
634 m_data(new wxxVariantDataT<T>(data) ), m_name(name) {}
635
636 ~wxxVariant() { delete m_data ; }
637
638 // get a ref to the stored data
639 template<typename T> T& Get(wxTEMPLATED_MEMBER_FIX(T))
640 {
641 wxxVariantDataT<T> *dataptr = dynamic_cast<wxxVariantDataT<T>*> (m_data) ;
642 wxASSERT_MSG( dataptr , wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) ) ;
643 return dataptr->Get() ;
644 }
645
646 // get a ref to the stored data
647 template<typename T> const T& Get(wxTEMPLATED_MEMBER_FIX(T)) const
648 {
649 const wxxVariantDataT<T> *dataptr = dynamic_cast<const wxxVariantDataT<T>*> (m_data) ;
650 wxASSERT_MSG( dataptr , wxString::Format(wxT("Cast to %s not possible"), typeid(T).name()) ) ;
651 return dataptr->Get() ;
652 }
653
654 bool IsEmpty() const { return m_data == NULL ; }
655
656 template<typename T> bool HasData(wxTEMPLATED_MEMBER_FIX(T)) const
657 {
658 const wxxVariantDataT<T> *dataptr = dynamic_cast<const wxxVariantDataT<T>*> (m_data) ;
659 return dataptr != NULL ;
660 }
661
662 // stores the data
663 template<typename T> void Set(const T& data) const
664 {
665 delete m_data ;
666 m_data = new wxxVariantDataT<T>(data) ;
667 }
668
669 wxxVariant& operator=(const wxxVariant &d)
670 {
671 delete m_data;
672 m_data = d.m_data ? d.m_data->Clone() : NULL ;
673 m_name = d.m_name ;
674 return *this ;
675 }
676
677 // gets the stored data casted to a wxObject* , returning NULL if cast is not possible
678 wxObject* GetAsObject() ;
679
680 // get the typeinfo of the stored object
681 const wxTypeInfo* GetTypeInfo() const { return m_data->GetTypeInfo() ; }
682
683 // returns this value as string
684 wxString GetAsString() const
685 {
686 wxString s ;
687 GetTypeInfo()->ConvertToString( *this , s ) ;
688 return s ;
689 }
690 const wxString& GetName() const { return m_name ; }
691 private :
692 wxxVariantData* m_data ;
693 wxString m_name ;
694 } ;
695
696 #include <wx/dynarray.h>
697
698 WX_DECLARE_OBJARRAY_WITH_DECL(wxxVariant, wxxVariantArray, class WXDLLIMPEXP_BASE);
699
700 // templated streaming, every type must have their specialization for these methods
701
702 template<typename T>
703 void wxStringReadValue( const wxString &s , T &data );
704
705 template<typename T>
706 void wxStringWriteValue( wxString &s , const T &data);
707
708 template<typename T>
709 void wxToStringConverter( const wxxVariant &v, wxString &s wxTEMPLATED_FUNCTION_FIX(T)) { wxStringWriteValue( s , v.wxTEMPLATED_MEMBER_CALL(Get , T) ) ; }
710
711 template<typename T>
712 void wxFromStringConverter( const wxString &s, wxxVariant &v wxTEMPLATED_FUNCTION_FIX(T)) { T d ; wxStringReadValue( s , d ) ; v = wxxVariant(d) ; }
713
714 // ----------------------------------------------------------------------------
715 // Property Support
716 //
717 // wxPropertyInfo is used to inquire of the property by name. It doesn't
718 // provide access to the property, only information about it. If you
719 // want access, look at wxPropertyAccessor.
720 // ----------------------------------------------------------------------------
721
722 class WXDLLIMPEXP_BASE wxSetter
723 {
724 public:
725 wxSetter( const wxString name ) { m_name = name ; }
726 virtual ~wxSetter() {}
727 virtual void Set( wxObject *object, const wxxVariant &variantValue ) const = 0;
728 const wxString& GetName() const { return m_name ; }
729 private:
730 wxString m_name;
731 };
732
733 class WXDLLIMPEXP_BASE wxGetter
734 {
735 public:
736 wxGetter( const wxString name ) { m_name = name ; }
737 virtual ~wxGetter() {}
738 virtual void Get( const wxObject *object , wxxVariant& result) const = 0;
739 const wxString& GetName() const { return m_name ; }
740 private:
741 wxString m_name;
742 };
743
744 class WXDLLIMPEXP_BASE wxCollectionGetter
745 {
746 public :
747 wxCollectionGetter( const wxString name ) { m_name = name ; }
748 virtual ~wxCollectionGetter() {}
749 virtual void Get( const wxObject *object , wxxVariantArray& result) const = 0;
750 const wxString& GetName() const { return m_name ; }
751 private :
752 wxString m_name ;
753 } ;
754
755 template<typename coll_t> void WXDLLIMPEXP_BASE wxCollectionToVariantArray( const coll_t& coll , wxxVariantArray& result ) ;
756
757 class WXDLLIMPEXP_BASE wxAdder
758 {
759 public :
760 wxAdder( const wxString name ) { m_name = name ; }
761 virtual ~wxAdder() {}
762 virtual void Add( wxObject *object, const wxxVariant &variantValue ) const= 0;
763 const wxString& GetName() const { return m_name ; }
764 private :
765 wxString m_name ;
766 } ;
767
768
769 #define wxSETTER( property, Klass, valueType, setterMethod ) \
770 class wxSetter##property : public wxSetter \
771 { \
772 public: \
773 wxINFUNC_CLASS_TYPE_FIX(Klass) \
774 wxSetter##property() : wxSetter( wxT(#setterMethod) ) {} \
775 ~wxSetter##property() {} \
776 void Set( wxObject *object, const wxxVariant &variantValue ) const \
777 { \
778 Klass *obj = dynamic_cast<Klass*>(object) ; \
779 if ( variantValue.wxTEMPLATED_MEMBER_CALL(HasData, valueType) ) \
780 obj->setterMethod(variantValue.wxTEMPLATED_MEMBER_CALL(Get , valueType)) ; \
781 else \
782 obj->setterMethod(*variantValue.wxTEMPLATED_MEMBER_CALL(Get , valueType*)) ; \
783 } \
784 } ;
785
786 #define wxGETTER( property, Klass, valueType , gettermethod ) \
787 class wxGetter##property : public wxGetter \
788 { \
789 public : \
790 wxINFUNC_CLASS_TYPE_FIX(Klass) \
791 wxGetter##property() : wxGetter( wxT(#gettermethod) ) {} \
792 ~wxGetter##property() {} \
793 void Get( const wxObject *object , wxxVariant &result) const \
794 { \
795 const Klass *obj = dynamic_cast<const Klass*>(object) ; \
796 result = wxxVariant( obj->gettermethod() ) ; \
797 } \
798 } ;
799
800 #define wxADDER( property, Klass, valueType , addermethod ) \
801 class wxAdder##property : public wxAdder \
802 { \
803 public: \
804 wxINFUNC_CLASS_TYPE_FIX(Klass) \
805 wxAdder##property() : wxAdder( wxT(#addermethod) ) {} \
806 ~wxAdder##property() {} \
807 void Add( wxObject *object, const wxxVariant &variantValue ) const \
808 { \
809 Klass *obj = dynamic_cast<Klass*>(object) ; \
810 if ( variantValue.wxTEMPLATED_MEMBER_CALL(HasData, valueType) ) \
811 obj->addermethod(variantValue.wxTEMPLATED_MEMBER_CALL(Get , valueType)) ; \
812 else \
813 obj->addermethod(*variantValue.wxTEMPLATED_MEMBER_CALL(Get , valueType*)) ; \
814 } \
815 } ;
816
817 #define wxCOLLECTION_GETTER( property, Klass, valueType , gettermethod ) \
818 class wxCollectionGetter##property : public wxCollectionGetter \
819 { \
820 public : \
821 wxINFUNC_CLASS_TYPE_FIX(Klass) \
822 wxCollectionGetter##property() : wxCollectionGetter( wxT(#gettermethod) ) {} \
823 ~wxCollectionGetter##property() {} \
824 void Get( const wxObject *object , wxxVariantArray &result) const \
825 { \
826 const Klass *obj = dynamic_cast<const Klass*>(object) ; \
827 wxCollectionToVariantArray( obj->gettermethod() , result ) ; \
828 } \
829 } ;
830
831 class WXDLLIMPEXP_BASE wxPropertyAccessor
832 {
833 public :
834 wxPropertyAccessor( wxSetter *setter , wxGetter *getter , wxAdder *adder , wxCollectionGetter *collectionGetter )
835 { m_setter = setter ; m_getter = getter ; m_adder = adder ; m_collectionGetter = collectionGetter ;}
836
837 virtual ~wxPropertyAccessor() {}
838
839 // Setting a simple property (non-collection)
840 virtual void SetProperty(wxObject *object, const wxxVariant &value) const
841 { if ( m_setter ) m_setter->Set( object , value ) ; else wxLogError( _("SetProperty called w/o valid setter") ) ;}
842
843 // Getting a simple property (non-collection)
844 virtual void GetProperty(const wxObject *object, wxxVariant &result) const
845 { if ( m_getter ) m_getter->Get( object , result ) ; else wxLogError( _("GetProperty called w/o valid getter") ) ;}
846
847 // Adding an element to a collection property
848 virtual void AddToPropertyCollection(wxObject *object, const wxxVariant &value) const
849 { if ( m_adder ) m_adder->Add( object , value ) ; else wxLogError( _("AddToPropertyCollection called w/o valid adder") ) ;}
850
851 // Getting a collection property
852 virtual void GetPropertyCollection( const wxObject *obj, wxxVariantArray &result) const
853 { if ( m_collectionGetter ) m_collectionGetter->Get( obj , result) ; else wxLogError( _("GetPropertyCollection called w/o valid collection getter") ) ;}
854
855 virtual bool HasSetter() const { return m_setter != NULL ; }
856 virtual bool HasCollectionGetter() const { return m_collectionGetter != NULL ; }
857 virtual bool HasGetter() const { return m_getter != NULL ; }
858 virtual bool HasAdder() const { return m_adder != NULL ; }
859
860 virtual const wxString& GetCollectionGetterName() const
861 { return m_collectionGetter->GetName() ; }
862 virtual const wxString& GetGetterName() const
863 { return m_getter->GetName() ; }
864 virtual const wxString& GetSetterName() const
865 { return m_setter->GetName() ; }
866 virtual const wxString& GetAdderName() const
867 { return m_adder->GetName() ; }
868
869 protected :
870 wxSetter *m_setter ;
871 wxAdder *m_adder ;
872 wxGetter *m_getter ;
873 wxCollectionGetter* m_collectionGetter ;
874 };
875
876 class WXDLLIMPEXP_BASE wxGenericPropertyAccessor : public wxPropertyAccessor
877 {
878 public :
879 wxGenericPropertyAccessor( const wxString &propName ) ;
880 ~wxGenericPropertyAccessor() ;
881
882 void RenameProperty( const wxString& WXUNUSED_UNLESS_DEBUG(oldName),
883 const wxString& newName )
884 {
885 wxASSERT( oldName == m_propertyName ) ; m_propertyName = newName ;
886 }
887 virtual bool HasSetter() const { return true ; }
888 virtual bool HasGetter() const { return true ; }
889 virtual bool HasAdder() const { return false ; }
890 virtual bool HasCollectionGetter() const { return false ; }
891
892 virtual const wxString& GetGetterName() const
893 { return m_getterName ; }
894 virtual const wxString& GetSetterName() const
895 { return m_setterName ; }
896
897 virtual void SetProperty(wxObject *object, const wxxVariant &value) const ;
898 virtual void GetProperty(const wxObject *object, wxxVariant &value) const ;
899
900 // Adding an element to a collection property
901 virtual void AddToPropertyCollection(wxObject *WXUNUSED(object), const wxxVariant &WXUNUSED(value)) const
902 { wxLogError( _("AddToPropertyCollection called on a generic accessor") ) ;}
903
904 // Getting a collection property
905 virtual void GetPropertyCollection( const wxObject *WXUNUSED(obj), wxxVariantArray &WXUNUSED(result)) const
906 { wxLogError ( _("GetPropertyCollection called on a generic accessor") ) ;}
907 private :
908 struct wxGenericPropertyAccessorInternal ;
909 wxGenericPropertyAccessorInternal* m_data ;
910 wxString m_propertyName ;
911 wxString m_setterName ;
912 wxString m_getterName ;
913 } ;
914
915 typedef long wxPropertyInfoFlags ;
916 enum {
917 // will be removed in future releases
918 wxPROP_DEPRECATED = 0x00000001 ,
919 // object graph property, will be streamed with priority (after constructor properties)
920 wxPROP_OBJECT_GRAPH = 0x00000002 ,
921 // this will only be streamed out and in as enum/set, the internal representation is still a long
922 wxPROP_ENUM_STORE_LONG = 0x00000004 ,
923 // don't stream out this property, needed eg to avoid streaming out children that are always created by their parents
924 wxPROP_DONT_STREAM = 0x00000008 ,
925 } ;
926
927 class WXDLLIMPEXP_BASE wxPropertyInfo
928 {
929 friend class WXDLLIMPEXP_BASE wxDynamicClassInfo ;
930 public :
931 wxPropertyInfo(wxPropertyInfo* &iter,
932 wxClassInfo* itsClass,
933 const wxString& name,
934 const wxString& typeName,
935 wxPropertyAccessor *accessor,
936 wxxVariant dv,
937 wxPropertyInfoFlags flags = 0,
938 const wxString& helpString = wxEmptyString,
939 const wxString& groupString = wxEmptyString) :
940 m_itsClass(itsClass),
941 m_name(name),
942 m_typeInfo(NULL),
943 m_typeName(typeName) ,
944 m_collectionElementTypeInfo(NULL),
945 m_accessor(accessor),
946 m_defaultValue(dv),
947 m_flags(flags),
948 m_helpString(helpString),
949 m_groupString(groupString)
950 {
951 Insert(iter);
952 }
953
954 #if wxUSE_UNICODE
955 wxPropertyInfo(wxPropertyInfo* &iter,
956 wxClassInfo* itsClass,
957 const wxString& name,
958 const char* typeName,
959 wxPropertyAccessor *accessor,
960 wxxVariant dv,
961 wxPropertyInfoFlags flags = 0,
962 const wxString& helpString = wxEmptyString,
963 const wxString& groupString = wxEmptyString) :
964 m_itsClass(itsClass),
965 m_name(name),
966 m_typeInfo(NULL),
967 m_typeName(wxString::FromAscii(typeName)) ,
968 m_collectionElementTypeInfo(NULL),
969 m_accessor(accessor),
970 m_defaultValue(dv),
971 m_flags(flags),
972 m_helpString(helpString),
973 m_groupString(groupString)
974 {
975 Insert(iter);
976 }
977 #endif
978 wxPropertyInfo(wxPropertyInfo* &iter,
979 wxClassInfo* itsClass,
980 const wxString& name,
981 wxDelegateTypeInfo* type,
982 wxPropertyAccessor *accessor,
983 wxxVariant dv,
984 wxPropertyInfoFlags flags = 0,
985 const wxString& helpString = wxEmptyString,
986 const wxString& groupString = wxEmptyString) :
987 m_itsClass(itsClass),
988 m_name(name),
989 m_typeInfo(type),
990 m_collectionElementTypeInfo(NULL),
991 m_accessor(accessor),
992 m_defaultValue(dv),
993 m_flags(flags),
994 m_helpString(helpString),
995 m_groupString(groupString)
996 {
997 Insert(iter);
998 }
999
1000 wxPropertyInfo(wxPropertyInfo* &iter,
1001 wxClassInfo* itsClass, const wxString& name,
1002 const wxString& collectionTypeName,
1003 const wxString& elementTypeName,
1004 wxPropertyAccessor *accessor,
1005 wxPropertyInfoFlags flags = 0,
1006 const wxString& helpString = wxEmptyString,
1007 const wxString& groupString = wxEmptyString) :
1008 m_itsClass(itsClass),
1009 m_name(name),
1010 m_typeInfo(NULL),
1011 m_typeName(collectionTypeName) ,
1012 m_collectionElementTypeInfo(NULL),
1013 m_collectionElementTypeName(elementTypeName),
1014 m_accessor(accessor) ,
1015 m_flags(flags),
1016 m_helpString(helpString),
1017 m_groupString(groupString)
1018 {
1019 Insert(iter);
1020 }
1021
1022 #if wxUSE_UNICODE
1023 wxPropertyInfo(wxPropertyInfo* &iter,
1024 wxClassInfo* itsClass, const wxString& name,
1025 const char* collectionTypeName,
1026 const char* elementTypeName,
1027 wxPropertyAccessor *accessor,
1028 wxPropertyInfoFlags flags = 0,
1029 const wxString& helpString = wxEmptyString,
1030 const wxString& groupString = wxEmptyString) :
1031 m_itsClass(itsClass),
1032 m_name(name),
1033 m_typeInfo(NULL),
1034 m_typeName(wxString::FromAscii(collectionTypeName)) ,
1035 m_collectionElementTypeInfo(NULL),
1036 m_collectionElementTypeName(wxString::FromAscii(elementTypeName)),
1037 m_accessor(accessor) ,
1038 m_flags(flags),
1039 m_helpString(helpString),
1040 m_groupString(groupString)
1041 {
1042 Insert(iter);
1043 }
1044 #endif
1045 ~wxPropertyInfo() ;
1046
1047 // return the class this property is declared in
1048 const wxClassInfo* GetDeclaringClass() const { return m_itsClass ; }
1049
1050 // return the name of this property
1051 const wxString& GetName() const { return m_name ; }
1052
1053 // returns the flags of this property
1054 wxPropertyInfoFlags GetFlags() const { return m_flags ;}
1055
1056 // returns the short help string of this property
1057 const wxString& GetHelpString() const { return m_helpString ; }
1058
1059 // returns the group string of this property
1060 const wxString& GetGroupString() const { return m_groupString ; }
1061
1062 // return the element type info of this property (for collections, otherwise NULL)
1063 const wxTypeInfo * GetCollectionElementTypeInfo() const
1064 {
1065 if ( m_collectionElementTypeInfo == NULL )
1066 m_collectionElementTypeInfo = wxTypeInfo::FindType(m_collectionElementTypeName) ;
1067 return m_collectionElementTypeInfo ;
1068 }
1069
1070 // return the type info of this property
1071 const wxTypeInfo * GetTypeInfo() const
1072 {
1073 if ( m_typeInfo == NULL )
1074 m_typeInfo = wxTypeInfo::FindType(m_typeName) ;
1075 return m_typeInfo ;
1076 }
1077
1078 // return the accessor for this property
1079 wxPropertyAccessor* GetAccessor() const { return m_accessor ; }
1080
1081 // returns NULL if this is the last property of this class
1082 wxPropertyInfo* GetNext() const { return m_next ; }
1083
1084 // returns the default value of this property, its kind may be wxT_VOID if it is not valid
1085 wxxVariant GetDefaultValue() const { return m_defaultValue ; }
1086 private :
1087 void Insert(wxPropertyInfo* &iter)
1088 {
1089 m_next = NULL ;
1090 if ( iter == NULL )
1091 iter = this ;
1092 else
1093 {
1094 wxPropertyInfo* i = iter ;
1095 while( i->m_next )
1096 i = i->m_next ;
1097
1098 i->m_next = this ;
1099 }
1100 }
1101
1102 wxClassInfo* m_itsClass ;
1103 wxString m_name ;
1104 mutable wxTypeInfo* m_typeInfo ;
1105 wxString m_typeName ;
1106 mutable wxTypeInfo* m_collectionElementTypeInfo ;
1107 wxString m_collectionElementTypeName ;
1108 wxPropertyAccessor* m_accessor ;
1109 wxxVariant m_defaultValue;
1110 wxPropertyInfoFlags m_flags ;
1111 wxString m_helpString ;
1112 wxString m_groupString ;
1113 // string representation of the default value
1114 // to be assigned by the designer to the property
1115 // when the component is dropped on the container.
1116 wxPropertyInfo* m_next ;
1117 };
1118
1119 WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxPropertyInfo* , wxPropertyInfoMap , class WXDLLIMPEXP_BASE ) ;
1120
1121 #define wxBEGIN_PROPERTIES_TABLE(theClass) \
1122 wxPropertyInfo *theClass::GetPropertiesStatic() \
1123 { \
1124 typedef theClass class_t; \
1125 static wxPropertyInfo* first = NULL ;
1126
1127 #define wxEND_PROPERTIES_TABLE() \
1128 return first ; }
1129
1130 #define wxHIDE_PROPERTY( pname ) \
1131 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(void).name() ,NULL , wxxVariant() , wxPROP_DONT_STREAM , wxEmptyString , wxEmptyString ) ;
1132
1133 #define wxPROPERTY( pname , type , setter , getter , defaultValue , flags , help , group) \
1134 wxSETTER( pname , class_t , type , setter ) \
1135 static wxSetter##pname _setter##pname ; \
1136 wxGETTER( pname , class_t , type , getter ) \
1137 static wxGetter##pname _getter##pname ; \
1138 static wxPropertyAccessor _accessor##pname( &_setter##pname , &_getter##pname , NULL , NULL ) ; \
1139 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(type).name() ,&_accessor##pname , wxxVariant(defaultValue) , flags , group , help ) ;
1140
1141 #define wxPROPERTY_FLAGS( pname , flags , type , setter , getter ,defaultValue , pflags , help , group) \
1142 wxSETTER( pname , class_t , type , setter ) \
1143 static wxSetter##pname _setter##pname ; \
1144 wxGETTER( pname , class_t , type , getter ) \
1145 static wxGetter##pname _getter##pname ; \
1146 static wxPropertyAccessor _accessor##pname( &_setter##pname , &_getter##pname , NULL , NULL ) ; \
1147 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(flags).name() ,&_accessor##pname , wxxVariant(defaultValue), wxPROP_ENUM_STORE_LONG | pflags , help , group ) ;
1148
1149 #define wxREADONLY_PROPERTY( pname , type , getter ,defaultValue , flags , help , group) \
1150 wxGETTER( pname , class_t , type , getter ) \
1151 static wxGetter##pname _getter##pname ; \
1152 static wxPropertyAccessor _accessor##pname( NULL , &_getter##pname , NULL , NULL ) ; \
1153 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(type).name() ,&_accessor##pname , wxxVariant(defaultValue), flags , help , group ) ;
1154
1155 #define wxREADONLY_PROPERTY_FLAGS( pname , flags , type , getter ,defaultValue , pflags , help , group) \
1156 wxGETTER( pname , class_t , type , getter ) \
1157 static wxGetter##pname _getter##pname ; \
1158 static wxPropertyAccessor _accessor##pname( NULL , &_getter##pname , NULL , NULL ) ; \
1159 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(flags).name() ,&_accessor##pname , wxxVariant(defaultValue), wxPROP_ENUM_STORE_LONG | pflags , help , group ) ;
1160
1161 #define wxPROPERTY_COLLECTION( pname , colltype , addelemtype , adder , getter , flags , help , group ) \
1162 wxADDER( pname , class_t , addelemtype , adder ) \
1163 static wxAdder##pname _adder##pname ; \
1164 wxCOLLECTION_GETTER( pname , class_t , colltype , getter ) \
1165 static wxCollectionGetter##pname _collectionGetter##pname ; \
1166 static wxPropertyAccessor _accessor##pname( NULL , NULL ,&_adder##pname , &_collectionGetter##pname ) ; \
1167 static wxPropertyInfo _propertyInfo##pname( first , class_t::GetClassInfoStatic() , wxT(#pname) , typeid(colltype).name() ,typeid(addelemtype).name() ,&_accessor##pname , flags , help , group ) ;
1168
1169 #define wxREADONLY_PROPERTY_COLLECTION( pname , colltype , addelemtype , getter , flags , help , group) \
1170 wxCOLLECTION_GETTER( pname , class_t , colltype , getter ) \
1171 static wxCollectionGetter##pname _collectionGetter##pname ; \
1172 static wxPropertyAccessor _accessor##pname( NULL , NULL , NULL , &_collectionGetter##pname ) ; \
1173 static wxPropertyInfo _propertyInfo##pname( first ,class_t::GetClassInfoStatic() , wxT(#pname) , typeid(colltype).name() ,typeid(addelemtype).name() ,&_accessor##pname , flags , help , group ) ;
1174
1175
1176 #define wxEVENT_PROPERTY( name , eventType , eventClass ) \
1177 static wxDelegateTypeInfo _typeInfo##name( eventType , CLASSINFO( eventClass ) ) ; \
1178 static wxPropertyInfo _propertyInfo##name( first ,class_t::GetClassInfoStatic() , wxT(#name) , &_typeInfo##name , NULL , wxxVariant() ) ; \
1179
1180 #define wxEVENT_RANGE_PROPERTY( name , eventType , lastEventType , eventClass ) \
1181 static wxDelegateTypeInfo _typeInfo##name( eventType , lastEventType , CLASSINFO( eventClass ) ) ; \
1182 static wxPropertyInfo _propertyInfo##name( first , class_t::GetClassInfoStatic() , wxT(#name) , &_typeInfo##name , NULL , wxxVariant() ) ; \
1183
1184 // ----------------------------------------------------------------------------
1185 // Implementation Helper for Simple Properties
1186 // ----------------------------------------------------------------------------
1187
1188 #define wxIMPLEMENT_PROPERTY(name, type) \
1189 private:\
1190 type m_##name; \
1191 public: \
1192 void Set##name( type const & p) { m_##name = p; } \
1193 type const & Get##name() const { return m_##name; }
1194
1195 // ----------------------------------------------------------------------------
1196 // Handler Info
1197 //
1198 // this is describing an event sink
1199 // ----------------------------------------------------------------------------
1200
1201 class WXDLLIMPEXP_BASE wxHandlerInfo
1202 {
1203 friend class WXDLLIMPEXP_BASE wxDynamicClassInfo ;
1204 public :
1205 wxHandlerInfo(wxHandlerInfo* &iter,
1206 wxClassInfo* itsClass,
1207 const wxString& name,
1208 wxObjectEventFunction address,
1209 const wxClassInfo* eventClassInfo) :
1210 m_eventFunction(address),
1211 m_name(name),
1212 m_eventClassInfo(eventClassInfo) ,
1213 m_itsClass(itsClass)
1214 {
1215 m_next = NULL ;
1216 if ( iter == NULL )
1217 iter = this ;
1218 else
1219 {
1220 wxHandlerInfo* i = iter ;
1221 while( i->m_next )
1222 i = i->m_next ;
1223
1224 i->m_next = this ;
1225 }
1226 }
1227
1228 ~wxHandlerInfo() ;
1229
1230 // return the name of this handler
1231 const wxString& GetName() const { return m_name ; }
1232
1233 // return the class info of the event
1234 const wxClassInfo *GetEventClassInfo() const { return m_eventClassInfo ; }
1235
1236 // get the handler function pointer
1237 wxObjectEventFunction GetEventFunction() const { return m_eventFunction ; }
1238
1239 // returns NULL if this is the last handler of this class
1240 wxHandlerInfo* GetNext() const { return m_next ; }
1241
1242 // return the class this property is declared in
1243 const wxClassInfo* GetDeclaringClass() const { return m_itsClass ; }
1244
1245 private :
1246 wxObjectEventFunction m_eventFunction ;
1247 wxString m_name;
1248 const wxClassInfo* m_eventClassInfo ;
1249 wxHandlerInfo* m_next ;
1250 wxClassInfo* m_itsClass ;
1251 };
1252
1253 #define wxHANDLER(name,eventClassType) \
1254 static wxHandlerInfo _handlerInfo##name( first , class_t::GetClassInfoStatic() , wxT(#name) , (wxObjectEventFunction) (wxEventFunction) &name , CLASSINFO( eventClassType ) ) ;
1255
1256 #define wxBEGIN_HANDLERS_TABLE(theClass) \
1257 wxHandlerInfo *theClass::GetHandlersStatic() \
1258 { \
1259 typedef theClass class_t; \
1260 static wxHandlerInfo* first = NULL ;
1261
1262 #define wxEND_HANDLERS_TABLE() \
1263 return first ; }
1264
1265 // ----------------------------------------------------------------------------
1266 // Constructor Bridges
1267 //
1268 // allow to set up constructors with params during runtime
1269 // ----------------------------------------------------------------------------
1270
1271 class WXDLLIMPEXP_BASE wxConstructorBridge
1272 {
1273 public :
1274 virtual void Create(wxObject * &o, wxxVariant *args) = 0;
1275 };
1276
1277 // a direct constructor bridge calls the operator new for this class and
1278 // passes all params to the constructor. needed for classes that cannot be
1279 // instantiated using alloc-create semantics
1280 class WXDLLIMPEXP_BASE wxDirectConstructorBrigde : public wxConstructorBridge
1281 {
1282 public :
1283 virtual void Create(wxObject * &o, wxxVariant *args) = 0;
1284 } ;
1285
1286 // Creator Bridges for all Numbers of Params
1287
1288 // no params
1289
1290 template<typename Class>
1291 struct wxConstructorBridge_0 : public wxConstructorBridge
1292 {
1293 void Create(wxObject * &o, wxxVariant *)
1294 {
1295 Class *obj = dynamic_cast<Class*>(o);
1296 obj->Create();
1297 }
1298 };
1299
1300 struct wxConstructorBridge_Dummy : public wxConstructorBridge
1301 {
1302 void Create(wxObject *&, wxxVariant *)
1303 {
1304 }
1305 } ;
1306
1307 #define wxCONSTRUCTOR_0(klass) \
1308 wxConstructorBridge_0<klass> constructor##klass ; \
1309 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1310 const wxChar *klass::ms_constructorProperties[] = { NULL } ; \
1311 const int klass::ms_constructorPropertiesCount = 0 ;
1312
1313 #define wxCONSTRUCTOR_DUMMY(klass) \
1314 wxConstructorBridge_Dummy constructor##klass ; \
1315 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1316 const wxChar *klass::ms_constructorProperties[] = { NULL } ; \
1317 const int klass::ms_constructorPropertiesCount = 0 ;
1318
1319 // 1 param
1320
1321 template<typename Class, typename T0>
1322 struct wxConstructorBridge_1 : public wxConstructorBridge
1323 {
1324 void Create(wxObject * &o, wxxVariant *args)
1325 {
1326 Class *obj = dynamic_cast<Class*>(o);
1327 obj->Create(
1328 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0)
1329 );
1330 }
1331 };
1332
1333 #define wxCONSTRUCTOR_1(klass,t0,v0) \
1334 wxConstructorBridge_1<klass,t0> constructor##klass ; \
1335 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1336 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) } ; \
1337 const int klass::ms_constructorPropertiesCount = 1 ;
1338
1339 // 2 params
1340
1341 template<typename Class,
1342 typename T0, typename T1>
1343 struct wxConstructorBridge_2 : public wxConstructorBridge
1344 {
1345 void Create(wxObject * &o, wxxVariant *args)
1346 {
1347 Class *obj = dynamic_cast<Class*>(o);
1348 obj->Create(
1349 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
1350 args[1].wxTEMPLATED_MEMBER_CALL(Get , T1)
1351 );
1352 }
1353 };
1354
1355 #define wxCONSTRUCTOR_2(klass,t0,v0,t1,v1) \
1356 wxConstructorBridge_2<klass,t0,t1> constructor##klass ; \
1357 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1358 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) } ; \
1359 const int klass::ms_constructorPropertiesCount = 2;
1360
1361 // direct constructor version
1362
1363 template<typename Class,
1364 typename T0, typename T1>
1365 struct wxDirectConstructorBridge_2 : public wxDirectConstructorBrigde
1366 {
1367 void Create(wxObject * &o, wxxVariant *args)
1368 {
1369 o = new Class(
1370 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
1371 args[1].wxTEMPLATED_MEMBER_CALL(Get , T1)
1372 );
1373 }
1374 };
1375
1376 #define wxDIRECT_CONSTRUCTOR_2(klass,t0,v0,t1,v1) \
1377 wxDirectConstructorBridge_2<klass,t0,t1> constructor##klass ; \
1378 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1379 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) } ; \
1380 const int klass::ms_constructorPropertiesCount = 2;
1381
1382
1383 // 3 params
1384
1385 template<typename Class,
1386 typename T0, typename T1, typename T2>
1387 struct wxConstructorBridge_3 : public wxConstructorBridge
1388 {
1389 void Create(wxObject * &o, wxxVariant *args)
1390 {
1391 Class *obj = dynamic_cast<Class*>(o);
1392 obj->Create(
1393 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
1394 args[1].wxTEMPLATED_MEMBER_CALL(Get , T1) ,
1395 args[2].wxTEMPLATED_MEMBER_CALL(Get , T2)
1396 );
1397 }
1398 };
1399
1400 #define wxCONSTRUCTOR_3(klass,t0,v0,t1,v1,t2,v2) \
1401 wxConstructorBridge_3<klass,t0,t1,t2> constructor##klass ; \
1402 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1403 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) } ; \
1404 const int klass::ms_constructorPropertiesCount = 3 ;
1405
1406 // 4 params
1407
1408 template<typename Class,
1409 typename T0, typename T1, typename T2, typename T3>
1410 struct wxConstructorBridge_4 : public wxConstructorBridge
1411 {
1412 void Create(wxObject * &o, wxxVariant *args)
1413 {
1414 Class *obj = dynamic_cast<Class*>(o);
1415 obj->Create(
1416 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
1417 args[1].wxTEMPLATED_MEMBER_CALL(Get , T1) ,
1418 args[2].wxTEMPLATED_MEMBER_CALL(Get , T2) ,
1419 args[3].wxTEMPLATED_MEMBER_CALL(Get , T3)
1420 );
1421 }
1422 };
1423
1424 #define wxCONSTRUCTOR_4(klass,t0,v0,t1,v1,t2,v2,t3,v3) \
1425 wxConstructorBridge_4<klass,t0,t1,t2,t3> constructor##klass ; \
1426 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1427 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) } ; \
1428 const int klass::ms_constructorPropertiesCount = 4 ;
1429
1430 // 5 params
1431
1432 template<typename Class,
1433 typename T0, typename T1, typename T2, typename T3, typename T4>
1434 struct wxConstructorBridge_5 : public wxConstructorBridge
1435 {
1436 void Create(wxObject * &o, wxxVariant *args)
1437 {
1438 Class *obj = dynamic_cast<Class*>(o);
1439 obj->Create(
1440 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
1441 args[1].wxTEMPLATED_MEMBER_CALL(Get , T1) ,
1442 args[2].wxTEMPLATED_MEMBER_CALL(Get , T2) ,
1443 args[3].wxTEMPLATED_MEMBER_CALL(Get , T3) ,
1444 args[4].wxTEMPLATED_MEMBER_CALL(Get , T4)
1445 );
1446 }
1447 };
1448
1449 #define wxCONSTRUCTOR_5(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4) \
1450 wxConstructorBridge_5<klass,t0,t1,t2,t3,t4> constructor##klass ; \
1451 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1452 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) } ; \
1453 const int klass::ms_constructorPropertiesCount = 5;
1454
1455 // 6 params
1456
1457 template<typename Class,
1458 typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
1459 struct wxConstructorBridge_6 : public wxConstructorBridge
1460 {
1461 void Create(wxObject * &o, wxxVariant *args)
1462 {
1463 Class *obj = dynamic_cast<Class*>(o);
1464 obj->Create(
1465 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
1466 args[1].wxTEMPLATED_MEMBER_CALL(Get , T1) ,
1467 args[2].wxTEMPLATED_MEMBER_CALL(Get , T2) ,
1468 args[3].wxTEMPLATED_MEMBER_CALL(Get , T3) ,
1469 args[4].wxTEMPLATED_MEMBER_CALL(Get , T4) ,
1470 args[5].wxTEMPLATED_MEMBER_CALL(Get , T5)
1471 );
1472 }
1473 };
1474
1475 #define wxCONSTRUCTOR_6(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \
1476 wxConstructorBridge_6<klass,t0,t1,t2,t3,t4,t5> constructor##klass ; \
1477 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1478 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) } ; \
1479 const int klass::ms_constructorPropertiesCount = 6;
1480
1481 // direct constructor version
1482
1483 template<typename Class,
1484 typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
1485 struct wxDirectConstructorBridge_6 : public wxDirectConstructorBrigde
1486 {
1487 void Create(wxObject * &o, wxxVariant *args)
1488 {
1489 o = new Class(
1490 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
1491 args[1].wxTEMPLATED_MEMBER_CALL(Get , T1) ,
1492 args[2].wxTEMPLATED_MEMBER_CALL(Get , T2) ,
1493 args[3].wxTEMPLATED_MEMBER_CALL(Get , T3) ,
1494 args[4].wxTEMPLATED_MEMBER_CALL(Get , T4) ,
1495 args[5].wxTEMPLATED_MEMBER_CALL(Get , T5)
1496 );
1497 }
1498 };
1499
1500 #define wxDIRECT_CONSTRUCTOR_6(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5) \
1501 wxDirectConstructorBridge_6<klass,t0,t1,t2,t3,t4,t5> constructor##klass ; \
1502 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1503 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) } ; \
1504 const int klass::ms_constructorPropertiesCount = 6;
1505
1506 // 7 params
1507
1508 template<typename Class,
1509 typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
1510 struct wxConstructorBridge_7 : public wxConstructorBridge
1511 {
1512 void Create(wxObject * &o, wxxVariant *args)
1513 {
1514 Class *obj = dynamic_cast<Class*>(o);
1515 obj->Create(
1516 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
1517 args[1].wxTEMPLATED_MEMBER_CALL(Get , T1) ,
1518 args[2].wxTEMPLATED_MEMBER_CALL(Get , T2) ,
1519 args[3].wxTEMPLATED_MEMBER_CALL(Get , T3) ,
1520 args[4].wxTEMPLATED_MEMBER_CALL(Get , T4) ,
1521 args[5].wxTEMPLATED_MEMBER_CALL(Get , T5) ,
1522 args[6].wxTEMPLATED_MEMBER_CALL(Get , T6)
1523 );
1524 }
1525 };
1526
1527 #define wxCONSTRUCTOR_7(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6) \
1528 wxConstructorBridge_7<klass,t0,t1,t2,t3,t4,t5,t6> constructor##klass ; \
1529 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1530 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) , wxT(#v6) } ; \
1531 const int klass::ms_constructorPropertiesCount = 7;
1532
1533 // 8 params
1534
1535 template<typename Class,
1536 typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
1537 struct wxConstructorBridge_8 : public wxConstructorBridge
1538 {
1539 void Create(wxObject * &o, wxxVariant *args)
1540 {
1541 Class *obj = dynamic_cast<Class*>(o);
1542 obj->Create(
1543 args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
1544 args[1].wxTEMPLATED_MEMBER_CALL(Get , T1) ,
1545 args[2].wxTEMPLATED_MEMBER_CALL(Get , T2) ,
1546 args[3].wxTEMPLATED_MEMBER_CALL(Get , T3) ,
1547 args[4].wxTEMPLATED_MEMBER_CALL(Get , T4) ,
1548 args[5].wxTEMPLATED_MEMBER_CALL(Get , T5) ,
1549 args[6].wxTEMPLATED_MEMBER_CALL(Get , T6) ,
1550 args[7].wxTEMPLATED_MEMBER_CALL(Get , T7)
1551 );
1552 }
1553 };
1554
1555 #define wxCONSTRUCTOR_8(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4,t5,v5,t6,v6,t7,v7) \
1556 wxConstructorBridge_8<klass,t0,t1,t2,t3,t4,t5,t6,t7> constructor##klass ; \
1557 wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
1558 const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) , wxT(#v3) , wxT(#v4) , wxT(#v5) , wxT(#v6) , wxT(#v7) } ; \
1559 const int klass::ms_constructorPropertiesCount = 8;
1560 // ----------------------------------------------------------------------------
1561 // wxClassInfo
1562 // ----------------------------------------------------------------------------
1563
1564 typedef wxObject *(*wxObjectConstructorFn)(void);
1565 typedef wxObject* (*wxVariantToObjectConverter)( wxxVariant &data ) ;
1566 typedef wxxVariant (*wxObjectToVariantConverter)( wxObject* ) ;
1567
1568 class WXDLLIMPEXP_BASE wxWriter;
1569 class WXDLLIMPEXP_BASE wxPersister;
1570
1571 typedef bool (*wxObjectStreamingCallback) ( const wxObject *, wxWriter * , wxPersister * , wxxVariantArray & ) ;
1572
1573 class WXDLLIMPEXP_BASE wxClassInfo
1574 {
1575 friend class WXDLLIMPEXP_BASE wxPropertyInfo ;
1576 friend class WXDLLIMPEXP_BASE wxHandlerInfo ;
1577 public:
1578 wxClassInfo(const wxClassInfo **_Parents,
1579 const wxChar *_UnitName,
1580 const wxChar *_ClassName,
1581 int size,
1582 wxObjectConstructorFn ctor ,
1583 wxPropertyInfo *_Props ,
1584 wxHandlerInfo *_Handlers ,
1585 wxConstructorBridge* _Constructor ,
1586 const wxChar ** _ConstructorProperties ,
1587 const int _ConstructorPropertiesCount ,
1588 wxVariantToObjectConverter _PtrConverter1 ,
1589 wxVariantToObjectConverter _Converter2 ,
1590 wxObjectToVariantConverter _Converter3 ,
1591 wxObjectStreamingCallback _streamingCallback = NULL
1592 ) :
1593
1594 m_className(_ClassName),
1595 m_objectSize(size),
1596 m_objectConstructor(ctor),
1597 m_next(sm_first),
1598 m_firstProperty(_Props),
1599 m_firstHandler(_Handlers),
1600 m_parents(_Parents),
1601 m_unitName(_UnitName),
1602 m_constructor(_Constructor),
1603 m_constructorProperties(_ConstructorProperties),
1604 m_constructorPropertiesCount(_ConstructorPropertiesCount),
1605 m_variantOfPtrToObjectConverter(_PtrConverter1),
1606 m_variantToObjectConverter(_Converter2),
1607 m_objectToVariantConverter(_Converter3),
1608 m_streamingCallback(_streamingCallback)
1609 {
1610 sm_first = this;
1611 Register() ;
1612 }
1613
1614 wxClassInfo(const wxChar *_UnitName, const wxChar *_ClassName,
1615 const wxClassInfo **_Parents) :
1616 m_className(_ClassName),
1617 m_objectSize(0),
1618 m_objectConstructor(NULL),
1619 m_next(sm_first),
1620 m_firstProperty(NULL),
1621 m_firstHandler(NULL),
1622 m_parents(_Parents),
1623 m_unitName(_UnitName),
1624 m_constructor(NULL),
1625 m_constructorProperties(NULL),
1626 m_constructorPropertiesCount(0),
1627 m_variantOfPtrToObjectConverter(NULL),
1628 m_variantToObjectConverter(NULL),
1629 m_objectToVariantConverter(NULL),
1630 m_streamingCallback(NULL)
1631 {
1632 sm_first = this;
1633 Register() ;
1634 }
1635
1636 virtual ~wxClassInfo() ;
1637
1638 // allocates an instance of this class, this object does not have to be initialized or fully constructed
1639 // as this call will be followed by a call to Create
1640 virtual wxObject *AllocateObject() const { return m_objectConstructor ? (*m_objectConstructor)() : 0; }
1641
1642 // 'old naming' for AllocateObject staying here for backward compatibility
1643 wxObject *CreateObject() const { return AllocateObject() ; }
1644
1645 // direct construction call for classes that cannot construct instances via alloc/create
1646 wxObject *ConstructObject(int ParamCount, wxxVariant *Params) const
1647 {
1648 if ( ParamCount != m_constructorPropertiesCount )
1649 {
1650 wxLogError( _("Illegal Parameter Count for ConstructObject Method") ) ;
1651 return NULL ;
1652 }
1653 wxObject *object = NULL ;
1654 m_constructor->Create( object , Params ) ;
1655 return object ;
1656 }
1657
1658 bool NeedsDirectConstruction() const { return dynamic_cast<wxDirectConstructorBrigde*>( m_constructor) != NULL ; }
1659
1660 const wxChar *GetClassName() const { return m_className; }
1661 const wxChar *GetBaseClassName1() const
1662 { return m_parents[0] ? m_parents[0]->GetClassName() : NULL; }
1663 const wxChar *GetBaseClassName2() const
1664 { return (m_parents[0] && m_parents[1]) ? m_parents[1]->GetClassName() : NULL; }
1665 const wxChar *GetIncludeName() const { return m_unitName ; }
1666 const wxClassInfo **GetParents() const { return m_parents; }
1667 int GetSize() const { return m_objectSize; }
1668
1669 wxObjectConstructorFn GetConstructor() const { return m_objectConstructor; }
1670 static const wxClassInfo *GetFirst() { return sm_first; }
1671 const wxClassInfo *GetNext() const { return m_next; }
1672 static wxClassInfo *FindClass(const wxChar *className);
1673
1674 // Climb upwards through inheritance hierarchy.
1675 // Dual inheritance is catered for.
1676
1677 bool IsKindOf(const wxClassInfo *info) const
1678 {
1679 if ( info != 0 )
1680 {
1681 if ( info == this )
1682 return true ;
1683
1684 for ( int i = 0 ; m_parents[i] ; ++ i )
1685 {
1686 if ( m_parents[i]->IsKindOf( info ) )
1687 return true ;
1688 }
1689 }
1690 return false ;
1691 }
1692
1693 // if there is a callback registered with that class it will be called
1694 // before this object will be written to disk, it can veto streaming out
1695 // this object by returning false, if this class has not registered a
1696 // callback, the search will go up the inheritance tree if no callback has
1697 // been registered true will be returned by default
1698 bool BeforeWriteObject( const wxObject *obj, wxWriter *streamer , wxPersister *persister , wxxVariantArray &metadata) const ;
1699
1700 // gets the streaming callback from this class or any superclass
1701 wxObjectStreamingCallback GetStreamingCallback() const ;
1702
1703 #if WXWIN_COMPATIBILITY_2_4
1704 // Initializes parent pointers and hash table for fast searching.
1705 wxDEPRECATED( static void InitializeClasses() );
1706 // Cleans up hash table used for fast searching.
1707 wxDEPRECATED( static void CleanUpClasses() );
1708 #endif
1709 static void CleanUp();
1710
1711 // returns the first property
1712 const wxPropertyInfo* GetFirstProperty() const { return m_firstProperty ; }
1713
1714 // returns the first handler
1715 const wxHandlerInfo* GetFirstHandler() const { return m_firstHandler ; }
1716
1717 // Call the Create upon an instance of the class, in the end the object is fully
1718 // initialized
1719 virtual void Create (wxObject *object, int ParamCount, wxxVariant *Params) const
1720 {
1721 if ( ParamCount != m_constructorPropertiesCount )
1722 {
1723 wxLogError( _("Illegal Parameter Count for Create Method") ) ;
1724 return ;
1725 }
1726 m_constructor->Create( object , Params ) ;
1727 }
1728
1729 // get number of parameters for constructor
1730 virtual int GetCreateParamCount() const { return m_constructorPropertiesCount; }
1731
1732 // get n-th constructor parameter
1733 virtual const wxChar* GetCreateParamName(int n) const { return m_constructorProperties[n] ; }
1734
1735 // Runtime access to objects for simple properties (get/set) by property name, and variant data
1736 virtual void SetProperty (wxObject *object, const wxChar *propertyName, const wxxVariant &value) const ;
1737 virtual wxxVariant GetProperty (wxObject *object, const wxChar *propertyName) const;
1738
1739 // Runtime access to objects for collection properties by property name
1740 virtual wxxVariantArray GetPropertyCollection(wxObject *object, const wxChar *propertyName) const ;
1741 virtual void AddToPropertyCollection(wxObject *object, const wxChar *propertyName , const wxxVariant& value) const ;
1742
1743 // we must be able to cast variants to wxObject pointers, templates seem not to be suitable
1744 wxObject* VariantToInstance( wxxVariant &data ) const
1745 {
1746 if ( data.GetTypeInfo()->GetKind() == wxT_OBJECT )
1747 return m_variantToObjectConverter( data ) ;
1748 else
1749 return m_variantOfPtrToObjectConverter( data ) ;
1750 }
1751
1752 wxxVariant InstanceToVariant( wxObject *object ) const { return m_objectToVariantConverter( object ) ; }
1753
1754 // find property by name
1755 virtual const wxPropertyInfo *FindPropertyInfo (const wxChar *PropertyName) const ;
1756
1757 // find handler by name
1758 virtual const wxHandlerInfo *FindHandlerInfo (const wxChar *PropertyName) const ;
1759
1760 // find property by name
1761 virtual wxPropertyInfo *FindPropertyInfoInThisClass (const wxChar *PropertyName) const ;
1762
1763 // find handler by name
1764 virtual wxHandlerInfo *FindHandlerInfoInThisClass (const wxChar *PropertyName) const ;
1765
1766 // puts all the properties of this class and its superclasses in the map, as long as there is not yet
1767 // an entry with the same name (overriding mechanism)
1768 void GetProperties( wxPropertyInfoMap &map ) const ;
1769 public:
1770 const wxChar *m_className;
1771 int m_objectSize;
1772 wxObjectConstructorFn m_objectConstructor;
1773
1774 // class info object live in a linked list:
1775 // pointers to its head and the next element in it
1776
1777 static wxClassInfo *sm_first;
1778 wxClassInfo *m_next;
1779
1780 // FIXME: this should be private (currently used directly by way too
1781 // many clients)
1782 static wxHashTable *sm_classTable;
1783
1784 protected :
1785 wxPropertyInfo * m_firstProperty ;
1786 wxHandlerInfo * m_firstHandler ;
1787 private:
1788 const wxClassInfo** m_parents ;
1789 const wxChar* m_unitName;
1790
1791 wxConstructorBridge* m_constructor ;
1792 const wxChar ** m_constructorProperties ;
1793 const int m_constructorPropertiesCount ;
1794 wxVariantToObjectConverter m_variantOfPtrToObjectConverter ;
1795 wxVariantToObjectConverter m_variantToObjectConverter ;
1796 wxObjectToVariantConverter m_objectToVariantConverter ;
1797 wxObjectStreamingCallback m_streamingCallback ;
1798 const wxPropertyAccessor *FindAccessor (const wxChar *propertyName) const ;
1799
1800
1801 // InitializeClasses() helper
1802 static wxClassInfo *GetBaseByName(const wxChar *name) ;
1803
1804 protected:
1805 // registers the class
1806 void Register();
1807 void Unregister();
1808
1809 DECLARE_NO_COPY_CLASS(wxClassInfo)
1810 };
1811
1812
1813 WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
1814
1815 // ----------------------------------------------------------------------------
1816 // wxDynamicObject
1817 // ----------------------------------------------------------------------------
1818 //
1819 // this object leads to having a pure runtime-instantiation
1820
1821 class WXDLLIMPEXP_BASE wxDynamicClassInfo : public wxClassInfo
1822 {
1823 friend class WXDLLIMPEXP_BASE wxDynamicObject ;
1824 public :
1825 wxDynamicClassInfo( const wxChar *_UnitName, const wxChar *_ClassName , const wxClassInfo* superClass ) ;
1826 virtual ~wxDynamicClassInfo() ;
1827
1828 // constructs a wxDynamicObject with an instance
1829 virtual wxObject *AllocateObject() const ;
1830
1831 // Call the Create method for a class
1832 virtual void Create (wxObject *object, int ParamCount, wxxVariant *Params) const ;
1833
1834 // get number of parameters for constructor
1835 virtual int GetCreateParamCount() const ;
1836
1837 // get i-th constructor parameter
1838 virtual const wxChar* GetCreateParamName(int i) const ;
1839
1840 // Runtime access to objects by property name, and variant data
1841 virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value) const ;
1842 virtual wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName) const ;
1843
1844 // adds a property to this class at runtime
1845 void AddProperty( const wxChar *propertyName , const wxTypeInfo* typeInfo ) ;
1846
1847 // removes an existing runtime-property
1848 void RemoveProperty( const wxChar *propertyName ) ;
1849
1850 // renames an existing runtime-property
1851 void RenameProperty( const wxChar *oldPropertyName , const wxChar *newPropertyName ) ;
1852
1853 // as a handler to this class at runtime
1854 void AddHandler( const wxChar *handlerName , wxObjectEventFunction address , const wxClassInfo* eventClassInfo ) ;
1855
1856 // removes an existing runtime-handler
1857 void RemoveHandler( const wxChar *handlerName ) ;
1858
1859 // renames an existing runtime-handler
1860 void RenameHandler( const wxChar *oldHandlerName , const wxChar *newHandlerName ) ;
1861 private :
1862 struct wxDynamicClassInfoInternal ;
1863 wxDynamicClassInfoInternal* m_data ;
1864 } ;
1865
1866 // ----------------------------------------------------------------------------
1867 // Dynamic class macros
1868 // ----------------------------------------------------------------------------
1869
1870 #define _DECLARE_DYNAMIC_CLASS(name) \
1871 public: \
1872 static wxClassInfo ms_classInfo; \
1873 static const wxClassInfo* ms_classParents[] ; \
1874 static wxPropertyInfo* GetPropertiesStatic() ; \
1875 static wxHandlerInfo* GetHandlersStatic() ; \
1876 static wxClassInfo *GetClassInfoStatic() \
1877 { return &name::ms_classInfo; } \
1878 virtual wxClassInfo *GetClassInfo() const \
1879 { return &name::ms_classInfo; }
1880
1881 /*
1882 #define _DECLARE_DYNAMIC_CLASS(name) \
1883 public: \
1884 static wxClassInfo ms_class##name; \
1885 static const wxClassInfo* ms_classParents##name[] ; \
1886 static wxPropertyInfo* GetPropertiesStatic() ; \
1887 static wxHandlerInfo* GetHandlersStatic() ; \
1888 static wxClassInfo *GetClassInfoStatic() \
1889 { return &name::ms_class##name; } \
1890 virtual wxClassInfo *GetClassInfo() const \
1891 { return &name::ms_class##name; }
1892 */
1893 #define DECLARE_DYNAMIC_CLASS(name) \
1894 static wxConstructorBridge* ms_constructor ; \
1895 static const wxChar * ms_constructorProperties[] ; \
1896 static const int ms_constructorPropertiesCount ; \
1897 _DECLARE_DYNAMIC_CLASS(name)
1898
1899 #define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name) \
1900 DECLARE_NO_ASSIGN_CLASS(name) \
1901 DECLARE_DYNAMIC_CLASS(name)
1902
1903 #define DECLARE_DYNAMIC_CLASS_NO_COPY(name) \
1904 DECLARE_NO_COPY_CLASS(name) \
1905 DECLARE_DYNAMIC_CLASS(name)
1906
1907 #define DECLARE_ABSTRACT_CLASS(name) _DECLARE_DYNAMIC_CLASS(name)
1908 #define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
1909
1910 // -----------------------------------
1911 // for concrete classes
1912 // -----------------------------------
1913
1914 // Single inheritance with one base class
1915
1916 #define _TYPEINFO_CLASSES(n , toString , fromString ) \
1917 wxClassTypeInfo s_typeInfo##n(wxT_OBJECT , &n::ms_classInfo , toString , fromString , typeid(n).name()) ; \
1918 wxClassTypeInfo s_typeInfoPtr##n(wxT_OBJECT_PTR , &n::ms_classInfo , toString , fromString , typeid(n*).name()) ;
1919
1920 #define _IMPLEMENT_DYNAMIC_CLASS(name, basename, unit , callback) \
1921 wxObject* wxConstructorFor##name() \
1922 { return new name; } \
1923 const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,NULL } ; \
1924 wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
1925 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1926 wxClassInfo name::ms_classInfo(name::ms_classParents , wxT(unit) , wxT(#name), \
1927 (int) sizeof(name), \
1928 (wxObjectConstructorFn) wxConstructorFor##name , \
1929 name::GetPropertiesStatic(),name::GetHandlersStatic(),name::ms_constructor , name::ms_constructorProperties , \
1930 name::ms_constructorPropertiesCount , wxVariantOfPtrToObjectConverter##name , NULL , wxObjectToVariantConverter##name , callback);
1931
1932 #define _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY(name, basename, unit, callback ) \
1933 wxObject* wxConstructorFor##name() \
1934 { return new name; } \
1935 const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,NULL } ; \
1936 wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return &data.wxTEMPLATED_MEMBER_CALL(Get , name) ; } \
1937 wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
1938 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
1939 wxClassInfo name::ms_classInfo(name::ms_classParents , wxT(unit) , wxT(#name), \
1940 (int) sizeof(name), \
1941 (wxObjectConstructorFn) wxConstructorFor##name , \
1942 name::GetPropertiesStatic(),name::GetHandlersStatic(),name::ms_constructor , name::ms_constructorProperties, \
1943 name::ms_constructorPropertiesCount , wxVariantOfPtrToObjectConverter##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name, callback);
1944
1945 #define IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename ) \
1946 _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , "" , NULL ) \
1947 _TYPEINFO_CLASSES(name, NULL , NULL) \
1948 const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
1949 const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1950 wxCONSTRUCTOR_DUMMY( name )
1951
1952 #define IMPLEMENT_DYNAMIC_CLASS( name , basename ) \
1953 _IMPLEMENT_DYNAMIC_CLASS( name , basename , "" , NULL ) \
1954 _TYPEINFO_CLASSES(name, NULL , NULL) \
1955 wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
1956 wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
1957 wxCONSTRUCTOR_DUMMY( name )
1958
1959 #define IMPLEMENT_DYNAMIC_CLASS_XTI( name , basename , unit ) \
1960 _IMPLEMENT_DYNAMIC_CLASS( name , basename , unit , NULL ) \
1961 _TYPEINFO_CLASSES(name, NULL , NULL)
1962
1963 #define IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK( name , basename , unit , callback ) \
1964 _IMPLEMENT_DYNAMIC_CLASS( name , basename , unit , &callback ) \
1965 _TYPEINFO_CLASSES(name, NULL , NULL)
1966
1967 #define IMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI( name , basename , unit ) \
1968 _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , unit , NULL ) \
1969 _TYPEINFO_CLASSES(name, NULL , NULL)
1970
1971 #define IMPLEMENT_DYNAMIC_CLASS_WITH_COPY_AND_STREAMERS_XTI( name , basename , unit , toString , fromString ) \
1972 _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name , basename , unit , NULL ) \
1973 _TYPEINFO_CLASSES(name, toString , fromString)
1974
1975 // this is for classes that do not derive from wxobject, there are no creators for these
1976
1977 #define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_NO_BASE_XTI( name , unit ) \
1978 const wxClassInfo* name::ms_classParents[] = { NULL } ; \
1979 wxClassInfo name::ms_classInfo(name::ms_classParents , wxEmptyString , wxT(#name), \
1980 (int) sizeof(name), \
1981 (wxObjectConstructorFn) 0 , \
1982 name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
1983 0 , 0 , 0 ); \
1984 _TYPEINFO_CLASSES(name, NULL , NULL)
1985
1986 // this is for subclasses that still do not derive from wxobject
1987
1988 #define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_XTI( name , basename, unit ) \
1989 const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,NULL } ; \
1990 wxClassInfo name::ms_classInfo(name::ms_classParents , wxEmptyString , wxT(#name), \
1991 (int) sizeof(name), \
1992 (wxObjectConstructorFn) 0 , \
1993 name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
1994 0 , 0 , 0 ); \
1995 _TYPEINFO_CLASSES(name, NULL , NULL)
1996
1997
1998 // Multiple inheritance with two base classes
1999
2000 #define _IMPLEMENT_DYNAMIC_CLASS2(name, basename, basename2, unit) \
2001 wxObject* wxConstructorFor##name() \
2002 { return new name; } \
2003 const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,&basename2::ms_classInfo , NULL } ; \
2004 wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
2005 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
2006 wxClassInfo name::ms_classInfo(name::ms_classParents , wxT(unit) , wxT(#name), \
2007 (int) sizeof(name), \
2008 (wxObjectConstructorFn) wxConstructorFor##name , \
2009 name::GetPropertiesStatic(),name::GetHandlersStatic(),name::ms_constructor , name::ms_constructorProperties , \
2010 name::ms_constructorPropertiesCount , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
2011
2012 #define IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2) \
2013 _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , "") \
2014 _TYPEINFO_CLASSES(name, NULL , NULL) \
2015 wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
2016 wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
2017 wxCONSTRUCTOR_DUMMY( name )
2018
2019 #define IMPLEMENT_DYNAMIC_CLASS2_XTI( name , basename , basename2, unit) \
2020 _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , unit) \
2021 _TYPEINFO_CLASSES(name, NULL , NULL)
2022
2023
2024 // -----------------------------------
2025 // for abstract classes
2026 // -----------------------------------
2027
2028 // Single inheritance with one base class
2029
2030 #define _IMPLEMENT_ABSTRACT_CLASS(name, basename) \
2031 const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,NULL } ; \
2032 wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
2033 wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
2034 wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
2035 wxClassInfo name::ms_classInfo(name::ms_classParents , wxEmptyString , wxT(#name), \
2036 (int) sizeof(name), \
2037 (wxObjectConstructorFn) 0 , \
2038 name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
2039 0 , wxVariantOfPtrToObjectConverter##name ,wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
2040 _TYPEINFO_CLASSES(name, NULL , NULL)
2041
2042 #define IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
2043 _IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
2044 wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
2045 wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; }
2046
2047 // Multiple inheritance with two base classes
2048
2049 #define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
2050 wxClassInfo name::ms_classInfo(wxT(#name), wxT(#basename1), \
2051 wxT(#basename2), (int) sizeof(name), \
2052 (wxObjectConstructorFn) 0);
2053
2054 #define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
2055 #define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
2056
2057 #define wxBEGIN_EVENT_TABLE( a , b ) BEGIN_EVENT_TABLE( a , b )
2058 #define wxEND_EVENT_TABLE() END_EVENT_TABLE()
2059
2060 // --------------------------------------------------------------------------
2061 // Collection Support
2062 // --------------------------------------------------------------------------
2063
2064 template<typename iter , typename collection_t > void wxListCollectionToVariantArray( const collection_t& coll , wxxVariantArray &value )
2065 {
2066 iter current = coll.GetFirst() ;
2067 while (current)
2068 {
2069 value.Add( new wxxVariant(current->GetData()) ) ;
2070 current = current->GetNext();
2071 }
2072 }
2073
2074 template<typename collection_t> void wxArrayCollectionToVariantArray( const collection_t& coll , wxxVariantArray &value )
2075 {
2076 for( size_t i = 0 ; i < coll.GetCount() ; i++ )
2077 {
2078 value.Add( new wxxVariant(coll[i]) ) ;
2079 }
2080 }
2081
2082
2083 #endif