src/common/xtixml.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/xtistrm.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
/////////////////////////////////////////////////////////////////////////////

#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
#endif

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

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

#if wxUSE_EXTENDED_RTTI

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