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

/////////////////////////////////////////////////////////////////////////////
// Name:        wx/xtiprop.h
// Purpose:     XTI properties
// Author:      Stefan Csomor
// Modified by: Francesco Montorsi
// Created:     27/07/03
// RCS-ID:      $Id$
// Copyright:   (c) 1997 Julian Smart
//              (c) 2003 Stefan Csomor
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifndef _XTIPROP_H_
#define _XTIPROP_H_

#include "wx/defs.h"

#if wxUSE_EXTENDED_RTTI

#include "wx/xti.h"
#include "wx/any.h"

class WXDLLIMPEXP_BASE wxObject;
class WXDLLIMPEXP_BASE wxClassInfo;
class WXDLLIMPEXP_BASE wxDynamicClassInfo;
class WXDLLIMPEXP_BASE wxHashTable;
class WXDLLIMPEXP_BASE wxHashTable_Node;
class WXDLLIMPEXP_BASE wxEvent;
class WXDLLIMPEXP_BASE wxEvtHandler;

// ----------------------------------------------------------------------------
// Property Accessors
//
// wxPropertySetter/Getter/CollectionGetter/CollectionAdder are all property
// accessors which are managed by wxPropertyAccessor class which in turn is
// handled by wxPropertyInfo.
// ----------------------------------------------------------------------------

class WXDLLIMPEXP_BASE wxPropertySetter
{
public:
    wxPropertySetter( const wxString name ) { m_name = name; }
    virtual ~wxPropertySetter() {}

    virtual void Set( wxObject *object, const wxAny &variantValue ) const = 0;
    const wxString& GetName() const { return m_name; }

private:
    wxString m_name;
};

class WXDLLIMPEXP_BASE wxPropertyGetter
{
public:
    wxPropertyGetter( const wxString name ) { m_name = name; }
    virtual ~wxPropertyGetter() {}

    virtual void Get( const wxObject *object, wxAny& result) const = 0;
    const wxString& GetName() const { return m_name; }

private:
    wxString m_name;
};

class WXDLLIMPEXP_BASE wxPropertyCollectionGetter
{
public:
    wxPropertyCollectionGetter( const wxString name ) { m_name = name; }
    virtual ~wxPropertyCollectionGetter() {}

    virtual void Get( const wxObject *object, wxAnyList& result) const = 0;
    const wxString& GetName() const { return m_name; }

private:
    wxString m_name;
};

template<typename coll_t> void WXDLLIMPEXP_BASE \
    wxCollectionToVariantArray( const coll_t& coll, wxAnyList& result );

class WXDLLIMPEXP_BASE wxPropertyCollectionAdder
{
public:
    wxPropertyCollectionAdder( const wxString name ) { m_name = name; }
    virtual ~wxPropertyCollectionAdder() {}

    virtual void Add( wxObject *object, const wxAny &variantValue ) const= 0;
    const wxString& GetName() const { return m_name; }

private:
    wxString m_name;
};

#define wxPROPERTY_SETTER( property, Klass, valueType, setterMethod )   \
class wxPropertySetter##property : public wxPropertySetter              \
{                                                                       \
public:                                                                 \
    wxINFUNC_CLASS_TYPE_FIX(Klass)                                      \
    wxPropertySetter##property() : wxPropertySetter( wxT(#setterMethod) ) {}            \
    virtual ~wxPropertySetter##property() {}                            \
                                                                        \
    void Set( wxObject *object, const wxAny &variantValue ) const       \
    {                                                                   \
        Klass *obj = dynamic_cast<Klass*>(object);                        \
        valueType tempobj;                                                \
        if ( variantValue.GetAs(&tempobj) )                                \
            obj->setterMethod(tempobj);                                    \
        else                                                            \
            obj->setterMethod(*wxANY_AS(variantValue, valueType*));      \
    }                                                                   \
};

#define wxPROPERTY_GETTER( property, Klass, valueType, gettermethod )           \
class wxPropertyGetter##property : public wxPropertyGetter                              \
{                                                                       \
public:                                                                 \
    wxINFUNC_CLASS_TYPE_FIX(Klass)                                      \
    wxPropertyGetter##property() : wxPropertyGetter( wxT(#gettermethod) ) {}            \
    virtual ~wxPropertyGetter##property() {}                                    \
                                                                        \
    void Get( const wxObject *object, wxAny &result) const        \
    {                                                                   \
        const Klass *obj = dynamic_cast<const Klass*>(object);          \
        result = wxAny( obj->gettermethod() );                     \
    }                                                                   \
};

#define wxPROPERTY_COLLECTION_ADDER( property, Klass, valueType, addermethod )             \
class wxPropertyCollectionAdder##property : public wxPropertyCollectionAdder                                \
{                                                                       \
public:                                                                 \
    wxINFUNC_CLASS_TYPE_FIX(Klass)                                      \
    wxPropertyCollectionAdder##property() : wxPropertyCollectionAdder( wxT(#addermethod) ) {}               \
    virtual ~wxPropertyCollectionAdder##property() {}                                     \
                                                                        \
    void Add( wxObject *object, const wxAny &variantValue ) const  \
    {                                                                   \
        Klass *obj = dynamic_cast<Klass*>(object);                      \
        valueType tempobj;                                                \
        if ( variantValue.GetAs(&tempobj) )                                \
            obj->addermethod(tempobj);    \
        else                                                                            \
            obj->addermethod(*wxANY_AS(variantValue, valueType*));  \
    }                                                                                   \
};

#define wxPROPERTY_COLLECTION_GETTER( property, Klass, valueType, gettermethod )    \
class wxPropertyCollectionGetter##property : public wxPropertyCollectionGetter              \
{                                                                           \
public:                                                                     \
    wxINFUNC_CLASS_TYPE_FIX(Klass)                                          \
    wxPropertyCollectionGetter##property() : wxPropertyCollectionGetter( wxT(#gettermethod) ) {} \
    virtual ~wxPropertyCollectionGetter##property() {}                              \
                                                                            \
    void Get( const wxObject *object, wxAnyList &result) const       \
    {                                                                       \
        const Klass *obj = dynamic_cast<const Klass*>(object);              \
        wxCollectionToVariantArray( obj->gettermethod(), result );         \
    }                                                                       \
};

