updated wxExecute checks in wxGTK to be same as in other Unix ports after recent...

[wxWidgets.git] / src / common / xtistrm.cpp

diff --git a/src/common/xtistrm.cpp b/src/common/xtistrm.cpp
index bdd76724bd2831109fcd199dc7b97404a11b404e..20d21f6f5b366a5e5758d605ff9481ca61f7a529 100644 (file)
--- a/src/common/xtistrm.cpp
+++ b/src/common/xtistrm.cpp
@@ -1,36 +1,33 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/common/xtistrm.cpp
 /////////////////////////////////////////////////////////////////////////////
 // Name:        src/common/xtistrm.cpp

-// Purpose:     streaming runtime metadata information 
+// Purpose:     streaming runtime metadata information

 // Author:      Stefan Csomor
 // Author:      Stefan Csomor

-// Modified by: 
+// Modified by:

 // Created:     27/07/03
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 Stefan Csomor
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // 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__
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 #ifdef __BORLANDC__

-#pragma hdrstop
+    #pragma hdrstop

 #endif
 
 #endif
 

+#if wxUSE_EXTENDED_RTTI
+
+#include "wx/xtistrm.h"
+

 #ifndef WX_PRECOMP
 #ifndef WX_PRECOMP

-#include "wx/hash.h"
-#include "wx/object.h"
+    #include "wx/object.h"
+    #include "wx/hash.h"
+    #include "wx/event.h"

 #endif
 
 #include "wx/tokenzr.h"
 #endif
 
 #include "wx/tokenzr.h"

-#include "wx/xtistrm.h"

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

-#include "wx/event.h"
-
-#if wxUSE_EXTENDED_RTTI

 
 #include "wx/beforestd.h"
 #include <map>
 
 #include "wx/beforestd.h"
 #include <map>


@@ -120,7 +117,7 @@ void wxWriter::FindConnectEntry(const wxEvtHandler * evSource,const wxDelegateTy
             wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
 
             // find the match
             wxDynamicEventTableEntry *entry = (wxDynamicEventTableEntry*)node->GetData();
 
             // find the match

-            if ( entry->m_fn && 
+            if ( entry->m_fn &&

                 (dti->GetEventType() == entry->m_eventType) &&
                 (entry->m_id == -1 ) &&
                 (entry->m_eventSink != NULL ) )
                 (dti->GetEventType() == entry->m_eventType) &&
                 (entry->m_id == -1 ) &&
                 (entry->m_eventSink != NULL ) )


@@ -151,31 +148,39 @@ void wxWriter::WriteAllProperties( const wxObject * obj , const wxClassInfo* ci
     {
         wxString name = ci->GetCreateParamName(i) ;
         const wxPropertyInfo* prop = map.find(name)->second ;
     {
         wxString name = ci->GetCreateParamName(i) ;
         const wxPropertyInfo* prop = map.find(name)->second ;

-        wxASSERT_MSG( prop , wxT("Create Parameter not found in declared RTTI Parameters") ) ;
-        WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
+        if ( prop )
+        {
+            WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
+        }
+        else
+        {
+            wxLogError( _("Create Parameter not found in declared RTTI Parameters") ) ;
+        }

         map.erase( name ) ;
     }
         map.erase( name ) ;
     }

-
-    for( wxPropertyInfoMap::iterator iter = map.begin() ; iter != map.end() ; ++iter )
-    {
-        const wxPropertyInfo* prop = iter->second ;
-        if ( prop->GetFlags() & wxPROP_OBJECT_GRAPH )
+    { // Extra block for broken compilers
+        for( wxPropertyInfoMap::iterator iter = map.begin() ; iter != map.end() ; ++iter )

         {
         {

-            WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
+            const wxPropertyInfo* prop = iter->second ;
+            if ( prop->GetFlags() & wxPROP_OBJECT_GRAPH )
+            {
+                WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
+            }

         }
     }
         }
     }

-
-    for( wxPropertyInfoMap::iterator iter = map.begin() ; iter != map.end() ; ++iter )
-    {
-        const wxPropertyInfo* prop = iter->second ;
-        if ( !(prop->GetFlags() & wxPROP_OBJECT_GRAPH) )
+    { // Extra block for broken compilers
+        for( wxPropertyInfoMap::iterator iter = map.begin() ; iter != map.end() ; ++iter )

         {
         {

-            WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
+            const wxPropertyInfo* prop = iter->second ;
+            if ( !(prop->GetFlags() & wxPROP_OBJECT_GRAPH) )
+            {
+                WriteOneProperty( obj , prop->GetDeclaringClass() , prop , persister , data ) ;
+            }

         }
     }
 }
 
         }
     }
 }
 

