src/common/xtixml.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/xtixml.cpp
// Purpose:     streaming runtime metadata information
// Author:      Stefan Csomor
// Modified by:
// Created:     27/07/03
// RCS-ID:      $Id$
// Copyright:   (c) 2003 Stefan Csomor
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_EXTENDED_RTTI

#include "wx/xtixml.h"

#ifndef WX_PRECOMP
    #include "wx/object.h"
    #include "wx/hash.h"
    #include "wx/event.h"
#endif

#include "wx/xml/xml.h"
#include "wx/tokenzr.h"
#include "wx/txtstrm.h"

#include "wx/xtistrm.h"

#include "wx/beforestd.h"
#include <map>
#include <vector>
#include <string>
#include "wx/afterstd.h"

using namespace std ;

//
// XML Streaming
//

// convenience functions

void wxXmlAddContentToNode( wxXmlNode* node , const wxString& data )
{
    node->AddChild(new wxXmlNode(wxXML_TEXT_NODE, wxT("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 ;

    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 ;
}

wxXmlWriter::~wxXmlWriter()
{
    delete m_data ;
}

void wxXmlWriter::DoBeginWriteTopLevelEntry( const wxString &name )
{
    wxXmlNode *pnode;
    pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("entry"));
    pnode->AddProperty(wxString(wxT("name")), name);
    m_data->m_current->AddChild(pnode) ;
    m_data->Push( pnode ) ;
}

void wxXmlWriter::DoEndWriteTopLevelEntry( const wxString &WXUNUSED(name) )
{
    m_data->Pop() ;
}

void wxXmlWriter::DoBeginWriteObject(const wxObject *WXUNUSED(object), const wxClassInfo *classInfo, int objectID , wxxVariantArray &metadata   )
{
    wxXmlNode *pnode;
    pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
    pnode->AddProperty(wxT("class"), wxString(classInfo->GetClassName()));
    pnode->AddProperty(wxT("id"), wxString::Format( wxT("%d") , objectID ) );

    for ( size_t i = 0 ; i < metadata.GetCount() ; ++i )
    {
        pnode->AddProperty( metadata[i].GetName() , metadata[i].GetAsString() ) ;
    }
    m_data->m_current->AddChild(pnode) ;
    m_data->Push( pnode ) ;
}

// 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, wxT("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, wxT("prop") );
    pnode->AddProperty(wxT("name"), pi->GetName() );
    m_data->m_current->AddChild(pnode) ;
    m_data->Push( pnode ) ;
}

void wxXmlWriter::DoEndWriteProperty(const wxPropertyInfo *WXUNUSED(propInfo) )
{
    m_data->Pop() ;
}


// 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(wxT("href")), wxString::Format( wxT("%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) ;
}

// writes a delegate in the stream format
void wxXmlWriter::DoWriteDelegate( const wxObject *WXUNUSED(object),  const wxClassInfo* WXUNUSED(classInfo) , const wxPropertyInfo *WXUNUSED(pi) ,
                                  const wxObject *eventSink, int sinkObjectID , const wxClassInfo* WXUNUSED(eventSinkClassInfo) , const wxHandlerInfo* handlerInfo )
{
    if ( eventSink != NULL && handlerInfo != NULL )
    {
        wxXmlAddContentToNode( m_data->m_current ,wxString::Format(wxT("%d.%s"), sinkObjectID , handlerInfo->GetName().c_str()) ) ;
    }
}

