synchronize GTK2 minimum version in docs

[wxWidgets.git] / include / wx / xti.h

diff --git a/include/wx/xti.h b/include/wx/xti.h
index dbb94294b5e5b117f2bb2452a4554cf8f67d1f70..dbbfc2d09af6aab3dcdb66220a6a6b83b1926f31 100644 (file)
--- a/include/wx/xti.h
+++ b/include/wx/xti.h
@@ -2,7 +2,7 @@
 // Name:        wx/xti.h
 // Purpose:     runtime metadata information (extended class info)
 // Author:      Stefan Csomor
 // Name:        wx/xti.h
 // Purpose:     runtime metadata information (extended class info)
 // Author:      Stefan Csomor

-// Modified by: 
+// Modified by: Francesco Montorsi

 // Created:     27/07/03
 // RCS-ID:      $Id$
 // Copyright:   (c) 1997 Julian Smart
 // Created:     27/07/03
 // RCS-ID:      $Id$
 // Copyright:   (c) 1997 Julian Smart


@@ -13,22 +13,18 @@
 #ifndef _WX_XTIH__
 #define _WX_XTIH__
 
 #ifndef _WX_XTIH__
 #define _WX_XTIH__
 

-#if defined(__GNUG__) && !defined(__APPLE__)
-#pragma interface "xti.h"
-#endif
-

 // We want to support properties, event sources and events sinks through
 // explicit declarations, using templates and specialization to make the
 // We want to support properties, event sources and events sinks through
 // explicit declarations, using templates and specialization to make the

-// effort as painless as possible. 
+// effort as painless as possible.

 //
 // This means we have the following domains :
 //
 // - Type Information for categorizing built in types as well as custom types
 //
 // This means we have the following domains :
 //
 // - Type Information for categorizing built in types as well as custom types

-// this includes information about enums, their values and names
-// - Type safe value storage : a kind of wxVariant, called right now wxxVariant
-// which will be merged with wxVariant 
+//   this includes information about enums, their values and names
+// - Type safe value storage : a kind of wxVariant, called right now wxAny
+//   which will be merged with wxVariant

 // - Property Information and Property Accessors providing access to a class'
 // - Property Information and Property Accessors providing access to a class'

-// values and exposed event delegates
+//   values and exposed event delegates

 // - Information about event handlers
 // - extended Class Information for accessing all these
 
 // - Information about event handlers
 // - extended Class Information for accessing all these
 


@@ -37,1131 +33,438 @@
 // ----------------------------------------------------------------------------
 
 #include "wx/defs.h"
 // ----------------------------------------------------------------------------
 
 #include "wx/defs.h"

-#include "wx/memory.h"
-#include "wx/set.h"
-#include "wx/string.h"
-
-class WXDLLIMPEXP_BASE wxObject;
-class WXDLLIMPEXP_BASE wxClassInfo;
-class WXDLLIMPEXP_BASE wxHashTable;
-class WXDLLIMPEXP_BASE wxObjectRefData;
-class WXDLLIMPEXP_BASE wxEvent;
-
-typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);
-
-// ----------------------------------------------------------------------------
-// Enum Support
-//
-// In the header files there would no change from pure c++ code, in the 
-// implementation, an enum would have
-// to be enumerated eg :
-//
-// WX_BEGIN_ENUM( wxFlavor )
-//   WX_ENUM_MEMBER( Vanilla )
-//   WX_ENUM_MEMBER( Chocolate )
-//   WX_ENUM_MEMBER( Strawberry )
-// WX_END_ENUM( wxFlavor )
-// ----------------------------------------------------------------------------
-
-struct WXDLLIMPEXP_BASE wxEnumMemberData
-{
-    const wxChar*      m_name;
-    int                                m_value;
-};
-
-class WXDLLIMPEXP_BASE wxEnumData
-{
-public :
-       wxEnumData( wxEnumMemberData* data ) ;
-
-       // returns true if the member has been found and sets the int value
-       // pointed to accordingly (if ptr != null )
-       // if not found returns false, value left unchanged
-       bool HasEnumMemberValue( const wxChar *name , int *value = NULL ) ;
-       
-       // returns the value of the member, if not found in debug mode an
-       // assert is issued, in release 0 is returned
-       int GetEnumMemberValue(const wxChar *name );
-       
-       // returns the name of the enum member having the passed in value
-       // returns an emtpy string if not found
-    const wxChar *GetEnumMemberName(int value);
-       
-       // returns the number of members in this enum
-       int GetEnumCount() { return m_count ; }
-       
-       // returns the value of the nth member
-       int GetEnumMemberValueByIndex( int n ) ;
-       
-       // returns the value of the nth member
-       const wxChar *GetEnumMemberNameByIndex( int n ) ;
-private :
-    wxEnumMemberData *m_members;
-       int m_count ;
-};
-
-#define WX_BEGIN_ENUM( e ) \
-       wxEnumMemberData s_enumDataMembers##e[] = {

 
 