class WXDLLIMPEXP_BASE wxPropertyAccessor
{
public:
    wxPropertyAccessor( wxPropertySetter *setter, wxPropertyGetter *getter, 
                        wxPropertyCollectionAdder *adder, wxPropertyCollectionGetter *collectionGetter )
    { m_setter = setter; m_getter = getter; m_adder = adder; 
      m_collectionGetter = collectionGetter; }

    virtual ~wxPropertyAccessor() {}

    // Setting a simple property (non-collection)
    virtual void SetProperty(wxObject *object, const wxAny &value) const
    { 
        if ( m_setter ) 
            m_setter->Set( object, value ); 
        else 
            wxLogError( _("SetProperty called w/o valid setter") ); 
    }

    // Getting a simple property (non-collection)
    virtual void GetProperty(const wxObject *object, wxAny &result) const
    { 
        if ( m_getter ) 
            m_getter->Get( object, result ); 
        else 
            wxLogError( _("GetProperty called w/o valid getter") ); 
    }

    // Adding an element to a collection property
    virtual void AddToPropertyCollection(wxObject *object, const wxAny &value) const
    { 
        if ( m_adder ) 
            m_adder->Add( object, value ); 
        else 
            wxLogError( _("AddToPropertyCollection called w/o valid adder") ); 
    }

    // Getting a collection property
    virtual void GetPropertyCollection( const wxObject *obj, wxAnyList &result) const
    { 
        if ( m_collectionGetter ) 
            m_collectionGetter->Get( obj, result); 
        else 
            wxLogError( _("GetPropertyCollection called w/o valid collection getter") ); 
    }

    virtual bool HasSetter() const { return m_setter != NULL; }
    virtual bool HasCollectionGetter() const { return m_collectionGetter != NULL; }
    virtual bool HasGetter() const { return m_getter != NULL; }
    virtual bool HasAdder() const { return m_adder != NULL; }

    virtual const wxString& GetCollectionGetterName() const
        { return m_collectionGetter->GetName(); }
    virtual const wxString&  GetGetterName() const
        { return m_getter->GetName(); }
    virtual const wxString& GetSetterName() const
        { return m_setter->GetName(); }
    virtual const wxString& GetAdderName() const
        { return m_adder->GetName(); }

protected:
    wxPropertySetter *m_setter;
    wxPropertyCollectionAdder *m_adder;
    wxPropertyGetter *m_getter;
    wxPropertyCollectionGetter* m_collectionGetter;
};

class WXDLLIMPEXP_BASE wxGenericPropertyAccessor : public wxPropertyAccessor
{
public:
    wxGenericPropertyAccessor( const wxString &propName );
    virtual ~wxGenericPropertyAccessor();

    void RenameProperty( const wxString& WXUNUSED_UNLESS_DEBUG(oldName),
        const wxString& newName )
    {
        wxASSERT( oldName == m_propertyName ); m_propertyName = newName;
    }

    virtual bool HasSetter() const { return true; }
    virtual bool HasGetter() const { return true; }
    virtual bool HasAdder() const { return false; }
    virtual bool HasCollectionGetter() const { return false; }

    virtual const wxString&  GetGetterName() const
        { return m_getterName; }
    virtual const wxString& GetSetterName() const
        { return m_setterName; }

    virtual void SetProperty(wxObject *object, const wxAny &value) const;
    virtual void GetProperty(const wxObject *object, wxAny &value) const;

    // Adding an element to a collection property
    virtual void AddToPropertyCollection(wxObject *WXUNUSED(object), 
                                         const wxAny &WXUNUSED(value)) const
    { 
        wxLogError( _("AddToPropertyCollection called on a generic accessor") ); 
    }

    // Getting a collection property
    virtual void GetPropertyCollection( const wxObject *WXUNUSED(obj), 
                                        wxAnyList &WXUNUSED(result)) const
    { 
        wxLogError ( _("GetPropertyCollection called on a generic accessor") ); 
    }

private:
    struct wxGenericPropertyAccessorInternal;
    wxGenericPropertyAccessorInternal* m_data;
    wxString m_propertyName;
    wxString m_setterName;
    wxString m_getterName;
};

typedef long wxPropertyInfoFlags;
enum 
{
    // will be removed in future releases
    wxPROP_DEPRECATED       = 0x00000001,

    // object graph property, will be streamed with priority (after constructor properties)
    wxPROP_OBJECT_GRAPH     = 0x00000002,

    // this will only be streamed out and in as enum/set, the internal representation 
    // is still a long
    wxPROP_ENUM_STORE_LONG  = 0x00000004,

    // don't stream out this property, needed eg to avoid streaming out children 
    // that are always created by their parents
    wxPROP_DONT_STREAM      = 0x00000008
};


// ----------------------------------------------------------------------------
// 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.
// ----------------------------------------------------------------------------

class WXDLLIMPEXP_BASE wxPropertyInfo
{
    friend class WXDLLIMPEXP_BASE wxDynamicClassInfo;

public:
    wxPropertyInfo(wxPropertyInfo* &iter,
                   wxClassInfo* itsClass,
                   const wxString& name,
                   const wxString& typeName,
                   wxPropertyAccessor *accessor,
                   wxAny dv,
                   wxPropertyInfoFlags flags = 0,
                   const wxString& helpString = wxEmptyString,
                   const wxString& groupString = wxEmptyString) :
                   m_itsClass(itsClass),
           m_name(name),
           m_typeInfo(NULL),
           m_typeName(typeName),
           m_collectionElementTypeInfo(NULL),
           m_accessor(accessor),
           m_defaultValue(dv),
           m_flags(flags),
           m_helpString(helpString),
           m_groupString(groupString)
       {
           Insert(iter);
       }