-void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , const wxPropertyInfo* pi , wxPersister *persister , wxWriterInternalPropertiesData *WXUNUSED(data) ) 
+void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , const wxPropertyInfo* pi , wxPersister *persister , wxWriterInternalPropertiesData *WXUNUSED(data) )

 {
     if ( pi->GetFlags() & wxPROP_DONT_STREAM )
         return ;
 {
     if ( pi->GetFlags() & wxPROP_DONT_STREAM )
         return ;


@@ -185,7 +190,6 @@ void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , c
     if ( dynobj && (dynamic_cast<const wxDynamicClassInfo*>(ci) == NULL) )
         obj = dynobj->GetSuperClassInstance() ;
 
     if ( dynobj && (dynamic_cast<const wxDynamicClassInfo*>(ci) == NULL) )
         obj = dynobj->GetSuperClassInstance() ;
 

-    DoBeginWriteProperty( pi ) ;

     if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION )
     {
         wxxVariantArray data ;
     if ( pi->GetTypeInfo()->GetKind() == wxT_COLLECTION )
     {
         wxxVariantArray data ;


@@ -193,9 +197,12 @@ void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , c
         const wxTypeInfo * elementType = dynamic_cast< const wxCollectionTypeInfo* >( pi->GetTypeInfo() )->GetElementType() ;
         for ( size_t i = 0 ; i < data.GetCount() ; ++i )
         {
         const wxTypeInfo * elementType = dynamic_cast< const wxCollectionTypeInfo* >( pi->GetTypeInfo() )->GetElementType() ;
         for ( size_t i = 0 ; i < data.GetCount() ; ++i )
         {

+            if ( i == 0 )
+                DoBeginWriteProperty( pi ) ;
+

             DoBeginWriteElement() ;
             wxxVariant value = data[i] ;
             DoBeginWriteElement() ;
             wxxVariant value = data[i] ;

-            if ( persister->BeforeWriteProperty( this , pi , value ) )
+            if ( persister->BeforeWriteProperty( this , obj, pi , value ) )

             {
                 const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( elementType ) ;
                 if ( cti )
             {
                 const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( elementType ) ;
                 if ( cti )


@@ -207,12 +214,14 @@ void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , c
                 }
                 else
                 {
                 }
                 else
                 {

-                     DoWriteSimpleType( value ) ;
+                    DoWriteSimpleType( value ) ;

                 }
             }
             DoEndWriteElement() ;
                 }
             }
             DoEndWriteElement() ;

-        }
-    }
+            if ( i == data.GetCount() - 1 )
+                 DoEndWriteProperty( pi ) ;
+       }
+   }

     else
     {
         const wxDelegateTypeInfo* dti = dynamic_cast< const wxDelegateTypeInfo* > ( pi->GetTypeInfo() ) ;
     else
     {
         const wxDelegateTypeInfo* dti = dynamic_cast< const wxDelegateTypeInfo* > ( pi->GetTypeInfo() ) ;


@@ -222,49 +231,97 @@ void wxWriter::WriteOneProperty( const wxObject *obj , const wxClassInfo* ci , c
             const wxHandlerInfo *handler = NULL ;
 
             const wxEvtHandler * evSource = dynamic_cast<const wxEvtHandler *>(obj) ;
             const wxHandlerInfo *handler = NULL ;
 
             const wxEvtHandler * evSource = dynamic_cast<const wxEvtHandler *>(obj) ;

-            wxASSERT_MSG( evSource , wxT("Illegal Object Class (Non-wxEvtHandler) as Event Source") ) ;
-
-            FindConnectEntry( evSource , dti , sink , handler ) ;
-            if ( persister->BeforeWriteDelegate( this , obj , ci , pi , sink , handler ) )
+            if ( evSource )

             {
             {

-                if ( sink != NULL && handler != NULL )
+                FindConnectEntry( evSource , dti , sink , handler ) ;
+                if ( persister->BeforeWriteDelegate( this , obj , ci , pi , sink , handler ) )

                 {
                 {

-                    wxASSERT_MSG( IsObjectKnown( sink ) , wxT("Streaming delegates for not already streamed objects not yet supported") ) ;
-                    DoWriteDelegate( obj , ci , pi , sink , GetObjectID( sink ) , sink->GetClassInfo() , handler ) ;
+                    if ( sink != NULL && handler != NULL )
+                    {
+                        DoBeginWriteProperty( pi ) ;
+                        if ( IsObjectKnown( sink ) )
+                        {
+                            DoWriteDelegate( obj , ci , pi , sink , GetObjectID( sink ) , sink->GetClassInfo() , handler ) ;
+                            DoEndWriteProperty( pi ) ;
+                        }
+                        else
+                        {
+                            wxLogError( _("Streaming delegates for not already streamed objects not yet supported") ) ;
+                        }
+                    }

                 }
             }
                 }
             }

+            else
+            {
+                wxLogError(_("Illegal Object Class (Non-wxEvtHandler) as Event Source") ) ;
+            }

         }
         else
         {
             wxxVariant value ;
             pi->GetAccessor()->GetProperty(obj, value) ;
         }
         else
         {
             wxxVariant value ;
             pi->GetAccessor()->GetProperty(obj, value) ;

-            if ( persister->BeforeWriteProperty( this , pi , value ) )
+
+            // avoid streaming out void objects
+            if( value.IsEmpty() )
+                return ;
+
+            if ( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
+            {
+                const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
+                if ( eti )
+                {
+                    eti->ConvertFromLong( value.wxTEMPLATED_MEMBER_CALL(Get , long) , value ) ;
+                }
+                else
+                {
+                    wxLogError( _("Type must have enum - long conversion") ) ;
+                }
+            }
+
+            // avoid streaming out default values
+            if ( pi->GetTypeInfo()->HasStringConverters() && !pi->GetDefaultValue().IsEmpty() )

             {
             {

-                const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( pi->GetTypeInfo() ) ;
+                if ( value.GetAsString() == pi->GetDefaultValue().GetAsString() )
+                    return ;
+            }
+
+            // avoid streaming out null objects
+            const wxClassTypeInfo* cti = dynamic_cast< const wxClassTypeInfo* > ( pi->GetTypeInfo() ) ;
+
+            if ( cti && value.GetAsObject() == NULL )
+                return ;
+
+            if ( persister->BeforeWriteProperty( this , obj, pi , value ) )
+            {
+                DoBeginWriteProperty( pi ) ;

                 if ( cti )
                 {
                     const wxClassInfo* pci = cti->GetClassInfo() ;
                     wxObject *vobj = pci->VariantToInstance( value ) ;
                 if ( cti )
                 {
                     const wxClassInfo* pci = cti->GetClassInfo() ;
                     wxObject *vobj = pci->VariantToInstance( value ) ;

-                    wxxVariantArray md ;
-                    WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT , md) ;
-                }
-                else
-                {                        
-                    if ( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
+                    if ( vobj && pi->GetTypeInfo()->HasStringConverters() )

                     {
                     {

-                        const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
-                        wxASSERT_MSG( eti , wxT("Type must have enum - long conversion") ) ;
-                        eti->ConvertFromLong( value.Get<long>() , value ) ;
+                        wxString stringValue ;
+                        cti->ConvertToString( value , stringValue ) ;
+                        wxxVariant convertedValue(stringValue) ;
+                        DoWriteSimpleType( convertedValue ) ;

                     }
                     }

+                    else
+                    {
+                        wxxVariantArray md ;
+                        WriteObject( vobj , (vobj ? vobj->GetClassInfo() : pci ) , persister , cti->GetKind()== wxT_OBJECT , md) ;
+                    }
+                }
+                else
+                {

                     DoWriteSimpleType( value ) ;
                 }
                     DoWriteSimpleType( value ) ;
                 }

+                DoEndWriteProperty( pi ) ;

             }
         }
     }
             }
         }
     }

