node.h

Go to the documentation of this file.

//**************************************************************************/
// Copyright (c) 2008 Autodesk, Inc.
// All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
//
//**************************************************************************/
// DESCRIPTION:
// CREATED: October 2008
//**************************************************************************/

#include <QtCore/QHash>

namespace mudbox {

class Template;
class Node;

class MBDLL_DECL ClassDesc
{
    const ClassDesc    *m_pParent[2], *m_pNext;
    QString             m_sName;
    QString             m_sDisplayName;
    typedef class Node *creator( unsigned int );
    creator            *m_pCreator;
    static ClassDesc   *s_pFirst;
    Template           *m_pTemplate;
    int                 m_iVersion;

public:
    int                 m_iStreamVersion;
    
    ClassDesc( const ClassDesc *pParent0, const ClassDesc *pParent1, const QString &sName, 
               const QString &sDisplayName, creator *pCreator, int iVersion = 0, int iStreamVersion = 0 );
    const ClassDesc *Parent( unsigned int iIndex = 0 ) const;
    const QString &Name( void ) const;
    const QString &DisplayName( void ) const;
    void SetDisplayName( const QString &sName );

    bool IsDerivedFrom( const ClassDesc *pClass ) const;
    class Node *CreateInstances( int iCount = 1 ) const;

    static const ClassDesc *First( void );
    const ClassDesc *Next( void ) const { return m_pNext; };

    static const ClassDesc *ByName( const QString &sName );
    int Version( void ) const;