// ----------------------------------------------------------------------------
// reading objects 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)
{
    wxASSERT_MSG( callbacks , wxT("Does not support reading without a Depersistor") ) ;
    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(wxT("href") , &ObjectIdString ) )
        {
            objectID = atoi( ObjectIdString.ToAscii() ) ;
            if ( HasObjectClassInfo( objectID ) )
            {
                return objectID ;
            }
            else
            {
                wxLogError( _("Forward hrefs are not supported") ) ;
                return wxInvalidObjectID ;
            }
        }
        if ( !node->GetPropVal(wxT("id") , &ObjectIdString ) )
        {
            return wxNullObjectID;
        }
    }
    if (!node->GetPropVal(wxT("class"), &className))
    {
        // No class name.  Eek. FIXME: error handling
        return wxInvalidObjectID;
    }
    classInfo = wxClassInfo::FindClass(className);
    if ( classInfo == NULL )
    {
        wxLogError( wxString::Format(_("unknown class %s"),className ) ) ;
        return wxInvalidObjectID ;
    }

    if ( children != NULL && children->GetType() == wxXML_TEXT_NODE )
    {
        wxLogError(_("objects cannot have XML Text Nodes") ) ;
        return wxInvalidObjectID;
    }
    if (!node->GetPropVal(wxT("id"), &ObjectIdString))
    {
        wxLogError(_("Objects must have an id attribute") ) ;
        // No object id.  Eek. FIXME: error handling
        return wxInvalidObjectID;
    }
    objectID = atoi( ObjectIdString.ToAscii() ) ;
    // is this object already has been streamed in, return it here
    if ( HasObjectClassInfo( objectID ) )
    {
        wxLogError ( wxString::Format(_("Doubly used id : %d"), objectID ) ) ;
        return wxInvalidObjectID ;
    }

    // new object, start with allocation
    // first make the object know to our internal registry
    SetObjectClassInfo( objectID , classInfo ) ;

    wxxVariantArray metadata ;
    wxXmlProperty *xp = node->GetProperties() ;
    while ( xp )
    {
        if ( xp->GetName() != wxString(wxT("class")) && xp->GetName() != wxString(wxT("id")) )
        {
            metadata.Add( new wxxVariant( xp->GetValue() , xp->GetName() ) ) ;
        }
        xp = xp->GetNext() ;
    }
    if ( !classInfo->NeedsDirectConstruction() )
        callbacks->AllocateObject(objectID, classInfo, metadata);

    //
    // stream back the Create parameters first
    createParams = new wxxVariant[ classInfo->GetCreateParamCount() ] ;
    createParamOids = new int[classInfo->GetCreateParamCount() ] ;
    createClassInfos = new const wxClassInfo*[classInfo->GetCreateParamCount() ] ;

#if wxUSE_UNICODE
    typedef map<wstring, wxXmlNode *> PropertyNodes ;
    typedef vector<wstring> PropertyNames ;
#else
    typedef map<string, wxXmlNode *> PropertyNodes ;
    typedef vector<string> PropertyNames ;