-#define WX_ENUM_MEMBER( v ) { #v, v } ,
-
-#define WX_END_ENUM( e ) { NULL , 0 } } ; \
-       wxEnumData s_enumData##e( s_enumDataMembers##e ) ; \
-       wxEnumData *wxGetEnumData(e) { return &s_enumData##e ; } \
-       template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxEnumTypeInfo s_typeInfo(wxT_ENUM , &s_enumData##e) ; return &s_typeInfo ; } \
-       template<> void wxStringReadValue(const wxString& s , e &data ) \
-       { \
-               data = (e) s_enumData##e.GetEnumMemberValue(s) ; \
-       } \
-       template<> void wxStringWriteValue(wxString &s , const e &data ) \
-       { \
-               s =  s_enumData##e.GetEnumMemberName((int)data) ; \
-       }
-
-// ----------------------------------------------------------------------------
-// Set Support
-// 
-// in the header :
-// 
-// enum wxFlavor
-// {  
-//     Vanilla,
-//     Chocolate,
-//     Strawberry,
-// };
-// 
-// typedef wxSet<wxFlavor> wxCoupe ;
-// 
-// in the implementation file :
-// 
-// WX_BEGIN_ENUM( wxFlavor )
-//     WX_ENUM_MEMBER( Vanilla )
-//     WX_ENUM_MEMBER( Chocolate )
-//     WX_ENUM_MEMBER( Strawberry )
-// WX_END_ENUM( wxFlavor )
-// 
-// WX_IMPLEMENT_SET_STREAMING( wxCoupe , wxFlavor ) 
-//
-// implementation note : no partial specialization for streaming, but a delegation to a 
-// different class
-//
-// ----------------------------------------------------------------------------
+#if wxUSE_EXTENDED_RTTI

 
 

-// in order to remove dependancy on string tokenizer
-void wxSetStringToArray( const wxString &s , wxArrayString &array ) ;
+class WXDLLIMPEXP_FWD_BASE wxAny;
+class WXDLLIMPEXP_FWD_BASE wxAnyList;
+class WXDLLIMPEXP_FWD_BASE wxObject;
+class WXDLLIMPEXP_FWD_BASE wxString;
+class WXDLLIMPEXP_FWD_BASE wxClassInfo;
+class WXDLLIMPEXP_FWD_BASE wxHashTable;
+class WXDLLIMPEXP_FWD_BASE wxObject;
+class WXDLLIMPEXP_FWD_BASE wxPluginLibrary;
+class WXDLLIMPEXP_FWD_BASE wxHashTable;
+class WXDLLIMPEXP_FWD_BASE wxHashTable_Node;

 
 

-template<typename e>
-void wxSetFromString(const wxString &s , wxSet<e> &data )  
-{
-       wxEnumData* edata = wxGetEnumData((e) 0) ;
-       data.Clear() ;
+class WXDLLIMPEXP_FWD_BASE wxStringToAnyHashMap;
+class WXDLLIMPEXP_FWD_BASE wxPropertyInfoMap;
+class WXDLLIMPEXP_FWD_BASE wxPropertyAccessor;
+class WXDLLIMPEXP_FWD_BASE wxObjectAllocatorAndCreator;
+class WXDLLIMPEXP_FWD_BASE wxObjectAllocator;

 
 

-       wxArrayString array ;
-       wxSetStringToArray( s , array ) ;
-    wxString flag;
-    for ( int i = 0 ; i < array.Count() ; ++i )
-    {
-        flag = array[i] ;
-               int ivalue ;
-               if ( edata->HasEnumMemberValue( flag , &ivalue ) )
-               {
-                       data.Set( (e) ivalue ) ;
-               }
-    }
-}

 
 

-template<typename e>
-void wxSetToString( wxString &s , const wxSet<e> &data )
-{
-       wxEnumData* edata = wxGetEnumData((e) 0) ;
-       int count = edata->GetEnumCount() ;
-       int i ;
-       s.Clear() ;
-       for ( i = 0 ; i < count ; i++ )
-       {
-               e value = (e) edata->GetEnumMemberValueByIndex(i) ;
-               if ( data.Contains( value ) )
-               {
-                       // this could also be done by the templated calls
-                       if ( !s.IsEmpty() )
-                               s +="|" ;
-                       s += edata->GetEnumMemberNameByIndex(i) ;
-               }
-       }
-}
-
-//  if the wxSet specialization above does not work for all compilers, add this to the WX_IMPLEMENT_SET_STREAMING macro
-//     template<> const wxTypeInfo* wxGetTypeInfo( SetName * ){ static wxEnumTypeInfo s_typeInfo(wxT_SET , &s_enumData##e) ; return &s_typeInfo ; }\
-
-#define WX_IMPLEMENT_SET_STREAMING(SetName,e) \
-       template<> void wxStringReadValue(const wxString &s , wxSet<e> &data ) \
-       { \
-               wxSetFromString( s , data ) ; \
-       } \
-       template<> void wxStringWriteValue( wxString &s , const wxSet<e> &data ) \
-       { \
-               wxSetToString( s , data ) ; \
-       } \
+#define wx_dynamic_cast(t, x) dynamic_cast<t>(x)

 
 

+#include "wx/xtitypes.h"
+#include "wx/xtihandler.h"

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

-// Type Information
+// wxClassInfo

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

-enum wxTypeKind
+class WXDLLIMPEXP_BASE wxObjectFunctor

 {
 {

-    wxT_VOID = 0, // unknown type
-    wxT_BOOL,
-    wxT_CHAR,
-    wxT_UCHAR,
-    wxT_INT,
-    wxT_UINT,
-    wxT_LONG,
-    wxT_ULONG,
-    wxT_FLOAT,
-    wxT_DOUBLE,
-    wxT_STRING, // must be wxString
-    wxT_SET, // must be wxSet<> template
-    wxT_ENUM,
-    wxT_OBJECT, // must be a component (pointer !!!)
-    wxT_CUSTOM, // user defined type (e.g. wxPoint)
-       wxT_DELEGATE , // for connecting against an event source
-    wxT_LAST_TYPE_KIND // sentinel for bad data, asserts, debugging
-};
+public:
+    virtual ~wxObjectFunctor();

 
 

-class WXDLLIMPEXP_BASE wxTypeInfo
-{
-public :
-       wxTypeInfo() : m_kind( wxT_VOID) {}
-       virtual ~wxTypeInfo() {}
-       wxTypeKind GetKind() const { return m_kind ; }
-protected :
-       wxTypeKind m_kind ;
+    // Invoke the actual event handler:
+    virtual void operator()(const wxObject *) = 0;

 };
 
 };
 

-class WXDLLIMPEXP_BASE wxBuiltInTypeInfo : public wxTypeInfo
-{
-public :
-       wxBuiltInTypeInfo( wxTypeKind kind ) { assert( kind < wxT_SET ) ; m_kind = kind ;}
-} ;
-
-class WXDLLIMPEXP_BASE wxCustomTypeInfo : public wxTypeInfo
-{
-public :
-       wxCustomTypeInfo( const wxChar *typeName ) 
-       { m_kind = wxT_CUSTOM ; m_typeName = typeName ;}
-       const wxChar *GetTypeName() const { assert( m_kind == wxT_CUSTOM ) ; return m_typeName ; }
-private :
-       const wxChar *m_typeName; // Kind == wxT_CUSTOM
-} ;
-
-class WXDLLIMPEXP_BASE wxEnumTypeInfo : public wxTypeInfo
-{
-public :
-       wxEnumTypeInfo( wxTypeKind kind , wxEnumData* enumInfo ) 
-       { assert( kind == wxT_ENUM || kind == wxT_SET ) ; m_kind = kind ; m_enumInfo = enumInfo ;}
-       const wxEnumData* GetEnumData() const { assert( m_kind == wxT_ENUM || m_kind == wxT_SET ) ; return m_enumInfo ; }
-private :
-       wxEnumData *m_enumInfo; // Kind == wxT_ENUM or Kind == wxT_SET
-} ;
-
-class WXDLLIMPEXP_BASE wxClassTypeInfo : public wxTypeInfo
-{
-public :
-       wxClassTypeInfo( wxClassInfo* classInfo ) 
-       { m_kind = wxT_OBJECT ; m_classInfo = classInfo ;}
-       const wxClassInfo *GetClassInfo() const { assert( m_kind == wxT_OBJECT ) ; return m_classInfo ; }
-private :
-       wxClassInfo *m_classInfo; // Kind == wxT_OBJECT - could be NULL
-} ;
-
-// a delegate is an exposed event source 
-
-class WXDLLIMPEXP_BASE wxDelegateTypeInfo : public wxTypeInfo
-{
-public :
-       wxDelegateTypeInfo( int eventType , wxClassInfo* eventClass ) 
-       { m_kind = wxT_DELEGATE ; m_eventClass = eventClass ; m_eventType = eventType ;}
-       const wxClassInfo *GetEventClass() const { assert( m_kind == wxT_DELEGATE ) ; return m_eventClass ; }
-       int GetEventType() const { assert( m_kind == wxT_DELEGATE ) ; return m_eventType ; }
-private :
-       const wxClassInfo *m_eventClass; // (extended will merge into classinfo)
-       int m_eventType ;
-} ;
-
-template<typename T> const wxTypeInfo* wxGetTypeInfo( T * ) ;
-
-template<typename T> const wxTypeInfo* wxGetTypeInfo( wxSet<T> * ) 
-{
-       static wxEnumTypeInfo s_typeInfo(wxT_SET , wxGetEnumData((T) 0) ) ; return &s_typeInfo ; 
-}
-
-// this macro is for usage with custom, non-object derived classes and structs, wxPoint is such a custom type
-
-#define WX_CUSTOM_TYPE_INFO( e ) \
-       template<> const wxTypeInfo* wxGetTypeInfo( e * ){ static wxCustomTypeInfo s_typeInfo(#e) ; return &s_typeInfo ; } \
+class WXDLLIMPEXP_FWD_BASE wxPropertyInfo;
+class WXDLLIMPEXP_FWD_BASE wxHandlerInfo;

 
 

-// ----------------------------------------------------------------------------
-// value streaming 
-//
-// streaming is defined for xml constructs right now, the aim is to make this
-// pluggable in the future
-// ----------------------------------------------------------------------------
-
-// convenience function (avoids including xml headers in users code)
-
-class wxXmlNode ;
-void wxXmlAddContentToNode( wxXmlNode* node , const wxString& data ) ;
-wxString wxXmlGetContentFromNode( wxXmlNode *node ) ;
-
-// templated streaming, every type must have their specialization for these methods
+typedef wxObject *(*wxObjectConstructorFn)(void);
+typedef wxPropertyInfo *(*wxPropertyInfoFn)(void);
+typedef wxHandlerInfo *(*wxHandlerInfoFn)(void);
+typedef void (*wxVariantToObjectConverter)( const wxAny &data, wxObjectFunctor* fn );
+typedef wxObject* (*wxVariantToObjectPtrConverter) ( const wxAny& data);
+typedef wxAny (*wxObjectToVariantConverter)( wxObject* );

 
 

-template<typename T>
-void wxStringReadValue( const wxString &s , T &data ) ;
+WXDLLIMPEXP_BASE wxString wxAnyGetAsString( const wxAny& data);
+WXDLLIMPEXP_BASE const wxObject* wxAnyGetAsObjectPtr( const wxAny& data);

 
 

-template<typename T>
-void wxStringWriteValue( wxString &s , const T &data) ;
+class WXDLLIMPEXP_BASE wxObjectWriter;
+class WXDLLIMPEXP_BASE wxObjectWriterCallback;

 
 

-// for simple types this default implementation is ok, composited structures will have to
-// loop through their properties 
+typedef bool (*wxObjectStreamingCallback) ( const wxObject *, wxObjectWriter *, \
+                                            wxObjectWriterCallback *, const wxStringToAnyHashMap & );

 
 

-template<typename T>
-void wxXmlReadValue( wxXmlNode *node , T &data ) 
-{
-       wxStringReadValue<T>( wxXmlGetContentFromNode( node ) , data ) ;
-}
-
-template<typename T>
-void wxXmlWriteValue( wxXmlNode *node , const T &data) 
-{
-       wxString s ;
-       wxStringWriteValue<T>( s, data ) ;
-       wxXmlAddContentToNode( node ,s ) ;
-}

 
 

-// ----------------------------------------------------------------------------
-// wxxVariant as typesafe data holder
-// ----------------------------------------------------------------------------

 
 

-class WXDLLIMPEXP_BASE wxxVariantData
+class WXDLLIMPEXP_BASE wxClassInfo

 {
 {

-public:
-       virtual ~wxxVariantData() {}
-
-       // return a heap allocated duplicate
-       virtual wxxVariantData* Clone() const = 0 ;
-
-       // returns the type info of the contentc
-       virtual const wxTypeInfo* GetTypeInfo() const = 0 ;
-
-       // write the value into an xml node
-       virtual void Write( wxXmlNode* node ) const = 0 ;
-
-       // read the value from the xml node
-       virtual void Read( wxXmlNode* node ) = 0 ;
-
-       // write the value into a string
-       virtual void Write( wxString &s ) const = 0 ;
-
-       // read the value from a string
-       virtual void Read( const wxString &s) = 0 ;
-} ;
+    friend class WXDLLIMPEXP_BASE wxPropertyInfo;
+    friend class /* WXDLLIMPEXP_BASE */ wxHandlerInfo;
+    friend wxObject *wxCreateDynamicObject(const wxString& name);

 
 

-template<typename T> class WXDLLIMPEXP_BASE wxxVariantDataT : public wxxVariantData
-{

 public:
 public:

-    wxxVariantDataT(T d) : m_data(d) {}
-       virtual ~wxxVariantDataT() {}
-
-       // get a copy of the stored data
-    T Get() const { return m_data; }
-
-       // set the data
-    void Set(T d) { m_data =  d; }
-
-       // return a heap allocated duplicate
-       virtual wxxVariantData* Clone() const { return new wxxVariantDataT<T>( Get() ) ; }
+    wxClassInfo(const wxClassInfo **_Parents,
+                const wxChar *_UnitName,
+                const wxChar *_ClassName,
+                int size,
+                wxObjectConstructorFn ctor,
+                wxPropertyInfoFn _Props,
+                wxHandlerInfoFn _Handlers,
+                wxObjectAllocatorAndCreator* _Constructor,
+                const wxChar ** _ConstructorProperties,
+                const int _ConstructorPropertiesCount,
+                wxVariantToObjectPtrConverter _PtrConverter1,
+                wxVariantToObjectConverter _Converter2,
+                wxObjectToVariantConverter _Converter3,
+                wxObjectStreamingCallback _streamingCallback = NULL) :
+            m_className(_ClassName),
+            m_objectSize(size),
+            m_objectConstructor(ctor),
+            m_next(sm_first),
+            m_firstPropertyFn(_Props),
+            m_firstHandlerFn(_Handlers),
+            m_firstProperty(NULL),
+            m_firstHandler(NULL),
+            m_firstInited(false),
+            m_parents(_Parents),
+            m_unitName(_UnitName),
+            m_constructor(_Constructor),
+            m_constructorProperties(_ConstructorProperties),
+            m_constructorPropertiesCount(_ConstructorPropertiesCount),
+            m_variantOfPtrToObjectConverter(_PtrConverter1),
+            m_variantToObjectConverter(_Converter2),
+            m_objectToVariantConverter(_Converter3),
+            m_streamingCallback(_streamingCallback)
+    {
+        sm_first = this;
+        Register();
+    }

 
 

-       // returns the type info of the contentc
-       virtual const wxTypeInfo* GetTypeInfo() const { return wxGetTypeInfo( (T*) NULL ) ; }
+    wxClassInfo(const wxChar *_UnitName, const wxChar *_ClassName,
+                const wxClassInfo **_Parents) :
+            m_className(_ClassName),
+            m_objectSize(0),
+            m_objectConstructor(NULL),
+            m_next(sm_first),
+            m_firstPropertyFn(NULL),
+            m_firstHandlerFn(NULL),
+            m_firstProperty(NULL),
+            m_firstHandler(NULL),
+            m_firstInited(true),
+            m_parents(_Parents),
+            m_unitName(_UnitName),
+            m_constructor(NULL),
+            m_constructorProperties(NULL),
+            m_constructorPropertiesCount(0),
+            m_variantOfPtrToObjectConverter(NULL),
+            m_variantToObjectConverter(NULL),
+            m_objectToVariantConverter(NULL),
+            m_streamingCallback(NULL)
+    {
+        sm_first = this;
+        Register();
+    }

 
 

-       // write the value into an xml node
-       virtual void Write( wxXmlNode* node ) const { wxXmlWriteValue( node , m_data ) ; }
+    // ctor compatible with old RTTI system
+    wxClassInfo(const wxChar *_ClassName,
+                const wxClassInfo *_Parent1,
+                const wxClassInfo *_Parent2,
+                int size,
+                wxObjectConstructorFn ctor) :
+            m_className(_ClassName),
+            m_objectSize(size),
+            m_objectConstructor(ctor),
+            m_next(sm_first),
+            m_firstPropertyFn(NULL),
+            m_firstHandlerFn(NULL),
+            m_firstProperty(NULL),
+            m_firstHandler(NULL),
+            m_firstInited(true),
+            m_parents(NULL),
+            m_unitName(NULL),
+            m_constructor(NULL),
+            m_constructorProperties(NULL),
+            m_constructorPropertiesCount(0),
+            m_variantOfPtrToObjectConverter(NULL),
+            m_variantToObjectConverter(NULL),
+            m_objectToVariantConverter(NULL),
+            m_streamingCallback(NULL)
+    {
+        sm_first = this;
+        m_parents[0] = _Parent1;
+        m_parents[1] = _Parent2;
+        m_parents[2] = NULL;
+        Register();
+    }

 
 

-       // read the value from the xml node
-       virtual void Read( wxXmlNode* node ) { wxXmlReadValue( node , m_data ) ; }
+    virtual ~wxClassInfo();

 
 

-       // write the value into a string
-       virtual void Write( wxString &s ) const { wxStringWriteValue( s , m_data ) ; }
+    // allocates an instance of this class, this object does not have to be 
+    // initialized or fully constructed as this call will be followed by a call to Create
+    virtual wxObject *AllocateObject() const 
+        { return m_objectConstructor ? (*m_objectConstructor)() : 0; }

 
 

-       // read the value from a string
-       virtual void Read( const wxString &s) { wxStringReadValue( s , m_data ) ; }
+    // 'old naming' for AllocateObject staying here for backward compatibility
+    wxObject *CreateObject() const { return AllocateObject(); }

 
 

-private:
-    T m_data;
-};
+    // direct construction call for classes that cannot construct instances via alloc/create
+    wxObject *ConstructObject(int ParamCount, wxAny *Params) const;

 
 

-class WXDLLIMPEXP_BASE wxxVariant
-{
-public :
-       wxxVariant() { m_data = NULL ; }
-       wxxVariant( wxxVariantData* data , const wxString& name = wxT("") ) : m_data(data) , m_name(name) {}
-       wxxVariant( const wxxVariant &d ) { if ( d.m_data ) m_data = d.m_data->Clone() ; else m_data = NULL ; m_name = d.m_name ; }
-
-       template<typename T> wxxVariant( T data , const wxString& name = wxT("") ) : 
-               m_data(new wxxVariantDataT<T>(data) ), m_name(name) {}
-       ~wxxVariant() { delete m_data ; }
-
-       // get a copy of the stored data
-       template<typename T> T Get() const
-       {
-               wxxVariantDataT<T> *dataptr = dynamic_cast<wxxVariantDataT<T>*> (m_data) ;
-               assert( dataptr ) ;
-               return dataptr->Get() ;
-       }
-       
-       // stores the data
-       template<typename T> Set(T data) const
-       {
-               delete m_data ;
-               m_data = new wxxVariantDataT<T>(data) ;
-       }
-
-       wxxVariant& operator=(const wxxVariant &d)
-       {
-               m_data = d.m_data->Clone() ; 
-               m_name = d.m_name ;
-               return *this ;
-       }
-       
-       // gets the stored data casted to a wxObject* , returning NULL if cast is not possible
-       wxObject* GetAsObject() const ;
-
-       // write the value into an xml node
-       void Write( wxXmlNode* node ) const { m_data->Write( node ) ; }
-
-       // read the value from the xml node
-       void Read( wxXmlNode* node ) { m_data->Read( node ) ; }
-
-       // write the value into a string
-       void Write( wxString &s ) const { m_data->Write( s ) ; }
-
-       // read the value from a string
-       void Read( const wxString &s) { m_data->Read( s ) ; }
-
-       // returns this value as string
-       wxString GetAsString() const
-       {
-               wxString s ;
-               Write( s ) ;
-               return s ;
-       }
-
-       void SetFromString( const wxString &s)
-       {
-               Read( s ) ;
-       }
-private :
-       wxxVariantData* m_data ;
-       wxString m_name ;
-} ;
+    bool NeedsDirectConstruction() const;
+    
+    const wxChar       *GetClassName() const 
+        { return m_className; }
+    const wxChar       *GetBaseClassName1() const
+        { return m_parents[0] ? m_parents[0]->GetClassName() : NULL; }
+    const wxChar       *GetBaseClassName2() const
+        { return (m_parents[0] && m_parents[1]) ? m_parents[1]->GetClassName() : NULL; }

 
 

-// ----------------------------------------------------------------------------
-// Property Support
-//
-// wxPropertyInfo is used to inquire of the property by name.  It doesn't
-// provide access to the property, only information about it.  If you
-// want access, look at wxPropertyAccessor.
-// ----------------------------------------------------------------------------
+    const wxClassInfo  *GetBaseClass1() const
+        { return m_parents[0]; }
+    const wxClassInfo  *GetBaseClass2() const
+        { return m_parents[0] ? m_parents[1] : NULL; }

 
 

-class WXDLLIMPEXP_BASE wxPropertyAccessor
-{
-public :
-    virtual void SetProperty(wxObject *object, const wxxVariant &value) const = 0 ;
-    virtual wxxVariant GetProperty(wxObject *object) const = 0 ;
-    virtual bool HasSetter() const = 0 ;
-    virtual bool HasGetter() const = 0 ;
-       const wxChar * GetGetterName() const { return m_setterName ; }
-       const wxChar * GetSetterName() const { return m_getterName ; }
-       virtual wxxVariant ReadValue( wxXmlNode* node ) const = 0 ;
-       virtual void WriteValue( wxXmlNode* node , wxObject *o ) const = 0 ;
-       virtual wxxVariant ReadValue( const wxString &value ) const = 0 ;
-       virtual void WriteValue( wxString& value , wxObject *o ) const = 0 ;
-protected :
-       const wxChar *m_setterName ;
-       const wxChar *m_getterName ;
-};
+    const wxChar       *GetIncludeName() const 
+        { return m_unitName; }
+    const wxClassInfo **GetParents() const 
+        { return m_parents; }
+    int                 GetSize() const 
+        { return m_objectSize; }
+    bool                IsDynamic() const 
+        { return (NULL != m_objectConstructor); }

 
 

-template<typename T>
-void wxXmlReadValue( wxXmlNode *node , T &data ) ;
+    wxObjectConstructorFn      GetConstructor() const 
+        { return m_objectConstructor; }
+    const wxClassInfo         *GetNext() const 
+        { return m_next; }

 
 

-template<typename T>
-void wxXmlWriteValue( wxXmlNode *node , const T &data) ;
+    // statics:

 
 

-template<class Klass, typename T>
-class WXDLLIMPEXP_BASE wxPropertyAccessorT : public wxPropertyAccessor
-{
-public:
-    typedef void (Klass::*setter_t)(T value);
-    typedef void (Klass::*setter_ref_t)(const T& value);
-    typedef T (Klass::*getter_t)() const;
-    typedef const T& (Klass::*getter_ref_t)() const;
-
-    wxPropertyAccessorT(setter_t setter, getter_t getter, const wxChar *g, const wxChar *s)
-        : m_setter(setter), m_setter_ref(NULL), m_getter(getter) ,m_getter_ref(NULL) {m_setterName = s;m_getterName=g ;}
-    wxPropertyAccessorT(int WXUNUSED(zero), getter_t getter, const wxChar *g, const wxChar *s)
-        : m_setter(NULL), m_setter_ref(NULL), m_getter(getter) ,m_getter_ref(NULL) {m_setterName = s;m_getterName=g ;}
-    wxPropertyAccessorT(setter_ref_t setter, getter_t getter, const wxChar *g, const wxChar *s)
-        : m_setter(NULL), m_setter_ref(setter), m_getter(getter) , m_getter_ref(NULL){m_setterName = s;m_getterName=g ;}
-    wxPropertyAccessorT(setter_ref_t setter, getter_ref_t getter, const wxChar *g, const wxChar *s)
-        : m_setter(NULL), m_setter_ref(setter), m_getter(NULL) , m_getter_ref(getter){m_setterName = s;m_getterName=g ;}
-    wxPropertyAccessorT(setter_t setter, getter_ref_t getter, const wxChar *g, const wxChar *s)
-        : m_setter(NULL), m_setter(setter), m_getter(NULL) ,  m_getter_ref(getter){m_setterName = s;m_getterName=g ;}
-    wxPropertyAccessorT(int WXUNUSED(zero), getter_ref_t getter, const wxChar *g, const wxChar *s)
-        : m_setter(NULL), m_setter(NULL), m_getter(NULL) ,  m_getter_ref(getter){m_setterName = s;m_getterName=g ;}
-
-       // returns true if this accessor has a setter
-       bool HasSetter() const { return m_setter != NULL || m_setter_ref != NULL ; }
-
-       // return true if this accessor has a getter
-       bool HasGetter() const { return m_getter != NULL || m_getter_ref != NULL ; }
-
-       // set the property this accessor is responsible for in an object
-       void SetProperty(wxObject *o, const wxxVariant &v) const
-    {
-        Klass *obj = dynamic_cast<Klass*>(o);
-        T value = v.Get<T>();
-        if (m_setter)
-            (obj->*(m_setter))(value);
-        else
-            (obj->*(m_setter_ref))(value);
-    }
+    static void                CleanUp();
+    static wxClassInfo        *FindClass(const wxString& className);
+    static const wxClassInfo  *GetFirst() 
+        { return sm_first; }

 
 

-       // gets the property this accessor is responsible for from an object
-    wxxVariant GetProperty(wxObject *o) const
-    {
-               return wxxVariant( (wxxVariantData* ) DoGetProperty( o ) ) ;
-     }
-
-       // write the property this accessor is responsible for from an object into
-       // a xml node
-       void WriteValue( wxXmlNode* node , wxObject *o ) const
-       {
-               DoGetProperty( o )->Write( node ) ;
-       }
-
-       // write the property this accessor is responsible for from an object into
-       // a string
-       void WriteValue( wxString& s , wxObject *o ) const
-       {
-               DoGetProperty( o )->Write( s ) ;
-       }
-
-       // read a wxxVariant having the correct type for the property this accessor
-       // is responsible for from an xml node
-       wxxVariant ReadValue( wxXmlNode* node ) const
-       {
-               T data ;
-               wxXmlReadValue( node , data ) ;
-               return wxxVariant( data ) ;
-       }
-
-       // read a wxxVariant having the correct type for the property this accessor
-       // is responsible for from a string
-       wxxVariant ReadValue( const wxString &value ) const
-       {
-               T data ;
-               wxStringReadValue( value , data ) ;
-               return wxxVariant( data ) ;
-       }
-
-private :
-    wxxVariantDataT<T>* DoGetProperty(wxObject *o) const
-    {
-        Klass *obj = dynamic_cast<Klass*>(o);
-               if ( m_getter )
-                       return new wxxVariantDataT<T>( (obj->*(m_getter))() ) ;
-               else
-                       return new wxxVariantDataT<T>( (obj->*(m_getter_ref))() ) ;
-    }

 
 

-    setter_t m_setter;
-    setter_ref_t m_setter_ref;
-    getter_t m_getter;
-       getter_ref_t m_getter_ref ;
-};
+    // Climb upwards through inheritance hierarchy.
+    // Dual inheritance is catered for.

 
 

-class WXDLLIMPEXP_BASE wxPropertyInfo
-{
-public :
-       wxPropertyInfo( wxPropertyInfo* &iter , const wxChar *name , const wxChar *typeName , const wxTypeInfo* typeInfo , wxPropertyAccessor *accessor , wxxVariant dv ) :
-          m_name( name ) , m_typeName(typeName) , m_typeInfo( typeInfo ) , m_accessor( accessor ) , m_defaultValue( dv )
-       {
-               m_next = NULL ;
-               if ( iter == NULL )
-                       iter = this ;
-               else
-               {
-                       wxPropertyInfo* i = iter ;
-                       while( i->m_next )
-                               i = i->m_next ;
-
-                       i->m_next = this ;
-               }
-       }
-       // return the name of this property
-       const wxChar *          GetName() const { return m_name ; }
-
-       // return the typename of this property
-       const wxChar *          GetTypeName() const { return m_typeName ; }
-
-       // return the type info of this property
-       const wxTypeInfo *      GetTypeInfo() const { return m_typeInfo ; }
-
-       // return the accessor for this property
-       wxPropertyAccessor* GetAccessor() const { return m_accessor ; }
-
-       // returns NULL if this is the last property of this class
-       wxPropertyInfo*     GetNext() const { return m_next ; }
-
-       // returns the default value of this property, its kind may be wxT_VOID if it is not valid
-       wxxVariant                      GetDefaultValue() const { return m_defaultValue ; }
-private : 
-       const wxChar *          m_name;
-       const wxChar *          m_typeName ;
-       const wxTypeInfo*       m_typeInfo ;
-       wxPropertyAccessor* m_accessor ;
-    wxxVariant m_defaultValue; 
-       // string representation of the default value
-       //  to be assigned by the designer to the property
-       //  when the component is dropped on the container.
-       wxPropertyInfo*         m_next ;
-};
+    bool IsKindOf(const wxClassInfo *info) const;

 
 

-#define WX_BEGIN_PROPERTIES_TABLE(theClass) \
-    const wxPropertyInfo *theClass::GetPropertiesStatic()  \
-    {  \
-        typedef theClass class_t; \
-               static wxPropertyInfo* first = NULL ;
+    wxDECLARE_CLASS_INFO_ITERATORS();

 
 

-#define WX_END_PROPERTIES_TABLE() \
-               return first ; } 
+    // if there is a callback registered with that class it will be called
+    // before this object will be written to disk, it can veto streaming out
+    // this object by returning false, if this class has not registered a
+    // callback, the search will go up the inheritance tree if no callback has
+    // been registered true will be returned by default
+    bool BeforeWriteObject( const wxObject *obj, wxObjectWriter *streamer, 
+                            wxObjectWriterCallback *writercallback, const wxStringToAnyHashMap &metadata) const;

 
 

-#define WX_PROPERTY( name , type , setter , getter ,defaultValue ) \
-       static wxPropertyAccessorT<class_t , type> _accessor##name( setter , getter , #setter , #getter ) ; \
-       static wxPropertyInfo _propertyInfo##name( first , #name , #type , wxGetTypeInfo( (type*) NULL ) ,&_accessor##name , wxxVariant(defaultValue) ) ;
+    // gets the streaming callback from this class or any superclass
+    wxObjectStreamingCallback GetStreamingCallback() const;

 
 

-#define WX_DELEGATE( name , eventType , eventClass ) \
-       static wxDelegateTypeInfo _typeInfo##name( eventType , CLASSINFO( eventClass ) ) ; \
-       static wxPropertyInfo _propertyInfo##name( first , #name , NULL , &_typeInfo##name , NULL , wxxVariant() ) ; \
+    // returns the first property
+    wxPropertyInfo* GetFirstProperty() const 
+        { EnsureInfosInited(); return m_firstProperty; }

 
 

-// ----------------------------------------------------------------------------
-// Handler Info
-//
-// this is describing an event sink
-// ----------------------------------------------------------------------------
+    // returns the first handler
+    wxHandlerInfo* GetFirstHandler() const 
+        { EnsureInfosInited(); return m_firstHandler; }

 
 

-class wxHandlerInfo
-{
-public :
-       wxHandlerInfo( wxHandlerInfo* &iter , const wxChar *name , wxObjectEventFunction address , const wxClassInfo* eventClassInfo ) :
-          m_name( name ) , m_eventClassInfo( eventClassInfo ) , m_eventFunction( address )  
-       {
-               m_next = NULL ;
-               if ( iter == NULL )
-                       iter = this ;
-               else
-               {
-                       wxHandlerInfo* i = iter ;
-                       while( i->m_next )
-                               i = i->m_next ;
-
-                       i->m_next = this ;
-               }
-       }
-
-       // get the name of the handler method
-       const wxChar *          GetName() const { return m_name ; }
-
-       // return the class info of the event
-       const wxClassInfo *     GetEventClassInfo() const { return m_eventClassInfo ; }
-
-       // get the handler function pointer
-       wxObjectEventFunction   GetEventFunction() const { return m_eventFunction ; }
-
-       // returns NULL if this is the last handler of this class
-       wxHandlerInfo*     GetNext() const { return m_next ; }
-private : 
-       wxObjectEventFunction m_eventFunction ;
-       const wxChar *          m_name;
-       const wxClassInfo*      m_eventClassInfo ;
-       wxHandlerInfo*          m_next ;
-};
+    // Call the Create upon an instance of the class, in the end the object is fully
+    // initialized
+    virtual bool Create (wxObject *object, int ParamCount, wxAny *Params) const;

 
 

-#define WX_HANDLER(name,eventClassType) \
-       static wxHandlerInfo _handlerInfo##name( first , #name , (wxObjectEventFunction) (wxEventFunction) &name , CLASSINFO( eventClassType ) ) ;
+    // get number of parameters for constructor
+    virtual int GetCreateParamCount() const 
+        { return m_constructorPropertiesCount; }

 
 

-#define WX_BEGIN_HANDLERS_TABLE(theClass) \
-    const wxHandlerInfo *theClass::GetHandlersStatic()  \
-    {  \
-        typedef theClass class_t; \
-               static wxHandlerInfo* first = NULL ;
+    // get n-th constructor parameter
+    virtual const wxChar* GetCreateParamName(int n) const 
+        { return m_constructorProperties[n]; }

 
 

-#define WX_END_HANDLERS_TABLE() \
-               return first ; } 
+    // Runtime access to objects for simple properties (get/set) by property 
+    // name and variant data
+    virtual void SetProperty (wxObject *object, const wxChar *propertyName, 
+                              const wxAny &value) const;
+    virtual wxAny GetProperty (wxObject *object, const wxChar *propertyName) const;

 
 

-// ----------------------------------------------------------------------------
-// Constructor Bridges
-//
-// allow to set up constructors with params during runtime
-// ----------------------------------------------------------------------------
+    // Runtime access to objects for collection properties by property name
+    virtual wxAnyList GetPropertyCollection(wxObject *object, 
+                                                  const wxChar *propertyName) const;
+    virtual void AddToPropertyCollection(wxObject *object, const wxChar *propertyName, 
+                                         const wxAny& value) const;

 
 

-class WXDLLIMPEXP_BASE wxConstructorBridge
-{
-public :
-    virtual void Create(wxObject *o, wxxVariant *args) = 0;
-};
+    // we must be able to cast variants to wxObject pointers, templates seem 
+    // not to be suitable
+    void CallOnAny( const wxAny &data, wxObjectFunctor* functor ) const;

 
 

-// Creator Bridges for all Numbers of Params
+    wxObject* AnyToObjectPtr( const wxAny &data) const;

 
 

-// no params
+    wxAny ObjectPtrToAny( wxObject *object ) const;

 
 

-template<typename Class>
-struct wxConstructorBridge_0 : public wxConstructorBridge
-{
-    void Create(wxObject *o, wxxVariant *)
-    {
-        Class *obj = dynamic_cast<Class*>(o);
-        obj->Create();
-    }
-};
+    // find property by name
+    virtual const wxPropertyInfo *FindPropertyInfo (const wxChar *PropertyName) const;

 
 

-struct wxConstructorBridge_Dummy : public wxConstructorBridge
-{
-    void Create(wxObject *, wxxVariant *)
-    {
-    }
-} ;
+    // find handler by name
+    virtual const wxHandlerInfo *FindHandlerInfo (const wxChar *handlerName) const;

 
 

-#define WX_CONSTRUCTOR_0(klass) \
-       wxConstructorBridge_0<klass> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 0 ;
+    // find property by name
+    virtual wxPropertyInfo *FindPropertyInfoInThisClass (const wxChar *PropertyName) const;

 
 

-#define WX_CONSTRUCTOR_DUMMY(klass) \
-       wxConstructorBridge_Dummy constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { NULL } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 0 ;
+    // find handler by name
+    virtual wxHandlerInfo *FindHandlerInfoInThisClass (const wxChar *handlerName) const;

 
 

-// 1 param
+    // puts all the properties of this class and its superclasses in the map, 
+    // as long as there is not yet an entry with the same name (overriding mechanism)
+    void GetProperties( wxPropertyInfoMap &map ) const;

 
 

-template<typename Class, typename T0>
-struct wxConstructorBridge_1 : public wxConstructorBridge
-{
-    void Create(wxObject *o, wxxVariant *args)
-    {
-        Class *obj = dynamic_cast<Class*>(o);
-        obj->Create(
-                    args[0].Get<T0>()
-                   );
-    }
-};
+private:
+    const wxChar            *m_className;
+    int                      m_objectSize;
+    wxObjectConstructorFn     m_objectConstructor;

 
 

-#define WX_CONSTRUCTOR_1(klass,t0,v0) \
-       wxConstructorBridge_1<klass,t0> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 1 ;
+    // class info object live in a linked list:
+    // pointers to its head and the next element in it

 
 

-// 2 params
+    static wxClassInfo      *sm_first;
+    wxClassInfo              *m_next;

 
 

-template<typename Class,
-         typename T0, typename T1>
-struct wxConstructorBridge_2 : public wxConstructorBridge
-{
-    void Create(wxObject *o, wxxVariant *args)
-    {
-        Class *obj = dynamic_cast<Class*>(o);
-        obj->Create(
-                    args[0].Get<T0>() ,
-                    args[1].Get<T1>() 
-                   );
-    }
-};
+    static wxHashTable      *sm_classTable;

 
 

-#define WX_CONSTRUCTOR_2(klass,t0,v0,t1,v1) \
-       wxConstructorBridge_2<klass,t0,t1> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 2;
+    wxPropertyInfoFn          m_firstPropertyFn;
+    wxHandlerInfoFn           m_firstHandlerFn;

 
 

-// 3 params

 
 

-template<typename Class,
-         typename T0, typename T1, typename T2>
-struct wxConstructorBridge_3 : public wxConstructorBridge
-{
-    void Create(wxObject *o, wxxVariant *args)
+protected:
+    void                      EnsureInfosInited() const

     {
     {

-        Class *obj = dynamic_cast<Class*>(o);
-        obj->Create(
-                    args[0].Get<T0>() ,
-                    args[1].Get<T1>() ,
-                    args[2].Get<T2>() 
-                   );
+        if ( !m_firstInited)
+        {
+            if ( m_firstPropertyFn != NULL)
+                m_firstProperty = (*m_firstPropertyFn)();
+            if ( m_firstHandlerFn != NULL)
+                m_firstHandler = (*m_firstHandlerFn)();
+            m_firstInited = true;
+        }

     }
     }

-};
+    mutable wxPropertyInfo*   m_firstProperty;
+    mutable wxHandlerInfo*    m_firstHandler;

 
 

-#define WX_CONSTRUCTOR_3(klass,t0,v0,t1,v1,t2,v2) \
-       wxConstructorBridge_3<klass,t0,t1,t2> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 3 ;
+private:
+    mutable bool              m_firstInited;

 
 

-// 4 params
+    const wxClassInfo**       m_parents;
+    const wxChar*             m_unitName;

 
 

-template<typename Class,
-         typename T0, typename T1, typename T2, typename T3>
-struct wxConstructorBridge_4 : public wxConstructorBridge
-{
-    void Create(wxObject *o, wxxVariant *args)
-    {
-        Class *obj = dynamic_cast<Class*>(o);
-        obj->Create(
-                    args[0].Get<T0>() ,
-                    args[1].Get<T1>() ,
-                    args[2].Get<T2>() ,
-                    args[3].Get<T3>() 
-                   );
-    }
-};
+    wxObjectAllocatorAndCreator*     m_constructor;
+    const wxChar **           m_constructorProperties;
+    const int                 m_constructorPropertiesCount;
+    wxVariantToObjectPtrConverter m_variantOfPtrToObjectConverter;
+    wxVariantToObjectConverter m_variantToObjectConverter;
+    wxObjectToVariantConverter m_objectToVariantConverter;
+    wxObjectStreamingCallback  m_streamingCallback;

 
 

-#define WX_CONSTRUCTOR_4(klass,t0,v0,t1,v1,t2,v2,t3,v3) \
-       wxConstructorBridge_4<klass,t0,t1,t2,t3> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 4 ;
+    const wxPropertyAccessor *FindAccessor (const wxChar *propertyName) const;

 
 

-// 5 params
+protected:
+    // registers the class
+    void Register();
+    void Unregister();

 
 

-template<typename Class,
-         typename T0, typename T1, typename T2, typename T3, typename T4>
-struct wxConstructorBridge_5 : public wxConstructorBridge
-{
-    void Create(wxObject *o, wxxVariant *args)
-    {
-        Class *obj = dynamic_cast<Class*>(o);
-        obj->Create(
-                    args[0].Get<T0>() ,
-                    args[1].Get<T1>() ,
-                    args[2].Get<T2>() ,
-                    args[3].Get<T3>() ,
-                    args[4].Get<T4>() 
-                   );
-    }
+    DECLARE_NO_COPY_CLASS(wxClassInfo)

 };
 
 };
 

-#define WX_CONSTRUCTOR_5(klass,t0,v0,t1,v1,t2,v2,t3,v3,t4,v4) \
-       wxConstructorBridge_5<klass,t0,t1,t2,t3,t4> constructor##klass ; \
-       wxConstructorBridge* klass::sm_constructor##klass = &constructor##klass ; \
-       const wxChar *klass::sm_constructorProperties##klass[] = { #v0 , #v1 , #v2 , #v3 , #v4 } ; \
-       const int klass::sm_constructorPropertiesCount##klass = 5;
+WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxString& name);

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

-// wxClassInfo
+// wxDynamicClassInfo

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

-typedef wxObject *(*wxObjectConstructorFn)(void);
-typedef wxObject* (*wxVariantToObjectConverter)( const wxxVariant &data ) ;
-typedef wxxVariant (*wxObjectToVariantConverter)( wxObject* ) ;
+// this object leads to having a pure runtime-instantiation

 
 

-class WXDLLIMPEXP_BASE wxClassInfo
+class WXDLLIMPEXP_BASE wxDynamicClassInfo : public wxClassInfo

 {
 {

-public:
-    wxClassInfo(const wxClassInfo **_Parents,
-                       const wxChar *_UnitName,
-                       const wxChar *_ClassName,
-            int size,
-            wxObjectConstructorFn ctor ,
-                       const wxPropertyInfo *_Props ,
-                       const wxHandlerInfo *_Handlers ,
-                       wxConstructorBridge* _Constructor ,
-                       const wxChar ** _ConstructorProperties , 
-                       const int _ConstructorPropertiesCount ,
-                       wxVariantToObjectConverter _Converter1 ,
-                       wxObjectToVariantConverter _Converter2 
-                       ) : m_parents(_Parents) , m_unitName(_UnitName) ,m_className(_ClassName),
-                       m_objectSize(size), m_objectConstructor(ctor) , m_firstProperty(_Props ) , m_firstHandler(_Handlers ) , m_constructor( _Constructor ) ,
-                       m_constructorProperties(_ConstructorProperties) , m_constructorPropertiesCount(_ConstructorPropertiesCount),
-                       m_variantToObjectConverter( _Converter1 ) , m_objectToVariantConverter( _Converter2 ) , m_next(sm_first)
-       {
-               sm_first = this; 
-               Register( m_className , this ) ;
-       }
-
-    ~wxClassInfo() ;
-
-    wxObject *CreateObject() { return m_objectConstructor ? (*m_objectConstructor)() : 0; }
-
-    const wxChar       *GetClassName() const { return m_className; }
-    const wxClassInfo **GetParents() const { return m_parents; }
-    int                 GetSize() const { return m_objectSize; }
-
-    wxObjectConstructorFn      GetConstructor() const { return m_objectConstructor; }
-    static const wxClassInfo  *GetFirst() { return sm_first; }
-    const wxClassInfo         *GetNext() const { return m_next; }
-    static wxClassInfo        *FindClass(const wxChar *className);
-
-        // Climb upwards through inheritance hierarchy.
-        // Dual inheritance is catered for.
-
-    bool IsKindOf(const wxClassInfo *info) const
-    {
-               if ( info != 0 )
-               {
-                       if ( info == this )
-                               return true ;
-
-                       for ( int i = 0 ; m_parents[i] ; ++ i )
-                       {
-                               if ( m_parents[i]->IsKindOf( info ) )
-                                       return true ;
-                       }
-               }
-               return false ;
-    }
+    friend class WXDLLIMPEXP_BASE wxDynamicObject;

 
 

-    // Initializes parent pointers and hash table for fast searching.
-       // this is going to be removed by Register/Unregister calls
-       // in Constructor / Destructor together with making the hash map private
-
-    static void     InitializeClasses();
-
-    // Cleans up hash table used for fast searching.
-
-    static void     CleanUpClasses();
-
-       // returns the first property
-       const wxPropertyInfo* GetFirstProperty() const { return m_firstProperty ; } 
+public:
+    wxDynamicClassInfo( const wxChar *_UnitName, const wxChar *_ClassName, 
+                        const wxClassInfo* superClass );
+    virtual ~wxDynamicClassInfo();

 
 

-       // returns the first handler 
-       const wxHandlerInfo* GetFirstHandler() const { return m_firstHandler ; } 
+    // constructs a wxDynamicObject with an instance
+    virtual wxObject *AllocateObject() const;

 
     // Call the Create method for a class
 
     // Call the Create method for a class

-    virtual void Create (wxObject *object, int ParamCount, wxxVariant *Params) 
-       {
-               wxASSERT( ParamCount == m_constructorPropertiesCount ) ;
-               m_constructor->Create( object , Params ) ;
-       }
+    virtual bool Create (wxObject *object, int ParamCount, wxAny *Params) const;

 
 

-       // get number of parameters for constructor
-       virtual int GetCreateParamCount() const { return m_constructorPropertiesCount; }
+    // get number of parameters for constructor
+    virtual int GetCreateParamCount() const;

 
 

-       // get i-th constructor parameter
-       virtual const wxChar* GetCreateParamName(int i) const { return m_constructorProperties[i] ; }
+    // get i-th constructor parameter
+    virtual const wxChar* GetCreateParamName(int i) const;

 
 

-   // Runtime access to objects by property name, and variant data
-    virtual void SetProperty (wxObject *object, const wxChar *PropertyName, const wxxVariant &Value);
-    virtual wxxVariant GetProperty (wxObject *object, const wxChar *PropertyName);
+    // Runtime access to objects by property name, and variant data
+    virtual void SetProperty (wxObject *object, const wxChar *PropertyName, 
+                              const wxAny &Value) const;
+    virtual wxAny GetProperty (wxObject *object, const wxChar *PropertyName) const;

 
 

-       // we must be able to cast variants to wxObject pointers, templates seem not to be suitable
-       wxObject* VariantToInstance( const wxxVariant &data ) const { return m_variantToObjectConverter( data ) ; }
-       wxxVariant InstanceToVariant( wxObject *object ) const { return m_objectToVariantConverter( object ) ; }
-    
-       // find property by name
-    virtual const wxPropertyInfo *FindPropertyInfo (const wxChar *PropertyName) const ;
+    // adds a property to this class at runtime
+    void AddProperty( const wxChar *propertyName, const wxTypeInfo* typeInfo );

 
 

-       // find handler by name
-    virtual const wxHandlerInfo *FindHandlerInfo (const wxChar *PropertyName) const ;
+    // removes an existing runtime-property
+    void RemoveProperty( const wxChar *propertyName );

 
 

-public:
-    const wxChar            *m_className;
-    int                      m_objectSize;
-    wxObjectConstructorFn    m_objectConstructor;
+    // renames an existing runtime-property
+    void RenameProperty( const wxChar *oldPropertyName, const wxChar *newPropertyName );

 
 

-    // class info object live in a linked list:
-    // pointers to its head and the next element in it
+    // as a handler to this class at runtime
+    void AddHandler( const wxChar *handlerName, wxObjectEventFunction address, 
+                     const wxClassInfo* eventClassInfo );

 
 

-    static wxClassInfo      *sm_first;
-    wxClassInfo             *m_next;
+    // removes an existing runtime-handler
+    void RemoveHandler( const wxChar *handlerName );

 
 

-       // FIXME: this should be private (currently used directly by way too
-    //        many clients)
-    static wxHashTable      *sm_classTable;
+    // renames an existing runtime-handler
+    void RenameHandler( const wxChar *oldHandlerName, const wxChar *newHandlerName );

 
 private:
 
 private:

-       const wxClassInfo**             m_parents ;
-       const wxPropertyInfo *  m_firstProperty ;
-       const wxHandlerInfo *   m_firstHandler ;
-    const wxChar*                      m_unitName;
-
-       wxConstructorBridge*    m_constructor ;
-       const wxChar **                 m_constructorProperties ; 
-       const int                               m_constructorPropertiesCount ;
-       wxVariantToObjectConverter m_variantToObjectConverter ; 
-       wxObjectToVariantConverter m_objectToVariantConverter ;
-
-    const wxPropertyAccessor *FindAccessor (const wxChar *propertyName);
-
-       // registers the class
-       static void Register(const wxChar *name, wxClassInfo *info);
-       
-       static void Unregister(const wxChar *name);
-
-       // InitializeClasses() helper
-    static wxClassInfo *GetBaseByName(const wxChar *name);
-
-    DECLARE_NO_COPY_CLASS(wxClassInfo)
+    struct wxDynamicClassInfoInternal;
+    wxDynamicClassInfoInternal* m_data;

 };
 
 };
 

-WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
-

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

-// Dynamic class macros
+// wxDECLARE class macros

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

-#define _DECLARE_DYNAMIC_CLASS(name)           \
- public:                                      \
-  static wxClassInfo sm_class##name;          \
-  static const wxClassInfo* sm_classParents##name[] ; \
-  static const wxPropertyInfo* GetPropertiesStatic() ; \
-  static const wxHandlerInfo* GetHandlersStatic() ; \
-  virtual wxClassInfo *GetClassInfo() const   \
-   { return &name::sm_class##name; }
-
-#define DECLARE_DYNAMIC_CLASS(name)           \
-       _DECLARE_DYNAMIC_CLASS(name) \
-       static wxConstructorBridge* sm_constructor##name ; \
-       static const wxChar * sm_constructorProperties##name[] ; \
-       static const int sm_constructorPropertiesCount##name ;
-
-#define DECLARE_DYNAMIC_CLASS_NO_ASSIGN(name)   \
-    DECLARE_NO_ASSIGN_CLASS(name)               \
-    DECLARE_DYNAMIC_CLASS(name)
-
-#define DECLARE_DYNAMIC_CLASS_NO_COPY(name)   \
-    DECLARE_NO_COPY_CLASS(name)               \
-    DECLARE_DYNAMIC_CLASS(name)
-
-#define DECLARE_ABSTRACT_CLASS(name) _DECLARE_DYNAMIC_CLASS(name)
-#define DECLARE_CLASS(name) DECLARE_DYNAMIC_CLASS(name)
-
-// -----------------------------------
-// for concrete classes
-// -----------------------------------
-
-    // Single inheritance with one base class
-
-#define _IMPLEMENT_DYNAMIC_CLASS(name, basename, unit)                 \
- wxObject* wxConstructorFor##name()                             \
-  { return new name; }                                          \
- const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
- wxObject* wxVariantToObjectConverter##name ( const wxxVariant &data ) { return data.Get<name*>() ; } \
- wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data)  ) ; } \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name),   \
-            (int) sizeof(name),                              \
-            (wxObjectConstructorFn) wxConstructorFor##name   ,   \
-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name ,     \
-                       name::sm_constructorPropertiesCount##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name);    \
- template<> void wxStringReadValue(const wxString & , name * & ){assert(0) ;}\
- template<> void wxStringWriteValue(wxString & , name* const & ){assert(0) ;}\
- template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
-
-#define IMPLEMENT_DYNAMIC_CLASS( name , basename ) \
-_IMPLEMENT_DYNAMIC_CLASS( name , basename , "" ) \
-const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
-const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
-WX_CONSTRUCTOR_DUMMY( name )
-
-#define IMPLEMENT_DYNAMIC_CLASS_XTI( name , basename , unit ) \
-_IMPLEMENT_DYNAMIC_CLASS( name , basename , unit )
-
-// this is for classes that do not derive from wxobject, there are no creators for these 
-
-#define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_NO_BASE_XTI( name , unit ) \
- const wxClassInfo* name::sm_classParents##name[] = { NULL } ; \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name),   \
-            (int) sizeof(name),                              \
-            (wxObjectConstructorFn) 0   ,   \
-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 ,     \
-                       0 , 0 , 0 );    \
- template<> void wxStringReadValue(const wxString & , name * & ){assert(0) ;}\
- template<> void wxStringWriteValue(wxString & , name* const & ){assert(0) ;}\
- template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
-
-// this is for subclasses that still do not derive from wxobject
-
-#define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_XTI( name , basename, unit ) \
- const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name),   \
-            (int) sizeof(name),                              \
-            (wxObjectConstructorFn) 0   ,   \
-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 ,     \
-                       0 , 0 , 0 );    \
- template<> void wxStringReadValue(const wxString & , name * & ){assert(0) ;}\
- template<> void wxStringWriteValue(wxString & , name* const & ){assert(0) ;}\
- template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
-
-    // Multiple inheritance with two base classes
-
-#define _IMPLEMENT_DYNAMIC_CLASS2(name, basename, basename2, unit)                 \
- wxObject* wxConstructorFor##name()                             \
-  { return new name; }                                          \
-  const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,&basename2::sm_class##basename2 , NULL } ; \
- wxObject* wxVariantToObjectConverter##name ( const wxxVariant &data ) { return data.Get<name*>() ; } \
- wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data)  ) ; } \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT(unit) , wxT(#name),   \
-            (int) sizeof(name),                              \
-            (wxObjectConstructorFn) wxConstructorFor##name   ,   \
-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),name::sm_constructor##name , name::sm_constructorProperties##name ,     \
-                       name::sm_constructorPropertiesCount##name , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name);    \
- template<> void wxStringReadValue(const wxString & , name * & ){assert(0) ;}\
- template<> void wxStringWriteValue(wxString & , name* const & ){assert(0) ;}\
- template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
-
-#define IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2) \
-_IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , "") \
-const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } \
-const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
-WX_CONSTRUCTOR_DUMMY( name )
-
-#define IMPLEMENT_DYNAMIC_CLASS2_XTI( name , basename , basename2, unit) \
-       _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , unit) 
-
-// -----------------------------------
-// for abstract classes
-// -----------------------------------
-
-    // Single inheritance with one base class
-
-#define _IMPLEMENT_ABSTRACT_CLASS(name, basename)                \
- const wxClassInfo* name::sm_classParents##name[] = { &basename::sm_class##basename ,NULL } ; \
- wxObject* wxVariantToObjectConverter##name ( const wxxVariant &data ) { return data.Get<name*>() ; } \
- wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data)  ) ; } \
- wxClassInfo name::sm_class##name(sm_classParents##name , wxT("") , wxT(#name),   \
-            (int) sizeof(name),                              \
-            (wxObjectConstructorFn) 0   ,   \
-                       name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 ,     \
-                       0 , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name);    \
- template<> void wxStringReadValue(const wxString & , name * & ){assert(0) ;}\
- template<> void wxStringWriteValue(wxString & , name* const & ){assert(0) ;}\
- template<> const wxTypeInfo* wxGetTypeInfo( name ** ){ static wxClassTypeInfo s_typeInfo(&name::sm_class##name) ; return &s_typeInfo ; }
-
-#define IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
-_IMPLEMENT_ABSTRACT_CLASS( name , basename ) \
-const wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL ; } \
-const wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL ; } 
-
-    // Multiple inheritance with two base classes
-
-#define IMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2)   \
- wxClassInfo name::sm_class##name(wxT(#name), wxT(#basename1),  \
-            wxT(#basename2), (int) sizeof(name),                \
-            (wxObjectConstructorFn) 0);
-
-#define IMPLEMENT_CLASS IMPLEMENT_ABSTRACT_CLASS
-#define IMPLEMENT_CLASS2 IMPLEMENT_ABSTRACT_CLASS2
-
-#endif
\ No newline at end of file
+#define _DECLARE_DYNAMIC_CLASS(name)                        \
+    public:                                                 \
+        static wxClassInfo ms_classInfo;                    \
+        static const wxClassInfo* ms_classParents[];        \
+        static wxPropertyInfo* GetPropertiesStatic();       \
+        static wxHandlerInfo* GetHandlersStatic();          \
+        static wxClassInfo *GetClassInfoStatic()            \
+            { return &name::ms_classInfo; }                 \
+        virtual wxClassInfo *GetClassInfo() const           \
+            { return &name::ms_classInfo; }
+
+#define wxDECLARE_DYNAMIC_CLASS(name)                       \
+    static wxObjectAllocatorAndCreator* ms_constructor;           \
+    static const wxChar * ms_constructorProperties[];       \
+    static const int ms_constructorPropertiesCount;         \
+    _DECLARE_DYNAMIC_CLASS(name)
+
+#define wxDECLARE_DYNAMIC_CLASS_NO_ASSIGN(name)             \
+    wxDECLARE_NO_ASSIGN_CLASS(name);                        \
+    wxDECLARE_DYNAMIC_CLASS(name)
+
+#define wxDECLARE_DYNAMIC_CLASS_NO_COPY(name)               \
+    wxDECLARE_NO_COPY_CLASS(name);                          \
+    wxDECLARE_DYNAMIC_CLASS(name)
+
+#define wxDECLARE_CLASS(name)                               \
+    wxDECLARE_DYNAMIC_CLASS(name)
+
+#define wxDECLARE_ABSTRACT_CLASS(name)    _DECLARE_DYNAMIC_CLASS(name)
+#define wxCLASSINFO(name)                 (&name::ms_classInfo)
+
+#endif  // wxUSE_EXTENDED_RTTI
+#endif // _WX_XTIH__