    friend class Node;
    friend class Stream;
};

#define DECLARE_CLASS \
private: \
    static mudbox::ClassDesc s_cMyClass; \
public: \
    virtual const mudbox::ClassDesc *RuntimeClass( void ) const { return &s_cMyClass; }; \
    static const mudbox::ClassDesc *StaticClass( void ); \
    static mudbox::Node *CreateInstances( unsigned int iCount = 1 );

#define IMPLEMENT_SDK_VCLASS2( name, parent0, parent1, displayname, instanceclass, version, streamversion ) \
    mudbox::ClassDesc name::s_cMyClass( parent0::StaticClass(), parent1::StaticClass(), #name, displayname, name::CreateInstances, version, streamversion ); \
    const mudbox::ClassDesc *name::StaticClass( void ) { return &s_cMyClass; }; \
    mudbox::Node *name::CreateInstances( unsigned int iCount ) \
        { Node *p; \
            if ( iCount > 1 ) { p = new instanceclass[iCount]; for ( unsigned int i = 0; i < iCount; i++ ) p[i].Initialize(); } \
            else { p = new instanceclass; p->Initialize(); }; \
            return p; };

#define IMPLEMENT_SDK_VCLASS( name, parent, displayname, instanceclass, streamversion ) IMPLEMENT_SDK_VCLASS2( name, parent, parent, displayname, instanceclass, 0, streamversion )
#define IMPLEMENT_SDK_CLASS( name, parent, displayname, instanceclass ) IMPLEMENT_SDK_VCLASS2( name, parent, parent, displayname, instanceclass, 0, 0 )
#define IMPLEMENT_VCLASS2( name, parent0, parent1, displayname, version ) IMPLEMENT_SDK_VCLASS2( name, parent0, parent1, displayname, name, version, 0 )
#define IMPLEMENT_VCLASS( name, parent, displayname, version ) IMPLEMENT_SDK_VCLASS2( name, parent, parent, displayname, name, version, 0 )
#define IMPLEMENT_CLASS2( name, parent0, parent1, displayname ) IMPLEMENT_SDK_VCLASS2( name, parent0, parent1, displayname, name, 0, 0 )
#define IMPLEMENT_CLASS( name, parent, displayname ) IMPLEMENT_SDK_VCLASS2( name, parent, parent, displayname, name, 0, 0 )
#define IMPLEMENT_SCLASS( name, parent, displayname, streamversion ) IMPLEMENT_SDK_VCLASS2( name, parent, parent, displayname, name, 0, streamversion )
#define IMPLEMENT_SCLASS2( name, parent0, parent1, displayname, streamversion ) IMPLEMENT_SDK_VCLASS2( name, parent0, parent1, displayname, name, 0, streamversion )

enum NodeEventType
{
    etValueChanged,
    etSourceChanged,
    etTargetChanged,
    etPointerContentChanged,
    etPointerTargetDestroyed,
    etStatusChanged,
    etPointerTargetUIChanged,
    etDeferred,
    etRefreshDialogUI,
    etEditingFinished,
    etEventTriggered = etValueChanged
};

struct MBDLL_DECL Attribute
{   
    enum AttributeType
    {
        typeUnknown,
        typeInt,
        typeFloat,
        typeBool,
        typeString,
        typePointer,
        typeColor,
        typeVector,
        typeEnum,
        typeWatch
    };

    unsigned int TargetCount( void ) const;
    Attribute *Target( unsigned int iIndex ) const;
    Attribute *Source( void ) const;
    bool operator ==( const Attribute &cAttribute ) const;
    bool operator !=( const Attribute &cAttribute ) const;
    virtual AttributeType Type( void ) const;

    QString ID( void ) const;
    QString Name( void ) const;
    void SetName( const QString &sName );
    QString Category( void ) const;
    void SetCategory( const QString &sCategory, bool bSeparator = false );
    bool Separator( void ) const;
    void SetSeparator( bool bSeparator );
    bool Const( void ) const;
    void SetConst( bool bConst );
    bool InstantEdit( void ) const;
    void SetInstantEdit( bool bOn );
    bool Visible( void ) const;
    void SetVisible( bool bVisible );
    QString ToolTip( void ) const;
    void SetToolTip( const QString &sToolTip );
    unsigned int Size( void ) const;
    float LabelWidth( void ) const;
    void SetLabelWidth( float fLabelWidth );
    int Index( void ) const;
    void SetIndex( int iIndex );

    Node *Owner( void ) const;
    virtual void Serialize( Stream &s );

    virtual QString AsString( bool bLocalized = false ) const;
    virtual void SetFromString( const QString &sValue, bool bInternal = true, bool bLocalized = false );

        void ClearTargets( void );
        void ClearSource( void );
        virtual void AddTarget( Attribute &cTarget, bool bInternal = false );
        void Connect( Attribute &cSource, bool bInternal = false );
        virtual void UpdateTargets( void );

        virtual const ClassDesc* TargetType( void ) const;
        virtual void SetPointerValue( Node *pValue, bool bLink = true );
        virtual Node *PointerValue( void ) const;
        virtual bool ValidatePointerValue( const Node *pValue );

    virtual ~Attribute( void );
    virtual void StartEvent( NodeEventType cType ) const;
    
    void SetOwner( Node *pOwner );

    virtual AttributeWidget *CreateEditorWidget( QWidget *pParent, 
        int iWidth 
        );
    
    virtual unsigned int ParameterCount( void ) const;
    virtual QString ParameterName( unsigned int iIndex ) const;
    virtual QString ParameterValue( unsigned int iIndex ) const;
    virtual void SetParameterValue( const QString &sName, const QString &sValue );

    void LogTargets( void );
    void LogSource( void );
    void CheckValidity( void );
    
protected:

    Attribute( Node *pOwner, const QString &sID);
    Attribute( Node *pOwner, bool bInstall);

    int m_iSize;
    Attribute *m_pSource, *m_pNext;
    Store<Attribute *> m_aTargets;
    Node   *m_pNode;
    QString m_sName;
    bool    m_bSeparator;
    QString m_sCategory;
    QString m_sToolTip;
    float   m_fLabelWidth;
    bool    m_bConst;
    bool    m_bVisible;
    int     m_iIndex;
    bool    m_bInstantEdit;
    QString m_sID;

    void    Uninstall( void );

    friend class Node;
};

class MBDLL_DECL AttributeVoid : public Attribute
{
public:
    AttributeVoid(Node *pOwner, const QString &sName ) : Attribute(pOwner, sName) {}
    ~AttributeVoid() {}
};

typedef AttributeVoid avoid;

template < typename type >
struct MBDLL_TEMPLATE_DECL AttributeInstance : public Attribute
{
    AttributeInstance( Node *pOwner, const QString &sID ) : Attribute( pOwner, sID ) { m_iSize = sizeof(type); };
    AttributeInstance( Node *pOwner, const QString &sID, const type &cValue ) : Attribute( pOwner, sID ) { m_cValue = cValue; m_iSize = sizeof(type); };
    AttributeInstance( const AttributeInstance<type> &o ) : Attribute( 0, "" ) { SetValue( o.Value(), true ); m_iSize = sizeof(type); };

    virtual ~AttributeInstance( void );

    // Value management
    const type &Value( void ) const { return m_cValue; };
    virtual void SetValue( type cValue, bool bInternal = false )
    {
        m_cValue = cValue;
        UpdateTargets();
        if ( !bInternal )
            StartEvent( etValueChanged );
    };
    void UpdateTargets( void )
    {
        for ( unsigned int i = 0; i < TargetCount(); i++ )
        {
            if ( Target(i)->Size() == Size() )
                ((AttributeInstance<type> *)Target(i))->SetValue( m_cValue );
            else
                Target(i)->StartEvent( etValueChanged );
        };
    };
    void Serialize( Stream &s );

    void AddTarget( Attribute &cTarget, bool bInternal = false )
    {
        Attribute::AddTarget( cTarget );
        if ( cTarget.Size() )
        {
            AttributeInstance<type> *pT = (AttributeInstance<type> *)&cTarget;
            if ( pT->Value() != Value() )
                pT->SetValue( Value(), bInternal );
        };

        StartEvent( etTargetChanged );
        cTarget.StartEvent( etSourceChanged );
    };

    // Default string operations
    virtual QString AsString( bool bLocalized = false ) const;

    virtual void SetFromString( const QString &sValue, bool bInternal = true, bool /*bLocalized*/ = false );

    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth ) { return Attribute::CreateEditorWidget( pParent, iWidth ); };
    Attribute::AttributeType Type( void ) const { return Attribute::AttributeType(); };

    // Operators
    // Used for the QString class which does not have a predefined ! operator
    // if the line below is used, than pointers wont be linked into the target node THIS pointer.
    //inline type operator =( type cValue ) { AttributeInstance<type>::SetValue( cValue, true ); return cValue; }; 
#define OPERATORS_NOEXCMARK( type ) \
 \
    inline operator type( void ) const { return AttributeInstance<type>::Value(); }; \
 \
    inline type const &operator ~( void ) const { return AttributeInstance<type>::Value(); }; \
 \
    inline type operator =( type cValue ) { SetValue( cValue, true ); return cValue; }; \
 \
    inline type operator =( const AttributeInstance<type> &cValue ) { /*AttributeInstance<type>::*/SetValue( cValue.AttributeInstance<type>::Value(), true ); return cValue; }; \
 \
    inline bool operator ==( type cValue ) const { return AttributeInstance<type>::Value() == cValue; }; \
 \
    inline bool operator !=( type cValue ) const { return AttributeInstance<type>::Value() != cValue; }; \
 \
    inline const QString &operator <<=( const QString &sCategory ) { AttributeInstance<type>::SetCategory( sCategory ); return sCategory; };
#define OPERATORS( type ) \
    OPERATORS_NOEXCMARK( type ) \
 \
    inline bool operator !( void ) { return !AttributeInstance<type>::Value(); };

    OPERATORS( type );
 
protected:
    AttributeInstance( Node *pOwner, const QString &sName, bool bInstall ) : Attribute( pOwner, bInstall ) { m_sName = sName; m_iSize = sizeof(type); };
    
private:
// HACK:
public:
    type m_cValue;
};

template<class T>
AttributeInstance<T>::~AttributeInstance()
{
    // no-op
    // Implementation used to create vtable on GCC compilers.
}

 
template<class T>
QString AttributeInstance<T>::AsString( bool bLocalized ) const
{
    bLocalized;
    QString sValue;
    const unsigned char *tData = (const unsigned char *)(void *)(&m_cValue);
    for ( unsigned int i = 0; i < sizeof(m_cValue); i++ )
    {
        if ( i ) 
            sValue += " ";
        sValue += QString("%1").arg(int(tData[i]));
    };
    return sValue;
};

 
template<class T>
void AttributeInstance<T>::SetFromString( const QString &sValue, bool bInternal, bool /*bLocalized*/ )
{
    T cValue;
    unsigned char *tData = (unsigned char *)(void *)(&cValue);
    for ( int i = 0; i < (int)sizeof(cValue); i++ )
        tData[i] = sValue.section(' ', i, i).toInt();
    SetValue( cValue, bInternal );
};

typedef AttributeInstance<int> aint;
typedef AttributeInstance<float> afloat;
typedef AttributeInstance<bool> abool;
typedef AttributeInstance<QString> astring; 

template <> inline
bool astring::operator !(void) { return !(m_cValue.isEmpty()); }

template <> MBDLL_DECL
QString aint::AsString( bool bLocalized ) const;
template <> MBDLL_DECL
QString afloat::AsString( bool bLocalized ) const;
template <> MBDLL_DECL
QString abool::AsString( bool bLocalized ) const;
template <> inline
QString astring::AsString( bool bLocalized ) const { return m_cValue; };

template <> MBDLL_DECL
void aint::SetFromString( const QString &sValue, bool bInternal, bool bLocalized );
template <> MBDLL_DECL
void afloat::SetFromString( const QString &sValue, bool bInternal, bool bLocalized );
template <> MBDLL_DECL
void abool::SetFromString( const QString &sValue, bool bInternal, bool bLocalized );
template <> inline
void astring::SetFromString( const QString &sValue, bool bInternal, bool bLocalized ) { SetValue( sValue, bInternal ); };

template <> inline
Attribute::AttributeType aint::Type( void ) const { return typeInt; };
template <> inline
Attribute::AttributeType abool::Type( void ) const { return typeBool; }; 
template <> inline
Attribute::AttributeType afloat::Type( void ) const { return typeFloat; };
template <> inline
Attribute::AttributeType astring::Type( void ) const { return typeString; };

MBDLL_DECL AttributeWidget *CreateNewPtrWidget( QWidget *pParent, int iWidth, Attribute *pAttribute, const ClassDesc *pType );
MBDLL_DECL AttributeWidget *CreateNewBoolWidget( QWidget *pParent, int iWidth, abool *pAttribute );
MBDLL_DECL AttributeWidget *CreateNewIntWidget( QWidget *pParent, int iWidth, aint *pAttribute );

template <> inline
AttributeWidget *abool::CreateEditorWidget( QWidget *pParent, int iWidth ) { return CreateNewBoolWidget( pParent, iWidth, this ); };
template <> inline
AttributeWidget *aint::CreateEditorWidget( QWidget *pParent, int iWidth ) { return CreateNewIntWidget( pParent, iWidth, this ); };

template < typename type > inline
bool operator ==( const Attribute &cA, const AttributeInstance<type> &cB )
{
    return &cA == &cB;
};
    
template < typename type > inline
Stream &operator ==( Stream &s, AttributeInstance<type> &c )
{
    c.Serialize( s );
    return s;
};

class EventGate;

template < typename type >
class AttributePointer : public AttributeInstance<type *>
{
    const ClassDesc *TargetType( void ) const { return type::StaticClass(); };
    Node *PointerValue( void ) const { return AttributeInstance<type *>::Value(); };
    void UpdateTargets( void )
    {
        for ( unsigned int i = 0; i < AttributeInstance<type *>::TargetCount(); i++ )
            AttributeInstance<type *>::Target(i)->SetPointerValue( PointerValue(), false );
    };
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth ) { return CreateNewPtrWidget( pParent, iWidth, this, type::StaticClass() ); };
    typedef bool validator( const type *pTarget );
    validator *m_pValidator;
    bool ValidatePointerValue( const Node *pValue )
    {
        if ( m_pValidator == 0 || m_pValidator( dynamic_cast< const type *>( pValue ) ) )
            return true;

        return false;
    };

public:
    AttributePointer( Node *pOwner=NULL, const QString &sID = "") : AttributeInstance<type *>( pOwner, sID ) 
    { SetValue( 0, true ); m_pValidator = 0; m_sNullString = "NULL"; m_bAllowNull = true; };

