Parameter.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of FRAPPER
research.animationsinstitut.de
sourceforge.net/projects/frapper

Copyright (c) 2008-2010 Filmakademie Baden-Wuerttemberg, Institute of Animation 

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; version 2.1 of the License.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html
-----------------------------------------------------------------------------
*/


#ifndef PARAMETER_H
#define PARAMETER_H

#include "FrapperPrerequisites.h"
#include "AbstractParameter.h"
#include "Connection.h"
#include <QtCore/QString>
#include <QtCore/QVariant>
#include <QtCore/QVariantList>
#include <QtXml/QDomElement>
#include <QtCore/QStringList>
#include <QtCore/QMutex>
#include "InstanceCounterMacros.h"

// OGRE
#include <Ogre.h>
#if (OGRE_PLATFORM  == OGRE_PLATFORM_WIN32)
#include <windows.h>
#endif

// Declare Ogre Metatypes to be used with QVariant
Q_DECLARE_METATYPE(Ogre::Vector3)
Q_DECLARE_METATYPE(Ogre::TexturePtr)
Q_DECLARE_METATYPE(Ogre::SceneNode*)

namespace Frapper {

    class ParameterGroup;

    class FRAPPER_CORE_EXPORT Parameter : public AbstractParameter
    {
                friend class SceneModel;
        Q_OBJECT
            ADD_INSTANCE_COUNTER

    public: // type definitions

        typedef unsigned int Size;

    public: // nested enumerations

        enum Type {
            T_Unknown = -1,
            T_Bool,
            T_Int,
            T_UnsignedInt,
            T_Float,
            T_String,
            T_Filename,
            T_Color,
            T_Enumeration,
            T_TextInfo,
            T_Command,
            T_Geometry,
            T_Light,
            T_Camera,
            T_Image,
            T_Group,
            T_PlugIn,
            T_Generic,

            T_NumTypes
        };

        enum Multiplicity {
            M_Invalid = -1,
            M_OneOrMore
        };

        enum PinType {
            PT_None = -1,
            PT_Input,
            PT_Output
        };

    public: // static functions

        static QString getTypeName ( Type type );

        static QColor getTypeColor ( Type type );

        static Type getTypeByName ( const QString &typeName );

        static QVariant getDefaultValue ( Type type );

        static QColor decodeIntColor ( const QString &color );

        static QColor decodeDoubleColor ( const QString &color );

        static Size decodeSize ( const QString &size );

        static int decodeMultiplicity ( const QString &multiplicity );

        static PinType decodePinType ( const QString &pinTypeString );

        static Parameter * create ( const QString &name, Type type, QVariant defaultValue = QVariant() );

        static Parameter * create ( const QDomElement &element );

        static Parameter * clone ( const Parameter &parameter );

        static QString extractFirstGroupName ( QString *path );

        static Parameter * createImageParameter ( const QString &name, Ogre::TexturePtr texturePointer = Ogre::TexturePtr(0) );

        static Parameter * createGroupParameter ( const QString &name, ParameterGroup *parameterGroup = 0 );

    public: // static data

        static const QString PathSeparator;

        static const QString EnumerationSeparator;

    public: // constructors and destructors

        Parameter ( const QString &name, Type type, const QVariant &value );

        Parameter ( const Parameter &parameter );

        virtual ~Parameter ();

    public: // functions

        virtual AbstractParameter * clone ();

        virtual bool isGroup () const;

        Type getType () const;

        Size getSize () const;

        void setSize ( Size size );

        int getMultiplicity () const;

        void setMultiplicity ( int multiplicity );

        int getNumberOfConnections () const;

        virtual QVariant getValue ( bool triggerEvaluation = false );

        virtual const QVariantList & getValueList () const;

        void setValue ( const QVariant &value, bool triggerDirtying = false );

        void setValue ( int index, const QVariant &value, bool triggerDirtying = false );

        bool hasDefaultValue () const;

        void setDefaultValue ( const QVariant &defaultValue );

        virtual void reset ();

        List getAffectedParameters () const;

        void addAffectedParameter ( Parameter *affectedParameter );

        void removeAffectedParameter ( Parameter *affectedParameter );

        List getAffectingParameters () const;

        void addAffectingParameter ( Parameter *affectingParameter );

        void removeAffectingParameter ( Parameter *affectingParameter );

        QString getDescription () const;

        void setDescription ( const QString &description );

        PinType getPinType () const;

        void setPinType ( PinType pinType );

        Connection::Map getConnectionMap () const;

        void addConnection ( Connection *connection );

        void removeConnection ( Connection::ID id );

        bool isConnected () const;

        Parameter * getConnectedParameter () const;

        bool isDirty ();

        virtual void setDirty ( bool dirty );

        bool isAuxDirty ();

        virtual void setAuxDirty ( bool dirty );

        bool isVisible () const;

        void setVisible ( bool visible );

        bool isReadOnly () const;

        void setReadOnly ( bool readOnly );

        void setSelfEvaluating ( bool selfEvaluating );

        bool isSelfEvaluating () const;

        void propagateDirty (bool setFirstTrue = true);

        void propagateAuxDirty ();

        void propagateEvaluation ();

        void setChangeFunction ( const char *changeFunction );

        void setProcessingFunction ( const char *processingFunction );

        void setAuxProcessingFunction ( const char *processingFunction );

        void setCommandFunction ( const char *commandFunction );

                void setOnConnectFunction ( const char *onConnectFunction );

                void setOnDisconnectFunction ( const char *onDisconnectFunction );

        void executeCommand ();

        QString getValueString ();

signals: // signals

        void dirtied ();

        void valueChanged ();

        void valueChanged ( int index );

        void processingRequested ();

        void auxProcessingRequested ();

        void commandExecutionRequested ();

                void connectionEstablished();

                void connectionDestroyed();

    protected: // data

        QMutex m_mutex;
        //NILZ: DEBUG:
        QStringList m_mutexList;

        Type m_type;

        int m_size;

        int m_multiplicity;

        QVariant m_defaultValue;

        QVariant m_value;

        QVariantList m_valueList;

        QString m_description;

        PinType m_pinType;

        Connection::Map m_connectionMap;

        List m_affectedParameters;

        List m_affectingParameters;

        bool m_dirty;

        bool m_auxDirty;

        bool m_visible;

        bool m_readOnly;

        bool m_selfEvaluating;
    };

// Declare Frapper Metatypes to be used with QVariant
Q_DECLARE_METATYPE(ParameterGroup*)

} // end namespace Frapper

#endif