really show the window after creation (calling Show(TRUE) doesn't do it any more)

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

diff --git a/src/common/xtixml.cpp b/src/common/xtixml.cpp
index 93676aafeffc314cbd2a384f5097df4aa156b00a..3bd916c1902644d134aab7732924a2634c8bbde5 100644 (file)
--- a/src/common/xtixml.cpp
+++ b/src/common/xtixml.cpp
@@ -27,13 +27,14 @@
 
 #include "wx/xml/xml.h"
 #include "wx/tokenzr.h"
 
 #include "wx/xml/xml.h"
 #include "wx/tokenzr.h"

-#include "wx/xtistrm.h"
-#include "wx/xtixml.h"

 #include "wx/txtstrm.h"
 #include "wx/event.h"
 
 #if wxUSE_EXTENDED_RTTI
 
 #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 "wx/beforestd.h"
 #include <map>
 #include <vector>


@@ -50,7 +51,7 @@ using namespace std ;
 
 void wxXmlAddContentToNode( wxXmlNode* node , const wxString& data )
 {
 
 void wxXmlAddContentToNode( wxXmlNode* node , const wxString& data )
 {

-    node->AddChild(new wxXmlNode(wxXML_TEXT_NODE, "value", data ) );
+    node->AddChild(new wxXmlNode(wxXML_TEXT_NODE, wxT("value"), data ) );

 }
 
 wxString wxXmlGetContentFromNode( wxXmlNode *node )
 }
 
 wxString wxXmlGetContentFromNode( wxXmlNode *node )


@@ -96,7 +97,7 @@ void wxXmlWriter::DoBeginWriteTopLevelEntry( const wxString &name )
 {
     wxXmlNode *pnode;
     pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("entry"));
 {
     wxXmlNode *pnode;
     pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("entry"));

-    pnode->AddProperty(wxString("name"), name);
+    pnode->AddProperty(wxString(wxT("name")), name);

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


@@ -111,7 +112,7 @@ void wxXmlWriter::DoBeginWriteObject(const wxObject *WXUNUSED(object), const wxC
     wxXmlNode *pnode;
     pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
     pnode->AddProperty(wxT("class"), wxString(classInfo->GetClassName()));
     wxXmlNode *pnode;
     pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
     pnode->AddProperty(wxT("class"), wxString(classInfo->GetClassName()));

-    pnode->AddProperty(wxT("id"), wxString::Format( "%d" , objectID ) );
+    pnode->AddProperty(wxT("id"), wxString::Format( wxT("%d") , objectID ) );

 
     for ( size_t i = 0 ; i < metadata.GetCount() ; ++i )
     {
 
     for ( size_t i = 0 ; i < metadata.GetCount() ; ++i )
     {


@@ -136,7 +137,7 @@ void wxXmlWriter::DoWriteSimpleType( wxxVariant &value )
 void wxXmlWriter::DoBeginWriteElement()
 {
     wxXmlNode *pnode;
 void wxXmlWriter::DoBeginWriteElement()
 {
     wxXmlNode *pnode;

-    pnode = new wxXmlNode(wxXML_ELEMENT_NODE, "element" );
+    pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("element") );

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


@@ -149,7 +150,7 @@ void wxXmlWriter::DoEndWriteElement()
 void wxXmlWriter::DoBeginWriteProperty(const wxPropertyInfo *pi )
 {
     wxXmlNode *pnode;
 void wxXmlWriter::DoBeginWriteProperty(const wxPropertyInfo *pi )
 {
     wxXmlNode *pnode;

-    pnode = new wxXmlNode(wxXML_ELEMENT_NODE, "prop" );
+    pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("prop") );

     pnode->AddProperty(wxT("name"), pi->GetName() );
     m_data->m_current->AddChild(pnode) ;
     m_data->Push( pnode ) ;
     pnode->AddProperty(wxT("name"), pi->GetName() );
     m_data->m_current->AddChild(pnode) ;
     m_data->Push( pnode ) ;


@@ -167,7 +168,7 @@ void wxXmlWriter::DoWriteRepeatedObject( int objectID )
 {
     wxXmlNode *pnode;
     pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));
 {
     wxXmlNode *pnode;
     pnode = new wxXmlNode(wxXML_ELEMENT_NODE, wxT("object"));

-    pnode->AddProperty(wxString("href"), wxString::Format( "%d" , objectID ) );
+    pnode->AddProperty(wxString(wxT("href")), wxString::Format( wxT("%d") , objectID ) );

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


@@ -222,34 +223,54 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
     if (!children)
     {
         // check for a null object or href
     if (!children)
     {
         // check for a null object or href

-        if (node->GetPropVal("href" , &ObjectIdString ) )
+        if (node->GetPropVal(wxT("href") , &ObjectIdString ) )

         {
         {

-            objectID = atoi( ObjectIdString.c_str() ) ;
-            wxASSERT_MSG( HasObjectClassInfo( objectID ) , wxT("Forward hrefs are not supported") ) ;
-            return objectID ;
+            objectID = atoi( ObjectIdString.ToAscii() ) ;
+            if ( HasObjectClassInfo( objectID ) )
+            {
+                return objectID ;
+            }
+            else
+            {
+                wxLogError( _("Forward hrefs are not supported") ) ;
+                return wxInvalidObjectID ;                
+            }

         }
         }

-        if ( !node->GetPropVal("id" , &ObjectIdString ) )
+        if ( !node->GetPropVal(wxT("id") , &ObjectIdString ) )

         {
             return wxNullObjectID;
         }
     }
         {
             return wxNullObjectID;
         }
     }

-    if (!node->GetPropVal("class", &className))
+    if (!node->GetPropVal(wxT("class"), &className))

     {
         // No class name.  Eek. FIXME: error handling
         return wxInvalidObjectID;
     }
     classInfo = wxClassInfo::FindClass(className);
     {
         // No class name.  Eek. FIXME: error handling
         return wxInvalidObjectID;
     }
     classInfo = wxClassInfo::FindClass(className);

-    wxASSERT_MSG( classInfo , wxString::Format(wxT("unknown class %s"),className ) ) ;
-    wxASSERT_MSG( !children || children->GetType() != wxXML_TEXT_NODE , wxT("objects cannot have XML Text Nodes") ) ;
-    if (!node->GetPropVal("id", &ObjectIdString))
+    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))

     {
     {

-        wxASSERT_MSG(0,wxT("Objects must have an id attribute") ) ;
+        wxLogError(_("Objects must have an id attribute") ) ;

         // No object id.  Eek. FIXME: error handling
         return wxInvalidObjectID;
     }
         // No object id.  Eek. FIXME: error handling
         return wxInvalidObjectID;
     }

-    objectID = atoi( ObjectIdString.c_str() ) ;
+    objectID = atoi( ObjectIdString.ToAscii() ) ;

     // is this object already has been streamed in, return it here
     // is this object already has been streamed in, return it here

-    wxASSERT_MSG( !HasObjectClassInfo( objectID ) , wxString::Format(wxT("Doubly used id : %d"), objectID ) ) ;
+    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
 
     // new object, start with allocation
     // first make the object know to our internal registry


@@ -259,13 +280,14 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
     wxXmlProperty *xp = node->GetProperties() ;
     while ( xp )
     {
     wxXmlProperty *xp = node->GetProperties() ;
     while ( xp )
     {

-        if ( xp->GetName() != wxString("class") && xp->GetName() != wxString("id") )
+        if ( xp->GetName() != wxString(wxT("class")) && xp->GetName() != wxString(wxT("id")) )

         {
             metadata.Add( new wxxVariant( xp->GetValue() , xp->GetName() ) ) ;
         }
         xp = xp->GetNext() ;
     }
         {
             metadata.Add( new wxxVariant( xp->GetValue() , xp->GetName() ) ) ;
         }
         xp = xp->GetNext() ;
     }

-    callbacks->AllocateObject(objectID, classInfo, metadata);
+    if ( !classInfo->NeedsDirectConstruction() )
+        callbacks->AllocateObject(objectID, classInfo, metadata);

 
     //
     // stream back the Create parameters first
 
     //
     // stream back the Create parameters first


@@ -273,9 +295,13 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
     createParamOids = new int[classInfo->GetCreateParamCount() ] ;
     createClassInfos = new const wxClassInfo*[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 ;
     typedef map<string, wxXmlNode *> PropertyNodes ;
     typedef vector<string> PropertyNames ;

-
+#endif

     PropertyNodes propertyNodes ;
     PropertyNames propertyNames ;
 
     PropertyNodes propertyNodes ;
     PropertyNames propertyNames ;
 


@@ -293,7 +319,10 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
         const wxChar* paramName = classInfo->GetCreateParamName(i) ;
         PropertyNodes::iterator propiter = propertyNodes.find( paramName ) ;
         const wxPropertyInfo* pi = classInfo->FindPropertyInfo( paramName ) ;
         const wxChar* paramName = classInfo->GetCreateParamName(i) ;
         PropertyNodes::iterator propiter = propertyNodes.find( paramName ) ;
         const wxPropertyInfo* pi = classInfo->FindPropertyInfo( paramName ) ;

-        wxASSERT_MSG(pi,wxString::Format("Unkown Property %s",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() )
         // if we don't have the value of a create param set in the xml
         // we use the default value
         if ( propiter != propertyNodes.end() )


@@ -311,11 +340,16 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
                 if( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
                 {
                     const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;
                 if( pi->GetFlags() & wxPROP_ENUM_STORE_LONG )
                 {
                     const wxEnumTypeInfo *eti = dynamic_cast<const wxEnumTypeInfo*>( pi->GetTypeInfo() ) ;

-                    wxASSERT_MSG( eti , wxT("Type must have enum - long conversion") ) ;
-
-                    long realval ;
-                    eti->ConvertToLong( createParams[i]  , realval ) ;
-                    createParams[i] = wxxVariant( realval ) ;
+                    if ( eti )
+                    {
+                        long realval ;
+                        eti->ConvertToLong( createParams[i]  , realval ) ;
+                        createParams[i] = wxxVariant( realval ) ;
+                    }
+                    else
+                    {
+                        wxLogError( _("Type must have enum - long conversion") ) ;
+                    }

                 }
                 createClassInfos[i] = NULL ;
             }
                 }
                 createClassInfos[i] = NULL ;
             }


@@ -324,21 +358,35 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
             {
                 if ( propertyNames[j] == paramName )
                 {
             {
                 if ( propertyNames[j] == paramName )
                 {

-                    propertyNames[j] = "" ;
+                    propertyNames[j] = wxEmptyString ;

                     break ;
                 }
             }
         }
         else
         {
                     break ;
                 }
             }
         }
         else
         {

-            createParams[i] = pi->GetDefaultValue() ;
+            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
         }
     }
 
     // got the parameters.  Call the Create method

-    callbacks->CreateObject(objectID, classInfo,
-        classInfo->GetCreateParamCount(),
-        createParams, createParamOids, createClassInfos, metadata );
+    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 )
 
     // 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 )


@@ -356,7 +404,11 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
                     const wxTypeInfo * elementType = collType->GetElementType() ;
                     while( prop )
                     {
                     const wxTypeInfo * elementType = collType->GetElementType() ;
                     while( prop )
                     {

-                        wxASSERT_MSG(prop->GetName() == wxT("element") , wxT("A non empty collection must consist of 'element' nodes")) ;
+                        if ( prop->GetName() != wxT("element") )
+                        {
+                            wxLogError( _("A non empty collection must consist of 'element' nodes" ) ) ;
+                            break ;
+                        }

                         wxXmlNode* elementContent = prop->GetChildren() ;
                         if ( elementContent )
                         {
                         wxXmlNode* elementContent = prop->GetChildren() ;
                         if ( elementContent )
                         {


@@ -385,12 +437,26 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
                 }
                 else if ( pi->GetTypeInfo()->IsObjectType() )
                 {
                 }
                 else if ( pi->GetTypeInfo()->IsObjectType() )
                 {

-                    int valueId = ReadComponent( prop , callbacks ) ;
-                    if ( valueId != wxInvalidObjectID )
+                    // 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 )

                     {
                     {

-                        callbacks->SetPropertyAsObject( objectID , classInfo , pi , valueId ) ;
-                        if ( pi->GetTypeInfo()->GetKind() == wxT_OBJECT && valueId != wxNullObjectID )
-                            callbacks->DestroyObject( valueId , GetObjectClassInfo( valueId ) ) ;
+                        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() )
                     }
                 }
                 else if ( pi->GetTypeInfo()->IsDelegateType() )


@@ -399,20 +465,40 @@ int wxXmlReader::ReadComponent(wxXmlNode *node, wxDepersister *callbacks)
                     {
                         wxString resstring = prop->GetContent() ;
                         wxInt32 pos = resstring.Find('.') ;
                     {
                         wxString resstring = prop->GetContent() ;
                         wxInt32 pos = resstring.Find('.') ;

-                        assert( pos != wxNOT_FOUND ) ;
-                        int sinkOid = atol(resstring.Left(pos)) ;
-                        wxString handlerName = resstring.Mid(pos+1) ;
-                        wxClassInfo* sinkClassInfo = GetObjectClassInfo( sinkOid ) ;
+                        if ( pos != wxNOT_FOUND )
+                        {
+                            int sinkOid = atol(resstring.Left(pos).ToAscii()) ;
+                            wxString handlerName = resstring.Mid(pos+1) ;
+                            wxClassInfo* sinkClassInfo = GetObjectClassInfo( sinkOid ) ;

 
 

-                        callbacks->SetConnect( objectID , classInfo , dynamic_cast<const wxDelegateTypeInfo*>(pi->GetTypeInfo()) , sinkClassInfo ,
-                            sinkClassInfo->FindHandlerInfo(handlerName) ,  sinkOid ) ;
+                            callbacks->SetConnect( objectID , classInfo , pi , sinkClassInfo ,
+                                sinkClassInfo->FindHandlerInfo(handlerName) ,  sinkOid ) ;
+                        }
+                        else
+                        {
+                            wxLogError( _("incorrect event handler string, missing dot") ) ;
+                        }

                     }
 
                 }
                 else
                 {
                     }
 
                 }
                 else
                 {

-                    wxxVariant nodeval ;
-                    callbacks->SetProperty( objectID, classInfo ,pi , ReadValue( prop , pi->GetTypeInfo() ) ) ;
+                    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 ) ;

                 }
             }
         }
                 }
             }
         }


@@ -442,7 +528,7 @@ int wxXmlReader::ReadObject( const wxString &name , wxDepersister *callbacks)
     while ( iter )
     {
         wxString entryName ;
     while ( iter )
     {
         wxString entryName ;

-        if ( iter->GetPropVal("name", &entryName) )
+        if ( iter->GetPropVal(wxT("name"), &entryName) )

         {
             if ( entryName == name )
                 return ReadComponent( iter->GetChildren() , callbacks ) ;
         {
             if ( entryName == name )
                 return ReadComponent( iter->GetChildren() , callbacks ) ;