    AttributePointer( Node *pOwner, const QString &sID,  bool bInstall ) : AttributeInstance<type *>( pOwner, sID, bInstall ) 
    { SetValue( 0, true ); m_pValidator = 0; m_sNullString = "NULL"; m_bAllowNull = true; };

    AttributePointer( const AttributePointer<type> &cOther ) : AttributeInstance<type *>( 0, "" ) 
    { SetValue( cOther.Value(), true ); m_pValidator = 0; m_sNullString = "NULL"; m_bAllowNull = true; };

    QString AsString( bool /*bLocalized*/ ) const { if ( PointerValue() ) return PointerValue()->Name(); else return m_sNullString; };

    void SetFromString( const QString & /*sValue*/, bool /*bInternal*/ = true, bool /*bLocalized*/ = false ) { SetPointerValue( 0 ); };

    inline void SetValidator( validator *pValidator ) { m_pValidator = pValidator; };

    void SetPointerValue( Node *pNode, bool bLink = true ) 
    {
        // always accept 0 pointer, the target may be destroyed
        if ( pNode && m_pValidator && !m_pValidator( dynamic_cast<type *>( pNode ) ) )
            return;
        if ( bLink )
            SetValue( dynamic_cast<type *>( pNode ) );
        else
            AttributeInstance<type *>::SetValue( dynamic_cast<type *>( pNode ) );
    };
    virtual void SetValue( type *cValue, bool bInternal = false )
    {
        if ( cValue == AttributePointer<type>::Value() )
            return;
        AttributeInstance<type *>::SetValue( cValue, bInternal );
        if ( cValue )
            cValue->m_pThis.AddTarget( *this );
        else
            Attribute::ClearSource();
    };
    void AddTarget( Attribute &cTarget )
    {
        Attribute::AddTarget( cTarget );
        if ( cTarget.Size() )
        {
            if ( cTarget.PointerValue() != PointerValue() )
                cTarget.SetPointerValue( PointerValue() );
        };
    };
    void DeleteTarget( void )
    {
        delete AttributePointer<type>::Value();
    };
    void Serialize( Stream &s );
    void StartEvent( NodeEventType cType ) const
    {
        AttributeInstance<type *>::StartEvent( cType );
        if ( cType == etPointerContentChanged || cType == etPointerTargetDestroyed || cType == etPointerTargetUIChanged || cType == etRefreshDialogUI )
            for ( unsigned int i = 0; i < AttributeInstance<type *>::TargetCount(); i++ )
                AttributeInstance<type *>::Target( i )->StartEvent( cType );
    };
    Attribute::AttributeType Type( void ) const { return AttributeInstance<type *>::typePointer; };
#define PTROPERATORS( type ) \
    OPERATORS( type* ); \
 \
    inline type *operator =( int iValue ) { MB_ASSERT( iValue == 0 ); return operator =( (type *)(uint64)iValue ); }; \
 \
    inline bool operator ==( int iValue ) { MB_ASSERT( iValue == 0 ); return operator ==( (type *)(uint64)iValue ); }; \
 \
    inline bool operator !=( int iValue ) { MB_ASSERT( iValue == 0 ); return operator !=( (type *)(uint64)iValue ); }; \
 \
    inline type *operator ->( void ) { return AttributeInstance<type *>::Value(); }; \
 \
    inline const type *operator ->( void ) const { return AttributeInstance<type *>::Value(); }; \
 \
    inline operator bool( void ) const { return AttributeInstance<type *>::Value() != 0; };
    PTROPERATORS( type );

