X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/14f355c2b5c71fc7c3d680aea366582d2ac60f7b..d485bda109d5ef0fef36a3f737549e9b9f54baab:/src/common/xtistrm.cpp diff --git a/src/common/xtistrm.cpp b/src/common/xtistrm.cpp index 621341ae4f..ed4a7a557c 100644 --- a/src/common/xtistrm.cpp +++ b/src/common/xtistrm.cpp @@ -1,791 +1,681 @@ ///////////////////////////////////////////////////////////////////////////// // Name: src/common/xtistrm.cpp -// Purpose: streaming runtime metadata information +// Purpose: streaming runtime metadata information // Author: Stefan Csomor -// Modified by: +// Modified by: // Created: 27/07/03 // RCS-ID: $Id$ // Copyright: (c) 2003 Stefan Csomor // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) -#pragma implementation "xtistrm.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" #ifdef __BORLANDC__ -#pragma hdrstop + #pragma hdrstop #endif +#if wxUSE_EXTENDED_RTTI + +#include "wx/xtistrm.h" + #ifndef WX_PRECOMP -#include "wx/hash.h" -#include "wx/object.h" + #include "wx/object.h" + #include "wx/hash.h" + #include "wx/event.h" #endif -#include "wx/xml/xml.h" #include "wx/tokenzr.h" -#include "wx/xtistrm.h" #include "wx/txtstrm.h" -#if wxUSE_EXTENDED_RTTI +// STL headers: + +#include "wx/beforestd.h" #include #include #include +#include "wx/afterstd.h" +using namespace std; + -using namespace std ; +// ---------------------------------------------------------------------------- +// wxObjectWriter +// ---------------------------------------------------------------------------- + +struct wxObjectWriter::wxObjectWriterInternal +{ + map< const wxObject*, int > m_writtenObjects; + int m_nextId; +}; -struct wxWriter::wxWriterInternal +wxObjectWriter::wxObjectWriter() { - map< const wxObject* , int > m_writtenObjects ; - int m_nextId ; -} ; + m_data = new wxObjectWriterInternal; + m_data->m_nextId = 0; +} -wxWriter::wxWriter() +wxObjectWriter::~wxObjectWriter() { - m_data = new wxWriterInternal ; - m_data->m_nextId = 0 ; + delete m_data; } -wxWriter::~wxWriter() +struct wxObjectWriter::wxObjectWriterInternalPropertiesData +{ + char nothing; +}; + +void wxObjectWriter::ClearObjectContext() { - delete m_data ; + delete m_data; + m_data = new wxObjectWriterInternal(); + m_data->m_nextId = 0; } -struct wxWriter::wxWriterInternalPropertiesData +void wxObjectWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo, + wxObjectWriterCallback *writercallback, const wxString &name, + const wxStringToAnyHashMap &metadata ) { - map< string , int > m_writtenProperties ; -} ; + DoBeginWriteTopLevelEntry( name ); + WriteObject( object, classInfo, writercallback, false, metadata); + DoEndWriteTopLevelEntry( name ); +} -void wxWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo , wxPersister *persister , const wxString &name ) +void wxObjectWriter::WriteObject(const wxObject *object, const wxClassInfo *classInfo, + wxObjectWriterCallback *writercallback, bool isEmbedded, + const wxStringToAnyHashMap &metadata ) { - if ( persister->BeforeWriteObject( object , classInfo , name ) ) + if ( !classInfo->BeforeWriteObject( object, this, writercallback, metadata) ) + return; + + if ( writercallback->BeforeWriteObject( this, object, classInfo, metadata) ) { - int oid = m_data->m_nextId++ ; - m_data->m_writtenObjects[object] = oid ; - DoBeginWriteObject( object , classInfo , oid , name ) ; - wxWriterInternalPropertiesData data ; - WriteAllProperties( object , classInfo , persister , &data ) ; - DoEndWriteObject( object , classInfo , oid , name ) ; + 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 = wx_dynamic_cast(const wxDynamicObject*, object); + if ( !isEmbedded && dynobj ) + m_data->m_writtenObjects[dynobj->GetSuperClassInstance()] = oid; + + DoBeginWriteObject( object, classInfo, oid, metadata ); + wxObjectWriterInternalPropertiesData data; + WriteAllProperties( object, classInfo, writercallback, &data ); + DoEndWriteObject( object, classInfo, oid ); + } + writercallback->AfterWriteObject( this,object, classInfo ); } } -void wxWriter::WriteAllProperties( const wxObject * obj , const wxClassInfo* ci , wxPersister *persister, wxWriterInternalPropertiesData * data ) +void wxObjectWriter::FindConnectEntry(const wxEvtHandler * evSource, + const wxEventSourceTypeInfo* dti, + const wxObject* &sink, + const wxHandlerInfo *&handler) { - const wxPropertyInfo *pi = ci->GetFirstProperty() ; - while( pi ) + wxList *dynamicEvents = evSource->GetDynamicEventTable(); + + if ( dynamicEvents ) { - if ( data->m_writtenProperties.find( pi->GetName() ) == data->m_writtenProperties.end() ) + for ( wxList::const_iterator node = dynamicEvents->begin(); node != dynamicEvents->end(); ++node ) { - data->m_writtenProperties[ pi->GetName() ] = 1 ; - const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( pi->GetTypeInfo() ) ; - if ( cti ) + wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)(*node); + + // find the match + if ( entry->m_fn && + (dti->GetEventType() == entry->m_eventType) && + (entry->m_id == -1 ) && + (entry->m_fn->GetEvtHandler() != NULL ) ) { - const wxClassInfo* pci = cti->GetClassInfo() ; - wxxVariant value = pi->GetAccessor()->GetProperty(obj) ; - if ( persister->BeforeWritePropertyAsObject( obj , ci , pi , value ) ) + sink = entry->m_fn->GetEvtHandler(); + const wxClassInfo* sinkClassInfo = sink->GetClassInfo(); + const wxHandlerInfo* sinkHandler = sinkClassInfo->GetFirstHandler(); + while ( sinkHandler ) { - wxObject *vobj = pci->VariantToInstance( value ) ; - bool embeddedObject = cti->GetKind() == wxT_OBJECT ; + if ( sinkHandler->GetEventFunction() == entry->m_fn->GetEvtMethod() ) + { + handler = sinkHandler; + break; + } + sinkHandler = sinkHandler->GetNext(); + } + break; + } + } + } +} +void wxObjectWriter::WriteAllProperties( const wxObject * obj, const wxClassInfo* ci, + wxObjectWriterCallback *writercallback, + wxObjectWriterInternalPropertiesData * data ) +{ + wxPropertyInfoMap map; + ci->GetProperties( map ); + for ( int i = 0; i < ci->GetCreateParamCount(); ++i ) + { + wxString name = ci->GetCreateParamName(i); + wxPropertyInfoMap::const_iterator iter = map.find(name); + const wxPropertyInfo* prop = iter == map.end() ? NULL : iter->second; + if ( prop ) + { + WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data ); + } + else + { + wxLogError( _("Create Parameter %s not found in declared RTTI Parameters"), name.c_str() ); + } + map.erase( name ); + } + { // Extra block for broken compilers + for( wxPropertyInfoMap::iterator iter = map.begin(); iter != map.end(); ++iter ) + { + const wxPropertyInfo* prop = iter->second; + if ( prop->GetFlags() & wxPROP_OBJECT_GRAPH ) + { + WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data ); + } + } + } + { // Extra block for broken compilers + for( wxPropertyInfoMap::iterator iter = map.begin(); iter != map.end(); ++iter ) + { + const wxPropertyInfo* prop = iter->second; + if ( !(prop->GetFlags() & wxPROP_OBJECT_GRAPH) ) + { + WriteOneProperty( obj, prop->GetDeclaringClass(), prop, writercallback, data ); + } + } + } +} + +class WXDLLIMPEXP_BASE wxObjectPropertyWriter: public wxObjectWriterFunctor +{ +public: + wxObjectPropertyWriter(const wxClassTypeInfo* cti, + wxObjectWriterCallback *writercallback, + wxObjectWriter* writer, + wxStringToAnyHashMap &props) : + m_cti(cti),m_persister(writercallback),m_writer(writer),m_props(props) + {} + + virtual void operator()(const wxObject *vobj) + { + m_writer->WriteObject( vobj, (vobj ? vobj->GetClassInfo() : m_cti->GetClassInfo() ), + m_persister, m_cti->GetKind()== wxT_OBJECT, m_props ); + } +private: + const wxClassTypeInfo* m_cti; + wxObjectWriterCallback *m_persister; + wxObjectWriter* m_writer; + wxStringToAnyHashMap& m_props; +}; - if ( vobj == NULL || IsObjectKnown( vobj ) ) +void wxObjectWriter::WriteOneProperty( const wxObject *obj, const wxClassInfo* ci, + const wxPropertyInfo* pi, wxObjectWriterCallback *writercallback, + wxObjectWriterInternalPropertiesData *WXUNUSED(data) ) +{ + if ( pi->GetFlags() & wxPROP_DONT_STREAM ) + return; + + // make sure that we are picking the correct object for accessing the property + const wxDynamicObject* dynobj = wx_dynamic_cast(const wxDynamicObject*, obj ); + if ( dynobj && (wx_dynamic_cast(const wxDynamicClassInfo*, ci) == NULL) ) + obj = dynobj->GetSuperClassInstance(); + + if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION ) + { + wxAnyList data; + pi->GetAccessor()->GetPropertyCollection(obj, data); + const wxTypeInfo * elementType = + wx_dynamic_cast( const wxCollectionTypeInfo*, pi->GetTypeInfo() )->GetElementType(); + if ( !data.empty() ) + { + DoBeginWriteProperty( pi ); + for ( wxAnyList::const_iterator iter = data.begin(); iter != data.end(); ++iter ) + { + DoBeginWriteElement(); + const wxAny* valptr = *iter; + if ( writercallback->BeforeWriteProperty( this, obj, pi, *valptr ) ) + { + const wxClassTypeInfo* cti = + wx_dynamic_cast( const wxClassTypeInfo*, elementType ); + if ( cti ) { - DoWriteObjectReference( obj , ci , vobj , pci , GetObjectID(vobj) , pi ) ; + wxStringToAnyHashMap md; + wxObjectPropertyWriter pw(cti,writercallback,this, md); + + const wxClassInfo* pci = cti->GetClassInfo(); + pci->CallOnAny( *valptr, &pw); } else { - int oid = m_data->m_nextId++ ; - if ( !embeddedObject) - m_data->m_writtenObjects[vobj] = oid ; + DoWriteSimpleType( *valptr ); + } + } + DoEndWriteElement(); + } + DoEndWriteProperty( pi ); + } + } + else + { + const wxEventSourceTypeInfo* dti = + wx_dynamic_cast( const wxEventSourceTypeInfo* , pi->GetTypeInfo() ); + if ( dti ) + { + const wxObject* sink = NULL; + const wxHandlerInfo *handler = NULL; - DoBeginWriteParamAsObject( obj , ci , vobj , pci , oid , pi ) ; - if ( vobj != NULL ) + const wxEvtHandler * evSource = wx_dynamic_cast(const wxEvtHandler *, obj); + if ( evSource ) + { + FindConnectEntry( evSource, dti, sink, handler ); + if ( writercallback->BeforeWriteDelegate( this, obj, ci, pi, sink, handler ) ) + { + if ( sink != NULL && handler != NULL ) + { + DoBeginWriteProperty( pi ); + if ( IsObjectKnown( sink ) ) { - wxWriterInternalPropertiesData data ; - WriteAllProperties( vobj , pci , persister , &data ) ; + DoWriteDelegate( obj, ci, pi, sink, GetObjectID( sink ), + sink->GetClassInfo(), handler ); + DoEndWriteProperty( pi ); + } + else + { + wxLogError( wxT("Streaming delegates for not already ") + wxT("streamed objects not yet supported") ); } - DoEndWriteParamAsObject( obj , ci , vobj , pci , oid , pi ) ; } } } else { - const wxDelegateTypeInfo* dti = dynamic_cast< const wxDelegateTypeInfo* > ( pi->GetTypeInfo() ) ; - if ( dti ) + wxLogError(_("Illegal Object Class (Non-wxEvtHandler) as Event Source") ); + } + } + else + { + wxAny value; + pi->GetAccessor()->GetProperty(obj, value); + + // avoid streaming out void objects + // TODO Verify + if( value.IsNull() ) + return; + + if ( pi->GetFlags() & wxPROP_ENUM_STORE_LONG ) + { + const wxEnumTypeInfo *eti = + wx_dynamic_cast(const wxEnumTypeInfo*, pi->GetTypeInfo() ); + if ( eti ) + { + eti->ConvertFromLong( wxANY_AS(value, long ), value ); + } + else { - 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") ) ; + wxLogError( _("Type must have enum - long conversion") ); + } + } + + // avoid streaming out default values + if ( pi->GetTypeInfo()->HasStringConverters() && + !pi->GetDefaultValue().IsNull() ) // TODO Verify + { + if ( wxAnyGetAsString(value) == wxAnyGetAsString(pi->GetDefaultValue()) ) + return; + } + + // avoid streaming out null objects + const wxClassTypeInfo* cti = + wx_dynamic_cast( const wxClassTypeInfo* , pi->GetTypeInfo() ); - wxList *dynamicEvents = evSource->GetDynamicEventTable() ; + if ( cti && cti->GetKind() == wxT_OBJECT_PTR && wxAnyGetAsObjectPtr(value) == NULL ) + return; - if ( dynamicEvents ) + if ( writercallback->BeforeWriteProperty( this, obj, pi, value ) ) + { + DoBeginWriteProperty( pi ); + if ( cti ) + { + if ( cti->HasStringConverters() ) { - 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(); - } - } - if ( persister->BeforeWriteDelegate( obj , ci , pi , sink , handler ) ) + wxString stringValue; + cti->ConvertToString( value, stringValue ); + wxAny convertedValue(stringValue); + DoWriteSimpleType( convertedValue ); + } + else { - 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 ) ; - } + wxStringToAnyHashMap md; + wxObjectPropertyWriter pw(cti,writercallback,this, md); + + const wxClassInfo* pci = cti->GetClassInfo(); + pci->CallOnAny(value, &pw); } } else { - wxxVariant value = pi->GetAccessor()->GetProperty(obj) ; - if ( persister->BeforeWriteProperty( obj , ci , pi , value ) ) - { - DoWriteProperty( obj , ci , pi , value ) ; - } + DoWriteSimpleType( value ); } + DoEndWriteProperty( pi ); } } - pi = pi->GetNext() ; - } - const wxClassInfo** parents = ci->GetParents() ; - for ( int i = 0 ; parents[i] ; ++ i ) - { - WriteAllProperties( obj , parents[i] , persister , data ) ; } } -int wxWriter::GetObjectID(const wxObject *obj) +int wxObjectWriter::GetObjectID(const wxObject *obj) { if ( !IsObjectKnown( obj ) ) - return wxInvalidObjectID ; - - return m_data->m_writtenObjects[obj] ; -} - -bool wxWriter::IsObjectKnown( const wxObject *obj ) -{ - return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end() ; -} - -// -// XML Streaming -// - -// convenience functions - -void wxXmlAddContentToNode( wxXmlNode* node , const wxString& data ) -{ - node->AddChild(new wxXmlNode(wxXML_TEXT_NODE, "value", data ) ); -} - -wxString wxXmlGetContentFromNode( wxXmlNode *node ) -{ - if ( node->GetChildren() ) - return node->GetChildren()->GetContent() ; - else - return wxEmptyString ; -} - -struct wxXmlWriter::wxXmlWriterInternal -{ - wxXmlNode *m_root ; - wxXmlNode *m_current ; - vector< wxXmlNode * > m_objectStack ; -} ; + return wxInvalidObjectID; -wxXmlWriter::wxXmlWriter( wxXmlNode * rootnode ) -{ - m_data = new wxXmlWriterInternal() ; - m_data->m_root = rootnode ; - m_data->m_current = rootnode ; + return m_data->m_writtenObjects[obj]; } -wxXmlWriter::~wxXmlWriter() +bool wxObjectWriter::IsObjectKnown( const wxObject *obj ) { - delete m_data ; + return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end(); } -// start of writing the root object -void wxXmlWriter::DoBeginWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *classInfo, int objectID , const wxString &name ) -{ - wxXmlNode *onode; - onode = new wxXmlNode(wxXML_ELEMENT_NODE, name); - onode->AddProperty(wxString("class"), wxString(classInfo->GetClassName())); - onode->AddProperty(wxString("id"), wxString::Format( "%d" , objectID ) ); - m_data->m_current->AddChild(onode) ; - m_data->m_objectStack.push_back( m_data->m_current ) ; - m_data->m_current = onode ; -} +// ---------------------------------------------------------------------------- +// wxObjectReader +// ---------------------------------------------------------------------------- -// end of writing the root object -void wxXmlWriter::DoEndWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *WXUNUSED(classInfo), int WXUNUSED(objectID) , const wxString &WXUNUSED(name) ) +struct wxObjectReader::wxObjectReaderInternal { - m_data->m_current = m_data->m_objectStack.back() ; - m_data->m_objectStack.pop_back() ; -} + map m_classInfos; +}; -// writes a property in the stream format -void wxXmlWriter::DoWriteProperty( const wxObject *WXUNUSED(obj), const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *pi , wxxVariant &value ) +wxObjectReader::wxObjectReader() { - wxXmlNode *pnode; - pnode = new wxXmlNode(wxXML_ELEMENT_NODE, pi->GetName() ); - wxXmlAddContentToNode( pnode ,value.GetAsString() ) ; - m_data->m_current->AddChild(pnode); + m_data = new wxObjectReaderInternal; } -void wxXmlWriter::DoBeginWriteParamAsObject(const wxObject *WXUNUSED(parentObject), const wxClassInfo *WXUNUSED(parentClassInfo), const wxObject *WXUNUSED(valueObject), - const wxClassInfo *valueObjectClassInfo, int valueObjectID , const wxPropertyInfo *propInfo ) +wxObjectReader::~wxObjectReader() { - wxXmlNode *onode; - onode = new wxXmlNode(wxXML_ELEMENT_NODE, propInfo->GetName()); - onode->AddProperty(wxString("class"), wxString(valueObjectClassInfo->GetClassName())); - onode->AddProperty(wxString("id"), wxString::Format( "%d" , valueObjectID ) ); - m_data->m_current->AddChild(onode) ; - m_data->m_objectStack.push_back( m_data->m_current ) ; - m_data->m_current = onode ; + delete m_data; } -// insert an object reference to an already written object -void wxXmlWriter::DoWriteObjectReference(const wxObject *WXUNUSED(parentObject), const wxClassInfo *WXUNUSED(parentClassInfo), const wxObject *valueObject, - const wxClassInfo *valueObjectClassInfo, int valueObjectID , const wxPropertyInfo *propInfo ) +wxClassInfo* wxObjectReader::GetObjectClassInfo(int objectID) { - wxXmlNode *onode; - onode = new wxXmlNode(wxXML_ELEMENT_NODE, propInfo->GetName()); - onode->AddProperty(wxString("class"), wxString(valueObjectClassInfo->GetClassName())); - if ( valueObject == NULL ) + if ( objectID == wxNullObjectID || objectID == wxInvalidObjectID ) { - wxXmlNode* nullnode = new wxXmlNode(wxXML_TEXT_NODE, wxEmptyString, "null"); - onode->AddChild(nullnode); + wxLogError( _("Invalid or Null Object ID passed to GetObjectClassInfo" ) ); + return NULL; } - else + if ( m_data->m_classInfos.find(objectID) == m_data->m_classInfos.end() ) { - onode->AddProperty(wxString("id"), wxString::Format( "%d" , valueObjectID ) ); + wxLogError( _("Unknown Object passed to GetObjectClassInfo" ) ); + return NULL; } - - m_data->m_current->AddChild(onode) ; + return m_data->m_classInfos[objectID]; } -void wxXmlWriter::DoEndWriteParamAsObject(const wxObject *WXUNUSED(parentObject), const wxClassInfo *WXUNUSED(parentClassInfo), const wxObject *WXUNUSED(valueObject), - const wxClassInfo *WXUNUSED(valueObjectClassInfo), int WXUNUSED(valueObjectID) , const wxPropertyInfo *WXUNUSED(propInfo) ) +void wxObjectReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo ) { - m_data->m_current = m_data->m_objectStack.back() ; - m_data->m_objectStack.pop_back() ; -} - - -// 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 ) + if ( objectID == wxNullObjectID || objectID == wxInvalidObjectID ) { - wxXmlNode *pnode; - pnode = new wxXmlNode(wxXML_ELEMENT_NODE, pi->GetName() ); - wxString s ; - s.Printf(wxT("%d.%s"), sinkObjectID , handlerInfo->GetName() ) ; - wxXmlAddContentToNode( pnode ,s ) ; - m_data->m_current->AddChild(pnode); + wxLogError( _("Invalid or Null Object ID passed to GetObjectClassInfo" ) ); + return; } + if ( m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() ) + { + wxLogError( _("Already Registered Object passed to SetObjectClassInfo" ) ); + return; + } + m_data->m_classInfos[objectID] = classInfo; } -// ---------------------------------------------------------------------------- -// 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 ) +bool wxObjectReader::HasObjectClassInfo( int objectID ) { - return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() ; + if ( objectID == wxNullObjectID || objectID == wxInvalidObjectID ) + { + wxLogError( _("Invalid or Null Object ID passed to HasObjectClassInfo" ) ); + return false; + } + return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end(); } // ---------------------------------------------------------------------------- -// reading xml in +// 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; - - children = node->GetChildren(); - if (!node->GetPropVal("class", &className)) - { - // No class name. Eek. FIXME: error handling - return wxInvalidObjectID; - } - classInfo = wxClassInfo::FindClass(className); - if (children && children->GetType() == wxXML_TEXT_NODE) - { - assert( wxXmlGetContentFromNode(node) == "null" ) ; - // this must be a NULL component reference. We just bail out - return wxNullObjectID; - } - - wxString ObjectIdString ; - if (!node->GetPropVal("id", &ObjectIdString)) - { - // 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 - if ( HasObjectClassInfo( objectID ) ) - return objectID ; - - // new object, start with allocation - // first make the object know to our internal registry - SetObjectClassInfo( objectID , classInfo ) ; - - callbacks->AllocateObject(objectID, classInfo); - - // - // stream back the Create parameters first - 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 ) - { - 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 ) ; - 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, 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 ; - const wxPropertyInfo* pi = classInfo->FindPropertyInfo( propertyNames[j].c_str() ) ; - 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() ) - { - wxString resstring = wxXmlGetContentFromNode(prop) ; - 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 ) -{ - return accessor->ReadValue(wxXmlGetContentFromNode( node ) ) ; -} - -int wxXmlReader::ReadObject(wxDepersister *callbacks) -{ - return ReadComponent( m_parent , callbacks ) ; -} // ---------------------------------------------------------------------------- -// depersisting to memory +// wxObjectRuntimeReaderCallback - depersisting to memory // ---------------------------------------------------------------------------- -struct wxRuntimeDepersister::wxRuntimeDepersisterInternal +struct wxObjectRuntimeReaderCallback::wxObjectRuntimeReaderCallbackInternal { map m_objects; void SetObject(int objectID, wxObject *obj ) { - assert( m_objects.find(objectID) == m_objects.end() ) ; - m_objects[objectID] = obj ; + if ( m_objects.find(objectID) != m_objects.end() ) + { + wxLogError( _("Passing a already registered object to SetObject") ); + return ; + } + m_objects[objectID] = obj; } wxObject* GetObject( int objectID ) { if ( objectID == wxNullObjectID ) - return NULL ; + return NULL; + if ( m_objects.find(objectID) == m_objects.end() ) + { + wxLogError( _("Passing an unknown object to GetObject") ); + return NULL; + } - assert( m_objects.find(objectID) != m_objects.end() ) ; - return m_objects[objectID] ; + return m_objects[objectID]; } -} ; +}; -wxRuntimeDepersister::wxRuntimeDepersister() +wxObjectRuntimeReaderCallback::wxObjectRuntimeReaderCallback() { - m_data = new wxRuntimeDepersisterInternal() ; + m_data = new wxObjectRuntimeReaderCallbackInternal(); } -wxRuntimeDepersister::~wxRuntimeDepersister() +wxObjectRuntimeReaderCallback::~wxObjectRuntimeReaderCallback() { - delete m_data ; + delete m_data; } -void wxRuntimeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo) +void wxObjectRuntimeReaderCallback::AllocateObject(int objectID, wxClassInfo *classInfo, + wxStringToAnyHashMap &WXUNUSED(metadata)) { wxObject *O; O = classInfo->CreateObject(); m_data->SetObject(objectID, O); } -void wxRuntimeDepersister::CreateObject(int objectID, +void wxObjectRuntimeReaderCallback::CreateObject(int objectID, const wxClassInfo *classInfo, int paramCount, - wxxVariant *params, + wxAny *params, int *objectIdValues, - const wxClassInfo **objectClassInfos) + const wxClassInfo **objectClassInfos, + wxStringToAnyHashMap &WXUNUSED(metadata)) { wxObject *o; o = m_data->GetObject(objectID); - for ( int i = 0 ; i < paramCount ; ++i ) + for ( int i = 0; i < paramCount; ++i ) { if ( objectIdValues[i] != wxInvalidObjectID ) { wxObject *o; o = m_data->GetObject(objectIdValues[i]); - params[i] = objectClassInfos[i]->InstanceToVariant(o) ; + // if this is a dynamic object and we are asked for another class + // than wxDynamicObject we cast it down manually. + wxDynamicObject *dyno = wx_dynamic_cast( wxDynamicObject *, o); + if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) ) + { + o = dyno->GetSuperClassInstance(); + } + params[i] = objectClassInfos[i]->ObjectPtrToAny(o); } } classInfo->Create(o, paramCount, params); } -void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) +void wxObjectRuntimeReaderCallback::ConstructObject(int objectID, + const wxClassInfo *classInfo, + int paramCount, + wxAny *params, + int *objectIdValues, + const wxClassInfo **objectClassInfos, + wxStringToAnyHashMap &WXUNUSED(metadata)) +{ + wxObject *o; + 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 = wx_dynamic_cast( wxDynamicObject *, o); + if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) ) + { + o = dyno->GetSuperClassInstance(); + } + params[i] = objectClassInfos[i]->ObjectPtrToAny(o); + } + } + o = classInfo->ConstructObject(paramCount, params); + m_data->SetObject(objectID, o); +} + + +void wxObjectRuntimeReaderCallback::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) { wxObject *o; o = m_data->GetObject(objectID); - delete o ; + delete o; } -void wxRuntimeDepersister::SetProperty(int objectID, - const wxClassInfo *WXUNUSED(classInfo), +void wxObjectRuntimeReaderCallback::SetProperty(int objectID, + const wxClassInfo *classInfo, const wxPropertyInfo* propertyInfo, - const wxxVariant &value) + const wxAny &value) { wxObject *o; o = m_data->GetObject(objectID); - propertyInfo->GetAccessor()->SetProperty( o , value ) ; + classInfo->SetProperty( o, propertyInfo->GetName().c_str(), value ); } -void wxRuntimeDepersister::SetPropertyAsObject(int objectID, - const wxClassInfo *WXUNUSED(classInfo), +void wxObjectRuntimeReaderCallback::SetPropertyAsObject(int objectID, + const wxClassInfo *classInfo, const wxPropertyInfo* propertyInfo, int valueObjectId) { wxObject *o, *valo; o = m_data->GetObject(objectID); valo = m_data->GetObject(valueObjectId); - 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) ) ; + const wxClassInfo* valClassInfo = + (wx_dynamic_cast(const wxClassTypeInfo*,propertyInfo->GetTypeInfo()))->GetClassInfo(); - if ( ehsource && ehsink ) + // if this is a dynamic object and we are asked for another class + // than wxDynamicObject we cast it down manually. + wxDynamicObject *dynvalo = wx_dynamic_cast( wxDynamicObject *, valo); + if ( dynvalo!=NULL && (valClassInfo != dynvalo->GetClassInfo()) ) { - ehsource->Connect( ehsource->GetId() , delegateInfo->GetEventType() , - handlerInfo->GetEventFunction() , NULL /*user data*/ , - ehsink ) ; + valo = dynvalo->GetSuperClassInstance(); } -} -wxObject *wxRuntimeDepersister::GetObject(int objectID) -{ - return m_data->GetObject( objectID ) ; + classInfo->SetProperty( o, propertyInfo->GetName().c_str(), + valClassInfo->ObjectPtrToAny(valo) ); } - -// ---------------------------------------------------------------------------- -// depersisting to code -// ---------------------------------------------------------------------------- - -struct wxCodeDepersister::wxCodeDepersisterInternal +void wxObjectRuntimeReaderCallback::SetConnect(int eventSourceObjectID, + const wxClassInfo *WXUNUSED(eventSourceClassInfo), + const wxPropertyInfo *delegateInfo, + const wxClassInfo *WXUNUSED(eventSinkClassInfo), + const wxHandlerInfo* handlerInfo, + int eventSinkObjectID ) { - map m_objectNames ; + wxEvtHandler *ehsource = + wx_dynamic_cast( wxEvtHandler* , m_data->GetObject( eventSourceObjectID ) ); + wxEvtHandler *ehsink = + wx_dynamic_cast( wxEvtHandler *,m_data->GetObject(eventSinkObjectID) ); - 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 ( ehsource && ehsink ) { - if ( objectID == wxNullObjectID ) - return "NULL" ; - - assert( m_objectNames.find(objectID) != m_objectNames.end() ) ; - return wxString( m_objectNames[objectID].c_str() ) ; + const wxEventSourceTypeInfo *delegateTypeInfo = + wx_dynamic_cast(const wxEventSourceTypeInfo*,delegateInfo->GetTypeInfo()); + if( delegateTypeInfo && delegateTypeInfo->GetLastEventType() == -1 ) + { + ehsource->Connect( -1, delegateTypeInfo->GetEventType(), + handlerInfo->GetEventFunction(), NULL /*user data*/, + ehsink ); + } + else + { + for ( wxEventType iter = delegateTypeInfo->GetEventType(); + iter <= delegateTypeInfo->GetLastEventType(); ++iter ) + { + ehsource->Connect( -1, iter, + handlerInfo->GetEventFunction(), NULL /*user data*/, + ehsink ); + } + } } -} ; - -wxCodeDepersister::wxCodeDepersister(wxTextOutputStream *out) -: m_fp(out) -{ - m_data = new wxCodeDepersisterInternal ; } -wxCodeDepersister::~wxCodeDepersister() +wxObject *wxObjectRuntimeReaderCallback::GetObject(int objectID) { - delete m_data ; + return m_data->GetObject( objectID ); } -void wxCodeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo) +void wxObjectRuntimeReaderCallback::AddToPropertyCollection( int objectID, + const wxClassInfo *classInfo, + const wxPropertyInfo* propertyInfo, + const wxAny &value) { - 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)) -{ - m_fp->WriteString( wxString::Format( "\tdelete %s;\n", - m_data->GetObjectName( objectID) ) ); + wxObject *o; + o = m_data->GetObject(objectID); + classInfo->AddToPropertyCollection( o, propertyInfo->GetName().c_str(), value ); } -wxString wxCodeDepersister::ValueAsCode( const wxxVariant ¶m ) +void wxObjectRuntimeReaderCallback::AddToPropertyCollectionAsObject(int objectID, + const wxClassInfo *classInfo, + const wxPropertyInfo* propertyInfo, + int valueObjectId) { - 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 + wxObject *o, *valo; + o = m_data->GetObject(objectID); + valo = m_data->GetObject(valueObjectId); + const wxCollectionTypeInfo * collectionTypeInfo = + wx_dynamic_cast( const wxCollectionTypeInfo *, propertyInfo->GetTypeInfo() ); + const wxClassInfo* valClassInfo = + (wx_dynamic_cast(const wxClassTypeInfo*,collectionTypeInfo->GetElementType()))->GetClassInfo(); + + // if this is a dynamic object and we are asked for another class + // than wxDynamicObject we cast it down manually. + wxDynamicObject *dynvalo = wx_dynamic_cast( wxDynamicObject *, valo); + if ( dynvalo!=NULL && (valClassInfo != dynvalo->GetClassInfo()) ) { - value.Printf( "%s", param.GetAsString() ); + valo = dynvalo->GetSuperClassInstance(); } - return value ; -} -void wxCodeDepersister::CreateObject(int objectID, - const wxClassInfo *WXUNUSED(classInfo), - int paramCount, - wxxVariant *params, - int *objectIDValues, - const wxClassInfo **WXUNUSED(objectClassInfos) - ) -{ - int i; - m_fp->WriteString( wxString::Format( "\t%s->Create(", m_data->GetObjectName(objectID) ) ); - for (i = 0; i < paramCount; i++) - { - 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( ", "); - } - m_fp->WriteString( ");\n"); + classInfo->AddToPropertyCollection( o, propertyInfo->GetName().c_str(), + valClassInfo->ObjectPtrToAny(valo) ); } -void wxCodeDepersister::SetProperty(int objectID, - const wxClassInfo *WXUNUSED(classInfo), - const wxPropertyInfo* propertyInfo, - const wxxVariant &value) -{ - m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n", - m_data->GetObjectName(objectID), - propertyInfo->GetAccessor()->GetSetterName(), - ValueAsCode(value)) ); -} - -void wxCodeDepersister::SetPropertyAsObject(int objectID, - const wxClassInfo *WXUNUSED(classInfo), - const wxPropertyInfo* propertyInfo, - int valueObjectId) -{ - 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) ) ); -} - -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 ) ); -} - -#endif +#endif // wxUSE_EXTENDED_RTTI