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

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/wxt2.h
// Purpose:     runtime metadata information (extended class info)
// Author:      Stefan Csomor
// Modified by: Francesco Montorsi
// Created:     27/07/03
// RCS-ID:      $Id$
// Copyright:   (c) 1997 Julian Smart
//              (c) 2003 Stefan Csomor
/////////////////////////////////////////////////////////////////////////////

#ifndef _WX_XTI2H__
#define _WX_XTI2H__

// ----------------------------------------------------------------------------
// second part of xti headers, is included from object.h
// ----------------------------------------------------------------------------

#if wxUSE_EXTENDED_RTTI

// ----------------------------------------------------------------------------
// wxDynamicObject class, its instances connect to a 'super class instance'
// ----------------------------------------------------------------------------

class WXDLLIMPEXP_BASE wxDynamicObject : public wxObject
{
    friend class WXDLLIMPEXP_FWD_BASE wxDynamicClassInfo ;
public:
    // instantiates this object with an instance of its superclass
    wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info) ;
    virtual ~wxDynamicObject();

    void SetProperty (const wxChar *propertyName, const wxAny &value);
    wxAny GetProperty (const wxChar *propertyName) const ;

    // get the runtime identity of this object
    wxClassInfo *GetClassInfo() const
    {
#ifdef _MSC_VER
        return (wxClassInfo*) m_classInfo;
#else
        wxDynamicClassInfo *nonconst = const_cast<wxDynamicClassInfo *>(m_classInfo);
        return static_cast<wxClassInfo *>(nonconst);
#endif
    }

    wxObject* GetSuperClassInstance() const
    {
        return m_superClassInstance ;
    }
private :
    // removes an existing runtime-property
    void RemoveProperty( const wxChar *propertyName ) ;

    // renames an existing runtime-property
    void RenameProperty( const wxChar *oldPropertyName , const wxChar *newPropertyName ) ;

    wxObject *m_superClassInstance ;
    const wxDynamicClassInfo *m_classInfo;
    struct wxDynamicObjectInternal;
    wxDynamicObjectInternal *m_data;
};

// ----------------------------------------------------------------------------
// String conversion templates supporting older compilers
// ----------------------------------------------------------------------------

#if wxUSE_FUNC_TEMPLATE_POINTER
#  define wxTO_STRING(type) wxToStringConverter<type>
#  define wxTO_STRING_IMP(type)
#  define wxFROM_STRING(type) wxFromStringConverter<type>
#  define wxFROM_STRING_IMP(type)
#else
#  define wxTO_STRING(type) ToString##type
#  define wxTO_STRING_IMP(type) \
    inline void ToString##type( const wxAny& data, wxString &result ) \
{ wxToStringConverter<type>(data, result); }

#  define wxFROM_STRING(type) FromString##type
#  define wxFROM_STRING_IMP(type) \
    inline void FromString##type( const wxString& data, wxAny &result ) \
{ wxFromStringConverter<type>(data, result); }
#endif

#include "wx/xtiprop.h"
#include "wx/xtictor.h"

// ----------------------------------------------------------------------------
// wxIMPLEMENT class macros for concrete classes
// ----------------------------------------------------------------------------

// Single inheritance with one base class

#define _DEFAULT_CONSTRUCTOR(name)                                          \
wxObject* wxConstructorFor##name()                                          \
{ return new name; }                                                        

#define _DEFAULT_CONVERTERS(name)                                          \
wxObject* wxVariantOfPtrToObjectConverter##name ( const wxAny &data )        \
{ return data.As( (name**)NULL ); }                    \
    wxAny wxObjectToVariantConverter##name ( wxObject *data )              \
{ return wxAny( wx_dynamic_cast(name*, data)  ); }

#define _TYPEINFO_CLASSES(n, toString, fromString )                           \
    wxClassTypeInfo s_typeInfo##n(wxT_OBJECT, &n::ms_classInfo,               \
    toString, fromString, typeid(n).name());    \
    wxClassTypeInfo s_typeInfoPtr##n(wxT_OBJECT_PTR, &n::ms_classInfo,        \
    toString, fromString, typeid(n*).name());