    QString m_sNullString;
    bool m_bAllowNull;

    friend class Node;
    friend class AttributeThisPointer;
    friend struct Attribute;
};

//template < typename type>
//typedef AttributePointer<type> aptr<type>;
#define aptr AttributePointer
template < typename type >
inline Stream &operator ==( Stream &cStream, AttributePointer<type> &cPointer ) { cPointer.AttributePointer<type>::Serialize( cStream ); return cStream; };

class MBDLL_DECL AttributeThisPointer : public aptr<Node>
{
    AttributeThisPointer( Node *pOwner );
    const ClassDesc *TargetType( void ) const;
    PTROPERATORS( Node );

    friend class Node;
};


//---------------------------------------------------------------------------------------
class MBDLL_DECL Node
{
private:
    Node                *m_pNext;
    Node                *m_pPrev;

    Attribute           *m_pAttributes;

    int                  m_iID;
    mutable unsigned int m_iVersion;

    QString              m_sStringID;
    QString              m_sDisplayName;
    QString              m_sHelpID;

    QList<Attribute *>   m_aRuntimeAttributes;

    // We use a hash table so we can find nodes by ID fast. 
    // (was a performance bottleneck for undo/redo and file serialization)
    typedef QHash<int, Node *> NodeIDMap;   

    static Node         *s_pFirstNode;
    static int           s_iNextID;
    static bool          s_bUseHashTable;   // QHash crashes if used during static construction time, so dont.