-    DoEndWriteProperty( pi ) ;

 }
 
 }
 

-int wxWriter::GetObjectID(const wxObject *obj) 
+int wxWriter::GetObjectID(const wxObject *obj)

 {
     if ( !IsObjectKnown( obj ) )
         return wxInvalidObjectID ;
 {
     if ( !IsObjectKnown( obj ) )
         return wxInvalidObjectID ;


@@ -272,14 +329,14 @@ int wxWriter::GetObjectID(const wxObject *obj)
     return m_data->m_writtenObjects[obj] ;
 }
 
     return m_data->m_writtenObjects[obj] ;
 }
 

-bool wxWriter::IsObjectKnown( const wxObject *obj ) 
+bool wxWriter::IsObjectKnown( const wxObject *obj )

 {
     return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end() ;
 }
 
 
 // ----------------------------------------------------------------------------
 {
     return m_data->m_writtenObjects.find( obj ) != m_data->m_writtenObjects.end() ;
 }
 
 
 // ----------------------------------------------------------------------------

-// reading objects in 
+// reading objects in

 // ----------------------------------------------------------------------------
 
 struct wxReader::wxReaderInternal
 // ----------------------------------------------------------------------------
 
 struct wxReader::wxReaderInternal


@@ -287,7 +344,7 @@ struct wxReader::wxReaderInternal
     map<int,wxClassInfo*> m_classInfos;
 };
 
     map<int,wxClassInfo*> m_classInfos;
 };
 

-wxReader::wxReader() 
+wxReader::wxReader()

 {
     m_data = new wxReaderInternal;
 }
 {
     m_data = new wxReaderInternal;
 }