#endif
    PropertyNodes propertyNodes ;
    PropertyNames propertyNames ;

    while( children )
    {
        wxString name ;
        children->GetPropVal( wxT("name") , &name ) ;
        propertyNames.push_back( (const wxChar*)name.c_str() ) ;
        propertyNodes[(const wxChar*)name.c_str()] = children->GetChildren() ;
        children = children->GetNext() ;
    }

    for ( int i = 0 ; i <classInfo->GetCreateParamCount() ; ++i )
    {
        const wxChar* paramName = classInfo->GetCreateParamName(i) ;
        PropertyNodes::iterator propiter = propertyNodes.find( paramName ) ;
        const wxPropertyInfo* pi = classInfo->FindPropertyInfo( paramName ) ;
        if ( pi == 0 )
        {
            wxLogError( wxString::Format(_("Unkown Property %s"),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<const wxClassTypeInfo*>(pi->GetTypeInfo())->GetClassInfo() ;
            }
            else
            {
                createParamOids[i] = wxInvalidObjectID ;
                createParams[i] = ReadValue( prop , pi->GetTypeInfo() ) ;
                if( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
                {
                    const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
                    if ( eti )
                    {
                        long realval ;
                        eti->ConvertToLong( createParams[i]  , realval ) ;
                        createParams[i] = wxxVariant( realval ) ;
                    }
                    else
                    {
                        wxLogError( _("Type must have enum - long conversion") ) ;
                    }
                }
                createClassInfos[i] = NULL ;
            }

            for ( size_t j = 0 ; j < propertyNames.size() ; ++j )
            {
                if ( propertyNames[j] == paramName )
                {
                    propertyNames[j] = wxEmptyString ;
                    break ;
                }
            }
        }
        else
        {
            if ( pi->GetTypeInfo()->IsObjectType() )
            {
                createParamOids[i] = wxNullObjectID ;
                createClassInfos[i] = dynamic_cast<const wxClassTypeInfo*>(pi->GetTypeInfo())->GetClassInfo() ;
            }
            else
            {
                createParams[i] = pi->GetDefaultValue() ;
                createParamOids[i] = wxInvalidObjectID ;
            }
        }
    }

    // got the parameters.  Call the Create method
    if ( classInfo->NeedsDirectConstruction() )
        callbacks->ConstructObject(objectID, classInfo,
            classInfo->GetCreateParamCount(),
            createParams, createParamOids, createClassInfos, metadata );
    else
        callbacks->CreateObject(objectID, classInfo,
            classInfo->GetCreateParamCount(),
            createParams, createParamOids, createClassInfos, metadata );

    // 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()->GetKind() == wxT_COLLECTION )
                {
                    const wxCollectionTypeInfo* collType = dynamic_cast< const wxCollectionTypeInfo* >( pi->GetTypeInfo() ) ;
                    const wxTypeInfo * elementType = collType->GetElementType() ;
                    while( prop )
                    {
                        if ( prop->GetName() != wxT("element") )
                        {
                            wxLogError( _("A non empty collection must consist of 'element' nodes" ) ) ;
                            break ;
                        }
                        wxXmlNode* elementContent = prop->GetChildren() ;
                        if ( elementContent )
                        {
                            // we skip empty elements
                            if ( elementType->IsObjectType() )
                            {
                                int valueId = ReadComponent( elementContent , callbacks ) ;
                                if ( valueId != wxInvalidObjectID )
                                {
                                    if ( pi->GetAccessor()->HasAdder() )
                                        callbacks->AddToPropertyCollectionAsObject( objectID , classInfo , pi , valueId ) ;
                                    // TODO for collections we must have a notation on taking over ownership or not
                                    if ( elementType->GetKind() == wxT_OBJECT && valueId != wxNullObjectID )
                                        callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ;
                                }
                            }
                            else
                            {
                                wxxVariant elementValue = ReadValue( elementContent , elementType ) ;
                                if ( pi->GetAccessor()->HasAdder() )
                                    callbacks->AddToPropertyCollection( objectID , classInfo ,pi , elementValue ) ;
                            }
                        }
                        prop = prop->GetNext() ;
                    }
                }
                else if ( pi->GetTypeInfo()->IsObjectType() )
                {
                    // and object can either be streamed out a string or as an object
                    // in case we have no node, then the object's streaming out has been vetoed
                    if ( prop )
                    {
                        if ( prop->GetName() == wxT("object") )
                        {
                            int valueId = ReadComponent( prop , callbacks ) ;
                            if ( valueId != wxInvalidObjectID )
                            {
                                callbacks->SetPropertyAsObject( objectID , classInfo , pi , valueId ) ;
                                if ( pi->GetTypeInfo()->GetKind() == wxT_OBJECT && valueId != wxNullObjectID )
                                    callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ;
                            }
                        }
                        else
                        {
                            wxASSERT( pi->GetTypeInfo()->HasStringConverters() ) ;
                            wxxVariant nodeval = ReadValue( prop , pi->GetTypeInfo() ) ;
                            callbacks->SetProperty( objectID, classInfo ,pi , nodeval ) ;
                        }
                    }
                }
                else if ( pi->GetTypeInfo()->IsDelegateType() )
                {
                    if ( prop )
                    {
                        wxString resstring = prop->GetContent() ;
                        wxInt32 pos = resstring.Find('.') ;
                        if ( pos != wxNOT_FOUND )
                        {
                            int sinkOid = atol(resstring.Left(pos).ToAscii()) ;
                            wxString handlerName = resstring.Mid(pos+1) ;
                            wxClassInfo* sinkClassInfo = GetObjectClassInfo( sinkOid ) ;

                            callbacks->SetConnect( objectID , classInfo , pi , sinkClassInfo ,
                                sinkClassInfo->FindHandlerInfo(handlerName) ,  sinkOid ) ;
                        }
                        else
                        {
                            wxLogError( _("incorrect event handler string, missing dot") ) ;
                        }
                    }

                }
                else
                {
                    wxxVariant nodeval = ReadValue( prop , pi->GetTypeInfo() ) ;
                    if( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
                    {
                        const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
                        if ( eti )
                        {
                            long realval ;
                            eti->ConvertToLong( nodeval , realval ) ;
                            nodeval = wxxVariant( realval ) ;
                        }
                        else
                        {
                            wxLogError( _("Type must have enum - long conversion") ) ;
                        }
                    }
                    callbacks->SetProperty( objectID, classInfo ,pi , nodeval ) ;
                }
            }
        }
    }

    delete[] createParams ;
    delete[] createParamOids ;
    delete[] createClassInfos ;

    return objectID;
}

