]> git.saurik.com Git - wxWidgets.git/blob - src/common/xti.cpp
add support for alpha in color dialog on OSX, see #14127
[wxWidgets.git] / src / common / xti.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/xti.cpp
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 // For compilers that support precompilation, includes "wx.h".
14 #include "wx/wxprec.h"
15
16 #ifdef __BORLANDC__
17 #pragma hdrstop
18 #endif
19
20 #if wxUSE_EXTENDED_RTTI
21
22 #ifndef WX_PRECOMP
23 #include "wx/object.h"
24 #include "wx/list.h"
25 #include "wx/hash.h"
26 #endif
27
28 #include "wx/xti.h"
29 #include "wx/xml/xml.h"
30 #include "wx/tokenzr.h"
31 #include "wx/range.h"
32
33 #include <string.h>
34
35 #include "wx/beforestd.h"
36 #include <map>
37 #include <string>
38 #include <list>
39 #include "wx/afterstd.h"
40
41 using namespace std;
42
43 // ----------------------------------------------------------------------------
44 // wxEnumData
45 // ----------------------------------------------------------------------------
46
47 wxEnumData::wxEnumData( wxEnumMemberData* data )
48 {
49 m_members = data;
50 for ( m_count = 0; m_members[m_count].m_name; m_count++)
51 {};
52 }
53
54 bool wxEnumData::HasEnumMemberValue(const wxChar *name, int *value) const
55 {
56 int i;
57 for (i = 0; m_members[i].m_name; i++ )
58 {
59 if (!wxStrcmp(name, m_members[i].m_name))
60 {
61 if ( value )
62 *value = m_members[i].m_value;
63 return true;
64 }
65 }
66 return false;
67 }
68
69 int wxEnumData::GetEnumMemberValue(const wxChar *name) const
70 {
71 int i;
72 for (i = 0; m_members[i].m_name; i++ )
73 {
74 if (!wxStrcmp(name, m_members[i].m_name))
75 {
76 return m_members[i].m_value;
77 }
78 }
79 return 0;
80 }
81
82 const wxChar *wxEnumData::GetEnumMemberName(int value) const
83 {
84 int i;
85 for (i = 0; m_members[i].m_name; i++)
86 if (value == m_members[i].m_value)
87 return m_members[i].m_name;
88
89 return wxEmptyString;
90 }
91
92 int wxEnumData::GetEnumMemberValueByIndex( int idx ) const
93 {
94 // we should cache the count in order to avoid out-of-bounds errors
95 return m_members[idx].m_value;
96 }
97
98 const wxChar * wxEnumData::GetEnumMemberNameByIndex( int idx ) const
99 {
100 // we should cache the count in order to avoid out-of-bounds errors
101 return m_members[idx].m_name;
102 }
103
104 // ----------------------------------------------------------------------------
105 // Type Information
106 // ----------------------------------------------------------------------------
107
108 // ----------------------------------------------------------------------------
109 // value streaming
110 // ----------------------------------------------------------------------------
111
112 // streamer specializations
113 // for all built-in types
114
115 // bool
116
117 template<> void wxStringReadValue(const wxString &s, bool &data )
118 {
119 int intdata;
120 wxSscanf(s, wxT("%d"), &intdata );
121 data = (bool)(intdata != 0);
122 }
123
124 template<> void wxStringWriteValue(wxString &s, const bool &data )
125 {
126 s = wxString::Format(wxT("%d"), data );
127 }
128
129 // char
130
131 template<> void wxStringReadValue(const wxString &s, char &data )
132 {
133 int intdata;
134 wxSscanf(s, wxT("%d"), &intdata );
135 data = char(intdata);
136 }
137
138 template<> void wxStringWriteValue(wxString &s, const char &data )
139 {
140 s = wxString::Format(wxT("%d"), data );
141 }
142
143 // unsigned char
144
145 template<> void wxStringReadValue(const wxString &s, unsigned char &data )
146 {
147 int intdata;
148 wxSscanf(s, wxT("%d"), &intdata );
149 data = (unsigned char)(intdata);
150 }
151
152 template<> void wxStringWriteValue(wxString &s, const unsigned char &data )
153 {
154 s = wxString::Format(wxT("%d"), data );
155 }
156
157 // int
158
159 template<> void wxStringReadValue(const wxString &s, int &data )
160 {
161 wxSscanf(s, wxT("%d"), &data );
162 }
163
164 template<> void wxStringWriteValue(wxString &s, const int &data )
165 {
166 s = wxString::Format(wxT("%d"), data );
167 }
168
169 // unsigned int
170
171 template<> void wxStringReadValue(const wxString &s, unsigned int &data )
172 {
173 wxSscanf(s, wxT("%d"), &data );
174 }
175
176 template<> void wxStringWriteValue(wxString &s, const unsigned int &data )
177 {
178 s = wxString::Format(wxT("%d"), data );
179 }
180
181 // long
182
183 template<> void wxStringReadValue(const wxString &s, long &data )
184 {
185 wxSscanf(s, wxT("%ld"), &data );
186 }
187
188 template<> void wxStringWriteValue(wxString &s, const long &data )
189 {
190 s = wxString::Format(wxT("%ld"), data );
191 }
192
193 // unsigned long
194
195 template<> void wxStringReadValue(const wxString &s, unsigned long &data )
196 {
197 wxSscanf(s, wxT("%ld"), &data );
198 }
199
200 template<> void wxStringWriteValue(wxString &s, const unsigned long &data )
201 {
202 s = wxString::Format(wxT("%ld"), data );
203 }
204
205 #ifdef wxLongLong_t
206 template<> void wxStringReadValue(const wxString &s, wxLongLong_t &data )
207 {
208 wxSscanf(s, wxT("%lld"), &data );
209 }
210
211 template<> void wxStringWriteValue(wxString &s, const wxLongLong_t &data )
212 {
213 s = wxString::Format(wxT("%lld"), data );
214 }
215
216 template<> void wxStringReadValue(const wxString &s, wxULongLong_t &data )
217 {
218 wxSscanf(s, wxT("%lld"), &data );
219 }
220
221 template<> void wxStringWriteValue(wxString &s, const wxULongLong_t &data )
222 {
223 s = wxString::Format(wxT("%lld"), data );
224 }
225 #endif
226 // float
227
228 template<> void wxStringReadValue(const wxString &s, float &data )
229 {
230 wxSscanf(s, wxT("%f"), &data );
231 }
232
233 template<> void wxStringWriteValue(wxString &s, const float &data )
234 {
235 s = wxString::Format(wxT("%f"), data );
236 }
237
238 // double
239
240 template<> void wxStringReadValue(const wxString &s, double &data )
241 {
242 wxSscanf(s, wxT("%lf"), &data );
243 }
244
245 template<> void wxStringWriteValue(wxString &s, const double &data )
246 {
247 s = wxString::Format(wxT("%lf"), data );
248 }
249
250 // wxString
251
252 template<> void wxStringReadValue(const wxString &s, wxString &data )
253 {
254 data = s;
255 }
256
257 template<> void wxStringWriteValue(wxString &s, const wxString &data )
258 {
259 s = data;
260 }
261
262
263 // built-ins
264 //
265
266 #if wxUSE_FUNC_TEMPLATE_POINTER
267 #define wxBUILTIN_TYPE_INFO( element, type ) \
268 wxBuiltInTypeInfo \
269 s_typeInfo##type(element, &wxToStringConverter<type>, \
270 &wxFromStringConverter<type>, typeid(type).name());
271 #else
272 #define wxBUILTIN_TYPE_INFO( element, type ) \
273 void _toString##element( const wxAny& data, wxString &result ) \
274 { wxToStringConverter<type, data, result); } \
275 void _fromString##element( const wxString& data, wxAny &result ) \
276 { wxFromStringConverter<type, data, result); } \
277 wxBuiltInTypeInfo s_typeInfo##type(element, &_toString##element, \
278 &_fromString##element, typeid(type).name());
279 #endif
280
281 typedef unsigned char unsigned_char;
282 typedef unsigned int unsigned_int;
283 typedef unsigned long unsigned_long;
284
285 wxBuiltInTypeInfo s_typeInfovoid( wxT_VOID, NULL, NULL, typeid(void).name());
286 wxBUILTIN_TYPE_INFO( wxT_BOOL, bool);
287 wxBUILTIN_TYPE_INFO( wxT_CHAR, char);
288 wxBUILTIN_TYPE_INFO( wxT_UCHAR, unsigned_char);
289 wxBUILTIN_TYPE_INFO( wxT_INT, int);
290 wxBUILTIN_TYPE_INFO( wxT_UINT, unsigned_int);
291 wxBUILTIN_TYPE_INFO( wxT_LONG, long);
292 wxBUILTIN_TYPE_INFO( wxT_ULONG, unsigned_long);
293 wxBUILTIN_TYPE_INFO( wxT_FLOAT, float);
294 wxBUILTIN_TYPE_INFO( wxT_DOUBLE, double);
295 wxBUILTIN_TYPE_INFO( wxT_STRING, wxString);
296
297 #ifdef wxLongLong_t
298 wxBUILTIN_TYPE_INFO(wxT_LONGLONG, wxLongLong_t)
299 wxBUILTIN_TYPE_INFO(wxT_ULONGLONG, wxULongLong_t)
300 #endif
301
302 // this are compiler induced specialization which are never used anywhere
303
304 wxILLEGAL_TYPE_SPECIALIZATION( char const * )
305 wxILLEGAL_TYPE_SPECIALIZATION( char * )
306 wxILLEGAL_TYPE_SPECIALIZATION( unsigned char * )
307 wxILLEGAL_TYPE_SPECIALIZATION( int * )
308 wxILLEGAL_TYPE_SPECIALIZATION( bool * )
309 wxILLEGAL_TYPE_SPECIALIZATION( long * )
310 wxILLEGAL_TYPE_SPECIALIZATION( wxString * )
311
312 // wxRange
313
314 template<> void wxStringReadValue(const wxString &s , wxRange &data)
315 {
316 int minValue, maxValue;
317 wxSscanf(s, wxT("%d,%d"), &minValue , &maxValue);
318 data = wxRange(minValue, maxValue);
319 }
320
321 template<> void wxStringWriteValue(wxString &s , const wxRange &data)
322 {
323 s = wxString::Format(wxT("%d,%d"), data.GetMin() , data.GetMax());
324 }
325
326 wxCUSTOM_TYPE_INFO(wxRange, wxToStringConverter<wxRange> , wxFromStringConverter<wxRange>)
327
328 // other types
329
330 wxCOLLECTION_TYPE_INFO( wxString, wxArrayString );
331
332 template<> void wxCollectionToVariantArray( wxArrayString const &theArray,
333 wxAnyList &value)
334 {
335 wxArrayCollectionToVariantArray( theArray, value );
336 }
337
338 wxTypeInfoMap *wxTypeInfo::ms_typeTable = NULL;
339
340 wxTypeInfo *wxTypeInfo::FindType(const wxString& typeName)
341 {
342 wxTypeInfoMap::iterator iter = ms_typeTable->find(typeName);
343
344 if (iter == ms_typeTable->end())
345 return NULL;
346
347 return (wxTypeInfo *)iter->second;
348 }
349
350 wxClassTypeInfo::wxClassTypeInfo( wxTypeKind kind, wxClassInfo* classInfo,
351 wxVariant2StringFnc to,
352 wxString2VariantFnc from,
353 const wxString &name) :
354 wxTypeInfo( kind, to, from, name)
355 {
356 wxASSERT_MSG( kind == wxT_OBJECT_PTR || kind == wxT_OBJECT,
357 wxT("Illegal Kind for Enum Type")); m_classInfo = classInfo;
358 }
359
360 wxEventSourceTypeInfo::wxEventSourceTypeInfo( int eventType, wxClassInfo* eventClass,
361 wxVariant2StringFnc to,
362 wxString2VariantFnc from ) :
363 wxTypeInfo ( wxT_DELEGATE, to, from, wxEmptyString )
364 {
365 m_eventClass = eventClass;
366 m_eventType = eventType;
367 m_lastEventType = -1;
368 }
369
370 wxEventSourceTypeInfo::wxEventSourceTypeInfo( int eventType, int lastEventType,
371 wxClassInfo* eventClass,
372 wxVariant2StringFnc to,
373 wxString2VariantFnc from ) :
374 wxTypeInfo ( wxT_DELEGATE, to, from, wxEmptyString )
375 {
376 m_eventClass = eventClass;
377 m_eventType = eventType;
378 m_lastEventType = lastEventType;
379 }
380
381 void wxTypeInfo::Register()
382 {
383 if ( ms_typeTable == NULL )
384 ms_typeTable = new wxTypeInfoMap();
385
386 if( !m_name.empty() )
387 (*ms_typeTable)[m_name] = this;
388 }
389
390 void wxTypeInfo::Unregister()
391 {
392 if( !m_name.empty() )
393 ms_typeTable->erase(m_name);
394 }
395
396 // removing header dependency on string tokenizer
397
398 void wxSetStringToArray( const wxString &s, wxArrayString &array )
399 {
400 wxStringTokenizer tokenizer(s, wxT("| \t\n"), wxTOKEN_STRTOK);
401 wxString flag;
402 array.Clear();
403 while (tokenizer.HasMoreTokens())
404 {
405 array.Add(tokenizer.GetNextToken());
406 }
407 }
408
409 // ----------------------------------------------------------------------------
410 // wxPropertyInfo
411 // ----------------------------------------------------------------------------
412
413 void wxPropertyInfo::Insert(wxPropertyInfo* &iter)
414 {
415 m_next = NULL;
416 if ( iter == NULL )
417 iter = this;
418 else
419 {
420 wxPropertyInfo* i = iter;
421 while( i->m_next )
422 i = i->m_next;
423
424 i->m_next = this;
425 }
426 }
427
428 void wxPropertyInfo::Remove()
429 {
430 if ( this == m_itsClass->m_firstProperty )
431 {
432 m_itsClass->m_firstProperty = m_next;
433 }
434 else
435 {
436 wxPropertyInfo *info = m_itsClass->m_firstProperty;
437 while (info)
438 {
439 if ( info->m_next == this )
440 {
441 info->m_next = m_next;
442 break;
443 }
444
445 info = info->m_next;
446 }
447 }
448
449 }
450
451 // ----------------------------------------------------------------------------
452 // wxHandlerInfo
453 // ----------------------------------------------------------------------------
454
455 void wxHandlerInfo::Insert(wxHandlerInfo* &iter)
456 {
457 m_next = NULL;
458 if ( iter == NULL )
459 iter = this;
460 else
461 {
462 wxHandlerInfo* i = iter;
463 while( i->m_next )
464 i = i->m_next;
465
466 i->m_next = this;
467 }
468 }
469
470 void wxHandlerInfo::Remove()
471 {
472 if ( this == m_itsClass->m_firstHandler )
473 {
474 m_itsClass->m_firstHandler = m_next;
475 }
476 else
477 {
478 wxHandlerInfo *info = m_itsClass->m_firstHandler;
479 while (info)
480 {
481 if ( info->m_next == this )
482 {
483 info->m_next = m_next;
484 break;
485 }
486
487 info = info->m_next;
488 }
489 }
490 }
491
492
493 // ----------------------------------------------------------------------------
494 // wxClassInfo
495 // ----------------------------------------------------------------------------
496
497 bool wxClassInfo::Create(wxObject *object, int ParamCount, wxAny *Params) const
498 {
499 if ( ParamCount != m_constructorPropertiesCount )
500 {
501 // FIXME: shouldn't we just return false and let the caller handle it?
502 wxLogError( _("Illegal Parameter Count for Create Method") );
503 return false;
504 }
505
506 return m_constructor->Create( object, Params );
507 }
508
509 wxObject *wxClassInfo::ConstructObject(int ParamCount, wxAny *Params) const
510 {
511 if ( ParamCount != m_constructorPropertiesCount )
512 {
513 // FIXME: shouldn't we just return NULL and let the caller handle this case?
514 wxLogError( _("Illegal Parameter Count for ConstructObject Method") );
515 return NULL;
516 }
517
518 wxObject *object = NULL;
519 if (!m_constructor->Create( object, Params ))
520 return NULL;
521 return object;
522 }
523
524 bool wxClassInfo::IsKindOf(const wxClassInfo *info) const
525 {
526 if ( info != 0 )
527 {
528 if ( info == this )
529 return true;
530
531 for ( int i = 0; m_parents[i]; ++ i )
532 {
533 if ( m_parents[i]->IsKindOf( info ) )
534 return true;
535 }
536 }
537 return false;
538 }
539
540 const wxPropertyAccessor *wxClassInfo::FindAccessor(const wxChar *PropertyName) const
541 {
542 const wxPropertyInfo* info = FindPropertyInfo( PropertyName );
543
544 if ( info )
545 return info->GetAccessor();
546
547 return NULL;
548 }
549
550 wxPropertyInfo *wxClassInfo::FindPropertyInfoInThisClass (const wxChar *PropertyName) const
551 {
552 wxPropertyInfo* info = GetFirstProperty();
553
554 while( info )
555 {
556 if ( wxStrcmp( info->GetName(), PropertyName ) == 0 )
557 return info;
558 info = info->GetNext();
559 }
560
561 return 0;
562 }
563
564 const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const wxChar *PropertyName) const
565 {
566 const wxPropertyInfo* info = FindPropertyInfoInThisClass( PropertyName );
567 if ( info )
568 return info;
569
570 const wxClassInfo** parents = GetParents();
571 for ( int i = 0; parents[i]; ++ i )
572 {
573 if ( ( info = parents[i]->FindPropertyInfo( PropertyName ) ) != NULL )
574 return info;
575 }
576
577 return 0;
578 }
579
580 wxHandlerInfo *wxClassInfo::FindHandlerInfoInThisClass (const wxChar *PropertyName) const
581 {
582 wxHandlerInfo* info = GetFirstHandler();
583
584 while( info )
585 {
586 if ( wxStrcmp( info->GetName(), PropertyName ) == 0 )
587 return info;
588 info = info->GetNext();
589 }
590
591 return 0;
592 }
593
594 const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const wxChar *PropertyName) const
595 {
596 const wxHandlerInfo* info = FindHandlerInfoInThisClass( PropertyName );
597
598 if ( info )
599 return info;
600
601 const wxClassInfo** parents = GetParents();
602 for ( int i = 0; parents[i]; ++ i )
603 {
604 if ( ( info = parents[i]->FindHandlerInfo( PropertyName ) ) != NULL )
605 return info;
606 }
607
608 return 0;
609 }
610
611 wxObjectStreamingCallback wxClassInfo::GetStreamingCallback() const
612 {
613 if ( m_streamingCallback )
614 return m_streamingCallback;
615
616 wxObjectStreamingCallback retval = NULL;
617 const wxClassInfo** parents = GetParents();
618 for ( int i = 0; parents[i] && retval == NULL; ++ i )
619 {
620 retval = parents[i]->GetStreamingCallback();
621 }
622 return retval;
623 }
624
625 bool wxClassInfo::BeforeWriteObject( const wxObject *obj, wxObjectWriter *streamer,
626 wxObjectWriterCallback *writercallback, const wxStringToAnyHashMap &metadata) const
627 {
628 wxObjectStreamingCallback sb = GetStreamingCallback();
629 if ( sb )
630 return (*sb)(obj, streamer, writercallback, metadata );
631
632 return true;
633 }
634
635 void wxClassInfo::SetProperty(wxObject *object, const wxChar *propertyName,
636 const wxAny &value) const
637 {
638 const wxPropertyAccessor *accessor;
639
640 accessor = FindAccessor(propertyName);
641 wxASSERT(accessor->HasSetter());
642 accessor->SetProperty( object, value );
643 }
644
645 wxAny wxClassInfo::GetProperty(wxObject *object, const wxChar *propertyName) const
646 {
647 const wxPropertyAccessor *accessor;
648
649 accessor = FindAccessor(propertyName);
650 wxASSERT(accessor->HasGetter());
651 wxAny result;
652 accessor->GetProperty(object,result);
653 return result;
654 }
655
656 wxAnyList wxClassInfo::GetPropertyCollection(wxObject *object,
657 const wxChar *propertyName) const
658 {
659 const wxPropertyAccessor *accessor;
660
661 accessor = FindAccessor(propertyName);
662 wxASSERT(accessor->HasGetter());
663 wxAnyList result;
664 accessor->GetPropertyCollection(object,result);
665 return result;
666 }
667
668 void wxClassInfo::AddToPropertyCollection(wxObject *object, const wxChar *propertyName,
669 const wxAny& value) const
670 {
671 const wxPropertyAccessor *accessor;
672
673 accessor = FindAccessor(propertyName);
674 wxASSERT(accessor->HasAdder());
675 accessor->AddToPropertyCollection( object, value );
676 }
677
678 // void wxClassInfo::GetProperties( wxPropertyInfoMap &map ) const
679 // The map parameter (the name map that is) seems something special
680 // to MSVC and so we use a other name.
681 void wxClassInfo::GetProperties( wxPropertyInfoMap &infomap ) const
682 {
683 const wxPropertyInfo *pi = GetFirstProperty();
684 while( pi )
685 {
686 if ( infomap.find( pi->GetName() ) == infomap.end() )
687 infomap[pi->GetName()] = (wxPropertyInfo*) pi;
688
689 pi = pi->GetNext();
690 }
691
692 const wxClassInfo** parents = GetParents();
693 for ( int i = 0; parents[i]; ++ i )
694 {
695 parents[i]->GetProperties( infomap );
696 }
697 }
698
699 wxObject* wxClassInfo::AnyToObjectPtr( const wxAny &data) const
700 {
701 return m_variantOfPtrToObjectConverter(data);
702 }
703
704 void wxClassInfo::CallOnAny( const wxAny &data, wxObjectFunctor* functor ) const
705 {
706 if ( data.GetTypeInfo()->GetKind() == wxT_OBJECT )
707 return m_variantToObjectConverter(data, functor);
708 else
709 return (*functor)(m_variantOfPtrToObjectConverter(data));
710 }
711
712 wxAny wxClassInfo::ObjectPtrToAny( wxObject* obj) const
713 {
714 return m_objectToVariantConverter(obj);
715 }
716
717 bool wxClassInfo::NeedsDirectConstruction() const
718 {
719 return wx_dynamic_cast(wxObjectAllocator*, m_constructor) != NULL;
720 }
721
722 // ----------------------------------------------------------------------------
723 // wxDynamicObject support
724 // ----------------------------------------------------------------------------
725
726 // Dynamic Objects are objects that have a real superclass instance and carry their
727 // own attributes in a hash map. Like this it is possible to create the objects and
728 // stream them, as if their class information was already available from compiled data
729
730 struct wxDynamicObject::wxDynamicObjectInternal
731 {
732 wxDynamicObjectInternal() {}
733
734 wxStringToAnyHashMap m_properties;
735 };
736
737 typedef list< wxDynamicObject* > wxDynamicObjectList;
738
739 struct wxDynamicClassInfo::wxDynamicClassInfoInternal
740 {
741 wxDynamicObjectList m_dynamicObjects;
742 };
743
744 // instantiates this object with an instance of its superclass
745 wxDynamicObject::wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info)
746 {
747 m_superClassInstance = superClassInstance;
748 m_classInfo = info;
749 m_data = new wxDynamicObjectInternal;
750 }
751
752 wxDynamicObject::~wxDynamicObject()
753 {
754 wx_dynamic_cast(const wxDynamicClassInfo*, m_classInfo)->
755 m_data->m_dynamicObjects.remove( this );
756 delete m_data;
757 delete m_superClassInstance;
758 }
759
760 void wxDynamicObject::SetProperty (const wxChar *propertyName, const wxAny &value)
761 {
762 wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),
763 wxT("Accessing Unknown Property in a Dynamic Object") );
764 m_data->m_properties[propertyName] = value;
765 }
766
767 wxAny wxDynamicObject::GetProperty (const wxChar *propertyName) const
768 {
769 wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),
770 wxT("Accessing Unknown Property in a Dynamic Object") );
771 return m_data->m_properties[propertyName];
772 }
773
774 void wxDynamicObject::RemoveProperty( const wxChar *propertyName )
775 {
776 wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),
777 wxT("Removing Unknown Property in a Dynamic Object") );
778 m_data->m_properties.erase( propertyName );
779 }
780
781 void wxDynamicObject::RenameProperty( const wxChar *oldPropertyName,
782 const wxChar *newPropertyName )
783 {
784 wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(oldPropertyName),
785 wxT("Renaming Unknown Property in a Dynamic Object") );
786
787 wxAny value = m_data->m_properties[oldPropertyName];
788 m_data->m_properties.erase( oldPropertyName );
789 m_data->m_properties[newPropertyName] = value;
790 }
791
792
793 // ----------------------------------------------------------------------------
794 // wxDynamicClassInfo
795 // ----------------------------------------------------------------------------
796
797 wxDynamicClassInfo::wxDynamicClassInfo( const wxChar *unitName,
798 const wxChar *className,
799 const wxClassInfo* superClass ) :
800 wxClassInfo( unitName, className, new const wxClassInfo*[2])
801 {
802 GetParents()[0] = superClass;
803 GetParents()[1] = NULL;
804 m_data = new wxDynamicClassInfoInternal;
805 }
806
807 wxDynamicClassInfo::~wxDynamicClassInfo()
808 {
809 delete[] GetParents();
810 delete m_data;
811 }
812
813 wxObject *wxDynamicClassInfo::AllocateObject() const
814 {
815 wxObject* parent = GetParents()[0]->AllocateObject();
816 wxDynamicObject *obj = new wxDynamicObject( parent, this );
817 m_data->m_dynamicObjects.push_back( obj );
818 return obj;
819 }
820
821 bool wxDynamicClassInfo::Create (wxObject *object, int paramCount, wxAny *params) const
822 {
823 wxDynamicObject *dynobj = wx_dynamic_cast( wxDynamicObject *, object );
824 wxASSERT_MSG( dynobj,
825 wxT("cannot call wxDynamicClassInfo::Create on ")
826 wxT("an object other than wxDynamicObject") );
827
828 return GetParents()[0]->Create( dynobj->GetSuperClassInstance(), paramCount, params );
829 }
830
831 // get number of parameters for constructor
832 int wxDynamicClassInfo::GetCreateParamCount() const
833 {
834 return GetParents()[0]->GetCreateParamCount();
835 }
836
837 // get i-th constructor parameter
838 const wxChar* wxDynamicClassInfo::GetCreateParamName(int i) const
839 {
840 return GetParents()[0]->GetCreateParamName( i );
841 }
842
843 void wxDynamicClassInfo::SetProperty(wxObject *object, const wxChar *propertyName, const wxAny &value) const
844 {
845 wxDynamicObject* dynobj = wx_dynamic_cast(wxDynamicObject*, object);
846 wxASSERT_MSG( dynobj, wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") );
847 if ( FindPropertyInfoInThisClass(propertyName) )
848 dynobj->SetProperty( propertyName, value );
849 else
850 GetParents()[0]->SetProperty( dynobj->GetSuperClassInstance(), propertyName, value );
851 }
852
853 wxAny wxDynamicClassInfo::GetProperty(wxObject *object, const wxChar *propertyName) const
854 {
855 wxDynamicObject* dynobj = wx_dynamic_cast(wxDynamicObject*, object);
856 wxASSERT_MSG( dynobj, wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") );
857 if ( FindPropertyInfoInThisClass(propertyName) )
858 return dynobj->GetProperty( propertyName );
859 else
860 return GetParents()[0]->GetProperty( dynobj->GetSuperClassInstance(), propertyName );
861 }
862
863 void wxDynamicClassInfo::AddProperty( const wxChar *propertyName, const wxTypeInfo* typeInfo )
864 {
865 EnsureInfosInited();
866 new wxPropertyInfo( m_firstProperty, this, propertyName, typeInfo->GetTypeName(), new wxGenericPropertyAccessor( propertyName ), wxAny() );
867 }
868
869 void wxDynamicClassInfo::AddHandler( const wxChar *handlerName, wxObjectEventFunction address, const wxClassInfo* eventClassInfo )
870 {
871 EnsureInfosInited();
872 new wxHandlerInfo( m_firstHandler, this, handlerName, address, eventClassInfo );
873 }
874
875 // removes an existing runtime-property
876 void wxDynamicClassInfo::RemoveProperty( const wxChar *propertyName )
877 {
878 for ( wxDynamicObjectList::iterator iter = m_data->m_dynamicObjects.begin(); iter != m_data->m_dynamicObjects.end(); ++iter )
879 (*iter)->RemoveProperty( propertyName );
880 delete FindPropertyInfoInThisClass(propertyName);
881 }
882
883 // removes an existing runtime-handler
884 void wxDynamicClassInfo::RemoveHandler( const wxChar *handlerName )
885 {
886 delete FindHandlerInfoInThisClass(handlerName);
887 }
888
889 // renames an existing runtime-property
890 void wxDynamicClassInfo::RenameProperty( const wxChar *oldPropertyName, const wxChar *newPropertyName )
891 {
892 wxPropertyInfo* pi = FindPropertyInfoInThisClass(oldPropertyName);
893 wxASSERT_MSG( pi,wxT("not existing property") );
894 pi->m_name = newPropertyName;
895 wx_dynamic_cast(wxGenericPropertyAccessor*, pi->GetAccessor())->RenameProperty( oldPropertyName, newPropertyName );
896 for ( wxDynamicObjectList::iterator iter = m_data->m_dynamicObjects.begin(); iter != m_data->m_dynamicObjects.end(); ++iter )
897 (*iter)->RenameProperty( oldPropertyName, newPropertyName );
898 }
899
900 // renames an existing runtime-handler
901 void wxDynamicClassInfo::RenameHandler( const wxChar *oldHandlerName, const wxChar *newHandlerName )
902 {
903 wxASSERT_MSG(FindHandlerInfoInThisClass(oldHandlerName),wxT("not existing handler") );
904 FindHandlerInfoInThisClass(oldHandlerName)->m_name = newHandlerName;
905 }
906
907 // ----------------------------------------------------------------------------
908 // wxGenericPropertyAccessor
909 // ----------------------------------------------------------------------------
910
911 struct wxGenericPropertyAccessor::wxGenericPropertyAccessorInternal
912 {
913 char filler;
914 };
915
916 wxGenericPropertyAccessor::wxGenericPropertyAccessor( const wxString& propertyName )
917 : wxPropertyAccessor( NULL, NULL, NULL, NULL )
918 {
919 m_data = new wxGenericPropertyAccessorInternal;
920 m_propertyName = propertyName;
921 m_getterName = wxT("Get")+propertyName;
922 m_setterName = wxT("Set")+propertyName;
923 }
924
925 wxGenericPropertyAccessor::~wxGenericPropertyAccessor()
926 {
927 delete m_data;
928 }
929
930 void wxGenericPropertyAccessor::SetProperty(wxObject *object, const wxAny &value) const
931 {
932 wxDynamicObject* dynobj = wx_dynamic_cast(wxDynamicObject*, object);
933 wxASSERT_MSG( dynobj, wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") );
934 dynobj->SetProperty(m_propertyName.c_str(), value );
935 }
936
937 void wxGenericPropertyAccessor::GetProperty(const wxObject *object, wxAny& value) const
938 {
939 const wxDynamicObject* dynobj = wx_dynamic_cast( const wxDynamicObject * , object );
940 wxASSERT_MSG( dynobj, wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") );
941 value = dynobj->GetProperty( m_propertyName.c_str() );
942 }
943
944 // ----------------------------------------------------------------------------
945 // wxGenericPropertyAccessor
946 // ----------------------------------------------------------------------------
947
948 wxString wxAnyGetAsString( const wxAny& data)
949 {
950 if ( data.IsNull() || data.GetTypeInfo()==NULL )
951 return wxEmptyString;
952
953 wxString s;
954 data.GetTypeInfo()->ConvertToString(data,s);
955 return s;
956 }
957
958 const wxObject* wxAnyGetAsObjectPtr( const wxAny& data)
959 {
960 if ( !data.IsNull() )
961 {
962 const wxClassTypeInfo* ti = wx_dynamic_cast(const wxClassTypeInfo*, data.GetTypeInfo());
963 if( ti )
964 return ti->GetClassInfo()->AnyToObjectPtr(data);
965 }
966 return NULL;
967 }
968
969 wxObjectFunctor::~wxObjectFunctor()
970 {};
971
972 #endif // wxUSE_EXTENDED_RTTI