@@ -299,27 +356,50 @@ wxReader::~wxReader()
 
 wxClassInfo* wxReader::GetObjectClassInfo(int objectID)
 {
 
 wxClassInfo* wxReader::GetObjectClassInfo(int objectID)
 {

-    assert( m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() );
+    if ( objectID == wxNullObjectID || objectID == wxInvalidObjectID )
+    {
+        wxLogError( _("Invalid or Null Object ID passed to GetObjectClassInfo" ) ) ;
+        return NULL ;
+    }
+    if ( m_data->m_classInfos.find(objectID) == m_data->m_classInfos.end() )
+    {
+        wxLogError( _("Unknown Object passed to GetObjectClassInfo" ) ) ;
+        return NULL ;
+    }

     return m_data->m_classInfos[objectID] ;
 }
 
 void wxReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo )
 {
     return m_data->m_classInfos[objectID] ;
 }
 
 void wxReader::SetObjectClassInfo(int objectID, wxClassInfo *classInfo )
 {

-    assert(  m_data->m_classInfos.find(objectID) == m_data->m_classInfos.end()  ) ;
+    if ( objectID == wxNullObjectID || objectID == wxInvalidObjectID )
+    {
+        wxLogError( _("Invalid or Null Object ID passed to GetObjectClassInfo" ) ) ;
+        return ;
+    }
+    if ( m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() )
+    {
+        wxLogError( _("Already Registered Object passed to SetObjectClassInfo" ) ) ;
+        return ;
+    }

     m_data->m_classInfos[objectID] = classInfo ;
 }
 
     m_data->m_classInfos[objectID] = classInfo ;
 }
 

-bool wxReader::HasObjectClassInfo( int objectID ) 
+bool wxReader::HasObjectClassInfo( int objectID )

 {
 {

+    if ( objectID == wxNullObjectID || objectID == wxInvalidObjectID )
+    {
+        wxLogError( _("Invalid or Null Object ID passed to HasObjectClassInfo" ) ) ;
+        return false ;
+    }

     return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() ;
 }
 
 
 // ----------------------------------------------------------------------------
     return m_data->m_classInfos.find(objectID) != m_data->m_classInfos.end() ;
 }
 
 
 // ----------------------------------------------------------------------------

