src/common/xtixml.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/xtixml.cpp
// Purpose:     streaming runtime metadata information
// Author:      Stefan Csomor
// Modified by:
// Created:     27/07/03
// 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/xtistrm.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/xtixml.h"

// STL headers

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

using namespace std;


// ----------------------------------------------------------------------------
// wxObjectXmlWriter
// ----------------------------------------------------------------------------

// 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 wxObjectXmlWriter::wxObjectXmlWriterInternal
{
    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();
    }
};

wxObjectXmlWriter::wxObjectXmlWriter( wxXmlNode * rootnode )
{
    m_data = new wxObjectXmlWriterInternal();
    m_data->m_root = rootnode;
    m_data->m_current = rootnode;
}

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

void wxObjectXmlWriter::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 wxObjectXmlWriter::DoEndWriteTopLevelEntry( const wxString &WXUNUSED(name) )
{
    m_data->Pop();
}

void wxObjectXmlWriter::DoBeginWriteObject(const wxObject *WXUNUSED(object),
                                     const wxClassInfo *classInfo,
                                     int objectID, const wxStringToAnyHashMap &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 ) );

    wxStringToAnyHashMap::const_iterator it, en;
    for( it = metadata.begin(), en = metadata.end(); it != en; ++it )
    {
        pnode->AddProperty( it->first, wxAnyGetAsString(it->second) );
    }

    m_data->m_current->AddChild(pnode);
    m_data->Push( pnode );
}

void wxObjectXmlWriter::DoEndWriteObject(const wxObject *WXUNUSED(object),
                                   const wxClassInfo *WXUNUSED(classInfo),
                                   int WXUNUSED(objectID) )
{
    m_data->Pop();
}

void wxObjectXmlWriter::DoWriteSimpleType( const wxAny &value )
{
    wxXmlAddContentToNode( m_data->m_current,wxAnyGetAsString(value) );
}

void wxObjectXmlWriter::DoBeginWriteElement()
{
    wxXmlNode *pnode;
    pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("element") );
    m_data->m_current->AddChild(pnode);
    m_data->Push( pnode );
}

void wxObjectXmlWriter::DoEndWriteElement()
{
    m_data->Pop();
}

void wxObjectXmlWriter::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 wxObjectXmlWriter::DoEndWriteProperty(const wxPropertyInfo *WXUNUSED(propInfo) )
{
    m_data->Pop();
}

void wxObjectXmlWriter::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);
}

void wxObjectXmlWriter::DoWriteNullObject()
{
    wxXmlNode *pnode;
    pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
    m_data->m_current->AddChild(pnode);
}

void wxObjectXmlWriter::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()) );
    }
}


// ----------------------------------------------------------------------------
// wxObjectXmlReader
// ----------------------------------------------------------------------------

/*
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 wxObjectXmlReader::ReadComponent(wxXmlNode *node, wxObjectReaderCallback *callbacks)
{
    wxASSERT_MSG( callbacks, wxT("Does not support reading without a Depersistor") );
    wxString className;
    wxClassInfo *classInfo;

    wxAny *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->GetAttribute(wxT("href"), &ObjectIdString ) )
        {
            objectID = atoi( ObjectIdString.ToAscii() );
            if ( HasObjectClassInfo( objectID ) )
            {
                return objectID;
            }
            else
            {
                wxLogError( _("Forward hrefs are not supported") );
                return wxInvalidObjectID;
            }
        }
        if ( !node->GetAttribute(wxT("id"), &ObjectIdString ) )
        {
            return wxNullObjectID;
        }
    }
    if (!node->GetAttribute(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->GetAttribute(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 );

    wxStringToAnyHashMap metadata;
    wxXmlProperty *xp = node->GetAttributes();
    while ( xp )
    {
        if ( xp->GetName() != wxString(wxT("class")) &&
             xp->GetName() != wxString(wxT("id")) )
        {
            metadata[xp->GetName()] = wxAny( xp->GetValue() );
        }
        xp = xp->GetNext();
    }
    if ( !classInfo->NeedsDirectConstruction() )
        callbacks->AllocateObject(objectID, classInfo, metadata);

    //
    // stream back the Create parameters first
    createParams = new wxAny[ 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->GetAttribute( 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(_("Unknown 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] =
                    wx_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 =
                        wx_dynamic_cast(const wxEnumTypeInfo*, pi->GetTypeInfo() );
                    if ( eti )
                    {
                        long realval;
                        eti->ConvertToLong( createParams[i], realval );
                        createParams[i] = wxAny( 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] =
                    wx_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].empty() )
        {
            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 =
                        wx_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
                            {
                                wxAny 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() );
                            wxAny 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.c_str()),  sinkOid );
                        }
                        else
                        {
                            wxLogError( _("incorrect event handler string, missing dot") );
                        }
                    }

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

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

    return objectID;
}

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

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