#define _IMPLEMENT_DYNAMIC_CLASS(name, basename, unit, callback)                \
    _DEFAULT_CONSTRUCTOR(name)                                                  \
    _DEFAULT_CONVERTERS(name)                                                   \
    \
    const wxClassInfo* name::ms_classParents[] =                                \
{ &basename::ms_classInfo, NULL };                                      \
    wxClassInfo name::ms_classInfo(name::ms_classParents, wxT(unit),            \
    wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name,   \
    name::GetPropertiesStatic, name::GetHandlersStatic, name::ms_constructor,     \
    name::ms_constructorProperties, name::ms_constructorPropertiesCount,              \
    wxVariantOfPtrToObjectConverter##name, NULL, wxObjectToVariantConverter##name,    \
    callback);

#define _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY(name, basename, unit, callback )         \
    _DEFAULT_CONSTRUCTOR(name)                                                  \
    _DEFAULT_CONVERTERS(name)                                                   \
    void wxVariantToObjectConverter##name ( const wxAny &data, wxObjectFunctor* fn )                 \
{ (*fn)( &wxANY_AS(data, name) ); }                        \
    \
    const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo,NULL };  \
    wxClassInfo name::ms_classInfo(name::ms_classParents, wxT(unit),                \
    wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name,  \
    name::GetPropertiesStatic,name::GetHandlersStatic,name::ms_constructor,      \
    name::ms_constructorProperties, name::ms_constructorPropertiesCount,             \
    wxVariantOfPtrToObjectConverter##name, wxVariantToObjectConverter##name,         \
    wxObjectToVariantConverter##name, callback);

#define wxIMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name, basename )                   \
    _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name, basename, "", NULL )              \
    _TYPEINFO_CLASSES(name, NULL, NULL)                                         \
    const wxPropertyInfo *name::GetPropertiesStatic()                           \
{ return (wxPropertyInfo*) NULL; }                                      \
    const wxHandlerInfo *name::GetHandlersStatic()                              \
{ return (wxHandlerInfo*) NULL; }                                       \
    wxCONSTRUCTOR_DUMMY( name )

#define wxIMPLEMENT_DYNAMIC_CLASS( name, basename )                             \
    _IMPLEMENT_DYNAMIC_CLASS( name, basename, "", NULL )                        \
    _TYPEINFO_CLASSES(name, NULL, NULL)                                         \
    wxPropertyInfo *name::GetPropertiesStatic()                                 \
{ return (wxPropertyInfo*) NULL; }                                      \
    wxHandlerInfo *name::GetHandlersStatic()                                    \
{ return (wxHandlerInfo*) NULL; }                                       \
    wxCONSTRUCTOR_DUMMY( name )

#define wxIMPLEMENT_DYNAMIC_CLASS_XTI( name, basename, unit )                   \
    _IMPLEMENT_DYNAMIC_CLASS( name, basename, unit, NULL )                      \
    _TYPEINFO_CLASSES(name, NULL, NULL)

#define wxIMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK( name, basename, unit, callback )\
    _IMPLEMENT_DYNAMIC_CLASS( name, basename, unit, &callback )                 \
    _TYPEINFO_CLASSES(name, NULL, NULL)

#define wxIMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI( name, basename, unit )         \
    _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name, basename, unit, NULL  )           \
    _TYPEINFO_CLASSES(name, NULL, NULL)

#define wxIMPLEMENT_DYNAMIC_CLASS_WITH_COPY_AND_STREAMERS_XTI( name, basename,  \
    unit, toString,    \
    fromString )       \
    _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name, basename, unit, NULL  )           \
    _TYPEINFO_CLASSES(name, toString, fromString)

// this is for classes that do not derive from wxObject, there are no creators for these