    wxPropertyInfo(wxPropertyInfo* &iter,
                   wxClassInfo* itsClass,
                   const wxString& name,
                   wxEventSourceTypeInfo* type,
                   wxPropertyAccessor *accessor,
                   wxAny dv,
                   wxPropertyInfoFlags flags = 0,
                   const wxString& helpString = wxEmptyString,
                   const wxString& groupString = wxEmptyString) :
           m_itsClass(itsClass),
           m_name(name),
           m_typeInfo(type),
           m_collectionElementTypeInfo(NULL),
           m_accessor(accessor),
           m_defaultValue(dv),
           m_flags(flags),
           m_helpString(helpString),
           m_groupString(groupString)
       {
           Insert(iter);
       }

    wxPropertyInfo(wxPropertyInfo* &iter,
                    wxClassInfo* itsClass, const wxString& name,
                    const wxString& collectionTypeName,
                    const wxString& elementTypeName,
                    wxPropertyAccessor *accessor,
                    wxPropertyInfoFlags flags = 0,
                    const wxString& helpString = wxEmptyString,
                    const wxString& groupString = wxEmptyString) :
        m_itsClass(itsClass),
        m_name(name),
        m_typeInfo(NULL),
        m_typeName(collectionTypeName),
        m_collectionElementTypeInfo(NULL),
        m_collectionElementTypeName(elementTypeName),
        m_accessor(accessor),
        m_flags(flags),
        m_helpString(helpString),
        m_groupString(groupString)
    {
        Insert(iter);
    }

    ~wxPropertyInfo()
        { Remove(); }

    // return the class this property is declared in
    const wxClassInfo*  GetDeclaringClass() const { return m_itsClass; }

    // return the name of this property
    const wxString&     GetName() const { return m_name; }

    // returns the flags of this property
    wxPropertyInfoFlags GetFlags() const { return m_flags; }

    // returns the short help string of this property
    const wxString&     GetHelpString() const { return m_helpString; }

    // returns the group string of this property
    const wxString&     GetGroupString() const { return m_groupString; }

    // return the element type info of this property (for collections, otherwise NULL)
    const wxTypeInfo *  GetCollectionElementTypeInfo() const
    {
        if ( m_collectionElementTypeInfo == NULL )
            m_collectionElementTypeInfo = wxTypeInfo::FindType(m_collectionElementTypeName);
        return m_collectionElementTypeInfo;
    }

    // return the type info of this property
    const wxTypeInfo *  GetTypeInfo() const
    {
        if ( m_typeInfo == NULL )
            m_typeInfo = wxTypeInfo::FindType(m_typeName);
        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
    wxAny          GetDefaultValue() const { return m_defaultValue; }

private:

    // inserts this property at the end of the linked chain which begins
    // with "iter" property.
    void Insert(wxPropertyInfo* &iter);

    // removes this property from the linked chain of the m_itsClass properties.
    void Remove();

    wxClassInfo*        m_itsClass;
    wxString            m_name;
    mutable wxTypeInfo* m_typeInfo;
    wxString            m_typeName;
    mutable wxTypeInfo* m_collectionElementTypeInfo;
    wxString            m_collectionElementTypeName;
    wxPropertyAccessor* m_accessor;
    wxAny          m_defaultValue;
    wxPropertyInfoFlags m_flags;
    wxString            m_helpString;
    wxString            m_groupString;
    wxPropertyInfo*     m_next;

    // FIXME: what's this comment about??
    // string representation of the default value
    // to be assigned by the designer to the property
    // when the component is dropped on the container.
};

WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxPropertyInfo*, wxPropertyInfoMap, 
                                      class WXDLLIMPEXP_BASE );

#define wxBEGIN_PROPERTIES_TABLE(theClass)                      \
    wxPropertyInfo *theClass::GetPropertiesStatic()             \
    {                                                           \
        typedef theClass class_t;                               \
        static wxPropertyInfo* first = NULL;

#define wxEND_PROPERTIES_TABLE() \
    return first; }

#define wxHIDE_PROPERTY( pname )                                                      \
    static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
            wxT(#pname), typeid(void).name(), NULL, wxAny(), wxPROP_DONT_STREAM, \
            wxEmptyString, wxEmptyString );

#define wxPROPERTY( pname, type, setter, getter, defaultValue, flags, help, group)    \
    wxPROPERTY_SETTER( pname, class_t, type, setter )                                 \
    static wxPropertySetter##pname _setter##pname;                                    \
    wxPROPERTY_GETTER( pname, class_t, type, getter )                                 \
    static wxPropertyGetter##pname _getter##pname;                                    \
    static wxPropertyAccessor _accessor##pname( &_setter##pname,                      \
                                                &_getter##pname, NULL, NULL );        \
    static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
            wxT(#pname), typeid(type).name(), &_accessor##pname,                      \
            wxAny(defaultValue), flags, group, help );

#define wxPROPERTY_FLAGS( pname, flags, type, setter, getter,defaultValue,            \
                          pflags, help, group)                                        \
    wxPROPERTY_SETTER( pname, class_t, type, setter )                                 \
    static wxPropertySetter##pname _setter##pname;                                    \
    wxPROPERTY_GETTER( pname, class_t, type, getter )                                 \
    static wxPropertyGetter##pname _getter##pname;                                    \
    static wxPropertyAccessor _accessor##pname( &_setter##pname,                      \
                                                &_getter##pname, NULL, NULL );        \
    static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
            wxT(#pname), typeid(flags).name(), &_accessor##pname,                     \
            wxAny(defaultValue), wxPROP_ENUM_STORE_LONG | pflags, help, group );