    static NodeIDMap    *s_NodeIDMap;       // Hash map so we can find nodes by ID fast.

    friend struct        Attribute;
    friend class         Stream;

public:

    //  Thanks Bjarne.... 
    static void StartHashing();        

    enum DiagnosticLevel
    {
        dgnLevel1,

        dgnLevel2,

        dgnLevel3
    };

    Node( const QString &sStringID = "", const QString &sDisplayName = "" );
    virtual ~Node( void );

    virtual void Initialize( void );


        virtual void OnNodeEvent( const Attribute &cAttribute, NodeEventType cType );
        virtual void OnEvent( const EventGate &cEvent );
        void RequestDeferredEvent( Attribute &cAttribute );

    void LoadTemplate( const QString &sFileName = "", bool bStartEvent = false );
    void SaveTemplate( const QString &sFileName = "", bool bSaveOnlyVisible = false);
    unsigned int Version( void ) const;
    void SetVersion( unsigned int iVersion );
    unsigned int ReferenceCount( void ) const;
    Attribute *ReferencePointer( unsigned int iIndex ) const;
    Node *ReferenceNode( unsigned int iIndex ) const;
    
        static Node *First( void );

        Node *Next( void ) const { return m_pNext; }

        int ID( void ) const { return m_iID; }

        bool SetID( int iID );