-// reading xml in 
+// reading xml in

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-/* 
+/*

 Reading components has not to be extended for components
 as properties are always sought by typeinfo over all levels
 and create params are always toplevel class only
 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


@@ -327,7 +407,7 @@ and create params are always toplevel class only
 
 
 // ----------------------------------------------------------------------------
 
 
 // ----------------------------------------------------------------------------

-// depersisting to memory 
+// depersisting to memory

 // ----------------------------------------------------------------------------
 
 struct wxRuntimeDepersister::wxRuntimeDepersisterInternal
 // ----------------------------------------------------------------------------
 
 struct wxRuntimeDepersister::wxRuntimeDepersisterInternal


@@ -336,15 +416,23 @@ struct wxRuntimeDepersister::wxRuntimeDepersisterInternal
 
     void SetObject(int objectID, wxObject *obj )
     {
 
     void SetObject(int objectID, wxObject *obj )
     {

-        assert(  m_objects.find(objectID) == m_objects.end()  ) ;
+        if ( m_objects.find(objectID) != m_objects.end() )
+        {
+            wxLogError( _("Passing a already registered object to SetObject") ) ;
+            return  ;
+        }

         m_objects[objectID] = obj ;
     }
     wxObject* GetObject( int objectID )
     {
         if ( objectID == wxNullObjectID )
             return NULL ;
         m_objects[objectID] = obj ;
     }
     wxObject* GetObject( int objectID )
     {
         if ( objectID == wxNullObjectID )
             return NULL ;

+        if ( m_objects.find(objectID) == m_objects.end() )
+        {
+            wxLogError( _("Passing an unkown object to GetObject") ) ;
+            return NULL ;
+        }

 
 

-        assert(  m_objects.find(objectID) != m_objects.end()  ) ;

         return m_objects[objectID] ;
     }
 } ;
         return m_objects[objectID] ;
     }
 } ;


@@ -396,7 +484,37 @@ void wxRuntimeDepersister::CreateObject(int objectID,
     classInfo->Create(o, paramCount, params);
 }
 
     classInfo->Create(o, paramCount, params);
 }
 

-void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) 
+void wxRuntimeDepersister::ConstructObject(int objectID,
+                                        const wxClassInfo *classInfo,
+                                        int paramCount,
+                                        wxxVariant *params,
+                                        int *objectIdValues,
+                                        const wxClassInfo **objectClassInfos ,
+                                        wxxVariantArray &WXUNUSED(metadata))
+{
+    wxObject *o;
+    for ( int i = 0 ; i < paramCount ; ++i )
+    {
+        if ( objectIdValues[i] != wxInvalidObjectID )
+        {
+            wxObject *o;
+            o = m_data->GetObject(objectIdValues[i]);
+            // if this is a dynamic object and we are asked for another class
+            // than wxDynamicObject we cast it down manually.
+            wxDynamicObject *dyno = dynamic_cast< wxDynamicObject * > (o) ;
+            if ( dyno!=NULL && (objectClassInfos[i] != dyno->GetClassInfo()) )
+            {
+                o = dyno->GetSuperClassInstance() ;
+            }
+            params[i] = objectClassInfos[i]->InstanceToVariant(o) ;
+        }
+    }
+    o = classInfo->ConstructObject(paramCount, params);
+    m_data->SetObject(objectID, o);
+}
+
+
+void wxRuntimeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))

 {
     wxObject *o;
     o = m_data->GetObject(objectID);
 {
     wxObject *o;
     o = m_data->GetObject(objectID);


@@ -435,7 +553,7 @@ void wxRuntimeDepersister::SetPropertyAsObject(int objectID,
 
 void wxRuntimeDepersister::SetConnect(int eventSourceObjectID,
                                       const wxClassInfo *WXUNUSED(eventSourceClassInfo),
 
 void wxRuntimeDepersister::SetConnect(int eventSourceObjectID,
                                       const wxClassInfo *WXUNUSED(eventSourceClassInfo),

-                                      const wxDelegateTypeInfo *delegateInfo ,
+                                      const wxPropertyInfo *delegateInfo ,

                                       const wxClassInfo *WXUNUSED(eventSinkClassInfo) ,
                                       const wxHandlerInfo* handlerInfo ,
                                       int eventSinkObjectID )
                                       const wxClassInfo *WXUNUSED(eventSinkClassInfo) ,
                                       const wxHandlerInfo* handlerInfo ,
                                       int eventSinkObjectID )


@@ -445,9 +563,22 @@ void wxRuntimeDepersister::SetConnect(int eventSourceObjectID,
 
     if ( ehsource && ehsink )
     {
 
     if ( ehsource && ehsink )
     {

-        ehsource->Connect( -1 , delegateInfo->GetEventType() , 
-            handlerInfo->GetEventFunction() , NULL /*user data*/ , 
-            ehsink ) ;
+        const wxDelegateTypeInfo *delegateTypeInfo = dynamic_cast<const wxDelegateTypeInfo*>(delegateInfo->GetTypeInfo());
+        if( delegateTypeInfo && delegateTypeInfo->GetLastEventType() == -1 )
+        {
+            ehsource->Connect( -1 , delegateTypeInfo->GetEventType() ,
+                handlerInfo->GetEventFunction() , NULL /*user data*/ ,
+                ehsink ) ;
+        }
+        else
+        {
+            for ( wxEventType iter = delegateTypeInfo->GetEventType() ; iter <= delegateTypeInfo->GetLastEventType() ; ++iter )
+            {
+                ehsource->Connect( -1 , iter ,
+                    handlerInfo->GetEventFunction() , NULL /*user data*/ ,
+                    ehsink ) ;
+            }
+        }

     }
 }
 
     }
 }
 


