X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/70e881039bfeab2f3cdd42ea8093f7313c5623a6..fae7d1580972e42b6bfea83abbcc19000e34c1a7:/src/common/xtistrm.cpp?ds=sidebyside diff --git a/src/common/xtistrm.cpp b/src/common/xtistrm.cpp index 146dca7b48..ccc44b4360 100644 --- a/src/common/xtistrm.cpp +++ b/src/common/xtistrm.cpp @@ -9,7 +9,7 @@ // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ +#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) #pragma implementation "xtistrm.h" #endif @@ -21,8 +21,8 @@ #endif #ifndef WX_PRECOMP - #include "wx/hash.h" - #include "wx/object.h" +#include "wx/hash.h" +#include "wx/object.h" #endif #include "wx/xml/xml.h" @@ -31,502 +31,915 @@ #include "wx/txtstrm.h" #if wxUSE_EXTENDED_RTTI + +#include "wx/beforestd.h" #include #include #include +#include "wx/afterstd.h" using namespace std ; -// ---------------------------------------------------------------------------- -// streaming xml out -// ---------------------------------------------------------------------------- +struct wxWriter::wxWriterInternal +{ + map< const wxObject* , int > m_writtenObjects ; + int m_nextId ; +} ; -void WriteComponent(wxObject *Object, const wxClassInfo *ClassInfo, wxXmlNode *parent, const wxString& nodeName , int &nextId , map< wxObject* , int > &writtenObjects ) ; - -void WriteComponentProperties( wxObject* obj , const wxClassInfo* ci , wxXmlNode *onode , int &nextId, map< wxObject* , int > &writtenObjects, map< string , int > &writtenProperties) -{ - const wxPropertyInfo *pi = ci->GetFirstProperty() ; - while( pi ) - { - if ( writtenProperties.find( pi->GetName() ) == writtenProperties.end() ) - { - writtenProperties[ pi->GetName() ] = 1 ; - const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( pi->GetTypeInfo() ) ; - if ( cti ) - { - const wxClassInfo* pci = cti->GetClassInfo() ; - WriteComponent( pci->VariantToInstance( pi->GetAccessor()->GetProperty(obj) ) , pci , onode , pi->GetName() , nextId , writtenObjects ) ; - } - else - { - const wxDelegateTypeInfo* dti = dynamic_cast< const wxDelegateTypeInfo* > ( pi->GetTypeInfo() ) ; - if ( dti ) - { - // in which form should we stream out these ? - } - else - { - wxXmlNode *pnode; - pnode = new wxXmlNode(wxXML_ELEMENT_NODE, pi->GetName() ); - pi->GetAccessor()->WriteValue(pnode, obj ) ; - onode->AddChild(pnode); - } - } - } - pi = pi->GetNext() ; - } - const wxClassInfo** parents = ci->GetParents() ; - for ( int i = 0 ; parents[i] ; ++ i ) - { - WriteComponentProperties( obj , parents[i] , onode , nextId , writtenObjects , writtenProperties ) ; - } -} - -/* - Writing Components does have to take inheritance into account, that's why we are iterating - over our parents as well - */ - -void WriteComponent(wxObject *obj, const wxClassInfo *classInfo, wxXmlNode *parent, const wxString &nodeName) -{ - int nextid = 0 ; // 0 is the root element - map< wxObject* , int > writtenobjects ; - WriteComponent( obj , classInfo, parent, nodeName , nextid , writtenobjects ) ; -} - -void WriteComponent(wxObject *obj, const wxClassInfo *classInfo, wxXmlNode *parent, const wxString& nodeName , int &nextId, map< wxObject* , int > &writtenObjects ) -{ - map< string , int > writtenProperties ; - wxXmlNode *onode; - - onode = new wxXmlNode(wxXML_ELEMENT_NODE, nodeName); - - onode->AddProperty(wxString("class"), wxString(classInfo->GetClassName())); - if ( obj == NULL ) - { - wxXmlNode* nullnode = new wxXmlNode(wxXML_TEXT_NODE, wxEmptyString, "null"); - onode->AddChild(nullnode); - } - else - { - // if we have already written this object, just insert an id - if ( writtenObjects.find( obj ) != writtenObjects.end() ) - { - onode->AddProperty(wxString("id"), wxString::Format( "%d" , writtenObjects[obj] ) ); - } - else - { - int id = nextId++ ; - writtenObjects[obj] = id ; - onode->AddProperty(wxString("id"), wxString::Format( "%d" , id ) ); - WriteComponentProperties( obj , classInfo , onode , nextId , writtenObjects, writtenProperties) ; - } - } - - parent->AddChild(onode); +wxWriter::wxWriter() +{ + m_data = new wxWriterInternal ; + m_data->m_nextId = 0 ; } -// ---------------------------------------------------------------------------- -// reading xml in -// ---------------------------------------------------------------------------- +wxWriter::~wxWriter() +{ + delete m_data ; +} + +struct wxWriter::wxWriterInternalPropertiesData +{ + map< string , int > m_writtenProperties ; +} ; -wxxVariant wxReader::ReadPropertyValueNoAssign(wxXmlNode *Node, - wxClassInfo *ClassInfo, - const wxPropertyInfo * &pi , - wxIDepersist *Callbacks) +void wxWriter::ClearObjectContext() { - wxxVariant res; - int ChildID; + delete m_data ; + m_data = new wxWriterInternal() ; + m_data->m_nextId = 0 ; +} + +void wxWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo , wxPersister *persister , const wxString &name ) +{ + DoBeginWriteTopLevelEntry( name ) ; + WriteObject( object , classInfo , persister , false ) ; + DoEndWriteTopLevelEntry( name ) ; +} - // form is: - // value +void wxWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo , wxPersister *persister , bool isEmbedded) +{ + if ( persister->BeforeWriteObject( this , object , classInfo ) ) + { + if ( object == NULL ) + DoWriteNullObject() ; + else if ( IsObjectKnown( object ) ) + DoWriteRepeatedObject( GetObjectID(object) ) ; + else + { + int oid = m_data->m_nextId++ ; + if ( !isEmbedded ) + m_data->m_writtenObjects[object] = oid ; + + // in case this object is a wxDynamicObject we also have to insert is superclass + // instance with the same id, so that object relations are streamed out correctly + const wxDynamicObject* dynobj = dynamic_cast( object ) ; + if ( !isEmbedded && dynobj ) + m_data->m_writtenObjects[dynobj->GetSuperClassInstance()] = oid ; + + DoBeginWriteObject( object , classInfo , oid ) ; + wxWriterInternalPropertiesData data ; + WriteAllProperties( object , classInfo , persister , &data ) ; + DoEndWriteObject( object , classInfo , oid ) ; + } + persister->AfterWriteObject( this ,object , classInfo ) ; + } +} - //ISSUE: NULL component references are streamed out as "null" text - // node. This is not in keeping with the XML mindset. +void wxWriter::FindConnectEntry(const wxWindow * evSource,const wxDelegateTypeInfo* dti, const wxObject* &sink , const wxHandlerInfo *&handler) +{ + wxList *dynamicEvents = evSource->GetDynamicEventTable() ; - pi = ClassInfo->FindPropertyInfo(Node->GetName()); - if (!pi) + if ( dynamicEvents ) + { + wxList::compatibility_iterator node = dynamicEvents->GetFirst(); + while (node) + { + wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData(); + + // find the match + if ( entry->m_fn && (dti->GetEventType() == entry->m_eventType) && + (entry->m_id == -1 || + (entry->m_lastId == -1 && evSource->GetId() == entry->m_id) || + (entry->m_lastId != -1 && + (evSource->GetId() >= entry->m_id && evSource->GetId() <= entry->m_lastId) ) ) && + entry->m_eventSink + ) + { + sink = entry->m_eventSink ; + const wxClassInfo* sinkClassInfo = sink->GetClassInfo() ; + const wxHandlerInfo* sinkHandler = sinkClassInfo->GetFirstHandler() ; + while ( sinkHandler ) + { + if ( sinkHandler->GetEventFunction() == entry->m_fn ) + { + handler = sinkHandler ; + break ; + } + sinkHandler = sinkHandler->GetNext() ; + } + break ; + } + node = node->GetNext(); + } + } +} +void wxWriter::WriteAllProperties( const wxObject * obj , const wxClassInfo* ci , wxPersister *persister, wxWriterInternalPropertiesData * data ) +{ + const wxPropertyInfo *pi = ci->GetFirstProperty() ; + while( pi ) + { + // this property was not written yet in this object and we don't get a veto + if ( data->m_writtenProperties.find( pi->GetName() ) == data->m_writtenProperties.end() ) + { + data->m_writtenProperties[ pi->GetName() ] = 1 ; + DoBeginWriteProperty( pi ) ; + if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION ) + { + wxxVariantArray data = pi->GetAccessor()->GetPropertyCollection(obj) ; + const wxTypeInfo * elementType = dynamic_cast< const wxCollectionTypeInfo* >( pi->GetTypeInfo() )->GetElementType() ; + for ( size_t i = 0 ; i < data.GetCount() ; ++i ) + { + DoBeginWriteElement() ; + wxxVariant value = data[i] ; + if ( persister->BeforeWriteProperty( this , pi , value ) ) + { + const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( elementType ) ; + if ( cti ) + { + const wxClassInfo* pci = cti->GetClassInfo() ; + wxObject *vobj = pci->VariantToInstance( value ) ; + WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT ) ; + } + else + { + DoWriteSimpleType( value ) ; + } + } + DoEndWriteElement() ; + } + } + else + { + const wxDelegateTypeInfo* dti = dynamic_cast< const wxDelegateTypeInfo* > ( pi->GetTypeInfo() ) ; + if ( dti ) + { + const wxObject* sink = NULL ; + const wxHandlerInfo *handler = NULL ; + + const wxWindow * evSource = dynamic_cast(obj) ; + wxASSERT_MSG( evSource , wxT("Illegal Object Class (Non-Window) as Event Source") ) ; + + FindConnectEntry( evSource , dti , sink , handler ) ; + if ( persister->BeforeWriteDelegate( this , obj , ci , pi , sink , handler ) ) + { + if ( sink != NULL && handler != NULL ) + { + wxASSERT_MSG( IsObjectKnown( sink ) , wxT("Streaming delegates for not already streamed objects not yet supported") ) ; + DoWriteDelegate( obj , ci , pi , sink , GetObjectID( sink ) , sink->GetClassInfo() , handler ) ; + } + } + } + else + { + wxxVariant value = pi->GetAccessor()->GetProperty(obj) ; + if ( persister->BeforeWriteProperty( this , pi , value ) ) + { + const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( pi->GetTypeInfo() ) ; + if ( cti ) + { + const wxClassInfo* pci = cti->GetClassInfo() ; + wxObject *vobj = pci->VariantToInstance( value ) ; + WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT ) ; + } + else + { + DoWriteSimpleType( value ) ; + } + } + } + } + DoEndWriteProperty( pi ) ; + } + pi = pi->GetNext() ; + } + // in case this object is wxDynamic object we have to hand over the streaming + // of the properties of the superclasses to the real super class instance + const wxDynamicObject* dynobj = dynamic_cast< const wxDynamicObject* > (obj ) ; + if ( dynobj ) + obj = dynobj->GetSuperClassInstance() ; + const wxClassInfo** parents = ci->GetParents() ; + for ( int i = 0 ; parents[i] ; ++ i ) { - // error handling, please - assert(!"Property not found in extended class info"); + WriteAllProperties( obj , parents[i] , persister , data ) ; } +} + +int wxWriter::GetObjectID(const wxObject *obj) +{ + if ( !IsObjectKnown( obj ) ) + return wxInvalidObjectID ; - const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( pi->GetTypeInfo() ) ; - if ( cti ) - { - const wxClassInfo* eci = cti->GetClassInfo() ; - - ChildID = ReadComponent(Node , Callbacks); - if (ChildID != -1) - { - if (genCode) - res = wxxVariant(GetObjectName(ChildID)); - else - res = eci->InstanceToVariant(GetObject(ChildID)); - } - else - { - if (genCode) - res = wxxVariant(wxString("NULL")); - else - res = eci->InstanceToVariant(NULL); - } - } - else - { - const wxDelegateTypeInfo* dti = dynamic_cast< const wxDelegateTypeInfo* > ( pi->GetTypeInfo() ) ; - if ( dti ) - { - if (genCode) - { - // in which form should we code these ? - res = wxxVariant( wxXmlGetContentFromNode(Node) ) ; - } - else - { - res = wxxVariant( wxXmlGetContentFromNode(Node) ) ; - } - } - else - { - if (genCode) - { - if ( pi->GetTypeInfo()->GetKind() == wxT_STRING ) - res = wxxVariant( wxString::Format("wxString(\"%s\")",wxXmlGetContentFromNode(Node))); - else - res = wxxVariant( wxString::Format("%s(%s)",pi->GetTypeName(),wxXmlGetContentFromNode(Node) ) ); - } - else - res = pi->GetAccessor()->ReadValue(Node) ; - } - } - return res ; -} - -void wxReader::ReadPropertyValue(wxXmlNode *Node, - wxClassInfo *ClassInfo, - int ObjectID , - wxIDepersist *Callbacks) -{ - const wxPropertyInfo *pi; - wxxVariant res = ReadPropertyValueNoAssign( Node , ClassInfo, pi , Callbacks ) ; - - const wxDelegateTypeInfo* dti = dynamic_cast< const wxDelegateTypeInfo* > ( pi->GetTypeInfo() ) ; - - if ( dti ) - { - wxString resstring = res.Get() ; - wxInt32 pos = resstring.Find('.') ; - assert( pos != wxNOT_FOUND ) ; - int handlerOid = atol(resstring.Left(pos)) ; - wxString handlerName = resstring.Mid(pos+1) ; - - if (Callbacks) - Callbacks->SetConnect( ObjectID , ClassInfo , dti->GetEventType() , handlerName , handlerOid ) ; - } - else - { - if (Callbacks) - Callbacks->SetProperty(ObjectID, ClassInfo, pi , res); - } + return m_data->m_writtenObjects[obj] ; } -struct wxReader::wxReaderInternal +bool wxWriter::IsObjectKnown( const wxObject *obj ) { - /* - Code streamer will be storing names here. Runtime object streamer - will be storing actual pointers to objects here. The two are never - mixed. So the Objects array either has data, or the ObjectNames - array has data. Never both. Keyed by ObjectID (int) - */ - map Objects; - - map ObjectNames; - // only used when generating code, since the names loose the type info - map ObjectClasses; -}; + return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end() ; +} -wxReader::wxReader(bool GenerateCode) : genCode(GenerateCode) +// +// XML Streaming +// + +// convenience functions + +void wxXmlAddContentToNode( wxXmlNode* node , const wxString& data ) { - Data = new wxReaderInternal; + node->AddChild(new wxXmlNode(wxXML_TEXT_NODE, "value", data ) ); } -wxReader::~wxReader() +wxString wxXmlGetContentFromNode( wxXmlNode *node ) { - delete Data; + if ( node->GetChildren() ) + return node->GetChildren()->GetContent() ; + else + return wxEmptyString ; } -wxObject *wxReader::GetObject(int id) +struct wxXmlWriter::wxXmlWriterInternal { - assert( Data->Objects.find(id) != Data->Objects.end() ); - return Data->Objects[id]; + wxXmlNode *m_root ; + wxXmlNode *m_current ; + vector< wxXmlNode * > m_objectStack ; + + void Push( wxXmlNode *newCurrent ) + { + m_objectStack.push_back( m_current ) ; + m_current = newCurrent ; + } + + void Pop() + { + m_current = m_objectStack.back() ; + m_objectStack.pop_back() ; + } +} ; + +wxXmlWriter::wxXmlWriter( wxXmlNode * rootnode ) +{ + m_data = new wxXmlWriterInternal() ; + m_data->m_root = rootnode ; + m_data->m_current = rootnode ; } -wxString wxReader::GetObjectName(int id) +wxXmlWriter::~wxXmlWriter() { - assert( Data->ObjectNames.find(id) != Data->ObjectNames.end() ); - return wxString(Data->ObjectNames[id].c_str()); + delete m_data ; } -wxClassInfo* wxReader::GetObjectClassInfo(int id) +void wxXmlWriter::DoBeginWriteTopLevelEntry( const wxString &name ) { - assert( Data->ObjectClasses.find(id) != Data->ObjectClasses.end() ); - return Data->ObjectClasses[id] ; + wxXmlNode *pnode; + pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("entry")); + pnode->AddProperty(wxString("name"), name); + m_data->m_current->AddChild(pnode) ; + m_data->Push( pnode ) ; } -void wxReader::SetObject(int id, wxObject *Object) +void wxXmlWriter::DoEndWriteTopLevelEntry( const wxString &WXUNUSED(name) ) { - assert( Data->Objects.find(id) == Data->Objects.end() ) ; - Data->Objects[id] = Object; + m_data->Pop() ; } -void wxReader::SetObjectName(int id, const wxString &Name, wxClassInfo *ClassInfo ) +void wxXmlWriter::DoBeginWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *classInfo, int objectID ) { - assert( Data->ObjectNames.find(id) == Data->ObjectNames.end() ) ; - Data->ObjectNames[id] = (const char *)Name; - Data->ObjectClasses[id] = ClassInfo ; + wxXmlNode *pnode; + pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object")); + pnode->AddProperty(wxT("class"), wxString(classInfo->GetClassName())); + pnode->AddProperty(wxT("id"), wxString::Format( "%d" , objectID ) ); + + m_data->m_current->AddChild(pnode) ; + m_data->Push( pnode ) ; } -/* - Reading components has not to be extended for components - as properties are always sought by typeinfo over all levels - and create params are always toplevel class only -*/ +// end of writing the root object +void wxXmlWriter::DoEndWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *WXUNUSED(classInfo), int WXUNUSED(objectID) ) +{ + m_data->Pop() ; +} + +// writes a property in the stream format +void wxXmlWriter::DoWriteSimpleType( wxxVariant &value ) +{ + wxXmlAddContentToNode( m_data->m_current ,value.GetAsString() ) ; +} + +void wxXmlWriter::DoBeginWriteElement() +{ + wxXmlNode *pnode; + pnode = new wxXmlNode(wxXML_ELEMENT_NODE, "element" ); + m_data->m_current->AddChild(pnode) ; + m_data->Push( pnode ) ; +} + +void wxXmlWriter::DoEndWriteElement() +{ + m_data->Pop() ; +} + +void wxXmlWriter::DoBeginWriteProperty(const wxPropertyInfo *pi ) +{ + wxXmlNode *pnode; + pnode = new wxXmlNode(wxXML_ELEMENT_NODE, "prop" ); + pnode->AddProperty(wxT("name"), pi->GetName() ); + m_data->m_current->AddChild(pnode) ; + m_data->Push( pnode ) ; +} -int wxReader::ReadComponent(wxXmlNode *Node, wxIDepersist *Callbacks) +void wxXmlWriter::DoEndWriteProperty(const wxPropertyInfo *WXUNUSED(propInfo) ) { - wxString ClassName; - wxClassInfo *ClassInfo; + m_data->Pop() ; +} + - wxxVariant *CreateParams ; - wxXmlNode *Children; - int ObjectID; - Callbacks->NotifyReader(this); +// insert an object reference to an already written object +void wxXmlWriter::DoWriteRepeatedObject( int objectID ) +{ + wxXmlNode *pnode; + pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object")); + pnode->AddProperty(wxString("href"), wxString::Format( "%d" , objectID ) ); + m_data->m_current->AddChild(pnode) ; +} + +// insert a null reference +void wxXmlWriter::DoWriteNullObject() +{ + wxXmlNode *pnode; + pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object")); + m_data->m_current->AddChild(pnode) ; +} - Children = Node->GetChildren(); - if (!Node->GetPropVal("class", &ClassName)) +// writes a delegate in the stream format +void wxXmlWriter::DoWriteDelegate( const wxObject *WXUNUSED(object), const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *pi , + const wxObject *eventSink, int sinkObjectID , const wxClassInfo* WXUNUSED(eventSinkClassInfo) , const wxHandlerInfo* handlerInfo ) +{ + if ( eventSink != NULL && handlerInfo != NULL ) { - // No class name. Eek. FIXME: error handling - return -1; + wxXmlAddContentToNode( m_data->m_current ,wxString::Format(wxT("%d.%s"), sinkObjectID , handlerInfo->GetName()) ) ; } - ClassInfo = wxClassInfo::FindClass(ClassName); - if (Node->GetType() == wxXML_TEXT_NODE) - { - assert( wxXmlGetContentFromNode(Node) == "null" ) ; - // this must be a NULL component reference. We just bail out - return -1; - } +} + +// ---------------------------------------------------------------------------- +// reading objects in +// ---------------------------------------------------------------------------- + +struct wxReader::wxReaderInternal +{ + map m_classInfos; +}; + +wxReader::wxReader() +{ + m_data = new wxReaderInternal; +} + +wxReader::~wxReader() +{ + delete m_data; +} + +wxClassInfo* wxReader::GetObjectClassInfo(int objectID) +{ + assert( m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() ); + return m_data->m_classInfos[objectID] ; +} + +void wxReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo ) +{ + assert( m_data->m_classInfos.find(objectID) == m_data->m_classInfos.end() ) ; + m_data->m_classInfos[objectID] = classInfo ; +} + +bool wxReader::HasObjectClassInfo( int objectID ) +{ + return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() ; +} + - wxString ObjectIdString ; - if (!Node->GetPropVal("id", &ObjectIdString)) +// ---------------------------------------------------------------------------- +// reading xml in +// ---------------------------------------------------------------------------- + +/* +Reading components has not to be extended for components +as properties are always sought by typeinfo over all levels +and create params are always toplevel class only +*/ + +int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks) +{ + wxString className; + wxClassInfo *classInfo; + + wxxVariant *createParams ; + int *createParamOids ; + const wxClassInfo** createClassInfos ; + wxXmlNode *children; + int objectID; + wxString ObjectIdString ; + + children = node->GetChildren(); + if (!children) + { + // check for a null object or href + if (node->GetPropVal("href" , &ObjectIdString ) ) + { + objectID = atoi( ObjectIdString.c_str() ) ; + wxASSERT_MSG( HasObjectClassInfo( objectID ) , wxT("Forward hrefs are not supported") ) ; + return objectID ; + } + if ( !node->GetPropVal("id" , &ObjectIdString ) ) + { + return wxNullObjectID; + } + } + if (!node->GetPropVal("class", &className)) { - // No object id. Eek. FIXME: error handling - return -1; + // No class name. Eek. FIXME: error handling + return wxInvalidObjectID; } + classInfo = wxClassInfo::FindClass(className); + wxASSERT_MSG( classInfo , wxString::Format(wxT("unknown class %s"),className ) ) ; + wxASSERT_MSG( !children || children->GetType() != wxXML_TEXT_NODE , wxT("objects cannot have XML Text Nodes") ) ; + if (!node->GetPropVal("id", &ObjectIdString)) + { + wxASSERT_MSG(0,wxT("Objects must have an id attribute") ) ; + // No object id. Eek. FIXME: error handling + return wxInvalidObjectID; + } + objectID = atoi( ObjectIdString.c_str() ) ; + // is this object already has been streamed in, return it here + wxASSERT_MSG( !HasObjectClassInfo( objectID ) , wxString::Format(wxT("Doubly used id : %d"), objectID ) ) ; + + // new object, start with allocation + // first make the object know to our internal registry + SetObjectClassInfo( objectID , classInfo ) ; - ObjectID = atoi( ObjectIdString.c_str() ) ; - // is this object already has been streamed in, return it here - if ( genCode ) - { - if ( Data->ObjectNames.find( ObjectID ) != Data->ObjectNames.end() ) - return ObjectID ; - } - else - { - if ( Data->Objects.find( ObjectID ) != Data->Objects.end() ) - return ObjectID ; - } - - // new object, start with allocation - Callbacks->AllocateObject(ObjectID, ClassInfo); - - // + callbacks->AllocateObject(objectID, classInfo); + + // // stream back the Create parameters first - CreateParams = new wxxVariant[ ClassInfo->GetCreateParamCount() ] ; - - typedef map PropertyNodes ; - typedef vector PropertyNames ; - - PropertyNodes propertyNodes ; - PropertyNames propertyNames ; - - while( Children ) - { - propertyNames.push_back( Children->GetName().c_str() ) ; - propertyNodes[Children->GetName().c_str()] = Children ; - Children = Children->GetNext() ; - } - - for ( int i = 0 ; i GetCreateParamCount() ; ++i ) - { - const wxChar* paramName = ClassInfo->GetCreateParamName(i) ; - PropertyNodes::iterator propiter = propertyNodes.find( paramName ) ; - // if we don't have the value of a create param set in the xml - // we use the default value - if ( propiter != propertyNodes.end() ) - { - wxXmlNode* prop = propiter->second ; - wxPropertyInfo* pi ; - CreateParams[i] = ReadPropertyValueNoAssign( prop , ClassInfo , pi , Callbacks ) ; - // CreateParams[i] = ClassInfo->FindPropertyInfo( ClassInfo->GetCreateParamName(i) ->GetAccessor()->ReadValue( prop ) ; - for ( size_t j = 0 ; j < propertyNames.size() ; ++j ) - { - if ( propertyNames[j] == paramName ) - { - propertyNames[j] = "" ; - break ; - } - } - } - else - { - CreateParams[i] = ClassInfo->FindPropertyInfo( paramName )->GetDefaultValue() ; - } - } + createParams = new wxxVariant[ classInfo->GetCreateParamCount() ] ; + createParamOids = new int[classInfo->GetCreateParamCount() ] ; + createClassInfos = new const wxClassInfo*[classInfo->GetCreateParamCount() ] ; + + typedef map PropertyNodes ; + typedef vector PropertyNames ; + + PropertyNodes propertyNodes ; + PropertyNames propertyNames ; + + while( children ) + { + wxString name ; + children->GetPropVal( wxT("name") , &name ) ; + propertyNames.push_back( name.c_str() ) ; + propertyNodes[name.c_str()] = children->GetChildren() ; + children = children->GetNext() ; + } + + for ( int i = 0 ; i GetCreateParamCount() ; ++i ) + { + const wxChar* paramName = classInfo->GetCreateParamName(i) ; + PropertyNodes::iterator propiter = propertyNodes.find( paramName ) ; + const wxPropertyInfo* pi = classInfo->FindPropertyInfo( paramName ) ; + // if we don't have the value of a create param set in the xml + // we use the default value + if ( propiter != propertyNodes.end() ) + { + wxXmlNode* prop = propiter->second ; + if ( pi->GetTypeInfo()->IsObjectType() ) + { + createParamOids[i] = ReadComponent( prop , callbacks ) ; + createClassInfos[i] = dynamic_cast(pi->GetTypeInfo())->GetClassInfo() ; + } + else + { + createParamOids[i] = wxInvalidObjectID ; + createParams[i] = ReadValue( prop , pi->GetAccessor() ) ; + createClassInfos[i] = NULL ; + } + + for ( size_t j = 0 ; j < propertyNames.size() ; ++j ) + { + if ( propertyNames[j] == paramName ) + { + propertyNames[j] = "" ; + break ; + } + } + } + else + { + createParams[i] = pi->GetDefaultValue() ; + } + } // got the parameters. Call the Create method - Callbacks->CreateObject(ObjectID, - ClassInfo, - ClassInfo->GetCreateParamCount(), - &CreateParams[0]); + callbacks->CreateObject(objectID, classInfo, + classInfo->GetCreateParamCount(), + createParams, createParamOids, createClassInfos); // now stream in the rest of the properties, in the sequence their properties were written in the xml - for ( size_t j = 0 ; j < propertyNames.size() ; ++j ) - { - if ( propertyNames[j].length() ) - { - PropertyNodes::iterator propiter = propertyNodes.find( propertyNames[j] ) ; - if ( propiter != propertyNodes.end() ) - { - wxXmlNode* prop = propiter->second ; - string name = propiter->first ; - ReadPropertyValue( prop , ClassInfo , ObjectID , Callbacks ) ; - } - } - } - /* - for( PropertyNodes::iterator propiter = propertyNodes.begin() ; propiter != propertyNodes.end() ; propiter++ ) - { - wxXmlNode* prop = propiter->second ; - string name = propiter->first ; - ReadPropertyValue( prop , ClassInfo , ObjectID , Callbacks ) ; - } - */ - - // FIXME: if the list of children is not NULL now, then that means that - // there were properties in the XML not represented in the meta data - // this just needs error handling. - assert(!Children); - - delete[] CreateParams ; - - return ObjectID; + for ( size_t j = 0 ; j < propertyNames.size() ; ++j ) + { + if ( propertyNames[j].length() ) + { + PropertyNodes::iterator propiter = propertyNodes.find( propertyNames[j] ) ; + if ( propiter != propertyNodes.end() ) + { + wxXmlNode* prop = propiter->second ; + const wxPropertyInfo* pi = classInfo->FindPropertyInfo( propertyNames[j].c_str() ) ; + if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION ) + { + const wxTypeInfo * elementType = dynamic_cast< const wxCollectionTypeInfo* >( pi->GetTypeInfo() )->GetElementType() ; + while( prop ) + { + wxASSERT_MSG(prop->GetName() == wxT("element") , wxT("A non empty collection must consist of 'element' nodes")) ; + wxXmlNode* elementContent = prop->GetChildren() ; + wxASSERT_MSG(elementContent, wxT("An element node cannot be empty")) ; + if ( elementType->IsObjectType() ) + { + int valueId = ReadComponent( elementContent , callbacks ) ; + if ( callbacks ) + { + if ( valueId != wxInvalidObjectID ) + { + /* + callbacks->SetPropertyAsObject( objectID , classInfo , pi , valueId ) ; + */ + if ( elementType->GetKind() == wxT_OBJECT && valueId != wxNullObjectID ) + callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ; + } + } + } + else + { + wxxVariant elementValue = ReadValue( prop , pi->GetAccessor() ) ; + /* + if ( callbacks ) + callbacks->SetProperty( objectID, classInfo ,pi , ) ; + */ + } + prop = prop->GetNext() ; + } + } + else if ( pi->GetTypeInfo()->IsObjectType() ) + { + int valueId = ReadComponent( prop , callbacks ) ; + if ( callbacks ) + { + if ( valueId != wxInvalidObjectID ) + { + callbacks->SetPropertyAsObject( objectID , classInfo , pi , valueId ) ; + if ( pi->GetTypeInfo()->GetKind() == wxT_OBJECT && valueId != wxNullObjectID ) + callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ; + } + } + } + else if ( pi->GetTypeInfo()->IsDelegateType() ) + { + if ( prop ) + { + wxString resstring = prop->GetContent() ; + wxInt32 pos = resstring.Find('.') ; + assert( pos != wxNOT_FOUND ) ; + int sinkOid = atol(resstring.Left(pos)) ; + wxString handlerName = resstring.Mid(pos+1) ; + wxClassInfo* sinkClassInfo = GetObjectClassInfo( sinkOid ) ; + + if (callbacks) + callbacks->SetConnect( objectID , classInfo , dynamic_cast(pi->GetTypeInfo()) , sinkClassInfo , + sinkClassInfo->FindHandlerInfo(handlerName) , sinkOid ) ; + } + + } + else + { + if ( callbacks ) + callbacks->SetProperty( objectID, classInfo ,pi , ReadValue( prop , pi->GetAccessor() ) ) ; + } + } + } + } + + delete[] createParams ; + delete[] createParamOids ; + delete[] createClassInfos ; + + return objectID; +} + +wxxVariant wxXmlReader::ReadValue(wxXmlNode *node, + wxPropertyAccessor *accessor ) +{ + wxString content ; + if ( node ) + content = node->GetContent() ; + return accessor->ReadValue(content) ; +} + +int wxXmlReader::ReadObject( const wxString &name , wxDepersister *callbacks) +{ + wxXmlNode *iter = m_parent->GetChildren() ; + while ( iter ) + { + wxString entryName ; + if ( iter->GetPropVal("name", &entryName) ) + { + if ( entryName == name ) + return ReadComponent( iter->GetChildren() , callbacks ) ; + } + iter = iter->GetNext() ; + } + return wxInvalidObjectID ; } // ---------------------------------------------------------------------------- // depersisting to memory // ---------------------------------------------------------------------------- -void wxIDepersistRuntime::AllocateObject(int ObjectID, wxClassInfo *ClassInfo) +struct wxRuntimeDepersister::wxRuntimeDepersisterInternal { - wxObject *O; - O = ClassInfo->CreateObject(); - Reader->SetObject(ObjectID, O); + map m_objects; + + void SetObject(int objectID, wxObject *obj ) + { + assert( m_objects.find(objectID) == m_objects.end() ) ; + m_objects[objectID] = obj ; + } + wxObject* GetObject( int objectID ) + { + if ( objectID == wxNullObjectID ) + return NULL ; + + assert( m_objects.find(objectID) != m_objects.end() ) ; + return m_objects[objectID] ; + } +} ; + +wxRuntimeDepersister::wxRuntimeDepersister() +{ + m_data = new wxRuntimeDepersisterInternal() ; } -void wxIDepersistRuntime::CreateObject(int ObjectID, - wxClassInfo *ClassInfo, - int ParamCount, - wxxVariant *Params) +wxRuntimeDepersister::~wxRuntimeDepersister() { - wxObject *O; - O = Reader->GetObject(ObjectID); - ClassInfo->Create(O, ParamCount, Params); + delete m_data ; } -void wxIDepersistRuntime::SetProperty(int ObjectID, - wxClassInfo *WXUNUSED(ClassInfo), - const wxPropertyInfo* PropertyInfo, - const wxxVariant &Value) +void wxRuntimeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo) { wxObject *O; - O = Reader->GetObject(ObjectID); - PropertyInfo->GetAccessor()->SetProperty( O , Value ) ; + O = classInfo->CreateObject(); + m_data->SetObject(objectID, O); } -void wxIDepersistRuntime::SetConnect(int EventSourceObjectID, - wxClassInfo *WXUNUSED(EventSourceClassInfo), - int eventType , - const wxString &handlerName , - int EventSinkObjectID ) +void wxRuntimeDepersister::CreateObject(int objectID, + const wxClassInfo *classInfo, + int paramCount, + wxxVariant *params, + int *objectIdValues, + const wxClassInfo **objectClassInfos) { - wxWindow *ehsource = dynamic_cast< wxWindow* >( Reader->GetObject( EventSourceObjectID ) ) ; - wxEvtHandler *ehsink = dynamic_cast< wxEvtHandler *>(Reader->GetObject(EventSinkObjectID) ) ; + wxObject *o; + o = m_data->GetObject(objectID); + for ( int i = 0 ; i < paramCount ; ++i ) + { + if ( objectIdValues[i] != wxInvalidObjectID ) + { + wxObject *o; + o = m_data->GetObject(objectIdValues[i]); + // if this is a dynamic object and we are asked for another class + // than wxDynamicObject we cast it down manually. + wxDynamicObject *dyno = dynamic_cast< wxDynamicObject * > (o) ; + if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) ) + { + o = dyno->GetSuperClassInstance() ; + } + params[i] = objectClassInfos[i]->InstanceToVariant(o) ; + } + } + classInfo->Create(o, paramCount, params); +} - if ( ehsource && ehsink ) - { - ehsource->Connect( ehsource->GetId() , eventType , - ehsink->GetClassInfo()->FindHandlerInfo(handlerName)->GetEventFunction() , NULL /*user data*/ , - ehsink ) ; - } +void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) +{ + wxObject *o; + o = m_data->GetObject(objectID); + delete o ; } +void wxRuntimeDepersister::SetProperty(int objectID, + const wxClassInfo *classInfo, + const wxPropertyInfo* propertyInfo, + const wxxVariant &value) +{ + wxObject *o; + o = m_data->GetObject(objectID); + classInfo->SetProperty( o , propertyInfo->GetName() , value ) ; + // propertyInfo->GetAccessor()->SetProperty( o , value ) ; +} + +void wxRuntimeDepersister::SetPropertyAsObject(int objectID, + const wxClassInfo *classInfo, + const wxPropertyInfo* propertyInfo, + int valueObjectId) +{ + wxObject *o, *valo; + o = m_data->GetObject(objectID); + valo = m_data->GetObject(valueObjectId); + const wxClassInfo* valClassInfo = (dynamic_cast(propertyInfo->GetTypeInfo()))->GetClassInfo() ; + // if this is a dynamic object and we are asked for another class + // than wxDynamicObject we cast it down manually. + wxDynamicObject *dynvalo = dynamic_cast< wxDynamicObject * > (valo) ; + if ( dynvalo!=NULL && (valClassInfo != dynvalo->GetClassInfo()) ) + { + valo = dynvalo->GetSuperClassInstance() ; + } + + classInfo->SetProperty( o , propertyInfo->GetName() , valClassInfo->InstanceToVariant(valo) ) ; + // propertyInfo->GetAccessor()->SetProperty( o , + // (dynamic_cast(propertyInfo->GetTypeInfo()))->GetClassInfo()->InstanceToVariant(valo) ) ; +} + +void wxRuntimeDepersister::SetConnect(int eventSourceObjectID, + const wxClassInfo *WXUNUSED(eventSourceClassInfo), + const wxDelegateTypeInfo *delegateInfo , + const wxClassInfo *WXUNUSED(eventSinkClassInfo) , + const wxHandlerInfo* handlerInfo , + int eventSinkObjectID ) +{ + wxWindow *ehsource = dynamic_cast< wxWindow* >( m_data->GetObject( eventSourceObjectID ) ) ; + wxEvtHandler *ehsink = dynamic_cast< wxEvtHandler *>(m_data->GetObject(eventSinkObjectID) ) ; + + if ( ehsource && ehsink ) + { + ehsource->Connect( ehsource->GetId() , delegateInfo->GetEventType() , + handlerInfo->GetEventFunction() , NULL /*user data*/ , + ehsink ) ; + } +} + +wxObject *wxRuntimeDepersister::GetObject(int objectID) +{ + return m_data->GetObject( objectID ) ; +} + + // ---------------------------------------------------------------------------- // depersisting to code // ---------------------------------------------------------------------------- +struct wxCodeDepersister::wxCodeDepersisterInternal +{ + map m_objectNames ; + + void SetObjectName(int objectID, const wxString &name ) + { + assert( m_objectNames.find(objectID) == m_objectNames.end() ) ; + m_objectNames[objectID] = (const char *)name; + } + wxString GetObjectName( int objectID ) + { + if ( objectID == wxNullObjectID ) + return "NULL" ; -void wxIDepersistCode::AllocateObject(int ObjectID, wxClassInfo *ClassInfo) + assert( m_objectNames.find(objectID) != m_objectNames.end() ) ; + return wxString( m_objectNames[objectID].c_str() ) ; + } +} ; + +wxCodeDepersister::wxCodeDepersister(wxTextOutputStream *out) +: m_fp(out) +{ + m_data = new wxCodeDepersisterInternal ; +} + +wxCodeDepersister::~wxCodeDepersister() +{ + delete m_data ; +} + +void wxCodeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo) +{ + wxString objectName = wxString::Format( "LocalObject_%d" , objectID ) ; + m_fp->WriteString( wxString::Format( "\t%s *%s = new %s;\n", + classInfo->GetClassName(), + objectName, + classInfo->GetClassName()) ); + m_data->SetObjectName( objectID , objectName ) ; +} + +void wxCodeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) { - wxString objectName = wxString::Format( "LocalObject_%d" , ObjectID ) ; - fp->WriteString( wxString::Format( "\t%s *%s = new %s;\n", - ClassInfo->GetClassName(), - objectName, - ClassInfo->GetClassName()) ); - Reader->SetObjectName(ObjectID, objectName, ClassInfo); + m_fp->WriteString( wxString::Format( "\tdelete %s;\n", + m_data->GetObjectName( objectID) ) ); } -void wxIDepersistCode::CreateObject(int ObjectID, - wxClassInfo *WXUNUSED(ClassInfo), - int ParamCount, - wxxVariant *Params) +wxString wxCodeDepersister::ValueAsCode( const wxxVariant ¶m ) +{ + wxString value ; + const wxTypeInfo* type = param.GetTypeInfo() ; + if ( type->GetKind() == wxT_CUSTOM ) + { + const wxCustomTypeInfo* cti = dynamic_cast(type) ; + wxASSERT_MSG( cti , wxT("Internal error, illegal wxCustomTypeInfo") ) ; + value.Printf( "%s(%s)",cti->GetTypeName(),param.GetAsString() ); + } + else if ( type->GetKind() == wxT_STRING ) + { + value.Printf( "\"%s\"",param.GetAsString() ); + } + else + { + value.Printf( "%s", param.GetAsString() ); + } + return value ; +} + +void wxCodeDepersister::CreateObject(int objectID, + const wxClassInfo *WXUNUSED(classInfo), + int paramCount, + wxxVariant *params, + int *objectIDValues, + const wxClassInfo **WXUNUSED(objectClassInfos) + ) { int i; - fp->WriteString( wxString::Format( "\t%s->Create(", Reader->GetObjectName(ObjectID) ) ); - for (i = 0; i < ParamCount; i++) + m_fp->WriteString( wxString::Format( "\t%s->Create(", m_data->GetObjectName(objectID) ) ); + for (i = 0; i < paramCount; i++) { - fp->WriteString( wxString::Format( "%s", (const char *)Params[i].Get() ) ); - if (i < ParamCount - 1) - fp->WriteString( ", "); + if ( objectIDValues[i] != wxInvalidObjectID ) + m_fp->WriteString( wxString::Format( "%s", m_data->GetObjectName( objectIDValues[i] ) ) ); + else + { + m_fp->WriteString( wxString::Format( "%s", ValueAsCode(params[i]) ) ); + } + if (i < paramCount - 1) + m_fp->WriteString( ", "); } - fp->WriteString( ");\n"); + m_fp->WriteString( ");\n"); } -void wxIDepersistCode::SetProperty(int ObjectID, - wxClassInfo *WXUNUSED(ClassInfo), - const wxPropertyInfo* PropertyInfo, - const wxxVariant &Value) +void wxCodeDepersister::SetProperty(int objectID, + const wxClassInfo *WXUNUSED(classInfo), + const wxPropertyInfo* propertyInfo, + const wxxVariant &value) { - wxString d = Value.Get() ; - fp->WriteString( wxString::Format( "\t%s->%s(%s);\n", - Reader->GetObjectName(ObjectID), - PropertyInfo->GetAccessor()->GetSetterName(), - d) ); + m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n", + m_data->GetObjectName(objectID), + propertyInfo->GetAccessor()->GetSetterName(), + ValueAsCode(value)) ); } -void wxIDepersistCode::SetConnect(int EventSourceObjectID, - wxClassInfo *WXUNUSED(EventSourceClassInfo), - int eventType , - const wxString &handlerName , - int EventSinkObjectID ) +void wxCodeDepersister::SetPropertyAsObject(int objectID, + const wxClassInfo *WXUNUSED(classInfo), + const wxPropertyInfo* propertyInfo, + int valueObjectId) { - wxString ehsource = Reader->GetObjectName( EventSourceObjectID ) ; - wxString ehsink = Reader->GetObjectName(EventSinkObjectID) ; - wxString ehsinkClass = Reader->GetObjectClassInfo(EventSinkObjectID)->GetClassName() ; + if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT ) + m_fp->WriteString( wxString::Format( "\t%s->%s(*%s);\n", + m_data->GetObjectName(objectID), + propertyInfo->GetAccessor()->GetSetterName(), + m_data->GetObjectName( valueObjectId) ) ); + else + m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n", + m_data->GetObjectName(objectID), + propertyInfo->GetAccessor()->GetSetterName(), + m_data->GetObjectName( valueObjectId) ) ); +} - fp->WriteString( wxString::Format( "\t%s->Connect( %s->GetId() , %d , (wxObjectEventFunction)(wxEventFunction) & %s::%s , NULL , %s ) ;" , - ehsource , ehsource , eventType , ehsinkClass , handlerName , ehsink ) ); +void wxCodeDepersister::SetConnect(int eventSourceObjectID, + const wxClassInfo *WXUNUSED(eventSourceClassInfo), + const wxDelegateTypeInfo *delegateInfo , + const wxClassInfo *eventSinkClassInfo , + const wxHandlerInfo* handlerInfo , + int eventSinkObjectID ) +{ + wxString ehsource = m_data->GetObjectName( eventSourceObjectID ) ; + wxString ehsink = m_data->GetObjectName(eventSinkObjectID) ; + wxString ehsinkClass = eventSinkClassInfo->GetClassName() ; + int eventType = delegateInfo->GetEventType() ; + wxString handlerName = handlerInfo->GetName() ; + + m_fp->WriteString( wxString::Format( "\t%s->Connect( %s->GetId() , %d , (wxObjectEventFunction)(wxEventFunction) & %s::%s , NULL , %s ) ;" , + ehsource , ehsource , eventType , ehsinkClass , handlerName , ehsink ) ); } +#include + +WX_DEFINE_OBJARRAY(wxxVariantArray); + #endif