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 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  14 #pragma implementation "xti.h"
  15 #endif
  16
  17 // For compilers that support precompilation, includes "wx.h".
  18 #include "wx/wxprec.h"
  19
  20 #ifdef __BORLANDC__
  21 #pragma hdrstop
  22 #endif
  23
  24 #ifndef WX_PRECOMP
  25     #include "wx/hash.h"
  26     #include "wx/object.h"
  27 #endif
  28
  29 #include "wx/xml/xml.h"
  30 #include "wx/tokenzr.h"
  31 #include "wx/list.h"
  32 #include <string.h>
  33
  34 #if wxUSE_EXTENDED_RTTI
  35
  36 #include "wx/beforestd.h"
  37 #include <map>
  38 #include <string>
  39 #include "wx/afterstd.h"
  40
  41 using namespace std ;
  42
  43 // ----------------------------------------------------------------------------
  44 // Enum Support
  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)
  55 {
  56     int i;
  57     for (i = 0; m_members[i].m_name ; i++ )
  58         {
  59                 if (!strcmp(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)
  70 {
  71     int i;
  72     for (i = 0; m_members[i].m_name ; i++ )
  73         {
  74                 if (!strcmp(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)
  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 wxT("") ;
  90 }
  91
  92 int wxEnumData::GetEnumMemberValueByIndex( int idx )
  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 char * wxEnumData::GetEnumMemberNameByIndex( int idx )
  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 // value streaming
 109 // ----------------------------------------------------------------------------
 110
 111 // streamer specializations
 112 // for all built-in types
 113
 114 // bool
 115
 116 template<> void wxStringReadValue(const wxString &s , bool &data )
 117 {
 118         int intdata ;
 119         wxSscanf(s, _T("%d"), &intdata ) ;
 120         data = bool(intdata) ;
 121 }
 122
 123 template<> void wxStringWriteValue(wxString &s , const bool &data )
 124 {
 125         s = wxString::Format("%d", data ) ;
 126 }
 127
 128 // char
 129
 130 template<> void wxStringReadValue(const wxString &s , char &data )
 131 {
 132         int intdata ;
 133         wxSscanf(s, _T("%d"), &intdata ) ;
 134         data = char(intdata) ;
 135 }
 136
 137 template<> void wxStringWriteValue(wxString &s , const char &data )
 138 {
 139         s = wxString::Format("%d", data ) ;
 140 }
 141
 142 // unsigned char
 143
 144 template<> void wxStringReadValue(const wxString &s , unsigned char &data )
 145 {
 146         int intdata ;
 147         wxSscanf(s, _T("%d"), &intdata ) ;
 148         data = (unsigned char)(intdata) ;
 149 }
 150
 151 template<> void wxStringWriteValue(wxString &s , const unsigned char &data )
 152 {
 153         s = wxString::Format("%d", data ) ;
 154 }
 155
 156 // int
 157
 158 template<> void wxStringReadValue(const wxString &s , int &data )
 159 {
 160         wxSscanf(s, _T("%d"), &data ) ;
 161 }
 162
 163 template<> void wxStringWriteValue(wxString &s , const int &data )
 164 {
 165         s = wxString::Format("%d", data ) ;
 166 }
 167
 168 // unsigned int
 169
 170 template<> void wxStringReadValue(const wxString &s , unsigned int &data )
 171 {
 172         wxSscanf(s, _T("%d"), &data ) ;
 173 }
 174
 175 template<> void wxStringWriteValue(wxString &s , const unsigned int &data )
 176 {
 177         s = wxString::Format("%d", data ) ;
 178 }
 179
 180 // long
 181
 182 template<> void wxStringReadValue(const wxString &s , long &data )
 183 {
 184         wxSscanf(s, _T("%ld"), &data ) ;
 185 }
 186
 187 template<> void wxStringWriteValue(wxString &s , const long &data )
 188 {
 189         s = wxString::Format("%ld", data ) ;
 190 }
 191
 192 // unsigned long
 193
 194 template<> void wxStringReadValue(const wxString &s , unsigned long &data )
 195 {
 196         wxSscanf(s, _T("%ld"), &data ) ;
 197 }
 198
 199 template<> void wxStringWriteValue(wxString &s , const unsigned long &data )
 200 {
 201         s = wxString::Format("%ld", data ) ;
 202 }
 203
 204 // float
 205
 206 template<> void wxStringReadValue(const wxString &s , float &data )
 207 {
 208         wxSscanf(s, _T("%f"), &data ) ;
 209 }
 210
 211 template<> void wxStringWriteValue(wxString &s , const float &data )
 212 {
 213         s = wxString::Format("%f", data ) ;
 214 }
 215
 216 // double
 217
 218 template<> void wxStringReadValue(const wxString &s , double &data )
 219 {
 220         wxSscanf(s, _T("%lf"), &data ) ;
 221 }
 222
 223 template<> void wxStringWriteValue(wxString &s , const double &data )
 224 {
 225         s = wxString::Format("%lf", data ) ;
 226 }
 227
 228 // wxString
 229
 230 template<> void wxStringReadValue(const wxString &s , wxString &data )
 231 {
 232         data = s ;
 233 }
 234
 235 template<> void wxStringWriteValue(wxString &s , const wxString &data )
 236 {
 237         s = data ;
 238 }
 239
 240 // built-ins
 241 //
 242
 243 template<> const wxTypeInfo* wxGetTypeInfo( void * )
 244 {
 245         static wxBuiltInTypeInfo s_typeInfo( wxT_VOID ) ;
 246         return &s_typeInfo ;
 247 }
 248
 249 template<> const wxTypeInfo* wxGetTypeInfo( bool * )
 250 {
 251         static wxBuiltInTypeInfo s_typeInfo( wxT_BOOL , &wxToStringConverter<bool> , &wxFromStringConverter<bool>) ;
 252         return &s_typeInfo ;
 253 }
 254
 255 template<> const wxTypeInfo* wxGetTypeInfo( char * )
 256 {
 257         static wxBuiltInTypeInfo s_typeInfo( wxT_CHAR , &wxToStringConverter<char> , &wxFromStringConverter<char>) ;
 258         return &s_typeInfo ;
 259 }
 260
 261 template<> const wxTypeInfo* wxGetTypeInfo( unsigned char * )
 262 {
 263         static wxBuiltInTypeInfo s_typeInfo( wxT_UCHAR , &wxToStringConverter< unsigned char > , &wxFromStringConverter<unsigned char>) ;
 264         return &s_typeInfo ;
 265 }
 266
 267 template<> const wxTypeInfo* wxGetTypeInfo( int * )
 268 {
 269         static wxBuiltInTypeInfo s_typeInfo( wxT_CHAR , &wxToStringConverter<int> , &wxFromStringConverter<int>) ;
 270         return &s_typeInfo ;
 271 }
 272
 273 template<> const wxTypeInfo* wxGetTypeInfo( unsigned int * )
 274 {
 275         static wxBuiltInTypeInfo s_typeInfo( wxT_UCHAR , &wxToStringConverter<unsigned int> , &wxFromStringConverter<unsigned int>) ;
 276         return &s_typeInfo ;
 277 }
 278
 279 template<> const wxTypeInfo* wxGetTypeInfo( long * )
 280 {
 281         static wxBuiltInTypeInfo s_typeInfo( wxT_LONG , &wxToStringConverter<long> , &wxFromStringConverter<long>) ;
 282         return &s_typeInfo ;
 283 }
 284
 285 template<> const wxTypeInfo* wxGetTypeInfo( unsigned long * )
 286 {
 287         static wxBuiltInTypeInfo s_typeInfo( wxT_ULONG , &wxToStringConverter<unsigned long> , &wxFromStringConverter<unsigned long>) ;
 288         return &s_typeInfo ;
 289 }
 290
 291 template<> const wxTypeInfo* wxGetTypeInfo( float * )
 292 {
 293         static wxBuiltInTypeInfo s_typeInfo( wxT_FLOAT , &wxToStringConverter<float> , &wxFromStringConverter<float>) ;
 294         return &s_typeInfo ;
 295 }
 296
 297 template<> const wxTypeInfo* wxGetTypeInfo( double * )
 298 {
 299         static wxBuiltInTypeInfo s_typeInfo( wxT_DOUBLE , &wxToStringConverter<double> , &wxFromStringConverter<double>) ;
 300         return &s_typeInfo ;
 301 }
 302
 303 template<> const wxTypeInfo* wxGetTypeInfo( wxString * )
 304 {
 305         static wxBuiltInTypeInfo s_typeInfo( wxT_STRING , &wxToStringConverter<wxString> , &wxFromStringConverter<wxString>) ;
 306         return &s_typeInfo ;
 307 }
 308
 309 // this are compiler induced specialization which are never used anywhere
 310
 311 WX_ILLEGAL_TYPE_SPECIALIZATION( char const * )
 312 WX_ILLEGAL_TYPE_SPECIALIZATION( char * )
 313 WX_ILLEGAL_TYPE_SPECIALIZATION( unsigned char * )
 314 WX_ILLEGAL_TYPE_SPECIALIZATION( int * )
 315 WX_ILLEGAL_TYPE_SPECIALIZATION( bool * )
 316 WX_ILLEGAL_TYPE_SPECIALIZATION( long * )
 317 WX_ILLEGAL_TYPE_SPECIALIZATION( wxString * )
 318
 319 WX_COLLECTION_TYPE_INFO( wxString , wxArrayString ) ;
 320
 321 template<> void wxCollectionToVariantArray( wxArrayString const &theArray, wxxVariantArray &value)
 322 {
 323     wxArrayCollectionToVariantArray( theArray , value ) ;
 324 }
 325
 326 wxTypeInfoMap *wxTypeInfo::sm_typeTable = NULL ;
 327
 328 wxTypeInfo *wxTypeInfo::FindType(const wxChar *typeName)
 329 {
 330     return (wxTypeInfo *)sm_typeTable->find(typeName)->second;
 331 }
 332
 333 wxClassTypeInfo::wxClassTypeInfo( wxTypeKind kind , wxClassInfo* classInfo , converterToString_t to , converterFromString_t from ) :
 334 wxTypeInfo( kind , to , from , classInfo->GetClassName() )
 335 { wxASSERT_MSG( kind == wxT_OBJECT_PTR || kind == wxT_OBJECT , wxT("Illegal Kind for Enum Type")) ; m_classInfo = classInfo ;}
 336
 337 wxDelegateTypeInfo::wxDelegateTypeInfo( int eventType , wxClassInfo* eventClass , converterToString_t to , converterFromString_t from ) :
 338         wxTypeInfo ( wxT_DELEGATE , to , from , wxEmptyString )
 339     { m_eventClass = eventClass ; m_eventType = eventType ;}
 340
 341 void wxTypeInfo::Register()
 342 {
 343     if ( sm_typeTable == NULL )
 344         sm_typeTable = new wxTypeInfoMap() ;
 345
 346     if( !m_name.IsEmpty() )
 347         (*sm_typeTable)[m_name] = this ;
 348 }
 349
 350 void wxTypeInfo::Unregister()
 351 {
 352     if( !m_name.IsEmpty() )
 353         sm_typeTable->erase(m_name);
 354  }
 355
 356 // removing header dependancy on string tokenizer
 357
 358 void wxSetStringToArray( const wxString &s , wxArrayString &array )
 359 {
 360     wxStringTokenizer tokenizer(s, wxT("| \t\n"), wxTOKEN_STRTOK);
 361     wxString flag;
 362         array.Clear() ;
 363     while (tokenizer.HasMoreTokens())
 364     {
 365                 array.Add(tokenizer.GetNextToken()) ;
 366         }
 367 }
 368
 369 // ----------------------------------------------------------------------------
 370 // wxClassInfo
 371 // ----------------------------------------------------------------------------
 372
 373 const wxPropertyAccessor *wxClassInfo::FindAccessor(const char *PropertyName) const
 374 {
 375     const wxPropertyInfo* info = FindPropertyInfo( PropertyName ) ;
 376
 377         if ( info )
 378                 return info->GetAccessor() ;
 379
 380         return NULL ;
 381 }
 382
 383 const wxPropertyInfo *wxClassInfo::FindPropertyInfoInThisClass (const char *PropertyName) const
 384 {
 385         const wxPropertyInfo* info = GetFirstProperty() ;
 386
 387         while( info )
 388         {
 389                 if ( strcmp( info->GetName() , PropertyName ) == 0 )
 390                         return info ;
 391                 info = info->GetNext() ;
 392         }
 393
 394     return 0;
 395 }
 396
 397 const wxPropertyInfo *wxClassInfo::FindPropertyInfo (const char *PropertyName) const
 398 {
 399         const wxPropertyInfo* info = FindPropertyInfoInThisClass( PropertyName ) ;
 400     if ( info )
 401         return info ;
 402
 403         const wxClassInfo** parents = GetParents() ;
 404         for ( int i = 0 ; parents[i] ; ++ i )
 405         {
 406                 if ( ( info = parents[i]->FindPropertyInfo( PropertyName ) ) != NULL )
 407                         return info ;
 408         }
 409
 410     return 0;
 411 }
 412
 413 const wxHandlerInfo *wxClassInfo::FindHandlerInfoInThisClass (const char *PropertyName) const
 414 {
 415         const wxHandlerInfo* info = GetFirstHandler() ;
 416
 417         while( info )
 418         {
 419                 if ( strcmp( info->GetName() , PropertyName ) == 0 )
 420                         return info ;
 421                 info = info->GetNext() ;
 422         }
 423
 424     return 0;
 425 }
 426
 427 const wxHandlerInfo *wxClassInfo::FindHandlerInfo (const char *PropertyName) const
 428 {
 429         const wxHandlerInfo* info = FindHandlerInfoInThisClass( PropertyName ) ;
 430
 431     if ( info )
 432         return info ;
 433
 434         const wxClassInfo** parents = GetParents() ;
 435         for ( int i = 0 ; parents[i] ; ++ i )
 436         {
 437                 if ( ( info = parents[i]->FindHandlerInfo( PropertyName ) ) != NULL )
 438                         return info ;
 439         }
 440
 441     return 0;
 442 }
 443
 444 wxObjectStreamingCallback wxClassInfo::GetStreamingCallback() const
 445 {
 446     if ( m_streamingCallback )
 447         return m_streamingCallback ;
 448
 449     wxObjectStreamingCallback retval = NULL ;
 450         const wxClassInfo** parents = GetParents() ;
 451     for ( int i = 0 ; parents[i] && retval == NULL ; ++ i )
 452         {
 453         retval = parents[i]->GetStreamingCallback() ;
 454         }
 455     return retval ;
 456 }
 457
 458 bool wxClassInfo::BeforeWriteObject( const wxObject *obj, wxWriter *streamer , wxPersister *persister , wxxVariantArray &metadata) const
 459 {
 460     wxObjectStreamingCallback sb = GetStreamingCallback() ;
 461     if ( sb )
 462         return (*sb)(obj , streamer , persister , metadata ) ;
 463
 464     return true ;
 465 }
 466
 467 void wxClassInfo::SetProperty(wxObject *object, const char *propertyName, const wxxVariant &value) const
 468 {
 469     const wxPropertyAccessor *accessor;
 470
 471     accessor = FindAccessor(propertyName);
 472     wxASSERT(accessor->HasSetter());
 473         accessor->SetProperty( object , value ) ;
 474 }
 475
 476 wxxVariant wxClassInfo::GetProperty(wxObject *object, const char *propertyName) const
 477 {
 478     const wxPropertyAccessor *accessor;
 479
 480     accessor = FindAccessor(propertyName);
 481     wxASSERT(accessor->HasGetter());
 482     wxxVariant result ;
 483     accessor->GetProperty(object,result);
 484     return result ;
 485 }
 486
 487 wxxVariantArray wxClassInfo::GetPropertyCollection(wxObject *object, const wxChar *propertyName) const
 488 {
 489     const wxPropertyAccessor *accessor;
 490
 491     accessor = FindAccessor(propertyName);
 492     wxASSERT(accessor->HasGetter());
 493     wxxVariantArray result ;
 494     accessor->GetPropertyCollection(object,result);
 495     return result ;
 496 }
 497
 498 void wxClassInfo::AddToPropertyCollection(wxObject *object, const wxChar *propertyName , const wxxVariant& value) const
 499 {
 500     const wxPropertyAccessor *accessor;
 501
 502     accessor = FindAccessor(propertyName);
 503     wxASSERT(accessor->HasAdder());
 504     accessor->AddToPropertyCollection( object , value ) ;
 505 }
 506
 507 void wxClassInfo::GetProperties( wxPropertyInfoMap &map ) const
 508 {
 509     const wxPropertyInfo *pi = GetFirstProperty() ;
 510     while( pi )
 511     {
 512         if ( map.find( pi->GetName() ) == map.end() )
 513             map[pi->GetName()] = (wxPropertyInfo*) pi ;
 514
 515         pi = pi->GetNext() ;
 516     }
 517
 518     const wxClassInfo** parents = GetParents() ;
 519     for ( int i = 0 ; parents[i] ; ++ i )
 520     {
 521         parents[i]->GetProperties( map ) ;
 522     }
 523 }
 524
 525 /*
 526 VARIANT TO OBJECT
 527 */
 528
 529 wxObject* wxxVariant::GetAsObject()
 530 {
 531         const wxClassTypeInfo *ti = dynamic_cast<const wxClassTypeInfo*>( m_data->GetTypeInfo() ) ;
 532         if ( ti )
 533                 return ti->GetClassInfo()->VariantToInstance(*this) ;
 534         else
 535                 return NULL ;
 536 }
 537
 538 // ----------------------------------------------------------------------------
 539 // wxDynamicObject support
 540 // ----------------------------------------------------------------------------
 541 //
 542 // Dynamic Objects are objects that have a real superclass instance and carry their
 543 // own attributes in a hash map. Like this it is possible to create the objects and
 544 // stream them, as if their class information was already available from compiled data
 545
 546 struct wxDynamicObject::wxDynamicObjectInternal
 547 {
 548     map<string,wxxVariant> m_properties ;
 549 } ;
 550
 551 // instantiates this object with an instance of its superclass
 552 wxDynamicObject::wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info)
 553 {
 554     m_superClassInstance = superClassInstance ;
 555     m_classInfo = info ;
 556     m_data = new wxDynamicObjectInternal ;
 557 }
 558
 559 wxDynamicObject::~wxDynamicObject()
 560 {
 561     delete m_data ;
 562     delete m_superClassInstance ;
 563 }
 564
 565 void wxDynamicObject::SetProperty (const wxChar *propertyName, const wxxVariant &value)
 566 {
 567     wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),wxT("Accessing Unknown Property in a Dynamic Object") ) ;
 568     m_data->m_properties[propertyName] = value ;
 569 }
 570
 571 wxxVariant wxDynamicObject::GetProperty (const wxChar *propertyName) const
 572 {
 573    wxASSERT_MSG(m_classInfo->FindPropertyInfoInThisClass(propertyName),wxT("Accessing Unknown Property in a Dynamic Object") ) ;
 574    return m_data->m_properties[propertyName] ;
 575 }
 576
 577 // ----------------------------------------------------------------------------
 578 // wxDynamiClassInfo
 579 // ----------------------------------------------------------------------------
 580
 581 wxDynamicClassInfo::wxDynamicClassInfo( const wxChar *unitName, const wxChar *className , const wxClassInfo* superClass ) :
 582     wxClassInfo( unitName, className , new const wxClassInfo*[2])
 583 {
 584     GetParents()[0] = superClass ;
 585     GetParents()[1] = NULL ;
 586 }
 587
 588 wxDynamicClassInfo::~wxDynamicClassInfo()
 589 {
 590     delete[] GetParents() ;
 591 }
 592
 593 wxObject *wxDynamicClassInfo::AllocateObject() const
 594 {
 595     wxObject* parent = GetParents()[0]->AllocateObject() ;
 596     return new wxDynamicObject( parent , this ) ;
 597 }
 598
 599 void wxDynamicClassInfo::Create (wxObject *object, int paramCount, wxxVariant *params) const
 600 {
 601     wxDynamicObject *dynobj = dynamic_cast< wxDynamicObject *>( object ) ;
 602     wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::Create on an object other than wxDynamicObject") ) ;
 603     GetParents()[0]->Create( dynobj->GetSuperClassInstance() , paramCount , params ) ;
 604 }
 605
 606 // get number of parameters for constructor
 607 int wxDynamicClassInfo::GetCreateParamCount() const
 608 {
 609     return GetParents()[0]->GetCreateParamCount() ;
 610 }
 611
 612 // get i-th constructor parameter
 613 const wxChar* wxDynamicClassInfo::GetCreateParamName(int i) const
 614 {
 615     return GetParents()[0]->GetCreateParamName( i ) ;
 616 }
 617
 618 void wxDynamicClassInfo::SetProperty(wxObject *object, const char *propertyName, const wxxVariant &value) const
 619 {
 620     wxDynamicObject* dynobj = dynamic_cast< wxDynamicObject * >( object ) ;
 621     wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") ) ;
 622     if ( FindPropertyInfoInThisClass(propertyName) )
 623         dynobj->SetProperty( propertyName , value ) ;
 624     else
 625         GetParents()[0]->SetProperty( dynobj->GetSuperClassInstance() , propertyName , value ) ;
 626 }
 627
 628 wxxVariant wxDynamicClassInfo::GetProperty(wxObject *object, const char *propertyName) const
 629 {
 630     wxDynamicObject* dynobj = dynamic_cast< wxDynamicObject * >( object ) ;
 631     wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") ) ;
 632     if ( FindPropertyInfoInThisClass(propertyName) )
 633         return dynobj->GetProperty( propertyName ) ;
 634     else
 635         return GetParents()[0]->GetProperty( dynobj->GetSuperClassInstance() , propertyName ) ;
 636 }
 637
 638 void wxDynamicClassInfo::AddProperty( const wxChar *propertyName , const wxTypeInfo* typeInfo )
 639 {
 640     new wxPropertyInfo( m_firstProperty , this , propertyName , typeInfo , new wxGenericPropertyAccessor( propertyName ) , wxxVariant() ) ;
 641 }
 642
 643 void wxDynamicClassInfo::AddHandler( const wxChar *handlerName , wxObjectEventFunction address , const wxClassInfo* eventClassInfo )
 644 {
 645     new wxHandlerInfo( m_firstHandler , handlerName , address , eventClassInfo ) ;
 646 }
 647
 648 // ----------------------------------------------------------------------------
 649 // wxGenericPropertyAccessor
 650 // ----------------------------------------------------------------------------
 651
 652 struct wxGenericPropertyAccessor::wxGenericPropertyAccessorInternal
 653 {
 654     char filler ;
 655 } ;
 656
 657 wxGenericPropertyAccessor::wxGenericPropertyAccessor( const wxString& propertyName )
 658 : wxPropertyAccessor( NULL , NULL , NULL , NULL )
 659 {
 660     m_data = new wxGenericPropertyAccessorInternal ;
 661     m_propertyName = propertyName ;
 662     m_getterName = wxT("Get")+propertyName ;
 663     m_setterName = wxT("Set")+propertyName ;
 664 }
 665
 666 wxGenericPropertyAccessor::~wxGenericPropertyAccessor()
 667 {
 668     delete m_data ;
 669 }
 670 void wxGenericPropertyAccessor::SetProperty(wxObject *object, const wxxVariant &value) const
 671 {
 672     wxDynamicObject* dynobj = dynamic_cast< wxDynamicObject * >( object ) ;
 673     wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") ) ;
 674     dynobj->SetProperty(m_propertyName , value ) ;
 675 }
 676
 677 void wxGenericPropertyAccessor::GetProperty(const wxObject *object, wxxVariant& value) const
 678 {
 679     const wxDynamicObject* dynobj = dynamic_cast< const wxDynamicObject * >( object ) ;
 680     wxASSERT_MSG( dynobj , wxT("cannot call wxDynamicClassInfo::SetProperty on an object other than wxDynamicObject") ) ;
 681     value = dynobj->GetProperty( m_propertyName ) ;
 682 }
 683 #endif