src/common/xtistrm.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/xtistrm.cpp
   3 // Purpose:     streaming runtime metadata information
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     27/07/03
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003 Stefan Csomor
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  13 #pragma implementation "xtistrm.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include "wx/hash.h"
  25 #include "wx/object.h"
  26 #endif
  27
  28 #include "wx/tokenzr.h"
  29 #include "wx/txtstrm.h"
  30 #include "wx/event.h"
  31
  32 #if wxUSE_EXTENDED_RTTI
  33
  34 #include "wx/xtistrm.h"
  35
  36 #include "wx/beforestd.h"
  37 #include <map>
  38 #include <vector>
  39 #include <string>
  40 #include "wx/afterstd.h"
  41
  42 using namespace std ;
  43
  44 struct wxWriter::wxWriterInternal
  45 {
  46     map< const wxObject* , int > m_writtenObjects ;
  47     int m_nextId ;
  48 } ;
  49
  50 wxWriter::wxWriter()
  51 {
  52     m_data = new wxWriterInternal ;
  53     m_data->m_nextId = 0 ;
  54 }
  55
  56 wxWriter::~wxWriter()
  57 {
  58     delete m_data ;
  59 }
  60
  61 struct wxWriter::wxWriterInternalPropertiesData
  62 {
  63     char nothing ;
  64 } ;
  65
  66 void wxWriter::ClearObjectContext()
  67 {
  68     delete m_data ;
  69     m_data = new wxWriterInternal() ;
  70     m_data->m_nextId = 0 ;
  71 }
  72
  73 void wxWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo , wxPersister *persister , const wxString &name , wxxVariantArray &metadata )
  74 {
  75     DoBeginWriteTopLevelEntry( name ) ;
  76     WriteObject( object , classInfo , persister , false , metadata) ;
  77     DoEndWriteTopLevelEntry( name ) ;
  78 }
  79
  80 void wxWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo , wxPersister *persister , bool isEmbedded, wxxVariantArray &metadata )
  81 {
  82     if ( !classInfo->BeforeWriteObject( object , this , persister , metadata) )
  83         return ;
  84
  85     if ( persister->BeforeWriteObject( this , object , classInfo , metadata) )
  86     {
  87         if ( object == NULL )
  88             DoWriteNullObject() ;
  89         else if ( IsObjectKnown( object ) )
  90             DoWriteRepeatedObject( GetObjectID(object) ) ;
  91         else
  92         {
  93             int oid = m_data->m_nextId++ ;
  94             if ( !isEmbedded )
  95                 m_data->m_writtenObjects[object] = oid ;
  96
  97             // in case this object is a wxDynamicObject we also have to insert is superclass
  98             // instance with the same id, so that object relations are streamed out correctly
  99             const wxDynamicObject* dynobj = dynamic_cast<const wxDynamicObject *>( object ) ;
 100             if ( !isEmbedded && dynobj )
 101                 m_data->m_writtenObjects[dynobj->GetSuperClassInstance()] = oid ;
 102
 103             DoBeginWriteObject( object , classInfo , oid , metadata ) ;
 104             wxWriterInternalPropertiesData data ;
 105             WriteAllProperties( object , classInfo , persister , &data ) ;
 106             DoEndWriteObject( object , classInfo , oid  ) ;
 107         }
 108         persister->AfterWriteObject( this ,object , classInfo ) ;
 109     }
 110 }
 111
 112 void wxWriter::FindConnectEntry(const wxEvtHandler * evSource,const wxDelegateTypeInfo* dti, const wxObject* &sink , const wxHandlerInfo *&handler)
 113 {
 114     wxList *dynamicEvents = evSource->GetDynamicEventTable() ;
 115
 116     if ( dynamicEvents )
 117     {
 118         wxList::compatibility_iterator node = dynamicEvents->GetFirst();
 119         while (node)
 120         {
 121             wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
 122
 123             // find the match
 124             if ( entry->m_fn &&
 125                 (dti->GetEventType() == entry->m_eventType) &&
 126                 (entry->m_id == -1 ) &&
 127                 (entry->m_eventSink != NULL ) )
 128             {
 129                 sink = entry->m_eventSink ;
 130                 const wxClassInfo* sinkClassInfo = sink->GetClassInfo() ;
 131                 const wxHandlerInfo* sinkHandler = sinkClassInfo->GetFirstHandler() ;
 132                 while ( sinkHandler )
 133                 {
 134                     if ( sinkHandler->GetEventFunction() == entry->m_fn )
 135                     {
 136                         handler = sinkHandler ;
 137                         break ;
 138                     }
 139                     sinkHandler = sinkHandler->GetNext() ;
 140                 }
 141                 break ;
 142             }
 143             node = node->GetNext();
 144         }
 145     }
 146 }
 147 void wxWriter::WriteAllProperties( const wxObject * obj , const wxClassInfo* ci , wxPersister *persister, wxWriterInternalPropertiesData * data )
 148 {
 149     wxPropertyInfoMap map ;
 150     ci->GetProperties( map ) ;
 151     for ( int i = 0 ; i < ci->GetCreateParamCount() ; ++i )
 152     {
 153         wxString name = ci->GetCreateParamName(i) ;
 154         const wxPropertyInfo* prop = map.find(name)->second ;
 155         wxASSERT_MSG( prop , wxT("Create Parameter not found in declared RTTI Parameters") ) ;
 156         WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
 157         map.erase( name ) ;
 158     }
 159
 160     for( wxPropertyInfoMap::iterator iter = map.begin() ; iter != map.end() ; ++iter )
 161     {
 162         const wxPropertyInfo* prop = iter->second ;
 163         if ( prop->GetFlags() & wxPROP_OBJECT_GRAPH )
 164         {
 165             WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
 166         }
 167     }
 168
 169     for( wxPropertyInfoMap::iterator iter = map.begin() ; iter != map.end() ; ++iter )
 170     {
 171         const wxPropertyInfo* prop = iter->second ;
 172         if ( !(prop->GetFlags() & wxPROP_OBJECT_GRAPH) )
 173         {
 174             WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
 175         }
 176     }
 177 }
 178
 179 void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , const wxPropertyInfo* pi , wxPersister *persister , wxWriterInternalPropertiesData *WXUNUSED(data) )
 180 {
 181     if ( pi->GetFlags() & wxPROP_DONT_STREAM )
 182         return ;
 183
 184     // make sure that we are picking the correct object for accessing the property
 185     const wxDynamicObject* dynobj = dynamic_cast< const wxDynamicObject* > (obj ) ;
 186     if ( dynobj && (dynamic_cast<const wxDynamicClassInfo*>(ci) == NULL) )
 187         obj = dynobj->GetSuperClassInstance() ;
 188
 189     if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION )
 190     {
 191         wxxVariantArray data ;
 192         pi->GetAccessor()->GetPropertyCollection(obj, data) ;
 193         const wxTypeInfo * elementType = dynamic_cast< const wxCollectionTypeInfo* >( pi->GetTypeInfo() )->GetElementType() ;
 194         for ( size_t i = 0 ; i < data.GetCount() ; ++i )
 195         {
 196             if ( i == 0 )
 197                 DoBeginWriteProperty( pi ) ;
 198
 199             DoBeginWriteElement() ;
 200             wxxVariant value = data[i] ;
 201             if ( persister->BeforeWriteProperty( this , obj, pi , value ) )
 202             {
 203                 const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( elementType ) ;
 204                 if ( cti )
 205                 {
 206                     const wxClassInfo* pci = cti->GetClassInfo() ;
 207                     wxObject *vobj = pci->VariantToInstance( value ) ;
 208                     wxxVariantArray md ;
 209                     WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT , md ) ;
 210                 }
 211                 else
 212                 {
 213                     DoWriteSimpleType( value ) ;
 214                 }
 215             }
 216             DoEndWriteElement() ;
 217             if ( i == data.GetCount() - 1 )
 218                  DoEndWriteProperty( pi ) ;
 219        }
 220    }
 221     else
 222     {
 223         const wxDelegateTypeInfo* dti = dynamic_cast< const wxDelegateTypeInfo* > ( pi->GetTypeInfo() ) ;
 224         if ( dti )
 225         {
 226             const wxObject* sink = NULL ;
 227             const wxHandlerInfo *handler = NULL ;
 228
 229             const wxEvtHandler * evSource = dynamic_cast<const wxEvtHandler *>(obj) ;
 230             wxASSERT_MSG( evSource , wxT("Illegal Object Class (Non-wxEvtHandler) as Event Source") ) ;
 231
 232             FindConnectEntry( evSource , dti , sink , handler ) ;
 233             if ( persister->BeforeWriteDelegate( this , obj , ci , pi , sink , handler ) )
 234             {
 235                 if ( sink != NULL && handler != NULL )
 236                 {
 237                     DoBeginWriteProperty( pi ) ;
 238                     wxASSERT_MSG( IsObjectKnown( sink ) , wxT("Streaming delegates for not already streamed objects not yet supported") ) ;
 239                     DoWriteDelegate( obj , ci , pi , sink , GetObjectID( sink ) , sink->GetClassInfo() , handler ) ;
 240                     DoEndWriteProperty( pi ) ;
 241                 }
 242             }
 243         }
 244         else
 245         {
 246             wxxVariant value ;
 247             pi->GetAccessor()->GetProperty(obj, value) ;
 248
 249             // avoid streaming out void objects
 250             if( value.IsEmpty() )
 251                 return ;
 252
 253             if ( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
 254             {
 255                 const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
 256                 wxASSERT_MSG( eti , wxT("Type must have enum - long conversion") ) ;
 257                 eti->ConvertFromLong( value.Get<long>() , value ) ;
 258             }
 259
 260             // avoid streaming out default values
 261             if ( pi->GetTypeInfo()->HasStringConverters() && !pi->GetDefaultValue().IsEmpty() )
 262             {
 263                 if ( value.GetAsString() == pi->GetDefaultValue().GetAsString() )
 264                     return ;
 265             }
 266
 267             // avoid streaming out null objects
 268             const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( pi->GetTypeInfo() ) ;
 269
 270             if ( cti && value.GetAsObject() == NULL )
 271                 return ;
 272
 273             if ( persister->BeforeWriteProperty( this , obj, pi , value ) )
 274             {
 275                 DoBeginWriteProperty( pi ) ;
 276                 if ( cti )
 277                 {
 278                     const wxClassInfo* pci = cti->GetClassInfo() ;
 279                     wxObject *vobj = pci->VariantToInstance( value ) ;
 280                     if ( vobj && pi->GetTypeInfo()->HasStringConverters() )
 281                     {
 282                         wxString stringValue ;
 283                         cti->ConvertToString( value , stringValue ) ;
 284                         wxxVariant convertedValue(stringValue) ;
 285                         DoWriteSimpleType( convertedValue ) ;
 286                     }
 287                     else
 288                     {
 289                         wxxVariantArray md ;
 290                         WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT , md) ;
 291                     }
 292                 }
 293                 else
 294                 {
 295                     DoWriteSimpleType( value ) ;
 296                 }
 297                 DoEndWriteProperty( pi ) ;
 298             }
 299         }
 300     }
 301 }
 302
 303 int wxWriter::GetObjectID(const wxObject *obj)
 304 {
 305     if ( !IsObjectKnown( obj ) )
 306         return wxInvalidObjectID ;
 307
 308     return m_data->m_writtenObjects[obj] ;
 309 }
 310
 311 bool wxWriter::IsObjectKnown( const wxObject *obj )
 312 {
 313     return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end() ;
 314 }
 315
 316
 317 // ----------------------------------------------------------------------------
 318 // reading objects in
 319 // ----------------------------------------------------------------------------
 320
 321 struct wxReader::wxReaderInternal
 322 {
 323     map<int,wxClassInfo*> m_classInfos;
 324 };
 325
 326 wxReader::wxReader()
 327 {
 328     m_data = new wxReaderInternal;
 329 }
 330
 331 wxReader::~wxReader()
 332 {
 333     delete m_data;
 334 }
 335
 336 wxClassInfo* wxReader::GetObjectClassInfo(int objectID)
 337 {
 338     assert( m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() );
 339     return m_data->m_classInfos[objectID] ;
 340 }
 341
 342 void wxReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo )
 343 {
 344     assert(  m_data->m_classInfos.find(objectID) == m_data->m_classInfos.end()  ) ;
 345     m_data->m_classInfos[objectID] = classInfo ;
 346 }
 347
 348 bool wxReader::HasObjectClassInfo( int objectID )
 349 {
 350     return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() ;
 351 }
 352
 353
 354 // ----------------------------------------------------------------------------
 355 // reading xml in
 356 // ----------------------------------------------------------------------------
 357
 358 /*
 359 Reading components has not to be extended for components
 360 as properties are always sought by typeinfo over all levels
 361 and create params are always toplevel class only
 362 */
 363
 364
 365 // ----------------------------------------------------------------------------
 366 // depersisting to memory
 367 // ----------------------------------------------------------------------------
 368
 369 struct wxRuntimeDepersister::wxRuntimeDepersisterInternal
 370 {
 371     map<int,wxObject *> m_objects;
 372
 373     void SetObject(int objectID, wxObject *obj )
 374     {
 375         assert(  m_objects.find(objectID) == m_objects.end()  ) ;
 376         m_objects[objectID] = obj ;
 377     }
 378     wxObject* GetObject( int objectID )
 379     {
 380         if ( objectID == wxNullObjectID )
 381             return NULL ;
 382
 383         assert(  m_objects.find(objectID) != m_objects.end()  ) ;
 384         return m_objects[objectID] ;
 385     }
 386 } ;
 387
 388 wxRuntimeDepersister::wxRuntimeDepersister()
 389 {
 390     m_data = new wxRuntimeDepersisterInternal() ;
 391 }
 392
 393 wxRuntimeDepersister::~wxRuntimeDepersister()
 394 {
 395     delete m_data ;
 396 }
 397
 398 void wxRuntimeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo ,
 399                                           wxxVariantArray &WXUNUSED(metadata))
 400 {
 401     wxObject *O;
 402     O = classInfo->CreateObject();
 403     m_data->SetObject(objectID, O);
 404 }
 405
 406 void wxRuntimeDepersister::CreateObject(int objectID,
 407                                         const wxClassInfo *classInfo,
 408                                         int paramCount,
 409                                         wxxVariant *params,
 410                                         int *objectIdValues,
 411                                         const wxClassInfo **objectClassInfos ,
 412                                         wxxVariantArray &WXUNUSED(metadata))
 413 {
 414     wxObject *o;
 415     o = m_data->GetObject(objectID);
 416     for ( int i = 0 ; i < paramCount ; ++i )
 417     {
 418         if ( objectIdValues[i] != wxInvalidObjectID )
 419         {
 420             wxObject *o;
 421             o = m_data->GetObject(objectIdValues[i]);
 422             // if this is a dynamic object and we are asked for another class
 423             // than wxDynamicObject we cast it down manually.
 424             wxDynamicObject *dyno = dynamic_cast< wxDynamicObject * > (o) ;
 425             if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
 426             {
 427                 o = dyno->GetSuperClassInstance() ;
 428             }
 429             params[i] = objectClassInfos[i]->InstanceToVariant(o) ;
 430         }
 431     }
 432     classInfo->Create(o, paramCount, params);
 433 }
 434
 435 void wxRuntimeDepersister::ConstructObject(int objectID,
 436                                         const wxClassInfo *classInfo,
 437                                         int paramCount,
 438                                         wxxVariant *params,
 439                                         int *objectIdValues,
 440                                         const wxClassInfo **objectClassInfos ,
 441                                         wxxVariantArray &WXUNUSED(metadata))
 442 {
 443     wxObject *o;
 444     for ( int i = 0 ; i < paramCount ; ++i )
 445     {
 446         if ( objectIdValues[i] != wxInvalidObjectID )
 447         {
 448             wxObject *o;
 449             o = m_data->GetObject(objectIdValues[i]);
 450             // if this is a dynamic object and we are asked for another class
 451             // than wxDynamicObject we cast it down manually.
 452             wxDynamicObject *dyno = dynamic_cast< wxDynamicObject * > (o) ;
 453             if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
 454             {
 455                 o = dyno->GetSuperClassInstance() ;
 456             }
 457             params[i] = objectClassInfos[i]->InstanceToVariant(o) ;
 458         }
 459     }
 460     o = classInfo->ConstructObject(paramCount, params);
 461     m_data->SetObject(objectID, o);
 462 }
 463
 464
 465 void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
 466 {
 467     wxObject *o;
 468     o = m_data->GetObject(objectID);
 469     delete o ;
 470 }
 471
 472 void wxRuntimeDepersister::SetProperty(int objectID,
 473                                        const wxClassInfo *classInfo,
 474                                        const wxPropertyInfo* propertyInfo,
 475                                        const wxxVariant &value)
 476 {
 477     wxObject *o;
 478     o = m_data->GetObject(objectID);
 479     classInfo->SetProperty( o , propertyInfo->GetName() , value ) ;
 480 }
 481
 482 void wxRuntimeDepersister::SetPropertyAsObject(int objectID,
 483                                                const wxClassInfo *classInfo,
 484                                                const wxPropertyInfo* propertyInfo,
 485                                                int valueObjectId)
 486 {
 487     wxObject *o, *valo;
 488     o = m_data->GetObject(objectID);
 489     valo = m_data->GetObject(valueObjectId);
 490     const wxClassInfo* valClassInfo = (dynamic_cast<const wxClassTypeInfo*>(propertyInfo->GetTypeInfo()))->GetClassInfo() ;
 491     // if this is a dynamic object and we are asked for another class
 492     // than wxDynamicObject we cast it down manually.
 493     wxDynamicObject *dynvalo = dynamic_cast< wxDynamicObject * > (valo) ;
 494     if ( dynvalo!=NULL  && (valClassInfo != dynvalo->GetClassInfo()) )
 495     {
 496         valo = dynvalo->GetSuperClassInstance() ;
 497     }
 498
 499     classInfo->SetProperty( o , propertyInfo->GetName() , valClassInfo->InstanceToVariant(valo) ) ;
 500 }
 501
 502 void wxRuntimeDepersister::SetConnect(int eventSourceObjectID,
 503                                       const wxClassInfo *WXUNUSED(eventSourceClassInfo),
 504                                       const wxPropertyInfo *delegateInfo ,
 505                                       const wxClassInfo *WXUNUSED(eventSinkClassInfo) ,
 506                                       const wxHandlerInfo* handlerInfo ,
 507                                       int eventSinkObjectID )
 508 {
 509     wxEvtHandler *ehsource = dynamic_cast< wxEvtHandler* >( m_data->GetObject( eventSourceObjectID ) ) ;
 510     wxEvtHandler *ehsink = dynamic_cast< wxEvtHandler *>(m_data->GetObject(eventSinkObjectID) ) ;
 511
 512     if ( ehsource && ehsink )
 513     {
 514         const wxDelegateTypeInfo *delegateTypeInfo = dynamic_cast<const wxDelegateTypeInfo*>(delegateInfo->GetTypeInfo());
 515         if( delegateTypeInfo && delegateTypeInfo->GetLastEventType() == -1 )
 516         {
 517             ehsource->Connect( -1 , delegateTypeInfo->GetEventType() ,
 518                 handlerInfo->GetEventFunction() , NULL /*user data*/ ,
 519                 ehsink ) ;
 520         }
 521         else
 522         {
 523             for ( wxEventType iter = delegateTypeInfo->GetEventType() ; iter <= delegateTypeInfo->GetLastEventType() ; ++iter )
 524             {
 525                 ehsource->Connect( -1 , iter ,
 526                     handlerInfo->GetEventFunction() , NULL /*user data*/ ,
 527                     ehsink ) ;
 528             }
 529         }
 530     }
 531 }
 532
 533 wxObject *wxRuntimeDepersister::GetObject(int objectID)
 534 {
 535     return m_data->GetObject( objectID ) ;
 536 }
 537
 538 // adds an element to a property collection
 539 void wxRuntimeDepersister::AddToPropertyCollection( int objectID ,
 540                                                    const wxClassInfo *classInfo,
 541                                                    const wxPropertyInfo* propertyInfo ,
 542                                                    const wxxVariant &value)
 543 {
 544     wxObject *o;
 545     o = m_data->GetObject(objectID);
 546     classInfo->AddToPropertyCollection( o , propertyInfo->GetName() , value ) ;
 547 }
 548
 549 // sets the corresponding property (value is an object)
 550 void wxRuntimeDepersister::AddToPropertyCollectionAsObject(int objectID,
 551                                                            const wxClassInfo *classInfo,
 552                                                            const wxPropertyInfo* propertyInfo ,
 553                                                            int valueObjectId)
 554 {
 555     wxObject *o, *valo;
 556     o = m_data->GetObject(objectID);
 557     valo = m_data->GetObject(valueObjectId);
 558     const wxCollectionTypeInfo * collectionTypeInfo = dynamic_cast< const wxCollectionTypeInfo * >(propertyInfo->GetTypeInfo() ) ;
 559     const wxClassInfo* valClassInfo = (dynamic_cast<const wxClassTypeInfo*>(collectionTypeInfo->GetElementType()))->GetClassInfo() ;
 560     // if this is a dynamic object and we are asked for another class
 561     // than wxDynamicObject we cast it down manually.
 562     wxDynamicObject *dynvalo = dynamic_cast< wxDynamicObject * > (valo) ;
 563     if ( dynvalo!=NULL  && (valClassInfo != dynvalo->GetClassInfo()) )
 564     {
 565         valo = dynvalo->GetSuperClassInstance() ;
 566     }
 567
 568     classInfo->AddToPropertyCollection( o , propertyInfo->GetName() , valClassInfo->InstanceToVariant(valo) ) ;
 569 }
 570
 571 // ----------------------------------------------------------------------------
 572 // depersisting to code
 573 // ----------------------------------------------------------------------------
 574
 575 struct wxCodeDepersister::wxCodeDepersisterInternal
 576 {
 577 #if wxUSE_UNICODE
 578     map<int,wstring> m_objectNames ;
 579 #else
 580     map<int,string> m_objectNames ;
 581 #endif
 582
 583     void SetObjectName(int objectID, const wxString &name )
 584     {
 585         assert(  m_objectNames.find(objectID) == m_objectNames.end()  ) ;
 586         m_objectNames[objectID] = (const wxChar *)name;
 587     }
 588     wxString GetObjectName( int objectID )
 589     {
 590         if ( objectID == wxNullObjectID )
 591             return wxT("NULL") ;
 592
 593         assert(  m_objectNames.find(objectID) != m_objectNames.end()  ) ;
 594         return wxString( m_objectNames[objectID].c_str() ) ;
 595     }
 596 } ;
 597
 598 wxCodeDepersister::wxCodeDepersister(wxTextOutputStream *out)
 599 : m_fp(out)
 600 {
 601     m_data = new wxCodeDepersisterInternal ;
 602 }
 603
 604 wxCodeDepersister::~wxCodeDepersister()
 605 {
 606     delete m_data ;
 607 }
 608
 609 void wxCodeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo ,
 610                                        wxxVariantArray &WXUNUSED(metadata))
 611 {
 612     wxString objectName = wxString::Format( wxT("LocalObject_%d") , objectID ) ;
 613     m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s;\n"),
 614         classInfo->GetClassName(),
 615         objectName.c_str(),
 616         classInfo->GetClassName()) );
 617     m_data->SetObjectName( objectID , objectName ) ;
 618 }
 619
 620 void wxCodeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
 621 {
 622     m_fp->WriteString( wxString::Format( wxT("\tdelete %s;\n"),
 623         m_data->GetObjectName( objectID).c_str() ) );
 624 }
 625
 626 wxString wxCodeDepersister::ValueAsCode( const wxxVariant &param )
 627 {
 628     wxString value ;
 629     const wxTypeInfo* type = param.GetTypeInfo() ;
 630     if ( type->GetKind() == wxT_CUSTOM )
 631     {
 632         const wxCustomTypeInfo* cti = dynamic_cast<const wxCustomTypeInfo*>(type) ;
 633         wxASSERT_MSG( cti , wxT("Internal error, illegal wxCustomTypeInfo") ) ;
 634         value.Printf( wxT("%s(%s)"), cti->GetTypeName().c_str(),param.GetAsString().c_str() );
 635     }
 636     else if ( type->GetKind() == wxT_STRING )
 637     {
 638         value.Printf( wxT("\"%s\""),param.GetAsString().c_str() );
 639     }
 640     else
 641     {
 642         value.Printf( wxT("%s"), param.GetAsString().c_str() );
 643     }
 644     return value ;
 645 }
 646
 647 void wxCodeDepersister::CreateObject(int objectID,
 648                                      const wxClassInfo *WXUNUSED(classInfo),
 649                                      int paramCount,
 650                                      wxxVariant *params,
 651                                      int *objectIDValues,
 652                                      const wxClassInfo **WXUNUSED(objectClassInfos) ,
 653                                      wxxVariantArray &WXUNUSED(metadata)
 654                                      )
 655 {
 656     int i;
 657     m_fp->WriteString( wxString::Format( wxT("\t%s->Create("), m_data->GetObjectName(objectID).c_str() ) );
 658     for (i = 0; i < paramCount; i++)
 659     {
 660         if ( objectIDValues[i] != wxInvalidObjectID )
 661             m_fp->WriteString( wxString::Format( wxT("%s"), m_data->GetObjectName( objectIDValues[i] ).c_str() ) );
 662         else
 663         {
 664             m_fp->WriteString( wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
 665         }
 666         if (i < paramCount - 1)
 667             m_fp->WriteString( wxT(", "));
 668     }
 669     m_fp->WriteString( wxT(");\n") );
 670 }
 671
 672 void wxCodeDepersister::ConstructObject(int objectID,
 673                                      const wxClassInfo *classInfo,
 674                                      int paramCount,
 675                                      wxxVariant *params,
 676                                      int *objectIDValues,
 677                                      const wxClassInfo **WXUNUSED(objectClassInfos) ,
 678                                      wxxVariantArray &WXUNUSED(metadata)
 679                                      )
 680 {
 681     wxString objectName = wxString::Format( wxT("LocalObject_%d") , objectID ) ;
 682     m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s("),
 683         classInfo->GetClassName(),
 684         objectName.c_str(),
 685         classInfo->GetClassName()) );
 686     m_data->SetObjectName( objectID , objectName ) ;
 687
 688     int i;
 689     for (i = 0; i < paramCount; i++)
 690     {
 691         if ( objectIDValues[i] != wxInvalidObjectID )
 692             m_fp->WriteString( wxString::Format( wxT("%s"), m_data->GetObjectName( objectIDValues[i] ).c_str() ) );
 693         else
 694         {
 695             m_fp->WriteString( wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
 696         }
 697         if (i < paramCount - 1)
 698             m_fp->WriteString( wxT(", ") );
 699     }
 700     m_fp->WriteString( wxT(");\n") );
 701 }
 702
 703 void wxCodeDepersister::SetProperty(int objectID,
 704                                     const wxClassInfo *WXUNUSED(classInfo),
 705                                     const wxPropertyInfo* propertyInfo,
 706                                     const wxxVariant &value)
 707 {
 708     m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
 709         m_data->GetObjectName(objectID).c_str(),
 710         propertyInfo->GetAccessor()->GetSetterName().c_str(),
 711         ValueAsCode(value).c_str()) );
 712 }
 713
 714 void wxCodeDepersister::SetPropertyAsObject(int objectID,
 715                                             const wxClassInfo *WXUNUSED(classInfo),
 716                                             const wxPropertyInfo* propertyInfo,
 717                                             int valueObjectId)
 718 {
 719     if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT )
 720         m_fp->WriteString( wxString::Format( wxT("\t%s->%s(*%s);\n"),
 721         m_data->GetObjectName(objectID).c_str(),
 722         propertyInfo->GetAccessor()->GetSetterName().c_str(),
 723         m_data->GetObjectName( valueObjectId).c_str() ) );
 724     else
 725         m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
 726         m_data->GetObjectName(objectID).c_str(),
 727         propertyInfo->GetAccessor()->GetSetterName().c_str(),
 728         m_data->GetObjectName( valueObjectId).c_str() ) );
 729 }
 730
 731 void wxCodeDepersister::AddToPropertyCollection( int objectID ,
 732                                                 const wxClassInfo *WXUNUSED(classInfo),
 733                                                 const wxPropertyInfo* propertyInfo ,
 734                                                 const wxxVariant &value)
 735 {
 736     m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
 737         m_data->GetObjectName(objectID).c_str(),
 738         propertyInfo->GetAccessor()->GetAdderName().c_str(),
 739         ValueAsCode(value).c_str()) );
 740 }
 741
 742 // sets the corresponding property (value is an object)
 743 void wxCodeDepersister::AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
 744                                                         const wxClassInfo *WXUNUSED(classInfo),
 745                                                         const wxPropertyInfo* WXUNUSED(propertyInfo) ,
 746                                                         int WXUNUSED(valueObjectId))
 747 {
 748     // TODO
 749 }
 750
 751 void wxCodeDepersister::SetConnect(int eventSourceObjectID,
 752                                    const wxClassInfo *WXUNUSED(eventSourceClassInfo),
 753                                    const wxPropertyInfo *delegateInfo ,
 754                                    const wxClassInfo *eventSinkClassInfo ,
 755                                    const wxHandlerInfo* handlerInfo ,
 756                                    int eventSinkObjectID )
 757 {
 758     wxString ehsource = m_data->GetObjectName( eventSourceObjectID ) ;
 759     wxString ehsink = m_data->GetObjectName(eventSinkObjectID) ;
 760     wxString ehsinkClass = eventSinkClassInfo->GetClassName() ;
 761     const wxDelegateTypeInfo *delegateTypeInfo = dynamic_cast<const wxDelegateTypeInfo*>(delegateInfo->GetTypeInfo());
 762     wxASSERT_MSG(delegateTypeInfo, "delegate has no type info");
 763     int eventType = delegateTypeInfo->GetEventType() ;
 764     wxString handlerName = handlerInfo->GetName() ;
 765
 766     m_fp->WriteString( wxString::Format(  wxT("\t%s->Connect( %s->GetId() , %d , (wxObjectEventFunction)(wxEventFunction) & %s::%s , NULL , %s ) ;") ,
 767         ehsource.c_str() , ehsource.c_str() , eventType , ehsinkClass.c_str() , handlerName.c_str() , ehsink.c_str() ) );
 768 }
 769
 770 #include <wx/arrimpl.cpp>
 771
 772 WX_DEFINE_OBJARRAY(wxxVariantArray);
 773
 774 #endif