        static Node *ByID( int iID );

        static Node *ByName( const QString &sClass, const QString &sName );

    // TODO I18N: remove this deprecated interface.
    virtual QString Name( const ClassDesc *pClass = 0 ) const;
    // TODO I18N: remove this deprecated interface.
    virtual void SetName( const QString &sName );
    virtual QString StringID( const ClassDesc *pClass = 0 ) const;
    virtual void SetStringID( const QString &sStringID );
    virtual QString DisplayName( void ) const;
    virtual void SetDisplayName( const QString & sDisplayName );
    virtual QString HelpID( void ) const;
    virtual void SetHelpID( const QString &sHelpID );

    void Annex( Node *pSource, const QString &sCategory = "" );

        unsigned int AttributeCount( void ) const;
        Attribute *AttributeByIndex( int iIndex ) const;
        Attribute *AttributeByName( const QString &sName ) const;
        Attribute *AttributeByID( const QString &sID ) const;
        void SetAttributeValue( const QString &sAttributeID, const QString &sNewValue );
        QString AttributeValue( const QString &sAttributeID ) const;
        void LogAttributes( void ) const;
        virtual QWidget *CreatePropertiesWindow( QWidget *pParent );
        Attribute *AddAttribute(Attribute::AttributeType type, const QString &id);
        // Allows SDK users to add attributes at runtime.  The Attribute passed into the function
        // *MUST* be allocated on the heap (dynamically allocated).  Returns true on success & false on failure.  On successfull adding
        // then this node manages the attribute (deletes on node destructor).  Returns true if attribute
        // already exists.  This function sets the owner of this attribute to the node.  The new owner is
        // responsible for deleting the attribute.  Attribute visibility is set to false.
        // Note that the attribute will be serialized when the node is serialized.
        //
        // Disabled until we support serialization of user-defined attribute types.
        //bool AddAttribute(Attribute *pAttribute);