#define wxREADONLY_PROPERTY( pname, type, getter,defaultValue, flags, help, group)    \
    wxPROPERTY_GETTER( pname, class_t, type, getter )                                 \
    static wxPropertyGetter##pname _getter##pname;                                    \
    static wxPropertyAccessor _accessor##pname( NULL, &_getter##pname, NULL, NULL );  \
    static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
            wxT(#pname), typeid(type).name(),&_accessor##pname,                       \
            wxAny(defaultValue), flags, help, group );

#define wxREADONLY_PROPERTY_FLAGS( pname, flags, type, getter,defaultValue,           \
                                   pflags, help, group)                               \
    wxPROPERTY_GETTER( pname, class_t, type, getter )                                 \
    static wxPropertyGetter##pname _getter##pname;                                    \
    static wxPropertyAccessor _accessor##pname( NULL, &_getter##pname, NULL, NULL );  \
    static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
            wxT(#pname), typeid(flags).name(),&_accessor##pname,                      \
            wxAny(defaultValue), wxPROP_ENUM_STORE_LONG | pflags, help, group );

#define wxPROPERTY_COLLECTION( pname, colltype, addelemtype, adder, getter,           \
                               flags, help, group )                                   \
    wxPROPERTY_COLLECTION_ADDER( pname, class_t, addelemtype, adder )                 \
    static wxPropertyCollectionAdder##pname _adder##pname;                            \
    wxPROPERTY_COLLECTION_GETTER( pname, class_t, colltype, getter )                  \
    static wxPropertyCollectionGetter##pname _collectionGetter##pname;                \
    static wxPropertyAccessor _accessor##pname( NULL, NULL,&_adder##pname,            \
                                                &_collectionGetter##pname );          \
    static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
            wxT(#pname), typeid(colltype).name(),typeid(addelemtype).name(),          \
            &_accessor##pname, flags, help, group );

#define wxREADONLY_PROPERTY_COLLECTION( pname, colltype, addelemtype, getter,         \
                                        flags, help, group)                           \
    wxPROPERTY_COLLECTION_GETTER( pname, class_t, colltype, getter )                  \
    static wxPropertyCollectionGetter##pname _collectionGetter##pname;                \
    static wxPropertyAccessor _accessor##pname( NULL, NULL, NULL,                     \
                                                &_collectionGetter##pname );          \
    static wxPropertyInfo _propertyInfo##pname( first,class_t::GetClassInfoStatic(),  \
        wxT(#pname), typeid(colltype).name(),typeid(addelemtype).name(),              \
        &_accessor##pname, flags, help, group  );

#define wxEVENT_PROPERTY( name, eventType, eventClass )                               \
    static wxEventSourceTypeInfo _typeInfo##name( eventType, CLASSINFO( eventClass ) );  \
    static wxPropertyInfo _propertyInfo##name( first,class_t::GetClassInfoStatic(),   \
        wxT(#name), &_typeInfo##name, NULL, wxAny() );

#define wxEVENT_RANGE_PROPERTY( name, eventType, lastEventType, eventClass )          \
    static wxEventSourceTypeInfo _typeInfo##name( eventType, lastEventType,              \
                                               CLASSINFO( eventClass ) );             \
    static wxPropertyInfo _propertyInfo##name( first, class_t::GetClassInfoStatic(),  \
        wxT(#name), &_typeInfo##name, NULL, wxAny() );

// ----------------------------------------------------------------------------
// Implementation Helper for Simple Properties
// ----------------------------------------------------------------------------

#define wxIMPLEMENT_PROPERTY(name, type)                \
private:                                                \
    type m_##name;                                      \
public:                                                 \
  void  Set##name( type const & p) { m_##name = p; }    \
  type const & Get##name() const  { return m_##name; }

WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxAny, wxStringToAnyHashMap,
    class WXDLLIMPEXP_BASE );

#endif      // wxUSE_EXTENDED_RTTI
#endif      // _XTIPROP_H_
Commit	Line	Data
e1d3601a PC	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: wx/xtiprop.h
	3	// Purpose: XTI properties
	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	// Licence: wxWindows licence
	11	/////////////////////////////////////////////////////////////////////////////
	12
	13	#ifndef _XTIPROP_H_
	14	#define _XTIPROP_H_
	15
	16	#include "wx/defs.h"
	17
	18	#if wxUSE_EXTENDED_RTTI
	19
6c887dde SC	20	#include "wx/xti.h"
6c887dde SC	21	#include "wx/any.h"
e1d3601a PC	22
	23	class WXDLLIMPEXP_BASE wxObject;
	24	class WXDLLIMPEXP_BASE wxClassInfo;
	25	class WXDLLIMPEXP_BASE wxDynamicClassInfo;
	26	class WXDLLIMPEXP_BASE wxHashTable;
	27	class WXDLLIMPEXP_BASE wxHashTable_Node;
e1d3601a PC	28	class WXDLLIMPEXP_BASE wxEvent;
	29	class WXDLLIMPEXP_BASE wxEvtHandler;
	30
	31	// ----------------------------------------------------------------------------
	32	// Property Accessors
	33	//
	34	// wxPropertySetter/Getter/CollectionGetter/CollectionAdder are all property
	35	// accessors which are managed by wxPropertyAccessor class which in turn is
	36	// handled by wxPropertyInfo.
	37	// ----------------------------------------------------------------------------
	38
	39	class WXDLLIMPEXP_BASE wxPropertySetter
	40	{
	41	public:
	42	wxPropertySetter( const wxString name ) { m_name = name; }
	43	virtual ~wxPropertySetter() {}
	44
6c887dde	45	virtual void Set( wxObject *object, const wxAny &variantValue ) const = 0;
e1d3601a PC	46	const wxString& GetName() const { return m_name; }
	47
	48	private:
	49	wxString m_name;
	50	};
	51
	52	class WXDLLIMPEXP_BASE wxPropertyGetter
	53	{
	54	public:
	55	wxPropertyGetter( const wxString name ) { m_name = name; }
	56	virtual ~wxPropertyGetter() {}
	57
6c887dde	58	virtual void Get( const wxObject *object, wxAny& result) const = 0;
e1d3601a PC	59	const wxString& GetName() const { return m_name; }
	60
	61	private:
	62	wxString m_name;
	63	};
	64
	65	class WXDLLIMPEXP_BASE wxPropertyCollectionGetter
	66	{
	67	public:
	68	wxPropertyCollectionGetter( const wxString name ) { m_name = name; }
	69	virtual ~wxPropertyCollectionGetter() {}
	70
6c887dde	71	virtual void Get( const wxObject *object, wxAnyList& result) const = 0;
e1d3601a PC	72	const wxString& GetName() const { return m_name; }
	73
	74	private:
	75	wxString m_name;
	76	};
	77
	78	template<typename coll_t> void WXDLLIMPEXP_BASE \
6c887dde	79	wxCollectionToVariantArray( const coll_t& coll, wxAnyList& result );
e1d3601a PC	80
	81	class WXDLLIMPEXP_BASE wxPropertyCollectionAdder
	82	{
	83	public:
	84	wxPropertyCollectionAdder( const wxString name ) { m_name = name; }
	85	virtual ~wxPropertyCollectionAdder() {}
	86
6c887dde	87	virtual void Add( wxObject *object, const wxAny &variantValue ) const= 0;
e1d3601a PC	88	const wxString& GetName() const { return m_name; }
	89
	90	private:
	91	wxString m_name;
	92	};
	93
6c887dde SC	94	#define wxPROPERTY_SETTER( property, Klass, valueType, setterMethod ) \
6c887dde SC	95	class wxPropertySetter##property : public wxPropertySetter \
e1d3601a PC	96	{ \
	97	public: \
	98	wxINFUNC_CLASS_TYPE_FIX(Klass) \
	99	wxPropertySetter##property() : wxPropertySetter( wxT(#setterMethod) ) {} \
6c887dde	100	virtual ~wxPropertySetter##property() {} \
e1d3601a	101	\
6c887dde	102	void Set( wxObject *object, const wxAny &variantValue ) const \
e1d3601a	103	{ \
6c887dde SC	104	Klass obj = dynamic_cast<Klass>(object); \
	105	valueType tempobj; \
	106	if ( variantValue.GetAs(&tempobj) ) \
	107	obj->setterMethod(tempobj); \
	108	else \
	109	obj->setterMethod(wxANY_AS(variantValue, valueType)); \
	110	} \
e1d3601a PC	111	};
	112
	113	#define wxPROPERTY_GETTER( property, Klass, valueType, gettermethod ) \
	114	class wxPropertyGetter##property : public wxPropertyGetter \
	115	{ \
	116	public: \
	117	wxINFUNC_CLASS_TYPE_FIX(Klass) \
	118	wxPropertyGetter##property() : wxPropertyGetter( wxT(#gettermethod) ) {} \
	119	virtual ~wxPropertyGetter##property() {} \
	120	\
6c887dde	121	void Get( const wxObject *object, wxAny &result) const \
e1d3601a PC	122	{ \
e1d3601a PC	123	const Klass obj = dynamic_cast<const Klass>(object); \
6c887dde	124	result = wxAny( obj->gettermethod() ); \
e1d3601a PC	125	} \
	126	};
	127
	128	#define wxPROPERTY_COLLECTION_ADDER( property, Klass, valueType, addermethod ) \
	129	class wxPropertyCollectionAdder##property : public wxPropertyCollectionAdder \
	130	{ \
	131	public: \
	132	wxINFUNC_CLASS_TYPE_FIX(Klass) \
	133	wxPropertyCollectionAdder##property() : wxPropertyCollectionAdder( wxT(#addermethod) ) {} \
	134	virtual ~wxPropertyCollectionAdder##property() {} \
	135	\
6c887dde	136	void Add( wxObject *object, const wxAny &variantValue ) const \
e1d3601a PC	137	{ \
e1d3601a PC	138	Klass obj = dynamic_cast<Klass>(object); \
6c887dde SC	139	valueType tempobj; \
	140	if ( variantValue.GetAs(&tempobj) ) \
	141	obj->addermethod(tempobj); \
e1d3601a	142	else \
6c887dde	143	obj->addermethod(wxANY_AS(variantValue, valueType)); \
e1d3601a PC	144	} \
	145	};
	146
	147	#define wxPROPERTY_COLLECTION_GETTER( property, Klass, valueType, gettermethod ) \
	148	class wxPropertyCollectionGetter##property : public wxPropertyCollectionGetter \
	149	{ \
	150	public: \
	151	wxINFUNC_CLASS_TYPE_FIX(Klass) \
	152	wxPropertyCollectionGetter##property() : wxPropertyCollectionGetter( wxT(#gettermethod) ) {} \
	153	virtual ~wxPropertyCollectionGetter##property() {} \
	154	\
6c887dde	155	void Get( const wxObject *object, wxAnyList &result) const \
e1d3601a PC	156	{ \
	157	const Klass obj = dynamic_cast<const Klass>(object); \
	158	wxCollectionToVariantArray( obj->gettermethod(), result ); \
	159	} \
	160	};
	161
	162	class WXDLLIMPEXP_BASE wxPropertyAccessor
	163	{
	164	public:
	165	wxPropertyAccessor( wxPropertySetter setter, wxPropertyGetter getter,
	166	wxPropertyCollectionAdder adder, wxPropertyCollectionGetter collectionGetter )
	167	{ m_setter = setter; m_getter = getter; m_adder = adder;
	168	m_collectionGetter = collectionGetter; }
	169
	170	virtual ~wxPropertyAccessor() {}
	171
	172	// Setting a simple property (non-collection)
6c887dde	173	virtual void SetProperty(wxObject *object, const wxAny &value) const
e1d3601a PC	174	{
	175	if ( m_setter )
	176	m_setter->Set( object, value );
	177	else
	178	wxLogError( _("SetProperty called w/o valid setter") );
	179	}
	180
	181	// Getting a simple property (non-collection)
6c887dde	182	virtual void GetProperty(const wxObject *object, wxAny &result) const
e1d3601a PC	183	{
	184	if ( m_getter )
	185	m_getter->Get( object, result );
	186	else
	187	wxLogError( _("GetProperty called w/o valid getter") );
	188	}
	189
	190	// Adding an element to a collection property
6c887dde	191	virtual void AddToPropertyCollection(wxObject *object, const wxAny &value) const
e1d3601a PC	192	{
	193	if ( m_adder )
	194	m_adder->Add( object, value );
	195	else
	196	wxLogError( _("AddToPropertyCollection called w/o valid adder") );
	197	}
	198
	199	// Getting a collection property
6c887dde	200	virtual void GetPropertyCollection( const wxObject *obj, wxAnyList &result) const
e1d3601a PC	201	{
	202	if ( m_collectionGetter )
	203	m_collectionGetter->Get( obj, result);
	204	else
	205	wxLogError( _("GetPropertyCollection called w/o valid collection getter") );
	206	}
	207
	208	virtual bool HasSetter() const { return m_setter != NULL; }
	209	virtual bool HasCollectionGetter() const { return m_collectionGetter != NULL; }
	210	virtual bool HasGetter() const { return m_getter != NULL; }
	211	virtual bool HasAdder() const { return m_adder != NULL; }
	212
	213	virtual const wxString& GetCollectionGetterName() const
	214	{ return m_collectionGetter->GetName(); }
	215	virtual const wxString& GetGetterName() const
	216	{ return m_getter->GetName(); }
	217	virtual const wxString& GetSetterName() const
	218	{ return m_setter->GetName(); }
	219	virtual const wxString& GetAdderName() const
	220	{ return m_adder->GetName(); }
	221
	222	protected:
	223	wxPropertySetter *m_setter;
	224	wxPropertyCollectionAdder *m_adder;
	225	wxPropertyGetter *m_getter;
	226	wxPropertyCollectionGetter* m_collectionGetter;
	227	};
	228
	229	class WXDLLIMPEXP_BASE wxGenericPropertyAccessor : public wxPropertyAccessor
	230	{
	231	public:
	232	wxGenericPropertyAccessor( const wxString &propName );
	233	virtual ~wxGenericPropertyAccessor();
	234
	235	void RenameProperty( const wxString& WXUNUSED_UNLESS_DEBUG(oldName),
	236	const wxString& newName )
	237	{
	238	wxASSERT( oldName == m_propertyName ); m_propertyName = newName;
	239	}
	240
	241	virtual bool HasSetter() const { return true; }
	242	virtual bool HasGetter() const { return true; }
	243	virtual bool HasAdder() const { return false; }
	244	virtual bool HasCollectionGetter() const { return false; }
	245
	246	virtual const wxString& GetGetterName() const
	247	{ return m_getterName; }
	248	virtual const wxString& GetSetterName() const
	249	{ return m_setterName; }
	250
6c887dde SC	251	virtual void SetProperty(wxObject *object, const wxAny &value) const;
6c887dde SC	252	virtual void GetProperty(const wxObject *object, wxAny &value) const;
e1d3601a PC	253
	254	// Adding an element to a collection property
	255	virtual void AddToPropertyCollection(wxObject *WXUNUSED(object),
6c887dde	256	const wxAny &WXUNUSED(value)) const
e1d3601a PC	257	{
	258	wxLogError( _("AddToPropertyCollection called on a generic accessor") );
	259	}
	260
	261	// Getting a collection property
	262	virtual void GetPropertyCollection( const wxObject *WXUNUSED(obj),
6c887dde	263	wxAnyList &WXUNUSED(result)) const
e1d3601a PC	264	{
	265	wxLogError ( _("GetPropertyCollection called on a generic accessor") );
	266	}
	267
	268	private:
	269	struct wxGenericPropertyAccessorInternal;
	270	wxGenericPropertyAccessorInternal* m_data;
	271	wxString m_propertyName;
	272	wxString m_setterName;
	273	wxString m_getterName;
	274	};
	275
	276	typedef long wxPropertyInfoFlags;
	277	enum
	278	{
	279	// will be removed in future releases
	280	wxPROP_DEPRECATED = 0x00000001,
	281
	282	// object graph property, will be streamed with priority (after constructor properties)
	283	wxPROP_OBJECT_GRAPH = 0x00000002,
	284
	285	// this will only be streamed out and in as enum/set, the internal representation
	286	// is still a long
	287	wxPROP_ENUM_STORE_LONG = 0x00000004,
	288
	289	// don't stream out this property, needed eg to avoid streaming out children
	290	// that are always created by their parents
	291	wxPROP_DONT_STREAM = 0x00000008
	292	};
	293
	294
	295	// ----------------------------------------------------------------------------
	296	// Property Support
	297	//
	298	// wxPropertyInfo is used to inquire of the property by name. It doesn't
	299	// provide access to the property, only information about it. If you
	300	// want access, look at wxPropertyAccessor.
	301	// ----------------------------------------------------------------------------
	302
	303	class WXDLLIMPEXP_BASE wxPropertyInfo
	304	{
	305	friend class WXDLLIMPEXP_BASE wxDynamicClassInfo;
	306
	307	public:
	308	wxPropertyInfo(wxPropertyInfo* &iter,
	309	wxClassInfo* itsClass,
	310	const wxString& name,
	311	const wxString& typeName,
	312	wxPropertyAccessor *accessor,
6c887dde	313	wxAny dv,
e1d3601a PC	314	wxPropertyInfoFlags flags = 0,
	315	const wxString& helpString = wxEmptyString,
	316	const wxString& groupString = wxEmptyString) :
	317	m_itsClass(itsClass),
	318	m_name(name),
	319	m_typeInfo(NULL),
	320	m_typeName(typeName),
	321	m_collectionElementTypeInfo(NULL),
	322	m_accessor(accessor),
	323	m_defaultValue(dv),
	324	m_flags(flags),
	325	m_helpString(helpString),
	326	m_groupString(groupString)
	327	{
	328	Insert(iter);
	329	}
	330
e1d3601a PC	331	wxPropertyInfo(wxPropertyInfo* &iter,
	332	wxClassInfo* itsClass,
	333	const wxString& name,
	334	wxEventSourceTypeInfo* type,
	335	wxPropertyAccessor *accessor,
6c887dde	336	wxAny dv,
e1d3601a PC	337	wxPropertyInfoFlags flags = 0,
	338	const wxString& helpString = wxEmptyString,
	339	const wxString& groupString = wxEmptyString) :
	340	m_itsClass(itsClass),
	341	m_name(name),
	342	m_typeInfo(type),
	343	m_collectionElementTypeInfo(NULL),
	344	m_accessor(accessor),
	345	m_defaultValue(dv),
	346	m_flags(flags),
	347	m_helpString(helpString),
	348	m_groupString(groupString)
	349	{
	350	Insert(iter);
	351	}
	352
	353	wxPropertyInfo(wxPropertyInfo* &iter,
	354	wxClassInfo* itsClass, const wxString& name,
	355	const wxString& collectionTypeName,
	356	const wxString& elementTypeName,
	357	wxPropertyAccessor *accessor,
	358	wxPropertyInfoFlags flags = 0,
	359	const wxString& helpString = wxEmptyString,
	360	const wxString& groupString = wxEmptyString) :
	361	m_itsClass(itsClass),
	362	m_name(name),
	363	m_typeInfo(NULL),
	364	m_typeName(collectionTypeName),
	365	m_collectionElementTypeInfo(NULL),
	366	m_collectionElementTypeName(elementTypeName),
	367	m_accessor(accessor),
	368	m_flags(flags),
	369	m_helpString(helpString),
	370	m_groupString(groupString)
	371	{
	372	Insert(iter);
	373	}
	374
e1d3601a PC	375	~wxPropertyInfo()
	376	{ Remove(); }
	377
	378	// return the class this property is declared in
	379	const wxClassInfo* GetDeclaringClass() const { return m_itsClass; }
	380
	381	// return the name of this property
	382	const wxString& GetName() const { return m_name; }
	383
	384	// returns the flags of this property
	385	wxPropertyInfoFlags GetFlags() const { return m_flags; }
	386
	387	// returns the short help string of this property
	388	const wxString& GetHelpString() const { return m_helpString; }
	389
	390	// returns the group string of this property
	391	const wxString& GetGroupString() const { return m_groupString; }
	392
	393	// return the element type info of this property (for collections, otherwise NULL)
	394	const wxTypeInfo * GetCollectionElementTypeInfo() const
	395	{
	396	if ( m_collectionElementTypeInfo == NULL )
	397	m_collectionElementTypeInfo = wxTypeInfo::FindType(m_collectionElementTypeName);
	398	return m_collectionElementTypeInfo;
	399	}
	400
	401	// return the type info of this property
	402	const wxTypeInfo * GetTypeInfo() const
	403	{
	404	if ( m_typeInfo == NULL )
	405	m_typeInfo = wxTypeInfo::FindType(m_typeName);
	406	return m_typeInfo;
	407	}
	408
	409	// return the accessor for this property
	410	wxPropertyAccessor* GetAccessor() const { return m_accessor; }
	411
	412	// returns NULL if this is the last property of this class
	413	wxPropertyInfo* GetNext() const { return m_next; }
	414
	415	// returns the default value of this property, its kind may be wxT_VOID if it is not valid
6c887dde	416	wxAny GetDefaultValue() const { return m_defaultValue; }
e1d3601a PC	417
	418	private:
	419
	420	// inserts this property at the end of the linked chain which begins
	421	// with "iter" property.
	422	void Insert(wxPropertyInfo* &iter);
	423
	424	// removes this property from the linked chain of the m_itsClass properties.
	425	void Remove();
	426
	427	wxClassInfo* m_itsClass;
	428	wxString m_name;
	429	mutable wxTypeInfo* m_typeInfo;
	430	wxString m_typeName;
	431	mutable wxTypeInfo* m_collectionElementTypeInfo;
	432	wxString m_collectionElementTypeName;
	433	wxPropertyAccessor* m_accessor;
6c887dde	434	wxAny m_defaultValue;
e1d3601a PC	435	wxPropertyInfoFlags m_flags;
	436	wxString m_helpString;
	437	wxString m_groupString;
	438	wxPropertyInfo* m_next;
	439
	440	// FIXME: what's this comment about??
	441	// string representation of the default value
	442	// to be assigned by the designer to the property
	443	// when the component is dropped on the container.
	444	};
	445
	446	WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxPropertyInfo*, wxPropertyInfoMap,
	447	class WXDLLIMPEXP_BASE );
	448
	449	#define wxBEGIN_PROPERTIES_TABLE(theClass) \
	450	wxPropertyInfo *theClass::GetPropertiesStatic() \
	451	{ \
	452	typedef theClass class_t; \
	453	static wxPropertyInfo* first = NULL;
	454
	455	#define wxEND_PROPERTIES_TABLE() \
	456	return first; }
	457
	458	#define wxHIDE_PROPERTY( pname ) \
	459	static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