@@ -460,7 +591,7 @@ wxObject *wxRuntimeDepersister::GetObject(int objectID)
 void wxRuntimeDepersister::AddToPropertyCollection( int objectID ,
                                                    const wxClassInfo *classInfo,
                                                    const wxPropertyInfo* propertyInfo ,
 void wxRuntimeDepersister::AddToPropertyCollection( int objectID ,
                                                    const wxClassInfo *classInfo,
                                                    const wxPropertyInfo* propertyInfo ,

-                                                   const wxxVariant &value) 
+                                                   const wxxVariant &value)

 {
     wxObject *o;
     o = m_data->GetObject(objectID);
 {
     wxObject *o;
     o = m_data->GetObject(objectID);


@@ -471,7 +602,7 @@ void wxRuntimeDepersister::AddToPropertyCollection( int objectID ,
 void wxRuntimeDepersister::AddToPropertyCollectionAsObject(int objectID,
                                                            const wxClassInfo *classInfo,
                                                            const wxPropertyInfo* propertyInfo ,
 void wxRuntimeDepersister::AddToPropertyCollectionAsObject(int objectID,
                                                            const wxClassInfo *classInfo,
                                                            const wxPropertyInfo* propertyInfo ,

-                                                           int valueObjectId) 
+                                                           int valueObjectId)

 {
     wxObject *o, *valo;
     o = m_data->GetObject(objectID);
 {
     wxObject *o, *valo;
     o = m_data->GetObject(objectID);


@@ -490,29 +621,42 @@ void wxRuntimeDepersister::AddToPropertyCollectionAsObject(int objectID,
 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------

-// depersisting to code 
+// depersisting to code

 // ----------------------------------------------------------------------------
 
 struct wxCodeDepersister::wxCodeDepersisterInternal
 {
 // ----------------------------------------------------------------------------
 
 struct wxCodeDepersister::wxCodeDepersisterInternal
 {

+#if wxUSE_UNICODE
+    map<int,wstring> m_objectNames ;
+#else

     map<int,string> m_objectNames ;
     map<int,string> m_objectNames ;

+#endif

 
     void SetObjectName(int objectID, const wxString &name )
     {
 
     void SetObjectName(int objectID, const wxString &name )
     {

-        assert(  m_objectNames.find(objectID) == m_objectNames.end()  ) ;
-        m_objectNames[objectID] = (const char *)name;
+        if ( m_objectNames.find(objectID) != m_objectNames.end() )
+        {
+            wxLogError( _("Passing a already registered object to SetObjectName") ) ;
+            return  ;
+        }
+        m_objectNames[objectID] = (const wxChar *)name;

     }
     }

+

     wxString GetObjectName( int objectID )
     {
         if ( objectID == wxNullObjectID )
     wxString GetObjectName( int objectID )
     {
         if ( objectID == wxNullObjectID )

-            return "NULL" ;
+            return wxT("NULL") ;

 
 

-        assert(  m_objectNames.find(objectID) != m_objectNames.end()  ) ;
+        if ( m_objectNames.find(objectID) == m_objectNames.end() )
+        {
+            wxLogError( _("Passing an unkown object to GetObject") ) ;
+            return wxEmptyString ;
+        }

         return wxString( m_objectNames[objectID].c_str() ) ;
     }
 } ;
 
         return wxString( m_objectNames[objectID].c_str() ) ;
     }
 } ;
 

-wxCodeDepersister::wxCodeDepersister(wxTextOutputStream *out) 
+wxCodeDepersister::wxCodeDepersister(wxTextOutputStream *out)

 : m_fp(out)
 {
     m_data = new wxCodeDepersisterInternal ;
 : m_fp(out)
 {
     m_data = new wxCodeDepersisterInternal ;


@@ -526,18 +670,18 @@ wxCodeDepersister::~wxCodeDepersister()
 void wxCodeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo ,
                                        wxxVariantArray &WXUNUSED(metadata))
 {
 void wxCodeDepersister::AllocateObject(int objectID, wxClassInfo *classInfo ,
                                        wxxVariantArray &WXUNUSED(metadata))
 {

-    wxString objectName = wxString::Format( "LocalObject_%d" , objectID ) ;
-    m_fp->WriteString( wxString::Format( "\t%s *%s = new %s;\n",
+    wxString objectName = wxString::Format( wxT("LocalObject_%d") , objectID ) ;
+    m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s;\n"),

         classInfo->GetClassName(),
         classInfo->GetClassName(),

-        objectName,
+        objectName.c_str(),

         classInfo->GetClassName()) );
     m_data->SetObjectName( objectID , objectName ) ;
 }
 
         classInfo->GetClassName()) );
     m_data->SetObjectName( objectID , objectName ) ;
 }
 

-void wxCodeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo)) 
+void wxCodeDepersister::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))

 {
 {

-    m_fp->WriteString( wxString::Format( "\tdelete %s;\n",
-        m_data->GetObjectName( objectID) ) );
+    m_fp->WriteString( wxString::Format( wxT("\tdelete %s;\n"),
+        m_data->GetObjectName( objectID).c_str() ) );

 }
 
 wxString wxCodeDepersister::ValueAsCode( const wxxVariant &param )
 }
 
 wxString wxCodeDepersister::ValueAsCode( const wxxVariant &param )


@@ -547,16 +691,22 @@ wxString wxCodeDepersister::ValueAsCode( const wxxVariant &param )
     if ( type->GetKind() == wxT_CUSTOM )
     {
         const wxCustomTypeInfo* cti = dynamic_cast<const wxCustomTypeInfo*>(type) ;
     if ( type->GetKind() == wxT_CUSTOM )
     {
         const wxCustomTypeInfo* cti = dynamic_cast<const wxCustomTypeInfo*>(type) ;

-        wxASSERT_MSG( cti , wxT("Internal error, illegal wxCustomTypeInfo") ) ;
-        value.Printf( "%s(%s)",cti->GetTypeName(),param.GetAsString() );
+        if ( cti )
+        {
+            value.Printf( wxT("%s(%s)"), cti->GetTypeName().c_str(),param.GetAsString().c_str() );
+        }
+        else
+        {
+            wxLogError ( _("Internal error, illegal wxCustomTypeInfo") ) ;
+        }

     }
     else if ( type->GetKind() == wxT_STRING )
     {
     }
     else if ( type->GetKind() == wxT_STRING )
     {

-        value.Printf( "\"%s\"",param.GetAsString() );
+        value.Printf( wxT("\"%s\""),param.GetAsString().c_str() );

     }
     else
     {
     }
     else
     {

-        value.Printf( "%s", param.GetAsString() );
+        value.Printf( wxT("%s"), param.GetAsString().c_str() );

     }
     return value ;
 }
     }
     return value ;
 }


