#ifndef _WX_XTIH__
#define _WX_XTIH__
-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-#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
// effort as painless as possible.
#define EMPTY_MACROVALUE /**/
-class WXDLLIMPEXP_BASE wxObject;
-class WXDLLIMPEXP_BASE wxClassInfo;
-class WXDLLIMPEXP_BASE wxDynamicClassInfo;
-class WXDLLIMPEXP_BASE wxHashTable;
-class WXDLLIMPEXP_BASE wxObjectRefData;
-class WXDLLIMPEXP_BASE wxEvent;
+class WXDLLIMPEXP_FWD_BASE wxObject;
+class WXDLLIMPEXP_FWD_BASE wxClassInfo;
+class WXDLLIMPEXP_FWD_BASE wxDynamicClassInfo;
+class WXDLLIMPEXP_FWD_BASE wxHashTable;
+class WXDLLIMPEXP_FWD_BASE wxHashTable_Node;
+class WXDLLIMPEXP_FWD_BASE wxObjectRefData;
+class WXDLLIMPEXP_FWD_BASE wxEvent;
+class WXDLLIMPEXP_FWD_BASE wxEvtHandler;
typedef void (wxObject::*wxObjectEventFunction)(wxEvent&);
#if wxUSE_FUNC_TEMPLATE_POINTER
-# define wxTO_STRING(type) wxToStringConverter<type>
+# define wxTO_STRING(type) wxToStringConverter<type>
# define wxTO_STRING_IMP(type)
# define wxFROM_STRING(type) wxFromStringConverter<type>
# define wxFROM_STRING_IMP(type)
// ----------------------------------------------------------------------------
// in order to remove dependancy on string tokenizer
-void wxSetStringToArray( const wxString &s , wxArrayString &array ) ;
+void WXDLLIMPEXP_BASE wxSetStringToArray( const wxString &s , wxArrayString &array ) ;
template<typename e>
void wxSetFromString(const wxString &s , wxBitset<e> &data )
if ( data.test( value ) )
{
// this could also be done by the templated calls
- if ( !s.IsEmpty() )
+ if ( !s.empty() )
s +=wxT("|") ;
s += edata->GetEnumMemberNameByIndex(i) ;
}
// clear the flags we just set
dataValue &= ~value ;
// this could also be done by the templated calls
- if ( !s.IsEmpty() )
+ if ( !s.empty() )
s +=wxT("|") ;
s += edata->GetEnumMemberNameByIndex(i) ;
}
wxT_LAST_TYPE_KIND = wxT_DELEGATE // sentinel for bad data, asserts, debugging
};
-class WXDLLIMPEXP_BASE wxxVariant ;
-class WXDLLIMPEXP_BASE wxTypeInfo ;
+class WXDLLIMPEXP_FWD_BASE wxxVariant ;
+class WXDLLIMPEXP_FWD_BASE wxTypeInfo ;
WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxTypeInfo* , wxTypeInfoMap , class WXDLLIMPEXP_BASE ) ;
}
#if wxUSE_UNICODE
wxTypeInfo(wxTypeKind kind,
- converterToString_t to = NULL, converterFromString_t from = NULL,
- const char *name = ""):
+ converterToString_t to, converterFromString_t from,
+ const char *name):
m_toString(to), m_fromString(from), m_kind(kind), m_name(wxString::FromAscii(name))
{
Register();
// convert a wxxVariant holding data of this type into a string
void ConvertToString( const wxxVariant& data , wxString &result ) const
- { if ( m_toString ) (*m_toString)( data , result ) ; else wxLogError( _("String conversions not supported") ) ; }
+ { if ( m_toString ) (*m_toString)( data , result ) ; else wxLogError( wxGetTranslation(_T("String conversions not supported")) ) ; }
// convert a string into a wxxVariant holding the corresponding data in this type
void ConvertFromString( const wxString& data , wxxVariant &result ) const
- { if( m_fromString ) (*m_fromString)( data , result ) ; else wxLogError( _("String conversions not supported") ) ; }
+ { if( m_fromString ) (*m_fromString)( data , result ) ; else wxLogError( wxGetTranslation(_T("String conversions not supported")) ) ; }
#if wxUSE_UNICODE
static wxTypeInfo *FindType(const char *typeName) { return FindType( wxString::FromAscii(typeName) ) ; }
#endif
static wxTypeInfo *FindType(const wxChar *typeName);
+ static wxTypeInfo *FindType(const wxString typeName)
+ {
+#if wxUSE_UNICODE
+ return FindType( typeName.wchar_str() );
+#else
+ return FindType( typeName.char_str() );
+#endif
+ }
private :
// convert a wxxVariant holding data of this type into a long
void ConvertToLong( const wxxVariant& data , long &result ) const
- { if( m_toLong ) (*m_toLong)( data , result ) ; else wxLogError( _("Long Conversions not supported") ) ; }
+ { if( m_toLong ) (*m_toLong)( data , result ) ; else wxLogError( wxGetTranslation(_T("Long Conversions not supported")) ) ; }
// convert a long into a wxxVariant holding the corresponding data in this type
void ConvertFromLong( long data , wxxVariant &result ) const
- { if( m_fromLong ) (*m_fromLong)( data , result ) ; else wxLogError( _("Long Conversions not supported") ) ;}
+ { if( m_fromLong ) (*m_fromLong)( data , result ) ; else wxLogError( wxGetTranslation(_T("Long Conversions not supported")) ) ;}
private :
converterToLong_t m_toLong ;
wxTypeInfo( wxT_COLLECTION , to , from , name )
{ m_elementTypeName = wxString::FromAscii( elementName ) ; m_elementType = NULL ;}
#endif
- const wxTypeInfo* GetElementType() const
- {
+ const wxTypeInfo* GetElementType() const
+ {
if ( m_elementType == NULL )
m_elementType = wxTypeInfo::FindType( m_elementTypeName ) ;
return m_elementType ; }
{
public :
wxxVariant() { m_data = NULL ; }
- wxxVariant( wxxVariantData* data , const wxString& name = wxT("") ) : m_data(data) , m_name(name) {}
+ wxxVariant( wxxVariantData* data , const wxString& name = wxEmptyString ) : 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( const T& data , const wxString& name = wxT("") ) :
+ template<typename T> wxxVariant( const T& data , const wxString& name = wxEmptyString ) :
m_data(new wxxVariantDataT<T>(data) ), m_name(name) {}
~wxxVariant() { delete m_data ; }
wxxVariant& operator=(const wxxVariant &d)
{
- m_data = d.m_data->Clone() ;
+ delete m_data;
+ m_data = d.m_data ? d.m_data->Clone() : NULL ;
m_name = d.m_name ;
return *this ;
}
wxString m_name ;
} ;
-#include <wx/dynarray.h>
+#include "wx/dynarray.h"
WX_DECLARE_OBJARRAY_WITH_DECL(wxxVariant, wxxVariantArray, class WXDLLIMPEXP_BASE);
void wxToStringConverter( const wxxVariant &v, wxString &s wxTEMPLATED_FUNCTION_FIX(T)) { wxStringWriteValue( s , v.wxTEMPLATED_MEMBER_CALL(Get , T) ) ; }
template<typename T>
-void wxFromStringConverter( const wxString &s, wxxVariant &v wxTEMPLATED_FUNCTION_FIX(T)) { T d ; wxStringReadValue( s , d ) ; v = wxxVariant(d) ; }
+void wxFromStringConverter( const wxString &s, wxxVariant &v wxTEMPLATED_FUNCTION_FIX(T)) { T d ; wxStringReadValue( s , d ) ; v = wxxVariant(d) ; }
// ----------------------------------------------------------------------------
// Property Support
wxString m_name ;
} ;
-template<typename coll_t> void wxCollectionToVariantArray( const coll_t& coll , wxxVariantArray& result ) ;
+template<typename coll_t> void WXDLLIMPEXP_BASE wxCollectionToVariantArray( const coll_t& coll , wxxVariantArray& result ) ;
class WXDLLIMPEXP_BASE wxAdder
{
public: \
wxINFUNC_CLASS_TYPE_FIX(Klass) \
wxSetter##property() : wxSetter( wxT(#setterMethod) ) {} \
- ~wxSetter##property() {} \
+ virtual ~wxSetter##property() {} \
void Set( wxObject *object, const wxxVariant &variantValue ) const \
{ \
Klass *obj = dynamic_cast<Klass*>(object) ; \
public : \
wxINFUNC_CLASS_TYPE_FIX(Klass) \
wxGetter##property() : wxGetter( wxT(#gettermethod) ) {} \
- ~wxGetter##property() {} \
+ virtual ~wxGetter##property() {} \
void Get( const wxObject *object , wxxVariant &result) const \
{ \
const Klass *obj = dynamic_cast<const Klass*>(object) ; \
public: \
wxINFUNC_CLASS_TYPE_FIX(Klass) \
wxAdder##property() : wxAdder( wxT(#addermethod) ) {} \
- ~wxAdder##property() {} \
+ virtual ~wxAdder##property() {} \
void Add( wxObject *object, const wxxVariant &variantValue ) const \
{ \
Klass *obj = dynamic_cast<Klass*>(object) ; \
public : \
wxINFUNC_CLASS_TYPE_FIX(Klass) \
wxCollectionGetter##property() : wxCollectionGetter( wxT(#gettermethod) ) {} \
- ~wxCollectionGetter##property() {} \
+ virtual ~wxCollectionGetter##property() {} \
void Get( const wxObject *object , wxxVariantArray &result) const \
{ \
const Klass *obj = dynamic_cast<const Klass*>(object) ; \
// Setting a simple property (non-collection)
virtual void SetProperty(wxObject *object, const wxxVariant &value) const
- { if ( m_setter ) m_setter->Set( object , value ) ; else wxLogError( _("SetProperty called w/o valid setter") ) ;}
+ { if ( m_setter ) m_setter->Set( object , value ) ; else wxLogError( wxGetTranslation(_T("SetProperty called w/o valid setter")) ) ;}
// Getting a simple property (non-collection)
virtual void GetProperty(const wxObject *object, wxxVariant &result) const
- { if ( m_getter ) m_getter->Get( object , result ) ; else wxLogError( _("GetProperty called w/o valid getter") ) ;}
+ { if ( m_getter ) m_getter->Get( object , result ) ; else wxLogError( wxGetTranslation(_T("GetProperty called w/o valid getter")) ) ;}
// Adding an element to a collection property
virtual void AddToPropertyCollection(wxObject *object, const wxxVariant &value) const
- { if ( m_adder ) m_adder->Add( object , value ) ; else wxLogError( _("AddToPropertyCollection called w/o valid adder") ) ;}
+ { if ( m_adder ) m_adder->Add( object , value ) ; else wxLogError( wxGetTranslation(_T("AddToPropertyCollection called w/o valid adder")) ) ;}
// Getting a collection property
virtual void GetPropertyCollection( const wxObject *obj, wxxVariantArray &result) const
- { if ( m_collectionGetter ) m_collectionGetter->Get( obj , result) ; else wxLogError( _("GetPropertyCollection called w/o valid collection getter") ) ;}
+ { if ( m_collectionGetter ) m_collectionGetter->Get( obj , result) ; else wxLogError( wxGetTranslation(_T("GetPropertyCollection called w/o valid collection getter")) ) ;}
virtual bool HasSetter() const { return m_setter != NULL ; }
virtual bool HasCollectionGetter() const { return m_collectionGetter != NULL ; }
{
public :
wxGenericPropertyAccessor( const wxString &propName ) ;
- ~wxGenericPropertyAccessor() ;
+ virtual ~wxGenericPropertyAccessor() ;
- void RenameProperty( const wxString &oldName , const wxString &newName )
+ void RenameProperty( const wxString& WXUNUSED_UNLESS_DEBUG(oldName),
+ const wxString& newName )
{
wxASSERT( oldName == m_propertyName ) ; m_propertyName = newName ;
}
// Adding an element to a collection property
virtual void AddToPropertyCollection(wxObject *WXUNUSED(object), const wxxVariant &WXUNUSED(value)) const
- { wxLogError( _("AddToPropertyCollection called on a generic accessor") ) ;}
+ { wxLogError( wxGetTranslation(_T("AddToPropertyCollection called on a generic accessor")) ) ;}
// Getting a collection property
virtual void GetPropertyCollection( const wxObject *WXUNUSED(obj), wxxVariantArray &WXUNUSED(result)) const
- { wxLogError ( _("GetPropertyCollection called on a generic accessor") ) ;}
+ { wxLogError ( wxGetTranslation(_T("GetPropertyCollection called on a generic accessor")) ) ;}
private :
struct wxGenericPropertyAccessorInternal ;
wxGenericPropertyAccessorInternal* m_data ;
class WXDLLIMPEXP_BASE wxPropertyInfo
{
- friend class WXDLLIMPEXP_BASE wxDynamicClassInfo ;
+ friend class WXDLLIMPEXP_FWD_BASE wxDynamicClassInfo ;
public :
wxPropertyInfo(wxPropertyInfo* &iter,
wxClassInfo* itsClass,
~wxPropertyInfo() ;
// return the class this property is declared in
- const wxClassInfo* GetDeclaringClass() const { return m_itsClass ; }
+ const wxClassInfo* GetDeclaringClass() const { return m_itsClass ; }
// return the name of this property
- const wxString& GetName() const { return m_name ; }
+ const wxString& GetName() const { return m_name ; }
// returns the flags of this property
- wxPropertyInfoFlags GetFlags() const { return m_flags ;}
+ wxPropertyInfoFlags GetFlags() const { return m_flags ;}
// returns the short help string of this property
const wxString& GetHelpString() const { return m_helpString ; }
const wxString& GetGroupString() const { return m_groupString ; }
// return the element type info of this property (for collections, otherwise NULL)
- const wxTypeInfo * GetCollectionElementTypeInfo() const
+ const wxTypeInfo * GetCollectionElementTypeInfo() const
{
if ( m_collectionElementTypeInfo == NULL )
m_collectionElementTypeInfo = wxTypeInfo::FindType(m_collectionElementTypeName) ;
}
// return the type info of this property
- const wxTypeInfo * GetTypeInfo() const
+ const wxTypeInfo * GetTypeInfo() const
{
if ( m_typeInfo == NULL )
m_typeInfo = wxTypeInfo::FindType(m_typeName) ;
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 ; }
+ wxxVariant GetDefaultValue() const { return m_defaultValue ; }
private :
void Insert(wxPropertyInfo* &iter)
{
mutable wxTypeInfo* m_collectionElementTypeInfo ;
wxString m_collectionElementTypeName ;
wxPropertyAccessor* m_accessor ;
- wxxVariant m_defaultValue;
+ wxxVariant m_defaultValue;
wxPropertyInfoFlags m_flags ;
wxString m_helpString ;
wxString m_groupString ;
class WXDLLIMPEXP_BASE wxHandlerInfo
{
- friend class WXDLLIMPEXP_BASE wxDynamicClassInfo ;
+ friend class WXDLLIMPEXP_FWD_BASE wxDynamicClassInfo ;
public :
wxHandlerInfo(wxHandlerInfo* &iter,
wxClassInfo* itsClass,
~wxHandlerInfo() ;
// return the name of this handler
- const wxString& GetName() const { return m_name ; }
+ const wxString& GetName() const { return m_name ; }
// return the class info of the event
- const wxClassInfo * GetEventClassInfo() const { return m_eventClassInfo ; }
+ const wxClassInfo *GetEventClassInfo() const { return m_eventClassInfo ; }
// get the handler function pointer
- wxObjectEventFunction GetEventFunction() const { return m_eventFunction ; }
+ wxObjectEventFunction GetEventFunction() const { return m_eventFunction ; }
// returns NULL if this is the last handler of this class
wxHandlerInfo* GetNext() const { return m_next ; }
class WXDLLIMPEXP_BASE wxConstructorBridge
{
public :
+ virtual ~wxConstructorBridge() {};
virtual void Create(wxObject * &o, wxxVariant *args) = 0;
};
const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) } ; \
const int klass::ms_constructorPropertiesCount = 3 ;
+// direct constructor version
+
+template<typename Class,
+typename T0, typename T1, typename T2>
+struct wxDirectConstructorBridge_3 : public wxDirectConstructorBrigde
+{
+ void Create(wxObject * &o, wxxVariant *args)
+ {
+ o = new Class(
+ args[0].wxTEMPLATED_MEMBER_CALL(Get , T0) ,
+ args[1].wxTEMPLATED_MEMBER_CALL(Get , T1) ,
+ args[2].wxTEMPLATED_MEMBER_CALL(Get , T2)
+ );
+ }
+};
+
+#define wxDIRECT_CONSTRUCTOR_3(klass,t0,v0,t1,v1,t2,v2) \
+ wxDirectConstructorBridge_3<klass,t0,t1,t2> constructor##klass ; \
+ wxConstructorBridge* klass::ms_constructor = &constructor##klass ; \
+ const wxChar *klass::ms_constructorProperties[] = { wxT(#v0) , wxT(#v1) , wxT(#v2) } ; \
+ const int klass::ms_constructorPropertiesCount = 3;
+
// 4 params
template<typename Class,
typedef wxObject* (*wxVariantToObjectConverter)( wxxVariant &data ) ;
typedef wxxVariant (*wxObjectToVariantConverter)( wxObject* ) ;
-class WXDLLIMPEXP_BASE wxWriter;
-class WXDLLIMPEXP_BASE wxPersister;
+class WXDLLIMPEXP_FWD_BASE wxWriter;
+class WXDLLIMPEXP_FWD_BASE wxPersister;
typedef bool (*wxObjectStreamingCallback) ( const wxObject *, wxWriter * , wxPersister * , wxxVariantArray & ) ;
class WXDLLIMPEXP_BASE wxClassInfo
{
- friend class WXDLLIMPEXP_BASE wxPropertyInfo ;
- friend class WXDLLIMPEXP_BASE wxHandlerInfo ;
+ friend class WXDLLIMPEXP_FWD_BASE wxPropertyInfo ;
+ friend class WXDLLIMPEXP_FWD_BASE wxHandlerInfo ;
+ friend wxObject *wxCreateDynamicObject(const wxString& name);
public:
wxClassInfo(const wxClassInfo **_Parents,
const wxChar *_UnitName,
{
if ( ParamCount != m_constructorPropertiesCount )
{
- wxLogError( _("Illegal Parameter Count for ConstructObject Method") ) ;
+ wxLogError( wxGetTranslation(_T("Illegal Parameter Count for ConstructObject Method")) ) ;
return NULL ;
}
wxObject *object = NULL ;
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); }
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);
+ static wxClassInfo *FindClass(const wxString& className);
// Climb upwards through inheritance hierarchy.
// Dual inheritance is catered for.
return false ;
}
+ DECLARE_CLASS_INFO_ITERATORS()
+
// 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
// gets the streaming callback from this class or any superclass
wxObjectStreamingCallback GetStreamingCallback() const ;
-#if WXWIN_COMPATIBILITY_2_4
- // Initializes parent pointers and hash table for fast searching.
- wxDEPRECATED( static void InitializeClasses() );
- // Cleans up hash table used for fast searching.
- wxDEPRECATED( static void CleanUpClasses() );
-#endif
static void CleanUp();
// returns the first property
{
if ( ParamCount != m_constructorPropertiesCount )
{
- wxLogError( _("Illegal Parameter Count for Create Method") ) ;
+ wxLogError( wxGetTranslation(_T("Illegal Parameter Count for Create Method")) ) ;
return ;
}
m_constructor->Create( object , Params ) ;
// we must be able to cast variants to wxObject pointers, templates seem not to be suitable
wxObject* VariantToInstance( wxxVariant &data ) const
- { if ( data.GetTypeInfo()->GetKind() == wxT_OBJECT )
- return m_variantToObjectConverter( data ) ;
- else
- return m_variantOfPtrToObjectConverter( data ) ;
+ {
+ if ( data.GetTypeInfo()->GetKind() == wxT_OBJECT )
+ return m_variantToObjectConverter( data ) ;
+ else
+ return m_variantOfPtrToObjectConverter( data ) ;
}
wxxVariant InstanceToVariant( wxObject *object ) const { return m_objectToVariantConverter( object ) ; }
// 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 ;
-public:
+private:
const wxChar *m_className;
int m_objectSize;
wxObjectConstructorFn m_objectConstructor;
static wxClassInfo *sm_first;
wxClassInfo *m_next;
- // FIXME: this should be private (currently used directly by way too
- // many clients)
static wxHashTable *sm_classTable;
protected :
- wxPropertyInfo * m_firstProperty ;
- wxHandlerInfo * m_firstHandler ;
+ wxPropertyInfo * m_firstProperty ;
+ wxHandlerInfo * m_firstHandler ;
private:
- const wxClassInfo** m_parents ;
- const wxChar* m_unitName;
+ const wxClassInfo** m_parents ;
+ const wxChar* m_unitName;
- wxConstructorBridge* m_constructor ;
- const wxChar ** m_constructorProperties ;
- const int m_constructorPropertiesCount ;
+ wxConstructorBridge* m_constructor ;
+ const wxChar ** m_constructorProperties ;
+ const int m_constructorPropertiesCount ;
wxVariantToObjectConverter m_variantOfPtrToObjectConverter ;
wxVariantToObjectConverter m_variantToObjectConverter ;
wxObjectToVariantConverter m_objectToVariantConverter ;
wxObjectStreamingCallback m_streamingCallback ;
const wxPropertyAccessor *FindAccessor (const wxChar *propertyName) const ;
-
- // InitializeClasses() helper
- static wxClassInfo *GetBaseByName(const wxChar *name) ;
-
protected:
// registers the class
void Register();
};
-WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxChar *name);
+WXDLLIMPEXP_BASE wxObject *wxCreateDynamicObject(const wxString& name);
// ----------------------------------------------------------------------------
// wxDynamicObject
class WXDLLIMPEXP_BASE wxDynamicClassInfo : public wxClassInfo
{
- friend class WXDLLIMPEXP_BASE wxDynamicObject ;
+ friend class WXDLLIMPEXP_FWD_BASE wxDynamicObject ;
public :
wxDynamicClassInfo( const wxChar *_UnitName, const wxChar *_ClassName , const wxClassInfo* superClass ) ;
virtual ~wxDynamicClassInfo() ;
#define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_NO_BASE_XTI( name , unit ) \
const wxClassInfo* name::ms_classParents[] = { NULL } ; \
- wxClassInfo name::ms_classInfo(name::ms_classParents , wxT("") , wxT(#name), \
+ wxClassInfo name::ms_classInfo(name::ms_classParents , wxEmptyString , wxT(#name), \
(int) sizeof(name), \
(wxObjectConstructorFn) 0 , \
name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
#define IMPLEMENT_DYNAMIC_CLASS_NO_WXOBJECT_XTI( name , basename, unit ) \
const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,NULL } ; \
- wxClassInfo name::ms_classInfo(name::ms_classParents , wxT("") , wxT(#name), \
+ wxClassInfo name::ms_classInfo(name::ms_classParents , wxEmptyString , wxT(#name), \
(int) sizeof(name), \
(wxObjectConstructorFn) 0 , \
name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
// Multiple inheritance with two base classes
-#define _IMPLEMENT_DYNAMIC_CLASS2(name, basename, basename2, unit) \
+#define _IMPLEMENT_DYNAMIC_CLASS2(name, basename, basename2, unit, callback) \
wxObject* wxConstructorFor##name() \
{ return new name; } \
const wxClassInfo* name::ms_classParents[] = { &basename::ms_classInfo ,&basename2::ms_classInfo , NULL } ; \
- wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
+ wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
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 , wxVariantToObjectConverter##name , wxObjectToVariantConverter##name); \
+ name::ms_constructorPropertiesCount , wxVariantOfPtrToObjectConverter##name , NULL , wxObjectToVariantConverter##name , callback);
#define IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2) \
- _IMPLEMENT_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 IMPLEMENT_DYNAMIC_CLASS2_XTI( name , basename , basename2, unit) \
- _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , unit) \
+ _IMPLEMENT_DYNAMIC_CLASS2( name , basename , basename2 , unit, NULL) \
_TYPEINFO_CLASSES(name, NULL , NULL)
wxObject* wxVariantToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
wxObject* wxVariantOfPtrToObjectConverter##name ( wxxVariant &data ) { return data.wxTEMPLATED_MEMBER_CALL(Get , name*) ; } \
wxxVariant wxObjectToVariantConverter##name ( wxObject *data ) { return wxxVariant( dynamic_cast<name*> (data) ) ; } \
- wxClassInfo name::ms_classInfo(name::ms_classParents , wxT("") , wxT(#name), \
+ wxClassInfo name::ms_classInfo(name::ms_classParents , wxEmptyString , wxT(#name), \
(int) sizeof(name), \
(wxObjectConstructorFn) 0 , \
name::GetPropertiesStatic(),name::GetHandlersStatic(),0 , 0 , \
}
-#endif
+#endif // _WX_XTIH__
projects / wxWidgets.git / blobdiff