6c887dde	460	wxT(#pname), typeid(void).name(), NULL, wxAny(), wxPROP_DONT_STREAM, \
e1d3601a PC	461	wxEmptyString, wxEmptyString );
	462
	463	#define wxPROPERTY( pname, type, setter, getter, defaultValue, flags, help, group) \
	464	wxPROPERTY_SETTER( pname, class_t, type, setter ) \
	465	static wxPropertySetter##pname _setter##pname; \
	466	wxPROPERTY_GETTER( pname, class_t, type, getter ) \
	467	static wxPropertyGetter##pname _getter##pname; \
	468	static wxPropertyAccessor _accessor##pname( &_setter##pname, \
	469	&_getter##pname, NULL, NULL ); \
	470	static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
	471	wxT(#pname), typeid(type).name(), &_accessor##pname, \
6c887dde	472	wxAny(defaultValue), flags, group, help );
e1d3601a PC	473
	474	#define wxPROPERTY_FLAGS( pname, flags, type, setter, getter,defaultValue, \
	475	pflags, help, group) \
	476	wxPROPERTY_SETTER( pname, class_t, type, setter ) \
	477	static wxPropertySetter##pname _setter##pname; \
	478	wxPROPERTY_GETTER( pname, class_t, type, getter ) \
	479	static wxPropertyGetter##pname _getter##pname; \
	480	static wxPropertyAccessor _accessor##pname( &_setter##pname, \
	481	&_getter##pname, NULL, NULL ); \
	482	static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
	483	wxT(#pname), typeid(flags).name(), &_accessor##pname, \
6c887dde	484	wxAny(defaultValue), wxPROP_ENUM_STORE_LONG \| pflags, help, group );
e1d3601a PC	485
	486	#define wxREADONLY_PROPERTY( pname, type, getter,defaultValue, flags, help, group) \
	487	wxPROPERTY_GETTER( pname, class_t, type, getter ) \
	488	static wxPropertyGetter##pname _getter##pname; \
	489	static wxPropertyAccessor _accessor##pname( NULL, &_getter##pname, NULL, NULL ); \
	490	static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
	491	wxT(#pname), typeid(type).name(),&_accessor##pname, \
6c887dde	492	wxAny(defaultValue), flags, help, group );
e1d3601a PC	493
	494	#define wxREADONLY_PROPERTY_FLAGS( pname, flags, type, getter,defaultValue, \
	495	pflags, help, group) \
	496	wxPROPERTY_GETTER( pname, class_t, type, getter ) \
	497	static wxPropertyGetter##pname _getter##pname; \
	498	static wxPropertyAccessor _accessor##pname( NULL, &_getter##pname, NULL, NULL ); \
	499	static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
	500	wxT(#pname), typeid(flags).name(),&_accessor##pname, \
6c887dde	501	wxAny(defaultValue), wxPROP_ENUM_STORE_LONG \| pflags, help, group );
e1d3601a PC	502
	503	#define wxPROPERTY_COLLECTION( pname, colltype, addelemtype, adder, getter, \
	504	flags, help, group ) \
	505	wxPROPERTY_COLLECTION_ADDER( pname, class_t, addelemtype, adder ) \
	506	static wxPropertyCollectionAdder##pname _adder##pname; \
	507	wxPROPERTY_COLLECTION_GETTER( pname, class_t, colltype, getter ) \
	508	static wxPropertyCollectionGetter##pname _collectionGetter##pname; \
	509	static wxPropertyAccessor _accessor##pname( NULL, NULL,&_adder##pname, \
	510	&_collectionGetter##pname ); \
	511	static wxPropertyInfo _propertyInfo##pname( first, class_t::GetClassInfoStatic(), \
	512	wxT(#pname), typeid(colltype).name(),typeid(addelemtype).name(), \
	513	&_accessor##pname, flags, help, group );
	514
	515	#define wxREADONLY_PROPERTY_COLLECTION( pname, colltype, addelemtype, getter, \
	516	flags, help, group) \
	517	wxPROPERTY_COLLECTION_GETTER( pname, class_t, colltype, getter ) \
	518	static wxPropertyCollectionGetter##pname _collectionGetter##pname; \
	519	static wxPropertyAccessor _accessor##pname( NULL, NULL, NULL, \
	520	&_collectionGetter##pname ); \
	521	static wxPropertyInfo _propertyInfo##pname( first,class_t::GetClassInfoStatic(), \
	522	wxT(#pname), typeid(colltype).name(),typeid(addelemtype).name(), \
	523	&_accessor##pname, flags, help, group );
	524
	525	#define wxEVENT_PROPERTY( name, eventType, eventClass ) \
	526	static wxEventSourceTypeInfo _typeInfo##name( eventType, CLASSINFO( eventClass ) ); \
	527	static wxPropertyInfo _propertyInfo##name( first,class_t::GetClassInfoStatic(), \
6c887dde	528	wxT(#name), &_typeInfo##name, NULL, wxAny() );
e1d3601a PC	529
	530	#define wxEVENT_RANGE_PROPERTY( name, eventType, lastEventType, eventClass ) \
	531	static wxEventSourceTypeInfo _typeInfo##name( eventType, lastEventType, \
	532	CLASSINFO( eventClass ) ); \
	533	static wxPropertyInfo _propertyInfo##name( first, class_t::GetClassInfoStatic(), \
6c887dde	534	wxT(#name), &_typeInfo##name, NULL, wxAny() );
e1d3601a PC	535
	536	// ----------------------------------------------------------------------------
	537	// Implementation Helper for Simple Properties
	538	// ----------------------------------------------------------------------------
	539
	540	#define wxIMPLEMENT_PROPERTY(name, type) \
	541	private: \
	542	type m_##name; \
	543	public: \
	544	void Set##name( type const & p) { m_##name = p; } \
	545	type const & Get##name() const { return m_##name; }
	546
6c887dde SC	547	WX_DECLARE_STRING_HASH_MAP_WITH_DECL( wxAny, wxStringToAnyHashMap,
	548	class WXDLLIMPEXP_BASE );
	549
e1d3601a PC	550	#endif // wxUSE_EXTENDED_RTTI
e1d3601a PC	551	#endif // _XTIPROP_H_