        // Runtime attribute count

    virtual void Serialize( Stream &s );

    AttributeThisPointer m_pThis;

    friend class EventGate;

    bool IsKindOf( const ClassDesc *pClass ) const;
    
    void ContentChanged( void ) const;
    
    virtual void CheckValidity( DiagnosticLevel iLevel = dgnLevel2 ) const;

    virtual void CopyTo( Node *pNode) const;

    virtual Node *Duplicate( void ) const;

    DECLARE_CLASS;
};

AttributeWidget *CreateNewEventWidget( QWidget *pParent, int iWidth, EventGate *pAttribute );

class MBDLL_DECL EventGate : public AttributeInstance<int>
{
    void StartEvent( NodeEventType cType ) const;
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth );

public:
    EventGate( Node *pOwner = NULL, const QString &sID = "" );
    void Trigger( void );
    void Connect( EventGate &cEvent, bool bInternal = false );
    bool operator ==( const EventGate &cEvent ) const;
};
typedef EventGate aevent;

// special attributes
class MBDLL_DECL AttributeFloatRange : public afloat
{
    Q_DECLARE_TR_FUNCTIONS(mudbox::AttributeFloatRange);
private:
    mutable float m_fMin, m_fMax;
    mutable float m_fEditMin, m_fEditMax;
    float m_fFactor;
    int m_iPrecision;

    QString AsString( bool /*bLocalized*/ ) const;
    void SetFromString( const QString &sValue, bool bInternal = true, bool bLocalized = false );

    unsigned int ParameterCount( void ) const;
    QString ParameterName( unsigned int iIndex ) const;
    QString ParameterValue( unsigned int iIndex ) const;
    void SetParameterValue( const QString &sName, const QString &sValue );
public:
    AttributeFloatRange( Node *pOwner, const QString &sID, float fMinimum = 0, float fMaximum = 1, float fFactor = 1, int iPrecision = 2 );
    OPERATORS( float );
    void StartEvent( NodeEventType cType ) const;
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth );
    float Min( void ) const;
    float Max( void ) const;
    void SetMin( float fValue );
    void SetMax( float fValue );
    // Set the min max limit to the edit box
    void SetEditMin( float fEditMin );
    void SetEditMax( float fEditMax );
    float EditMin( void ) const;
    float EditMax( void ) const;
};

typedef AttributeFloatRange afloatr;
MBDLL_DECL Stream &operator ==( Stream &s, afloatr &a );

class MBDLL_DECL AttributeNumber : public AttributeInstance<int>
{
    int m_iDigitCount;
    int m_iControlWidth;
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth );
public:
    AttributeNumber( Node *pOwner, const QString &sID, int m_iControlwidth = 40, int m_iDigitCount = 0 );
    OPERATORS( int );
};

