]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/xtistrm.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
correction for include name
[wxWidgets.git] / src / common / xtistrm.cpp
... / ...
CommitLineData
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
42using namespace std ;
43
44struct wxWriter::wxWriterInternal
45{
46 map< const wxObject* , int > m_writtenObjects ;
47 int m_nextId ;
48} ;
49
50wxWriter::wxWriter()
51{
52 m_data = new wxWriterInternal ;
53 m_data->m_nextId = 0 ;
54}
55
56wxWriter::~wxWriter()
57{
58 delete m_data ;
59}
60
61struct wxWriter::wxWriterInternalPropertiesData
62{
63 char nothing ;
64} ;
65
66void wxWriter::ClearObjectContext()
67{
68 delete m_data ;
69 m_data = new wxWriterInternal() ;
70 m_data->m_nextId = 0 ;
71}
72
73void 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
80void 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
112void 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}
147void 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
179void 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 , 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 , 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
303int wxWriter::GetObjectID(const wxObject *obj)
304{
305 if ( !IsObjectKnown( obj ) )
306 return wxInvalidObjectID ;
307
308 return m_data->m_writtenObjects[obj] ;
309}
310
311bool 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
321struct wxReader::wxReaderInternal
322{
323 map<int,wxClassInfo*> m_classInfos;
324};
325
326wxReader::wxReader()
327{
328 m_data = new wxReaderInternal;
329}
330
331wxReader::~wxReader()
332{
333 delete m_data;
334}
335
336wxClassInfo* 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
342void 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
348bool 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/*
359Reading components has not to be extended for components
360as properties are always sought by typeinfo over all levels
361and create params are always toplevel class only
362*/
363
364
365// ----------------------------------------------------------------------------
366// depersisting to memory
367// ----------------------------------------------------------------------------
368
369struct 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
388wxRuntimeDepersister::wxRuntimeDepersister()
389{
390 m_data = new wxRuntimeDepersisterInternal() ;
391}
392
393wxRuntimeDepersister::~wxRuntimeDepersister()
394{
395 delete m_data ;
396}
397
398void 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
406void 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
435void 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
465void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
466{
467 wxObject *o;
468 o = m_data->GetObject(objectID);
469 delete o ;
470}
471
472void 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
482void 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
502void wxRuntimeDepersister::SetConnect(int eventSourceObjectID,
503 const wxClassInfo *WXUNUSED(eventSourceClassInfo),
504 const wxDelegateTypeInfo *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 if( delegateInfo->GetLastEventType() == -1 )
515 {
516 ehsource->Connect( -1 , delegateInfo->GetEventType() ,
517 handlerInfo->GetEventFunction() , NULL /*user data*/ ,
518 ehsink ) ;
519 }
520 else
521 {
522 for ( wxEventType iter = delegateInfo->GetEventType() ; iter <= delegateInfo->GetLastEventType() ; ++iter )
523 {
524 ehsource->Connect( -1 , iter ,
525 handlerInfo->GetEventFunction() , NULL /*user data*/ ,
526 ehsink ) ;
527 }
528 }
529
530 }
531}
532
533wxObject *wxRuntimeDepersister::GetObject(int objectID)
534{
535 return m_data->GetObject( objectID ) ;
536}
537
538// adds an element to a property collection
539void 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)
550void 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
575struct 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
598wxCodeDepersister::wxCodeDepersister(wxTextOutputStream *out)
599: m_fp(out)
600{
601 m_data = new wxCodeDepersisterInternal ;
602}
603
604wxCodeDepersister::~wxCodeDepersister()
605{
606 delete m_data ;
607}
608
609void 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
620void 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
626wxString 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
647void 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
672void 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
703void 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
714void 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
731void 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)
743void wxCodeDepersister::AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
744 const wxClassInfo *WXUNUSED(classInfo),
745 const wxPropertyInfo* WXUNUSED(propertyInfo) ,
746 int WXUNUSED(valueObjectId))
747{
748 // TODO
749}
750
751void wxCodeDepersister::SetConnect(int eventSourceObjectID,
752 const wxClassInfo *WXUNUSED(eventSourceClassInfo),
753 const wxDelegateTypeInfo *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 int eventType = delegateInfo->GetEventType() ;
762 wxString handlerName = handlerInfo->GetName() ;
763
764 m_fp->WriteString( wxString::Format( wxT("\t%s->Connect( %s->GetId() , %d , (wxObjectEventFunction)(wxEventFunction) & %s::%s , NULL , %s ) ;") ,
765 ehsource.c_str() , ehsource.c_str() , eventType , ehsinkClass.c_str() , handlerName.c_str() , ehsink.c_str() ) );
766}
767
768#include <wx/arrimpl.cpp>
769
770WX_DEFINE_OBJARRAY(wxxVariantArray);
771
772#endif
wxWidgets (Impactor)