@@ -571,19 +721,50 @@ void wxCodeDepersister::CreateObject(int objectID,
                                      )
 {
     int i;
                                      )
 {
     int i;

-    m_fp->WriteString( wxString::Format( "\t%s->Create(", m_data->GetObjectName(objectID) ) );
+    m_fp->WriteString( wxString::Format( wxT("\t%s->Create("), m_data->GetObjectName(objectID).c_str() ) );
+    for (i = 0; i < paramCount; i++)
+    {
+        if ( objectIDValues[i] != wxInvalidObjectID )
+            m_fp->WriteString( wxString::Format( wxT("%s"), m_data->GetObjectName( objectIDValues[i] ).c_str() ) );
+        else
+        {
+            m_fp->WriteString( wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
+        }
+        if (i < paramCount - 1)
+            m_fp->WriteString( wxT(", "));
+    }
+    m_fp->WriteString( wxT(");\n") );
+}
+
+void wxCodeDepersister::ConstructObject(int objectID,
+                                     const wxClassInfo *classInfo,
+                                     int paramCount,
+                                     wxxVariant *params,
+                                     int *objectIDValues,
+                                     const wxClassInfo **WXUNUSED(objectClassInfos) ,
+                                     wxxVariantArray &WXUNUSED(metadata)
+                                     )
+{
+    wxString objectName = wxString::Format( wxT("LocalObject_%d") , objectID ) ;
+    m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s("),
+        classInfo->GetClassName(),
+        objectName.c_str(),
+        classInfo->GetClassName()) );
+    m_data->SetObjectName( objectID , objectName ) ;
+
+    int i;

     for (i = 0; i < paramCount; i++)
     {
         if ( objectIDValues[i] != wxInvalidObjectID )
     for (i = 0; i < paramCount; i++)
     {
         if ( objectIDValues[i] != wxInvalidObjectID )

-            m_fp->WriteString( wxString::Format( "%s", m_data->GetObjectName( objectIDValues[i] ) ) );
+            m_fp->WriteString( wxString::Format( wxT("%s"), m_data->GetObjectName( objectIDValues[i] ).c_str() ) );

         else
         {
         else
         {

-            m_fp->WriteString( wxString::Format( "%s", ValueAsCode(params[i]) ) );
+            m_fp->WriteString( wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );

         }
         if (i < paramCount - 1)
         }
         if (i < paramCount - 1)

-            m_fp->WriteString( ", ");
+            m_fp->WriteString( wxT(", ") );

     }
     }

-    m_fp->WriteString( ");\n");
+    m_fp->WriteString( wxT(");\n") );

 }
 
 void wxCodeDepersister::SetProperty(int objectID,
 }
 
 void wxCodeDepersister::SetProperty(int objectID,


@@ -591,10 +772,10 @@ void wxCodeDepersister::SetProperty(int objectID,
                                     const wxPropertyInfo* propertyInfo,
                                     const wxxVariant &value)
 {
                                     const wxPropertyInfo* propertyInfo,
                                     const wxxVariant &value)
 {

-    m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n",
-        m_data->GetObjectName(objectID),
-        propertyInfo->GetAccessor()->GetSetterName(),
-        ValueAsCode(value)) );
+    m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
+        m_data->GetObjectName(objectID).c_str(),
+        propertyInfo->GetAccessor()->GetSetterName().c_str(),
+        ValueAsCode(value).c_str()) );

 }
 
 void wxCodeDepersister::SetPropertyAsObject(int objectID,
 }
 
 void wxCodeDepersister::SetPropertyAsObject(int objectID,


@@ -603,40 +784,40 @@ void wxCodeDepersister::SetPropertyAsObject(int objectID,
                                             int valueObjectId)
 {
     if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT )
                                             int valueObjectId)
 {
     if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT )

-        m_fp->WriteString( wxString::Format( "\t%s->%s(*%s);\n",
-        m_data->GetObjectName(objectID),
-        propertyInfo->GetAccessor()->GetSetterName(),
-        m_data->GetObjectName( valueObjectId) ) );
+        m_fp->WriteString( wxString::Format( wxT("\t%s->%s(*%s);\n"),
+        m_data->GetObjectName(objectID).c_str(),
+        propertyInfo->GetAccessor()->GetSetterName().c_str(),
+        m_data->GetObjectName( valueObjectId).c_str() ) );

     else
     else

