samples/xti/codereadercallback.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/common/xtistrm.cpp
   3 // Purpose:     streaming runtime metadata information
   4 // Author:      Stefan Csomor
   5 // Modified by:
   6 // Created:     27/07/03
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 2003 Stefan Csomor
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #include "wx/xtistrm.h"
  20
  21 #ifndef WX_PRECOMP
  22     #include "wx/object.h"
  23     #include "wx/hash.h"
  24     #include "wx/event.h"
  25 #endif
  26
  27 #include <map>
  28 #include <vector>
  29 #include <string>
  30 using namespace std;
  31
  32 #include "wx/tokenzr.h"
  33 #include "wx/txtstrm.h"
  34 #include "codereadercallback.h"
  35
  36 #if !wxUSE_EXTENDED_RTTI
  37     #error This sample requires XTI (eXtended RTTI) enabled
  38 #endif
  39
  40 // ----------------------------------------------------------------------------
  41 // wxObjectCodeReaderCallback - depersisting to code
  42 // ----------------------------------------------------------------------------
  43
  44 struct wxObjectCodeReaderCallback::wxObjectCodeReaderCallbackInternal
  45 {
  46 #if wxUSE_UNICODE
  47     map<int,wstring> m_objectNames;
  48 #else
  49     map<int,string> m_objectNames;
  50 #endif
  51
  52     void SetObjectName(int objectID, const wxString &name )
  53     {
  54         if ( m_objectNames.find(objectID) != m_objectNames.end() )
  55         {
  56             wxLogError( _("Passing a already registered object to SetObjectName") );
  57             return ;
  58         }
  59         m_objectNames[objectID] = (const wxChar *)name;
  60     }
  61
  62     wxString GetObjectName( int objectID )
  63     {
  64         if ( objectID == wxNullObjectID )
  65             return wxT("NULL");
  66
  67         if ( m_objectNames.find(objectID) == m_objectNames.end() )
  68         {
  69             wxLogError( _("Passing an unkown object to GetObject") );
  70             return wxEmptyString;
  71         }
  72         return wxString( m_objectNames[objectID].c_str() );
  73     }
  74 };
  75
  76 wxObjectCodeReaderCallback::wxObjectCodeReaderCallback(wxTextOutputStream *out)
  77 : m_fp(out)
  78 {
  79     m_data = new wxObjectCodeReaderCallbackInternal;
  80 }
  81
  82 wxObjectCodeReaderCallback::~wxObjectCodeReaderCallback()
  83 {
  84     delete m_data;
  85 }
  86
  87 void wxObjectCodeReaderCallback::AllocateObject(int objectID, wxClassInfo *classInfo,
  88                                        wxVariantBaseArray &WXUNUSED(metadata))
  89 {
  90     wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID );
  91     m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s;\n"),
  92         classInfo->GetClassName(),
  93         objectName.c_str(),
  94         classInfo->GetClassName()) );
  95     m_data->SetObjectName( objectID, objectName );
  96 }
  97
  98 void wxObjectCodeReaderCallback::DestroyObject(int objectID, wxClassInfo *WXUNUSED(classInfo))
  99 {
 100     m_fp->WriteString( wxString::Format( wxT("\tdelete %s;\n"),
 101         m_data->GetObjectName( objectID).c_str() ) );
 102 }
 103
 104 wxString wxObjectCodeReaderCallback::ValueAsCode( const wxVariantBase &param )
 105 {
 106     wxString value;
 107     const wxTypeInfo* type = param.GetTypeInfo();
 108     if ( type->GetKind() == wxT_CUSTOM )
 109     {
 110         const wxCustomTypeInfo* cti = wx_dynamic_cast(const wxCustomTypeInfo*, type);
 111         if ( cti )
 112         {
 113             value.Printf( wxT("%s(%s)"), cti->GetTypeName().c_str(),
 114                           param.GetAsString().c_str() );
 115         }
 116         else
 117         {
 118             wxLogError ( _("Internal error, illegal wxCustomTypeInfo") );
 119         }
 120     }
 121     else if ( type->GetKind() == wxT_STRING )
 122     {
 123         value.Printf( wxT("\"%s\""),param.GetAsString().c_str() );
 124     }
 125     else
 126     {
 127         value.Printf( wxT("%s"), param.GetAsString().c_str() );
 128     }
 129     return value;
 130 }
 131
 132 void wxObjectCodeReaderCallback::CreateObject(int objectID,
 133                                      const wxClassInfo *WXUNUSED(classInfo),
 134                                      int paramCount,
 135                                      wxVariantBase *params,
 136                                      int *objectIDValues,
 137                                      const wxClassInfo **WXUNUSED(objectClassInfos),
 138                                      wxVariantBaseArray &WXUNUSED(metadata)
 139                                      )
 140 {
 141     int i;
 142     m_fp->WriteString( wxString::Format( wxT("\t%s->Create("),
 143                        m_data->GetObjectName(objectID).c_str() ) );
 144     for (i = 0; i < paramCount; i++)
 145     {
 146         if ( objectIDValues[i] != wxInvalidObjectID )
 147         {
 148             wxString str =
 149                 wxString::Format( wxT("%s"),
 150                                   m_data->GetObjectName( objectIDValues[i] ).c_str() );
 151             m_fp->WriteString( str );
 152         }
 153         else
 154         {
 155             m_fp->WriteString(
 156                 wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
 157         }
 158         if (i < paramCount - 1)
 159             m_fp->WriteString( wxT(", "));
 160     }
 161     m_fp->WriteString( wxT(");\n") );
 162 }
 163
 164 void wxObjectCodeReaderCallback::ConstructObject(int objectID,
 165                                      const wxClassInfo *classInfo,
 166                                      int paramCount,
 167                                      wxVariantBase *params,
 168                                      int *objectIDValues,
 169                                      const wxClassInfo **WXUNUSED(objectClassInfos),
 170                                      wxVariantBaseArray &WXUNUSED(metadata)
 171                                      )
 172 {
 173     wxString objectName = wxString::Format( wxT("LocalObject_%d"), objectID );
 174     m_fp->WriteString( wxString::Format( wxT("\t%s *%s = new %s("),
 175         classInfo->GetClassName(),
 176         objectName.c_str(),
 177         classInfo->GetClassName()) );
 178     m_data->SetObjectName( objectID, objectName );
 179
 180     int i;
 181     for (i = 0; i < paramCount; i++)
 182     {
 183         if ( objectIDValues[i] != wxInvalidObjectID )
 184             m_fp->WriteString( wxString::Format( wxT("%s"),
 185                                m_data->GetObjectName( objectIDValues[i] ).c_str() ) );
 186         else
 187         {
 188             m_fp->WriteString(
 189                 wxString::Format( wxT("%s"), ValueAsCode(params[i]).c_str() ) );
 190         }
 191         if (i < paramCount - 1)
 192             m_fp->WriteString( wxT(", ") );
 193     }
 194     m_fp->WriteString( wxT(");\n") );
 195 }
 196
 197 void wxObjectCodeReaderCallback::SetProperty(int objectID,
 198                                     const wxClassInfo *WXUNUSED(classInfo),
 199                                     const wxPropertyInfo* propertyInfo,
 200                                     const wxVariantBase &value)
 201 {
 202     m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
 203         m_data->GetObjectName(objectID).c_str(),
 204         propertyInfo->GetAccessor()->GetSetterName().c_str(),
 205         ValueAsCode(value).c_str()) );
 206 }
 207
 208 void wxObjectCodeReaderCallback::SetPropertyAsObject(int objectID,
 209                                             const wxClassInfo *WXUNUSED(classInfo),
 210                                             const wxPropertyInfo* propertyInfo,
 211                                             int valueObjectId)
 212 {
 213     if ( propertyInfo->GetTypeInfo()->GetKind() == wxT_OBJECT )
 214         m_fp->WriteString( wxString::Format( wxT("\t%s->%s(*%s);\n"),
 215         m_data->GetObjectName(objectID).c_str(),
 216         propertyInfo->GetAccessor()->GetSetterName().c_str(),
 217         m_data->GetObjectName( valueObjectId).c_str() ) );
 218     else
 219         m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
 220         m_data->GetObjectName(objectID).c_str(),
 221         propertyInfo->GetAccessor()->GetSetterName().c_str(),
 222         m_data->GetObjectName( valueObjectId).c_str() ) );
 223 }
 224
 225 void wxObjectCodeReaderCallback::AddToPropertyCollection( int objectID,
 226                                                 const wxClassInfo *WXUNUSED(classInfo),
 227                                                 const wxPropertyInfo* propertyInfo,
 228                                                 const wxVariantBase &value)
 229 {
 230     m_fp->WriteString( wxString::Format( wxT("\t%s->%s(%s);\n"),
 231         m_data->GetObjectName(objectID).c_str(),
 232         propertyInfo->GetAccessor()->GetAdderName().c_str(),
 233         ValueAsCode(value).c_str()) );
 234 }
 235
 236 // sets the corresponding property (value is an object)
 237 void wxObjectCodeReaderCallback::
 238     AddToPropertyCollectionAsObject(int WXUNUSED(objectID),
 239                                     const wxClassInfo *WXUNUSED(classInfo),
 240                                     const wxPropertyInfo* WXUNUSED(propertyInfo),
 241                                     int WXUNUSED(valueObjectId))
 242 {
 243     // TODO
 244 }
 245
 246 void wxObjectCodeReaderCallback::SetConnect(int eventSourceObjectID,
 247                                    const wxClassInfo *WXUNUSED(eventSourceClassInfo),
 248                                    const wxPropertyInfo *delegateInfo,
 249                                    const wxClassInfo *eventSinkClassInfo,
 250                                    const wxHandlerInfo* handlerInfo,
 251                                    int eventSinkObjectID )
 252 {
 253     wxString ehsource = m_data->GetObjectName( eventSourceObjectID );
 254     wxString ehsink = m_data->GetObjectName(eventSinkObjectID);
 255     wxString ehsinkClass = eventSinkClassInfo->GetClassName();
 256     const wxEventSourceTypeInfo *delegateTypeInfo =
 257         wx_dynamic_cast(const wxEventSourceTypeInfo*, delegateInfo->GetTypeInfo());
 258     if ( delegateTypeInfo )
 259     {
 260         int eventType = delegateTypeInfo->GetEventType();
 261         wxString handlerName = handlerInfo->GetName();
 262
 263         wxString code =
 264             wxString::Format(
 265                 wxT("\t%s->Connect( %s->GetId(), %d, ")
 266                 wxT("(wxObjectEventFunction)(wxEventFunction) & %s::%s, NULL, %s );"),
 267                 ehsource.c_str(), ehsource.c_str(), eventType, ehsinkClass.c_str(),
 268                 handlerName.c_str(), ehsink.c_str() );
 269
 270         m_fp->WriteString( code );
 271     }
 272     else
 273     {
 274         wxLogError(_("delegate has no type info"));
 275     }
 276 }