#define wxIMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_NO_BASE_XTI( name, unit )         \
    const wxClassInfo* name::ms_classParents[] = { NULL };                      \
    wxClassInfo name::ms_classInfo(name::ms_classParents, wxEmptyString,        \
    wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) 0,          \
    name::GetPropertiesStatic,name::GetHandlersStatic, 0, 0,        \
    0, 0, 0 );                                                          \
    _TYPEINFO_CLASSES(name, NULL, NULL)

// this is for subclasses that still do not derive from wxObject

#define wxIMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_XTI( name, basename, unit )           \
    const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo, NULL }; \
    wxClassInfo name::ms_classInfo(name::ms_classParents, wxEmptyString,            \
    wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) 0,              \
    name::GetPropertiesStatic,name::GetHandlersStatic, 0, 0,            \
    0, 0, 0 );                                                              \
    _TYPEINFO_CLASSES(name, NULL, NULL)


// Multiple inheritance with two base classes

#define _IMPLEMENT_DYNAMIC_CLASS2(name, basename, basename2, unit, callback)         \
    _DEFAULT_CONSTRUCTOR(name)                                                  \
    _DEFAULT_CONVERTERS(name)                                                   \
    \
    const wxClassInfo* name::ms_classParents[] =                                     \
{ &basename::ms_classInfo,&basename2::ms_classInfo, NULL };                  \
    wxClassInfo name::ms_classInfo(name::ms_classParents, wxT(unit),                 \
    wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name, \
    name::GetPropertiesStatic,name::GetHandlersStatic,name::ms_constructor,     \
    name::ms_constructorProperties, name::ms_constructorPropertiesCount,            \
    wxVariantOfPtrToObjectConverter##name, NULL, wxObjectToVariantConverter##name,  \
    callback);

#define wxIMPLEMENT_DYNAMIC_CLASS2( name, basename, basename2)                      \
    _IMPLEMENT_DYNAMIC_CLASS2( name, basename, basename2, "", NULL)                 \
    _TYPEINFO_CLASSES(name, NULL, NULL)                                             \
    wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL; }  \
    wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL; }      \
    wxCONSTRUCTOR_DUMMY( name )

#define wxIMPLEMENT_DYNAMIC_CLASS2_XTI( name, basename, basename2, unit) \
    _IMPLEMENT_DYNAMIC_CLASS2( name, basename, basename2, unit, NULL)    \
    _TYPEINFO_CLASSES(name, NULL, NULL)


// ----------------------------------------------------------------------------
// wxIMPLEMENT class macros for abstract classes
// ----------------------------------------------------------------------------

// Single inheritance with one base class

#define _IMPLEMENT_ABSTRACT_CLASS(name, basename)                               \
    _DEFAULT_CONVERTERS(name)                                                   \
    \
    const wxClassInfo* name::ms_classParents[] =                                \
{ &basename::ms_classInfo,NULL };                                       \
    wxClassInfo name::ms_classInfo(name::ms_classParents, wxEmptyString,        \
    wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) 0,              \
    name::GetPropertiesStatic,name::GetHandlersStatic, 0, 0,            \
    0, wxVariantOfPtrToObjectConverter##name,0, \
    wxObjectToVariantConverter##name);                                         \
    _TYPEINFO_CLASSES(name, NULL, NULL)

#define wxIMPLEMENT_ABSTRACT_CLASS( name, basename )                            \
    _IMPLEMENT_ABSTRACT_CLASS( name, basename )                                 \
    wxHandlerInfo *name::GetHandlersStatic() { return (wxHandlerInfo*) NULL; }  \
    wxPropertyInfo *name::GetPropertiesStatic() { return (wxPropertyInfo*) NULL; }

// Multiple inheritance with two base classes