-        m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n",
-        m_data->GetObjectName(objectID),
-        propertyInfo->GetAccessor()->GetSetterName(),
-        m_data->GetObjectName( valueObjectId) ) );
+        m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
+        m_data->GetObjectName(objectID).c_str(),
+        propertyInfo->GetAccessor()->GetSetterName().c_str(),
+        m_data->GetObjectName( valueObjectId).c_str() ) );

 }
 
 void wxCodeDepersister::AddToPropertyCollection( int objectID ,
                                                 const wxClassInfo *WXUNUSED(classInfo),
                                                 const wxPropertyInfo* propertyInfo ,
 }
 
 void wxCodeDepersister::AddToPropertyCollection( int objectID ,
                                                 const wxClassInfo *WXUNUSED(classInfo),
                                                 const wxPropertyInfo* propertyInfo ,

-                                                const wxxVariant &value) 
+                                                const wxxVariant &value)

 {
 {

-    m_fp->WriteString( wxString::Format( "\t%s->%s(%s);\n",
-        m_data->GetObjectName(objectID),
-        propertyInfo->GetAccessor()->GetAdderName(),
-        ValueAsCode(value)) );
+    m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
+        m_data->GetObjectName(objectID).c_str(),
+        propertyInfo->GetAccessor()->GetAdderName().c_str(),
+        ValueAsCode(value).c_str()) );

 }
 
 // sets the corresponding property (value is an object)
 void wxCodeDepersister::AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
                                                         const wxClassInfo *WXUNUSED(classInfo),
                                                         const wxPropertyInfo* WXUNUSED(propertyInfo) ,
 }
 
 // sets the corresponding property (value is an object)
 void wxCodeDepersister::AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
                                                         const wxClassInfo *WXUNUSED(classInfo),
                                                         const wxPropertyInfo* WXUNUSED(propertyInfo) ,

-                                                        int WXUNUSED(valueObjectId)) 
+                                                        int WXUNUSED(valueObjectId))

 {
     // TODO
 }
 
 void wxCodeDepersister::SetConnect(int eventSourceObjectID,
                                    const wxClassInfo *WXUNUSED(eventSourceClassInfo),
 {
     // TODO
 }
 
 void wxCodeDepersister::SetConnect(int eventSourceObjectID,
                                    const wxClassInfo *WXUNUSED(eventSourceClassInfo),

-                                   const wxDelegateTypeInfo *delegateInfo ,
+                                   const wxPropertyInfo *delegateInfo ,

                                    const wxClassInfo *eventSinkClassInfo ,
                                    const wxHandlerInfo* handlerInfo ,
                                    int eventSinkObjectID )
                                    const wxClassInfo *eventSinkClassInfo ,
                                    const wxHandlerInfo* handlerInfo ,
                                    int eventSinkObjectID )


@@ -644,15 +825,23 @@ void wxCodeDepersister::SetConnect(int eventSourceObjectID,
     wxString ehsource = m_data->GetObjectName( eventSourceObjectID ) ;
     wxString ehsink = m_data->GetObjectName(eventSinkObjectID) ;
     wxString ehsinkClass = eventSinkClassInfo->GetClassName() ;
     wxString ehsource = m_data->GetObjectName( eventSourceObjectID ) ;
     wxString ehsink = m_data->GetObjectName(eventSinkObjectID) ;
     wxString ehsinkClass = eventSinkClassInfo->GetClassName() ;

-    int eventType = delegateInfo->GetEventType() ;
-    wxString handlerName = handlerInfo->GetName() ;
+    const wxDelegateTypeInfo *delegateTypeInfo = dynamic_cast<const wxDelegateTypeInfo*>(delegateInfo->GetTypeInfo());
+    if ( delegateTypeInfo )
+    {
+        int eventType = delegateTypeInfo->GetEventType() ;
+        wxString handlerName = handlerInfo->GetName() ;

 
 

-    m_fp->WriteString( wxString::Format(  "\t%s->Connect( %s->GetId() , %d , (wxObjectEventFunction)(wxEventFunction) & %s::%s , NULL , %s ) ;" , 
-        ehsource , ehsource , eventType , ehsinkClass , handlerName , ehsink ) );
+        m_fp->WriteString( wxString::Format(  wxT("\t%s->Connect( %s->GetId() , %d , (wxObjectEventFunction)(wxEventFunction) & %s::%s , NULL , %s ) ;") ,
+            ehsource.c_str() , ehsource.c_str() , eventType , ehsinkClass.c_str() , handlerName.c_str() , ehsink.c_str() ) );
+    }
+    else
+    {
+        wxLogError(_("delegate has no type info"));
+    }

 }
 
 }
 

-#include <wx/arrimpl.cpp>
+#include "wx/arrimpl.cpp"

 
 WX_DEFINE_OBJARRAY(wxxVariantArray);
 
 
 WX_DEFINE_OBJARRAY(wxxVariantArray);
 

-#endif
+#endif // wxUSE_EXTENDED_RTTI