typedef AttributeNumber anumber;

class MBDLL_DECL AttributeEnumeration : public aint
{
    Q_DECLARE_TR_FUNCTIONS(mudbox::AttributeEnumeration);
private:
    Store<QString> m_aValues;
    Store<bool> m_aEnabledStates;
    bool m_bDisplayAsIcons;

    unsigned int ParameterCount( void ) const;
    QString ParameterName( unsigned int iIndex ) const;
    QString ParameterValue( unsigned int iIndex ) const;
    void SetParameterValue( const QString &sName, const QString &sValue );
public:
    AttributeEnumeration( Node *pOwner, const QString &sID );
    OPERATORS( int );
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth );
    unsigned int AddItem( const QString &sValue, bool bEnabled = true );
    void SetItem( unsigned int iIndex, const QString &sValue, bool bEnabled = true );
    void SetIconMode( 
        bool bDisplayAsIcons 
        ) { m_bDisplayAsIcons = bDisplayAsIcons; };
    bool IconMode( void ) const { return m_bDisplayAsIcons; };
    AttributeEnumeration &operator <<( const char *sValue );
    AttributeEnumeration &operator =( const AttributeEnumeration &aeValue );

    unsigned int ItemCount( void ) const;
    void Clear( void );
    QString Item( unsigned int iIndex ) const;
    bool IsItemEnabled( unsigned int iIndex ) const;
};
typedef AttributeEnumeration aenum;
MBDLL_DECL Stream &operator ==( Stream &s, aenum &a );

class MBDLL_DECL AttributeFilename : public astring
{
public:
    AttributeFilename( Node *pOwner, const QString &sID, bool bMustExists = true );
    OPERATORS_NOEXCMARK( QString );
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth );

    unsigned int ParameterCount( void ) const;
    QString ParameterName( unsigned int iIndex ) const;
    QString ParameterValue( unsigned int iIndex ) const;
    void SetParameterValue( const QString &sName, const QString &sValue );

    bool m_bMustExists;
    QString m_sFilter;
    QString m_sPath;
    QString m_sSelectedFilter;
};
typedef AttributeFilename afilename;

class MBDLL_DECL AttributeTextureFilename : public AttributeFilename
{
public:
    AttributeTextureFilename( Node *pOwner, const QString &sID,  bool bMustExists = true );
    OPERATORS_NOEXCMARK( QString );
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth );
};
typedef AttributeTextureFilename atexturefilename;
MBDLL_DECL Stream &operator ==( Stream &s, afilename &a );

class MBDLL_DECL AttributeWatch : public Attribute
{
    Attribute::AttributeType Type( void ) const;
public:
    AttributeWatch( Node *pOwner, const QString &sID = "");
};

class MBDLL_DECL AttributeBoolCollection : public AttributeInstance<int>
{
    Q_DECLARE_TR_FUNCTIONS(mudbox::AttributeBoolCollection);

private:
    AttributeWidget *CreateEditorWidget( QWidget *pParent, int iWidth );
    QString m_aNames[32];
    unsigned int m_iBoolCount;

    unsigned int ParameterCount( void ) const;
    QString ParameterName( unsigned int iIndex ) const;
    QString ParameterValue( unsigned int iIndex ) const;
    void SetParameterValue( const QString &sName, const QString &sValue );
public:
    AttributeBoolCollection( Node *pOwner, const QString &sID );
    void Clear( void );
    void SetValue( unsigned int iIndex, bool bValue, bool bInternal = false );
    bool Value( unsigned int iIndex ) const;
    int AddBool( const QString &sName, bool bValue = false );
    unsigned int BoolCount( void ) const;
    void SetBoolName( unsigned int iIndex, const QString &sName );
    QString BoolName( unsigned int iIndex ) const;
};
typedef AttributeBoolCollection aboolc;

}; // end of namespace mudbox