#define wxIMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2)                 \
    wxClassInfo name::ms_classInfo(wxT(#name), wxT(#basename1),                 \
    wxT(#basename2), (int) sizeof(name),         \
    (wxObjectConstructorFn) 0);

// templated streaming, every type that can be converted to wxString
// must have their specialization for these methods

template<typename T>
void wxStringReadValue( const wxString &s, T &data );

template<typename T>
void wxStringWriteValue( wxString &s, const T &data);

template<typename T>
void wxToStringConverter( const wxAny &v, wxString &s ) 
{ wxStringWriteValue(s, wxANY_AS(v, T)); }

template<typename T>
void wxFromStringConverter( const wxString &s, wxAny &v) 
{ T d; wxStringReadValue(s, d); v = wxAny(d); }

// --------------------------------------------------------------------------
// Collection Support
// --------------------------------------------------------------------------

template<typename iter, typename collection_t > void wxListCollectionToAnyList( 
                                                                               const collection_t& coll, wxAnyList &value )
{
    for ( iter current = coll.GetFirst(); current; 
         current = current->GetNext() )
    {
        value.Append( new wxAny(current->GetData()) );
    }
}

template<typename collection_t> void wxArrayCollectionToVariantArray( 
                                                                     const collection_t& coll, wxAnyList &value )
{
    for( size_t i = 0; i < coll.GetCount(); i++ )
    {
        value.Append( new wxAny(coll[i]) );
    }
}

#endif

#endif // _WX_XTIH2__
Commit	Line	Data
aa3fcb2f SC	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/wxt2.h
	3	// Purpose: runtime metadata information (extended class info)
	4	// Author: Stefan Csomor
	5	// Modified by: Francesco Montorsi
	6	// Created: 27/07/03
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1997 Julian Smart
	9	// (c) 2003 Stefan Csomor
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifndef _WX_XTI2H__
	13	#define _WX_XTI2H__
	14
	15	// ----------------------------------------------------------------------------
	16	// second part of xti headers, is included from object.h
	17	// ----------------------------------------------------------------------------
	18
	19	#if wxUSE_EXTENDED_RTTI
	20
f06d6937 SC	21	// ----------------------------------------------------------------------------
	22	// wxDynamicObject class, its instances connect to a 'super class instance'
	23	// ----------------------------------------------------------------------------
	24
aa3fcb2f SC	25	class WXDLLIMPEXP_BASE wxDynamicObject : public wxObject
	26	{
	27	friend class WXDLLIMPEXP_FWD_BASE wxDynamicClassInfo ;
	28	public:
	29	// instantiates this object with an instance of its superclass
	30	wxDynamicObject(wxObject* superClassInstance, const wxDynamicClassInfo *info) ;
	31	virtual ~wxDynamicObject();
	32
	33	void SetProperty (const wxChar *propertyName, const wxAny &value);
	34	wxAny GetProperty (const wxChar *propertyName) const ;
	35
	36	// get the runtime identity of this object
	37	wxClassInfo *GetClassInfo() const
	38	{
	39	#ifdef _MSC_VER
	40	return (wxClassInfo*) m_classInfo;
	41	#else
	42	wxDynamicClassInfo nonconst = const_cast<wxDynamicClassInfo >(m_classInfo);
	43	return static_cast<wxClassInfo *>(nonconst);
	44	#endif
	45	}
	46
	47	wxObject* GetSuperClassInstance() const
	48	{
	49	return m_superClassInstance ;
	50	}
	51	private :
	52	// removes an existing runtime-property
	53	void RemoveProperty( const wxChar *propertyName ) ;
	54
	55	// renames an existing runtime-property
	56	void RenameProperty( const wxChar oldPropertyName , const wxChar newPropertyName ) ;
	57
	58	wxObject *m_superClassInstance ;
	59	const wxDynamicClassInfo *m_classInfo;
	60	struct wxDynamicObjectInternal;
	61	wxDynamicObjectInternal *m_data;
	62	};
	63
f06d6937 SC	64	// ----------------------------------------------------------------------------
	65	// String conversion templates supporting older compilers
	66	// ----------------------------------------------------------------------------
	67
	68	#if wxUSE_FUNC_TEMPLATE_POINTER
	69	# define wxTO_STRING(type) wxToStringConverter<type>
	70	# define wxTO_STRING_IMP(type)
	71	# define wxFROM_STRING(type) wxFromStringConverter<type>
	72	# define wxFROM_STRING_IMP(type)
	73	#else
	74	# define wxTO_STRING(type) ToString##type
	75	# define wxTO_STRING_IMP(type) \
	76	inline void ToString##type( const wxAny& data, wxString &result ) \
	77	{ wxToStringConverter<type>(data, result); }
	78
	79	# define wxFROM_STRING(type) FromString##type
	80	# define wxFROM_STRING_IMP(type) \
	81	inline void FromString##type( const wxString& data, wxAny &result ) \
	82	{ wxFromStringConverter<type>(data, result); }
	83	#endif
	84
aa3fcb2f	85	#include "wx/xtiprop.h"
bca6bd38	86	#include "wx/xtictor.h"
aa3fcb2f SC	87
	88	// ----------------------------------------------------------------------------
	89	// wxIMPLEMENT class macros for concrete classes
	90	// ----------------------------------------------------------------------------
	91
	92	// Single inheritance with one base class
	93
	94	#define _DEFAULT_CONSTRUCTOR(name) \
	95	wxObject* wxConstructorFor##name() \
	96	{ return new name; }
	97
	98	#define _DEFAULT_CONVERTERS(name) \
	99	wxObject* wxVariantOfPtrToObjectConverter##name ( const wxAny &data ) \
	100	{ return data.As( (name**)NULL ); } \
	101	wxAny wxObjectToVariantConverter##name ( wxObject *data ) \
	102	{ return wxAny( wx_dynamic_cast(name*, data) ); }
	103
	104	#define _TYPEINFO_CLASSES(n, toString, fromString ) \
	105	wxClassTypeInfo s_typeInfo##n(wxT_OBJECT, &n::ms_classInfo, \
	106	toString, fromString, typeid(n).name()); \
	107	wxClassTypeInfo s_typeInfoPtr##n(wxT_OBJECT_PTR, &n::ms_classInfo, \
	108	toString, fromString, typeid(n*).name());
	109
	110	#define _IMPLEMENT_DYNAMIC_CLASS(name, basename, unit, callback) \
	111	_DEFAULT_CONSTRUCTOR(name) \
	112	_DEFAULT_CONVERTERS(name) \
	113	\
	114	const wxClassInfo* name::ms_classParents[] = \
	115	{ &basename::ms_classInfo, NULL }; \
	116	wxClassInfo name::ms_classInfo(name::ms_classParents, wxT(unit), \
	117	wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name, \
	118	name::GetPropertiesStatic, name::GetHandlersStatic, name::ms_constructor, \
	119	name::ms_constructorProperties, name::ms_constructorPropertiesCount, \
	120	wxVariantOfPtrToObjectConverter##name, NULL, wxObjectToVariantConverter##name, \
	121	callback);
	122
	123	#define _IMPLEMENT_DYNAMIC_CLASS_WITH_COPY(name, basename, unit, callback ) \
	124	_DEFAULT_CONSTRUCTOR(name) \
	125	_DEFAULT_CONVERTERS(name) \
	126	void wxVariantToObjectConverter##name ( const wxAny &data, wxObjectFunctor* fn ) \
	127	{ (*fn)( &wxANY_AS(data, name) ); } \
	128	\
	129	const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo,NULL }; \
	130	wxClassInfo name::ms_classInfo(name::ms_classParents, wxT(unit), \
	131	wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name, \
	132	name::GetPropertiesStatic,name::GetHandlersStatic,name::ms_constructor, \
	133	name::ms_constructorProperties, name::ms_constructorPropertiesCount, \
	134	wxVariantOfPtrToObjectConverter##name, wxVariantToObjectConverter##name, \
	135	wxObjectToVariantConverter##name, callback);
	136
	137	#define wxIMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name, basename ) \
	138	_IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name, basename, "", NULL ) \
	139	_TYPEINFO_CLASSES(name, NULL, NULL) \
	140	const wxPropertyInfo *name::GetPropertiesStatic() \
	141	{ return (wxPropertyInfo*) NULL; } \
	142	const wxHandlerInfo *name::GetHandlersStatic() \
	143	{ return (wxHandlerInfo*) NULL; } \
	144	wxCONSTRUCTOR_DUMMY( name )
	145
	146	#define wxIMPLEMENT_DYNAMIC_CLASS( name, basename ) \
	147	_IMPLEMENT_DYNAMIC_CLASS( name, basename, "", NULL ) \
	148	_TYPEINFO_CLASSES(name, NULL, NULL) \
	149	wxPropertyInfo *name::GetPropertiesStatic() \
	150	{ return (wxPropertyInfo*) NULL; } \