wxxVariant wxXmlReader::ReadValue(wxXmlNode *node,
                                  const wxTypeInfo *type )
{
    wxString content ;
    if ( node )
        content = node->GetContent() ;
    wxxVariant result ;
    type->ConvertFromString( content , result ) ;
    return result ;
}

int wxXmlReader::ReadObject( const wxString &name , wxDepersister *callbacks)
{
    wxXmlNode *iter = m_parent->GetChildren() ;
    while ( iter )
    {
        wxString entryName ;
        if ( iter->GetPropVal(wxT("name"), &entryName) )
        {
            if ( entryName == name )
                return ReadComponent( iter->GetChildren() , callbacks ) ;
        }
        iter = iter->GetNext() ;
    }
    return wxInvalidObjectID ;
}

#endif // wxUSE_EXTENDED_RTTI
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/common/xtixml.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	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#if wxUSE_EXTENDED_RTTI
	20
	21	#include "wx/xtixml.h"
	22
	23	#ifndef WX_PRECOMP
	24	#include "wx/object.h"
	25	#include "wx/hash.h"
	26	#include "wx/event.h"
	27	#endif
	28
	29	#include "wx/xml/xml.h"
	30	#include "wx/tokenzr.h"
	31	#include "wx/txtstrm.h"
	32
	33	#include "wx/xtistrm.h"
	34
	35	#include "wx/beforestd.h"
	36	#include <map>
	37	#include <vector>
	38	#include <string>
	39	#include "wx/afterstd.h"
	40
	41	using namespace std ;
	42
	43	//
	44	// XML Streaming
	45	//
	46
	47	// convenience functions
	48
	49	void wxXmlAddContentToNode( wxXmlNode* node , const wxString& data )
	50	{
	51	node->AddChild(new wxXmlNode(wxXML_TEXT_NODE, wxT("value"), data ) );
	52	}
	53
	54	wxString wxXmlGetContentFromNode( wxXmlNode *node )
	55	{
	56	if ( node->GetChildren() )
	57	return node->GetChildren()->GetContent() ;
	58	else
	59	return wxEmptyString ;
	60	}
	61
	62	struct wxXmlWriter::wxXmlWriterInternal
	63	{
	64	wxXmlNode *m_root ;
	65	wxXmlNode *m_current ;
	66	vector< wxXmlNode * > m_objectStack ;
	67
	68	void Push( wxXmlNode *newCurrent )
	69	{
	70	m_objectStack.push_back( m_current ) ;
	71	m_current = newCurrent ;
	72	}
	73
	74	void Pop()
	75	{
	76	m_current = m_objectStack.back() ;
	77	m_objectStack.pop_back() ;
	78	}
	79	} ;
	80
	81	wxXmlWriter::wxXmlWriter( wxXmlNode * rootnode )
	82	{
	83	m_data = new wxXmlWriterInternal() ;
	84	m_data->m_root = rootnode ;
	85	m_data->m_current = rootnode ;
	86	}
	87
	88	wxXmlWriter::~wxXmlWriter()
	89	{
	90	delete m_data ;
	91	}
	92
	93	void wxXmlWriter::DoBeginWriteTopLevelEntry( const wxString &name )
	94	{
	95	wxXmlNode *pnode;
	96	pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("entry"));
	97	pnode->AddProperty(wxString(wxT("name")), name);
	98	m_data->m_current->AddChild(pnode) ;
	99	m_data->Push( pnode ) ;
	100	}
	101
	102	void wxXmlWriter::DoEndWriteTopLevelEntry( const wxString &WXUNUSED(name) )
	103	{
	104	m_data->Pop() ;
	105	}
	106
	107	void wxXmlWriter::DoBeginWriteObject(const wxObject WXUNUSED(object), const wxClassInfo classInfo, int objectID , wxxVariantArray &metadata )
	108	{
	109	wxXmlNode *pnode;
	110	pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
	111	pnode->AddProperty(wxT("class"), wxString(classInfo->GetClassName()));
	112	pnode->AddProperty(wxT("id"), wxString::Format( wxT("%d") , objectID ) );
	113
	114	for ( size_t i = 0 ; i < metadata.GetCount() ; ++i )
	115	{
	116	pnode->AddProperty( metadata[i].GetName() , metadata[i].GetAsString() ) ;
	117	}
	118	m_data->m_current->AddChild(pnode) ;
	119	m_data->Push( pnode ) ;
	120	}
	121
	122	// end of writing the root object
	123	void wxXmlWriter::DoEndWriteObject(const wxObject WXUNUSED(object), const wxClassInfo WXUNUSED(classInfo), int WXUNUSED(objectID) )
	124	{
	125	m_data->Pop() ;
	126	}
	127
	128	// writes a property in the stream format
	129	void wxXmlWriter::DoWriteSimpleType( wxxVariant &value )
	130	{
	131	wxXmlAddContentToNode( m_data->m_current ,value.GetAsString() ) ;
	132	}
	133
	134	void wxXmlWriter::DoBeginWriteElement()
	135	{
	136	wxXmlNode *pnode;
	137	pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("element") );
	138	m_data->m_current->AddChild(pnode) ;
	139	m_data->Push( pnode ) ;
	140	}
	141
	142	void wxXmlWriter::DoEndWriteElement()
	143	{
	144	m_data->Pop() ;
	145	}
	146
	147	void wxXmlWriter::DoBeginWriteProperty(const wxPropertyInfo *pi )
	148	{
	149	wxXmlNode *pnode;
	150	pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("prop") );
	151	pnode->AddProperty(wxT("name"), pi->GetName() );
	152	m_data->m_current->AddChild(pnode) ;
	153	m_data->Push( pnode ) ;
	154	}
	155
	156	void wxXmlWriter::DoEndWriteProperty(const wxPropertyInfo *WXUNUSED(propInfo) )
	157	{
	158	m_data->Pop() ;
	159	}
	160
	161
	162
	163	// insert an object reference to an already written object
	164	void wxXmlWriter::DoWriteRepeatedObject( int objectID )
	165	{
	166	wxXmlNode *pnode;
	167	pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
	168	pnode->AddProperty(wxString(wxT("href")), wxString::Format( wxT("%d") , objectID ) );
	169	m_data->m_current->AddChild(pnode) ;
	170	}
	171
	172	// insert a null reference
	173	void wxXmlWriter::DoWriteNullObject()
	174	{
	175	wxXmlNode *pnode;
	176	pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
	177	m_data->m_current->AddChild(pnode) ;
	178	}
	179
	180	// writes a delegate in the stream format
	181	void wxXmlWriter::DoWriteDelegate( const wxObject WXUNUSED(object), const wxClassInfo WXUNUSED(classInfo) , const wxPropertyInfo *WXUNUSED(pi) ,
	182	const wxObject eventSink, int sinkObjectID , const wxClassInfo WXUNUSED(eventSinkClassInfo) , const wxHandlerInfo* handlerInfo )
	183	{
	184	if ( eventSink != NULL && handlerInfo != NULL )
	185	{
	186	wxXmlAddContentToNode( m_data->m_current ,wxString::Format(wxT("%d.%s"), sinkObjectID , handlerInfo->GetName().c_str()) ) ;
	187	}
	188	}
	189
	190	// ----------------------------------------------------------------------------
	191	// reading objects in
	192	// ----------------------------------------------------------------------------
	193
	194
	195
	196	// ----------------------------------------------------------------------------
	197	// reading xml in
	198	// ----------------------------------------------------------------------------
	199
	200	/*
	201	Reading components has not to be extended for components
	202	as properties are always sought by typeinfo over all levels
	203	and create params are always toplevel class only
	204	*/
	205
	206	int wxXmlReader::ReadComponent(wxXmlNode node, wxDepersister callbacks)
	207	{
	208	wxASSERT_MSG( callbacks , wxT("Does not support reading without a Depersistor") ) ;
	209	wxString className;
	210	wxClassInfo *classInfo;
	211
	212	wxxVariant *createParams ;
	213	int *createParamOids ;
	214	const wxClassInfo** createClassInfos ;
	215	wxXmlNode *children;
	216	int objectID;
	217	wxString ObjectIdString ;
	218
	219	children = node->GetChildren();
	220	if (!children)
	221	{
	222	// check for a null object or href
	223	if (node->GetPropVal(wxT("href") , &ObjectIdString ) )
	224	{
	225	objectID = atoi( ObjectIdString.ToAscii() ) ;
	226	if ( HasObjectClassInfo( objectID ) )
	227	{
	228	return objectID ;
	229	}
	230	else
	231	{
	232	wxLogError( _("Forward hrefs are not supported") ) ;
	233	return wxInvalidObjectID ;
	234	}
	235	}
	236	if ( !node->GetPropVal(wxT("id") , &ObjectIdString ) )
	237	{
	238	return wxNullObjectID;
	239	}
	240	}
	241	if (!node->GetPropVal(wxT("class"), &className))
	242	{
	243	// No class name. Eek. FIXME: error handling
	244	return wxInvalidObjectID;
	245	}
	246	classInfo = wxClassInfo::FindClass(className);
	247	if ( classInfo == NULL )
	248	{
	249	wxLogError( wxString::Format(_("unknown class %s"),className ) ) ;
	250	return wxInvalidObjectID ;
	251	}
	252
	253	if ( children != NULL && children->GetType() == wxXML_TEXT_NODE )
	254	{
	255	wxLogError(_("objects cannot have XML Text Nodes") ) ;
	256	return wxInvalidObjectID;
	257	}
	258	if (!node->GetPropVal(wxT("id"), &ObjectIdString))
	259	{
	260	wxLogError(_("Objects must have an id attribute") ) ;
	261	// No object id. Eek. FIXME: error handling
	262	return wxInvalidObjectID;
	263	}
	264	objectID = atoi( ObjectIdString.ToAscii() ) ;
	265	// is this object already has been streamed in, return it here
	266	if ( HasObjectClassInfo( objectID ) )
	267	{
	268	wxLogError ( wxString::Format(_("Doubly used id : %d"), objectID ) ) ;
	269	return wxInvalidObjectID ;
	270	}
	271
	272	// new object, start with allocation
	273	// first make the object know to our internal registry
	274	SetObjectClassInfo( objectID , classInfo ) ;
	275
	276	wxxVariantArray metadata ;
	277	wxXmlProperty *xp = node->GetProperties() ;
	278	while ( xp )
	279	{
	280	if ( xp->GetName() != wxString(wxT("class")) && xp->GetName() != wxString(wxT("id")) )
	281	{
	282	metadata.Add( new wxxVariant( xp->GetValue() , xp->GetName() ) ) ;
	283	}
	284	xp = xp->GetNext() ;
	285	}
	286	if ( !classInfo->NeedsDirectConstruction() )
	287	callbacks->AllocateObject(objectID, classInfo, metadata);
	288
	289	//
	290	// stream back the Create parameters first
	291	createParams = new wxxVariant[ classInfo->GetCreateParamCount() ] ;
	292	createParamOids = new int[classInfo->GetCreateParamCount() ] ;
	293	createClassInfos = new const wxClassInfo*[classInfo->GetCreateParamCount() ] ;
	294
	295	#if wxUSE_UNICODE
	296	typedef map<wstring, wxXmlNode *> PropertyNodes ;
	297	typedef vector<wstring> PropertyNames ;
	298	#else
	299	typedef map<string, wxXmlNode *> PropertyNodes ;
	300	typedef vector<string> PropertyNames ;
	301	#endif
	302	PropertyNodes propertyNodes ;
	303	PropertyNames propertyNames ;
	304
	305	while( children )
	306	{
	307	wxString name ;
	308	children->GetPropVal( wxT("name") , &name ) ;
	309	propertyNames.push_back( (const wxChar*)name.c_str() ) ;
	310	propertyNodes[(const wxChar*)name.c_str()] = children->GetChildren() ;
	311	children = children->GetNext() ;
	312	}
	313
	314	for ( int i = 0 ; i <classInfo->GetCreateParamCount() ; ++i )
	315	{
	316	const wxChar* paramName = classInfo->GetCreateParamName(i) ;
	317	PropertyNodes::iterator propiter = propertyNodes.find( paramName ) ;
	318	const wxPropertyInfo* pi = classInfo->FindPropertyInfo( paramName ) ;
	319	if ( pi == 0 )
	320	{
	321	wxLogError( wxString::Format(_("Unkown Property %s"),paramName) ) ;
	322	}
	323	// if we don't have the value of a create param set in the xml
	324	// we use the default value
	325	if ( propiter != propertyNodes.end() )
	326	{
	327	wxXmlNode* prop = propiter->second ;
	328	if ( pi->GetTypeInfo()->IsObjectType() )
	329	{
	330	createParamOids[i] = ReadComponent( prop , callbacks ) ;
	331	createClassInfos[i] = dynamic_cast<const wxClassTypeInfo*>(pi->GetTypeInfo())->GetClassInfo() ;
	332	}
	333	else
	334	{
	335	createParamOids[i] = wxInvalidObjectID ;
	336	createParams[i] = ReadValue( prop , pi->GetTypeInfo() ) ;
	337	if( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
	338	{
	339	const wxEnumTypeInfo eti = dynamic_cast<const wxEnumTypeInfo>( pi->GetTypeInfo() ) ;
	340	if ( eti )
	341	{
	342	long realval ;
	343	eti->ConvertToLong( createParams[i] , realval ) ;
	344	createParams[i] = wxxVariant( realval ) ;
	345	}
	346	else
	347	{
	348	wxLogError( _("Type must have enum - long conversion") ) ;
	349	}
	350	}
	351	createClassInfos[i] = NULL ;
	352	}
	353
	354	for ( size_t j = 0 ; j < propertyNames.size() ; ++j )
	355	{
	356	if ( propertyNames[j] == paramName )
	357	{
	358	propertyNames[j] = wxEmptyString ;
	359	break ;
	360	}
	361	}
	362	}
	363	else
	364	{
	365	if ( pi->GetTypeInfo()->IsObjectType() )
	366	{
	367	createParamOids[i] = wxNullObjectID ;
	368	createClassInfos[i] = dynamic_cast<const wxClassTypeInfo*>(pi->GetTypeInfo())->GetClassInfo() ;
	369	}
	370	else
	371	{
	372	createParams[i] = pi->GetDefaultValue() ;
	373	createParamOids[i] = wxInvalidObjectID ;
	374	}
	375	}
	376	}
	377
	378	// got the parameters. Call the Create method
	379	if ( classInfo->NeedsDirectConstruction() )
	380	callbacks->ConstructObject(objectID, classInfo,
	381	classInfo->GetCreateParamCount(),
	382	createParams, createParamOids, createClassInfos, metadata );
	383	else
	384	callbacks->CreateObject(objectID, classInfo,
	385	classInfo->GetCreateParamCount(),
	386	createParams, createParamOids, createClassInfos, metadata );
	387
	388	// now stream in the rest of the properties, in the sequence their properties were written in the xml
	389	for ( size_t j = 0 ; j < propertyNames.size() ; ++j )
	390	{
	391	if ( propertyNames[j].length() )
	392	{
	393	PropertyNodes::iterator propiter = propertyNodes.find( propertyNames[j] ) ;
	394	if ( propiter != propertyNodes.end() )
	395	{
	396	wxXmlNode* prop = propiter->second ;
	397	const wxPropertyInfo* pi = classInfo->FindPropertyInfo( propertyNames[j].c_str() ) ;
	398	if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION )
	399	{
	400	const wxCollectionTypeInfo* collType = dynamic_cast< const wxCollectionTypeInfo* >( pi->GetTypeInfo() ) ;
	401	const wxTypeInfo * elementType = collType->GetElementType() ;
	402	while( prop )
	403	{
	404	if ( prop->GetName() != wxT("element") )
	405	{
	406	wxLogError( _("A non empty collection must consist of 'element' nodes" ) ) ;
	407	break ;
	408	}
	409	wxXmlNode* elementContent = prop->GetChildren() ;
	410	if ( elementContent )
	411	{
	412	// we skip empty elements
	413	if ( elementType->IsObjectType() )
	414	{
	415	int valueId = ReadComponent( elementContent , callbacks ) ;
	416	if ( valueId != wxInvalidObjectID )
	417	{
	418	if ( pi->GetAccessor()->HasAdder() )
	419	callbacks->AddToPropertyCollectionAsObject( objectID , classInfo , pi , valueId ) ;
	420	// TODO for collections we must have a notation on taking over ownership or not
	421	if ( elementType->GetKind() == wxT_OBJECT && valueId != wxNullObjectID )
	422	callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ;
	423	}
	424	}
	425	else
	426	{
	427	wxxVariant elementValue = ReadValue( elementContent , elementType ) ;
	428	if ( pi->GetAccessor()->HasAdder() )
	429	callbacks->AddToPropertyCollection( objectID , classInfo ,pi , elementValue ) ;
	430	}
	431	}
	432	prop = prop->GetNext() ;
	433	}
	434	}
	435	else if ( pi->GetTypeInfo()->IsObjectType() )
	436	{
	437	// and object can either be streamed out a string or as an object
	438	// in case we have no node, then the object's streaming out has been vetoed
	439	if ( prop )
	440	{
	441	if ( prop->GetName() == wxT("object") )
	442	{
	443	int valueId = ReadComponent( prop , callbacks ) ;
	444	if ( valueId != wxInvalidObjectID )
	445	{
	446	callbacks->SetPropertyAsObject( objectID , classInfo , pi , valueId ) ;
	447	if ( pi->GetTypeInfo()->GetKind() == wxT_OBJECT && valueId != wxNullObjectID )
	448	callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ;
	449	}
	450	}
	451	else
	452	{
	453	wxASSERT( pi->GetTypeInfo()->HasStringConverters() ) ;
	454	wxxVariant nodeval = ReadValue( prop , pi->GetTypeInfo() ) ;
	455	callbacks->SetProperty( objectID, classInfo ,pi , nodeval ) ;
	456	}
	457	}
	458	}
	459	else if ( pi->GetTypeInfo()->IsDelegateType() )
	460	{
	461	if ( prop )
	462	{
	463	wxString resstring = prop->GetContent() ;
	464	wxInt32 pos = resstring.Find('.') ;
	465	if ( pos != wxNOT_FOUND )
	466	{
	467	int sinkOid = atol(resstring.Left(pos).ToAscii()) ;
	468	wxString handlerName = resstring.Mid(pos+1) ;
	469	wxClassInfo* sinkClassInfo = GetObjectClassInfo( sinkOid ) ;
	470
	471	callbacks->SetConnect( objectID , classInfo , pi , sinkClassInfo ,
	472	sinkClassInfo->FindHandlerInfo(handlerName) , sinkOid ) ;
	473	}
	474	else
	475	{
	476	wxLogError( _("incorrect event handler string, missing dot") ) ;
	477	}
	478	}
	479
	480	}
	481	else
	482	{
	483	wxxVariant nodeval = ReadValue( prop , pi->GetTypeInfo() ) ;
	484	if( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
	485	{
	486	const wxEnumTypeInfo eti = dynamic_cast<const wxEnumTypeInfo>( pi->GetTypeInfo() ) ;
	487	if ( eti )
	488	{
	489	long realval ;
	490	eti->ConvertToLong( nodeval , realval ) ;
	491	nodeval = wxxVariant( realval ) ;
	492	}
	493	else
	494	{
	495	wxLogError( _("Type must have enum - long conversion") ) ;
	496	}
	497	}
	498	callbacks->SetProperty( objectID, classInfo ,pi , nodeval ) ;
	499	}
	500	}
	501	}
	502	}
	503
	504	delete[] createParams ;
	505	delete[] createParamOids ;
	506	delete[] createClassInfos ;
	507
	508	return objectID;
	509	}
	510
	511	wxxVariant wxXmlReader::ReadValue(wxXmlNode *node,
	512	const wxTypeInfo *type )
	513	{
	514	wxString content ;
	515	if ( node )
	516	content = node->GetContent() ;
	517	wxxVariant result ;
	518	type->ConvertFromString( content , result ) ;
	519	return result ;
	520	}
	521
	522	int wxXmlReader::ReadObject( const wxString &name , wxDepersister *callbacks)
	523	{
	524	wxXmlNode *iter = m_parent->GetChildren() ;
	525	while ( iter )
	526	{
	527	wxString entryName ;
	528	if ( iter->GetPropVal(wxT("name"), &entryName) )
	529	{
	530	if ( entryName == name )
	531	return ReadComponent( iter->GetChildren() , callbacks ) ;
	532	}
	533	iter = iter->GetNext() ;
	534	}
	535	return wxInvalidObjectID ;
	536	}
	537
	538	#endif // wxUSE_EXTENDED_RTTI