151	wxHandlerInfo *name::GetHandlersStatic() \
152	{ return (wxHandlerInfo*) NULL; } \
153	wxCONSTRUCTOR_DUMMY( name )
154
155	#define wxIMPLEMENT_DYNAMIC_CLASS_XTI( name, basename, unit ) \
156	_IMPLEMENT_DYNAMIC_CLASS( name, basename, unit, NULL ) \
157	_TYPEINFO_CLASSES(name, NULL, NULL)
158
159	#define wxIMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK( name, basename, unit, callback )\
160	_IMPLEMENT_DYNAMIC_CLASS( name, basename, unit, &callback ) \
161	_TYPEINFO_CLASSES(name, NULL, NULL)
162
163	#define wxIMPLEMENT_DYNAMIC_CLASS_WITH_COPY_XTI( name, basename, unit ) \
164	_IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name, basename, unit, NULL ) \
165	_TYPEINFO_CLASSES(name, NULL, NULL)
166
167	#define wxIMPLEMENT_DYNAMIC_CLASS_WITH_COPY_AND_STREAMERS_XTI( name, basename, \
168	unit, toString, \
169	fromString ) \
170	_IMPLEMENT_DYNAMIC_CLASS_WITH_COPY( name, basename, unit, NULL ) \
171	_TYPEINFO_CLASSES(name, toString, fromString)
172
173	// this is for classes that do not derive from wxObject, there are no creators for these
174
175	#define wxIMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_NO_BASE_XTI( name, unit ) \
176	const wxClassInfo* name::ms_classParents[] = { NULL }; \
177	wxClassInfo name::ms_classInfo(name::ms_classParents, wxEmptyString, \
178	wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) 0, \
179	name::GetPropertiesStatic,name::GetHandlersStatic, 0, 0, \
180	0, 0, 0 ); \
181	_TYPEINFO_CLASSES(name, NULL, NULL)
182
183	// this is for subclasses that still do not derive from wxObject
184
185	#define wxIMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_XTI( name, basename, unit ) \
186	const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo, NULL }; \
187	wxClassInfo name::ms_classInfo(name::ms_classParents, wxEmptyString, \
188	wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) 0, \
189	name::GetPropertiesStatic,name::GetHandlersStatic, 0, 0, \
190	0, 0, 0 ); \
191	_TYPEINFO_CLASSES(name, NULL, NULL)
192
193
194	// Multiple inheritance with two base classes
195
196	#define _IMPLEMENT_DYNAMIC_CLASS2(name, basename, basename2, unit, callback) \
197	_DEFAULT_CONSTRUCTOR(name) \
198	_DEFAULT_CONVERTERS(name) \
199	\
200	const wxClassInfo* name::ms_classParents[] = \
201	{ &basename::ms_classInfo,&basename2::ms_classInfo, NULL }; \
202	wxClassInfo name::ms_classInfo(name::ms_classParents, wxT(unit), \
203	wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) wxConstructorFor##name, \
204	name::GetPropertiesStatic,name::GetHandlersStatic,name::ms_constructor, \
205	name::ms_constructorProperties, name::ms_constructorPropertiesCount, \
206	wxVariantOfPtrToObjectConverter##name, NULL, wxObjectToVariantConverter##name, \
207	callback);
208
209	#define wxIMPLEMENT_DYNAMIC_CLASS2( name, basename, basename2) \
210	_IMPLEMENT_DYNAMIC_CLASS2( name, basename, basename2, "", NULL) \
211	_TYPEINFO_CLASSES(name, NULL, NULL) \
212	wxPropertyInfo name::GetPropertiesStatic() { return (wxPropertyInfo) NULL; } \
213	wxHandlerInfo name::GetHandlersStatic() { return (wxHandlerInfo) NULL; } \
214	wxCONSTRUCTOR_DUMMY( name )
215
216	#define wxIMPLEMENT_DYNAMIC_CLASS2_XTI( name, basename, basename2, unit) \
217	_IMPLEMENT_DYNAMIC_CLASS2( name, basename, basename2, unit, NULL) \
218	_TYPEINFO_CLASSES(name, NULL, NULL)
219
220
221
222	// ----------------------------------------------------------------------------
223	// wxIMPLEMENT class macros for abstract classes
224	// ----------------------------------------------------------------------------
225
226	// Single inheritance with one base class
227
228	#define _IMPLEMENT_ABSTRACT_CLASS(name, basename) \
229	_DEFAULT_CONVERTERS(name) \
230	\
231	const wxClassInfo* name::ms_classParents[] = \
232	{ &basename::ms_classInfo,NULL }; \
233	wxClassInfo name::ms_classInfo(name::ms_classParents, wxEmptyString, \
234	wxT(#name), (int) sizeof(name), (wxObjectConstructorFn) 0, \
235	name::GetPropertiesStatic,name::GetHandlersStatic, 0, 0, \
236	0, wxVariantOfPtrToObjectConverter##name,0, \
237	wxObjectToVariantConverter##name); \
238	_TYPEINFO_CLASSES(name, NULL, NULL)
239
240	#define wxIMPLEMENT_ABSTRACT_CLASS( name, basename ) \
241	_IMPLEMENT_ABSTRACT_CLASS( name, basename ) \
242	wxHandlerInfo name::GetHandlersStatic() { return (wxHandlerInfo) NULL; } \
243	wxPropertyInfo name::GetPropertiesStatic() { return (wxPropertyInfo) NULL; }
244
245	// Multiple inheritance with two base classes
246
247	#define wxIMPLEMENT_ABSTRACT_CLASS2(name, basename1, basename2) \
248	wxClassInfo name::ms_classInfo(wxT(#name), wxT(#basename1), \
249	wxT(#basename2), (int) sizeof(name), \
250	(wxObjectConstructorFn) 0);
251
c294641f SC	252	// templated streaming, every type that can be converted to wxString
c294641f SC	253	// must have their specialization for these methods
aa3fcb2f SC	254
	255	template<typename T>
	256	void wxStringReadValue( const wxString &s, T &data );
	257
	258	template<typename T>
	259	void wxStringWriteValue( wxString &s, const T &data);
	260
	261	template<typename T>
	262	void wxToStringConverter( const wxAny &v, wxString &s )
	263	{ wxStringWriteValue(s, wxANY_AS(v, T)); }
	264
	265	template<typename T>
	266	void wxFromStringConverter( const wxString &s, wxAny &v)
	267	{ T d; wxStringReadValue(s, d); v = wxAny(d); }
	268
bca6bd38 SC	269	// --------------------------------------------------------------------------
	270	// Collection Support
	271	// --------------------------------------------------------------------------
	272
	273	template<typename iter, typename collection_t > void wxListCollectionToAnyList(
	274	const collection_t& coll, wxAnyList &value )
	275	{
	276	for ( iter current = coll.GetFirst(); current;
	277	current = current->GetNext() )
	278	{
	279	value.Append( new wxAny(current->GetData()) );
	280	}
	281	}
	282
	283	template<typename collection_t> void wxArrayCollectionToVariantArray(
	284	const collection_t& coll, wxAnyList &value )
	285	{
	286	for( size_t i = 0; i < coll.GetCount(); i++ )
	287	{
	288	value.Append( new wxAny(coll[i]) );
	289	}
	290	}
	291
aa3fcb2f SC	292	#endif
	293
	294	#endif // _WX_XTIH2__